Add generic registry object so we can stop rewriting this code

pkg/registry/generic/doc.go

+/*
+Copyright 2014 Google Inc. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Package generic provides a generic object store interface and a
+// generic label/field matching type.
+package generic

pkg/registry/generic/etcd.go

+/*
+Copyright 2014 Google Inc. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package generic
+
+import (
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/api"
+	etcderr "github.com/GoogleCloudPlatform/kubernetes/pkg/api/errors/etcd"
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/runtime"
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/tools"
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/watch"
+)
+
+// Etcd implements generic.Registry, backing it with etcd storage.
+// It's intended to be embeddable, so that you can implement any
+// non-generic functions if needed.
+// You must supply a value for every field below before use; these are
+// left public as it's meant to be overridable if need be.
+type Etcd struct {
+	// Called to make a new object, should return e.g., &api.Pod{}
+	NewFunc func() runtime.Object
+
+	// Called to make a new listing object, should return e.g., &api.PodList{}
+	NewListFunc func() runtime.Object
+
+	// Used for error reporting
+	EndpointName string
+
+	// Used for listing/watching; should not include trailing "/"
+	KeyRoot string
+
+	// Called for Create/Update/Get/Delete
+	KeyFunc func(id string) string
+
+	// Used for all etcd access functions
+	Helper tools.EtcdHelper
+}
+
+// List returns a list of all the items matching m.
+func (e *Etcd) List(ctx api.Context, m Matcher) (runtime.Object, error) {
+	list := e.NewListFunc()
+	err := e.Helper.ExtractToList(e.KeyRoot, list)
+	if err != nil {
+		return nil, err
+	}
+	return FilterList(list, m)
+}
+
+// FilterList filters any list object that conforms to the api conventions,
+// provided that 'm' works with the concrete type of list.
+func FilterList(list runtime.Object, m Matcher) (filtered runtime.Object, err error) {
+	// TODO: push a matcher down into tools.EtcdHelper to avoid all this
+	// nonsense. This is a lot of unnecessary copies.
+	items, err := runtime.ExtractList(list)
+	if err != nil {
+		return nil, err
+	}
+	var filteredItems []runtime.Object
+	for _, obj := range items {
+		if match, err := m.Matches(obj); err == nil && match {
+			filteredItems = append(filteredItems, obj)
+		}
+	}
+	err = runtime.SetList(list, filteredItems)
+	if err != nil {
+		return nil, err
+	}
+	return list, nil
+}
+
+// Create inserts a new item.
+func (e *Etcd) Create(ctx api.Context, id string, obj runtime.Object) error {
+	err := e.Helper.CreateObj(e.KeyFunc(id), obj, 0)
+	return etcderr.InterpretCreateError(err, e.EndpointName, id)
+}
+
+// Update updates the item.
+func (e *Etcd) Update(ctx api.Context, id string, obj runtime.Object) error {
+	err := e.Helper.SetObj(e.KeyFunc(id), obj)
+	return etcderr.InterpretUpdateError(err, e.EndpointName, id)
+}
+
+// Get retrieves the item from etcd.
+func (e *Etcd) Get(ctx api.Context, id string) (runtime.Object, error) {
+	obj := e.NewFunc()
+	err := e.Helper.ExtractObj(e.KeyFunc(id), obj, false)
+	if err != nil {
+		return nil, etcderr.InterpretGetError(err, e.EndpointName, id)
+	}
+	return obj, nil
+}
+
+// Delete removes the item from etcd.
+func (e *Etcd) Delete(ctx api.Context, id string) error {
+	err := e.Helper.Delete(e.KeyFunc(id), false)
+	return etcderr.InterpretDeleteError(err, e.EndpointName, id)
+}
+
+// Watch starts a watch for the items that m matches.
+// TODO: Detect if m references a single object instead of a list.
+func (e *Etcd) Watch(ctx api.Context, m Matcher, resourceVersion uint64) (watch.Interface, error) {
+	return e.Helper.WatchList(e.KeyRoot, resourceVersion, func(obj runtime.Object) bool {
+		matches, err := m.Matches(obj)
+		return err == nil && matches
+	})
+}

pkg/registry/generic/registry.go

+/*
+Copyright 2014 Google Inc. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package generic
+
+import (
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/api"
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/labels"
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/runtime"
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/watch"
+)
+
+// AttrFunc returns label and field sets for List or Watch to compare against, or an error.
+type AttrFunc func(obj runtime.Object) (label, field labels.Set, err error)
+
+// SelectionPredicate implements a generic predicate that can be passed to
+// GenericRegistry's List or Watch methods. Implements the Matcher interface.
+type SelectionPredicate struct {
+	Label    labels.Selector
+	Field    labels.Selector
+	GetAttrs AttrFunc
+}
+
+// Matches returns true if the given object's labels and fields (as
+// returned by s.GetAttrs) match s.Label and s.Field. An error is
+// returned if s.GetAttrs fails.
+func (s *SelectionPredicate) Matches(obj runtime.Object) (bool, error) {
+	if s.Label.Empty() && s.Field.Empty() {
+		return true, nil
+	}
+	labels, fields, err := s.GetAttrs(obj)
+	if err != nil {
+		return false, err
+	}
+	return s.Label.Matches(labels) && s.Field.Matches(fields), nil
+}
+
+// Matcher can return true if an object matches the Matcher's selection
+// criteria.
+type Matcher interface {
+	Matches(obj runtime.Object) (bool, error)
+}
+
+// Registry knows how to store & list any runtime.Object. Can be used for
+// any object types which don't require special features from the storage
+// layer.
+type Registry interface {
+	List(api.Context, Matcher) (runtime.Object, error)
+	Create(ctx api.Context, id string, obj runtime.Object) error
+	Update(ctx api.Context, id string, obj runtime.Object) error
+	Get(ctx api.Context, id string) (runtime.Object, error)
+	Delete(ctx api.Context, id string) error
+	Watch(ctx api.Context, m Matcher, resourceVersion uint64) (watch.Interface, error)
+}

pkg/registry/generic/registry_test.go

+/*
+Copyright 2014 Google Inc. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package generic
+
+import (
+	"errors"
+	"testing"
+
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/labels"
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/runtime"
+)
+
+type Ignored struct{}
+
+func (*Ignored) IsAnAPIObject() {}
+
+func TestSelectionPredicate(t *testing.T) {
+	table := map[string]struct {
+		labelSelector, fieldSelector string
+		labels, fields               labels.Set
+		err                          error
+		shouldMatch                  bool
+	}{
+		"A": {
+			labelSelector: "name=foo",
+			fieldSelector: "uid=12345",
+			labels:        labels.Set{"name": "foo"},
+			fields:        labels.Set{"uid": "12345"},
+			shouldMatch:   true,
+		},
+		"B": {
+			labelSelector: "name=foo",
+			fieldSelector: "uid=12345",
+			labels:        labels.Set{"name": "foo"},
+			fields:        labels.Set{},
+			shouldMatch:   false,
+		},
+		"C": {
+			labelSelector: "name=foo",
+			fieldSelector: "uid=12345",
+			labels:        labels.Set{},
+			fields:        labels.Set{"uid": "12345"},
+			shouldMatch:   false,
+		},
+		"error": {
+			labelSelector: "name=foo",
+			fieldSelector: "uid=12345",
+			err:           errors.New("maybe this is a 'wrong object type' error"),
+			shouldMatch:   false,
+		},
+	}
+
+	for name, item := range table {
+		parsedLabel, err := labels.ParseSelector(item.labelSelector)
+		if err != nil {
+			panic(err)
+		}
+		parsedField, err := labels.ParseSelector(item.fieldSelector)
+		if err != nil {
+			panic(err)
+		}
+		sp := &SelectionPredicate{
+			Label: parsedLabel,
+			Field: parsedField,
+			GetAttrs: func(runtime.Object) (label, field labels.Set, err error) {
+				return item.labels, item.fields, item.err
+			},
+		}
+		got, err := sp.Matches(&Ignored{})
+		if e, a := item.err, err; e != a {
+			t.Errorf("%v: expected %v, got %v", name, e, a)
+			continue
+		}
+		if e, a := item.shouldMatch, got; e != a {
+			t.Errorf("%v: expected %v, got %v", name, e, a)
+		}
+	}
+}

pkg/registry/registrytest/generic.go

+/*
+Copyright 2014 Google Inc. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package registrytest
+
+import (
+	"sync"
+
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/api"
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/registry/generic"
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/runtime"
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/watch"
+)
+
+// GenericRegistry knows how to store & list any runtime.Object. Events don't require
+// any non-generic features from the storage layer.
+type GenericRegistry struct {
+	Err        error
+	Object     runtime.Object
+	ObjectList runtime.Object
+	sync.Mutex
+
+	Mux *watch.Mux
+}
+
+func NewGeneric(list runtime.Object) *GenericRegistry {
+	return &GenericRegistry{
+		ObjectList: list,
+		Mux:        watch.NewMux(0),
+	}
+}
+
+func (r *GenericRegistry) List(ctx api.Context, m generic.Matcher) (runtime.Object, error) {
+	r.Lock()
+	defer r.Unlock()
+	if r.Err != nil {
+		return nil, r.Err
+	}
+	return generic.FilterList(r.ObjectList, m)
+}
+
+func (r *GenericRegistry) Watch(ctx api.Context, m generic.Matcher, resourceVersion uint64) (watch.Interface, error) {
+	// TODO: wire filter down into the mux; it needs access to current and previous state :(
+	return r.Mux.Watch(), nil
+}
+
+func (r *GenericRegistry) Get(ctx api.Context, id string) (runtime.Object, error) {
+	r.Lock()
+	defer r.Unlock()
+	return r.Object, r.Err
+}
+
+func (r *GenericRegistry) Create(ctx api.Context, id string, obj runtime.Object) error {
+	r.Lock()
+	defer r.Unlock()
+	r.Object = obj
+	r.Mux.Action(watch.Added, obj)
+	return r.Err
+}
+
+func (r *GenericRegistry) Update(ctx api.Context, id string, obj runtime.Object) error {
+	r.Lock()
+	defer r.Unlock()
+	r.Object = obj
+	r.Mux.Action(watch.Modified, obj)
+	return r.Err
+}
+
+func (r *GenericRegistry) Delete(ctx api.Context, id string) error {
+	r.Lock()
+	defer r.Unlock()
+	r.Mux.Action(watch.Deleted, r.Object)
+	return r.Err
+}

pkg/tools/fake_etcd_client.go

@@ -167,6 +167,7 @@ func (f *FakeEtcdClient) setLocked(key, value string, ttl uint64) (*etcd.Respons
 				Value:         value,
 				CreatedIndex:  i,
 				ModifiedIndex: i,
+				TTL:           int64(ttl),
 			},
 		},
 	}