fraggle 1.0.0pre → 1.0.0.pre.2

data/README.md

@@ -1,9 +1,9 @@
-# Fraggle
+# Fraggle (v1.0.0.pre.2 is compatable with Doozer 0.5)
 **An EventMachine based Doozer client**
 
 ## Install
 
-    $ gem install fraggle
+    $ gem install fraggle --pre
 
 ## Use
 
@@ -14,15 +14,13 @@
     EM.start do
       # Fraggle keeps track of this addr plus all others it finds once
       # connected.  In the event of a lost connection, fraggle will attempt
-      # other doozers until one accepts or it runs out of options; An
-      # AssemlyError will be raised if that later happens.
+      # other doozers until one accepts or it runs out of options; A NoAddrs
+      # exception will be raised if that later happens.
       c = Fraggle.connect "doozerd://127.0.0.1:8046"
 
-      req = c.get "/foo" do |e|
+      req = c.get("/foo") do |e|
         e.value   # => "bar"
-        e.cas     # => "123"
-        e.dir?    # => false
-        e.notdir? # => true
+        e.rev     # => 123
       end
 
       req.error do |e|
@@ -30,18 +28,14 @@
         e.err_detail # => nil
       end
 
-      watch = c.watch "/foo" do |e|
+      watch = c.watch("/foo") do |e|
         # The event has:
         # ------------------------
         e.err_code   # => nil
         e.err_detail # => nil
         e.path       # => "/foo"
         e.value      # => "bar"
-        e.cas        # => "123"
-        e.dir?       # => false
-        e.notdir?    # => true
-        e.set?       # => true
-        e.del?       # => false
+        e.rev        # => 123
 
         do_something_with(e)
 
@@ -52,43 +46,84 @@
       end
 
       ## Setting a key (this will trigger the watch above)
-      req = c.set "/foo", "zomg!", :missing do |e|
-        case true
-        when e.mismatch? # CAS mis-match
-          # retry if we must
-        when e.ok?
-          e.cas # => "123"
+      req = c.set(0, "/foo", "zomg!") do |e|
+        # Success!
+      end.error do |e|
+        if e.mismatch?
+          # There was a rev mismatch, handle this.
         else
           raise e.err_detail
         end
       end
 
-      req.error do |e|
-        # This is the default behavior for fraggle.
-        # I'm showing this to bring attention to the use of the
-        # error callback.
-        raise e.err_detail
-      end
-
       # Knowning when a command is done is useful in some cases.
       # Use the `done` callback for those situations.
       ents = []
       req = c.getdir("/test") do |e|
         ents << e
-      end
-
-      req.done do
+      end.done do
         p ents
       end
 
     end
 
+## Consistency
+
+Fraggle read commands take a `rev`.  If no rev is given, Doozer will reply with
+the most up-to-date data.   If you need to do multiple reads at certain
+point in time for consistency, use the `rev` command.
+
+    c.rev do |v|
+      c.get("/a", v.rev) { ... }
+      c.get("/b", v.rev) { ... }
+      c.get("/c", v.rev) { ... }
+    end
+
+This also means you can go back in time or into the future!
+
+    # This will not yield until the data store is at revision 100,000
+    c.get("/a", 100_000) { ... }
+
+## High Availability
+
+  Fraggle has mechanisms to gracefully deal with connection loss.  They are:
+
+*Monitoring cluster activity*
+
+  Fraggle monitors new Doozer nodes that come and go.  This enables Fraggle to
+  keep an up-to-date list of available nodes it can connect to in the case of
+  a connection loss.
+
+*Resend / Connection loss*
+
+  When a connection is lost and Fraggle successfully reconnects to another
+  Doozer node, Fraggle will resend most pending requests to the new connection.
+  This means you will not miss events; Even events that happened while you were
+  disconnected!  All read commands will pick up where they left off.  This is
+  valuable to understand because it means you don't need to code for failure on
+  reads; Fraggle gracefully handles it for you.  This is really important for
+  the `WATCH` command.
+
+  Write commands will be resent if their `rev` is greater than 0.  These are
+  idempotent requests.  A rev of 0 or less will cause that request's error
+  callback to be invoked with a Fraggle::Connection::Disconnected response.
+  You will have to handle these yourself because Fraggle cannot know whether or
+  not it's safe to retry on your behalf.
+
+  For commands with multiple responses (i.e. `walk`, `watch`, `getdir`), Fraggle
+  will update their offset and limit as each response comes in.  This means
+  if you disconnect in the middle of the responses, Fraggle will gracefully
+  resend the requests making it appear nothing happened and continue giving you
+  the remaining responses.
 
 ## Dev
 
 **Clone**
