fraggle-spanx 4.0.1.1

data/lib/fraggle/msg.pb.rb

@@ -0,0 +1,60 @@
+## Generated from msg.proto for server
+require "beefcake"
+
+module Fraggle
+
+  class Request
+    include Beefcake::Message
+
+    module Verb
+      GET = 1
+      SET = 2
+      DEL = 3
+      REV = 5
+      WAIT = 6
+      NOP = 7
+      WALK = 9
+      GETDIR = 14
+      STAT = 16
+      ACCESS = 99
+    end
+
+    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 :rev, :int64, 9
+
+  end
+
+  class Response
+    include Beefcake::Message
+
+    module Err
+      OTHER = 127
+      TAG_IN_USE = 1
+      UNKNOWN_VERB = 2
+      READONLY = 3
+      TOO_LATE = 4
+      REV_MISMATCH = 5
+      BAD_PATH = 6
+      MISSING_ARG = 7
+      RANGE = 8
+      NOTDIR = 20
+      ISDIR = 21
+      NOENT = 22
+    end
+
+    optional :tag, :int32, 1
+    optional :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/response.rb

@@ -0,0 +1,28 @@
+require 'fraggle/msg.pb'
+
+module Fraggle
+  class Response
+
+    SET   = 4
+    DEL   = 8
+
+    def set?
+      return false if !flags
+      (flags & SET) > 0
+    end
+
+    def del?
+      return false if !flags
+      (flags & DEL) > 0
+    end
+
+    def missing?
+      rev == 0
+    end
+
+    def ok?
+      err_code.nil?
+    end
+
+  end
+end

data/lib/fraggle/version.rb

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

data/test/fraggle_client_test.rb

