protobuffy 3.6.0 → 4.0.0

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

@@ -16,7 +16,7 @@ module Protobuf
           :broadcast_beacons => false,
           :broadcast_busy => false,
           :zmq_inproc => true,
-        }
+        }.freeze
 
         attr_accessor :options, :workers
         attr_reader :zmq_context
@@ -62,15 +62,10 @@ module Protobuf
         end
 
         def beacon_port
-          unless @beacon_port
-            unless port = options[:beacon_port]
-              port = ::Protobuf::Rpc::ServiceDirectory.port
-            end
-
-            @beacon_port = port.to_i
-          end
-
-          @beacon_port
+          @beacon_port ||= options.fetch(
+            :beacon_port,
+            ::Protobuf::Rpc::ServiceDirectory.port
+          ).to_i
         end
 
         def beacon_uri
@@ -81,10 +76,14 @@ module Protobuf
           !brokerless? && options[:broadcast_beacons]
         end
 
+        def broadcast_busy?
+          broadcast_beacons? && options[:broadcast_busy]
+        end
+
         def broadcast_flatline
           flatline = ::Protobuf::Rpc::DynamicDiscovery::Beacon.new(
             :beacon_type => ::Protobuf::Rpc::DynamicDiscovery::BeaconType::FLATLINE,
-            :server => self.to_proto
+            :server => to_proto
           )
 
           @beacon_socket.send(flatline.encode, 0)
@@ -95,12 +94,12 @@ module Protobuf
 
           heartbeat = ::Protobuf::Rpc::DynamicDiscovery::Beacon.new(
             :beacon_type => ::Protobuf::Rpc::DynamicDiscovery::BeaconType::HEARTBEAT,
-            :server => self.to_proto
+            :server => to_proto
           )
 
           @beacon_socket.send(heartbeat.encode, 0)
 
-          log_debug { sign_message("sent heartbeat to #{beacon_uri}") }
+          logger.debug { sign_message("sent heartbeat to #{beacon_uri}") }
         end
 
         def broadcast_heartbeat?
@@ -118,7 +117,7 @@ module Protobuf
         def frontend_ip
           @frontend_ip ||= resolve_ip(options[:host])
         end
-        alias_method :backend_ip, :frontend_ip
+        alias :backend_ip frontend_ip
 
         def frontend_port
           options[:port]
@@ -129,7 +128,7 @@ module Protobuf
         end
 
         def inproc?
-          !!self.options[:zmq_inproc]
+          !!options[:zmq_inproc]
         end
 
         def maintenance_timeout
@@ -167,7 +166,7 @@ module Protobuf
           @last_reaping = Time.now.to_i
 
           @workers.keep_if do |worker|
-            worker.alive? or worker.join && false
+            worker.alive? || worker.join && false
           end
         end
 
@@ -181,15 +180,11 @@ module Protobuf
 
         def run
           @running = true
-
-          start_broker unless brokerless?
-          start_missing_workers
-
           yield if block_given? # runs on startup
           wait_for_shutdown_signal
           broadcast_flatline if broadcast_beacons?
           Thread.pass until reap_dead_workers.empty?
-          @broker.join unless brokerless?
+          @broker_thread.join unless brokerless?
         ensure
           @running = false
           teardown
@@ -204,7 +199,7 @@ module Protobuf
 
           if missing_workers > 0
             missing_workers.times { start_worker }
-            log_debug { sign_message("#{total_workers} workers started") }
+            logger.debug { sign_message("#{total_workers} workers started") }
           end
         end
 
@@ -221,16 +216,17 @@ module Protobuf
           @last_reaping = @last_beacon = @timeout = nil
         end
 
-        def total_workers
-          @total_workers ||= [@options[:threads].to_i, 1].max
+        def timeout
+          @timeout =
+            if @timeout.nil?
+              0
+            else
+              [minimum_timeout, maintenance_timeout].max
+            end
         end
 