+
     $ git clone http://github.com/bmizerany/fraggle.git
 
 **Test**
+
     $ gem install turn
+
     $ turn

data/example/addrs.rb

@@ -0,0 +1,13 @@
+require 'rubygems'
+require 'eventmachine'
+require 'fraggle'
+# This is for testing Fraggle's monitoring of addresses in a cluster.
+
+EM.run do
+  c = Fraggle.connect "doozer:?ca=127.0.0.1:8041"
+  c.log.level = Logger::DEBUG
+
+  EM.add_periodic_timer(1) do
+    p [:addrs, c.addr, c.addrs]
+  end
+end

data/example/getdir.rb

@@ -4,21 +4,16 @@ require 'fraggle'
 
 EM.run do
 
-  EM.error_handler do |e|
-    $stderr.puts e.message + "\n" + (e.backtrace * "\n")
-  end
-
   c = Fraggle.connect
-  c.level = Fraggle::Logger::INFO
+  c.log.level = Logger::DEBUG
 
   ents = []
-  req = c.getdir "/doozer" do |e|
+  c.getdir("/") do |e|
     ents << e.path
+  end.done do
+    p [:ents, ents]
+  end.error do |e|
+    raise StandardError.new("err: "+e.inspect)
   end
 
-  req.error do
-    puts *ents
-  end
-
-
 end

data/example/redirect.rb

@@ -0,0 +1,28 @@
+require 'rubygems'
+require 'fraggle'
+
+# This example assumes you have a Doozer with CAL privledges listening on port
+# 8041 and a Doozer sink listening on 8042.  This example will connect to the
+# sink and attempt a write operation that will be redirected by the sink.
+# Fraggle will pick the only remaining addr it has which is the CAL Doozer and
+# retry the write operation.
+
+EM.run do
+  # Connect to a slave (be sure this is a slave)
+  c = Fraggle.connect("doozer:?ca=127.0.0.1:8042&ca=127.0.0.1:8041")
+  c.log.level = Logger::DEBUG
+
+  a = c.set("/foo", "bar", -1) do |e|
+    # This shouldn't happen
+    p [:valid, a, e]
+  end.error do |e|
+    p [:err, a, e]
+  end
+
+  b = c.set("/foo", "bar", 1) do |e|
+    p [:valid, b, e]
+  end.error do |e|
+    # This shouldn't happen
+    p [:err, b, e]
+  end
+end

data/example/resend.rb

@@ -0,0 +1,25 @@
+require 'rubygems'
+require 'fraggle'
+
+###
+# To see this example in action, run 1 doozerd and attach 2
+# more to it before running.
+#
+# NOTE: If you have the doozerd source, you can run ./bin/test-cluster
+#
+EM.run do
+  c = Fraggle.connect
+
+  puts "# To see this work, kill the doozer this is connected to"
+  puts "# to see it resend the request to the next connection."
+  puts
+
+  # Wait for rev 100,000
+  c.get(100_000, "/foo") do |e|
+    p ["This should not be!", e]
+  end.error do |e|
+    p [:err, e]
+  end.done do
+    p [:done, "This should not be!"]
+  end
+end

data/example/{ping.rb → rev.rb}

@@ -4,15 +4,11 @@ require 'fraggle'
 
 EM.run do
 
-  EM.error_handler do |e|
-    $stderr.puts e.message + "\n" + (e.backtrace * "\n")
-  end
-
   c = Fraggle.connect
 
   EM.add_periodic_timer(1) do
-    c.get nil, "/ping" do |e|
-      p [:e, e]
+    c.rev do |e|
+      p [:rev, e.rev]
     end
   end
 

data/example/set.rb

@@ -3,19 +3,15 @@ require 'eventmachine'
 require 'fraggle'
 
 EM.run do
-  EM.error_handler do |e|
-    $stderr.puts e.message + "\n" + (e.backtrace * "\n")
-  end
-
   c = Fraggle.connect
 
   EM.add_periodic_timer(1) do
