fairway 0.1.4 → 0.2.0

data/Gemfile

@@ -1,5 +1,7 @@
 source :rubygems
 
+gem "rake"
+
 # Specify your gem's dependencies in fairway.gemspec
 gemspec
 

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    fairway (0.1.3)
+    fairway (0.1.4)
       activesupport
       redis
       redis-namespace (>= 1.3.0)
@@ -27,6 +27,7 @@ GEM
     facter (1.6.17)
     i18n (0.6.1)
     multi_json (1.5.0)
+    rake (10.1.0)
     redis (3.0.4)
     redis-namespace (1.3.0)
       redis (~> 3.0.0)
@@ -52,5 +53,6 @@ PLATFORMS
 DEPENDENCIES
   debugger
   fairway!
+  rake
   rspec
   sidekiq

data/Rakefile

@@ -1 +1,22 @@
 require "bundler/gem_tasks"
+require "active_support/core_ext"
+
+task "sync:go" do
+  Dir.glob("redis/*") do |src|
+    script = File.read(src)
+
+    name = /redis\/(.*)\.lua/.match(src)[1]
+
+    File.open("go/#{name}.go", "w") do |dest|  
+      dest.puts <<-EOF
+package fairway
+
+func #{name.camelize}() string {
+  return `
+#{script}
+`
+}
+      EOF
+    end  
+  end
+end

data/go/all_specs_test.go

@@ -0,0 +1,35 @@
+package fairway
+
+import (
+	"github.com/customerio/gospec"
+	"github.com/garyburd/redigo/redis"
+	"testing"
+)
+
+// You will need to list every spec in a TestXxx method like this,
+// so that gotest can be used to run the specs. Later GoSpec might
+// get its own command line tool similar to gotest, but for now this
+// is the way to go. This shouldn't require too much typing, because
+// there will be typically only one top-level spec per class/feature.
+
+func TestAllSpecs(t *testing.T) {
+	r := gospec.NewRunner()
+
+	r.Parallel = false
+
+	r.BeforeEach = func() {
+		// Load test instance of redis on port 6400
+		conn, _ := redis.Dial("tcp", "localhost:6400")
+		conn.Do("flushdb")
+	}
+
+	// List all specs here
+	r.AddSpec(ConfigSpec)
+	r.AddSpec(ConnectionSpec)
+	r.AddSpec(ChanneledConnectionSpec)
+	r.AddSpec(MsgSpec)
+	r.AddSpec(QueueSpec)
+
+	// Run GoSpec and report any errors to gotest's `testing.T` instance
+	gospec.MainGoTest(r, t)
+}

data/go/channeled_connection.go

@@ -0,0 +1,23 @@
+package fairway
+
+type channeledConn struct {
+	*conn
+	channel func(message *Msg) string
+}
+
+func (c *channeledConn) Channel(msg *Msg) string {
+	return c.channel(msg)
+}
+
+func (c *channeledConn) Deliver(msg *Msg) error {
+	channel := c.Channel(msg)
+	facet := c.config.Facet(msg)
+	return c.scripts.deliver(channel, facet, msg)
+}
+
+func NewChanneledConnection(config *Config, channelFunc func(message *Msg) string) Connection {
+	return &channeledConn{
+		NewConnection(config).(*conn),
+		channelFunc,
+	}
+}

data/go/channeled_connection_test.go

