fraggle 0.3.5 → 0.4.0

data/lib/fraggle/client.rb

@@ -21,15 +21,18 @@ module Fraggle
 
     Nibbles = "0123456789abcdef"
 
-    def initialize(addrs)
-      @addr  = addrs.shift
-      @init  = addrs
-      @addrs = {}
-      @shun  = {}
+    def initialize(addr, addrs=[], opts={})
       @cbx   = {}
 
+      @addr  = addr
+      @addrs = {}
+
+      addrs.each_with_index do |addr, i|
+        @addrs[i] = addr
+      end
+
       # Logging
-      @level   = ERROR
+      @level   = opts[:level] || ERROR
       @writer  = $stderr
     end
 
@@ -56,13 +59,20 @@ module Fraggle
       end
     end
 
-    def checkin(path, cas, &blk)
+    def rev
       req = Request.new
-      req.verb  = Request::Verb::CHECKIN
-      req.path  = path
-      req.cas   = casify(cas)
+      req.verb = Request::Verb::REV
+
+      resend(req)
+    end
 
-      send(req, &blk)
+    def checkin(path, rev)
+      req = Request.new
+      req.verb = Request::Verb::CHECKIN
+      req.path = path
+      req.rev  = casify(rev)
+
+      resend(req)
     end
 
     def session(prefix=nil, &blk)
@@ -79,103 +89,121 @@ module Fraggle
         estab = true
 
         # Get back to the server ASAP
-        checkin(name, e.cas, &f)
+        checkin(name, e.rev).valid(&f)
       end
 
-      checkin(name, 0, &f)
+      checkin(name, 0).valid(&f)
     end
 
-    def get(sid, path, &blk)
+    def get(rev, path)
       req = Request.new
+      req.rev  = rev
       req.verb = Request::Verb::GET
-      req.id   = sid if sid != 0 # wire optimization
       req.path = path
 
-      send(req, &blk)
+      resend(req)
     end
 
-    def stat(sid, path, &blk)
+    def stat(rev, path)
       req = Request.new
+      req.rev  = rev
       req.verb = Request::Verb::STAT
-      req.id   = sid if sid != 0 # wire optimization
       req.path = path
 
-      send(req, &blk)
+      resend(req)
     end
 
-    def getdir(sid, path, offset, limit, &blk)
+    def getdir(rev, path, offset, limit)
       req = Request.new
+      req.rev    = rev
       req.verb   = Request::Verb::GETDIR
-      req.id     = sid    if sid != 0
       req.offset = offset if offset != 0
       req.limit  = limit  if limit  != 0
       req.path   = path
 
-      send(req, &blk)
+      resend(req)
     end
 
-    def set(path, value, cas, &blk)
+    def set(path, value, rev)
       req = Request.new
       req.verb  = Request::Verb::SET
       req.path  = path
       req.value = value
-      req.cas   = casify(cas)
+      req.rev   = casify(rev)
 
-      send(req, &blk)
+      send(req)
     end
 
-    def del(path, cas, &blk)
+    def del(path, rev)
       req = Request.new
       req.verb  = Request::Verb::DEL
       req.path  = path
-      req.cas   = casify(cas)
+      req.rev   = casify(rev)
 
-      send(req, &blk)
+      send(req)
     end
 
-    def walk(sid, glob, &blk)
+    def walk(rev, glob, offset=nil, limit=nil)
       req = Request.new
-      req.verb = Request::Verb::WALK
-      req.id   = sid if sid != 0 # wire optimization
-      req.path = glob
+      req.verb   = Request::Verb::WALK
+      req.rev    = rev
+      req.path   = glob
+      req.offset = offset
+      req.limit  = limit
 
-      cancelable(send(req, &blk))
+      cancelable(resend(req))
     end
 
-    def watch(glob, &blk)
+    def watch(rev, glob)
       req = Request.new
+      req.rev  = rev
       req.verb = Request::Verb::WATCH
       req.path = glob
 
-      cancelable(send(req, &blk))
+      cancelable(resend(req))
     end
 
-    def snap(&blk)
+    def monitor(rev, glob)
       req = Request.new