-    c.get "/hello" do |e|
+    c.get("/hello") do |e|
       p [:e, e]
     end
   end
 
-  c.set '/hello', 'world', :missing do |e|
+  c.set('/hello', 'world', 0) do |e|
     p e
   end
 end

data/example/stat.rb

@@ -3,21 +3,17 @@ require 'eventmachine'
 require 'fraggle'
 
 EM.run do
-
-  EM.error_handler do |e|
-    $stderr.puts e.message + "\n" + (e.backtrace * "\n")
-  end
-
   c = Fraggle.connect
 
   EM.add_periodic_timer(1) do
-    c.stat "/example" do |e|
+    c.stat("/example") do |e|
       p e
+    end.error do |e|
+      p [:err, e]
     end
   end
 
   EM.add_periodic_timer(0.5) do
-    c.set "/example/#{rand(10)}", "test", :clobber
+    c.set("/example/#{rand(10)}", "test", -1)
   end
-
 end

data/example/walk.rb

@@ -3,21 +3,27 @@ require 'eventmachine'
 require 'fraggle'
 
 EM.run do
-
-  EM.error_handler do |e|
-    $stderr.puts e.message + "\n" + (e.backtrace * "\n")
-  end
-
   c = Fraggle.connect
 
   paths = []
-  req = c.walk "/**" do |e|
+
+  req = c.walk("/**", 1)
+
+  valid = Proc.new do |e|
     paths << e.path+"="+e.value
   end
 
-  req.done do
+  done = Proc.new do
+    puts "rev #{req.rev} " + ("-"*25)
     puts *paths
-  end
 
+    paths.clear
+
+    req = c.walk("/**", req.rev+1)
+    req.valid(&valid)
+    req.done(&done)
+  end
 
+  req.valid(&valid)
+  req.done(&done)
 end

data/example/watch.rb

@@ -4,19 +4,17 @@ require 'fraggle'
 
 EM.run do
 
-  EM.error_handler do |e|
-    $stderr.puts e.message + "\n" + (e.backtrace * "\n")
-  end
-
   c = Fraggle.connect
-  c.level = Fraggle::Logger::WARN
+  c.log.level = Logger::DEBUG
 
-  c.watch "/example/*" do |e|
+  c.watch("/example/*") do |e|
     p e
+  end.error do |e|
+    p [:err, e]
   end
 
   EM.add_periodic_timer(0.5) do
-    c.set "/example/#{rand(10)}", "test", :clobber
+    c.set("/example/#{rand(10)}", "test", -1)
   end
 
 end

data/fraggle.gemspec

@@ -20,6 +20,7 @@ Gem::Specification.new do |s|
   s.require_paths = ["lib"]
 
   s.add_dependency "beefcake", "~>0.3"
+  s.add_dependency "eventmachine"
 
   s.add_development_dependency "turn"
 end

data/lib/fraggle.rb

@@ -2,7 +2,7 @@ require 'fraggle/client'
 
 module Fraggle
 
