protobuffy 3.6.0 → 4.0.0

data/bin/protoc-gen-ruby

@@ -10,8 +10,13 @@ require 'protobuf'
 require 'protobuf/descriptors'
 require 'protobuf/code_generator'
 
+# Ensure that no encoding conversions are done on STDIN and STDOUT since
+# we are passing binary data back and forth. Otherwise these streams
+# will be mangled on Windows.
+STDIN.binmode
+STDOUT.binmode
+
 request_bytes = STDIN.read
 code_generator = ::Protobuf::CodeGenerator.new(request_bytes)
-response_bytes = code_generator.response_bytes
-STDOUT.print(response_bytes)
-
+code_generator.eval_unknown_extensions!
+STDOUT.print(code_generator.response_bytes)

data/bin/rpc_server

@@ -2,3 +2,4 @@
 
 require 'protobuf/cli'
 ::Protobuf::CLI.start(ARGV)
+exit

data/examples/lib/example/reverse-client.rb

@@ -6,11 +6,11 @@ require_relative "reverse.pb.rb"
 
 configuration = {
   :host => "localhost",
-  :port => 9399
+  :port => 9399,
 }
 
 request = {
-  :input => (ARGV[0] or 'hello world')
+  :input => (ARGV[0] || 'hello world'),
 }
 
 Example::ReverseService.client(configuration).reverse(Example::ReverseRequest.new(request)) do |client|

data/install-protobuf.sh

@@ -0,0 +1,28 @@
+#!/usr/bin/env sh
+
+set -ex
+
+gdie() {
+    echo "$@" >&2
+    exit 1
+}
+
+test -n "$PROTOBUF_VERSION" || die "PROTOBUF_VERSION env var is undefined"
+
+case "$PROTOBUF_VERSION" in
+2*)
+    basename=protobuf-$PROTOBUF_VERSION
+    ;;
+3*)
+    basename=protobuf-cpp-$PROTOBUF_VERSION
+    ;;
+*)
+    die "unknown protobuf version: $PROTOBUF_VERSION"
+    ;;
+esac
+
+curl -sL https://github.com/google/protobuf/releases/download/v$PROTOBUF_VERSION/$basename.tar.gz | tar zx
+
+cd protobuf-$PROTOBUF_VERSION
+
+./configure --prefix=/usr && make -j2 && make install

data/lib/protobuf.rb

@@ -5,46 +5,50 @@ require 'stringio'
 
 require 'active_support/core_ext/object/blank'
 require 'active_support/core_ext/object/try'
-require 'active_support/notifications'
 require 'active_support/inflector'
 require 'active_support/json'
+require 'active_support/notifications'
 
-module Protobuf
+# All top-level run time code requires, ordered by necessity
+require 'protobuf/wire_type'
 
-  # See Protobuf#connector_type documentation.
-  CONNECTORS = [ :socket, :zmq, :http ].freeze
+require 'protobuf/varint_pure'
+require 'protobuf/varint'
 
-  # Default is Socket as it has no external dependencies.
-  DEFAULT_CONNECTOR = :socket
+require 'protobuf/exceptions'
+require 'protobuf/deprecation'
+require 'protobuf/logging'
 
-  module_function
+require 'protobuf/encoder'
+require 'protobuf/decoder'
 
-  # Client Host
-  #
-  # Default: `hostname` of the system
-  #
-  # The name or address of the host to use during client RPC calls.
-  def self.client_host
-    @_client_host ||= `hostname`.chomp
+require 'protobuf/optionable'
+require 'protobuf/field'
+require 'protobuf/enum'
+require 'protobuf/message'
+require 'protobuf/descriptors'
+
+module Protobuf
+
+  class << self
+    # Client Host
+    #
+    # Default: `hostname` of the system
+    #
+    # The name or address of the host to use during client RPC calls.
+    attr_writer :client_host
   end
 
-  def self.client_host=(host)
-    @_client_host = host
+  def self.client_host
+    @client_host ||= Socket.gethostname
   end
 
-  # Connector Type
-  #
-  # Default: socket
-  #
-  # Symbol value which denotes the type of connector to use
-  # during client requests to an RPC server.
-  def self.connector_type
-    @_connector_type ||= DEFAULT_CONNECTOR
+  def self.connector_type_class
+    @connector_type_class ||= ::Protobuf::Rpc::Connectors::Socket
   end
 
-  def self.connector_type=(type)
-    raise ArgumentError, 'Invalid connector type given' unless CONNECTORS.include?(type)
-    @_connector_type = type
+  def self.connector_type_class=(type_class)
+    @connector_type_class = type_class
   end
 
   # GC Pause during server requests
