protobuf 2.7.12 → 2.8.0.beta1

data/README.md

@@ -303,8 +303,7 @@ any other filter calls which would run afterwards, as well as canceling
 invocation of the service method. Note: You must actually return false,
 not just a "falsey" value such as nil.
 
-__After Filters__ – There is no request shortcutting since the after
-filter runs after the request. Duh.
+__After Filters__ – No request shortcutting.
 
 #### Filter options
 
@@ -415,6 +414,44 @@ Many different options can be passed to the `.client` call above
 (such as `:timeout => 600`). See the `lib/protobuf/rpc/client.rb`
 and `lib/protobuf/rpc/service.rb` files for more documentation.
 
+### Dynamic Discovery (ZMQ Only)
+It is possible to setup the RPC server and client in a way that
+allows servers to be dynamically discovered by the client.
+
+#### In the client
+```ruby
+ServiceDirectory.start do |config|
+  config.port = 53000
+end
+
+# If your server also runs this code, it will default to the
+# given port when sending beacons and have its own service
+# directory. You can prevent this code from running on the
+# server if needed:
+unless defined? ::Protobuf::CLI
+  ServiceDirectory.start do |config|
+    config.port = 53000
+  end
+end
+```
+
+#### Starting the server
+```
+$ rpc_server --broadcast-beacons --beacon-port 53000 ...
+```
+
+The client will listen on the specified port for beacons broadcast
+by servers. Each beacon includes a list of services provided by the
+broadcasting server. The client randomly selects a server for the
+desired service each time a request is made.
+
+__CAUTION:__ When running multiple environments on a single network,
+e.g., qa and staging, be sure that each environment is setup with
+a unique beacon port; otherwise, clients in one environment _will_
+make requests to servers in the other environment.
+
+Check out {Protobuf::ServiceDirectory} for more details.
+
 ## 3. RPC Interop
 
 The main reason I wrote this gem was to provide a ruby implementation

data/lib/protobuf.rb

@@ -3,16 +3,7 @@ require 'socket'
 require 'pp'
 require 'stringio'
 require 'active_support/core_ext/object/blank'
-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/core_ext/object/try'
 require 'active_support/inflector'
 require 'active_support/json'
 
@@ -24,7 +15,7 @@ module Protobuf
   # Default is Socket as it has no external dependencies.
   DEFAULT_CONNECTOR = :socket
 
-	module_function
+  module_function
 
   # Client Host
   #
@@ -62,14 +53,14 @@ module Protobuf
   # the Garbage Collector when handling an rpc request.
   # Once the request is completed, the GC is enabled again.
   # This optomization provides a huge boost in speed to rpc requests.
-	def self.gc_pause_server_request?
-		return @_gc_pause_server_request unless @_gc_pause_server_request.nil?
-		gc_pause_server_request = false
-	end
+  def self.gc_pause_server_request?
+    return @_gc_pause_server_request unless @_gc_pause_server_request.nil?
+    gc_pause_server_request = false
+  end
 
-	def self.gc_pause_server_request=(value)
-		@_gc_pause_server_request = !!value
-	end
+  def self.gc_pause_server_request=(value)
+    @_gc_pause_server_request = !!value
+  end
 
   # Print Deprecation Warnings
   #
@@ -81,14 +72,14 @@ module Protobuf
   # ENV['PB_IGNORE_DEPRECATIONS'] to a non-empty value.
   #
   # The rpc_server option will override the ENV setting.
-	def self.print_deprecation_warnings?
-		return @_print_deprecation_warnings unless @_print_deprecation_warnings.nil?
-		print_deprecation_warnings = ENV.key?('PB_IGNORE_DEPRECATIONS') ? false : true
-	end
-
-	def self.print_deprecation_warnings=(value)
-		@_print_deprecation_warnings = !!value
-	end
+  def self.print_deprecation_warnings?
+    return @_print_deprecation_warnings unless @_print_deprecation_warnings.nil?
+    print_deprecation_warnings = ENV.key?('PB_IGNORE_DEPRECATIONS') ? false : true
+  end
+
+  def self.print_deprecation_warnings=(value)
+    @_print_deprecation_warnings = !!value
+  end
 
 end
 

data/lib/protobuf/cli.rb