-  DEFAULT_URI = "doozerd:?" + [
+  DEFAULT_URI = "doozer:?" + [
     "ca=127.0.0.1:8046",
     "ca=127.0.0.1:8041",
     "ca=127.0.0.1:8042",
@@ -26,7 +26,7 @@ module Fraggle
   end
 
   def self.uri(u)
-    if u =~ /^doozerd:\?(.*)$/
+    if u =~ /^doozer:\?(.*)$/
       parts = $1.split("&")
       parts.inject([]) do |m, pt|
         k, v = pt.split("=")
@@ -36,7 +36,7 @@ module Fraggle
         m
       end
     else
-      raise ArgumentError, "invalid doozerd uri"
+      raise ArgumentError, "invalid doozer uri"
     end
   end
 

data/lib/fraggle/client.rb

@@ -1,5 +1,6 @@
 require 'eventmachine'
 require 'fraggle/connection'
+require 'logger'
 
 module Fraggle
   class Client
@@ -8,13 +9,21 @@ module Fraggle
     class NoMoreAddrs < StandardError
     end
 
-    attr_reader :cn
+    DefaultLog = Logger.new(STDERR)
+    DefaultLog.level = Logger::UNKNOWN
 
-    def initialize(cn, addrs)
-      @cn, @addrs = cn, addrs
+    attr_reader :cn, :log, :addrs
+
+    def initialize(cn, addrs, log=DefaultLog)
+      @cn, @addrs, @log = cn, addrs, log
+      monitor_addrs
+    end
+
+    def addr
+      cn.addr
     end
 
-    def set(rev, path, value, &blk)
+    def set(path, value, rev, &blk)
       req = Request.new
       req.verb  = SET
       req.rev   = rev
@@ -22,61 +31,69 @@ module Fraggle
       req.value = value
       req.valid(&blk)
 
-      send(req)
+      idemp(req)
     end
 
-    def get(rev, path, &blk)
+    def get(path, rev=nil, &blk)
       req = Request.new
       req.verb = GET
       req.rev  = rev
       req.path = path
       req.valid(&blk)
 
-      send(req)
+      resend(req)
     end
 
-    def del(rev, path, &blk)
+    def del(path, rev, &blk)
       req = Request.new
       req.verb = DEL
       req.rev  = rev
       req.path = path
       req.valid(&blk)
 
-      send(req)
+      idemp(req)
     end
 
-    def getdir(rev, path, offset=nil, limit=nil, &blk)
+    def getdir(path, rev=nil, offset=nil, limit=nil, &blk)
       req = Request.new
       req.verb = GETDIR
       req.rev  = rev
       req.path = path
-      req.offset = offset
+
+      # To reliably pick-up where we left off in the event of a disconnect, we
+      # must default the offset to zero.  This is best done here and not in the
+      # param declaration because the user could override it to nil there.
+      req.offset = offset || 0
       req.limit  = limit
       req.valid(&blk)
 
-      send(req)
+      resend(req)
     end
 
-    def walk(rev, path, offset=nil, limit=nil, &blk)
+    def walk(path, rev=nil, offset=nil, limit=nil, &blk)
       req = Request.new
       req.verb = WALK
       req.rev  = rev
       req.path = path
-      req.offset = offset
+
+      # To reliably pick-up where we left off in the event of a disconnect, we
+      # must default the offset to zero.  This is best done here and not in the
+      # param declaration because the user could override it to nil there.
+      req.offset = offset || 0
       req.limit  = limit
       req.valid(&blk)
 
-      send(req)
+      resend(req)
     end
 
-    def watch(rev, path, &blk)
+    def watch(path, rev=nil, &blk)
       req = Request.new
       req.verb = WATCH
       req.rev  = rev
       req.path = path
       req.valid(&blk)
 
-      send(req)
+      resend(req)
     end
 
     def rev(&blk)
@@ -84,16 +101,65 @@ module Fraggle
       req.verb = REV
       req.valid(&blk)
 
-      send(req)
+      resend(req)
+    end
+
+    def stat(path, rev=nil, &blk)
+      req = Request.new
+      req.rev  = rev
+      req.verb = STAT
+      req.path = path
+      req.valid(&blk)
+
+      resend(req)
+    end
+
+    def monitor_addrs
+      log.debug("monitor addrs")
+      rev do |v|
+        walk("/ctl/cal/*", v.rev) do |e|
+          get("/ctl/node/#{e.value}/addr", v.rev) do |a|
+            if a.value != ""
+              add_addr(a.value)
+            end
+          end
+        end.done do
+          watch("/ctl/cal/*", v.rev+1) do |e|
+            if e.value == ""
+              ## Look to see what it was before
+              get(e.path, e.rev-1) do |b|
+                if b.rev > 0
+                  # The node was cleared.  Delete it from the list of addrs.
+                  log.debug("del addr: #{addr}")
+                  @addrs.delete(b.value)
+                end
+              end
+            else
+              get("/ctl/node/#{e.value}/addr", e.rev) do |b|
+                add_addr(b.value)
+              end
+            end
+          end
+        end
+      end
+    end
+
+    def add_addr(s)
+      return if s == self.addr
+      return if @addrs.include?(s)
+      log.debug("add addr: #{s}")
+      @addrs << s
     end
 
+    # Sends a request to the server.  Returns the request with a new tag
+    # assigned. If `onre` is supplied, it will be invoked when a new connection
+    # is established
     def send(req, &onre)
       wr = Request.new(req.to_hash)
-      wr = cn.send_request(wr)
-
-      req.tag = wr.tag
 
       wr.valid do |e|
+        log.debug("response: #{e.inspect} for #{req.inspect}")
+
         if req.offset
           req.offset += 1
         end
@@ -103,36 +169,84 @@ module Fraggle
         end
 
         if (req.rev || 0) < (e.rev || 0)
+          log.debug("updating rev: to #{e.rev} - #{req.inspect}")
           req.rev = e.rev
         end
 
         req.emit(:valid, e)
       end
 
-      wr.done  do
+      wr.done do
         req.emit(:done)
       end
 
       wr.error do |e|
         case true
-        when cn.err? || e.redirect?
-          reconnect!
-          onre.call if onre
+        when e.disconnected?
+          # If we haven't already reconnected, do so.
+          if cn.err?
+            log.error("conn err: #{req.inspect}")
+            reconnect!
+          end
+
+          if onre
+            # Someone else will handle this
+            onre.call
+          else
+            req.emit(:error, e)
+          end
+        when e.redirect?
+
+          log.error("redirect: #{req.inspect}")
+
+          # Closing the connection triggers a reconnect above.
+          cn.close_connection
+
+          if onre
+            # Someone else will handle this
+            onre.call
+          else
+            req.emit(:error, Connection::Disconnected)
+          end
         else
+          log.error("error: #{e.inspect} for #{req.inspect}")
           req.emit(:error, e)
         end
+
       end
 
+      wr = cn.send_request(wr)
+      req.tag = wr.tag
+      log.debug("sending: #{req.inspect}")
+
       req
     end
 
     def resend(req)
       send(req) do
         req.tag = nil
+        log.debug("resending: #{req.inspect}")
         resend(req)
       end
     end
 
+    def idemp(req)
+      send(req) do
+        if req.rev > 0
+          # If we're trying to update a value that isn't missing or that we're
+          # not trying to clobber, it's safe to retry.  We can't idempotently
+          # update missing values because there may be a race with another
+          # client that sets and/or deletes the key during the time between your
+          # read and write.
+          req.tag = nil
+          idemp(req)
+        else
+          # We can't safely retry the write.  Inform the user.
+          req.emit(:error, Connection::Disconnected)
+        end
+      end
+    end
+
     def reconnect!
       if addr = @addrs.shift
         reconnect(addr)
@@ -142,8 +256,9 @@ module Fraggle
     end
 
     def reconnect(addr)
+      log.warn("reconnecting to #{addr}")
       host, port = addr.split(":")
-      @cn = EM.connect(host, port, Fraggle::Connection, @addrs)
+      @cn = EM.connect(host, port, Fraggle::Connection, addr)
     end
 
   end

data/lib/fraggle/connection.rb

@@ -5,6 +5,9 @@ module Fraggle
 
   module Connection
 
+    Disconnected = Response.new
+    Disconnected.disconnected = true
+
     # Base class for all Connection errors
     class Error < StandardError
       attr_accessor :req
@@ -23,6 +26,7 @@ module Fraggle
     attr_reader :last_received, :addr
 
     def initialize(addr)
+      p [:init, addr]
       @addr, @cb = addr, {}
     end
 
@@ -48,6 +52,10 @@ module Fraggle
 
     # The default receive_response
     def receive_response(res)
+      if err?
+        return
+      end
+
       req = @cb[res.tag]
 
       if ! req
@@ -60,14 +68,14 @@ module Fraggle
         return
       end
 
+      if res.valid?
+        req.emit(:valid, res)
+      end
+
       if res.done?
         @cb.delete(req.tag)
         req.emit(:done)
       end
-
-      if res.valid?
-        req.emit(:valid, res)
-      end
     end
 
     def send_request(req)
@@ -76,7 +84,7 @@ module Fraggle
       end
 
       if err?
-        next_tick { req.emit(:error, nil) }
+        next_tick { req.emit(:error, Disconnected) }
         return req
       end
 
@@ -118,7 +126,7 @@ module Fraggle
     def unbind
       @err = true
       @cb.values.each do |req|
-        req.emit(:error, nil)
+        req.emit(:error, Disconnected)
       end
     end
 

data/lib/fraggle/request.rb

@@ -3,12 +3,14 @@ require 'fraggle/msg.pb'
 module Fraggle
   class Request
 
+    DEFAULT_PROC = Proc.new {}
+
     attr_accessor :cn
     attr_reader   :cb
 
     def initialize(attrs={})
       super(attrs)
-      @cb = Hash.new(Proc.new{})
+      @cb = Hash.new
     end
 
     def valid(&blk)
@@ -27,7 +29,7 @@ module Fraggle
     end
 
     def emit(name, *args)
-      @cb[name].call(*args)
+      (@cb[name] || DEFAULT_PROC).call(*args)
     end
 
     def cancel

data/lib/fraggle/response.rb

@@ -6,6 +6,8 @@ module Fraggle
     VALID = 1
     DONE  = 2
 
+    attr_accessor :disconnected
+
     def valid?
       return false if !flags
       (flags & VALID) > 0
@@ -24,5 +26,9 @@ module Fraggle
       err_code == Err::REDIRECT
     end
 
+    def disconnected?
+      !!@disconnected
+    end
+
   end
 end

data/lib/fraggle/version.rb

@@ -1,3 +1,3 @@
 module Fraggle
-  VERSION = "1.0.0pre"
+  VERSION = "1.0.0.pre.2"
 end

data/test/fraggle_client_test.rb

@@ -10,11 +10,17 @@ class FraggleClientTest < Test::Unit::TestCase
     cn   = TestConn.new(addr)
 
     @addrs  = ["1.1.1.1:1", "2.2.2.2:2", "3.3.3.3:3"]
-    @c      = Fraggle::Client.new(cn, @addrs)
+    @c      = Fraggle::Client.allocate
 
     def @c.reconnect(addr)
       @cn = TestConn.new(addr)
     end
+
+    def @c.monitor_addrs
+      # do nothing
+    end
+
+    @c.__send__(:initialize, cn, @addrs)
   end
 
   def test_send_valid_done
@@ -29,6 +35,24 @@ class FraggleClientTest < Test::Unit::TestCase
     assert_equal [], log.error
   end
 
+  def test_send_valid_called_before_done
+    req, _ = request(V::NOP)
+    req = c.send(req)
+
+    log = []
+    req.valid do
+      log << :valid
+    end
+    req.done do
+      log << :done
+    end
+
+    res = Fraggle::Response.new :tag => req.tag, :value => "ing", :flags => F::VALID|F::DONE
+    c.cn.receive_response(res)
+
+    assert_equal [:valid, :done], log
+  end
+
   def test_send_error
     req, log = request(V::NOP)
     req = c.send(req)
@@ -57,7 +81,7 @@ class FraggleClientTest < Test::Unit::TestCase
     assert exp.include?(c.cn.addr), "#{c.cn.addr.inspect} not in #{exp.inspect}"
 
     # If the client can handle an error, it should not mention it to the user.
-    assert_equal [], log.error
+    assert_equal [Fraggle::Connection::Disconnected], log.error
   end
 
   def test_reconnect_with_pending_request
@@ -75,11 +99,35 @@ class FraggleClientTest < Test::Unit::TestCase
 
     assert exp.include?(c.cn.addr), "#{c.cn.addr.inspect} not in #{exp.inspect}"
 
+    assert_equal [Fraggle::Connection::Disconnected], log.error
+  end
+
+  def test_reconnect_with_multiple_pending_requests
+    exp = @addrs.dup
+
+    # Send a request to invoke reconnect
+    req, loga = request(V::NOP)
+    req = c.send(req)
+
+    req, logb = request(V::NOP)
+    req = c.send(req)
+
+    # Disconnect from 127.0.0.1:0
+    c.cn.close_connection
+
+    # Fake reactor turn (only available in tests)
+    c.cn.tick!
+
+    assert exp.include?(c.cn.addr), "#{c.cn.addr.inspect} not in #{exp.inspect}"
+
+    # Reconnect should only be called once.
+    assert_equal exp.length - 1, c.addrs.length
+
     # If the client can handle an error, it should not mention it to the user.
-    assert_equal [], log.error
+    assert_equal [Fraggle::Connection::Disconnected], loga.error
+    assert_equal [Fraggle::Connection::Disconnected], logb.error
   end
 
-  # retry
   def test_resend_pending_requests
     req, log = request(V::GET, :path => "/foo")
     req = c.resend(req)
@@ -89,6 +137,24 @@ class FraggleClientTest < Test::Unit::TestCase
     assert_equal [req], c.cn.sent
   end
 
+  def test_idemp_pending_requests
+    one, olog = request(V::SET, :rev => 1, :path => "/foo", :value => "bar")
+    one = c.idemp(one)
+
+    zero, zlog = request(V::SET, :rev => 0, :path => "/foo", :value => "bar")
+    zero = c.idemp(zero)
+
+    neg, nlog = request(V::SET, :rev => -1, :path => "/foo", :value => "bar")
+    zero = c.idemp(neg)
+
+    c.cn.close_connection
+
+    assert_equal [one], c.cn.sent
+
+    assert_equal [Fraggle::Connection::Disconnected], zlog.error
+    assert_equal [Fraggle::Connection::Disconnected], nlog.error
+  end
+
   def test_manage_offset
     req, log = request(V::WALK, :path => "/foo/*", :offset => 3)
     req = c.resend(req)
@@ -148,12 +214,15 @@ class FraggleClientTest < Test::Unit::TestCase
     assert_equal [exp], c.cn.sent
   end
 
-  def test_redirect
-    req, log = request(V::SET, :rev => 0, :path => "/foo", :value => "bar")
-    req = c.send(req)
+  def test_redirect_simple
+    a, al = request(V::SET, :rev => 0, :path => "/foo")
+    a = c.send(a)
+
+    b, bl = request(V::SET, :rev => 0, :path => "/foo")
+    b = c.send(b)
 
     res = Fraggle::Response.new(
-      :tag => req.tag,
+      :tag => a.tag,
       :err_code => E::REDIRECT,
       :err_detail => "9.9.9.9:9",
       :flags => F::VALID|F::DONE
@@ -162,8 +231,11 @@ class FraggleClientTest < Test::Unit::TestCase
     c.cn.receive_response(res)
 
     assert_equal "1.1.1.1:1", c.cn.addr
-  end
+    assert_equal ["2.2.2.2:2", "3.3.3.3:3"], c.addrs
 
+    assert_equal [Fraggle::Connection::Disconnected], al.error
+    assert_equal [Fraggle::Connection::Disconnected], bl.error
+  end
 
   ###
   # Sugar
@@ -191,7 +263,7 @@ class FraggleClientTest < Test::Unit::TestCase
       :value => "bar"
     }
 
-    assert_verb exp, :set, 0, "/foo", "bar"
+    assert_verb exp, :set, "/foo", "bar", 0
   end
 
   def test_get
@@ -201,7 +273,7 @@ class FraggleClientTest < Test::Unit::TestCase
       :path => "/foo"
     }
 
-    assert_verb exp, :get, 0, "/foo"
+    assert_verb exp, :get, "/foo", 0
   end
 
   def test_del
@@ -211,7 +283,7 @@ class FraggleClientTest < Test::Unit::TestCase
       :path => "/foo"
     }
 
