fraggle 0.4.0 → 1.0.0pre

data/lib/fraggle/connection.rb

@@ -0,0 +1,139 @@
+require 'fraggle/request'
+require 'fraggle/response'
+
+module Fraggle
+
+  module Connection
+
+    # Base class for all Connection errors
+    class Error < StandardError
+      attr_accessor :req
+
+      def initialize(req, msg=nil)
+        @req = req
+        super(msg)
+      end
+    end
+
+    # Raised when a request is invalid
+    class SendError < Error
+    end
+
+
+    attr_reader :last_received, :addr
+
+    def initialize(addr)
+      @addr, @cb = addr, {}
+    end
+
+    def receive_data(data)
+      @last_received = Time.now
+
+      (@buf ||= "") << data
+
+      while @buf.length > 0
+        if @len && @buf.length >= @len
+            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]
+        else
+          break
+        end
+      end
+    end
+
+    # The default receive_response
+    def receive_response(res)
+      req = @cb[res.tag]
+
+      if ! req
+        return
+      end
+
+      if ! res.ok?
+        @cb.delete(req.tag)
+        req.emit(:error, res)
+        return
+      end
+
+      if res.done?
+        @cb.delete(req.tag)
+        req.emit(:done)
+      end
+
+      if res.valid?
+        req.emit(:valid, res)
+      end
+    end
+
+    def send_request(req)
+      if req.tag
+        raise SendError, "Already sent #{req.inspect}"
+      end
+
+      if err?
+        next_tick { req.emit(:error, nil) }
+        return req
+      end
+
+      req.tag = 0
+      while @cb.has_key?(req.tag)
+        req.tag += 1
+
+        req.tag %= 2**31
+      end
+
+      req.cn = self
+
+      @cb[req.tag] = req
+
+      data = req.encode
+      head = [data.length].pack("N")
+
+      send_data("#{head}#{data}")
+
+      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|
+        req.emit(:error, nil)
+      end
+    end
+
+    def err?
+      !!@err
+    end
+
+    def timer(n, &blk)
+      EM.add_timer(n, &blk)
+    end
+
+    def next_tick(&blk)
+      EM.next_tick(&blk)
+    end
+
+  end
+
+end

data/lib/fraggle/msg.pb.rb

@@ -0,0 +1,62 @@
+## Generated from msg.proto for proto
+require "beefcake"
+
+module Fraggle
+
+  class Request
+    include Beefcake::Message
+
+    module Verb
+      CHECKIN = 0
+      GET = 1
+      SET = 2
+      DEL = 3
+      ESET = 4
+      REV = 5
+      NOP = 7
+      WATCH = 8
+      WALK = 9
+      CANCEL = 10
+      GETDIR = 14
+      STAT = 16
+    end
+
+    required :tag, :int32, 1
+    required :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
+
+  class Response
+    include Beefcake::Message
+
+    module Err
+      OTHER = 127
+      TAG_IN_USE = 1
+      UNKNOWN_VERB = 2
+      REDIRECT = 3
+      TOO_LATE = 4
+      REV_MISMATCH = 5
+      BAD_PATH = 6
+      MISSING_ARG = 7
+      NOTDIR = 20
+      ISDIR = 21
+      NOENT = 22
+    end
+
+    required :tag, :int32, 1
+    required :flags, :int32, 2
+    optional :rev, :int64, 3
+    optional :path, :string, 5
+    optional :value, :bytes, 6
+    optional :len, :int32, 8
+    optional :err_code, Response::Err, 100
+    optional :err_detail, :string, 101
+
+  end
+end

data/lib/fraggle/request.rb

@@ -1,15 +1,42 @@
-require 'fraggle/msg'
-require 'fraggle/emitter'
-
-##
-# An extension to Request in msg.rb. I want to keep these seperated so when
-# future versions of Beefcake can generate code, we don't have to manually add
-# this back in for each generation.
+require 'fraggle/msg.pb'
 
 module Fraggle
-
   class Request
-    include Emitter
-  end
 
+    attr_accessor :cn
+    attr_reader   :cb
+
+    def initialize(attrs={})
+      super(attrs)
+      @cb = Hash.new(Proc.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].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

@@ -1,49 +1,28 @@
-require 'fraggle/msg'
-
-##
-# An extension to Response in msg.rb. I want to keep these seperated so when
-# future versions of Beefcake can generate code, we don't have to manually add
-# this back in for each generation.
+require 'fraggle/msg.pb'
 
 module Fraggle
-
   class Response
 
-    module Flag
-      VALID = 1
-      DONE  = 2
-      SET   = 4
-      DEL   = 8
-    end
-
-
-    Missing =  0
-    Clobber = -1
-    Dir     = -2
-    Nop   = -3
+    VALID = 1
+    DONE  = 2
 