@@ -0,0 +1,41 @@
+package fairway
+
+import (
+	"fmt"
+	"github.com/customerio/gospec"
+	. "github.com/customerio/gospec"
+	"github.com/garyburd/redigo/redis"
+)
+
+func ChanneledConnectionSpec(c gospec.Context) {
+	// Load test instance of redis on port 6400
+	config := NewConfig("localhost:6400", 2)
+	config.AddQueue("myqueue", "typea")
+	config.AddQueue("myqueue2", "typeb")
+
+	conn := NewChanneledConnection(config, func(message *Msg) string {
+		channel, _ := message.Get("type").String()
+		return fmt.Sprint("channel:type", channel, ":channel")
+	})
+
+	c.Specify("Deliver", func() {
+		c.Specify("only queues up message for matching queues", func() {
+			r := config.redisPool.Get()
+			defer r.Close()
+
+			count, _ := redis.Int(r.Do("llen", "fairway:myqueue:default"))
+			c.Expect(count, Equals, 0)
+			count, _ = redis.Int(r.Do("llen", "fairway:myqueue2:default"))
+			c.Expect(count, Equals, 0)
+
+			msg, _ := NewMsg(map[string]string{"type": "a"})
+
+			conn.Deliver(msg)
+
+			count, _ = redis.Int(r.Do("llen", "fairway:myqueue:default"))
+			c.Expect(count, Equals, 1)
+			count, _ = redis.Int(r.Do("llen", "fairway:myqueue2:default"))
+			c.Expect(count, Equals, 0)
+		})
+	})
+}

data/go/config.go

@@ -0,0 +1,50 @@
+package fairway
+
+import (
+	"github.com/garyburd/redigo/redis"
+	"time"
+)
+
+type QueueDefinition struct {
+	name    string
+	channel string
+}
+
+type Config struct {
+	Namespace string
+	Facet     func(message *Msg) string
+	queues    []*QueueDefinition
+	redisPool *redis.Pool
+}
+
+func (c *Config) AddQueue(name, channel string) {
+	c.queues = append(c.queues, &QueueDefinition{name, channel})
+}
+
+func (c *Config) scripts() *scripts {
+	return newScripts(c)
+}
+
+func NewConfig(server string, poolSize int) *Config {
+	return &Config{
+		"fairway",
+		func(message *Msg) string { return "default" },
+		[]*QueueDefinition{},
+		&redis.Pool{
+			MaxIdle:     poolSize,
+			MaxActive:   poolSize,
+			IdleTimeout: 240 * time.Second,
+			Dial: func() (redis.Conn, error) {
+				c, err := redis.Dial("tcp", server)
+				if err != nil {
+					return nil, err
+				}
+				return c, err
+			},
+			TestOnBorrow: func(c redis.Conn, t time.Time) error {
+				_, err := c.Do("PING")
+				return err
+			},
+		},
+	}
+}

data/go/config_test.go

@@ -0,0 +1,53 @@
+package fairway
+
+import (
+	"github.com/customerio/gospec"
+	. "github.com/customerio/gospec"
+)
+
+func ConfigSpec(c gospec.Context) {
+	// Load test instance of redis on port 6400
+	config := NewConfig("localhost:6400", 10)
+
+	c.Specify("NewConfig", func() {
+		c.Specify("namespace is fairway", func() {
+			c.Expect(config.Namespace, Equals, "fairway")
+		})
+
+		c.Specify("sets the facet to always return 'default'", func() {
+			msg, _ := NewMsg(make([]string, 0))
+			c.Expect(config.Facet(msg), Equals, "default")
+		})
+
+		c.Specify("doesn't have any defined queues", func() {
+			c.Expect(len(config.queues), Equals, 0)
+		})
+	})
+
+	c.Specify("sets redis pool size", func() {
+		c.Expect(config.redisPool.MaxIdle, Equals, 10)
+		c.Expect(config.redisPool.MaxActive, Equals, 10)
+		config = NewConfig("localhost:6400", 20)
+		c.Expect(config.redisPool.MaxIdle, Equals, 20)
+		c.Expect(config.redisPool.MaxActive, Equals, 20)
+	})
+
+	c.Specify("can specify custom namespace", func() {
+		config.Namespace = "mynamespace"
+		c.Expect(config.Namespace, Equals, "mynamespace")
+	})
+
+	c.Specify("can specify custom facet", func() {
+		config.Facet = func(message *Msg) string {
+			return "myfacet"
+		}
+		msg, _ := NewMsg(make([]string, 0))
+		c.Expect(config.Facet(msg), Equals, "myfacet")
+	})
+
+	c.Specify("can define a queue", func() {
+		config.AddQueue("myqueue", "default")
+		c.Expect(len(config.queues), Equals, 1)
+		c.Expect(*config.queues[0], Equals, QueueDefinition{"myqueue", "default"})
+	})
+}

