fraggle 0.1.0

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2011 Blake Mizerany, Keith Rarick, Chris Moos
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,68 @@
+# Fraggle
+**An EventMachine based Doozer client**
+
+## Install
+
+    $ gem install fraggle
+
+## Use
+
+    require 'rubygems'
+    require 'eventmachine'
+    require 'fraggle'
+
+    EM.start do
+      c = Fraggle.connect "127.0.0.1", 8046
+
+      ## Setting a key
+      c.set "/foo", "bar", :missing do |e|
+        if ! e.err
+          e.cas # => "123"
+        end
+      end
+
+      c.get "/foo" do |e|
+        if err != nil
+          e.body     # => "bar"
+          e.cas      # => "123"
+          e.dir? # => false
+        end
+      end
+
+      watch = c.watch "/foo" do |e|
+        # The event has:
+        # ------------------------
+        # NOTE:  `err` will be set iff the glob is bad
+        # e.err       # => nil
+        # e.path      # => "/foo"
+        # e.body      # => "bar"
+        # e.cas       # => "123"
+        # e.set?  # => true
+        # e.del?  # => false
+        # e.done? # => true
+        # ------------------------
+
+        if e.done?
+          # This watch was closed, do something if you wish.
+        else
+          done_something_with(e)
+
+          # Phoney check for example
+          if can_stop_watching?(path)
+            c.close(watch)
+          end
+        end
+
+      end
+
+    end
+
+
+## Dev
+
+**Clone**
+    $ git clone http://github.com/bmizerany/fraggle.git
+
+**Test**
+    $ gem install turn
+    $ turn

data/lib/fraggle.rb