@@ -0,0 +1,238 @@
+require File.expand_path(File.dirname(__FILE__)+"/helper")
+require 'fraggle/client'
+
+class FraggleClientTest < Test::Unit::TestCase
+
+  attr_reader :c
+
+  def setup
+    addr = "127.0.0.1:0"
+    cn   = TestConn.new(addr)
+
+    @addrs  = ["1.1.1.1:1", "2.2.2.2:2", "3.3.3.3:3"]
+    @c      = Fraggle::Client.allocate
+
+    def @c.reconnect(addr)
+      @cn = TestConn.new(addr)
+    end
+
+    def @c.monitor_addrs
+      # do nothing
+    end
+
+    @c.__send__(:initialize, cn, @addrs)
+  end
+
+  def test_response_error
+    req, log = request(V::REV)
+
+    c.send(req, &log)
+
+    res = reply(req.tag, :err_code => E::OTHER)
+    c.cn.receive_response(res)
+
+    assert_equal [[nil, C::ResponseError.new(res)]], log
+  end
+
+  def test_reconnect_without_pending_requests
+    exp = @addrs.dup
+
+    # Disconnect from 127.0.0.1:0
+    c.cn.close_connection
+
+    # Send a request to invoke reconnect
+    req, log = request(V::REV)
+    c.send(req, &log)
+
+    # Fake reactor turn (only available in tests)
+    c.cn.tick!
+
+    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 [[nil, C::DisconnectedError.new("127.0.0.1:0")]], log
+  end
+
+  def test_reconnect_with_pending_request
+    exp = @addrs.dup
+
+    # Send a request to invoke reconnect
+    req, log = request(V::REV)
+    c.send(req, &log)
+
+    # Disconnect from 127.0.0.1:0
+    c.cn.close_connection
+
+    # Fake reactor turn (only available in tests)
+    c.cn.tick!
+
+    assert exp.include?(c.cn.addr), "#{c.cn.addr.inspect} not in #{exp.inspect}"
+
+    assert_equal [[nil, C::DisconnectedError.new("127.0.0.1:0")]], log
+  end
+
+  def test_reconnect_with_multiple_pending_requests
+    exp = @addrs.dup
+
+    # Send a request to invoke reconnect
+    req, loga = request(V::REV)
+    c.send(req, &loga)
+
+    req, logb = request(V::REV)
+    c.send(req, &logb)
+
+    # Disconnect from 127.0.0.1:0
+    c.cn.close_connection
+
+    # Fake reactor turn (only available in tests)
+    c.cn.tick!
+
+    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 [[nil, C::DisconnectedError.new("127.0.0.1:0")]], loga
+    assert_equal [[nil, C::DisconnectedError.new("127.0.0.1:0")]], logb
+  end
+
+  def test_resend_pending_requests
+    req, log = request(V::GET, :path => "/foo")
+    c.resend(req, &log)
+
+    c.cn.close_connection
+
+    assert_equal [req], c.cn.sent
+  end
+
+  def test_idemp_pending_requests
+    one, olog = request(V::SET, :rev => 1, :path => "/foo", :value => "bar")
+    c.idemp(one, &olog)
+
+    zero, zlog = request(V::SET, :rev => 0, :path => "/foo", :value => "bar")
+    c.idemp(zero, &zlog)
+
+    c.cn.close_connection
+
+    assert_equal [one], c.cn.sent
+
+    assert_equal [[nil, C::DisconnectedError.new("127.0.0.1:0")]], zlog
+  end
+
+  def test_idemp_unhandled_error
+    req, log = request(V::SET, :path => "/foo", :value => "bar", :rev => Fraggle::Client::MaxInt64)
+    c.idemp(req, &log)
+
+    res = reply(req.tag, :err_code => E::OTHER)
+    c.cn.receive_response(res)
+
+    assert_equal [[nil, C::ResponseError.new(res)]], log
+  end
+
+  ###
+  # Sugar
+
+  def last_sent
+    c.cn.sent.last
+  end
+
+  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
+
+    c.cn.receive_response(reply(req.tag))
+    assert called
+  end
+
+  def test_set
+    exp = {
+      :verb => V::SET,
+      :rev => 0,
+      :path => "/foo",
+      :value => "bar"
+    }
+
+    assert_verb exp, :set, 0, "/foo", "bar"
+  end
+
+  def test_get
+    exp = {
+      :verb => V::GET,
+      :rev => 0,
+      :path => "/foo"
+    }
+
+    assert_verb exp, :get, 0, "/foo"
+  end
+
+  def test_del
+    exp = {
+      :verb => V::DEL,
+      :rev => 0,
+      :path => "/foo"
+    }
+
+    assert_verb exp, :del, 0, "/foo"
+  end
+
+  def test_getdir
+    exp = {
+      :verb => V::GETDIR,
+      :rev => 0,
+      :path => "/foo",
+      :offset => 0
+    }
+
+    assert_verb exp, :_getdir, 0, "/foo", 0
+  end
+
+  def test_rev
+    exp = {
+      :verb => V::REV
+    }
+
+    assert_verb exp, :rev
+  end
+
+  def test_stat
+    exp = {
+      :rev  => 0,
+      :verb => V::STAT,
+      :path => "/foo"
+    }
+
+    assert_verb exp, :stat, 0, "/foo"
+  end
+
+  def test_walk
+    exp = {
+      :verb => V::WALK,
+      :rev => 0,
+      :path => "/foo/*",
+      :offset => 0
+    }
+
+    assert_verb exp, :_walk, 0, "/foo/*", 0
+  end
+
+  def test_wait
+    exp = {
+      :verb => V::WAIT,
+      :rev => 0,
+      :path => "/foo/*"
+    }
+
+    assert_verb exp, :wait, 0, "/foo/*"
+  end
+
+  def test_wait
+    exp = {
+      :verb => V::ACCESS,
+      :value => "abc"
+    }
+
+    assert_verb exp, :access, "abc"
+  end
+
+end

data/test/fraggle_protocol_test.rb