data/go/connection.go

@@ -0,0 +1,54 @@
+package fairway
+
+type Connection interface {
+	RegisterQueues()
+	Queues() []*Queue
+	Channel(*Msg) string
+	Deliver(*Msg) error
+	Configuration() *Config
+}
+
+type conn struct {
+	config  *Config
+	scripts *scripts
+}
+
+func (c *conn) RegisterQueues() {
+	for _, definition := range c.config.queues {
+		c.scripts.registerQueue(definition)
+	}
+}
+
+func (c *conn) Queues() []*Queue {
+	registered, _ := c.scripts.registeredQueues()
+	queues := make([]*Queue, len(registered))
+
+	for i, queue := range registered {
+		queues[i] = NewQueue(c, queue)
+	}
+
+	return queues
+}
+
+func (c *conn) Channel(msg *Msg) string {
+	return "default"
+}
+
+func (c *conn) Deliver(msg *Msg) error {
+	channel := c.Channel(msg)
+	facet := c.config.Facet(msg)
+	return c.scripts.deliver(channel, facet, msg)
+}
+
+func (c *conn) Configuration() *Config {
+	return c.config
+}
+
+func NewConnection(config *Config) Connection {
+	c := &conn{
+		config,
+		config.scripts(),
+	}
+	c.RegisterQueues()
+	return c
+}

data/go/connection_test.go

@@ -0,0 +1,125 @@
+package fairway
+
+import (
+	"github.com/customerio/gospec"
+	. "github.com/customerio/gospec"
+	"github.com/garyburd/redigo/redis"
+)
+
+func ConnectionSpec(c gospec.Context) {
+	// Load test instance of redis on port 6400
+	config := NewConfig("localhost:6400", 2)
+	config.AddQueue("myqueue", ".*")
+	conn := NewConnection(config)
+
+	c.Specify("NewConnection", func() {
+		c.Specify("registers any queues defined in configuration", func() {
+			c.Expect(len(conn.Queues()), Equals, 1)
+			config.AddQueue("myqueue2", ".*")
+			conn.RegisterQueues()
+			c.Expect(len(conn.Queues()), Equals, 2)
+		})
+
+		c.Specify("stores registered queues in redis", func() {
+			r := config.redisPool.Get()
+			defer r.Close()
+
+			values, _ := redis.Strings(r.Do("hgetall", "fairway:registered_queues"))
+
+			expected := []string{"myqueue", ".*"}
+
+			for i, str := range values {
+				c.Expect(str, Equals, expected[i])
+			}
+		})
+	})
+
+	c.Specify("Queues", func() {
+		c.Specify("returns a Queue for every currently registered queue", func() {
+			c.Expect(*conn.Queues()[0], Equals, *NewQueue(conn, "myqueue"))
+		})
+	})
+
+	c.Specify("Deliver", func() {
+		c.Specify("adds message to the facet for the queue", func() {
+			r := config.redisPool.Get()
+			defer r.Close()
+
+			count, _ := redis.Int(r.Do("llen", "fairway:myqueue:default"))
+			c.Expect(count, Equals, 0)
+
+			msg, _ := NewMsg(map[string]string{"name": "mymessage"})
+
+			conn.Deliver(msg)
+
+			count, _ = redis.Int(r.Do("llen", "fairway:myqueue:default"))
+			c.Expect(count, Equals, 1)
+
+			value, _ := redis.String(r.Do("lindex", "fairway:myqueue:default", 0))
+			c.Expect(value, Equals, msg.json())
+		})
+
+		c.Specify("adds facets to the list of active facets", func() {
+			r := config.redisPool.Get()
+			defer r.Close()
+
+			facets, _ := redis.Strings(r.Do("smembers", "fairway:myqueue:active_facets"))
+			c.Expect(len(facets), Equals, 0)
+
+			msg, _ := NewMsg(map[string]string{})
+
+			conn.Deliver(msg)
+
+			facets, _ = redis.Strings(r.Do("smembers", "fairway:myqueue:active_facets"))
+			c.Expect(len(facets), Equals, 1)
+			c.Expect(facets[0], Equals, "default")
+		})
+
+		c.Specify("pushes facet onto the facet queue", func() {
+			r := config.redisPool.Get()
+			defer r.Close()
+
+			count, _ := redis.Int(r.Do("llen", "fairway:myqueue:facet_queue"))
+			c.Expect(count, Equals, 0)
+
+			msg, _ := NewMsg(map[string]string{})
+
+			conn.Deliver(msg)
+
+			count, _ = redis.Int(r.Do("llen", "fairway:myqueue:facet_queue"))
+			c.Expect(count, Equals, 1)
+
+			value, _ := redis.String(r.Do("lindex", "fairway:myqueue:facet_queue", 0))
+			c.Expect(value, Equals, "default")
+		})
+
+		c.Specify("doesn't push facet if already active", func() {
+			r := config.redisPool.Get()
+			defer r.Close()
+
+			r.Do("sadd", "fairway:myqueue:active_facets", "default")
+
+			msg, _ := NewMsg(map[string]string{})
+
+			conn.Deliver(msg)
+
+			count, _ := redis.Int(r.Do("llen", "fairway:myqueue:facet_queue"))
+			c.Expect(count, Equals, 0)
+		})
+
+		c.Specify("returns nil if delivery succeeds", func() {
+			msg, _ := NewMsg(map[string]string{})
+			err := conn.Deliver(msg)
+			c.Expect(err, IsNil)
+		})
+
+		c.Specify("returns error if delivery fails", func() {
+			config := NewConfig("localhost:9999", 2)
+			conn := NewConnection(config)
+
+			msg, _ := NewMsg(map[string]string{})
+			err := conn.Deliver(msg)
+			c.Expect(err.Error(), Equals, "dial tcp 127.0.0.1:9999: connection refused")
+		})
+	})
+}