-        def timeout
-          if @timeout.nil?
-            @timeout = 0
-          else
-            @timeout = [minimum_timeout, maintenance_timeout].max
-          end
+        def total_workers
+          @total_workers ||= [@options[:threads].to_i, 1].max
         end
 
         def to_proto
@@ -251,19 +247,17 @@ module Protobuf
           loop do
             break if IO.select([@shutdown_r], nil, nil, timeout)
 
-            if reap_dead_workers?
-              reap_dead_workers
-              start_missing_workers
-            end
+            start_broker unless brokerless?
+            reap_dead_workers if reap_dead_workers?
+            start_missing_workers
 
-            if broadcast_heartbeat?
-              if all_workers_busy? && options[:broadcast_busy]
-                broadcast_flatline
-              else
-                broadcast_heartbeat
-              end
-            end
+            next unless broadcast_heartbeat?
 
+            if broadcast_busy? && all_workers_busy?
+              broadcast_flatline
+            else
+              broadcast_heartbeat
+            end
           end
         end
 
@@ -291,19 +285,33 @@ module Protobuf
         end
 
         def start_broker
-          @broker = Thread.new(self) do |server|
-            ::Protobuf::Rpc::Zmq::Broker.new(server).run
+          return if @broker && @broker.running? && @broker_thread.alive?
+          if @broker && !@broker.running?
+            broadcast_flatline if broadcast_busy?
+            @broker_thread.join if @broker_thread
+            init_zmq_context # need a new context to restart the broker
+          end
+
+          @broker = ::Protobuf::Rpc::Zmq::Broker.new(self)
+          @broker_thread = Thread.new(@broker) do |broker|
+            begin
+              broker.run
+            rescue => e
+              message = "Broker failed: #{e.inspect}\n #{e.backtrace.join($INPUT_RECORD_SEPARATOR)}"
+              $stderr.puts(message)
+              logger.error { message }
+            end
           end
         end
 
         def start_worker
-          @workers << Thread.new(self) do |server|
+          @workers << Thread.new(self, @broker) do |server, broker|
             begin
-              ::Protobuf::Rpc::Zmq::Worker.new(server).run
+              ::Protobuf::Rpc::Zmq::Worker.new(server, broker).run
             rescue => e
-              message = "Worker failed: #{e.inspect}\n #{e.backtrace.join($/)}"
+              message = "Worker failed: #{e.inspect}\n #{e.backtrace.join($INPUT_RECORD_SEPARATOR)}"
               $stderr.puts(message)
-              log_error { message }
+              logger.error { message }
             end
           end
         end

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

@@ -4,27 +4,28 @@ module Protobuf
   module Rpc
     module Zmq
 
-      ADDRESS_MATCH = /\A\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\z/.freeze
-      WORKER_READY_MESSAGE = "\1"
-      CHECK_AVAILABLE_MESSAGE = "\3"
-      NO_WORKERS_AVAILABLE = "\4"
-      WORKERS_AVAILABLE = "\5"
+      ADDRESS_MATCH = /\A\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\z/
+      WORKER_READY_MESSAGE = "\1".freeze
+      CHECK_AVAILABLE_MESSAGE = "\3".freeze
+      NO_WORKERS_AVAILABLE = "\4".freeze
+      WORKERS_AVAILABLE = "\5".freeze
+      EMPTY_STRING = "".freeze
 
       module Util
-        include ::Protobuf::Logger::LogMethods
+        include ::Protobuf::Logging
 
         def self.included(base)
           base.extend(::Protobuf::Rpc::Zmq::Util)
         end
 
         def zmq_error_check(return_code, source = nil)
-          unless ::ZMQ::Util.resultcode_ok?(return_code)
-            raise <<-ERROR
-            Last ZMQ API call #{source ? "to #{source}" : ""} failed with "#{::ZMQ::Util.error_string}".
+          return if ::ZMQ::Util.resultcode_ok?(return_code)
 
