// DefaultKeyFunctions sets the default behavior for storage key generation onto a Store. func DefaultKeyFunctions(store *registry.Store, prefix string, isNamespaced bool) { if isNamespaced { if store.KeyRootFunc == nil { store.KeyRootFunc = func(ctx kapi.Context) string { return registry.NamespaceKeyRootFunc(ctx, prefix) } } if store.KeyFunc == nil { store.KeyFunc = func(ctx kapi.Context, name string) (string, error) { return registry.NamespaceKeyFunc(ctx, prefix, name) } } } else { if store.KeyRootFunc == nil { store.KeyRootFunc = func(ctx kapi.Context) string { return prefix } } if store.KeyFunc == nil { store.KeyFunc = func(ctx kapi.Context, name string) (string, error) { return registry.NoNamespaceKeyFunc(ctx, prefix, name) } } } }
// NewREST returns a RESTStorage object that will work against services. func NewREST(opts generic.RESTOptions) (*REST, *StatusREST) { prefix := "/services/specs" newListFunc := func() runtime.Object { return &api.ServiceList{} } storageInterface := opts.Decorator( opts.Storage, cachesize.GetWatchCacheSizeByResource(cachesize.Services), &api.Service{}, prefix, service.Strategy, newListFunc) store := ®istry.Store{ NewFunc: func() runtime.Object { return &api.Service{} }, NewListFunc: newListFunc, KeyRootFunc: func(ctx api.Context) string { return registry.NamespaceKeyRootFunc(ctx, prefix) }, KeyFunc: func(ctx api.Context, name string) (string, error) { return registry.NamespaceKeyFunc(ctx, prefix, name) }, ObjectNameFunc: func(obj runtime.Object) (string, error) { return obj.(*api.Service).Name, nil }, PredicateFunc: service.MatchServices, QualifiedResource: api.Resource("services"), DeleteCollectionWorkers: opts.DeleteCollectionWorkers, CreateStrategy: service.Strategy, UpdateStrategy: service.Strategy, DeleteStrategy: service.Strategy, ExportStrategy: service.Strategy, Storage: storageInterface, } statusStore := *store statusStore.UpdateStrategy = service.StatusStrategy return &REST{store}, &StatusREST{store: &statusStore} }
// NewREST returns a RESTStorage object that will work against templates. func NewREST(optsGetter restoptions.Getter) (*REST, error) { prefix := "/templates" store := ®istry.Store{ NewFunc: func() runtime.Object { return &api.Template{} }, NewListFunc: func() runtime.Object { return &api.TemplateList{} }, KeyRootFunc: func(ctx kapi.Context) string { return registry.NamespaceKeyRootFunc(ctx, prefix) }, KeyFunc: func(ctx kapi.Context, name string) (string, error) { return registry.NamespaceKeyFunc(ctx, prefix, name) }, ObjectNameFunc: func(obj runtime.Object) (string, error) { return obj.(*api.Template).Name, nil }, PredicateFunc: func(label labels.Selector, field fields.Selector) generic.Matcher { return tregistry.Matcher(label, field) }, QualifiedResource: api.Resource("templates"), CreateStrategy: tregistry.Strategy, UpdateStrategy: tregistry.Strategy, ReturnDeletedObject: true, } if err := restoptions.ApplyOptions(optsGetter, store, prefix); err != nil { return nil, err } return &REST{store}, nil }
// NewREST returns a registry which will store ThirdPartyResourceData in the given helper func NewREST(opts generic.RESTOptions, group, kind string) *REST { prefix := "/ThirdPartyResourceData/" + group + "/" + strings.ToLower(kind) + "s" // We explicitly do NOT do any decoration here yet. storageInterface, dFunc := generic.NewRawStorage(opts.StorageConfig) store := ®istry.Store{ NewFunc: func() runtime.Object { return &extensions.ThirdPartyResourceData{} }, NewListFunc: func() runtime.Object { return &extensions.ThirdPartyResourceDataList{} }, KeyRootFunc: func(ctx api.Context) string { return registry.NamespaceKeyRootFunc(ctx, prefix) }, KeyFunc: func(ctx api.Context, id string) (string, error) { return registry.NamespaceKeyFunc(ctx, prefix, id) }, ObjectNameFunc: func(obj runtime.Object) (string, error) { return obj.(*extensions.ThirdPartyResourceData).Name, nil }, PredicateFunc: thirdpartyresourcedata.Matcher, QualifiedResource: extensions.Resource("thirdpartyresourcedatas"), DeleteCollectionWorkers: opts.DeleteCollectionWorkers, CreateStrategy: thirdpartyresourcedata.Strategy, UpdateStrategy: thirdpartyresourcedata.Strategy, DeleteStrategy: thirdpartyresourcedata.Strategy, Storage: storageInterface, DestroyFunc: dFunc, } return &REST{ Store: store, kind: kind, } }
// NewREST returns a RESTStorage object that will work against egress network policy func NewREST(optsGetter restoptions.Getter) (*REST, error) { store := ®istry.Store{ NewFunc: func() runtime.Object { return &api.EgressNetworkPolicy{} }, NewListFunc: func() runtime.Object { return &api.EgressNetworkPolicyList{} }, KeyRootFunc: func(ctx kapi.Context) string { return registry.NamespaceKeyRootFunc(ctx, etcdPrefix) }, KeyFunc: func(ctx kapi.Context, name string) (string, error) { return registry.NamespaceKeyFunc(ctx, etcdPrefix, name) }, ObjectNameFunc: func(obj runtime.Object) (string, error) { return obj.(*api.EgressNetworkPolicy).Name, nil }, PredicateFunc: func(label labels.Selector, field fields.Selector) generic.Matcher { return egressnetworkpolicy.Matcher(label, field) }, QualifiedResource: api.Resource("egressnetworkpolicies"), CreateStrategy: egressnetworkpolicy.Strategy, UpdateStrategy: egressnetworkpolicy.Strategy, } if err := restoptions.ApplyOptions(optsGetter, store, etcdPrefix); err != nil { return nil, err } return &REST{*store}, nil }
// NewREST returns a RESTStorage object that will work against events. func NewREST(opts generic.RESTOptions, ttl uint64) *REST { prefix := "/" + opts.ResourcePrefix // We explicitly do NOT do any decoration here - switching on Cacher // for events will lead to too high memory consumption. storageInterface, dFunc := generic.NewRawStorage(opts.StorageConfig) store := ®istry.Store{ NewFunc: func() runtime.Object { return &api.Event{} }, NewListFunc: func() runtime.Object { return &api.EventList{} }, KeyRootFunc: func(ctx api.Context) string { return registry.NamespaceKeyRootFunc(ctx, prefix) }, KeyFunc: func(ctx api.Context, id string) (string, error) { return registry.NamespaceKeyFunc(ctx, prefix, id) }, ObjectNameFunc: func(obj runtime.Object) (string, error) { return obj.(*api.Event).Name, nil }, PredicateFunc: event.MatchEvent, TTLFunc: func(runtime.Object, uint64, bool) (uint64, error) { return ttl, nil }, QualifiedResource: api.Resource("events"), DeleteCollectionWorkers: opts.DeleteCollectionWorkers, CreateStrategy: event.Strategy, UpdateStrategy: event.Strategy, DeleteStrategy: event.Strategy, Storage: storageInterface, DestroyFunc: dFunc, } return &REST{store} }
// NewREST returns a registry which will store ThirdPartyResource in the given helper func NewREST(opts generic.RESTOptions) *REST { prefix := "/thirdpartyresources" // We explicitly do NOT do any decoration here yet. storageInterface := opts.Storage store := ®istry.Store{ NewFunc: func() runtime.Object { return &extensions.ThirdPartyResource{} }, NewListFunc: func() runtime.Object { return &extensions.ThirdPartyResourceList{} }, KeyRootFunc: func(ctx api.Context) string { return registry.NamespaceKeyRootFunc(ctx, prefix) }, KeyFunc: func(ctx api.Context, id string) (string, error) { return registry.NamespaceKeyFunc(ctx, prefix, id) }, ObjectNameFunc: func(obj runtime.Object) (string, error) { return obj.(*extensions.ThirdPartyResource).Name, nil }, PredicateFunc: func(label labels.Selector, field fields.Selector) generic.Matcher { return thirdpartyresource.Matcher(label, field) }, QualifiedResource: extensions.Resource("thirdpartyresources"), DeleteCollectionWorkers: opts.DeleteCollectionWorkers, CreateStrategy: thirdpartyresource.Strategy, UpdateStrategy: thirdpartyresource.Strategy, DeleteStrategy: thirdpartyresource.Strategy, Storage: storageInterface, } return &REST{store} }
// NewStorage returns a RESTStorage object that will work against Build objects. func NewREST(optsGetter restoptions.Getter) (*REST, *DetailsREST, error) { prefix := "/builds" store := ®istry.Store{ NewFunc: func() runtime.Object { return &api.Build{} }, NewListFunc: func() runtime.Object { return &api.BuildList{} }, QualifiedResource: api.Resource("builds"), KeyRootFunc: func(ctx kapi.Context) string { return registry.NamespaceKeyRootFunc(ctx, prefix) }, KeyFunc: func(ctx kapi.Context, id string) (string, error) { return registry.NamespaceKeyFunc(ctx, prefix, id) }, ObjectNameFunc: func(obj runtime.Object) (string, error) { return obj.(*api.Build).Name, nil }, PredicateFunc: func(label labels.Selector, field fields.Selector) generic.Matcher { return build.Matcher(label, field) }, CreateStrategy: build.Strategy, UpdateStrategy: build.Strategy, DeleteStrategy: build.Strategy, Decorator: build.Decorator, ReturnDeletedObject: false, } if err := restoptions.ApplyOptions(optsGetter, store, prefix); err != nil { return nil, nil, err } detailsStore := *store detailsStore.UpdateStrategy = build.DetailsStrategy return &REST{store}, &DetailsREST{&detailsStore}, nil }
// NewREST returns a RESTStorage object that will work against routes. func NewREST(optsGetter restoptions.Getter, allocator route.RouteAllocator) (*REST, *StatusREST, error) { strategy := rest.NewStrategy(allocator) prefix := "/routes" store := ®istry.Store{ NewFunc: func() runtime.Object { return &api.Route{} }, NewListFunc: func() runtime.Object { return &api.RouteList{} }, KeyRootFunc: func(ctx kapi.Context) string { return registry.NamespaceKeyRootFunc(ctx, prefix) }, KeyFunc: func(ctx kapi.Context, id string) (string, error) { return registry.NamespaceKeyFunc(ctx, prefix, id) }, ObjectNameFunc: func(obj runtime.Object) (string, error) { return obj.(*api.Route).Name, nil }, PredicateFunc: func(label labels.Selector, field fields.Selector) generic.Matcher { return rest.Matcher(label, field) }, QualifiedResource: api.Resource("routes"), CreateStrategy: strategy, UpdateStrategy: strategy, } if err := restoptions.ApplyOptions(optsGetter, store, prefix); err != nil { return nil, nil, err } statusStore := *store statusStore.UpdateStrategy = rest.StatusStrategy return &REST{store}, &StatusREST{&statusStore}, nil }
// NewREST returns a RESTStorage object that will work against horizontal pod autoscalers. func NewREST(opts generic.RESTOptions) *REST { prefix := "/limitranges" newListFunc := func() runtime.Object { return &api.LimitRangeList{} } storageInterface := opts.Decorator( opts.Storage, cachesize.GetWatchCacheSizeByResource(cachesize.LimitRanges), &api.LimitRange{}, prefix, limitrange.Strategy, newListFunc) store := ®istry.Store{ NewFunc: func() runtime.Object { return &api.LimitRange{} }, NewListFunc: newListFunc, KeyRootFunc: func(ctx api.Context) string { return registry.NamespaceKeyRootFunc(ctx, prefix) }, KeyFunc: func(ctx api.Context, id string) (string, error) { return registry.NamespaceKeyFunc(ctx, prefix, id) }, ObjectNameFunc: func(obj runtime.Object) (string, error) { return obj.(*api.LimitRange).Name, nil }, PredicateFunc: func(label labels.Selector, field fields.Selector) generic.Matcher { return limitrange.MatchLimitRange(label, field) }, QualifiedResource: api.Resource("limitranges"), DeleteCollectionWorkers: opts.DeleteCollectionWorkers, CreateStrategy: limitrange.Strategy, UpdateStrategy: limitrange.Strategy, DeleteStrategy: limitrange.Strategy, ExportStrategy: limitrange.Strategy, Storage: storageInterface, } return &REST{store} }
// NewREST returns a RESTStorage object that will work with testtype. func NewREST(s storage.Interface, storageDecorator generic.StorageDecorator) *REST { prefix := "/testtype" newListFunc := func() runtime.Object { return &testgroup.TestTypeList{} } // Usually you should reuse your RESTCreateStrategy. strategy := &NotNamespaceScoped{} storageInterface := storageDecorator( s, 100, &testgroup.TestType{}, prefix, strategy, newListFunc) store := ®istry.Store{ NewFunc: func() runtime.Object { return &testgroup.TestType{} }, // NewListFunc returns an object capable of storing results of an etcd list. NewListFunc: newListFunc, // Produces a path that etcd understands, to the root of the resource // by combining the namespace in the context with the given prefix. KeyRootFunc: func(ctx api.Context) string { return registry.NamespaceKeyRootFunc(ctx, prefix) }, // Produces a path that etcd understands, to the resource by combining // the namespace in the context with the given prefix. KeyFunc: func(ctx api.Context, name string) (string, error) { return registry.NamespaceKeyFunc(ctx, prefix, name) }, // Retrieve the name field of the resource. ObjectNameFunc: func(obj runtime.Object) (string, error) { return obj.(*testgroup.TestType).Name, nil }, // Used to match objects based on labels/fields for list. PredicateFunc: func(label labels.Selector, field fields.Selector) generic.Matcher { return generic.MatcherFunc(nil) }, Storage: storageInterface, } return &REST{store} }
// NewREST returns a RESTStorage object that will work against service accounts. func NewREST(opts generic.RESTOptions) *REST { prefix := "/serviceaccounts" newListFunc := func() runtime.Object { return &api.ServiceAccountList{} } storageInterface := opts.Decorator( opts.Storage, cachesize.GetWatchCacheSizeByResource(cachesize.ServiceAccounts), &api.ServiceAccount{}, prefix, serviceaccount.Strategy, newListFunc) store := ®istry.Store{ NewFunc: func() runtime.Object { return &api.ServiceAccount{} }, NewListFunc: newListFunc, KeyRootFunc: func(ctx api.Context) string { return registry.NamespaceKeyRootFunc(ctx, prefix) }, KeyFunc: func(ctx api.Context, name string) (string, error) { return registry.NamespaceKeyFunc(ctx, prefix, name) }, ObjectNameFunc: func(obj runtime.Object) (string, error) { return obj.(*api.ServiceAccount).Name, nil }, PredicateFunc: serviceaccount.Matcher, QualifiedResource: api.Resource("serviceaccounts"), DeleteCollectionWorkers: opts.DeleteCollectionWorkers, CreateStrategy: serviceaccount.Strategy, UpdateStrategy: serviceaccount.Strategy, DeleteStrategy: serviceaccount.Strategy, ReturnDeletedObject: true, Storage: storageInterface, } return &REST{store} }
// NewREST returns a RESTStorage object that will work against endpoints. func NewREST(opts generic.RESTOptions) *REST { prefix := "/services/endpoints" newListFunc := func() runtime.Object { return &api.EndpointsList{} } storageInterface := opts.Decorator( opts.Storage, cachesize.GetWatchCacheSizeByResource(cachesize.Endpoints), &api.Endpoints{}, prefix, endpoint.Strategy, newListFunc) store := ®istry.Store{ NewFunc: func() runtime.Object { return &api.Endpoints{} }, NewListFunc: newListFunc, KeyRootFunc: func(ctx api.Context) string { return registry.NamespaceKeyRootFunc(ctx, prefix) }, KeyFunc: func(ctx api.Context, name string) (string, error) { return registry.NamespaceKeyFunc(ctx, prefix, name) }, ObjectNameFunc: func(obj runtime.Object) (string, error) { return obj.(*api.Endpoints).Name, nil }, PredicateFunc: func(label labels.Selector, field fields.Selector) generic.Matcher { return endpoint.MatchEndpoints(label, field) }, QualifiedResource: api.Resource("endpoints"), DeleteCollectionWorkers: opts.DeleteCollectionWorkers, CreateStrategy: endpoint.Strategy, UpdateStrategy: endpoint.Strategy, DeleteStrategy: endpoint.Strategy, Storage: storageInterface, } return &REST{store} }
// NewStorage returns a RESTStorage object that will work against nodes. func NewStorage(optsGetter restoptions.Getter) (*REST, error) { store := ®istry.Store{ NewFunc: func() runtime.Object { return &authorizationapi.Policy{} }, NewListFunc: func() runtime.Object { return &authorizationapi.PolicyList{} }, QualifiedResource: authorizationapi.Resource("policies"), KeyRootFunc: func(ctx kapi.Context) string { return registry.NamespaceKeyRootFunc(ctx, PolicyPath) }, KeyFunc: func(ctx kapi.Context, id string) (string, error) { return registry.NamespaceKeyFunc(ctx, PolicyPath, id) }, ObjectNameFunc: func(obj runtime.Object) (string, error) { return obj.(*authorizationapi.Policy).Name, nil }, PredicateFunc: func(label labels.Selector, field fields.Selector) generic.Matcher { return policy.Matcher(label, field) }, CreateStrategy: policy.Strategy, UpdateStrategy: policy.Strategy, } if err := restoptions.ApplyOptions(optsGetter, store, PolicyPath); err != nil { return nil, err } return &REST{store}, nil }
// NewREST returns a new REST. func NewREST(optsGetter restoptions.Getter, defaultRegistry api.DefaultRegistry, subjectAccessReviewRegistry subjectaccessreview.Registry, limitVerifier imageadmission.LimitVerifier) (*REST, *StatusREST, *InternalREST, error) { prefix := "/imagestreams" store := registry.Store{ NewFunc: func() runtime.Object { return &api.ImageStream{} }, // NewListFunc returns an object capable of storing results of an etcd list. NewListFunc: func() runtime.Object { return &api.ImageStreamList{} }, // Produces a path that etcd understands, to the root of the resource // by combining the namespace in the context with the given prefix. KeyRootFunc: func(ctx kapi.Context) string { return registry.NamespaceKeyRootFunc(ctx, prefix) }, // Produces a path that etcd understands, to the resource by combining // the namespace in the context with the given prefix KeyFunc: func(ctx kapi.Context, name string) (string, error) { return registry.NamespaceKeyFunc(ctx, prefix, name) }, // Retrieve the name field of an image ObjectNameFunc: func(obj runtime.Object) (string, error) { return obj.(*api.ImageStream).Name, nil }, // Used to match objects based on labels/fields for list and watch PredicateFunc: func(label labels.Selector, field fields.Selector) generic.Matcher { return imagestream.MatchImageStream(label, field) }, QualifiedResource: api.Resource("imagestreams"), ReturnDeletedObject: false, } strategy := imagestream.NewStrategy(defaultRegistry, subjectAccessReviewRegistry, limitVerifier) rest := &REST{Store: &store, subjectAccessReviewRegistry: subjectAccessReviewRegistry} strategy.ImageStreamGetter = rest store.CreateStrategy = strategy store.UpdateStrategy = strategy store.Decorator = strategy.Decorate if err := restoptions.ApplyOptions(optsGetter, &store, prefix); err != nil { return nil, nil, nil, err } statusStore := store statusStore.Decorator = nil statusStore.CreateStrategy = nil statusStore.UpdateStrategy = imagestream.NewStatusStrategy(strategy) internalStore := store internalStrategy := imagestream.NewInternalStrategy(strategy) internalStore.Decorator = nil internalStore.CreateStrategy = internalStrategy internalStore.UpdateStrategy = internalStrategy return rest, &StatusREST{store: &statusStore}, &InternalREST{store: &internalStore}, nil }
// NewStorage returns a RESTStorage object that will work against pods. func NewStorage(opts generic.RESTOptions, k client.ConnectionInfoGetter, proxyTransport http.RoundTripper, podDisruptionBudgetClient policyclient.PodDisruptionBudgetsGetter) PodStorage { prefix := "/" + opts.ResourcePrefix newListFunc := func() runtime.Object { return &api.PodList{} } storageInterface, dFunc := opts.Decorator( opts.StorageConfig, cachesize.GetWatchCacheSizeByResource(cachesize.Pods), &api.Pod{}, prefix, pod.Strategy, newListFunc, pod.GetAttrs, pod.NodeNameTriggerFunc, ) store := &genericregistry.Store{ NewFunc: func() runtime.Object { return &api.Pod{} }, NewListFunc: newListFunc, KeyRootFunc: func(ctx api.Context) string { return genericregistry.NamespaceKeyRootFunc(ctx, prefix) }, KeyFunc: func(ctx api.Context, name string) (string, error) { return genericregistry.NamespaceKeyFunc(ctx, prefix, name) }, ObjectNameFunc: func(obj runtime.Object) (string, error) { return obj.(*api.Pod).Name, nil }, PredicateFunc: pod.MatchPod, QualifiedResource: api.Resource("pods"), EnableGarbageCollection: opts.EnableGarbageCollection, DeleteCollectionWorkers: opts.DeleteCollectionWorkers, CreateStrategy: pod.Strategy, UpdateStrategy: pod.Strategy, DeleteStrategy: pod.Strategy, ReturnDeletedObject: true, Storage: storageInterface, DestroyFunc: dFunc, } statusStore := *store statusStore.UpdateStrategy = pod.StatusStrategy return PodStorage{ Pod: &REST{store, proxyTransport}, Binding: &BindingREST{store: store}, Eviction: newEvictionStorage(store, podDisruptionBudgetClient), Status: &StatusREST{store: &statusStore}, Log: &podrest.LogREST{Store: store, KubeletConn: k}, Proxy: &podrest.ProxyREST{Store: store, ProxyTransport: proxyTransport}, Exec: &podrest.ExecREST{Store: store, KubeletConn: k}, Attach: &podrest.AttachREST{Store: store, KubeletConn: k}, PortForward: &podrest.PortForwardREST{Store: store, KubeletConn: k}, } }
// NewREST returns a RESTStorage object that will work against replication controllers. func NewREST(opts generic.RESTOptions) (*REST, *StatusREST) { prefix := "/" + opts.ResourcePrefix newListFunc := func() runtime.Object { return &api.ReplicationControllerList{} } storageInterface, dFunc := opts.Decorator( opts.StorageConfig, cachesize.GetWatchCacheSizeByResource(cachesize.Controllers), &api.ReplicationController{}, prefix, controller.Strategy, newListFunc, controller.GetAttrs, storage.NoTriggerPublisher, ) store := &genericregistry.Store{ NewFunc: func() runtime.Object { return &api.ReplicationController{} }, // NewListFunc returns an object capable of storing results of an etcd list. NewListFunc: newListFunc, // Produces a path that etcd understands, to the root of the resource // by combining the namespace in the context with the given prefix KeyRootFunc: func(ctx api.Context) string { return genericregistry.NamespaceKeyRootFunc(ctx, prefix) }, // Produces a path that etcd understands, to the resource by combining // the namespace in the context with the given prefix KeyFunc: func(ctx api.Context, name string) (string, error) { return genericregistry.NamespaceKeyFunc(ctx, prefix, name) }, // Retrieve the name field of a replication controller ObjectNameFunc: func(obj runtime.Object) (string, error) { return obj.(*api.ReplicationController).Name, nil }, // Used to match objects based on labels/fields for list and watch PredicateFunc: controller.MatchController, QualifiedResource: api.Resource("replicationcontrollers"), EnableGarbageCollection: opts.EnableGarbageCollection, DeleteCollectionWorkers: opts.DeleteCollectionWorkers, // Used to validate controller creation CreateStrategy: controller.Strategy, // Used to validate controller updates UpdateStrategy: controller.Strategy, DeleteStrategy: controller.Strategy, Storage: storageInterface, DestroyFunc: dFunc, } statusStore := *store statusStore.UpdateStrategy = controller.StatusStrategy return &REST{store}, &StatusREST{store: &statusStore} }
// NewREST returns a RESTStorage object that will work with ConfigMap objects. func NewREST(opts generic.RESTOptions) *REST { prefix := "/" + opts.ResourcePrefix newListFunc := func() runtime.Object { return &api.ConfigMapList{} } storageInterface, dFunc := opts.Decorator( opts.StorageConfig, cachesize.GetWatchCacheSizeByResource(cachesize.ConfigMaps), &api.ConfigMap{}, prefix, configmap.Strategy, newListFunc, configmap.GetAttrs, storage.NoTriggerPublisher) store := &genericregistry.Store{ NewFunc: func() runtime.Object { return &api.ConfigMap{} }, // NewListFunc returns an object to store results of an etcd list. NewListFunc: newListFunc, // Produces a path that etcd understands, to the root of the resource // by combining the namespace in the context with the given prefix. KeyRootFunc: func(ctx api.Context) string { return genericregistry.NamespaceKeyRootFunc(ctx, prefix) }, // Produces a path that etcd understands, to the resource by combining // the namespace in the context with the given prefix KeyFunc: func(ctx api.Context, name string) (string, error) { return genericregistry.NamespaceKeyFunc(ctx, prefix, name) }, // Retrieves the name field of a ConfigMap object. ObjectNameFunc: func(obj runtime.Object) (string, error) { return obj.(*api.ConfigMap).Name, nil }, // Matches objects based on labels/fields for list and watch PredicateFunc: configmap.MatchConfigMap, QualifiedResource: api.Resource("configmaps"), EnableGarbageCollection: opts.EnableGarbageCollection, DeleteCollectionWorkers: opts.DeleteCollectionWorkers, CreateStrategy: configmap.Strategy, UpdateStrategy: configmap.Strategy, DeleteStrategy: configmap.Strategy, Storage: storageInterface, DestroyFunc: dFunc, } return &REST{store} }
// NewREST returns a RESTStorage object that will work against ScheduledJobs. func NewREST(opts generic.RESTOptions) (*REST, *StatusREST) { prefix := "/" + opts.ResourcePrefix newListFunc := func() runtime.Object { return &batch.ScheduledJobList{} } storageInterface := opts.Decorator( opts.StorageConfig, cachesize.GetWatchCacheSizeByResource(cachesize.ScheduledJobs), &batch.ScheduledJob{}, prefix, scheduledjob.Strategy, newListFunc, storage.NoTriggerPublisher, ) store := ®istry.Store{ NewFunc: func() runtime.Object { return &batch.ScheduledJob{} }, // NewListFunc returns an object capable of storing results of an etcd list. NewListFunc: newListFunc, // Produces a path that etcd understands, to the root of the resource // by combining the namespace in the context with the given prefix KeyRootFunc: func(ctx api.Context) string { return registry.NamespaceKeyRootFunc(ctx, prefix) }, // Produces a path that etcd understands, to the resource by combining // the namespace in the context with the given prefix KeyFunc: func(ctx api.Context, name string) (string, error) { return registry.NamespaceKeyFunc(ctx, prefix, name) }, // Retrieve the name field of a scheduled job ObjectNameFunc: func(obj runtime.Object) (string, error) { return obj.(*batch.ScheduledJob).Name, nil }, // Used to match objects based on labels/fields for list and watch PredicateFunc: scheduledjob.MatchScheduledJob, QualifiedResource: batch.Resource("scheduledjobs"), DeleteCollectionWorkers: opts.DeleteCollectionWorkers, // Used to validate scheduled job creation CreateStrategy: scheduledjob.Strategy, // Used to validate scheduled job updates UpdateStrategy: scheduledjob.Strategy, DeleteStrategy: scheduledjob.Strategy, Storage: storageInterface, } statusStore := *store statusStore.UpdateStrategy = scheduledjob.StatusStrategy return &REST{store}, &StatusREST{store: &statusStore} }
// NewREST returns a RESTStorage object that will work against pod disruption budgets. func NewREST(opts generic.RESTOptions) (*REST, *StatusREST) { prefix := "/poddisruptionbudgets" newListFunc := func() runtime.Object { return &policyapi.PodDisruptionBudgetList{} } storageInterface := opts.Decorator( opts.Storage, cachesize.GetWatchCacheSizeByResource(cachesize.PodDisruptionBudget), &policyapi.PodDisruptionBudget{}, prefix, poddisruptionbudget.Strategy, newListFunc, storage.NoTriggerPublisher, ) store := ®istry.Store{ NewFunc: func() runtime.Object { return &policyapi.PodDisruptionBudget{} }, // NewListFunc returns an object capable of storing results of an etcd list. NewListFunc: newListFunc, // Produces a podDisruptionBudget that etcd understands, to the root of the resource // by combining the namespace in the context with the given prefix KeyRootFunc: func(ctx api.Context) string { return registry.NamespaceKeyRootFunc(ctx, prefix) }, // Produces a podDisruptionBudget that etcd understands, to the resource by combining // the namespace in the context with the given prefix KeyFunc: func(ctx api.Context, name string) (string, error) { return registry.NamespaceKeyFunc(ctx, prefix, name) }, // Retrieve the name field of a pod disruption budget ObjectNameFunc: func(obj runtime.Object) (string, error) { return obj.(*policyapi.PodDisruptionBudget).Name, nil }, // Used to match objects based on labels/fields for list and watch PredicateFunc: poddisruptionbudget.MatchPodDisruptionBudget, QualifiedResource: policyapi.Resource("poddisruptionbudgets"), DeleteCollectionWorkers: opts.DeleteCollectionWorkers, // Used to validate controller creation CreateStrategy: poddisruptionbudget.Strategy, // Used to validate controller updates UpdateStrategy: poddisruptionbudget.Strategy, DeleteStrategy: poddisruptionbudget.Strategy, Storage: storageInterface, } statusStore := *store statusStore.UpdateStrategy = poddisruptionbudget.StatusStrategy return &REST{store}, &StatusREST{store: &statusStore} }
// NewREST returns a RESTStorage object that will work against deployments. func NewREST(opts generic.RESTOptions) (*REST, *StatusREST, *RollbackREST) { prefix := "/" + opts.ResourcePrefix newListFunc := func() runtime.Object { return &extensions.DeploymentList{} } storageInterface, dFunc := opts.Decorator( opts.StorageConfig, cachesize.GetWatchCacheSizeByResource(cachesize.Deployments), &extensions.Deployment{}, prefix, deployment.Strategy, newListFunc, storage.NoTriggerPublisher, ) store := ®istry.Store{ NewFunc: func() runtime.Object { return &extensions.Deployment{} }, // NewListFunc returns an object capable of storing results of an etcd list. NewListFunc: newListFunc, // Produces a path that etcd understands, to the root of the resource // by combining the namespace in the context with the given prefix. KeyRootFunc: func(ctx api.Context) string { return registry.NamespaceKeyRootFunc(ctx, prefix) }, // Produces a path that etcd understands, to the resource by combining // the namespace in the context with the given prefix. KeyFunc: func(ctx api.Context, name string) (string, error) { return registry.NamespaceKeyFunc(ctx, prefix, name) }, // Retrieve the name field of a deployment. ObjectNameFunc: func(obj runtime.Object) (string, error) { return obj.(*extensions.Deployment).Name, nil }, // Used to match objects based on labels/fields for list. PredicateFunc: deployment.MatchDeployment, QualifiedResource: extensions.Resource("deployments"), DeleteCollectionWorkers: opts.DeleteCollectionWorkers, // Used to validate deployment creation. CreateStrategy: deployment.Strategy, // Used to validate deployment updates. UpdateStrategy: deployment.Strategy, DeleteStrategy: deployment.Strategy, Storage: storageInterface, DestroyFunc: dFunc, } statusStore := *store statusStore.UpdateStrategy = deployment.StatusStrategy return &REST{store}, &StatusREST{store: &statusStore}, &RollbackREST{store: store} }
// NewREST returns a RESTStorage object that will work against network policies. func NewREST(opts generic.RESTOptions) *REST { prefix := "/" + opts.ResourcePrefix newListFunc := func() runtime.Object { return &extensionsapi.NetworkPolicyList{} } storageInterface, dFunc := opts.Decorator( opts.StorageConfig, cachesize.GetWatchCacheSizeByResource(cachesize.NetworkPolicys), &extensionsapi.NetworkPolicy{}, prefix, networkpolicy.Strategy, newListFunc, storage.NoTriggerPublisher, ) store := ®istry.Store{ NewFunc: func() runtime.Object { return &extensionsapi.NetworkPolicy{} }, // NewListFunc returns an object capable of storing results of an etcd list. NewListFunc: newListFunc, // Produces a NetworkPolicy that etcd understands, to the root of the resource // by combining the namespace in the context with the given prefix KeyRootFunc: func(ctx api.Context) string { return registry.NamespaceKeyRootFunc(ctx, prefix) }, // Produces a NetworkPolicy that etcd understands, to the resource by combining // the namespace in the context with the given prefix KeyFunc: func(ctx api.Context, name string) (string, error) { return registry.NamespaceKeyFunc(ctx, prefix, name) }, // Retrieve the name field of a network policy ObjectNameFunc: func(obj runtime.Object) (string, error) { return obj.(*extensionsapi.NetworkPolicy).Name, nil }, // Used to match objects based on labels/fields for list and watch PredicateFunc: networkpolicy.MatchNetworkPolicy, QualifiedResource: extensionsapi.Resource("networkpolicies"), EnableGarbageCollection: opts.EnableGarbageCollection, DeleteCollectionWorkers: opts.DeleteCollectionWorkers, // Used to validate controller creation CreateStrategy: networkpolicy.Strategy, // Used to validate controller updates UpdateStrategy: networkpolicy.Strategy, DeleteStrategy: networkpolicy.Strategy, Storage: storageInterface, DestroyFunc: dFunc, } return &REST{store} }
// NewREST returns a RESTStorage object that will work with testtype. func NewREST(config *storagebackend.Config, storageDecorator generic.StorageDecorator) *REST { prefix := "/testtype" newListFunc := func() runtime.Object { return &testgroup.TestTypeList{} } // Usually you should reuse your RESTCreateStrategy. strategy := &NotNamespaceScoped{} getAttrs := func(obj runtime.Object) (labels.Set, fields.Set, error) { testObj, ok := obj.(*testgroup.TestType) if !ok { return nil, nil, fmt.Errorf("not a TestType") } return labels.Set(testObj.Labels), nil, nil } storageInterface, _ := storageDecorator( config, 100, &testgroup.TestType{}, prefix, strategy, newListFunc, getAttrs, storage.NoTriggerPublisher) store := &genericregistry.Store{ NewFunc: func() runtime.Object { return &testgroup.TestType{} }, // NewListFunc returns an object capable of storing results of an etcd list. NewListFunc: newListFunc, // Produces a path that etcd understands, to the root of the resource // by combining the namespace in the context with the given prefix. KeyRootFunc: func(ctx api.Context) string { return genericregistry.NamespaceKeyRootFunc(ctx, prefix) }, // Produces a path that etcd understands, to the resource by combining // the namespace in the context with the given prefix. KeyFunc: func(ctx api.Context, name string) (string, error) { return genericregistry.NamespaceKeyFunc(ctx, prefix, name) }, // Retrieve the name field of the resource. ObjectNameFunc: func(obj runtime.Object) (string, error) { return obj.(*testgroup.TestType).Name, nil }, // Used to match objects based on labels/fields for list. PredicateFunc: func(label labels.Selector, field fields.Selector) storage.SelectionPredicate { return storage.SelectionPredicate{ Label: label, Field: field, GetAttrs: func(obj runtime.Object) (labels.Set, fields.Set, error) { testType, ok := obj.(*testgroup.TestType) if !ok { return nil, nil, fmt.Errorf("unexpected type of given object") } return labels.Set(testType.ObjectMeta.Labels), fields.Set{}, nil }, } }, Storage: storageInterface, } return &REST{store} }
// NewStorage returns a RESTStorage object that will work against pods. func NewStorage(opts generic.RESTOptions, k client.ConnectionInfoGetter, proxyTransport http.RoundTripper) PodStorage { prefix := "/pods" newListFunc := func() runtime.Object { return &api.PodList{} } storageInterface := opts.Decorator( opts.Storage, cachesize.GetWatchCacheSizeByResource(cachesize.Pods), &api.Pod{}, prefix, pod.Strategy, newListFunc) store := ®istry.Store{ NewFunc: func() runtime.Object { return &api.Pod{} }, NewListFunc: newListFunc, KeyRootFunc: func(ctx api.Context) string { return registry.NamespaceKeyRootFunc(ctx, prefix) }, KeyFunc: func(ctx api.Context, name string) (string, error) { return registry.NamespaceKeyFunc(ctx, prefix, name) }, ObjectNameFunc: func(obj runtime.Object) (string, error) { return obj.(*api.Pod).Name, nil }, PredicateFunc: func(label labels.Selector, field fields.Selector) generic.Matcher { return pod.MatchPod(label, field) }, QualifiedResource: api.Resource("pods"), DeleteCollectionWorkers: opts.DeleteCollectionWorkers, CreateStrategy: pod.Strategy, UpdateStrategy: pod.Strategy, DeleteStrategy: pod.Strategy, ReturnDeletedObject: true, Storage: storageInterface, } statusStore := *store statusStore.UpdateStrategy = pod.StatusStrategy return PodStorage{ Pod: &REST{store, proxyTransport}, Binding: &BindingREST{store: store}, Status: &StatusREST{store: &statusStore}, Log: &podrest.LogREST{Store: store, KubeletConn: k}, Proxy: &podrest.ProxyREST{Store: store, ProxyTransport: proxyTransport}, Exec: &podrest.ExecREST{Store: store, KubeletConn: k}, Attach: &podrest.AttachREST{Store: store, KubeletConn: k}, PortForward: &podrest.PortForwardREST{Store: store, KubeletConn: k}, } }
// NewREST returns a RESTStorage object that will work against ReplicaSet. func NewREST(opts generic.RESTOptions) (*REST, *StatusREST) { prefix := "/replicasets" newListFunc := func() runtime.Object { return &extensions.ReplicaSetList{} } storageInterface := opts.Decorator( opts.Storage, cachesize.GetWatchCacheSizeByResource(cachesize.Replicasets), &extensions.ReplicaSet{}, prefix, replicaset.Strategy, newListFunc) store := ®istry.Store{ NewFunc: func() runtime.Object { return &extensions.ReplicaSet{} }, // NewListFunc returns an object capable of storing results of an etcd list. NewListFunc: newListFunc, // Produces a path that etcd understands, to the root of the resource // by combining the namespace in the context with the given prefix KeyRootFunc: func(ctx api.Context) string { return registry.NamespaceKeyRootFunc(ctx, prefix) }, // Produces a path that etcd understands, to the resource by combining // the namespace in the context with the given prefix KeyFunc: func(ctx api.Context, name string) (string, error) { return registry.NamespaceKeyFunc(ctx, prefix, name) }, // Retrieve the name field of a ReplicaSet ObjectNameFunc: func(obj runtime.Object) (string, error) { return obj.(*extensions.ReplicaSet).Name, nil }, // Used to match objects based on labels/fields for list and watch PredicateFunc: func(label labels.Selector, field fields.Selector) generic.Matcher { return replicaset.MatchReplicaSet(label, field) }, QualifiedResource: api.Resource("replicasets"), DeleteCollectionWorkers: opts.DeleteCollectionWorkers, // Used to validate ReplicaSet creation CreateStrategy: replicaset.Strategy, // Used to validate ReplicaSet updates UpdateStrategy: replicaset.Strategy, DeleteStrategy: replicaset.Strategy, Storage: storageInterface, } statusStore := *store statusStore.UpdateStrategy = replicaset.StatusStrategy return &REST{store}, &StatusREST{store: &statusStore} }
// NewREST returns a RESTStorage object that will work against resource quotas. func NewREST(opts generic.RESTOptions) (*REST, *StatusREST) { prefix := "/" + opts.ResourcePrefix newListFunc := func() runtime.Object { return &api.ResourceQuotaList{} } storageInterface, dFunc := opts.Decorator( opts.StorageConfig, cachesize.GetWatchCacheSizeByResource(cachesize.ResourceQuotas), &api.ResourceQuota{}, prefix, resourcequota.Strategy, newListFunc, resourcequota.GetAttrs, storage.NoTriggerPublisher, ) store := &genericregistry.Store{ NewFunc: func() runtime.Object { return &api.ResourceQuota{} }, NewListFunc: newListFunc, KeyRootFunc: func(ctx api.Context) string { return genericregistry.NamespaceKeyRootFunc(ctx, prefix) }, KeyFunc: func(ctx api.Context, name string) (string, error) { return genericregistry.NamespaceKeyFunc(ctx, prefix, name) }, ObjectNameFunc: func(obj runtime.Object) (string, error) { return obj.(*api.ResourceQuota).Name, nil }, PredicateFunc: resourcequota.MatchResourceQuota, QualifiedResource: api.Resource("resourcequotas"), EnableGarbageCollection: opts.EnableGarbageCollection, DeleteCollectionWorkers: opts.DeleteCollectionWorkers, CreateStrategy: resourcequota.Strategy, UpdateStrategy: resourcequota.Strategy, DeleteStrategy: resourcequota.Strategy, ReturnDeletedObject: true, Storage: storageInterface, DestroyFunc: dFunc, } statusStore := *store statusStore.UpdateStrategy = resourcequota.StatusStrategy return &REST{store}, &StatusREST{store: &statusStore} }
// NewREST returns a RESTStorage object that will work against pod templates. func NewREST(opts generic.RESTOptions) *REST { prefix := "/" + opts.ResourcePrefix newListFunc := func() runtime.Object { return &api.PodTemplateList{} } storageInterface, dFunc := opts.Decorator( opts.StorageConfig, cachesize.GetWatchCacheSizeByResource(cachesize.PodTemplates), &api.PodTemplate{}, prefix, podtemplate.Strategy, newListFunc, podtemplate.GetAttrs, storage.NoTriggerPublisher, ) store := &genericregistry.Store{ NewFunc: func() runtime.Object { return &api.PodTemplate{} }, NewListFunc: newListFunc, KeyRootFunc: func(ctx api.Context) string { return genericregistry.NamespaceKeyRootFunc(ctx, prefix) }, KeyFunc: func(ctx api.Context, name string) (string, error) { return genericregistry.NamespaceKeyFunc(ctx, prefix, name) }, ObjectNameFunc: func(obj runtime.Object) (string, error) { return obj.(*api.PodTemplate).Name, nil }, PredicateFunc: podtemplate.MatchPodTemplate, QualifiedResource: api.Resource("podtemplates"), EnableGarbageCollection: opts.EnableGarbageCollection, DeleteCollectionWorkers: opts.DeleteCollectionWorkers, CreateStrategy: podtemplate.Strategy, UpdateStrategy: podtemplate.Strategy, DeleteStrategy: podtemplate.Strategy, ExportStrategy: podtemplate.Strategy, ReturnDeletedObject: true, Storage: storageInterface, DestroyFunc: dFunc, } return &REST{store} }
// NewREST returns a RESTStorage object that will work against persistent volume claims. func NewREST(opts generic.RESTOptions) (*REST, *StatusREST) { prefix := "/" + opts.ResourcePrefix newListFunc := func() runtime.Object { return &api.PersistentVolumeClaimList{} } storageInterface, dFunc := opts.Decorator( opts.StorageConfig, cachesize.GetWatchCacheSizeByResource(cachesize.PersistentVolumeClaims), &api.PersistentVolumeClaim{}, prefix, persistentvolumeclaim.Strategy, newListFunc, storage.NoTriggerPublisher, ) store := ®istry.Store{ NewFunc: func() runtime.Object { return &api.PersistentVolumeClaim{} }, NewListFunc: newListFunc, KeyRootFunc: func(ctx api.Context) string { return registry.NamespaceKeyRootFunc(ctx, prefix) }, KeyFunc: func(ctx api.Context, name string) (string, error) { return registry.NamespaceKeyFunc(ctx, prefix, name) }, ObjectNameFunc: func(obj runtime.Object) (string, error) { return obj.(*api.PersistentVolumeClaim).Name, nil }, PredicateFunc: persistentvolumeclaim.MatchPersistentVolumeClaim, QualifiedResource: api.Resource("persistentvolumeclaims"), DeleteCollectionWorkers: opts.DeleteCollectionWorkers, CreateStrategy: persistentvolumeclaim.Strategy, UpdateStrategy: persistentvolumeclaim.Strategy, DeleteStrategy: persistentvolumeclaim.Strategy, ReturnDeletedObject: true, Storage: storageInterface, DestroyFunc: dFunc, } statusStore := *store statusStore.UpdateStrategy = persistentvolumeclaim.StatusStrategy return &REST{store}, &StatusREST{store: &statusStore} }
// NewREST returns a RESTStorage object that will work against horizontal pod autoscalers. func NewREST(opts generic.RESTOptions) (*REST, *StatusREST) { prefix := "/horizontalpodautoscalers" newListFunc := func() runtime.Object { return &autoscaling.HorizontalPodAutoscalerList{} } storageInterface := opts.Decorator( opts.Storage, cachesize.GetWatchCacheSizeByResource(cachesize.HorizontalPodAutoscalers), &autoscaling.HorizontalPodAutoscaler{}, prefix, horizontalpodautoscaler.Strategy, newListFunc) store := ®istry.Store{ NewFunc: func() runtime.Object { return &autoscaling.HorizontalPodAutoscaler{} }, // NewListFunc returns an object capable of storing results of an etcd list. NewListFunc: newListFunc, // Produces a path that etcd understands, to the root of the resource // by combining the namespace in the context with the given prefix KeyRootFunc: func(ctx api.Context) string { return registry.NamespaceKeyRootFunc(ctx, prefix) }, // Produces a path that etcd understands, to the resource by combining // the namespace in the context with the given prefix KeyFunc: func(ctx api.Context, name string) (string, error) { return registry.NamespaceKeyFunc(ctx, prefix, name) }, // Retrieve the name field of an autoscaler ObjectNameFunc: func(obj runtime.Object) (string, error) { return obj.(*autoscaling.HorizontalPodAutoscaler).Name, nil }, // Used to match objects based on labels/fields for list PredicateFunc: horizontalpodautoscaler.MatchAutoscaler, QualifiedResource: autoscaling.Resource("horizontalpodautoscalers"), DeleteCollectionWorkers: opts.DeleteCollectionWorkers, // Used to validate autoscaler creation CreateStrategy: horizontalpodautoscaler.Strategy, // Used to validate autoscaler updates UpdateStrategy: horizontalpodautoscaler.Strategy, DeleteStrategy: horizontalpodautoscaler.Strategy, Storage: storageInterface, } statusStore := *store statusStore.UpdateStrategy = horizontalpodautoscaler.StatusStrategy return &REST{store}, &StatusREST{store: &statusStore} }
// NewREST returns a RESTStorage object that will work against RoleBinding objects. func NewREST(opts generic.RESTOptions) *REST { prefix := "/" + opts.ResourcePrefix newListFunc := func() runtime.Object { return &rbac.RoleBindingList{} } storageInterface, dFunc := opts.Decorator( opts.StorageConfig, cachesize.GetWatchCacheSizeByResource(cachesize.RoleBindings), &rbac.RoleBinding{}, prefix, rolebinding.Strategy, newListFunc, rolebinding.GetAttrs, storage.NoTriggerPublisher, ) store := &genericregistry.Store{ NewFunc: func() runtime.Object { return &rbac.RoleBinding{} }, NewListFunc: newListFunc, KeyRootFunc: func(ctx api.Context) string { return genericregistry.NamespaceKeyRootFunc(ctx, prefix) }, KeyFunc: func(ctx api.Context, id string) (string, error) { return genericregistry.NamespaceKeyFunc(ctx, prefix, id) }, ObjectNameFunc: func(obj runtime.Object) (string, error) { return obj.(*rbac.RoleBinding).Name, nil }, PredicateFunc: rolebinding.Matcher, QualifiedResource: rbac.Resource("rolebindings"), EnableGarbageCollection: opts.EnableGarbageCollection, DeleteCollectionWorkers: opts.DeleteCollectionWorkers, CreateStrategy: rolebinding.Strategy, UpdateStrategy: rolebinding.Strategy, DeleteStrategy: rolebinding.Strategy, Storage: storageInterface, DestroyFunc: dFunc, } return &REST{store} }