data/go/fairway_deliver.go

@@ -0,0 +1,67 @@
+package fairway
+
+func FairwayDeliver() string {
+  return `
+local namespace = KEYS[1];
+local topic     = ARGV[1];
+local facet     = ARGV[2];
+local message   = ARGV[3];
+
+local k = function (queue, subkey)
+  return namespace .. queue .. ':' .. subkey;
+end
+
+local registered_queues_key = namespace .. 'registered_queues';
+local registered_queues     = redis.call('hgetall', registered_queues_key);
+
+-- Determine whether or not the message should
+-- be delivered to each registered queue.
+for i = 1, #registered_queues, 2 do
+  local queue       = registered_queues[i];
+  local queue_topic = registered_queues[i+1];
+
+  -- If the message topic matches the queue topic,
+  -- we deliver the message to the queue.
+  if string.find(topic, queue_topic) then
+    local priorities    = k(queue, 'priorities');
+    local active_facets = k(queue, 'active_facets');
+    local round_robin   = k(queue, 'facet_queue');
+    local facet_pool    = k(queue, 'facet_pool');
+
+    -- Delivering the message to a queue is as simple as
+    -- pushing it onto the facet's message list, and
+    -- incrementing the length of the queue itself.
+    redis.call('lpush', k(queue, facet), message)
+    redis.call('incr', k(queue, 'length'));
+
+    -- If the facet just became active, we need to add
+    -- the facet to the round-robin queue, so it's
+    -- messages will be processed.
+    if redis.call('sadd', active_facets, facet) == 1 then
+      local priority = tonumber(redis.call('hget', priorities, facet)) or 1
+
+      -- If the facet currently has a priority
+      -- we need to jump start the facet by adding
+      -- it to the round-robin queue and updating
+      -- the current priority.
+      if priority > 0 then
+        redis.call('lpush', round_robin, facet);
+        redis.call('hset', facet_pool, facet, 1);
+      
+      -- If the facet has no set priority, just set the
+      -- current priority to zero. Since the facet just
+      -- became active, we can be sure it's already zero
+      -- or undefined.
+      else
+        redis.call('hset', facet_pool, facet, 0);
+      end
+    end
+  end
+end
+
+-- For any clients listening over pub/sub,
+-- we should publish the message.
+redis.call('publish', namespace .. topic, message);
+
+`
+}