-      req.verb = Request::Verb::SNAP
+      req.rev  = rev
+      req.path = glob
 
-      send(req, &blk)
-    end
+      wt = nil
+      wk = nil
 
-    def delsnap(sid, &blk)
-      req = Request.new
-      req.verb = Request::Verb::DELSNAP
-      req.id = sid
+      req.metadef :cancel do
+        wt.cancel if wt
+        wk.cancel if wk
+      end
+
+      wk = walk(rev, glob).valid do |e|
+        req.emit(:valid, e)
+      end.error do |e|
+        req.emit(:error, e)
+      end.done do
+        req.emit(:done)
+
+        wt = watch(rev+1, glob).valid do |e|
+          req.emit(:valid, e)
+        end.error do |e|
+          req.emit(:error, e)
+        end
+      end
 
-      send(req, &blk)
+      req
     end
 
     def noop(&blk)
       req = Request.new
       req.verb = Request::Verb::NOOP
 
-      send(req, &blk)
+      send(req)
     end
 
     # Be careful with this.  It is recommended you use #cancel on the Request
     # returned to ensure you don't run into a race-condition where you cancel an
     # operation you may have thought was something else.
-    def __cancel__(what, &blk)
+    def __cancel__(what)
       req = Request.new
       req.verb = Request::Verb::CANCEL
       req.id = what.tag
@@ -183,39 +211,28 @@ module Fraggle
       # Hold on to the tag as unavaiable for reuse until the cancel succeeds.
       @cbx[what.tag] = nil
 
-      send(req) do |res|
+      send(req).valid do |res|
         # Do not send any more responses from the server to this request.
         @cbx.delete(what.tag)
-        blk.call(res) if blk
+        what.emit(:valid, res)
       end
     end
 
-    def send(req, &blk)
-      if ! req.tag
-        tag = MinTag
+    def next_tag
+      tag = MinTag
 
-        while @cbx.has_key?(tag)
-          tag += 1
-          if tag > MaxTag
-            tag = MinTag
-          end
+      while @cbx.has_key?(tag)
+        tag += 1
+        if tag > MaxTag
+          tag = MinTag
         end
-
-        req.tag = tag
       end
 
-      if blk
-        req.valid(&blk)
-      end
+      tag
+    end
 
-      # Setup a default error handler that gives useful information
-      req.error do |e|
-        warn("'error (%d) (%s)' for: %s" % [
-          e.err_code,
-          e.err_detail.inspect,
-          req.inspect
-        ])
-      end
+    def send(req)
+      req.tag ||= next_tag
 
       @cbx[req.tag] = req
 
@@ -225,6 +242,44 @@ module Fraggle
       req
     end
 
+    def resend(req)
+      req.tag ||= next_tag
+
+      wrap = Request.new(req.to_hash)
+
+      req.valid do |e|
+        if req.offset
+          req.offset += 1
+        end
+
+        if req.limit
+          req.limit -= 1
+        end
+
+        if (req.rev || 0) < (e.rev || 0)
+          req.rev = e.rev
+        end
+
+        wrap.emit(:valid, e)
+      end
+
+      req.error do |err|
+        if err.disconnected?
+          send(req)
+        else
+          wrap.emit(:error, err)
+        end
+      end
+
+      req.done do
+        wrap.emit(:done)
+      end
+
+      send(req)
+
+      wrap
+    end
+
     def cancelable(req)
       c   = self
       can = true
@@ -246,88 +301,52 @@ module Fraggle
     def post_init
       info "successfully connected to #{@addr}"
 
-      @last_received = Time.now
-
-      # We've been connected to a new server.  Notify all requests.
-      @cbx.values.each do |req|
-        req.emit(:again, req)
+      res = Response.new(:err_code => Errno::ECONNREFUSED::Errno)
+      @cbx.values.compact.each do |req|
+        debug "sending disconnected error to #{req.inspect}"
+        req.emit(:error, res)
       end
 
