protobuf 2.7.11-java → 2.8.0.beta1-java

data/lib/protobuf/rpc/stat.rb

@@ -27,7 +27,7 @@ module Protobuf
       end
 
       def method_name
-        @method_name ||= @dispatcher.try(:service).try(:rpc)
+        @method_name ||= @dispatcher.try(:service).try(:method_name)
       end
 
       def server=(peer)

data/lib/protobuf/version.rb

@@ -1,4 +1,4 @@
 module Protobuf
-  VERSION = '2.7.11'
+  VERSION = '2.8.0.beta1'
   PROTOC_VERSION = '2.4.1'
 end

data/proto/dynamic_discovery.proto

@@ -0,0 +1,44 @@
+// Copyright (c) 2013 MoneyDesktop, Inc.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+// Authors: Devin Christensen
+//
+// Protobufs needed for dynamic discovery zmq server and client.
+
+package protobuf.rpc.dynamicDiscovery;
+
+enum BeaconType {
+  HEARTBEAT = 0;
+  FLATLINE = 1;
+}
+
+message Server {
+  optional string uuid = 1;
+  optional string address = 2;
+  optional string port = 3;
+  optional int32 ttl = 4;
+  repeated string services = 5;
+}
+
+message Beacon {
+  optional BeaconType beacon_type = 1;
+  optional Server server = 2;
+}
+

data/spec/benchmark/tasks.rb

@@ -32,9 +32,7 @@ namespace :benchmark do
     EM.stop if EM.reactor_running?
 
     EventMachine.fiber_run do
-      StubServer.new do |server|
-        client = ::Test::ResourceService.client
-
+      StubServer.new(:server => Protobuf::Rpc::Evented::Server) do |server|
         benchmark_wrapper(global_bench) do |bench|
           bench.report("ES / EC") do
             (1..number_tests.to_i).each { client.find(:name => "Test Name" * test_length.to_i, :active => true) }

data/spec/functional/socket_server_spec.rb

@@ -4,14 +4,14 @@ require 'spec/support/test/resource_service'
 describe 'Functional Socket Client' do
   before(:all) do
     load "protobuf/socket.rb"
-    Thread.abort_on_exception = true
-    server = OpenStruct.new(:host => "127.0.0.1", :port => 9399, :backlog => 100, :threshold => 100)
-    @server_thread = Thread.new(server) { |s| Protobuf::Rpc::SocketRunner.run(s) }
-    Thread.pass until Protobuf::Rpc::Socket::Server.running?
+    @options = OpenStruct.new(:host => "127.0.0.1", :port => 9399, :backlog => 100, :threshold => 100)
+    @runner = ::Protobuf::Rpc::SocketRunner.new(@options)
+    @server_thread = Thread.new(@runner) { |runner| runner.run }
+    Thread.pass until @runner.running?
   end
 
   after(:all) do
-    Protobuf::Rpc::SocketRunner.stop
+    @runner.stop
     @server_thread.join
   end
 
@@ -56,3 +56,4 @@ describe 'Functional Socket Client' do
     error.message.should =~ /expected request.*ResourceFindRequest.*Resource instead/i
   end
 end
+

data/spec/functional/zmq_server_spec.rb

@@ -1,24 +1,29 @@
 require 'spec_helper'
 require 'spec/support/test/resource_service'
+require 'protobuf/rpc/service_directory'
 
 describe 'Functional ZMQ Client' do
-  before(:all) do
-    load "protobuf/zmq.rb"
-    Thread.abort_on_exception = true
-    server = OpenStruct.new(:host => "127.0.0.1", 
-                            :port => 9399, 
-                            :worker_port => 9400, 
-                            :backlog => 100, 
-                            :threshold => 100, 
-                            :threads => 5)
+  let(:options) {{
+    :host => "127.0.0.1",
+    :port => 9399,
+    :worker_port => 9400,
+    :backlog => 100,
+    :threshold => 100,
+    :threads => 5
+  }}
+
+  let(:server) { ::Protobuf::Rpc::Zmq::Server.new(options) }
+  let(:server_thread) { Thread.new(server) { |server| server.run } }
 
-    @server_thread = Thread.new(server) { |s| Protobuf::Rpc::ZmqRunner.run(s) }
-    Thread.pass until Protobuf::Rpc::Zmq::Server.running?
+  before do
+    load "protobuf/zmq.rb"
+    server_thread.abort_on_exception = true
+    Thread.pass until server.running?
   end
 