data/go/fairway_destroy.go

@@ -0,0 +1,36 @@
+package fairway
+
+func FairwayDestroy() string {
+  return `
+local namespace = KEYS[1];
+
+local k = function (queue, subkey)
+  return namespace .. queue .. ':' .. subkey;
+end
+
+-- Multiple queues can be passed through
+-- fairway_destroy. We'll loop through all 
+-- provided queues, and delete related keys
+-- for each queue.
+for i, queue in ipairs(ARGV) do
+  local priorities    = k(queue, 'priorities');
+  local active_facets = k(queue, 'active_facets');
+  local round_robin   = k(queue, 'facet_queue');
+  local facet_pool    = k(queue, 'facet_pool');
+  local length        = k(queue, 'length');
+
+  local facets = redis.call('smembers', active_facets);
+
+  for i = 1, #facets, 1 do
+    redis.call('del', k(queue, facets[i]));
+  end
+
+  redis.call('del', priorities);
+  redis.call('del', active_facets);
+  redis.call('del', round_robin);
+  redis.call('del', facet_pool);
+  redis.call('del', length);
+end
+
+`
+}

data/go/fairway_peek.go

@@ -0,0 +1,22 @@
+package fairway
+
+func FairwayPeek() string {
+  return `
+local namespace = KEYS[1];
+
+for index, queue_name in ipairs(ARGV) do
+  local active_facets = namespace .. queue_name .. ':active_facets';
+  local facet_queue   = namespace .. queue_name .. ':facet_queue';
+
+  local facet = redis.call('lrange', facet_queue, -1, -1)[1];
+
+  if facet then
+    local message_queue = namespace .. queue_name .. ':' .. facet;
+    local message = redis.call('lrange', message_queue, -1, -1)[1];
+
+    return {queue_name, message};
+  end
+end
+
+`
+}

data/go/fairway_priority.go

@@ -0,0 +1,36 @@
+package fairway
+
+func FairwayPriority() string {
+  return `
+local namespace    = KEYS[1];
+local queue        = ARGV[1];
+local facet        = ARGV[2];
+local new_priority = tonumber(ARGV[3]);
+
+local k = function (queue, subkey)
+  return namespace .. queue .. ':' .. subkey;
+end
+
+local priorities  = k(queue, 'priorities');
+local round_robin = k(queue, 'facet_queue');
+local facet_pool  = k(queue, 'facet_pool');
+
+-- Find the current state of the facet for the queue
+local priority = tonumber(redis.call('hget', priorities, facet)) or 1;
+local current  = tonumber(redis.call('hget', facet_pool, facet));
+
+-- If priority is currently zero, we need to jump
+-- start the facet by adding it to the round-robin
+-- queue and updating the current priority.
+if new_priority > 0 and priority == 0 and current == 0 then
+  redis.call('lpush', round_robin, facet);
+  redis.call('hset', facet_pool, facet, 1);
+end
+
+-- Other than the 0 priority case, we can just
+-- set the new priority, and the real priority
+-- will update lazily on pull.
+redis.call('hset', priorities, facet, new_priority);
+
+`
+}

data/go/fairway_pull.go

