fraggle 2.0.0 → 3.0.0

data/README.md

@@ -1,4 +1,4 @@
-# Fraggle (v2.0.0 is compatible with Doozer 0.6)
+# Fraggle (v3.0.0 is compatible with Doozer 0.6)
 
 Fraggle currently is only a raw interface to Doozer 0.6.
 Sugar for `WALK`, `GETDIR`, etc are to come in v3.0.0.
@@ -7,7 +7,7 @@ Sugar for `WALK`, `GETDIR`, etc are to come in v3.0.0.
 
 ## Install
 
-    $ gem install fraggle --pre
+    $ gem install fraggle
 
 ## Use
 
@@ -16,65 +16,51 @@ Sugar for `WALK`, `GETDIR`, etc are to come in v3.0.0.
     require 'fraggle'
 
     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
+      # In the event of a lost connection, fraggle will attempt
       # 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|
-        e.value   # => "bar"
-        e.rev     # => 123
-      end
-
-      req.error do |e|
-        e.err_code   # => nil
-        e.err_detail # => nil
+        if e.ok?
+          e.value    # => nil
+          e.rev      # => 0
+          e.missing? # => true
+        else
+          e.err_code # => Fraggle::<CONST>
+          e.err_detail # => "bad path" or something
+        end
       end
 
-      watch = c.watch("/foo") do |e|
-        # The event has:
-        # ------------------------
-        e.err_code   # => nil
-        e.err_detail # => nil
-        e.path       # => "/foo"
-        e.value      # => "bar"
-        e.rev        # => 123
-        e.set?       # => true
-        e.del?       # => false
-
-        do_something_with(e)
-
-        # Phoney check for example
-        if can_stop_watching?(path)
-          watch.cancel
+      c.rev do |v|
+        ## Obtain the current revision the store is at and watch from then on for
+        ## any SET or DEL to /foo.
+        c.wait("/foo", v.rev) do |e|
+          # 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
         end
       end
 
       ## Setting a key (this will trigger the watch above)
       req = c.set("/foo", "zomg!", 0) do |e|
         # Success!
-      end.error do |e|
-        if e.mismatch?
-          # There was a rev mismatch, handle this.
+        case e.err_code
+        when Fraggle::REV_MISMATCH
+          # We didn't win
+        when nil
+          # Success!
         else
-          raise e.err_detail
+          fail "something bad happened"
         end
       end
 
-      # Knowning when a command is done is useful in some cases.
-      # Use the `done` callback for those situations.
-      ents = []
-      c.getdir("/test") do |e|
-        ents << e
-      end.done do
-        p ents
-      end
-
-      c.get("/nothere") do |e|
-        e.missing? # => true
-      end
-
     end
 
 ## Consistency

data/bench/gets.rb

@@ -0,0 +1,32 @@
+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"

data/lib/fraggle/client.rb

@@ -28,9 +28,8 @@ module Fraggle
       req.rev   = rev
       req.path  = path
       req.value = value
-      req.valid(&blk)
 
-      idemp(req)
+      idemp(req, &blk)
     end
 
     def get(path, rev=nil, &blk)
@@ -38,9 +37,8 @@ module Fraggle
       req.verb = GET
       req.rev  = rev
       req.path = path
-      req.valid(&blk)
 
-      resend(req)
+      resend(req, &blk)
     end
 
     def del(path, rev, &blk)
@@ -48,9 +46,8 @@ module Fraggle
       req.verb = DEL
       req.rev  = rev
       req.path = path
-      req.valid(&blk)
 
-      idemp(req)
+      idemp(req, &blk)
     end
 
     def getdir(path, rev=nil, offset=nil, &blk)
@@ -59,9 +56,8 @@ module Fraggle
       req.rev    = rev
       req.path   = path
       req.offset = offset
-      req.valid(&blk)
 
-      resend(req)
+      resend(req, &blk)
     end
 
     def walk(path, rev=nil, offset=nil, &blk)
@@ -70,9 +66,8 @@ module Fraggle
       req.rev    = rev
       req.path   = path
       req.offset = offset
-      req.valid(&blk)
 