@@ -56,51 +60,51 @@ module Protobuf
   # 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?
+    return @gc_pause_server_request unless @gc_pause_server_request.nil?
     self.gc_pause_server_request = false
   end
 
   def self.gc_pause_server_request=(value)
-    @_gc_pause_server_request = !!value
+    @gc_pause_server_request = !!value
   end
 
-  # Print Deprecation Warnings
+  # Permit unknown field on Message initialization
   #
   # Default: true
   #
-  # Simple boolean to define whether we want field deprecation warnings to
-  # be printed to stderr or not. The rpc_server has an option to set this value
-  # explicitly, or you can turn this option off by setting
-  # 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?
-    self.print_deprecation_warnings = ENV.key?('PB_IGNORE_DEPRECATIONS') ? false : true
+  # Simple boolean to define whether we want to permit unknown fields
+  # on Message intialization; otherwise a ::Protobuf::FieldNotDefinedError is thrown.
+  def self.ignore_unknown_fields?
+    !defined?(@ignore_unknown_fields) || @ignore_unknown_fields
   end
 
-  def self.print_deprecation_warnings=(value)
-    @_print_deprecation_warnings = !!value
+  def self.ignore_unknown_fields=(value)
+    @ignore_unknown_fields = !!value
   end
-
 end
 
 unless ENV.key?('PB_NO_NETWORKING')
   require 'protobuf/rpc/client'
   require 'protobuf/rpc/service'
 
-  env_connector_type = ENV.fetch('PB_CLIENT_TYPE') {
-    ::Protobuf::DEFAULT_CONNECTOR
-  }.to_s.downcase.strip.to_sym
+  env_connector_type = ENV.fetch('PB_CLIENT_TYPE') do
+    :socket
+  end
 
-  if ::Protobuf::CONNECTORS.include?(env_connector_type)
-    require "protobuf/#{env_connector_type}"
+  symbolized_connector_type = env_connector_type.to_s.downcase.strip.to_sym
+  if [:zmq, :socket].include?(symbolized_connector_type)
+    require "protobuf/#{symbolized_connector_type}"
+
+    ::Protobuf.connector_type_class =
+      case symbolized_connector_type
+      when :zmq
+        ::Protobuf::Rpc::Connectors::Zmq
+      else
+        ::Protobuf::Rpc::Connectors::Socket
+      end
   else
-    $stderr.puts <<-WARN
-    [WARNING] Require attempted on an invalid connector type '#{env_connector_type}'.
-              Falling back to default '#{::Protobuf::DEFAULT_CONNECTOR}' connector.
-    WARN
-
-    require "protobuf/#{::Protobuf::DEFAULT_CONNECTOR}"
+    require "#{env_connector_type}" # rubocop:disable Style/UnneededInterpolation
+    classified = env_connector_type.classify
+    ::Protobuf.connector_type_class = classified.constantize
   end
 end

data/lib/protobuf/cli.rb

@@ -1,6 +1,9 @@
+require 'active_support/core_ext/hash/keys'
+require 'active_support/inflector'
+
 require 'thor'
 require 'protobuf/version'
-require 'protobuf/logger'
+require 'protobuf/logging'
 require 'protobuf/rpc/servers/socket_runner'
 require 'protobuf/rpc/servers/zmq_runner'
 require 'protobuf/rpc/servers/http_runner'
@@ -8,8 +11,13 @@ require 'protobuf/rpc/servers/http_runner'
 module Protobuf
   class CLI < ::Thor
     include ::Thor::Actions
+    include ::Protobuf::Logging
+
+    attr_accessor :runner, :mode, :exit_requested
 
-    attr_accessor :runner, :mode
+    no_commands do
+      alias_method :exit_requested?, :exit_requested
+    end
 
     default_task :start
 
@@ -22,7 +30,7 @@ module Protobuf
     option :threshold,                  :type => :numeric, :default => 100, :aliases => %w(-t), :desc => 'Multi-threaded Socket Server cleanup threshold.'
     option :threads,                    :type => :numeric, :default => 5, :aliases => %w(-r), :desc => 'Number of worker threads to run. Only applicable in --zmq mode.'
 
