bertrpc 0.2.0 → 0.3.0

data/README.md

@@ -17,21 +17,43 @@ BERTRPC is a Ruby BERT-RPC client library.
 Installation
 ------------
 
-    gem install mojombo-bertrpc -s http://gems.github.com
+From GemCutter:
 
+    gem install bertrpc
 
-Example
--------
+From GitHub:
+
+    gem install mojombo-bertrpc -s http://gems.github.com \
+                                -s http://gemcutter.org
+
+
+Examples
+--------
+
+Require the library and create a service:
 
     require 'bertrpc'
-    
     svc = BERTRPC::Service.new('localhost', 9999)
+
+Make a call:
+
     svc.call.calc.add(1, 2)
     # => 3
 
-This generates a BERT-RPC request like so:
+The underlying BERT-RPC transaction of the above call is:
 
     -> {call, calc, add, [1, 2]}
+    <- {reply, 3}
+
+Make a cast:
+
+    svc.cast.stats.incr
+    # => nil
+
+The underlying BERT-RPC transaction of the above cast is:
+
+    -> {cast, stats, incr, []}
+    <- {noreply}
 
 
 Copyright

data/VERSION

@@ -1 +1 @@
-0.2.0
+0.3.0

data/bertrpc.gemspec

@@ -2,11 +2,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{bertrpc}
-  s.version = "0.2.0"
+  s.version = "0.3.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Tom Preston-Werner"]
-  s.date = %q{2009-08-13}
+  s.date = %q{2009-09-05}
   s.email = %q{tom@mojombo.com}
   s.extra_rdoc_files = [
     "LICENSE",
@@ -21,16 +21,16 @@ Gem::Specification.new do |s|
      "VERSION",
      "bertrpc.gemspec",
      "lib/bertrpc.rb",
-     "lib/bertrpc/call.rb",
-     "lib/bertrpc/call_proxy.rb",
+     "lib/bertrpc/action.rb",
      "lib/bertrpc/encodes.rb",
      "lib/bertrpc/errors.rb",
      "lib/bertrpc/mod.rb",
+     "lib/bertrpc/request.rb",
      "lib/bertrpc/service.rb",
-     "test/call_proxy_test.rb",
-     "test/call_test.rb",
+     "test/action_test.rb",
      "test/encodes_test.rb",
      "test/mod_test.rb",
+     "test/request_test.rb",
      "test/service_test.rb",
      "test/test_helper.rb"
   ]
@@ -40,10 +40,10 @@ Gem::Specification.new do |s|
   s.rubygems_version = %q{1.3.5}
   s.summary = %q{BERTRPC is a Ruby BERT-RPC client library.}
   s.test_files = [
-    "test/call_proxy_test.rb",
-     "test/call_test.rb",
+    "test/action_test.rb",
      "test/encodes_test.rb",
      "test/mod_test.rb",
+     "test/request_test.rb",
      "test/service_test.rb",
      "test/test_helper.rb"
   ]

data/lib/bertrpc/action.rb

@@ -0,0 +1,47 @@
+module BERTRPC
+  class Action
+    include Encodes
+
+    def initialize(svc, req, mod, fun, args)
+      @svc = svc
+      @req = req
+      @mod = mod
+      @fun = fun
+      @args = args
+    end
+
+    def execute
+      bert_request = encode_ruby_request([@req.kind, @mod, @fun, @args])
+      bert_response = transaction(bert_request)
+      decode_bert_response(bert_response)
+    end
+
+    #private
+
+    def write(sock, bert)
+      sock.write([bert.length].pack("N"))
+      sock.write(bert)
+    end
+
+    def transaction(bert_request)
+      sock = TCPSocket.new(@svc.host, @svc.port)
+
+      if @req.options
+        if @req.options[:cache] && @req.options[:cache][0] == :validation
+          token = @req.options[:cache][1]
+          info_bert = encode_ruby_request([:info, :cache, [:validation, token]])
+          write(sock, info_bert)
+        end
+      end
+
+      write(sock, bert_request)
+      lenheader = sock.read(4)
+      raise ProtocolError.new("Unable to read length header from server.") unless lenheader
+      len = lenheader.unpack('N').first
+      bert_response = sock.read(len)
+      raise ProtocolError.new("Unable to read data from server.") unless bert_response
+      sock.close
+      bert_response
+    end
+  end
+end

