protobuffy 3.6.0 → 4.0.0

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

@@ -1,111 +1,119 @@
-require 'protobuf/rpc/server'
+require 'set'
+
 require 'protobuf/rpc/servers/socket/worker'
 
 module Protobuf
   module Rpc
     module Socket
       class Server
-        include ::Protobuf::Logger::LogMethods
+        include ::Protobuf::Logging
 
         AUTO_COLLECT_TIMEOUT = 5 # seconds
 
+        private
+
+        attr_accessor :threshold, :host, :port, :backlog
+        attr_writer :running
+
+        public
+
+        attr_reader :running
+        alias :running? running
+
         def initialize(options)
-          @options = options
+          self.running = false
+          self.host = options.fetch(:host)
+          self.port = options.fetch(:port)
+          self.backlog = options.fetch(:backlog, 100)
+          self.threshold = options.fetch(:threshold, 100)
+        end
+
+        def threads
+          @threads ||= []
+        end
+
+        def working
+          @working ||= Set.new
         end
 
         def cleanup?
-          # every 10 connections run a cleanup routine after closing the response
-          @threads.size > (@threshold - 1) && (@threads.size % @threshold) == 0
+          # every `threshold` connections run a cleanup routine after closing the response
+          !threads.empty? && threads.size % threshold == 0
         end
 
         def cleanup_threads
-          log_debug { sign_message("Thread cleanup - #{@threads.size} - start") }
-
-          @threads = @threads.select do |t|
-            if t[:thread].alive?
-              true
-            else
-              t[:thread].join
-              @working.delete(t[:socket])
-              false
+          logger.debug { sign_message("Thread cleanup - #{threads.size} - start") }
+
+          threads.delete_if do |hash|
+            unless (thread = hash.fetch(:thread)).alive?
+              thread.join
+              working.delete(hash.fetch(:socket))
             end
           end
 
-          log_debug { sign_message("Thread cleanup - #{@threads.size} - complete") }
+          logger.debug { sign_message("Thread cleanup - #{threads.size} - complete") }
         end
 
         def log_signature
-          @_log_signature ||= "server-#{self.class.name}"
+          @_log_signature ||= "[server-#{self.class.name}]"
         end
 
         def new_worker(socket)
           Thread.new(socket) do |sock|
-            ::Protobuf::Rpc::Socket::Worker.new(sock) do |s|
-              s.close
-            end
+            ::Protobuf::Rpc::Socket::Worker.new(sock, &:close)
           end
         end
 
         def run
-          log_debug { sign_message("Run") }
-          host = @options[:host]
-          port = @options[:port]
-          backlog = @options[:backlog]
-          @threshold = @options[:threshold]
-
-          @threads = []
-          @server = ::TCPServer.new(host, port)
-          raise "The server was unable to start properly." if @server.closed?
-
-          @server.listen(backlog)
-          @working = []
-          @listen_fds = [@server]
-          @running = true
-
-          while running?
-            log_debug { sign_message("Waiting for connections") }
-            ready_cnxns = IO.select(@listen_fds, [], [], AUTO_COLLECT_TIMEOUT) rescue nil
-
-            if ready_cnxns
-              cnxns = ready_cnxns.first
-              cnxns.each do |client|
-                case
-                when !running? then
-                  # no-op
-                when client == @server then
-                  log_debug { sign_message("Accepted new connection") }
-                  client, sockaddr = @server.accept
-                  @listen_fds << client
-                else
-                  unless @working.include?(client)
-                    @working << @listen_fds.delete(client)
-                    log_debug { sign_message("Working")  }
-                    @threads << { :thread => new_worker(client), :socket => client }
-
-                    cleanup_threads if cleanup?
+          logger.debug { sign_message("Run") }
+
+          server = ::TCPServer.new(host, port)
+          fail "The server was unable to start properly." if server.closed?
+
+          begin
+            server.listen(backlog)
+            listen_fds = [server]
+            self.running = true
+
+            while running?
+              logger.debug { sign_message("Waiting for connections") }
+              ready_cnxns = begin
+                IO.select(listen_fds, [], [], AUTO_COLLECT_TIMEOUT)
+              rescue IOError
+                nil
+              end
+
+              if ready_cnxns
+                ready_cnxns.first.each do |client|
+                  case
+                  when !running?
+                    # no-op
+                  when client == server
+                    logger.debug { sign_message("Accepted new connection") }
+                    client, _sockaddr = server.accept
+                    listen_fds << client
+                  else
+                    unless working.include?(client)
+                      working << listen_fds.delete(client)
+                      logger.debug { sign_message("Working") }
+                      threads << { :thread => new_worker(client), :socket => client }
+
+                      cleanup_threads if cleanup?
+                    end
                   end
                 end