-    assert_verb exp, :del, 0, "/foo"
+    assert_verb exp, :del, "/foo", 0
   end
 
   def test_getdir
@@ -223,7 +295,7 @@ class FraggleClientTest < Test::Unit::TestCase
       :limit => 5
     }
 
-    assert_verb exp, :getdir, 0, "/foo", 0, 5
+    assert_verb exp, :getdir, "/foo", 0, 0, 5
   end
 
   def test_rev
@@ -234,6 +306,16 @@ class FraggleClientTest < Test::Unit::TestCase
     assert_verb exp, :rev
   end
 
+  def test_stat
+    exp = {
+      :rev  => 0,
+      :verb => V::STAT,
+      :path => "/foo"
+    }
+
+    assert_verb exp, :stat, "/foo", 0
+  end
+
   def test_walk
     exp = {
       :verb => V::WALK,
@@ -243,7 +325,18 @@ class FraggleClientTest < Test::Unit::TestCase
       :limit => 5
     }
 
-    assert_verb exp, :walk, 0, "/foo/*", 0, 5
+    assert_verb exp, :walk, "/foo/*", 0, 0, 5
+  end
+
+  def test_walk_no_offset_limit_given
+    exp = {
+      :verb => V::WALK,
+      :rev => 0,
+      :path => "/foo/*",
+      :offset => 0
+    }
+
+    assert_verb exp, :walk, "/foo/*", 0
   end
 
   def test_watch
