fairway 0.2.7 → 0.3.1

data/go/queue_test.go

@@ -23,16 +23,128 @@ func QueueSpec(c gospec.Context) {
 			conn.Deliver(msg1)
 			conn.Deliver(msg2)
 
-			queueName, message := queue.Pull()
+			r := config.Pool.Get()
+			defer r.Close()
+
+			count, _ := redis.Int(r.Do("llen", "fairway:myqueue:default"))
+			c.Expect(count, Equals, 2)
+			count, _ = redis.Int(r.Do("scard", "fairway:myqueue:active_facets"))
+			c.Expect(count, Equals, 1)
+			count, _ = redis.Int(r.Do("llen", "fairway:myqueue:facet_queue"))
+			c.Expect(count, Equals, 1)
+			count, _ = redis.Int(r.Do("get", "fairway:myqueue:limit"))
+			c.Expect(count, Equals, 0)
+			count, _ = redis.Int(r.Do("get", "fairway:myqueue:inflight"))
+			c.Expect(count, Equals, 0)
+			count, _ = redis.Int(r.Do("hget", "fairway:myqueue:facet_pool", "default"))
+			c.Expect(count, Equals, 1)
+
+			queueName, message := queue.Pull(-1)
+
+			count, _ = redis.Int(r.Do("llen", "fairway:myqueue:default"))
+			c.Expect(count, Equals, 1)
+			count, _ = redis.Int(r.Do("scard", "fairway:myqueue:active_facets"))
+			c.Expect(count, Equals, 1)
+			count, _ = redis.Int(r.Do("llen", "fairway:myqueue:facet_queue"))
+			c.Expect(count, Equals, 1)
+			count, _ = redis.Int(r.Do("get", "fairway:myqueue:limit"))
+			c.Expect(count, Equals, 0)
+			count, _ = redis.Int(r.Do("get", "fairway:myqueue:inflight"))
+			c.Expect(count, Equals, 0)
+			count, _ = redis.Int(r.Do("hget", "fairway:myqueue:facet_pool", "default"))
+			c.Expect(count, Equals, 1)
+
 			c.Expect(queueName, Equals, "myqueue")
 			c.Expect(message.json(), Equals, msg1.json())
 
-			queueName, message = queue.Pull()
+			queueName, message = queue.Pull(-1)
 			c.Expect(queueName, Equals, "myqueue")
 			c.Expect(message.json(), Equals, msg2.json())
 		})
 