-      EM.add_periodic_timer(2) do
-        if (n = Time.now - last_received) >= 3
-          error("timeout talking to #{@addr}")
-          close_connection
-        else
-          get(0, "/ping")
-        end
+      if ! @tracking
+        trackaddrs
+        @tracking = true
       end
+    end
 
-      waw = Proc.new do |e|
-        if e.value != ""
-          addr = @addrs.delete(e.value)
-          if addr
-            error "noticed #{addr} is gone; removing"
-          end
-        else
-          get 0, "/doozer/info/#{e.value}/public-addr" do |a|
-            addr = a.value.to_s
-            if @shun.has_key?(addr)
-              if (n = Time.now - @shun[addr]) > 3
-                info "pardoning #{addr} after #{n} secs"
-                @shun.delete(addr)
-              else
-                info "ignoring shunned addr #{addr}"
-                next
-              end
+    # Track addresses of doozers in a cluster.  This will retry
+    # in the event of a new connection.
+    def trackaddrs
+      rev.valid do |v|
+        monitor(v.rev, "/doozer/slot/*").valid do |e|
+          if e.value == ""
+            @addrs.delete(e.path)
+          else
+            get(v.rev, "/doozer/info/#{e.value}/addr").valid do |g|
+              next if g.value == @addr
+              @addrs[e.path] = g.value
             end
-            # TODO: Be defensive and check the addr value is valid
-            @addrs[e.path] = addr
-            info("added #{e.path} addr #{addr}")
           end
+        end.error do |err|
+          error "address tracking: #{err.inspect} for #{req.inspect}"
         end
       end
-
-      watch("/doozer/slot/*", &waw)
-
-      w = walk(0, "/doozer/slot/*", &waw)
-      w.done do
-        # We have the best known addrs;  We can clear the initial
-        # ones given at inception.
-        debug "addrs list complete; clearing init addrs"
-        @init.clear
-      end
     end
 
     # What happens when a connection is closed for any reason.
     def unbind
-      warn "disconnected from #{@addr}"
-
-      # Shun the address we were currently attempting/connected to.
-      @shun[@addr] = Time.now
-      @addrs.delete_if {|_, v| v == @addr }
-
-      # We don't want the timer to race us while
-      # we're trying to reconnect.  Once the reconnect
-      # has been complete, we'll start the timer again.
-      EM.cancel_timer(@timer)
+      info "disconnected from #{@addr}"
 
-      # Attempt to use an addr given to us by a Doozer
       _, @addr = @addrs.shift
-
-      if ! @addr
-        # As a last resort, try one of the addresses given
-        # at inception.
-        @addr = @init.shift
-      end
-
       if ! @addr
-        # We are all out of addresses to try
-        raise NoAddrs
+        raise "No more addrs"
       end
 
       host, port = @addr.split(":")
-      info "attempting reconnect to #{host}:#{port}"
+
+      info "attempting connection to #{@addr}"
+
       reconnect(host, port.to_i)
+
       post_init
     end
 

data/lib/fraggle/msg.rb

@@ -8,23 +8,22 @@ module Fraggle
     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               => {}
+      CHECKIN  = 0;  # rev, id          => rev
+      GET      = 1;  # path, id         => rev, value
+      SET      = 2;  # rev, path, value => rev
+      DEL      = 3;  # rev, path        => {}
+      ESET     = 4;  # rev, path        => {}
+      REV      = 5;  # {}               => seqn, id
       NOOP     = 7;  # {}               => {}
-      WATCH    = 8;  # path             => {cas, path, value}+
+      WATCH    = 8;  # path             => {rev, path, value}+
       CANCEL   = 10; # id               => {}
-      STAT     = 16; # path, id         => cas, len
+      STAT     = 16; # path, id         => rev, len
 
       # future
-      GETDIR   = 14; # path             => {cas, value}+
-      MONITOR  = 11; # path             => {cas, path, value}+
-      SYNCPATH = 12; # path             => cas, value
-      WALK     = 9;  # path, id         => {cas, path, value}+
+      GETDIR   = 14; # path             => {rev, value}+
+      MONITOR  = 11; # path             => {rev, path, value}+
+      SYNCPATH = 12; # path             => rev, value
+      WALK     = 9;  # path, id         => {rev, path, value}+
 
       # deprecated
       JOIN     = 13;