-      resend(req)
+      resend(req, &blk)
     end
 
     def wait(path, rev=nil, &blk)
@@ -80,17 +75,15 @@ module Fraggle
       req.verb = WAIT
       req.rev  = rev
       req.path = path
-      req.valid(&blk)
 
-      resend(req)
+      resend(req, &blk)
     end
 
     def rev(&blk)
       req = Request.new
       req.verb = REV
-      req.valid(&blk)
 
-      resend(req)
+      resend(req, &blk)
     end
 
     def stat(path, rev=nil, &blk)
@@ -98,27 +91,16 @@ module Fraggle
       req.rev  = rev
       req.verb = STAT
       req.path = path
-      req.valid(&blk)
 
-      resend(req)
+      resend(req, &blk)
     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.valid do |e|
+    # assigned.
+    def send(req, &blk)
+      cb = Proc.new do |e|
         log.debug("response: #{e.inspect} for #{req.inspect}")
-        req.emit(:valid, e)
-      end
 
-      wr.done do
-        req.emit(:done)
-      end
-
-      wr.error do |e|
         case true
         when e.disconnected?
           # If we haven't already reconnected, do so.
@@ -126,63 +108,46 @@ module Fraggle
             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.readonly?
-
-          log.error("readonly: #{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
 
+        blk.call(e)
       end
 
-      wr = cn.send_request(wr)
-      req.tag = wr.tag
       log.debug("sending: #{req.inspect}")
-
-      req
+      cn.send_request(req, cb)
     end
 
-    def resend(req)
-      send(req) do
-        req.tag = nil
-        log.debug("resending: #{req.inspect}")
-        resend(req)
+    def resend(req, &blk)
+      cb = Proc.new do |e|
+        if e.disconnected?
+          req.tag = nil
+          log.debug("resending: #{req.inspect}")
+          resend(req, &blk)
+        else
+          blk.call(e)
+        end
       end
+
+      send(req, &cb)
     end
 
-    def idemp(req)
-      send(req) do
-        if req.rev > 0
+    def idemp(req, &blk)
+      cb = Proc.new do |e|
+        if e.disconnected? && 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)
+          idemp(req, &blk)
+          next
         end
+
+        blk.call(e)
       end
+
+      send(req, &cb)
     end
 
     def reconnect!

data/lib/fraggle/connection.rb

@@ -1,4 +1,3 @@
-require 'fraggle/request'
 require 'fraggle/response'
 
 module Fraggle
@@ -23,15 +22,13 @@ module Fraggle
     end
 
 
-    attr_reader :last_received, :addr
+    attr_reader :addr
 
     def initialize(addr)
       @addr, @cb = addr, {}
     end
 
     def receive_data(data)
-      @last_received = Time.now
-
       (@buf ||= "") << data
 
       while @buf.length > 0
@@ -51,30 +48,19 @@ module Fraggle
 
     # The default receive_response
     def receive_response(res)
-      if err?
-        return
-      end
-
-      req = @cb.delete(res.tag)
-
-      if ! req
-        return
-      end
-
-      if res.ok?
-        req.emit(:valid, res)
-      else
-        req.emit(:error, res)
-      end
+      return if err?
+      req, blk = @cb.delete(res.tag)
+      return if ! blk
+      blk.call(res)
     end
 
-    def send_request(req)
+    def send_request(req, blk)
       if req.tag
         raise SendError, "Already sent #{req.inspect}"
       end
 
       if err?
-        next_tick { req.emit(:error, Disconnected) }
+        next_tick { blk.call(Disconnected) }
         return req
       end
 
@@ -85,9 +71,8 @@ module Fraggle
         req.tag %= 2**31
       end
 
-      req.cn = self
-
-      @cb[req.tag] = req
+      # TODO: remove this!
+      @cb[req.tag] = [req, blk]
 
       data = req.encode
       head = [data.length].pack("N")
@@ -99,8 +84,8 @@ module Fraggle
 
     def unbind
       @err = true
-      @cb.values.each do |req|
-        req.emit(:error, Disconnected)
+      @cb.values.each do |_, blk|
+        blk.call(Disconnected)
       end
     end
 