-		c.Specify("pulls from facets of the queue in round-robin", func() {
+		c.Specify("places pulled message on inflight sorted set until acknowledged", func() {
+			msg1, _ := NewMsg(map[string]string{"name": "mymessage1"})
+
+			conn.Deliver(msg1)
+
+			c.Expect(len(queue.Inflight()), Equals, 0)
+
+			queueName, message := queue.Pull(100)
+			c.Expect(queueName, Equals, "myqueue")
+			c.Expect(message.json(), Equals, msg1.json())
+
+			c.Expect(len(queue.Inflight()), Equals, 1)
+			c.Expect(queue.Inflight()[0], Equals, msg1.json())
+
+			queue.Ack(msg1)
+
+			c.Expect(len(queue.Inflight()), Equals, 0)
+		})
+
+		c.Specify("pulls from inflight message set if messages are unacknowledged", func() {
+			msg1, _ := NewMsg(map[string]string{"name": "mymessage1"})
+			msg2, _ := NewMsg(map[string]string{"name": "mymessage2"})
+
+			conn.Deliver(msg1)
+			conn.Deliver(msg2)
+
+			queueName, message := queue.Pull(0)
+			c.Expect(queueName, Equals, "myqueue")
+			c.Expect(message.json(), Equals, msg1.json())
+
+			queueName, message = queue.Pull(10)
+			c.Expect(queueName, Equals, "myqueue")
+			c.Expect(message.json(), Equals, msg1.json())
+
+			queueName, message = queue.Pull(10)
+			c.Expect(queueName, Equals, "myqueue")
+			c.Expect(message.json(), Equals, msg2.json())
+		})
+
+		c.Specify("allows puller to ping to keep message inflight", func() {
+			msg1, _ := NewMsg(map[string]string{"name": "mymessage1"})
+			msg2, _ := NewMsg(map[string]string{"name": "mymessage2"})
+
+			conn.Deliver(msg1)
+			conn.Deliver(msg2)
+
+			queueName, message := queue.Pull(0)
+			c.Expect(queueName, Equals, "myqueue")
+			c.Expect(message.json(), Equals, msg1.json())
+
+			// Extends time before message is resent
+			queue.Ping(msg1, 10)
+
+			queueName, message = queue.Pull(10)
+			c.Expect(queueName, Equals, "myqueue")
+			c.Expect(message.json(), Equals, msg2.json())
+
+			// Sets time for message to resend to now
+			queue.Ping(msg1, 0)
+
+			queueName, message = queue.Pull(10)
+			c.Expect(queueName, Equals, "myqueue")
+			c.Expect(message.json(), Equals, msg1.json())
+		})
+
+		c.Specify("set limits messages inflight", func() {
+			limit, err := queue.InflightLimit()
+
+			c.Expect(limit, Equals, 0)
+			c.Expect(err, IsNil)
+
+			queue.SetInflightLimit(1)
+
+			limit, err = queue.InflightLimit()
+
+			c.Expect(limit, Equals, 1)
+			c.Expect(err, IsNil)
+		})
+
+		c.Specify("limits messages inflight", func() {
+			r := config.Pool.Get()
+			defer r.Close()
+
 			config.Facet = func(msg *Msg) string {
 				str, _ := msg.Get("facet").String()
 				return str
@@ -46,12 +158,358 @@ func QueueSpec(c gospec.Context) {
 			conn.Deliver(msg2)
 			conn.Deliver(msg3)
 
-			_, message := queue.Pull()
+			queue.SetInflightLimit(1)
+
+			_, message := queue.Pull(2)
 			c.Expect(message.json(), Equals, msg1.json())
-			_, message = queue.Pull()
+
+			count, _ := redis.Int(r.Do("get", "fairway:myqueue:1:inflight"))
+			c.Expect(count, Equals, 1)
+
+			_, message = queue.Pull(2)
 			c.Expect(message.json(), Equals, msg3.json())
-			_, message = queue.Pull()
+
+			count, _ = redis.Int(r.Do("get", "fairway:myqueue:1:inflight"))
+			c.Expect(count, Equals, 1)
+
+			count, _ = redis.Int(r.Do("get", "fairway:myqueue:2:inflight"))
+			c.Expect(count, Equals, 1)
+
+			_, message = queue.Pull(2)
+			c.Expect(message, IsNil)
+			_, message = queue.Pull(2)
+			c.Expect(message, IsNil)
+
+			count, _ = redis.Int(r.Do("get", "fairway:myqueue:1:inflight"))
+			c.Expect(count, Equals, 1)
+
+			count, _ = redis.Int(r.Do("get", "fairway:myqueue:2:inflight"))
+			c.Expect(count, Equals, 1)
+
+			queue.Ack(msg1)
+			queue.Ack(msg1)
+			queue.Ack(msg1)
+			queue.Ack(msg1)
+			queue.Ack(msg1)
+
+			count, err := redis.Int(r.Do("get", "fairway:myqueue:1:inflight"))
+			c.Expect(count, Equals, 0)
+			c.Expect(err, IsNil)
+
+			count, _ = redis.Int(r.Do("get", "fairway:myqueue:2:inflight"))
+			c.Expect(count, Equals, 1)
+
+			_, message = queue.Pull(2)
 			c.Expect(message.json(), Equals, msg2.json())
+
+			count, _ = redis.Int(r.Do("get", "fairway:myqueue:1:inflight"))
+			c.Expect(count, Equals, 1)
+
+			count, _ = redis.Int(r.Do("get", "fairway:myqueue:2:inflight"))
+			c.Expect(count, Equals, 1)
+		})
+
+		c.Specify("prevents overlimit messages when all messages are inflight", func() {
+			r := config.Pool.Get()
+			defer r.Close()
+
+			config.Facet = func(msg *Msg) string {
+				str, _ := msg.Get("facet").String()
+				return str
+			}
+
+			msg1, _ := NewMsg(map[string]string{"facet": "1", "name": "mymessage1"})
+			msg2, _ := NewMsg(map[string]string{"facet": "1", "name": "mymessage2"})
+			msg3, _ := NewMsg(map[string]string{"facet": "1", "name": "mymessage3"})
+
+			queue.SetInflightLimit(1)
+
+			active, _ := redis.Strings(r.Do("smembers", "fairway:myqueue:active_facets"))
+			c.Expect(len(active), Equals, 0)
+			fqueue, _ := redis.Int(r.Do("llen", "fairway:myqueue:facet_queue"))
+			c.Expect(fqueue, Equals, 0)
+
+			conn.Deliver(msg1)
+
+			active, _ = redis.Strings(r.Do("smembers", "fairway:myqueue:active_facets"))
+			c.Expect(len(active), Equals, 1)
+			c.Expect(active[0], Equals, "1")
+			fqueue, _ = redis.Int(r.Do("llen", "fairway:myqueue:facet_queue"))
+			c.Expect(fqueue, Equals, 1)
+
+			_, message := queue.Pull(2)
+			c.Expect(message.json(), Equals, msg1.json())
+
+			active, _ = redis.Strings(r.Do("smembers", "fairway:myqueue:active_facets"))
+			c.Expect(len(active), Equals, 1)
+			c.Expect(active[0], Equals, "1")
+			fqueue, _ = redis.Int(r.Do("llen", "fairway:myqueue:facet_queue"))
+			c.Expect(fqueue, Equals, 0)
+
+			conn.Deliver(msg2)
+
+			_, message = queue.Pull(2)
+			c.Expect(message, IsNil)
+
+			active, _ = redis.Strings(r.Do("smembers", "fairway:myqueue:active_facets"))
+			c.Expect(len(active), Equals, 1)
+			c.Expect(active[0], Equals, "1")
+			fqueue, _ = redis.Int(r.Do("llen", "fairway:myqueue:facet_queue"))
+			c.Expect(fqueue, Equals, 0)
+
+			queue.Ack(msg1)
+
+			active, _ = redis.Strings(r.Do("smembers", "fairway:myqueue:active_facets"))
+			c.Expect(len(active), Equals, 1)
+			c.Expect(active[0], Equals, "1")
+			fqueue, _ = redis.Int(r.Do("llen", "fairway:myqueue:facet_queue"))
+			c.Expect(fqueue, Equals, 1)
+
+			_, message = queue.Pull(2)
+			c.Expect(message.json(), Equals, msg2.json())
+
+			active, _ = redis.Strings(r.Do("smembers", "fairway:myqueue:active_facets"))
+			c.Expect(len(active), Equals, 1)
+			c.Expect(active[0], Equals, "1")
+			fqueue, _ = redis.Int(r.Do("llen", "fairway:myqueue:facet_queue"))
+			c.Expect(fqueue, Equals, 0)
+
+			conn.Deliver(msg3)
+
+			active, _ = redis.Strings(r.Do("smembers", "fairway:myqueue:active_facets"))
+			c.Expect(len(active), Equals, 1)
+			c.Expect(active[0], Equals, "1")
+			fqueue, _ = redis.Int(r.Do("llen", "fairway:myqueue:facet_queue"))
+			c.Expect(fqueue, Equals, 0)
+
+			_, message = queue.Pull(2)
+			c.Expect(message, IsNil)
+
+			queue.Ack(msg2)
+
+			active, _ = redis.Strings(r.Do("smembers", "fairway:myqueue:active_facets"))
+			c.Expect(len(active), Equals, 1)
+			c.Expect(active[0], Equals, "1")
+			fqueue, _ = redis.Int(r.Do("llen", "fairway:myqueue:facet_queue"))
+			c.Expect(fqueue, Equals, 1)
+
+			_, message = queue.Pull(2)
+			c.Expect(message.json(), Equals, msg3.json())
+
+			active, _ = redis.Strings(r.Do("smembers", "fairway:myqueue:active_facets"))
+			c.Expect(len(active), Equals, 1)
+			c.Expect(active[0], Equals, "1")
+			fqueue, _ = redis.Int(r.Do("llen", "fairway:myqueue:facet_queue"))
+			c.Expect(fqueue, Equals, 0)
+
+			_, message = queue.Pull(2)
+			c.Expect(message, IsNil)
+
+			queue.Ack(msg3)
+
+			active, _ = redis.Strings(r.Do("smembers", "fairway:myqueue:active_facets"))
+			c.Expect(len(active), Equals, 0)
+			fqueue, _ = redis.Int(r.Do("llen", "fairway:myqueue:facet_queue"))
+			c.Expect(fqueue, Equals, 0)
+
+			msg4, _ := NewMsg(map[string]string{"facet": "1", "name": "mymessage4"})
+
+			conn.Deliver(msg4)
+
+			active, _ = redis.Strings(r.Do("smembers", "fairway:myqueue:active_facets"))
+			c.Expect(len(active), Equals, 1)
+			fqueue, _ = redis.Int(r.Do("llen", "fairway:myqueue:facet_queue"))
+			c.Expect(fqueue, Equals, 1)
+
+			_, message = queue.Pull(2)
+			c.Expect(message.json(), Equals, msg4.json())
+
+			active, _ = redis.Strings(r.Do("smembers", "fairway:myqueue:active_facets"))
+			c.Expect(len(active), Equals, 1)
+			fqueue, _ = redis.Int(r.Do("llen", "fairway:myqueue:facet_queue"))
+			c.Expect(fqueue, Equals, 0)
+
+			queue.Ack(msg4)
+
+			active, _ = redis.Strings(r.Do("smembers", "fairway:myqueue:active_facets"))
+			c.Expect(len(active), Equals, 0)
+			fqueue, _ = redis.Int(r.Do("llen", "fairway:myqueue:facet_queue"))
+			c.Expect(fqueue, Equals, 0)
+
+			_, message = queue.Pull(2)
+			c.Expect(message, IsNil)
+
+			active, _ = redis.Strings(r.Do("smembers", "fairway:myqueue:active_facets"))
+			c.Expect(len(active), Equals, 0)
+			fqueue, _ = redis.Int(r.Do("llen", "fairway:myqueue:facet_queue"))
+			c.Expect(fqueue, Equals, 0)
+		})
+
+		c.Specify("if inflight limit is 0, no limit", func() {
+			r := config.Pool.Get()
+			defer r.Close()
+
+			config.Facet = func(msg *Msg) string {
+				str, _ := msg.Get("facet").String()
+				return str
+			}
+
+			msg1, _ := NewMsg(map[string]string{"facet": "1", "name": "mymessage1"})
+			msg2, _ := NewMsg(map[string]string{"facet": "1", "name": "mymessage2"})
+			msg3, _ := NewMsg(map[string]string{"facet": "2", "name": "mymessage3"})
+
+			queue.SetInflightLimit(0)
+
+			conn.Deliver(msg1)
+			conn.Deliver(msg2)
+			conn.Deliver(msg3)
+
+			active, _ := redis.Strings(r.Do("smembers", "fairway:myqueue:active_facets"))
+			c.Expect(len(active), Equals, 2)
+			fqueue, _ := redis.Int(r.Do("llen", "fairway:myqueue:facet_queue"))
+			c.Expect(fqueue, Equals, 2)
+
+			_, message := queue.Pull(2)
+			c.Expect(message.json(), Equals, msg1.json())
+
+			_, message = queue.Pull(2)
+			c.Expect(message.json(), Equals, msg3.json())
+
+			active, _ = redis.Strings(r.Do("smembers", "fairway:myqueue:active_facets"))
+			c.Expect(len(active), Equals, 2)
+			fqueue, _ = redis.Int(r.Do("llen", "fairway:myqueue:facet_queue"))
+			c.Expect(fqueue, Equals, 1)
+
+			_, message = queue.Pull(2)
+			c.Expect(message.json(), Equals, msg2.json())
+
+			active, _ = redis.Strings(r.Do("smembers", "fairway:myqueue:active_facets"))
+			c.Expect(len(active), Equals, 2)
+			fqueue, _ = redis.Int(r.Do("llen", "fairway:myqueue:facet_queue"))
+			c.Expect(fqueue, Equals, 0)
+
+			msg4, _ := NewMsg(map[string]string{"facet": "2", "name": "mymessage4"})
+
+			conn.Deliver(msg4)
+
+			active, _ = redis.Strings(r.Do("smembers", "fairway:myqueue:active_facets"))
+			c.Expect(len(active), Equals, 2)
+			fqueue, _ = redis.Int(r.Do("llen", "fairway:myqueue:facet_queue"))
+			c.Expect(fqueue, Equals, 1)
+
+			queue.Ack(msg1)
+			queue.Ack(msg2)
+
+			active, _ = redis.Strings(r.Do("smembers", "fairway:myqueue:active_facets"))
+			c.Expect(len(active), Equals, 1)
+			fqueue, _ = redis.Int(r.Do("llen", "fairway:myqueue:facet_queue"))
+			c.Expect(fqueue, Equals, 1)
+
+			_, message = queue.Pull(2)
+			c.Expect(message.json(), Equals, msg4.json())
+
+			active, _ = redis.Strings(r.Do("smembers", "fairway:myqueue:active_facets"))
+			c.Expect(len(active), Equals, 1)
+			fqueue, _ = redis.Int(r.Do("llen", "fairway:myqueue:facet_queue"))
+			c.Expect(fqueue, Equals, 0)
+
+			_, message = queue.Pull(2)
+			c.Expect(message, IsNil)
+
+			queue.Ack(msg3)
+
+			active, _ = redis.Strings(r.Do("smembers", "fairway:myqueue:active_facets"))
+			c.Expect(len(active), Equals, 1)
+			fqueue, _ = redis.Int(r.Do("llen", "fairway:myqueue:facet_queue"))
+			c.Expect(fqueue, Equals, 0)
+
+			queue.Ack(msg4)
+
+			active, _ = redis.Strings(r.Do("smembers", "fairway:myqueue:active_facets"))
+			c.Expect(len(active), Equals, 0)
+			fqueue, _ = redis.Int(r.Do("llen", "fairway:myqueue:facet_queue"))
+			c.Expect(fqueue, Equals, 0)
+
+		})
+
+		c.Specify("doesn't place pulled message on inflight sorted set if inflight is disabled", func() {
+			msg1, _ := NewMsg(map[string]string{"name": "mymessage1"})
+
+			conn.Deliver(msg1)
+
+			c.Expect(len(queue.Inflight()), Equals, 0)
+
+			queueName, message := queue.Pull(-1)
+			c.Expect(queueName, Equals, "myqueue")
+			c.Expect(message.json(), Equals, msg1.json())
+
+			c.Expect(len(queue.Inflight()), Equals, 0)
+		})
+
+		c.Specify("doesn't pull from inflight message set if inflight is disabled", func() {
+			msg1, _ := NewMsg(map[string]string{"name": "mymessage1"})
+			msg2, _ := NewMsg(map[string]string{"name": "mymessage2"})
+
+			conn.Deliver(msg1)
+			conn.Deliver(msg2)
+
+			queueName, message := queue.Pull(-1)
+			c.Expect(queueName, Equals, "myqueue")
+			c.Expect(message.json(), Equals, msg1.json())
+
+			queueName, message = queue.Pull(-1)
+			c.Expect(queueName, Equals, "myqueue")
+			c.Expect(message.json(), Equals, msg2.json())
+		})
+
+		c.Specify("pulls from facets of the queue in round-robin", func() {
+			r := config.Pool.Get()
+			defer r.Close()
+
+			config.Facet = func(msg *Msg) string {
+				str, _ := msg.Get("facet").String()
+				return str
+			}
+
+			msg1, _ := NewMsg(map[string]string{"facet": "1", "name": "my message1"})
+			msg2, _ := NewMsg(map[string]string{"facet": "1", "name": "my message2"})
+			msg3, _ := NewMsg(map[string]string{"facet": "2", "name": "my message3"})
+
+			active, _ := redis.Strings(r.Do("smembers", "fairway:myqueue:active_facets"))
+			c.Expect(len(active), Equals, 0)
+
+			conn.Deliver(msg1)
+			conn.Deliver(msg2)
+
+			active, _ = redis.Strings(r.Do("smembers", "fairway:myqueue:active_facets"))
+			c.Expect(len(active), Equals, 1)
+			c.Expect(active[0], Equals, "1")
+
+			conn.Deliver(msg3)
+
+			active, _ = redis.Strings(r.Do("smembers", "fairway:myqueue:active_facets"))
+			c.Expect(len(active), Equals, 2)
+			c.Expect(active[0], Equals, "1")
+			c.Expect(active[1], Equals, "2")
+
+			_, message := queue.Pull(-1)
+			c.Expect(message.json(), Equals, msg1.json())
+
+			_, message = queue.Pull(-1)
+			c.Expect(message.json(), Equals, msg3.json())
+
+			active, _ = redis.Strings(r.Do("smembers", "fairway:myqueue:active_facets"))
+			c.Expect(len(active), Equals, 1)
+			c.Expect(active[0], Equals, "1")
+
+			_, message = queue.Pull(-1)
+			c.Expect(message.json(), Equals, msg2.json())
+
+			active, _ = redis.Strings(r.Do("smembers", "fairway:myqueue:active_facets"))
+			c.Expect(len(active), Equals, 0)
+
+			_, message = queue.Pull(2)
+			c.Expect(message, IsNil)
 		})
 
 		c.Specify("removes facet from active list if it becomes empty", func() {
@@ -64,7 +522,7 @@ func QueueSpec(c gospec.Context) {
 			count, _ := redis.Int(r.Do("scard", "fairway:myqueue:active_facets"))
 			c.Expect(count, Equals, 1)
 
-			queue.Pull()
+			queue.Pull(-1)
 
 			count, _ = redis.Int(r.Do("scard", "fairway:myqueue:active_facets"))
 			c.Expect(count, Equals, 0)
@@ -74,9 +532,9 @@ func QueueSpec(c gospec.Context) {
 			msg, _ := NewMsg(map[string]string{})
 			conn.Deliver(msg)
 
-			queueName, message := queue.Pull()
+			queueName, message := queue.Pull(-1)
 			c.Expect(queueName, Equals, "myqueue")
-			queueName, message = queue.Pull()
+			queueName, message = queue.Pull(-1)
 			c.Expect(queueName, Equals, "")
 			c.Expect(message, IsNil)
 		})

data/go/scripts.go

@@ -1,8 +1,10 @@
 package fairway
 
 import (
-	"fmt"
 	"github.com/customerio/redigo/redis"
+
+	"fmt"
+	"time"
 )
 
 type scripts struct {
@@ -56,13 +58,30 @@ func (s *scripts) deliver(channel, facet string, msg *Msg) error {
 	return err
 }
 
-func (s *scripts) pull(queueName string) (string, *Msg) {
+func (s *scripts) deliverBytes(channel, facet string, msg []byte) error {
 	conn := s.config.Pool.Get()
 	defer conn.Close()
 
-	script := s.findScript(FairwayPull, 1)
+	script := s.findScript(FairwayDeliver, 1)
+
+	_, err := script.Do(conn, s.namespace(), channel, facet, string(msg))
 
-	result, err := redis.Strings(script.Do(conn, s.namespace(), queueName))
+	return err
+}
+
+func (s *scripts) length(queue string) (int, error) {
+	conn := s.config.Pool.Get()
+	defer conn.Close()
+	return redis.Int(conn.Do("get", s.namespace()+queue+":length"))
+}
+
+func (s *scripts) pull(queueName string, wait int) (string, *Msg) {
+	conn := s.config.Pool.Get()
+	defer conn.Close()
+
+	script := s.findScript(FairwayPull, 3)
+
+	result, err := redis.Strings(script.Do(conn, s.namespace(), int(time.Now().Unix()), wait, queueName))
 
 	if err != nil {
 		return "", nil
@@ -74,6 +93,65 @@ func (s *scripts) pull(queueName string) (string, *Msg) {
 	return queue, message
 }
 
+func (s *scripts) inflight(queueName string) []string {
+	conn := s.config.Pool.Get()
+	defer conn.Close()
+
+	script := s.findScript(FairwayInflight, 1)
+
+	result, err := redis.Strings(script.Do(conn, s.namespace(), queueName))
+
+	if err != nil {
+		return []string{}
+	}
+
+	return result
+}
+
+func (s *scripts) inflightLimit(queue string) (limit int, err error) {
+	conn := s.config.Pool.Get()
+	defer conn.Close()
+
+	limit, err = redis.Int(conn.Do("get", s.namespace()+queue+":limit"))
+
+	if err != nil && err.Error() == "redigo: nil returned" {
+		return 0, nil
+	}
+
+	return
+}
+
+func (s *scripts) setInflightLimit(queue string, limit int) (err error) {
+	conn := s.config.Pool.Get()
+	defer conn.Close()
+
+	_, err = conn.Do("set", s.namespace()+queue+":limit", limit)
+
+	return
+}
+
+func (s *scripts) ping(queueName string, message *Msg, wait int) error {
+	conn := s.config.Pool.Get()
+	defer conn.Close()
+
+	script := s.findScript(FairwayPing, 3)
+
+	_, err := redis.Strings(script.Do(conn, s.namespace(), int(time.Now().Unix()), wait, queueName, message.Original))
+
+	return err
+}
+
+func (s *scripts) ack(queueName string, facet string, message *Msg) error {
+	conn := s.config.Pool.Get()
+	defer conn.Close()
+
+	script := s.findScript(FairwayAck, 1)
+
+	_, err := redis.Strings(script.Do(conn, s.namespace(), queueName, facet, message.Original))
+
+	return err
+}
+
 func (s *scripts) findScript(script func() string, keyCount int) *redis.Script {
 	content := script()
 

data/lib/fairway/queue.rb

@@ -29,12 +29,24 @@ module Fairway
       end.sum
     end
 
+    def inflight_limit=(limit)
+      redis.with_each do |conn|
+        unique_queues.each do |queue|
+          if limit < 1
+            conn.del("#{queue}:limit")
+          else
+            conn.set("#{queue}:limit", limit)
+          end
+        end
+      end
+    end
+
     def peek
       scripts.fairway_peek(@queue_names.shuffle.uniq)
     end
 
     def pull
-      scripts.fairway_pull(@queue_names.shuffle.uniq)
+      scripts.fairway_pull(Time.now.to_i, -1, @queue_names.shuffle.uniq)
     end
 
     def ==(other)

data/lib/fairway/scripts.rb

@@ -32,6 +32,26 @@ module Fairway
       end
     end
 
+    def fairway_pull(timestamp, wait, queue_name)
+      loaded = false
+
+      first_pool do |conn|
+        conn.evalsha(script_sha(:fairway_pull), [namespace, timestamp, wait], [queue_name])
+      end
+
+    rescue Redis::CommandError => ex
+      if ex.message.include?("NOSCRIPT") && !loaded
+        redis.with_each do |conn|
+          conn.script(:load, script_source(:fairway_pull))
+        end
+
+        loaded = true
+        retry
+      else
+        raise
+      end
+    end
+
     def method_missing(method_name, *args)
       loaded = false
 

data/lib/fairway/version.rb

@@ -1,3 +1,3 @@
 module Fairway
-  VERSION = "0.2.7"
+  VERSION = "0.3.1"
 end