@@ -0,0 +1,99 @@
+package fairway
+
+func FairwayPull() string {
+  return `
+local namespace = KEYS[1];
+
+local k = function (queue, subkey)
+  return namespace .. queue .. ':' .. subkey;
+end
+
+-- Multiple queues can be passed through
+-- fairway_pull. We'll loop through all 
+-- provided queues, and return a message
+-- from the first one that isn't empty.
+for i, queue in ipairs(ARGV) do
+  local priorities    = k(queue, 'priorities');
+  local active_facets = k(queue, 'active_facets');
+  local round_robin   = k(queue, 'facet_queue');
+  local facet_pool    = k(queue, 'facet_pool');
+
+  -- Pull a facet from the round-robin list.
+  -- This list guarantees each active facet will have a
+  -- message pulled from the queue every time through..
+  local facet = redis.call('rpop', round_robin);
+
+  if facet then
+    -- If we found an active facet, we know the facet
+    -- has at least one message available to be pulled
+    -- from it's message queue.
+    local messages = k(queue, facet);
+    local message  = redis.call('rpop', messages);
+
+    if message then
+      redis.call('decr', k(queue, 'length'));
+    end
+
+    local length = redis.call('llen', messages);
+
+    -- If the length of the facet's message queue
+    -- is empty, then it is no longer active as
+    -- it no longer has any messages.
+    if length == 0 then
+      -- We remove the facet from the set of active
+      -- facets and don't push the facet back on the
+      -- round-robin queue.
+      redis.call('srem', active_facets, facet);
+     
+    -- If the facet still has messages to process,
+    -- it remains in the active facet set, and is
+    -- pushed back on the round-robin queue.
+    --
+    -- Additionally, the priority of the facet may
+    -- have changed, so we'll check and update the
+    -- current facet's priority if needed.
+    else
+      local priority = tonumber(redis.call('hget', priorities, facet)) or 1
+      local current  = tonumber(redis.call('hget', facet_pool, facet)) or 1
+
+      -- If the current priority is less than the
+      -- desired priority, let's increase the priority
+      -- by pushing the current facet on the round-robin
+      -- queue twice, and incrementing the current
+      -- priority.
+      --
+      -- Note: If there aren't enough messages left
+      -- on the facet, we don't increase priority.
+      if current < priority and length > current then
+        redis.call('lpush', round_robin, facet);
+        redis.call('lpush', round_robin, facet);
+        redis.call('hset', facet_pool, facet, current + 1);
+        
+      -- If the current priority is greater than the
+      -- desired priority, let's decrease the priority
+      -- by not pushing the current facet on the round-robin
+      -- queue, and decrementing the current priority.
+      --
+      -- Note: Also decrement priority if there aren't
+      -- enough messages for the current priority. This
+      -- ensures priority (entries in the round-robin queue)
+      -- never exceeds the number of messages for a given
+      -- facet.
+      elseif current > priority or current > length then
+        redis.call('hset', facet_pool, facet, current - 1);
+      
+      -- If the current priority is equals the
+      -- desired priority, let's maintain the current priority
+      -- by pushing the current facet on the round-robin
+      -- queue once.
+      else
+        redis.call('lpush', round_robin, facet);
+      end
+    end
+
+    return {queue, message};
+  end
+end
+
+`
+}

data/go/message.go

@@ -0,0 +1,38 @@
+package fairway
+
+import (
+	"encoding/json"
+	"github.com/bitly/go-simplejson"
+)
+
+type Msg struct {
+	*simplejson.Json
+}
+
+func NewMsg(body interface{}) (*Msg, error) {
+	bytes, err := json.Marshal(body)
+	if err != nil {
+		return nil, err
+	}
+
+	simplej, err := simplejson.NewJson(bytes)
+	if err != nil {
+		return nil, err
+	}
+
+	return &Msg{simplej}, nil
+}
+
+func NewMsgFromString(body string) (*Msg, error) {
+	simplej, err := simplejson.NewJson([]byte(body))
+	if err != nil {
+		return nil, err
+	}
+
+	return &Msg{simplej}, nil
+}
+
+func (m *Msg) json() string {
+	j, _ := m.MarshalJSON()
+	return string(j)
+}

data/go/message_test.go

