From 943eadec3814ae5d5c82642723b86cdf37fc4fac Mon Sep 17 00:00:00 2001 From: fibonacci1729 Date: Sun, 31 Jul 2016 23:20:57 -0600 Subject: [PATCH 1/6] move old memory impl. to driver/ --- pkg/storage/memory.go | 118 --------------------------------- pkg/storage/memory_test.go | 130 ------------------------------------- 2 files changed, 248 deletions(-) delete mode 100644 pkg/storage/memory.go delete mode 100644 pkg/storage/memory_test.go diff --git a/pkg/storage/memory.go b/pkg/storage/memory.go deleted file mode 100644 index 1ab8b3a69..000000000 --- a/pkg/storage/memory.go +++ /dev/null @@ -1,118 +0,0 @@ -/* -Copyright 2016 The Kubernetes Authors 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 storage - -import ( - "errors" - "sync" - - "k8s.io/helm/pkg/proto/hapi/release" -) - -// Memory is an in-memory ReleaseStorage implementation. -type Memory struct { - sync.RWMutex - releases map[string]*release.Release -} - -// NewMemory creates a new in-memory storage. -func NewMemory() *Memory { - return &Memory{ - releases: map[string]*release.Release{}, - } -} - -// ErrNotFound indicates that a release is not found. -var ErrNotFound = errors.New("release not found") - -// Read returns the named Release. -// -// If the release is not found, an ErrNotFound error is returned. -func (m *Memory) Read(k string) (*release.Release, error) { - m.RLock() - defer m.RUnlock() - v, ok := m.releases[k] - if !ok { - return v, ErrNotFound - } - return v, nil -} - -// Create sets a release. -func (m *Memory) Create(rel *release.Release) error { - m.Lock() - defer m.Unlock() - m.releases[rel.Name] = rel - return nil -} - -// Update sets a release. -func (m *Memory) Update(rel *release.Release) error { - m.Lock() - defer m.Unlock() - if _, ok := m.releases[rel.Name]; !ok { - return ErrNotFound - } - - // FIXME: When Release is done, we need to do this right by marking the old - // release as superseded, and creating a new release. - m.releases[rel.Name] = rel - return nil -} - -// Delete removes a release. -func (m *Memory) Delete(name string) (*release.Release, error) { - m.Lock() - defer m.Unlock() - rel, ok := m.releases[name] - if !ok { - return nil, ErrNotFound - } - delete(m.releases, name) - return rel, nil -} - -// List returns all releases whose status is not Status_DELETED. -func (m *Memory) List() ([]*release.Release, error) { - m.RLock() - defer m.RUnlock() - buf := []*release.Release{} - for _, v := range m.releases { - if v.Info.Status.Code != release.Status_DELETED { - buf = append(buf, v) - } - } - return buf, nil -} - -// Query searches all releases for matches. -func (m *Memory) Query(labels map[string]string) ([]*release.Release, error) { - m.RLock() - defer m.RUnlock() - return []*release.Release{}, errors.New("not implemented") -} - -// History returns the history of this release, in the form of a series of releases. -func (m *Memory) History(name string) ([]*release.Release, error) { - // TODO: This _should_ return all of the releases with the given name, sorted - // by LastDeployed, regardless of status. - r, err := m.Read(name) - if err != nil { - return []*release.Release{}, err - } - return []*release.Release{r}, nil -} diff --git a/pkg/storage/memory_test.go b/pkg/storage/memory_test.go deleted file mode 100644 index b83cd1a72..000000000 --- a/pkg/storage/memory_test.go +++ /dev/null @@ -1,130 +0,0 @@ -/* -Copyright 2016 The Kubernetes Authors 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 storage - -import ( - "testing" - - "k8s.io/helm/pkg/proto/hapi/release" -) - -func TestCreate(t *testing.T) { - k := "test-1" - r := &release.Release{Name: k} - - ms := NewMemory() - if err := ms.Create(r); err != nil { - t.Fatalf("Failed create: %s", err) - } - - if ms.releases[k].Name != k { - t.Errorf("Unexpected release name: %s", ms.releases[k].Name) - } -} - -func TestRead(t *testing.T) { - k := "test-1" - r := &release.Release{Name: k} - - ms := NewMemory() - ms.Create(r) - - if out, err := ms.Read(k); err != nil { - t.Errorf("Could not get %s: %s", k, err) - } else if out.Name != k { - t.Errorf("Expected %s, got %s", k, out.Name) - } -} - -func TestHistory(t *testing.T) { - k := "test-1" - r := &release.Release{Name: k} - - ms := NewMemory() - ms.Create(r) - - if out, err := ms.History(k); err != nil { - t.Errorf("Could not get %s: %s", k, err) - } else if len(out) != 1 { - t.Fatalf("Expected 1 release, got %d", len(out)) - } else if out[0].Name != k { - t.Errorf("Expected %s, got %s", k, out[0].Name) - } -} - -func TestUpdate(t *testing.T) { - k := "test-1" - r := &release.Release{Name: k} - - ms := NewMemory() - if err := ms.Create(r); err != nil { - t.Fatalf("Failed create: %s", err) - } - if err := ms.Update(r); err != nil { - t.Fatalf("Failed update: %s", err) - } - - if ms.releases[k].Name != k { - t.Errorf("Unexpected release name: %s", ms.releases[k].Name) - } -} - -func TestList(t *testing.T) { - ms := NewMemory() - rels := []string{"a", "b", "c"} - - for _, k := range rels { - ms.Create(&release.Release{ - Name: k, - Info: &release.Info{ - Status: &release.Status{Code: release.Status_UNKNOWN}, - }, - }) - ms.Create(&release.Release{ - Name: "deleted-should-not-show-up", - Info: &release.Info{ - Status: &release.Status{Code: release.Status_DELETED}, - }, - }) - } - - l, err := ms.List() - if err != nil { - t.Error(err) - } - - if len(l) != 3 { - t.Errorf("Expected 3, got %d", len(l)) - } - - for _, n := range rels { - foundN := false - for _, rr := range l { - if rr.Name == n { - foundN = true - break - } - } - if !foundN { - t.Errorf("Did not find %s in list.", n) - } - } -} - -func TestQuery(t *testing.T) { - t.Skip("Not Implemented") -} From 6dd5c9783e02db034aeaa4e2fab8a2d8c18943ee Mon Sep 17 00:00:00 2001 From: fibonacci1729 Date: Sun, 31 Jul 2016 23:21:57 -0600 Subject: [PATCH 2/6] add driver package to encapsulate storage backends --- pkg/storage/driver/driver.go | 53 +++++++++++++++ pkg/storage/driver/memory.go | 106 ++++++++++++++++++++++++++++++ pkg/storage/driver/memory_test.go | 92 ++++++++++++++++++++++++++ 3 files changed, 251 insertions(+) create mode 100644 pkg/storage/driver/driver.go create mode 100644 pkg/storage/driver/memory.go create mode 100644 pkg/storage/driver/memory_test.go diff --git a/pkg/storage/driver/driver.go b/pkg/storage/driver/driver.go new file mode 100644 index 000000000..b6e2de5e7 --- /dev/null +++ b/pkg/storage/driver/driver.go @@ -0,0 +1,53 @@ +/* +Copyright 2016 The Kubernetes Authors 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 driver // import "k8s.io/helm/pkg/storage/driver" + +import ( + "errors" + rspb "k8s.io/helm/pkg/proto/hapi/release" +) + +var ( + // ErrReleaseNotFound indicates that a release is not found. + ErrReleaseNotFound = errors.New("release not found") + // Temporary error while WIP. + ErrNotImplemented = errors.New("not implemented") +) + +type Creator interface { + Create(*rspb.Release) error +} + +type Updator interface { + Update(*rspb.Release) error +} + +type Deletor interface { + Delete(string) (*rspb.Release, error) +} + +type Queryor interface { + Get(string) (*rspb.Release, error) + + All(string, ...interface{}) ([]*rspb.Release, error) +} + +type Driver interface { + Creator + Updator + Deletor + Queryor +} \ No newline at end of file diff --git a/pkg/storage/driver/memory.go b/pkg/storage/driver/memory.go new file mode 100644 index 000000000..8c5394106 --- /dev/null +++ b/pkg/storage/driver/memory.go @@ -0,0 +1,106 @@ +/* +Copyright 2016 The Kubernetes Authors 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 driver // import "k8s.io/helm/pkg/storage/driver" + +import ( + "sync" + + rspb "k8s.io/helm/pkg/proto/hapi/release" +) + +// Memory is an in-memory storage driver implementation. +type Memory struct { + sync.RWMutex + cache map[string]*rspb.Release +} + +func NewMemory() *Memory { + return &Memory{cache: map[string]*rspb.Release{}} +} + +// Get returns the release named by key. +func (mem *Memory) Get(key string) (*rspb.Release, error) { + defer unlock(mem.rlock()) + + if rls, ok := mem.cache[key]; ok { + return rls, nil + } + return nil, ErrReleaseNotFound +} + +// All returns all releases whose status is not Status_DELETED. +func (mem *Memory) All(key string, opts ...interface{}) ([]*rspb.Release, error) { + defer unlock(mem.rlock()) + + var releases []*rspb.Release + for _, rls := range mem.cache { + if rls.Info.Status.Code != rspb.Status_DELETED { + releases = append(releases, rls) + } + } + return releases, nil +} + +// Create creates a new release or error. +func (mem *Memory) Create(rls *rspb.Release) error { + defer unlock(mem.wlock()) + + mem.cache[rls.Name] = rls + return nil +} + +// Update updates a release or error. +func (mem *Memory) Update(rls *rspb.Release) error { + defer unlock(mem.wlock()) + + if old, ok := mem.cache[rls.Name]; ok { + // FIXME: when release update is complete, old release should + // be marked as superseded, creating the new release. + _ = old + + mem.cache[rls.Name] = rls + return nil + } + return ErrReleaseNotFound +} + +// Delete deletes a release or error. +func (mem *Memory) Delete(key string) (*rspb.Release, error) { + defer unlock(mem.wlock()) + + if old, ok := mem.cache[key]; ok { + old.Info.Status.Code = rspb.Status_DELETED + delete(mem.cache, key) + return old, nil + } + return nil, ErrReleaseNotFound +} + +func (mem *Memory) wlock() func() { + mem.Lock() + return func() { + mem.Unlock() + } +} + +func (mem *Memory) rlock() func() { + mem.RLock() + return func() { + mem.RUnlock() + } +} + +func unlock(fn func()) { fn() } \ No newline at end of file diff --git a/pkg/storage/driver/memory_test.go b/pkg/storage/driver/memory_test.go new file mode 100644 index 000000000..001718e10 --- /dev/null +++ b/pkg/storage/driver/memory_test.go @@ -0,0 +1,92 @@ +/* +Copyright 2016 The Kubernetes Authors 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 driver // import "k8s.io/helm/pkg/storage/driver" + +import ( + "testing" + rspb "k8s.io/helm/pkg/proto/hapi/release" +) + +func TestMemoryGet(t *testing.T) { + key := "test-1" + rls := &rspb.Release{Name: key} + + mem := NewMemory() + mem.Create(rls) + + res, err := mem.Get(key) + switch { + case err != nil: + t.Errorf("Could not get %s: %s", key, err) + case res.Name != key: + t.Errorf("Expected %s, got %s", key, res.Name) + } +} + +func TestMemoryAll(t *testing.T) { + t.Skip("MemoryAll") +} + +func TestMemoryCreate(t *testing.T) { + key := "test-1" + rls := &rspb.Release{Name: key} + + mem := NewMemory() + err := mem.Create(rls) + + switch { + case err != nil: + t.Fatalf("Failed create: %s", err) + case mem.cache[key].Name != key: + t.Errorf("Unexpected release name: %s", mem.cache[key].Name) + } +} + +func TestMemoryUpdate(t *testing.T) { + key := "test-1" + rls := &rspb.Release{Name: key} + + mem := NewMemory() + if err := mem.Create(rls); err != nil { + t.Fatalf("Failed create: %s", err) + } + if err := mem.Update(rls); err != nil { + t.Fatalf("Failed update: %s", err) + } + if mem.cache[key].Name != key { + t.Errorf("Unexpected release name: %s", mem.cache[key].Name) + } +} + +func TestMemoryDelete(t *testing.T) { + key := "test-1" + rls := &rspb.Release{Name: key} + + mem := NewMemory() + if err := mem.Create(rls); err != nil { + t.Fatalf("Failed create: %s", err) + } + + res, err := mem.Delete(key) + switch { + case err != nil: + t.Fatalf("Failed delete: %s", err) + case mem.cache[key] != nil: + t.Errorf("Expected nil, got %s", mem.cache[key]) + case res.Info.Status.Code != release.Status_DELETED: + t.Errorf("Expected Status_DELETED, got %s", res.Info.Status.Code) + } +} \ No newline at end of file From 4210d60c5e9111c49e73772df22b10fb12ac846d Mon Sep 17 00:00:00 2001 From: fibonacci1729 Date: Sun, 31 Jul 2016 23:22:50 -0600 Subject: [PATCH 3/6] add storage type to interface with multiple drivers --- pkg/storage/storage.go | 48 ++++++++++++ pkg/storage/storage_test.go | 141 ++++++++++++++++++++++++++++++++++++ 2 files changed, 189 insertions(+) create mode 100644 pkg/storage/storage.go create mode 100644 pkg/storage/storage_test.go diff --git a/pkg/storage/storage.go b/pkg/storage/storage.go new file mode 100644 index 000000000..d5e2cf91b --- /dev/null +++ b/pkg/storage/storage.go @@ -0,0 +1,48 @@ +/* +Copyright 2016 The Kubernetes Authors 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 storage // import "k8s.io/helm/pkg/storage" + +import ( + "k8s.io/helm/pkg/storage/driver" + rspb "k8s.io/helm/pkg/proto/hapi/release" +) + +type Storage struct { + drv driver.Driver +} + +func (st *Storage) StoreRelease(rls *rspb.Release) error { + return st.drv.Create(rls) +} + +func (st *Storage) UpdateRelease(rls *rspb.Release) error { + return st.drv.Update(rls) +} + +func (st *Storage) QueryRelease(key string) (*rspb.Release, error) { + return st.drv.Get(key) +} + +func (st *Storage) DeleteRelease(key string) (*rspb.Release, error) { + return st.drv.Delete(key) +} + +func Init(drv driver.Driver) *Storage { + if drv == nil { + drv = driver.NewMemory() + } + return &Storage{drv: drv} +} \ No newline at end of file diff --git a/pkg/storage/storage_test.go b/pkg/storage/storage_test.go new file mode 100644 index 000000000..691ffdd5e --- /dev/null +++ b/pkg/storage/storage_test.go @@ -0,0 +1,141 @@ +/* +Copyright 2016 The Kubernetes Authors 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 storage // import "k8s.io/helm/pkg/storage" + +import ( + "fmt" + "time" + "reflect" + "testing" + + "k8s.io/helm/pkg/storage/driver" + rspb "k8s.io/helm/pkg/proto/hapi/release" + + tspb "github.com/golang/protobuf/ptypes" +) + +var storage = Init(driver.NewMemory()) + +func releaseData() *rspb.Release { + var manifest = `apiVersion: v1 + kind: ConfigMap + metadata: + name: configmap-storage-test + data: + count: "100" + limit: "200" + state: "new" + token: "abc" + ` + + tm, _ := tspb.TimestampProto(time.Now()) + return &rspb.Release{ + Name: "hungry-hippo", + Info: &rspb.Info{ + FirstDeployed: tm, + LastDeployed: tm, + Status: &rspb.Status{Code: rspb.Status_DEPLOYED}, + }, + Version: 2, + Manifest: manifest, + Namespace: "kube-system", + } +} + +func TestStoreRelease(t *testing.T) { + ckerr := func(err error, msg string) { + if err != nil { + t.Fatalf(fmt.Sprintf("Failed to %s: %q", msg, err)) + } + } + + rls := releaseData() + ckerr(storage.StoreRelease(rls), "StoreRelease") + + res, err := storage.QueryRelease(rls.Name) + ckerr(err, "QueryRelease") + + if !reflect.DeepEqual(rls, res) { + t.Fatalf("Expected %q, got %q", rls, res) + } +} + +func TestQueryRelease(t *testing.T) { + ckerr := func(err error, msg string) { + if err != nil { + t.Fatalf(fmt.Sprintf("Failed to %s: %q", msg, err)) + } + } + + rls := releaseData() + ckerr(storage.StoreRelease(rls), "StoreRelease") + + res, err := storage.QueryRelease(rls.Name) + ckerr(err, "QueryRelease") + + if !reflect.DeepEqual(rls, res) { + t.Fatalf("Expected %q, got %q", rls, res) + } +} + +func TestDeleteRelease(t *testing.T) { + ckerr := func(err error, msg string) { + if err != nil { + t.Fatalf(fmt.Sprintf("Failed to %s: %q", msg, err)) + } + } + + rls := releaseData() + ckerr(storage.StoreRelease(rls), "StoreRelease") + + res, err := storage.DeleteRelease(rls.Name) + ckerr(err, "DeleteRelease") + + if !reflect.DeepEqual(rls, res) { + t.Fatalf("Expected %q, got %q", rls, res) + } +} + +func TestUpdateRelease(t *testing.T) { + ckeql := func(got, want interface{}, msg string) { + if !reflect.DeepEqual(got, want) { + t.Fatalf(fmt.Sprintf("%s: got %T, want %T", msg, got, want)) + } + } + + ckerr := func(err error, msg string) { + if err != nil { + t.Fatalf(fmt.Sprintf("Failed to %s: %q", msg, err)) + } + } + + rls := releaseData() + ckerr(storage.StoreRelease(rls), "StoreRelease") + + rls.Name = "hungry-hippo" + rls.Version = 2 + rls.Manifest = "old-manifest" + + err := storage.UpdateRelease(rls) + ckerr(err, "UpdateRelease") + + res, err := storage.QueryRelease(rls.Name) + ckerr(err, "QueryRelease") + ckeql(res, rls, "Expected Release") + ckeql(res.Name, rls.Name, "Expected Name") + ckeql(res.Version, rls.Version, "Expected Version") + ckeql(res.Manifest, rls.Manifest, "Expected Manifest") +} \ No newline at end of file From aff817a1fc47f834f82301ede28dabbc1ea1cabb Mon Sep 17 00:00:00 2001 From: fibonacci1729 Date: Sun, 31 Jul 2016 23:34:50 -0600 Subject: [PATCH 4/6] run gofmt --- pkg/storage/driver/driver.go | 4 ++-- pkg/storage/driver/memory.go | 2 +- pkg/storage/driver/memory_test.go | 6 +++--- pkg/storage/storage.go | 4 ++-- pkg/storage/storage_test.go | 24 ++++++++++++------------ 5 files changed, 20 insertions(+), 20 deletions(-) diff --git a/pkg/storage/driver/driver.go b/pkg/storage/driver/driver.go index b6e2de5e7..c6670cb41 100644 --- a/pkg/storage/driver/driver.go +++ b/pkg/storage/driver/driver.go @@ -24,7 +24,7 @@ var ( // ErrReleaseNotFound indicates that a release is not found. ErrReleaseNotFound = errors.New("release not found") // Temporary error while WIP. - ErrNotImplemented = errors.New("not implemented") + ErrNotImplemented = errors.New("not implemented") ) type Creator interface { @@ -50,4 +50,4 @@ type Driver interface { Updator Deletor Queryor -} \ No newline at end of file +} diff --git a/pkg/storage/driver/memory.go b/pkg/storage/driver/memory.go index 8c5394106..e5301f0de 100644 --- a/pkg/storage/driver/memory.go +++ b/pkg/storage/driver/memory.go @@ -103,4 +103,4 @@ func (mem *Memory) rlock() func() { } } -func unlock(fn func()) { fn() } \ No newline at end of file +func unlock(fn func()) { fn() } diff --git a/pkg/storage/driver/memory_test.go b/pkg/storage/driver/memory_test.go index 001718e10..728cdb603 100644 --- a/pkg/storage/driver/memory_test.go +++ b/pkg/storage/driver/memory_test.go @@ -16,8 +16,8 @@ limitations under the License. package driver // import "k8s.io/helm/pkg/storage/driver" import ( - "testing" rspb "k8s.io/helm/pkg/proto/hapi/release" + "testing" ) func TestMemoryGet(t *testing.T) { @@ -79,7 +79,7 @@ func TestMemoryDelete(t *testing.T) { if err := mem.Create(rls); err != nil { t.Fatalf("Failed create: %s", err) } - + res, err := mem.Delete(key) switch { case err != nil: @@ -89,4 +89,4 @@ func TestMemoryDelete(t *testing.T) { case res.Info.Status.Code != release.Status_DELETED: t.Errorf("Expected Status_DELETED, got %s", res.Info.Status.Code) } -} \ No newline at end of file +} diff --git a/pkg/storage/storage.go b/pkg/storage/storage.go index d5e2cf91b..6345d33d6 100644 --- a/pkg/storage/storage.go +++ b/pkg/storage/storage.go @@ -16,8 +16,8 @@ limitations under the License. package storage // import "k8s.io/helm/pkg/storage" import ( - "k8s.io/helm/pkg/storage/driver" rspb "k8s.io/helm/pkg/proto/hapi/release" + "k8s.io/helm/pkg/storage/driver" ) type Storage struct { @@ -45,4 +45,4 @@ func Init(drv driver.Driver) *Storage { drv = driver.NewMemory() } return &Storage{drv: drv} -} \ No newline at end of file +} diff --git a/pkg/storage/storage_test.go b/pkg/storage/storage_test.go index 691ffdd5e..d84e1cd71 100644 --- a/pkg/storage/storage_test.go +++ b/pkg/storage/storage_test.go @@ -17,12 +17,12 @@ package storage // import "k8s.io/helm/pkg/storage" import ( "fmt" - "time" "reflect" "testing" + "time" - "k8s.io/helm/pkg/storage/driver" rspb "k8s.io/helm/pkg/proto/hapi/release" + "k8s.io/helm/pkg/storage/driver" tspb "github.com/golang/protobuf/ptypes" ) @@ -61,10 +61,10 @@ func TestStoreRelease(t *testing.T) { t.Fatalf(fmt.Sprintf("Failed to %s: %q", msg, err)) } } - + rls := releaseData() ckerr(storage.StoreRelease(rls), "StoreRelease") - + res, err := storage.QueryRelease(rls.Name) ckerr(err, "QueryRelease") @@ -79,10 +79,10 @@ func TestQueryRelease(t *testing.T) { t.Fatalf(fmt.Sprintf("Failed to %s: %q", msg, err)) } } - + rls := releaseData() ckerr(storage.StoreRelease(rls), "StoreRelease") - + res, err := storage.QueryRelease(rls.Name) ckerr(err, "QueryRelease") @@ -97,10 +97,10 @@ func TestDeleteRelease(t *testing.T) { t.Fatalf(fmt.Sprintf("Failed to %s: %q", msg, err)) } } - + rls := releaseData() ckerr(storage.StoreRelease(rls), "StoreRelease") - + res, err := storage.DeleteRelease(rls.Name) ckerr(err, "DeleteRelease") @@ -121,12 +121,12 @@ func TestUpdateRelease(t *testing.T) { t.Fatalf(fmt.Sprintf("Failed to %s: %q", msg, err)) } } - + rls := releaseData() ckerr(storage.StoreRelease(rls), "StoreRelease") - rls.Name = "hungry-hippo" - rls.Version = 2 + rls.Name = "hungry-hippo" + rls.Version = 2 rls.Manifest = "old-manifest" err := storage.UpdateRelease(rls) @@ -138,4 +138,4 @@ func TestUpdateRelease(t *testing.T) { ckeql(res.Name, rls.Name, "Expected Name") ckeql(res.Version, rls.Version, "Expected Version") ckeql(res.Manifest, rls.Manifest, "Expected Manifest") -} \ No newline at end of file +} From 061b5348852a4111de78e068c42919f7db3e5448 Mon Sep 17 00:00:00 2001 From: fibonacci1729 Date: Sun, 31 Jul 2016 23:49:27 -0600 Subject: [PATCH 5/6] fix panic in memory_test when release status is nil --- pkg/storage/driver/memory_test.go | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/pkg/storage/driver/memory_test.go b/pkg/storage/driver/memory_test.go index 728cdb603..0edd77ff1 100644 --- a/pkg/storage/driver/memory_test.go +++ b/pkg/storage/driver/memory_test.go @@ -73,7 +73,12 @@ func TestMemoryUpdate(t *testing.T) { func TestMemoryDelete(t *testing.T) { key := "test-1" - rls := &rspb.Release{Name: key} + rls := &rspb.Release{ + Name: key, + Info: &rspb.Info{ + Status: &rspb.Status{Code: rspb.Status_DEPLOYED}, + }, + } mem := NewMemory() if err := mem.Create(rls); err != nil { @@ -86,7 +91,7 @@ func TestMemoryDelete(t *testing.T) { t.Fatalf("Failed delete: %s", err) case mem.cache[key] != nil: t.Errorf("Expected nil, got %s", mem.cache[key]) - case res.Info.Status.Code != release.Status_DELETED: + case res.Info.Status.Code != rspb.Status_DELETED: t.Errorf("Expected Status_DELETED, got %s", res.Info.Status.Code) } } From 4dd732b3daf552009519ae03cee0e10cc10e5a3d Mon Sep 17 00:00:00 2001 From: fibonacci1729 Date: Sun, 31 Jul 2016 23:52:09 -0600 Subject: [PATCH 6/6] add configmaps stub impl. of storage driver --- pkg/storage/driver/cfgmaps.go | 53 ++++++++++++++++++++++++++++++ pkg/storage/driver/cfgmaps_test.go | 40 ++++++++++++++++++++++ 2 files changed, 93 insertions(+) create mode 100644 pkg/storage/driver/cfgmaps.go create mode 100644 pkg/storage/driver/cfgmaps_test.go diff --git a/pkg/storage/driver/cfgmaps.go b/pkg/storage/driver/cfgmaps.go new file mode 100644 index 000000000..a83954479 --- /dev/null +++ b/pkg/storage/driver/cfgmaps.go @@ -0,0 +1,53 @@ +/* +Copyright 2016 The Kubernetes Authors 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 driver // import "k8s.io/helm/pkg/storage/driver" + +import ( + rspb "k8s.io/helm/pkg/proto/hapi/release" +) + +type ConfigMaps struct { + *Memory // simple cache +} + +func NewConfigMaps() *ConfigMaps { + return &ConfigMaps{Memory: NewMemory()} +} + +// Get retrieves the releases named by key from the ConfigMap +func (cfg *ConfigMaps) Get(key string) (*rspb.Release, error) { + return nil, ErrNotImplemented +} + +// All returns all releases whose status is not Status_DELETED. +func (cfg *ConfigMaps) All(key string, opts ...interface{}) ([]*rspb.Release, error) { + return nil, ErrNotImplemented +} + +// Create creates a new release or error. +func (cfg *ConfigMaps) Create(rls *rspb.Release) error { + return ErrNotImplemented +} + +// Update updates a release or error. +func (cfg *ConfigMaps) Update(rls *rspb.Release) error { + return ErrNotImplemented +} + +// Delete deletes a release or error. +func (cfg *ConfigMaps) Delete(key string) (*rspb.Release, error) { + return nil, ErrNotImplemented +} diff --git a/pkg/storage/driver/cfgmaps_test.go b/pkg/storage/driver/cfgmaps_test.go new file mode 100644 index 000000000..dd8f39200 --- /dev/null +++ b/pkg/storage/driver/cfgmaps_test.go @@ -0,0 +1,40 @@ +/* +Copyright 2016 The Kubernetes Authors 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 driver // import "k8s.io/helm/pkg/storage/driver" + +import ( + "testing" +) + +func TestConfigMapsGet(t *testing.T) { + t.Skip("ConfigMapsGet") +} + +func TestConfigMapsAll(t *testing.T) { + t.Skip("ConfigMapsAll") +} + +func TestConfigMapsCreate(t *testing.T) { + t.Skip("ConfigMapsCreate") +} + +func TestConfigMapsUpdate(t *testing.T) { + t.Skip("ConfigMapsUpdate") +} + +func TestConfigMapsDelete(t *testing.T) { + t.Skip("ConfigMapsDelete") +}