prepor-protobuf 3.5.0

data/lib/protobuf/rpc/server.rb

@@ -0,0 +1,39 @@
+require 'protobuf'
+require 'protobuf/logging'
+require 'protobuf/rpc/rpc.pb'
+require 'protobuf/rpc/buffer'
+require 'protobuf/rpc/env'
+require 'protobuf/rpc/error'
+require 'protobuf/rpc/middleware'
+require 'protobuf/rpc/service_dispatcher'
+
+module Protobuf
+  module Rpc
+    module Server
+      def gc_pause
+        ::GC.disable if ::Protobuf.gc_pause_server_request?
+
+        yield
+
+        ::GC.enable if ::Protobuf.gc_pause_server_request?
+      end
+
+      # Invoke the service method dictated by the proto wrapper request object
+      #
+      def handle_request(request_data)
+        # Create an env object that holds different parts of the environment and
+        # is available to all of the middlewares
+        env = Env.new('encoded_request' => request_data, 'log_signature' => log_signature)
+
+        # Invoke the middleware stack, the last of which is the service dispatcher
+        env = Rpc.middleware.call(env)
+
+        env.encoded_response
+      end
+
+      def log_signature
+        @_log_signature ||= "[server-#{self.class.name}]"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,123 @@
+require 'set'
+
+require 'protobuf/rpc/servers/socket/worker'
+
+module Protobuf
+  module Rpc
+    module Socket
+      class Server
+        include ::Protobuf::Logging
+
+        AUTO_COLLECT_TIMEOUT = 5 # seconds
+
+        private
+
+        attr_accessor :threshold, :host, :port, :backlog
+        attr_writer :running
+
+        public
+
+        attr_reader :running
+        alias_method :running?, :running
+
+        def initialize(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 `threshold` connections run a cleanup routine after closing the response
+          threads.size > 0 && threads.size % threshold == 0
+        end
+
+        def cleanup_threads
+          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
+
+          logger.debug { sign_message("Thread cleanup - #{threads.size} - complete") }
+        end
+
+        def log_signature
+          @_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
+          end
+        end
+
+        def run
+          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
+              else
+                # Run a cleanup if select times out while waiting
+                cleanup_threads if threads.size > 1
+              end
+            end
+          ensure
+            server.close
+          end
+        end
+
+        def stop
+          self.running = false
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+require 'protobuf/rpc/server'
+require 'protobuf/logging'
+
+module Protobuf
+  module Rpc
+    module Socket
+      class Worker
+        include ::Protobuf::Rpc::Server
+        include ::Protobuf::Logging
+
+        def initialize(sock, &complete_cb)
+          @socket = sock
+          @complete_cb = complete_cb
+
+          data = read_data
+          return unless data
+
+          gc_pause do
+            encoded_response = handle_request(data)
+            send_data(encoded_response)
+          end
+        end
+
+        def read_data
+          size_io = StringIO.new
+
+          until (size_reader = @socket.getc) == "-"
+            size_io << size_reader
+          end
+          str_size_io = size_io.string
+
+          @socket.read(str_size_io.to_i)
+        end
+
+        def send_data(data)
+          fail 'Socket closed unexpectedly' unless socket_writable?
+          response_buffer = Protobuf::Rpc::Buffer.new(:write)
+          response_buffer.set_data(data)
+
+          @socket.write(response_buffer.write)
+          @socket.flush
+
+          @complete_cb.call(@socket)
+        end
+
+        def log_signature
+          @_log_signature ||= "[server-#{self.class}-#{object_id}]"
+        end
+
+        def socket_writable?
+          ! @socket.nil? && ! @socket.closed?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+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
+                     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
+      end
+
+      def running?
+        server.running?
+      end
+
+      def stop
+        server.stop
+      end
+    end
+  end
+end

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

@@ -0,0 +1,193 @@
+require 'thread'
+
+module Protobuf
+  module Rpc
+    module Zmq
+      class Broker
+        include ::Protobuf::Rpc::Zmq::Util
+
+        attr_reader :local_queue
+
+        def initialize(server)
+          @server = server
+
+          init_zmq_context
+          init_local_queue
+          init_backend_socket
+          init_frontend_socket
+          init_poller
+        rescue
+          teardown
+          raise
+        end
+
+        def run
+          @idle_workers = []
+          @running = true
+
+          loop do
+            process_local_queue
+            rc = @poller.poll(broker_polling_milliseconds)
+
+            # The server was shutdown and no requests are pending
+            break if rc == 0 && !running? && @server.workers.empty?
+            # Something went wrong
+            break if rc == -1
+
+            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?
+          @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))
+        end
+
+        def init_frontend_socket
+          @frontend_socket = @zmq_context.socket(ZMQ::ROUTER)
+          zmq_error_check(@frontend_socket.bind(@server.frontend_uri))
+        end
+
+        def init_local_queue
+          @local_queue = []
+        end
+
+        def init_poller
+          @poller = ZMQ::Poller.new
+          @poller.register_readable(@frontend_socket)
+          @poller.register_readable(@backend_socket)
+        end
+
+        def init_zmq_context
+          if inproc?
+            @zmq_context = @server.zmq_context
+          else
+            @zmq_context = 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
+
+          @idle_workers << worker
+
+          unless frames == [::Protobuf::Rpc::Zmq::WORKER_READY_MESSAGE]
+            write_to_frontend(frames)
+          end
+        end
+
+        def process_frontend
+          address, _, message, *frames = read_from_frontend
+
+          if message == ::Protobuf::Rpc::Zmq::CHECK_AVAILABLE_MESSAGE
+            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::EMPTY_STRING, ::Protobuf::Rpc::Zmq::NO_WORKERS_AVAILABLE])
+            end
+          else
+            if @idle_workers.empty?
+              local_queue << [address, ::Protobuf::Rpc::Zmq::EMPTY_STRING, message].concat(frames)
+            else
+              write_to_backend([@idle_workers.shift, ::Protobuf::Rpc::Zmq::EMPTY_STRING].concat([address, ::Protobuf::Rpc::Zmq::EMPTY_STRING, message]).concat(frames))
+            end
+          end
+        end
+
+        def process_local_queue
+          return if local_queue.empty?
+          return if @idle_workers.empty?
+
+          write_to_backend([@idle_workers.shift, ::Protobuf::Rpc::Zmq::EMPTY_STRING].concat(local_queue.shift))
+          process_local_queue
+        end
+
+        def read_from_backend
+          frames = []
+          zmq_error_check(@backend_socket.recv_strings(frames))
+          frames
+        end
+
+        def read_from_frontend
+          frames = []
+          zmq_error_check(@frontend_socket.recv_strings(frames))
+          frames
+        end
+
+        def teardown
+          @frontend_socket.try(:close)
+          @backend_socket.try(:close)
+          @zmq_context.try(:terminate) unless inproc?
+        end
+
+        def write_to_backend(frames)
+          zmq_error_check(@backend_socket.send_strings(frames))
+        end
+
+        def write_to_frontend(frames)
+          zmq_error_check(@frontend_socket.send_strings(frames))
+        end
+      end
+    end
+  end
+end