Add support for Namespace as Kind

Add example for using namespaces

pkg/registry/namespace/doc.go

@@ -0,0 +1,19 @@
+/*
+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 namespace provides Registry interface and it's REST
+// implementation for storing Namespace api objects.
+package namespace

pkg/registry/namespace/registry.go

@@ -0,0 +1,48 @@
+/*
+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 namespace
+
+import (
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/api"
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/registry/generic"
+	etcdgeneric "github.com/GoogleCloudPlatform/kubernetes/pkg/registry/generic/etcd"
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/runtime"
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/tools"
+)
+
+// registry implements custom changes to generic.Etcd for Namespace storage
+type registry struct {
+	*etcdgeneric.Etcd
+}
+
+// NewEtcdRegistry returns a registry which will store Namespace objects in the given EtcdHelper.
+func NewEtcdRegistry(h tools.EtcdHelper) generic.Registry {
+	return registry{
+		Etcd: &etcdgeneric.Etcd{
+			NewFunc:      func() runtime.Object { return &api.Namespace{} },
+			NewListFunc:  func() runtime.Object { return &api.NamespaceList{} },
+			EndpointName: "namespaces",
+			KeyRootFunc: func(ctx api.Context) string {
+				return "/registry/namespaces"
+			},
+			KeyFunc: func(ctx api.Context, id string) (string, error) {
+				return "/registry/namespaces/" + id, nil
+			},
+			Helper: h,
+		},
+	}
+}

pkg/registry/namespace/registry_test.go

@@ -0,0 +1,17 @@
+/*
+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 namespace

pkg/registry/namespace/rest.go

@@ -0,0 +1,134 @@
+/*
+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 namespace
+
+import (
+	"fmt"
+
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/api"
+	kerrors "github.com/GoogleCloudPlatform/kubernetes/pkg/api/errors"
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/api/rest"
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/api/validation"
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/apiserver"
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/labels"
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/registry/generic"
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/runtime"
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/watch"
+)
+
+// REST provides the RESTStorage access patterns to work with Namespace objects.
+type REST struct {
+	registry generic.Registry
+}
+
+// NewREST returns a new REST. You must use a registry created by
+// NewEtcdRegistry unless you're testing.
+func NewREST(registry generic.Registry) *REST {
+	return &REST{
+		registry: registry,
+	}
+}
+
+// Create creates a Namespace object
+func (rs *REST) Create(ctx api.Context, obj runtime.Object) (<-chan apiserver.RESTResult, error) {
+	namespace := obj.(*api.Namespace)
+	if err := rest.BeforeCreate(rest.Namespaces, ctx, obj); err != nil {
+		return nil, err
+	}
+	return apiserver.MakeAsync(func() (runtime.Object, error) {
+		if err := rs.registry.Create(ctx, namespace.Name, namespace); err != nil {
+			err = rest.CheckGeneratedNameError(rest.Namespaces, err, namespace)
+			return nil, err
+		}
+		return rs.registry.Get(ctx, namespace.Name)
+	}), nil
+}
+
+// Update updates a Namespace object.
+func (rs *REST) Update(ctx api.Context, obj runtime.Object) (<-chan apiserver.RESTResult, error) {
+	namespace, ok := obj.(*api.Namespace)
+	if !ok {
+		return nil, fmt.Errorf("not a namespace: %#v", obj)
+	}
+
+	oldObj, err := rs.registry.Get(ctx, namespace.Name)
+	if err != nil {
+		return nil, err
+	}
+
+	oldNamespace := oldObj.(*api.Namespace)
+	if errs := validation.ValidateNamespaceUpdate(oldNamespace, namespace); len(errs) > 0 {
+		return nil, kerrors.NewInvalid("namespace", namespace.Name, errs)
+	}
+
+	return apiserver.MakeAsync(func() (runtime.Object, error) {
+		err := rs.registry.Update(ctx, oldNamespace.Name, oldNamespace)
+		if err != nil {
+			return nil, err
+		}
+		return rs.registry.Get(ctx, oldNamespace.Name)
+	}), nil
+}
+
+// Delete deletes the Namespace with the specified name
+func (rs *REST) Delete(ctx api.Context, id string) (<-chan apiserver.RESTResult, error) {
+	obj, err := rs.registry.Get(ctx, id)
+	if err != nil {
+		return nil, err
+	}
+	_, ok := obj.(*api.Namespace)
+	if !ok {
+		return nil, fmt.Errorf("invalid object type")
+	}
+
+	return apiserver.MakeAsync(func() (runtime.Object, error) {
+		return &api.Status{Status: api.StatusSuccess}, rs.registry.Delete(ctx, id)
+	}), nil
+}
+
+func (rs *REST) Get(ctx api.Context, id string) (runtime.Object, error) {
+	obj, err := rs.registry.Get(ctx, id)
+	if err != nil {
+		return nil, err
+	}
+	namespace, ok := obj.(*api.Namespace)
+	if !ok {
+		return nil, fmt.Errorf("invalid object type")
+	}
+	return namespace, err
+}
+
+func (rs *REST) getAttrs(obj runtime.Object) (objLabels, objFields labels.Set, err error) {
+	return labels.Set{}, labels.Set{}, nil
+}
+
+func (rs *REST) List(ctx api.Context, label, field labels.Selector) (runtime.Object, error) {
+	return rs.registry.List(ctx, &generic.SelectionPredicate{label, field, rs.getAttrs})
+}
+
+func (rs *REST) Watch(ctx api.Context, label, field labels.Selector, resourceVersion string) (watch.Interface, error) {
+	return rs.registry.Watch(ctx, &generic.SelectionPredicate{label, field, rs.getAttrs}, resourceVersion)
+}
+
+// New returns a new api.Namespace
+func (*REST) New() runtime.Object {
+	return &api.Namespace{}
+}
+
+func (*REST) NewList() runtime.Object {
+	return &api.NamespaceList{}
+}

pkg/registry/namespace/rest_test.go

@@ -0,0 +1,188 @@
+/*
+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 namespace
+
+import (
+	"reflect"
+	"testing"
+
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/api"
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/apiserver"
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/labels"
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/registry/registrytest"
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/util"
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/watch"
+)
+
+type testRegistry struct {
+	*registrytest.GenericRegistry
+}
+
+func NewTestREST() (testRegistry, *REST) {
+	reg := testRegistry{registrytest.NewGeneric(nil)}
+	return reg, NewREST(reg)
+}
+
+func testNamespace(name string) *api.Namespace {
+	return &api.Namespace{
+		ObjectMeta: api.ObjectMeta{
+			Name: name,
+		},
+	}
+}
+
+func TestRESTCreate(t *testing.T) {
+	table := []struct {
+		ctx       api.Context
+		namespace *api.Namespace
+		valid     bool
+	}{
+		{
+			ctx:       api.NewContext(),
+			namespace: testNamespace("foo"),
+			valid:     true,
+		}, {
+			ctx:       api.NewContext(),
+			namespace: testNamespace("bar"),
+			valid:     true,
+		},
+	}
+
+	for _, item := range table {
+		_, rest := NewTestREST()
+		c, err := rest.Create(item.ctx, item.namespace)
+		if !item.valid {
+			if err == nil {
+				t.Errorf("unexpected non-error for %v", item.namespace.Name)
+			}
+			continue
+		}
+		if err != nil {
+			t.Errorf("%v: Unexpected error %v", item.namespace.Name, err)
+			continue
+		}
+		if !api.HasObjectMetaSystemFieldValues(&item.namespace.ObjectMeta) {
+			t.Errorf("storage did not populate object meta field values")
+		}
+		if e, a := item.namespace, (<-c).Object; !reflect.DeepEqual(e, a) {
+			t.Errorf("diff: %s", util.ObjectDiff(e, a))
+		}
+		// Ensure we implement the interface
+		_ = apiserver.ResourceWatcher(rest)
+	}
+}
+
+func TestRESTUpdate(t *testing.T) {
+	_, rest := NewTestREST()
+	namespaceA := testNamespace("foo")
+	c, err := rest.Create(api.NewDefaultContext(), namespaceA)
+	if err != nil {
+		t.Fatalf("Unexpected error %v", err)
+	}
+	<-c
+	got, err := rest.Get(api.NewDefaultContext(), namespaceA.Name)
+	if err != nil {
+		t.Fatalf("Unexpected error %v", err)
+	}
+	if e, a := namespaceA, got; !reflect.DeepEqual(e, a) {
+		t.Errorf("diff: %s", util.ObjectDiff(e, a))
+	}
+	namespaceB := testNamespace("foo")
+	u, err := rest.Update(api.NewDefaultContext(), namespaceB)
+	if err != nil {
+		t.Fatalf("Unexpected error %v", err)
+	}
+	<-u
+	got2, err := rest.Get(api.NewDefaultContext(), namespaceB.Name)
+	if err != nil {
+		t.Fatalf("Unexpected error %v", err)
+	}
+	if e, a := namespaceB, got2; !reflect.DeepEqual(e, a) {
+		t.Errorf("diff: %s", util.ObjectDiff(e, a))
+	}
+
+}
+
+func TestRESTDelete(t *testing.T) {
+	_, rest := NewTestREST()
+	namespaceA := testNamespace("foo")
+	c, err := rest.Create(api.NewContext(), namespaceA)
+	if err != nil {
+		t.Fatalf("Unexpected error %v", err)
+	}
+	<-c
+	c, err = rest.Delete(api.NewContext(), namespaceA.Name)
+	if err != nil {
+		t.Fatalf("Unexpected error %v", err)
+	}
+	if stat := (<-c).Object.(*api.Status); stat.Status != api.StatusSuccess {
+		t.Errorf("unexpected status: %v", stat)
+	}
+}
+
+func TestRESTGet(t *testing.T) {
+	_, rest := NewTestREST()
+	namespaceA := testNamespace("foo")
+	c, err := rest.Create(api.NewContext(), namespaceA)
+	if err != nil {
+		t.Fatalf("Unexpected error %v", err)
+	}
+	<-c
+	got, err := rest.Get(api.NewContext(), namespaceA.Name)
+	if err != nil {
+		t.Fatalf("Unexpected error %v", err)
+	}
+	if e, a := namespaceA, got; !reflect.DeepEqual(e, a) {
+		t.Errorf("diff: %s", util.ObjectDiff(e, a))
+	}
+}
+
+func TestRESTList(t *testing.T) {
+	reg, rest := NewTestREST()
+	namespaceA := testNamespace("foo")
+	namespaceB := testNamespace("bar")
+	namespaceC := testNamespace("baz")
+	reg.ObjectList = &api.NamespaceList{
+		Items: []api.Namespace{*namespaceA, *namespaceB, *namespaceC},
+	}
+	got, err := rest.List(api.NewContext(), labels.Everything(), labels.Everything())
+	if err != nil {
+		t.Fatalf("Unexpected error %v", err)
+	}
+	expect := &api.NamespaceList{
+		Items: []api.Namespace{*namespaceA, *namespaceB, *namespaceC},
+	}
+	if e, a := expect, got; !reflect.DeepEqual(e, a) {
+		t.Errorf("diff: %s", util.ObjectDiff(e, a))
+	}
+}
+
+func TestRESTWatch(t *testing.T) {
+	namespaceA := testNamespace("foo")
+	reg, rest := NewTestREST()
+	wi, err := rest.Watch(api.NewContext(), labels.Everything(), labels.Everything(), "0")
+	if err != nil {
+		t.Fatalf("Unexpected error %v", err)
+	}
+	go func() {
+		reg.Broadcaster.Action(watch.Added, namespaceA)
+	}()
+	got := <-wi.ResultChan()
+	if e, a := namespaceA, got.Object; !reflect.DeepEqual(e, a) {
+		t.Errorf("diff: %s", util.ObjectDiff(e, a))
+	}
+}