@@ -32,7 +31,6 @@ module Fraggle
 
     required :verb, Verb, 2
 
-    optional :cas,   :int64,  3
     optional :path,  :string, 4
     optional :value, :bytes,  5
     optional :id,    :int32,  6
@@ -40,6 +38,7 @@ module Fraggle
     optional :offset, :int32, 7
     optional :limit,  :int32, 8
 
+    optional :rev,    :int64, 9
   end
 
 
@@ -56,18 +55,13 @@ module Fraggle
     optional :id,    :int32,  7
     optional :len,   :int32,  8
 
-    module Flag
-      VALID = 1
-      DONE  = 2
-    end
-
     module Err
       # don't use value 0
       OTHER        = 127
       TAG_IN_USE   = 1
       UNKNOWN_VERB = 2
       REDIRECT     = 3
-      INVALID_SNAP = 4
+      TOO_LATE     = 4
       CAS_MISMATCH = 5
 
       # match unix errno

data/lib/fraggle/response.rb

@@ -9,27 +9,35 @@ module Fraggle
 
   class Response
 
+    module Flag
+      VALID = 1
+      DONE  = 2
+      SET   = 4
+      DEL   = 8
+    end
+
+
     Missing =  0
     Clobber = -1
     Dir     = -2
-    Dummy   = -3
+    Nop   = -3
 
     Refused = -1
 
     # CAS
-    def missing?  ; cas == Missing ; end
-    def dir?      ; cas == Dir     ; end
-    def dummy?    ; cas == Dummy   ; end
+    def missing?  ; rev == Missing ; end
+    def dir?      ; rev == Dir     ; end
+    def dummy?    ; rev == Nop     ; end
 
-    def del?      ; missing?       ; end
-    def set?      ; !del?          ; end
+    def del?      ; (flags & Flag::Del) > 0 ; end
+    def set?      ; (flags & Flag::Set) > 0 ; end
 
     # ERR
     def ok?           ; err_code != 0                 ; end
     def other?        ; err_code == Err::OTHER        ; 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 too_late?     ; err_code == Err::TOO_LATE     ; end
     def mismatch?     ; err_code == Err::CAS_MISMATCH ; end
     def not_dir?      ; err_code == Err::NOT_DIR      ; end
     def is_dir?       ; err_code == Err::ISDIR        ; end

data/lib/fraggle.rb

@@ -1,6 +1,6 @@
+require 'fraggle/client'
 require 'fraggle/errors'
 require 'fraggle/logger'
-require 'fraggle/snap'
 require 'uri'
 
 module Fraggle
@@ -15,11 +15,13 @@ module Fraggle
     "ca=127.0.0.1:8042&"+
     "ca=127.0.0.1:8043"
 
-  def self.connect(uri=ENV["DOOZER_URI"] || DefaultUri)
+  def self.connect(*args)
+    opts  = args.last.is_a?(Hash) ? args.pop : {}
+    uri   = args.shift || ENV["DOOZER_URI"] || DefaultUri
     addrs = addrs_for(uri)
+
     host, port = addrs.first.split(":")
-    c = EM.connect(host, port, Client, addrs)
-    Snap.new(0, c)
+    EM.connect(host, port, Client, addrs.shift, addrs, opts)
   end
 
   def self.addrs_for(uri)

data/test/fraggle_client_test.rb

@@ -13,14 +13,14 @@ class FraggleClientTest < Test::Unit::TestCase
   end
 
   def test_send_recv
-    req = c.send(Fraggle::Request.new, &blk)
+    req = c.send(Fraggle::Request.new).valid(&blk)
 
     assert_sent req.tag
     assert_recv reply(req.tag)
   end
 
   def test_valid
-    req = c.send(Fraggle::Request.new, &blk)
+    req = c.send(Fraggle::Request.new).valid(&blk)
 
     reply(req.tag)
     reply(req.tag)
