// NewREST returns a RESTStorage object that will work against nodes.
func NewREST(s storage.Interface, storageDecorator generic.StorageDecorator, connection client.ConnectionInfoGetter, proxyTransport http.RoundTripper) (*REST, *StatusREST) {
prefix := "/minions"
newListFunc := func() runtime.Object { return &api.NodeList{} }
storageInterface := storageDecorator(
s, 1000, &api.Node{}, prefix, false, newListFunc)
store := &etcdgeneric.Etcd{
NewFunc: func() runtime.Object { return &api.Node{} },
NewListFunc: newListFunc,
KeyRootFunc: func(ctx api.Context) string {
return prefix
},
KeyFunc: func(ctx api.Context, name string) (string, error) {
return etcdgeneric.NoNamespaceKeyFunc(ctx, prefix, name)
},
ObjectNameFunc: func(obj runtime.Object) (string, error) {
return obj.(*api.Node).Name, nil
},
PredicateFunc: node.MatchNode,
EndpointName: "node",
CreateStrategy: node.Strategy,
UpdateStrategy: node.Strategy,
Storage: storageInterface,
}
statusStore := *store
statusStore.UpdateStrategy = node.StatusStrategy
return &REST{store, connection, proxyTransport}, &StatusREST{store: &statusStore}
}
// NewREST returns a RESTStorage object that will work against PodSecurityPolicy objects.
func NewREST(opts generic.RESTOptions) *REST {
newListFunc := func() runtime.Object { return &extensions.PodSecurityPolicyList{} }
storageInterface := opts.Decorator(
opts.Storage, 100, &extensions.PodSecurityPolicy{}, Prefix, podsecuritypolicy.Strategy, newListFunc)
store := &etcdgeneric.Etcd{
NewFunc: func() runtime.Object { return &extensions.PodSecurityPolicy{} },
NewListFunc: newListFunc,
KeyRootFunc: func(ctx api.Context) string {
return Prefix
},
KeyFunc: func(ctx api.Context, name string) (string, error) {
return etcdgeneric.NoNamespaceKeyFunc(ctx, Prefix, name)
},
ObjectNameFunc: func(obj runtime.Object) (string, error) {
return obj.(*extensions.PodSecurityPolicy).Name, nil
},
PredicateFunc: func(label labels.Selector, field fields.Selector) generic.Matcher {
return podsecuritypolicy.MatchPodSecurityPolicy(label, field)
},
QualifiedResource: extensions.Resource("podsecuritypolicies"),
CreateStrategy: podsecuritypolicy.Strategy,
UpdateStrategy: podsecuritypolicy.Strategy,
ReturnDeletedObject: true,
Storage: storageInterface,
}
return &REST{store}
}
// NewREST returns a RESTStorage object that will work against subnets
func NewREST(s storage.Interface) *REST {
store := &etcdgeneric.Etcd{
NewFunc: func() runtime.Object { return &api.HostSubnet{} },
NewListFunc: func() runtime.Object { return &api.HostSubnetList{} },
KeyRootFunc: func(ctx kapi.Context) string {
return etcdPrefix
},
KeyFunc: func(ctx kapi.Context, name string) (string, error) {
return etcdgeneric.NoNamespaceKeyFunc(ctx, etcdPrefix, name)
},
ObjectNameFunc: func(obj runtime.Object) (string, error) {
return obj.(*api.HostSubnet).Host, nil
},
PredicateFunc: func(label labels.Selector, field fields.Selector) generic.Matcher {
return hostsubnet.Matcher(label, field)
},
QualifiedResource: api.Resource("hostsubnets"),
Storage: s,
}
store.CreateStrategy = hostsubnet.Strategy
store.UpdateStrategy = hostsubnet.Strategy
return &REST{*store}
}
// NewREST returns a RESTStorage object that will work against netnamespaces
func NewREST(s storage.Interface) *REST {
store := &etcdgeneric.Etcd{
NewFunc: func() runtime.Object { return &api.NetNamespace{} },
NewListFunc: func() runtime.Object { return &api.NetNamespaceList{} },
KeyRootFunc: func(ctx kapi.Context) string {
return etcdPrefix
},
KeyFunc: func(ctx kapi.Context, name string) (string, error) {
return etcdgeneric.NoNamespaceKeyFunc(ctx, etcdPrefix, name)
},
ObjectNameFunc: func(obj runtime.Object) (string, error) {
return obj.(*api.NetNamespace).NetName, nil
},
PredicateFunc: func(label labels.Selector, field fields.Selector) generic.Matcher {
return netnamespace.Matcher(label, field)
},
EndpointName: "netnamespace",
Storage: s,
}
store.CreateStrategy = netnamespace.Strategy
store.UpdateStrategy = netnamespace.Strategy
return &REST{*store}
}
// NewREST returns a new REST.
func NewREST(s storage.Interface) *REST {
prefix := "/images"
store := &etcdgeneric.Etcd{
NewFunc: func() runtime.Object { return &api.Image{} },
NewListFunc: func() runtime.Object { return &api.ImageList{} },
KeyRootFunc: func(ctx kapi.Context) string {
// images are not namespace scoped
return prefix
},
KeyFunc: func(ctx kapi.Context, name string) (string, error) {
// images are not namespace scoped
return etcdgeneric.NoNamespaceKeyFunc(ctx, prefix, name)
},
ObjectNameFunc: func(obj runtime.Object) (string, error) {
return obj.(*api.Image).Name, nil
},
EndpointName: "image",
CreateStrategy: image.Strategy,
UpdateStrategy: image.Strategy,
ReturnDeletedObject: false,
Storage: s,
}
return &REST{store: store}
}
// NewREST returns a new REST.
func NewREST(s storage.Interface, oClient *oclient.Client, kClient *kclient.Client) *REST {
prefix := "/applications"
application.AppStrategy.OClient = oClient
application.AppStrategy.KClient = kClient
store := &etcdgeneric.Etcd{
NewFunc: func() runtime.Object { return &api.Application{} },
NewListFunc: func() runtime.Object { return &api.ApplicationList{} },
KeyRootFunc: func(ctx kapi.Context) string {
return prefix
},
KeyFunc: func(ctx kapi.Context, name string) (string, error) {
return etcdgeneric.NoNamespaceKeyFunc(ctx, prefix, name)
},
ObjectNameFunc: func(obj runtime.Object) (string, error) {
return obj.(*api.Application).Name, nil
},
PredicateFunc: func(label labels.Selector, field fields.Selector) generic.Matcher {
return application.Matcher(label, field)
},
QualifiedResource: api.Resource("applications"),
CreateStrategy: application.AppStrategy,
UpdateStrategy: application.AppStrategy,
ReturnDeletedObject: false,
Storage: s,
}
return &REST{store: store}
}
// NewREST returns a RESTStorage object that will work against persistent volumes.
func NewREST(s storage.Interface) (*REST, *StatusREST) {
prefix := "/persistentvolumes"
store := &etcdgeneric.Etcd{
NewFunc: func() runtime.Object { return &api.PersistentVolume{} },
NewListFunc: func() runtime.Object { return &api.PersistentVolumeList{} },
KeyRootFunc: func(ctx api.Context) string {
return prefix
},
KeyFunc: func(ctx api.Context, name string) (string, error) {
return etcdgeneric.NoNamespaceKeyFunc(ctx, prefix, name)
},
ObjectNameFunc: func(obj runtime.Object) (string, error) {
return obj.(*api.PersistentVolume).Name, nil
},
PredicateFunc: func(label labels.Selector, field fields.Selector) generic.Matcher {
return persistentvolume.MatchPersistentVolumes(label, field)
},
EndpointName: "persistentvolume",
CreateStrategy: persistentvolume.Strategy,
UpdateStrategy: persistentvolume.Strategy,
ReturnDeletedObject: true,
Storage: s,
}
statusStore := *store
statusStore.UpdateStrategy = persistentvolume.StatusStrategy
return &REST{store}, &StatusREST{store: &statusStore}
}
// NewREST returns a RESTStorage object that will work against nodes.
func NewREST(s storage.Interface, useCacher bool, connection client.ConnectionInfoGetter, proxyTransport http.RoundTripper) (*REST, *StatusREST) {
prefix := "/minions"
storageInterface := s
if useCacher {
config := storage.CacherConfig{
CacheCapacity: 1000,
Storage: s,
Type: &api.Node{},
ResourcePrefix: prefix,
KeyFunc: func(obj runtime.Object) (string, error) {
return storage.NoNamespaceKeyFunc(prefix, obj)
},
NewListFunc: func() runtime.Object { return &api.NodeList{} },
}
storageInterface = storage.NewCacher(config)
}
store := &etcdgeneric.Etcd{
NewFunc: func() runtime.Object { return &api.Node{} },
NewListFunc: func() runtime.Object { return &api.NodeList{} },
KeyRootFunc: func(ctx api.Context) string {
return prefix
},
KeyFunc: func(ctx api.Context, name string) (string, error) {
return etcdgeneric.NoNamespaceKeyFunc(ctx, prefix, name)
},
ObjectNameFunc: func(obj runtime.Object) (string, error) {
return obj.(*api.Node).Name, nil
},
PredicateFunc: node.MatchNode,
EndpointName: "node",
CreateStrategy: node.Strategy,
UpdateStrategy: node.Strategy,
Storage: storageInterface,
}
statusStore := *store
statusStore.UpdateStrategy = node.StatusStrategy
return &REST{store, connection, proxyTransport}, &StatusREST{store: &statusStore}
}
// NewREST returns a new REST.
func NewREST(s storage.Interface) *REST {
prefix := "/images"
store := &etcdgeneric.Etcd{
NewFunc: func() runtime.Object { return &api.Image{} },
// NewListFunc returns an object capable of storing results of an etcd list.
NewListFunc: func() runtime.Object { return &api.ImageList{} },
// Produces a path that etcd understands, to the root of the resource
// by combining the namespace in the context with the given prefix.
// Yet images are not namespace scoped, so we're returning just prefix here.
KeyRootFunc: func(ctx kapi.Context) string {
return prefix
},
// Produces a path that etcd understands, to the resource by combining
// the namespace in the context with the given prefix
// Yet images are not namespace scoped, so we're returning just prefix here.
KeyFunc: func(ctx kapi.Context, name string) (string, error) {
return etcdgeneric.NoNamespaceKeyFunc(ctx, prefix, name)
},
// Retrieve the name field of an image
ObjectNameFunc: func(obj runtime.Object) (string, error) {
return obj.(*api.Image).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 image.MatchImage(label, field)
},
QualifiedResource: api.Resource("images"),
// Used to validate image creation
CreateStrategy: image.Strategy,
// Used to validate image updates
UpdateStrategy: image.Strategy,
ReturnDeletedObject: false,
Storage: s,
}
return &REST{store}
}
// NewREST returns a RESTStorage object that will work against nodes.
func NewStorage(opts generic.RESTOptions, connection client.ConnectionInfoGetter, proxyTransport http.RoundTripper) NodeStorage {
prefix := "/minions"
newListFunc := func() runtime.Object { return &api.NodeList{} }
storageInterface := opts.Decorator(
opts.Storage, cachesize.GetWatchCacheSizeByResource(cachesize.Nodes), &api.Node{}, prefix, node.Strategy, newListFunc)
store := &etcdgeneric.Etcd{
NewFunc: func() runtime.Object { return &api.Node{} },
NewListFunc: newListFunc,
KeyRootFunc: func(ctx api.Context) string {
return prefix
},
KeyFunc: func(ctx api.Context, name string) (string, error) {
return etcdgeneric.NoNamespaceKeyFunc(ctx, prefix, name)
},
ObjectNameFunc: func(obj runtime.Object) (string, error) {
return obj.(*api.Node).Name, nil
},
PredicateFunc: node.MatchNode,
QualifiedResource: api.Resource("nodes"),
DeleteCollectionWorkers: opts.DeleteCollectionWorkers,
CreateStrategy: node.Strategy,
UpdateStrategy: node.Strategy,
DeleteStrategy: node.Strategy,
ExportStrategy: node.Strategy,
Storage: storageInterface,
}
statusStore := *store
statusStore.UpdateStrategy = node.StatusStrategy
nodeREST := &REST{store, connection, proxyTransport}
return NodeStorage{
Node: nodeREST,
Status: &StatusREST{store: &statusStore},
Proxy: &noderest.ProxyREST{Store: store, Connection: client.ConnectionInfoGetter(nodeREST), ProxyTransport: proxyTransport},
}
}
// NewREST returns a RESTStorage object that will work against namespaces.
func NewREST(opts generic.RESTOptions) (*REST, *StatusREST, *FinalizeREST) {
prefix := "/namespaces"
newListFunc := func() runtime.Object { return &api.NamespaceList{} }
storageInterface := opts.Decorator(
opts.Storage, cachesize.GetWatchCacheSizeByResource(cachesize.Namespaces), &api.Namespace{}, prefix, namespace.Strategy, newListFunc)
store := &etcdgeneric.Etcd{
NewFunc: func() runtime.Object { return &api.Namespace{} },
NewListFunc: newListFunc,
KeyRootFunc: func(ctx api.Context) string {
return prefix
},
KeyFunc: func(ctx api.Context, name string) (string, error) {
return etcdgeneric.NoNamespaceKeyFunc(ctx, prefix, name)
},
ObjectNameFunc: func(obj runtime.Object) (string, error) {
return obj.(*api.Namespace).Name, nil
},
PredicateFunc: func(label labels.Selector, field fields.Selector) generic.Matcher {
return namespace.MatchNamespace(label, field)
},
QualifiedResource: api.Resource("namespaces"),
DeleteCollectionWorkers: opts.DeleteCollectionWorkers,
CreateStrategy: namespace.Strategy,
UpdateStrategy: namespace.Strategy,
DeleteStrategy: namespace.Strategy,
ReturnDeletedObject: true,
Storage: storageInterface,
}
statusStore := *store
statusStore.UpdateStrategy = namespace.StatusStrategy
finalizeStore := *store
finalizeStore.UpdateStrategy = namespace.FinalizeStrategy
return &REST{Etcd: store, status: &statusStore}, &StatusREST{store: &statusStore}, &FinalizeREST{store: &finalizeStore}
}
// NewREST returns a RESTStorage object that will work against namespaces.
func NewREST(s storage.Interface, storageDecorator generic.StorageDecorator) (*REST, *StatusREST, *FinalizeREST) {
prefix := "/namespaces"
newListFunc := func() runtime.Object { return &api.NamespaceList{} }
storageInterface := storageDecorator(
s, 100, &api.Namespace{}, prefix, true, newListFunc)
store := &etcdgeneric.Etcd{
NewFunc: func() runtime.Object { return &api.Namespace{} },
NewListFunc: newListFunc,
KeyRootFunc: func(ctx api.Context) string {
return prefix
},
KeyFunc: func(ctx api.Context, name string) (string, error) {
return etcdgeneric.NoNamespaceKeyFunc(ctx, prefix, name)
},
ObjectNameFunc: func(obj runtime.Object) (string, error) {
return obj.(*api.Namespace).Name, nil
},
PredicateFunc: func(label labels.Selector, field fields.Selector) generic.Matcher {
return namespace.MatchNamespace(label, field)
},
EndpointName: "namespaces",
CreateStrategy: namespace.Strategy,
UpdateStrategy: namespace.Strategy,
ReturnDeletedObject: true,
Storage: storageInterface,
}
statusStore := *store
statusStore.UpdateStrategy = namespace.StatusStrategy
finalizeStore := *store
finalizeStore.UpdateStrategy = namespace.FinalizeStrategy
return &REST{Etcd: store, status: &statusStore}, &StatusREST{store: &statusStore}, &FinalizeREST{store: &finalizeStore}
}
// NewREST returns a new REST.
func NewREST(s storage.Interface, oClient *oclient.Client) *REST {
prefix := "/servicebrokers"
store := &etcdgeneric.Etcd{
NewFunc: func() runtime.Object {
return &servicebrokerapi.ServiceBroker{}
},
NewListFunc: func() runtime.Object {
return &servicebrokerapi.ServiceBrokerList{}
},
KeyRootFunc: func(ctx kapi.Context) string {
return prefix
},
KeyFunc: func(ctx kapi.Context, name string) (string, error) {
return etcdgeneric.NoNamespaceKeyFunc(ctx, prefix, name)
},
ObjectNameFunc: func(obj runtime.Object) (string, error) {
return obj.(*servicebrokerapi.ServiceBroker).Name, nil
},
PredicateFunc: func(label labels.Selector, field fields.Selector) generic.Matcher {
return servicebroker.Matcher(label, field)
},
QualifiedResource: servicebrokerapi.Resource("servicebroker"),
CreateStrategy: servicebroker.SbStrategy,
UpdateStrategy: servicebroker.SbStrategy,
ReturnDeletedObject: false,
Storage: s,
}
return &REST{
store: store,
bsClient: oClient.BackingServices(backingserviceapi.BSNS),
bsiClient: oClient.BackingServiceInstances(kapi.NamespaceAll),
}
}
// NewREST returns a RESTStorage object that will work against persistent volumes.
func NewREST(s storage.Interface, storageDecorator generic.StorageDecorator) (*REST, *StatusREST) {
prefix := "/persistentvolumes"
newListFunc := func() runtime.Object { return &api.PersistentVolumeList{} }
storageInterface := storageDecorator(
s, cachesize.GetWatchCacheSizeByResource(cachesize.PersistentVolumes), &api.PersistentVolume{}, prefix, persistentvolume.Strategy, newListFunc)
store := &etcdgeneric.Etcd{
NewFunc: func() runtime.Object { return &api.PersistentVolume{} },
NewListFunc: newListFunc,
KeyRootFunc: func(ctx api.Context) string {
return prefix
},
KeyFunc: func(ctx api.Context, name string) (string, error) {
return etcdgeneric.NoNamespaceKeyFunc(ctx, prefix, name)
},
ObjectNameFunc: func(obj runtime.Object) (string, error) {
return obj.(*api.PersistentVolume).Name, nil
},
PredicateFunc: func(label labels.Selector, field fields.Selector) generic.Matcher {
return persistentvolume.MatchPersistentVolumes(label, field)
},
QualifiedResource: api.Resource("persistentvolumes"),
CreateStrategy: persistentvolume.Strategy,
UpdateStrategy: persistentvolume.Strategy,
ReturnDeletedObject: true,
Storage: storageInterface,
}
statusStore := *store
statusStore.UpdateStrategy = persistentvolume.StatusStrategy
return &REST{store}, &StatusREST{store: &statusStore}
}