-  after(:all) do
-    ::Protobuf::Rpc::Zmq::Server.stop
-    @server_thread.try(:join)
+  after do
+    server.stop
+    server_thread.join
   end
 
   it 'runs fine when required fields are set' do
@@ -38,27 +43,51 @@ describe 'Functional ZMQ Client' do
     }.to_not raise_error
   end
 
-  it 'calls the on_failure callback when a message is malformed' do
-    error = nil
-    request = ::Test::ResourceFindRequest.new(:active => true)
-    client = ::Test::ResourceService.client
+  context 'when a message is malformed' do
+    it 'calls the on_failure callback' do
+      error = nil
+      StubServer.new(:server => Protobuf::Rpc::Zmq::Server) do
+        request = ::Test::ResourceFindRequest.new(:active => true)
+        client = ::Test::ResourceService.client
+
+        client.find(request) do |c|
+          c.on_success { raise "shouldn't pass" }
+          c.on_failure {|e| error = e }
+        end
+      end
+      error.message.should match(/name.*required/)
+    end
+  end
+
+  context 'when the request type is wrong' do
+    it 'calls the on_failure callback' do
+      error = nil
+      StubServer.new(:server => Protobuf::Rpc::Zmq::Server) do
+        request = ::Test::Resource.new(:name => 'Test Name')
+        client = ::Test::ResourceService.client
 
-    client.find(request) do |c|
-      c.on_success { raise "shouldn't pass"}
-      c.on_failure {|e| error = e}
+        client.find(request) do |c|
+          c.on_success { raise "shouldn't pass" }
+          c.on_failure {|e| error = e}
+        end
+      end
+      error.message.should match(/expected request.*ResourceFindRequest.*Resource instead/i)
     end
-    error.message.should =~ /name.*required/
   end
 
-  it 'calls the on_failure callback when the request type is wrong' do
-    error = nil
-    request = ::Test::Resource.new(:name => 'Test Name')
-    client = ::Test::ResourceService.client
+  context 'when the server takes too long to respond' do
+    it 'responds with a timeout error' do
+      error = nil
+      StubServer.new(:server => Protobuf::Rpc::Zmq::Server) do
+        client = ::Test::ResourceService.client(:timeout => 1)
 
-    client.find(request) do |c|
-      c.on_success { raise "shouldn't pass"}
-      c.on_failure {|e| error = e}
+        client.find_with_sleep(:sleep => 2) do |c|
+          c.on_success { raise "shouldn't pass" }
+          c.on_failure { |e| error = e }
+        end
+      end
+      error.message.should match(/The server took longer than 1 seconds to respond/i)
     end
-    error.message.should =~ /expected request.*ResourceFindRequest.*Resource instead/i
   end
+
 end

data/spec/lib/protobuf/cli_spec.rb

@@ -7,10 +7,14 @@ describe ::Protobuf::CLI do
     File.expand_path('../../../support/test_app_file.rb', __FILE__)
   end
 
-  before do
-    ::Protobuf::Rpc::SocketRunner.stub(:run)
-    ::Protobuf::Rpc::ZmqRunner.stub(:run)
-    ::Protobuf::Rpc::EventedRunner.stub(:run)
+  let(:sock_runner) { double "SocketRunner", run: nil, register_signals: nil }
+  let(:zmq_runner) { double "ZmqRunner", run: nil, register_signals: nil }
+  let(:evented_runner) { double "EventedRunner", run: nil, register_signals: nil }
+
+  before(:each) do
+    ::Protobuf::Rpc::SocketRunner.stub(:new) { sock_runner }
+    ::Protobuf::Rpc::ZmqRunner.stub(:new) { zmq_runner }
+    ::Protobuf::Rpc::EventedRunner.stub(:new) { evented_runner }
   end
 
   describe '#start' do
@@ -22,9 +26,9 @@ describe ::Protobuf::CLI do
       let(:test_args) { [ '--host=123.123.123.123' ] }
 
       it 'sends the host option to the runner' do
-        ::Protobuf::Rpc::SocketRunner.should_receive(:run) do |options|
+        ::Protobuf::Rpc::SocketRunner.should_receive(:new) do |options|
           options[:host].should eq '123.123.123.123'