@@ -0,0 +1,34 @@
+package fairway
+
+import (
+	"github.com/customerio/gospec"
+	. "github.com/customerio/gospec"
+)
+
+func MsgSpec(c gospec.Context) {
+	c.Specify("NewMsg", func() {
+		c.Specify("returns a new message with body as the content", func() {
+			msg, _ := NewMsg(map[string]string{"hello": "world"})
+			c.Expect(msg.json(), Equals, "{\"hello\":\"world\"}")
+		})
+
+		c.Specify("returns err if couldn't convert object", func() {
+			msg, err := NewMsg(func() {})
+			c.Expect(msg, IsNil)
+			c.Expect(err, Not(IsNil))
+		})
+	})
+
+	c.Specify("NewMsgFromString", func() {
+		c.Specify("returns a new message with string as the content", func() {
+			msg, _ := NewMsgFromString("{\"hello\":\"world\"}")
+			c.Expect(msg.json(), Equals, "{\"hello\":\"world\"}")
+		})
+
+		c.Specify("returns err if couldn't convert string", func() {
+			msg, err := NewMsgFromString("not json")
+			c.Expect(msg, IsNil)
+			c.Expect(err, Not(IsNil))
+		})
+	})
+}

data/go/queue.go

@@ -0,0 +1,14 @@
+package fairway
+
+type Queue struct {
+	conn Connection
+	name string
+}
+
+func NewQueue(conn Connection, name string) *Queue {
+	return &Queue{conn, name}
+}
+
+func (q *Queue) Pull() (string, *Msg) {
+	return q.conn.Configuration().scripts().pull(q.name)
+}

data/go/queue_test.go

@@ -0,0 +1,85 @@
+package fairway
+
+import (
+	"github.com/customerio/gospec"
+	. "github.com/customerio/gospec"
+	"github.com/garyburd/redigo/redis"
+)
+
+func QueueSpec(c gospec.Context) {
+	// Load test instance of redis on port 6400
+	config := NewConfig("localhost:6400", 2)
+	config.AddQueue("myqueue", ".*")
+	conn := NewConnection(config)
+	queue := NewQueue(conn, "myqueue")
+
+	c.Specify("NewQueue", func() {
+	})
+
+	c.Specify("Pull", func() {
+		c.Specify("pulls a message off the queue using FIFO", 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()
+			c.Expect(queueName, Equals, "myqueue")
+			c.Expect(message.json(), Equals, msg1.json())
+
+			queueName, message = queue.Pull()
+			c.Expect(queueName, Equals, "myqueue")
+			c.Expect(message.json(), Equals, msg2.json())
+		})
+
+		c.Specify("pulls from facets of the queue in round-robin", func() {
+			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"})
+
+			conn.Deliver(msg1)
+			conn.Deliver(msg2)
+			conn.Deliver(msg3)
+
+			_, message := queue.Pull()
+			c.Expect(message.json(), Equals, msg1.json())
+			_, message = queue.Pull()
+			c.Expect(message.json(), Equals, msg3.json())
+			_, message = queue.Pull()
+			c.Expect(message.json(), Equals, msg2.json())
+		})
+
+		c.Specify("removes facet from active list if it becomes empty", func() {
+			r := config.redisPool.Get()
+			defer r.Close()
+
+			msg, _ := NewMsg(map[string]string{})
+			conn.Deliver(msg)
+
+			count, _ := redis.Int(r.Do("scard", "fairway:myqueue:active_facets"))
+			c.Expect(count, Equals, 1)
+
+			queue.Pull()
+
+			count, _ = redis.Int(r.Do("scard", "fairway:myqueue:active_facets"))
+			c.Expect(count, Equals, 0)
+		})
+
+		c.Specify("returns nil if there are no messages to receive", func() {
+			msg, _ := NewMsg(map[string]string{})
+			conn.Deliver(msg)
+
+			queueName, message := queue.Pull()
+			c.Expect(queueName, Equals, "myqueue")
+			queueName, message = queue.Pull()
+			c.Expect(queueName, Equals, "")
+			c.Expect(message, IsNil)
+		})
+	})
+}

