protobuf 2.8.0.beta2 → 2.8.0.beta3

data/lib/protobuf.rb

@@ -3,7 +3,16 @@ require 'socket'
 require 'pp'
 require 'stringio'
 require 'active_support/core_ext/object/blank'
-require 'active_support/core_ext/object/try'
+require 'active_support/version'
+
+if ActiveSupport::VERSION::MAJOR > 2
+  require 'active_support/core_ext/object/try'
+else
+  require 'active_support/core_ext/module/delegation'
+  require 'active_support/core_ext/kernel/reporting'
+  require 'active_support/core_ext/try'
+end
+
 require 'active_support/inflector'
 require 'active_support/json'
 

data/lib/protobuf/field/float_field.rb

@@ -4,10 +4,6 @@ module Protobuf
   module Field
     class FloatField < BaseField
       def self.default; 0.0; end
-      def self.max;  1.0/0; end
-      def self.min; -1.0/0; end
-      def max;  1.0/0; end
-      def min; -1.0/0; end
 
       def wire_type
         WireType::FIXED32
@@ -22,7 +18,7 @@ module Protobuf
       end
 
       def acceptable?(val)
-        (val > min || val < max) rescue false
+        val.respond_to?(:to_f)
       end
     end
   end

data/lib/protobuf/rpc/connectors/zmq.rb

@@ -19,6 +19,13 @@ module Protobuf
 
         CLIENT_RETRIES = (ENV['PB_CLIENT_RETRIES'] || 3)
 
+        ##
+        # Class Methods
+        #
+        def self.zmq_context
+          @zmq_context ||= ZMQ::Context.new
+        end
+
         ##
         # Instance methods
         #
@@ -47,7 +54,6 @@ module Protobuf
 
         def close_connection
           socket_close
-          zmq_context_terminate
         end
 
         # Establish a request socket connection to the remote rpc_server.
@@ -106,7 +112,7 @@ module Protobuf
               read_response
               return
             else
-              close_connection
+              socket_close
             end
           end
 
@@ -171,16 +177,7 @@ module Protobuf
         # an exit block to ensure the context is terminated correctly.
         #
         def zmq_context
-          @zmq_context ||= ::ZMQ::Context.new
-        end
-
-        # Terminate the zmq_context (if any).
-        #
-        def zmq_context_terminate
-          log_debug { sign_message("Terminating ZMQ Context")  }
-          @zmq_context.try(:terminate)
-          @zmq_context = nil
-          log_debug { sign_message("ZMQ Context terminated")  }
+          self.class.zmq_context
         end
 
         def zmq_error_check(return_code, source)

data/lib/protobuf/rpc/servers/zmq/broker.rb

@@ -1,4 +1,3 @@
-
 module Protobuf
   module Rpc
     module Zmq
@@ -11,31 +10,24 @@ module Protobuf
           init_zmq_context
           init_backend_socket
           init_frontend_socket
-          init_shutdown_socket
           init_poller
         rescue
           teardown
           raise
         end
 
-        def join
-          @thread.try(:join)
-        end
-
         def run
           @idle_workers = []
 
-          catch(:shutdown) do
-            while @poller.poll > 0
-              @poller.readables.each do |readable|
-                case readable
-                when @frontend_socket
-                  process_frontend
-                when @backend_socket
-                  process_backend
-                when @shutdown_socket
-                  throw :shutdown
-                end
+          while running?
+            break if @poller.poll(500) < 0
+
+            @poller.readables.each do |readable|
+              case readable
+              when @frontend_socket
+                process_frontend
+              when @backend_socket
+                process_backend
               end
             end
           end
@@ -43,23 +35,8 @@ module Protobuf
           teardown
         end
 
-        def start
-          log_debug { sign_message("starting broker") }
-
-          @thread = Thread.new { self.run }
-
-          self
-        end
-
-        def shutdown_uri
-          "inproc://#{object_id}"
-        end
-
-        def signal_shutdown
-          socket = @zmq_context.socket(ZMQ::PAIR)
-          zmq_error_check(socket.connect(shutdown_uri))
-          zmq_error_check(socket.send_string ".")
-          zmq_error_check(socket.close)
+        def running?
+          @server.running? || @server.workers.any?
         end
 
         private
@@ -78,12 +55,6 @@ module Protobuf
           @poller = ZMQ::Poller.new
           @poller.register_readable(@frontend_socket)
           @poller.register_readable(@backend_socket)
-          @poller.register_readable(@shutdown_socket)
-        end
-
-        def init_shutdown_socket
-          @shutdown_socket = @zmq_context.socket(ZMQ::PAIR)
-          zmq_error_check(@shutdown_socket.bind(shutdown_uri))
         end
 
         def init_zmq_context