@@ -9,7 +9,7 @@ module Protobuf
   class CLI < ::Thor
     include ::Thor::Actions
 
-    attr_accessor :runner, :mode, :start_aborted
+    attr_accessor :runner, :mode
 
     default_task :start
 
@@ -29,6 +29,10 @@ module Protobuf
     option :evented,                    :type => :boolean, :aliases => %w(-m), :desc => 'Evented Mode for server and client connections (uses EventMachine).'
     option :zmq,                        :type => :boolean, :aliases => %w(-z), :desc => 'ZeroMQ Socket Mode for server and client connections.'
 
+    option :beacon_address,             :type => :string,  :desc => 'Broadcast beacons to this address (defaul: value of ServiceDirectory.address)'
+    option :beacon_interval,            :type => :numeric, :desc => 'Broadcast beacons every N seconds. (default: 5)'
+    option :beacon_port,                :type => :numeric, :desc => 'Broadcast beacons to this port (default: value of ServiceDirectory.port)'
+    option :broadcast_beacons,          :type => :boolean, :desc => 'Broadcast beacons for dynamic discovery (Currently only available with ZeroMQ).'
     option :debug,                      :type => :boolean, :default => false, :aliases => %w(-d), :desc => 'Debug Mode. Override log level to DEBUG.'
     option :gc_pause_request,           :type => :boolean, :default => false, :desc => 'Enable/Disable GC pause during request.'
     option :print_deprecation_warnings, :type => :boolean, :default => nil, :desc => 'Cause use of deprecated fields to be printed or ignored.'
@@ -36,26 +40,25 @@ module Protobuf
     option :worker_port,                :type => :numeric, :default => nil, :desc => "Port for 'backend' where workers connect (defaults to port + 1)"
 
     def start(app_file)
-      debug_say 'Configuring the rpc_server process'
-      @start_aborted = false
+      debug_say('Configuring the rpc_server process')
 
       configure_logger
       configure_traps
-      configure_server_mode
-      require_protobuf!
+      configure_runner_mode
+      create_runner
+      configure_process_name(app_file)
       configure_gc
       configure_deprecation_warnings
 
-      run_if_no_abort { require_application!(app_file) }
-      run_if_no_abort { configure_process_name(app_file) }
-      run_if_no_abort { start_server! }
+      require_application(app_file) unless exit_requested?
+      start_server unless exit_requested?
     rescue => e
-      say_and_exit!('ERROR: RPC Server failed to start.', e)
+      say_and_exit('ERROR: RPC Server failed to start.', e)
     end
 
     desc 'version', 'Print ruby and protoc versions and exit.'
     def version
-      say "Ruby Protobuf v#{::Protobuf::VERSION}, protoc v#{::Protobuf::PROTOC_VERSION}"
+      say("Ruby Protobuf v#{::Protobuf::VERSION}, protoc v#{::Protobuf::PROTOC_VERSION}")
     end
 
     no_tasks do
@@ -71,7 +74,7 @@ module Protobuf
 
       # If we pause during request we don't need to pause in serialization
       def configure_gc
-        debug_say 'Configuring gc'
+        debug_say('Configuring gc')
 
         if defined?(JRUBY_VERSION)
           # GC.enable/disable are noop's on Jruby
@@ -83,7 +86,7 @@ module Protobuf
 
       # Setup the protobuf logger.
       def configure_logger
-        debug_say 'Configuring logger'
+        debug_say('Configuring logger')
         ::Protobuf::Logger.configure({ :file => options.log || STDOUT,
                                        :level => options.debug? ? ::Logger::DEBUG : options.level })
 
@@ -94,100 +97,110 @@ module Protobuf
 
       # Re-write the $0 var to have a nice process name in ps.
       def configure_process_name(app_file)
-        debug_say 'Configuring process name'
-        $0 = "rpc_server --#{@mode} #{options.host}:#{options.port} #{app_file}"
+        debug_say('Configuring process name')
+        $0 = "rpc_server --#{@runner_mode} #{options.host}:#{options.port} #{app_file}"
       end
 
       # Configure the mode of the server and the runner class.