+              elsif threads.size > 1
+                # Run a cleanup if select times out while waiting
+                cleanup_threads
               end
-            else
-              # Run a cleanup if select times out while waiting
-              cleanup_threads if @threads.size > 1
             end
+          ensure
+            server.close
           end
-
-        rescue Errno::EADDRINUSE
-          raise
-        rescue
-          # Closing the server causes the loop to raise an exception here
-          raise #if running?
-        end
-
-        def running?
-          !!@running
         end
 
         def stop
-          @running = false
-          @server.try(:close)
+          self.running = false
         end
       end
     end

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

@@ -1,12 +1,12 @@
 require 'protobuf/rpc/server'
-require 'protobuf/logger'
+require 'protobuf/logging'
 
 module Protobuf
   module Rpc
     module Socket
       class Worker
         include ::Protobuf::Rpc::Server
-        include ::Protobuf::Logger::LogMethods
+        include ::Protobuf::Logging
 
         def initialize(sock, &complete_cb)
           @socket = sock
@@ -33,7 +33,7 @@ module Protobuf
         end
 
         def send_data(data)
-          raise 'Socket closed unexpectedly' unless socket_writable?
+          fail 'Socket closed unexpectedly' unless socket_writable?
           response_buffer = Protobuf::Rpc::Buffer.new(:write)
           response_buffer.set_data(data)
 
@@ -44,7 +44,7 @@ module Protobuf
         end
 
         def log_signature
-          @_log_signature ||= "server-#{self.class}-#{object_id}"
+          @_log_signature ||= "[server-#{self.class}-#{object_id}]"
         end
 
         def socket_writable?

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

@@ -2,33 +2,45 @@ module Protobuf
   module Rpc
     class SocketRunner
 
+      private
+
+      attr_accessor :server
+
+      public
+
       def initialize(options)
-        @options = case
-                   when options.is_a?(OpenStruct) then
-                     options.marshal_dump
-                   when options.is_a?(Hash) then
-                     options
-                   when options.respond_to?(:to_hash) then
-                     options.to_hash
-                   else
-                     raise "Cannot parser Socket Server - server options"
-                   end
-
-        @server = ::Protobuf::Rpc::Socket::Server.new(@options)
+        options = case
+                  when options.is_a?(OpenStruct) then
+                    options.marshal_dump
+                  when options.respond_to?(:to_hash) then
+                    options.to_hash.symbolize_keys
+                  else
+                    fail "Cannot parser Socket Server - server options"
+                  end
+
+        self.server = ::Protobuf::Rpc::Socket::Server.new(options)
       end
 
       def run
         yield if block_given?
-        @server.run
+        server.run
       end
 
       def running?
-        @server.running?
+        server.running?
       end
 
       def stop
-        @server.stop
+        server.stop
       end
     end
   end
 end
+
+module Protobuf
+  module Rpc
+    module Servers # bad file namespacing
+      SocketRunner = ::Protobuf::Rpc::SocketRunner
+    end
+  end
+end

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

@@ -23,39 +23,69 @@ module Protobuf
 
         def run
           @idle_workers = []
+          @running = true
 
           loop do
-            unless local_queue.empty?
-              process_local_queue
-            end
-
-            rc = @poller.poll(500)
+            process_local_queue
+            rc = @poller.poll(broker_polling_milliseconds)
 
             # The server was shutdown and no requests are pending
-            break if rc == 0 && !running?
-
+            break if rc == 0 && !running? && @server.workers.empty?
             # Something went wrong
             break if rc == -1
 
-            @poller.readables.each do |readable|
-              case readable
-              when @frontend_socket
-                process_frontend
-              when @backend_socket
-                process_backend
-              end
-            end
+            check_and_process_backend
+            process_local_queue # Fair ordering so queued requests get in before new requests
+            check_and_process_frontend
           end
         ensure
           teardown
+          @running = false
         end
 
         def running?
-          @server.running? || @server.workers.any?
+          @running && @server.running?
         end
 
         private
 