-        end
+        end.and_return(sock_runner)
         described_class.start(args)
       end
     end
@@ -33,9 +37,9 @@ describe ::Protobuf::CLI do
       let(:test_args) { [ '--port=12345' ] }
 
       it 'sends the port option to the runner' do
-        ::Protobuf::Rpc::SocketRunner.should_receive(:run) do |options|
+        ::Protobuf::Rpc::SocketRunner.should_receive(:new) do |options|
           options[:port].should eq 12345
-        end
+        end.and_return(sock_runner)
         described_class.start(args)
       end
     end
@@ -44,9 +48,9 @@ describe ::Protobuf::CLI do
       let(:test_args) { [ '--threads=500' ] }
 
       it 'sends the threads option to the runner' do
-        ::Protobuf::Rpc::SocketRunner.should_receive(:run) do |options|
+        ::Protobuf::Rpc::SocketRunner.should_receive(:new) do |options|
           options[:threads].should eq 500
-        end
+        end.and_return(sock_runner)
         described_class.start(args)
       end
     end
@@ -55,9 +59,9 @@ describe ::Protobuf::CLI do
       let(:test_args) { [ '--backlog=500' ] }
 
       it 'sends the backlog option to the runner' do
-        ::Protobuf::Rpc::SocketRunner.should_receive(:run) do |options|
+        ::Protobuf::Rpc::SocketRunner.should_receive(:new) do |options|
           options[:backlog].should eq 500
-        end
+        end.and_return(sock_runner)
         described_class.start(args)
       end
     end
@@ -66,9 +70,9 @@ describe ::Protobuf::CLI do
       let(:test_args) { [ '--threshold=500' ] }
 
       it 'sends the backlog option to the runner' do
-        ::Protobuf::Rpc::SocketRunner.should_receive(:run) do |options|
+        ::Protobuf::Rpc::SocketRunner.should_receive(:new) do |options|
           options[:threshold].should eq 500
-        end
+        end.and_return(sock_runner)
         described_class.start(args)
       end
     end
@@ -83,17 +87,6 @@ describe ::Protobuf::CLI do
         end
         described_class.start(args)
       end
-
-      context 'when debugging' do
-        let(:test_args) { [ '--level=3', '--debug' ] }
-
-        it 'overrides the log-level to DEBUG' do
-          ::Protobuf::Logger.should_receive(:configure) do |options|
-            options[:level].should eq ::Logger::DEBUG
-          end
-          described_class.start(args)
-        end
-      end
     end
 
     context 'gc options' do
@@ -103,16 +96,18 @@ describe ::Protobuf::CLI do
 
         it 'sets both request and serialization pausing to false' do
           described_class.start(args)
-          ::Protobuf.gc_pause_server_request?.should be_false
+          ::Protobuf.should_not be_gc_pause_server_request
         end
       end
 
-      context 'request pausing' do
-        let(:test_args) { [ '--gc_pause_request' ] }
+      unless defined?(JRUBY_VERSION)
+        context 'request pausing' do
+          let(:test_args) { [ '--gc_pause_request' ] }
 
-        it 'sets the configuration option to GC pause server request' do
-          described_class.start(args)
-          ::Protobuf.gc_pause_server_request?.should be_true
+          it 'sets the configuration option to GC pause server request' do
+            described_class.start(args)
+            ::Protobuf.should be_gc_pause_server_request
+          end
         end
       end
     end
@@ -167,18 +162,18 @@ describe ::Protobuf::CLI do
         let(:runner) { ::Protobuf::Rpc::SocketRunner }
 
         before do
-          ::Protobuf::Rpc::EventedRunner.should_not_receive(:run)
-          ::Protobuf::Rpc::ZmqRunner.should_not_receive(:run)
+          ::Protobuf::Rpc::EventedRunner.should_not_receive(:new)
+          ::Protobuf::Rpc::ZmqRunner.should_not_receive(:new)
         end
 
         it 'is activated by the --socket switch' do
-          runner.should_receive(:run)
+          runner.should_receive(:new)
           described_class.start(args)
         end
 
         it 'is activated by PB_SERVER_TYPE=Socket ENV variable' do 
           ENV['PB_SERVER_TYPE'] = "Socket"
