fraggle 0.1.1 → 0.2.0

data/lib/fraggle/emitter.rb

@@ -0,0 +1,26 @@
+module Fraggle
+
+  module Emitter
+
+    def callbacks
+      @callbacks ||= Hash.new(lambda {})
+    end
+
+    def emit(name, *args)
+      callbacks[name].call(*args)
+    end
+
+    def valid(&blk) ; must_callback!(:valid, blk) ; end
+    def done(&blk)  ; must_callback!(:done,  blk) ; end
+    def error(&blk) ; must_callback!(:error, blk) ; end
+
+    def must_callback!(name, blk)
+      if ! blk
+        raise ArgumentError, "no block given to `#{name}`"
+      end
+      callbacks[name] = blk
+    end
+
+  end
+
+end

data/lib/fraggle/logger.rb

@@ -0,0 +1,26 @@
+module Fraggle
+  module Logger
+
+    DEBUG = 0
+    INFO  = 1
+    ERROR = 2
+
+    attr_accessor :writer, :level
+
+    def log(lv, msg)
+      label = case lv
+      when DEBUG then "debug "
+      when INFO  then "info  "
+      when ERROR then "error "
+      end
+
+      if lv >= level
+        writer.puts "#{label}: #{msg}"
+      end
+    end
+
+    def debug(msg) ; log(DEBUG, msg) ; end
+    def info(msg)  ; log(INFO,  msg) ; end
+    def error(msg) ; log(ERROR, msg) ; end
+  end
+end

data/lib/fraggle/meta.rb

@@ -0,0 +1,9 @@
+class Object
+  def metaclass
+    (class << self ; self ; end)
+  end
+
+  def metadef(name, &blk)
+    metaclass.__send__(:define_method, name, &blk)
+  end
+end

data/lib/fraggle/{proto.rb → msg.rb}

@@ -18,6 +18,7 @@ module Fraggle
       NOOP     = 7;  # {}               => {}
       WATCH    = 8;  # path             => {cas, path, value}+
       CANCEL   = 10; # id               => {}
+      STAT     = 16; # path, id         => cas, len
 
       # future
       GETDIR   = 14; # path             => {cas, value}+
@@ -45,14 +46,20 @@ module Fraggle
   class Response
     include Beefcake::Message
 
-    required :tag,   :int32, 1
+    required :tag,   :uint32, 1
     required :flags, :int32, 2
 
-    optional :seqn,  :int64,  3
+    optional :rev,   :int64,  3
     optional :cas,   :int64,  4
     optional :path,  :string, 5
     optional :value, :bytes,  6
     optional :id,    :int32,  7
+    optional :len,   :int32,  8
+
+    module Flag
+      VALID = 1
+      DONE  = 2
+    end
 
     module Err
       # don't use value 0
@@ -66,6 +73,7 @@ module Fraggle
       # match unix errno
       NOTDIR       = 20
       ISDIR        = 21
+      NOINT        = 22
     end
 
     optional :err_code,   Err,     100

data/lib/fraggle/protocol.rb

@@ -0,0 +1,47 @@
+require 'fraggle/response'
+
+module Fraggle
+
+  module Protocol
+
+    attr_reader :last_received
+
+    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)
+      p res
+    end
+
+    def send_request(req)
+      data = req.encode
+      head = [data.length].pack("N")
+
+      send_data("#{head}#{data}")
+    end
+
+    def send_data(data)
+      super(data)
+    end
+
+  end
+
+end

data/lib/fraggle/request.rb

@@ -0,0 +1,15 @@
+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.
+
+module Fraggle
+
+  class Request
+    include Emitter
+  end
+
+end

data/lib/fraggle/response.rb

@@ -0,0 +1,33 @@
+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.
+
+module Fraggle
+
+  class Response
+
+    Missing =  0
+    Clobber = -1
+    Dir     = -2
+    Dummy   = -3
+
+    # CAS
+    def missing?  ; cas == Missing ; end
+    def dir?      ; cas == Dir     ; end
+    def dummy?    ; cas == Dummy   ; end
+
+    # ERR
+    def ok?           ; error_code != 0                 ; end
+    def other?        ; error_code == Err::OTHER        ; end
+    def unknown_verb? ; error_code == Err::UNKNOWN_VERB ; end
+    def redirect?     ; error_code == Err::REDIRECT     ; end
+    def invalid_snap? ; error_code == Err::INVALID_SNAP ; end
+    def mismatch?     ; error_code == Err::CAS_MISMATCH ; end
+    def not_dir?      ; error_code == Err::NOT_DIR      ; end
+    def is_dir?       ; error_code == Err::ISDIR        ; end
+  end
+
+end