@@ -253,7 +346,7 @@ class FraggleClientTest < Test::Unit::TestCase
       :path => "/foo/*"
     }
 
-    assert_verb exp, :watch, 0, "/foo/*"
+    assert_verb exp, :watch, "/foo/*", 0
   end
 
 end

data/test/fraggle_test.rb

@@ -3,7 +3,7 @@ require 'fraggle'
 class FraggleTest < Test::Unit::TestCase
 
   def test_uri
-    uri = "doozerd:?ca=1:1&ca=2:2&ca=3:3&ignore=this"
+    uri = "doozer:?ca=1:1&ca=2:2&ca=3:3&ignore=this"
     addrs = Fraggle.uri(uri)
     assert_equal ["1:1", "2:2", "3:3"], addrs
   end

data/test/fraggle_transaction_test.rb

@@ -165,13 +165,25 @@ class FraggleTransactionTest < Test::Unit::TestCase
     cn.unbind
 
     assert_equal 1, al.error.length
-    assert_equal nil, al.error.first
+    assert_equal Fraggle::Connection::Disconnected, al.error.first
 
     assert_equal 1, bl.error.length
-    assert_equal nil, bl.error.first
+    assert_equal Fraggle::Connection::Disconnected, bl.error.first
 
     assert_equal 1, cl.error.length
