NotFoundError now exposes correctly

cmd/coherence/cache.go

@@ -111,7 +111,7 @@ func runCache(args []string) error {
 	}
 
 	var (
-		persistence = store.New(*cacheBuckets, *cacheSize)
+		persistence = store.New(*cacheBuckets, *cacheSize, log.With(logger, "component", "store"))
 		nodeSet     = nodes.NewNodeSet(peer)
 		supervisor  = farm.NewReal(nodeSet)
 	)

pkg/api/api.go

@@ -242,7 +242,7 @@ func (a *API) handleSelect(w http.ResponseWriter, r *http.Request) {
 
 	member, err := a.store.Select(qp.Key(), qp.Field())
 	if err != nil {
-		if store.NotFoundError(err) {
+		if selectors.NotFoundError(err) {
 			a.errors.NotFound(w, r)
 		} else {
 			a.errors.InternalServerError(w, r, err.Error())

pkg/client/client.go

@@ -9,6 +9,7 @@ import (
 
 	"github.com/SimonRichardson/resilience/breaker"
 	"github.com/pkg/errors"
+	"github.com/trussle/coherence/pkg/selectors"
 )
 
 const (
@@ -45,7 +46,7 @@ func (c *Client) Get(u string) (b []byte, err error) {
 		defer resp.Body.Close()
 
 		if resp.StatusCode == http.StatusNotFound {
-			return NewNotFoundError(errors.Errorf("invalid status code: %d", resp.StatusCode))
+			return selectors.NewNotFoundError(errors.Errorf("invalid status code: %d", resp.StatusCode))
 		}
 		if resp.StatusCode != http.StatusOK {
 			return errors.Errorf("invalid status code: %d", resp.StatusCode)
@@ -71,7 +72,7 @@ func (c *Client) Post(u string, p []byte) (b []byte, err error) {
 		defer resp.Body.Close()
 
 		if resp.StatusCode == http.StatusNotFound {
-			return NewNotFoundError(errors.Errorf("invalid status code: %d", resp.StatusCode))
+			return selectors.NewNotFoundError(errors.Errorf("invalid status code: %d", resp.StatusCode))
 		}
 		if resp.StatusCode != http.StatusOK {
 			return errors.Errorf("invalid status code: %d", resp.StatusCode)
@@ -88,25 +89,3 @@ func (c *Client) Post(u string, p []byte) (b []byte, err error) {
 func (c *Client) Host() string {
 	return c.host
 }
-
-type errNotFound struct {
-	err error
-}
-
-// NewNotFoundError creates a new NotFoundError
-func NewNotFoundError(err error) error {
-	return errNotFound{err}
-}
-
-func (e errNotFound) Error() string {
-	return e.err.Error()
-}
-
-// NotFoundError finds if the error passed in, is actually a partial error or not
-func NotFoundError(err error) bool {
-	if err == nil {
-		return false
-	}
-	_, ok := err.(errNotFound)
-	return ok
-}

pkg/farm/nop.go

@@ -2,7 +2,6 @@ package farm
 
 import (
 	"github.com/pkg/errors"
-	"github.com/trussle/coherence/pkg/client"
 	"github.com/trussle/coherence/pkg/selectors"
 	"github.com/trussle/coherence/pkg/store"
 )
@@ -27,7 +26,7 @@ func (nop) Delete(key selectors.Key, members []selectors.FieldValueScore) (selec
 	}, nil
 }
 func (nop) Select(selectors.Key, selectors.Field) (selectors.FieldValueScore, error) {
-	return selectors.FieldValueScore{}, client.NewNotFoundError(errors.New("not found"))
+	return selectors.FieldValueScore{}, selectors.NewNotFoundError(errors.New("not found"))
 }
 func (nop) Keys() ([]selectors.Key, error)                   { return nil, nil }
 func (nop) Size(selectors.Key) (int64, error)                { return -1, nil }

pkg/farm/real.go

@@ -7,7 +7,6 @@ import (
 
 	"github.com/SimonRichardson/resilience/breaker"
 	"github.com/pkg/errors"
-	"github.com/trussle/coherence/pkg/client"
 	"github.com/trussle/coherence/pkg/nodes"
 	"github.com/trussle/coherence/pkg/selectors"
 	"github.com/trussle/coherence/pkg/store"
@@ -400,10 +399,10 @@ func tactic(n []nodes.Node, fn func(k int, n nodes.Node)) error {
 func mapErrors(errs []error) error {
 	notFound := true
 	for _, v := range errs {
-		notFound = notFound && client.NotFoundError(v)
+		notFound = notFound && selectors.NotFoundError(v)
 	}
 	if notFound {
-		return client.NewNotFoundError(errors.New("not found"))
+		return selectors.NewNotFoundError(errors.New("not found"))
 	}
 	return errors.Wrapf(joinErrors(errs), "partial error")
 }

pkg/selectors/errors.go

@@ -0,0 +1,23 @@
+package selectors
+
+type errNotFound struct {
+	err error
+}
+
+// NewNotFoundError creates a new NotFoundError
+func NewNotFoundError(err error) error {
+	return errNotFound{err}
+}
+
+func (e errNotFound) Error() string {
+	return e.err.Error()
+}
+
+// NotFoundError finds if the error passed in, is actually a partial error or not
+func NotFoundError(err error) bool {
+	if err == nil {
+		return false
+	}
+	_, ok := err.(errNotFound)
+	return ok
+}

pkg/store/bucket.go

@@ -78,7 +78,7 @@ func (b *Bucket) Select(field selectors.Field) (selectors.FieldValueScore, error
 			Score: v.Score,
 		}, nil
 	}
-	return selectors.FieldValueScore{}, errNotFound{errors.New("not found")}
+	return selectors.FieldValueScore{}, selectors.NewNotFoundError(errors.New("not found"))
 }
 
 // Members defines a way to return all members

pkg/store/bucket_test.go

@@ -300,7 +300,7 @@ func TestBucketDeletion(t *testing.T) {
 			}
 
 			_, err = bucket.Select(field)
-			return NotFoundError(err)
+			return selectors.NotFoundError(err)
 		}
 		if err := quick.Check(fn, nil); err != nil {
 			t.Error(err)

pkg/store/memory.go

@@ -3,6 +3,9 @@ package store
 import (
 	"strings"
 
+	"github.com/go-kit/kit/log"
+	"github.com/go-kit/kit/log/level"
+
 	"github.com/pkg/errors"
 	"github.com/trussle/coherence/pkg/selectors"
 )
@@ -14,11 +17,12 @@ type memory struct {
 	size    uint
 	buckets []*Bucket
 	keys    map[selectors.Key]struct{}
+	logger  log.Logger
 }
 
 // New creates a new in-memory Store according to the size required by
 // the value requested.
-func New(amountBuckets, amountPerBucket uint) Store {
+func New(amountBuckets, amountPerBucket uint, logger log.Logger) Store {
 	buckets := make([]*Bucket, amountBuckets)
 	for k := range buckets {
 		buckets[k] = NewBucket(int(amountPerBucket))
@@ -28,6 +32,7 @@ func New(amountBuckets, amountPerBucket uint) Store {
 		size:    amountBuckets,
 		buckets: buckets,
 		keys:    make(map[selectors.Key]struct{}),
+		logger:  logger,
 	}
 }
 
@@ -84,6 +89,7 @@ func (m *memory) Delete(key selectors.Key, members []selectors.FieldValueScore)
 
 func (m *memory) Select(key selectors.Key, field selectors.Field) (selectors.FieldValueScore, error) {
 	index := uint(key.Hash()) % m.size
+	level.Info(m.logger).Log("key", key, "index", index, "field", field)
 	return m.buckets[index].Select(field)
 }
 

pkg/store/memory_test.go

@@ -6,6 +6,7 @@ import (
 	"testing"
 	"testing/quick"
 
+	"github.com/go-kit/kit/log"
 	"github.com/trussle/coherence/pkg/selectors"
 )
 
@@ -14,7 +15,7 @@ func TestMemoryInsertion(t *testing.T) {
 
 	t.Run("inserting key and value", func(t *testing.T) {
 		fn := func(key selectors.Key, members []selectors.FieldValueScore) bool {
-			store := New(1, uint(len(members)*2))
+			store := New(1, uint(len(members)*2), log.NewNopLogger())
 			changeSet, err := store.Insert(key, members)
 			if err != nil {
 				t.Fatal(err)
@@ -46,7 +47,7 @@ func TestMemoryInsertion(t *testing.T) {
 					Score: member.Score - 1,
 				},
 			}
-			store := New(1, 1)
+			store := New(1, 1, log.NewNopLogger())
 			if _, err := store.Insert(key, members0); err != nil {
 				t.Fatal(err)
 			}
@@ -72,7 +73,7 @@ func TestMemoryInsertion(t *testing.T) {
 				member,
 			}
 
-			store := New(1, uint(len(members)*2))
+			store := New(1, uint(len(members)*2), log.NewNopLogger())
 			_, err := store.Insert(key, members)
 			if err != nil {
 				t.Fatal(err)
@@ -96,7 +97,7 @@ func TestMemoryInsertion(t *testing.T) {
 				return true
 			}
 
-			store := New(1, uint(len(members)*2))
+			store := New(1, uint(len(members)*2), log.NewNopLogger())
 			_, err := store.Insert(key, members)
 			if err != nil {
 				t.Fatal(err)
@@ -118,7 +119,7 @@ func TestMemoryInsertion(t *testing.T) {
 
 	t.Run("inserting members", func(t *testing.T) {
 		fn := func(key selectors.Key, members []selectors.FieldValueScore) bool {
-			store := New(1, uint(len(members)*2))
+			store := New(1, uint(len(members)*2), log.NewNopLogger())
 			_, err := store.Insert(key, members)
 			if err != nil {
 				t.Fatal(err)
@@ -152,7 +153,7 @@ func TestMemoryInsertion(t *testing.T) {
 				member,
 			}
 
-			store := New(1, uint(len(members)*2))
+			store := New(1, uint(len(members)*2), log.NewNopLogger())
 			_, err := store.Insert(key, members)
 			if err != nil {
 				t.Fatal(err)
@@ -180,7 +181,7 @@ func TestMemoryDeletion(t *testing.T) {
 
 	t.Run("deleting key and value", func(t *testing.T) {
 		fn := func(key selectors.Key, members []selectors.FieldValueScore) bool {
-			store := New(1, uint(len(members)*2))
+			store := New(1, uint(len(members)*2), log.NewNopLogger())
 			changeSet, err := store.Delete(key, members)
 			if err != nil {
 				t.Fatal(err)
@@ -209,7 +210,7 @@ func TestMemoryDeletion(t *testing.T) {
 				},
 			}
 
-			store := New(1, 1)
+			store := New(1, 1, log.NewNopLogger())
 			if _, err := store.Delete(key, members0); err != nil {
 				t.Fatal(err)
 			}
@@ -237,14 +238,14 @@ func TestMemoryDeletion(t *testing.T) {
 				member,
 			}
 
-			store := New(1, uint(len(members)*2))
+			store := New(1, uint(len(members)*2), log.NewNopLogger())
 			_, err := store.Delete(key, members)
 			if err != nil {
 				t.Fatal(err)
 			}
 
 			_, err = store.Select(key, member.Field)
-			return NotFoundError(err)
+			return selectors.NotFoundError(err)
 		}
 		if err := quick.Check(fn, nil); err != nil {
 			t.Error(err)
@@ -253,7 +254,7 @@ func TestMemoryDeletion(t *testing.T) {
 
 	t.Run("deleting keys", func(t *testing.T) {
 		fn := func(key selectors.Key, members []selectors.FieldValueScore) bool {
-			store := New(1, uint(len(members)*2))
+			store := New(1, uint(len(members)*2), log.NewNopLogger())
 
 			_, err := store.Insert(key, members)
 			if err != nil {
@@ -277,7 +278,7 @@ func TestMemoryDeletion(t *testing.T) {
 
 	t.Run("deleting members", func(t *testing.T) {
 		fn := func(key selectors.Key, members []selectors.FieldValueScore) bool {
-			store := New(1, uint(len(members)*2))
+			store := New(1, uint(len(members)*2), log.NewNopLogger())
 			_, err := store.Delete(key, members)
 			if err != nil {
 				t.Fatal(err)
@@ -301,7 +302,7 @@ func TestMemoryDeletion(t *testing.T) {
 				member,
 			}
 
-			store := New(1, 1)
+			store := New(1, 1, log.NewNopLogger())
 			_, err := store.Delete(key, members)
 			if err != nil {
 				t.Fatal(err)

pkg/store/store.go

@@ -32,20 +32,3 @@ type Store interface {
 	// Repair attempts to repair the store depending on the elements
 	Repair([]selectors.KeyFieldValue) error
 }
-
-type errNotFound struct {
-	err error
-}
-
-func (e errNotFound) Error() string {
-	return e.err.Error()
-}
-
-// NotFoundError finds if the error passed in, is actually a partial error or not
-func NotFoundError(err error) bool {
-	if err == nil {
-		return false
-	}
-	_, ok := err.(errNotFound)
-	return ok
-}