data/lib/bertrpc/encodes.rb

@@ -10,6 +10,8 @@ module BERTRPC
       case ruby_response[0]
         when :reply
           deconvert(ruby_response[1])
+        when :noreply
+          nil
         when :error
           error(ruby_response[1])
         else

data/lib/bertrpc/errors.rb

@@ -18,4 +18,8 @@ module BERTRPC
   class ProxyError < BERTRPCError
 
   end
+
+  class InvalidOption < BERTRPCError
+
+  end
 end

data/lib/bertrpc/mod.rb

@@ -1,14 +1,14 @@
 module BERTRPC
   class Mod
-    def initialize(svc, type, mod)
+    def initialize(svc, req, mod)
       @svc = svc
-      @type = type
+      @req = req
       @mod = mod
     end
 
     def method_missing(cmd, *args)
       args = [*args]
-      @type.new(@svc, @mod, cmd, args).execute
+      Action.new(@svc, @req, @mod, cmd, args).execute
     end
   end
 end

data/lib/bertrpc/request.rb

@@ -0,0 +1,15 @@
+module BERTRPC
+  class Request
+    attr_accessor :kind, :options
+
+    def initialize(svc, kind, options)
+      @svc = svc
+      @kind = kind
+      @options = options
+    end
+
+    def method_missing(cmd, *args)
+      Mod.new(@svc, self, cmd)
+    end
+  end
+end

data/lib/bertrpc/service.rb

@@ -7,8 +7,28 @@ module BERTRPC
       @port = port
     end
 
-    def call
-      CallProxy.new(self)
+    def call(options = nil)
+      verify_options(options)
+      Request.new(self, :call, options)
+    end
+
+    def cast(options = nil)
+      verify_options(options)
+      Request.new(self, :cast, options)
+    end
+
+    # private
+
+    def verify_options(options)
+      if options
+        if cache = options[:cache]
+          unless cache[0] == :validation && cache[1].is_a?(String)
+            raise InvalidOption.new("Valid :cache args are [:validation, String]")
+          end
+        else
+          raise InvalidOption.new("Valid options are :cache")
+        end
+      end
     end
   end
 end

data/lib/bertrpc.rb

@@ -2,8 +2,8 @@ require 'erlectricity'
 require 'socket'
 
 require 'bertrpc/service'
-require 'bertrpc/call_proxy'
+require 'bertrpc/request'
 require 'bertrpc/mod'
 require 'bertrpc/encodes'
-require 'bertrpc/call'
+require 'bertrpc/action'
 require 'bertrpc/errors'

data/test/{call_test.rb → action_test.rb}

@@ -1,50 +1,53 @@
 require 'test_helper'
 
-class CallTest < Test::Unit::TestCase
-  context "A Call" do
+class ActionTest < Test::Unit::TestCase
+  context "An Action" do
     setup do
       @svc = BERTRPC::Service.new('localhost', 9941)
+      @req = @svc.call
     end
 
     should "be created with a Service, module name, fun name, and args" do
-      assert BERTRPC::Call.new(@svc, :mymod, :myfun, [1, 2]).is_a?(BERTRPC::Call)
+      assert BERTRPC::Action.new(@svc, @req, :mymod, :myfun, [1, 2]).is_a?(BERTRPC::Action)
     end
   end
 
-  context "A Call instance" do
+  context "An Action instance" do
     setup do
       @svc = BERTRPC::Service.new('localhost', 9941)
+      @req = @svc.call
       @enc = Enc.new
     end
 
     should "call with single-arity" do
       req = @enc.encode_ruby_request([:call, :mymod, :myfun, [1]])
       res = @enc.encode_ruby_request([:reply, 2])
-      call = BERTRPC::Call.new(@svc, :mymod, :myfun, [1])
-      call.expects(:sync_request).with(req).returns(res)
+      call = BERTRPC::Action.new(@svc, @req, :mymod, :myfun, [1])
+      call.expects(:transaction).with(req).returns(res)
       assert_equal 2, call.execute
     end
 
     should "call with single-arity array" do
       req = @enc.encode_ruby_request([:call, :mymod, :myfun, [[1, 2, 3]]])
       res = @enc.encode_ruby_request([:reply, [4, 5, 6]])
-      call = BERTRPC::Call.new(@svc, :mymod, :myfun, [[1, 2, 3]])
-      call.expects(:sync_request).with(req).returns(res)
+      call = BERTRPC::Action.new(@svc, @req, :mymod, :myfun, [[1, 2, 3]])
+      call.expects(:transaction).with(req).returns(res)
       assert_equal [4, 5, 6], call.execute
     end
 
     should "call with multi-arity" do
       req = @enc.encode_ruby_request([:call, :mymod, :myfun, [1, 2, 3]])
       res = @enc.encode_ruby_request([:reply, [4, 5, 6]])
-      call = BERTRPC::Call.new(@svc, :mymod, :myfun, [1, 2, 3])
-      call.expects(:sync_request).with(req).returns(res)
+      call = BERTRPC::Action.new(@svc, @req, :mymod, :myfun, [1, 2, 3])
+      call.expects(:transaction).with(req).returns(res)
       assert_equal [4, 5, 6], call.execute
     end
 
     context "sync_request" do
       setup do
         @svc = BERTRPC::Service.new('localhost', 9941)
-        @call = BERTRPC::Call.new(@svc, :mymod, :myfun, [])
+        @req = @svc.call
+        @call = BERTRPC::Action.new(@svc, @req, :mymod, :myfun, [])
       end
     
       should "read and write BERT-Ps from the socket" do
@@ -55,7 +58,7 @@ class CallTest < Test::Unit::TestCase
         io.expects(:read).with(3).returns("bar")
         io.expects(:close)
         TCPSocket.expects(:new).returns(io)
-        assert_equal "bar", @call.sync_request("foo")
+        assert_equal "bar", @call.transaction("foo")
       end
 
       should "raise a ProtocolError when the length is invalid" do
@@ -65,7 +68,7 @@ class CallTest < Test::Unit::TestCase
         io.expects(:read).with(4).returns(nil)
         TCPSocket.expects(:new).returns(io)
         assert_raises(BERTRPC::ProtocolError) do
-          @call.sync_request("foo")
+          @call.transaction("foo")
         end
       end
       
@@ -77,7 +80,7 @@ class CallTest < Test::Unit::TestCase
         io.expects(:read).with(3).returns(nil)
         TCPSocket.expects(:new).returns(io)
         assert_raises(BERTRPC::ProtocolError) do
-          @call.sync_request("foo")
+          @call.transaction("foo")
         end
       end
     end

data/test/encodes_test.rb

@@ -8,7 +8,10 @@ class EncodesTest < Test::Unit::TestCase
 
     context "converter" do
       should "convert top level hashes to BERT-RPC dict form" do
-        assert_equal([:dict, [:foo, 1], [:bar, 2]], @enc.convert({:foo => 1, :bar => 2}))
+        arr = @enc.convert({:foo => 1, :bar => 2})
+        a = [:dict, [:foo, 1], [:bar, 2]] == arr
+        b = [:dict, [:bar, 2], [:foo, 1]] == arr
+        assert(a || b)
       end
 
       should "convert nested hashes in the same way" do
@@ -33,21 +36,27 @@ class EncodesTest < Test::Unit::TestCase
         assert_equal [1, 2, "foo", :bar, 3.14], @enc.deconvert([1, 2, "foo", :bar, 3.14])
       end
     end
-    
+
     context "ruby request encoder" do
       should "return BERT-RPC encoded request" do
         bert = "\203h\004d\000\004calld\000\005mymodd\000\005myfunh\003a\001a\002a\003"
         assert_equal bert, @enc.encode_ruby_request([:call, :mymod, :myfun, [1, 2, 3]])
       end
     end
-    
+
     context "bert response decoder" do
-      should "return response when successful" do
+      should "return response when reply" do
         req = @enc.encode_ruby_request([:reply, [1, 2, 3]])
         res = @enc.decode_bert_response(req)
         assert_equal [1, 2, 3], res
       end
 
+      should "return nil when noreply" do
+        req = @enc.encode_ruby_request([:noreply])
+        res = @enc.decode_bert_response(req)
+        assert_equal nil, res
+      end
+
       should "raise a ProtocolError error when protocol level error is returned" do
         req = @enc.encode_ruby_request([:error, [:protocol, 1, "invalid"]])
         assert_raises(BERTRPC::ProtocolError) do

data/test/mod_test.rb

@@ -4,26 +4,28 @@ class ModTest < Test::Unit::TestCase
   context "A Mod" do
     setup do
       @svc = BERTRPC::Service.new('localhost', 9941)
+      @req = @svc.call
     end
 
-    should "be created with a Service and type and module name" do
-      assert BERTRPC::Mod.new(@svc, BERTRPC::Call, :mymod).is_a?(BERTRPC::Mod)
+    should "be created with a Service, request and module name" do
+      assert BERTRPC::Mod.new(@svc, @req, :mymod).is_a?(BERTRPC::Mod)
     end
   end
 
   context "A Mod instance" do
     setup do
       @svc = BERTRPC::Service.new('localhost', 9941)
-      @mod = BERTRPC::Mod.new(@svc, BERTRPC::Call, :mymod)
+      @req = @svc.call
+      @mod = BERTRPC::Mod.new(@svc, @req, :mymod)
     end
 
     should "call execute on the type" do
       m = mock(:execute => nil)
-      BERTRPC::Call.expects(:new).with(@svc, :mymod, :myfun, [1, 2, 3]).returns(m)
+      BERTRPC::Action.expects(:new).with(@svc, @req, :mymod, :myfun, [1, 2, 3]).returns(m)
       @mod.myfun(1, 2, 3)
-      
+
       m = mock(:execute => nil)
-      BERTRPC::Call.expects(:new).with(@svc, :mymod, :myfun, [1]).returns(m)
+      BERTRPC::Action.expects(:new).with(@svc, @req, :mymod, :myfun, [1]).returns(m)
       @mod.myfun(1)
     end
   end

data/test/request_test.rb

@@ -0,0 +1,24 @@
+require 'test_helper'
+
+class RequestTest < Test::Unit::TestCase
+  context "A Request" do
+    setup do
+      @svc = BERTRPC::Service.new('localhost', 9941)
+    end
+
+    should "be created with a Service and type" do
+      assert BERTRPC::Request.new(@svc, :call, nil).is_a?(BERTRPC::Request)
+    end
+  end
+
+  context "A Request instance" do
+    setup do
+      svc = BERTRPC::Service.new('localhost', 9941)
+      @req = BERTRPC::Request.new(@svc, :call, nil)
+    end
+
+    should "return a Mod instance" do
+      assert @req.myfun.is_a?(BERTRPC::Mod)
+    end
+  end
+end

data/test/service_test.rb

@@ -8,21 +8,35 @@ class ServiceTest < Test::Unit::TestCase
     end
   end
 
-  context "A Service Instance" do
+  context "A Service Instance's" do
     setup do
       @svc = BERTRPC::Service.new('localhost', 9941)
     end
 
-    should "return it's host" do
-      assert_equal 'localhost', @svc.host
+    context "accessors" do
+      should "return it's host" do
+        assert_equal 'localhost', @svc.host
+      end
+
+      should "return it's port" do
+        assert_equal 9941, @svc.port
+      end
     end
 
-    should "return it's port" do
-      assert_equal 9941, @svc.port
+    context "call method" do
+      should "return a call type Request" do
+        req = @svc.call
+        assert req.is_a?(BERTRPC::Request)
+        assert_equal :call, req.kind
+      end
     end
 
-    should "return a Call instance" do
-      assert @svc.call.is_a?(BERTRPC::CallProxy)
+    context "cast method" do
+      should "return a cast type Request" do
+        req = @svc.cast
+        assert req.is_a?(BERTRPC::Request)
+        assert_equal :cast, req.kind
+      end
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: bertrpc
 version: !ruby/object:Gem::Version 
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors: 
 - Tom Preston-Werner
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-08-13 00:00:00 -07:00
+date: 2009-09-05 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -40,16 +40,16 @@ files:
 - VERSION
 - bertrpc.gemspec
 - lib/bertrpc.rb
-- lib/bertrpc/call.rb
-- lib/bertrpc/call_proxy.rb
+- lib/bertrpc/action.rb
 - lib/bertrpc/encodes.rb
 - lib/bertrpc/errors.rb
 - lib/bertrpc/mod.rb
+- lib/bertrpc/request.rb
 - lib/bertrpc/service.rb
-- test/call_proxy_test.rb
-- test/call_test.rb
+- test/action_test.rb
 - test/encodes_test.rb
 - test/mod_test.rb
+- test/request_test.rb
 - test/service_test.rb
 - test/test_helper.rb
 has_rdoc: true
@@ -81,9 +81,9 @@ signing_key:
 specification_version: 3
 summary: BERTRPC is a Ruby BERT-RPC client library.
 test_files: 
-- test/call_proxy_test.rb
-- test/call_test.rb
+- test/action_test.rb
 - test/encodes_test.rb
 - test/mod_test.rb
+- test/request_test.rb
 - test/service_test.rb
 - test/test_helper.rb

data/lib/bertrpc/call.rb

@@ -1,33 +0,0 @@
-module BERTRPC
-  class Call
-    include Encodes
-    
-    def initialize(svc, mod, fun, args)
-      @svc = svc
-      @mod = mod
-      @fun = fun
-      @args = args
-    end
-
-    def execute
-      bert_request = encode_ruby_request([:call, @mod, @fun, @args])
-      bert_response = sync_request(bert_request)
-      decode_bert_response(bert_response)
-    end
-
-    #private
-
-    def sync_request(bert_request)
-      sock = TCPSocket.new(@svc.host, @svc.port)
-      sock.write([bert_request.length].pack("N"))
-      sock.write(bert_request)
-      lenheader = sock.read(4)
-      raise ProtocolError.new("Unable to read length header from server.") unless lenheader
-      len = lenheader.unpack('N').first
-      bert_response = sock.read(len)
-      raise ProtocolError.new("Unable to read data from server.") unless bert_response
-      sock.close
-      bert_response
-    end
-  end
-end

data/lib/bertrpc/call_proxy.rb

@@ -1,11 +0,0 @@
-module BERTRPC
-  class CallProxy
-    def initialize(svc)
-      @svc = svc
-    end
-
-    def method_missing(cmd, *args)
-      Mod.new(@svc, Call, cmd)
-    end
-  end
-end

data/test/call_proxy_test.rb

@@ -1,24 +0,0 @@
-require 'test_helper'
-
-class CallProxyTest < Test::Unit::TestCase
-  context "A CallProxy" do
-    setup do
-      @svc = BERTRPC::Service.new('localhost', 9941)
-    end
-
-    should "be created with a Service" do
-      assert BERTRPC::CallProxy.new(@svc).is_a?(BERTRPC::CallProxy)
-    end
-  end
-
-  context "A CallProxy instance" do
-    setup do
-      svc = BERTRPC::Service.new('localhost', 9941)
-      @cp = BERTRPC::CallProxy.new(@svc)
-    end
-
-    should "return a Mod instance" do
-      assert @cp.myfun.is_a?(BERTRPC::Mod)
-    end
-  end
-end