data/lib/fraggle/snap.rb

@@ -0,0 +1,43 @@
+require 'fraggle/client'
+
+module Fraggle
+
+  class Snap
+
+    attr_reader :id
+
+    def initialize(id, c)
+      @id = id
+      @c  = c
+    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)
+        blk.call(sn)
+      end
+    end
+
+    def method_missing(*args, &blk)
+      @c.__send__(*args, &blk)
+    end
+
+  end
+
+end

data/lib/fraggle/test.rb

@@ -0,0 +1,72 @@
+require 'fraggle/request'
+require 'fraggle/response'
+
+module Fraggle
+
+  ##
+  # I want this to be a great starting point for testing fraggle applications.
+  # It's currently a work in progress.  Think Rack::Test for fraggle.
+  #
+  module Test
+
+    V = Fraggle::Request::Verb
+    F = Fraggle::Response::Flag
+    E = Fraggle::Response::Err
+
+
+    class TestClient < Array
+      include Fraggle::Client
+      alias :send_request :<<
+    end
+
+
+    # This is handy for testing callbacks
+    class Blk < Array
+      def to_proc
+        Proc.new {|res| self << res }
+      end
+    end
+
+
+    def assert_sent(tag, attrs={})
+      req = Fraggle::Request.new(attrs)
+      req.tag = tag
+
+      msg =  "This was not sent:\n"
+      msg << "  #{req.inspect}\n"
+      msg << "Sent:\n  "
+      msg << c.map {|r| r.inspect }.join("\n  ")
+      msg << "\n"
+
+      assert_block(msg) { c.include?(req) }
+    end
+
+    def assert_recv(attrs)
+      req = Fraggle::Response.new(attrs)
+      msg =  "This was not recieved:\n"
+      msg << "  #{req.inspect}\n"
+      msg << "Received:\n  "
+      msg << blk.map {|r| r.inspect }.join("\n  ")
+      msg << "\n"
+
+      assert_block(msg) { blk.include?(attrs) }
+    end
+
+    # Replies with a valid response
+    def reply(tag, attrs={})
+      res = Fraggle::Response.new(attrs)
+      res.tag   = tag
+      res.flags ||= 0
+      res.flags |= Fraggle::Response::Flag::VALID
+      c.receive_response(res)
+      res
+    end
+
+    # Replies with a valid + done response
+    def reply!(tag, attrs={})
+      reply(tag, attrs.merge(:flags => Fraggle::Response::Flag::DONE))
+    end
+
+  end
+
+end

data/test/fraggle_client_test.rb