-    assert_equal nil,  cl.error.first
+    assert_equal Fraggle::Connection::Disconnected,  cl.error.first
+  end
+
+  def test_ignores_responses_in_err_state
+    a, al = nop
+    a = cn.send_request(a)
+
+    cn.unbind
+
+    res = Fraggle::Response.new(:tag => a.tag, :flags => F::VALID|F::DONE)
+    cn.receive_response(res)
+
+    assert_equal [], al.valid
   end
 
   def test_send_request_in_error_state
@@ -213,6 +225,7 @@ class FraggleTransactionTest < Test::Unit::TestCase
     cn.receive_response(res)
     assert ! cn.err?
 
+    res.tag += 1
     cn.receive_response(res)
     assert cn.err?
   end

metadata

@@ -1,14 +1,15 @@
 --- !ruby/object:Gem::Specification 
 name: fraggle
 version: !ruby/object:Gem::Version 
-  hash: 961915988
-  prerelease: 5
+  hash: 1923831949
+  prerelease: 6
   segments: 
   - 1
   - 0
   - 0
   - pre
-  version: 1.0.0pre
+  - 2
+  version: 1.0.0.pre.2
 platform: ruby
 authors: 
 - Blake Mizerany
@@ -16,7 +17,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-03-28 00:00:00 -07:00
+date: 2011-04-25 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -35,7 +36,7 @@ dependencies:
   type: :runtime
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
-  name: turn
+  name: eventmachine
   prerelease: false
   requirement: &id002 !ruby/object:Gem::Requirement 
     none: false