@@ -74,100 +74,84 @@ class FraggleClientTest < Test::Unit::TestCase
 
   # CHECKIN cas, path         => cas
   def test_checkin
-    req = c.checkin("abc123", 123, &blk)
+    req = c.checkin("abc123", 123).valid(&blk)
 
-    assert_sent(req.tag, :verb => V::CHECKIN, :path => "abc123", :cas => 123)
-    assert_recv(reply(req.tag, :cas => 123))
+    assert_sent(req.tag, :verb => V::CHECKIN, :path => "abc123", :rev => 123)
+    assert_recv(reply(req.tag, :rev => 123))
   end
 
   # GET     path, id         => cas, value
   def test_get
-    req = c.get(0, "/ping", &blk)
+    req = c.get(0, "/ping").valid(&blk)
 
-    assert_sent req.tag, :verb => V::GET, :path => "/ping"
+    assert_sent req.tag, :rev => 0, :verb => V::GET, :path => "/ping"
     assert_recv reply(req.tag, :cas => 123, :value => "pong")
   end
 
   # STAT     path, id         => cas, len
   def test_stat
-    req = c.stat(0, "/ping", &blk)
+    req = c.stat(0, "/ping").valid(&blk)
 
-    assert_sent req.tag, :verb => V::STAT, :path => "/ping"
+    assert_sent req.tag, :rev => 0, :verb => V::STAT, :path => "/ping"
     assert_recv reply(req.tag, :cas => 123, :len => 4)
   end
 
   # GETDIR     id, path, offset, limit         => {cas, value}+
   def test_getdir
-    req = c.getdir(0, "/test", 0, 0, &blk)
+    req = c.getdir(0, "/test", nil, nil).valid(&blk)
 
-    assert_sent req.tag, :verb => V::GETDIR, :path => "/test"
-    assert_recv reply(req.tag, :cas => 123, :value => "a")
+    assert_sent req.tag, :rev => 0, :verb => V::GETDIR, :path => "/test"
+    assert_recv reply(req.tag, :rev => 123, :value => "a")
 
-    req = c.getdir(0, "/test", 1, 2, &blk)
+    req = c.getdir(0, "/test", 1, 2).valid(&blk)
 
-    assert_sent req.tag, :verb => V::GETDIR, :path => "/test", :offset => 1, :limit => 2
+    assert_sent req.tag, :rev => 0, :verb => V::GETDIR, :path => "/test", :offset => 1, :limit => 2
     assert_recv reply(req.tag, :cas => 123, :value => "b")
   end
 
   # SET     cas, path, value => cas
   def test_set
-    req = c.set("/foo", "bar", 123, &blk)
+    req = c.set("/foo", "bar", 123).valid(&blk)
 
-    assert_sent(req.tag, :verb => V::SET,  :cas => 123, :path => "/foo", :value => "bar")
-    assert_recv(reply(req.tag, :cas => 123))
+    assert_sent(req.tag, :verb => V::SET,  :rev => 123, :path => "/foo", :value => "bar")
+    assert_recv(reply(req.tag, :rev => 123))
   end
 
   # DEL     cas, path        => {}
   def test_del
-    req = c.del("/foo", 123, &blk)
+    req = c.del("/foo", 123).valid(&blk)
 
-    assert_sent(req.tag, :verb => V::DEL, :cas => 123, :path => "/foo")
+    assert_sent(req.tag, :verb => V::DEL, :rev => 123, :path => "/foo")
     assert_recv(reply(req.tag))
   end
 
   # WALK     path, id         => {cas, path, value}+
   def test_walk
-    req = c.walk(0, "/foo/*", &blk)
+    req = c.walk(nil, "/foo/*").valid(&blk)
 
     assert_respond_to req, :cancel
 
     assert_sent(req.tag, :verb => V::WALK, :path => "/foo/*")