-            #{caller(1).join($/)}
-            ERROR
-          end
+          fail <<-ERROR
+          Last ZMQ API call #{source ? "to #{source}" : ''} failed with "#{::ZMQ::Util.error_string}".
+
+          #{caller(1).join($INPUT_RECORD_SEPARATOR)}
+          ERROR
         end
 
         def log_signature
@@ -37,7 +38,7 @@ module Protobuf
         end
 
         def resolve_ip(hostname)
-          ::Resolv.getaddresses(hostname).detect do |address|
+          ::Resolv.getaddresses(hostname).find do |address|
             address =~ ADDRESS_MATCH
           end
         end

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

@@ -12,8 +12,9 @@ module Protobuf
         ##
         # Constructor
         #
-        def initialize(server)
+        def initialize(server, broker)
           @server = server
+          @broker = broker
 
           init_zmq_context
           init_backend_socket
@@ -31,7 +32,7 @@ module Protobuf
 
           gc_pause do
             encoded_response = handle_request(data)
-            write_to_backend([client_address, "", encoded_response])
+            write_to_backend([client_address, ::Protobuf::Rpc::Zmq::EMPTY_STRING, encoded_response])
           end
         end
 
@@ -46,13 +47,11 @@ module Protobuf
           loop do
             rc = poller.poll(500)
 
-            # The server was shutdown and no requests are pending
-            break if rc == 0 && !running?
-
-            # Something went wrong
-            break if rc == -1
-
-            if rc > 0
+            if rc == 0 && !running? # rubocop:disable Style/GuardClause
+              break # The server was shutdown and no requests are pending
+            elsif rc == -1
+              break # Something went wrong
+            elsif rc > 0
               ::Thread.current[:busy] = true
               process_request
               ::Thread.current[:busy] = false
@@ -63,17 +62,18 @@ module Protobuf
         end
 
         def running?
-          @server.running?
+          @broker.running? && @server.running?
         end
 
         private
 
         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 init_backend_socket
@@ -93,7 +93,7 @@ module Protobuf
 
         def teardown
           @backend_socket.try(:close)
-          @zmq_context.try(:terminate)
+          @zmq_context.try(:terminate) unless inproc?
         end
 
         def write_to_backend(frames)

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

@@ -1,20 +1,20 @@
 require 'ostruct'
+require 'thread'
 
 module Protobuf
   module Rpc
     class ZmqRunner
-      include ::Protobuf::Logger::LogMethods
+      include ::Protobuf::Logging
 
       def initialize(options)
         @options = case
                    when options.is_a?(OpenStruct) then
                      options.marshal_dump
                    when options.respond_to?(:to_hash) then
-                     options.to_hash
+                     options.to_hash.symbolize_keys
                    else
-                     raise "Cannot parser Zmq Server - server options"
+                     fail "Cannot parser Zmq Server - server options"
                    end
-
       end
 
       def run
@@ -36,16 +36,35 @@ module Protobuf
       private
 
       def register_signals
+        trap(:TRAP) do
+          ::Thread.list.each do |thread|
+            logger.info do
+              <<-THREAD_TRACE
+                #{thread.inspect}:
+                  #{thread.backtrace.try(:join, $INPUT_RECORD_SEPARATOR)}"
+              THREAD_TRACE
+            end
+          end
+        end
+
         trap(:TTIN) do
           @server.add_worker
-          log_info { "Increased worker size to: #{@server.total_workers}" }
+          logger.info { "Increased worker size to: #{@server.total_workers}" }
         end
 
         trap(:TTOU) do
-          log_info { "Current worker size: #{@server.workers.size}" }
-          log_info { "Current worker size: #{@server.busy_worker_count}" }
+          logger.info { "Current worker size: #{@server.workers.size}" }
+          logger.info { "Current busy worker size: #{@server.busy_worker_count}" }
         end
       end
     end
   end
 end