+        def backend_poll_weight
+          @backend_poll_weight ||= [ENV["PB_ZMQ_SERVER_BACKEND_POLL_WEIGHT"].to_i, 1].max
+        end
+
+        def broker_polling_milliseconds
+          @broker_polling_milliseconds ||= [ENV["PB_ZMQ_BROKER_POLLING_MILLISECONDS"].to_i, 500].max
+        end
+
+        def check_and_process_backend
+          readables_include_backend = @poller.readables.include?(@backend_socket)
+          message_count_read_from_backend = 0
+
+          while readables_include_backend && message_count_read_from_backend < backend_poll_weight
+            message_count_read_from_backend += 1
+            process_backend
+            @poller.poll_nonblock
+            readables_include_backend = @poller.readables.include?(@backend_socket)
+          end
+        end
+
+        def check_and_process_frontend
+          readables_include_frontend = @poller.readables.include?(@frontend_socket)
+          message_count_read_from_frontend = 0
+
+          while readables_include_frontend && message_count_read_from_frontend < frontend_poll_weight
+            message_count_read_from_frontend += 1
+            process_frontend
+            break unless local_queue_available? # no need to read frontend just to throw away messages, will prioritize backend when full
+            @poller.poll_nonblock
+            readables_include_frontend = @poller.readables.include?(@frontend_socket)
+          end
+        end
+
+        def frontend_poll_weight
+          @frontend_poll_weight ||= [ENV["PB_ZMQ_SERVER_FRONTEND_POLL_WEIGHT"].to_i, 1].max
+        end
+
         def init_backend_socket
           @backend_socket = @zmq_context.socket(ZMQ::ROUTER)
           zmq_error_check(@backend_socket.bind(@server.backend_uri))
@@ -67,7 +97,7 @@ module Protobuf
         end
 
         def init_local_queue
-          @local_queue = ::Queue.new
+          @local_queue = []
         end
 
         def init_poller
@@ -77,19 +107,28 @@ module Protobuf
         end
 
         def init_zmq_context
-          if inproc?
-            @zmq_context = @server.zmq_context
-          else
-            @zmq_context = ZMQ::Context.new
-          end
+          @zmq_context =
+            if inproc?
+              @server.zmq_context
+            else
+              ZMQ::Context.new
+            end
         end
 
         def inproc?
           !!@server.try(:inproc?)
         end
 
+        def local_queue_available?
+          local_queue.size < local_queue_max_size && running?
+        end
+
+        def local_queue_max_size
+          @local_queue_max_size ||= [ENV["PB_ZMQ_SERVER_QUEUE_MAX_SIZE"].to_i, 5].max
+        end
+
         def process_backend
-          worker, ignore, *frames = read_from_backend
+          worker, _ignore, *frames = read_from_backend
 
           @idle_workers << worker
 
@@ -102,16 +141,16 @@ module Protobuf
           address, _, message, *frames = read_from_frontend
 
           if message == ::Protobuf::Rpc::Zmq::CHECK_AVAILABLE_MESSAGE
-            if @idle_workers.any? || local_queue.empty?
-              write_to_frontend([address, "", ::Protobuf::Rpc::Zmq::WORKERS_AVAILABLE])
+            if local_queue_available?
+              write_to_frontend([address, ::Protobuf::Rpc::Zmq::EMPTY_STRING, ::Protobuf::Rpc::Zmq::WORKERS_AVAILABLE])
             else
-              write_to_frontend([address, "", ::Protobuf::Rpc::Zmq::NO_WORKERS_AVAILABLE])
+              write_to_frontend([address, ::Protobuf::Rpc::Zmq::EMPTY_STRING, ::Protobuf::Rpc::Zmq::NO_WORKERS_AVAILABLE])
             end
           else
-            if @idle_workers.any?
-              write_to_backend([@idle_workers.shift, ""] + [address, "", message ] + frames)
+            if @idle_workers.empty? # rubocop:disable Style/IfInsideElse
+              local_queue << [address, ::Protobuf::Rpc::Zmq::EMPTY_STRING, message].concat(frames)
             else
-              local_queue.push([address, "", message ] + frames)
+              write_to_backend([@idle_workers.shift, ::Protobuf::Rpc::Zmq::EMPTY_STRING].concat([address, ::Protobuf::Rpc::Zmq::EMPTY_STRING, message]).concat(frames))
             end
           end
         end
@@ -120,7 +159,7 @@ module Protobuf
           return if local_queue.empty?
           return if @idle_workers.empty?
 
-          write_to_backend([@idle_workers.shift, ""] + local_queue.pop)
+          write_to_backend([@idle_workers.shift, ::Protobuf::Rpc::Zmq::EMPTY_STRING].concat(local_queue.shift))
           process_local_queue
         end
 
@@ -139,7 +178,7 @@ module Protobuf
         def teardown
           @frontend_socket.try(:close)
           @backend_socket.try(:close)
-          @zmq_context.try(:terminate)
+          @zmq_context.try(:terminate) unless inproc?
         end
 
         def write_to_backend(frames)