data/lib/fraggle/response.rb

@@ -26,10 +26,6 @@ module Fraggle
       err_code.nil?
     end
 
-    def readonly?
-      err_code == Err::READONLY
-    end
-
     def disconnected?
       !!@disconnected
     end

data/lib/fraggle/version.rb

@@ -1,3 +1,3 @@
 module Fraggle
-  VERSION = "2.0.0"
+  VERSION = "3.0.0"
 end

data/test/fraggle_client_test.rb

@@ -1,9 +1,9 @@
-require File.dirname(__FILE__)+"/helper"
+require File.expand_path(File.dirname(__FILE__)+"/helper")
 require 'fraggle/client'
 
 class FraggleClientTest < Test::Unit::TestCase
 
-  attr_reader :c, :addrs, :blk, :called
+  attr_reader :c
 
   def setup
     addr = "127.0.0.1:0"
@@ -24,14 +24,14 @@ class FraggleClientTest < Test::Unit::TestCase
   end
 
   def test_send_error
-    req, log = request(V::NOP)
-    req = c.send(req)
+    req, log = request(V::REV)
 
-    res = Fraggle::Response.new :tag => req.tag, :err_code => E::OTHER
+    c.send(req, &log)
+
+    res = reply(req.tag, :err_code => E::OTHER)
     c.cn.receive_response(res)
 
-    assert_equal [], log.done
-    assert_equal [res], log.error
+    assert_equal [res], log.valid
   end
 
   def test_reconnect_without_pending_requests
@@ -41,8 +41,8 @@ class FraggleClientTest < Test::Unit::TestCase
     c.cn.close_connection
 
     # Send a request to invoke reconnect
-    req, log = request(V::NOP)
-    req = c.send(req)
+    req, log = request(V::REV)
+    c.send(req, &log)
 
     # Fake reactor turn (only available in tests)
     c.cn.tick!
@@ -50,15 +50,15 @@ 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.error
+    assert_equal [Fraggle::Connection::Disconnected], log.valid
   end
 
   def test_reconnect_with_pending_request
     exp = @addrs.dup
 
     # Send a request to invoke reconnect
-    req, log = request(V::NOP)
-    req = c.send(req)
+    req, log = request(V::REV)
+    c.send(req, &log)
 
     # Disconnect from 127.0.0.1:0
     c.cn.close_connection
@@ -68,18 +68,18 @@ 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
+    assert_equal [Fraggle::Connection::Disconnected], log.valid
   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, loga = request(V::REV)
+    c.send(req, &loga)
 
-    req, logb = request(V::NOP)
-    req = c.send(req)
+    req, logb = request(V::REV)
+    c.send(req, &logb)
 
     # Disconnect from 127.0.0.1:0
     c.cn.close_connection
@@ -93,13 +93,13 @@ 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.error
-    assert_equal [Fraggle::Connection::Disconnected], logb.error
+    assert_equal [Fraggle::Connection::Disconnected], loga.valid
+    assert_equal [Fraggle::Connection::Disconnected], logb.valid
   end
 
   def test_resend_pending_requests
     req, log = request(V::GET, :path => "/foo")
-    req = c.resend(req)
+    c.resend(req, &log)
 
     c.cn.close_connection
 
@@ -108,42 +108,20 @@ class FraggleClientTest < Test::Unit::TestCase
 
   def test_idemp_pending_requests
     one, olog = request(V::SET, :rev => 1, :path => "/foo", :value => "bar")
-    one = c.idemp(one)
+    c.idemp(one, &olog)
 
     zero, zlog = request(V::SET, :rev => 0, :path => "/foo", :value => "bar")
-    zero = c.idemp(zero)
+    c.idemp(zero, &zlog)
 
     neg, nlog = request(V::SET, :rev => -1, :path => "/foo", :value => "bar")
-    zero = c.idemp(neg)
+    c.idemp(neg, &nlog)
 
     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_readonly_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 => a.tag,