-      def configure_server_mode
-        debug_say 'Configuring runner mode'
-        if options.zmq? && ! options.evented? && ! options.socket?
-          server_zmq!
-        elsif options.evented? && ! options.zmq? && ! options.socket?
-          server_evented!
-        elsif (env_server_type = ENV["PB_SERVER_TYPE"])
-          case
-          when env_server_type =~ /zmq/i then
-            server_zmq!
-          when env_server_type =~ /socket/i then
-            server_socket!
-          when env_server_type =~ /evented/i then
-            server_evented!
+      def configure_runner_mode
+        debug_say('Configuring runner mode')
+
+        if multi_mode?
+          say('WARNING: You have provided multiple mode options. Defaulting to socket mode.', :yellow)
+          @runner_mode = :socket
+        elsif options.zmq?
+          @runner_mode = :zmq
+        elsif options.evented?
+          @runner_mode = :evented
+        else
+          case server_type = ENV["PB_SERVER_TYPE"]
+          when nil, /socket/i
+            @runner_mode = :socket
+          when /zmq/i
+            @runner_mode = :zmq
+          when /evented/i
+            @runner_mode = :evented
           else
-            say "WARNING: You have provided incorrect option 'PB_SERVER_TYPE=#{env_server_type}'. Defaulting to socket mode.", :yellow
-            server_socket!
+            say "WARNING: You have provided incorrect option 'PB_SERVER_TYPE=#{server_type}'. Defaulting to socket mode.", :yellow
+            @runner_mode = :socket
           end
-        else
-          say 'WARNING: You have provided multiple mode options. Defaulting to socket mode.', :yellow if multi_mode?
-          server_socket!
         end
       end
 
       # Configure signal traps.
       # TODO add signal handling for hot-reloading the application.
       def configure_traps
-        debug_say 'Configuring traps'
-        [:INT, :QUIT, :TERM].each do |signal|
-          debug_say "Registering signal trap for #{signal}", :blue
+        debug_say('Configuring traps')
+
+        exit_signals = [:INT, :TERM]
+        exit_signals << :QUIT unless defined?(JRUBY_VERSION)
+
+        exit_signals.each do |signal|
+          debug_say("Registering trap for exit signal #{signal}", :blue)
+
           trap(signal) do
-            ::Protobuf::Logger.info { 'RPC Server shutting down...' }
-            @start_aborted = true
-            @runner.stop
-            ::Protobuf::Logger.info { 'Shutdown complete' }
+            @exit_requested = true
+            shutdown_server
           end
         end
       end
 
+      # Create the runner for the configured mode
+      def create_runner
+        debug_say("Creating #{@runner_mode} runner")
+        @runner = case @runner_mode
+                  when :evented
+                    create_evented_runner
+                  when :zmq
+                    create_zmq_runner
+                  when :socket
+                    create_socket_runner
+                  else
+                    say_and_exit("Unknown runner mode: #{@runner_mode}")
+                  end
+      end
+
       # Say something if we're in debug mode.
       def debug_say(message, color = :yellow)
         say(message, color) if options.debug?
       end
 
+      def exit_requested?
+        !!@exit_requested
+      end
+
       # Internal helper to determine if the modes are multi-set which is not valid.
       def multi_mode?
-        (options.zmq? && (options.evented? || options.socket?)) \
-          && (options.evented? && (options.evented? || options.socket?)) \
-          && (options.zmq? && (options.evented? || options.socket?)) \
+        [
+          options.zmq?,
+          options.evented?,
+          options.socket?,
+        ].count(true) > 1
       end
 
       # Require the application file given, exiting if the file doesn't exist.
-      def require_application!(app_file)
-        debug_say 'Requiring app file'
+      def require_application(app_file)
+        debug_say('Requiring app file')
         require app_file
       rescue LoadError => e
-        say_and_exit!("Failed to load application file #{app_file}", e)
+        say_and_exit("Failed to load application file #{app_file}", e)
       end
 
-      # Loads protobuf in the given mode, exiting if somehow the mode is wrong.
-      def require_protobuf!
-        require "protobuf/#{@mode}.rb"
-      rescue LoadError => e
-        puts e.message, *(e.backtrace)
-        say_and_exit!("Failed to load protobuf runner #{@mode}", e)
-      end
+      def runner_options
+        # Symbolize keys
+        opt = options.inject({}) { |h, (k, v)| h[k.to_sym] = v; h }
+
+        opt[:workers_only] = (!!ENV['PB_WORKERS_ONLY']) || options.workers_only
 
