diff --git a/cmd/kube-conversion/conversion.go b/cmd/kube-conversion/conversion.go new file mode 100644 index 00000000000..e7ac90cf995 --- /dev/null +++ b/cmd/kube-conversion/conversion.go @@ -0,0 +1,71 @@ +/* +Copyright 2015 Google Inc. All rights reserved. + +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 main + +import ( + "io" + "os" + "runtime" + "strings" + + "github.com/GoogleCloudPlatform/kubernetes/pkg/api" + _ "github.com/GoogleCloudPlatform/kubernetes/pkg/api/v1beta1" + _ "github.com/GoogleCloudPlatform/kubernetes/pkg/api/v1beta2" + _ "github.com/GoogleCloudPlatform/kubernetes/pkg/api/v1beta3" + "github.com/GoogleCloudPlatform/kubernetes/pkg/conversion" + + "github.com/golang/glog" + flag "github.com/spf13/pflag" +) + +var ( + outputDest = flag.StringP("output", "o", "-", "Output destination; '-' means stdout") + versions = flag.StringP("versions", "v", "v1beta3", "Comma separated list of versions for conversion.") +) + +func main() { + runtime.GOMAXPROCS(runtime.NumCPU()) + flag.Parse() + + var out io.Writer + if *outputDest == "-" { + out = os.Stdout + } else { + file, err := os.Create(*outputDest) + if err != nil { + glog.Fatalf("Couldn't open %v: %v", *outputDest, err) + } + defer file.Close() + out = file + } + + versionsForConversion := strings.Split(*versions, ",") + for _, version := range versionsForConversion { + generator := conversion.NewGenerator(api.Scheme.Raw()) + // TODO(wojtek-t): Change the overwrites to a flag. + generator.OverwritePackage(version, "") + generator.OverwritePackage("api", "newer") + for _, knownType := range api.Scheme.KnownTypes(version) { + if err := generator.GenerateConversionsForType(version, knownType); err != nil { + glog.Errorf("error while generating conversion functions for %v: %v", knownType, err) + } + } + if err := generator.WriteConversionFunctions(out); err != nil { + glog.Fatalf("Error while writing conversion functions: %v", err) + } + } +} diff --git a/pkg/api/v1beta3/conversion.go b/pkg/api/v1beta3/conversion.go index 700bda3701e..ff3a4cd6588 100644 --- a/pkg/api/v1beta3/conversion.go +++ b/pkg/api/v1beta3/conversion.go @@ -20,11 +20,2638 @@ import ( "fmt" newer "github.com/GoogleCloudPlatform/kubernetes/pkg/api" + "github.com/GoogleCloudPlatform/kubernetes/pkg/api/resource" + "github.com/GoogleCloudPlatform/kubernetes/pkg/conversion" ) func init() { + err := newer.Scheme.AddGeneratedConversionFuncs( + func(in *EndpointSubset, out *newer.EndpointSubset, s conversion.Scope) error { + if in.Addresses != nil { + out.Addresses = make([]newer.EndpointAddress, len(in.Addresses)) + for i := range in.Addresses { + if err := s.Convert(&in.Addresses[i], &out.Addresses[i], 0); err != nil { + return err + } + } + } + if in.Ports != nil { + out.Ports = make([]newer.EndpointPort, len(in.Ports)) + for i := range in.Ports { + if err := s.Convert(&in.Ports[i], &out.Ports[i], 0); err != nil { + return err + } + } + } + return nil + }, + func(in *newer.EndpointSubset, out *EndpointSubset, s conversion.Scope) error { + if in.Addresses != nil { + out.Addresses = make([]EndpointAddress, len(in.Addresses)) + for i := range in.Addresses { + if err := s.Convert(&in.Addresses[i], &out.Addresses[i], 0); err != nil { + return err + } + } + } + if in.Ports != nil { + out.Ports = make([]EndpointPort, len(in.Ports)) + for i := range in.Ports { + if err := s.Convert(&in.Ports[i], &out.Ports[i], 0); err != nil { + return err + } + } + } + return nil + }, + func(in *EndpointsList, out *newer.EndpointsList, s conversion.Scope) error { + if err := s.Convert(&in.TypeMeta, &out.TypeMeta, 0); err != nil { + return err + } + if err := s.Convert(&in.ListMeta, &out.ListMeta, 0); err != nil { + return err + } + if in.Items != nil { + out.Items = make([]newer.Endpoints, len(in.Items)) + for i := range in.Items { + if err := s.Convert(&in.Items[i], &out.Items[i], 0); err != nil { + return err + } + } + } + return nil + }, + func(in *newer.EndpointsList, out *EndpointsList, s conversion.Scope) error { + if err := s.Convert(&in.TypeMeta, &out.TypeMeta, 0); err != nil { + return err + } + if err := s.Convert(&in.ListMeta, &out.ListMeta, 0); err != nil { + return err + } + if in.Items != nil { + out.Items = make([]Endpoints, len(in.Items)) + for i := range in.Items { + if err := s.Convert(&in.Items[i], &out.Items[i], 0); err != nil { + return err + } + } + } + return nil + }, + func(in *PodList, out *newer.PodList, s conversion.Scope) error { + if err := s.Convert(&in.TypeMeta, &out.TypeMeta, 0); err != nil { + return err + } + if err := s.Convert(&in.ListMeta, &out.ListMeta, 0); err != nil { + return err + } + if in.Items != nil { + out.Items = make([]newer.Pod, len(in.Items)) + for i := range in.Items { + if err := s.Convert(&in.Items[i], &out.Items[i], 0); err != nil { + return err + } + } + } + return nil + }, + func(in *newer.PodList, out *PodList, s conversion.Scope) error { + if err := s.Convert(&in.TypeMeta, &out.TypeMeta, 0); err != nil { + return err + } + if err := s.Convert(&in.ListMeta, &out.ListMeta, 0); err != nil { + return err + } + if in.Items != nil { + out.Items = make([]Pod, len(in.Items)) + for i := range in.Items { + if err := s.Convert(&in.Items[i], &out.Items[i], 0); err != nil { + return err + } + } + } + return nil + }, + func(in *Binding, out *newer.Binding, s conversion.Scope) error { + if err := s.Convert(&in.TypeMeta, &out.TypeMeta, 0); err != nil { + return err + } + if err := s.Convert(&in.ObjectMeta, &out.ObjectMeta, 0); err != nil { + return err + } + if err := s.Convert(&in.Target, &out.Target, 0); err != nil { + return err + } + return nil + }, + func(in *newer.Binding, out *Binding, s conversion.Scope) error { + if err := s.Convert(&in.TypeMeta, &out.TypeMeta, 0); err != nil { + return err + } + if err := s.Convert(&in.ObjectMeta, &out.ObjectMeta, 0); err != nil { + return err + } + if err := s.Convert(&in.Target, &out.Target, 0); err != nil { + return err + } + return nil + }, + func(in *StatusDetails, out *newer.StatusDetails, s conversion.Scope) error { + out.ID = in.ID + out.Kind = in.Kind + if in.Causes != nil { + out.Causes = make([]newer.StatusCause, len(in.Causes)) + for i := range in.Causes { + if err := s.Convert(&in.Causes[i], &out.Causes[i], 0); err != nil { + return err + } + } + } + out.RetryAfterSeconds = in.RetryAfterSeconds + return nil + }, + func(in *newer.StatusDetails, out *StatusDetails, s conversion.Scope) error { + out.ID = in.ID + out.Kind = in.Kind + if in.Causes != nil { + out.Causes = make([]StatusCause, len(in.Causes)) + for i := range in.Causes { + if err := s.Convert(&in.Causes[i], &out.Causes[i], 0); err != nil { + return err + } + } + } + out.RetryAfterSeconds = in.RetryAfterSeconds + return nil + }, + func(in *NamespaceStatus, out *newer.NamespaceStatus, s conversion.Scope) error { + out.Phase = newer.NamespacePhase(in.Phase) + return nil + }, + func(in *newer.NamespaceStatus, out *NamespaceStatus, s conversion.Scope) error { + out.Phase = NamespacePhase(in.Phase) + return nil + }, + func(in *HTTPGetAction, out *newer.HTTPGetAction, s conversion.Scope) error { + out.Path = in.Path + if err := s.Convert(&in.Port, &out.Port, 0); err != nil { + return err + } + out.Host = in.Host + return nil + }, + func(in *newer.HTTPGetAction, out *HTTPGetAction, s conversion.Scope) error { + out.Path = in.Path + if err := s.Convert(&in.Port, &out.Port, 0); err != nil { + return err + } + out.Host = in.Host + return nil + }, + func(in *ISCSIVolumeSource, out *newer.ISCSIVolumeSource, s conversion.Scope) error { + out.TargetPortal = in.TargetPortal + out.IQN = in.IQN + out.Lun = in.Lun + out.FSType = in.FSType + out.ReadOnly = in.ReadOnly + return nil + }, + func(in *newer.ISCSIVolumeSource, out *ISCSIVolumeSource, s conversion.Scope) error { + out.TargetPortal = in.TargetPortal + out.IQN = in.IQN + out.Lun = in.Lun + out.FSType = in.FSType + out.ReadOnly = in.ReadOnly + return nil + }, + func(in *Handler, out *newer.Handler, s conversion.Scope) error { + if err := s.Convert(&in.Exec, &out.Exec, 0); err != nil { + return err + } + if err := s.Convert(&in.HTTPGet, &out.HTTPGet, 0); err != nil { + return err + } + if err := s.Convert(&in.TCPSocket, &out.TCPSocket, 0); err != nil { + return err + } + return nil + }, + func(in *newer.Handler, out *Handler, s conversion.Scope) error { + if err := s.Convert(&in.Exec, &out.Exec, 0); err != nil { + return err + } + if err := s.Convert(&in.HTTPGet, &out.HTTPGet, 0); err != nil { + return err + } + if err := s.Convert(&in.TCPSocket, &out.TCPSocket, 0); err != nil { + return err + } + return nil + }, + func(in *PodStatus, out *newer.PodStatus, s conversion.Scope) error { + out.Phase = newer.PodPhase(in.Phase) + if in.Conditions != nil { + out.Conditions = make([]newer.PodCondition, len(in.Conditions)) + for i := range in.Conditions { + if err := s.Convert(&in.Conditions[i], &out.Conditions[i], 0); err != nil { + return err + } + } + } + out.Message = in.Message + out.HostIP = in.HostIP + out.PodIP = in.PodIP + if in.ContainerStatuses != nil { + out.ContainerStatuses = make([]newer.ContainerStatus, len(in.ContainerStatuses)) + for i := range in.ContainerStatuses { + if err := s.Convert(&in.ContainerStatuses[i], &out.ContainerStatuses[i], 0); err != nil { + return err + } + } + } + return nil + }, + func(in *newer.PodStatus, out *PodStatus, s conversion.Scope) error { + out.Phase = PodPhase(in.Phase) + if in.Conditions != nil { + out.Conditions = make([]PodCondition, len(in.Conditions)) + for i := range in.Conditions { + if err := s.Convert(&in.Conditions[i], &out.Conditions[i], 0); err != nil { + return err + } + } + } + out.Message = in.Message + out.HostIP = in.HostIP + out.PodIP = in.PodIP + if in.ContainerStatuses != nil { + out.ContainerStatuses = make([]ContainerStatus, len(in.ContainerStatuses)) + for i := range in.ContainerStatuses { + if err := s.Convert(&in.ContainerStatuses[i], &out.ContainerStatuses[i], 0); err != nil { + return err + } + } + } + return nil + }, + func(in *Pod, out *newer.Pod, s conversion.Scope) error { + if err := s.Convert(&in.TypeMeta, &out.TypeMeta, 0); err != nil { + return err + } + if err := s.Convert(&in.ObjectMeta, &out.ObjectMeta, 0); err != nil { + return err + } + if err := s.Convert(&in.Spec, &out.Spec, 0); err != nil { + return err + } + if err := s.Convert(&in.Status, &out.Status, 0); err != nil { + return err + } + return nil + }, + func(in *newer.Pod, out *Pod, s conversion.Scope) error { + if err := s.Convert(&in.TypeMeta, &out.TypeMeta, 0); err != nil { + return err + } + if err := s.Convert(&in.ObjectMeta, &out.ObjectMeta, 0); err != nil { + return err + } + if err := s.Convert(&in.Spec, &out.Spec, 0); err != nil { + return err + } + if err := s.Convert(&in.Status, &out.Status, 0); err != nil { + return err + } + return nil + }, + func(in *NodeList, out *newer.NodeList, s conversion.Scope) error { + if err := s.Convert(&in.TypeMeta, &out.TypeMeta, 0); err != nil { + return err + } + if err := s.Convert(&in.ListMeta, &out.ListMeta, 0); err != nil { + return err + } + if in.Items != nil { + out.Items = make([]newer.Node, len(in.Items)) + for i := range in.Items { + if err := s.Convert(&in.Items[i], &out.Items[i], 0); err != nil { + return err + } + } + } + return nil + }, + func(in *newer.NodeList, out *NodeList, s conversion.Scope) error { + if err := s.Convert(&in.TypeMeta, &out.TypeMeta, 0); err != nil { + return err + } + if err := s.Convert(&in.ListMeta, &out.ListMeta, 0); err != nil { + return err + } + if in.Items != nil { + out.Items = make([]Node, len(in.Items)) + for i := range in.Items { + if err := s.Convert(&in.Items[i], &out.Items[i], 0); err != nil { + return err + } + } + } + return nil + }, + func(in *ResourceQuotaSpec, out *newer.ResourceQuotaSpec, s conversion.Scope) error { + if in.Hard != nil { + out.Hard = make(map[newer.ResourceName]resource.Quantity) + for key, val := range in.Hard { + newVal := resource.Quantity{} + if err := s.Convert(&val, &newVal, 0); err != nil { + return err + } + out.Hard[newer.ResourceName(key)] = newVal + } + } + return nil + }, + func(in *newer.ResourceQuotaSpec, out *ResourceQuotaSpec, s conversion.Scope) error { + if in.Hard != nil { + out.Hard = make(map[ResourceName]resource.Quantity) + for key, val := range in.Hard { + newVal := resource.Quantity{} + if err := s.Convert(&val, &newVal, 0); err != nil { + return err + } + out.Hard[ResourceName(key)] = newVal + } + } + return nil + }, + func(in *TypeMeta, out *newer.TypeMeta, s conversion.Scope) error { + out.Kind = in.Kind + out.APIVersion = in.APIVersion + return nil + }, + func(in *newer.TypeMeta, out *TypeMeta, s conversion.Scope) error { + out.Kind = in.Kind + out.APIVersion = in.APIVersion + return nil + }, + func(in *GCEPersistentDiskVolumeSource, out *newer.GCEPersistentDiskVolumeSource, s conversion.Scope) error { + out.PDName = in.PDName + out.FSType = in.FSType + out.Partition = in.Partition + out.ReadOnly = in.ReadOnly + return nil + }, + func(in *newer.GCEPersistentDiskVolumeSource, out *GCEPersistentDiskVolumeSource, s conversion.Scope) error { + out.PDName = in.PDName + out.FSType = in.FSType + out.Partition = in.Partition + out.ReadOnly = in.ReadOnly + return nil + }, + func(in *PodProxyOptions, out *newer.PodProxyOptions, s conversion.Scope) error { + if err := s.Convert(&in.TypeMeta, &out.TypeMeta, 0); err != nil { + return err + } + out.Path = in.Path + return nil + }, + func(in *newer.PodProxyOptions, out *PodProxyOptions, s conversion.Scope) error { + if err := s.Convert(&in.TypeMeta, &out.TypeMeta, 0); err != nil { + return err + } + out.Path = in.Path + return nil + }, + func(in *PodStatusResult, out *newer.PodStatusResult, s conversion.Scope) error { + if err := s.Convert(&in.TypeMeta, &out.TypeMeta, 0); err != nil { + return err + } + if err := s.Convert(&in.ObjectMeta, &out.ObjectMeta, 0); err != nil { + return err + } + if err := s.Convert(&in.Status, &out.Status, 0); err != nil { + return err + } + return nil + }, + func(in *newer.PodStatusResult, out *PodStatusResult, s conversion.Scope) error { + if err := s.Convert(&in.TypeMeta, &out.TypeMeta, 0); err != nil { + return err + } + if err := s.Convert(&in.ObjectMeta, &out.ObjectMeta, 0); err != nil { + return err + } + if err := s.Convert(&in.Status, &out.Status, 0); err != nil { + return err + } + return nil + }, + func(in *SecretVolumeSource, out *newer.SecretVolumeSource, s conversion.Scope) error { + out.SecretName = in.SecretName + return nil + }, + func(in *newer.SecretVolumeSource, out *SecretVolumeSource, s conversion.Scope) error { + out.SecretName = in.SecretName + return nil + }, + func(in *VolumeMount, out *newer.VolumeMount, s conversion.Scope) error { + out.Name = in.Name + out.ReadOnly = in.ReadOnly + out.MountPath = in.MountPath + return nil + }, + func(in *newer.VolumeMount, out *VolumeMount, s conversion.Scope) error { + out.Name = in.Name + out.ReadOnly = in.ReadOnly + out.MountPath = in.MountPath + return nil + }, + func(in *PodCondition, out *newer.PodCondition, s conversion.Scope) error { + out.Type = newer.PodConditionType(in.Type) + out.Status = newer.ConditionStatus(in.Status) + return nil + }, + func(in *newer.PodCondition, out *PodCondition, s conversion.Scope) error { + out.Type = PodConditionType(in.Type) + out.Status = ConditionStatus(in.Status) + return nil + }, + func(in *ListMeta, out *newer.ListMeta, s conversion.Scope) error { + out.SelfLink = in.SelfLink + out.ResourceVersion = in.ResourceVersion + return nil + }, + func(in *newer.ListMeta, out *ListMeta, s conversion.Scope) error { + out.SelfLink = in.SelfLink + out.ResourceVersion = in.ResourceVersion + return nil + }, + func(in *GitRepoVolumeSource, out *newer.GitRepoVolumeSource, s conversion.Scope) error { + out.Repository = in.Repository + out.Revision = in.Revision + return nil + }, + func(in *newer.GitRepoVolumeSource, out *GitRepoVolumeSource, s conversion.Scope) error { + out.Repository = in.Repository + out.Revision = in.Revision + return nil + }, + func(in *PersistentVolumeStatus, out *newer.PersistentVolumeStatus, s conversion.Scope) error { + out.Phase = newer.PersistentVolumePhase(in.Phase) + return nil + }, + func(in *newer.PersistentVolumeStatus, out *PersistentVolumeStatus, s conversion.Scope) error { + out.Phase = PersistentVolumePhase(in.Phase) + return nil + }, + func(in *ServiceStatus, out *newer.ServiceStatus, s conversion.Scope) error { + return nil + }, + func(in *newer.ServiceStatus, out *ServiceStatus, s conversion.Scope) error { + return nil + }, + func(in *ReplicationControllerList, out *newer.ReplicationControllerList, s conversion.Scope) error { + if err := s.Convert(&in.TypeMeta, &out.TypeMeta, 0); err != nil { + return err + } + if err := s.Convert(&in.ListMeta, &out.ListMeta, 0); err != nil { + return err + } + if in.Items != nil { + out.Items = make([]newer.ReplicationController, len(in.Items)) + for i := range in.Items { + if err := s.Convert(&in.Items[i], &out.Items[i], 0); err != nil { + return err + } + } + } + return nil + }, + func(in *newer.ReplicationControllerList, out *ReplicationControllerList, s conversion.Scope) error { + if err := s.Convert(&in.TypeMeta, &out.TypeMeta, 0); err != nil { + return err + } + if err := s.Convert(&in.ListMeta, &out.ListMeta, 0); err != nil { + return err + } + if in.Items != nil { + out.Items = make([]ReplicationController, len(in.Items)) + for i := range in.Items { + if err := s.Convert(&in.Items[i], &out.Items[i], 0); err != nil { + return err + } + } + } + return nil + }, + func(in *ResourceQuotaList, out *newer.ResourceQuotaList, s conversion.Scope) error { + if err := s.Convert(&in.TypeMeta, &out.TypeMeta, 0); err != nil { + return err + } + if err := s.Convert(&in.ListMeta, &out.ListMeta, 0); err != nil { + return err + } + if in.Items != nil { + out.Items = make([]newer.ResourceQuota, len(in.Items)) + for i := range in.Items { + if err := s.Convert(&in.Items[i], &out.Items[i], 0); err != nil { + return err + } + } + } + return nil + }, + func(in *newer.ResourceQuotaList, out *ResourceQuotaList, s conversion.Scope) error { + if err := s.Convert(&in.TypeMeta, &out.TypeMeta, 0); err != nil { + return err + } + if err := s.Convert(&in.ListMeta, &out.ListMeta, 0); err != nil { + return err + } + if in.Items != nil { + out.Items = make([]ResourceQuota, len(in.Items)) + for i := range in.Items { + if err := s.Convert(&in.Items[i], &out.Items[i], 0); err != nil { + return err + } + } + } + return nil + }, + func(in *NodeAddress, out *newer.NodeAddress, s conversion.Scope) error { + out.Type = newer.NodeAddressType(in.Type) + out.Address = in.Address + return nil + }, + func(in *newer.NodeAddress, out *NodeAddress, s conversion.Scope) error { + out.Type = NodeAddressType(in.Type) + out.Address = in.Address + return nil + }, + func(in *Secret, out *newer.Secret, s conversion.Scope) error { + if err := s.Convert(&in.TypeMeta, &out.TypeMeta, 0); err != nil { + return err + } + if err := s.Convert(&in.ObjectMeta, &out.ObjectMeta, 0); err != nil { + return err + } + if in.Data != nil { + out.Data = make(map[string][]uint8) + for key, val := range in.Data { + newVal := []uint8{} + if err := s.Convert(&val, &newVal, 0); err != nil { + return err + } + out.Data[key] = newVal + } + } + out.Type = newer.SecretType(in.Type) + return nil + }, + func(in *newer.Secret, out *Secret, s conversion.Scope) error { + if err := s.Convert(&in.TypeMeta, &out.TypeMeta, 0); err != nil { + return err + } + if err := s.Convert(&in.ObjectMeta, &out.ObjectMeta, 0); err != nil { + return err + } + if in.Data != nil { + out.Data = make(map[string][]uint8) + for key, val := range in.Data { + newVal := []uint8{} + if err := s.Convert(&val, &newVal, 0); err != nil { + return err + } + out.Data[key] = newVal + } + } + out.Type = SecretType(in.Type) + return nil + }, + func(in *NodeSpec, out *newer.NodeSpec, s conversion.Scope) error { + out.PodCIDR = in.PodCIDR + out.ExternalID = in.ExternalID + out.Unschedulable = in.Unschedulable + return nil + }, + func(in *newer.NodeSpec, out *NodeSpec, s conversion.Scope) error { + out.PodCIDR = in.PodCIDR + out.ExternalID = in.ExternalID + out.Unschedulable = in.Unschedulable + return nil + }, + func(in *NodeCondition, out *newer.NodeCondition, s conversion.Scope) error { + out.Type = newer.NodeConditionType(in.Type) + out.Status = newer.ConditionStatus(in.Status) + if err := s.Convert(&in.LastHeartbeatTime, &out.LastHeartbeatTime, 0); err != nil { + return err + } + if err := s.Convert(&in.LastTransitionTime, &out.LastTransitionTime, 0); err != nil { + return err + } + out.Reason = in.Reason + out.Message = in.Message + return nil + }, + func(in *newer.NodeCondition, out *NodeCondition, s conversion.Scope) error { + out.Type = NodeConditionType(in.Type) + out.Status = ConditionStatus(in.Status) + if err := s.Convert(&in.LastHeartbeatTime, &out.LastHeartbeatTime, 0); err != nil { + return err + } + if err := s.Convert(&in.LastTransitionTime, &out.LastTransitionTime, 0); err != nil { + return err + } + out.Reason = in.Reason + out.Message = in.Message + return nil + }, + func(in *NodeSystemInfo, out *newer.NodeSystemInfo, s conversion.Scope) error { + out.MachineID = in.MachineID + out.SystemUUID = in.SystemUUID + out.BootID = in.BootID + out.KernelVersion = in.KernelVersion + out.OsImage = in.OsImage + out.ContainerRuntimeVersion = in.ContainerRuntimeVersion + out.KubeletVersion = in.KubeletVersion + out.KubeProxyVersion = in.KubeProxyVersion + return nil + }, + func(in *newer.NodeSystemInfo, out *NodeSystemInfo, s conversion.Scope) error { + out.MachineID = in.MachineID + out.SystemUUID = in.SystemUUID + out.BootID = in.BootID + out.KernelVersion = in.KernelVersion + out.OsImage = in.OsImage + out.ContainerRuntimeVersion = in.ContainerRuntimeVersion + out.KubeletVersion = in.KubeletVersion + out.KubeProxyVersion = in.KubeProxyVersion + return nil + }, + func(in *EndpointPort, out *newer.EndpointPort, s conversion.Scope) error { + out.Name = in.Name + out.Port = in.Port + out.Protocol = newer.Protocol(in.Protocol) + return nil + }, + func(in *newer.EndpointPort, out *EndpointPort, s conversion.Scope) error { + out.Name = in.Name + out.Port = in.Port + out.Protocol = Protocol(in.Protocol) + return nil + }, + func(in *PersistentVolumeSource, out *newer.PersistentVolumeSource, s conversion.Scope) error { + if err := s.Convert(&in.GCEPersistentDisk, &out.GCEPersistentDisk, 0); err != nil { + return err + } + if err := s.Convert(&in.AWSElasticBlockStore, &out.AWSElasticBlockStore, 0); err != nil { + return err + } + if err := s.Convert(&in.HostPath, &out.HostPath, 0); err != nil { + return err + } + if err := s.Convert(&in.Glusterfs, &out.Glusterfs, 0); err != nil { + return err + } + return nil + }, + func(in *newer.PersistentVolumeSource, out *PersistentVolumeSource, s conversion.Scope) error { + if err := s.Convert(&in.GCEPersistentDisk, &out.GCEPersistentDisk, 0); err != nil { + return err + } + if err := s.Convert(&in.AWSElasticBlockStore, &out.AWSElasticBlockStore, 0); err != nil { + return err + } + if err := s.Convert(&in.HostPath, &out.HostPath, 0); err != nil { + return err + } + if err := s.Convert(&in.Glusterfs, &out.Glusterfs, 0); err != nil { + return err + } + return nil + }, + func(in *EventList, out *newer.EventList, s conversion.Scope) error { + if err := s.Convert(&in.TypeMeta, &out.TypeMeta, 0); err != nil { + return err + } + if err := s.Convert(&in.ListMeta, &out.ListMeta, 0); err != nil { + return err + } + if in.Items != nil { + out.Items = make([]newer.Event, len(in.Items)) + for i := range in.Items { + if err := s.Convert(&in.Items[i], &out.Items[i], 0); err != nil { + return err + } + } + } + return nil + }, + func(in *newer.EventList, out *EventList, s conversion.Scope) error { + if err := s.Convert(&in.TypeMeta, &out.TypeMeta, 0); err != nil { + return err + } + if err := s.Convert(&in.ListMeta, &out.ListMeta, 0); err != nil { + return err + } + if in.Items != nil { + out.Items = make([]Event, len(in.Items)) + for i := range in.Items { + if err := s.Convert(&in.Items[i], &out.Items[i], 0); err != nil { + return err + } + } + } + return nil + }, + func(in *Container, out *newer.Container, s conversion.Scope) error { + out.Name = in.Name + out.Image = in.Image + if in.Command != nil { + out.Command = make([]string, len(in.Command)) + for i := range in.Command { + out.Command[i] = in.Command[i] + } + } + if in.Args != nil { + out.Args = make([]string, len(in.Args)) + for i := range in.Args { + out.Args[i] = in.Args[i] + } + } + out.WorkingDir = in.WorkingDir + if in.Ports != nil { + out.Ports = make([]newer.ContainerPort, len(in.Ports)) + for i := range in.Ports { + if err := s.Convert(&in.Ports[i], &out.Ports[i], 0); err != nil { + return err + } + } + } + if in.Env != nil { + out.Env = make([]newer.EnvVar, len(in.Env)) + for i := range in.Env { + if err := s.Convert(&in.Env[i], &out.Env[i], 0); err != nil { + return err + } + } + } + if err := s.Convert(&in.Resources, &out.Resources, 0); err != nil { + return err + } + if in.VolumeMounts != nil { + out.VolumeMounts = make([]newer.VolumeMount, len(in.VolumeMounts)) + for i := range in.VolumeMounts { + if err := s.Convert(&in.VolumeMounts[i], &out.VolumeMounts[i], 0); err != nil { + return err + } + } + } + if err := s.Convert(&in.LivenessProbe, &out.LivenessProbe, 0); err != nil { + return err + } + if err := s.Convert(&in.ReadinessProbe, &out.ReadinessProbe, 0); err != nil { + return err + } + if err := s.Convert(&in.Lifecycle, &out.Lifecycle, 0); err != nil { + return err + } + out.TerminationMessagePath = in.TerminationMessagePath + out.Privileged = in.Privileged + out.ImagePullPolicy = newer.PullPolicy(in.ImagePullPolicy) + if err := s.Convert(&in.Capabilities, &out.Capabilities, 0); err != nil { + return err + } + return nil + }, + func(in *newer.Container, out *Container, s conversion.Scope) error { + out.Name = in.Name + out.Image = in.Image + if in.Command != nil { + out.Command = make([]string, len(in.Command)) + for i := range in.Command { + out.Command[i] = in.Command[i] + } + } + if in.Args != nil { + out.Args = make([]string, len(in.Args)) + for i := range in.Args { + out.Args[i] = in.Args[i] + } + } + out.WorkingDir = in.WorkingDir + if in.Ports != nil { + out.Ports = make([]ContainerPort, len(in.Ports)) + for i := range in.Ports { + if err := s.Convert(&in.Ports[i], &out.Ports[i], 0); err != nil { + return err + } + } + } + if in.Env != nil { + out.Env = make([]EnvVar, len(in.Env)) + for i := range in.Env { + if err := s.Convert(&in.Env[i], &out.Env[i], 0); err != nil { + return err + } + } + } + if err := s.Convert(&in.Resources, &out.Resources, 0); err != nil { + return err + } + if in.VolumeMounts != nil { + out.VolumeMounts = make([]VolumeMount, len(in.VolumeMounts)) + for i := range in.VolumeMounts { + if err := s.Convert(&in.VolumeMounts[i], &out.VolumeMounts[i], 0); err != nil { + return err + } + } + } + if err := s.Convert(&in.LivenessProbe, &out.LivenessProbe, 0); err != nil { + return err + } + if err := s.Convert(&in.ReadinessProbe, &out.ReadinessProbe, 0); err != nil { + return err + } + if err := s.Convert(&in.Lifecycle, &out.Lifecycle, 0); err != nil { + return err + } + out.TerminationMessagePath = in.TerminationMessagePath + out.Privileged = in.Privileged + out.ImagePullPolicy = PullPolicy(in.ImagePullPolicy) + if err := s.Convert(&in.Capabilities, &out.Capabilities, 0); err != nil { + return err + } + return nil + }, + func(in *ContainerStateWaiting, out *newer.ContainerStateWaiting, s conversion.Scope) error { + out.Reason = in.Reason + return nil + }, + func(in *newer.ContainerStateWaiting, out *ContainerStateWaiting, s conversion.Scope) error { + out.Reason = in.Reason + return nil + }, + func(in *PersistentVolumeClaimList, out *newer.PersistentVolumeClaimList, s conversion.Scope) error { + if err := s.Convert(&in.TypeMeta, &out.TypeMeta, 0); err != nil { + return err + } + if err := s.Convert(&in.ListMeta, &out.ListMeta, 0); err != nil { + return err + } + if in.Items != nil { + out.Items = make([]newer.PersistentVolumeClaim, len(in.Items)) + for i := range in.Items { + if err := s.Convert(&in.Items[i], &out.Items[i], 0); err != nil { + return err + } + } + } + return nil + }, + func(in *newer.PersistentVolumeClaimList, out *PersistentVolumeClaimList, s conversion.Scope) error { + if err := s.Convert(&in.TypeMeta, &out.TypeMeta, 0); err != nil { + return err + } + if err := s.Convert(&in.ListMeta, &out.ListMeta, 0); err != nil { + return err + } + if in.Items != nil { + out.Items = make([]PersistentVolumeClaim, len(in.Items)) + for i := range in.Items { + if err := s.Convert(&in.Items[i], &out.Items[i], 0); err != nil { + return err + } + } + } + return nil + }, + func(in *ReplicationController, out *newer.ReplicationController, s conversion.Scope) error { + if err := s.Convert(&in.TypeMeta, &out.TypeMeta, 0); err != nil { + return err + } + if err := s.Convert(&in.ObjectMeta, &out.ObjectMeta, 0); err != nil { + return err + } + if err := s.Convert(&in.Spec, &out.Spec, 0); err != nil { + return err + } + if err := s.Convert(&in.Status, &out.Status, 0); err != nil { + return err + } + return nil + }, + func(in *newer.ReplicationController, out *ReplicationController, s conversion.Scope) error { + if err := s.Convert(&in.TypeMeta, &out.TypeMeta, 0); err != nil { + return err + } + if err := s.Convert(&in.ObjectMeta, &out.ObjectMeta, 0); err != nil { + return err + } + if err := s.Convert(&in.Spec, &out.Spec, 0); err != nil { + return err + } + if err := s.Convert(&in.Status, &out.Status, 0); err != nil { + return err + } + return nil + }, + func(in *ObjectReference, out *newer.ObjectReference, s conversion.Scope) error { + out.Kind = in.Kind + out.Namespace = in.Namespace + out.Name = in.Name + out.UID = in.UID + out.APIVersion = in.APIVersion + out.ResourceVersion = in.ResourceVersion + out.FieldPath = in.FieldPath + return nil + }, + func(in *newer.ObjectReference, out *ObjectReference, s conversion.Scope) error { + out.Kind = in.Kind + out.Namespace = in.Namespace + out.Name = in.Name + out.UID = in.UID + out.APIVersion = in.APIVersion + out.ResourceVersion = in.ResourceVersion + out.FieldPath = in.FieldPath + return nil + }, + func(in *EndpointAddress, out *newer.EndpointAddress, s conversion.Scope) error { + out.IP = in.IP + if err := s.Convert(&in.TargetRef, &out.TargetRef, 0); err != nil { + return err + } + return nil + }, + func(in *newer.EndpointAddress, out *EndpointAddress, s conversion.Scope) error { + out.IP = in.IP + if err := s.Convert(&in.TargetRef, &out.TargetRef, 0); err != nil { + return err + } + return nil + }, + func(in *ResourceQuota, out *newer.ResourceQuota, s conversion.Scope) error { + if err := s.Convert(&in.TypeMeta, &out.TypeMeta, 0); err != nil { + return err + } + if err := s.Convert(&in.ObjectMeta, &out.ObjectMeta, 0); err != nil { + return err + } + if err := s.Convert(&in.Spec, &out.Spec, 0); err != nil { + return err + } + if err := s.Convert(&in.Status, &out.Status, 0); err != nil { + return err + } + return nil + }, + func(in *newer.ResourceQuota, out *ResourceQuota, s conversion.Scope) error { + if err := s.Convert(&in.TypeMeta, &out.TypeMeta, 0); err != nil { + return err + } + if err := s.Convert(&in.ObjectMeta, &out.ObjectMeta, 0); err != nil { + return err + } + if err := s.Convert(&in.Spec, &out.Spec, 0); err != nil { + return err + } + if err := s.Convert(&in.Status, &out.Status, 0); err != nil { + return err + } + return nil + }, + func(in *Event, out *newer.Event, s conversion.Scope) error { + if err := s.Convert(&in.TypeMeta, &out.TypeMeta, 0); err != nil { + return err + } + if err := s.Convert(&in.ObjectMeta, &out.ObjectMeta, 0); err != nil { + return err + } + if err := s.Convert(&in.InvolvedObject, &out.InvolvedObject, 0); err != nil { + return err + } + out.Reason = in.Reason + out.Message = in.Message + if err := s.Convert(&in.Source, &out.Source, 0); err != nil { + return err + } + if err := s.Convert(&in.FirstTimestamp, &out.FirstTimestamp, 0); err != nil { + return err + } + if err := s.Convert(&in.LastTimestamp, &out.LastTimestamp, 0); err != nil { + return err + } + out.Count = in.Count + return nil + }, + func(in *newer.Event, out *Event, s conversion.Scope) error { + if err := s.Convert(&in.TypeMeta, &out.TypeMeta, 0); err != nil { + return err + } + if err := s.Convert(&in.ObjectMeta, &out.ObjectMeta, 0); err != nil { + return err + } + if err := s.Convert(&in.InvolvedObject, &out.InvolvedObject, 0); err != nil { + return err + } + out.Reason = in.Reason + out.Message = in.Message + if err := s.Convert(&in.Source, &out.Source, 0); err != nil { + return err + } + if err := s.Convert(&in.FirstTimestamp, &out.FirstTimestamp, 0); err != nil { + return err + } + if err := s.Convert(&in.LastTimestamp, &out.LastTimestamp, 0); err != nil { + return err + } + out.Count = in.Count + return nil + }, + func(in *LimitRangeList, out *newer.LimitRangeList, s conversion.Scope) error { + if err := s.Convert(&in.TypeMeta, &out.TypeMeta, 0); err != nil { + return err + } + if err := s.Convert(&in.ListMeta, &out.ListMeta, 0); err != nil { + return err + } + if in.Items != nil { + out.Items = make([]newer.LimitRange, len(in.Items)) + for i := range in.Items { + if err := s.Convert(&in.Items[i], &out.Items[i], 0); err != nil { + return err + } + } + } + return nil + }, + func(in *newer.LimitRangeList, out *LimitRangeList, s conversion.Scope) error { + if err := s.Convert(&in.TypeMeta, &out.TypeMeta, 0); err != nil { + return err + } + if err := s.Convert(&in.ListMeta, &out.ListMeta, 0); err != nil { + return err + } + if in.Items != nil { + out.Items = make([]LimitRange, len(in.Items)) + for i := range in.Items { + if err := s.Convert(&in.Items[i], &out.Items[i], 0); err != nil { + return err + } + } + } + return nil + }, + func(in *Volume, out *newer.Volume, s conversion.Scope) error { + out.Name = in.Name + if err := s.Convert(&in.VolumeSource, &out.VolumeSource, 0); err != nil { + return err + } + return nil + }, + func(in *newer.Volume, out *Volume, s conversion.Scope) error { + out.Name = in.Name + if err := s.Convert(&in.VolumeSource, &out.VolumeSource, 0); err != nil { + return err + } + return nil + }, + func(in *NFSVolumeSource, out *newer.NFSVolumeSource, s conversion.Scope) error { + out.Server = in.Server + out.Path = in.Path + out.ReadOnly = in.ReadOnly + return nil + }, + func(in *newer.NFSVolumeSource, out *NFSVolumeSource, s conversion.Scope) error { + out.Server = in.Server + out.Path = in.Path + out.ReadOnly = in.ReadOnly + return nil + }, + func(in *ContainerPort, out *newer.ContainerPort, s conversion.Scope) error { + out.Name = in.Name + out.HostPort = in.HostPort + out.ContainerPort = in.ContainerPort + out.Protocol = newer.Protocol(in.Protocol) + out.HostIP = in.HostIP + return nil + }, + func(in *newer.ContainerPort, out *ContainerPort, s conversion.Scope) error { + out.Name = in.Name + out.HostPort = in.HostPort + out.ContainerPort = in.ContainerPort + out.Protocol = Protocol(in.Protocol) + out.HostIP = in.HostIP + return nil + }, + func(in *Status, out *newer.Status, s conversion.Scope) error { + if err := s.Convert(&in.TypeMeta, &out.TypeMeta, 0); err != nil { + return err + } + if err := s.Convert(&in.ListMeta, &out.ListMeta, 0); err != nil { + return err + } + out.Status = in.Status + out.Message = in.Message + out.Reason = newer.StatusReason(in.Reason) + if err := s.Convert(&in.Details, &out.Details, 0); err != nil { + return err + } + out.Code = in.Code + return nil + }, + func(in *newer.Status, out *Status, s conversion.Scope) error { + if err := s.Convert(&in.TypeMeta, &out.TypeMeta, 0); err != nil { + return err + } + if err := s.Convert(&in.ListMeta, &out.ListMeta, 0); err != nil { + return err + } + out.Status = in.Status + out.Message = in.Message + out.Reason = StatusReason(in.Reason) + if err := s.Convert(&in.Details, &out.Details, 0); err != nil { + return err + } + out.Code = in.Code + return nil + }, + func(in *NamespaceSpec, out *newer.NamespaceSpec, s conversion.Scope) error { + if in.Finalizers != nil { + out.Finalizers = make([]newer.FinalizerName, len(in.Finalizers)) + for i := range in.Finalizers { + if err := s.Convert(&in.Finalizers[i], &out.Finalizers[i], 0); err != nil { + return err + } + } + } + return nil + }, + func(in *newer.NamespaceSpec, out *NamespaceSpec, s conversion.Scope) error { + if in.Finalizers != nil { + out.Finalizers = make([]FinalizerName, len(in.Finalizers)) + for i := range in.Finalizers { + if err := s.Convert(&in.Finalizers[i], &out.Finalizers[i], 0); err != nil { + return err + } + } + } + return nil + }, + func(in *ComponentStatusList, out *newer.ComponentStatusList, s conversion.Scope) error { + if err := s.Convert(&in.TypeMeta, &out.TypeMeta, 0); err != nil { + return err + } + if err := s.Convert(&in.ListMeta, &out.ListMeta, 0); err != nil { + return err + } + if in.Items != nil { + out.Items = make([]newer.ComponentStatus, len(in.Items)) + for i := range in.Items { + if err := s.Convert(&in.Items[i], &out.Items[i], 0); err != nil { + return err + } + } + } + return nil + }, + func(in *newer.ComponentStatusList, out *ComponentStatusList, s conversion.Scope) error { + if err := s.Convert(&in.TypeMeta, &out.TypeMeta, 0); err != nil { + return err + } + if err := s.Convert(&in.ListMeta, &out.ListMeta, 0); err != nil { + return err + } + if in.Items != nil { + out.Items = make([]ComponentStatus, len(in.Items)) + for i := range in.Items { + if err := s.Convert(&in.Items[i], &out.Items[i], 0); err != nil { + return err + } + } + } + return nil + }, + func(in *Namespace, out *newer.Namespace, s conversion.Scope) error { + if err := s.Convert(&in.TypeMeta, &out.TypeMeta, 0); err != nil { + return err + } + if err := s.Convert(&in.ObjectMeta, &out.ObjectMeta, 0); err != nil { + return err + } + if err := s.Convert(&in.Spec, &out.Spec, 0); err != nil { + return err + } + if err := s.Convert(&in.Status, &out.Status, 0); err != nil { + return err + } + return nil + }, + func(in *newer.Namespace, out *Namespace, s conversion.Scope) error { + if err := s.Convert(&in.TypeMeta, &out.TypeMeta, 0); err != nil { + return err + } + if err := s.Convert(&in.ObjectMeta, &out.ObjectMeta, 0); err != nil { + return err + } + if err := s.Convert(&in.Spec, &out.Spec, 0); err != nil { + return err + } + if err := s.Convert(&in.Status, &out.Status, 0); err != nil { + return err + } + return nil + }, + func(in *EmptyDirVolumeSource, out *newer.EmptyDirVolumeSource, s conversion.Scope) error { + out.Medium = newer.StorageType(in.Medium) + return nil + }, + func(in *newer.EmptyDirVolumeSource, out *EmptyDirVolumeSource, s conversion.Scope) error { + out.Medium = StorageType(in.Medium) + return nil + }, + func(in *LimitRangeSpec, out *newer.LimitRangeSpec, s conversion.Scope) error { + if in.Limits != nil { + out.Limits = make([]newer.LimitRangeItem, len(in.Limits)) + for i := range in.Limits { + if err := s.Convert(&in.Limits[i], &out.Limits[i], 0); err != nil { + return err + } + } + } + return nil + }, + func(in *newer.LimitRangeSpec, out *LimitRangeSpec, s conversion.Scope) error { + if in.Limits != nil { + out.Limits = make([]LimitRangeItem, len(in.Limits)) + for i := range in.Limits { + if err := s.Convert(&in.Limits[i], &out.Limits[i], 0); err != nil { + return err + } + } + } + return nil + }, + func(in *LimitRange, out *newer.LimitRange, s conversion.Scope) error { + if err := s.Convert(&in.TypeMeta, &out.TypeMeta, 0); err != nil { + return err + } + if err := s.Convert(&in.ObjectMeta, &out.ObjectMeta, 0); err != nil { + return err + } + if err := s.Convert(&in.Spec, &out.Spec, 0); err != nil { + return err + } + return nil + }, + func(in *newer.LimitRange, out *LimitRange, s conversion.Scope) error { + if err := s.Convert(&in.TypeMeta, &out.TypeMeta, 0); err != nil { + return err + } + if err := s.Convert(&in.ObjectMeta, &out.ObjectMeta, 0); err != nil { + return err + } + if err := s.Convert(&in.Spec, &out.Spec, 0); err != nil { + return err + } + return nil + }, + func(in *ExecAction, out *newer.ExecAction, s conversion.Scope) error { + if in.Command != nil { + out.Command = make([]string, len(in.Command)) + for i := range in.Command { + out.Command[i] = in.Command[i] + } + } + return nil + }, + func(in *newer.ExecAction, out *ExecAction, s conversion.Scope) error { + if in.Command != nil { + out.Command = make([]string, len(in.Command)) + for i := range in.Command { + out.Command[i] = in.Command[i] + } + } + return nil + }, + func(in *Probe, out *newer.Probe, s conversion.Scope) error { + if err := s.Convert(&in.Handler, &out.Handler, 0); err != nil { + return err + } + out.InitialDelaySeconds = in.InitialDelaySeconds + out.TimeoutSeconds = in.TimeoutSeconds + return nil + }, + func(in *newer.Probe, out *Probe, s conversion.Scope) error { + if err := s.Convert(&in.Handler, &out.Handler, 0); err != nil { + return err + } + out.InitialDelaySeconds = in.InitialDelaySeconds + out.TimeoutSeconds = in.TimeoutSeconds + return nil + }, + func(in *ReplicationControllerSpec, out *newer.ReplicationControllerSpec, s conversion.Scope) error { + out.Replicas = in.Replicas + if in.Selector != nil { + out.Selector = make(map[string]string) + for key, val := range in.Selector { + out.Selector[key] = val + } + } + if err := s.Convert(&in.TemplateRef, &out.TemplateRef, 0); err != nil { + return err + } + if err := s.Convert(&in.Template, &out.Template, 0); err != nil { + return err + } + return nil + }, + func(in *newer.ReplicationControllerSpec, out *ReplicationControllerSpec, s conversion.Scope) error { + out.Replicas = in.Replicas + if in.Selector != nil { + out.Selector = make(map[string]string) + for key, val := range in.Selector { + out.Selector[key] = val + } + } + if err := s.Convert(&in.TemplateRef, &out.TemplateRef, 0); err != nil { + return err + } + if err := s.Convert(&in.Template, &out.Template, 0); err != nil { + return err + } + return nil + }, + func(in *LimitRangeItem, out *newer.LimitRangeItem, s conversion.Scope) error { + out.Type = newer.LimitType(in.Type) + if in.Max != nil { + out.Max = make(map[newer.ResourceName]resource.Quantity) + for key, val := range in.Max { + newVal := resource.Quantity{} + if err := s.Convert(&val, &newVal, 0); err != nil { + return err + } + out.Max[newer.ResourceName(key)] = newVal + } + } + if in.Min != nil { + out.Min = make(map[newer.ResourceName]resource.Quantity) + for key, val := range in.Min { + newVal := resource.Quantity{} + if err := s.Convert(&val, &newVal, 0); err != nil { + return err + } + out.Min[newer.ResourceName(key)] = newVal + } + } + if in.Default != nil { + out.Default = make(map[newer.ResourceName]resource.Quantity) + for key, val := range in.Default { + newVal := resource.Quantity{} + if err := s.Convert(&val, &newVal, 0); err != nil { + return err + } + out.Default[newer.ResourceName(key)] = newVal + } + } + return nil + }, + func(in *newer.LimitRangeItem, out *LimitRangeItem, s conversion.Scope) error { + out.Type = LimitType(in.Type) + if in.Max != nil { + out.Max = make(map[ResourceName]resource.Quantity) + for key, val := range in.Max { + newVal := resource.Quantity{} + if err := s.Convert(&val, &newVal, 0); err != nil { + return err + } + out.Max[ResourceName(key)] = newVal + } + } + if in.Min != nil { + out.Min = make(map[ResourceName]resource.Quantity) + for key, val := range in.Min { + newVal := resource.Quantity{} + if err := s.Convert(&val, &newVal, 0); err != nil { + return err + } + out.Min[ResourceName(key)] = newVal + } + } + if in.Default != nil { + out.Default = make(map[ResourceName]resource.Quantity) + for key, val := range in.Default { + newVal := resource.Quantity{} + if err := s.Convert(&val, &newVal, 0); err != nil { + return err + } + out.Default[ResourceName(key)] = newVal + } + } + return nil + }, + func(in *EnvVar, out *newer.EnvVar, s conversion.Scope) error { + out.Name = in.Name + out.Value = in.Value + return nil + }, + func(in *newer.EnvVar, out *EnvVar, s conversion.Scope) error { + out.Name = in.Name + out.Value = in.Value + return nil + }, + func(in *PodSpec, out *newer.PodSpec, s conversion.Scope) error { + if in.Volumes != nil { + out.Volumes = make([]newer.Volume, len(in.Volumes)) + for i := range in.Volumes { + if err := s.Convert(&in.Volumes[i], &out.Volumes[i], 0); err != nil { + return err + } + } + } + if in.Containers != nil { + out.Containers = make([]newer.Container, len(in.Containers)) + for i := range in.Containers { + if err := s.Convert(&in.Containers[i], &out.Containers[i], 0); err != nil { + return err + } + } + } + out.RestartPolicy = newer.RestartPolicy(in.RestartPolicy) + out.DNSPolicy = newer.DNSPolicy(in.DNSPolicy) + if in.NodeSelector != nil { + out.NodeSelector = make(map[string]string) + for key, val := range in.NodeSelector { + out.NodeSelector[key] = val + } + } + out.Host = in.Host + out.HostNetwork = in.HostNetwork + return nil + }, + func(in *newer.PodSpec, out *PodSpec, s conversion.Scope) error { + if in.Volumes != nil { + out.Volumes = make([]Volume, len(in.Volumes)) + for i := range in.Volumes { + if err := s.Convert(&in.Volumes[i], &out.Volumes[i], 0); err != nil { + return err + } + } + } + if in.Containers != nil { + out.Containers = make([]Container, len(in.Containers)) + for i := range in.Containers { + if err := s.Convert(&in.Containers[i], &out.Containers[i], 0); err != nil { + return err + } + } + } + out.RestartPolicy = RestartPolicy(in.RestartPolicy) + out.DNSPolicy = DNSPolicy(in.DNSPolicy) + if in.NodeSelector != nil { + out.NodeSelector = make(map[string]string) + for key, val := range in.NodeSelector { + out.NodeSelector[key] = val + } + } + out.Host = in.Host + out.HostNetwork = in.HostNetwork + return nil + }, + func(in *ComponentCondition, out *newer.ComponentCondition, s conversion.Scope) error { + out.Type = newer.ComponentConditionType(in.Type) + out.Status = newer.ConditionStatus(in.Status) + out.Message = in.Message + out.Error = in.Error + return nil + }, + func(in *newer.ComponentCondition, out *ComponentCondition, s conversion.Scope) error { + out.Type = ComponentConditionType(in.Type) + out.Status = ConditionStatus(in.Status) + out.Message = in.Message + out.Error = in.Error + return nil + }, + func(in *AWSElasticBlockStoreVolumeSource, out *newer.AWSElasticBlockStoreVolumeSource, s conversion.Scope) error { + out.VolumeID = in.VolumeID + out.FSType = in.FSType + out.Partition = in.Partition + out.ReadOnly = in.ReadOnly + return nil + }, + func(in *newer.AWSElasticBlockStoreVolumeSource, out *AWSElasticBlockStoreVolumeSource, s conversion.Scope) error { + out.VolumeID = in.VolumeID + out.FSType = in.FSType + out.Partition = in.Partition + out.ReadOnly = in.ReadOnly + return nil + }, + func(in *PersistentVolumeClaimSpec, out *newer.PersistentVolumeClaimSpec, s conversion.Scope) error { + if in.AccessModes != nil { + out.AccessModes = make([]newer.AccessModeType, len(in.AccessModes)) + for i := range in.AccessModes { + if err := s.Convert(&in.AccessModes[i], &out.AccessModes[i], 0); err != nil { + return err + } + } + } + if err := s.Convert(&in.Resources, &out.Resources, 0); err != nil { + return err + } + return nil + }, + func(in *newer.PersistentVolumeClaimSpec, out *PersistentVolumeClaimSpec, s conversion.Scope) error { + if in.AccessModes != nil { + out.AccessModes = make([]AccessModeType, len(in.AccessModes)) + for i := range in.AccessModes { + if err := s.Convert(&in.AccessModes[i], &out.AccessModes[i], 0); err != nil { + return err + } + } + } + if err := s.Convert(&in.Resources, &out.Resources, 0); err != nil { + return err + } + return nil + }, + func(in *HostPathVolumeSource, out *newer.HostPathVolumeSource, s conversion.Scope) error { + out.Path = in.Path + return nil + }, + func(in *newer.HostPathVolumeSource, out *HostPathVolumeSource, s conversion.Scope) error { + out.Path = in.Path + return nil + }, + func(in *EventSource, out *newer.EventSource, s conversion.Scope) error { + out.Component = in.Component + out.Host = in.Host + return nil + }, + func(in *newer.EventSource, out *EventSource, s conversion.Scope) error { + out.Component = in.Component + out.Host = in.Host + return nil + }, + func(in *Lifecycle, out *newer.Lifecycle, s conversion.Scope) error { + if err := s.Convert(&in.PostStart, &out.PostStart, 0); err != nil { + return err + } + if err := s.Convert(&in.PreStop, &out.PreStop, 0); err != nil { + return err + } + return nil + }, + func(in *newer.Lifecycle, out *Lifecycle, s conversion.Scope) error { + if err := s.Convert(&in.PostStart, &out.PostStart, 0); err != nil { + return err + } + if err := s.Convert(&in.PreStop, &out.PreStop, 0); err != nil { + return err + } + return nil + }, + func(in *ContainerState, out *newer.ContainerState, s conversion.Scope) error { + if err := s.Convert(&in.Waiting, &out.Waiting, 0); err != nil { + return err + } + if err := s.Convert(&in.Running, &out.Running, 0); err != nil { + return err + } + if err := s.Convert(&in.Termination, &out.Termination, 0); err != nil { + return err + } + return nil + }, + func(in *newer.ContainerState, out *ContainerState, s conversion.Scope) error { + if err := s.Convert(&in.Waiting, &out.Waiting, 0); err != nil { + return err + } + if err := s.Convert(&in.Running, &out.Running, 0); err != nil { + return err + } + if err := s.Convert(&in.Termination, &out.Termination, 0); err != nil { + return err + } + return nil + }, + func(in *ContainerStatus, out *newer.ContainerStatus, s conversion.Scope) error { + out.Name = in.Name + if err := s.Convert(&in.State, &out.State, 0); err != nil { + return err + } + if err := s.Convert(&in.LastTerminationState, &out.LastTerminationState, 0); err != nil { + return err + } + out.Ready = in.Ready + out.RestartCount = in.RestartCount + out.Image = in.Image + out.ImageID = in.ImageID + out.ContainerID = in.ContainerID + return nil + }, + func(in *newer.ContainerStatus, out *ContainerStatus, s conversion.Scope) error { + out.Name = in.Name + if err := s.Convert(&in.State, &out.State, 0); err != nil { + return err + } + if err := s.Convert(&in.LastTerminationState, &out.LastTerminationState, 0); err != nil { + return err + } + out.Ready = in.Ready + out.RestartCount = in.RestartCount + out.Image = in.Image + out.ImageID = in.ImageID + out.ContainerID = in.ContainerID + return nil + }, + func(in *Node, out *newer.Node, s conversion.Scope) error { + if err := s.Convert(&in.TypeMeta, &out.TypeMeta, 0); err != nil { + return err + } + if err := s.Convert(&in.ObjectMeta, &out.ObjectMeta, 0); err != nil { + return err + } + if err := s.Convert(&in.Spec, &out.Spec, 0); err != nil { + return err + } + if err := s.Convert(&in.Status, &out.Status, 0); err != nil { + return err + } + return nil + }, + func(in *newer.Node, out *Node, s conversion.Scope) error { + if err := s.Convert(&in.TypeMeta, &out.TypeMeta, 0); err != nil { + return err + } + if err := s.Convert(&in.ObjectMeta, &out.ObjectMeta, 0); err != nil { + return err + } + if err := s.Convert(&in.Spec, &out.Spec, 0); err != nil { + return err + } + if err := s.Convert(&in.Status, &out.Status, 0); err != nil { + return err + } + return nil + }, + func(in *StatusCause, out *newer.StatusCause, s conversion.Scope) error { + out.Type = newer.CauseType(in.Type) + out.Message = in.Message + out.Field = in.Field + return nil + }, + func(in *newer.StatusCause, out *StatusCause, s conversion.Scope) error { + out.Type = CauseType(in.Type) + out.Message = in.Message + out.Field = in.Field + return nil + }, + func(in *PersistentVolumeList, out *newer.PersistentVolumeList, s conversion.Scope) error { + if err := s.Convert(&in.TypeMeta, &out.TypeMeta, 0); err != nil { + return err + } + if err := s.Convert(&in.ListMeta, &out.ListMeta, 0); err != nil { + return err + } + if in.Items != nil { + out.Items = make([]newer.PersistentVolume, len(in.Items)) + for i := range in.Items { + if err := s.Convert(&in.Items[i], &out.Items[i], 0); err != nil { + return err + } + } + } + return nil + }, + func(in *newer.PersistentVolumeList, out *PersistentVolumeList, s conversion.Scope) error { + if err := s.Convert(&in.TypeMeta, &out.TypeMeta, 0); err != nil { + return err + } + if err := s.Convert(&in.ListMeta, &out.ListMeta, 0); err != nil { + return err + } + if in.Items != nil { + out.Items = make([]PersistentVolume, len(in.Items)) + for i := range in.Items { + if err := s.Convert(&in.Items[i], &out.Items[i], 0); err != nil { + return err + } + } + } + return nil + }, + func(in *VolumeSource, out *newer.VolumeSource, s conversion.Scope) error { + if err := s.Convert(&in.HostPath, &out.HostPath, 0); err != nil { + return err + } + if err := s.Convert(&in.EmptyDir, &out.EmptyDir, 0); err != nil { + return err + } + if err := s.Convert(&in.GCEPersistentDisk, &out.GCEPersistentDisk, 0); err != nil { + return err + } + if err := s.Convert(&in.AWSElasticBlockStore, &out.AWSElasticBlockStore, 0); err != nil { + return err + } + if err := s.Convert(&in.GitRepo, &out.GitRepo, 0); err != nil { + return err + } + if err := s.Convert(&in.Secret, &out.Secret, 0); err != nil { + return err + } + if err := s.Convert(&in.NFS, &out.NFS, 0); err != nil { + return err + } + if err := s.Convert(&in.ISCSI, &out.ISCSI, 0); err != nil { + return err + } + if err := s.Convert(&in.Glusterfs, &out.Glusterfs, 0); err != nil { + return err + } + if err := s.Convert(&in.PersistentVolumeClaimVolumeSource, &out.PersistentVolumeClaimVolumeSource, 0); err != nil { + return err + } + return nil + }, + func(in *newer.VolumeSource, out *VolumeSource, s conversion.Scope) error { + if err := s.Convert(&in.HostPath, &out.HostPath, 0); err != nil { + return err + } + if err := s.Convert(&in.EmptyDir, &out.EmptyDir, 0); err != nil { + return err + } + if err := s.Convert(&in.GCEPersistentDisk, &out.GCEPersistentDisk, 0); err != nil { + return err + } + if err := s.Convert(&in.AWSElasticBlockStore, &out.AWSElasticBlockStore, 0); err != nil { + return err + } + if err := s.Convert(&in.GitRepo, &out.GitRepo, 0); err != nil { + return err + } + if err := s.Convert(&in.Secret, &out.Secret, 0); err != nil { + return err + } + if err := s.Convert(&in.NFS, &out.NFS, 0); err != nil { + return err + } + if err := s.Convert(&in.ISCSI, &out.ISCSI, 0); err != nil { + return err + } + if err := s.Convert(&in.Glusterfs, &out.Glusterfs, 0); err != nil { + return err + } + if err := s.Convert(&in.PersistentVolumeClaimVolumeSource, &out.PersistentVolumeClaimVolumeSource, 0); err != nil { + return err + } + return nil + }, + func(in *ResourceRequirements, out *newer.ResourceRequirements, s conversion.Scope) error { + if in.Limits != nil { + out.Limits = make(map[newer.ResourceName]resource.Quantity) + for key, val := range in.Limits { + newVal := resource.Quantity{} + if err := s.Convert(&val, &newVal, 0); err != nil { + return err + } + out.Limits[newer.ResourceName(key)] = newVal + } + } + if in.Requests != nil { + out.Requests = make(map[newer.ResourceName]resource.Quantity) + for key, val := range in.Requests { + newVal := resource.Quantity{} + if err := s.Convert(&val, &newVal, 0); err != nil { + return err + } + out.Requests[newer.ResourceName(key)] = newVal + } + } + return nil + }, + func(in *newer.ResourceRequirements, out *ResourceRequirements, s conversion.Scope) error { + if in.Limits != nil { + out.Limits = make(map[ResourceName]resource.Quantity) + for key, val := range in.Limits { + newVal := resource.Quantity{} + if err := s.Convert(&val, &newVal, 0); err != nil { + return err + } + out.Limits[ResourceName(key)] = newVal + } + } + if in.Requests != nil { + out.Requests = make(map[ResourceName]resource.Quantity) + for key, val := range in.Requests { + newVal := resource.Quantity{} + if err := s.Convert(&val, &newVal, 0); err != nil { + return err + } + out.Requests[ResourceName(key)] = newVal + } + } + return nil + }, + func(in *PersistentVolume, out *newer.PersistentVolume, s conversion.Scope) error { + if err := s.Convert(&in.TypeMeta, &out.TypeMeta, 0); err != nil { + return err + } + if err := s.Convert(&in.ObjectMeta, &out.ObjectMeta, 0); err != nil { + return err + } + if err := s.Convert(&in.Spec, &out.Spec, 0); err != nil { + return err + } + if err := s.Convert(&in.Status, &out.Status, 0); err != nil { + return err + } + return nil + }, + func(in *newer.PersistentVolume, out *PersistentVolume, s conversion.Scope) error { + if err := s.Convert(&in.TypeMeta, &out.TypeMeta, 0); err != nil { + return err + } + if err := s.Convert(&in.ObjectMeta, &out.ObjectMeta, 0); err != nil { + return err + } + if err := s.Convert(&in.Spec, &out.Spec, 0); err != nil { + return err + } + if err := s.Convert(&in.Status, &out.Status, 0); err != nil { + return err + } + return nil + }, + func(in *Service, out *newer.Service, s conversion.Scope) error { + if err := s.Convert(&in.TypeMeta, &out.TypeMeta, 0); err != nil { + return err + } + if err := s.Convert(&in.ObjectMeta, &out.ObjectMeta, 0); err != nil { + return err + } + if err := s.Convert(&in.Spec, &out.Spec, 0); err != nil { + return err + } + if err := s.Convert(&in.Status, &out.Status, 0); err != nil { + return err + } + return nil + }, + func(in *newer.Service, out *Service, s conversion.Scope) error { + if err := s.Convert(&in.TypeMeta, &out.TypeMeta, 0); err != nil { + return err + } + if err := s.Convert(&in.ObjectMeta, &out.ObjectMeta, 0); err != nil { + return err + } + if err := s.Convert(&in.Spec, &out.Spec, 0); err != nil { + return err + } + if err := s.Convert(&in.Status, &out.Status, 0); err != nil { + return err + } + return nil + }, + func(in *ReplicationControllerStatus, out *newer.ReplicationControllerStatus, s conversion.Scope) error { + out.Replicas = in.Replicas + return nil + }, + func(in *newer.ReplicationControllerStatus, out *ReplicationControllerStatus, s conversion.Scope) error { + out.Replicas = in.Replicas + return nil + }, + func(in *ServiceList, out *newer.ServiceList, s conversion.Scope) error { + if err := s.Convert(&in.TypeMeta, &out.TypeMeta, 0); err != nil { + return err + } + if err := s.Convert(&in.ListMeta, &out.ListMeta, 0); err != nil { + return err + } + if in.Items != nil { + out.Items = make([]newer.Service, len(in.Items)) + for i := range in.Items { + if err := s.Convert(&in.Items[i], &out.Items[i], 0); err != nil { + return err + } + } + } + return nil + }, + func(in *newer.ServiceList, out *ServiceList, s conversion.Scope) error { + if err := s.Convert(&in.TypeMeta, &out.TypeMeta, 0); err != nil { + return err + } + if err := s.Convert(&in.ListMeta, &out.ListMeta, 0); err != nil { + return err + } + if in.Items != nil { + out.Items = make([]Service, len(in.Items)) + for i := range in.Items { + if err := s.Convert(&in.Items[i], &out.Items[i], 0); err != nil { + return err + } + } + } + return nil + }, + func(in *PodLogOptions, out *newer.PodLogOptions, s conversion.Scope) error { + if err := s.Convert(&in.TypeMeta, &out.TypeMeta, 0); err != nil { + return err + } + out.Container = in.Container + out.Follow = in.Follow + return nil + }, + func(in *newer.PodLogOptions, out *PodLogOptions, s conversion.Scope) error { + if err := s.Convert(&in.TypeMeta, &out.TypeMeta, 0); err != nil { + return err + } + out.Container = in.Container + out.Follow = in.Follow + return nil + }, + func(in *GlusterfsVolumeSource, out *newer.GlusterfsVolumeSource, s conversion.Scope) error { + out.EndpointsName = in.EndpointsName + out.Path = in.Path + out.ReadOnly = in.ReadOnly + return nil + }, + func(in *newer.GlusterfsVolumeSource, out *GlusterfsVolumeSource, s conversion.Scope) error { + out.EndpointsName = in.EndpointsName + out.Path = in.Path + out.ReadOnly = in.ReadOnly + return nil + }, + func(in *SecretList, out *newer.SecretList, s conversion.Scope) error { + if err := s.Convert(&in.TypeMeta, &out.TypeMeta, 0); err != nil { + return err + } + if err := s.Convert(&in.ListMeta, &out.ListMeta, 0); err != nil { + return err + } + if in.Items != nil { + out.Items = make([]newer.Secret, len(in.Items)) + for i := range in.Items { + if err := s.Convert(&in.Items[i], &out.Items[i], 0); err != nil { + return err + } + } + } + return nil + }, + func(in *newer.SecretList, out *SecretList, s conversion.Scope) error { + if err := s.Convert(&in.TypeMeta, &out.TypeMeta, 0); err != nil { + return err + } + if err := s.Convert(&in.ListMeta, &out.ListMeta, 0); err != nil { + return err + } + if in.Items != nil { + out.Items = make([]Secret, len(in.Items)) + for i := range in.Items { + if err := s.Convert(&in.Items[i], &out.Items[i], 0); err != nil { + return err + } + } + } + return nil + }, + func(in *Capabilities, out *newer.Capabilities, s conversion.Scope) error { + if in.Add != nil { + out.Add = make([]newer.CapabilityType, len(in.Add)) + for i := range in.Add { + if err := s.Convert(&in.Add[i], &out.Add[i], 0); err != nil { + return err + } + } + } + if in.Drop != nil { + out.Drop = make([]newer.CapabilityType, len(in.Drop)) + for i := range in.Drop { + if err := s.Convert(&in.Drop[i], &out.Drop[i], 0); err != nil { + return err + } + } + } + return nil + }, + func(in *newer.Capabilities, out *Capabilities, s conversion.Scope) error { + if in.Add != nil { + out.Add = make([]CapabilityType, len(in.Add)) + for i := range in.Add { + if err := s.Convert(&in.Add[i], &out.Add[i], 0); err != nil { + return err + } + } + } + if in.Drop != nil { + out.Drop = make([]CapabilityType, len(in.Drop)) + for i := range in.Drop { + if err := s.Convert(&in.Drop[i], &out.Drop[i], 0); err != nil { + return err + } + } + } + return nil + }, + func(in *ContainerStateRunning, out *newer.ContainerStateRunning, s conversion.Scope) error { + if err := s.Convert(&in.StartedAt, &out.StartedAt, 0); err != nil { + return err + } + return nil + }, + func(in *newer.ContainerStateRunning, out *ContainerStateRunning, s conversion.Scope) error { + if err := s.Convert(&in.StartedAt, &out.StartedAt, 0); err != nil { + return err + } + return nil + }, + func(in *ContainerStateTerminated, out *newer.ContainerStateTerminated, s conversion.Scope) error { + out.ExitCode = in.ExitCode + out.Signal = in.Signal + out.Reason = in.Reason + out.Message = in.Message + if err := s.Convert(&in.StartedAt, &out.StartedAt, 0); err != nil { + return err + } + if err := s.Convert(&in.FinishedAt, &out.FinishedAt, 0); err != nil { + return err + } + out.ContainerID = in.ContainerID + return nil + }, + func(in *newer.ContainerStateTerminated, out *ContainerStateTerminated, s conversion.Scope) error { + out.ExitCode = in.ExitCode + out.Signal = in.Signal + out.Reason = in.Reason + out.Message = in.Message + if err := s.Convert(&in.StartedAt, &out.StartedAt, 0); err != nil { + return err + } + if err := s.Convert(&in.FinishedAt, &out.FinishedAt, 0); err != nil { + return err + } + out.ContainerID = in.ContainerID + return nil + }, + func(in *NodeStatus, out *newer.NodeStatus, s conversion.Scope) error { + if in.Capacity != nil { + out.Capacity = make(map[newer.ResourceName]resource.Quantity) + for key, val := range in.Capacity { + newVal := resource.Quantity{} + if err := s.Convert(&val, &newVal, 0); err != nil { + return err + } + out.Capacity[newer.ResourceName(key)] = newVal + } + } + out.Phase = newer.NodePhase(in.Phase) + if in.Conditions != nil { + out.Conditions = make([]newer.NodeCondition, len(in.Conditions)) + for i := range in.Conditions { + if err := s.Convert(&in.Conditions[i], &out.Conditions[i], 0); err != nil { + return err + } + } + } + if in.Addresses != nil { + out.Addresses = make([]newer.NodeAddress, len(in.Addresses)) + for i := range in.Addresses { + if err := s.Convert(&in.Addresses[i], &out.Addresses[i], 0); err != nil { + return err + } + } + } + if err := s.Convert(&in.NodeInfo, &out.NodeInfo, 0); err != nil { + return err + } + return nil + }, + func(in *newer.NodeStatus, out *NodeStatus, s conversion.Scope) error { + if in.Capacity != nil { + out.Capacity = make(map[ResourceName]resource.Quantity) + for key, val := range in.Capacity { + newVal := resource.Quantity{} + if err := s.Convert(&val, &newVal, 0); err != nil { + return err + } + out.Capacity[ResourceName(key)] = newVal + } + } + out.Phase = NodePhase(in.Phase) + if in.Conditions != nil { + out.Conditions = make([]NodeCondition, len(in.Conditions)) + for i := range in.Conditions { + if err := s.Convert(&in.Conditions[i], &out.Conditions[i], 0); err != nil { + return err + } + } + } + if in.Addresses != nil { + out.Addresses = make([]NodeAddress, len(in.Addresses)) + for i := range in.Addresses { + if err := s.Convert(&in.Addresses[i], &out.Addresses[i], 0); err != nil { + return err + } + } + } + if err := s.Convert(&in.NodeInfo, &out.NodeInfo, 0); err != nil { + return err + } + return nil + }, + func(in *PersistentVolumeSpec, out *newer.PersistentVolumeSpec, s conversion.Scope) error { + if in.Capacity != nil { + out.Capacity = make(map[newer.ResourceName]resource.Quantity) + for key, val := range in.Capacity { + newVal := resource.Quantity{} + if err := s.Convert(&val, &newVal, 0); err != nil { + return err + } + out.Capacity[newer.ResourceName(key)] = newVal + } + } + if err := s.Convert(&in.PersistentVolumeSource, &out.PersistentVolumeSource, 0); err != nil { + return err + } + if in.AccessModes != nil { + out.AccessModes = make([]newer.AccessModeType, len(in.AccessModes)) + for i := range in.AccessModes { + if err := s.Convert(&in.AccessModes[i], &out.AccessModes[i], 0); err != nil { + return err + } + } + } + if err := s.Convert(&in.ClaimRef, &out.ClaimRef, 0); err != nil { + return err + } + return nil + }, + func(in *newer.PersistentVolumeSpec, out *PersistentVolumeSpec, s conversion.Scope) error { + if in.Capacity != nil { + out.Capacity = make(map[ResourceName]resource.Quantity) + for key, val := range in.Capacity { + newVal := resource.Quantity{} + if err := s.Convert(&val, &newVal, 0); err != nil { + return err + } + out.Capacity[ResourceName(key)] = newVal + } + } + if err := s.Convert(&in.PersistentVolumeSource, &out.PersistentVolumeSource, 0); err != nil { + return err + } + if in.AccessModes != nil { + out.AccessModes = make([]AccessModeType, len(in.AccessModes)) + for i := range in.AccessModes { + if err := s.Convert(&in.AccessModes[i], &out.AccessModes[i], 0); err != nil { + return err + } + } + } + if err := s.Convert(&in.ClaimRef, &out.ClaimRef, 0); err != nil { + return err + } + return nil + }, + func(in *ServiceSpec, out *newer.ServiceSpec, s conversion.Scope) error { + if in.Ports != nil { + out.Ports = make([]newer.ServicePort, len(in.Ports)) + for i := range in.Ports { + if err := s.Convert(&in.Ports[i], &out.Ports[i], 0); err != nil { + return err + } + } + } + if in.Selector != nil { + out.Selector = make(map[string]string) + for key, val := range in.Selector { + out.Selector[key] = val + } + } + out.PortalIP = in.PortalIP + out.CreateExternalLoadBalancer = in.CreateExternalLoadBalancer + if in.PublicIPs != nil { + out.PublicIPs = make([]string, len(in.PublicIPs)) + for i := range in.PublicIPs { + out.PublicIPs[i] = in.PublicIPs[i] + } + } + out.SessionAffinity = newer.AffinityType(in.SessionAffinity) + return nil + }, + func(in *newer.ServiceSpec, out *ServiceSpec, s conversion.Scope) error { + if in.Ports != nil { + out.Ports = make([]ServicePort, len(in.Ports)) + for i := range in.Ports { + if err := s.Convert(&in.Ports[i], &out.Ports[i], 0); err != nil { + return err + } + } + } + if in.Selector != nil { + out.Selector = make(map[string]string) + for key, val := range in.Selector { + out.Selector[key] = val + } + } + out.PortalIP = in.PortalIP + out.CreateExternalLoadBalancer = in.CreateExternalLoadBalancer + if in.PublicIPs != nil { + out.PublicIPs = make([]string, len(in.PublicIPs)) + for i := range in.PublicIPs { + out.PublicIPs[i] = in.PublicIPs[i] + } + } + out.SessionAffinity = AffinityType(in.SessionAffinity) + return nil + }, + func(in *ComponentStatus, out *newer.ComponentStatus, s conversion.Scope) error { + if err := s.Convert(&in.TypeMeta, &out.TypeMeta, 0); err != nil { + return err + } + if err := s.Convert(&in.ObjectMeta, &out.ObjectMeta, 0); err != nil { + return err + } + if in.Conditions != nil { + out.Conditions = make([]newer.ComponentCondition, len(in.Conditions)) + for i := range in.Conditions { + if err := s.Convert(&in.Conditions[i], &out.Conditions[i], 0); err != nil { + return err + } + } + } + return nil + }, + func(in *newer.ComponentStatus, out *ComponentStatus, s conversion.Scope) error { + if err := s.Convert(&in.TypeMeta, &out.TypeMeta, 0); err != nil { + return err + } + if err := s.Convert(&in.ObjectMeta, &out.ObjectMeta, 0); err != nil { + return err + } + if in.Conditions != nil { + out.Conditions = make([]ComponentCondition, len(in.Conditions)) + for i := range in.Conditions { + if err := s.Convert(&in.Conditions[i], &out.Conditions[i], 0); err != nil { + return err + } + } + } + return nil + }, + func(in *PersistentVolumeClaimVolumeSource, out *newer.PersistentVolumeClaimVolumeSource, s conversion.Scope) error { + out.ClaimName = in.ClaimName + out.ReadOnly = in.ReadOnly + return nil + }, + func(in *newer.PersistentVolumeClaimVolumeSource, out *PersistentVolumeClaimVolumeSource, s conversion.Scope) error { + out.ClaimName = in.ClaimName + out.ReadOnly = in.ReadOnly + return nil + }, + func(in *PersistentVolumeClaimStatus, out *newer.PersistentVolumeClaimStatus, s conversion.Scope) error { + out.Phase = newer.PersistentVolumeClaimPhase(in.Phase) + if in.AccessModes != nil { + out.AccessModes = make([]newer.AccessModeType, len(in.AccessModes)) + for i := range in.AccessModes { + if err := s.Convert(&in.AccessModes[i], &out.AccessModes[i], 0); err != nil { + return err + } + } + } + if in.Capacity != nil { + out.Capacity = make(map[newer.ResourceName]resource.Quantity) + for key, val := range in.Capacity { + newVal := resource.Quantity{} + if err := s.Convert(&val, &newVal, 0); err != nil { + return err + } + out.Capacity[newer.ResourceName(key)] = newVal + } + } + if err := s.Convert(&in.VolumeRef, &out.VolumeRef, 0); err != nil { + return err + } + return nil + }, + func(in *newer.PersistentVolumeClaimStatus, out *PersistentVolumeClaimStatus, s conversion.Scope) error { + out.Phase = PersistentVolumeClaimPhase(in.Phase) + if in.AccessModes != nil { + out.AccessModes = make([]AccessModeType, len(in.AccessModes)) + for i := range in.AccessModes { + if err := s.Convert(&in.AccessModes[i], &out.AccessModes[i], 0); err != nil { + return err + } + } + } + if in.Capacity != nil { + out.Capacity = make(map[ResourceName]resource.Quantity) + for key, val := range in.Capacity { + newVal := resource.Quantity{} + if err := s.Convert(&val, &newVal, 0); err != nil { + return err + } + out.Capacity[ResourceName(key)] = newVal + } + } + if err := s.Convert(&in.VolumeRef, &out.VolumeRef, 0); err != nil { + return err + } + return nil + }, + func(in *PersistentVolumeClaim, out *newer.PersistentVolumeClaim, s conversion.Scope) error { + if err := s.Convert(&in.TypeMeta, &out.TypeMeta, 0); err != nil { + return err + } + if err := s.Convert(&in.ObjectMeta, &out.ObjectMeta, 0); err != nil { + return err + } + if err := s.Convert(&in.Spec, &out.Spec, 0); err != nil { + return err + } + if err := s.Convert(&in.Status, &out.Status, 0); err != nil { + return err + } + return nil + }, + func(in *newer.PersistentVolumeClaim, out *PersistentVolumeClaim, s conversion.Scope) error { + if err := s.Convert(&in.TypeMeta, &out.TypeMeta, 0); err != nil { + return err + } + if err := s.Convert(&in.ObjectMeta, &out.ObjectMeta, 0); err != nil { + return err + } + if err := s.Convert(&in.Spec, &out.Spec, 0); err != nil { + return err + } + if err := s.Convert(&in.Status, &out.Status, 0); err != nil { + return err + } + return nil + }, + func(in *Endpoints, out *newer.Endpoints, s conversion.Scope) error { + if err := s.Convert(&in.TypeMeta, &out.TypeMeta, 0); err != nil { + return err + } + if err := s.Convert(&in.ObjectMeta, &out.ObjectMeta, 0); err != nil { + return err + } + if in.Subsets != nil { + out.Subsets = make([]newer.EndpointSubset, len(in.Subsets)) + for i := range in.Subsets { + if err := s.Convert(&in.Subsets[i], &out.Subsets[i], 0); err != nil { + return err + } + } + } + return nil + }, + func(in *newer.Endpoints, out *Endpoints, s conversion.Scope) error { + if err := s.Convert(&in.TypeMeta, &out.TypeMeta, 0); err != nil { + return err + } + if err := s.Convert(&in.ObjectMeta, &out.ObjectMeta, 0); err != nil { + return err + } + if in.Subsets != nil { + out.Subsets = make([]EndpointSubset, len(in.Subsets)) + for i := range in.Subsets { + if err := s.Convert(&in.Subsets[i], &out.Subsets[i], 0); err != nil { + return err + } + } + } + return nil + }, + func(in *PodExecOptions, out *newer.PodExecOptions, s conversion.Scope) error { + if err := s.Convert(&in.TypeMeta, &out.TypeMeta, 0); err != nil { + return err + } + out.Stdin = in.Stdin + out.Stdout = in.Stdout + out.Stderr = in.Stderr + out.TTY = in.TTY + out.Container = in.Container + out.Command = in.Command + return nil + }, + func(in *newer.PodExecOptions, out *PodExecOptions, s conversion.Scope) error { + if err := s.Convert(&in.TypeMeta, &out.TypeMeta, 0); err != nil { + return err + } + out.Stdin = in.Stdin + out.Stdout = in.Stdout + out.Stderr = in.Stderr + out.TTY = in.TTY + out.Container = in.Container + out.Command = in.Command + return nil + }, + func(in *ResourceQuotaStatus, out *newer.ResourceQuotaStatus, s conversion.Scope) error { + if in.Hard != nil { + out.Hard = make(map[newer.ResourceName]resource.Quantity) + for key, val := range in.Hard { + newVal := resource.Quantity{} + if err := s.Convert(&val, &newVal, 0); err != nil { + return err + } + out.Hard[newer.ResourceName(key)] = newVal + } + } + if in.Used != nil { + out.Used = make(map[newer.ResourceName]resource.Quantity) + for key, val := range in.Used { + newVal := resource.Quantity{} + if err := s.Convert(&val, &newVal, 0); err != nil { + return err + } + out.Used[newer.ResourceName(key)] = newVal + } + } + return nil + }, + func(in *newer.ResourceQuotaStatus, out *ResourceQuotaStatus, s conversion.Scope) error { + if in.Hard != nil { + out.Hard = make(map[ResourceName]resource.Quantity) + for key, val := range in.Hard { + newVal := resource.Quantity{} + if err := s.Convert(&val, &newVal, 0); err != nil { + return err + } + out.Hard[ResourceName(key)] = newVal + } + } + if in.Used != nil { + out.Used = make(map[ResourceName]resource.Quantity) + for key, val := range in.Used { + newVal := resource.Quantity{} + if err := s.Convert(&val, &newVal, 0); err != nil { + return err + } + out.Used[ResourceName(key)] = newVal + } + } + return nil + }, + func(in *NamespaceList, out *newer.NamespaceList, s conversion.Scope) error { + if err := s.Convert(&in.TypeMeta, &out.TypeMeta, 0); err != nil { + return err + } + if err := s.Convert(&in.ListMeta, &out.ListMeta, 0); err != nil { + return err + } + if in.Items != nil { + out.Items = make([]newer.Namespace, len(in.Items)) + for i := range in.Items { + if err := s.Convert(&in.Items[i], &out.Items[i], 0); err != nil { + return err + } + } + } + return nil + }, + func(in *newer.NamespaceList, out *NamespaceList, s conversion.Scope) error { + if err := s.Convert(&in.TypeMeta, &out.TypeMeta, 0); err != nil { + return err + } + if err := s.Convert(&in.ListMeta, &out.ListMeta, 0); err != nil { + return err + } + if in.Items != nil { + out.Items = make([]Namespace, len(in.Items)) + for i := range in.Items { + if err := s.Convert(&in.Items[i], &out.Items[i], 0); err != nil { + return err + } + } + } + return nil + }, + func(in *ServicePort, out *newer.ServicePort, s conversion.Scope) error { + out.Name = in.Name + out.Protocol = newer.Protocol(in.Protocol) + out.Port = in.Port + if err := s.Convert(&in.TargetPort, &out.TargetPort, 0); err != nil { + return err + } + return nil + }, + func(in *newer.ServicePort, out *ServicePort, s conversion.Scope) error { + out.Name = in.Name + out.Protocol = Protocol(in.Protocol) + out.Port = in.Port + if err := s.Convert(&in.TargetPort, &out.TargetPort, 0); err != nil { + return err + } + return nil + }, + func(in *DeleteOptions, out *newer.DeleteOptions, s conversion.Scope) error { + if err := s.Convert(&in.TypeMeta, &out.TypeMeta, 0); err != nil { + return err + } + if err := s.Convert(&in.GracePeriodSeconds, &out.GracePeriodSeconds, 0); err != nil { + return err + } + return nil + }, + func(in *newer.DeleteOptions, out *DeleteOptions, s conversion.Scope) error { + if err := s.Convert(&in.TypeMeta, &out.TypeMeta, 0); err != nil { + return err + } + if err := s.Convert(&in.GracePeriodSeconds, &out.GracePeriodSeconds, 0); err != nil { + return err + } + return nil + }, + func(in *PodTemplateSpec, out *newer.PodTemplateSpec, s conversion.Scope) error { + if err := s.Convert(&in.ObjectMeta, &out.ObjectMeta, 0); err != nil { + return err + } + if err := s.Convert(&in.Spec, &out.Spec, 0); err != nil { + return err + } + return nil + }, + func(in *newer.PodTemplateSpec, out *PodTemplateSpec, s conversion.Scope) error { + if err := s.Convert(&in.ObjectMeta, &out.ObjectMeta, 0); err != nil { + return err + } + if err := s.Convert(&in.Spec, &out.Spec, 0); err != nil { + return err + } + return nil + }, + func(in *ObjectMeta, out *newer.ObjectMeta, s conversion.Scope) error { + out.Name = in.Name + out.GenerateName = in.GenerateName + out.Namespace = in.Namespace + out.SelfLink = in.SelfLink + out.UID = in.UID + out.ResourceVersion = in.ResourceVersion + if err := s.Convert(&in.CreationTimestamp, &out.CreationTimestamp, 0); err != nil { + return err + } + if err := s.Convert(&in.DeletionTimestamp, &out.DeletionTimestamp, 0); err != nil { + return err + } + if in.Labels != nil { + out.Labels = make(map[string]string) + for key, val := range in.Labels { + out.Labels[key] = val + } + } + if in.Annotations != nil { + out.Annotations = make(map[string]string) + for key, val := range in.Annotations { + out.Annotations[key] = val + } + } + return nil + }, + func(in *newer.ObjectMeta, out *ObjectMeta, s conversion.Scope) error { + out.Name = in.Name + out.GenerateName = in.GenerateName + out.Namespace = in.Namespace + out.SelfLink = in.SelfLink + out.UID = in.UID + out.ResourceVersion = in.ResourceVersion + if err := s.Convert(&in.CreationTimestamp, &out.CreationTimestamp, 0); err != nil { + return err + } + if err := s.Convert(&in.DeletionTimestamp, &out.DeletionTimestamp, 0); err != nil { + return err + } + if in.Labels != nil { + out.Labels = make(map[string]string) + for key, val := range in.Labels { + out.Labels[key] = val + } + } + if in.Annotations != nil { + out.Annotations = make(map[string]string) + for key, val := range in.Annotations { + out.Annotations[key] = val + } + } + return nil + }, + func(in *TCPSocketAction, out *newer.TCPSocketAction, s conversion.Scope) error { + if err := s.Convert(&in.Port, &out.Port, 0); err != nil { + return err + } + return nil + }, + func(in *newer.TCPSocketAction, out *TCPSocketAction, s conversion.Scope) error { + if err := s.Convert(&in.Port, &out.Port, 0); err != nil { + return err + } + return nil + }, + ) + // Add field conversion funcs. - err := newer.Scheme.AddFieldLabelConversionFunc("v1beta3", "Pod", + err = newer.Scheme.AddFieldLabelConversionFunc("v1beta3", "Pod", func(label, value string) (string, string, error) { switch label { case "metadata.name", diff --git a/pkg/conversion/generator.go b/pkg/conversion/generator.go new file mode 100644 index 00000000000..067b9969a1b --- /dev/null +++ b/pkg/conversion/generator.go @@ -0,0 +1,414 @@ +/* +Copyright 2015 Google Inc. All rights reserved. + +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 conversion + +import ( + "fmt" + "io" + "reflect" + "strings" +) + +type Generator interface { + GenerateConversionsForType(version string, reflection reflect.Type) error + WriteConversionFunctions(w io.Writer) error + OverwritePackage(pkg, overwrite string) +} + +func NewGenerator(scheme *Scheme) Generator { + return &generator{ + scheme: scheme, + convertibles: make(map[reflect.Type]reflect.Type), + pkgOverwrites: make(map[string]string), + } +} + +var complexTypes []reflect.Kind = []reflect.Kind{reflect.Map, reflect.Ptr, reflect.Slice, reflect.Interface, reflect.Struct} + +type generator struct { + scheme *Scheme + convertibles map[reflect.Type]reflect.Type + // If pkgOverwrites is set for a given package name, that package name + // will be replaced while writing conversion function. If empty, package + // name will be omitted. + pkgOverwrites map[string]string +} + +func (g *generator) GenerateConversionsForType(version string, reflection reflect.Type) error { + kind := reflection.Name() + internalObj, err := g.scheme.NewObject(g.scheme.InternalVersion, kind) + if err != nil { + return fmt.Errorf("cannot create an object of type %v in internal version", kind) + } + internalObjType := reflect.TypeOf(internalObj) + if internalObjType.Kind() != reflect.Ptr { + return fmt.Errorf("created object should be of type Ptr: ", internalObjType.Kind()) + } + return g.generateConversionsBetween(reflection, internalObjType.Elem()) +} + +func (g *generator) generateConversionsBetween(inType, outType reflect.Type) error { + // Avoid processing the same type multiple times. + if value, found := g.convertibles[inType]; found { + if value != outType { + return fmt.Errorf("multiple possible convertibles for %v", inType) + } + return nil + } + if inType == outType { + // Don't generate conversion methods for the same type. + return nil + } + + if inType.Kind() != outType.Kind() { + return fmt.Errorf("cannot convert types of different kinds: %v %v", inType, outType) + } + switch inType.Kind() { + case reflect.Map: + return g.generateConversionsForMap(inType, outType) + case reflect.Ptr: + return g.generateConversionsBetween(inType.Elem(), outType.Elem()) + case reflect.Slice: + return g.generateConversionsForSlice(inType, outType) + case reflect.Interface: + // TODO(wojtek-t): Currently we rely on default conversion functions for interfaces. + // Add support for reflect.Interface. + return nil + case reflect.Struct: + return g.generateConversionsForStruct(inType, outType) + default: + // All simple types should be handled correctly with default conversion. + return nil + } + panic("This should never happen") +} + +func isComplexType(reflection reflect.Type) bool { + for _, complexType := range complexTypes { + if complexType == reflection.Kind() { + return true + } + } + return false +} + +func (g *generator) generateConversionsForMap(inType, outType reflect.Type) error { + inKey := inType.Key() + outKey := outType.Key() + if err := g.generateConversionsBetween(inKey, outKey); err != nil { + return err + } + inValue := inType.Elem() + outValue := outType.Elem() + if err := g.generateConversionsBetween(inValue, outValue); err != nil { + return err + } + // We don't add it to g.convertibles - maps should be handled correctly + // inside appropriate conversion functions. + return nil +} + +func (g *generator) generateConversionsForSlice(inType, outType reflect.Type) error { + inElem := inType.Elem() + outElem := outType.Elem() + if err := g.generateConversionsBetween(inElem, outElem); err != nil { + return err + } + // We don't add it to g.convertibles - slices should be handled correctly + // inside appropriate conversion functions. + return nil +} + +func (g *generator) generateConversionsForStruct(inType, outType reflect.Type) error { + for i := 0; i < inType.NumField(); i++ { + inField := inType.Field(i) + outField, found := outType.FieldByName(inField.Name) + if !found { + return fmt.Errorf("couldn't find a corresponding field %v in %v", inField.Name, outType) + } + if inField.Type.Kind() != outField.Type.Kind() { + return fmt.Errorf("cannot convert types of different kinds: %v %v", inField, outField) + } + if isComplexType(inField.Type) { + if err := g.generateConversionsBetween(inField.Type, outField.Type); err != nil { + return err + } + } + } + g.convertibles[inType] = outType + return nil +} + +func (g *generator) WriteConversionFunctions(w io.Writer) error { + indent := 2 + for inType, outType := range g.convertibles { + // All types in g.convertibles are structs. + if inType.Kind() != reflect.Struct { + return fmt.Errorf("non-struct conversions are not-supported") + } + if err := g.writeConversionForStruct(w, inType, outType, indent); err != nil { + return err + } + if err := g.writeConversionForStruct(w, outType, inType, indent); err != nil { + return err + } + } + return nil +} + +func (g *generator) typeName(inType reflect.Type) string { + switch inType.Kind() { + case reflect.Map: + return fmt.Sprintf("map[%s]%s", g.typeName(inType.Key()), g.typeName(inType.Elem())) + case reflect.Slice: + return fmt.Sprintf("[]%s", g.typeName(inType.Elem())) + default: + typeWithPkg := fmt.Sprintf("%s", inType) + slices := strings.Split(typeWithPkg, ".") + if len(slices) == 1 { + // Default package. + return slices[0] + } + if len(slices) == 2 { + pkg := slices[0] + if val, found := g.pkgOverwrites[pkg]; found { + pkg = val + } + if pkg != "" { + pkg = pkg + "." + } + return pkg + slices[1] + } + panic("Incorrect type name: " + typeWithPkg) + } +} + +func indentLine(w io.Writer, indent int) error { + indentation := "" + for i := 0; i < indent; i++ { + indentation = indentation + "\t" + } + _, err := io.WriteString(w, indentation) + return err +} + +func writeLine(w io.Writer, indent int, line string) error { + if err := indentLine(w, indent); err != nil { + return err + } + if _, err := io.WriteString(w, line); err != nil { + return err + } + return nil +} + +func writeHeader(w io.Writer, inType, outType string, indent int) error { + format := "func(in *%s, out *%s, s conversion.Scope) error {\n" + stmt := fmt.Sprintf(format, inType, outType) + return writeLine(w, indent, stmt) +} + +func writeFooter(w io.Writer, indent int) error { + if err := writeLine(w, indent+1, "return nil\n"); err != nil { + return err + } + if err := writeLine(w, indent, "},\n"); err != nil { + return err + } + return nil +} + +func (g *generator) writeConversionForMap(w io.Writer, inField, outField reflect.StructField, indent int) error { + ifFormat := "if in.%s != nil {\n" + ifStmt := fmt.Sprintf(ifFormat, inField.Name) + if err := writeLine(w, indent, ifStmt); err != nil { + return err + } + makeFormat := "out.%s = make(%s)\n" + makeStmt := fmt.Sprintf(makeFormat, outField.Name, g.typeName(outField.Type)) + if err := writeLine(w, indent+1, makeStmt); err != nil { + return err + } + forFormat := "for key, val := range in.%s {\n" + forStmt := fmt.Sprintf(forFormat, inField.Name) + if err := writeLine(w, indent+1, forStmt); err != nil { + return err + } + // Whether we need to explicitly create a new value. + newValue := false + if isComplexType(inField.Type.Elem()) || !inField.Type.Elem().ConvertibleTo(outField.Type.Elem()) { + newValue = true + newFormat := "newVal := %s{}\n" + newStmt := fmt.Sprintf(newFormat, g.typeName(outField.Type.Elem())) + if err := writeLine(w, indent+2, newStmt); err != nil { + return err + } + convertStmt := "if err := s.Convert(&val, &newVal, 0); err != nil {\n" + if err := writeLine(w, indent+2, convertStmt); err != nil { + return err + } + if err := writeLine(w, indent+3, "return err\n"); err != nil { + return err + } + if err := writeLine(w, indent+2, "}\n"); err != nil { + return err + } + } + if inField.Type.Key().ConvertibleTo(outField.Type.Key()) { + value := "val" + if newValue { + value = "newVal" + } + assignStmt := "" + if inField.Type.Key().AssignableTo(outField.Type.Key()) { + assignStmt = fmt.Sprintf("out.%s[key] = %s\n", outField.Name, value) + } else { + assignStmt = fmt.Sprintf("out.%s[%s(key)] = %s\n", outField.Name, g.typeName(outField.Type.Key()), value) + } + if err := writeLine(w, indent+2, assignStmt); err != nil { + return err + } + } else { + // TODO(wojtek-t): Support maps with keys that are non-convertible to each other. + return fmt.Errorf("conversions between unconvertible keys in map are not supported.") + } + if err := writeLine(w, indent+1, "}\n"); err != nil { + return err + } + if err := writeLine(w, indent, "}\n"); err != nil { + return err + } + return nil +} + +func (g *generator) writeConversionForSlice(w io.Writer, inField, outField reflect.StructField, indent int) error { + ifFormat := "if in.%s != nil {\n" + ifStmt := fmt.Sprintf(ifFormat, inField.Name) + if err := writeLine(w, indent, ifStmt); err != nil { + return err + } + + makeFormat := "out.%s = make(%s, len(in.%s))\n" + makeStmt := fmt.Sprintf(makeFormat, outField.Name, g.typeName(outField.Type), inField.Name) + if err := writeLine(w, indent+1, makeStmt); err != nil { + return err + } + forFormat := "for i := range in.%s {\n" + forStmt := fmt.Sprintf(forFormat, inField.Name) + if err := writeLine(w, indent+1, forStmt); err != nil { + return err + } + if inField.Type.Elem().AssignableTo(outField.Type.Elem()) { + assignFormat := "out.%s[i] = in.%s[i]\n" + assignStmt := fmt.Sprintf(assignFormat, outField.Name, inField.Name) + if err := writeLine(w, indent+2, assignStmt); err != nil { + return err + } + } else { + assignFormat := "if err := s.Convert(&in.%s[i], &out.%s[i], 0); err != nil {\n" + assignStmt := fmt.Sprintf(assignFormat, inField.Name, outField.Name) + if err := writeLine(w, indent+2, assignStmt); err != nil { + return err + } + if err := writeLine(w, indent+3, "return err\n"); err != nil { + return err + } + if err := writeLine(w, indent+2, "}\n"); err != nil { + return err + } + } + if err := writeLine(w, indent+1, "}\n"); err != nil { + return err + } + if err := writeLine(w, indent, "}\n"); err != nil { + return err + } + return nil +} + +func (g *generator) writeConversionForStruct(w io.Writer, inType, outType reflect.Type, indent int) error { + if err := writeHeader(w, g.typeName(inType), g.typeName(outType), indent); err != nil { + return err + } + for i := 0; i < inType.NumField(); i++ { + inField := inType.Field(i) + outField, _ := outType.FieldByName(inField.Name) + + switch inField.Type.Kind() { + case reflect.Map, reflect.Ptr, reflect.Slice, reflect.Interface, reflect.Struct: + // Don't copy these via assignment/conversion! + default: + // This should handle all simple types. + if inField.Type.AssignableTo(outField.Type) { + assignFormat := "out.%s = in.%s\n" + assignStmt := fmt.Sprintf(assignFormat, outField.Name, inField.Name) + if err := writeLine(w, indent+1, assignStmt); err != nil { + return err + } + continue + } + if inField.Type.ConvertibleTo(outField.Type) { + assignFormat := "out.%s = %s(in.%s)\n" + assignStmt := fmt.Sprintf(assignFormat, outField.Name, g.typeName(outField.Type), inField.Name) + if err := writeLine(w, indent+1, assignStmt); err != nil { + return err + } + continue + } + } + + // If the field is a slice, copy its elements one by one. + if inField.Type.Kind() == reflect.Slice { + if err := g.writeConversionForSlice(w, inField, outField, indent+1); err != nil { + return err + } + continue + } + + // If the field is a map, copy its elements one by one. + if inField.Type.Kind() == reflect.Map { + if err := g.writeConversionForMap(w, inField, outField, indent+1); err != nil { + return err + } + continue + } + + // TODO(wojtek-t): At some point we may consider named functions and call + // appropriate function here instead of using generic Convert method that + // will call the same method underneath after some additional operations. + + assignFormat := "if err := s.Convert(&in.%s, &out.%s, 0); err != nil {\n" + assignStmt := fmt.Sprintf(assignFormat, inField.Name, outField.Name) + if err := writeLine(w, indent+1, assignStmt); err != nil { + return err + } + if err := writeLine(w, indent+2, "return err\n"); err != nil { + return err + } + if err := writeLine(w, indent+1, "}\n"); err != nil { + return err + } + } + if err := writeFooter(w, indent); err != nil { + return err + } + return nil +} + +func (g *generator) OverwritePackage(pkg, overwrite string) { + g.pkgOverwrites[pkg] = overwrite +} diff --git a/pkg/conversion/scheme.go b/pkg/conversion/scheme.go index 5314d0995bb..7f9f8aa4014 100644 --- a/pkg/conversion/scheme.go +++ b/pkg/conversion/scheme.go @@ -201,6 +201,12 @@ func (s *Scheme) AddConversionFuncs(conversionFuncs ...interface{}) error { return nil } +// Similar to AddConversionFuncs, but registers conversion functions that were +// automatically generated. +func (s *Scheme) AddGeneratedConversionFuncs(conversionFuncs ...interface{}) error { + return s.AddConversionFuncs(conversionFuncs...) +} + // AddStructFieldConversion allows you to specify a mechanical copy for a moved // or renamed struct field without writing an entire conversion function. See // the comment in Converter.SetStructFieldCopy for parameter details. diff --git a/pkg/runtime/scheme.go b/pkg/runtime/scheme.go index 2670c0946e0..376313de9fd 100644 --- a/pkg/runtime/scheme.go +++ b/pkg/runtime/scheme.go @@ -307,6 +307,12 @@ func (s *Scheme) AddConversionFuncs(conversionFuncs ...interface{}) error { return s.raw.AddConversionFuncs(conversionFuncs...) } +// Similar to AddConversionFuncs, but registers conversion functions that were +// automatically generated. +func (s *Scheme) AddGeneratedConversionFuncs(conversionFuncs ...interface{}) error { + return s.raw.AddGeneratedConversionFuncs(conversionFuncs...) +} + // AddFieldLabelConversionFunc adds a conversion function to convert field selectors // of the given kind from the given version to internal version representation. func (s *Scheme) AddFieldLabelConversionFunc(version, kind string, conversionFunc FieldLabelConversionFunc) error {