@@ -0,0 +1,322 @@
+require 'beefcake'
+require 'eventmachine'
+require 'fraggle/proto'
+
+module Fraggle
+
+  MaxInt32 = (1<<31)-1
+  MinInt32 = -(1<<31)
+
+  ##
+  # Response extensions
+  class Response
+    module Flag
+      VALID = 1
+      DONE  = 2
+    end
+
+    def valid?
+      (flags & Flag::VALID) > 0
+    end
+
+    def done?
+      (flags & Flag::DONE) > 0
+    end
+
+    # Err sugar
+    def ok?           ; err_code == nil               ; end
+    def other?        ; err_code == Err::OTHER        ; end
+    def tag_in_use?   ; err_code == Err::TAG_IN_USE   ; end
+    def unknown_verb? ; err_code == Err::UNKNOWN_VERB ; end
+    def redirect?     ; err_code == Err::REDIRECT     ; end
+    def invalid_snap? ; err_code == Err::INVALID_SNAP ; end
+    def mismatch?     ; err_code == Err::CAS_MISMATCH ; end
+    def notdir?       ; err_code == Err::NOTDIR       ; end
+    def dir?          ; err_code == Err::ISDIR        ; end
+
+    # CAS sugar
+    def missing?  ; cas ==  0 ; end
+    def clobber?  ; cas == -1 ; end
+    def dir?      ; cas == -2 ; end
+    def dummy?    ; cas == -3 ; end
+  end
+
+
+  class AssemblyError < StandardError
+  end
+
+
+  def self.connect(addr="127.0.0.1:8046", opts={})
+    # TODO: take a magnet link instead
+    host, port = addr.split(":")
+    EM.connect(host, port, self, addr, opts)
+  end
+
+  attr_reader :doozers, :addr, :opts
+
+  def initialize(addr, opts)
+    opts[:assemble] = opts.fetch(:assemble, true)
+
+    # TODO: take a magnet link and load into @doozers
+    @addr    = addr
+    @opts    = opts
+    @doozers = {}
+  end
+
+  ##
+  # Collect all cluster information for the event of a disconnect from the
+  # server; At which point we will want to attempt a connecting to them one by
+  # one until we have a connection or run out of options.
+  def assemble
+    return if ! opts[:assemble]
+
+    blk = Proc.new do |we|
+      if ! we.ok?
+        raise AssemblyError, we.err_detail
+      end
+
+      if we.value == ""
+        doozers.delete(we.path)
+      else
+        get "/doozer/info/#{we.value}/public-addr" do |e|
+          next if e.value == addr
+          doozers[we.path] = e.value
+        end
+      end
+    end
+
+    watch "/doozer/slot/*", &blk
+    walk  "/doozer/slot/*", &blk
+  end
+
+  ##
+  # Attempts to connect to another doozer when a connection is lost
+  def unbind
+    return if ! opts[:assemble]
+
+    _, @addr = doozers.shift
+    if ! @addr
+      raise AssemblyError, "All known doozers are down"
+    end
+
+    host, port = @addr.split(":")
+    reconnect(host, port)
+  end
+
+
+
+
+  ##
+  # Session generation
+  def gen_key(name, size=16)
+    nibbles = "0123456789abcdef"
+    "#{name}." + (0...size).map { nibbles[rand(nibbles.length)].chr }.join
+  end
+
+  def session(name="fraggle", &blk)
+    raise ArgumentError, "no block given" if ! blk
+
+    id = gen_key(name)
+
+    fun = lambda do |e|
+      raise e.err_detail if ! e.ok?
+      checkin(e.cas, id, &fun)
+    end
+
+    established = lambda do |e|
+      case true
+      when e.mismatch?
+        id = gen_key(name)
+        checkin(0, id, &established)
+      when ! e.ok?
+        raise e.err_detail
+      else
+        blk.call
+        checkin(e.cas, id, &fun)
+      end
+    end
+
+    checkin(0, id, &established)
+  end
+
+  def checkin(cas, id, &blk)
+    call(
+      Request::Verb::CHECKIN,
+      :cas => casify(cas),
+      :path => id.to_s,
+      &blk
+    )
+  end
+
+  def post_init
+    @buf = ""
+    @tag = 0
+    @cbx = {}
+    @len = nil
+
+    assemble
+  end
+
+  def receive_data(data)
+    @buf << data
+
+    got = true
+    while got
+      got = false
+
+      if @len.nil? && @buf.length >= 4
+        @len = @buf.slice!(0, 4).unpack("N").first
+      end
+
+      if @len && @buf.length >= @len
+        bytes = @buf.slice!(0, @len)
+        res   = Response.decode(bytes)
+        receive_response(res)
+        @len = nil
+        got = true
+      end
+    end
+  end
+
+  def receive_response(res)
+    blk = @cbx[res.tag]
+
+    if blk && res.valid?
+      if blk.arity == 2
+        blk.call(res, false)
+      else
+        blk.call(res)
+      end
+    end
+
+    if res.done?
+      if blk && blk.arity == 2
+        blk.call(nil, true)
+      end
+      @cbx.delete(res.tag)
+    end
+  end
+
+  def call(verb, attrs={}, &blk)
+    if @tag == MaxInt32
+      @tag = MinInt32
+    end
+
+    while true
+      break if ! @cbx.has_key?(@tag)
+      @tag += 1
+    end
+
+    attrs[:verb] = verb
+    attrs[:tag]  = @tag
+    @cbx[@tag]   = blk
+
+    send_request(Request.new(attrs))
+
+    @tag
+  end
+
+  def send_request(req)
+    buf = req.encode
+
+    send_data([buf.length].pack("N"))
+    send_data(buf)
+  end
+
+
+
+  ##
+  # Sugar
+  def get(path, sid=0, &blk)
+    call(
+      Request::Verb::GET,
+      :path => path,
+      :id => sid,
+      &blk
+    )
+  end
+
+  def set(path, body, cas, &blk)
+    call(
+      Request::Verb::SET,
+      :path => path,
+      :value => body,
+      :cas => casify(cas),
+      &blk
+    )
+  end
+
+  def del(path, cas, &blk)
+    call(
+      Request::Verb::DEL,
+      :path => path,
+      :cas  => casify(cas),
+      &blk
+    )
+  end
+
+  def watch(glob, &blk)
+    call(
+      Request::Verb::WATCH,
+      :path => glob,
+      &blk
+    )
+  end
+
+  def walk(glob, &blk)
+    call(
+      Request::Verb::WALK,
+      :path => glob,
+      &blk
+    )
+  end
+
+  def snap(&blk)
+    call(
+      Request::Verb::SNAP,
+      &blk
+    )
+  end
+
+  def delsnap(id, &blk)
+    call(
+      Request::Verb::DELSNAP,
+      :id => id,
+      &blk
+    )
+  end
+
+  def noop(&blk)
+    call(
+      Request::Verb::NOOP,
+      &blk
+    )
+  end
+
+  def cancel(tag)
+    blk = lambda do |e|
+      if e.ok?
+        if blk = @cbx.delete(tag)
+          blk.call(nil, true)
+        end
+      end
+    end
+
+    call(
+      Request::Verb::CANCEL,
+      :id => tag,
+      &blk
+    )
+  end
+
+  private
+
+  def casify(cas)
+    case cas
+    when :missing then 0
+    when :clobber then -1
+    else cas
+    end
+  end
+
+end

