fraggle 1.0.1 → 2.0.0

data/README.md

@@ -1,4 +1,8 @@
-# Fraggle (v1.0.0.pre.2 is compatable with Doozer 0.5)
+# Fraggle (v2.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.
+
 **An EventMachine based Doozer client**
 
 ## Install
@@ -90,16 +94,14 @@ 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) { ... }
 
+NOTE:  Doozer's data store is a persistent data structure.  You can reference the
+stores history as far back as it is configured to hold it.  The default is
+360,000 revisions.  See [data model][] for more information.
+
 ## 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
@@ -107,21 +109,14 @@ This also means you can go back in time or into the future!
   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.
+  reads; Fraggle gracefully handles it for you.
 
   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
+  idempotent requests.  A rev of 0 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**
@@ -133,3 +128,10 @@ This also means you can go back in time or into the future!
     $ gem install turn
 
     $ turn
+
+**Mailing List**
+
+Please join the Doozer mailing list for help:
+http://groups.google.com/forum/#!forum/doozer
+
+[data model]: https://github.com/ha/doozerd/blob/master/doc/data-model.md

data/Rakefile

@@ -2,7 +2,7 @@ require 'bundler'
 Bundler::GemHelper.install_tasks
 
 HOME  = ENV["HOME"]
-PBDIR = HOME+"/src/doozer/src/pkg/proto"
+PBDIR = HOME+"/src/doozerd/src/pkg/server"
 
 namespace :proto do
   task :update do

data/example/getdir.rb

@@ -4,16 +4,55 @@ 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
 
-  ents = []
-  c.getdir("/") do |e|
+  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
-  end.done do
-    p [:ents, ents]
-  end.error do |e|
-    raise StandardError.new("err: "+e.inspect)
+    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/resend.rb

@@ -9,13 +9,14 @@ require 'fraggle'
 #
 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(100_000, "/foo") do |e|
+  c.get("/foo", 100_000) do |e|
     p ["This should not be!", e]
   end.error do |e|
     p [:err, e]

data/example/set.rb

@@ -2,8 +2,11 @@ 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|
@@ -11,7 +14,7 @@ EM.run do
     end
   end
 
-  c.set('/hello', 'world', 0) do |e|
-    p e
+  c.set('/hello', 'world', MaxInt64) do |e|
+    p [:set, e]
   end
 end

data/lib/fraggle/client.rb

@@ -16,7 +16,6 @@ module Fraggle
 
     def initialize(cn, addrs, log=DefaultLog)
       @cn, @addrs, @log = cn, addrs, log
-      monitor_addrs
     end
 
     def addr
@@ -54,41 +53,31 @@ module Fraggle
       idemp(req)
     end
 
-    def getdir(path, rev=nil, offset=nil, limit=nil, &blk)
+    def getdir(path, rev=nil, offset=nil, &blk)
       req = Request.new
-      req.verb = GETDIR
-      req.rev  = rev
-      req.path = path
-
-      # 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.verb   = GETDIR
+      req.rev    = rev
+      req.path   = path
+      req.offset = offset
       req.valid(&blk)
 
       resend(req)
     end
 
-    def walk(path, rev=nil, offset=nil, limit=nil, &blk)
+    def walk(path, rev=nil, offset=nil, &blk)
       req = Request.new
-      req.verb = WALK
-      req.rev  = rev
-      req.path = path
-
-      # 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.verb   = WALK
+      req.rev    = rev
+      req.path   = path
+      req.offset = offset
       req.valid(&blk)
 
       resend(req)
     end
 
-    def watch(path, rev=nil, &blk)
+    def wait(path, rev=nil, &blk)
       req = Request.new
-      req.verb = WATCH
+      req.verb = WAIT
       req.rev  = rev
       req.path = path
       req.valid(&blk)
@@ -114,43 +103,6 @@ module Fraggle
       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
@@ -159,20 +111,6 @@ module Fraggle
 
       wr.valid do |e|
         log.debug("response: #{e.inspect} for #{req.inspect}")
-
-        if req.offset
-          req.offset += 1
-        end
-
-        if req.limit
-          req.limit -= 1
-        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
 
@@ -195,9 +133,9 @@ module Fraggle
           else
             req.emit(:error, e)
           end
-        when e.redirect?
+        when e.readonly?
 
-          log.error("redirect: #{req.inspect}")
+          log.error("readonly: #{req.inspect}")
 
           # Closing the connection triggers a reconnect above.
           cn.close_connection

data/lib/fraggle/connection.rb