-      :err_code => E::READONLY,
-      :err_detail => "9.9.9.9:9"
-    )
-
-    c.cn.receive_response(res)
-
-    assert_equal "1.1.1.1:1", c.cn.addr
-    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
+    assert_equal [Fraggle::Connection::Disconnected], zlog.valid
+    assert_equal [Fraggle::Connection::Disconnected], nlog.valid
   end
 
   ###

data/test/fraggle_protocol_test.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__)+"/helper"
+require File.expand_path(File.dirname(__FILE__)+"/helper")
 require 'fraggle/connection'
 
 class FraggleProtocolTest < Test::Unit::TestCase
@@ -80,7 +80,7 @@ class FraggleProtocolTest < Test::Unit::TestCase
     end
 
     nop = Fraggle::Request.new :verb => V::NOP
-    cn.send_request(nop)
+    cn.send_request(nop, nil)
 
     assert_equal head+bytes, got
   end

data/test/fraggle_transaction_test.rb

@@ -1,9 +1,9 @@
-require File.dirname(__FILE__)+"/helper"
+require File.expand_path(File.dirname(__FILE__)+"/helper")
 require 'fraggle/connection'
 
 class FraggleTransactionTest < Test::Unit::TestCase
 
-  attr_reader :cn, :tmp, :valid, :done, :error
+  attr_reader :cn
 
   def nop(attrs={})
     request(V::NOP, attrs)
@@ -15,45 +15,37 @@ class FraggleTransactionTest < Test::Unit::TestCase
 
   def test_tagging
     req, _ = nop
-    assert_equal 0, cn.send_request(req).tag
+    assert_equal 0, cn.send_request(req, _).tag
     req, _ = nop
-    assert_equal 1, cn.send_request(req).tag
+    assert_equal 1, cn.send_request(req, _).tag
     req, _ = nop
-    assert_equal 2, cn.send_request(req).tag
+    assert_equal 2, cn.send_request(req, _).tag
   end
 
   def test_valid
-    req, log =  nop
-    req = cn.send_request(req)
+    req, log = request(V::REV)
 
-    res = Fraggle::Response.new :tag => req.tag
+    cn.send_request(req, log)
+
+    res = reply(req.tag)
     cn.receive_response(res)
 
     assert_equal [res], log.valid
-    assert_equal [], log.done
   end
 
   def test_error
-    req, log = nop
-    req = cn.send_request(req)
+    req, log = request(V::REV)
 
-    res = Fraggle::Response.new(
-      :tag => req.tag,
-      :err_code => E::OTHER
-    )
+    cn.send_request(req, log)
 
+    res = reply(req.tag, :err_code => E::OTHER)
     cn.receive_response(res)
 
-    assert_equal [], log.valid
-    assert_equal [], log.done
-    assert_equal [res], log.error
+    assert_equal [res], log.valid
   end
 
   def test_invalid_tag
-    res = Fraggle::Response.new(
-      :tag => 0,
-      :err_code => E::OTHER
-    )
+    res = reply(0, :err_code => E::OTHER)
 
     assert_nothing_raised do
       cn.receive_response(res)
@@ -61,10 +53,11 @@ class FraggleTransactionTest < Test::Unit::TestCase
   end
 
   def test_deletes_callback
-    req, log = nop
-    req = cn.send_request(req)
+    req, log = request(V::REV)
+
+    cn.send_request(req, log)
 
-    res = Fraggle::Response.new(:tag => req.tag)
+    res = reply(req.tag)
     cn.receive_response(res)
 
     # This should be ignored
@@ -74,70 +67,53 @@ class FraggleTransactionTest < Test::Unit::TestCase
   end
 
   def test_error_deletes_callback
-    req, log = nop
-    req = cn.send_request(req)
+    req, log = request(V::REV)
 
-    res = Fraggle::Response.new(
-      :tag => req.tag,
-      :err_code => E::OTHER
-    )
+    cn.send_request(req, log)
 
+    res = reply(req.tag, :err_code => E::OTHER)
     cn.receive_response(res)
 
     # This should be ignored
     cn.receive_response(res)
 
-    assert_equal [res], log.error
+    assert_equal [res], log.valid
   end
 
   def test_cannot_reuse_sent_request