data/lib/fraggle/proto.rb

@@ -0,0 +1,75 @@
+require 'beefcake'
+
+module Fraggle
+
+  class Request
+    include Beefcake::Message
+
+    required :tag, :int32, 1
+
+    module Verb
+      CHECKIN  = 0;  # cas, id          => cas
+      GET      = 1;  # path, id         => cas, value
+      SET      = 2;  # cas, path, value => cas
+      DEL      = 3;  # cas, path        => {}
+      ESET     = 4;  # cas, path        => {}
+      SNAP     = 5;  # {}               => seqn, id
+      DELSNAP  = 6;  # id               => {}
+      NOOP     = 7;  # {}               => {}
+      WATCH    = 8;  # path             => {cas, path, value}+
+      CANCEL   = 10; # id               => {}
+
+      # future
+      GETDIR   = 14; # path             => {cas, value}+
+      MONITOR  = 11; # path             => {cas, path, value}+
+      SYNCPATH = 12; # path             => cas, value
+      WALK     = 9;  # path, id         => {cas, path, value}+
+
+      # deprecated
+      JOIN     = 13;
+    end
+
+    required :verb, Verb, 2
+
+    optional :cas,   :int64,  3
+    optional :path,  :string, 4
+    optional :value, :bytes,  5
+    optional :id,    :int32,  6
+
+    optional :offset, :int32, 7
+    optional :limit,  :int32, 8
+
+  end
+
+
+  class Response
+    include Beefcake::Message
+
+    required :tag,   :int32, 1
+    required :flags, :int32, 2
+
+    optional :seqn,  :int64,  3
+    optional :cas,   :int64,  4
+    optional :path,  :string, 5
+    optional :value, :bytes,  6
+    optional :id,    :int32,  7
+
+    module Err
+      # don't use value 0
+      OTHER        = 127
+      TAG_IN_USE   = 1
+      UNKNOWN_VERB = 2
+      REDIRECT     = 3
+      INVALID_SNAP = 4
+      CAS_MISMATCH = 5
+
+      # match unix errno
+      NOTDIR       = 20
+      ISDIR        = 21
+    end
+
+    optional :err_code,   Err,     100
+    optional :err_detail, :string, 101
+  end
+
+end

data/test/core_test.rb

