Working example with Middlewares

middleware.go

@@ -1,22 +1,16 @@
 package goriak
 
-type SetMiddlewarer interface {
- GetValue() ([]byte, error)
- SetValue([]byte) error
-
- //GetMapOperation() (*riak.MapOperation, error)
- //SetMapOperation(*riak.MapOperation) error
-
+type ExecMiddlewarer interface {
  GetKey() string
- SetKey(string)
 }
 
-type SetMiddleware func(SetMiddlewarer, SetMiddleware)
+type ExecuteMiddleware func(cmd ExecMiddlewarer, next func() (*Result, error)) (*Result, error)
 
-var globalSetMiddleware []SetMiddleware
-
-type NextMiddlewareFunc func()
+func (c *SetRawCommand) AddMiddleware(mid ExecuteMiddleware) *SetRawCommand {
+ c.execMiddleware = append(c.execMiddleware, mid)
+ return c
+}
 
-func RegisterSetMiddleware(middleware SetMiddleware) {
- globalSetMiddleware = append(globalSetMiddleware, middleware)
+func (c *SetRawCommand) GetKey() string {
+ return c.key
 }

middleware_test.go

@@ -2,16 +2,28 @@ package goriak
 
 import (
  //riak "github.com/basho/riak-go-client"
+ "errors"
+ "log"
  "testing"
 )
 
 func TestMiddlewareSet(t *testing.T) {
 
- RegisterSetMiddleware(func(item SetMiddlewarer, next NextMiddlewareFunc) {
+ m := func(cmd ExecMiddlewarer, next func() (*Result, error)) (*Result, error) {
+ log.Println("Middleware BEFORE:", cmd.GetKey())
+ return nil, errors.New("abort!")
 
- })
+ res, err := next()
+ log.Println("Middleware After:", cmd.GetKey())
+ return res, err
+ }
 
- Bucket("middleware", "raw").
+ res, err := Bucket("middleware", "tests").
  SetRaw([]byte{1, 2, 3, 4, 5}).
+ ///Key("abc123").
+ AddMiddleware(m).
+ AddMiddleware(m).
  Run(con())
+
+ t.Log(res, err)
 }

query_store_value.go

@@ -3,6 +3,7 @@ package goriak
 import (
  "errors"
  riak "github.com/basho/riak-go-client"
+ "log"
 )
 
 type SetRawCommand struct {
@@ -14,6 +15,8 @@ type SetRawCommand struct {
  storeValueCommandBuilder *riak.StoreValueCommandBuilder
  storeValueObject *riak.Object
 
+ execMiddleware []ExecuteMiddleware
+
  key string
 
  err error
@@ -62,12 +65,37 @@ func (c *SetRawCommand) Run(session *Session) (*Result, error) {
  // Set object
  c.storeValueCommandBuilder.WithContent(c.storeValueObject)
 
+ // Keep track of whick middleware that we should execute next
+ middlewareI := 0
+
+ // Needed so that next can call itself
+ var next2 func() (*Result, error)
+
+ next := func() (*Result, error) {
+ if middlewareI == len(c.execMiddleware) {
+ return c.riakExecute(session)
+ }
+
+ middlewareI++
+
+ return c.execMiddleware[middlewareI-1](c, next2)
+ }
+
+ next2 = next
+
+ return next()
+}
+
+func (c *SetRawCommand) riakExecute(session *Session) (*Result, error) {
+
  // Build it!
  cmd, err := c.storeValueCommandBuilder.Build()
  if err != nil {
  return nil, err
  }
 
+ log.Println("Riak Execute")
+
  err = session.riak.Execute(cmd)
  if err != nil {
  return nil, err
@@ -79,15 +107,14 @@ func (c *SetRawCommand) Run(session *Session) (*Result, error) {
  return nil, errors.New("Not successful")
  }
 
- var key string
+ log.Println("Key:", c.key)
 
- if c.key != "" {
- key = c.key
- } else {
- key = storeCmd.Response.GeneratedKey
+ if c.key == "" {
+ log.Println("Added GeneratedKey")
+ c.key = storeCmd.Response.GeneratedKey
  }
 
  return &Result{
- Key: key,
+ Key: c.key,
  }, nil
 }

raw.go

@@ -8,10 +8,6 @@ import (
 // SetRaw gives you full control of the data stored, compared to SetJSON and Set.
 func (c *Command) SetRaw(value []byte) *SetRawCommand {
 
- if len(GlobalSetMiddleware) > 0 {
- globalSetMiddleware[0]()
- }
-
  object := &riak.Object{
  Value: value,
  }