-    req, _ = nop
-    req = cn.send_request(req)
+    req, _ = request(V::REV)
+    cn.send_request(req, _)
 
     assert_raises Fraggle::Connection::SendError do
-      cn.send_request(req)
+      cn.send_request(req, _)
     end
   end
 
-  def test_disconnected
-    a, al = nop
-    a = cn.send_request(a)
-    b, bl = nop
-    b = cn.send_request(b)
-    c, cl = nop
-    c = cn.send_request(c)
+  def test_disconnect_with_pending_requests
+    a, al = request(V::REV)
+    a = cn.send_request(a, al)
+    b, bl = request(V::REV)
+    b = cn.send_request(b, bl)
+    c, cl = request(V::REV)
+    c = cn.send_request(c, cl)
 
     cn.unbind
 
-    assert_equal 1, al.error.length
-    assert_equal Fraggle::Connection::Disconnected, al.error.first
-
-    assert_equal 1, bl.error.length
-    assert_equal Fraggle::Connection::Disconnected, bl.error.first
-
-    assert_equal 1, cl.error.length
-    assert_equal Fraggle::Connection::Disconnected,  cl.error.first
+    assert_equal [Fraggle::Connection::Disconnected], al.valid
+    assert_equal [Fraggle::Connection::Disconnected], bl.valid
+    assert_equal [Fraggle::Connection::Disconnected], cl.valid
   end
 
-  def test_ignores_responses_in_err_state
-    a, al = nop
-    a = cn.send_request(a)
-
+  def test_send_when_disconnected
     cn.unbind
 
-    res = Fraggle::Response.new(:tag => a.tag)
-    cn.receive_response(res)
-
-    assert_equal [], al.valid
-  end
+    req, log = request(V::REV)
+    ret = cn.send_request(req, log)
 
-  def test_send_request_in_error_state
-    cn.err = true
+    assert_equal req, ret
 
-    req, log = nop
-    req = cn.send_request(req)
-    assert_equal nil, req.tag
+    cn.tick!
 
-    assert_equal nil, log.error.first
+    assert_equal [Fraggle::Connection::Disconnected], log.valid
   end
 end

data/test/helper.rb

@@ -14,8 +14,8 @@ class TestConn
     @ticks = []
   end
 
-  def send_request(req)
-    @sent << super(req)
+  def send_request(req, blk)
+    @sent << super(req, blk)
     req
   end
 
@@ -50,23 +50,29 @@ class Test::Unit::TestCase
   F = Fraggle::Response
   E = Fraggle::Response::Err
 
-  Log = Struct.new(:valid, :error, :done)
+  class Log
+    attr_reader :valid
+
+    def initialize
+      @valid = []
+    end
+
+    def call(e)
+      @valid << e
+    end
+
+    def to_proc
+      me = self
+      Proc.new {|e| me.call(e) }
+    end
+  end
 
   def request(verb, attrs={})
     logable(Fraggle::Request.new(attrs.merge(:verb => verb)))
   end
 
   def logable(req)
-    log = Log.new([], [], [])
-    req.valid do |e|
-      log.valid << e
-    end
-    req.done do
-      log.done << req
-    end
-    req.error do |e|
-      log.error << e
-    end
+    log = Log.new
     [req, log]
   end
 

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: fraggle
 version: !ruby/object:Gem::Version 
-  hash: 15
+  hash: 7
   prerelease: 
   segments: 
-  - 2
+  - 3
   - 0
   - 0
-  version: 2.0.0
+  version: 3.0.0
 platform: ruby
 authors: 
 - Blake Mizerany
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-04-27 00:00:00 -07:00
+date: 2011-04-29 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -76,19 +76,12 @@ files:
 - LICENSE
 - README.md
 - Rakefile
-- example/getdir.rb
-- example/readonly.rb
-- example/resend.rb
-- example/rev.rb
-- example/set.rb
-- example/stat.rb
-- example/walk.rb
+- bench/gets.rb
 - fraggle.gemspec
 - lib/fraggle.rb
 - lib/fraggle/client.rb
 - lib/fraggle/connection.rb
 - lib/fraggle/msg.pb.rb