@@ -0,0 +1,215 @@
+require 'fraggle'
+
+##
+# This is used to test core functionality that the live integration tests will
+# rely on.
+class FakeConn
+  include Fraggle
+
+  attr_reader   :sent, :cbx
+  attr_accessor :tag
+
+  def initialize
+    @sent = ""
+    super("127.0.0.1", :assemble => false)
+    post_init
+  end
+
+  def send_data(data)
+    @sent << data
+  end
+end
+
+class CoreTest < Test::Unit::TestCase
+
+  attr_reader :c
+
+  V = Fraggle::Request::Verb
+  F = Fraggle::Response::Flag
+
+  def setup
+    @c = FakeConn.new
+  end
+
+  def reply(attrs={})
+    attrs[:tag] = c.tag
+    attrs[:flags] ||= 0
+    attrs[:flags] |= F::VALID
+    res = Fraggle::Response.new(attrs)
+    c.receive_response(res)
+    res
+  end
+
+  def reply!(attrs={})
+    attrs[:flags] = F::DONE
+    reply(attrs)
+  end
+
+  def test_sending_data
+    c.call(V::NOOP)
+
+    req = Fraggle::Request.new(
+      :tag   => c.tag,
+      :verb  => V::NOOP
+    )
+
+    buf = req.encode
+    pre = [buf.length].pack("N")
+
+    assert_equal pre+buf, c.sent
+  end
+
+  def test_receive_small_buffered_data
+    count = 0
+
+    tag = c.call(V::WATCH, :path => "**") do |e|
+      count += 1
+    end
+
+    res = Fraggle::Response.new(
+      :tag   => tag,
+      :flags => F::VALID
+    )
+
+    exp   = 10
+    buf   = res.encode
+    pre   = [buf.length].pack("N")
+    bytes = (pre+buf)*exp
+
+    # Chunk bytes to receive_data in some arbitrary size
+    0.step(bytes.length, 3) do |n|
+      c.receive_data(bytes.slice!(0, n))
+    end
+
+    assert_equal 10, count
+  end
+
+  def test_receive_large_buffered_data
+    count = 0
+
+    tag = c.call(V::WATCH, :path => "**") do |e|
+      count += 1
+    end
+
+    res = Fraggle::Response.new(
+      :tag   => tag,
+      :flags => F::VALID
+    )
+
+    exp   = 10
+    buf   = res.encode
+    pre   = [buf.length].pack("N")
+    bytes = (pre+buf)*exp
+
+    c.receive_data(bytes)
+
+    assert_equal 10, count
+  end
+
+  def test_callback_without_done
+    valid = lambda do |e|
+      assert_kind_of Fraggle::Response, e
+    end
+
+    done = lambda do |e|
+      assert false, "Unreachable"
+    end
+
+    tests = [valid, done]
+
+    c.call(V::NOOP) do |e|
+      tests.shift.call(e)
+    end
+    reply!
+
+    assert_equal 1, tests.length
+  end
+
+  def test_callback_with_done
+    valid = lambda do |e, done|
+      assert_kind_of Fraggle::Response, e
+      assert_equal false, done
+    end
+
+    done = lambda do |e, done|
+      assert_nil e
+      assert_equal true, done
+    end
+
+    tests = [valid, done]
+
+    c.call(V::NOOP) do |e, done|
+      tests.shift.call(e, done)
+    end
+
+    reply!
+    assert tests.empty?
+  end
+
+  def test_no_callback
+    c.call(V::NOOP)
+
+    assert_nothing_raised do
+      reply!
+    end
+  end
+
+  def test_no_callback_gc
+    c.call(V::NOOP)
+    reply!
+
+    assert ! c.cbx.has_key?(1)
+  end
+
+  def test_callback_gc
+    c.call(V::NOOP) {}
+    reply
+
+    assert c.cbx.has_key?(c.tag)
+
+    reply!
+
+    assert ! c.cbx.has_key?(c.tag)
+  end
+
+  def test_call_returns_tag
+    assert_equal 0, c.call(V::NOOP)
+    assert_equal 1, c.call(V::NOOP)
+  end
+
+  def test_call_increments_tag
+    c.call(V::NOOP)
+    assert_equal 0, c.tag
+    c.call(V::NOOP)
+    assert_equal 1, c.tag
+    c.call(V::NOOP)
+    assert_equal 2, c.tag
+    c.call(V::NOOP)
+    assert_equal 3, c.tag
+    c.call(V::NOOP)
+    assert_equal 4, c.tag
+    c.call(V::NOOP)
+    assert_equal 5, c.tag
+    c.call(V::NOOP)
+    assert_equal 6, c.tag
+    c.call(V::NOOP)
+    assert_equal 7, c.tag
+    c.call(V::NOOP)
+    assert_equal 8, c.tag
+    c.call(V::NOOP)
+    assert_equal 9, c.tag
+  end
+
+  def test_no_overlap_in_tags
+    c.cbx[0] = Proc.new {}
+    assert_equal 1, c.call(V::NOOP)
+  end
+
+  def test_rollover_tag_when_maxed_out
+    c.tag = Fraggle::MaxInt32
+    c.call(V::NOOP)
+
+    assert_equal  Fraggle::MinInt32, c.tag
+  end
+
+end

