From 2eda19da7be9b8e0fad294bf902684f23a795dd2 Mon Sep 17 00:00:00 2001 From: Shiyang Wang Date: Wed, 19 Jul 2017 10:15:21 +0800 Subject: [PATCH] Fix NotFound errors do not line up with API endpoint's group version --- federation/registry/cluster/etcd/etcd.go | 12 +- .../storage/storage.go | 6 +- .../storage/storage.go | 6 +- .../controllerrevision/storage/storage.go | 12 +- .../apps/statefulset/storage/storage.go | 12 +- .../storage/storage.go | 12 +- pkg/registry/batch/cronjob/storage/storage.go | 17 ++- pkg/registry/batch/job/storage/storage.go | 12 +- .../certificates/storage/storage.go | 12 +- .../core/configmap/storage/storage.go | 12 +- pkg/registry/core/endpoint/storage/storage.go | 12 +- pkg/registry/core/event/storage/storage.go | 4 +- .../core/limitrange/storage/storage.go | 12 +- .../core/namespace/storage/storage.go | 12 +- pkg/registry/core/node/storage/storage.go | 12 +- .../core/persistentvolume/storage/storage.go | 12 +- .../persistentvolumeclaim/storage/storage.go | 12 +- pkg/registry/core/pod/storage/storage.go | 12 +- .../core/podtemplate/storage/storage.go | 12 +- .../replicationcontroller/storage/storage.go | 12 +- .../core/resourcequota/storage/storage.go | 12 +- pkg/registry/core/secret/storage/storage.go | 12 +- pkg/registry/core/service/storage/storage.go | 12 +- .../core/serviceaccount/storage/storage.go | 12 +- .../extensions/daemonset/storage/storage.go | 12 +- .../extensions/deployment/storage/storage.go | 12 +- .../extensions/ingress/storage/storage.go | 12 +- .../networkpolicy/storage/storage.go | 12 +- .../podsecuritypolicy/storage/storage.go | 12 +- .../extensions/replicaset/storage/storage.go | 12 +- .../networkpolicy/storage/storage.go | 12 +- .../poddisruptionbudget/storage/storage.go | 12 +- .../rbac/clusterrole/storage/storage.go | 12 +- .../clusterrolebinding/storage/storage.go | 12 +- pkg/registry/rbac/role/storage/storage.go | 12 +- .../rbac/rolebinding/storage/storage.go | 12 +- .../priorityclass/storage/storage.go | 12 +- .../settings/podpreset/storage/storage.go | 12 +- .../storage/storageclass/storage/storage.go | 12 +- .../pkg/registry/customresource/etcd.go | 4 +- .../registry/customresourcedefinition/etcd.go | 10 +- .../pkg/registry/generic/registry/store.go | 96 +++++++++------- .../registry/generic/registry/store_test.go | 107 ++++++++++++++++-- .../pkg/registry/apiservice/etcd/etcd.go | 10 +- .../pkg/registry/wardle/fischer/etcd.go | 10 +- .../pkg/registry/wardle/flunder/etcd.go | 10 +- 46 files changed, 403 insertions(+), 297 deletions(-) diff --git a/federation/registry/cluster/etcd/etcd.go b/federation/registry/cluster/etcd/etcd.go index 180ce8ca934..8f8c3be28c1 100644 --- a/federation/registry/cluster/etcd/etcd.go +++ b/federation/registry/cluster/etcd/etcd.go @@ -48,12 +48,12 @@ func (r *StatusREST) Update(ctx genericapirequest.Context, name string, objInfo // NewREST returns a RESTStorage object that will work against clusters. func NewREST(optsGetter generic.RESTOptionsGetter) (*REST, *StatusREST) { store := &genericregistry.Store{ - Copier: api.Scheme, - NewFunc: func() runtime.Object { return &federation.Cluster{} }, - NewListFunc: func() runtime.Object { return &federation.ClusterList{} }, - PredicateFunc: cluster.MatchCluster, - QualifiedResource: federation.Resource("clusters"), - WatchCacheSize: cachesize.GetWatchCacheSizeByResource("clusters"), + Copier: api.Scheme, + NewFunc: func() runtime.Object { return &federation.Cluster{} }, + NewListFunc: func() runtime.Object { return &federation.ClusterList{} }, + PredicateFunc: cluster.MatchCluster, + DefaultQualifiedResource: federation.Resource("clusters"), + WatchCacheSize: cachesize.GetWatchCacheSizeByResource("clusters"), CreateStrategy: cluster.Strategy, UpdateStrategy: cluster.Strategy, diff --git a/pkg/registry/admissionregistration/externaladmissionhookconfiguration/storage/storage.go b/pkg/registry/admissionregistration/externaladmissionhookconfiguration/storage/storage.go index 0aefa3b4521..8e7d570bcb0 100644 --- a/pkg/registry/admissionregistration/externaladmissionhookconfiguration/storage/storage.go +++ b/pkg/registry/admissionregistration/externaladmissionhookconfiguration/storage/storage.go @@ -40,9 +40,9 @@ func NewREST(optsGetter generic.RESTOptionsGetter) *REST { ObjectNameFunc: func(obj runtime.Object) (string, error) { return obj.(*admissionregistration.ExternalAdmissionHookConfiguration).Name, nil }, - PredicateFunc: externaladmissionhookconfiguration.MatchExternalAdmissionHookConfiguration, - QualifiedResource: admissionregistration.Resource("externaladmissionhookconfigurations"), - WatchCacheSize: cachesize.GetWatchCacheSizeByResource("externaladmissionhookconfigurations"), + PredicateFunc: externaladmissionhookconfiguration.MatchExternalAdmissionHookConfiguration, + DefaultQualifiedResource: admissionregistration.Resource("externaladmissionhookconfigurations"), + WatchCacheSize: cachesize.GetWatchCacheSizeByResource("externaladmissionhookconfigurations"), CreateStrategy: externaladmissionhookconfiguration.Strategy, UpdateStrategy: externaladmissionhookconfiguration.Strategy, diff --git a/pkg/registry/admissionregistration/initializerconfiguration/storage/storage.go b/pkg/registry/admissionregistration/initializerconfiguration/storage/storage.go index e7351fc9869..becea1ae56b 100644 --- a/pkg/registry/admissionregistration/initializerconfiguration/storage/storage.go +++ b/pkg/registry/admissionregistration/initializerconfiguration/storage/storage.go @@ -40,9 +40,9 @@ func NewREST(optsGetter generic.RESTOptionsGetter) *REST { ObjectNameFunc: func(obj runtime.Object) (string, error) { return obj.(*admissionregistration.InitializerConfiguration).Name, nil }, - PredicateFunc: initializerconfiguration.MatchInitializerConfiguration, - QualifiedResource: admissionregistration.Resource("initializerconfigurations"), - WatchCacheSize: cachesize.GetWatchCacheSizeByResource("initializerconfigurations"), + PredicateFunc: initializerconfiguration.MatchInitializerConfiguration, + DefaultQualifiedResource: admissionregistration.Resource("initializerconfigurations"), + WatchCacheSize: cachesize.GetWatchCacheSizeByResource("initializerconfigurations"), CreateStrategy: initializerconfiguration.Strategy, UpdateStrategy: initializerconfiguration.Strategy, diff --git a/pkg/registry/apps/controllerrevision/storage/storage.go b/pkg/registry/apps/controllerrevision/storage/storage.go index d994c338f27..556d5ef1be5 100644 --- a/pkg/registry/apps/controllerrevision/storage/storage.go +++ b/pkg/registry/apps/controllerrevision/storage/storage.go @@ -34,12 +34,12 @@ type REST struct { // NewREST returns a RESTStorage object that will work with ControllerRevision objects. func NewREST(optsGetter generic.RESTOptionsGetter) *REST { store := &genericregistry.Store{ - Copier: api.Scheme, - NewFunc: func() runtime.Object { return &apps.ControllerRevision{} }, - NewListFunc: func() runtime.Object { return &apps.ControllerRevisionList{} }, - PredicateFunc: controllerrevision.MatchControllerRevision, - QualifiedResource: apps.Resource("controllerrevisions"), - WatchCacheSize: cachesize.GetWatchCacheSizeByResource("controllerrevisions"), + Copier: api.Scheme, + NewFunc: func() runtime.Object { return &apps.ControllerRevision{} }, + NewListFunc: func() runtime.Object { return &apps.ControllerRevisionList{} }, + PredicateFunc: controllerrevision.MatchControllerRevision, + DefaultQualifiedResource: apps.Resource("controllerrevisions"), + WatchCacheSize: cachesize.GetWatchCacheSizeByResource("controllerrevisions"), CreateStrategy: controllerrevision.Strategy, UpdateStrategy: controllerrevision.Strategy, diff --git a/pkg/registry/apps/statefulset/storage/storage.go b/pkg/registry/apps/statefulset/storage/storage.go index fc6d417c7fe..d40f1d14c5e 100644 --- a/pkg/registry/apps/statefulset/storage/storage.go +++ b/pkg/registry/apps/statefulset/storage/storage.go @@ -37,12 +37,12 @@ type REST struct { // NewREST returns a RESTStorage object that will work against replication controllers. func NewREST(optsGetter generic.RESTOptionsGetter) (*REST, *StatusREST) { store := &genericregistry.Store{ - Copier: api.Scheme, - NewFunc: func() runtime.Object { return &appsapi.StatefulSet{} }, - NewListFunc: func() runtime.Object { return &appsapi.StatefulSetList{} }, - PredicateFunc: statefulset.MatchStatefulSet, - QualifiedResource: appsapi.Resource("statefulsets"), - WatchCacheSize: cachesize.GetWatchCacheSizeByResource("statefulsets"), + Copier: api.Scheme, + NewFunc: func() runtime.Object { return &appsapi.StatefulSet{} }, + NewListFunc: func() runtime.Object { return &appsapi.StatefulSetList{} }, + PredicateFunc: statefulset.MatchStatefulSet, + DefaultQualifiedResource: appsapi.Resource("statefulsets"), + WatchCacheSize: cachesize.GetWatchCacheSizeByResource("statefulsets"), CreateStrategy: statefulset.Strategy, UpdateStrategy: statefulset.Strategy, diff --git a/pkg/registry/autoscaling/horizontalpodautoscaler/storage/storage.go b/pkg/registry/autoscaling/horizontalpodautoscaler/storage/storage.go index 33280d82233..3421192cd07 100644 --- a/pkg/registry/autoscaling/horizontalpodautoscaler/storage/storage.go +++ b/pkg/registry/autoscaling/horizontalpodautoscaler/storage/storage.go @@ -36,12 +36,12 @@ type REST struct { // NewREST returns a RESTStorage object that will work against horizontal pod autoscalers. func NewREST(optsGetter generic.RESTOptionsGetter) (*REST, *StatusREST) { store := &genericregistry.Store{ - Copier: api.Scheme, - NewFunc: func() runtime.Object { return &autoscaling.HorizontalPodAutoscaler{} }, - NewListFunc: func() runtime.Object { return &autoscaling.HorizontalPodAutoscalerList{} }, - PredicateFunc: horizontalpodautoscaler.MatchAutoscaler, - QualifiedResource: autoscaling.Resource("horizontalpodautoscalers"), - WatchCacheSize: cachesize.GetWatchCacheSizeByResource("horizontalpodautoscalers"), + Copier: api.Scheme, + NewFunc: func() runtime.Object { return &autoscaling.HorizontalPodAutoscaler{} }, + NewListFunc: func() runtime.Object { return &autoscaling.HorizontalPodAutoscalerList{} }, + PredicateFunc: horizontalpodautoscaler.MatchAutoscaler, + DefaultQualifiedResource: autoscaling.Resource("horizontalpodautoscalers"), + WatchCacheSize: cachesize.GetWatchCacheSizeByResource("horizontalpodautoscalers"), CreateStrategy: horizontalpodautoscaler.Strategy, UpdateStrategy: horizontalpodautoscaler.Strategy, diff --git a/pkg/registry/batch/cronjob/storage/storage.go b/pkg/registry/batch/cronjob/storage/storage.go index f4ada18bc6b..dbff7059b24 100644 --- a/pkg/registry/batch/cronjob/storage/storage.go +++ b/pkg/registry/batch/cronjob/storage/storage.go @@ -37,15 +37,14 @@ type REST struct { // NewREST returns a RESTStorage object that will work against CronJobs. func NewREST(optsGetter generic.RESTOptionsGetter) (*REST, *StatusREST) { store := &genericregistry.Store{ - Copier: api.Scheme, - NewFunc: func() runtime.Object { return &batch.CronJob{} }, - NewListFunc: func() runtime.Object { return &batch.CronJobList{} }, - QualifiedResource: batch.Resource("cronjobs"), - WatchCacheSize: cachesize.GetWatchCacheSizeByResource("cronjobs"), - - CreateStrategy: cronjob.Strategy, - UpdateStrategy: cronjob.Strategy, - DeleteStrategy: cronjob.Strategy, + Copier: api.Scheme, + NewFunc: func() runtime.Object { return &batch.CronJob{} }, + NewListFunc: func() runtime.Object { return &batch.CronJobList{} }, + DefaultQualifiedResource: batch.Resource("cronjobs"), + WatchCacheSize: cachesize.GetWatchCacheSizeByResource("cronjobs"), + CreateStrategy: cronjob.Strategy, + UpdateStrategy: cronjob.Strategy, + DeleteStrategy: cronjob.Strategy, } options := &generic.StoreOptions{RESTOptions: optsGetter} if err := store.CompleteWithOptions(options); err != nil { diff --git a/pkg/registry/batch/job/storage/storage.go b/pkg/registry/batch/job/storage/storage.go index 912c86e4827..aa52d251023 100644 --- a/pkg/registry/batch/job/storage/storage.go +++ b/pkg/registry/batch/job/storage/storage.go @@ -52,12 +52,12 @@ type REST struct { // NewREST returns a RESTStorage object that will work against Jobs. func NewREST(optsGetter generic.RESTOptionsGetter) (*REST, *StatusREST) { store := &genericregistry.Store{ - Copier: api.Scheme, - NewFunc: func() runtime.Object { return &batch.Job{} }, - NewListFunc: func() runtime.Object { return &batch.JobList{} }, - PredicateFunc: job.MatchJob, - QualifiedResource: batch.Resource("jobs"), - WatchCacheSize: cachesize.GetWatchCacheSizeByResource("jobs"), + Copier: api.Scheme, + NewFunc: func() runtime.Object { return &batch.Job{} }, + NewListFunc: func() runtime.Object { return &batch.JobList{} }, + PredicateFunc: job.MatchJob, + DefaultQualifiedResource: batch.Resource("jobs"), + WatchCacheSize: cachesize.GetWatchCacheSizeByResource("jobs"), CreateStrategy: job.Strategy, UpdateStrategy: job.Strategy, diff --git a/pkg/registry/certificates/certificates/storage/storage.go b/pkg/registry/certificates/certificates/storage/storage.go index f8f719a6642..2da56ee106f 100644 --- a/pkg/registry/certificates/certificates/storage/storage.go +++ b/pkg/registry/certificates/certificates/storage/storage.go @@ -36,12 +36,12 @@ type REST struct { // NewREST returns a registry which will store CertificateSigningRequest in the given helper func NewREST(optsGetter generic.RESTOptionsGetter) (*REST, *StatusREST, *ApprovalREST) { store := &genericregistry.Store{ - Copier: api.Scheme, - NewFunc: func() runtime.Object { return &certificates.CertificateSigningRequest{} }, - NewListFunc: func() runtime.Object { return &certificates.CertificateSigningRequestList{} }, - PredicateFunc: csrregistry.Matcher, - QualifiedResource: certificates.Resource("certificatesigningrequests"), - WatchCacheSize: cachesize.GetWatchCacheSizeByResource("certificatesigningrequests"), + Copier: api.Scheme, + NewFunc: func() runtime.Object { return &certificates.CertificateSigningRequest{} }, + NewListFunc: func() runtime.Object { return &certificates.CertificateSigningRequestList{} }, + PredicateFunc: csrregistry.Matcher, + DefaultQualifiedResource: certificates.Resource("certificatesigningrequests"), + WatchCacheSize: cachesize.GetWatchCacheSizeByResource("certificatesigningrequests"), CreateStrategy: csrregistry.Strategy, UpdateStrategy: csrregistry.Strategy, diff --git a/pkg/registry/core/configmap/storage/storage.go b/pkg/registry/core/configmap/storage/storage.go index 9931f24ff07..8aed341b7c0 100644 --- a/pkg/registry/core/configmap/storage/storage.go +++ b/pkg/registry/core/configmap/storage/storage.go @@ -34,12 +34,12 @@ type REST struct { // NewREST returns a RESTStorage object that will work with ConfigMap objects. func NewREST(optsGetter generic.RESTOptionsGetter) *REST { store := &genericregistry.Store{ - Copier: api.Scheme, - NewFunc: func() runtime.Object { return &api.ConfigMap{} }, - NewListFunc: func() runtime.Object { return &api.ConfigMapList{} }, - PredicateFunc: configmap.MatchConfigMap, - QualifiedResource: api.Resource("configmaps"), - WatchCacheSize: cachesize.GetWatchCacheSizeByResource("configmaps"), + Copier: api.Scheme, + NewFunc: func() runtime.Object { return &api.ConfigMap{} }, + NewListFunc: func() runtime.Object { return &api.ConfigMapList{} }, + PredicateFunc: configmap.MatchConfigMap, + DefaultQualifiedResource: api.Resource("configmaps"), + WatchCacheSize: cachesize.GetWatchCacheSizeByResource("configmaps"), CreateStrategy: configmap.Strategy, UpdateStrategy: configmap.Strategy, diff --git a/pkg/registry/core/endpoint/storage/storage.go b/pkg/registry/core/endpoint/storage/storage.go index f440066ac44..44abfc437a8 100644 --- a/pkg/registry/core/endpoint/storage/storage.go +++ b/pkg/registry/core/endpoint/storage/storage.go @@ -33,12 +33,12 @@ type REST struct { // NewREST returns a RESTStorage object that will work against endpoints. func NewREST(optsGetter generic.RESTOptionsGetter) *REST { store := &genericregistry.Store{ - Copier: api.Scheme, - NewFunc: func() runtime.Object { return &api.Endpoints{} }, - NewListFunc: func() runtime.Object { return &api.EndpointsList{} }, - PredicateFunc: endpoint.MatchEndpoints, - QualifiedResource: api.Resource("endpoints"), - WatchCacheSize: cachesize.GetWatchCacheSizeByResource("endpoints"), + Copier: api.Scheme, + NewFunc: func() runtime.Object { return &api.Endpoints{} }, + NewListFunc: func() runtime.Object { return &api.EndpointsList{} }, + PredicateFunc: endpoint.MatchEndpoints, + DefaultQualifiedResource: api.Resource("endpoints"), + WatchCacheSize: cachesize.GetWatchCacheSizeByResource("endpoints"), CreateStrategy: endpoint.Strategy, UpdateStrategy: endpoint.Strategy, diff --git a/pkg/registry/core/event/storage/storage.go b/pkg/registry/core/event/storage/storage.go index 125f36de5c6..abc030be1fb 100644 --- a/pkg/registry/core/event/storage/storage.go +++ b/pkg/registry/core/event/storage/storage.go @@ -50,8 +50,8 @@ func NewREST(optsGetter generic.RESTOptionsGetter, ttl uint64) *REST { TTLFunc: func(runtime.Object, uint64, bool) (uint64, error) { return ttl, nil }, - QualifiedResource: resource, - WatchCacheSize: cachesize.GetWatchCacheSizeByResource(resource.Resource), + DefaultQualifiedResource: resource, + WatchCacheSize: cachesize.GetWatchCacheSizeByResource(resource.Resource), CreateStrategy: event.Strategy, UpdateStrategy: event.Strategy, diff --git a/pkg/registry/core/limitrange/storage/storage.go b/pkg/registry/core/limitrange/storage/storage.go index bfe7e91a3b7..ba29960e362 100644 --- a/pkg/registry/core/limitrange/storage/storage.go +++ b/pkg/registry/core/limitrange/storage/storage.go @@ -33,12 +33,12 @@ type REST struct { // NewREST returns a RESTStorage object that will work against horizontal pod autoscalers. func NewREST(optsGetter generic.RESTOptionsGetter) *REST { store := &genericregistry.Store{ - Copier: api.Scheme, - NewFunc: func() runtime.Object { return &api.LimitRange{} }, - NewListFunc: func() runtime.Object { return &api.LimitRangeList{} }, - PredicateFunc: limitrange.MatchLimitRange, - QualifiedResource: api.Resource("limitranges"), - WatchCacheSize: cachesize.GetWatchCacheSizeByResource("limitranges"), + Copier: api.Scheme, + NewFunc: func() runtime.Object { return &api.LimitRange{} }, + NewListFunc: func() runtime.Object { return &api.LimitRangeList{} }, + PredicateFunc: limitrange.MatchLimitRange, + DefaultQualifiedResource: api.Resource("limitranges"), + WatchCacheSize: cachesize.GetWatchCacheSizeByResource("limitranges"), CreateStrategy: limitrange.Strategy, UpdateStrategy: limitrange.Strategy, diff --git a/pkg/registry/core/namespace/storage/storage.go b/pkg/registry/core/namespace/storage/storage.go index f1c7ffc2df2..0b3edf132d5 100644 --- a/pkg/registry/core/namespace/storage/storage.go +++ b/pkg/registry/core/namespace/storage/storage.go @@ -54,12 +54,12 @@ type FinalizeREST struct { // NewREST returns a RESTStorage object that will work against namespaces. func NewREST(optsGetter generic.RESTOptionsGetter) (*REST, *StatusREST, *FinalizeREST) { store := &genericregistry.Store{ - Copier: api.Scheme, - NewFunc: func() runtime.Object { return &api.Namespace{} }, - NewListFunc: func() runtime.Object { return &api.NamespaceList{} }, - PredicateFunc: namespace.MatchNamespace, - QualifiedResource: api.Resource("namespaces"), - WatchCacheSize: cachesize.GetWatchCacheSizeByResource("namespaces"), + Copier: api.Scheme, + NewFunc: func() runtime.Object { return &api.Namespace{} }, + NewListFunc: func() runtime.Object { return &api.NamespaceList{} }, + PredicateFunc: namespace.MatchNamespace, + DefaultQualifiedResource: api.Resource("namespaces"), + WatchCacheSize: cachesize.GetWatchCacheSizeByResource("namespaces"), CreateStrategy: namespace.Strategy, UpdateStrategy: namespace.Strategy, diff --git a/pkg/registry/core/node/storage/storage.go b/pkg/registry/core/node/storage/storage.go index 32aab18e7be..fb9e6c2fcdb 100644 --- a/pkg/registry/core/node/storage/storage.go +++ b/pkg/registry/core/node/storage/storage.go @@ -73,12 +73,12 @@ func (r *StatusREST) Update(ctx genericapirequest.Context, name string, objInfo // NewStorage returns a NodeStorage object that will work against nodes. func NewStorage(optsGetter generic.RESTOptionsGetter, kubeletClientConfig client.KubeletClientConfig, proxyTransport http.RoundTripper) (*NodeStorage, error) { store := &genericregistry.Store{ - Copier: api.Scheme, - NewFunc: func() runtime.Object { return &api.Node{} }, - NewListFunc: func() runtime.Object { return &api.NodeList{} }, - PredicateFunc: node.MatchNode, - QualifiedResource: api.Resource("nodes"), - WatchCacheSize: cachesize.GetWatchCacheSizeByResource("nodes"), + Copier: api.Scheme, + NewFunc: func() runtime.Object { return &api.Node{} }, + NewListFunc: func() runtime.Object { return &api.NodeList{} }, + PredicateFunc: node.MatchNode, + DefaultQualifiedResource: api.Resource("nodes"), + WatchCacheSize: cachesize.GetWatchCacheSizeByResource("nodes"), CreateStrategy: node.Strategy, UpdateStrategy: node.Strategy, diff --git a/pkg/registry/core/persistentvolume/storage/storage.go b/pkg/registry/core/persistentvolume/storage/storage.go index 8bc34e578ba..7c69f7eb812 100644 --- a/pkg/registry/core/persistentvolume/storage/storage.go +++ b/pkg/registry/core/persistentvolume/storage/storage.go @@ -35,12 +35,12 @@ type REST struct { // NewREST returns a RESTStorage object that will work against persistent volumes. func NewREST(optsGetter generic.RESTOptionsGetter) (*REST, *StatusREST) { store := &genericregistry.Store{ - Copier: api.Scheme, - NewFunc: func() runtime.Object { return &api.PersistentVolume{} }, - NewListFunc: func() runtime.Object { return &api.PersistentVolumeList{} }, - PredicateFunc: persistentvolume.MatchPersistentVolumes, - QualifiedResource: api.Resource("persistentvolumes"), - WatchCacheSize: cachesize.GetWatchCacheSizeByResource("persistentvolumes"), + Copier: api.Scheme, + NewFunc: func() runtime.Object { return &api.PersistentVolume{} }, + NewListFunc: func() runtime.Object { return &api.PersistentVolumeList{} }, + PredicateFunc: persistentvolume.MatchPersistentVolumes, + DefaultQualifiedResource: api.Resource("persistentvolumes"), + WatchCacheSize: cachesize.GetWatchCacheSizeByResource("persistentvolumes"), CreateStrategy: persistentvolume.Strategy, UpdateStrategy: persistentvolume.Strategy, diff --git a/pkg/registry/core/persistentvolumeclaim/storage/storage.go b/pkg/registry/core/persistentvolumeclaim/storage/storage.go index 79c23de7f0d..d5295dbf631 100644 --- a/pkg/registry/core/persistentvolumeclaim/storage/storage.go +++ b/pkg/registry/core/persistentvolumeclaim/storage/storage.go @@ -35,12 +35,12 @@ type REST struct { // NewREST returns a RESTStorage object that will work against persistent volume claims. func NewREST(optsGetter generic.RESTOptionsGetter) (*REST, *StatusREST) { store := &genericregistry.Store{ - Copier: api.Scheme, - NewFunc: func() runtime.Object { return &api.PersistentVolumeClaim{} }, - NewListFunc: func() runtime.Object { return &api.PersistentVolumeClaimList{} }, - PredicateFunc: persistentvolumeclaim.MatchPersistentVolumeClaim, - QualifiedResource: api.Resource("persistentvolumeclaims"), - WatchCacheSize: cachesize.GetWatchCacheSizeByResource("persistentvolumeclaims"), + Copier: api.Scheme, + NewFunc: func() runtime.Object { return &api.PersistentVolumeClaim{} }, + NewListFunc: func() runtime.Object { return &api.PersistentVolumeClaimList{} }, + PredicateFunc: persistentvolumeclaim.MatchPersistentVolumeClaim, + DefaultQualifiedResource: api.Resource("persistentvolumeclaims"), + WatchCacheSize: cachesize.GetWatchCacheSizeByResource("persistentvolumeclaims"), CreateStrategy: persistentvolumeclaim.Strategy, UpdateStrategy: persistentvolumeclaim.Strategy, diff --git a/pkg/registry/core/pod/storage/storage.go b/pkg/registry/core/pod/storage/storage.go index ca58827d832..83b20d588ef 100644 --- a/pkg/registry/core/pod/storage/storage.go +++ b/pkg/registry/core/pod/storage/storage.go @@ -66,12 +66,12 @@ type REST struct { func NewStorage(optsGetter generic.RESTOptionsGetter, k client.ConnectionInfoGetter, proxyTransport http.RoundTripper, podDisruptionBudgetClient policyclient.PodDisruptionBudgetsGetter) PodStorage { store := &genericregistry.Store{ - Copier: api.Scheme, - NewFunc: func() runtime.Object { return &api.Pod{} }, - NewListFunc: func() runtime.Object { return &api.PodList{} }, - PredicateFunc: pod.MatchPod, - QualifiedResource: api.Resource("pods"), - WatchCacheSize: cachesize.GetWatchCacheSizeByResource("pods"), + Copier: api.Scheme, + NewFunc: func() runtime.Object { return &api.Pod{} }, + NewListFunc: func() runtime.Object { return &api.PodList{} }, + PredicateFunc: pod.MatchPod, + DefaultQualifiedResource: api.Resource("pods"), + WatchCacheSize: cachesize.GetWatchCacheSizeByResource("pods"), CreateStrategy: pod.Strategy, UpdateStrategy: pod.Strategy, diff --git a/pkg/registry/core/podtemplate/storage/storage.go b/pkg/registry/core/podtemplate/storage/storage.go index 0a9e67c1ffc..13d1d436594 100644 --- a/pkg/registry/core/podtemplate/storage/storage.go +++ b/pkg/registry/core/podtemplate/storage/storage.go @@ -32,12 +32,12 @@ type REST struct { // NewREST returns a RESTStorage object that will work against pod templates. func NewREST(optsGetter generic.RESTOptionsGetter) *REST { store := &genericregistry.Store{ - Copier: api.Scheme, - NewFunc: func() runtime.Object { return &api.PodTemplate{} }, - NewListFunc: func() runtime.Object { return &api.PodTemplateList{} }, - PredicateFunc: podtemplate.MatchPodTemplate, - QualifiedResource: api.Resource("podtemplates"), - WatchCacheSize: cachesize.GetWatchCacheSizeByResource("podtemplates"), + Copier: api.Scheme, + NewFunc: func() runtime.Object { return &api.PodTemplate{} }, + NewListFunc: func() runtime.Object { return &api.PodTemplateList{} }, + PredicateFunc: podtemplate.MatchPodTemplate, + DefaultQualifiedResource: api.Resource("podtemplates"), + WatchCacheSize: cachesize.GetWatchCacheSizeByResource("podtemplates"), CreateStrategy: podtemplate.Strategy, UpdateStrategy: podtemplate.Strategy, diff --git a/pkg/registry/core/replicationcontroller/storage/storage.go b/pkg/registry/core/replicationcontroller/storage/storage.go index 54b84f4246a..1d0bb1e76e9 100644 --- a/pkg/registry/core/replicationcontroller/storage/storage.go +++ b/pkg/registry/core/replicationcontroller/storage/storage.go @@ -61,12 +61,12 @@ type REST struct { // NewREST returns a RESTStorage object that will work against replication controllers. func NewREST(optsGetter generic.RESTOptionsGetter) (*REST, *StatusREST) { store := &genericregistry.Store{ - Copier: api.Scheme, - NewFunc: func() runtime.Object { return &api.ReplicationController{} }, - NewListFunc: func() runtime.Object { return &api.ReplicationControllerList{} }, - PredicateFunc: replicationcontroller.MatchController, - QualifiedResource: api.Resource("replicationcontrollers"), - WatchCacheSize: cachesize.GetWatchCacheSizeByResource("replicationcontrollers"), + Copier: api.Scheme, + NewFunc: func() runtime.Object { return &api.ReplicationController{} }, + NewListFunc: func() runtime.Object { return &api.ReplicationControllerList{} }, + PredicateFunc: replicationcontroller.MatchController, + DefaultQualifiedResource: api.Resource("replicationcontrollers"), + WatchCacheSize: cachesize.GetWatchCacheSizeByResource("replicationcontrollers"), CreateStrategy: replicationcontroller.Strategy, UpdateStrategy: replicationcontroller.Strategy, diff --git a/pkg/registry/core/resourcequota/storage/storage.go b/pkg/registry/core/resourcequota/storage/storage.go index a54df9271ae..90638de8a6f 100644 --- a/pkg/registry/core/resourcequota/storage/storage.go +++ b/pkg/registry/core/resourcequota/storage/storage.go @@ -35,12 +35,12 @@ type REST struct { // NewREST returns a RESTStorage object that will work against resource quotas. func NewREST(optsGetter generic.RESTOptionsGetter) (*REST, *StatusREST) { store := &genericregistry.Store{ - Copier: api.Scheme, - NewFunc: func() runtime.Object { return &api.ResourceQuota{} }, - NewListFunc: func() runtime.Object { return &api.ResourceQuotaList{} }, - PredicateFunc: resourcequota.MatchResourceQuota, - QualifiedResource: api.Resource("resourcequotas"), - WatchCacheSize: cachesize.GetWatchCacheSizeByResource("resourcequotas"), + Copier: api.Scheme, + NewFunc: func() runtime.Object { return &api.ResourceQuota{} }, + NewListFunc: func() runtime.Object { return &api.ResourceQuotaList{} }, + PredicateFunc: resourcequota.MatchResourceQuota, + DefaultQualifiedResource: api.Resource("resourcequotas"), + WatchCacheSize: cachesize.GetWatchCacheSizeByResource("resourcequotas"), CreateStrategy: resourcequota.Strategy, UpdateStrategy: resourcequota.Strategy, diff --git a/pkg/registry/core/secret/storage/storage.go b/pkg/registry/core/secret/storage/storage.go index 7bb7b268752..8dc5592eed0 100644 --- a/pkg/registry/core/secret/storage/storage.go +++ b/pkg/registry/core/secret/storage/storage.go @@ -32,12 +32,12 @@ type REST struct { // NewREST returns a RESTStorage object that will work against secrets. func NewREST(optsGetter generic.RESTOptionsGetter) *REST { store := &genericregistry.Store{ - Copier: api.Scheme, - NewFunc: func() runtime.Object { return &api.Secret{} }, - NewListFunc: func() runtime.Object { return &api.SecretList{} }, - PredicateFunc: secret.Matcher, - QualifiedResource: api.Resource("secrets"), - WatchCacheSize: cachesize.GetWatchCacheSizeByResource("secrets"), + Copier: api.Scheme, + NewFunc: func() runtime.Object { return &api.Secret{} }, + NewListFunc: func() runtime.Object { return &api.SecretList{} }, + PredicateFunc: secret.Matcher, + DefaultQualifiedResource: api.Resource("secrets"), + WatchCacheSize: cachesize.GetWatchCacheSizeByResource("secrets"), CreateStrategy: secret.Strategy, UpdateStrategy: secret.Strategy, diff --git a/pkg/registry/core/service/storage/storage.go b/pkg/registry/core/service/storage/storage.go index 4551ba39715..6192b2842c8 100644 --- a/pkg/registry/core/service/storage/storage.go +++ b/pkg/registry/core/service/storage/storage.go @@ -35,12 +35,12 @@ type REST struct { // NewREST returns a RESTStorage object that will work against services. func NewREST(optsGetter generic.RESTOptionsGetter) (*REST, *StatusREST) { store := &genericregistry.Store{ - Copier: api.Scheme, - NewFunc: func() runtime.Object { return &api.Service{} }, - NewListFunc: func() runtime.Object { return &api.ServiceList{} }, - PredicateFunc: service.MatchServices, - QualifiedResource: api.Resource("services"), - WatchCacheSize: cachesize.GetWatchCacheSizeByResource("services"), + Copier: api.Scheme, + NewFunc: func() runtime.Object { return &api.Service{} }, + NewListFunc: func() runtime.Object { return &api.ServiceList{} }, + PredicateFunc: service.MatchServices, + DefaultQualifiedResource: api.Resource("services"), + WatchCacheSize: cachesize.GetWatchCacheSizeByResource("services"), CreateStrategy: service.Strategy, UpdateStrategy: service.Strategy, diff --git a/pkg/registry/core/serviceaccount/storage/storage.go b/pkg/registry/core/serviceaccount/storage/storage.go index 7fb488aea79..3c9b1d26e94 100644 --- a/pkg/registry/core/serviceaccount/storage/storage.go +++ b/pkg/registry/core/serviceaccount/storage/storage.go @@ -33,12 +33,12 @@ type REST struct { // NewREST returns a RESTStorage object that will work against service accounts. func NewREST(optsGetter generic.RESTOptionsGetter) *REST { store := &genericregistry.Store{ - Copier: api.Scheme, - NewFunc: func() runtime.Object { return &api.ServiceAccount{} }, - NewListFunc: func() runtime.Object { return &api.ServiceAccountList{} }, - PredicateFunc: serviceaccount.Matcher, - QualifiedResource: api.Resource("serviceaccounts"), - WatchCacheSize: cachesize.GetWatchCacheSizeByResource("serviceaccounts"), + Copier: api.Scheme, + NewFunc: func() runtime.Object { return &api.ServiceAccount{} }, + NewListFunc: func() runtime.Object { return &api.ServiceAccountList{} }, + PredicateFunc: serviceaccount.Matcher, + DefaultQualifiedResource: api.Resource("serviceaccounts"), + WatchCacheSize: cachesize.GetWatchCacheSizeByResource("serviceaccounts"), CreateStrategy: serviceaccount.Strategy, UpdateStrategy: serviceaccount.Strategy, diff --git a/pkg/registry/extensions/daemonset/storage/storage.go b/pkg/registry/extensions/daemonset/storage/storage.go index 233b4d61e12..86e7e45c2fb 100644 --- a/pkg/registry/extensions/daemonset/storage/storage.go +++ b/pkg/registry/extensions/daemonset/storage/storage.go @@ -37,12 +37,12 @@ type REST struct { // NewREST returns a RESTStorage object that will work against DaemonSets. func NewREST(optsGetter generic.RESTOptionsGetter) (*REST, *StatusREST) { store := &genericregistry.Store{ - Copier: api.Scheme, - NewFunc: func() runtime.Object { return &extensions.DaemonSet{} }, - NewListFunc: func() runtime.Object { return &extensions.DaemonSetList{} }, - PredicateFunc: daemonset.MatchDaemonSet, - QualifiedResource: extensions.Resource("daemonsets"), - WatchCacheSize: cachesize.GetWatchCacheSizeByResource("daemonsets"), + Copier: api.Scheme, + NewFunc: func() runtime.Object { return &extensions.DaemonSet{} }, + NewListFunc: func() runtime.Object { return &extensions.DaemonSetList{} }, + PredicateFunc: daemonset.MatchDaemonSet, + DefaultQualifiedResource: extensions.Resource("daemonsets"), + WatchCacheSize: cachesize.GetWatchCacheSizeByResource("daemonsets"), CreateStrategy: daemonset.Strategy, UpdateStrategy: daemonset.Strategy, diff --git a/pkg/registry/extensions/deployment/storage/storage.go b/pkg/registry/extensions/deployment/storage/storage.go index 55fa90b6cbc..d747ecad8af 100644 --- a/pkg/registry/extensions/deployment/storage/storage.go +++ b/pkg/registry/extensions/deployment/storage/storage.go @@ -63,12 +63,12 @@ type REST struct { // NewREST returns a RESTStorage object that will work against deployments. func NewREST(optsGetter generic.RESTOptionsGetter) (*REST, *StatusREST, *RollbackREST) { store := &genericregistry.Store{ - Copier: api.Scheme, - NewFunc: func() runtime.Object { return &extensions.Deployment{} }, - NewListFunc: func() runtime.Object { return &extensions.DeploymentList{} }, - PredicateFunc: deployment.MatchDeployment, - QualifiedResource: extensions.Resource("deployments"), - WatchCacheSize: cachesize.GetWatchCacheSizeByResource("deployments"), + Copier: api.Scheme, + NewFunc: func() runtime.Object { return &extensions.Deployment{} }, + NewListFunc: func() runtime.Object { return &extensions.DeploymentList{} }, + PredicateFunc: deployment.MatchDeployment, + DefaultQualifiedResource: extensions.Resource("deployments"), + WatchCacheSize: cachesize.GetWatchCacheSizeByResource("deployments"), CreateStrategy: deployment.Strategy, UpdateStrategy: deployment.Strategy, diff --git a/pkg/registry/extensions/ingress/storage/storage.go b/pkg/registry/extensions/ingress/storage/storage.go index e4e8601ef3b..8b891a6209a 100644 --- a/pkg/registry/extensions/ingress/storage/storage.go +++ b/pkg/registry/extensions/ingress/storage/storage.go @@ -37,12 +37,12 @@ type REST struct { // NewREST returns a RESTStorage object that will work against replication controllers. func NewREST(optsGetter generic.RESTOptionsGetter) (*REST, *StatusREST) { store := &genericregistry.Store{ - Copier: api.Scheme, - NewFunc: func() runtime.Object { return &extensions.Ingress{} }, - NewListFunc: func() runtime.Object { return &extensions.IngressList{} }, - PredicateFunc: ingress.MatchIngress, - QualifiedResource: extensions.Resource("ingresses"), - WatchCacheSize: cachesize.GetWatchCacheSizeByResource("ingresses"), + Copier: api.Scheme, + NewFunc: func() runtime.Object { return &extensions.Ingress{} }, + NewListFunc: func() runtime.Object { return &extensions.IngressList{} }, + PredicateFunc: ingress.MatchIngress, + DefaultQualifiedResource: extensions.Resource("ingresses"), + WatchCacheSize: cachesize.GetWatchCacheSizeByResource("ingresses"), CreateStrategy: ingress.Strategy, UpdateStrategy: ingress.Strategy, diff --git a/pkg/registry/extensions/networkpolicy/storage/storage.go b/pkg/registry/extensions/networkpolicy/storage/storage.go index 5f4ebaa31b2..8bb412a4a0d 100644 --- a/pkg/registry/extensions/networkpolicy/storage/storage.go +++ b/pkg/registry/extensions/networkpolicy/storage/storage.go @@ -34,12 +34,12 @@ type REST struct { // NewREST returns a RESTStorage object that will work against network policies. func NewREST(optsGetter generic.RESTOptionsGetter) *REST { store := &genericregistry.Store{ - Copier: api.Scheme, - NewFunc: func() runtime.Object { return &extensionsapi.NetworkPolicy{} }, - NewListFunc: func() runtime.Object { return &extensionsapi.NetworkPolicyList{} }, - PredicateFunc: networkpolicy.MatchNetworkPolicy, - QualifiedResource: extensionsapi.Resource("networkpolicies"), - WatchCacheSize: cachesize.GetWatchCacheSizeByResource("networkpolicies"), + Copier: api.Scheme, + NewFunc: func() runtime.Object { return &extensionsapi.NetworkPolicy{} }, + NewListFunc: func() runtime.Object { return &extensionsapi.NetworkPolicyList{} }, + PredicateFunc: networkpolicy.MatchNetworkPolicy, + DefaultQualifiedResource: extensionsapi.Resource("networkpolicies"), + WatchCacheSize: cachesize.GetWatchCacheSizeByResource("networkpolicies"), CreateStrategy: networkpolicy.Strategy, UpdateStrategy: networkpolicy.Strategy, diff --git a/pkg/registry/extensions/podsecuritypolicy/storage/storage.go b/pkg/registry/extensions/podsecuritypolicy/storage/storage.go index 7ba363699f7..eff8d11b76e 100644 --- a/pkg/registry/extensions/podsecuritypolicy/storage/storage.go +++ b/pkg/registry/extensions/podsecuritypolicy/storage/storage.go @@ -34,12 +34,12 @@ type REST struct { // NewREST returns a RESTStorage object that will work against PodSecurityPolicy objects. func NewREST(optsGetter generic.RESTOptionsGetter) *REST { store := &genericregistry.Store{ - Copier: api.Scheme, - NewFunc: func() runtime.Object { return &extensions.PodSecurityPolicy{} }, - NewListFunc: func() runtime.Object { return &extensions.PodSecurityPolicyList{} }, - PredicateFunc: podsecuritypolicy.MatchPodSecurityPolicy, - QualifiedResource: extensions.Resource("podsecuritypolicies"), - WatchCacheSize: cachesize.GetWatchCacheSizeByResource("podsecuritypolicies"), + Copier: api.Scheme, + NewFunc: func() runtime.Object { return &extensions.PodSecurityPolicy{} }, + NewListFunc: func() runtime.Object { return &extensions.PodSecurityPolicyList{} }, + PredicateFunc: podsecuritypolicy.MatchPodSecurityPolicy, + DefaultQualifiedResource: extensions.Resource("podsecuritypolicies"), + WatchCacheSize: cachesize.GetWatchCacheSizeByResource("podsecuritypolicies"), CreateStrategy: podsecuritypolicy.Strategy, UpdateStrategy: podsecuritypolicy.Strategy, diff --git a/pkg/registry/extensions/replicaset/storage/storage.go b/pkg/registry/extensions/replicaset/storage/storage.go index 78e0ecc6567..b10c455ae91 100644 --- a/pkg/registry/extensions/replicaset/storage/storage.go +++ b/pkg/registry/extensions/replicaset/storage/storage.go @@ -60,12 +60,12 @@ type REST struct { // NewREST returns a RESTStorage object that will work against ReplicaSet. func NewREST(optsGetter generic.RESTOptionsGetter) (*REST, *StatusREST) { store := &genericregistry.Store{ - Copier: api.Scheme, - NewFunc: func() runtime.Object { return &extensions.ReplicaSet{} }, - NewListFunc: func() runtime.Object { return &extensions.ReplicaSetList{} }, - PredicateFunc: replicaset.MatchReplicaSet, - QualifiedResource: extensions.Resource("replicasets"), - WatchCacheSize: cachesize.GetWatchCacheSizeByResource("replicasets"), + Copier: api.Scheme, + NewFunc: func() runtime.Object { return &extensions.ReplicaSet{} }, + NewListFunc: func() runtime.Object { return &extensions.ReplicaSetList{} }, + PredicateFunc: replicaset.MatchReplicaSet, + DefaultQualifiedResource: extensions.Resource("replicasets"), + WatchCacheSize: cachesize.GetWatchCacheSizeByResource("replicasets"), CreateStrategy: replicaset.Strategy, UpdateStrategy: replicaset.Strategy, diff --git a/pkg/registry/networking/networkpolicy/storage/storage.go b/pkg/registry/networking/networkpolicy/storage/storage.go index 4779813a4f9..3e26dd33751 100644 --- a/pkg/registry/networking/networkpolicy/storage/storage.go +++ b/pkg/registry/networking/networkpolicy/storage/storage.go @@ -35,12 +35,12 @@ type REST struct { // NewREST returns a RESTStorage object that will work against NetworkPolicies func NewREST(optsGetter generic.RESTOptionsGetter) *REST { store := &genericregistry.Store{ - Copier: api.Scheme, - NewFunc: func() runtime.Object { return &networkingapi.NetworkPolicy{} }, - NewListFunc: func() runtime.Object { return &networkingapi.NetworkPolicyList{} }, - PredicateFunc: networkpolicy.Matcher, - QualifiedResource: networkingapi.Resource("networkpolicies"), - WatchCacheSize: cachesize.GetWatchCacheSizeByResource("networkpolicies"), + Copier: api.Scheme, + NewFunc: func() runtime.Object { return &networkingapi.NetworkPolicy{} }, + NewListFunc: func() runtime.Object { return &networkingapi.NetworkPolicyList{} }, + PredicateFunc: networkpolicy.Matcher, + DefaultQualifiedResource: networkingapi.Resource("networkpolicies"), + WatchCacheSize: cachesize.GetWatchCacheSizeByResource("networkpolicies"), CreateStrategy: networkpolicy.Strategy, UpdateStrategy: networkpolicy.Strategy, diff --git a/pkg/registry/policy/poddisruptionbudget/storage/storage.go b/pkg/registry/policy/poddisruptionbudget/storage/storage.go index 99777872c15..2daa230365d 100644 --- a/pkg/registry/policy/poddisruptionbudget/storage/storage.go +++ b/pkg/registry/policy/poddisruptionbudget/storage/storage.go @@ -37,12 +37,12 @@ type REST struct { // NewREST returns a RESTStorage object that will work against pod disruption budgets. func NewREST(optsGetter generic.RESTOptionsGetter) (*REST, *StatusREST) { store := &genericregistry.Store{ - Copier: api.Scheme, - NewFunc: func() runtime.Object { return &policyapi.PodDisruptionBudget{} }, - NewListFunc: func() runtime.Object { return &policyapi.PodDisruptionBudgetList{} }, - PredicateFunc: poddisruptionbudget.MatchPodDisruptionBudget, - QualifiedResource: policyapi.Resource("poddisruptionbudgets"), - WatchCacheSize: cachesize.GetWatchCacheSizeByResource("poddisruptionbudgets"), + Copier: api.Scheme, + NewFunc: func() runtime.Object { return &policyapi.PodDisruptionBudget{} }, + NewListFunc: func() runtime.Object { return &policyapi.PodDisruptionBudgetList{} }, + PredicateFunc: poddisruptionbudget.MatchPodDisruptionBudget, + DefaultQualifiedResource: policyapi.Resource("poddisruptionbudgets"), + WatchCacheSize: cachesize.GetWatchCacheSizeByResource("poddisruptionbudgets"), CreateStrategy: poddisruptionbudget.Strategy, UpdateStrategy: poddisruptionbudget.Strategy, diff --git a/pkg/registry/rbac/clusterrole/storage/storage.go b/pkg/registry/rbac/clusterrole/storage/storage.go index 119dca07613..e434280a409 100644 --- a/pkg/registry/rbac/clusterrole/storage/storage.go +++ b/pkg/registry/rbac/clusterrole/storage/storage.go @@ -34,12 +34,12 @@ type REST struct { // NewREST returns a RESTStorage object that will work against ClusterRole objects. func NewREST(optsGetter generic.RESTOptionsGetter) *REST { store := &genericregistry.Store{ - Copier: api.Scheme, - NewFunc: func() runtime.Object { return &rbac.ClusterRole{} }, - NewListFunc: func() runtime.Object { return &rbac.ClusterRoleList{} }, - PredicateFunc: clusterrole.Matcher, - QualifiedResource: rbac.Resource("clusterroles"), - WatchCacheSize: cachesize.GetWatchCacheSizeByResource("clusterroles"), + Copier: api.Scheme, + NewFunc: func() runtime.Object { return &rbac.ClusterRole{} }, + NewListFunc: func() runtime.Object { return &rbac.ClusterRoleList{} }, + PredicateFunc: clusterrole.Matcher, + DefaultQualifiedResource: rbac.Resource("clusterroles"), + WatchCacheSize: cachesize.GetWatchCacheSizeByResource("clusterroles"), CreateStrategy: clusterrole.Strategy, UpdateStrategy: clusterrole.Strategy, diff --git a/pkg/registry/rbac/clusterrolebinding/storage/storage.go b/pkg/registry/rbac/clusterrolebinding/storage/storage.go index ccc7f8df76f..2cb178ca63f 100644 --- a/pkg/registry/rbac/clusterrolebinding/storage/storage.go +++ b/pkg/registry/rbac/clusterrolebinding/storage/storage.go @@ -34,12 +34,12 @@ type REST struct { // NewREST returns a RESTStorage object that will work against ClusterRoleBinding objects. func NewREST(optsGetter generic.RESTOptionsGetter) *REST { store := &genericregistry.Store{ - Copier: api.Scheme, - NewFunc: func() runtime.Object { return &rbac.ClusterRoleBinding{} }, - NewListFunc: func() runtime.Object { return &rbac.ClusterRoleBindingList{} }, - PredicateFunc: clusterrolebinding.Matcher, - QualifiedResource: rbac.Resource("clusterrolebindings"), - WatchCacheSize: cachesize.GetWatchCacheSizeByResource("clusterrolebindings"), + Copier: api.Scheme, + NewFunc: func() runtime.Object { return &rbac.ClusterRoleBinding{} }, + NewListFunc: func() runtime.Object { return &rbac.ClusterRoleBindingList{} }, + PredicateFunc: clusterrolebinding.Matcher, + DefaultQualifiedResource: rbac.Resource("clusterrolebindings"), + WatchCacheSize: cachesize.GetWatchCacheSizeByResource("clusterrolebindings"), CreateStrategy: clusterrolebinding.Strategy, UpdateStrategy: clusterrolebinding.Strategy, diff --git a/pkg/registry/rbac/role/storage/storage.go b/pkg/registry/rbac/role/storage/storage.go index 039587d411e..18f17867252 100644 --- a/pkg/registry/rbac/role/storage/storage.go +++ b/pkg/registry/rbac/role/storage/storage.go @@ -34,12 +34,12 @@ type REST struct { // NewREST returns a RESTStorage object that will work against Role objects. func NewREST(optsGetter generic.RESTOptionsGetter) *REST { store := &genericregistry.Store{ - Copier: api.Scheme, - NewFunc: func() runtime.Object { return &rbac.Role{} }, - NewListFunc: func() runtime.Object { return &rbac.RoleList{} }, - PredicateFunc: role.Matcher, - QualifiedResource: rbac.Resource("roles"), - WatchCacheSize: cachesize.GetWatchCacheSizeByResource("roles"), + Copier: api.Scheme, + NewFunc: func() runtime.Object { return &rbac.Role{} }, + NewListFunc: func() runtime.Object { return &rbac.RoleList{} }, + PredicateFunc: role.Matcher, + DefaultQualifiedResource: rbac.Resource("roles"), + WatchCacheSize: cachesize.GetWatchCacheSizeByResource("roles"), CreateStrategy: role.Strategy, UpdateStrategy: role.Strategy, diff --git a/pkg/registry/rbac/rolebinding/storage/storage.go b/pkg/registry/rbac/rolebinding/storage/storage.go index 641ffab63f9..3ccf4f72cf6 100644 --- a/pkg/registry/rbac/rolebinding/storage/storage.go +++ b/pkg/registry/rbac/rolebinding/storage/storage.go @@ -34,12 +34,12 @@ type REST struct { // NewREST returns a RESTStorage object that will work against RoleBinding objects. func NewREST(optsGetter generic.RESTOptionsGetter) *REST { store := &genericregistry.Store{ - Copier: api.Scheme, - NewFunc: func() runtime.Object { return &rbac.RoleBinding{} }, - NewListFunc: func() runtime.Object { return &rbac.RoleBindingList{} }, - PredicateFunc: rolebinding.Matcher, - QualifiedResource: rbac.Resource("rolebindings"), - WatchCacheSize: cachesize.GetWatchCacheSizeByResource("rolebindings"), + Copier: api.Scheme, + NewFunc: func() runtime.Object { return &rbac.RoleBinding{} }, + NewListFunc: func() runtime.Object { return &rbac.RoleBindingList{} }, + PredicateFunc: rolebinding.Matcher, + DefaultQualifiedResource: rbac.Resource("rolebindings"), + WatchCacheSize: cachesize.GetWatchCacheSizeByResource("rolebindings"), CreateStrategy: rolebinding.Strategy, UpdateStrategy: rolebinding.Strategy, diff --git a/pkg/registry/scheduling/priorityclass/storage/storage.go b/pkg/registry/scheduling/priorityclass/storage/storage.go index e24a319f680..5f2ba014b5d 100644 --- a/pkg/registry/scheduling/priorityclass/storage/storage.go +++ b/pkg/registry/scheduling/priorityclass/storage/storage.go @@ -35,12 +35,12 @@ type REST struct { // NewREST returns a RESTStorage object that will work against priority classes. func NewREST(optsGetter generic.RESTOptionsGetter) *REST { store := &genericregistry.Store{ - Copier: api.Scheme, - NewFunc: func() runtime.Object { return &schedulingapi.PriorityClass{} }, - NewListFunc: func() runtime.Object { return &schedulingapi.PriorityClassList{} }, - PredicateFunc: priorityclass.Matcher, - QualifiedResource: schedulingapi.Resource("priorityclasses"), - WatchCacheSize: cachesize.GetWatchCacheSizeByResource("priorityclasses"), + Copier: api.Scheme, + NewFunc: func() runtime.Object { return &schedulingapi.PriorityClass{} }, + NewListFunc: func() runtime.Object { return &schedulingapi.PriorityClassList{} }, + PredicateFunc: priorityclass.Matcher, + DefaultQualifiedResource: schedulingapi.Resource("priorityclasses"), + WatchCacheSize: cachesize.GetWatchCacheSizeByResource("priorityclasses"), CreateStrategy: priorityclass.Strategy, UpdateStrategy: priorityclass.Strategy, diff --git a/pkg/registry/settings/podpreset/storage/storage.go b/pkg/registry/settings/podpreset/storage/storage.go index 233146c3194..4d1c7ca54b5 100644 --- a/pkg/registry/settings/podpreset/storage/storage.go +++ b/pkg/registry/settings/podpreset/storage/storage.go @@ -34,12 +34,12 @@ type REST struct { // NewREST returns a RESTStorage object that will work against replication controllers. func NewREST(optsGetter generic.RESTOptionsGetter) *REST { store := &genericregistry.Store{ - Copier: api.Scheme, - NewFunc: func() runtime.Object { return &settingsapi.PodPreset{} }, - NewListFunc: func() runtime.Object { return &settingsapi.PodPresetList{} }, - PredicateFunc: podpreset.Matcher, - QualifiedResource: settingsapi.Resource("podpresets"), - WatchCacheSize: cachesize.GetWatchCacheSizeByResource("podpresets"), + Copier: api.Scheme, + NewFunc: func() runtime.Object { return &settingsapi.PodPreset{} }, + NewListFunc: func() runtime.Object { return &settingsapi.PodPresetList{} }, + PredicateFunc: podpreset.Matcher, + DefaultQualifiedResource: settingsapi.Resource("podpresets"), + WatchCacheSize: cachesize.GetWatchCacheSizeByResource("podpresets"), CreateStrategy: podpreset.Strategy, UpdateStrategy: podpreset.Strategy, diff --git a/pkg/registry/storage/storageclass/storage/storage.go b/pkg/registry/storage/storageclass/storage/storage.go index e8d98c8332f..3dcb18a301f 100644 --- a/pkg/registry/storage/storageclass/storage/storage.go +++ b/pkg/registry/storage/storageclass/storage/storage.go @@ -34,12 +34,12 @@ type REST struct { // NewREST returns a RESTStorage object that will work against persistent volumes. func NewREST(optsGetter generic.RESTOptionsGetter) *REST { store := &genericregistry.Store{ - Copier: api.Scheme, - NewFunc: func() runtime.Object { return &storageapi.StorageClass{} }, - NewListFunc: func() runtime.Object { return &storageapi.StorageClassList{} }, - PredicateFunc: storageclass.MatchStorageClasses, - QualifiedResource: storageapi.Resource("storageclasses"), - WatchCacheSize: cachesize.GetWatchCacheSizeByResource("storageclass"), + Copier: api.Scheme, + NewFunc: func() runtime.Object { return &storageapi.StorageClass{} }, + NewListFunc: func() runtime.Object { return &storageapi.StorageClassList{} }, + PredicateFunc: storageclass.MatchStorageClasses, + DefaultQualifiedResource: storageapi.Resource("storageclasses"), + WatchCacheSize: cachesize.GetWatchCacheSizeByResource("storageclass"), CreateStrategy: storageclass.Strategy, UpdateStrategy: storageclass.Strategy, diff --git a/staging/src/k8s.io/apiextensions-apiserver/pkg/registry/customresource/etcd.go b/staging/src/k8s.io/apiextensions-apiserver/pkg/registry/customresource/etcd.go index 138b05932fc..6abd528354b 100644 --- a/staging/src/k8s.io/apiextensions-apiserver/pkg/registry/customresource/etcd.go +++ b/staging/src/k8s.io/apiextensions-apiserver/pkg/registry/customresource/etcd.go @@ -40,8 +40,8 @@ func NewREST(resource schema.GroupResource, listKind schema.GroupVersionKind, co ret.SetGroupVersionKind(listKind) return ret }, - PredicateFunc: strategy.MatchCustomResourceDefinitionStorage, - QualifiedResource: resource, + PredicateFunc: strategy.MatchCustomResourceDefinitionStorage, + DefaultQualifiedResource: resource, CreateStrategy: strategy, UpdateStrategy: strategy, diff --git a/staging/src/k8s.io/apiextensions-apiserver/pkg/registry/customresourcedefinition/etcd.go b/staging/src/k8s.io/apiextensions-apiserver/pkg/registry/customresourcedefinition/etcd.go index f300dac285d..901406bfef2 100644 --- a/staging/src/k8s.io/apiextensions-apiserver/pkg/registry/customresourcedefinition/etcd.go +++ b/staging/src/k8s.io/apiextensions-apiserver/pkg/registry/customresourcedefinition/etcd.go @@ -41,11 +41,11 @@ func NewREST(scheme *runtime.Scheme, optsGetter generic.RESTOptionsGetter) *REST strategy := NewStrategy(scheme) store := &genericregistry.Store{ - Copier: scheme, - NewFunc: func() runtime.Object { return &apiextensions.CustomResourceDefinition{} }, - NewListFunc: func() runtime.Object { return &apiextensions.CustomResourceDefinitionList{} }, - PredicateFunc: MatchCustomResourceDefinition, - QualifiedResource: apiextensions.Resource("customresourcedefinitions"), + Copier: scheme, + NewFunc: func() runtime.Object { return &apiextensions.CustomResourceDefinition{} }, + NewListFunc: func() runtime.Object { return &apiextensions.CustomResourceDefinitionList{} }, + PredicateFunc: MatchCustomResourceDefinition, + DefaultQualifiedResource: apiextensions.Resource("customresourcedefinitions"), CreateStrategy: strategy, UpdateStrategy: strategy, diff --git a/staging/src/k8s.io/apiserver/pkg/registry/generic/registry/store.go b/staging/src/k8s.io/apiserver/pkg/registry/generic/registry/store.go index ef1bd068f38..3b514376cf5 100644 --- a/staging/src/k8s.io/apiserver/pkg/registry/generic/registry/store.go +++ b/staging/src/k8s.io/apiserver/pkg/registry/generic/registry/store.go @@ -37,6 +37,7 @@ import ( "k8s.io/apimachinery/pkg/util/sets" "k8s.io/apimachinery/pkg/util/validation/field" "k8s.io/apimachinery/pkg/watch" + "k8s.io/apiserver/pkg/endpoints/request" genericapirequest "k8s.io/apiserver/pkg/endpoints/request" "k8s.io/apiserver/pkg/registry/generic" "k8s.io/apiserver/pkg/registry/rest" @@ -82,8 +83,10 @@ type Store struct { // curl GET /apis/group/version/namespaces/my-ns/myresource NewListFunc func() runtime.Object - // QualifiedResource is the pluralized name of the resource. - QualifiedResource schema.GroupResource + // DefaultQualifiedResource is the pluralized name of the resource. + // This field is used if there is no request info present in the context. + // See qualifiedResourceFromContext for details. + DefaultQualifiedResource schema.GroupResource // KeyRootFunc returns the root etcd key for this resource; should not // include trailing "/". This is used for operations that work on the @@ -262,16 +265,17 @@ func (e *Store) ListPredicate(ctx genericapirequest.Context, p storage.Selection } p.IncludeUninitialized = options.IncludeUninitialized list := e.NewListFunc() + qualifiedResource := e.qualifiedResourceFromContext(ctx) if name, ok := p.MatchesSingle(); ok { if key, err := e.KeyFunc(ctx, name); err == nil { err := e.Storage.GetToList(ctx, key, options.ResourceVersion, p, list) - return list, storeerr.InterpretListError(err, e.QualifiedResource) + return list, storeerr.InterpretListError(err, qualifiedResource) } // if we cannot extract a key based on the current context, the optimization is skipped } err := e.Storage.List(ctx, e.KeyRootFunc(ctx), options.ResourceVersion, p, list) - return list, storeerr.InterpretListError(err, e.QualifiedResource) + return list, storeerr.InterpretListError(err, qualifiedResource) } // Create inserts a new item according to the unique key from the object. @@ -287,13 +291,14 @@ func (e *Store) Create(ctx genericapirequest.Context, obj runtime.Object, includ if err != nil { return nil, err } + qualifiedResource := e.qualifiedResourceFromContext(ctx) ttl, err := e.calculateTTL(obj, 0, false) if err != nil { return nil, err } out := e.NewFunc() if err := e.Storage.Create(ctx, key, obj, out, ttl); err != nil { - err = storeerr.InterpretCreateError(err, e.QualifiedResource, name) + err = storeerr.InterpretCreateError(err, qualifiedResource, name) err = rest.CheckGeneratedNameError(e.CreateStrategy, err, obj) if !kubeerr.IsAlreadyExists(err) { return nil, err @@ -327,6 +332,8 @@ func (e *Store) Create(ctx genericapirequest.Context, obj runtime.Object, includ return out, nil } +// WaitForInitialized holds until the object is initialized, or returns an error if the default limit expires. +// This method is exposed publicly for consumers of generic rest tooling. func (e *Store) WaitForInitialized(ctx genericapirequest.Context, obj runtime.Object) (runtime.Object, error) { // return early if we don't have initializers, or if they've completed already accessor, err := meta.Accessor(obj) @@ -345,6 +352,7 @@ func (e *Store) WaitForInitialized(ctx genericapirequest.Context, obj runtime.Ob if err != nil { return nil, err } + qualifiedResource := e.qualifiedResourceFromContext(ctx) w, err := e.Storage.Watch(ctx, key, accessor.GetResourceVersion(), storage.SelectionPredicate{ Label: labels.Everything(), Field: fields.Everything(), @@ -363,7 +371,7 @@ func (e *Store) WaitForInitialized(ctx genericapirequest.Context, obj runtime.Ob case event, ok := <-ch: if !ok { msg := fmt.Sprintf("server has timed out waiting for the initialization of %s %s", - e.QualifiedResource.String(), accessor.GetName()) + qualifiedResource.String(), accessor.GetName()) return nil, kubeerr.NewTimeoutError(msg, 0) } switch event.Type { @@ -448,15 +456,15 @@ func (e *Store) deleteWithoutFinalizers(ctx genericapirequest.Context, name, key // requests to remove all finalizers from the object, so we // ignore the NotFound error. if storage.IsNotFound(err) { - _, err := e.finalizeDelete(obj, true) + _, err := e.finalizeDelete(ctx, obj, true) // clients are expecting an updated object if a PUT succeeded, // but finalizeDelete returns a metav1.Status, so return // the object in the request instead. return obj, false, err } - return nil, false, storeerr.InterpretDeleteError(err, e.QualifiedResource, name) + return nil, false, storeerr.InterpretDeleteError(err, e.qualifiedResourceFromContext(ctx), name) } - _, err := e.finalizeDelete(out, true) + _, err := e.finalizeDelete(ctx, out, true) // clients are expecting an updated object if a PUT succeeded, but // finalizeDelete returns a metav1.Status, so return the object in // the request instead. @@ -477,6 +485,7 @@ func (e *Store) Update(ctx genericapirequest.Context, name string, objInfo rest. creating = false ) + qualifiedResource := e.qualifiedResourceFromContext(ctx) storagePreconditions := &storage.Preconditions{} if preconditions := objInfo.Preconditions(); preconditions != nil { storagePreconditions.UID = preconditions.UID @@ -508,7 +517,7 @@ func (e *Store) Update(ctx genericapirequest.Context, name string, objInfo rest. } if version == 0 { if !e.UpdateStrategy.AllowCreateOnUpdate() { - return nil, nil, kubeerr.NewNotFound(e.QualifiedResource, name) + return nil, nil, kubeerr.NewNotFound(qualifiedResource, name) } creating = true creatingObj = obj @@ -542,12 +551,12 @@ func (e *Store) Update(ctx genericapirequest.Context, name string, objInfo rest. // TODO: The Invalid error should have a field for Resource. // After that field is added, we should fill the Resource and // leave the Kind field empty. See the discussion in #18526. - qualifiedKind := schema.GroupKind{Group: e.QualifiedResource.Group, Kind: e.QualifiedResource.Resource} + qualifiedKind := schema.GroupKind{Group: qualifiedResource.Group, Kind: qualifiedResource.Resource} fieldErrList := field.ErrorList{field.Invalid(field.NewPath("metadata").Child("resourceVersion"), newVersion, "must be specified for an update")} return nil, nil, kubeerr.NewInvalid(qualifiedKind, name, fieldErrList) } if newVersion != version { - return nil, nil, kubeerr.NewConflict(e.QualifiedResource, name, fmt.Errorf(OptimisticLockErrorMsg)) + return nil, nil, kubeerr.NewConflict(qualifiedResource, name, fmt.Errorf(OptimisticLockErrorMsg)) } } if err := rest.BeforeUpdate(e.UpdateStrategy, ctx, obj, existing); err != nil { @@ -573,10 +582,10 @@ func (e *Store) Update(ctx genericapirequest.Context, name string, objInfo rest. return e.deleteWithoutFinalizers(ctx, name, key, deleteObj, storagePreconditions) } if creating { - err = storeerr.InterpretCreateError(err, e.QualifiedResource, name) + err = storeerr.InterpretCreateError(err, qualifiedResource, name) err = rest.CheckGeneratedNameError(e.CreateStrategy, err, creatingObj) } else { - err = storeerr.InterpretUpdateError(err, e.QualifiedResource, name) + err = storeerr.InterpretUpdateError(err, qualifiedResource, name) } return nil, false, err } @@ -614,7 +623,7 @@ func (e *Store) Get(ctx genericapirequest.Context, name string, options *metav1. return nil, err } if err := e.Storage.Get(ctx, key, options.ResourceVersion, obj, false); err != nil { - return nil, storeerr.InterpretGetError(err, e.QualifiedResource, name) + return nil, storeerr.InterpretGetError(err, e.qualifiedResourceFromContext(ctx), name) } if e.Decorator != nil { if err := e.Decorator(obj); err != nil { @@ -624,6 +633,16 @@ func (e *Store) Get(ctx genericapirequest.Context, name string, options *metav1. return obj, nil } +// qualifiedResourceFromContext attempts to retrieve a GroupResource from the context's request info. +// If the context has no request info, DefaultQualifiedResource is used. +func (e *Store) qualifiedResourceFromContext(ctx genericapirequest.Context) schema.GroupResource { + if info, ok := request.RequestInfoFrom(ctx); ok { + return schema.GroupResource{Group: info.APIGroup, Resource: info.Resource} + } + // some implementations access storage directly and thus the context has no RequestInfo + return e.DefaultQualifiedResource +} + var ( errAlreadyDeleting = fmt.Errorf("abort delete") errDeleteNow = fmt.Errorf("delete now") @@ -827,10 +846,10 @@ func (e *Store) updateForGracefulDeletion(ctx genericapirequest.Context, name, k // we should fall through and truly delete the object. return nil, false, true, out, lastExisting case errAlreadyDeleting: - out, err = e.finalizeDelete(in, true) + out, err = e.finalizeDelete(ctx, in, true) return err, false, false, out, lastExisting default: - return storeerr.InterpretUpdateError(err, e.QualifiedResource, name), false, false, out, lastExisting + return storeerr.InterpretUpdateError(err, e.qualifiedResourceFromContext(ctx), name), false, false, out, lastExisting } } @@ -918,10 +937,10 @@ func (e *Store) updateForGracefulDeletionAndFinalizers(ctx genericapirequest.Con // we should fall through and truly delete the object. return nil, false, true, out, lastExisting case errAlreadyDeleting: - out, err = e.finalizeDelete(in, true) + out, err = e.finalizeDelete(ctx, in, true) return err, false, false, out, lastExisting default: - return storeerr.InterpretUpdateError(err, e.QualifiedResource, name), false, false, out, lastExisting + return storeerr.InterpretUpdateError(err, e.qualifiedResourceFromContext(ctx), name), false, false, out, lastExisting } } @@ -931,10 +950,10 @@ func (e *Store) Delete(ctx genericapirequest.Context, name string, options *meta if err != nil { return nil, false, err } - obj := e.NewFunc() + qualifiedResource := e.qualifiedResourceFromContext(ctx) if err := e.Storage.Get(ctx, key, "", obj, false); err != nil { - return nil, false, storeerr.InterpretDeleteError(err, e.QualifiedResource, name) + return nil, false, storeerr.InterpretDeleteError(err, qualifiedResource, name) } // support older consumers of delete by treating "nil" as delete immediately if options == nil { @@ -950,7 +969,7 @@ func (e *Store) Delete(ctx genericapirequest.Context, name string, options *meta } // this means finalizers cannot be updated via DeleteOptions if a deletion is already pending if pendingGraceful { - out, err := e.finalizeDelete(obj, false) + out, err := e.finalizeDelete(ctx, obj, false) return out, false, err } // check if obj has pending finalizers @@ -991,12 +1010,12 @@ func (e *Store) Delete(ctx genericapirequest.Context, name string, options *meta if storage.IsNotFound(err) && ignoreNotFound && lastExisting != nil { // The lastExisting object may not be the last state of the object // before its deletion, but it's the best approximation. - out, err := e.finalizeDelete(lastExisting, true) + out, err := e.finalizeDelete(ctx, lastExisting, true) return out, true, err } - return nil, false, storeerr.InterpretDeleteError(err, e.QualifiedResource, name) + return nil, false, storeerr.InterpretDeleteError(err, qualifiedResource, name) } - out, err = e.finalizeDelete(out, true) + out, err = e.finalizeDelete(ctx, out, true) return out, true, err } @@ -1098,7 +1117,7 @@ func (e *Store) DeleteCollection(ctx genericapirequest.Context, options *metav1. // finalizeDelete runs the Store's AfterDelete hook if runHooks is set and // returns the decorated deleted object if appropriate. -func (e *Store) finalizeDelete(obj runtime.Object, runHooks bool) (runtime.Object, error) { +func (e *Store) finalizeDelete(ctx genericapirequest.Context, obj runtime.Object, runHooks bool) (runtime.Object, error) { if runHooks && e.AfterDelete != nil { if err := e.AfterDelete(obj); err != nil { return nil, err @@ -1118,10 +1137,11 @@ func (e *Store) finalizeDelete(obj runtime.Object, runHooks bool) (runtime.Objec if err != nil { return nil, err } + qualifiedResource := e.qualifiedResourceFromContext(ctx) details := &metav1.StatusDetails{ Name: accessor.GetName(), - Group: e.QualifiedResource.Group, - Kind: e.QualifiedResource.Resource, // Yes we set Kind field to resource. + Group: qualifiedResource.Group, + Kind: qualifiedResource.Resource, // Yes we set Kind field to resource. UID: accessor.GetUID(), } status := &metav1.Status{Status: metav1.StatusSuccess, Details: details} @@ -1238,17 +1258,17 @@ func (e *Store) Export(ctx genericapirequest.Context, name string, opts metav1.E // CompleteWithOptions updates the store with the provided options and // defaults common fields. func (e *Store) CompleteWithOptions(options *generic.StoreOptions) error { - if e.QualifiedResource.Empty() { + if e.DefaultQualifiedResource.Empty() { return fmt.Errorf("store %#v must have a non-empty qualified resource", e) } if e.NewFunc == nil { - return fmt.Errorf("store for %s must have NewFunc set", e.QualifiedResource.String()) + return fmt.Errorf("store for %s must have NewFunc set", e.DefaultQualifiedResource.String()) } if e.NewListFunc == nil { - return fmt.Errorf("store for %s must have NewListFunc set", e.QualifiedResource.String()) + return fmt.Errorf("store for %s must have NewListFunc set", e.DefaultQualifiedResource.String()) } if (e.KeyRootFunc == nil) != (e.KeyFunc == nil) { - return fmt.Errorf("store for %s must set both KeyRootFunc and KeyFunc or neither", e.QualifiedResource.String()) + return fmt.Errorf("store for %s must set both KeyRootFunc and KeyFunc or neither", e.DefaultQualifiedResource.String()) } var isNamespaced bool @@ -1258,15 +1278,15 @@ func (e *Store) CompleteWithOptions(options *generic.StoreOptions) error { case e.UpdateStrategy != nil: isNamespaced = e.UpdateStrategy.NamespaceScoped() default: - return fmt.Errorf("store for %s must have CreateStrategy or UpdateStrategy set", e.QualifiedResource.String()) + return fmt.Errorf("store for %s must have CreateStrategy or UpdateStrategy set", e.DefaultQualifiedResource.String()) } if e.DeleteStrategy == nil { - return fmt.Errorf("store for %s must have DeleteStrategy set", e.QualifiedResource.String()) + return fmt.Errorf("store for %s must have DeleteStrategy set", e.DefaultQualifiedResource.String()) } if options.RESTOptions == nil { - return fmt.Errorf("options for %s must have RESTOptions set", e.QualifiedResource.String()) + return fmt.Errorf("options for %s must have RESTOptions set", e.DefaultQualifiedResource.String()) } attrFunc := options.AttrFunc @@ -1287,7 +1307,7 @@ func (e *Store) CompleteWithOptions(options *generic.StoreOptions) error { } } - opts, err := options.RESTOptions.GetRESTOptions(e.QualifiedResource) + opts, err := options.RESTOptions.GetRESTOptions(e.DefaultQualifiedResource) if err != nil { return err } @@ -1298,7 +1318,7 @@ func (e *Store) CompleteWithOptions(options *generic.StoreOptions) error { prefix = "/" + prefix } if prefix == "/" { - return fmt.Errorf("store for %s has an invalid prefix %q", e.QualifiedResource.String(), opts.ResourcePrefix) + return fmt.Errorf("store for %s has an invalid prefix %q", e.DefaultQualifiedResource.String(), opts.ResourcePrefix) } // Set the default behavior for storage key generation @@ -1377,5 +1397,5 @@ func (e *Store) ConvertToTable(ctx genericapirequest.Context, object runtime.Obj if e.TableConvertor != nil { return e.TableConvertor.ConvertToTable(ctx, object, tableOptions) } - return rest.NewDefaultTableConvertor(e.QualifiedResource).ConvertToTable(ctx, object, tableOptions) + return rest.NewDefaultTableConvertor(e.qualifiedResourceFromContext(ctx)).ConvertToTable(ctx, object, tableOptions) } diff --git a/staging/src/k8s.io/apiserver/pkg/registry/generic/registry/store_test.go b/staging/src/k8s.io/apiserver/pkg/registry/generic/registry/store_test.go index fa61ac97b9d..800d1b257c4 100644 --- a/staging/src/k8s.io/apiserver/pkg/registry/generic/registry/store_test.go +++ b/staging/src/k8s.io/apiserver/pkg/registry/generic/registry/store_test.go @@ -42,6 +42,7 @@ import ( "k8s.io/apimachinery/pkg/watch" "k8s.io/apiserver/pkg/apis/example" examplev1 "k8s.io/apiserver/pkg/apis/example/v1" + "k8s.io/apiserver/pkg/endpoints/request" genericapirequest "k8s.io/apiserver/pkg/endpoints/request" "k8s.io/apiserver/pkg/registry/generic" "k8s.io/apiserver/pkg/registry/rest" @@ -381,6 +382,13 @@ func isInitialized(obj metav1.Object) bool { return obj.GetInitializers() == nil } +func isQualifiedResource(err error, kind, group string) bool { + if err.(errors.APIStatus).Status().Details.Kind != kind || err.(errors.APIStatus).Status().Details.Group != group { + return false + } + return true +} + func TestStoreCreateInitialized(t *testing.T) { podA := &example.Pod{ ObjectMeta: metav1.ObjectMeta{ @@ -1801,13 +1809,13 @@ func newTestGenericStoreRegistry(t *testing.T, scheme *runtime.Scheme, hasCacheE } return destroyFunc, &Store{ - Copier: scheme, - NewFunc: func() runtime.Object { return &example.Pod{} }, - NewListFunc: func() runtime.Object { return &example.PodList{} }, - QualifiedResource: example.Resource("pods"), - CreateStrategy: strategy, - UpdateStrategy: strategy, - DeleteStrategy: strategy, + Copier: scheme, + NewFunc: func() runtime.Object { return &example.Pod{} }, + NewListFunc: func() runtime.Object { return &example.PodList{} }, + DefaultQualifiedResource: example.Resource("pods"), + CreateStrategy: strategy, + UpdateStrategy: strategy, + DeleteStrategy: strategy, KeyRootFunc: func(ctx genericapirequest.Context) string { return podPrefix }, @@ -1842,7 +1850,7 @@ func TestFinalizeDelete(t *testing.T) { obj := &example.Pod{ ObjectMeta: metav1.ObjectMeta{Name: "foo", UID: "random-uid"}, } - result, err := s.finalizeDelete(obj, false) + result, err := s.finalizeDelete(genericapirequest.NewContext(), obj, false) if err != nil { t.Fatalf("unexpected err: %s", err) } @@ -1852,8 +1860,8 @@ func TestFinalizeDelete(t *testing.T) { Status: metav1.StatusSuccess, Details: &metav1.StatusDetails{ Name: "foo", - Group: s.QualifiedResource.Group, - Kind: s.QualifiedResource.Resource, + Group: s.DefaultQualifiedResource.Group, + Kind: s.DefaultQualifiedResource.Resource, UID: "random-uid", }, } @@ -1861,3 +1869,82 @@ func TestFinalizeDelete(t *testing.T) { t.Errorf("unexpected obj. expected %#v, got %#v", expectedObj, returnedObj) } } + +func fakeRequestInfo(resource, apiGroup string) *request.RequestInfo { + return &request.RequestInfo{ + IsResourceRequest: true, + Path: "/api/v1/test", + Verb: "test", + APIPrefix: "api", + APIGroup: apiGroup, + APIVersion: "v1", + Namespace: "", + Resource: resource, + Subresource: "", + Name: "", + Parts: []string{"test"}, + } +} + +func TestQualifiedResource(t *testing.T) { + podA := &example.Pod{ + ObjectMeta: metav1.ObjectMeta{Name: "foo", Namespace: "test"}, + Spec: example.PodSpec{NodeName: "machine"}, + } + + qualifiedKind := "pod" + qualifiedGroup := "test" + testContext := genericapirequest.WithNamespace(genericapirequest.NewContext(), "test") + testContext = genericapirequest.WithRequestInfo(testContext, fakeRequestInfo(qualifiedKind, qualifiedGroup)) + + destroyFunc, registry := NewTestGenericStoreRegistry(t) + defer destroyFunc() + + // update a non-exist object + _, _, err := registry.Update(testContext, podA.Name, rest.DefaultUpdatedObjectInfo(podA, scheme)) + if !errors.IsNotFound(err) { + t.Fatalf("Unexpected error: %v", err) + } + + if !isQualifiedResource(err, qualifiedKind, qualifiedGroup) { + t.Fatalf("Unexpected error: %#v", err) + } + + // get a non-exist object + _, err = registry.Get(testContext, podA.Name, &metav1.GetOptions{}) + + if !errors.IsNotFound(err) { + t.Fatalf("Unexpected error: %v", err) + } + + if !isQualifiedResource(err, qualifiedKind, qualifiedGroup) { + t.Fatalf("Unexpected error: %#v", err) + } + + // delete a non-exist object + _, _, err = registry.Delete(testContext, podA.Name, nil) + + if !errors.IsNotFound(err) { + t.Fatalf("Unexpected error: %v", err) + } + + if !isQualifiedResource(err, qualifiedKind, qualifiedGroup) { + t.Fatalf("Unexpected error: %#v", err) + } + + // create a non-exist object + _, err = registry.Create(testContext, podA, false) + if err != nil { + t.Fatal(err) + } + + // create a exist object will fail + _, err = registry.Create(testContext, podA, false) + if !errors.IsAlreadyExists(err) { + t.Fatalf("Unexpected error: %v", err) + } + + if !isQualifiedResource(err, qualifiedKind, qualifiedGroup) { + t.Fatalf("Unexpected error: %#v", err) + } +} diff --git a/staging/src/k8s.io/kube-aggregator/pkg/registry/apiservice/etcd/etcd.go b/staging/src/k8s.io/kube-aggregator/pkg/registry/apiservice/etcd/etcd.go index 320aa5f0f0d..82db5783f2f 100644 --- a/staging/src/k8s.io/kube-aggregator/pkg/registry/apiservice/etcd/etcd.go +++ b/staging/src/k8s.io/kube-aggregator/pkg/registry/apiservice/etcd/etcd.go @@ -35,11 +35,11 @@ type REST struct { func NewREST(scheme *runtime.Scheme, optsGetter generic.RESTOptionsGetter) *REST { strategy := apiservice.NewStrategy(scheme) store := &genericregistry.Store{ - Copier: scheme, - NewFunc: func() runtime.Object { return &apiregistration.APIService{} }, - NewListFunc: func() runtime.Object { return &apiregistration.APIServiceList{} }, - PredicateFunc: apiservice.MatchAPIService, - QualifiedResource: apiregistration.Resource("apiservices"), + Copier: scheme, + NewFunc: func() runtime.Object { return &apiregistration.APIService{} }, + NewListFunc: func() runtime.Object { return &apiregistration.APIServiceList{} }, + PredicateFunc: apiservice.MatchAPIService, + DefaultQualifiedResource: apiregistration.Resource("apiservices"), CreateStrategy: strategy, UpdateStrategy: strategy, diff --git a/staging/src/k8s.io/sample-apiserver/pkg/registry/wardle/fischer/etcd.go b/staging/src/k8s.io/sample-apiserver/pkg/registry/wardle/fischer/etcd.go index 5cf11ec8c8e..228a668feaa 100644 --- a/staging/src/k8s.io/sample-apiserver/pkg/registry/wardle/fischer/etcd.go +++ b/staging/src/k8s.io/sample-apiserver/pkg/registry/wardle/fischer/etcd.go @@ -29,11 +29,11 @@ func NewREST(scheme *runtime.Scheme, optsGetter generic.RESTOptionsGetter) (*reg strategy := NewStrategy(scheme) store := &genericregistry.Store{ - Copier: scheme, - NewFunc: func() runtime.Object { return &wardle.Fischer{} }, - NewListFunc: func() runtime.Object { return &wardle.FischerList{} }, - PredicateFunc: MatchFischer, - QualifiedResource: wardle.Resource("fischers"), + Copier: scheme, + NewFunc: func() runtime.Object { return &wardle.Fischer{} }, + NewListFunc: func() runtime.Object { return &wardle.FischerList{} }, + PredicateFunc: MatchFischer, + DefaultQualifiedResource: wardle.Resource("fischers"), CreateStrategy: strategy, UpdateStrategy: strategy, diff --git a/staging/src/k8s.io/sample-apiserver/pkg/registry/wardle/flunder/etcd.go b/staging/src/k8s.io/sample-apiserver/pkg/registry/wardle/flunder/etcd.go index 8bb5ef44033..7f12cb4cbe3 100644 --- a/staging/src/k8s.io/sample-apiserver/pkg/registry/wardle/flunder/etcd.go +++ b/staging/src/k8s.io/sample-apiserver/pkg/registry/wardle/flunder/etcd.go @@ -29,11 +29,11 @@ func NewREST(scheme *runtime.Scheme, optsGetter generic.RESTOptionsGetter) (*reg strategy := NewStrategy(scheme) store := &genericregistry.Store{ - Copier: scheme, - NewFunc: func() runtime.Object { return &wardle.Flunder{} }, - NewListFunc: func() runtime.Object { return &wardle.FlunderList{} }, - PredicateFunc: MatchFlunder, - QualifiedResource: wardle.Resource("flunders"), + Copier: scheme, + NewFunc: func() runtime.Object { return &wardle.Flunder{} }, + NewListFunc: func() runtime.Object { return &wardle.FlunderList{} }, + PredicateFunc: MatchFlunder, + DefaultQualifiedResource: wardle.Resource("flunders"), CreateStrategy: strategy, UpdateStrategy: strategy,