@@ -0,0 +1,261 @@
+require 'fraggle/client'
+require 'fraggle/response'
+require 'fraggle/test'
+
+class FraggleClientTest < Test::Unit::TestCase
+  include Fraggle::Test
+
+  attr_reader :c, :blk
+
+  def setup
+    @c   = TestClient.new("doozer://127.0.0.1:8046")
+    @blk = Blk.new
+  end
+
+  def test_send_recv
+    req = c.send(Fraggle::Request.new, &blk)
+
+    assert_sent req.tag
+    assert_recv reply(req.tag)
+  end
+
+  def test_valid
+    req = c.send(Fraggle::Request.new, &blk)
+
+    reply(req.tag)
+    reply(req.tag)
+    reply(req.tag)
+
+    assert_equal 3, blk.length
+  end
+
+  def test_done
+    req = c.send(Fraggle::Request.new)
+    req.done(&blk)
+
+    reply!(req.tag)
+
+    assert_equal 1, blk.length
+
+    req.valid(&blk)
+
+    reply(req.tag)
+    reply(req.tag)
+    reply(req.tag)
+
+    assert_equal 1, blk.length
+  end
+
+  def test_default_error
+    req = c.send(Fraggle::Request.new)
+
+    assert_raises Fraggle::Client::Error do
+      reply(req.tag, :err_code => E::OTHER, :err_detail => "boom!")
+    end
+
+    assert_nothing_raised do
+      reply(req.tag, :err_code => E::OTHER, :err_detail => "boom!")
+    end
+  end
+
+  def test_error
+    req = c.send(Fraggle::Request.new)
+    req.error(&blk)
+
+    reply(req.tag, :err_code => E::OTHER, :err_detail => "boom!")
+    reply(req.tag, :err_code => E::OTHER, :err_detail => "boom!")
+
+    assert_equal 1, blk.length
+  end
+
+  def test_tagging
+    t = Fraggle::Client::MinTag
+
+    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
+
+  # CHECKIN cas, path         => cas
+  def test_checkin
+    req = c.checkin("abc123", 123, &blk)
+
+    assert_sent(req.tag, :verb => V::CHECKIN, :path => "abc123", :cas => 123)
+    assert_recv(reply(req.tag, :cas => 123))
+  end
+
+  # GET     path, id         => cas, value
+  def test_get
+    req = c.get(0, "/ping", &blk)
+
+    assert_sent req.tag, :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)
+
+    assert_sent req.tag, :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)
+
+    assert_sent req.tag, :verb => V::GETDIR, :path => "/test"
+    assert_recv reply(req.tag, :cas => 123, :value => "a")
+
+    req = c.getdir(0, "/test", 1, 2, &blk)
+
+    assert_sent req.tag, :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)
+
+    assert_sent(req.tag, :verb => V::SET,  :cas => 123, :path => "/foo", :value => "bar")
+    assert_recv(reply(req.tag, :cas => 123))
+  end
+
+  # DEL     cas, path        => {}
+  def test_del
+    req = c.del("/foo", 123, &blk)
+
+    assert_sent(req.tag, :verb => V::DEL, :cas => 123, :path => "/foo")
+    assert_recv(reply(req.tag))
+  end
+
+  # WALK     path, id         => {cas, path, value}+
+  def test_walk
+    req = c.walk(0, "/foo/*", &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"))
+  end
+
+  # WATCH    path             => {cas, path, value}+
+  def test_watch
+    req = c.watch("/foo/*", &blk)
+
+    assert_respond_to req, :cancel
+
+    assert_sent(req.tag, :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)
+
+    assert_sent(req.tag, :verb => V::NOOP)
+    assert_recv(reply(req.tag))
+  end
+
+  # CANCEL   id               => {}
+  def test_cancel
+    nop = c.noop(&blk)
+    req = c.__cancel__(nop, &blk)
+
+    assert_sent(req.tag, :verb => V::CANCEL, :id => nop.tag)
+    assert_recv(reply(req.tag))
+  end
+
+  def test_cancelable
+    can = c.cancelable(Fraggle::Request.new(:tag => 123))
+
+    assert ! can.canceled?
+
+    req = can.cancel
+
+    assert can.canceled?
+    assert_equal 1, c.length
+    assert_sent req.tag, :verb => V::CANCEL, :id => can.tag
+
+    # A few more for good measure
+    can.cancel
+    can.cancel
+
+    # Ensure we haven't called cancel on the same tag more than once.
+    assert_equal 1, c.length
+  end
+
+  def test_cancel_does_not_prematurely_remove_callback
+    x = c.watch("/foo/*", &blk)
+    y = x.cancel
+
+    assert_not_equal x.object_id, y.object_id
+    assert_not_equal x.tag, y.tag
+  end
+
+  def test_cancel_discards_further_replies
+    x = c.watch("/foo/*", &blk)
+    x.cancel
+
+    reply!(x.tag)
+
+    # 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
+  end
+
+  def test_tag_pending_cancel_is_not_useable
+    x = c.watch("/foo/*", &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 }
+
+    z = c.noop
+
+    assert_not_equal x.tag, z.tag
+    assert_not_equal y.tag, z.tag
+  end
+
+  def test_reuse_canceled_tag
+    x = c.watch("/foo/*", &blk)
+    y = x.cancel
+
+    reply!(y.tag)
+
+    z = c.noop
+
+    assert_equal x.tag, z.tag
+  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