data/go/scripts.go

@@ -0,0 +1,85 @@
+package fairway
+
+import (
+	"fmt"
+	"github.com/garyburd/redigo/redis"
+)
+
+type scripts struct {
+	config *Config
+	data   map[string]*redis.Script
+}
+
+func newScripts(config *Config) *scripts {
+	return &scripts{config, make(map[string]*redis.Script)}
+}
+
+func (s *scripts) namespace() string {
+	namespace := s.config.Namespace
+
+	if len(namespace) > 0 {
+		namespace = fmt.Sprint(namespace, ":")
+	}
+
+	return namespace
+}
+
+func (s *scripts) registeredQueuesKey() string {
+	return fmt.Sprint(s.namespace(), "registered_queues")
+}
+
+func (s *scripts) registerQueue(queue *QueueDefinition) {
+	conn := s.config.redisPool.Get()
+	defer conn.Close()
+
+	_, err := redis.Bool(conn.Do("hset", s.registeredQueuesKey(), queue.name, queue.channel))
+
+	if err != nil {
+		panic(err)
+	}
+}
+
+func (s *scripts) registeredQueues() ([]string, error) {
+	conn := s.config.redisPool.Get()
+	defer conn.Close()
+	return redis.Strings(conn.Do("hkeys", s.registeredQueuesKey()))
+}
+
+func (s *scripts) deliver(channel, facet string, msg *Msg) error {
+	conn := s.config.redisPool.Get()
+	defer conn.Close()
+
+	script := s.findScript(FairwayDeliver, 1)
+
+	_, err := script.Do(conn, s.namespace(), channel, facet, msg.json())
+
+	return err
+}
+
+func (s *scripts) pull(queueName string) (string, *Msg) {
+	conn := s.config.redisPool.Get()
+	defer conn.Close()
+
+	script := s.findScript(FairwayPull, 1)
+
+	result, err := redis.Strings(script.Do(conn, s.namespace(), queueName))
+
+	if err != nil {
+		return "", nil
+	}
+
+	queue := result[0]
+	message, _ := NewMsgFromString(result[1])
+
+	return queue, message
+}
+
+func (s *scripts) findScript(script func() string, keyCount int) *redis.Script {
+	content := script()
+
+	if s.data[content] == nil {
+		s.data[content] = redis.NewScript(keyCount, content)
+	}
+
+	return s.data[content]
+}

data/lib/fairway/config.rb

@@ -1,7 +1,7 @@
 module Fairway
   class Config
     attr_accessor :namespace
-    attr_reader :defined_queues
+    attr_reader :defined_queues, :redis_options
 
     DEFAULT_FACET = "default"
 

data/lib/fairway/sidekiq/basic_fetch.rb

@@ -14,7 +14,6 @@ module Fairway
 
         work = ::Sidekiq.redis do |conn|
           script = <<-SCRIPT
-            -- take advantage of non-blocking scripts
             for i = 1, #KEYS do
               local work = redis.call('rpop', KEYS[i]);
 

data/lib/fairway/version.rb

@@ -1,3 +1,3 @@
 module Fairway
-  VERSION = "0.1.4"
+  VERSION = "0.2.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fairway
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-05-29 00:00:00.000000000 Z
+date: 2013-10-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -74,6 +74,23 @@ files:
 - Rakefile
 - boot.rb
 - fairway.gemspec
+- go/all_specs_test.go
+- go/channeled_connection.go
+- go/channeled_connection_test.go
+- go/config.go
+- go/config_test.go
+- go/connection.go
+- go/connection_test.go
+- go/fairway_deliver.go
+- go/fairway_destroy.go
+- go/fairway_peek.go
+- go/fairway_priority.go
+- go/fairway_pull.go
+- go/message.go
+- go/message_test.go
+- go/queue.go
+- go/queue_test.go
+- go/scripts.go
 - lib/fairway.rb
 - lib/fairway/channeled_connection.rb
 - lib/fairway/config.rb