@@ -108,21 +79,20 @@ module Protobuf
         end
 
         def read_from_backend
-          [].tap do |frames|
-            zmq_error_check(@backend_socket.recv_strings(frames))
-          end
+          frames = []
+          zmq_error_check(@backend_socket.recv_strings(frames))
+          frames
         end
 
         def read_from_frontend
-          [].tap do |frames|
-            zmq_error_check(@frontend_socket.recv_strings(frames))
-          end
+          frames = []
+          zmq_error_check(@frontend_socket.recv_strings(frames))
+          frames
         end
 
         def teardown
           @frontend_socket.try(:close)
           @backend_socket.try(:close)
-          @shutdown_socket.try(:close)
           @zmq_context.try(:terminate)
         end
 

data/lib/protobuf/rpc/servers/zmq/server.rb

@@ -15,7 +15,7 @@ module Protobuf
           :broadcast_beacons => false
         }
 
-        attr_accessor :options
+        attr_accessor :options, :workers
 
         def initialize(options)
           @options = DEFAULT_OPTIONS.merge(options)
@@ -23,12 +23,16 @@ module Protobuf
 
           init_zmq_context
           init_beacon_socket if broadcast_beacons?
-          init_shutdown_socket
+          init_shutdown_pipe
         rescue
           teardown
           raise
         end
 
+        def add_worker
+          @total_workers = total_workers + 1
+        end
+
         def backend_ip
           frontend_ip
         end
@@ -120,7 +124,7 @@ module Protobuf
         end
 
         def maintenance_timeout
-          1_000 * (next_maintenance - Time.now.to_i)
+          next_maintenance - Time.now.to_i
         end
 
         def next_maintenance
@@ -131,7 +135,7 @@ module Protobuf
         end
 
         def minimum_timeout
-          100
+          0.1
         end
 
         def next_beacon
@@ -173,8 +177,8 @@ module Protobuf
           start_missing_workers
           wait_for_shutdown_signal
           broadcast_flatline if broadcast_beacons?
-          stop_workers
-          stop_broker unless brokerless?
+          Thread.pass until reap_dead_workers.empty?
+          @broker.join unless brokerless?
         ensure
           @running = false
           teardown
@@ -184,21 +188,6 @@ module Protobuf
           !!@running
         end
 
-        def shutdown_uri
-          "inproc://#{object_id}"
-        end
-
-        def signal_shutdown
-          socket = @zmq_context.socket ZMQ::PAIR
-          zmq_error_check(socket.connect shutdown_uri)
-          zmq_error_check(socket.send_string ".")
-          zmq_error_check(socket.close)
-        end
-
-        def start_broker
-          @broker = ::Protobuf::Rpc::Zmq::Broker.new(self).start
-        end
-
         def start_missing_workers
           missing_workers = total_workers - @workers.size
 
@@ -208,26 +197,14 @@ module Protobuf
           end
         end
 
-        def start_worker
-          @workers << ::Protobuf::Rpc::Zmq::Worker.new(self).start
-        end
-
         def stop
-          signal_shutdown
-        end
-
-        def stop_broker
-          @broker.signal_shutdown
-          @broker.join
-        end
-
-        def stop_workers
-          @workers.each(&:signal_shutdown)
-          Thread.pass until reap_dead_workers.empty?
+          @running = false
+          @shutdown_w.write('.')
         end
 
         def teardown
-          @shutdown_socket.try(:close)
+          @shutdown_r.try(:close)
+          @shutdown_w.try(:close)
           @beacon_socket.try(:close)
           @zmq_context.try(:terminate)
           @last_reaping = @last_beacon = @timeout = nil
@@ -260,12 +237,9 @@ module Protobuf
         end
 
         def wait_for_shutdown_signal
-          poller = ZMQ::Poller.new
-          poller.register_readable(@shutdown_socket)
+          loop do
+            break if IO.select([@shutdown_r], nil, nil, timeout)
 
-          # If the poller returns 1, a shutdown signal has been received.
-          # If the poller returns -1, something went wrong.
-          while poller.poll(timeout) === 0
             if reap_dead_workers?
               reap_dead_workers
               start_missing_workers
@@ -283,14 +257,31 @@ module Protobuf
           @beacon_socket.connect(beacon_ip, beacon_port)
         end
 