-    Refused = -1
+    def valid?
+      return false if !flags
+      (flags & VALID) > 0
+    end
 
-    # CAS
-    def missing?  ; rev == Missing ; end
-    def dir?      ; rev == Dir     ; end
-    def dummy?    ; rev == Nop     ; end
+    def done?
+      return false if !flags
+      (flags & DONE) > 0
+    end
 
-    def del?      ; (flags & Flag::Del) > 0 ; end
-    def set?      ; (flags & Flag::Set) > 0 ; end
+    def ok?
+      err_code.nil?
+    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 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
+    def redirect?
+      err_code == Err::REDIRECT
+    end
 
-    # Custom
-    def disconnected? ; err_code == Errno::ECONNREFUSED::Errno ; end
   end
-
 end

data/lib/fraggle/version.rb

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

data/test/fraggle_client_test.rb

@@ -1,239 +1,259 @@
+require File.dirname(__FILE__)+"/helper"
 require 'fraggle/client'
-require 'fraggle/response'
-require 'fraggle/test'
 
 class FraggleClientTest < Test::Unit::TestCase
-  include Fraggle::Test
 
-  attr_reader :c, :blk
+  attr_reader :c, :addrs, :blk, :called
 
   def setup
-    @c   = TestClient.new(["127.0.0.1:8046"])
-    @blk = Blk.new
-  end
+    addr = "127.0.0.1:0"
+    cn   = TestConn.new(addr)
 
-  def test_send_recv
-    req = c.send(Fraggle::Request.new).valid(&blk)
+    @addrs  = ["1.1.1.1:1", "2.2.2.2:2", "3.3.3.3:3"]
+    @c      = Fraggle::Client.new(cn, @addrs)
 
-    assert_sent req.tag
-    assert_recv reply(req.tag)
+    def @c.reconnect(addr)
+      @cn = TestConn.new(addr)
+    end
   end
 
-  def test_valid
-    req = c.send(Fraggle::Request.new).valid(&blk)
+  def test_send_valid_done
+    req, log = request(V::NOP)
+    req = c.send(req)
 
-    reply(req.tag)
-    reply(req.tag)
-    reply(req.tag)
+    res = Fraggle::Response.new :tag => req.tag, :value => "ing", :flags => F::VALID|F::DONE
+    c.cn.receive_response(res)
 
-    assert_equal 3, blk.length
+    assert_equal [res], log.valid
+    assert_equal [req], log.done
+    assert_equal [], log.error
   end
 
-  def test_done
-    req = c.send(Fraggle::Request.new)
-    req.done(&blk)
-
-    reply!(req.tag)
-
-    assert_equal 1, blk.length
+  def test_send_error
+    req, log = request(V::NOP)
+    req = c.send(req)
 
-    req.valid(&blk)
+    res = Fraggle::Response.new :tag => req.tag, :err_code => E::OTHER, :flags => F::VALID|F::DONE
+    c.cn.receive_response(res)
 
-    reply(req.tag)
-    reply(req.tag)
-    reply(req.tag)
-
-    assert_equal 1, blk.length
+    assert_equal [], log.valid
+    assert_equal [], log.done
+    assert_equal [res], log.error
   end
 
-  def test_error
-    req = c.send(Fraggle::Request.new)
-    req.error(&blk)
+  def test_reconnect_without_pending_requests
+    exp = @addrs.dup
 
-    reply(req.tag, :err_code => E::OTHER, :err_detail => "boom!")
-    reply(req.tag, :err_code => E::OTHER, :err_detail => "boom!")
+    # Disconnect from 127.0.0.1:0
+    c.cn.close_connection
 
-    assert_equal 1, blk.length
-  end
+    # Send a request to invoke reconnect
+    req, log = request(V::NOP)
+    req = c.send(req)
 
-  def test_tagging
-    t = Fraggle::Client::MinTag
+    # Fake reactor turn (only available in tests)
+    c.cn.tick!
 
-    assert_equal t+0, c.noop.tag
-    assert_equal t+1, c.noop.tag
-    assert_equal t+2, c.noop.tag
-    assert_equal t+3, c.noop.tag
-    assert_equal t+4, c.noop.tag
-  end
+    assert exp.include?(c.cn.addr), "#{c.cn.addr.inspect} not in #{exp.inspect}"
 
-  def test_no_tag_if_tag
-    req = Fraggle::Request.new :tag => 99
-    c.send(req)
-    assert_sent 99
+    # If the client can handle an error, it should not mention it to the user.
+    assert_equal [], log.error
   end
 
-  # CHECKIN cas, path         => cas
-  def test_checkin
-    req = c.checkin("abc123", 123).valid(&blk)
+  def test_reconnect_with_pending_request
+    exp = @addrs.dup
 
-    assert_sent(req.tag, :verb => V::CHECKIN, :path => "abc123", :rev => 123)
-    assert_recv(reply(req.tag, :rev => 123))
-  end
+    # Send a request to invoke reconnect
+    req, log = request(V::NOP)
+    req = c.send(req)
 
-  # GET     path, id         => cas, value
-  def test_get
-    req = c.get(0, "/ping").valid(&blk)
+    # Disconnect from 127.0.0.1:0
+    c.cn.close_connection
 
-    assert_sent req.tag, :rev => 0, :verb => V::GET, :path => "/ping"
-    assert_recv reply(req.tag, :cas => 123, :value => "pong")
-  end
+    # Fake reactor turn (only available in tests)
+    c.cn.tick!
 
-  # STAT     path, id         => cas, len
-  def test_stat
-    req = c.stat(0, "/ping").valid(&blk)
+    assert exp.include?(c.cn.addr), "#{c.cn.addr.inspect} not in #{exp.inspect}"
 
-    assert_sent req.tag, :rev => 0, :verb => V::STAT, :path => "/ping"
-    assert_recv reply(req.tag, :cas => 123, :len => 4)
+    # If the client can handle an error, it should not mention it to the user.
+    assert_equal [], log.error
   end
 
-  # GETDIR     id, path, offset, limit         => {cas, value}+
-  def test_getdir
-    req = c.getdir(0, "/test", nil, nil).valid(&blk)
-
-    assert_sent req.tag, :rev => 0, :verb => V::GETDIR, :path => "/test"
-    assert_recv reply(req.tag, :rev => 123, :value => "a")
+  # retry
+  def test_resend_pending_requests
+    req, log = request(V::GET, :path => "/foo")
+    req = c.resend(req)
 
-    req = c.getdir(0, "/test", 1, 2).valid(&blk)
+    c.cn.close_connection
 
-    assert_sent req.tag, :rev => 0, :verb => V::GETDIR, :path => "/test", :offset => 1, :limit => 2
-    assert_recv reply(req.tag, :cas => 123, :value => "b")
+    assert_equal [req], c.cn.sent
   end
 
-  # SET     cas, path, value => cas
-  def test_set
-    req = c.set("/foo", "bar", 123).valid(&blk)
+  def test_manage_offset
+    req, log = request(V::WALK, :path => "/foo/*", :offset => 3)
+    req = c.resend(req)
 
-    assert_sent(req.tag, :verb => V::SET,  :rev => 123, :path => "/foo", :value => "bar")
-    assert_recv(reply(req.tag, :rev => 123))
-  end
+    res = Fraggle::Response.new :tag => req.tag, :flags => F::VALID
+    c.cn.receive_response(res)
 
-  # DEL     cas, path        => {}
-  def test_del
-    req = c.del("/foo", 123).valid(&blk)
+    c.cn.close_connection
 
-    assert_sent(req.tag, :verb => V::DEL, :rev => 123, :path => "/foo")
-    assert_recv(reply(req.tag))
+    exp, _ = request(V::WALK, :tag => req.tag, :path => "/foo/*", :offset => 4)
+    assert_equal [exp], c.cn.sent
   end
 
-  # WALK     path, id         => {cas, path, value}+
-  def test_walk
-    req = c.walk(nil, "/foo/*").valid(&blk)
-
-    assert_respond_to req, :cancel
+  def test_manage_limit
+    req, log = request(V::WALK, :path => "/foo/*", :limit => 4)
+    req = c.resend(req)
 
-    assert_sent(req.tag, :verb => V::WALK, :path => "/foo/*")
-    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
+    res = Fraggle::Response.new :tag => req.tag, :flags => F::VALID
+    c.cn.receive_response(res)
 
-  # WATCH    path             => {cas, path, value}+
-  def test_watch
-    req = c.watch(123, "/foo/*").valid(&blk)
+    c.cn.close_connection
 
-    assert_respond_to req, :cancel
+    exp, _ = request(V::WALK, :tag => req.tag, :path => "/foo/*", :limit => 3)
+    assert_equal [exp], c.cn.sent
+  end
 
-    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"))
+  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
 
-  # NOOP     {}               => {}
-  def test_noop
-    req = c.noop.valid(&blk)
+  def test_redirect
+    req, log = request(V::SET, :rev => 0, :path => "/foo", :value => "bar")
+    req = c.send(req)
 
-    assert_sent(req.tag, :verb => V::NOOP)
-    assert_recv(reply(req.tag))
-  end
+    res = Fraggle::Response.new(
+      :tag => req.tag,
+      :err_code => E::REDIRECT,
+      :err_detail => "9.9.9.9:9",
+      :flags => F::VALID|F::DONE
+    )
 
-  # CANCEL   id               => {}
-  def test_cancel
-    nop = c.noop.valid(&blk)
-    req = c.__cancel__(nop).valid(&blk)
+    c.cn.receive_response(res)
 
-    assert_sent(req.tag, :verb => V::CANCEL, :id => nop.tag)
-    assert_recv(reply(req.tag))
+    assert_equal "1.1.1.1:1", c.cn.addr
   end
 
-  def test_cancelable
-    can = c.cancelable(Fraggle::Request.new(:tag => 123))
 
-    assert ! can.canceled?
+  ###
+  # Sugar
 
-    req = can.cancel
+  def last_sent
+    c.cn.sent.last
+  end
 
-    assert can.canceled?
-    assert_equal 1, c.length
-    assert_sent req.tag, :verb => V::CANCEL, :id => can.tag
+  def assert_verb(exp, name, *args)
+    called = false
+    blk = Proc.new { called = true }
+    req = c.__send__(name, *args, &blk)
+    exp[:tag] = req.tag
+    assert_equal exp, last_sent.to_hash
 
-    # A few more for good measure
-    can.cancel
-    can.cancel
+    c.cn.receive_response(reply(req.tag))
+    assert called
+  end
 
-    # Ensure we haven't called cancel on the same tag more than once.
-    assert_equal 1, c.length
+  def test_set
+    exp = {
+      :verb => V::SET,
+      :rev => 0,
+      :path => "/foo",
+      :value => "bar"
+    }
+
+    assert_verb exp, :set, 0, "/foo", "bar"
   end
 
-  def test_cancel_does_not_prematurely_remove_callback
-    x = c.watch(123, "/foo/*").valid(&blk)
-    y = x.cancel
+  def test_get
+    exp = {
+      :verb => V::GET,
+      :rev => 0,
+      :path => "/foo"
+    }
 
-    assert_not_equal x.object_id, y.object_id
-    assert_not_equal x.tag, y.tag
+    assert_verb exp, :get, 0, "/foo"
   end
 
-  def test_cancel_discards_further_replies
-    x = c.watch(123, "/foo/*").valid(&blk)
-    x.cancel
-
-    reply!(x.tag)
+  def test_del
+    exp = {
+      :verb => V::DEL,
+      :rev => 0,
+      :path => "/foo"
+    }
 
-    # The cancel happened before the reply was received by the reactor.  Any
-    # remaining data from the server should be discarded.
-    assert_equal 0, blk.length
+    assert_verb exp, :del, 0, "/foo"
   end
 
-  def test_tag_pending_cancel_is_not_useable
-    x = c.watch(123, "/foo/*").valid(&blk)
-    y = x.cancel
-
-    # Force a reset of tag so that `send` will attempt
-    # to reuse the pending cancels tag.
-    c.instance_eval { @tag = x.tag }
+  def test_getdir
+    exp = {
+      :verb => V::GETDIR,
+      :rev => 0,
+      :path => "/foo",
+      :offset => 0,
+      :limit => 5
+    }
+
+    assert_verb exp, :getdir, 0, "/foo", 0, 5
+  end
 
-    z = c.noop
+  def test_rev
+    exp = {
+      :verb => V::REV
+    }
 
-    assert_not_equal x.tag, z.tag
-    assert_not_equal y.tag, z.tag
+    assert_verb exp, :rev
   end
 
-  def test_reuse_canceled_tag
-    x = c.watch(123, "/foo/*").valid(&blk)
-    y = x.cancel
-
-    reply!(y.tag)
+  def test_walk
+    exp = {
+      :verb => V::WALK,
+      :rev => 0,
+      :path => "/foo/*",
+      :offset => 0,
+      :limit => 5
+    }
+
+    assert_verb exp, :walk, 0, "/foo/*", 0, 5
+  end
 
-    z = c.noop
+  def test_watch
+    exp = {
+      :verb => V::WATCH,
+      :rev => 0,
+      :path => "/foo/*"
+    }
 
-    assert_equal x.tag, z.tag
+    assert_verb exp, :watch, 0, "/foo/*"
   end
 
-  # These are planned for future doozer versions
-  #
-  # ESET     cas, path        => {}
-  # GETDIR   path             => {cas, value}+
-  # MONITOR  path             => {cas, path, value}+
-  # SYNCPATH path             => cas, value
-
 end