-- lib/fraggle/request.rb
 - lib/fraggle/response.rb
 - lib/fraggle/version.rb
 - test/fraggle_client_test.rb

data/example/getdir.rb

@@ -1,58 +0,0 @@
-require 'rubygems'
-require 'eventmachine'
-require 'fraggle'
-
-EM.run do
-
-  ## NOTE:  This will be easier the very near future.
-
-  ## Collects names in a directory
-
-  c = Fraggle.connect
-  c.log.level = Logger::DEBUG
-
-  def c.getdirx(path, rev, offset, &blk)
-    w = Request.new
-    w.valid(&blk)
-
-    err = Proc.new do |e|
-      if e.err_code == Fraggle::Response::Err::AGAIN
-        w.emit(:done)
-      else
-        w.emit(:error, e)
-      end
-    end
-
-    req = getdir(path, rev, offset) do |e|
-      blk.call(e)
-      req = getdirx(path, rev, offset+1, &blk)
-      req.error(&err)
-    end
-    req.error(&err)
-
-    w
-  end
-
-  ents, n = [], 0
-
-  f = Proc.new do |e|
-    ents << e.path
-    n += 1
-    c.getdir("/ctl", nil, n, &f).error do |e|
-      if e.err_code == Fraggle::Response::Err::RANGE
-        p [:ents, ents]
-      else
-        p [:err, e]
-      end
-    end
-  end
-
-  c.getdir("/ctl", nil, n, &f).error do |e|
-    if e.err_code == Fraggle::Response::Err::RANGE
-      p [:ents, ents]
-    else
-      p [:err, e]
-    end
-  end
-
-end

data/example/readonly.rb

@@ -1,28 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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
-  c.log.level = Logger::DEBUG
-
-  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("/foo", 100_000) 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/rev.rb

@@ -1,15 +0,0 @@
-require 'rubygems'
-require 'eventmachine'
-require 'fraggle'
-
-EM.run do
-
-  c = Fraggle.connect
-
-  EM.add_periodic_timer(1) do
-    c.rev do |e|
-      p [:rev, e.rev]
-    end
-  end
-
-end

data/example/set.rb

@@ -1,20 +0,0 @@
-require 'rubygems'
-require 'eventmachine'
-require 'fraggle'
-
-MaxInt64 = (1<<62)-1
-
-EM.run do
-  c = Fraggle.connect
-  c.log.level = Logger::DEBUG
-
-  EM.add_periodic_timer(1) do
-    c.get("/hello") do |e|
-      p [:e, e]
-    end
-  end
-
-  c.set('/hello', 'world', MaxInt64) do |e|
-    p [:set, e]
-  end
-end

data/example/stat.rb

@@ -1,19 +0,0 @@
-require 'rubygems'
-require 'eventmachine'
-require 'fraggle'
-
-EM.run do
-  c = Fraggle.connect
-
-  EM.add_periodic_timer(1) do
-    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", -1)
-  end
-end

data/example/walk.rb

@@ -1,29 +0,0 @@
-require 'rubygems'
-require 'eventmachine'
-require 'fraggle'
-
-EM.run do
-  c = Fraggle.connect
-
-  paths = []
-
-  req = c.walk("/**", 1)
-
-  valid = Proc.new do |e|
-    paths << e.path+"="+e.value
-  end
-
-  done = Proc.new do
-    puts "rev #{req.rev} " + ("-"*25)
-    puts *paths
-
-    paths.clear
-
-    req = c.walk("/**", req.rev+1)
-    req.valid(&valid)
-    req.done(&done)
-  end
-
-  req.valid(&valid)
-  req.done(&done)
-end

data/lib/fraggle/request.rb

@@ -1,36 +0,0 @@
-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
-    end
-
-    def valid(&blk)
-      @cb[:valid] = blk
-      self
-    end
-
-    def done(&blk)
-      @cb[:done] = blk
-      self
-    end
-
-    def error(&blk)
-      @cb[:error] = blk
-      self
-    end
-
-    def emit(name, *args)
-      (@cb[name] || DEFAULT_PROC).call(*args)
-    end
-
-  end
-end