-    option :log,                        :type => :string, :aliases => %w(-l), :desc => 'Log file or device. Default is STDOUT.'
+    option :log,                        :type => :string, :default => STDOUT, :aliases => %w(-l), :desc => 'Log file or device. Default is STDOUT.'
     option :level,                      :type => :numeric, :default => ::Logger::INFO, :aliases => %w(-v), :desc => 'Log level to use, 0-5 (see http://www.ruby-doc.org/stdlib/libdoc/logger/rdoc/)'
 
     option :socket,                     :type => :boolean, :aliases => %w(-s), :desc => 'Socket Mode for server and client connections.'
@@ -34,7 +42,7 @@ module Protobuf
     option :broadcast_beacons,          :type => :boolean, :desc => 'Broadcast beacons for dynamic discovery (Currently only available with ZeroMQ).'
     option :broadcast_busy,             :type => :boolean, :default => false, :desc => 'Remove busy nodes from cluster when all workers are busy (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 :gc_pause_request,           :type => :boolean, :default => false, :desc => 'DEPRECATED: 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.'
     option :workers_only,               :type => :boolean, :default => false, :desc => "Starts process with only workers (no broker/frontend is started) only relevant for Zmq Server"
     option :worker_port,                :type => :numeric, :default => nil, :desc => "Port for 'backend' where workers connect (defaults to port + 1)"
@@ -66,70 +74,77 @@ module Protobuf
 
       # Tell protobuf how to handle the printing of deprecated field usage.
       def configure_deprecation_warnings
-        if options.print_deprecation_warnings.nil?
-          ::Protobuf.print_deprecation_warnings = !ENV.key?("PB_IGNORE_DEPRECATIONS")
-        else
-          ::Protobuf.print_deprecation_warnings = options.print_deprecation_warnings?
-        end
+        ::Protobuf.print_deprecation_warnings =
+          if options.print_deprecation_warnings.nil?
+            !ENV.key?("PB_IGNORE_DEPRECATIONS")
+          else
+            options.print_deprecation_warnings?
+          end
       end
 
       # If we pause during request we don't need to pause in serialization
       def configure_gc
+        say "DEPRECATED: The gc_pause_request option is deprecated and will be removed in 4.0." if options.gc_pause_request?
+
         debug_say('Configuring gc')
 
-        if defined?(JRUBY_VERSION)
-          # GC.enable/disable are noop's on Jruby
-          ::Protobuf.gc_pause_server_request = false
-        else
-          ::Protobuf.gc_pause_server_request = options.gc_pause_request?
-        end
+        ::Protobuf.gc_pause_server_request =
+          if defined?(JRUBY_VERSION)
+            # GC.enable/disable are noop's on Jruby
+            false
+          else
+            options.gc_pause_request?
+          end
       end
 
       # Setup the protobuf logger.
       def configure_logger
         debug_say('Configuring logger')
-        ::Protobuf::Logger.configure({ :file => options.log || STDOUT,
-                                     :level => options.debug? ? ::Logger::DEBUG : options.level })
+
+        log_level = options.debug? ? ::Logger::DEBUG : options.level
+
+        ::Protobuf::Logging.initialize_logger(options.log, log_level)
 
         # Debug output the server options to the log file.
-        ::Protobuf::Logger.debug { 'Debugging options:' }
-        ::Protobuf::Logger.debug { options.inspect }
+        logger.debug { 'Debugging options:' }
+        logger.debug { options.inspect }
       end
 
       # 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 --#{@runner_mode} #{options.host}:#{options.port} #{app_file}"
+        $0 = "rpc_server --#{mode} #{options.host}:#{options.port} #{app_file}"
       end
 
       # Configure the mode of the server and the runner class.
       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.http?
-          @runner_mode = :http
-        else
-          case server_type = ENV["PB_SERVER_TYPE"]
-          when nil, /socket/i
-            @runner_mode = :socket
-          when /zmq/i
-            @runner_mode = :zmq
-          when /http/i
-            @runner_mode = :http
-          else
-            say "WARNING: You have provided incorrect option 'PB_SERVER_TYPE=#{server_type}'. Defaulting to socket mode.", :yellow
-            @runner_mode = :socket
-          end
-        end
+        server_type = ENV["PB_SERVER_TYPE"]
+
+        self.mode = if multi_mode?
+                      say('WARNING: You have provided multiple mode options. Defaulting to socket mode.', :yellow)
+                      :socket
+                    elsif options.zmq?
+                      :zmq
+                    elsif options.http?
+                      :http
+                    else
+                      case server_type
+                      when nil, /\Asocket[[:space:]]*\z/i
+                        :socket
+                      when /\Azmq[[:space:]]*\z/i
+                        :zmq
+                      when /http/i
+                        :http
+                      else
+                        require server_type.to_s
+                        server_type
+                      end
+                    end
       end
 
       # Configure signal traps.