@@ -0,0 +1,88 @@
+require File.expand_path(File.dirname(__FILE__)+"/helper")
+require 'fraggle/connection'
+
+class FraggleProtocolTest < Test::Unit::TestCase
+
+  attr_reader :cn
+
+  def setup
+    @cn  = TestConn.new("127.0.0.1:0")
+  end
+
+  def encode(req)
+    data = req.encode
+    [data.length].pack("N") + data
+  end
+
+  def test_simple
+    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
+    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
+    b = Fraggle::Response.new :tag => 1, :verb => V::NOP
+    cn.receive_data(encode(a))
+    cn.receive_data(encode(b))
+
+    assert_equal [a, b], cn.received
+  end
+
+  def test_small_chunks
+    req = Fraggle::Response.new :tag => 0, :verb => V::NOP
+
+    bytes = encode(req) * 3
+    len   = bytes.length
+
+    0.step(len, 1) do |i|
+      data = bytes.slice!(0, i)
+      cn.receive_data(data)
+    end
+
+    assert_equal [req, req, req], cn.received
+  end
+
+  def test_big_chunks
+    req = Fraggle::Response.new :tag => 0, :verb => V::NOP
+
+    bytes = encode(req) * 3
+    len   = bytes.length
+
+    0.step(len, len/2) do |i|
+      data = bytes.slice!(0, i)
+      cn.receive_data(data)
+    end
+
+    assert_equal [req, req, req], cn.received
+  end
+
+  def test_send_request
+    req   = Fraggle::Request.new :tag => 0, :verb => V::NOP
+    bytes = req.encode
+    head  = [bytes.length].pack("N")
+    exp   = head+bytes
+
+    got = ""
+    (class << cn ; self ; end).instance_eval do
+      define_method(:send_data) do |data|
+        got << data
+      end
+    end
+
+    nop = Fraggle::Request.new :verb => V::NOP
+    cn.send_request(nop, nil)
+
+    assert_equal head+bytes, got
+  end
+
+end

data/test/fraggle_test.rb

@@ -0,0 +1,12 @@
+require 'fraggle'
+
+class FraggleTest < Test::Unit::TestCase
+
+  def test_uri
+    uri = "doozer:?ca=1:1&ca=2:2&ca=3:3&ignore=this&sk=foo"
+    addrs, sk = Fraggle.uri(uri)
+    assert_equal ["1:1", "2:2", "3:3"], addrs
+    assert_equal "foo", sk
+  end
+
+end

data/test/fraggle_transaction_test.rb

@@ -0,0 +1,116 @@
+require File.expand_path(File.dirname(__FILE__)+"/helper")
+require 'fraggle/connection'
+
+class FraggleTransactionTest < Test::Unit::TestCase
+
+  attr_reader :cn
+
+  def setup
+    @cn = TestConn.new("127.0.0.1:0")
+  end
+
+  def test_tagging
+    req, _ = request(V::REV)
+    assert_equal 0, cn.send_request(req, _).tag
+    req, _ = request(V::REV)
+    assert_equal 1, cn.send_request(req, _).tag
+    req, _ = request(V::REV)
+    assert_equal 2, cn.send_request(req, _).tag
+  end
+
+  def test
+    req, log = request(V::REV)
+
+    cn.send_request(req, log)
+
+    res = reply(req.tag)
+    cn.receive_response(res)
+
+    assert_equal [[res, nil]], log
+  end
+
+  def test_error
+    req, log = request(V::REV)
+
+    cn.send_request(req, log)
+
+    res = reply(req.tag, :err_code => E::OTHER)
+    cn.receive_response(res)
+
+    err = C::ResponseError.new(res)
+    assert_equal [[nil, err]], log
+  end
+
+  def test_i_tag
+    res = reply(0, :err_code => E::OTHER)
+
+    assert_nothing_raised do
+      cn.receive_response(res)
+    end
+  end
+
+  def test_deletes_callback
+    req, log = request(V::REV)
+
+    cn.send_request(req, log)
+
+    res = reply(req.tag)
+    cn.receive_response(res)
+
+    # This should be ignored
+    cn.receive_response(res)
+
+    assert_equal [[res, nil]], log
+  end
+
+  def test_error_deletes_callback
+    req, log = request(V::REV)
+
+    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 [[nil, C::ResponseError.new(res)]], log
+  end
+
+  def test_cannot_reuse_sent_request
+    req, _ = request(V::REV)
+    cn.send_request(req, _)
+
+    assert_raises C::SendError do
+      cn.send_request(req, _)
+    end
+  end
+
+  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 [[nil, C::DisconnectedError.new("127.0.0.1:0")]], al
+    assert_equal [[nil, C::DisconnectedError.new("127.0.0.1:0")]], bl
+    assert_equal [[nil, C::DisconnectedError.new("127.0.0.1:0")]], cl
+  end
+
+  def test_send_when_disconnected
+    cn.unbind
+
+    req, log = request(V::REV)
+    ret = cn.send_request(req, log)
+
+    assert_equal req, ret
+
+    cn.tick!
+
+    assert_equal [[nil, C::DisconnectedError.new("127.0.0.1:0")]], log
+  end
+end