@@ -46,8 +47,22 @@ dependencies:
         segments: 
         - 0
         version: "0"
-  type: :development
+  type: :runtime
   version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: turn
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
 description: An EventMachine Client for Doozer
 email: 
 - blake.mizerany@gmail.com
@@ -63,10 +78,11 @@ files:
 - LICENSE
 - README.md
 - Rakefile
-- example/again.rb
+- example/addrs.rb
 - example/getdir.rb
-- example/ping.rb
-- example/session.rb
+- example/redirect.rb
+- example/resend.rb
+- example/rev.rb
 - example/set.rb
 - example/stat.rb
 - example/walk.rb

data/example/again.rb

@@ -1,21 +0,0 @@
-require 'rubygems'
-require 'eventmachine'
-require 'fraggle'
-
-EM.run do
-
-  c = Fraggle.connect
-  c.level = Fraggle::Logger::INFO
-
-  paths = []
-
-  c.walk("/**") do |e|
-    paths << e.path+"="+e.value
-  end.again do |w|
-    # We've been connected to to a new server, Resend the request
-    c.send(w)
-  end.done do
-    puts "## DONE", *paths
-  end
-
-end

data/example/session.rb

@@ -1,16 +0,0 @@
-require 'rubygems'
-require 'eventmachine'
-require 'fraggle'
-
-EM.run do
-
-  EM.error_handler do |e|
-    $stderr.puts e.message + "\n" + (e.backtrace * "\n")
-  end
-
-  c = Fraggle.connect :level => Fraggle::Client::DEBUG
-
-  c.session "example." do |session_id|
-    c.debug "established session (#{session_id})!"
-  end
-end