-      # TODO add signal handling for hot-reloading the application.
+      # TODO: add signal handling for hot-reloading the application.
       def configure_traps
         debug_say('Configuring traps')
 
@@ -140,7 +155,7 @@ module Protobuf
           debug_say("Registering trap for exit signal #{signal}", :blue)
 
           trap(signal) do
-            @exit_requested = true
+            self.exit_requested = true
             shutdown_server
           end
         end
@@ -148,17 +163,18 @@ module Protobuf
 
       # Create the runner for the configured mode
       def create_runner
-        debug_say("Creating #{@runner_mode} runner")
-        @runner = case @runner_mode
-                  when :zmq
-                    create_zmq_runner
-                  when :socket
-                    create_socket_runner
-                  when :http
-                    create_http_runner
-                  else
-                    say_and_exit("Unknown runner mode: #{@runner_mode}")
-                  end
+        debug_say("Creating #{mode} runner")
+        self.runner = case mode
+                      when :zmq
+                        create_zmq_runner
+                      when :socket
+                        create_socket_runner
+                      when :http
+                        create_http_runner
+                      else
+                        say("Extension runner mode: #{mode}")
+                        create_extension_server_runner
+                      end
       end
 
       # Say something if we're in debug mode.
@@ -166,10 +182,6 @@ module Protobuf
         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.socket?
@@ -184,8 +196,7 @@ module Protobuf
       end
 
       def runner_options
-        # Symbolize keys
-        opt = options.inject({}) { |h, (k, v)| h[k.to_sym] = v; h }
+        opt = options.to_hash.symbolize_keys
 
         opt[:workers_only] = (!!ENV['PB_WORKERS_ONLY']) || options.workers_only
 
@@ -193,56 +204,65 @@ module Protobuf
       end
 
       def say_and_exit(message, exception = nil)
-        message = set_color(message, :red) if ::Protobuf::Logger.file == STDOUT
+        message = set_color(message, :red) if options.log == STDOUT
+
+        logger.error { message }
 
-        ::Protobuf::Logger.error { message }
         if exception
           $stderr.puts "[#{exception.class.name}] #{exception.message}"
           $stderr.puts exception.backtrace.join("\n")
 
-          ::Protobuf::Logger.error { "[#{exception.class.name}] #{exception.message}" }
-          ::Protobuf::Logger.debug { exception.backtrace.join("\n") }
+          logger.error { "[#{exception.class.name}] #{exception.message}" }
+          logger.debug { exception.backtrace.join("\n") }
         end
 
         exit(1)
       end
 
+      def create_extension_server_runner
+        classified = mode.classify
+        extension_server_class = classified.constantize
+
+        self.runner = extension_server_class.new(runner_options)
+      end
+
       def create_socket_runner
         require 'protobuf/socket'
 
-        @runner = ::Protobuf::Rpc::SocketRunner.new(runner_options)
+        self.runner = ::Protobuf::Rpc::SocketRunner.new(runner_options)
       end
 
       def create_zmq_runner
         require 'protobuf/zmq'
 
-        @runner = ::Protobuf::Rpc::ZmqRunner.new(runner_options)
+        self.runner = ::Protobuf::Rpc::ZmqRunner.new(runner_options)
       end
 
       def create_http_runner
         require 'protobuf/http'
 
-        @runner = ::Protobuf::Rpc::HttpRunner.new(runner_options)
+        self.runner = ::Protobuf::Rpc::HttpRunner.new(runner_options)
       end
 
       def shutdown_server
-        ::Protobuf::Logger.info { 'RPC Server shutting down...' }
-        @runner.try(:stop)
+        logger.info { 'RPC Server shutting down...' }
+        runner.stop
         ::Protobuf::Rpc::ServiceDirectory.instance.stop
-        ::Protobuf::Logger.info { 'Shutdown complete' }
       end
 
       # Start the runner and log the relevant options.
       def start_server
         debug_say('Running server')
 
-        @runner.run do
-          ::Protobuf::Logger.info {
-            "pid #{::Process.pid} -- #{@runner_mode} RPC Server listening at #{options.host}:#{options.port}"
-          }
+        runner.run do
+          logger.info do
+            "pid #{::Process.pid} -- #{mode} RPC Server listening at #{options.host}:#{options.port}"
+          end
 
           ::ActiveSupport::Notifications.instrument("after_server_bind")
         end
+
+        logger.info { 'Shutdown complete' }
       end
     end
   end