data/test/live_test.rb

@@ -0,0 +1,197 @@
+require 'fraggle'
+
+class LiveTest < Test::Unit::TestCase
+  def start(timeout=1, &blk)
+    EM.run do
+      if timeout > 0
+        EM.add_timer(timeout) { fail "Test timeout!" }
+      end
+
+      c = Fraggle.connect(
+        "127.0.0.1:8046",
+        :assemble => false
+      )
+
+      blk.call(c)
+    end
+  end
+
+  def stop
+    EM.stop
+  end
+
+  def test_get
+    start do |c|
+      c.get "/ping" do |e|
+        assert e.ok?, e.err_detail
+        assert e.cas > 0
+        assert_equal "pong", e.value
+        stop
+      end
+    end
+  end
+
+  def test_set
+    start do |c|
+      c.set "/test-set", "a", :clobber do |ea|
+        assert ea.ok?, ea.err_detail
+        assert ea.cas > 0
+        assert_nil ea.value
+
+        c.get "/test-set" do |eb|
+          assert eb.ok?, eb.err_detail
+          assert_equal "a", eb.value
+          stop
+        end
+      end
+    end
+  end
+
+  def test_del
+    start do |c|
+      c.set "/test-del", "a", :clobber do |e|
+        assert e.ok?, e.err_detail
+
+        c.del("/test-del", e.cas) do |de|
+          assert de.ok?, de.err_detail
+          stop
+        end
+      end
+    end
+  end
+
+  def test_error
+    start do |c|
+      c.set "/test-error", "a", :clobber do |ea|
+        assert ! ea.mismatch?
+        assert ea.ok?, ea.err_detail
+        c.set "/test-error", "b", :missing do |eb|
+          assert eb.mismatch?, eb.err_detail
+          stop
+        end
+      end
+    end
+  end
+
+  def test_watch
+    start do |c|
+      count = 0
+      c.watch("/**") do |e|
+        assert e.ok?, e.err_detail
+
+        count += 1
+        if count == 9
+          stop
+        end
+      end
+
+      10.times do
+        EM.next_tick { c.set("/test-watch", "something", :clobber) }
+      end
+    end
+  end
+
+  def test_snap
+    start do |c|
+      c.set "/test-snap", "a", :clobber do |e|
+        assert e.ok?, e.err_detail
+
+        c.snap do |se|
+          assert se.ok?, se.err_detail
+          assert_not_equal 0, se.id
+
+          c.set "/test-snap", "b", :clobber do |e|
+            assert e.ok?, e.err_detail
+
+            c.get "/test-snap", se.id do |ge|
+              assert ge.ok?, ge.err_detail
+              assert_equal "a", ge.value
+              stop
+            end
+          end
+        end
+      end
+    end
+  end
+
+  # TODO:  ???  Shouldn't a deleted snapid produce an error on read?
+  def test_delsnap
+    start do |c|
+      c.snap do |se|
+        assert se.ok?, se.err_detail
+        assert_not_equal 0, se.id
+
+
+        c.delsnap se.id do |de|
+          assert de.ok?, de.err_detail
+
+          c.get "/ping", se.id do |ge|
+            assert ! ge.ok?, ge.err_detail
+            stop
+          end
+        end
+      end
+    end
+  end
+
+  def test_noop
+    start do |c|
+      c.noop do |e|
+        assert e.ok?, e.err_detail
+        stop
+      end
+    end
+  end
+
+  def test_cancel
+    start do |c|
+      tag = c.watch("/test-cancel") do |e, done|
+        if ! done
+          assert e.ok?, e.err_detail
+        end
+
+        if done
+          stop
+        end
+
+        c.cancel(tag)
+      end
+
+      c.set("/test-cancel", "a", :clobber)
+    end
+  end
+
+  def test_walk
+    start do |c|
+
+      exp = [
+        ["/test-walk/1", "a"],
+        ["/test-walk/2", "b"],
+        ["/test-walk/3", "c"]
+      ]
+
+      n = exp.length
+
+      exp.each do |path, val|
+        c.set path, val, :clobber do |e|
+          assert e.ok?, e.err_detail
+          n -= 1
+
+          if n == 0
+            items = []
+            c.walk "/test-walk/*" do |e, done|
+              if done
+                assert_equal exp, items
+                stop
+              else
+                items << [e.path, e.value]
+              end
+            end
+          end
+        end
+      end
+
+    end
+  end
+
+end