-    assert_recv(reply(req.tag, :cas => 123, :path => "/foo/a", :value => "1"))
-    assert_recv(reply(req.tag, :cas => 456, :path => "/foo/b", :value => "2"))
-    assert_recv(reply(req.tag, :cas => 789, :path => "/foo/c", :value => "3"))
+    assert_recv(reply(req.tag, :rev => 123, :path => "/foo/a", :value => "1"))
+    assert_recv(reply(req.tag, :rev => 456, :path => "/foo/b", :value => "2"))
+    assert_recv(reply(req.tag, :rev => 789, :path => "/foo/c", :value => "3"))
   end
 
   # WATCH    path             => {cas, path, value}+
   def test_watch
-    req = c.watch("/foo/*", &blk)
+    req = c.watch(123, "/foo/*").valid(&blk)
 
     assert_respond_to req, :cancel
 
-    assert_sent(req.tag, :verb => V::WATCH, :path => "/foo/*")
+    assert_sent(req.tag, :rev => 123, :verb => V::WATCH, :path => "/foo/*")
     assert_recv(reply(req.tag, :cas => 123, :path => "/foo/a", :value => "1"))
     assert_recv(reply(req.tag, :cas => 456, :path => "/foo/b", :value => "2"))
     assert_recv(reply(req.tag, :cas => 789, :path => "/foo/c", :value => "3"))
   end
 
-  # SNAP     {}               => id
-  def test_snap
-    req = c.snap(&blk)
-
-    assert_sent(req.tag, :verb => V::SNAP)
-    assert_recv(reply(req.tag, :id => 1))
-  end
-
-  # DELSNAP  id               => {}
-  def test_delsnap
-    req = c.delsnap(1, &blk)
-
-    assert_sent(req.tag, :verb => V::DELSNAP, :id => 1)
-    assert_recv(reply(req.tag))
-  end
-
   # NOOP     {}               => {}
   def test_noop
-    req = c.noop(&blk)
+    req = c.noop.valid(&blk)
 
     assert_sent(req.tag, :verb => V::NOOP)
     assert_recv(reply(req.tag))
@@ -175,8 +159,8 @@ class FraggleClientTest < Test::Unit::TestCase
 
   # CANCEL   id               => {}
   def test_cancel
-    nop = c.noop(&blk)
-    req = c.__cancel__(nop, &blk)
+    nop = c.noop.valid(&blk)
+    req = c.__cancel__(nop).valid(&blk)
 
     assert_sent(req.tag, :verb => V::CANCEL, :id => nop.tag)
     assert_recv(reply(req.tag))
@@ -202,7 +186,7 @@ class FraggleClientTest < Test::Unit::TestCase
   end
 
   def test_cancel_does_not_prematurely_remove_callback
-    x = c.watch("/foo/*", &blk)
+    x = c.watch(123, "/foo/*").valid(&blk)
     y = x.cancel
 
     assert_not_equal x.object_id, y.object_id
@@ -210,7 +194,7 @@ class FraggleClientTest < Test::Unit::TestCase
   end
 
   def test_cancel_discards_further_replies
-    x = c.watch("/foo/*", &blk)
+    x = c.watch(123, "/foo/*").valid(&blk)
     x.cancel
 
     reply!(x.tag)
@@ -221,7 +205,7 @@ class FraggleClientTest < Test::Unit::TestCase
   end
 
   def test_tag_pending_cancel_is_not_useable
-    x = c.watch("/foo/*", &blk)
+    x = c.watch(123, "/foo/*").valid(&blk)
     y = x.cancel
 
     # Force a reset of tag so that `send` will attempt
@@ -235,7 +219,7 @@ class FraggleClientTest < Test::Unit::TestCase
   end
 
   def test_reuse_canceled_tag
-    x = c.watch("/foo/*", &blk)
+    x = c.watch(123, "/foo/*").valid(&blk)
     y = x.cancel
 
     reply!(y.tag)

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: fraggle
 version: !ruby/object:Gem::Version 
-  hash: 25
+  hash: 15
   prerelease: 
   segments: 
   - 0
-  - 3
-  - 5
-  version: 0.3.5
+  - 4
+  - 0
+  version: 0.4.0
 platform: ruby
 authors: 
 - Blake Mizerany
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-02-10 00:00:00 -08:00
+date: 2011-03-21 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -55,12 +55,10 @@ files:
 - lib/fraggle/protocol.rb
 - lib/fraggle/request.rb
 - lib/fraggle/response.rb