+
+module Protobuf
+  module Rpc
+    module Servers # bad file namespacing
+      ZmqRunner = ::Protobuf::Rpc::ZmqRunner
+    end
+  end
+end

data/lib/protobuf/rpc/service.rb

@@ -1,4 +1,5 @@
-require 'protobuf/logger'
+require 'protobuf/logging'
+require 'protobuf/message'
 require 'protobuf/rpc/client'
 require 'protobuf/rpc/error'
 require 'protobuf/rpc/service_filters'
@@ -10,8 +11,9 @@ module Protobuf
     RpcMethod = Struct.new("RpcMethod", :method, :request_type, :response_type)
 
     class Service
-      include ::Protobuf::Logger::LogMethods
+      include ::Protobuf::Logging
       include ::Protobuf::Rpc::ServiceFilters
+      ::Protobuf::Optionable.inject(self) { ::Google::Protobuf::ServiceOptions }
 
       DEFAULT_HOST = '127.0.0.1'.freeze
       DEFAULT_PORT = 9399
@@ -54,19 +56,19 @@ module Protobuf
       # The host location of the service.
       #
       def self.host
-        @_host ||= DEFAULT_HOST
+        @host ||= DEFAULT_HOST
       end
 
       # The host location setter.
       #
-      def self.host=(new_host)
-        @_host = new_host
+      class << self
+        attr_writer :host
       end
 
       # An array of defined service classes that contain implementation
       # code
       def self.implemented_services
-        classes = (self.subclasses || []).select do |subclass|
+        classes = (subclasses || []).select do |subclass|
           subclass.rpcs.any? do |(name, _)|
             subclass.method_defined? name
           end
@@ -88,13 +90,13 @@ module Protobuf
       # The port of the service on the destination server.
       #
       def self.port
-        @_port ||= DEFAULT_PORT
+        @port ||= DEFAULT_PORT
       end
 
       # The port location setter.
       #
-      def self.port=(new_port)
-        @_port = new_port
+      class << self
+        attr_writer :port
       end
 
       # Define an rpc method with the given request and response types.
@@ -108,7 +110,7 @@ module Protobuf
       # Hash containing the set of methods defined via `rpc`.
       #
       def self.rpcs
-        @_rpcs ||= {}
+        @rpcs ||= {}
       end
 
       # Check if the given method name is a known rpc endpoint.
@@ -117,22 +119,14 @@ module Protobuf
         rpcs.key?(name)
       end
 
-      ##
-      # Instance Methods
-      #
-      # Get a callable object that will be used by the dispatcher
-      # to invoke the specified rpc method. Facilitates callback dispatch.
-      # The returned lambda is expected to be called at a later time (which
-      # is why we wrap the method call).
-      #
-      def callable_rpc_method(method_name)
-        lambda { run_filters(method_name) }
+      def call(method_name)
+        run_filters(method_name)
       end
 
       # Response object for this rpc cycle. Not assignable.
       #
       def response
-        @_response ||= response_type.new
+        @response ||= response_type.new
       end
 
       # Convenience method to get back to class method.
@@ -147,10 +141,10 @@ module Protobuf
         self.class.rpcs
       end
 
-    private
+      private
 
       def request_type
-        @_request_type ||= env.request_type
+        @request_type ||= env.request_type
       end
 
       # Sugar to make an rpc method feel like a controller method.
@@ -158,19 +152,19 @@ module Protobuf
       # object returned by the response reader.
       #
       def respond_with(candidate)
-        @_response = candidate
+        @response = candidate
       end
-      alias_method :return_from_whence_you_came, :respond_with
+      alias :return_from_whence_you_came respond_with
 
       def response_type
-        @_response_type ||= env.response_type
+        @response_type ||= env.response_type
       end
 
       # Automatically fail a service method.
       #
       def rpc_failed(message)
         message = message.message if message.respond_to?(:message)
-        raise RpcFailed.new(message)
+        fail RpcFailed, message
       end
     end