@@ -55,25 +55,16 @@ module Fraggle
         return
       end
 
-      req = @cb[res.tag]
+      req = @cb.delete(res.tag)
 
       if ! req
         return
       end
 
-      if ! res.ok?
-        @cb.delete(req.tag)
-        req.emit(:error, res)
-        return
-      end
-
-      if res.valid?
+      if res.ok?
         req.emit(:valid, res)
-      end
-
-      if res.done?
-        @cb.delete(req.tag)
-        req.emit(:done)
+      else
+        req.emit(:error, res)
       end
     end
 
@@ -106,22 +97,6 @@ module Fraggle
       req
     end
 
-    def post_init
-      last = 0
-      rev  = Request.new :verb => Request::Verb::REV
-
-      rev.valid do |e|
-        if e.rev <= last
-          close_connection
-        else
-          timer(5) { send_request(rev.dup) }
-          last = e.rev
-        end
-      end
-
-      send_request(rev.dup)
-    end
-
     def unbind
       @err = true
       @cb.values.each do |req|

data/lib/fraggle/msg.pb.rb

@@ -1,4 +1,4 @@
-## Generated from msg.proto for proto
+## Generated from msg.proto for server
 require "beefcake"
 
 module Fraggle
@@ -7,27 +7,23 @@ module Fraggle
     include Beefcake::Message
 
     module Verb
-      CHECKIN = 0
       GET = 1
       SET = 2
       DEL = 3
-      ESET = 4
       REV = 5
+      WAIT = 6
       NOP = 7
-      WATCH = 8
       WALK = 9
-      CANCEL = 10
       GETDIR = 14
       STAT = 16
     end
 
-    required :tag, :int32, 1
-    required :verb, Request::Verb, 2
+    optional :tag, :int32, 1
+    optional :verb, Request::Verb, 2
     optional :path, :string, 4
     optional :value, :bytes, 5
     optional :other_tag, :int32, 6
     optional :offset, :int32, 7
-    optional :limit, :int32, 8
     optional :rev, :int64, 9
 
   end
@@ -39,18 +35,19 @@ module Fraggle
       OTHER = 127
       TAG_IN_USE = 1
       UNKNOWN_VERB = 2
-      REDIRECT = 3
+      READONLY = 3
       TOO_LATE = 4
       REV_MISMATCH = 5
       BAD_PATH = 6
       MISSING_ARG = 7
+      RANGE = 8
       NOTDIR = 20
       ISDIR = 21
       NOENT = 22
     end
 
-    required :tag, :int32, 1
-    required :flags, :int32, 2
+    optional :tag, :int32, 1
+    optional :flags, :int32, 2
     optional :rev, :int64, 3
     optional :path, :string, 5
     optional :value, :bytes, 6

data/lib/fraggle/request.rb

@@ -32,13 +32,5 @@ module Fraggle
       (@cb[name] || DEFAULT_PROC).call(*args)
     end
 
-    def cancel
-      @can ||= Request.new(:verb => Verb::CANCEL, :other_tag => self.tag)
-      req = cn.send_request(@can)
-      req.done do
-        emit(:done)
-      end
-    end
-
   end
 end

data/lib/fraggle/response.rb

@@ -3,23 +3,11 @@ require 'fraggle/msg.pb'
 module Fraggle
   class Response
 
-    VALID = 1
-    DONE  = 2
     SET   = 4
     DEL   = 8
 
     attr_accessor :disconnected
 
-    def valid?
-      return false if !flags
-      (flags & VALID) > 0
-    end
-
-    def done?
-      return false if !flags
-      (flags & DONE) > 0
-    end
-
     def set?
       return false if !flags
       (flags & SET) > 0
@@ -38,8 +26,8 @@ module Fraggle
       err_code.nil?
     end
 
-    def redirect?
-      err_code == Err::REDIRECT
+    def readonly?
+      err_code == Err::READONLY
     end
 
     def disconnected?

data/lib/fraggle/version.rb

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

data/test/fraggle_client_test.rb

@@ -23,44 +23,13 @@ class FraggleClientTest < Test::Unit::TestCase
     @c.__send__(:initialize, cn, @addrs)
   end
 
-  def test_send_valid_done
-    req, log = request(V::NOP)
-    req = c.send(req)
-
-    res = Fraggle::Response.new :tag => req.tag, :value => "ing", :flags => F::VALID|F::DONE
-    c.cn.receive_response(res)
-
-    assert_equal [res], log.valid
-    assert_equal [req], log.done
-    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)
 
-    res = Fraggle::Response.new :tag => req.tag, :err_code => E::OTHER, :flags => F::VALID|F::DONE
+    res = Fraggle::Response.new :tag => req.tag, :err_code => E::OTHER
     c.cn.receive_response(res)
 
-    assert_equal [], log.valid
     assert_equal [], log.done
     assert_equal [res], log.error
   end
@@ -155,66 +124,7 @@ class FraggleClientTest < Test::Unit::TestCase
     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)
-
-    res = Fraggle::Response.new :tag => req.tag, :flags => F::VALID
-    c.cn.receive_response(res)
-
-    c.cn.close_connection
-
-    exp, _ = request(V::WALK, :tag => req.tag, :path => "/foo/*", :offset => 4)
-    assert_equal [exp], c.cn.sent
-  end
-
-  def test_manage_limit
-    req, log = request(V::WALK, :path => "/foo/*", :limit => 4)
-    req = c.resend(req)
-
-    res = Fraggle::Response.new :tag => req.tag, :flags => F::VALID
-    c.cn.receive_response(res)
-
-    c.cn.close_connection
-
-    exp, _ = request(V::WALK, :tag => req.tag, :path => "/foo/*", :limit => 3)
-    assert_equal [exp], c.cn.sent
-  end
-
-  def test_manage_rev
-    req, log = request(V::WALK, :path => "/foo/*", :rev => 4)
-    req = c.resend(req)
-
-    # nil rev
-    res = Fraggle::Response.new :tag => req.tag, :flags => F::VALID
-    c.cn.receive_response(res)
-    assert_equal 4, req.rev
-
-    # equal to rev
-    res = Fraggle::Response.new :tag => req.tag, :rev => 4, :flags => F::VALID
-    c.cn.receive_response(res)
-    assert_equal 4, req.rev
-
-    # less than rev
-    res = Fraggle::Response.new :tag => req.tag, :rev => 3, :flags => F::VALID
-    c.cn.receive_response(res)
-    assert_equal 4, req.rev
-
-    # greater than rev
-    # NOTE: This will never happen in life on a WALK, this is purely a
-    # test.
-    res = Fraggle::Response.new :tag => req.tag, :rev => 5, :flags => F::VALID
-    c.cn.receive_response(res)
-    assert_equal 5, req.rev
-
-    # force retry
-    c.cn.close_connection
-
-    exp, _ = request(V::WALK, :tag => req.tag, :rev => 5, :path => "/foo/*")
-    assert_equal [exp], c.cn.sent
-  end
-
-  def test_redirect_simple
+  def test_readonly_simple
     a, al = request(V::SET, :rev => 0, :path => "/foo")
     a = c.send(a)
 
@@ -223,9 +133,8 @@ class FraggleClientTest < Test::Unit::TestCase
 
     res = Fraggle::Response.new(
       :tag => a.tag,
-      :err_code => E::REDIRECT,
-      :err_detail => "9.9.9.9:9",
-      :flags => F::VALID|F::DONE
+      :err_code => E::READONLY,
+      :err_detail => "9.9.9.9:9"
     )
 
     c.cn.receive_response(res)
@@ -291,11 +200,10 @@ class FraggleClientTest < Test::Unit::TestCase
       :verb => V::GETDIR,
       :rev => 0,
       :path => "/foo",
-      :offset => 0,
-      :limit => 5
+      :offset => 0
     }
 
-    assert_verb exp, :getdir, "/foo", 0, 0, 5
+    assert_verb exp, :getdir, "/foo", 0, 0
   end
 
   def test_rev
@@ -317,18 +225,6 @@ class FraggleClientTest < Test::Unit::TestCase
   end
 
   def test_walk
-    exp = {
-      :verb => V::WALK,
-      :rev => 0,
-      :path => "/foo/*",
-      :offset => 0,
-      :limit => 5
-    }
-
-    assert_verb exp, :walk, "/foo/*", 0, 0, 5
-  end
-
-  def test_walk_no_offset_limit_given
     exp = {
       :verb => V::WALK,
       :rev => 0,
@@ -336,17 +232,17 @@ class FraggleClientTest < Test::Unit::TestCase
       :offset => 0
     }
 
-    assert_verb exp, :walk, "/foo/*", 0
+    assert_verb exp, :walk, "/foo/*", 0, 0
   end
 
-  def test_watch
+  def test_wait
     exp = {
-      :verb => V::WATCH,
+      :verb => V::WAIT,
       :rev => 0,
       :path => "/foo/*"
     }
 
-    assert_verb exp, :watch, "/foo/*", 0
+    assert_verb exp, :wait, "/foo/*", 0
   end
 
 end

data/test/fraggle_protocol_test.rb

@@ -15,23 +15,23 @@ class FraggleProtocolTest < Test::Unit::TestCase
   end
 
   def test_simple
-    req = Fraggle::Response.new :tag => 0, :verb => V::NOP, :flags => F::VALID
+    req = Fraggle::Response.new :tag => 0, :verb => V::NOP
     cn.receive_data(encode(req))
 
     assert_equal [req], cn.received
   end
 
   def test_multiple_single
-    a = Fraggle::Response.new :tag => 0, :verb => V::NOP, :flags => F::VALID
-    b = Fraggle::Response.new :tag => 1, :verb => V::NOP, :flags => F::VALID
+    a = Fraggle::Response.new :tag => 0, :verb => V::NOP
+    b = Fraggle::Response.new :tag => 1, :verb => V::NOP
     cn.receive_data(encode(a) + encode(b))
 
     assert_equal [a, b], cn.received
   end
 
   def test_multiple_double
-    a = Fraggle::Response.new :tag => 0, :verb => V::NOP, :flags => F::VALID
-    b = Fraggle::Response.new :tag => 1, :verb => V::NOP, :flags => F::VALID
+    a = Fraggle::Response.new :tag => 0, :verb => V::NOP
+    b = Fraggle::Response.new :tag => 1, :verb => V::NOP
     cn.receive_data(encode(a))
     cn.receive_data(encode(b))
 
@@ -39,7 +39,7 @@ class FraggleProtocolTest < Test::Unit::TestCase
   end
 
   def test_small_chunks
-    req = Fraggle::Response.new :tag => 0, :verb => V::NOP, :flags => F::VALID
+    req = Fraggle::Response.new :tag => 0, :verb => V::NOP
 
     bytes = encode(req) * 3
     len   = bytes.length
@@ -53,7 +53,7 @@ class FraggleProtocolTest < Test::Unit::TestCase
   end
 
   def test_big_chunks
-    req = Fraggle::Response.new :tag => 0, :verb => V::NOP, :flags => F::VALID
+    req = Fraggle::Response.new :tag => 0, :verb => V::NOP
 
     bytes = encode(req) * 3
     len   = bytes.length

data/test/fraggle_transaction_test.rb

@@ -26,42 +26,19 @@ class FraggleTransactionTest < Test::Unit::TestCase
     req, log =  nop
     req = cn.send_request(req)
 
-    res = Fraggle::Response.new :tag => req.tag, :flags => F::VALID
+    res = Fraggle::Response.new :tag => req.tag
     cn.receive_response(res)
 
     assert_equal [res], log.valid
     assert_equal [], log.done
   end
 
-  def test_done
-    req, log = nop
-    req = cn.send_request(req)
-
-    res = Fraggle::Response.new :tag => req.tag, :flags => F::DONE
-    cn.receive_response(res)
-
-    assert_equal [], log.valid
-    assert_equal [req], log.done
-  end
-
-  def test_valid_and_done
-    req, log = nop
-    req = cn.send_request(req)
-
-    res = Fraggle::Response.new :tag => req.tag, :flags => F::VALID|F::DONE
-    cn.receive_response(res)
-
-    assert_equal [res], log.valid
-    assert_equal [req], log.done
-  end
-
   def test_error
     req, log = nop
     req = cn.send_request(req)
 
     res = Fraggle::Response.new(
       :tag => req.tag,
-      :flags => F::VALID|F::DONE,
       :err_code => E::OTHER
     )
 
@@ -75,7 +52,6 @@ class FraggleTransactionTest < Test::Unit::TestCase
   def test_invalid_tag
     res = Fraggle::Response.new(
       :tag => 0,
-      :flags => F::VALID|F::DONE,
       :err_code => E::OTHER
     )
 
@@ -84,11 +60,11 @@ class FraggleTransactionTest < Test::Unit::TestCase
     end
   end
 
-  def test_done_deletes_callback
+  def test_deletes_callback
     req, log = nop
     req = cn.send_request(req)
 
-    res = Fraggle::Response.new(:tag => req.tag, :flags => F::VALID|F::DONE)
+    res = Fraggle::Response.new(:tag => req.tag)
     cn.receive_response(res)
 
     # This should be ignored
@@ -97,13 +73,12 @@ class FraggleTransactionTest < Test::Unit::TestCase
     assert_equal [res], log.valid
   end
 
-  def test_error_with_done_deletes_callback
+  def test_error_deletes_callback
     req, log = nop
     req = cn.send_request(req)
 
     res = Fraggle::Response.new(
       :tag => req.tag,
-      :flags => F::VALID|F::DONE,
       :err_code => E::OTHER
     )
 
@@ -124,36 +99,6 @@ class FraggleTransactionTest < Test::Unit::TestCase
     end
   end
 
-  def test_cancel
-    req, _ = nop
-    req = cn.send_request(req)
-    can = req.cancel
-
-    canx = Fraggle::Response.new(:tag => can.tag, :flags => F::VALID|F::DONE)
-    cn.receive_response(canx)
-  end
-
-  def test_cannot_cancel_more_than_once
-    req, _ = nop
-    req = cn.send_request(req)
-    req.cancel
-
-    assert_raises Fraggle::Connection::SendError do
-      req.cancel
-    end
-  end
-
-  def test_cancel_emits_done
-    req, log = nop
-    req = cn.send_request(req)
-    can = req.cancel
-
-    canx = Fraggle::Response.new(:tag => can.tag, :flags => F::VALID|F::DONE)
-    cn.receive_response(canx)
-
-    assert_equal [req], log.done
-  end
-
   def test_disconnected
     a, al = nop
     a = cn.send_request(a)
@@ -180,7 +125,7 @@ class FraggleTransactionTest < Test::Unit::TestCase
 
     cn.unbind
 
-    res = Fraggle::Response.new(:tag => a.tag, :flags => F::VALID|F::DONE)
+    res = Fraggle::Response.new(:tag => a.tag)
     cn.receive_response(res)
 
     assert_equal [], al.valid
@@ -195,39 +140,4 @@ class FraggleTransactionTest < Test::Unit::TestCase
 
     assert_equal nil, log.error.first
   end
-
-  def test_liveness
-    live = cn.post_init
-
-    def cn.timer(_, &blk)
-      blk.call
-    end
-
-    res = Fraggle::Response.new(:tag => live.tag, :rev => 1, :flags => F::VALID|F::DONE)
-    cn.receive_response(res)
-    assert ! cn.err?
-
-    # Connections reuse tags and we're only responding to one request in this
-    # test, so we know the next rev will use the previous tag
-    res = Fraggle::Response.new(:tag => live.tag, :rev => 2, :flags => F::VALID|F::DONE)
-    cn.receive_response(res)
-    assert ! cn.err?
-  end
-
-  def test_not_alive
-    live = cn.post_init
-
-    def cn.timer(_, &blk)
-      blk.call
-    end
-
-    res = Fraggle::Response.new(:tag => live.tag, :rev => 1, :flags => F::VALID|F::DONE)
-    cn.receive_response(res)
-    assert ! cn.err?
-
-    res.tag += 1
-    cn.receive_response(res)
-    assert cn.err?
-  end
-
 end

data/test/helper.rb

@@ -71,14 +71,7 @@ class Test::Unit::TestCase
   end
 
   def reply(tag, attrs={})
-    attrs[:flags] ||= 0
-    attrs[:flags] |= F::VALID
     Fraggle::Response.new(attrs.merge(:tag => tag))
   end
 
-  def reply!(tag, attrs={})
-    attrs[:flags] = F::DONE
-    reply(tag, attrs)
-  end
-
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: fraggle
 version: !ruby/object:Gem::Version 
-  hash: 21
+  hash: 15
   prerelease: 
   segments: 
-  - 1
+  - 2
   - 0
-  - 1
-  version: 1.0.1
+  - 0
+  version: 2.0.0
 platform: ruby
 authors: 
 - Blake Mizerany
@@ -76,15 +76,13 @@ files:
 - LICENSE
 - README.md
 - Rakefile
-- example/addrs.rb
 - example/getdir.rb
-- example/redirect.rb
+- example/readonly.rb
 - example/resend.rb
 - example/rev.rb
 - example/set.rb
 - example/stat.rb
 - example/walk.rb
-- example/watch.rb
 - fraggle.gemspec
 - lib/fraggle.rb
 - lib/fraggle/client.rb

data/example/addrs.rb

@@ -1,13 +0,0 @@
-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/watch.rb

@@ -1,20 +0,0 @@
-require 'rubygems'
-require 'eventmachine'
-require 'fraggle'
-
-EM.run do
-
-  c = Fraggle.connect
-  c.log.level = Logger::DEBUG
-
-  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", -1)
-  end
-
-end