-- lib/fraggle/snap.rb
 - lib/fraggle/test.rb
 - lib/fraggle.rb
 - test/fraggle_client_test.rb
 - test/fraggle_protocol_test.rb
-- test/fraggle_snap_test.rb
 - test/fraggle_test.rb
 has_rdoc: true
 homepage: http://github.com/bmizerany/fraggle
@@ -104,5 +102,4 @@ summary: A Ruby/EventMachine Client for Doozer
 test_files: 
 - test/fraggle_client_test.rb
 - test/fraggle_protocol_test.rb
-- test/fraggle_snap_test.rb
 - test/fraggle_test.rb

data/lib/fraggle/snap.rb

@@ -1,52 +0,0 @@
-require 'fraggle/client'
-
-module Fraggle
-
-  class Snap
-
-    attr_reader :id, :rev, :c
-
-    def initialize(id, c, rev=nil)
-      @id  = id
-      @c   = c
-      @rev = rev
-    end
-
-    def get(path, &blk)
-      @c.get(@id, path, &blk)
-    end
-
-    def walk(glob, &blk)
-      @c.walk(@id, glob, &blk)
-    end
-
-    def stat(path, &blk)
-      @c.stat(@id, path, &blk)
-    end
-
-    def getdir(path, offset=0, limit=0, &blk)
-      @c.getdir(@id, path, offset, limit, &blk)
-    end
-
-    def snap(&blk)
-      @c.snap do |res|
-        sn = Snap.new(res.id, @c, res.rev)
-        blk.call(sn)
-      end
-    end
-
-    def delete(&blk)
-      @c.delsnap(@id, &blk)
-    end
-
-    def send(req, &blk)
-      @c.send(req, &blk)
-    end
-
-    def method_missing(*args, &blk)
-      @c.__send__(*args, &blk)
-    end
-
-  end
-
-end

data/test/fraggle_snap_test.rb

@@ -1,67 +0,0 @@
-require 'fraggle/test'
-require 'fraggle/snap'
-
-class FraggleSnapTest < Test::Unit::TestCase
-  include Fraggle::Test
-
-  attr_reader :c, :blk
-
-  def setup
-    cl   = TestClient.new(["127.0.0.1:8046"])
-    @c   = Fraggle::Snap.new(1, cl)
-    @blk = Blk.new
-  end
-
-  def test_get
-    req = c.get("/ping", &blk)
-
-    assert_sent req.tag, :verb => V::GET, :id => 1, :path => "/ping"
-    assert_recv reply(req.tag)
-  end
-
-  def test_stat
-    req = c.stat("/ping", &blk)
-
-    assert_sent req.tag, :verb => V::STAT, :id => 1, :path => "/ping"
-    assert_recv reply(req.tag)
-  end
-
-  def test_getdir
-    req = c.getdir("/test", &blk)
-
-    assert_sent req.tag, :verb => V::GETDIR, :path => "/test", :id => 1
-    assert_recv reply(req.tag)
-
-    req = c.getdir("/test", 1, 2, &blk)
-
-    assert_sent req.tag, :verb => V::GETDIR, :path => "/test", :offset => 1, :limit => 2, :id => 1
-    assert_recv reply(req.tag)
-  end
-
-  def test_walk
-    req = c.walk("/letters/*", &blk)
-
-    assert_sent req.tag, :verb => V::WALK, :id => 1, :path => "/letters/*"
-    assert_recv reply(req.tag)
-  end
-
-  def test_other
-    req = c.noop(&blk)
-
-    assert_sent req.tag, :verb => V::NOOP
-    assert_recv reply(req.tag)
-  end
-
-  def test_snap
-    b = nil
-    a = c.snap do |sn|
-      b = sn.get("/ping")
-    end
-
-    reply(a.tag, :id => 99)
-
-    assert_sent a.tag, :verb => V::SNAP
-    assert_sent b.tag, :verb => V::GET, :id => 99, :path => "/ping"
-  end
-
-end