fraggle 4.0.0.pre.1 → 4.0.0.pre.2

data/.gitignore

@@ -2,3 +2,4 @@
 .bundle
 Gemfile.lock
 pkg/*
+*.prof*

data/README.md

@@ -1,11 +1,14 @@
-# Fraggle (v4.0.0.pre.1 is compatible with Doozer 0.6)
+# Fraggle
+## The current gem is v4.0.0.pre.1 is compatible with Doozer 0.6
 
-Fraggle currently is only a raw interface to Doozer 0.6.
+Please see the [4.0.0.pre.1 README](https://github.com/ha/fraggle/tree/v4.0.0.pre.1) for instructions on use.
 
 **An EventMachine based Doozer client**
 
 ## Install
 
+(For pre-releases, use `--pre`)
+
     $ gem install fraggle
 
 ## Use
@@ -31,48 +34,75 @@ addresses with IP 127.0.0.1 and ports 8046, 8041, 8042, 8043.
       c = Fraggle.connect
 
       c.rev do |v|
-        c.get(v.rev, "/foo") do |e|
-          p [:get, e]
-          if e.ok?
+        c.get(v, "/foo") do |e, err|
+          if err
+            err.code   # => nil
+            err.detail # => nil
+          else
             e.value    # => nil
             e.rev      # => 0
             e.missing? # => true
-          else
-            e.err_code # => nil
-            e.err_detail # => nil
           end
+
+          p [:get, e, err]
         end
 
         ## Obtain the current revision the store is at and watch from then on for
         ## any SET or DEL to /foo.
-        c.wait(v.rev, "/foo") do |e|
+        c.wait(v, "/foo") do |e, err|
           # The event has:
           # ------------------------
-          e.err_code   # => nil
-          e.err_detail # => nil
-          e.path       # => "/foo"
-          e.value      # => "zomg!"
-          e.rev        # => 123
-          e.set?       # => true
-          e.del?       # => false
-
-          p [:wait, e]
+          if err
+            err.code   # => nil
+            err.detail # => nil
+          else
+            e.path       # => "/foo"
+            e.value      # => "zomg!"
+            e.rev        # => 123
+            e.set?       # => true
+            e.del?       # => false
+          end
+
+          p [:wait, e, err]
         end
       end
 
       ## Setting a key (this will trigger the watch above)
-      c.set(Fraggle::Clobber, "/foo", "zomg!") do |e|
+      f = Proc.new do |e, err|
+        p [:e, e, err]
+
+        if err && err.disconnected?
+          # Fraggle (for now) does not attempt a non-idempotent request.  This means
+          # Fraggle will hand off the error to the user if there is a SET or DEL
+          # with rev 0 (missing) and delete it during the time we may be
+          # disconnected.
+          #
+          # In this scenario, there are no other clients that can exist that will
+          # attempt to set this "lock" if it's missing then delete it.  It is safe
+          # for us to resend the request if we were disconnected from the previous
+          # server before a response.
+          #
+          # See High-Availability in the README for more information about this.
+          #
+          c.set(0, "/foo", "zomg!", &f)
+          next
+        end
+
         # Success!
-        case e.err_code
-        when Fraggle::REV_MISMATCH
-          # We didn't win
-        when nil
-          # Success!
-        else
-          fail "something bad happened: " + e.inspect
+        if err
+          case err.code
+          when Fraggle::REV_MISMATCH
+            p :not_it
+          when nil
+            # Success!
+            p [:it, e]
+          else
+            fail "something bad happened: " + e.inspect
+          end
         end
       end
 
+      c.set(0, "/foo", "zomg!", &f)
     end
 
 ## Consistency
@@ -82,9 +112,9 @@ 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(v.rev, "/a") { ... }
-      c.get(v.rev, "/b") { ... }
-      c.get(v.rev, "/c") { ... }
+      c.get(v, "/a") { ... }
+      c.get(v, "/b") { ... }
+      c.get(v, "/c") { ... }
     end
 
 This also means you can go back in time or into the future!
@@ -117,8 +147,9 @@ stores history as far back as it is configured to hold it.  The default is
 
 ## Commands
 
-Each command behaves according to the [proto spec][], respectively.
-Their `blk`s are called with one parameter, a `Fraggle::Response`, when a response is
+Each command below behaves according to the [proto spec][], respectively.
+Their `blk`s are called with two parameters, a `Fraggle::Response` as the first
+or a `Fraggle::Connection::ResponseError` as the second if a response is
 returned from the server.
 
 `set(rev, path, value, &blk)`
@@ -127,10 +158,6 @@ returned from the server.
 
 `get(rev, path, &blk)`
 
-`getdir(rev, path, offset, &blk)`
-
-`walk(rev, path, offset, &blk)`
-
 `wait(rev, path, &blk)`
 
 `rev(&blk)`
@@ -144,19 +171,17 @@ returned from the server.
 Watches `path` (a glob pattern) for changes, from `rev` in history on.  Its
 `blk` is called with a `Fraggle::Response` for each event.
 
-`getdir_all(rev, path, off=0, lim=MaxInt64, ents=[], &blk)`
+`getdir(rev, path, off=0, lim=MaxInt64, ents=[], &blk)`
 
 Behaves like `getdir` but collects `ents`, starting at `off` until all or `lim`
-entries are read. When done `blk` is called with the result as the first
-parameter or an error as the second.  Depending on the response, one or the
-other will be set and the other with be `nil`.
+entries are read. When done, `blk` is called with the result (an `Array`) as the
+first parameter or a `Fraggle::Connection::Response` as the second.  Depending
+on the response, one or the other will be set and the other with be `nil`.
 
-`walk_all(rev, path, off=0, lim=MaxInt64, ents=[], &blk)`
+`walk(rev, path, off=0, lim=MaxInt64, ents=[], &blk)`
 
-Behaves like `walk` but collects `ents`, starting at `off` until all or `lim`
-entries are read. When done `blk` is called with the result as the first
-parameter or an error as the second.  Depending on the response, one or the
-other will be set and the other with be `nil`.
+Like `getdir`, but but path is a glob pattern and each result contains a `path`,
+`value`, and `rev`.
 
 ## Dev
 

data/bench/gs.rb

@@ -0,0 +1,77 @@
+#!/usr/bin/env ruby
+
+# By Mark McGranaghan
+
+require "rubygems"
+require "bundler"
+Bundler.setup
+require "fraggle"
+require "statsample"
+
+$stdout.sync = true
+
+abort("read <[get|set]> <total> <width> [verbose]") if (ARGV.size < 2)
+op = ARGV.shift.to_sym
+total = ARGV.shift.to_i
+width = ARGV.shift.to_i
+verbose = !!ARGV.shift
+latencies = []
+sent_at = nil
+
+EM.run do
+  client = Fraggle.connect
+  sent = 0
+  received = 0
+  start = Time.now
+
+  f = Proc.new do |r|
+    received_at = Time.now
+    received +=1
+    latency = received_at - sent_at
+
+    latencies << latency
+    if verbose
+      $stdout.puts("received=#{received} ok=#{r.ok?} rev=#{r.rev} latency=#{latency}")
+    elsif (received % 10 == 0)
+      $stdout.print(".")
+    end
+    if (received == total)
+      EM.stop
+      elapsed = Time.now - start
+      vector = latencies.to_scale
+      $stdout.puts
+      $stdout.puts("total=#{total}")
+      $stdout.puts("elapsed=#{elapsed}")
+      $stdout.puts("rate=#{total / elapsed}")
+      $stdout.puts("mean=#{vector.mean}")
+      $stdout.puts("sd=#{vector.sd}")
+      $stdout.puts("perc90=#{vector.percentil(90)}")
+      $stdout.puts("perc99=#{vector.percentil(99)}")
+      $stdout.puts("max=#{vector.max}")
+    end
+  end
+
+  tick = Proc.new do
+    if (sent == total)
+      # done sending
+    elsif ((sent - received) < width)
+      # pipe open
+      sent_at = Time.now
+      sent += 1
+      if verbose
+        $stdout.puts("sent=#{sent}")
+      end
+
+      case op
+      when :get
+        client.get(nil, "/processes/#{sent}", &f)
+      when :set
+        client.set(Fraggle::Clobber, "/processes/#{sent}", "1", &f)
+      end
+    else
+      # pipe closed
+    end
+    EM.next_tick(&tick)
+  end
+  tick.call
+end

data/example/{getdir_all.rb → getdir.rb}

@@ -6,7 +6,7 @@ EM.run do
 
   c.rev do |v|
     # Valid
-    req = c.getdir_all("/ctl/node", v.rev) do |ents, err|
+    req = c.getdir(v, "/ctl/node") do |ents, err|
       if err
         p [:err, err]
       else
@@ -17,12 +17,12 @@ EM.run do
     end
 
     # Limit 0 return nothing
-    c.getdir_all("/ctl/node", v.rev, 0, 0) do |ents, err|
+    c.getdir(v, "/ctl/node", 0, 0) do |ents, err|
       p [:ret, ents, err]
     end
 
     # Error
-    c.getdir_all("/nothere", v.rev) do |ents, err|
+    c.getdir(v, "/nothere") do |ents, err|
       p [:ret, ents, err]
     end
   end

data/example/readme.rb

@@ -10,47 +10,73 @@ EM.run do
   c = Fraggle.connect
 
   c.rev do |v|
-    c.get(v.rev, "/foo") do |e|
-      p [:get, e]
-      if e.ok?
+    c.get(v, "/foo") do |e, err|
+      if err
+        err.code   # => nil
+        err.detail # => nil
+      else
         e.value    # => nil
         e.rev      # => 0
         e.missing? # => true
-      else
-        e.err_code # => nil
-        e.err_detail # => nil
       end
+
+      p [:get, e, err]
     end
 
     ## Obtain the current revision the store is at and watch from then on for
     ## any SET or DEL to /foo.
-    c.wait(v.rev, "/foo") do |e|
+    c.wait(v, "/foo") do |e, err|
       # The event has:
       # ------------------------
-      e.err_code   # => nil
-      e.err_detail # => nil
-      e.path       # => "/foo"
-      e.value      # => "zomg!"
-      e.rev        # => 123
-      e.set?       # => true
-      e.del?       # => false
-
-      p [:wait, e]
+      if err
+        err.code   # => nil
+        err.detail # => nil
+      else
+        e.path       # => "/foo"
+        e.value      # => "zomg!"
+        e.rev        # => 123
+        e.set?       # => true
+        e.del?       # => false
+      end
+
+      p [:wait, e, err]
     end
   end
 
   ## Setting a key (this will trigger the watch above)
-  c.set(0, "/foo", "zomg!") do |e|
+  f = Proc.new do |e, err|
+    p [:e, e, err]
+
+    if err && err.disconnected?
+      # Fraggle (for now) does not attempt a non-idempotent request.  This means
+      # Fraggle will hand off the error to the user if there is a SET or DEL
+      # with rev 0 (missing) and delete it during the time we may be
+      # disconnected.
+      #
+      # In this scenario, there are no other clients that can exist that will
+      # attempt to set this "lock" if it's missing then delete it.  It is safe
+      # for us to resend the request if we were disconnected from the previous
+      # server before a response.
+      #
+      # See High-Availability in the README for more information about this.
+      #
+      c.set(0, "/foo", "zomg!", &f)
+      next
+    end
+
     # Success!
-    case e.err_code
-    when Fraggle::REV_MISMATCH
-      p :not_it
-    when nil
-      # Success!
-      p :it
-    else
-      fail "something bad happened: " + e.inspect
+    if err
+      case err.code
+      when Fraggle::REV_MISMATCH
+        p :not_it
+      when nil
+        # Success!
+        p [:it, e]
+      else
+        fail "something bad happened: " + e.inspect
+      end
     end
   end
 
+  c.set(0, "/foo", "zomg!", &f)
 end

data/example/{walk_all.rb → walk.rb}

@@ -6,7 +6,7 @@ EM.run do
 
   c.rev do |v|
     # Valid
-    req = c.walk_all("/ctl/node/**", v.rev) do |ents, err|
+    req = c.walk(v, "/ctl/node/**") do |ents, err|
       if err
         p [:err, err]
       else
@@ -17,13 +17,13 @@ EM.run do
     end
 
     # Limit 0 return nothing
-    c.walk_all("/ctl/node/**", v.rev, 0, 0) do |ents, err|
-      p [:ret, ents, err]
+    c.walk(v, "/ctl/node/**", 0, 0) do |ents, err|
+      p [:nothing, ents, err]
     end
 
     # Error
-    c.walk_all("/nothere", v.rev) do |ents, err|
-      p [:ret, ents, err]
+    c.walk(v, "/nothere") do |ents, err|
+      p [:nothere, ents, err]
     end
   end
 end

data/example/watch.rb

@@ -5,8 +5,8 @@ EM.run do
   c = Fraggle.connect
 
   c.rev do |v|
-    c.watch("/ctl/node/**", v.rev) do |e|
-      p e
+    c.watch(v, "/ctl/node/**") do |e, err|
+      p [e, err]
     end
   end
 end

data/fraggle.gemspec

@@ -23,4 +23,5 @@ Gem::Specification.new do |s|
   s.add_dependency "eventmachine"
 
   s.add_development_dependency "turn"
+  s.add_development_dependency "statsample"
 end

data/lib/fraggle/client.rb

@@ -1,6 +1,5 @@
 require 'eventmachine'
 require 'fraggle/connection'
-require 'logger'
 
 module Fraggle
   class Client
@@ -11,13 +10,10 @@ module Fraggle
     class NoMoreAddrs < StandardError
     end
 
-    DefaultLog = Logger.new(STDERR)
-    DefaultLog.level = Logger::UNKNOWN
+    attr_reader :cn, :addrs
 
-    attr_reader :cn, :log, :addrs
-
-    def initialize(cn, addrs, log=DefaultLog)
-      @cn, @addrs, @log = cn, addrs, log
+    def initialize(cn, addrs)
+      @cn, @addrs = cn, addrs
     end
 
     def addr
@@ -52,7 +48,7 @@ module Fraggle
       idemp(req, &blk)
     end
 
-    def getdir(rev, path, offset, &blk)
+    def _getdir(rev, path, offset, &blk)
       req = Request.new
       req.verb   = GETDIR
       req.rev    = rev
@@ -62,7 +58,7 @@ module Fraggle
       resend(req, &blk)
     end
 
-    def walk(rev, path, offset, &blk)
+    def _walk(rev, path, offset, &blk)
       req = Request.new
       req.verb   = WALK
       req.rev    = rev
@@ -85,7 +81,9 @@ module Fraggle
       req = Request.new
       req.verb = REV
 
-      resend(req, &blk)
+      resend(req) do |v, _|
+        blk.call(v.rev)
+      end
     end
 
     def stat(rev, path, &blk)
@@ -97,21 +95,29 @@ module Fraggle
       resend(req, &blk)
     end
 
+    def access(secret, &blk)
+      req = Request.new
+      req.verb  = ACCESS
+      req.value = secret
+
+      resend(req, &blk)
+    end
+
     def watch(rev, path, &blk)
-      wait(rev, path, rev) do |e|
-        blk.call(e)
-        if e.ok?
-          watch(rev, path, e.rev+1, &blk)
+      wait(rev, path) do |e, err|
+        blk.call(e, err)
+        if ! err
+          watch(e.rev+1, path, &blk)
         end
       end
     end
 
-    def getdir_all(rev, path, off=0, lim=MaxInt64, ents=[], &blk)
-      all(:getdir, rev, path, off, lim, ents, &blk)
+    def getdir(rev, path, off=0, lim=MaxInt64, ents=[], &blk)
+      all(:_getdir, rev, path, off, lim, ents, &blk)
     end
 
-    def walk_all(rev, path, off=0, lim=MaxInt64, ents=[], &blk)
-      all(:walk, rev, path, off, lim, ents, &blk)
+    def walk(rev, path, off=0, lim=MaxInt64, ents=[], &blk)
+      all(:_walk, rev, path, off, lim, ents, &blk)
     end
 
     def all(m, rev, path, off, lim, ents=[], &blk)
@@ -120,11 +126,10 @@ module Fraggle
         return
       end
 
-      __send__(m, rev, path, off) do |e|
-        case e.err_code
+      __send__(m, rev, path, off) do |e, err|
+        case err && err.code
         when nil
-          ents << e
-          all(m, rev, path, off+1, lim-1, ents, &blk)
+          all(m, rev, path, off+1, lim-1, ents << e, &blk)
         when Fraggle::Response::Err::RANGE
           blk.call(ents, nil)
         else
@@ -136,56 +141,56 @@ module Fraggle
     # Sends a request to the server.  Returns the request with a new tag
     # assigned.
     def send(req, &blk)
-      cb = Proc.new do |e|
-        log.debug("response: #{e.inspect} for #{req.inspect}")
-
-        if e.disconnected? && cn.err?
-          log.error("conn err: #{req.inspect}")
-          reconnect!
+      cb = Proc.new do |e, err|
+        case err
+        when Connection::DisconnectedError
+          if cn.err?
+            reconnect!
+          end
         end
-
-        blk.call(e)
+        blk.call(e, err)
       end
 
-      log.debug("sending: #{req.inspect}")
       cn.send_request(req, cb)
     end
 
     def resend(req, &blk)
-      cb = Proc.new do |e|
-        if e.disconnected?
+      send(req) do |e, err|
+        case err
+        when nil
+          blk.call(e, err)
+        when Connection::DisconnectedError
           req.tag = nil
-          log.debug("resending: #{req.inspect}")
           resend(req, &blk)
         else
-          blk.call(e)
+          blk.call(e, err)
         end
       end
-
-      send(req, &cb)
     end
 
     def idemp(req, &blk)
-      cb = Proc.new do |e|
-        if e.disconnected? && req.rev > 0
+      send(req) do |e, err|
+        case err
+        when Connection::DisconnectedError
           # 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, &blk)
-          next
+          if (req.rev || 0) > 0
+            req.tag = nil
+            idemp(req, &blk)
+          else
+            blk.call(e, err)
+          end
+        when nil
+          blk.call(e, err)
         end
-
-        blk.call(e)
       end
-
-      send(req, &cb)
     end
 
     def reconnect!
-      if addr = @addrs.shift
+      if addr = @addrs.slice!(rand(@addrs.length))
         reconnect(addr)
       else
         raise NoMoreAddrs
@@ -193,7 +198,6 @@ module Fraggle
     end
 
     def reconnect(addr)
-      log.warn("reconnecting to #{addr}")
       host, port = addr.split(":")
       @cn = EM.connect(host, port, Fraggle::Connection, addr)
     end

data/lib/fraggle/connection.rb

@@ -4,21 +4,35 @@ module Fraggle
 
   module Connection
 
-    Disconnected = Response.new
-    Disconnected.disconnected = true
-
-    # Base class for all Connection errors
-    class Error < StandardError
-      attr_accessor :req
-
+    # Raised when a request is invalid
+    class SendError < StandardError
       def initialize(req, msg=nil)
         @req = req
         super(msg)
       end
     end
 
-    # Raised when a request is invalid
-    class SendError < Error
+    class DisconnectedError < StandardError
+      def ==(o)
+        return false if ! o.kind_of?(self.class)
+        message == o.message
+      end
+    end
+
+    class ResponseError < StandardError
+      attr_reader :code
+
+      alias :detail :message
+
+      def initialize(res)
+        @code = res.err_code
+        super("#{res.name_for(Response::Err, code)}: #{res.err_detail}")
+      end
+
+      def ==(o)
+        return false if ! o.kind_of?(self.class)
+        code == o.code && message == o.message
+      end
     end
 
 
@@ -33,10 +47,10 @@ module Fraggle
 
       while @buf.length > 0
         if @len && @buf.length >= @len
-            bytes = @buf.slice!(0, @len)
-            @len = nil
-            res = Response.decode(bytes)
-            receive_response(res)
+          bytes = @buf.slice!(0, @len)
+          @len = nil
+          res = Response.decode(bytes)
+          receive_response(res)
         elsif @buf.length >= 4
           bytes = @buf.slice!(0, 4)
           @len = bytes.unpack("N")[0]
@@ -51,7 +65,11 @@ module Fraggle
       return if err?
       req, blk = @cb.delete(res.tag)
       return if ! blk
-      blk.call(res)
+      if res.err_code
+        blk.call(nil, ResponseError.new(res))
+      else
+        blk.call(res, nil)
+      end
     end
 
     def send_request(req, blk)
@@ -60,7 +78,7 @@ module Fraggle
       end
 
       if err?
-        next_tick { blk.call(Disconnected) }
+        next_tick { blk.call(nil, DisconnectedError.new(self.addr)) }
         return req
       end
 
@@ -85,7 +103,7 @@ module Fraggle
     def unbind
       @err = true
       @cb.values.each do |_, blk|
-        blk.call(Disconnected)
+        blk.call(nil, DisconnectedError.new(self.addr))
       end
     end
 

data/lib/fraggle/msg.pb.rb

@@ -16,6 +16,7 @@ module Fraggle
       WALK = 9
       GETDIR = 14
       STAT = 16
+      ACCESS = 99
     end
 
     optional :tag, :int32, 1

data/lib/fraggle/response.rb

@@ -6,8 +6,6 @@ module Fraggle
     SET   = 4
     DEL   = 8
 
-    attr_accessor :disconnected
-
     def set?
       return false if !flags
       (flags & SET) > 0
@@ -26,9 +24,5 @@ module Fraggle
       err_code.nil?
     end
 
-    def disconnected?
-      !!@disconnected
-    end
-
   end
 end

data/lib/fraggle/version.rb

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

data/test/fraggle_client_test.rb

@@ -23,7 +23,7 @@ class FraggleClientTest < Test::Unit::TestCase
     @c.__send__(:initialize, cn, @addrs)
   end
 
-  def test_send_error
+  def test_response_error
     req, log = request(V::REV)
 
     c.send(req, &log)
@@ -31,7 +31,7 @@ class FraggleClientTest < Test::Unit::TestCase
     res = reply(req.tag, :err_code => E::OTHER)
     c.cn.receive_response(res)
 
-    assert_equal [res], log.valid
+    assert_equal [[nil, C::ResponseError.new(res)]], log.valid
   end
 
   def test_reconnect_without_pending_requests
@@ -50,7 +50,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 [Fraggle::Connection::Disconnected], log.valid
+    assert_equal [[nil, C::DisconnectedError.new("127.0.0.1:0")]], log.valid
   end
 
   def test_reconnect_with_pending_request
@@ -68,7 +68,7 @@ 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.valid
+    assert_equal [[nil, C::DisconnectedError.new("127.0.0.1:0")]], log.valid
   end
 
   def test_reconnect_with_multiple_pending_requests
@@ -93,8 +93,8 @@ class FraggleClientTest < Test::Unit::TestCase
     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 [Fraggle::Connection::Disconnected], loga.valid
-    assert_equal [Fraggle::Connection::Disconnected], logb.valid
+    assert_equal [[nil, C::DisconnectedError.new("127.0.0.1:0")]], loga.valid
+    assert_equal [[nil, C::DisconnectedError.new("127.0.0.1:0")]], logb.valid
   end
 
   def test_resend_pending_requests
@@ -120,8 +120,8 @@ class FraggleClientTest < Test::Unit::TestCase
 
     assert_equal [one], c.cn.sent
 
-    assert_equal [Fraggle::Connection::Disconnected], zlog.valid
-    assert_equal [Fraggle::Connection::Disconnected], nlog.valid
+    assert_equal [[nil, C::DisconnectedError.new("127.0.0.1:0")]], zlog.valid
+    assert_equal [[nil, C::DisconnectedError.new("127.0.0.1:0")]], nlog.valid
   end
 
   ###
@@ -181,7 +181,7 @@ class FraggleClientTest < Test::Unit::TestCase
       :offset => 0
     }
 
-    assert_verb exp, :getdir, 0, "/foo", 0
+    assert_verb exp, :_getdir, 0, "/foo", 0
   end
 
   def test_rev
@@ -210,7 +210,7 @@ class FraggleClientTest < Test::Unit::TestCase
       :offset => 0
     }
 
-    assert_verb exp, :walk, 0, "/foo/*", 0
+    assert_verb exp, :_walk, 0, "/foo/*", 0
   end
 
   def test_wait
@@ -223,4 +223,13 @@ class FraggleClientTest < Test::Unit::TestCase
     assert_verb exp, :wait, 0, "/foo/*"
   end
 
+  def test_wait
+    exp = {
+      :verb => V::ACCESS,
+      :value => "abc"
+    }
+
+    assert_verb exp, :access, "abc"
+  end
+
 end

data/test/fraggle_transaction_test.rb

@@ -5,20 +5,16 @@ class FraggleTransactionTest < Test::Unit::TestCase
 
   attr_reader :cn
 
-  def nop(attrs={})
-    request(V::NOP, attrs)
-  end
-
   def setup
     @cn = TestConn.new("127.0.0.1:0")
   end
 
   def test_tagging
-    req, _ = nop
+    req, _ = request(V::REV)
     assert_equal 0, cn.send_request(req, _).tag
-    req, _ = nop
+    req, _ = request(V::REV)
     assert_equal 1, cn.send_request(req, _).tag
-    req, _ = nop
+    req, _ = request(V::REV)
     assert_equal 2, cn.send_request(req, _).tag
   end
 
@@ -30,7 +26,7 @@ class FraggleTransactionTest < Test::Unit::TestCase
     res = reply(req.tag)
     cn.receive_response(res)
 
-    assert_equal [res], log.valid
+    assert_equal [[res, nil]], log.valid
   end
 
   def test_error
@@ -41,7 +37,8 @@ class FraggleTransactionTest < Test::Unit::TestCase
     res = reply(req.tag, :err_code => E::OTHER)
     cn.receive_response(res)
 
-    assert_equal [res], log.valid
+    err = C::ResponseError.new(res)
+    assert_equal [[nil, err]], log.valid
   end
 
   def test_invalid_tag
@@ -63,7 +60,7 @@ class FraggleTransactionTest < Test::Unit::TestCase
     # This should be ignored
     cn.receive_response(res)
 
-    assert_equal [res], log.valid
+    assert_equal [[res, nil]], log.valid
   end
 
   def test_error_deletes_callback
@@ -77,14 +74,14 @@ class FraggleTransactionTest < Test::Unit::TestCase
     # This should be ignored
     cn.receive_response(res)
 
-    assert_equal [res], log.valid
+    assert_equal [[nil, C::ResponseError.new(res)]], log.valid
   end
 
   def test_cannot_reuse_sent_request
     req, _ = request(V::REV)
     cn.send_request(req, _)
 
-    assert_raises Fraggle::Connection::SendError do
+    assert_raises C::SendError do
       cn.send_request(req, _)
     end
   end
@@ -99,9 +96,9 @@ class FraggleTransactionTest < Test::Unit::TestCase
 
     cn.unbind
 
-    assert_equal [Fraggle::Connection::Disconnected], al.valid
-    assert_equal [Fraggle::Connection::Disconnected], bl.valid
-    assert_equal [Fraggle::Connection::Disconnected], cl.valid
+    assert_equal [[nil, C::DisconnectedError.new("127.0.0.1:0")]], al.valid
+    assert_equal [[nil, C::DisconnectedError.new("127.0.0.1:0")]], bl.valid
+    assert_equal [[nil, C::DisconnectedError.new("127.0.0.1:0")]], cl.valid
   end
 
   def test_send_when_disconnected
@@ -114,6 +111,6 @@ class FraggleTransactionTest < Test::Unit::TestCase
 
     cn.tick!
 
-    assert_equal [Fraggle::Connection::Disconnected], log.valid
+    assert_equal [[nil, C::DisconnectedError.new("127.0.0.1:0")]], log.valid
   end
 end

data/test/helper.rb

@@ -46,6 +46,7 @@ end
 
 class Test::Unit::TestCase
 
+  C = Fraggle::Connection
   V = Fraggle::Request::Verb
   F = Fraggle::Response
   E = Fraggle::Response::Err
@@ -57,13 +58,13 @@ class Test::Unit::TestCase
       @valid = []
     end
 
-    def call(e)
-      @valid << e
+    def call(e, err)
+      @valid << [e, err]
     end
 
     def to_proc
       me = self
-      Proc.new {|e| me.call(e) }
+      Proc.new {|e, err| me.call(e, err) }
     end
   end
 

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification 
 name: fraggle
 version: !ruby/object:Gem::Version 
-  hash: 1923831851
+  hash: 1923831853
   prerelease: 6
   segments: 
   - 4
   - 0
   - 0
   - pre
-  - 1
-  version: 4.0.0.pre.1
+  - 2
+  version: 4.0.0.pre.2
 platform: ruby
 authors: 
 - Blake Mizerany
@@ -17,7 +17,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-05-02 00:00:00 -07:00
+date: 2011-05-05 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -63,6 +63,20 @@ dependencies:
         version: "0"
   type: :development
   version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: statsample
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id004
 description: An EventMachine Client for Doozer
 email: 
 - blake.mizerany@gmail.com
@@ -78,10 +92,10 @@ files:
 - LICENSE
 - README.md
 - Rakefile
-- bench/gets.rb
-- example/getdir_all.rb
+- bench/gs.rb
+- example/getdir.rb
 - example/readme.rb
-- example/walk_all.rb
+- example/walk.rb
 - example/watch.rb
 - fraggle.gemspec
 - lib/fraggle.rb

data/bench/gets.rb

@@ -1,32 +0,0 @@
-require 'rubygems'
-require 'eventmachine'
-require 'fraggle'
-
-reqs = 0
-
-def rget(c, path, rev, &blk)
-  c.get(path, rev) do |e|
-    blk.call
-    rget(c, path, rev, &blk)
-  end
-end
-
-EM.run do
-  c = Fraggle.connect
-
-  EM.add_timer(1) do
-    # The primer is done.  Reset `reqs` and do it for real.
-    reqs = 0
-    EM.add_timer(1) do
-      EM.stop_event_loop
-    end
-  end
-
-  c.rev do |v|
-    rget(c, "/ctl/cal/0", v.rev) do
-      reqs += 1
-    end
-  end
-end
-
-puts "Result (GET): #{reqs}/sec"