-        def init_shutdown_socket
-          @shutdown_socket = @zmq_context.socket(ZMQ::PAIR)
-          zmq_error_check(@shutdown_socket.bind shutdown_uri)
+        def init_shutdown_pipe
+          @shutdown_r, @shutdown_w = IO.pipe
         end
 
         def init_zmq_context
           @zmq_context = ZMQ::Context.new
         end
+
+        def start_broker
+          @broker = Thread.new(self) do |server|
+            ::Protobuf::Rpc::Zmq::Broker.new(server).run
+          end
+        end
+
+        def start_worker
+          @workers << Thread.new(self) do |server|
+            begin
+              ::Protobuf::Rpc::Zmq::Worker.new(server).run
+            rescue => e
+              message = "Worker failed: #{e.inspect}\n #{e.backtrace.join($/)}"
+              $stderr.puts(message)
+              log_error { message }
+            end
+          end
+        end
       end
     end
   end

data/lib/protobuf/rpc/servers/zmq/worker.rb

@@ -13,9 +13,9 @@ module Protobuf
         #
         def initialize(server)
           @server = server
+
           init_zmq_context
           init_backend_socket
-          init_shutdown_socket
         rescue
           teardown
           raise
@@ -24,14 +24,6 @@ module Protobuf
         ##
         # Instance Methods
         #
-        def alive?
-          @thread.try(:alive?) || false
-        end
-
-        def join
-          @thread.try(:join)
-        end
-
         def process_request
           @client_address, empty, @request_data = read_from_backend
 
@@ -41,12 +33,6 @@ module Protobuf
           end
         end
 
-        def read_from_backend
-          [].tap do |frames|
-            zmq_error_check(@backend_socket.recv_strings(frames))
-          end
-        end
-
         def run
           poller = ::ZMQ::Poller.new
           poller.register_readable(@backend_socket)
@@ -55,23 +41,22 @@ module Protobuf
           # Send request to broker telling it we are ready
           write_to_backend([::Protobuf::Rpc::Zmq::WORKER_READY_MESSAGE])
 
-          catch(:shutdown) do
-            while poller.poll > 0
-              poller.readables.each do |readable|
-                case readable
-                when @backend_socket
-                  initialize_request!
-                  process_request
-                when @shutdown_socket
-                  throw :shutdown
-                end
-              end
+          while running?
+            break if poller.poll(500) < 0
+
+            if poller.readables.any?
+              initialize_request!
+              process_request
             end
           end
         ensure
           teardown
         end
 
+        def running?
+          @server.running?
+        end
+
         def send_data
           data = @response.serialize_to_string
 
@@ -80,56 +65,31 @@ module Protobuf
           write_to_backend([@client_address, "", data])
         end
 
-        def shutdown_uri
-          "inproc://#{object_id}"
-        end
+        private
 
-        def signal_shutdown
-          socket = @zmq_context.socket ZMQ::PAIR
-          zmq_error_check(socket.connect(shutdown_uri))
-          zmq_error_check(socket.send_string("."))
-          zmq_error_check(socket.close)
+        def init_zmq_context
+          @zmq_context = ZMQ::Context.new
         end
 
-        def start
-          @thread = Thread.new do
-            begin
-              self.run
-            rescue => e
-              message = "Worker failed: #{e.inspect}\n #{e.backtrace.join($/)}"
-              $stderr.puts(message)
-              log_error { message }
-            end
-          end
+        def init_backend_socket
+          @backend_socket = @zmq_context.socket(ZMQ::REQ)
+          zmq_error_check(@backend_socket.connect(@server.backend_uri))
+        end
 
-          self
+        def read_from_backend
+          frames = []
+          zmq_error_check(@backend_socket.recv_strings(frames))
+          frames
         end
 
         def teardown
           @backend_socket.try(:close)
-          @shutdown_socket.try(:close)
           @zmq_context.try(:terminate)
         end
 
         def write_to_backend(frames)
           zmq_error_check(@backend_socket.send_strings(frames))
         end
-
-        private
-
-        def init_zmq_context
-          @zmq_context = ZMQ::Context.new
-        end
-
-        def init_backend_socket
-          @backend_socket = @zmq_context.socket(ZMQ::REQ)
-          zmq_error_check(@backend_socket.connect(@server.backend_uri))
-        end
-
-        def init_shutdown_socket
-          @shutdown_socket = @zmq_context.socket(ZMQ::PAIR)
-          zmq_error_check(@shutdown_socket.bind(shutdown_uri))
-        end
       end
     end
   end

data/lib/protobuf/rpc/servers/zmq_runner.rb

@@ -36,9 +36,8 @@ module Protobuf
 
       def register_signals
         trap(:TTIN) do