-          runner.should_receive(:run)
+          runner.should_receive(:new).and_return(sock_runner)
           described_class.start(args)
           ENV.delete('PB_SERVER_TYPE')
         end
@@ -194,18 +189,18 @@ describe ::Protobuf::CLI do
         let(:runner) { ::Protobuf::Rpc::EventedRunner }
 
         before do
-          ::Protobuf::Rpc::SocketRunner.should_not_receive(:run)
-          ::Protobuf::Rpc::ZmqRunner.should_not_receive(:run)
+          ::Protobuf::Rpc::SocketRunner.should_not_receive(:new)
+          ::Protobuf::Rpc::ZmqRunner.should_not_receive(:new)
         end
 
         it 'is activated by the --evented switch' do
-          runner.should_receive(:run)
+          runner.should_receive(:new).and_return(evented_runner)
           described_class.start(args)
         end
 
         it 'is activated by PB_SERVER_TYPE=Evented ENV variable' do 
           ENV['PB_SERVER_TYPE'] = "Evented"
-          runner.should_receive(:run)
+          runner.should_receive(:new).and_return(evented_runner)
           described_class.start(args)
           ENV.delete('PB_SERVER_TYPE')
         end
@@ -215,29 +210,29 @@ describe ::Protobuf::CLI do
           ::Protobuf.connector_type.should == :evented
         end
       end
-      
+
       context 'zmq workers only' do
         let(:test_args) { [ '--workers_only', '--zmq' ] }
         let(:runner) { ::Protobuf::Rpc::ZmqRunner }
 
         before do
-          ::Protobuf::Rpc::SocketRunner.should_not_receive(:run)
-          ::Protobuf::Rpc::EventedRunner.should_not_receive(:run)
+          ::Protobuf::Rpc::SocketRunner.should_not_receive(:new)
+          ::Protobuf::Rpc::EventedRunner.should_not_receive(:new)
         end
 
         it 'is activated by the --workers_only switch' do
-          runner.should_receive(:run) do |options|
+          runner.should_receive(:new) do |options|
             options[:workers_only].should be_true
-          end
+          end.and_return(zmq_runner)
 
           described_class.start(args)
         end
 
         it 'is activated by PB_WORKERS_ONLY=1 ENV variable' do 
           ENV['PB_WORKERS_ONLY'] = "1"
-          runner.should_receive(:run) do |options|
+          runner.should_receive(:new) do |options|
             options[:workers_only].should be_true
-          end
+          end.and_return(zmq_runner)
 
           described_class.start(args)
           ENV.delete('PB_WORKERS_ONLY')
@@ -249,14 +244,14 @@ describe ::Protobuf::CLI do
         let(:runner) { ::Protobuf::Rpc::ZmqRunner }
 
         before do
-          ::Protobuf::Rpc::SocketRunner.should_not_receive(:run)
-          ::Protobuf::Rpc::EventedRunner.should_not_receive(:run)
+          ::Protobuf::Rpc::SocketRunner.should_not_receive(:new)
+          ::Protobuf::Rpc::EventedRunner.should_not_receive(:new)
         end
 
         it 'is activated by the --worker_port switch' do
-          runner.should_receive(:run) do |options|
+          runner.should_receive(:new) do |options|
             options[:worker_port].should eq(1234)
-          end
+          end.and_return(zmq_runner)
 
           described_class.start(args)
         end
@@ -267,18 +262,18 @@ describe ::Protobuf::CLI do
         let(:runner) { ::Protobuf::Rpc::ZmqRunner }
 
         before do
-          ::Protobuf::Rpc::SocketRunner.should_not_receive(:run)
-          ::Protobuf::Rpc::EventedRunner.should_not_receive(:run)
+          ::Protobuf::Rpc::SocketRunner.should_not_receive(:new)
+          ::Protobuf::Rpc::EventedRunner.should_not_receive(:new)
         end
 
         it 'is activated by the --zmq switch' do
-          runner.should_receive(:run)
+          runner.should_receive(:new)
           described_class.start(args)
         end
 
         it 'is activated by PB_SERVER_TYPE=Zmq ENV variable' do 
           ENV['PB_SERVER_TYPE'] = "Zmq"
-          runner.should_receive(:run)
+          runner.should_receive(:new)
           described_class.start(args)
           ENV.delete('PB_SERVER_TYPE')
         end