-      def run_if_no_abort
-        yield unless @start_aborted
+        opt
       end
 
-      def runner_options
-        { 
-          :host => options.host,
-          :port => options.port,
-          :backlog => options.backlog,
-          :threshold => options.threshold,
-          :threads => options.threads,
-          :worker_port => options.worker_port || (options.port + 1),
-          :workers_only => !!ENV['PB_WORKERS_ONLY'] || options.workers_only
-        }
-      end
-
-      def say_and_exit!(message, exception = nil)
+      def say_and_exit(message, exception = nil)
         message = set_color(message, :red) if ::Protobuf::Logger.file == STDOUT
 
         ::Protobuf::Logger.error { message }
         if exception
-          $stderr.puts "[#{exception.class.name}] #{exception.message}" 
+          $stderr.puts "[#{exception.class.name}] #{exception.message}"
           $stderr.puts exception.backtrace.join("\n")
 
           ::Protobuf::Logger.error { "[#{exception.class.name}] #{exception.message}" }
@@ -197,35 +210,42 @@ module Protobuf
         exit(1)
       end
 
-      def server_evented!
-        @mode = :evented
-        @runner = ::Protobuf::Rpc::EventedRunner
+      def create_evented_runner
+        require 'protobuf/evented'
+
+        @runner = ::Protobuf::Rpc::EventedRunner.new(runner_options)
+      end
+
+      def create_socket_runner
+        require 'protobuf/socket'
+
+        @runner = ::Protobuf::Rpc::SocketRunner.new(runner_options)
       end
 
-      def server_socket!
-        @mode = :socket
-        @runner = ::Protobuf::Rpc::SocketRunner
+      def create_zmq_runner
+        require 'protobuf/zmq'
+
+        @runner = ::Protobuf::Rpc::ZmqRunner.new(runner_options)
       end
 
-      def server_zmq!
-        @mode = :zmq
-        @runner = ::Protobuf::Rpc::ZmqRunner
+      def shutdown_server
+        ::Protobuf::Logger.info { 'RPC Server shutting down...' }
+        @runner.try(:stop)
+        ::Protobuf::Rpc::ServiceDirectory.instance.stop
+        ::Protobuf::Logger.info { 'Shutdown complete' }
       end
 
       # Start the runner and log the relevant options.
-      def start_server!
-        @runner.register_signals
+      def start_server
+        debug_say('Running server')
 
-        debug_say 'Invoking server start'
-        @runner.run(runner_options) do
-          ::Protobuf::Logger.info { 
-            "pid #{::Process.pid} -- #{@mode} RPC Server listening at #{options.host}:#{options.port}"
+        @runner.run do
+          ::Protobuf::Logger.info {
+            "pid #{::Process.pid} -- #{@runner_mode} RPC Server listening at #{options.host}:#{options.port}"
           }
         end
       end
-
     end
-
   end
 end
 

data/lib/protobuf/field/bytes_field.rb

@@ -18,9 +18,8 @@ module Protobuf
       end
 
       def decode(bytes)
-        bytes_to_decode = bytes.dup
-        bytes_to_decode.force_encoding(::Protobuf::Field::BytesField::BYTES_ENCODING)
-        bytes_to_decode
+        bytes.force_encoding(::Protobuf::Field::BytesField::BYTES_ENCODING)
+        bytes
       end
 
       def define_setter
@@ -47,12 +46,11 @@ module Protobuf
       end
 
       def encode(value)
-        value_to_encode = value.dup
-        value_to_encode = value.serialize_to_string if value.is_a?(::Protobuf::Message)
-        value_to_encode.force_encoding(::Protobuf::Field::BytesField::BYTES_ENCODING)
+        value = value.serialize_to_string if value.is_a?(::Protobuf::Message)
+        value.force_encoding(::Protobuf::Field::BytesField::BYTES_ENCODING)
 
-        string_size = ::Protobuf::Field::VarintField.encode(value_to_encode.size)
-        string_size << value_to_encode
+        string_size = ::Protobuf::Field::VarintField.encode(value.size)
+        string_size << value
       end
 
       def wire_type