data/test/reconnect_test.rb

@@ -0,0 +1,175 @@
+require 'fraggle'
+
+class RecConn
+  include Fraggle
+
+  attr_reader :store, :recs
+
+  def initialize
+    super("1:1", :assemble => true)
+    post_init
+    @store = {}
+    @recs  = []
+  end
+
+  def get(path, sid=0, &blk)
+    res = store.fetch(path) { fail("testing: no slot for #{path}") }
+    blk.call(res)
+  end
+
+  def reconnect(host, port)
+    @recs << [host, port]
+  end
+
+  def send_data(data)
+    # do nothing
+  end
+end
+
+class ReconnectTest < Test::Unit::TestCase
+
+  Walk  = 0
+  Watch = 1
+
+  attr_reader :c
+
+  def setup
+    @c = RecConn.new
+  end
+
+  def reply(to, path, value)
+    res = Fraggle::Response.new
+    res.tag   = to
+    res.flags = Fraggle::Response::Flag::VALID
+    res.path  = path
+    res.value = value
+    res.validate!
+
+    c.receive_response(res)
+  end
+
+  def set(path, value)
+    res = Fraggle::Response.new
+    res.tag   = 123
+    res.flags = Fraggle::Response::Flag::VALID
+    res.value = value
+    res.validate!
+
+    c.store[path] = res
+  end
+
+  def test_ignore_current
+    assert_equal Hash.new, c.doozers
+
+    set "/doozer/info/ABC/public-addr", "1:1"
+    reply(Walk, "/doozer/slot/1", "ABC")
+
+    assert_equal Hash.new, c.doozers
+  end
+
+  def test_add_other_slots_at_start
+    set "/doozer/info/DEF/public-addr", "2:2"
+    set "/doozer/info/GHI/public-addr", "3:3"
+    reply(Walk, "/doozer/slot/2", "DEF")
+    reply(Walk, "/doozer/slot/3", "GHI")
+
+    exp = {
+      "/doozer/slot/2" => "2:2",
+      "/doozer/slot/3" => "3:3"
+    }
+
+    assert_equal exp, c.doozers
+  end
+
+  def test_add_new_slots_as_they_come
+    set "/doozer/info/DEF/public-addr", "2:2"
+    set "/doozer/info/GHI/public-addr", "3:3"
+    reply(Watch, "/doozer/slot/2", "DEF")
+    reply(Watch, "/doozer/slot/3", "GHI")
+
+    exp = {
+      "/doozer/slot/2" => "2:2",
+      "/doozer/slot/3" => "3:3"
+    }
+
+    assert_equal exp, c.doozers
+  end
+
+  def test_del_slots_if_they_emptied
+    set "/doozer/info/DEF/public-addr", "2:2"
+    set "/doozer/info/GHI/public-addr", "3:3"
+    reply(Walk, "/doozer/slot/2", "DEF")
+    reply(Walk, "/doozer/slot/3", "GHI")
+
+    # Del
+    reply(Watch, "/doozer/slot/3", "")
+
+    exp = {
+      "/doozer/slot/2" => "2:2"
+    }
+
+    assert_equal exp, c.doozers
+  end
+
+  def test_raise_error_if_given_by_server
+    res = Fraggle::Response.new
+    res.tag        = Walk
+    res.flags      = Fraggle::Response::Flag::VALID
+    res.err_code   = Fraggle::Response::Err::OTHER
+    res.err_detail = "invalid glob"
+
+    assert_raises Fraggle::AssemblyError do
+      c.receive_response(res)
+    end
+  end
+
+  def test_out_of_doozers
+    assert_raises Fraggle::AssemblyError do
+      c.unbind
+    end
+  end
+
+  def test_first_reconnect_success
+    set "/doozer/info/DEF/public-addr", "2:2"
+    set "/doozer/info/GHI/public-addr", "3:3"
+    reply(Walk, "/doozer/slot/2", "DEF")
+    reply(Walk, "/doozer/slot/3", "GHI")
+
+    c.unbind
+    assert_equal 1, c.recs.length
+
+    # The order in which the client try is non-detrministic because we're
+    # shifting off a Hash.
+    assert ["2:2", "3:3"].include?(c.addr)
+  end
+
+  def test_second_reconnect_success
+    set "/doozer/info/DEF/public-addr", "2:2"
+    set "/doozer/info/GHI/public-addr", "3:3"
+    reply(Walk, "/doozer/slot/2", "DEF")
+    reply(Walk, "/doozer/slot/3", "GHI")
+
+    c.unbind
+    c.unbind
+    assert_equal 2, c.recs.length
+
+    # The order in which the client try is non-detrministic because we're
+    # shifting off a Hash.
+    assert ["2:2", "3:3"].include?(c.addr)
+  end
+
+  def test_all_recconcts_fail
+    set "/doozer/info/DEF/public-addr", "2:2"
+    set "/doozer/info/GHI/public-addr", "3:3"
+    reply(Walk, "/doozer/slot/2", "DEF")
+    reply(Walk, "/doozer/slot/3", "GHI")
+
+    c.unbind
+    c.unbind
+
+    assert_raises Fraggle::AssemblyError do
+      c.unbind
+    end
+  end
+
+end

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification 
+name: fraggle
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Blake Mizerany
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-01-25 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: beefcake
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 1
+        - 1
+        version: 0.1.1
+  type: :runtime
+  version_requirements: *id001
+description: A Ruby/EventMachine Client for Doozer
+email: 
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.md
+- LICENSE
+files: 
+- LICENSE
+- README.md
+- lib/fraggle/proto.rb
+- lib/fraggle.rb
+- test/core_test.rb
+- test/live_test.rb
+- test/reconnect_test.rb
+has_rdoc: true
+homepage: http://github.com/bmizerany/fraggle
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --line-numbers
+- --inline-source
+- --title
+- Sinatra
+- --main
+- README.rdoc
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: fraggle
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 2
+summary: A Ruby/EventMachine Client for Doozer
+test_files: 
+- test/core_test.rb
+- test/live_test.rb
+- test/reconnect_test.rb