diff --git a/cmd/kube-conversion/conversion.go b/cmd/genconversion/conversion.go similarity index 100% rename from cmd/kube-conversion/conversion.go rename to cmd/genconversion/conversion.go diff --git a/cmd/gendeepcopy/deep_copy.go b/cmd/gendeepcopy/deep_copy.go new file mode 100644 index 00000000000..864c22743c0 --- /dev/null +++ b/cmd/gendeepcopy/deep_copy.go @@ -0,0 +1,82 @@ +/* +Copyright 2015 The Kubernetes Authors 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/v1" + _ "github.com/GoogleCloudPlatform/kubernetes/pkg/api/v1beta1" + _ "github.com/GoogleCloudPlatform/kubernetes/pkg/api/v1beta2" + _ "github.com/GoogleCloudPlatform/kubernetes/pkg/api/v1beta3" + pkg_runtime "github.com/GoogleCloudPlatform/kubernetes/pkg/runtime" + + "github.com/golang/glog" + flag "github.com/spf13/pflag" +) + +var ( + functionDest = flag.StringP("func-dest", "f", "-", "Output for deep copy functions; '-' means stdout") + version = flag.StringP("version", "v", "v1beta3", "Version for deep copies.") + overwrites = flag.StringP("overwrites", "o", "", "Comma-separated overwrites for package names") +) + +func main() { + runtime.GOMAXPROCS(runtime.NumCPU()) + flag.Parse() + + var funcOut io.Writer + if *functionDest == "-" { + funcOut = os.Stdout + } else { + file, err := os.Create(*functionDest) + if err != nil { + glog.Fatalf("Couldn't open %v: %v", *functionDest, err) + } + defer file.Close() + funcOut = file + } + + knownVersion := *version + if knownVersion == "api" { + knownVersion = api.Scheme.Raw().InternalVersion + } + generator := pkg_runtime.NewDeepCopyGenerator(api.Scheme.Raw()) + + for _, overwrite := range strings.Split(*overwrites, ",") { + vals := strings.Split(overwrite, "=") + generator.OverwritePackage(vals[0], vals[1]) + } + for _, knownType := range api.Scheme.KnownTypes(knownVersion) { + if err := generator.AddType(knownType); err != nil { + glog.Errorf("error while generating deep copy functions for %v: %v", knownType, err) + } + } + if err := generator.WriteImports(funcOut, *version); err != nil { + glog.Fatalf("error while writing imports: %v", err) + } + if err := generator.WriteDeepCopyFunctions(funcOut); err != nil { + glog.Fatalf("error while writing deep copy functions: %v", err) + } + if err := generator.RegisterDeepCopyFunctions(funcOut, *version); err != nil { + glog.Fatalf("error while registering deep copy functions: %v", err) + } +} diff --git a/hack/lib/golang.sh b/hack/lib/golang.sh index 96caa0ae52c..aaa328b068a 100644 --- a/hack/lib/golang.sh +++ b/hack/lib/golang.sh @@ -48,6 +48,8 @@ readonly KUBE_TEST_TARGETS=( cmd/gendocs cmd/genman cmd/genbashcomp + cmd/genconversion + cmd/gendeepcopy examples/k8petstore/web-server github.com/onsi/ginkgo/ginkgo test/e2e/e2e.test diff --git a/hack/update-generated-conversions.sh b/hack/update-generated-conversions.sh index 773de0c3d6f..1236079ee7c 100755 --- a/hack/update-generated-conversions.sh +++ b/hack/update-generated-conversions.sh @@ -39,7 +39,7 @@ import ( // AUTO-GENERATED FUNCTIONS START HERE EOF - GOPATH=$(godep path):$GOPATH go run cmd/kube-conversion/conversion.go -v ${version} -f - >> $TMPFILE + GOPATH=$(godep path):$GOPATH go run cmd/genconversion/conversion.go -v ${version} -f - >> $TMPFILE cat >> $TMPFILE < $TMPFILE + cat >> $TMPFILE <&2 exit 1 fi diff --git a/hack/verify-generated-deep-copies.sh b/hack/verify-generated-deep-copies.sh new file mode 100755 index 00000000000..20a25089327 --- /dev/null +++ b/hack/verify-generated-deep-copies.sh @@ -0,0 +1,60 @@ +#!/bin/bash + +# Copyright 2015 The Kubernetes Authors 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. + +set -o errexit +set -o nounset +set -o pipefail + +KUBE_ROOT=$(dirname "${BASH_SOURCE}")/.. +source "${KUBE_ROOT}/hack/lib/init.sh" + +kube::golang::setup_env +"${KUBE_ROOT}/hack/build-go.sh" cmd/gendeepcopy + +genconversion=$(kube::util::find-binary "gendeepcopy") + +if [[ ! -x "$genconversion" ]]; then + { + echo "It looks as if you don't have a compiled conversion binary" + echo + echo "If you are running from a clone of the git repo, please run" + echo "'./hack/build-go.sh cmd/gendeepcopy'." + } >&2 + exit 1 +fi + +APIROOT="${KUBE_ROOT}/pkg/api" +TMP_APIROOT="${KUBE_ROOT}/_tmp/api" +_tmp="${KUBE_ROOT}/_tmp" + +mkdir -p "${_tmp}" +cp -a "${APIROOT}" "${TMP_APIROOT}" + +"${KUBE_ROOT}/hack/update-generated-deep-copies.sh" +echo "diffing ${APIROOT} against freshly generated deep copies" +ret=0 +diff -Naupr -I 'Auto generated by' "${APIROOT}" "${TMP_APIROOT}" || ret=$? +cp -a ${TMP_APIROOT} "${KUBE_ROOT}/pkg" +rm -rf "${_tmp}" +if [[ $ret -eq 0 ]] +then + echo "${APIROOT} up to date." +else + echo "${APIROOT} is out of date. Please run hack/update-generated-deep-copies.sh" + exit 1 +fi + +# ex: ts=2 sw=2 et filetype=sh diff --git a/pkg/api/deep_copy_generated.go b/pkg/api/deep_copy_generated.go new file mode 100644 index 00000000000..fbc74c98483 --- /dev/null +++ b/pkg/api/deep_copy_generated.go @@ -0,0 +1,2257 @@ +/* +Copyright 2015 The Kubernetes Authors 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 api + +// AUTO-GENERATED FUNCTIONS START HERE +import ( + "github.com/GoogleCloudPlatform/kubernetes/pkg/api/resource" + "github.com/GoogleCloudPlatform/kubernetes/pkg/conversion" + "github.com/GoogleCloudPlatform/kubernetes/pkg/fields" + "github.com/GoogleCloudPlatform/kubernetes/pkg/labels" + "github.com/GoogleCloudPlatform/kubernetes/pkg/runtime" + "github.com/GoogleCloudPlatform/kubernetes/pkg/util" + "speter.net/go/exp/math/dec/inf" + "time" +) + +func deepCopy_api_AWSElasticBlockStoreVolumeSource(in AWSElasticBlockStoreVolumeSource, out *AWSElasticBlockStoreVolumeSource, c *conversion.Cloner) error { + out.VolumeID = in.VolumeID + out.FSType = in.FSType + out.Partition = in.Partition + out.ReadOnly = in.ReadOnly + return nil +} + +func deepCopy_api_Binding(in Binding, out *Binding, c *conversion.Cloner) error { + if err := deepCopy_api_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_api_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil { + return err + } + if err := deepCopy_api_ObjectReference(in.Target, &out.Target, c); err != nil { + return err + } + return nil +} + +func deepCopy_api_Capabilities(in Capabilities, out *Capabilities, c *conversion.Cloner) error { + if in.Add != nil { + out.Add = make([]Capability, len(in.Add)) + for i := range in.Add { + out.Add[i] = in.Add[i] + } + } else { + out.Add = nil + } + if in.Drop != nil { + out.Drop = make([]Capability, len(in.Drop)) + for i := range in.Drop { + out.Drop[i] = in.Drop[i] + } + } else { + out.Drop = nil + } + return nil +} + +func deepCopy_api_ComponentCondition(in ComponentCondition, out *ComponentCondition, c *conversion.Cloner) error { + out.Type = in.Type + out.Status = in.Status + out.Message = in.Message + out.Error = in.Error + return nil +} + +func deepCopy_api_ComponentStatus(in ComponentStatus, out *ComponentStatus, c *conversion.Cloner) error { + if err := deepCopy_api_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_api_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil { + return err + } + if in.Conditions != nil { + out.Conditions = make([]ComponentCondition, len(in.Conditions)) + for i := range in.Conditions { + if err := deepCopy_api_ComponentCondition(in.Conditions[i], &out.Conditions[i], c); err != nil { + return err + } + } + } else { + out.Conditions = nil + } + return nil +} + +func deepCopy_api_ComponentStatusList(in ComponentStatusList, out *ComponentStatusList, c *conversion.Cloner) error { + if err := deepCopy_api_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_api_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil { + return err + } + if in.Items != nil { + out.Items = make([]ComponentStatus, len(in.Items)) + for i := range in.Items { + if err := deepCopy_api_ComponentStatus(in.Items[i], &out.Items[i], c); err != nil { + return err + } + } + } else { + out.Items = nil + } + return nil +} + +func deepCopy_api_Container(in Container, out *Container, c *conversion.Cloner) 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] + } + } else { + out.Command = nil + } + if in.Args != nil { + out.Args = make([]string, len(in.Args)) + for i := range in.Args { + out.Args[i] = in.Args[i] + } + } else { + out.Args = nil + } + out.WorkingDir = in.WorkingDir + if in.Ports != nil { + out.Ports = make([]ContainerPort, len(in.Ports)) + for i := range in.Ports { + if err := deepCopy_api_ContainerPort(in.Ports[i], &out.Ports[i], c); err != nil { + return err + } + } + } else { + out.Ports = nil + } + if in.Env != nil { + out.Env = make([]EnvVar, len(in.Env)) + for i := range in.Env { + if err := deepCopy_api_EnvVar(in.Env[i], &out.Env[i], c); err != nil { + return err + } + } + } else { + out.Env = nil + } + if err := deepCopy_api_ResourceRequirements(in.Resources, &out.Resources, c); err != nil { + return err + } + if in.VolumeMounts != nil { + out.VolumeMounts = make([]VolumeMount, len(in.VolumeMounts)) + for i := range in.VolumeMounts { + if err := deepCopy_api_VolumeMount(in.VolumeMounts[i], &out.VolumeMounts[i], c); err != nil { + return err + } + } + } else { + out.VolumeMounts = nil + } + if in.LivenessProbe != nil { + out.LivenessProbe = new(Probe) + if err := deepCopy_api_Probe(*in.LivenessProbe, out.LivenessProbe, c); err != nil { + return err + } + } else { + out.LivenessProbe = nil + } + if in.ReadinessProbe != nil { + out.ReadinessProbe = new(Probe) + if err := deepCopy_api_Probe(*in.ReadinessProbe, out.ReadinessProbe, c); err != nil { + return err + } + } else { + out.ReadinessProbe = nil + } + if in.Lifecycle != nil { + out.Lifecycle = new(Lifecycle) + if err := deepCopy_api_Lifecycle(*in.Lifecycle, out.Lifecycle, c); err != nil { + return err + } + } else { + out.Lifecycle = nil + } + out.TerminationMessagePath = in.TerminationMessagePath + out.ImagePullPolicy = in.ImagePullPolicy + if in.SecurityContext != nil { + out.SecurityContext = new(SecurityContext) + if err := deepCopy_api_SecurityContext(*in.SecurityContext, out.SecurityContext, c); err != nil { + return err + } + } else { + out.SecurityContext = nil + } + return nil +} + +func deepCopy_api_ContainerManifest(in ContainerManifest, out *ContainerManifest, c *conversion.Cloner) error { + out.Version = in.Version + out.ID = in.ID + out.UUID = in.UUID + if in.Volumes != nil { + out.Volumes = make([]Volume, len(in.Volumes)) + for i := range in.Volumes { + if err := deepCopy_api_Volume(in.Volumes[i], &out.Volumes[i], c); err != nil { + return err + } + } + } else { + out.Volumes = nil + } + if in.Containers != nil { + out.Containers = make([]Container, len(in.Containers)) + for i := range in.Containers { + if err := deepCopy_api_Container(in.Containers[i], &out.Containers[i], c); err != nil { + return err + } + } + } else { + out.Containers = nil + } + out.RestartPolicy = in.RestartPolicy + if in.TerminationGracePeriodSeconds != nil { + out.TerminationGracePeriodSeconds = new(int64) + *out.TerminationGracePeriodSeconds = *in.TerminationGracePeriodSeconds + } else { + out.TerminationGracePeriodSeconds = nil + } + if in.ActiveDeadlineSeconds != nil { + out.ActiveDeadlineSeconds = new(int64) + *out.ActiveDeadlineSeconds = *in.ActiveDeadlineSeconds + } else { + out.ActiveDeadlineSeconds = nil + } + out.DNSPolicy = in.DNSPolicy + out.HostNetwork = in.HostNetwork + if in.ImagePullSecrets != nil { + out.ImagePullSecrets = make([]LocalObjectReference, len(in.ImagePullSecrets)) + for i := range in.ImagePullSecrets { + if err := deepCopy_api_LocalObjectReference(in.ImagePullSecrets[i], &out.ImagePullSecrets[i], c); err != nil { + return err + } + } + } else { + out.ImagePullSecrets = nil + } + return nil +} + +func deepCopy_api_ContainerManifestList(in ContainerManifestList, out *ContainerManifestList, c *conversion.Cloner) error { + if err := deepCopy_api_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_api_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil { + return err + } + if in.Items != nil { + out.Items = make([]ContainerManifest, len(in.Items)) + for i := range in.Items { + if err := deepCopy_api_ContainerManifest(in.Items[i], &out.Items[i], c); err != nil { + return err + } + } + } else { + out.Items = nil + } + return nil +} + +func deepCopy_api_ContainerPort(in ContainerPort, out *ContainerPort, c *conversion.Cloner) error { + out.Name = in.Name + out.HostPort = in.HostPort + out.ContainerPort = in.ContainerPort + out.Protocol = in.Protocol + out.HostIP = in.HostIP + return nil +} + +func deepCopy_api_ContainerState(in ContainerState, out *ContainerState, c *conversion.Cloner) error { + if in.Waiting != nil { + out.Waiting = new(ContainerStateWaiting) + if err := deepCopy_api_ContainerStateWaiting(*in.Waiting, out.Waiting, c); err != nil { + return err + } + } else { + out.Waiting = nil + } + if in.Running != nil { + out.Running = new(ContainerStateRunning) + if err := deepCopy_api_ContainerStateRunning(*in.Running, out.Running, c); err != nil { + return err + } + } else { + out.Running = nil + } + if in.Termination != nil { + out.Termination = new(ContainerStateTerminated) + if err := deepCopy_api_ContainerStateTerminated(*in.Termination, out.Termination, c); err != nil { + return err + } + } else { + out.Termination = nil + } + return nil +} + +func deepCopy_api_ContainerStateRunning(in ContainerStateRunning, out *ContainerStateRunning, c *conversion.Cloner) error { + if err := deepCopy_util_Time(in.StartedAt, &out.StartedAt, c); err != nil { + return err + } + return nil +} + +func deepCopy_api_ContainerStateTerminated(in ContainerStateTerminated, out *ContainerStateTerminated, c *conversion.Cloner) error { + out.ExitCode = in.ExitCode + out.Signal = in.Signal + out.Reason = in.Reason + out.Message = in.Message + if err := deepCopy_util_Time(in.StartedAt, &out.StartedAt, c); err != nil { + return err + } + if err := deepCopy_util_Time(in.FinishedAt, &out.FinishedAt, c); err != nil { + return err + } + out.ContainerID = in.ContainerID + return nil +} + +func deepCopy_api_ContainerStateWaiting(in ContainerStateWaiting, out *ContainerStateWaiting, c *conversion.Cloner) error { + out.Reason = in.Reason + return nil +} + +func deepCopy_api_ContainerStatus(in ContainerStatus, out *ContainerStatus, c *conversion.Cloner) error { + out.Name = in.Name + if err := deepCopy_api_ContainerState(in.State, &out.State, c); err != nil { + return err + } + if err := deepCopy_api_ContainerState(in.LastTerminationState, &out.LastTerminationState, c); 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 deepCopy_api_DeleteOptions(in DeleteOptions, out *DeleteOptions, c *conversion.Cloner) error { + if err := deepCopy_api_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if in.GracePeriodSeconds != nil { + out.GracePeriodSeconds = new(int64) + *out.GracePeriodSeconds = *in.GracePeriodSeconds + } else { + out.GracePeriodSeconds = nil + } + return nil +} + +func deepCopy_api_EmptyDirVolumeSource(in EmptyDirVolumeSource, out *EmptyDirVolumeSource, c *conversion.Cloner) error { + out.Medium = in.Medium + return nil +} + +func deepCopy_api_EndpointAddress(in EndpointAddress, out *EndpointAddress, c *conversion.Cloner) error { + out.IP = in.IP + if in.TargetRef != nil { + out.TargetRef = new(ObjectReference) + if err := deepCopy_api_ObjectReference(*in.TargetRef, out.TargetRef, c); err != nil { + return err + } + } else { + out.TargetRef = nil + } + return nil +} + +func deepCopy_api_EndpointPort(in EndpointPort, out *EndpointPort, c *conversion.Cloner) error { + out.Name = in.Name + out.Port = in.Port + out.Protocol = in.Protocol + return nil +} + +func deepCopy_api_EndpointSubset(in EndpointSubset, out *EndpointSubset, c *conversion.Cloner) error { + if in.Addresses != nil { + out.Addresses = make([]EndpointAddress, len(in.Addresses)) + for i := range in.Addresses { + if err := deepCopy_api_EndpointAddress(in.Addresses[i], &out.Addresses[i], c); err != nil { + return err + } + } + } else { + out.Addresses = nil + } + if in.Ports != nil { + out.Ports = make([]EndpointPort, len(in.Ports)) + for i := range in.Ports { + if err := deepCopy_api_EndpointPort(in.Ports[i], &out.Ports[i], c); err != nil { + return err + } + } + } else { + out.Ports = nil + } + return nil +} + +func deepCopy_api_Endpoints(in Endpoints, out *Endpoints, c *conversion.Cloner) error { + if err := deepCopy_api_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_api_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil { + return err + } + if in.Subsets != nil { + out.Subsets = make([]EndpointSubset, len(in.Subsets)) + for i := range in.Subsets { + if err := deepCopy_api_EndpointSubset(in.Subsets[i], &out.Subsets[i], c); err != nil { + return err + } + } + } else { + out.Subsets = nil + } + return nil +} + +func deepCopy_api_EndpointsList(in EndpointsList, out *EndpointsList, c *conversion.Cloner) error { + if err := deepCopy_api_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_api_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil { + return err + } + if in.Items != nil { + out.Items = make([]Endpoints, len(in.Items)) + for i := range in.Items { + if err := deepCopy_api_Endpoints(in.Items[i], &out.Items[i], c); err != nil { + return err + } + } + } else { + out.Items = nil + } + return nil +} + +func deepCopy_api_EnvVar(in EnvVar, out *EnvVar, c *conversion.Cloner) error { + out.Name = in.Name + out.Value = in.Value + if in.ValueFrom != nil { + out.ValueFrom = new(EnvVarSource) + if err := deepCopy_api_EnvVarSource(*in.ValueFrom, out.ValueFrom, c); err != nil { + return err + } + } else { + out.ValueFrom = nil + } + return nil +} + +func deepCopy_api_EnvVarSource(in EnvVarSource, out *EnvVarSource, c *conversion.Cloner) error { + if in.FieldRef != nil { + out.FieldRef = new(ObjectFieldSelector) + if err := deepCopy_api_ObjectFieldSelector(*in.FieldRef, out.FieldRef, c); err != nil { + return err + } + } else { + out.FieldRef = nil + } + return nil +} + +func deepCopy_api_Event(in Event, out *Event, c *conversion.Cloner) error { + if err := deepCopy_api_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_api_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil { + return err + } + if err := deepCopy_api_ObjectReference(in.InvolvedObject, &out.InvolvedObject, c); err != nil { + return err + } + out.Reason = in.Reason + out.Message = in.Message + if err := deepCopy_api_EventSource(in.Source, &out.Source, c); err != nil { + return err + } + if err := deepCopy_util_Time(in.FirstTimestamp, &out.FirstTimestamp, c); err != nil { + return err + } + if err := deepCopy_util_Time(in.LastTimestamp, &out.LastTimestamp, c); err != nil { + return err + } + out.Count = in.Count + return nil +} + +func deepCopy_api_EventList(in EventList, out *EventList, c *conversion.Cloner) error { + if err := deepCopy_api_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_api_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil { + return err + } + if in.Items != nil { + out.Items = make([]Event, len(in.Items)) + for i := range in.Items { + if err := deepCopy_api_Event(in.Items[i], &out.Items[i], c); err != nil { + return err + } + } + } else { + out.Items = nil + } + return nil +} + +func deepCopy_api_EventSource(in EventSource, out *EventSource, c *conversion.Cloner) error { + out.Component = in.Component + out.Host = in.Host + return nil +} + +func deepCopy_api_ExecAction(in ExecAction, out *ExecAction, c *conversion.Cloner) error { + if in.Command != nil { + out.Command = make([]string, len(in.Command)) + for i := range in.Command { + out.Command[i] = in.Command[i] + } + } else { + out.Command = nil + } + return nil +} + +func deepCopy_api_GCEPersistentDiskVolumeSource(in GCEPersistentDiskVolumeSource, out *GCEPersistentDiskVolumeSource, c *conversion.Cloner) error { + out.PDName = in.PDName + out.FSType = in.FSType + out.Partition = in.Partition + out.ReadOnly = in.ReadOnly + return nil +} + +func deepCopy_api_GitRepoVolumeSource(in GitRepoVolumeSource, out *GitRepoVolumeSource, c *conversion.Cloner) error { + out.Repository = in.Repository + out.Revision = in.Revision + return nil +} + +func deepCopy_api_GlusterfsVolumeSource(in GlusterfsVolumeSource, out *GlusterfsVolumeSource, c *conversion.Cloner) error { + out.EndpointsName = in.EndpointsName + out.Path = in.Path + out.ReadOnly = in.ReadOnly + return nil +} + +func deepCopy_api_HTTPGetAction(in HTTPGetAction, out *HTTPGetAction, c *conversion.Cloner) error { + out.Path = in.Path + if err := deepCopy_util_IntOrString(in.Port, &out.Port, c); err != nil { + return err + } + out.Host = in.Host + return nil +} + +func deepCopy_api_Handler(in Handler, out *Handler, c *conversion.Cloner) error { + if in.Exec != nil { + out.Exec = new(ExecAction) + if err := deepCopy_api_ExecAction(*in.Exec, out.Exec, c); err != nil { + return err + } + } else { + out.Exec = nil + } + if in.HTTPGet != nil { + out.HTTPGet = new(HTTPGetAction) + if err := deepCopy_api_HTTPGetAction(*in.HTTPGet, out.HTTPGet, c); err != nil { + return err + } + } else { + out.HTTPGet = nil + } + if in.TCPSocket != nil { + out.TCPSocket = new(TCPSocketAction) + if err := deepCopy_api_TCPSocketAction(*in.TCPSocket, out.TCPSocket, c); err != nil { + return err + } + } else { + out.TCPSocket = nil + } + return nil +} + +func deepCopy_api_HostPathVolumeSource(in HostPathVolumeSource, out *HostPathVolumeSource, c *conversion.Cloner) error { + out.Path = in.Path + return nil +} + +func deepCopy_api_ISCSIVolumeSource(in ISCSIVolumeSource, out *ISCSIVolumeSource, c *conversion.Cloner) error { + out.TargetPortal = in.TargetPortal + out.IQN = in.IQN + out.Lun = in.Lun + out.FSType = in.FSType + out.ReadOnly = in.ReadOnly + return nil +} + +func deepCopy_api_Lifecycle(in Lifecycle, out *Lifecycle, c *conversion.Cloner) error { + if in.PostStart != nil { + out.PostStart = new(Handler) + if err := deepCopy_api_Handler(*in.PostStart, out.PostStart, c); err != nil { + return err + } + } else { + out.PostStart = nil + } + if in.PreStop != nil { + out.PreStop = new(Handler) + if err := deepCopy_api_Handler(*in.PreStop, out.PreStop, c); err != nil { + return err + } + } else { + out.PreStop = nil + } + return nil +} + +func deepCopy_api_LimitRange(in LimitRange, out *LimitRange, c *conversion.Cloner) error { + if err := deepCopy_api_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_api_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil { + return err + } + if err := deepCopy_api_LimitRangeSpec(in.Spec, &out.Spec, c); err != nil { + return err + } + return nil +} + +func deepCopy_api_LimitRangeItem(in LimitRangeItem, out *LimitRangeItem, c *conversion.Cloner) error { + out.Type = in.Type + if in.Max != nil { + out.Max = make(map[ResourceName]resource.Quantity) + for key, val := range in.Max { + newVal := new(resource.Quantity) + if err := deepCopy_resource_Quantity(val, newVal, c); err != nil { + return err + } + out.Max[key] = *newVal + } + } else { + out.Max = nil + } + if in.Min != nil { + out.Min = make(map[ResourceName]resource.Quantity) + for key, val := range in.Min { + newVal := new(resource.Quantity) + if err := deepCopy_resource_Quantity(val, newVal, c); err != nil { + return err + } + out.Min[key] = *newVal + } + } else { + out.Min = nil + } + if in.Default != nil { + out.Default = make(map[ResourceName]resource.Quantity) + for key, val := range in.Default { + newVal := new(resource.Quantity) + if err := deepCopy_resource_Quantity(val, newVal, c); err != nil { + return err + } + out.Default[key] = *newVal + } + } else { + out.Default = nil + } + return nil +} + +func deepCopy_api_LimitRangeList(in LimitRangeList, out *LimitRangeList, c *conversion.Cloner) error { + if err := deepCopy_api_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_api_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil { + return err + } + if in.Items != nil { + out.Items = make([]LimitRange, len(in.Items)) + for i := range in.Items { + if err := deepCopy_api_LimitRange(in.Items[i], &out.Items[i], c); err != nil { + return err + } + } + } else { + out.Items = nil + } + return nil +} + +func deepCopy_api_LimitRangeSpec(in LimitRangeSpec, out *LimitRangeSpec, c *conversion.Cloner) error { + if in.Limits != nil { + out.Limits = make([]LimitRangeItem, len(in.Limits)) + for i := range in.Limits { + if err := deepCopy_api_LimitRangeItem(in.Limits[i], &out.Limits[i], c); err != nil { + return err + } + } + } else { + out.Limits = nil + } + return nil +} + +func deepCopy_api_List(in List, out *List, c *conversion.Cloner) error { + if err := deepCopy_api_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_api_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil { + return err + } + if in.Items != nil { + out.Items = make([]runtime.Object, len(in.Items)) + for i := range in.Items { + if newVal, err := c.DeepCopy(in.Items[i]); err != nil { + return err + } else { + out.Items[i] = newVal.(runtime.Object) + } + } + } else { + out.Items = nil + } + return nil +} + +func deepCopy_api_ListMeta(in ListMeta, out *ListMeta, c *conversion.Cloner) error { + out.SelfLink = in.SelfLink + out.ResourceVersion = in.ResourceVersion + return nil +} + +func deepCopy_api_ListOptions(in ListOptions, out *ListOptions, c *conversion.Cloner) error { + if err := deepCopy_api_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if newVal, err := c.DeepCopy(in.LabelSelector); err != nil { + return err + } else { + out.LabelSelector = newVal.(labels.Selector) + } + if newVal, err := c.DeepCopy(in.FieldSelector); err != nil { + return err + } else { + out.FieldSelector = newVal.(fields.Selector) + } + out.Watch = in.Watch + out.ResourceVersion = in.ResourceVersion + return nil +} + +func deepCopy_api_LoadBalancerIngress(in LoadBalancerIngress, out *LoadBalancerIngress, c *conversion.Cloner) error { + out.IP = in.IP + out.Hostname = in.Hostname + return nil +} + +func deepCopy_api_LoadBalancerStatus(in LoadBalancerStatus, out *LoadBalancerStatus, c *conversion.Cloner) error { + if in.Ingress != nil { + out.Ingress = make([]LoadBalancerIngress, len(in.Ingress)) + for i := range in.Ingress { + if err := deepCopy_api_LoadBalancerIngress(in.Ingress[i], &out.Ingress[i], c); err != nil { + return err + } + } + } else { + out.Ingress = nil + } + return nil +} + +func deepCopy_api_LocalObjectReference(in LocalObjectReference, out *LocalObjectReference, c *conversion.Cloner) error { + out.Name = in.Name + return nil +} + +func deepCopy_api_NFSVolumeSource(in NFSVolumeSource, out *NFSVolumeSource, c *conversion.Cloner) error { + out.Server = in.Server + out.Path = in.Path + out.ReadOnly = in.ReadOnly + return nil +} + +func deepCopy_api_Namespace(in Namespace, out *Namespace, c *conversion.Cloner) error { + if err := deepCopy_api_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_api_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil { + return err + } + if err := deepCopy_api_NamespaceSpec(in.Spec, &out.Spec, c); err != nil { + return err + } + if err := deepCopy_api_NamespaceStatus(in.Status, &out.Status, c); err != nil { + return err + } + return nil +} + +func deepCopy_api_NamespaceList(in NamespaceList, out *NamespaceList, c *conversion.Cloner) error { + if err := deepCopy_api_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_api_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil { + return err + } + if in.Items != nil { + out.Items = make([]Namespace, len(in.Items)) + for i := range in.Items { + if err := deepCopy_api_Namespace(in.Items[i], &out.Items[i], c); err != nil { + return err + } + } + } else { + out.Items = nil + } + return nil +} + +func deepCopy_api_NamespaceSpec(in NamespaceSpec, out *NamespaceSpec, c *conversion.Cloner) error { + if in.Finalizers != nil { + out.Finalizers = make([]FinalizerName, len(in.Finalizers)) + for i := range in.Finalizers { + out.Finalizers[i] = in.Finalizers[i] + } + } else { + out.Finalizers = nil + } + return nil +} + +func deepCopy_api_NamespaceStatus(in NamespaceStatus, out *NamespaceStatus, c *conversion.Cloner) error { + out.Phase = in.Phase + return nil +} + +func deepCopy_api_Node(in Node, out *Node, c *conversion.Cloner) error { + if err := deepCopy_api_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_api_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil { + return err + } + if err := deepCopy_api_NodeSpec(in.Spec, &out.Spec, c); err != nil { + return err + } + if err := deepCopy_api_NodeStatus(in.Status, &out.Status, c); err != nil { + return err + } + return nil +} + +func deepCopy_api_NodeAddress(in NodeAddress, out *NodeAddress, c *conversion.Cloner) error { + out.Type = in.Type + out.Address = in.Address + return nil +} + +func deepCopy_api_NodeCondition(in NodeCondition, out *NodeCondition, c *conversion.Cloner) error { + out.Type = in.Type + out.Status = in.Status + if err := deepCopy_util_Time(in.LastHeartbeatTime, &out.LastHeartbeatTime, c); err != nil { + return err + } + if err := deepCopy_util_Time(in.LastTransitionTime, &out.LastTransitionTime, c); err != nil { + return err + } + out.Reason = in.Reason + out.Message = in.Message + return nil +} + +func deepCopy_api_NodeList(in NodeList, out *NodeList, c *conversion.Cloner) error { + if err := deepCopy_api_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_api_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil { + return err + } + if in.Items != nil { + out.Items = make([]Node, len(in.Items)) + for i := range in.Items { + if err := deepCopy_api_Node(in.Items[i], &out.Items[i], c); err != nil { + return err + } + } + } else { + out.Items = nil + } + return nil +} + +func deepCopy_api_NodeSpec(in NodeSpec, out *NodeSpec, c *conversion.Cloner) error { + out.PodCIDR = in.PodCIDR + out.ExternalID = in.ExternalID + out.Unschedulable = in.Unschedulable + return nil +} + +func deepCopy_api_NodeStatus(in NodeStatus, out *NodeStatus, c *conversion.Cloner) error { + if in.Capacity != nil { + out.Capacity = make(map[ResourceName]resource.Quantity) + for key, val := range in.Capacity { + newVal := new(resource.Quantity) + if err := deepCopy_resource_Quantity(val, newVal, c); err != nil { + return err + } + out.Capacity[key] = *newVal + } + } else { + out.Capacity = nil + } + out.Phase = in.Phase + if in.Conditions != nil { + out.Conditions = make([]NodeCondition, len(in.Conditions)) + for i := range in.Conditions { + if err := deepCopy_api_NodeCondition(in.Conditions[i], &out.Conditions[i], c); err != nil { + return err + } + } + } else { + out.Conditions = nil + } + if in.Addresses != nil { + out.Addresses = make([]NodeAddress, len(in.Addresses)) + for i := range in.Addresses { + if err := deepCopy_api_NodeAddress(in.Addresses[i], &out.Addresses[i], c); err != nil { + return err + } + } + } else { + out.Addresses = nil + } + if err := deepCopy_api_NodeSystemInfo(in.NodeInfo, &out.NodeInfo, c); err != nil { + return err + } + return nil +} + +func deepCopy_api_NodeSystemInfo(in NodeSystemInfo, out *NodeSystemInfo, c *conversion.Cloner) 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 deepCopy_api_ObjectFieldSelector(in ObjectFieldSelector, out *ObjectFieldSelector, c *conversion.Cloner) error { + out.APIVersion = in.APIVersion + out.FieldPath = in.FieldPath + return nil +} + +func deepCopy_api_ObjectMeta(in ObjectMeta, out *ObjectMeta, c *conversion.Cloner) 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 := deepCopy_util_Time(in.CreationTimestamp, &out.CreationTimestamp, c); err != nil { + return err + } + if in.DeletionTimestamp != nil { + out.DeletionTimestamp = new(util.Time) + if err := deepCopy_util_Time(*in.DeletionTimestamp, out.DeletionTimestamp, c); err != nil { + return err + } + } else { + out.DeletionTimestamp = nil + } + if in.Labels != nil { + out.Labels = make(map[string]string) + for key, val := range in.Labels { + out.Labels[key] = val + } + } else { + out.Labels = nil + } + if in.Annotations != nil { + out.Annotations = make(map[string]string) + for key, val := range in.Annotations { + out.Annotations[key] = val + } + } else { + out.Annotations = nil + } + return nil +} + +func deepCopy_api_ObjectReference(in ObjectReference, out *ObjectReference, c *conversion.Cloner) 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 deepCopy_api_PersistentVolume(in PersistentVolume, out *PersistentVolume, c *conversion.Cloner) error { + if err := deepCopy_api_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_api_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil { + return err + } + if err := deepCopy_api_PersistentVolumeSpec(in.Spec, &out.Spec, c); err != nil { + return err + } + if err := deepCopy_api_PersistentVolumeStatus(in.Status, &out.Status, c); err != nil { + return err + } + return nil +} + +func deepCopy_api_PersistentVolumeClaim(in PersistentVolumeClaim, out *PersistentVolumeClaim, c *conversion.Cloner) error { + if err := deepCopy_api_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_api_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil { + return err + } + if err := deepCopy_api_PersistentVolumeClaimSpec(in.Spec, &out.Spec, c); err != nil { + return err + } + if err := deepCopy_api_PersistentVolumeClaimStatus(in.Status, &out.Status, c); err != nil { + return err + } + return nil +} + +func deepCopy_api_PersistentVolumeClaimList(in PersistentVolumeClaimList, out *PersistentVolumeClaimList, c *conversion.Cloner) error { + if err := deepCopy_api_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_api_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil { + return err + } + if in.Items != nil { + out.Items = make([]PersistentVolumeClaim, len(in.Items)) + for i := range in.Items { + if err := deepCopy_api_PersistentVolumeClaim(in.Items[i], &out.Items[i], c); err != nil { + return err + } + } + } else { + out.Items = nil + } + return nil +} + +func deepCopy_api_PersistentVolumeClaimSpec(in PersistentVolumeClaimSpec, out *PersistentVolumeClaimSpec, c *conversion.Cloner) error { + if in.AccessModes != nil { + out.AccessModes = make([]PersistentVolumeAccessMode, len(in.AccessModes)) + for i := range in.AccessModes { + out.AccessModes[i] = in.AccessModes[i] + } + } else { + out.AccessModes = nil + } + if err := deepCopy_api_ResourceRequirements(in.Resources, &out.Resources, c); err != nil { + return err + } + out.VolumeName = in.VolumeName + return nil +} + +func deepCopy_api_PersistentVolumeClaimStatus(in PersistentVolumeClaimStatus, out *PersistentVolumeClaimStatus, c *conversion.Cloner) error { + out.Phase = in.Phase + if in.AccessModes != nil { + out.AccessModes = make([]PersistentVolumeAccessMode, len(in.AccessModes)) + for i := range in.AccessModes { + out.AccessModes[i] = in.AccessModes[i] + } + } else { + out.AccessModes = nil + } + if in.Capacity != nil { + out.Capacity = make(map[ResourceName]resource.Quantity) + for key, val := range in.Capacity { + newVal := new(resource.Quantity) + if err := deepCopy_resource_Quantity(val, newVal, c); err != nil { + return err + } + out.Capacity[key] = *newVal + } + } else { + out.Capacity = nil + } + return nil +} + +func deepCopy_api_PersistentVolumeClaimVolumeSource(in PersistentVolumeClaimVolumeSource, out *PersistentVolumeClaimVolumeSource, c *conversion.Cloner) error { + out.ClaimName = in.ClaimName + out.ReadOnly = in.ReadOnly + return nil +} + +func deepCopy_api_PersistentVolumeList(in PersistentVolumeList, out *PersistentVolumeList, c *conversion.Cloner) error { + if err := deepCopy_api_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_api_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil { + return err + } + if in.Items != nil { + out.Items = make([]PersistentVolume, len(in.Items)) + for i := range in.Items { + if err := deepCopy_api_PersistentVolume(in.Items[i], &out.Items[i], c); err != nil { + return err + } + } + } else { + out.Items = nil + } + return nil +} + +func deepCopy_api_PersistentVolumeSource(in PersistentVolumeSource, out *PersistentVolumeSource, c *conversion.Cloner) error { + if in.GCEPersistentDisk != nil { + out.GCEPersistentDisk = new(GCEPersistentDiskVolumeSource) + if err := deepCopy_api_GCEPersistentDiskVolumeSource(*in.GCEPersistentDisk, out.GCEPersistentDisk, c); err != nil { + return err + } + } else { + out.GCEPersistentDisk = nil + } + if in.AWSElasticBlockStore != nil { + out.AWSElasticBlockStore = new(AWSElasticBlockStoreVolumeSource) + if err := deepCopy_api_AWSElasticBlockStoreVolumeSource(*in.AWSElasticBlockStore, out.AWSElasticBlockStore, c); err != nil { + return err + } + } else { + out.AWSElasticBlockStore = nil + } + if in.HostPath != nil { + out.HostPath = new(HostPathVolumeSource) + if err := deepCopy_api_HostPathVolumeSource(*in.HostPath, out.HostPath, c); err != nil { + return err + } + } else { + out.HostPath = nil + } + if in.Glusterfs != nil { + out.Glusterfs = new(GlusterfsVolumeSource) + if err := deepCopy_api_GlusterfsVolumeSource(*in.Glusterfs, out.Glusterfs, c); err != nil { + return err + } + } else { + out.Glusterfs = nil + } + if in.NFS != nil { + out.NFS = new(NFSVolumeSource) + if err := deepCopy_api_NFSVolumeSource(*in.NFS, out.NFS, c); err != nil { + return err + } + } else { + out.NFS = nil + } + if in.RBD != nil { + out.RBD = new(RBDVolumeSource) + if err := deepCopy_api_RBDVolumeSource(*in.RBD, out.RBD, c); err != nil { + return err + } + } else { + out.RBD = nil + } + return nil +} + +func deepCopy_api_PersistentVolumeSpec(in PersistentVolumeSpec, out *PersistentVolumeSpec, c *conversion.Cloner) error { + if in.Capacity != nil { + out.Capacity = make(map[ResourceName]resource.Quantity) + for key, val := range in.Capacity { + newVal := new(resource.Quantity) + if err := deepCopy_resource_Quantity(val, newVal, c); err != nil { + return err + } + out.Capacity[key] = *newVal + } + } else { + out.Capacity = nil + } + if err := deepCopy_api_PersistentVolumeSource(in.PersistentVolumeSource, &out.PersistentVolumeSource, c); err != nil { + return err + } + if in.AccessModes != nil { + out.AccessModes = make([]PersistentVolumeAccessMode, len(in.AccessModes)) + for i := range in.AccessModes { + out.AccessModes[i] = in.AccessModes[i] + } + } else { + out.AccessModes = nil + } + if in.ClaimRef != nil { + out.ClaimRef = new(ObjectReference) + if err := deepCopy_api_ObjectReference(*in.ClaimRef, out.ClaimRef, c); err != nil { + return err + } + } else { + out.ClaimRef = nil + } + return nil +} + +func deepCopy_api_PersistentVolumeStatus(in PersistentVolumeStatus, out *PersistentVolumeStatus, c *conversion.Cloner) error { + out.Phase = in.Phase + return nil +} + +func deepCopy_api_Pod(in Pod, out *Pod, c *conversion.Cloner) error { + if err := deepCopy_api_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_api_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil { + return err + } + if err := deepCopy_api_PodSpec(in.Spec, &out.Spec, c); err != nil { + return err + } + if err := deepCopy_api_PodStatus(in.Status, &out.Status, c); err != nil { + return err + } + return nil +} + +func deepCopy_api_PodCondition(in PodCondition, out *PodCondition, c *conversion.Cloner) error { + out.Type = in.Type + out.Status = in.Status + return nil +} + +func deepCopy_api_PodExecOptions(in PodExecOptions, out *PodExecOptions, c *conversion.Cloner) error { + if err := deepCopy_api_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + out.Stdin = in.Stdin + out.Stdout = in.Stdout + out.Stderr = in.Stderr + out.TTY = in.TTY + out.Container = in.Container + if in.Command != nil { + out.Command = make([]string, len(in.Command)) + for i := range in.Command { + out.Command[i] = in.Command[i] + } + } else { + out.Command = nil + } + return nil +} + +func deepCopy_api_PodList(in PodList, out *PodList, c *conversion.Cloner) error { + if err := deepCopy_api_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_api_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil { + return err + } + if in.Items != nil { + out.Items = make([]Pod, len(in.Items)) + for i := range in.Items { + if err := deepCopy_api_Pod(in.Items[i], &out.Items[i], c); err != nil { + return err + } + } + } else { + out.Items = nil + } + return nil +} + +func deepCopy_api_PodLogOptions(in PodLogOptions, out *PodLogOptions, c *conversion.Cloner) error { + if err := deepCopy_api_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + out.Container = in.Container + out.Follow = in.Follow + out.Previous = in.Previous + return nil +} + +func deepCopy_api_PodProxyOptions(in PodProxyOptions, out *PodProxyOptions, c *conversion.Cloner) error { + if err := deepCopy_api_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + out.Path = in.Path + return nil +} + +func deepCopy_api_PodSpec(in PodSpec, out *PodSpec, c *conversion.Cloner) error { + if in.Volumes != nil { + out.Volumes = make([]Volume, len(in.Volumes)) + for i := range in.Volumes { + if err := deepCopy_api_Volume(in.Volumes[i], &out.Volumes[i], c); err != nil { + return err + } + } + } else { + out.Volumes = nil + } + if in.Containers != nil { + out.Containers = make([]Container, len(in.Containers)) + for i := range in.Containers { + if err := deepCopy_api_Container(in.Containers[i], &out.Containers[i], c); err != nil { + return err + } + } + } else { + out.Containers = nil + } + out.RestartPolicy = in.RestartPolicy + if in.TerminationGracePeriodSeconds != nil { + out.TerminationGracePeriodSeconds = new(int64) + *out.TerminationGracePeriodSeconds = *in.TerminationGracePeriodSeconds + } else { + out.TerminationGracePeriodSeconds = nil + } + if in.ActiveDeadlineSeconds != nil { + out.ActiveDeadlineSeconds = new(int64) + *out.ActiveDeadlineSeconds = *in.ActiveDeadlineSeconds + } else { + out.ActiveDeadlineSeconds = nil + } + out.DNSPolicy = in.DNSPolicy + if in.NodeSelector != nil { + out.NodeSelector = make(map[string]string) + for key, val := range in.NodeSelector { + out.NodeSelector[key] = val + } + } else { + out.NodeSelector = nil + } + out.ServiceAccount = in.ServiceAccount + out.Host = in.Host + out.HostNetwork = in.HostNetwork + if in.ImagePullSecrets != nil { + out.ImagePullSecrets = make([]LocalObjectReference, len(in.ImagePullSecrets)) + for i := range in.ImagePullSecrets { + if err := deepCopy_api_LocalObjectReference(in.ImagePullSecrets[i], &out.ImagePullSecrets[i], c); err != nil { + return err + } + } + } else { + out.ImagePullSecrets = nil + } + return nil +} + +func deepCopy_api_PodStatus(in PodStatus, out *PodStatus, c *conversion.Cloner) error { + out.Phase = in.Phase + if in.Conditions != nil { + out.Conditions = make([]PodCondition, len(in.Conditions)) + for i := range in.Conditions { + if err := deepCopy_api_PodCondition(in.Conditions[i], &out.Conditions[i], c); err != nil { + return err + } + } + } else { + out.Conditions = nil + } + out.Message = in.Message + out.HostIP = in.HostIP + out.PodIP = in.PodIP + if in.StartTime != nil { + out.StartTime = new(util.Time) + if err := deepCopy_util_Time(*in.StartTime, out.StartTime, c); err != nil { + return err + } + } else { + out.StartTime = nil + } + if in.ContainerStatuses != nil { + out.ContainerStatuses = make([]ContainerStatus, len(in.ContainerStatuses)) + for i := range in.ContainerStatuses { + if err := deepCopy_api_ContainerStatus(in.ContainerStatuses[i], &out.ContainerStatuses[i], c); err != nil { + return err + } + } + } else { + out.ContainerStatuses = nil + } + return nil +} + +func deepCopy_api_PodStatusResult(in PodStatusResult, out *PodStatusResult, c *conversion.Cloner) error { + if err := deepCopy_api_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_api_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil { + return err + } + if err := deepCopy_api_PodStatus(in.Status, &out.Status, c); err != nil { + return err + } + return nil +} + +func deepCopy_api_PodTemplate(in PodTemplate, out *PodTemplate, c *conversion.Cloner) error { + if err := deepCopy_api_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_api_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil { + return err + } + if err := deepCopy_api_PodTemplateSpec(in.Template, &out.Template, c); err != nil { + return err + } + return nil +} + +func deepCopy_api_PodTemplateList(in PodTemplateList, out *PodTemplateList, c *conversion.Cloner) error { + if err := deepCopy_api_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_api_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil { + return err + } + if in.Items != nil { + out.Items = make([]PodTemplate, len(in.Items)) + for i := range in.Items { + if err := deepCopy_api_PodTemplate(in.Items[i], &out.Items[i], c); err != nil { + return err + } + } + } else { + out.Items = nil + } + return nil +} + +func deepCopy_api_PodTemplateSpec(in PodTemplateSpec, out *PodTemplateSpec, c *conversion.Cloner) error { + if err := deepCopy_api_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil { + return err + } + if err := deepCopy_api_PodSpec(in.Spec, &out.Spec, c); err != nil { + return err + } + return nil +} + +func deepCopy_api_Probe(in Probe, out *Probe, c *conversion.Cloner) error { + if err := deepCopy_api_Handler(in.Handler, &out.Handler, c); err != nil { + return err + } + out.InitialDelaySeconds = in.InitialDelaySeconds + out.TimeoutSeconds = in.TimeoutSeconds + return nil +} + +func deepCopy_api_RBDVolumeSource(in RBDVolumeSource, out *RBDVolumeSource, c *conversion.Cloner) error { + if in.CephMonitors != nil { + out.CephMonitors = make([]string, len(in.CephMonitors)) + for i := range in.CephMonitors { + out.CephMonitors[i] = in.CephMonitors[i] + } + } else { + out.CephMonitors = nil + } + out.RBDImage = in.RBDImage + out.FSType = in.FSType + out.RBDPool = in.RBDPool + out.RadosUser = in.RadosUser + out.Keyring = in.Keyring + if in.SecretRef != nil { + out.SecretRef = new(LocalObjectReference) + if err := deepCopy_api_LocalObjectReference(*in.SecretRef, out.SecretRef, c); err != nil { + return err + } + } else { + out.SecretRef = nil + } + out.ReadOnly = in.ReadOnly + return nil +} + +func deepCopy_api_RangeAllocation(in RangeAllocation, out *RangeAllocation, c *conversion.Cloner) error { + if err := deepCopy_api_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_api_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil { + return err + } + out.Range = in.Range + if in.Data != nil { + out.Data = make([]uint8, len(in.Data)) + for i := range in.Data { + out.Data[i] = in.Data[i] + } + } else { + out.Data = nil + } + return nil +} + +func deepCopy_api_ReplicationController(in ReplicationController, out *ReplicationController, c *conversion.Cloner) error { + if err := deepCopy_api_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_api_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil { + return err + } + if err := deepCopy_api_ReplicationControllerSpec(in.Spec, &out.Spec, c); err != nil { + return err + } + if err := deepCopy_api_ReplicationControllerStatus(in.Status, &out.Status, c); err != nil { + return err + } + return nil +} + +func deepCopy_api_ReplicationControllerList(in ReplicationControllerList, out *ReplicationControllerList, c *conversion.Cloner) error { + if err := deepCopy_api_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_api_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil { + return err + } + if in.Items != nil { + out.Items = make([]ReplicationController, len(in.Items)) + for i := range in.Items { + if err := deepCopy_api_ReplicationController(in.Items[i], &out.Items[i], c); err != nil { + return err + } + } + } else { + out.Items = nil + } + return nil +} + +func deepCopy_api_ReplicationControllerSpec(in ReplicationControllerSpec, out *ReplicationControllerSpec, c *conversion.Cloner) 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 + } + } else { + out.Selector = nil + } + if in.TemplateRef != nil { + out.TemplateRef = new(ObjectReference) + if err := deepCopy_api_ObjectReference(*in.TemplateRef, out.TemplateRef, c); err != nil { + return err + } + } else { + out.TemplateRef = nil + } + if in.Template != nil { + out.Template = new(PodTemplateSpec) + if err := deepCopy_api_PodTemplateSpec(*in.Template, out.Template, c); err != nil { + return err + } + } else { + out.Template = nil + } + return nil +} + +func deepCopy_api_ReplicationControllerStatus(in ReplicationControllerStatus, out *ReplicationControllerStatus, c *conversion.Cloner) error { + out.Replicas = in.Replicas + return nil +} + +func deepCopy_api_ResourceQuota(in ResourceQuota, out *ResourceQuota, c *conversion.Cloner) error { + if err := deepCopy_api_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_api_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil { + return err + } + if err := deepCopy_api_ResourceQuotaSpec(in.Spec, &out.Spec, c); err != nil { + return err + } + if err := deepCopy_api_ResourceQuotaStatus(in.Status, &out.Status, c); err != nil { + return err + } + return nil +} + +func deepCopy_api_ResourceQuotaList(in ResourceQuotaList, out *ResourceQuotaList, c *conversion.Cloner) error { + if err := deepCopy_api_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_api_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil { + return err + } + if in.Items != nil { + out.Items = make([]ResourceQuota, len(in.Items)) + for i := range in.Items { + if err := deepCopy_api_ResourceQuota(in.Items[i], &out.Items[i], c); err != nil { + return err + } + } + } else { + out.Items = nil + } + return nil +} + +func deepCopy_api_ResourceQuotaSpec(in ResourceQuotaSpec, out *ResourceQuotaSpec, c *conversion.Cloner) error { + if in.Hard != nil { + out.Hard = make(map[ResourceName]resource.Quantity) + for key, val := range in.Hard { + newVal := new(resource.Quantity) + if err := deepCopy_resource_Quantity(val, newVal, c); err != nil { + return err + } + out.Hard[key] = *newVal + } + } else { + out.Hard = nil + } + return nil +} + +func deepCopy_api_ResourceQuotaStatus(in ResourceQuotaStatus, out *ResourceQuotaStatus, c *conversion.Cloner) error { + if in.Hard != nil { + out.Hard = make(map[ResourceName]resource.Quantity) + for key, val := range in.Hard { + newVal := new(resource.Quantity) + if err := deepCopy_resource_Quantity(val, newVal, c); err != nil { + return err + } + out.Hard[key] = *newVal + } + } else { + out.Hard = nil + } + if in.Used != nil { + out.Used = make(map[ResourceName]resource.Quantity) + for key, val := range in.Used { + newVal := new(resource.Quantity) + if err := deepCopy_resource_Quantity(val, newVal, c); err != nil { + return err + } + out.Used[key] = *newVal + } + } else { + out.Used = nil + } + return nil +} + +func deepCopy_api_ResourceRequirements(in ResourceRequirements, out *ResourceRequirements, c *conversion.Cloner) error { + if in.Limits != nil { + out.Limits = make(map[ResourceName]resource.Quantity) + for key, val := range in.Limits { + newVal := new(resource.Quantity) + if err := deepCopy_resource_Quantity(val, newVal, c); err != nil { + return err + } + out.Limits[key] = *newVal + } + } else { + out.Limits = nil + } + if in.Requests != nil { + out.Requests = make(map[ResourceName]resource.Quantity) + for key, val := range in.Requests { + newVal := new(resource.Quantity) + if err := deepCopy_resource_Quantity(val, newVal, c); err != nil { + return err + } + out.Requests[key] = *newVal + } + } else { + out.Requests = nil + } + return nil +} + +func deepCopy_api_SELinuxOptions(in SELinuxOptions, out *SELinuxOptions, c *conversion.Cloner) error { + out.User = in.User + out.Role = in.Role + out.Type = in.Type + out.Level = in.Level + return nil +} + +func deepCopy_api_Secret(in Secret, out *Secret, c *conversion.Cloner) error { + if err := deepCopy_api_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_api_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil { + return err + } + if in.Data != nil { + out.Data = make(map[string][]uint8) + for key, val := range in.Data { + if newVal, err := c.DeepCopy(val); err != nil { + return err + } else { + out.Data[key] = newVal.([]uint8) + } + } + } else { + out.Data = nil + } + out.Type = in.Type + return nil +} + +func deepCopy_api_SecretList(in SecretList, out *SecretList, c *conversion.Cloner) error { + if err := deepCopy_api_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_api_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil { + return err + } + if in.Items != nil { + out.Items = make([]Secret, len(in.Items)) + for i := range in.Items { + if err := deepCopy_api_Secret(in.Items[i], &out.Items[i], c); err != nil { + return err + } + } + } else { + out.Items = nil + } + return nil +} + +func deepCopy_api_SecretVolumeSource(in SecretVolumeSource, out *SecretVolumeSource, c *conversion.Cloner) error { + out.SecretName = in.SecretName + return nil +} + +func deepCopy_api_SecurityContext(in SecurityContext, out *SecurityContext, c *conversion.Cloner) error { + if in.Capabilities != nil { + out.Capabilities = new(Capabilities) + if err := deepCopy_api_Capabilities(*in.Capabilities, out.Capabilities, c); err != nil { + return err + } + } else { + out.Capabilities = nil + } + if in.Privileged != nil { + out.Privileged = new(bool) + *out.Privileged = *in.Privileged + } else { + out.Privileged = nil + } + if in.SELinuxOptions != nil { + out.SELinuxOptions = new(SELinuxOptions) + if err := deepCopy_api_SELinuxOptions(*in.SELinuxOptions, out.SELinuxOptions, c); err != nil { + return err + } + } else { + out.SELinuxOptions = nil + } + if in.RunAsUser != nil { + out.RunAsUser = new(int64) + *out.RunAsUser = *in.RunAsUser + } else { + out.RunAsUser = nil + } + return nil +} + +func deepCopy_api_SerializedReference(in SerializedReference, out *SerializedReference, c *conversion.Cloner) error { + if err := deepCopy_api_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_api_ObjectReference(in.Reference, &out.Reference, c); err != nil { + return err + } + return nil +} + +func deepCopy_api_Service(in Service, out *Service, c *conversion.Cloner) error { + if err := deepCopy_api_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_api_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil { + return err + } + if err := deepCopy_api_ServiceSpec(in.Spec, &out.Spec, c); err != nil { + return err + } + if err := deepCopy_api_ServiceStatus(in.Status, &out.Status, c); err != nil { + return err + } + return nil +} + +func deepCopy_api_ServiceAccount(in ServiceAccount, out *ServiceAccount, c *conversion.Cloner) error { + if err := deepCopy_api_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_api_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil { + return err + } + if in.Secrets != nil { + out.Secrets = make([]ObjectReference, len(in.Secrets)) + for i := range in.Secrets { + if err := deepCopy_api_ObjectReference(in.Secrets[i], &out.Secrets[i], c); err != nil { + return err + } + } + } else { + out.Secrets = nil + } + return nil +} + +func deepCopy_api_ServiceAccountList(in ServiceAccountList, out *ServiceAccountList, c *conversion.Cloner) error { + if err := deepCopy_api_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_api_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil { + return err + } + if in.Items != nil { + out.Items = make([]ServiceAccount, len(in.Items)) + for i := range in.Items { + if err := deepCopy_api_ServiceAccount(in.Items[i], &out.Items[i], c); err != nil { + return err + } + } + } else { + out.Items = nil + } + return nil +} + +func deepCopy_api_ServiceList(in ServiceList, out *ServiceList, c *conversion.Cloner) error { + if err := deepCopy_api_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_api_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil { + return err + } + if in.Items != nil { + out.Items = make([]Service, len(in.Items)) + for i := range in.Items { + if err := deepCopy_api_Service(in.Items[i], &out.Items[i], c); err != nil { + return err + } + } + } else { + out.Items = nil + } + return nil +} + +func deepCopy_api_ServicePort(in ServicePort, out *ServicePort, c *conversion.Cloner) error { + out.Name = in.Name + out.Protocol = in.Protocol + out.Port = in.Port + if err := deepCopy_util_IntOrString(in.TargetPort, &out.TargetPort, c); err != nil { + return err + } + out.NodePort = in.NodePort + return nil +} + +func deepCopy_api_ServiceSpec(in ServiceSpec, out *ServiceSpec, c *conversion.Cloner) error { + if in.Ports != nil { + out.Ports = make([]ServicePort, len(in.Ports)) + for i := range in.Ports { + if err := deepCopy_api_ServicePort(in.Ports[i], &out.Ports[i], c); err != nil { + return err + } + } + } else { + out.Ports = nil + } + if in.Selector != nil { + out.Selector = make(map[string]string) + for key, val := range in.Selector { + out.Selector[key] = val + } + } else { + out.Selector = nil + } + out.PortalIP = in.PortalIP + out.Type = in.Type + if in.DeprecatedPublicIPs != nil { + out.DeprecatedPublicIPs = make([]string, len(in.DeprecatedPublicIPs)) + for i := range in.DeprecatedPublicIPs { + out.DeprecatedPublicIPs[i] = in.DeprecatedPublicIPs[i] + } + } else { + out.DeprecatedPublicIPs = nil + } + out.SessionAffinity = in.SessionAffinity + return nil +} + +func deepCopy_api_ServiceStatus(in ServiceStatus, out *ServiceStatus, c *conversion.Cloner) error { + if err := deepCopy_api_LoadBalancerStatus(in.LoadBalancer, &out.LoadBalancer, c); err != nil { + return err + } + return nil +} + +func deepCopy_api_Status(in Status, out *Status, c *conversion.Cloner) error { + if err := deepCopy_api_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_api_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil { + return err + } + out.Status = in.Status + out.Message = in.Message + out.Reason = in.Reason + if in.Details != nil { + out.Details = new(StatusDetails) + if err := deepCopy_api_StatusDetails(*in.Details, out.Details, c); err != nil { + return err + } + } else { + out.Details = nil + } + out.Code = in.Code + return nil +} + +func deepCopy_api_StatusCause(in StatusCause, out *StatusCause, c *conversion.Cloner) error { + out.Type = in.Type + out.Message = in.Message + out.Field = in.Field + return nil +} + +func deepCopy_api_StatusDetails(in StatusDetails, out *StatusDetails, c *conversion.Cloner) 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 := deepCopy_api_StatusCause(in.Causes[i], &out.Causes[i], c); err != nil { + return err + } + } + } else { + out.Causes = nil + } + out.RetryAfterSeconds = in.RetryAfterSeconds + return nil +} + +func deepCopy_api_TCPSocketAction(in TCPSocketAction, out *TCPSocketAction, c *conversion.Cloner) error { + if err := deepCopy_util_IntOrString(in.Port, &out.Port, c); err != nil { + return err + } + return nil +} + +func deepCopy_api_TypeMeta(in TypeMeta, out *TypeMeta, c *conversion.Cloner) error { + out.Kind = in.Kind + out.APIVersion = in.APIVersion + return nil +} + +func deepCopy_api_Volume(in Volume, out *Volume, c *conversion.Cloner) error { + out.Name = in.Name + if err := deepCopy_api_VolumeSource(in.VolumeSource, &out.VolumeSource, c); err != nil { + return err + } + return nil +} + +func deepCopy_api_VolumeMount(in VolumeMount, out *VolumeMount, c *conversion.Cloner) error { + out.Name = in.Name + out.ReadOnly = in.ReadOnly + out.MountPath = in.MountPath + return nil +} + +func deepCopy_api_VolumeSource(in VolumeSource, out *VolumeSource, c *conversion.Cloner) error { + if in.HostPath != nil { + out.HostPath = new(HostPathVolumeSource) + if err := deepCopy_api_HostPathVolumeSource(*in.HostPath, out.HostPath, c); err != nil { + return err + } + } else { + out.HostPath = nil + } + if in.EmptyDir != nil { + out.EmptyDir = new(EmptyDirVolumeSource) + if err := deepCopy_api_EmptyDirVolumeSource(*in.EmptyDir, out.EmptyDir, c); err != nil { + return err + } + } else { + out.EmptyDir = nil + } + if in.GCEPersistentDisk != nil { + out.GCEPersistentDisk = new(GCEPersistentDiskVolumeSource) + if err := deepCopy_api_GCEPersistentDiskVolumeSource(*in.GCEPersistentDisk, out.GCEPersistentDisk, c); err != nil { + return err + } + } else { + out.GCEPersistentDisk = nil + } + if in.AWSElasticBlockStore != nil { + out.AWSElasticBlockStore = new(AWSElasticBlockStoreVolumeSource) + if err := deepCopy_api_AWSElasticBlockStoreVolumeSource(*in.AWSElasticBlockStore, out.AWSElasticBlockStore, c); err != nil { + return err + } + } else { + out.AWSElasticBlockStore = nil + } + if in.GitRepo != nil { + out.GitRepo = new(GitRepoVolumeSource) + if err := deepCopy_api_GitRepoVolumeSource(*in.GitRepo, out.GitRepo, c); err != nil { + return err + } + } else { + out.GitRepo = nil + } + if in.Secret != nil { + out.Secret = new(SecretVolumeSource) + if err := deepCopy_api_SecretVolumeSource(*in.Secret, out.Secret, c); err != nil { + return err + } + } else { + out.Secret = nil + } + if in.NFS != nil { + out.NFS = new(NFSVolumeSource) + if err := deepCopy_api_NFSVolumeSource(*in.NFS, out.NFS, c); err != nil { + return err + } + } else { + out.NFS = nil + } + if in.ISCSI != nil { + out.ISCSI = new(ISCSIVolumeSource) + if err := deepCopy_api_ISCSIVolumeSource(*in.ISCSI, out.ISCSI, c); err != nil { + return err + } + } else { + out.ISCSI = nil + } + if in.Glusterfs != nil { + out.Glusterfs = new(GlusterfsVolumeSource) + if err := deepCopy_api_GlusterfsVolumeSource(*in.Glusterfs, out.Glusterfs, c); err != nil { + return err + } + } else { + out.Glusterfs = nil + } + if in.PersistentVolumeClaimVolumeSource != nil { + out.PersistentVolumeClaimVolumeSource = new(PersistentVolumeClaimVolumeSource) + if err := deepCopy_api_PersistentVolumeClaimVolumeSource(*in.PersistentVolumeClaimVolumeSource, out.PersistentVolumeClaimVolumeSource, c); err != nil { + return err + } + } else { + out.PersistentVolumeClaimVolumeSource = nil + } + if in.RBD != nil { + out.RBD = new(RBDVolumeSource) + if err := deepCopy_api_RBDVolumeSource(*in.RBD, out.RBD, c); err != nil { + return err + } + } else { + out.RBD = nil + } + return nil +} + +func deepCopy_resource_Quantity(in resource.Quantity, out *resource.Quantity, c *conversion.Cloner) error { + if in.Amount != nil { + if newVal, err := c.DeepCopy(in.Amount); err != nil { + return err + } else { + out.Amount = newVal.(*inf.Dec) + } + } else { + out.Amount = nil + } + out.Format = in.Format + return nil +} + +func deepCopy_util_IntOrString(in util.IntOrString, out *util.IntOrString, c *conversion.Cloner) error { + out.Kind = in.Kind + out.IntVal = in.IntVal + out.StrVal = in.StrVal + return nil +} + +func deepCopy_util_Time(in util.Time, out *util.Time, c *conversion.Cloner) error { + if newVal, err := c.DeepCopy(in.Time); err != nil { + return err + } else { + out.Time = newVal.(time.Time) + } + return nil +} + +func init() { + err := Scheme.AddGeneratedDeepCopyFuncs( + deepCopy_api_AWSElasticBlockStoreVolumeSource, + deepCopy_api_Binding, + deepCopy_api_Capabilities, + deepCopy_api_ComponentCondition, + deepCopy_api_ComponentStatus, + deepCopy_api_ComponentStatusList, + deepCopy_api_Container, + deepCopy_api_ContainerManifest, + deepCopy_api_ContainerManifestList, + deepCopy_api_ContainerPort, + deepCopy_api_ContainerState, + deepCopy_api_ContainerStateRunning, + deepCopy_api_ContainerStateTerminated, + deepCopy_api_ContainerStateWaiting, + deepCopy_api_ContainerStatus, + deepCopy_api_DeleteOptions, + deepCopy_api_EmptyDirVolumeSource, + deepCopy_api_EndpointAddress, + deepCopy_api_EndpointPort, + deepCopy_api_EndpointSubset, + deepCopy_api_Endpoints, + deepCopy_api_EndpointsList, + deepCopy_api_EnvVar, + deepCopy_api_EnvVarSource, + deepCopy_api_Event, + deepCopy_api_EventList, + deepCopy_api_EventSource, + deepCopy_api_ExecAction, + deepCopy_api_GCEPersistentDiskVolumeSource, + deepCopy_api_GitRepoVolumeSource, + deepCopy_api_GlusterfsVolumeSource, + deepCopy_api_HTTPGetAction, + deepCopy_api_Handler, + deepCopy_api_HostPathVolumeSource, + deepCopy_api_ISCSIVolumeSource, + deepCopy_api_Lifecycle, + deepCopy_api_LimitRange, + deepCopy_api_LimitRangeItem, + deepCopy_api_LimitRangeList, + deepCopy_api_LimitRangeSpec, + deepCopy_api_List, + deepCopy_api_ListMeta, + deepCopy_api_ListOptions, + deepCopy_api_LoadBalancerIngress, + deepCopy_api_LoadBalancerStatus, + deepCopy_api_LocalObjectReference, + deepCopy_api_NFSVolumeSource, + deepCopy_api_Namespace, + deepCopy_api_NamespaceList, + deepCopy_api_NamespaceSpec, + deepCopy_api_NamespaceStatus, + deepCopy_api_Node, + deepCopy_api_NodeAddress, + deepCopy_api_NodeCondition, + deepCopy_api_NodeList, + deepCopy_api_NodeSpec, + deepCopy_api_NodeStatus, + deepCopy_api_NodeSystemInfo, + deepCopy_api_ObjectFieldSelector, + deepCopy_api_ObjectMeta, + deepCopy_api_ObjectReference, + deepCopy_api_PersistentVolume, + deepCopy_api_PersistentVolumeClaim, + deepCopy_api_PersistentVolumeClaimList, + deepCopy_api_PersistentVolumeClaimSpec, + deepCopy_api_PersistentVolumeClaimStatus, + deepCopy_api_PersistentVolumeClaimVolumeSource, + deepCopy_api_PersistentVolumeList, + deepCopy_api_PersistentVolumeSource, + deepCopy_api_PersistentVolumeSpec, + deepCopy_api_PersistentVolumeStatus, + deepCopy_api_Pod, + deepCopy_api_PodCondition, + deepCopy_api_PodExecOptions, + deepCopy_api_PodList, + deepCopy_api_PodLogOptions, + deepCopy_api_PodProxyOptions, + deepCopy_api_PodSpec, + deepCopy_api_PodStatus, + deepCopy_api_PodStatusResult, + deepCopy_api_PodTemplate, + deepCopy_api_PodTemplateList, + deepCopy_api_PodTemplateSpec, + deepCopy_api_Probe, + deepCopy_api_RBDVolumeSource, + deepCopy_api_RangeAllocation, + deepCopy_api_ReplicationController, + deepCopy_api_ReplicationControllerList, + deepCopy_api_ReplicationControllerSpec, + deepCopy_api_ReplicationControllerStatus, + deepCopy_api_ResourceQuota, + deepCopy_api_ResourceQuotaList, + deepCopy_api_ResourceQuotaSpec, + deepCopy_api_ResourceQuotaStatus, + deepCopy_api_ResourceRequirements, + deepCopy_api_SELinuxOptions, + deepCopy_api_Secret, + deepCopy_api_SecretList, + deepCopy_api_SecretVolumeSource, + deepCopy_api_SecurityContext, + deepCopy_api_SerializedReference, + deepCopy_api_Service, + deepCopy_api_ServiceAccount, + deepCopy_api_ServiceAccountList, + deepCopy_api_ServiceList, + deepCopy_api_ServicePort, + deepCopy_api_ServiceSpec, + deepCopy_api_ServiceStatus, + deepCopy_api_Status, + deepCopy_api_StatusCause, + deepCopy_api_StatusDetails, + deepCopy_api_TCPSocketAction, + deepCopy_api_TypeMeta, + deepCopy_api_Volume, + deepCopy_api_VolumeMount, + deepCopy_api_VolumeSource, + deepCopy_resource_Quantity, + deepCopy_util_IntOrString, + deepCopy_util_Time, + ) + if err != nil { + // if one of the deep copy functions is malformed, detect it immediately. + panic(err) + } +} + +// AUTO-GENERATED FUNCTIONS END HERE diff --git a/pkg/api/deep_copy_test.go b/pkg/api/deep_copy_test.go index ca2b62eff55..232ad7d67dd 100644 --- a/pkg/api/deep_copy_test.go +++ b/pkg/api/deep_copy_test.go @@ -21,7 +21,6 @@ import ( "testing" "github.com/GoogleCloudPlatform/kubernetes/pkg/api" - "github.com/GoogleCloudPlatform/kubernetes/pkg/conversion" ) func BenchmarkPodCopy(b *testing.B) { @@ -36,7 +35,7 @@ func BenchmarkPodCopy(b *testing.B) { var result *api.Pod for i := 0; i < b.N; i++ { - obj, err := conversion.DeepCopy(&pod) + obj, err := api.Scheme.DeepCopy(&pod) if err != nil { b.Fatalf("Unexpected error copying pod: %v", err) } @@ -59,7 +58,7 @@ func BenchmarkNodeCopy(b *testing.B) { var result *api.Node for i := 0; i < b.N; i++ { - obj, err := conversion.DeepCopy(&node) + obj, err := api.Scheme.DeepCopy(&node) if err != nil { b.Fatalf("Unexpected error copying node: %v", err) } @@ -82,7 +81,7 @@ func BenchmarkReplicationControllerCopy(b *testing.B) { var result *api.ReplicationController for i := 0; i < b.N; i++ { - obj, err := conversion.DeepCopy(&replicationController) + obj, err := api.Scheme.DeepCopy(&replicationController) if err != nil { b.Fatalf("Unexpected error copying replication controller: %v", err) } diff --git a/pkg/api/v1/deep_copy_generated.go b/pkg/api/v1/deep_copy_generated.go new file mode 100644 index 00000000000..a9c6328b6fe --- /dev/null +++ b/pkg/api/v1/deep_copy_generated.go @@ -0,0 +1,2190 @@ +/* +Copyright 2015 The Kubernetes Authors 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 v1 + +// AUTO-GENERATED FUNCTIONS START HERE +import ( + "github.com/GoogleCloudPlatform/kubernetes/pkg/api" + "github.com/GoogleCloudPlatform/kubernetes/pkg/api/resource" + "github.com/GoogleCloudPlatform/kubernetes/pkg/conversion" + "github.com/GoogleCloudPlatform/kubernetes/pkg/runtime" + "github.com/GoogleCloudPlatform/kubernetes/pkg/util" + "speter.net/go/exp/math/dec/inf" + "time" +) + +func deepCopy_resource_Quantity(in resource.Quantity, out *resource.Quantity, c *conversion.Cloner) error { + if in.Amount != nil { + if newVal, err := c.DeepCopy(in.Amount); err != nil { + return err + } else { + out.Amount = newVal.(*inf.Dec) + } + } else { + out.Amount = nil + } + out.Format = in.Format + return nil +} + +func deepCopy_v1_AWSElasticBlockStoreVolumeSource(in AWSElasticBlockStoreVolumeSource, out *AWSElasticBlockStoreVolumeSource, c *conversion.Cloner) error { + out.VolumeID = in.VolumeID + out.FSType = in.FSType + out.Partition = in.Partition + out.ReadOnly = in.ReadOnly + return nil +} + +func deepCopy_v1_Binding(in Binding, out *Binding, c *conversion.Cloner) error { + if err := deepCopy_v1_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_v1_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil { + return err + } + if err := deepCopy_v1_ObjectReference(in.Target, &out.Target, c); err != nil { + return err + } + return nil +} + +func deepCopy_v1_Capabilities(in Capabilities, out *Capabilities, c *conversion.Cloner) error { + if in.Add != nil { + out.Add = make([]Capability, len(in.Add)) + for i := range in.Add { + out.Add[i] = in.Add[i] + } + } else { + out.Add = nil + } + if in.Drop != nil { + out.Drop = make([]Capability, len(in.Drop)) + for i := range in.Drop { + out.Drop[i] = in.Drop[i] + } + } else { + out.Drop = nil + } + return nil +} + +func deepCopy_v1_ComponentCondition(in ComponentCondition, out *ComponentCondition, c *conversion.Cloner) error { + out.Type = in.Type + out.Status = in.Status + out.Message = in.Message + out.Error = in.Error + return nil +} + +func deepCopy_v1_ComponentStatus(in ComponentStatus, out *ComponentStatus, c *conversion.Cloner) error { + if err := deepCopy_v1_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_v1_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil { + return err + } + if in.Conditions != nil { + out.Conditions = make([]ComponentCondition, len(in.Conditions)) + for i := range in.Conditions { + if err := deepCopy_v1_ComponentCondition(in.Conditions[i], &out.Conditions[i], c); err != nil { + return err + } + } + } else { + out.Conditions = nil + } + return nil +} + +func deepCopy_v1_ComponentStatusList(in ComponentStatusList, out *ComponentStatusList, c *conversion.Cloner) error { + if err := deepCopy_v1_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_v1_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil { + return err + } + if in.Items != nil { + out.Items = make([]ComponentStatus, len(in.Items)) + for i := range in.Items { + if err := deepCopy_v1_ComponentStatus(in.Items[i], &out.Items[i], c); err != nil { + return err + } + } + } else { + out.Items = nil + } + return nil +} + +func deepCopy_v1_Container(in Container, out *Container, c *conversion.Cloner) 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] + } + } else { + out.Command = nil + } + if in.Args != nil { + out.Args = make([]string, len(in.Args)) + for i := range in.Args { + out.Args[i] = in.Args[i] + } + } else { + out.Args = nil + } + out.WorkingDir = in.WorkingDir + if in.Ports != nil { + out.Ports = make([]ContainerPort, len(in.Ports)) + for i := range in.Ports { + if err := deepCopy_v1_ContainerPort(in.Ports[i], &out.Ports[i], c); err != nil { + return err + } + } + } else { + out.Ports = nil + } + if in.Env != nil { + out.Env = make([]EnvVar, len(in.Env)) + for i := range in.Env { + if err := deepCopy_v1_EnvVar(in.Env[i], &out.Env[i], c); err != nil { + return err + } + } + } else { + out.Env = nil + } + if err := deepCopy_v1_ResourceRequirements(in.Resources, &out.Resources, c); err != nil { + return err + } + if in.VolumeMounts != nil { + out.VolumeMounts = make([]VolumeMount, len(in.VolumeMounts)) + for i := range in.VolumeMounts { + if err := deepCopy_v1_VolumeMount(in.VolumeMounts[i], &out.VolumeMounts[i], c); err != nil { + return err + } + } + } else { + out.VolumeMounts = nil + } + if in.LivenessProbe != nil { + out.LivenessProbe = new(Probe) + if err := deepCopy_v1_Probe(*in.LivenessProbe, out.LivenessProbe, c); err != nil { + return err + } + } else { + out.LivenessProbe = nil + } + if in.ReadinessProbe != nil { + out.ReadinessProbe = new(Probe) + if err := deepCopy_v1_Probe(*in.ReadinessProbe, out.ReadinessProbe, c); err != nil { + return err + } + } else { + out.ReadinessProbe = nil + } + if in.Lifecycle != nil { + out.Lifecycle = new(Lifecycle) + if err := deepCopy_v1_Lifecycle(*in.Lifecycle, out.Lifecycle, c); err != nil { + return err + } + } else { + out.Lifecycle = nil + } + out.TerminationMessagePath = in.TerminationMessagePath + out.ImagePullPolicy = in.ImagePullPolicy + if in.SecurityContext != nil { + out.SecurityContext = new(SecurityContext) + if err := deepCopy_v1_SecurityContext(*in.SecurityContext, out.SecurityContext, c); err != nil { + return err + } + } else { + out.SecurityContext = nil + } + return nil +} + +func deepCopy_v1_ContainerPort(in ContainerPort, out *ContainerPort, c *conversion.Cloner) error { + out.Name = in.Name + out.HostPort = in.HostPort + out.ContainerPort = in.ContainerPort + out.Protocol = in.Protocol + out.HostIP = in.HostIP + return nil +} + +func deepCopy_v1_ContainerState(in ContainerState, out *ContainerState, c *conversion.Cloner) error { + if in.Waiting != nil { + out.Waiting = new(ContainerStateWaiting) + if err := deepCopy_v1_ContainerStateWaiting(*in.Waiting, out.Waiting, c); err != nil { + return err + } + } else { + out.Waiting = nil + } + if in.Running != nil { + out.Running = new(ContainerStateRunning) + if err := deepCopy_v1_ContainerStateRunning(*in.Running, out.Running, c); err != nil { + return err + } + } else { + out.Running = nil + } + if in.Termination != nil { + out.Termination = new(ContainerStateTerminated) + if err := deepCopy_v1_ContainerStateTerminated(*in.Termination, out.Termination, c); err != nil { + return err + } + } else { + out.Termination = nil + } + return nil +} + +func deepCopy_v1_ContainerStateRunning(in ContainerStateRunning, out *ContainerStateRunning, c *conversion.Cloner) error { + if err := deepCopy_util_Time(in.StartedAt, &out.StartedAt, c); err != nil { + return err + } + return nil +} + +func deepCopy_v1_ContainerStateTerminated(in ContainerStateTerminated, out *ContainerStateTerminated, c *conversion.Cloner) error { + out.ExitCode = in.ExitCode + out.Signal = in.Signal + out.Reason = in.Reason + out.Message = in.Message + if err := deepCopy_util_Time(in.StartedAt, &out.StartedAt, c); err != nil { + return err + } + if err := deepCopy_util_Time(in.FinishedAt, &out.FinishedAt, c); err != nil { + return err + } + out.ContainerID = in.ContainerID + return nil +} + +func deepCopy_v1_ContainerStateWaiting(in ContainerStateWaiting, out *ContainerStateWaiting, c *conversion.Cloner) error { + out.Reason = in.Reason + return nil +} + +func deepCopy_v1_ContainerStatus(in ContainerStatus, out *ContainerStatus, c *conversion.Cloner) error { + out.Name = in.Name + if err := deepCopy_v1_ContainerState(in.State, &out.State, c); err != nil { + return err + } + if err := deepCopy_v1_ContainerState(in.LastTerminationState, &out.LastTerminationState, c); 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 deepCopy_v1_DeleteOptions(in DeleteOptions, out *DeleteOptions, c *conversion.Cloner) error { + if err := deepCopy_v1_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if in.GracePeriodSeconds != nil { + out.GracePeriodSeconds = new(int64) + *out.GracePeriodSeconds = *in.GracePeriodSeconds + } else { + out.GracePeriodSeconds = nil + } + return nil +} + +func deepCopy_v1_EmptyDirVolumeSource(in EmptyDirVolumeSource, out *EmptyDirVolumeSource, c *conversion.Cloner) error { + out.Medium = in.Medium + return nil +} + +func deepCopy_v1_EndpointAddress(in EndpointAddress, out *EndpointAddress, c *conversion.Cloner) error { + out.IP = in.IP + if in.TargetRef != nil { + out.TargetRef = new(ObjectReference) + if err := deepCopy_v1_ObjectReference(*in.TargetRef, out.TargetRef, c); err != nil { + return err + } + } else { + out.TargetRef = nil + } + return nil +} + +func deepCopy_v1_EndpointPort(in EndpointPort, out *EndpointPort, c *conversion.Cloner) error { + out.Name = in.Name + out.Port = in.Port + out.Protocol = in.Protocol + return nil +} + +func deepCopy_v1_EndpointSubset(in EndpointSubset, out *EndpointSubset, c *conversion.Cloner) error { + if in.Addresses != nil { + out.Addresses = make([]EndpointAddress, len(in.Addresses)) + for i := range in.Addresses { + if err := deepCopy_v1_EndpointAddress(in.Addresses[i], &out.Addresses[i], c); err != nil { + return err + } + } + } else { + out.Addresses = nil + } + if in.Ports != nil { + out.Ports = make([]EndpointPort, len(in.Ports)) + for i := range in.Ports { + if err := deepCopy_v1_EndpointPort(in.Ports[i], &out.Ports[i], c); err != nil { + return err + } + } + } else { + out.Ports = nil + } + return nil +} + +func deepCopy_v1_Endpoints(in Endpoints, out *Endpoints, c *conversion.Cloner) error { + if err := deepCopy_v1_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_v1_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil { + return err + } + if in.Subsets != nil { + out.Subsets = make([]EndpointSubset, len(in.Subsets)) + for i := range in.Subsets { + if err := deepCopy_v1_EndpointSubset(in.Subsets[i], &out.Subsets[i], c); err != nil { + return err + } + } + } else { + out.Subsets = nil + } + return nil +} + +func deepCopy_v1_EndpointsList(in EndpointsList, out *EndpointsList, c *conversion.Cloner) error { + if err := deepCopy_v1_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_v1_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil { + return err + } + if in.Items != nil { + out.Items = make([]Endpoints, len(in.Items)) + for i := range in.Items { + if err := deepCopy_v1_Endpoints(in.Items[i], &out.Items[i], c); err != nil { + return err + } + } + } else { + out.Items = nil + } + return nil +} + +func deepCopy_v1_EnvVar(in EnvVar, out *EnvVar, c *conversion.Cloner) error { + out.Name = in.Name + out.Value = in.Value + if in.ValueFrom != nil { + out.ValueFrom = new(EnvVarSource) + if err := deepCopy_v1_EnvVarSource(*in.ValueFrom, out.ValueFrom, c); err != nil { + return err + } + } else { + out.ValueFrom = nil + } + return nil +} + +func deepCopy_v1_EnvVarSource(in EnvVarSource, out *EnvVarSource, c *conversion.Cloner) error { + if in.FieldRef != nil { + out.FieldRef = new(ObjectFieldSelector) + if err := deepCopy_v1_ObjectFieldSelector(*in.FieldRef, out.FieldRef, c); err != nil { + return err + } + } else { + out.FieldRef = nil + } + return nil +} + +func deepCopy_v1_Event(in Event, out *Event, c *conversion.Cloner) error { + if err := deepCopy_v1_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_v1_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil { + return err + } + if err := deepCopy_v1_ObjectReference(in.InvolvedObject, &out.InvolvedObject, c); err != nil { + return err + } + out.Reason = in.Reason + out.Message = in.Message + if err := deepCopy_v1_EventSource(in.Source, &out.Source, c); err != nil { + return err + } + if err := deepCopy_util_Time(in.FirstTimestamp, &out.FirstTimestamp, c); err != nil { + return err + } + if err := deepCopy_util_Time(in.LastTimestamp, &out.LastTimestamp, c); err != nil { + return err + } + out.Count = in.Count + return nil +} + +func deepCopy_v1_EventList(in EventList, out *EventList, c *conversion.Cloner) error { + if err := deepCopy_v1_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_v1_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil { + return err + } + if in.Items != nil { + out.Items = make([]Event, len(in.Items)) + for i := range in.Items { + if err := deepCopy_v1_Event(in.Items[i], &out.Items[i], c); err != nil { + return err + } + } + } else { + out.Items = nil + } + return nil +} + +func deepCopy_v1_EventSource(in EventSource, out *EventSource, c *conversion.Cloner) error { + out.Component = in.Component + out.Host = in.Host + return nil +} + +func deepCopy_v1_ExecAction(in ExecAction, out *ExecAction, c *conversion.Cloner) error { + if in.Command != nil { + out.Command = make([]string, len(in.Command)) + for i := range in.Command { + out.Command[i] = in.Command[i] + } + } else { + out.Command = nil + } + return nil +} + +func deepCopy_v1_GCEPersistentDiskVolumeSource(in GCEPersistentDiskVolumeSource, out *GCEPersistentDiskVolumeSource, c *conversion.Cloner) error { + out.PDName = in.PDName + out.FSType = in.FSType + out.Partition = in.Partition + out.ReadOnly = in.ReadOnly + return nil +} + +func deepCopy_v1_GitRepoVolumeSource(in GitRepoVolumeSource, out *GitRepoVolumeSource, c *conversion.Cloner) error { + out.Repository = in.Repository + out.Revision = in.Revision + return nil +} + +func deepCopy_v1_GlusterfsVolumeSource(in GlusterfsVolumeSource, out *GlusterfsVolumeSource, c *conversion.Cloner) error { + out.EndpointsName = in.EndpointsName + out.Path = in.Path + out.ReadOnly = in.ReadOnly + return nil +} + +func deepCopy_v1_HTTPGetAction(in HTTPGetAction, out *HTTPGetAction, c *conversion.Cloner) error { + out.Path = in.Path + if err := deepCopy_util_IntOrString(in.Port, &out.Port, c); err != nil { + return err + } + out.Host = in.Host + return nil +} + +func deepCopy_v1_Handler(in Handler, out *Handler, c *conversion.Cloner) error { + if in.Exec != nil { + out.Exec = new(ExecAction) + if err := deepCopy_v1_ExecAction(*in.Exec, out.Exec, c); err != nil { + return err + } + } else { + out.Exec = nil + } + if in.HTTPGet != nil { + out.HTTPGet = new(HTTPGetAction) + if err := deepCopy_v1_HTTPGetAction(*in.HTTPGet, out.HTTPGet, c); err != nil { + return err + } + } else { + out.HTTPGet = nil + } + if in.TCPSocket != nil { + out.TCPSocket = new(TCPSocketAction) + if err := deepCopy_v1_TCPSocketAction(*in.TCPSocket, out.TCPSocket, c); err != nil { + return err + } + } else { + out.TCPSocket = nil + } + return nil +} + +func deepCopy_v1_HostPathVolumeSource(in HostPathVolumeSource, out *HostPathVolumeSource, c *conversion.Cloner) error { + out.Path = in.Path + return nil +} + +func deepCopy_v1_ISCSIVolumeSource(in ISCSIVolumeSource, out *ISCSIVolumeSource, c *conversion.Cloner) error { + out.TargetPortal = in.TargetPortal + out.IQN = in.IQN + out.Lun = in.Lun + out.FSType = in.FSType + out.ReadOnly = in.ReadOnly + return nil +} + +func deepCopy_v1_Lifecycle(in Lifecycle, out *Lifecycle, c *conversion.Cloner) error { + if in.PostStart != nil { + out.PostStart = new(Handler) + if err := deepCopy_v1_Handler(*in.PostStart, out.PostStart, c); err != nil { + return err + } + } else { + out.PostStart = nil + } + if in.PreStop != nil { + out.PreStop = new(Handler) + if err := deepCopy_v1_Handler(*in.PreStop, out.PreStop, c); err != nil { + return err + } + } else { + out.PreStop = nil + } + return nil +} + +func deepCopy_v1_LimitRange(in LimitRange, out *LimitRange, c *conversion.Cloner) error { + if err := deepCopy_v1_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_v1_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil { + return err + } + if err := deepCopy_v1_LimitRangeSpec(in.Spec, &out.Spec, c); err != nil { + return err + } + return nil +} + +func deepCopy_v1_LimitRangeItem(in LimitRangeItem, out *LimitRangeItem, c *conversion.Cloner) error { + out.Type = in.Type + if in.Max != nil { + out.Max = make(map[ResourceName]resource.Quantity) + for key, val := range in.Max { + newVal := new(resource.Quantity) + if err := deepCopy_resource_Quantity(val, newVal, c); err != nil { + return err + } + out.Max[key] = *newVal + } + } else { + out.Max = nil + } + if in.Min != nil { + out.Min = make(map[ResourceName]resource.Quantity) + for key, val := range in.Min { + newVal := new(resource.Quantity) + if err := deepCopy_resource_Quantity(val, newVal, c); err != nil { + return err + } + out.Min[key] = *newVal + } + } else { + out.Min = nil + } + if in.Default != nil { + out.Default = make(map[ResourceName]resource.Quantity) + for key, val := range in.Default { + newVal := new(resource.Quantity) + if err := deepCopy_resource_Quantity(val, newVal, c); err != nil { + return err + } + out.Default[key] = *newVal + } + } else { + out.Default = nil + } + return nil +} + +func deepCopy_v1_LimitRangeList(in LimitRangeList, out *LimitRangeList, c *conversion.Cloner) error { + if err := deepCopy_v1_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_v1_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil { + return err + } + if in.Items != nil { + out.Items = make([]LimitRange, len(in.Items)) + for i := range in.Items { + if err := deepCopy_v1_LimitRange(in.Items[i], &out.Items[i], c); err != nil { + return err + } + } + } else { + out.Items = nil + } + return nil +} + +func deepCopy_v1_LimitRangeSpec(in LimitRangeSpec, out *LimitRangeSpec, c *conversion.Cloner) error { + if in.Limits != nil { + out.Limits = make([]LimitRangeItem, len(in.Limits)) + for i := range in.Limits { + if err := deepCopy_v1_LimitRangeItem(in.Limits[i], &out.Limits[i], c); err != nil { + return err + } + } + } else { + out.Limits = nil + } + return nil +} + +func deepCopy_v1_List(in List, out *List, c *conversion.Cloner) error { + if err := deepCopy_v1_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_v1_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil { + return err + } + if in.Items != nil { + out.Items = make([]runtime.RawExtension, len(in.Items)) + for i := range in.Items { + if err := deepCopy_runtime_RawExtension(in.Items[i], &out.Items[i], c); err != nil { + return err + } + } + } else { + out.Items = nil + } + return nil +} + +func deepCopy_v1_ListMeta(in ListMeta, out *ListMeta, c *conversion.Cloner) error { + out.SelfLink = in.SelfLink + out.ResourceVersion = in.ResourceVersion + return nil +} + +func deepCopy_v1_ListOptions(in ListOptions, out *ListOptions, c *conversion.Cloner) error { + if err := deepCopy_v1_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + out.LabelSelector = in.LabelSelector + out.FieldSelector = in.FieldSelector + out.Watch = in.Watch + out.ResourceVersion = in.ResourceVersion + return nil +} + +func deepCopy_v1_LoadBalancerIngress(in LoadBalancerIngress, out *LoadBalancerIngress, c *conversion.Cloner) error { + out.IP = in.IP + out.Hostname = in.Hostname + return nil +} + +func deepCopy_v1_LoadBalancerStatus(in LoadBalancerStatus, out *LoadBalancerStatus, c *conversion.Cloner) error { + if in.Ingress != nil { + out.Ingress = make([]LoadBalancerIngress, len(in.Ingress)) + for i := range in.Ingress { + if err := deepCopy_v1_LoadBalancerIngress(in.Ingress[i], &out.Ingress[i], c); err != nil { + return err + } + } + } else { + out.Ingress = nil + } + return nil +} + +func deepCopy_v1_LocalObjectReference(in LocalObjectReference, out *LocalObjectReference, c *conversion.Cloner) error { + out.Name = in.Name + return nil +} + +func deepCopy_v1_NFSVolumeSource(in NFSVolumeSource, out *NFSVolumeSource, c *conversion.Cloner) error { + out.Server = in.Server + out.Path = in.Path + out.ReadOnly = in.ReadOnly + return nil +} + +func deepCopy_v1_Namespace(in Namespace, out *Namespace, c *conversion.Cloner) error { + if err := deepCopy_v1_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_v1_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil { + return err + } + if err := deepCopy_v1_NamespaceSpec(in.Spec, &out.Spec, c); err != nil { + return err + } + if err := deepCopy_v1_NamespaceStatus(in.Status, &out.Status, c); err != nil { + return err + } + return nil +} + +func deepCopy_v1_NamespaceList(in NamespaceList, out *NamespaceList, c *conversion.Cloner) error { + if err := deepCopy_v1_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_v1_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil { + return err + } + if in.Items != nil { + out.Items = make([]Namespace, len(in.Items)) + for i := range in.Items { + if err := deepCopy_v1_Namespace(in.Items[i], &out.Items[i], c); err != nil { + return err + } + } + } else { + out.Items = nil + } + return nil +} + +func deepCopy_v1_NamespaceSpec(in NamespaceSpec, out *NamespaceSpec, c *conversion.Cloner) error { + if in.Finalizers != nil { + out.Finalizers = make([]FinalizerName, len(in.Finalizers)) + for i := range in.Finalizers { + out.Finalizers[i] = in.Finalizers[i] + } + } else { + out.Finalizers = nil + } + return nil +} + +func deepCopy_v1_NamespaceStatus(in NamespaceStatus, out *NamespaceStatus, c *conversion.Cloner) error { + out.Phase = in.Phase + return nil +} + +func deepCopy_v1_Node(in Node, out *Node, c *conversion.Cloner) error { + if err := deepCopy_v1_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_v1_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil { + return err + } + if err := deepCopy_v1_NodeSpec(in.Spec, &out.Spec, c); err != nil { + return err + } + if err := deepCopy_v1_NodeStatus(in.Status, &out.Status, c); err != nil { + return err + } + return nil +} + +func deepCopy_v1_NodeAddress(in NodeAddress, out *NodeAddress, c *conversion.Cloner) error { + out.Type = in.Type + out.Address = in.Address + return nil +} + +func deepCopy_v1_NodeCondition(in NodeCondition, out *NodeCondition, c *conversion.Cloner) error { + out.Type = in.Type + out.Status = in.Status + if err := deepCopy_util_Time(in.LastHeartbeatTime, &out.LastHeartbeatTime, c); err != nil { + return err + } + if err := deepCopy_util_Time(in.LastTransitionTime, &out.LastTransitionTime, c); err != nil { + return err + } + out.Reason = in.Reason + out.Message = in.Message + return nil +} + +func deepCopy_v1_NodeList(in NodeList, out *NodeList, c *conversion.Cloner) error { + if err := deepCopy_v1_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_v1_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil { + return err + } + if in.Items != nil { + out.Items = make([]Node, len(in.Items)) + for i := range in.Items { + if err := deepCopy_v1_Node(in.Items[i], &out.Items[i], c); err != nil { + return err + } + } + } else { + out.Items = nil + } + return nil +} + +func deepCopy_v1_NodeSpec(in NodeSpec, out *NodeSpec, c *conversion.Cloner) error { + out.PodCIDR = in.PodCIDR + out.ExternalID = in.ExternalID + out.Unschedulable = in.Unschedulable + return nil +} + +func deepCopy_v1_NodeStatus(in NodeStatus, out *NodeStatus, c *conversion.Cloner) error { + if in.Capacity != nil { + out.Capacity = make(map[ResourceName]resource.Quantity) + for key, val := range in.Capacity { + newVal := new(resource.Quantity) + if err := deepCopy_resource_Quantity(val, newVal, c); err != nil { + return err + } + out.Capacity[key] = *newVal + } + } else { + out.Capacity = nil + } + out.Phase = in.Phase + if in.Conditions != nil { + out.Conditions = make([]NodeCondition, len(in.Conditions)) + for i := range in.Conditions { + if err := deepCopy_v1_NodeCondition(in.Conditions[i], &out.Conditions[i], c); err != nil { + return err + } + } + } else { + out.Conditions = nil + } + if in.Addresses != nil { + out.Addresses = make([]NodeAddress, len(in.Addresses)) + for i := range in.Addresses { + if err := deepCopy_v1_NodeAddress(in.Addresses[i], &out.Addresses[i], c); err != nil { + return err + } + } + } else { + out.Addresses = nil + } + if err := deepCopy_v1_NodeSystemInfo(in.NodeInfo, &out.NodeInfo, c); err != nil { + return err + } + return nil +} + +func deepCopy_v1_NodeSystemInfo(in NodeSystemInfo, out *NodeSystemInfo, c *conversion.Cloner) 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 deepCopy_v1_ObjectFieldSelector(in ObjectFieldSelector, out *ObjectFieldSelector, c *conversion.Cloner) error { + out.APIVersion = in.APIVersion + out.FieldPath = in.FieldPath + return nil +} + +func deepCopy_v1_ObjectMeta(in ObjectMeta, out *ObjectMeta, c *conversion.Cloner) 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 := deepCopy_util_Time(in.CreationTimestamp, &out.CreationTimestamp, c); err != nil { + return err + } + if in.DeletionTimestamp != nil { + out.DeletionTimestamp = new(util.Time) + if err := deepCopy_util_Time(*in.DeletionTimestamp, out.DeletionTimestamp, c); err != nil { + return err + } + } else { + out.DeletionTimestamp = nil + } + if in.Labels != nil { + out.Labels = make(map[string]string) + for key, val := range in.Labels { + out.Labels[key] = val + } + } else { + out.Labels = nil + } + if in.Annotations != nil { + out.Annotations = make(map[string]string) + for key, val := range in.Annotations { + out.Annotations[key] = val + } + } else { + out.Annotations = nil + } + return nil +} + +func deepCopy_v1_ObjectReference(in ObjectReference, out *ObjectReference, c *conversion.Cloner) 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 deepCopy_v1_PersistentVolume(in PersistentVolume, out *PersistentVolume, c *conversion.Cloner) error { + if err := deepCopy_v1_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_v1_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil { + return err + } + if err := deepCopy_v1_PersistentVolumeSpec(in.Spec, &out.Spec, c); err != nil { + return err + } + if err := deepCopy_v1_PersistentVolumeStatus(in.Status, &out.Status, c); err != nil { + return err + } + return nil +} + +func deepCopy_v1_PersistentVolumeClaim(in PersistentVolumeClaim, out *PersistentVolumeClaim, c *conversion.Cloner) error { + if err := deepCopy_v1_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_v1_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil { + return err + } + if err := deepCopy_v1_PersistentVolumeClaimSpec(in.Spec, &out.Spec, c); err != nil { + return err + } + if err := deepCopy_v1_PersistentVolumeClaimStatus(in.Status, &out.Status, c); err != nil { + return err + } + return nil +} + +func deepCopy_v1_PersistentVolumeClaimList(in PersistentVolumeClaimList, out *PersistentVolumeClaimList, c *conversion.Cloner) error { + if err := deepCopy_v1_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_v1_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil { + return err + } + if in.Items != nil { + out.Items = make([]PersistentVolumeClaim, len(in.Items)) + for i := range in.Items { + if err := deepCopy_v1_PersistentVolumeClaim(in.Items[i], &out.Items[i], c); err != nil { + return err + } + } + } else { + out.Items = nil + } + return nil +} + +func deepCopy_v1_PersistentVolumeClaimSpec(in PersistentVolumeClaimSpec, out *PersistentVolumeClaimSpec, c *conversion.Cloner) error { + if in.AccessModes != nil { + out.AccessModes = make([]PersistentVolumeAccessMode, len(in.AccessModes)) + for i := range in.AccessModes { + out.AccessModes[i] = in.AccessModes[i] + } + } else { + out.AccessModes = nil + } + if err := deepCopy_v1_ResourceRequirements(in.Resources, &out.Resources, c); err != nil { + return err + } + out.VolumeName = in.VolumeName + return nil +} + +func deepCopy_v1_PersistentVolumeClaimStatus(in PersistentVolumeClaimStatus, out *PersistentVolumeClaimStatus, c *conversion.Cloner) error { + out.Phase = in.Phase + if in.AccessModes != nil { + out.AccessModes = make([]PersistentVolumeAccessMode, len(in.AccessModes)) + for i := range in.AccessModes { + out.AccessModes[i] = in.AccessModes[i] + } + } else { + out.AccessModes = nil + } + if in.Capacity != nil { + out.Capacity = make(map[ResourceName]resource.Quantity) + for key, val := range in.Capacity { + newVal := new(resource.Quantity) + if err := deepCopy_resource_Quantity(val, newVal, c); err != nil { + return err + } + out.Capacity[key] = *newVal + } + } else { + out.Capacity = nil + } + return nil +} + +func deepCopy_v1_PersistentVolumeClaimVolumeSource(in PersistentVolumeClaimVolumeSource, out *PersistentVolumeClaimVolumeSource, c *conversion.Cloner) error { + out.ClaimName = in.ClaimName + out.ReadOnly = in.ReadOnly + return nil +} + +func deepCopy_v1_PersistentVolumeList(in PersistentVolumeList, out *PersistentVolumeList, c *conversion.Cloner) error { + if err := deepCopy_v1_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_v1_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil { + return err + } + if in.Items != nil { + out.Items = make([]PersistentVolume, len(in.Items)) + for i := range in.Items { + if err := deepCopy_v1_PersistentVolume(in.Items[i], &out.Items[i], c); err != nil { + return err + } + } + } else { + out.Items = nil + } + return nil +} + +func deepCopy_v1_PersistentVolumeSource(in PersistentVolumeSource, out *PersistentVolumeSource, c *conversion.Cloner) error { + if in.GCEPersistentDisk != nil { + out.GCEPersistentDisk = new(GCEPersistentDiskVolumeSource) + if err := deepCopy_v1_GCEPersistentDiskVolumeSource(*in.GCEPersistentDisk, out.GCEPersistentDisk, c); err != nil { + return err + } + } else { + out.GCEPersistentDisk = nil + } + if in.AWSElasticBlockStore != nil { + out.AWSElasticBlockStore = new(AWSElasticBlockStoreVolumeSource) + if err := deepCopy_v1_AWSElasticBlockStoreVolumeSource(*in.AWSElasticBlockStore, out.AWSElasticBlockStore, c); err != nil { + return err + } + } else { + out.AWSElasticBlockStore = nil + } + if in.HostPath != nil { + out.HostPath = new(HostPathVolumeSource) + if err := deepCopy_v1_HostPathVolumeSource(*in.HostPath, out.HostPath, c); err != nil { + return err + } + } else { + out.HostPath = nil + } + if in.Glusterfs != nil { + out.Glusterfs = new(GlusterfsVolumeSource) + if err := deepCopy_v1_GlusterfsVolumeSource(*in.Glusterfs, out.Glusterfs, c); err != nil { + return err + } + } else { + out.Glusterfs = nil + } + if in.NFS != nil { + out.NFS = new(NFSVolumeSource) + if err := deepCopy_v1_NFSVolumeSource(*in.NFS, out.NFS, c); err != nil { + return err + } + } else { + out.NFS = nil + } + if in.RBD != nil { + out.RBD = new(RBDVolumeSource) + if err := deepCopy_v1_RBDVolumeSource(*in.RBD, out.RBD, c); err != nil { + return err + } + } else { + out.RBD = nil + } + return nil +} + +func deepCopy_v1_PersistentVolumeSpec(in PersistentVolumeSpec, out *PersistentVolumeSpec, c *conversion.Cloner) error { + if in.Capacity != nil { + out.Capacity = make(map[ResourceName]resource.Quantity) + for key, val := range in.Capacity { + newVal := new(resource.Quantity) + if err := deepCopy_resource_Quantity(val, newVal, c); err != nil { + return err + } + out.Capacity[key] = *newVal + } + } else { + out.Capacity = nil + } + if err := deepCopy_v1_PersistentVolumeSource(in.PersistentVolumeSource, &out.PersistentVolumeSource, c); err != nil { + return err + } + if in.AccessModes != nil { + out.AccessModes = make([]PersistentVolumeAccessMode, len(in.AccessModes)) + for i := range in.AccessModes { + out.AccessModes[i] = in.AccessModes[i] + } + } else { + out.AccessModes = nil + } + if in.ClaimRef != nil { + out.ClaimRef = new(ObjectReference) + if err := deepCopy_v1_ObjectReference(*in.ClaimRef, out.ClaimRef, c); err != nil { + return err + } + } else { + out.ClaimRef = nil + } + return nil +} + +func deepCopy_v1_PersistentVolumeStatus(in PersistentVolumeStatus, out *PersistentVolumeStatus, c *conversion.Cloner) error { + out.Phase = in.Phase + return nil +} + +func deepCopy_v1_Pod(in Pod, out *Pod, c *conversion.Cloner) error { + if err := deepCopy_v1_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_v1_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil { + return err + } + if err := deepCopy_v1_PodSpec(in.Spec, &out.Spec, c); err != nil { + return err + } + if err := deepCopy_v1_PodStatus(in.Status, &out.Status, c); err != nil { + return err + } + return nil +} + +func deepCopy_v1_PodCondition(in PodCondition, out *PodCondition, c *conversion.Cloner) error { + out.Type = in.Type + out.Status = in.Status + return nil +} + +func deepCopy_v1_PodExecOptions(in PodExecOptions, out *PodExecOptions, c *conversion.Cloner) error { + if err := deepCopy_v1_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + out.Stdin = in.Stdin + out.Stdout = in.Stdout + out.Stderr = in.Stderr + out.TTY = in.TTY + out.Container = in.Container + if in.Command != nil { + out.Command = make([]string, len(in.Command)) + for i := range in.Command { + out.Command[i] = in.Command[i] + } + } else { + out.Command = nil + } + return nil +} + +func deepCopy_v1_PodList(in PodList, out *PodList, c *conversion.Cloner) error { + if err := deepCopy_v1_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_v1_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil { + return err + } + if in.Items != nil { + out.Items = make([]Pod, len(in.Items)) + for i := range in.Items { + if err := deepCopy_v1_Pod(in.Items[i], &out.Items[i], c); err != nil { + return err + } + } + } else { + out.Items = nil + } + return nil +} + +func deepCopy_v1_PodLogOptions(in PodLogOptions, out *PodLogOptions, c *conversion.Cloner) error { + if err := deepCopy_v1_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + out.Container = in.Container + out.Follow = in.Follow + out.Previous = in.Previous + return nil +} + +func deepCopy_v1_PodProxyOptions(in PodProxyOptions, out *PodProxyOptions, c *conversion.Cloner) error { + if err := deepCopy_v1_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + out.Path = in.Path + return nil +} + +func deepCopy_v1_PodSpec(in PodSpec, out *PodSpec, c *conversion.Cloner) error { + if in.Volumes != nil { + out.Volumes = make([]Volume, len(in.Volumes)) + for i := range in.Volumes { + if err := deepCopy_v1_Volume(in.Volumes[i], &out.Volumes[i], c); err != nil { + return err + } + } + } else { + out.Volumes = nil + } + if in.Containers != nil { + out.Containers = make([]Container, len(in.Containers)) + for i := range in.Containers { + if err := deepCopy_v1_Container(in.Containers[i], &out.Containers[i], c); err != nil { + return err + } + } + } else { + out.Containers = nil + } + out.RestartPolicy = in.RestartPolicy + if in.TerminationGracePeriodSeconds != nil { + out.TerminationGracePeriodSeconds = new(int64) + *out.TerminationGracePeriodSeconds = *in.TerminationGracePeriodSeconds + } else { + out.TerminationGracePeriodSeconds = nil + } + if in.ActiveDeadlineSeconds != nil { + out.ActiveDeadlineSeconds = new(int64) + *out.ActiveDeadlineSeconds = *in.ActiveDeadlineSeconds + } else { + out.ActiveDeadlineSeconds = nil + } + out.DNSPolicy = in.DNSPolicy + if in.NodeSelector != nil { + out.NodeSelector = make(map[string]string) + for key, val := range in.NodeSelector { + out.NodeSelector[key] = val + } + } else { + out.NodeSelector = nil + } + out.ServiceAccount = in.ServiceAccount + out.Host = in.Host + out.HostNetwork = in.HostNetwork + if in.ImagePullSecrets != nil { + out.ImagePullSecrets = make([]LocalObjectReference, len(in.ImagePullSecrets)) + for i := range in.ImagePullSecrets { + if err := deepCopy_v1_LocalObjectReference(in.ImagePullSecrets[i], &out.ImagePullSecrets[i], c); err != nil { + return err + } + } + } else { + out.ImagePullSecrets = nil + } + return nil +} + +func deepCopy_v1_PodStatus(in PodStatus, out *PodStatus, c *conversion.Cloner) error { + out.Phase = in.Phase + if in.Conditions != nil { + out.Conditions = make([]PodCondition, len(in.Conditions)) + for i := range in.Conditions { + if err := deepCopy_v1_PodCondition(in.Conditions[i], &out.Conditions[i], c); err != nil { + return err + } + } + } else { + out.Conditions = nil + } + out.Message = in.Message + out.HostIP = in.HostIP + out.PodIP = in.PodIP + if in.StartTime != nil { + out.StartTime = new(util.Time) + if err := deepCopy_util_Time(*in.StartTime, out.StartTime, c); err != nil { + return err + } + } else { + out.StartTime = nil + } + if in.ContainerStatuses != nil { + out.ContainerStatuses = make([]ContainerStatus, len(in.ContainerStatuses)) + for i := range in.ContainerStatuses { + if err := deepCopy_v1_ContainerStatus(in.ContainerStatuses[i], &out.ContainerStatuses[i], c); err != nil { + return err + } + } + } else { + out.ContainerStatuses = nil + } + return nil +} + +func deepCopy_v1_PodStatusResult(in PodStatusResult, out *PodStatusResult, c *conversion.Cloner) error { + if err := deepCopy_v1_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_v1_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil { + return err + } + if err := deepCopy_v1_PodStatus(in.Status, &out.Status, c); err != nil { + return err + } + return nil +} + +func deepCopy_v1_PodTemplate(in PodTemplate, out *PodTemplate, c *conversion.Cloner) error { + if err := deepCopy_v1_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_v1_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil { + return err + } + if err := deepCopy_v1_PodTemplateSpec(in.Template, &out.Template, c); err != nil { + return err + } + return nil +} + +func deepCopy_v1_PodTemplateList(in PodTemplateList, out *PodTemplateList, c *conversion.Cloner) error { + if err := deepCopy_v1_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_v1_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil { + return err + } + if in.Items != nil { + out.Items = make([]PodTemplate, len(in.Items)) + for i := range in.Items { + if err := deepCopy_v1_PodTemplate(in.Items[i], &out.Items[i], c); err != nil { + return err + } + } + } else { + out.Items = nil + } + return nil +} + +func deepCopy_v1_PodTemplateSpec(in PodTemplateSpec, out *PodTemplateSpec, c *conversion.Cloner) error { + if err := deepCopy_v1_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil { + return err + } + if err := deepCopy_v1_PodSpec(in.Spec, &out.Spec, c); err != nil { + return err + } + return nil +} + +func deepCopy_v1_Probe(in Probe, out *Probe, c *conversion.Cloner) error { + if err := deepCopy_v1_Handler(in.Handler, &out.Handler, c); err != nil { + return err + } + out.InitialDelaySeconds = in.InitialDelaySeconds + out.TimeoutSeconds = in.TimeoutSeconds + return nil +} + +func deepCopy_v1_RBDVolumeSource(in RBDVolumeSource, out *RBDVolumeSource, c *conversion.Cloner) error { + if in.CephMonitors != nil { + out.CephMonitors = make([]string, len(in.CephMonitors)) + for i := range in.CephMonitors { + out.CephMonitors[i] = in.CephMonitors[i] + } + } else { + out.CephMonitors = nil + } + out.RBDImage = in.RBDImage + out.FSType = in.FSType + out.RBDPool = in.RBDPool + out.RadosUser = in.RadosUser + out.Keyring = in.Keyring + if in.SecretRef != nil { + out.SecretRef = new(LocalObjectReference) + if err := deepCopy_v1_LocalObjectReference(*in.SecretRef, out.SecretRef, c); err != nil { + return err + } + } else { + out.SecretRef = nil + } + out.ReadOnly = in.ReadOnly + return nil +} + +func deepCopy_v1_RangeAllocation(in RangeAllocation, out *RangeAllocation, c *conversion.Cloner) error { + if err := deepCopy_v1_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_v1_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil { + return err + } + out.Range = in.Range + if in.Data != nil { + out.Data = make([]uint8, len(in.Data)) + for i := range in.Data { + out.Data[i] = in.Data[i] + } + } else { + out.Data = nil + } + return nil +} + +func deepCopy_v1_ReplicationController(in ReplicationController, out *ReplicationController, c *conversion.Cloner) error { + if err := deepCopy_v1_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_v1_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil { + return err + } + if err := deepCopy_v1_ReplicationControllerSpec(in.Spec, &out.Spec, c); err != nil { + return err + } + if err := deepCopy_v1_ReplicationControllerStatus(in.Status, &out.Status, c); err != nil { + return err + } + return nil +} + +func deepCopy_v1_ReplicationControllerList(in ReplicationControllerList, out *ReplicationControllerList, c *conversion.Cloner) error { + if err := deepCopy_v1_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_v1_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil { + return err + } + if in.Items != nil { + out.Items = make([]ReplicationController, len(in.Items)) + for i := range in.Items { + if err := deepCopy_v1_ReplicationController(in.Items[i], &out.Items[i], c); err != nil { + return err + } + } + } else { + out.Items = nil + } + return nil +} + +func deepCopy_v1_ReplicationControllerSpec(in ReplicationControllerSpec, out *ReplicationControllerSpec, c *conversion.Cloner) error { + if in.Replicas != nil { + out.Replicas = new(int) + *out.Replicas = *in.Replicas + } else { + out.Replicas = nil + } + if in.Selector != nil { + out.Selector = make(map[string]string) + for key, val := range in.Selector { + out.Selector[key] = val + } + } else { + out.Selector = nil + } + if in.TemplateRef != nil { + out.TemplateRef = new(ObjectReference) + if err := deepCopy_v1_ObjectReference(*in.TemplateRef, out.TemplateRef, c); err != nil { + return err + } + } else { + out.TemplateRef = nil + } + if in.Template != nil { + out.Template = new(PodTemplateSpec) + if err := deepCopy_v1_PodTemplateSpec(*in.Template, out.Template, c); err != nil { + return err + } + } else { + out.Template = nil + } + return nil +} + +func deepCopy_v1_ReplicationControllerStatus(in ReplicationControllerStatus, out *ReplicationControllerStatus, c *conversion.Cloner) error { + out.Replicas = in.Replicas + return nil +} + +func deepCopy_v1_ResourceQuota(in ResourceQuota, out *ResourceQuota, c *conversion.Cloner) error { + if err := deepCopy_v1_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_v1_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil { + return err + } + if err := deepCopy_v1_ResourceQuotaSpec(in.Spec, &out.Spec, c); err != nil { + return err + } + if err := deepCopy_v1_ResourceQuotaStatus(in.Status, &out.Status, c); err != nil { + return err + } + return nil +} + +func deepCopy_v1_ResourceQuotaList(in ResourceQuotaList, out *ResourceQuotaList, c *conversion.Cloner) error { + if err := deepCopy_v1_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_v1_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil { + return err + } + if in.Items != nil { + out.Items = make([]ResourceQuota, len(in.Items)) + for i := range in.Items { + if err := deepCopy_v1_ResourceQuota(in.Items[i], &out.Items[i], c); err != nil { + return err + } + } + } else { + out.Items = nil + } + return nil +} + +func deepCopy_v1_ResourceQuotaSpec(in ResourceQuotaSpec, out *ResourceQuotaSpec, c *conversion.Cloner) error { + if in.Hard != nil { + out.Hard = make(map[ResourceName]resource.Quantity) + for key, val := range in.Hard { + newVal := new(resource.Quantity) + if err := deepCopy_resource_Quantity(val, newVal, c); err != nil { + return err + } + out.Hard[key] = *newVal + } + } else { + out.Hard = nil + } + return nil +} + +func deepCopy_v1_ResourceQuotaStatus(in ResourceQuotaStatus, out *ResourceQuotaStatus, c *conversion.Cloner) error { + if in.Hard != nil { + out.Hard = make(map[ResourceName]resource.Quantity) + for key, val := range in.Hard { + newVal := new(resource.Quantity) + if err := deepCopy_resource_Quantity(val, newVal, c); err != nil { + return err + } + out.Hard[key] = *newVal + } + } else { + out.Hard = nil + } + if in.Used != nil { + out.Used = make(map[ResourceName]resource.Quantity) + for key, val := range in.Used { + newVal := new(resource.Quantity) + if err := deepCopy_resource_Quantity(val, newVal, c); err != nil { + return err + } + out.Used[key] = *newVal + } + } else { + out.Used = nil + } + return nil +} + +func deepCopy_v1_ResourceRequirements(in ResourceRequirements, out *ResourceRequirements, c *conversion.Cloner) error { + if in.Limits != nil { + out.Limits = make(map[ResourceName]resource.Quantity) + for key, val := range in.Limits { + newVal := new(resource.Quantity) + if err := deepCopy_resource_Quantity(val, newVal, c); err != nil { + return err + } + out.Limits[key] = *newVal + } + } else { + out.Limits = nil + } + if in.Requests != nil { + out.Requests = make(map[ResourceName]resource.Quantity) + for key, val := range in.Requests { + newVal := new(resource.Quantity) + if err := deepCopy_resource_Quantity(val, newVal, c); err != nil { + return err + } + out.Requests[key] = *newVal + } + } else { + out.Requests = nil + } + return nil +} + +func deepCopy_v1_SELinuxOptions(in SELinuxOptions, out *SELinuxOptions, c *conversion.Cloner) error { + out.User = in.User + out.Role = in.Role + out.Type = in.Type + out.Level = in.Level + return nil +} + +func deepCopy_v1_Secret(in Secret, out *Secret, c *conversion.Cloner) error { + if err := deepCopy_v1_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_v1_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil { + return err + } + if in.Data != nil { + out.Data = make(map[string][]uint8) + for key, val := range in.Data { + if newVal, err := c.DeepCopy(val); err != nil { + return err + } else { + out.Data[key] = newVal.([]uint8) + } + } + } else { + out.Data = nil + } + out.Type = in.Type + return nil +} + +func deepCopy_v1_SecretList(in SecretList, out *SecretList, c *conversion.Cloner) error { + if err := deepCopy_v1_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_v1_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil { + return err + } + if in.Items != nil { + out.Items = make([]Secret, len(in.Items)) + for i := range in.Items { + if err := deepCopy_v1_Secret(in.Items[i], &out.Items[i], c); err != nil { + return err + } + } + } else { + out.Items = nil + } + return nil +} + +func deepCopy_v1_SecretVolumeSource(in SecretVolumeSource, out *SecretVolumeSource, c *conversion.Cloner) error { + out.SecretName = in.SecretName + return nil +} + +func deepCopy_v1_SecurityContext(in SecurityContext, out *SecurityContext, c *conversion.Cloner) error { + if in.Capabilities != nil { + out.Capabilities = new(Capabilities) + if err := deepCopy_v1_Capabilities(*in.Capabilities, out.Capabilities, c); err != nil { + return err + } + } else { + out.Capabilities = nil + } + if in.Privileged != nil { + out.Privileged = new(bool) + *out.Privileged = *in.Privileged + } else { + out.Privileged = nil + } + if in.SELinuxOptions != nil { + out.SELinuxOptions = new(SELinuxOptions) + if err := deepCopy_v1_SELinuxOptions(*in.SELinuxOptions, out.SELinuxOptions, c); err != nil { + return err + } + } else { + out.SELinuxOptions = nil + } + if in.RunAsUser != nil { + out.RunAsUser = new(int64) + *out.RunAsUser = *in.RunAsUser + } else { + out.RunAsUser = nil + } + return nil +} + +func deepCopy_v1_SerializedReference(in SerializedReference, out *SerializedReference, c *conversion.Cloner) error { + if err := deepCopy_v1_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_v1_ObjectReference(in.Reference, &out.Reference, c); err != nil { + return err + } + return nil +} + +func deepCopy_v1_Service(in Service, out *Service, c *conversion.Cloner) error { + if err := deepCopy_v1_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_v1_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil { + return err + } + if err := deepCopy_v1_ServiceSpec(in.Spec, &out.Spec, c); err != nil { + return err + } + if err := deepCopy_v1_ServiceStatus(in.Status, &out.Status, c); err != nil { + return err + } + return nil +} + +func deepCopy_v1_ServiceAccount(in ServiceAccount, out *ServiceAccount, c *conversion.Cloner) error { + if err := deepCopy_v1_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_v1_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil { + return err + } + if in.Secrets != nil { + out.Secrets = make([]ObjectReference, len(in.Secrets)) + for i := range in.Secrets { + if err := deepCopy_v1_ObjectReference(in.Secrets[i], &out.Secrets[i], c); err != nil { + return err + } + } + } else { + out.Secrets = nil + } + return nil +} + +func deepCopy_v1_ServiceAccountList(in ServiceAccountList, out *ServiceAccountList, c *conversion.Cloner) error { + if err := deepCopy_v1_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_v1_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil { + return err + } + if in.Items != nil { + out.Items = make([]ServiceAccount, len(in.Items)) + for i := range in.Items { + if err := deepCopy_v1_ServiceAccount(in.Items[i], &out.Items[i], c); err != nil { + return err + } + } + } else { + out.Items = nil + } + return nil +} + +func deepCopy_v1_ServiceList(in ServiceList, out *ServiceList, c *conversion.Cloner) error { + if err := deepCopy_v1_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_v1_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil { + return err + } + if in.Items != nil { + out.Items = make([]Service, len(in.Items)) + for i := range in.Items { + if err := deepCopy_v1_Service(in.Items[i], &out.Items[i], c); err != nil { + return err + } + } + } else { + out.Items = nil + } + return nil +} + +func deepCopy_v1_ServicePort(in ServicePort, out *ServicePort, c *conversion.Cloner) error { + out.Name = in.Name + out.Protocol = in.Protocol + out.Port = in.Port + if err := deepCopy_util_IntOrString(in.TargetPort, &out.TargetPort, c); err != nil { + return err + } + out.NodePort = in.NodePort + return nil +} + +func deepCopy_v1_ServiceSpec(in ServiceSpec, out *ServiceSpec, c *conversion.Cloner) error { + if in.Ports != nil { + out.Ports = make([]ServicePort, len(in.Ports)) + for i := range in.Ports { + if err := deepCopy_v1_ServicePort(in.Ports[i], &out.Ports[i], c); err != nil { + return err + } + } + } else { + out.Ports = nil + } + if in.Selector != nil { + out.Selector = make(map[string]string) + for key, val := range in.Selector { + out.Selector[key] = val + } + } else { + out.Selector = nil + } + out.PortalIP = in.PortalIP + out.Type = in.Type + if in.DeprecatedPublicIPs != nil { + out.DeprecatedPublicIPs = make([]string, len(in.DeprecatedPublicIPs)) + for i := range in.DeprecatedPublicIPs { + out.DeprecatedPublicIPs[i] = in.DeprecatedPublicIPs[i] + } + } else { + out.DeprecatedPublicIPs = nil + } + out.SessionAffinity = in.SessionAffinity + return nil +} + +func deepCopy_v1_ServiceStatus(in ServiceStatus, out *ServiceStatus, c *conversion.Cloner) error { + if err := deepCopy_v1_LoadBalancerStatus(in.LoadBalancer, &out.LoadBalancer, c); err != nil { + return err + } + return nil +} + +func deepCopy_v1_Status(in Status, out *Status, c *conversion.Cloner) error { + if err := deepCopy_v1_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_v1_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil { + return err + } + out.Status = in.Status + out.Message = in.Message + out.Reason = in.Reason + if in.Details != nil { + out.Details = new(StatusDetails) + if err := deepCopy_v1_StatusDetails(*in.Details, out.Details, c); err != nil { + return err + } + } else { + out.Details = nil + } + out.Code = in.Code + return nil +} + +func deepCopy_v1_StatusCause(in StatusCause, out *StatusCause, c *conversion.Cloner) error { + out.Type = in.Type + out.Message = in.Message + out.Field = in.Field + return nil +} + +func deepCopy_v1_StatusDetails(in StatusDetails, out *StatusDetails, c *conversion.Cloner) error { + out.Name = in.Name + out.Kind = in.Kind + if in.Causes != nil { + out.Causes = make([]StatusCause, len(in.Causes)) + for i := range in.Causes { + if err := deepCopy_v1_StatusCause(in.Causes[i], &out.Causes[i], c); err != nil { + return err + } + } + } else { + out.Causes = nil + } + out.RetryAfterSeconds = in.RetryAfterSeconds + return nil +} + +func deepCopy_v1_TCPSocketAction(in TCPSocketAction, out *TCPSocketAction, c *conversion.Cloner) error { + if err := deepCopy_util_IntOrString(in.Port, &out.Port, c); err != nil { + return err + } + return nil +} + +func deepCopy_v1_TypeMeta(in TypeMeta, out *TypeMeta, c *conversion.Cloner) error { + out.Kind = in.Kind + out.APIVersion = in.APIVersion + return nil +} + +func deepCopy_v1_Volume(in Volume, out *Volume, c *conversion.Cloner) error { + out.Name = in.Name + if err := deepCopy_v1_VolumeSource(in.VolumeSource, &out.VolumeSource, c); err != nil { + return err + } + return nil +} + +func deepCopy_v1_VolumeMount(in VolumeMount, out *VolumeMount, c *conversion.Cloner) error { + out.Name = in.Name + out.ReadOnly = in.ReadOnly + out.MountPath = in.MountPath + return nil +} + +func deepCopy_v1_VolumeSource(in VolumeSource, out *VolumeSource, c *conversion.Cloner) error { + if in.HostPath != nil { + out.HostPath = new(HostPathVolumeSource) + if err := deepCopy_v1_HostPathVolumeSource(*in.HostPath, out.HostPath, c); err != nil { + return err + } + } else { + out.HostPath = nil + } + if in.EmptyDir != nil { + out.EmptyDir = new(EmptyDirVolumeSource) + if err := deepCopy_v1_EmptyDirVolumeSource(*in.EmptyDir, out.EmptyDir, c); err != nil { + return err + } + } else { + out.EmptyDir = nil + } + if in.GCEPersistentDisk != nil { + out.GCEPersistentDisk = new(GCEPersistentDiskVolumeSource) + if err := deepCopy_v1_GCEPersistentDiskVolumeSource(*in.GCEPersistentDisk, out.GCEPersistentDisk, c); err != nil { + return err + } + } else { + out.GCEPersistentDisk = nil + } + if in.AWSElasticBlockStore != nil { + out.AWSElasticBlockStore = new(AWSElasticBlockStoreVolumeSource) + if err := deepCopy_v1_AWSElasticBlockStoreVolumeSource(*in.AWSElasticBlockStore, out.AWSElasticBlockStore, c); err != nil { + return err + } + } else { + out.AWSElasticBlockStore = nil + } + if in.GitRepo != nil { + out.GitRepo = new(GitRepoVolumeSource) + if err := deepCopy_v1_GitRepoVolumeSource(*in.GitRepo, out.GitRepo, c); err != nil { + return err + } + } else { + out.GitRepo = nil + } + if in.Secret != nil { + out.Secret = new(SecretVolumeSource) + if err := deepCopy_v1_SecretVolumeSource(*in.Secret, out.Secret, c); err != nil { + return err + } + } else { + out.Secret = nil + } + if in.NFS != nil { + out.NFS = new(NFSVolumeSource) + if err := deepCopy_v1_NFSVolumeSource(*in.NFS, out.NFS, c); err != nil { + return err + } + } else { + out.NFS = nil + } + if in.ISCSI != nil { + out.ISCSI = new(ISCSIVolumeSource) + if err := deepCopy_v1_ISCSIVolumeSource(*in.ISCSI, out.ISCSI, c); err != nil { + return err + } + } else { + out.ISCSI = nil + } + if in.Glusterfs != nil { + out.Glusterfs = new(GlusterfsVolumeSource) + if err := deepCopy_v1_GlusterfsVolumeSource(*in.Glusterfs, out.Glusterfs, c); err != nil { + return err + } + } else { + out.Glusterfs = nil + } + if in.PersistentVolumeClaimVolumeSource != nil { + out.PersistentVolumeClaimVolumeSource = new(PersistentVolumeClaimVolumeSource) + if err := deepCopy_v1_PersistentVolumeClaimVolumeSource(*in.PersistentVolumeClaimVolumeSource, out.PersistentVolumeClaimVolumeSource, c); err != nil { + return err + } + } else { + out.PersistentVolumeClaimVolumeSource = nil + } + if in.RBD != nil { + out.RBD = new(RBDVolumeSource) + if err := deepCopy_v1_RBDVolumeSource(*in.RBD, out.RBD, c); err != nil { + return err + } + } else { + out.RBD = nil + } + return nil +} + +func deepCopy_runtime_RawExtension(in runtime.RawExtension, out *runtime.RawExtension, c *conversion.Cloner) error { + if in.RawJSON != nil { + out.RawJSON = make([]uint8, len(in.RawJSON)) + for i := range in.RawJSON { + out.RawJSON[i] = in.RawJSON[i] + } + } else { + out.RawJSON = nil + } + return nil +} + +func deepCopy_util_IntOrString(in util.IntOrString, out *util.IntOrString, c *conversion.Cloner) error { + out.Kind = in.Kind + out.IntVal = in.IntVal + out.StrVal = in.StrVal + return nil +} + +func deepCopy_util_Time(in util.Time, out *util.Time, c *conversion.Cloner) error { + if newVal, err := c.DeepCopy(in.Time); err != nil { + return err + } else { + out.Time = newVal.(time.Time) + } + return nil +} + +func init() { + err := api.Scheme.AddGeneratedDeepCopyFuncs( + deepCopy_resource_Quantity, + deepCopy_v1_AWSElasticBlockStoreVolumeSource, + deepCopy_v1_Binding, + deepCopy_v1_Capabilities, + deepCopy_v1_ComponentCondition, + deepCopy_v1_ComponentStatus, + deepCopy_v1_ComponentStatusList, + deepCopy_v1_Container, + deepCopy_v1_ContainerPort, + deepCopy_v1_ContainerState, + deepCopy_v1_ContainerStateRunning, + deepCopy_v1_ContainerStateTerminated, + deepCopy_v1_ContainerStateWaiting, + deepCopy_v1_ContainerStatus, + deepCopy_v1_DeleteOptions, + deepCopy_v1_EmptyDirVolumeSource, + deepCopy_v1_EndpointAddress, + deepCopy_v1_EndpointPort, + deepCopy_v1_EndpointSubset, + deepCopy_v1_Endpoints, + deepCopy_v1_EndpointsList, + deepCopy_v1_EnvVar, + deepCopy_v1_EnvVarSource, + deepCopy_v1_Event, + deepCopy_v1_EventList, + deepCopy_v1_EventSource, + deepCopy_v1_ExecAction, + deepCopy_v1_GCEPersistentDiskVolumeSource, + deepCopy_v1_GitRepoVolumeSource, + deepCopy_v1_GlusterfsVolumeSource, + deepCopy_v1_HTTPGetAction, + deepCopy_v1_Handler, + deepCopy_v1_HostPathVolumeSource, + deepCopy_v1_ISCSIVolumeSource, + deepCopy_v1_Lifecycle, + deepCopy_v1_LimitRange, + deepCopy_v1_LimitRangeItem, + deepCopy_v1_LimitRangeList, + deepCopy_v1_LimitRangeSpec, + deepCopy_v1_List, + deepCopy_v1_ListMeta, + deepCopy_v1_ListOptions, + deepCopy_v1_LoadBalancerIngress, + deepCopy_v1_LoadBalancerStatus, + deepCopy_v1_LocalObjectReference, + deepCopy_v1_NFSVolumeSource, + deepCopy_v1_Namespace, + deepCopy_v1_NamespaceList, + deepCopy_v1_NamespaceSpec, + deepCopy_v1_NamespaceStatus, + deepCopy_v1_Node, + deepCopy_v1_NodeAddress, + deepCopy_v1_NodeCondition, + deepCopy_v1_NodeList, + deepCopy_v1_NodeSpec, + deepCopy_v1_NodeStatus, + deepCopy_v1_NodeSystemInfo, + deepCopy_v1_ObjectFieldSelector, + deepCopy_v1_ObjectMeta, + deepCopy_v1_ObjectReference, + deepCopy_v1_PersistentVolume, + deepCopy_v1_PersistentVolumeClaim, + deepCopy_v1_PersistentVolumeClaimList, + deepCopy_v1_PersistentVolumeClaimSpec, + deepCopy_v1_PersistentVolumeClaimStatus, + deepCopy_v1_PersistentVolumeClaimVolumeSource, + deepCopy_v1_PersistentVolumeList, + deepCopy_v1_PersistentVolumeSource, + deepCopy_v1_PersistentVolumeSpec, + deepCopy_v1_PersistentVolumeStatus, + deepCopy_v1_Pod, + deepCopy_v1_PodCondition, + deepCopy_v1_PodExecOptions, + deepCopy_v1_PodList, + deepCopy_v1_PodLogOptions, + deepCopy_v1_PodProxyOptions, + deepCopy_v1_PodSpec, + deepCopy_v1_PodStatus, + deepCopy_v1_PodStatusResult, + deepCopy_v1_PodTemplate, + deepCopy_v1_PodTemplateList, + deepCopy_v1_PodTemplateSpec, + deepCopy_v1_Probe, + deepCopy_v1_RBDVolumeSource, + deepCopy_v1_RangeAllocation, + deepCopy_v1_ReplicationController, + deepCopy_v1_ReplicationControllerList, + deepCopy_v1_ReplicationControllerSpec, + deepCopy_v1_ReplicationControllerStatus, + deepCopy_v1_ResourceQuota, + deepCopy_v1_ResourceQuotaList, + deepCopy_v1_ResourceQuotaSpec, + deepCopy_v1_ResourceQuotaStatus, + deepCopy_v1_ResourceRequirements, + deepCopy_v1_SELinuxOptions, + deepCopy_v1_Secret, + deepCopy_v1_SecretList, + deepCopy_v1_SecretVolumeSource, + deepCopy_v1_SecurityContext, + deepCopy_v1_SerializedReference, + deepCopy_v1_Service, + deepCopy_v1_ServiceAccount, + deepCopy_v1_ServiceAccountList, + deepCopy_v1_ServiceList, + deepCopy_v1_ServicePort, + deepCopy_v1_ServiceSpec, + deepCopy_v1_ServiceStatus, + deepCopy_v1_Status, + deepCopy_v1_StatusCause, + deepCopy_v1_StatusDetails, + deepCopy_v1_TCPSocketAction, + deepCopy_v1_TypeMeta, + deepCopy_v1_Volume, + deepCopy_v1_VolumeMount, + deepCopy_v1_VolumeSource, + deepCopy_runtime_RawExtension, + deepCopy_util_IntOrString, + deepCopy_util_Time, + ) + if err != nil { + // if one of the deep copy functions is malformed, detect it immediately. + panic(err) + } +} + +// AUTO-GENERATED FUNCTIONS END HERE diff --git a/pkg/api/v1beta3/deep_copy_generated.go b/pkg/api/v1beta3/deep_copy_generated.go new file mode 100644 index 00000000000..abe95f7ca40 --- /dev/null +++ b/pkg/api/v1beta3/deep_copy_generated.go @@ -0,0 +1,2190 @@ +/* +Copyright 2015 The Kubernetes Authors 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 v1beta3 + +// AUTO-GENERATED FUNCTIONS START HERE +import ( + "github.com/GoogleCloudPlatform/kubernetes/pkg/api" + "github.com/GoogleCloudPlatform/kubernetes/pkg/api/resource" + "github.com/GoogleCloudPlatform/kubernetes/pkg/conversion" + "github.com/GoogleCloudPlatform/kubernetes/pkg/runtime" + "github.com/GoogleCloudPlatform/kubernetes/pkg/util" + "speter.net/go/exp/math/dec/inf" + "time" +) + +func deepCopy_resource_Quantity(in resource.Quantity, out *resource.Quantity, c *conversion.Cloner) error { + if in.Amount != nil { + if newVal, err := c.DeepCopy(in.Amount); err != nil { + return err + } else { + out.Amount = newVal.(*inf.Dec) + } + } else { + out.Amount = nil + } + out.Format = in.Format + return nil +} + +func deepCopy_v1beta3_AWSElasticBlockStoreVolumeSource(in AWSElasticBlockStoreVolumeSource, out *AWSElasticBlockStoreVolumeSource, c *conversion.Cloner) error { + out.VolumeID = in.VolumeID + out.FSType = in.FSType + out.Partition = in.Partition + out.ReadOnly = in.ReadOnly + return nil +} + +func deepCopy_v1beta3_Binding(in Binding, out *Binding, c *conversion.Cloner) error { + if err := deepCopy_v1beta3_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_v1beta3_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil { + return err + } + if err := deepCopy_v1beta3_ObjectReference(in.Target, &out.Target, c); err != nil { + return err + } + return nil +} + +func deepCopy_v1beta3_Capabilities(in Capabilities, out *Capabilities, c *conversion.Cloner) error { + if in.Add != nil { + out.Add = make([]Capability, len(in.Add)) + for i := range in.Add { + out.Add[i] = in.Add[i] + } + } else { + out.Add = nil + } + if in.Drop != nil { + out.Drop = make([]Capability, len(in.Drop)) + for i := range in.Drop { + out.Drop[i] = in.Drop[i] + } + } else { + out.Drop = nil + } + return nil +} + +func deepCopy_v1beta3_ComponentCondition(in ComponentCondition, out *ComponentCondition, c *conversion.Cloner) error { + out.Type = in.Type + out.Status = in.Status + out.Message = in.Message + out.Error = in.Error + return nil +} + +func deepCopy_v1beta3_ComponentStatus(in ComponentStatus, out *ComponentStatus, c *conversion.Cloner) error { + if err := deepCopy_v1beta3_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_v1beta3_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil { + return err + } + if in.Conditions != nil { + out.Conditions = make([]ComponentCondition, len(in.Conditions)) + for i := range in.Conditions { + if err := deepCopy_v1beta3_ComponentCondition(in.Conditions[i], &out.Conditions[i], c); err != nil { + return err + } + } + } else { + out.Conditions = nil + } + return nil +} + +func deepCopy_v1beta3_ComponentStatusList(in ComponentStatusList, out *ComponentStatusList, c *conversion.Cloner) error { + if err := deepCopy_v1beta3_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_v1beta3_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil { + return err + } + if in.Items != nil { + out.Items = make([]ComponentStatus, len(in.Items)) + for i := range in.Items { + if err := deepCopy_v1beta3_ComponentStatus(in.Items[i], &out.Items[i], c); err != nil { + return err + } + } + } else { + out.Items = nil + } + return nil +} + +func deepCopy_v1beta3_Container(in Container, out *Container, c *conversion.Cloner) 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] + } + } else { + out.Command = nil + } + if in.Args != nil { + out.Args = make([]string, len(in.Args)) + for i := range in.Args { + out.Args[i] = in.Args[i] + } + } else { + out.Args = nil + } + out.WorkingDir = in.WorkingDir + if in.Ports != nil { + out.Ports = make([]ContainerPort, len(in.Ports)) + for i := range in.Ports { + if err := deepCopy_v1beta3_ContainerPort(in.Ports[i], &out.Ports[i], c); err != nil { + return err + } + } + } else { + out.Ports = nil + } + if in.Env != nil { + out.Env = make([]EnvVar, len(in.Env)) + for i := range in.Env { + if err := deepCopy_v1beta3_EnvVar(in.Env[i], &out.Env[i], c); err != nil { + return err + } + } + } else { + out.Env = nil + } + if err := deepCopy_v1beta3_ResourceRequirements(in.Resources, &out.Resources, c); err != nil { + return err + } + if in.VolumeMounts != nil { + out.VolumeMounts = make([]VolumeMount, len(in.VolumeMounts)) + for i := range in.VolumeMounts { + if err := deepCopy_v1beta3_VolumeMount(in.VolumeMounts[i], &out.VolumeMounts[i], c); err != nil { + return err + } + } + } else { + out.VolumeMounts = nil + } + if in.LivenessProbe != nil { + out.LivenessProbe = new(Probe) + if err := deepCopy_v1beta3_Probe(*in.LivenessProbe, out.LivenessProbe, c); err != nil { + return err + } + } else { + out.LivenessProbe = nil + } + if in.ReadinessProbe != nil { + out.ReadinessProbe = new(Probe) + if err := deepCopy_v1beta3_Probe(*in.ReadinessProbe, out.ReadinessProbe, c); err != nil { + return err + } + } else { + out.ReadinessProbe = nil + } + if in.Lifecycle != nil { + out.Lifecycle = new(Lifecycle) + if err := deepCopy_v1beta3_Lifecycle(*in.Lifecycle, out.Lifecycle, c); err != nil { + return err + } + } else { + out.Lifecycle = nil + } + out.TerminationMessagePath = in.TerminationMessagePath + out.Privileged = in.Privileged + out.ImagePullPolicy = in.ImagePullPolicy + if err := deepCopy_v1beta3_Capabilities(in.Capabilities, &out.Capabilities, c); err != nil { + return err + } + if in.SecurityContext != nil { + out.SecurityContext = new(SecurityContext) + if err := deepCopy_v1beta3_SecurityContext(*in.SecurityContext, out.SecurityContext, c); err != nil { + return err + } + } else { + out.SecurityContext = nil + } + return nil +} + +func deepCopy_v1beta3_ContainerPort(in ContainerPort, out *ContainerPort, c *conversion.Cloner) error { + out.Name = in.Name + out.HostPort = in.HostPort + out.ContainerPort = in.ContainerPort + out.Protocol = in.Protocol + out.HostIP = in.HostIP + return nil +} + +func deepCopy_v1beta3_ContainerState(in ContainerState, out *ContainerState, c *conversion.Cloner) error { + if in.Waiting != nil { + out.Waiting = new(ContainerStateWaiting) + if err := deepCopy_v1beta3_ContainerStateWaiting(*in.Waiting, out.Waiting, c); err != nil { + return err + } + } else { + out.Waiting = nil + } + if in.Running != nil { + out.Running = new(ContainerStateRunning) + if err := deepCopy_v1beta3_ContainerStateRunning(*in.Running, out.Running, c); err != nil { + return err + } + } else { + out.Running = nil + } + if in.Termination != nil { + out.Termination = new(ContainerStateTerminated) + if err := deepCopy_v1beta3_ContainerStateTerminated(*in.Termination, out.Termination, c); err != nil { + return err + } + } else { + out.Termination = nil + } + return nil +} + +func deepCopy_v1beta3_ContainerStateRunning(in ContainerStateRunning, out *ContainerStateRunning, c *conversion.Cloner) error { + if err := deepCopy_util_Time(in.StartedAt, &out.StartedAt, c); err != nil { + return err + } + return nil +} + +func deepCopy_v1beta3_ContainerStateTerminated(in ContainerStateTerminated, out *ContainerStateTerminated, c *conversion.Cloner) error { + out.ExitCode = in.ExitCode + out.Signal = in.Signal + out.Reason = in.Reason + out.Message = in.Message + if err := deepCopy_util_Time(in.StartedAt, &out.StartedAt, c); err != nil { + return err + } + if err := deepCopy_util_Time(in.FinishedAt, &out.FinishedAt, c); err != nil { + return err + } + out.ContainerID = in.ContainerID + return nil +} + +func deepCopy_v1beta3_ContainerStateWaiting(in ContainerStateWaiting, out *ContainerStateWaiting, c *conversion.Cloner) error { + out.Reason = in.Reason + return nil +} + +func deepCopy_v1beta3_ContainerStatus(in ContainerStatus, out *ContainerStatus, c *conversion.Cloner) error { + out.Name = in.Name + if err := deepCopy_v1beta3_ContainerState(in.State, &out.State, c); err != nil { + return err + } + if err := deepCopy_v1beta3_ContainerState(in.LastTerminationState, &out.LastTerminationState, c); 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 deepCopy_v1beta3_DeleteOptions(in DeleteOptions, out *DeleteOptions, c *conversion.Cloner) error { + if err := deepCopy_v1beta3_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if in.GracePeriodSeconds != nil { + out.GracePeriodSeconds = new(int64) + *out.GracePeriodSeconds = *in.GracePeriodSeconds + } else { + out.GracePeriodSeconds = nil + } + return nil +} + +func deepCopy_v1beta3_EmptyDirVolumeSource(in EmptyDirVolumeSource, out *EmptyDirVolumeSource, c *conversion.Cloner) error { + out.Medium = in.Medium + return nil +} + +func deepCopy_v1beta3_EndpointAddress(in EndpointAddress, out *EndpointAddress, c *conversion.Cloner) error { + out.IP = in.IP + if in.TargetRef != nil { + out.TargetRef = new(ObjectReference) + if err := deepCopy_v1beta3_ObjectReference(*in.TargetRef, out.TargetRef, c); err != nil { + return err + } + } else { + out.TargetRef = nil + } + return nil +} + +func deepCopy_v1beta3_EndpointPort(in EndpointPort, out *EndpointPort, c *conversion.Cloner) error { + out.Name = in.Name + out.Port = in.Port + out.Protocol = in.Protocol + return nil +} + +func deepCopy_v1beta3_EndpointSubset(in EndpointSubset, out *EndpointSubset, c *conversion.Cloner) error { + if in.Addresses != nil { + out.Addresses = make([]EndpointAddress, len(in.Addresses)) + for i := range in.Addresses { + if err := deepCopy_v1beta3_EndpointAddress(in.Addresses[i], &out.Addresses[i], c); err != nil { + return err + } + } + } else { + out.Addresses = nil + } + if in.Ports != nil { + out.Ports = make([]EndpointPort, len(in.Ports)) + for i := range in.Ports { + if err := deepCopy_v1beta3_EndpointPort(in.Ports[i], &out.Ports[i], c); err != nil { + return err + } + } + } else { + out.Ports = nil + } + return nil +} + +func deepCopy_v1beta3_Endpoints(in Endpoints, out *Endpoints, c *conversion.Cloner) error { + if err := deepCopy_v1beta3_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_v1beta3_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil { + return err + } + if in.Subsets != nil { + out.Subsets = make([]EndpointSubset, len(in.Subsets)) + for i := range in.Subsets { + if err := deepCopy_v1beta3_EndpointSubset(in.Subsets[i], &out.Subsets[i], c); err != nil { + return err + } + } + } else { + out.Subsets = nil + } + return nil +} + +func deepCopy_v1beta3_EndpointsList(in EndpointsList, out *EndpointsList, c *conversion.Cloner) error { + if err := deepCopy_v1beta3_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_v1beta3_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil { + return err + } + if in.Items != nil { + out.Items = make([]Endpoints, len(in.Items)) + for i := range in.Items { + if err := deepCopy_v1beta3_Endpoints(in.Items[i], &out.Items[i], c); err != nil { + return err + } + } + } else { + out.Items = nil + } + return nil +} + +func deepCopy_v1beta3_EnvVar(in EnvVar, out *EnvVar, c *conversion.Cloner) error { + out.Name = in.Name + out.Value = in.Value + if in.ValueFrom != nil { + out.ValueFrom = new(EnvVarSource) + if err := deepCopy_v1beta3_EnvVarSource(*in.ValueFrom, out.ValueFrom, c); err != nil { + return err + } + } else { + out.ValueFrom = nil + } + return nil +} + +func deepCopy_v1beta3_EnvVarSource(in EnvVarSource, out *EnvVarSource, c *conversion.Cloner) error { + if in.FieldRef != nil { + out.FieldRef = new(ObjectFieldSelector) + if err := deepCopy_v1beta3_ObjectFieldSelector(*in.FieldRef, out.FieldRef, c); err != nil { + return err + } + } else { + out.FieldRef = nil + } + return nil +} + +func deepCopy_v1beta3_Event(in Event, out *Event, c *conversion.Cloner) error { + if err := deepCopy_v1beta3_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_v1beta3_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil { + return err + } + if err := deepCopy_v1beta3_ObjectReference(in.InvolvedObject, &out.InvolvedObject, c); err != nil { + return err + } + out.Reason = in.Reason + out.Message = in.Message + if err := deepCopy_v1beta3_EventSource(in.Source, &out.Source, c); err != nil { + return err + } + if err := deepCopy_util_Time(in.FirstTimestamp, &out.FirstTimestamp, c); err != nil { + return err + } + if err := deepCopy_util_Time(in.LastTimestamp, &out.LastTimestamp, c); err != nil { + return err + } + out.Count = in.Count + return nil +} + +func deepCopy_v1beta3_EventList(in EventList, out *EventList, c *conversion.Cloner) error { + if err := deepCopy_v1beta3_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_v1beta3_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil { + return err + } + if in.Items != nil { + out.Items = make([]Event, len(in.Items)) + for i := range in.Items { + if err := deepCopy_v1beta3_Event(in.Items[i], &out.Items[i], c); err != nil { + return err + } + } + } else { + out.Items = nil + } + return nil +} + +func deepCopy_v1beta3_EventSource(in EventSource, out *EventSource, c *conversion.Cloner) error { + out.Component = in.Component + out.Host = in.Host + return nil +} + +func deepCopy_v1beta3_ExecAction(in ExecAction, out *ExecAction, c *conversion.Cloner) error { + if in.Command != nil { + out.Command = make([]string, len(in.Command)) + for i := range in.Command { + out.Command[i] = in.Command[i] + } + } else { + out.Command = nil + } + return nil +} + +func deepCopy_v1beta3_GCEPersistentDiskVolumeSource(in GCEPersistentDiskVolumeSource, out *GCEPersistentDiskVolumeSource, c *conversion.Cloner) error { + out.PDName = in.PDName + out.FSType = in.FSType + out.Partition = in.Partition + out.ReadOnly = in.ReadOnly + return nil +} + +func deepCopy_v1beta3_GitRepoVolumeSource(in GitRepoVolumeSource, out *GitRepoVolumeSource, c *conversion.Cloner) error { + out.Repository = in.Repository + out.Revision = in.Revision + return nil +} + +func deepCopy_v1beta3_GlusterfsVolumeSource(in GlusterfsVolumeSource, out *GlusterfsVolumeSource, c *conversion.Cloner) error { + out.EndpointsName = in.EndpointsName + out.Path = in.Path + out.ReadOnly = in.ReadOnly + return nil +} + +func deepCopy_v1beta3_HTTPGetAction(in HTTPGetAction, out *HTTPGetAction, c *conversion.Cloner) error { + out.Path = in.Path + if err := deepCopy_util_IntOrString(in.Port, &out.Port, c); err != nil { + return err + } + out.Host = in.Host + return nil +} + +func deepCopy_v1beta3_Handler(in Handler, out *Handler, c *conversion.Cloner) error { + if in.Exec != nil { + out.Exec = new(ExecAction) + if err := deepCopy_v1beta3_ExecAction(*in.Exec, out.Exec, c); err != nil { + return err + } + } else { + out.Exec = nil + } + if in.HTTPGet != nil { + out.HTTPGet = new(HTTPGetAction) + if err := deepCopy_v1beta3_HTTPGetAction(*in.HTTPGet, out.HTTPGet, c); err != nil { + return err + } + } else { + out.HTTPGet = nil + } + if in.TCPSocket != nil { + out.TCPSocket = new(TCPSocketAction) + if err := deepCopy_v1beta3_TCPSocketAction(*in.TCPSocket, out.TCPSocket, c); err != nil { + return err + } + } else { + out.TCPSocket = nil + } + return nil +} + +func deepCopy_v1beta3_HostPathVolumeSource(in HostPathVolumeSource, out *HostPathVolumeSource, c *conversion.Cloner) error { + out.Path = in.Path + return nil +} + +func deepCopy_v1beta3_ISCSIVolumeSource(in ISCSIVolumeSource, out *ISCSIVolumeSource, c *conversion.Cloner) error { + out.TargetPortal = in.TargetPortal + out.IQN = in.IQN + out.Lun = in.Lun + out.FSType = in.FSType + out.ReadOnly = in.ReadOnly + return nil +} + +func deepCopy_v1beta3_Lifecycle(in Lifecycle, out *Lifecycle, c *conversion.Cloner) error { + if in.PostStart != nil { + out.PostStart = new(Handler) + if err := deepCopy_v1beta3_Handler(*in.PostStart, out.PostStart, c); err != nil { + return err + } + } else { + out.PostStart = nil + } + if in.PreStop != nil { + out.PreStop = new(Handler) + if err := deepCopy_v1beta3_Handler(*in.PreStop, out.PreStop, c); err != nil { + return err + } + } else { + out.PreStop = nil + } + return nil +} + +func deepCopy_v1beta3_LimitRange(in LimitRange, out *LimitRange, c *conversion.Cloner) error { + if err := deepCopy_v1beta3_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_v1beta3_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil { + return err + } + if err := deepCopy_v1beta3_LimitRangeSpec(in.Spec, &out.Spec, c); err != nil { + return err + } + return nil +} + +func deepCopy_v1beta3_LimitRangeItem(in LimitRangeItem, out *LimitRangeItem, c *conversion.Cloner) error { + out.Type = in.Type + if in.Max != nil { + out.Max = make(map[ResourceName]resource.Quantity) + for key, val := range in.Max { + newVal := new(resource.Quantity) + if err := deepCopy_resource_Quantity(val, newVal, c); err != nil { + return err + } + out.Max[key] = *newVal + } + } else { + out.Max = nil + } + if in.Min != nil { + out.Min = make(map[ResourceName]resource.Quantity) + for key, val := range in.Min { + newVal := new(resource.Quantity) + if err := deepCopy_resource_Quantity(val, newVal, c); err != nil { + return err + } + out.Min[key] = *newVal + } + } else { + out.Min = nil + } + if in.Default != nil { + out.Default = make(map[ResourceName]resource.Quantity) + for key, val := range in.Default { + newVal := new(resource.Quantity) + if err := deepCopy_resource_Quantity(val, newVal, c); err != nil { + return err + } + out.Default[key] = *newVal + } + } else { + out.Default = nil + } + return nil +} + +func deepCopy_v1beta3_LimitRangeList(in LimitRangeList, out *LimitRangeList, c *conversion.Cloner) error { + if err := deepCopy_v1beta3_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_v1beta3_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil { + return err + } + if in.Items != nil { + out.Items = make([]LimitRange, len(in.Items)) + for i := range in.Items { + if err := deepCopy_v1beta3_LimitRange(in.Items[i], &out.Items[i], c); err != nil { + return err + } + } + } else { + out.Items = nil + } + return nil +} + +func deepCopy_v1beta3_LimitRangeSpec(in LimitRangeSpec, out *LimitRangeSpec, c *conversion.Cloner) error { + if in.Limits != nil { + out.Limits = make([]LimitRangeItem, len(in.Limits)) + for i := range in.Limits { + if err := deepCopy_v1beta3_LimitRangeItem(in.Limits[i], &out.Limits[i], c); err != nil { + return err + } + } + } else { + out.Limits = nil + } + return nil +} + +func deepCopy_v1beta3_List(in List, out *List, c *conversion.Cloner) error { + if err := deepCopy_v1beta3_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_v1beta3_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil { + return err + } + if in.Items != nil { + out.Items = make([]runtime.RawExtension, len(in.Items)) + for i := range in.Items { + if err := deepCopy_runtime_RawExtension(in.Items[i], &out.Items[i], c); err != nil { + return err + } + } + } else { + out.Items = nil + } + return nil +} + +func deepCopy_v1beta3_ListMeta(in ListMeta, out *ListMeta, c *conversion.Cloner) error { + out.SelfLink = in.SelfLink + out.ResourceVersion = in.ResourceVersion + return nil +} + +func deepCopy_v1beta3_ListOptions(in ListOptions, out *ListOptions, c *conversion.Cloner) error { + if err := deepCopy_v1beta3_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + out.LabelSelector = in.LabelSelector + out.FieldSelector = in.FieldSelector + out.Watch = in.Watch + out.ResourceVersion = in.ResourceVersion + return nil +} + +func deepCopy_v1beta3_LoadBalancerIngress(in LoadBalancerIngress, out *LoadBalancerIngress, c *conversion.Cloner) error { + out.IP = in.IP + out.Hostname = in.Hostname + return nil +} + +func deepCopy_v1beta3_LoadBalancerStatus(in LoadBalancerStatus, out *LoadBalancerStatus, c *conversion.Cloner) error { + if in.Ingress != nil { + out.Ingress = make([]LoadBalancerIngress, len(in.Ingress)) + for i := range in.Ingress { + if err := deepCopy_v1beta3_LoadBalancerIngress(in.Ingress[i], &out.Ingress[i], c); err != nil { + return err + } + } + } else { + out.Ingress = nil + } + return nil +} + +func deepCopy_v1beta3_LocalObjectReference(in LocalObjectReference, out *LocalObjectReference, c *conversion.Cloner) error { + out.Name = in.Name + return nil +} + +func deepCopy_v1beta3_NFSVolumeSource(in NFSVolumeSource, out *NFSVolumeSource, c *conversion.Cloner) error { + out.Server = in.Server + out.Path = in.Path + out.ReadOnly = in.ReadOnly + return nil +} + +func deepCopy_v1beta3_Namespace(in Namespace, out *Namespace, c *conversion.Cloner) error { + if err := deepCopy_v1beta3_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_v1beta3_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil { + return err + } + if err := deepCopy_v1beta3_NamespaceSpec(in.Spec, &out.Spec, c); err != nil { + return err + } + if err := deepCopy_v1beta3_NamespaceStatus(in.Status, &out.Status, c); err != nil { + return err + } + return nil +} + +func deepCopy_v1beta3_NamespaceList(in NamespaceList, out *NamespaceList, c *conversion.Cloner) error { + if err := deepCopy_v1beta3_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_v1beta3_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil { + return err + } + if in.Items != nil { + out.Items = make([]Namespace, len(in.Items)) + for i := range in.Items { + if err := deepCopy_v1beta3_Namespace(in.Items[i], &out.Items[i], c); err != nil { + return err + } + } + } else { + out.Items = nil + } + return nil +} + +func deepCopy_v1beta3_NamespaceSpec(in NamespaceSpec, out *NamespaceSpec, c *conversion.Cloner) error { + if in.Finalizers != nil { + out.Finalizers = make([]FinalizerName, len(in.Finalizers)) + for i := range in.Finalizers { + out.Finalizers[i] = in.Finalizers[i] + } + } else { + out.Finalizers = nil + } + return nil +} + +func deepCopy_v1beta3_NamespaceStatus(in NamespaceStatus, out *NamespaceStatus, c *conversion.Cloner) error { + out.Phase = in.Phase + return nil +} + +func deepCopy_v1beta3_Node(in Node, out *Node, c *conversion.Cloner) error { + if err := deepCopy_v1beta3_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_v1beta3_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil { + return err + } + if err := deepCopy_v1beta3_NodeSpec(in.Spec, &out.Spec, c); err != nil { + return err + } + if err := deepCopy_v1beta3_NodeStatus(in.Status, &out.Status, c); err != nil { + return err + } + return nil +} + +func deepCopy_v1beta3_NodeAddress(in NodeAddress, out *NodeAddress, c *conversion.Cloner) error { + out.Type = in.Type + out.Address = in.Address + return nil +} + +func deepCopy_v1beta3_NodeCondition(in NodeCondition, out *NodeCondition, c *conversion.Cloner) error { + out.Type = in.Type + out.Status = in.Status + if err := deepCopy_util_Time(in.LastHeartbeatTime, &out.LastHeartbeatTime, c); err != nil { + return err + } + if err := deepCopy_util_Time(in.LastTransitionTime, &out.LastTransitionTime, c); err != nil { + return err + } + out.Reason = in.Reason + out.Message = in.Message + return nil +} + +func deepCopy_v1beta3_NodeList(in NodeList, out *NodeList, c *conversion.Cloner) error { + if err := deepCopy_v1beta3_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_v1beta3_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil { + return err + } + if in.Items != nil { + out.Items = make([]Node, len(in.Items)) + for i := range in.Items { + if err := deepCopy_v1beta3_Node(in.Items[i], &out.Items[i], c); err != nil { + return err + } + } + } else { + out.Items = nil + } + return nil +} + +func deepCopy_v1beta3_NodeSpec(in NodeSpec, out *NodeSpec, c *conversion.Cloner) error { + out.PodCIDR = in.PodCIDR + out.ExternalID = in.ExternalID + out.Unschedulable = in.Unschedulable + return nil +} + +func deepCopy_v1beta3_NodeStatus(in NodeStatus, out *NodeStatus, c *conversion.Cloner) error { + if in.Capacity != nil { + out.Capacity = make(map[ResourceName]resource.Quantity) + for key, val := range in.Capacity { + newVal := new(resource.Quantity) + if err := deepCopy_resource_Quantity(val, newVal, c); err != nil { + return err + } + out.Capacity[key] = *newVal + } + } else { + out.Capacity = nil + } + out.Phase = in.Phase + if in.Conditions != nil { + out.Conditions = make([]NodeCondition, len(in.Conditions)) + for i := range in.Conditions { + if err := deepCopy_v1beta3_NodeCondition(in.Conditions[i], &out.Conditions[i], c); err != nil { + return err + } + } + } else { + out.Conditions = nil + } + if in.Addresses != nil { + out.Addresses = make([]NodeAddress, len(in.Addresses)) + for i := range in.Addresses { + if err := deepCopy_v1beta3_NodeAddress(in.Addresses[i], &out.Addresses[i], c); err != nil { + return err + } + } + } else { + out.Addresses = nil + } + if err := deepCopy_v1beta3_NodeSystemInfo(in.NodeInfo, &out.NodeInfo, c); err != nil { + return err + } + return nil +} + +func deepCopy_v1beta3_NodeSystemInfo(in NodeSystemInfo, out *NodeSystemInfo, c *conversion.Cloner) 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 deepCopy_v1beta3_ObjectFieldSelector(in ObjectFieldSelector, out *ObjectFieldSelector, c *conversion.Cloner) error { + out.APIVersion = in.APIVersion + out.FieldPath = in.FieldPath + return nil +} + +func deepCopy_v1beta3_ObjectMeta(in ObjectMeta, out *ObjectMeta, c *conversion.Cloner) 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 := deepCopy_util_Time(in.CreationTimestamp, &out.CreationTimestamp, c); err != nil { + return err + } + if in.DeletionTimestamp != nil { + out.DeletionTimestamp = new(util.Time) + if err := deepCopy_util_Time(*in.DeletionTimestamp, out.DeletionTimestamp, c); err != nil { + return err + } + } else { + out.DeletionTimestamp = nil + } + if in.Labels != nil { + out.Labels = make(map[string]string) + for key, val := range in.Labels { + out.Labels[key] = val + } + } else { + out.Labels = nil + } + if in.Annotations != nil { + out.Annotations = make(map[string]string) + for key, val := range in.Annotations { + out.Annotations[key] = val + } + } else { + out.Annotations = nil + } + return nil +} + +func deepCopy_v1beta3_ObjectReference(in ObjectReference, out *ObjectReference, c *conversion.Cloner) 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 deepCopy_v1beta3_PersistentVolume(in PersistentVolume, out *PersistentVolume, c *conversion.Cloner) error { + if err := deepCopy_v1beta3_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_v1beta3_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil { + return err + } + if err := deepCopy_v1beta3_PersistentVolumeSpec(in.Spec, &out.Spec, c); err != nil { + return err + } + if err := deepCopy_v1beta3_PersistentVolumeStatus(in.Status, &out.Status, c); err != nil { + return err + } + return nil +} + +func deepCopy_v1beta3_PersistentVolumeClaim(in PersistentVolumeClaim, out *PersistentVolumeClaim, c *conversion.Cloner) error { + if err := deepCopy_v1beta3_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_v1beta3_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil { + return err + } + if err := deepCopy_v1beta3_PersistentVolumeClaimSpec(in.Spec, &out.Spec, c); err != nil { + return err + } + if err := deepCopy_v1beta3_PersistentVolumeClaimStatus(in.Status, &out.Status, c); err != nil { + return err + } + return nil +} + +func deepCopy_v1beta3_PersistentVolumeClaimList(in PersistentVolumeClaimList, out *PersistentVolumeClaimList, c *conversion.Cloner) error { + if err := deepCopy_v1beta3_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_v1beta3_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil { + return err + } + if in.Items != nil { + out.Items = make([]PersistentVolumeClaim, len(in.Items)) + for i := range in.Items { + if err := deepCopy_v1beta3_PersistentVolumeClaim(in.Items[i], &out.Items[i], c); err != nil { + return err + } + } + } else { + out.Items = nil + } + return nil +} + +func deepCopy_v1beta3_PersistentVolumeClaimSpec(in PersistentVolumeClaimSpec, out *PersistentVolumeClaimSpec, c *conversion.Cloner) error { + if in.AccessModes != nil { + out.AccessModes = make([]PersistentVolumeAccessMode, len(in.AccessModes)) + for i := range in.AccessModes { + out.AccessModes[i] = in.AccessModes[i] + } + } else { + out.AccessModes = nil + } + if err := deepCopy_v1beta3_ResourceRequirements(in.Resources, &out.Resources, c); err != nil { + return err + } + out.VolumeName = in.VolumeName + return nil +} + +func deepCopy_v1beta3_PersistentVolumeClaimStatus(in PersistentVolumeClaimStatus, out *PersistentVolumeClaimStatus, c *conversion.Cloner) error { + out.Phase = in.Phase + if in.AccessModes != nil { + out.AccessModes = make([]PersistentVolumeAccessMode, len(in.AccessModes)) + for i := range in.AccessModes { + out.AccessModes[i] = in.AccessModes[i] + } + } else { + out.AccessModes = nil + } + if in.Capacity != nil { + out.Capacity = make(map[ResourceName]resource.Quantity) + for key, val := range in.Capacity { + newVal := new(resource.Quantity) + if err := deepCopy_resource_Quantity(val, newVal, c); err != nil { + return err + } + out.Capacity[key] = *newVal + } + } else { + out.Capacity = nil + } + return nil +} + +func deepCopy_v1beta3_PersistentVolumeClaimVolumeSource(in PersistentVolumeClaimVolumeSource, out *PersistentVolumeClaimVolumeSource, c *conversion.Cloner) error { + out.ClaimName = in.ClaimName + out.ReadOnly = in.ReadOnly + return nil +} + +func deepCopy_v1beta3_PersistentVolumeList(in PersistentVolumeList, out *PersistentVolumeList, c *conversion.Cloner) error { + if err := deepCopy_v1beta3_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_v1beta3_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil { + return err + } + if in.Items != nil { + out.Items = make([]PersistentVolume, len(in.Items)) + for i := range in.Items { + if err := deepCopy_v1beta3_PersistentVolume(in.Items[i], &out.Items[i], c); err != nil { + return err + } + } + } else { + out.Items = nil + } + return nil +} + +func deepCopy_v1beta3_PersistentVolumeSource(in PersistentVolumeSource, out *PersistentVolumeSource, c *conversion.Cloner) error { + if in.GCEPersistentDisk != nil { + out.GCEPersistentDisk = new(GCEPersistentDiskVolumeSource) + if err := deepCopy_v1beta3_GCEPersistentDiskVolumeSource(*in.GCEPersistentDisk, out.GCEPersistentDisk, c); err != nil { + return err + } + } else { + out.GCEPersistentDisk = nil + } + if in.AWSElasticBlockStore != nil { + out.AWSElasticBlockStore = new(AWSElasticBlockStoreVolumeSource) + if err := deepCopy_v1beta3_AWSElasticBlockStoreVolumeSource(*in.AWSElasticBlockStore, out.AWSElasticBlockStore, c); err != nil { + return err + } + } else { + out.AWSElasticBlockStore = nil + } + if in.HostPath != nil { + out.HostPath = new(HostPathVolumeSource) + if err := deepCopy_v1beta3_HostPathVolumeSource(*in.HostPath, out.HostPath, c); err != nil { + return err + } + } else { + out.HostPath = nil + } + if in.Glusterfs != nil { + out.Glusterfs = new(GlusterfsVolumeSource) + if err := deepCopy_v1beta3_GlusterfsVolumeSource(*in.Glusterfs, out.Glusterfs, c); err != nil { + return err + } + } else { + out.Glusterfs = nil + } + if in.NFS != nil { + out.NFS = new(NFSVolumeSource) + if err := deepCopy_v1beta3_NFSVolumeSource(*in.NFS, out.NFS, c); err != nil { + return err + } + } else { + out.NFS = nil + } + if in.RBD != nil { + out.RBD = new(RBDVolumeSource) + if err := deepCopy_v1beta3_RBDVolumeSource(*in.RBD, out.RBD, c); err != nil { + return err + } + } else { + out.RBD = nil + } + return nil +} + +func deepCopy_v1beta3_PersistentVolumeSpec(in PersistentVolumeSpec, out *PersistentVolumeSpec, c *conversion.Cloner) error { + if in.Capacity != nil { + out.Capacity = make(map[ResourceName]resource.Quantity) + for key, val := range in.Capacity { + newVal := new(resource.Quantity) + if err := deepCopy_resource_Quantity(val, newVal, c); err != nil { + return err + } + out.Capacity[key] = *newVal + } + } else { + out.Capacity = nil + } + if err := deepCopy_v1beta3_PersistentVolumeSource(in.PersistentVolumeSource, &out.PersistentVolumeSource, c); err != nil { + return err + } + if in.AccessModes != nil { + out.AccessModes = make([]PersistentVolumeAccessMode, len(in.AccessModes)) + for i := range in.AccessModes { + out.AccessModes[i] = in.AccessModes[i] + } + } else { + out.AccessModes = nil + } + if in.ClaimRef != nil { + out.ClaimRef = new(ObjectReference) + if err := deepCopy_v1beta3_ObjectReference(*in.ClaimRef, out.ClaimRef, c); err != nil { + return err + } + } else { + out.ClaimRef = nil + } + return nil +} + +func deepCopy_v1beta3_PersistentVolumeStatus(in PersistentVolumeStatus, out *PersistentVolumeStatus, c *conversion.Cloner) error { + out.Phase = in.Phase + return nil +} + +func deepCopy_v1beta3_Pod(in Pod, out *Pod, c *conversion.Cloner) error { + if err := deepCopy_v1beta3_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_v1beta3_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil { + return err + } + if err := deepCopy_v1beta3_PodSpec(in.Spec, &out.Spec, c); err != nil { + return err + } + if err := deepCopy_v1beta3_PodStatus(in.Status, &out.Status, c); err != nil { + return err + } + return nil +} + +func deepCopy_v1beta3_PodCondition(in PodCondition, out *PodCondition, c *conversion.Cloner) error { + out.Type = in.Type + out.Status = in.Status + return nil +} + +func deepCopy_v1beta3_PodExecOptions(in PodExecOptions, out *PodExecOptions, c *conversion.Cloner) error { + if err := deepCopy_v1beta3_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + out.Stdin = in.Stdin + out.Stdout = in.Stdout + out.Stderr = in.Stderr + out.TTY = in.TTY + out.Container = in.Container + if in.Command != nil { + out.Command = make([]string, len(in.Command)) + for i := range in.Command { + out.Command[i] = in.Command[i] + } + } else { + out.Command = nil + } + return nil +} + +func deepCopy_v1beta3_PodList(in PodList, out *PodList, c *conversion.Cloner) error { + if err := deepCopy_v1beta3_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_v1beta3_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil { + return err + } + if in.Items != nil { + out.Items = make([]Pod, len(in.Items)) + for i := range in.Items { + if err := deepCopy_v1beta3_Pod(in.Items[i], &out.Items[i], c); err != nil { + return err + } + } + } else { + out.Items = nil + } + return nil +} + +func deepCopy_v1beta3_PodLogOptions(in PodLogOptions, out *PodLogOptions, c *conversion.Cloner) error { + if err := deepCopy_v1beta3_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + out.Container = in.Container + out.Follow = in.Follow + out.Previous = in.Previous + return nil +} + +func deepCopy_v1beta3_PodProxyOptions(in PodProxyOptions, out *PodProxyOptions, c *conversion.Cloner) error { + if err := deepCopy_v1beta3_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + out.Path = in.Path + return nil +} + +func deepCopy_v1beta3_PodSpec(in PodSpec, out *PodSpec, c *conversion.Cloner) error { + if in.Volumes != nil { + out.Volumes = make([]Volume, len(in.Volumes)) + for i := range in.Volumes { + if err := deepCopy_v1beta3_Volume(in.Volumes[i], &out.Volumes[i], c); err != nil { + return err + } + } + } else { + out.Volumes = nil + } + if in.Containers != nil { + out.Containers = make([]Container, len(in.Containers)) + for i := range in.Containers { + if err := deepCopy_v1beta3_Container(in.Containers[i], &out.Containers[i], c); err != nil { + return err + } + } + } else { + out.Containers = nil + } + out.RestartPolicy = in.RestartPolicy + if in.TerminationGracePeriodSeconds != nil { + out.TerminationGracePeriodSeconds = new(int64) + *out.TerminationGracePeriodSeconds = *in.TerminationGracePeriodSeconds + } else { + out.TerminationGracePeriodSeconds = nil + } + if in.ActiveDeadlineSeconds != nil { + out.ActiveDeadlineSeconds = new(int64) + *out.ActiveDeadlineSeconds = *in.ActiveDeadlineSeconds + } else { + out.ActiveDeadlineSeconds = nil + } + out.DNSPolicy = in.DNSPolicy + if in.NodeSelector != nil { + out.NodeSelector = make(map[string]string) + for key, val := range in.NodeSelector { + out.NodeSelector[key] = val + } + } else { + out.NodeSelector = nil + } + out.ServiceAccount = in.ServiceAccount + out.Host = in.Host + out.HostNetwork = in.HostNetwork + if in.ImagePullSecrets != nil { + out.ImagePullSecrets = make([]LocalObjectReference, len(in.ImagePullSecrets)) + for i := range in.ImagePullSecrets { + if err := deepCopy_v1beta3_LocalObjectReference(in.ImagePullSecrets[i], &out.ImagePullSecrets[i], c); err != nil { + return err + } + } + } else { + out.ImagePullSecrets = nil + } + return nil +} + +func deepCopy_v1beta3_PodStatus(in PodStatus, out *PodStatus, c *conversion.Cloner) error { + out.Phase = in.Phase + if in.Conditions != nil { + out.Conditions = make([]PodCondition, len(in.Conditions)) + for i := range in.Conditions { + if err := deepCopy_v1beta3_PodCondition(in.Conditions[i], &out.Conditions[i], c); err != nil { + return err + } + } + } else { + out.Conditions = nil + } + out.Message = in.Message + out.HostIP = in.HostIP + out.PodIP = in.PodIP + if in.StartTime != nil { + out.StartTime = new(util.Time) + if err := deepCopy_util_Time(*in.StartTime, out.StartTime, c); err != nil { + return err + } + } else { + out.StartTime = nil + } + if in.ContainerStatuses != nil { + out.ContainerStatuses = make([]ContainerStatus, len(in.ContainerStatuses)) + for i := range in.ContainerStatuses { + if err := deepCopy_v1beta3_ContainerStatus(in.ContainerStatuses[i], &out.ContainerStatuses[i], c); err != nil { + return err + } + } + } else { + out.ContainerStatuses = nil + } + return nil +} + +func deepCopy_v1beta3_PodStatusResult(in PodStatusResult, out *PodStatusResult, c *conversion.Cloner) error { + if err := deepCopy_v1beta3_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_v1beta3_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil { + return err + } + if err := deepCopy_v1beta3_PodStatus(in.Status, &out.Status, c); err != nil { + return err + } + return nil +} + +func deepCopy_v1beta3_PodTemplate(in PodTemplate, out *PodTemplate, c *conversion.Cloner) error { + if err := deepCopy_v1beta3_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_v1beta3_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil { + return err + } + if err := deepCopy_v1beta3_PodTemplateSpec(in.Template, &out.Template, c); err != nil { + return err + } + return nil +} + +func deepCopy_v1beta3_PodTemplateList(in PodTemplateList, out *PodTemplateList, c *conversion.Cloner) error { + if err := deepCopy_v1beta3_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_v1beta3_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil { + return err + } + if in.Items != nil { + out.Items = make([]PodTemplate, len(in.Items)) + for i := range in.Items { + if err := deepCopy_v1beta3_PodTemplate(in.Items[i], &out.Items[i], c); err != nil { + return err + } + } + } else { + out.Items = nil + } + return nil +} + +func deepCopy_v1beta3_PodTemplateSpec(in PodTemplateSpec, out *PodTemplateSpec, c *conversion.Cloner) error { + if err := deepCopy_v1beta3_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil { + return err + } + if err := deepCopy_v1beta3_PodSpec(in.Spec, &out.Spec, c); err != nil { + return err + } + return nil +} + +func deepCopy_v1beta3_Probe(in Probe, out *Probe, c *conversion.Cloner) error { + if err := deepCopy_v1beta3_Handler(in.Handler, &out.Handler, c); err != nil { + return err + } + out.InitialDelaySeconds = in.InitialDelaySeconds + out.TimeoutSeconds = in.TimeoutSeconds + return nil +} + +func deepCopy_v1beta3_RBDVolumeSource(in RBDVolumeSource, out *RBDVolumeSource, c *conversion.Cloner) error { + if in.CephMonitors != nil { + out.CephMonitors = make([]string, len(in.CephMonitors)) + for i := range in.CephMonitors { + out.CephMonitors[i] = in.CephMonitors[i] + } + } else { + out.CephMonitors = nil + } + out.RBDImage = in.RBDImage + out.FSType = in.FSType + out.RBDPool = in.RBDPool + out.RadosUser = in.RadosUser + out.Keyring = in.Keyring + if in.SecretRef != nil { + out.SecretRef = new(LocalObjectReference) + if err := deepCopy_v1beta3_LocalObjectReference(*in.SecretRef, out.SecretRef, c); err != nil { + return err + } + } else { + out.SecretRef = nil + } + out.ReadOnly = in.ReadOnly + return nil +} + +func deepCopy_v1beta3_RangeAllocation(in RangeAllocation, out *RangeAllocation, c *conversion.Cloner) error { + if err := deepCopy_v1beta3_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_v1beta3_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil { + return err + } + out.Range = in.Range + if in.Data != nil { + out.Data = make([]uint8, len(in.Data)) + for i := range in.Data { + out.Data[i] = in.Data[i] + } + } else { + out.Data = nil + } + return nil +} + +func deepCopy_v1beta3_ReplicationController(in ReplicationController, out *ReplicationController, c *conversion.Cloner) error { + if err := deepCopy_v1beta3_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_v1beta3_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil { + return err + } + if err := deepCopy_v1beta3_ReplicationControllerSpec(in.Spec, &out.Spec, c); err != nil { + return err + } + if err := deepCopy_v1beta3_ReplicationControllerStatus(in.Status, &out.Status, c); err != nil { + return err + } + return nil +} + +func deepCopy_v1beta3_ReplicationControllerList(in ReplicationControllerList, out *ReplicationControllerList, c *conversion.Cloner) error { + if err := deepCopy_v1beta3_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_v1beta3_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil { + return err + } + if in.Items != nil { + out.Items = make([]ReplicationController, len(in.Items)) + for i := range in.Items { + if err := deepCopy_v1beta3_ReplicationController(in.Items[i], &out.Items[i], c); err != nil { + return err + } + } + } else { + out.Items = nil + } + return nil +} + +func deepCopy_v1beta3_ReplicationControllerSpec(in ReplicationControllerSpec, out *ReplicationControllerSpec, c *conversion.Cloner) 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 + } + } else { + out.Selector = nil + } + if in.TemplateRef != nil { + out.TemplateRef = new(ObjectReference) + if err := deepCopy_v1beta3_ObjectReference(*in.TemplateRef, out.TemplateRef, c); err != nil { + return err + } + } else { + out.TemplateRef = nil + } + if in.Template != nil { + out.Template = new(PodTemplateSpec) + if err := deepCopy_v1beta3_PodTemplateSpec(*in.Template, out.Template, c); err != nil { + return err + } + } else { + out.Template = nil + } + return nil +} + +func deepCopy_v1beta3_ReplicationControllerStatus(in ReplicationControllerStatus, out *ReplicationControllerStatus, c *conversion.Cloner) error { + out.Replicas = in.Replicas + return nil +} + +func deepCopy_v1beta3_ResourceQuota(in ResourceQuota, out *ResourceQuota, c *conversion.Cloner) error { + if err := deepCopy_v1beta3_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_v1beta3_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil { + return err + } + if err := deepCopy_v1beta3_ResourceQuotaSpec(in.Spec, &out.Spec, c); err != nil { + return err + } + if err := deepCopy_v1beta3_ResourceQuotaStatus(in.Status, &out.Status, c); err != nil { + return err + } + return nil +} + +func deepCopy_v1beta3_ResourceQuotaList(in ResourceQuotaList, out *ResourceQuotaList, c *conversion.Cloner) error { + if err := deepCopy_v1beta3_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_v1beta3_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil { + return err + } + if in.Items != nil { + out.Items = make([]ResourceQuota, len(in.Items)) + for i := range in.Items { + if err := deepCopy_v1beta3_ResourceQuota(in.Items[i], &out.Items[i], c); err != nil { + return err + } + } + } else { + out.Items = nil + } + return nil +} + +func deepCopy_v1beta3_ResourceQuotaSpec(in ResourceQuotaSpec, out *ResourceQuotaSpec, c *conversion.Cloner) error { + if in.Hard != nil { + out.Hard = make(map[ResourceName]resource.Quantity) + for key, val := range in.Hard { + newVal := new(resource.Quantity) + if err := deepCopy_resource_Quantity(val, newVal, c); err != nil { + return err + } + out.Hard[key] = *newVal + } + } else { + out.Hard = nil + } + return nil +} + +func deepCopy_v1beta3_ResourceQuotaStatus(in ResourceQuotaStatus, out *ResourceQuotaStatus, c *conversion.Cloner) error { + if in.Hard != nil { + out.Hard = make(map[ResourceName]resource.Quantity) + for key, val := range in.Hard { + newVal := new(resource.Quantity) + if err := deepCopy_resource_Quantity(val, newVal, c); err != nil { + return err + } + out.Hard[key] = *newVal + } + } else { + out.Hard = nil + } + if in.Used != nil { + out.Used = make(map[ResourceName]resource.Quantity) + for key, val := range in.Used { + newVal := new(resource.Quantity) + if err := deepCopy_resource_Quantity(val, newVal, c); err != nil { + return err + } + out.Used[key] = *newVal + } + } else { + out.Used = nil + } + return nil +} + +func deepCopy_v1beta3_ResourceRequirements(in ResourceRequirements, out *ResourceRequirements, c *conversion.Cloner) error { + if in.Limits != nil { + out.Limits = make(map[ResourceName]resource.Quantity) + for key, val := range in.Limits { + newVal := new(resource.Quantity) + if err := deepCopy_resource_Quantity(val, newVal, c); err != nil { + return err + } + out.Limits[key] = *newVal + } + } else { + out.Limits = nil + } + if in.Requests != nil { + out.Requests = make(map[ResourceName]resource.Quantity) + for key, val := range in.Requests { + newVal := new(resource.Quantity) + if err := deepCopy_resource_Quantity(val, newVal, c); err != nil { + return err + } + out.Requests[key] = *newVal + } + } else { + out.Requests = nil + } + return nil +} + +func deepCopy_v1beta3_SELinuxOptions(in SELinuxOptions, out *SELinuxOptions, c *conversion.Cloner) error { + out.User = in.User + out.Role = in.Role + out.Type = in.Type + out.Level = in.Level + return nil +} + +func deepCopy_v1beta3_Secret(in Secret, out *Secret, c *conversion.Cloner) error { + if err := deepCopy_v1beta3_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_v1beta3_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil { + return err + } + if in.Data != nil { + out.Data = make(map[string][]uint8) + for key, val := range in.Data { + if newVal, err := c.DeepCopy(val); err != nil { + return err + } else { + out.Data[key] = newVal.([]uint8) + } + } + } else { + out.Data = nil + } + out.Type = in.Type + return nil +} + +func deepCopy_v1beta3_SecretList(in SecretList, out *SecretList, c *conversion.Cloner) error { + if err := deepCopy_v1beta3_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_v1beta3_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil { + return err + } + if in.Items != nil { + out.Items = make([]Secret, len(in.Items)) + for i := range in.Items { + if err := deepCopy_v1beta3_Secret(in.Items[i], &out.Items[i], c); err != nil { + return err + } + } + } else { + out.Items = nil + } + return nil +} + +func deepCopy_v1beta3_SecretVolumeSource(in SecretVolumeSource, out *SecretVolumeSource, c *conversion.Cloner) error { + out.SecretName = in.SecretName + return nil +} + +func deepCopy_v1beta3_SecurityContext(in SecurityContext, out *SecurityContext, c *conversion.Cloner) error { + if in.Capabilities != nil { + out.Capabilities = new(Capabilities) + if err := deepCopy_v1beta3_Capabilities(*in.Capabilities, out.Capabilities, c); err != nil { + return err + } + } else { + out.Capabilities = nil + } + if in.Privileged != nil { + out.Privileged = new(bool) + *out.Privileged = *in.Privileged + } else { + out.Privileged = nil + } + if in.SELinuxOptions != nil { + out.SELinuxOptions = new(SELinuxOptions) + if err := deepCopy_v1beta3_SELinuxOptions(*in.SELinuxOptions, out.SELinuxOptions, c); err != nil { + return err + } + } else { + out.SELinuxOptions = nil + } + if in.RunAsUser != nil { + out.RunAsUser = new(int64) + *out.RunAsUser = *in.RunAsUser + } else { + out.RunAsUser = nil + } + return nil +} + +func deepCopy_v1beta3_SerializedReference(in SerializedReference, out *SerializedReference, c *conversion.Cloner) error { + if err := deepCopy_v1beta3_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_v1beta3_ObjectReference(in.Reference, &out.Reference, c); err != nil { + return err + } + return nil +} + +func deepCopy_v1beta3_Service(in Service, out *Service, c *conversion.Cloner) error { + if err := deepCopy_v1beta3_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_v1beta3_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil { + return err + } + if err := deepCopy_v1beta3_ServiceSpec(in.Spec, &out.Spec, c); err != nil { + return err + } + if err := deepCopy_v1beta3_ServiceStatus(in.Status, &out.Status, c); err != nil { + return err + } + return nil +} + +func deepCopy_v1beta3_ServiceAccount(in ServiceAccount, out *ServiceAccount, c *conversion.Cloner) error { + if err := deepCopy_v1beta3_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_v1beta3_ObjectMeta(in.ObjectMeta, &out.ObjectMeta, c); err != nil { + return err + } + if in.Secrets != nil { + out.Secrets = make([]ObjectReference, len(in.Secrets)) + for i := range in.Secrets { + if err := deepCopy_v1beta3_ObjectReference(in.Secrets[i], &out.Secrets[i], c); err != nil { + return err + } + } + } else { + out.Secrets = nil + } + return nil +} + +func deepCopy_v1beta3_ServiceAccountList(in ServiceAccountList, out *ServiceAccountList, c *conversion.Cloner) error { + if err := deepCopy_v1beta3_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_v1beta3_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil { + return err + } + if in.Items != nil { + out.Items = make([]ServiceAccount, len(in.Items)) + for i := range in.Items { + if err := deepCopy_v1beta3_ServiceAccount(in.Items[i], &out.Items[i], c); err != nil { + return err + } + } + } else { + out.Items = nil + } + return nil +} + +func deepCopy_v1beta3_ServiceList(in ServiceList, out *ServiceList, c *conversion.Cloner) error { + if err := deepCopy_v1beta3_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_v1beta3_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil { + return err + } + if in.Items != nil { + out.Items = make([]Service, len(in.Items)) + for i := range in.Items { + if err := deepCopy_v1beta3_Service(in.Items[i], &out.Items[i], c); err != nil { + return err + } + } + } else { + out.Items = nil + } + return nil +} + +func deepCopy_v1beta3_ServicePort(in ServicePort, out *ServicePort, c *conversion.Cloner) error { + out.Name = in.Name + out.Protocol = in.Protocol + out.Port = in.Port + if err := deepCopy_util_IntOrString(in.TargetPort, &out.TargetPort, c); err != nil { + return err + } + out.NodePort = in.NodePort + return nil +} + +func deepCopy_v1beta3_ServiceSpec(in ServiceSpec, out *ServiceSpec, c *conversion.Cloner) error { + if in.Ports != nil { + out.Ports = make([]ServicePort, len(in.Ports)) + for i := range in.Ports { + if err := deepCopy_v1beta3_ServicePort(in.Ports[i], &out.Ports[i], c); err != nil { + return err + } + } + } else { + out.Ports = nil + } + if in.Selector != nil { + out.Selector = make(map[string]string) + for key, val := range in.Selector { + out.Selector[key] = val + } + } else { + out.Selector = nil + } + out.PortalIP = in.PortalIP + out.CreateExternalLoadBalancer = in.CreateExternalLoadBalancer + out.Type = in.Type + if in.PublicIPs != nil { + out.PublicIPs = make([]string, len(in.PublicIPs)) + for i := range in.PublicIPs { + out.PublicIPs[i] = in.PublicIPs[i] + } + } else { + out.PublicIPs = nil + } + out.SessionAffinity = in.SessionAffinity + return nil +} + +func deepCopy_v1beta3_ServiceStatus(in ServiceStatus, out *ServiceStatus, c *conversion.Cloner) error { + if err := deepCopy_v1beta3_LoadBalancerStatus(in.LoadBalancer, &out.LoadBalancer, c); err != nil { + return err + } + return nil +} + +func deepCopy_v1beta3_Status(in Status, out *Status, c *conversion.Cloner) error { + if err := deepCopy_v1beta3_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { + return err + } + if err := deepCopy_v1beta3_ListMeta(in.ListMeta, &out.ListMeta, c); err != nil { + return err + } + out.Status = in.Status + out.Message = in.Message + out.Reason = in.Reason + if in.Details != nil { + out.Details = new(StatusDetails) + if err := deepCopy_v1beta3_StatusDetails(*in.Details, out.Details, c); err != nil { + return err + } + } else { + out.Details = nil + } + out.Code = in.Code + return nil +} + +func deepCopy_v1beta3_StatusCause(in StatusCause, out *StatusCause, c *conversion.Cloner) error { + out.Type = in.Type + out.Message = in.Message + out.Field = in.Field + return nil +} + +func deepCopy_v1beta3_StatusDetails(in StatusDetails, out *StatusDetails, c *conversion.Cloner) 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 := deepCopy_v1beta3_StatusCause(in.Causes[i], &out.Causes[i], c); err != nil { + return err + } + } + } else { + out.Causes = nil + } + out.RetryAfterSeconds = in.RetryAfterSeconds + return nil +} + +func deepCopy_v1beta3_TCPSocketAction(in TCPSocketAction, out *TCPSocketAction, c *conversion.Cloner) error { + if err := deepCopy_util_IntOrString(in.Port, &out.Port, c); err != nil { + return err + } + return nil +} + +func deepCopy_v1beta3_TypeMeta(in TypeMeta, out *TypeMeta, c *conversion.Cloner) error { + out.Kind = in.Kind + out.APIVersion = in.APIVersion + return nil +} + +func deepCopy_v1beta3_Volume(in Volume, out *Volume, c *conversion.Cloner) error { + out.Name = in.Name + if err := deepCopy_v1beta3_VolumeSource(in.VolumeSource, &out.VolumeSource, c); err != nil { + return err + } + return nil +} + +func deepCopy_v1beta3_VolumeMount(in VolumeMount, out *VolumeMount, c *conversion.Cloner) error { + out.Name = in.Name + out.ReadOnly = in.ReadOnly + out.MountPath = in.MountPath + return nil +} + +func deepCopy_v1beta3_VolumeSource(in VolumeSource, out *VolumeSource, c *conversion.Cloner) error { + if in.HostPath != nil { + out.HostPath = new(HostPathVolumeSource) + if err := deepCopy_v1beta3_HostPathVolumeSource(*in.HostPath, out.HostPath, c); err != nil { + return err + } + } else { + out.HostPath = nil + } + if in.EmptyDir != nil { + out.EmptyDir = new(EmptyDirVolumeSource) + if err := deepCopy_v1beta3_EmptyDirVolumeSource(*in.EmptyDir, out.EmptyDir, c); err != nil { + return err + } + } else { + out.EmptyDir = nil + } + if in.GCEPersistentDisk != nil { + out.GCEPersistentDisk = new(GCEPersistentDiskVolumeSource) + if err := deepCopy_v1beta3_GCEPersistentDiskVolumeSource(*in.GCEPersistentDisk, out.GCEPersistentDisk, c); err != nil { + return err + } + } else { + out.GCEPersistentDisk = nil + } + if in.AWSElasticBlockStore != nil { + out.AWSElasticBlockStore = new(AWSElasticBlockStoreVolumeSource) + if err := deepCopy_v1beta3_AWSElasticBlockStoreVolumeSource(*in.AWSElasticBlockStore, out.AWSElasticBlockStore, c); err != nil { + return err + } + } else { + out.AWSElasticBlockStore = nil + } + if in.GitRepo != nil { + out.GitRepo = new(GitRepoVolumeSource) + if err := deepCopy_v1beta3_GitRepoVolumeSource(*in.GitRepo, out.GitRepo, c); err != nil { + return err + } + } else { + out.GitRepo = nil + } + if in.Secret != nil { + out.Secret = new(SecretVolumeSource) + if err := deepCopy_v1beta3_SecretVolumeSource(*in.Secret, out.Secret, c); err != nil { + return err + } + } else { + out.Secret = nil + } + if in.NFS != nil { + out.NFS = new(NFSVolumeSource) + if err := deepCopy_v1beta3_NFSVolumeSource(*in.NFS, out.NFS, c); err != nil { + return err + } + } else { + out.NFS = nil + } + if in.ISCSI != nil { + out.ISCSI = new(ISCSIVolumeSource) + if err := deepCopy_v1beta3_ISCSIVolumeSource(*in.ISCSI, out.ISCSI, c); err != nil { + return err + } + } else { + out.ISCSI = nil + } + if in.Glusterfs != nil { + out.Glusterfs = new(GlusterfsVolumeSource) + if err := deepCopy_v1beta3_GlusterfsVolumeSource(*in.Glusterfs, out.Glusterfs, c); err != nil { + return err + } + } else { + out.Glusterfs = nil + } + if in.PersistentVolumeClaimVolumeSource != nil { + out.PersistentVolumeClaimVolumeSource = new(PersistentVolumeClaimVolumeSource) + if err := deepCopy_v1beta3_PersistentVolumeClaimVolumeSource(*in.PersistentVolumeClaimVolumeSource, out.PersistentVolumeClaimVolumeSource, c); err != nil { + return err + } + } else { + out.PersistentVolumeClaimVolumeSource = nil + } + if in.RBD != nil { + out.RBD = new(RBDVolumeSource) + if err := deepCopy_v1beta3_RBDVolumeSource(*in.RBD, out.RBD, c); err != nil { + return err + } + } else { + out.RBD = nil + } + return nil +} + +func deepCopy_runtime_RawExtension(in runtime.RawExtension, out *runtime.RawExtension, c *conversion.Cloner) error { + if in.RawJSON != nil { + out.RawJSON = make([]uint8, len(in.RawJSON)) + for i := range in.RawJSON { + out.RawJSON[i] = in.RawJSON[i] + } + } else { + out.RawJSON = nil + } + return nil +} + +func deepCopy_util_IntOrString(in util.IntOrString, out *util.IntOrString, c *conversion.Cloner) error { + out.Kind = in.Kind + out.IntVal = in.IntVal + out.StrVal = in.StrVal + return nil +} + +func deepCopy_util_Time(in util.Time, out *util.Time, c *conversion.Cloner) error { + if newVal, err := c.DeepCopy(in.Time); err != nil { + return err + } else { + out.Time = newVal.(time.Time) + } + return nil +} + +func init() { + err := api.Scheme.AddGeneratedDeepCopyFuncs( + deepCopy_resource_Quantity, + deepCopy_v1beta3_AWSElasticBlockStoreVolumeSource, + deepCopy_v1beta3_Binding, + deepCopy_v1beta3_Capabilities, + deepCopy_v1beta3_ComponentCondition, + deepCopy_v1beta3_ComponentStatus, + deepCopy_v1beta3_ComponentStatusList, + deepCopy_v1beta3_Container, + deepCopy_v1beta3_ContainerPort, + deepCopy_v1beta3_ContainerState, + deepCopy_v1beta3_ContainerStateRunning, + deepCopy_v1beta3_ContainerStateTerminated, + deepCopy_v1beta3_ContainerStateWaiting, + deepCopy_v1beta3_ContainerStatus, + deepCopy_v1beta3_DeleteOptions, + deepCopy_v1beta3_EmptyDirVolumeSource, + deepCopy_v1beta3_EndpointAddress, + deepCopy_v1beta3_EndpointPort, + deepCopy_v1beta3_EndpointSubset, + deepCopy_v1beta3_Endpoints, + deepCopy_v1beta3_EndpointsList, + deepCopy_v1beta3_EnvVar, + deepCopy_v1beta3_EnvVarSource, + deepCopy_v1beta3_Event, + deepCopy_v1beta3_EventList, + deepCopy_v1beta3_EventSource, + deepCopy_v1beta3_ExecAction, + deepCopy_v1beta3_GCEPersistentDiskVolumeSource, + deepCopy_v1beta3_GitRepoVolumeSource, + deepCopy_v1beta3_GlusterfsVolumeSource, + deepCopy_v1beta3_HTTPGetAction, + deepCopy_v1beta3_Handler, + deepCopy_v1beta3_HostPathVolumeSource, + deepCopy_v1beta3_ISCSIVolumeSource, + deepCopy_v1beta3_Lifecycle, + deepCopy_v1beta3_LimitRange, + deepCopy_v1beta3_LimitRangeItem, + deepCopy_v1beta3_LimitRangeList, + deepCopy_v1beta3_LimitRangeSpec, + deepCopy_v1beta3_List, + deepCopy_v1beta3_ListMeta, + deepCopy_v1beta3_ListOptions, + deepCopy_v1beta3_LoadBalancerIngress, + deepCopy_v1beta3_LoadBalancerStatus, + deepCopy_v1beta3_LocalObjectReference, + deepCopy_v1beta3_NFSVolumeSource, + deepCopy_v1beta3_Namespace, + deepCopy_v1beta3_NamespaceList, + deepCopy_v1beta3_NamespaceSpec, + deepCopy_v1beta3_NamespaceStatus, + deepCopy_v1beta3_Node, + deepCopy_v1beta3_NodeAddress, + deepCopy_v1beta3_NodeCondition, + deepCopy_v1beta3_NodeList, + deepCopy_v1beta3_NodeSpec, + deepCopy_v1beta3_NodeStatus, + deepCopy_v1beta3_NodeSystemInfo, + deepCopy_v1beta3_ObjectFieldSelector, + deepCopy_v1beta3_ObjectMeta, + deepCopy_v1beta3_ObjectReference, + deepCopy_v1beta3_PersistentVolume, + deepCopy_v1beta3_PersistentVolumeClaim, + deepCopy_v1beta3_PersistentVolumeClaimList, + deepCopy_v1beta3_PersistentVolumeClaimSpec, + deepCopy_v1beta3_PersistentVolumeClaimStatus, + deepCopy_v1beta3_PersistentVolumeClaimVolumeSource, + deepCopy_v1beta3_PersistentVolumeList, + deepCopy_v1beta3_PersistentVolumeSource, + deepCopy_v1beta3_PersistentVolumeSpec, + deepCopy_v1beta3_PersistentVolumeStatus, + deepCopy_v1beta3_Pod, + deepCopy_v1beta3_PodCondition, + deepCopy_v1beta3_PodExecOptions, + deepCopy_v1beta3_PodList, + deepCopy_v1beta3_PodLogOptions, + deepCopy_v1beta3_PodProxyOptions, + deepCopy_v1beta3_PodSpec, + deepCopy_v1beta3_PodStatus, + deepCopy_v1beta3_PodStatusResult, + deepCopy_v1beta3_PodTemplate, + deepCopy_v1beta3_PodTemplateList, + deepCopy_v1beta3_PodTemplateSpec, + deepCopy_v1beta3_Probe, + deepCopy_v1beta3_RBDVolumeSource, + deepCopy_v1beta3_RangeAllocation, + deepCopy_v1beta3_ReplicationController, + deepCopy_v1beta3_ReplicationControllerList, + deepCopy_v1beta3_ReplicationControllerSpec, + deepCopy_v1beta3_ReplicationControllerStatus, + deepCopy_v1beta3_ResourceQuota, + deepCopy_v1beta3_ResourceQuotaList, + deepCopy_v1beta3_ResourceQuotaSpec, + deepCopy_v1beta3_ResourceQuotaStatus, + deepCopy_v1beta3_ResourceRequirements, + deepCopy_v1beta3_SELinuxOptions, + deepCopy_v1beta3_Secret, + deepCopy_v1beta3_SecretList, + deepCopy_v1beta3_SecretVolumeSource, + deepCopy_v1beta3_SecurityContext, + deepCopy_v1beta3_SerializedReference, + deepCopy_v1beta3_Service, + deepCopy_v1beta3_ServiceAccount, + deepCopy_v1beta3_ServiceAccountList, + deepCopy_v1beta3_ServiceList, + deepCopy_v1beta3_ServicePort, + deepCopy_v1beta3_ServiceSpec, + deepCopy_v1beta3_ServiceStatus, + deepCopy_v1beta3_Status, + deepCopy_v1beta3_StatusCause, + deepCopy_v1beta3_StatusDetails, + deepCopy_v1beta3_TCPSocketAction, + deepCopy_v1beta3_TypeMeta, + deepCopy_v1beta3_Volume, + deepCopy_v1beta3_VolumeMount, + deepCopy_v1beta3_VolumeSource, + deepCopy_runtime_RawExtension, + deepCopy_util_IntOrString, + deepCopy_util_Time, + ) + if err != nil { + // if one of the deep copy functions is malformed, detect it immediately. + panic(err) + } +} + +// AUTO-GENERATED FUNCTIONS END HERE diff --git a/pkg/conversion/cloner.go b/pkg/conversion/cloner.go new file mode 100644 index 00000000000..d42922159dc --- /dev/null +++ b/pkg/conversion/cloner.go @@ -0,0 +1,226 @@ +/* +Copyright 2014 The Kubernetes Authors 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" + "reflect" +) + +// Cloner knows how to copy one type to another. +type Cloner struct { + // Map from the type to a function which can do the deep copy. + deepCopyFuncs map[reflect.Type]reflect.Value + generatedDeepCopyFuncs map[reflect.Type]reflect.Value +} + +// NewCloner creates a new Cloner object. +func NewCloner() *Cloner { + c := &Cloner{ + deepCopyFuncs: map[reflect.Type]reflect.Value{}, + generatedDeepCopyFuncs: map[reflect.Type]reflect.Value{}, + } + if err := c.RegisterDeepCopyFunc(byteSliceDeepCopy); err != nil { + // If one of the deep-copy functions is malformed, detect it immediately. + panic(err) + } + return c +} + +// Prevent recursing into every byte... +func byteSliceDeepCopy(in []byte, out *[]byte, c *Cloner) error { + *out = make([]byte, len(in)) + copy(*out, in) + return nil +} + +// Verifies whether a deep-copy function has a correct signature. +func verifyDeepCopyFunctionSignature(ft reflect.Type) error { + if ft.Kind() != reflect.Func { + return fmt.Errorf("expected func, got: %v", ft) + } + if ft.NumIn() != 3 { + return fmt.Errorf("expected three 'in' params, got $v", ft) + } + if ft.NumOut() != 1 { + return fmt.Errorf("expected one 'out' param, got %v", ft) + } + if ft.In(1).Kind() != reflect.Ptr { + return fmt.Errorf("expected pointer arg for 'in' param 1, got: %v", ft) + } + if ft.In(1).Elem() != ft.In(0) { + return fmt.Errorf("expected 'in' param 0 the same as param 1, got: %v", ft) + } + var forClonerType Cloner + if expected := reflect.TypeOf(&forClonerType); ft.In(2) != expected { + return fmt.Errorf("expected '%v' arg for 'in' param 2, got: '%v'", expected, ft.In(2)) + } + var forErrorType error + // This convolution is necessary, otherwise TypeOf picks up on the fact + // that forErrorType is nil + errorType := reflect.TypeOf(&forErrorType).Elem() + if ft.Out(0) != errorType { + return fmt.Errorf("expected error return, got: %v", ft) + } + return nil +} + +// RegisterGeneratedDeepCopyFunc registers a copying func with the Cloner. +// deepCopyFunc must take two parameters: a type and a pointer to Cloner +// and return an element of the same type and an error. +// +// Example: +// c.RegisterGeneratedDeepCopyFunc( +// func(in Pod, c *Cloner) (Pod, error) { +// // deep copy logic... +// return copy, nil +// }) +func (c *Cloner) RegisterDeepCopyFunc(deepCopyFunc interface{}) error { + fv := reflect.ValueOf(deepCopyFunc) + ft := fv.Type() + if err := verifyDeepCopyFunctionSignature(ft); err != nil { + return err + } + c.deepCopyFuncs[ft.In(0)] = fv + return nil +} + +// Similar to RegisterDeepCopyFunc, but registers deep copy function that were +// automatically generated. +func (c *Cloner) RegisterGeneratedDeepCopyFunc(deepCopyFunc interface{}) error { + fv := reflect.ValueOf(deepCopyFunc) + ft := fv.Type() + if err := verifyDeepCopyFunctionSignature(ft); err != nil { + return err + } + c.generatedDeepCopyFuncs[ft.In(0)] = fv + return nil +} + +// DeepCopy will perform a deep copy of a given object. +func (c *Cloner) DeepCopy(in interface{}) (interface{}, error) { + inValue := reflect.ValueOf(in) + outValue, err := c.deepCopy(inValue) + if err != nil { + return nil, err + } + return outValue.Interface(), nil +} + +func (c *Cloner) deepCopy(src reflect.Value) (reflect.Value, error) { + inType := src.Type() + + if fv, ok := c.deepCopyFuncs[inType]; ok { + return c.customDeepCopy(src, fv) + } + if fv, ok := c.generatedDeepCopyFuncs[inType]; ok { + return c.customDeepCopy(src, fv) + } + return c.defaultDeepCopy(src) +} + +func (c *Cloner) customDeepCopy(src, fv reflect.Value) (reflect.Value, error) { + outValue := reflect.New(src.Type()) + args := []reflect.Value{src, outValue, reflect.ValueOf(c)} + result := fv.Call(args)[0].Interface() + // This convolution is necessary because nil interfaces won't convert + // to error. + if result == nil { + return outValue.Elem(), nil + } + return outValue.Elem(), result.(error) +} + +func (c *Cloner) defaultDeepCopy(src reflect.Value) (reflect.Value, error) { + switch src.Kind() { + case reflect.Chan, reflect.Func, reflect.UnsafePointer, reflect.Uintptr: + return src, fmt.Errorf("cannot deep copy kind: %s", src.Kind()) + case reflect.Array: + dst := reflect.New(src.Type()) + for i := 0; i < src.Len(); i++ { + copyVal, err := c.deepCopy(src.Index(i)) + if err != nil { + return src, err + } + dst.Elem().Index(i).Set(copyVal) + } + return dst.Elem(), nil + case reflect.Interface: + if src.IsNil() { + return src, nil + } + return c.deepCopy(src.Elem()) + case reflect.Map: + if src.IsNil() { + return src, nil + } + dst := reflect.MakeMap(src.Type()) + for _, k := range src.MapKeys() { + copyVal, err := c.deepCopy(src.MapIndex(k)) + if err != nil { + return src, err + } + dst.SetMapIndex(k, copyVal) + } + return dst, nil + case reflect.Ptr: + if src.IsNil() { + return src, nil + } + dst := reflect.New(src.Type().Elem()) + copyVal, err := c.deepCopy(src.Elem()) + if err != nil { + return src, err + } + dst.Elem().Set(copyVal) + return dst, nil + case reflect.Slice: + if src.IsNil() { + return src, nil + } + dst := reflect.MakeSlice(src.Type(), 0, src.Len()) + for i := 0; i < src.Len(); i++ { + copyVal, err := c.deepCopy(src.Index(i)) + if err != nil { + return src, err + } + dst = reflect.Append(dst, copyVal) + } + return dst, nil + case reflect.Struct: + dst := reflect.New(src.Type()) + for i := 0; i < src.NumField(); i++ { + if !dst.Elem().Field(i).CanSet() { + // Can't set private fields. At this point, the + // best we can do is a shallow copy. For + // example, time.Time is a value type with + // private members that can be shallow copied. + return src, nil + } + copyVal, err := c.deepCopy(src.Field(i)) + if err != nil { + return src, err + } + dst.Elem().Field(i).Set(copyVal) + } + return dst.Elem(), nil + + default: + // Value types like numbers, booleans, and strings. + return src, nil + } +} diff --git a/pkg/conversion/scheme.go b/pkg/conversion/scheme.go index b2724eb496d..e534345a1ae 100644 --- a/pkg/conversion/scheme.go +++ b/pkg/conversion/scheme.go @@ -40,6 +40,10 @@ type Scheme struct { // default coverting behavior. converter *Converter + // cloner stores all registered copy functions. It also has default + // deep copy behavior. + cloner *Cloner + // Indent will cause the JSON output from Encode to be indented, iff it is true. Indent bool @@ -60,6 +64,7 @@ func NewScheme() *Scheme { typeToVersion: map[reflect.Type]string{}, typeToKind: map[reflect.Type][]string{}, converter: NewConverter(), + cloner: NewCloner(), InternalVersion: "", MetaFactory: DefaultMetaFactory, } @@ -212,6 +217,29 @@ func (s *Scheme) AddGeneratedConversionFuncs(conversionFuncs ...interface{}) err return nil } +// AddDeepCopyFuncs adds functions to the list of deep copy functions. +// Note that to copy sub-objects, you can use the conversion.Cloner object that +// will be passed to your deep-copy function. +func (s *Scheme) AddDeepCopyFuncs(deepCopyFuncs ...interface{}) error { + for _, f := range deepCopyFuncs { + if err := s.cloner.RegisterDeepCopyFunc(f); err != nil { + return err + } + } + return nil +} + +// Similar to AddDeepCopyFuncs, but registers deep copy functions that were +// automatically generated. +func (s *Scheme) AddGeneratedDeepCopyFuncs(deepCopyFuncs ...interface{}) error { + for _, f := range deepCopyFuncs { + if err := s.cloner.RegisterGeneratedDeepCopyFunc(f); err != nil { + return err + } + } + return nil +} + // 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. @@ -262,6 +290,11 @@ func (s *Scheme) RegisterInputDefaults(in interface{}, fn FieldMappingFunc, defa return s.converter.RegisterInputDefaults(in, fn, defaultFlags) } +// Performs a deep copy of the given object. +func (s *Scheme) DeepCopy(in interface{}) (interface{}, error) { + return s.cloner.DeepCopy(in) +} + // Convert will attempt to convert in into out. Both must be pointers. For easy // testing of conversion functions. Returns an error if the conversion isn't // possible. You can call this with types that haven't been registered (for example, diff --git a/pkg/runtime/conversion_generation_test.go b/pkg/runtime/conversion_generation_test.go index 9a69515cad2..006494d8614 100644 --- a/pkg/runtime/conversion_generation_test.go +++ b/pkg/runtime/conversion_generation_test.go @@ -47,9 +47,6 @@ func generateConversions(t *testing.T, version string) bytes.Buffer { if err := g.WriteConversionFunctions(functionsWriter); err != nil { t.Fatalf("couldn't generate conversion functions: %v", err) } - if err := functionsWriter.Flush(); err != nil { - t.Fatalf("error while flushing writer") - } if err := g.RegisterConversionFunctions(functionsWriter); err != nil { t.Fatalf("couldn't generate conversion function names: %v", err) } @@ -81,7 +78,7 @@ func readLinesUntil(t *testing.T, reader *bufio.Reader, stop string, buffer *byt return nil } -func bufferExistingConversions(t *testing.T, fileName string) bytes.Buffer { +func bufferExistingGeneratedCode(t *testing.T, fileName string) bytes.Buffer { file, err := os.Open(fileName) if err != nil { t.Fatalf("couldn't open file %s", fileName) @@ -139,7 +136,7 @@ func TestNoManualChangesToGenerateConversions(t *testing.T) { for _, version := range versions { fileName := fmt.Sprintf("../../pkg/api/%s/conversion_generated.go", version) - existingFunctions := bufferExistingConversions(t, fileName) + existingFunctions := bufferExistingGeneratedCode(t, fileName) generatedFunctions := generateConversions(t, version) functionsTxt := fmt.Sprintf("%s.functions.txt", version) diff --git a/pkg/runtime/deep_copy_generation_test.go b/pkg/runtime/deep_copy_generation_test.go new file mode 100644 index 00000000000..47c12208f2e --- /dev/null +++ b/pkg/runtime/deep_copy_generation_test.go @@ -0,0 +1,87 @@ +/* +Copyright 2015 The Kubernetes Authors 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 runtime_test + +import ( + "bufio" + "bytes" + "fmt" + "io/ioutil" + "os" + "testing" + + "github.com/GoogleCloudPlatform/kubernetes/pkg/api" + _ "github.com/GoogleCloudPlatform/kubernetes/pkg/api/v1" + _ "github.com/GoogleCloudPlatform/kubernetes/pkg/api/v1beta3" + "github.com/GoogleCloudPlatform/kubernetes/pkg/runtime" + + "github.com/golang/glog" +) + +func generateDeepCopies(t *testing.T, version string) bytes.Buffer { + g := runtime.NewDeepCopyGenerator(api.Scheme.Raw()) + g.OverwritePackage(version, "") + testedVersion := version + if version == "api" { + testedVersion = api.Scheme.Raw().InternalVersion + } + for _, knownType := range api.Scheme.KnownTypes(testedVersion) { + if err := g.AddType(knownType); err != nil { + glog.Errorf("error while generating deep-copy functions for %v: %v", knownType, err) + } + } + + var functions bytes.Buffer + functionsWriter := bufio.NewWriter(&functions) + if err := g.WriteImports(functionsWriter, version); err != nil { + t.Fatalf("couldn't generate deep-copy function imports: %v", err) + } + if err := g.WriteDeepCopyFunctions(functionsWriter); err != nil { + t.Fatalf("couldn't generate deep-copy functions: %v", err) + } + if err := g.RegisterDeepCopyFunctions(functionsWriter, version); err != nil { + t.Fatalf("couldn't generate deep-copy function names: %v", err) + } + if err := functionsWriter.Flush(); err != nil { + t.Fatalf("error while flushing writer") + } + + return functions +} + +func TestNoManualChangesToGenerateDeepCopies(t *testing.T) { + versions := []string{"api", "v1beta3", "v1"} + + for _, version := range versions { + fileName := "" + if version == "api" { + fileName = "../../pkg/api/deep_copy_generated.go" + } else { + fileName = fmt.Sprintf("../../pkg/api/%s/deep_copy_generated.go", version) + } + + existingFunctions := bufferExistingGeneratedCode(t, fileName) + generatedFunctions := generateDeepCopies(t, version) + + functionsTxt := fmt.Sprintf("%s.deep_copy.txt", version) + ioutil.WriteFile(functionsTxt, generatedFunctions.Bytes(), os.FileMode(0644)) + + if ok := compareBuffers(t, functionsTxt, existingFunctions, generatedFunctions); ok { + os.Remove(functionsTxt) + } + } +} diff --git a/pkg/runtime/deep_copy_generator.go b/pkg/runtime/deep_copy_generator.go new file mode 100644 index 00000000000..1c35633c2e8 --- /dev/null +++ b/pkg/runtime/deep_copy_generator.go @@ -0,0 +1,481 @@ +/* +Copyright 2015 The Kubernetes Authors 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 runtime + +import ( + "fmt" + "io" + "reflect" + "sort" + "strings" + + "github.com/GoogleCloudPlatform/kubernetes/pkg/conversion" + "github.com/GoogleCloudPlatform/kubernetes/pkg/util" +) + +type DeepCopyGenerator interface { + // Adds a type to a generator. + // If the type is non-struct, it will return an error, otherwise deep-copy + // functions for this type and all nested types will be generated. + AddType(inType reflect.Type) error + + // Writes all imports that are necessary for deep-copy function and + // their registration. + WriteImports(w io.Writer, pkg string) error + + // Writes deel-copy functions for all types added via AddType() method + // and their nested types. + WriteDeepCopyFunctions(w io.Writer) error + + // Writes an init() function that registers all the generated deep-copy + // functions. + RegisterDeepCopyFunctions(w io.Writer, pkg string) error + + // When generating code, all references to "pkg" package name will be + // replaced with "overwrite". It is used mainly to replace references + // to name of the package in which the code will be created with empty + // string. + OverwritePackage(pkg, overwrite string) +} + +func NewDeepCopyGenerator(scheme *conversion.Scheme) DeepCopyGenerator { + return &deepCopyGenerator{ + scheme: scheme, + copyables: make(map[reflect.Type]bool), + imports: util.StringSet{}, + pkgOverwrites: make(map[string]string), + } +} + +type deepCopyGenerator struct { + scheme *conversion.Scheme + copyables map[reflect.Type]bool + imports util.StringSet + pkgOverwrites map[string]string +} + +func (g *deepCopyGenerator) addAllRecursiveTypes(inType reflect.Type) error { + if _, found := g.copyables[inType]; found { + return nil + } + switch inType.Kind() { + case reflect.Map: + if err := g.addAllRecursiveTypes(inType.Key()); err != nil { + return err + } + if err := g.addAllRecursiveTypes(inType.Elem()); err != nil { + return err + } + case reflect.Slice, reflect.Ptr: + if err := g.addAllRecursiveTypes(inType.Elem()); err != nil { + return err + } + case reflect.Interface: + g.imports.Insert(inType.PkgPath()) + return nil + case reflect.Struct: + g.imports.Insert(inType.PkgPath()) + if !strings.HasPrefix(inType.PkgPath(), "github.com/GoogleCloudPlatform/kubernetes") { + return nil + } + for i := 0; i < inType.NumField(); i++ { + inField := inType.Field(i) + if err := g.addAllRecursiveTypes(inField.Type); err != nil { + return err + } + } + g.copyables[inType] = true + default: + // Simple types should be copied automatically. + } + return nil +} + +func (g *deepCopyGenerator) AddType(inType reflect.Type) error { + if inType.Kind() != reflect.Struct { + return fmt.Errorf("non-struct copies are not supported") + } + return g.addAllRecursiveTypes(inType) +} + +func (g *deepCopyGenerator) WriteImports(w io.Writer, pkg string) error { + var packages []string + packages = append(packages, "github.com/GoogleCloudPlatform/kubernetes/pkg/api") + packages = append(packages, "github.com/GoogleCloudPlatform/kubernetes/pkg/conversion") + for key := range g.imports { + packages = append(packages, key) + } + sort.Strings(packages) + + buffer := newBuffer() + indent := 0 + buffer.addLine("import (\n", indent) + for _, importPkg := range packages { + if strings.HasSuffix(importPkg, pkg) { + continue + } + buffer.addLine(fmt.Sprintf("\"%s\"\n", importPkg), indent+1) + } + buffer.addLine(")\n", indent) + buffer.addLine("\n", indent) + if err := buffer.flushLines(w); err != nil { + return err + } + return nil +} + +type byPkgAndName []reflect.Type + +func (s byPkgAndName) Len() int { + return len(s) +} + +func (s byPkgAndName) Less(i, j int) bool { + fullNameI := s[i].PkgPath() + "/" + s[i].Name() + fullNameJ := s[j].PkgPath() + "/" + s[j].Name() + return fullNameI < fullNameJ +} + +func (s byPkgAndName) Swap(i, j int) { + s[i], s[j] = s[j], s[i] +} + +func (g *deepCopyGenerator) 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())) + case reflect.Ptr: + 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 (g *deepCopyGenerator) deepCopyFunctionName(inType reflect.Type) string { + funcNameFormat := "deepCopy_%s_%s" + inPkg := packageForName(inType) + funcName := fmt.Sprintf(funcNameFormat, inPkg, inType.Name()) + return funcName +} + +func (g *deepCopyGenerator) writeHeader(b *buffer, inType reflect.Type, indent int) { + format := "func %s(in %s, out *%s, c *conversion.Cloner) error {\n" + stmt := fmt.Sprintf(format, g.deepCopyFunctionName(inType), g.typeName(inType), g.typeName(inType)) + b.addLine(stmt, indent) +} + +func (g *deepCopyGenerator) writeFooter(b *buffer, indent int) { + b.addLine("return nil\n", indent+1) + b.addLine("}\n", indent) +} + +func (g *deepCopyGenerator) WriteDeepCopyFunctions(w io.Writer) error { + var keys []reflect.Type + for key := range g.copyables { + keys = append(keys, key) + } + sort.Sort(byPkgAndName(keys)) + + buffer := newBuffer() + indent := 0 + for _, inType := range keys { + if err := g.writeDeepCopyForType(buffer, inType, indent); err != nil { + return err + } + buffer.addLine("\n", 0) + } + if err := buffer.flushLines(w); err != nil { + return err + } + return nil +} + +func (g *deepCopyGenerator) writeDeepCopyForMap(b *buffer, inField reflect.StructField, indent int) error { + ifFormat := "if in.%s != nil {\n" + ifStmt := fmt.Sprintf(ifFormat, inField.Name) + b.addLine(ifStmt, indent) + newFormat := "out.%s = make(%s)\n" + newStmt := fmt.Sprintf(newFormat, inField.Name, g.typeName(inField.Type)) + b.addLine(newStmt, indent+1) + forFormat := "for key, val := range in.%s {\n" + forStmt := fmt.Sprintf(forFormat, inField.Name) + b.addLine(forStmt, indent+1) + + switch inField.Type.Key().Kind() { + case reflect.Map, reflect.Ptr, reflect.Slice, reflect.Interface, reflect.Struct: + return fmt.Errorf("not supported") + default: + switch inField.Type.Elem().Kind() { + case reflect.Map, reflect.Ptr, reflect.Slice, reflect.Interface, reflect.Struct: + if _, found := g.copyables[inField.Type.Elem()]; found { + newFormat := "newVal := new(%s)\n" + newStmt := fmt.Sprintf(newFormat, g.typeName(inField.Type.Elem())) + b.addLine(newStmt, indent+2) + assignFormat := "if err := %s(val, newVal, c); err != nil {\n" + funcName := g.deepCopyFunctionName(inField.Type.Elem()) + assignStmt := fmt.Sprintf(assignFormat, funcName) + b.addLine(assignStmt, indent+2) + b.addLine("return err\n", indent+3) + b.addLine("}\n", indent+2) + setFormat := "out.%s[key] = *newVal\n" + setStmt := fmt.Sprintf(setFormat, inField.Name) + b.addLine(setStmt, indent+2) + } else { + ifStmt := "if newVal, err := c.DeepCopy(val); err != nil {\n" + b.addLine(ifStmt, indent+2) + b.addLine("return err\n", indent+3) + b.addLine("} else {\n", indent+2) + assignFormat := "out.%s[key] = newVal.(%s)\n" + assignStmt := fmt.Sprintf(assignFormat, inField.Name, g.typeName(inField.Type.Elem())) + b.addLine(assignStmt, indent+3) + b.addLine("}\n", indent+2) + } + default: + assignFormat := "out.%s[key] = val\n" + assignStmt := fmt.Sprintf(assignFormat, inField.Name) + b.addLine(assignStmt, indent+2) + } + } + b.addLine("}\n", indent+1) + b.addLine("} else {\n", indent) + elseFormat := "out.%s = nil\n" + elseStmt := fmt.Sprintf(elseFormat, inField.Name) + b.addLine(elseStmt, indent+1) + b.addLine("}\n", indent) + return nil +} + +func (g *deepCopyGenerator) writeDeepCopyForPtr(b *buffer, inField reflect.StructField, indent int) error { + ifFormat := "if in.%s != nil {\n" + ifStmt := fmt.Sprintf(ifFormat, inField.Name) + b.addLine(ifStmt, indent) + + switch inField.Type.Elem().Kind() { + case reflect.Map, reflect.Ptr, reflect.Slice, reflect.Interface, reflect.Struct: + if _, found := g.copyables[inField.Type.Elem()]; found { + newFormat := "out.%s = new(%s)\n" + newStmt := fmt.Sprintf(newFormat, inField.Name, g.typeName(inField.Type.Elem())) + b.addLine(newStmt, indent+1) + assignFormat := "if err := %s(*in.%s, out.%s, c); err != nil {\n" + funcName := g.deepCopyFunctionName(inField.Type.Elem()) + assignStmt := fmt.Sprintf(assignFormat, funcName, inField.Name, inField.Name) + b.addLine(assignStmt, indent+1) + b.addLine("return err\n", indent+2) + b.addLine("}\n", indent+1) + } else { + ifFormat := "if newVal, err := c.DeepCopy(in.%s); err != nil {\n" + ifStmt := fmt.Sprintf(ifFormat, inField.Name) + b.addLine(ifStmt, indent+1) + b.addLine("return err\n", indent+2) + b.addLine("} else {\n", indent+1) + assignFormat := "out.%s = newVal.(%s)\n" + assignStmt := fmt.Sprintf(assignFormat, inField.Name, g.typeName(inField.Type)) + b.addLine(assignStmt, indent+2) + b.addLine("}\n", indent+1) + } + default: + newFormat := "out.%s = new(%s)\n" + newStmt := fmt.Sprintf(newFormat, inField.Name, g.typeName(inField.Type.Elem())) + b.addLine(newStmt, indent+1) + assignFormat := "*out.%s = *in.%s\n" + assignStmt := fmt.Sprintf(assignFormat, inField.Name, inField.Name) + b.addLine(assignStmt, indent+1) + } + b.addLine("} else {\n", indent) + elseFormat := "out.%s = nil\n" + elseStmt := fmt.Sprintf(elseFormat, inField.Name) + b.addLine(elseStmt, indent+1) + b.addLine("}\n", indent) + return nil +} + +func (g *deepCopyGenerator) writeDeepCopyForSlice(b *buffer, inField reflect.StructField, indent int) error { + ifFormat := "if in.%s != nil {\n" + ifStmt := fmt.Sprintf(ifFormat, inField.Name) + b.addLine(ifStmt, indent) + newFormat := "out.%s = make(%s, len(in.%s))\n" + newStmt := fmt.Sprintf(newFormat, inField.Name, g.typeName(inField.Type), inField.Name) + b.addLine(newStmt, indent+1) + forFormat := "for i := range in.%s {\n" + forStmt := fmt.Sprintf(forFormat, inField.Name) + b.addLine(forStmt, indent+1) + + switch inField.Type.Elem().Kind() { + case reflect.Map, reflect.Ptr, reflect.Slice, reflect.Interface, reflect.Struct: + if _, found := g.copyables[inField.Type.Elem()]; found { + assignFormat := "if err := %s(in.%s[i], &out.%s[i], c); err != nil {\n" + funcName := g.deepCopyFunctionName(inField.Type.Elem()) + assignStmt := fmt.Sprintf(assignFormat, funcName, inField.Name, inField.Name) + b.addLine(assignStmt, indent+2) + b.addLine("return err\n", indent+3) + b.addLine("}\n", indent+2) + } else { + ifFormat := "if newVal, err := c.DeepCopy(in.%s[i]); err != nil {\n" + ifStmt := fmt.Sprintf(ifFormat, inField.Name) + b.addLine(ifStmt, indent+2) + b.addLine("return err\n", indent+3) + b.addLine("} else {\n", indent+2) + assignFormat := "out.%s[i] = newVal.(%s)\n" + assignStmt := fmt.Sprintf(assignFormat, inField.Name, g.typeName(inField.Type.Elem())) + b.addLine(assignStmt, indent+3) + b.addLine("}\n", indent+2) + } + default: + assignFormat := "out.%s[i] = in.%s[i]\n" + assignStmt := fmt.Sprintf(assignFormat, inField.Name, inField.Name) + b.addLine(assignStmt, indent+2) + } + b.addLine("}\n", indent+1) + b.addLine("} else {\n", indent) + elseFormat := "out.%s = nil\n" + elseStmt := fmt.Sprintf(elseFormat, inField.Name) + b.addLine(elseStmt, indent+1) + b.addLine("}\n", indent) + return nil +} + +func (g *deepCopyGenerator) writeDeepCopyForStruct(b *buffer, inType reflect.Type, indent int) error { + for i := 0; i < inType.NumField(); i++ { + inField := inType.Field(i) + switch inField.Type.Kind() { + case reflect.Map: + if err := g.writeDeepCopyForMap(b, inField, indent); err != nil { + return err + } + case reflect.Ptr: + if err := g.writeDeepCopyForPtr(b, inField, indent); err != nil { + return err + } + case reflect.Slice: + if err := g.writeDeepCopyForSlice(b, inField, indent); err != nil { + return err + } + case reflect.Interface: + ifFormat := "if newVal, err := c.DeepCopy(in.%s); err != nil {\n" + ifStmt := fmt.Sprintf(ifFormat, inField.Name) + b.addLine(ifStmt, indent) + b.addLine("return err\n", indent+1) + b.addLine("} else {\n", indent) + copyFormat := "out.%s = newVal.(%s)\n" + copyStmt := fmt.Sprintf(copyFormat, inField.Name, g.typeName(inField.Type)) + b.addLine(copyStmt, indent+1) + b.addLine("}\n", indent) + case reflect.Struct: + if _, found := g.copyables[inField.Type]; found { + ifFormat := "if err := %s(in.%s, &out.%s, c); err != nil {\n" + funcName := g.deepCopyFunctionName(inField.Type) + ifStmt := fmt.Sprintf(ifFormat, funcName, inField.Name, inField.Name) + b.addLine(ifStmt, indent) + b.addLine("return err\n", indent+1) + b.addLine("}\n", indent) + } else { + ifFormat := "if newVal, err := c.DeepCopy(in.%s); err != nil {\n" + ifStmt := fmt.Sprintf(ifFormat, inField.Name) + b.addLine(ifStmt, indent) + b.addLine("return err\n", indent+1) + b.addLine("} else {\n", indent) + assignFormat := "out.%s = newVal.(%s)\n" + assignStmt := fmt.Sprintf(assignFormat, inField.Name, g.typeName(inField.Type)) + b.addLine(assignStmt, indent+1) + b.addLine("}\n", indent) + } + default: + // This should handle all simple types. + assignFormat := "out.%s = in.%s\n" + assignStmt := fmt.Sprintf(assignFormat, inField.Name, inField.Name) + b.addLine(assignStmt, indent) + } + } + return nil +} + +func (g *deepCopyGenerator) writeDeepCopyForType(b *buffer, inType reflect.Type, indent int) error { + g.writeHeader(b, inType, indent) + switch inType.Kind() { + case reflect.Struct: + if err := g.writeDeepCopyForStruct(b, inType, indent+1); err != nil { + return err + } + default: + return fmt.Errorf("type not supported: %v", inType) + } + g.writeFooter(b, indent) + return nil +} + +func (g *deepCopyGenerator) writeRegisterHeader(b *buffer, pkg string, indent int) { + b.addLine("func init() {\n", indent) + registerFormat := "err := %sScheme.AddGeneratedDeepCopyFuncs(\n" + if pkg == "api" { + b.addLine(fmt.Sprintf(registerFormat, ""), indent+1) + } else { + b.addLine(fmt.Sprintf(registerFormat, "api."), indent+1) + } +} + +func (g *deepCopyGenerator) writeRegisterFooter(b *buffer, indent int) { + b.addLine(")\n", indent+1) + b.addLine("if err != nil {\n", indent+1) + b.addLine("// if one of the deep copy functions is malformed, detect it immediately.\n", indent+2) + b.addLine("panic(err)\n", indent+2) + b.addLine("}\n", indent+1) + b.addLine("}\n", indent) + b.addLine("\n", indent) +} + +func (g *deepCopyGenerator) RegisterDeepCopyFunctions(w io.Writer, pkg string) error { + var keys []reflect.Type + for key := range g.copyables { + keys = append(keys, key) + } + sort.Sort(byPkgAndName(keys)) + + buffer := newBuffer() + indent := 0 + g.writeRegisterHeader(buffer, pkg, indent) + for _, inType := range keys { + funcStmt := fmt.Sprintf("%s,\n", g.deepCopyFunctionName(inType)) + buffer.addLine(funcStmt, indent+2) + } + g.writeRegisterFooter(buffer, indent) + if err := buffer.flushLines(w); err != nil { + return err + } + return nil +} + +func (g *deepCopyGenerator) OverwritePackage(pkg, overwrite string) { + g.pkgOverwrites[pkg] = overwrite +} diff --git a/pkg/runtime/scheme.go b/pkg/runtime/scheme.go index a1445f83078..a5c5b50b304 100644 --- a/pkg/runtime/scheme.go +++ b/pkg/runtime/scheme.go @@ -321,6 +321,19 @@ func (s *Scheme) AddGeneratedConversionFuncs(conversionFuncs ...interface{}) err return s.raw.AddGeneratedConversionFuncs(conversionFuncs...) } +// AddDeepCopyFuncs adds a function to the list of deep-copy functions. +// For the expected format of deep-copy function, see the comment for +// Copier.RegisterDeepCopyFunction. +func (s *Scheme) AddDeepCopyFuncs(deepCopyFuncs ...interface{}) error { + return s.raw.AddDeepCopyFuncs(deepCopyFuncs...) +} + +// Similar to AddDeepCopyFuncs, but registers deep-copy functions that were +// automatically generated. +func (s *Scheme) AddGeneratedDeepCopyFuncs(deepCopyFuncs ...interface{}) error { + return s.raw.AddGeneratedDeepCopyFuncs(deepCopyFuncs...) +} + // 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 { @@ -347,6 +360,11 @@ func (s *Scheme) AddDefaultingFuncs(defaultingFuncs ...interface{}) error { return s.raw.AddDefaultingFuncs(defaultingFuncs...) } +// Performs a deep copy of the given object. +func (s *Scheme) DeepCopy(src interface{}) (interface{}, error) { + return s.raw.DeepCopy(src) +} + // Convert will attempt to convert in into out. Both must be pointers. // For easy testing of conversion functions. Returns an error if the conversion isn't // possible.