-          log_info { "TTIN received: Starting new worker" }
-          @server.start_worker
-          log_info { "Worker count : #{::Protobuf::Rpc::Zmq::Server.threads.size}" }
+          @server.add_worker
+          log_info { "Increased worker size to: #{@server.total_workers}" }
         end
       end
     end

data/lib/protobuf/rpc/service_directory.rb

@@ -183,7 +183,8 @@ module Protobuf
 
       def run
         loop do
-          process_beacon(wait_for_beacon)
+          beacon = wait_for_beacon
+          process_beacon(beacon)
           remove_expired_listings
         end
       rescue => e
@@ -194,12 +195,13 @@ module Protobuf
       def wait_for_beacon
         data, addr = @socket.recvfrom(2048)
 
-        ::Protobuf::Rpc::DynamicDiscovery::Beacon.new.tap do |beacon|
-          beacon.parse_from_string(data) rescue nil
+        beacon = ::Protobuf::Rpc::DynamicDiscovery::Beacon.new
+        beacon.parse_from_string(data)
 
-          # Favor the address captured by the socket
-          beacon.try(:server).try(:address=, addr[3])
-        end
+        # Favor the address captured by the socket
+        beacon.try(:server).try(:address=, addr[3])
+
+        beacon
       end
     end
   end

data/lib/protobuf/version.rb

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

data/spec/functional/zmq_server_spec.rb

@@ -1,4 +1,5 @@
 require 'spec_helper'
+
 require 'spec/support/test/resource_service'
 require 'protobuf/rpc/service_directory'
 
@@ -13,11 +14,13 @@ describe 'Functional ZMQ Client' do
   }}
 
   let(:server) { ::Protobuf::Rpc::Zmq::Server.new(options) }
-  let(:server_thread) { Thread.new(server) { |server| server.run } }
+  let!(:server_thread) { Thread.new(server) { |server| server.run } }
 
-  before do
+  before(:all) do
     load "protobuf/zmq.rb"
-    server_thread.abort_on_exception = true
+  end
+
+  before do
     Thread.pass until server.running?
   end
 
@@ -43,17 +46,36 @@ describe 'Functional ZMQ Client' do
     }.to_not raise_error
   end
 
+  it 'runs under heavy load' do
+    100.times do |x|
+      50.times.map do |y|
+        Thread.new do
+          client = ::Test::ResourceService.client
+
+          client.find(:name => 'Test Name', :active => true) do |c|
+            c.on_success do |succ|
+              succ.name.should eq("Test Name")
+              succ.status.should eq(::Test::StatusType::ENABLED)
+            end
+
+            c.on_failure do |err|
+              raise err.inspect
+            end
+          end
+        end
+      end.each(&:join)
+    end
+  end
+
   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
+      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
+      client.find(request) do |c|
+        c.on_success { raise "shouldn't pass" }
+        c.on_failure {|e| error = e }
       end
       error.message.should match(/name.*required/)
     end
@@ -62,14 +84,12 @@ describe 'Functional ZMQ Client' do
   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
+      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}
-        end
+      client.find(request) do |c|
+        c.on_success { raise "shouldn't pass" }
+        c.on_failure {|e| error = e}
       end
       error.message.should match(/expected request.*ResourceFindRequest.*Resource instead/i)
     end
@@ -78,13 +98,11 @@ describe 'Functional ZMQ Client' do
   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 = ::Test::ResourceService.client(:timeout => 1)
 
-        client.find_with_sleep(:sleep => 2) do |c|
-          c.on_success { raise "shouldn't pass" }
-          c.on_failure { |e| error = e }
-        end
+      client.find_with_sleep(:sleep => 2) do |c|
+        c.on_success { raise "shouldn't pass" }
+        c.on_failure { |e| error = e }
       end
       error.message.should match(/The server took longer than 1 seconds to respond/i)
     end

data/spec/lib/protobuf/rpc/servers/zmq/server_spec.rb

@@ -32,11 +32,6 @@ describe Protobuf::Rpc::Zmq::Server do
   end
 
   describe '.stop' do
-    it 'signals shutdown' do
-      subject.should_receive(:signal_shutdown)
-      subject.stop
-    end
-
     it 'sets running to false' do
       subject.instance_variable_set(:@workers, [])
       subject.stop

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: protobuf
 version: !ruby/object:Gem::Version
-  version: 2.8.0.beta2
+  version: 2.8.0.beta3
   prerelease: 6
 platform: ruby
 authors:
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-06-18 00:00:00.000000000 Z
+date: 2013-06-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -507,7 +507,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -1688433425465903447
+      hash: 4440359638295804549
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements: