protobuf 2.5.0-java → 2.5.2-java

data/README.md

@@ -14,6 +14,8 @@ So let's dive in and see how to work with all three.
 
 ## 1. Generating ruby classes from `.proto` files
 
+_The `protobuf` package is required for compilation. Mac: `brew install protobuf`, Ubuntu: `sudo apt-get install -y protobuf`_
+
 Protocol Buffers are great because they allow you to clearly define data storage or data transfer packets. Google officially supports Java, C++, and Python for compilation and usage. Let's make it ruby aware!
 
 Let's say you have a `defs.proto` file that defines a User message.
@@ -24,9 +26,11 @@ message User {
   required string first_name = 1;
   required string last_name = 2;
 }
+```
 
 Now let's compile that definition to ruby:
 
+```
 $ rprotoc defs.proto --ruby_out ./lib
 ```
 

data/lib/protobuf.rb

@@ -14,6 +14,19 @@ module Protobuf
 
 	module_function
 
+  # 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
+  end
+
+  def self.client_host=(host)
+    @_client_host = host
+  end
+
   # Connector Type
   #
   # Default: socket

data/lib/protobuf/cli.rb

@@ -31,7 +31,7 @@ module Protobuf
 
     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 => true, :desc => 'Cause use of deprecated fields to be printed or ignored.'
+    option :print_deprecation_warnings, :type => :boolean, :default => nil, :desc => 'Cause use of deprecated fields to be printed or ignored.'
 
     def start(app_file)
       debug_say 'Configuring the rpc_server process'
@@ -61,13 +61,23 @@ module Protobuf
 
       # Tell protobuf how to handle the printing of deprecated field usage.
       def configure_deprecation_warnings
-        ::Protobuf.print_deprecation_warnings = options.print_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
       end
 
       # If we pause during request we don't need to pause in serialization
       def configure_gc
         debug_say 'Configuring gc'
-        ::Protobuf.gc_pause_server_request = options.gc_pause_request?
+
+        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
       end
 
       # Setup the protobuf logger.
@@ -91,15 +101,24 @@ module Protobuf
       def configure_server_mode
         debug_say 'Configuring runner mode'
         if options.zmq? && ! options.evented? && ! options.socket?
-          @mode = :zmq
-          @runner = ::Protobuf::Rpc::ZmqRunner
+          server_zmq!
         elsif options.evented? && ! options.zmq? && ! options.socket?
-          @mode = :evented
-          @runner = ::Protobuf::Rpc::EventedRunner
+          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!
+          else
+            say "WARNING: You have provided incorrect option 'PB_SERVER_TYPE=#{env_server_type}'. Defaulting to socket mode.", :yellow
+            server_socket!
+          end
         else
           say 'WARNING: You have provided multiple mode options. Defaulting to socket mode.', :yellow if multi_mode?
-          @mode = :socket
-          @runner = ::Protobuf::Rpc::SocketRunner
+          server_socket!
         end
       end
 
@@ -173,6 +192,21 @@ module Protobuf
         exit(1)
       end
 
+      def server_evented!
+        @mode = :evented
+        @runner = ::Protobuf::Rpc::EventedRunner
+      end
+
+      def server_socket!
+        @mode = :socket
+        @runner = ::Protobuf::Rpc::SocketRunner
+      end
+
+      def server_zmq!
+        @mode = :zmq
+        @runner = ::Protobuf::Rpc::ZmqRunner
+      end
+
       # Start the runner and log the relevant options.
       def start_server!
         debug_say 'Invoking server start'

data/lib/protobuf/rpc/connectors/base.rb

@@ -9,14 +9,15 @@ module Protobuf
   module Rpc
     module Connectors
       DEFAULT_OPTIONS = {
-        :service        => nil,           # Service to invoke
-        :method         => nil,           # Service method to call
-        :host           => '127.0.0.1',   # A default host (usually overridden)
-        :port           => '9399',        # A default port (usually overridden)
+        :service        => nil,           # Fully-qualified Service class
+        :method         => nil,           # Service method to invoke
+        :host           => '127.0.0.1',   # The hostname or address of the service (usually overridden or pre-configured)
+        :port           => '9399',        # The port of the service (usually overridden or pre-configured)
         :request        => nil,           # The request object sent by the client
         :request_type   => nil,           # The request type expected by the client
         :response_type  => nil,           # The response type expected by the client
-        :timeout        => 30             # The default timeout for the request, also handled by client.rb
+        :timeout        => 30,            # The default timeout for the request, also handled by client.rb
+        :client_host    => nil            # The hostname or address of this client
       }
 
       class Base

data/lib/protobuf/rpc/connectors/common.rb

@@ -11,6 +11,10 @@ module Protobuf
           end
         end
 
+        def request_caller
+          @options[:client_host] || ::Protobuf.client_host
+        end
+
         def complete
           @stats.stop
           log_info { @stats.to_s }
@@ -101,21 +105,21 @@ module Protobuf
           fail(:RPC_ERROR, "Connection error: #{e.message}")
         end
 
-        def rpc_request_data
-          validate_request_type
+        def request_bytes
+          validate_request_type!
+          fields = { :service_name => @options[:service].name,
+                     :method_name => @options[:method].to_s,
+                     :request_proto => @options[:request],
+                     :caller => request_caller }
 
-          return ::Protobuf::Socketrpc::Request.new(
-            :service_name => @options[:service].name,
-            :method_name => @options[:method].to_s,
-            :request_proto => @options[:request]
-          ).serialize_to_string
+          return ::Protobuf::Socketrpc::Request.new(fields).serialize_to_string
         rescue => e
           fail(:INVALID_REQUEST_PROTO, "Could not set request proto: #{e.message}")
         end
 
         def setup_connection
           initialize_stats
-          @request_data = rpc_request_data
+          @request_data = request_bytes
         end
 
         def succeed(response)
@@ -129,7 +133,7 @@ module Protobuf
           complete
         end
 
-        def validate_request_type
+        def validate_request_type!
           unless @options[:request].class == @options[:request_type]
             expected = @options[:request_type].name
             actual = @options[:request].class.name
@@ -138,13 +142,13 @@ module Protobuf
         end
 
         def verify_callbacks
-          if !any_callbacks?
+          unless any_callbacks?
             log_debug { sign_message("No callbacks set, using data_callback") }
             @success_cb = @failure_cb = self.method(:data_callback)
           end
         end
 
-        def verify_options
+        def verify_options!
           # Verify the options that are necessary and merge them in
           [:service, :method, :host, :port].each do |opt|
             fail(:RPC_ERROR, "Invalid client connection configuration. #{opt} must be a defined option.") if @options[opt].nil?

data/lib/protobuf/rpc/connectors/em_client.rb

@@ -17,7 +17,7 @@ module Protobuf
           @failure_cb = failure_cb
           @options = DEFAULT_OPTIONS.merge(options)
           @response_buffer = ::Protobuf::Rpc::Buffer.new(:read)
-          verify_options
+          verify_options!
 
           log_debug { sign_message("Client Initialized: #{options.inspect}") }
         rescue => e

data/lib/protobuf/rpc/rpc.pb.rb

@@ -1,78 +1,6 @@
-### Generated by rprotoc. DO NOT EDIT!
-### <proto file: rpc.proto>
-# // Copyright (c) 2009 Shardul Deo
-# //
-# // Permission is hereby granted, free of charge, to any person obtaining a copy
-# // of this software and associated documentation files (the "Software"), to deal
-# // in the Software without restriction, including without limitation the rights
-# // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# // copies of the Software, and to permit persons to whom the Software is
-# // furnished to do so, subject to the following conditions:
-# //
-# // The above copyright notice and this permission notice shall be included in
-# // all copies or substantial portions of the Software.
-# //
-# // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-# // THE SOFTWARE.
-# 
-# // Author: Shardul Deo
-# //
-# // Protobufs needed for socket rpcs.
-# 
-# package protobuf.socketrpc;
-# 
-# message Request {
-# 
-#   // RPC service full name
-#   required string service_name = 1;
-#   
-#   // RPC method name
-#   required string method_name = 2;
-#   
-#   // RPC request proto
-#   required bytes request_proto = 3;
-# }
-# 
-# message Response {
-# 
-#   // RPC response proto
-#   optional bytes response_proto = 1;
-#   
-#   // Error, if any
-#   optional string error = 2;
-#   
-#   // Was callback invoked
-#   optional bool callback = 3 [default = false];
-#   
-#   // Error Reason
-#   optional ErrorReason error_reason = 4;
-# }
-# 
-# // Possible error reasons
-# // The server-side errors are returned in the response from the server.
-# // The client-side errors are returned by the client-side code when it doesn't 
-# // have a response from the server.
-# enum ErrorReason {
-# 
-#   // Server-side errors
-#   BAD_REQUEST_DATA = 0; // Server received bad request data
-#   BAD_REQUEST_PROTO = 1; // Server received bad request proto
-#   SERVICE_NOT_FOUND = 2; // Service not found on server
-#   METHOD_NOT_FOUND = 3; // Method not found on server
-#   RPC_ERROR = 4; // Rpc threw exception on server
-#   RPC_FAILED = 5; // Rpc failed on server
-#   
-#   // Client-side errors (these are returned by the client-side code)
-#   INVALID_REQUEST_PROTO = 6; // Rpc was called with invalid request proto
-#   BAD_RESPONSE_PROTO = 7; // Server returned a bad response proto
-#   UNKNOWN_HOST = 8; // Could not find supplied host
-#   IO_ERROR = 9; // I/O error while communicating with server
-# }
+##
+# This file is auto-generated. DO NOT EDIT!
+#
 require 'protobuf/message'
 
 module Protobuf
@@ -91,28 +19,35 @@ module Protobuf
     ##
     # Enum Values
     #
-    ::Protobuf::Socketrpc::ErrorReason.define :BAD_REQUEST_DATA, 0
-    ::Protobuf::Socketrpc::ErrorReason.define :BAD_REQUEST_PROTO, 1
-    ::Protobuf::Socketrpc::ErrorReason.define :SERVICE_NOT_FOUND, 2
-    ::Protobuf::Socketrpc::ErrorReason.define :METHOD_NOT_FOUND, 3
-    ::Protobuf::Socketrpc::ErrorReason.define :RPC_ERROR, 4
-    ::Protobuf::Socketrpc::ErrorReason.define :RPC_FAILED, 5
-    ::Protobuf::Socketrpc::ErrorReason.define :INVALID_REQUEST_PROTO, 6
-    ::Protobuf::Socketrpc::ErrorReason.define :BAD_RESPONSE_PROTO, 7
-    ::Protobuf::Socketrpc::ErrorReason.define :UNKNOWN_HOST, 8
-    ::Protobuf::Socketrpc::ErrorReason.define :IO_ERROR, 9
+    class ErrorReason
+      define :BAD_REQUEST_DATA, 0
+      define :BAD_REQUEST_PROTO, 1
+      define :SERVICE_NOT_FOUND, 2
+      define :METHOD_NOT_FOUND, 3
+      define :RPC_ERROR, 4
+      define :RPC_FAILED, 5
+      define :INVALID_REQUEST_PROTO, 6
+      define :BAD_RESPONSE_PROTO, 7
+      define :UNKNOWN_HOST, 8
+      define :IO_ERROR, 9
+    end
     
     ##
     # Message Fields
     #
-    ::Protobuf::Socketrpc::Request.required(::Protobuf::Field::StringField, :service_name, 1)
-    ::Protobuf::Socketrpc::Request.required(::Protobuf::Field::StringField, :method_name, 2)
-    ::Protobuf::Socketrpc::Request.required(::Protobuf::Field::BytesField, :request_proto, 3)
+    class Request
+      required ::Protobuf::Field::StringField, :service_name, 1
+      required ::Protobuf::Field::StringField, :method_name, 2
+      optional ::Protobuf::Field::BytesField, :request_proto, 3
+      optional ::Protobuf::Field::StringField, :caller, 4
+    end
     
-    ::Protobuf::Socketrpc::Response.optional(::Protobuf::Field::BytesField, :response_proto, 1)
-    ::Protobuf::Socketrpc::Response.optional(::Protobuf::Field::StringField, :error, 2)
-    ::Protobuf::Socketrpc::Response.optional(::Protobuf::Field::BoolField, :callback, 3, :default => false)
-    ::Protobuf::Socketrpc::Response.optional(::Protobuf::Socketrpc::ErrorReason, :error_reason, 4)
+    class Response
+      optional ::Protobuf::Field::BytesField, :response_proto, 1
+      optional ::Protobuf::Field::StringField, :error, 2
+      optional ::Protobuf::Field::BoolField, :callback, 3, :default => false
+      optional ::Protobuf::Socketrpc::ErrorReason, :error_reason, 4
+    end
     
   end
 end

data/lib/protobuf/rpc/server.rb

@@ -14,7 +14,6 @@ module Protobuf
         @request = ::Protobuf::Socketrpc::Request.new
         @response = ::Protobuf::Socketrpc::Response.new
         @stats = Protobuf::Rpc::Stat.new(:SERVER)
-        set_peer
       end
 
       def disable_gc!
@@ -25,12 +24,11 @@ module Protobuf
         ::GC.enable && ::GC.start if ::Protobuf.gc_pause_server_request?
       end
 
-      # no-op, implemented by including class if desired.
-      def set_peer; end
-
       # Invoke the service method dictated by the proto wrapper request object
       def handle_client
         parse_request_from_buffer
+        @stats.client = @request.caller
+
         @dispatcher = ::Protobuf::Rpc::ServiceDispatcher.new(@request)
         @stats.dispatcher = @dispatcher
 

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

@@ -31,10 +31,6 @@ module Protobuf
           log_debug { sign_message("sending data: #{response_buffer.inspect}") }
           super(response_buffer.write)
         end
-
-        def set_peer
-          @stats.client = ::Socket.unpack_sockaddr_in(get_peername)
-        end
       end
     end
   end

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

@@ -74,7 +74,7 @@ module Protobuf
                   client, sockaddr = @server.accept
                   @listen_fds << client
                 else
-                  if !@working.include?(client)
+                  unless @working.include?(client)
                     @working << @listen_fds.delete(client)
                     log_debug { sign_message("Working")  }
                     @threads << { :thread => new_worker(client), :socket => client }

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

@@ -52,10 +52,6 @@ module Protobuf
           @_log_signature ||= "server-#{self.class}-#{object_id}"
         end
 
-        def set_peer
-          @stats.client = ::Socket.unpack_sockaddr_in(@socket.getpeername)
-        end
-
         def socket_writable?
           ! @socket.nil? && ! @socket.closed?
         end

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

@@ -29,7 +29,7 @@ module Protobuf
         def handle_request(socket)
           @request_data = ''
           zmq_error_check(socket.recv_string(@request_data))
-          log_debug { sign_message("handling request") } if !@request_data.nil?
+          log_debug { sign_message("handling request") } unless @request_data.nil?
         end
 
         def run

data/lib/protobuf/rpc/service.rb

@@ -15,8 +15,6 @@ module Protobuf
       include ::Protobuf::Logger::LogMethods
 
 
-      attr_reader :response, :rpc
-
       DEFAULT_HOST = '127.0.0.1'.freeze
       DEFAULT_PORT = 9399
 
@@ -102,23 +100,26 @@ module Protobuf
       # Instance Methods
       #
 
+      attr_reader :response, :method_name, :client_host
+
       # Initialize a service with the rpc endpoint name and the bytes
       # for the request.
-      def initialize(rpc, request_bytes)
-        @rpc = rpc
-        @request_bytes = request_bytes
+      def initialize(method_name, request_bytes, client_host = nil)
+        @method_name = method_name
+        @client_host = client_host
+        @_request_bytes = request_bytes
       end
 
       # Register a failure callback for use when rpc_failed is invoked.
       #
       def on_rpc_failed(callable)
-        @rpc_failed_callback ||= callable
+        @_rpc_failed_callback ||= callable
       end
 
       # Response object for this rpc cycle. Not assignable.
       #
       def response
-        @_response ||= rpcs[@rpc].response_type.new
+        @_response ||= response_type.new
       end
 
       # Convenience method to get back to class method.
@@ -144,18 +145,26 @@ module Protobuf
 
       private
 
+      def response_type
+        @_response_type ||= rpcs[@method_name].response_type
+      end
+
       # Request object for this rpc cycle. Not assignable.
       #
       def request
-        @_request ||= if @request_bytes.present?
-            rpcs[@rpc].request_type.new.parse_from_string(@request_bytes)
+        @_request ||= if @_request_bytes.present?
+            request_type.new.parse_from_string(@_request_bytes)
           else
-            rpcs[@rpc].request_type.new
+            request_type.new
           end
       rescue => e
         raise BadRequestProto, "Unable to parse request: #{e.message}"
       end
 
+      def request_type
+        @_request_type ||= rpcs[@method_name].request_type
+      end
+
       # Sugar to make an rpc method feel like a controller method.
       # If this method is not called, the response will be the memoized
       # object returned by the response reader.
@@ -165,10 +174,22 @@ module Protobuf
       end
       alias_method :return_from_whence_you_came, :respond_with
 
+      # Renamed attribute from prior implementaiton due to lack of clarity
+      # in what the variable contained. DEPRECATED.
+      def rpc
+        if ::Protobuf.print_deprecation_warnings?
+          $stderr.puts <<-ERROR
+            [WARNING] Service#rpc method has been deprecated
+                      and will be removed in a future version of protobuf.
+          ERROR
+        end
+        @method_name
+      end
+
       # Automatically fail a service method.
       #
       def rpc_failed(message)
-        @rpc_failed_callback.call(message)
+        @_rpc_failed_callback.call(message)
       end
 
     end

data/lib/protobuf/rpc/service_dispatcher.rb

@@ -74,7 +74,7 @@ module Protobuf
         request_proto = outer_request.has_field?(:request_proto) ? outer_request.request_proto : nil
 
         if service_klass.rpc_method?(method_name)
-          self.service = service_klass.new(method_name, request_proto)
+          self.service = service_klass.new(method_name, request_proto, outer_request.caller)
           self.callable_method = service.callable_rpc_method(method_name)
           self.definition = service.rpcs[method_name]
         else

data/lib/protobuf/rpc/stat.rb

@@ -14,12 +14,12 @@ module Protobuf
         start
       end
 
-      def client=(peer)
-        @client = {:port => peer[0], :ip => peer[1]}
+      def client=(client_host)
+        @client = client_host
       end
 
       def client
-        @client ? "#{@client[:ip]}:#{@client[:port]}" : nil
+        @client || nil
       end
 
       def method_name
@@ -47,7 +47,7 @@ module Protobuf
       end
 
       def stop
-        start if !@start_time
+        start unless @start_time
         @end_time ||= Time.now
       end
 

data/lib/protobuf/version.rb

@@ -1,4 +1,4 @@
 module Protobuf
-  VERSION = '2.5.0'
+  VERSION = '2.5.2'
   PROTOC_VERSION = '2.4.1'
 end

data/proto/rpc.proto

@@ -18,56 +18,45 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 // THE SOFTWARE.
 
-// Author: Shardul Deo
+// Authors: Shardul Deo, BJ Neilsen
 //
 // Protobufs needed for socket rpcs.
 
 package protobuf.socketrpc;
 
-message Request {
-
-  // RPC service full name
-  required string service_name = 1;
-  
-  // RPC method name
-  required string method_name = 2;
-  
-  // RPC request proto
-  optional bytes request_proto = 3;
+message Request
+{
+  required string service_name = 1;             // Fully- qualified Service class name
+  required string method_name = 2;              // Service method to invoke
+  optional bytes request_proto = 3;             // Serialized request bytes
+  optional string caller = 4;                   // Calling hostname or address
 }
 
-message Response {
-
-  // RPC response proto
-  optional bytes response_proto = 1;
-  
-  // Error, if any
-  optional string error = 2;
-  
-  // Was callback invoked
-  optional bool callback = 3 [default = false];
-  
-  // Error Reason
-  optional ErrorReason error_reason = 4;
+message Response
+{
+  optional bytes response_proto = 1;            // Serialized response
+  optional string error = 2;                    // Error message, if any
+  optional bool callback = 3 [default = false]; // Was callback invoked (not sure what this is for)
+  optional ErrorReason error_reason = 4;        // Error Reason
 }
 
 // Possible error reasons
 // The server-side errors are returned in the response from the server.
-// The client-side errors are returned by the client-side code when it doesn't 
+// The client-side errors are returned by the client-side code when it doesn't
 // have a response from the server.
-enum ErrorReason {
-
+enum ErrorReason
+{
   // Server-side errors
-  BAD_REQUEST_DATA = 0; // Server received bad request data
-  BAD_REQUEST_PROTO = 1; // Server received bad request proto
-  SERVICE_NOT_FOUND = 2; // Service not found on server
-  METHOD_NOT_FOUND = 3; // Method not found on server
-  RPC_ERROR = 4; // Rpc threw exception on server
-  RPC_FAILED = 5; // Rpc failed on server
-  
+  BAD_REQUEST_DATA = 0;                         // Server received bad request data
+  BAD_REQUEST_PROTO = 1;                        // Server received bad request proto
+  SERVICE_NOT_FOUND = 2;                        // Service not found on server
+  METHOD_NOT_FOUND = 3;                         // Method not found on server
+  RPC_ERROR = 4;                                // Rpc threw exception on server
+  RPC_FAILED = 5;                               // Rpc failed on server
+
   // Client-side errors (these are returned by the client-side code)
-  INVALID_REQUEST_PROTO = 6; // Rpc was called with invalid request proto
-  BAD_RESPONSE_PROTO = 7; // Server returned a bad response proto
-  UNKNOWN_HOST = 8; // Could not find supplied host
-  IO_ERROR = 9; // I/O error while communicating with server
+  INVALID_REQUEST_PROTO = 6;                    // Rpc was called with invalid request proto
+  BAD_RESPONSE_PROTO = 7;                       // Server returned a bad response proto
+  UNKNOWN_HOST = 8;                             // Could not find supplied host
+  IO_ERROR = 9;                                 // I/O error while communicating with server
 }

data/spec/lib/protobuf/cli_spec.rb

@@ -3,127 +3,134 @@ require 'protobuf/cli'
 
 describe ::Protobuf::CLI do
 
-	let(:app_file) do
-		File.expand_path('../../../support/test_app_file.rb', __FILE__)
-	end
-
-	before do
-		::Protobuf::Rpc::SocketRunner.stub(:run)
-		::Protobuf::Rpc::ZmqRunner.stub(:run)
-		::Protobuf::Rpc::EventedRunner.stub(:run)
-	end
-
-	describe '#start' do
-		let(:base_args) { [ 'start', app_file ] }
-		let(:test_args) { [] }
-		let(:args) { base_args + test_args }
-
-		context 'host option' do
-			let(:test_args) { [ '--host=123.123.123.123' ] }
-
-			it 'sends the host option to the runner' do
-				::Protobuf::Rpc::SocketRunner.should_receive(:run) do |options|
-					options[:host].should eq '123.123.123.123'
-				end
-				described_class.start(args)
-			end
-		end
-
-		context 'port option' do
-			let(:test_args) { [ '--port=12345' ] }
-
-			it 'sends the port option to the runner' do
-				::Protobuf::Rpc::SocketRunner.should_receive(:run) do |options|
-					options[:port].should eq 12345
-				end
-				described_class.start(args)
-			end
-		end
-
-		context 'threads option' do
-			let(:test_args) { [ '--threads=500' ] }
-
-			it 'sends the threads option to the runner' do
-				::Protobuf::Rpc::SocketRunner.should_receive(:run) do |options|
-					options[:threads].should eq 500
-				end
-				described_class.start(args)
-			end
-		end
-
-		context 'backlog option' do
-			let(:test_args) { [ '--backlog=500' ] }
-
-			it 'sends the backlog option to the runner' do
-				::Protobuf::Rpc::SocketRunner.should_receive(:run) do |options|
-					options[:backlog].should eq 500
-				end
-				described_class.start(args)
-			end
-		end
-
-		context 'threshold option' do
-			let(:test_args) { [ '--threshold=500' ] }
-
-			it 'sends the backlog option to the runner' do
-				::Protobuf::Rpc::SocketRunner.should_receive(:run) do |options|
-					options[:threshold].should eq 500
-				end
-				described_class.start(args)
-			end
-		end
-
-		context 'log options' do
-			let(:test_args) { [ '--log=mylog.log', '--level=0' ] }
-
-			it 'sends the log file and level options to the runner' do
-				::Protobuf::Logger.should_receive(:configure) do |options|
-					options[:file].should eq 'mylog.log'
-					options[:level].should eq 0
-				end
-				described_class.start(args)
-			end
-
-			context 'when debugging' do
-				let(:test_args) { [ '--level=3', '--debug' ] }
-
-				it 'overrides the log-level to DEBUG' do
-					::Protobuf::Logger.should_receive(:configure) do |options|
-						options[:level].should eq ::Logger::DEBUG
-					end
-					described_class.start(args)
-				end
-			end
-		end
-
-		context 'gc options' do
-
-			context 'when gc options are not present' do
-				let(:test_args) { [] }
-
-				it 'sets both request and serialization pausing to false' do
-					described_class.start(args)
-					::Protobuf.gc_pause_server_request?.should be_false
-				end
-			end
-
-			context 'request pausing' do
-				let(:test_args) { [ '--gc_pause_request' ] }
-
-				it 'sets the configuration option to GC pause server request' do
-					described_class.start(args)
-					::Protobuf.gc_pause_server_request?.should be_true
-				end
-			end
-		end
-
-		context 'deprecation options' do
+  let(:app_file) do
+    File.expand_path('../../../support/test_app_file.rb', __FILE__)
+  end
+
+  before do
+    ::Protobuf::Rpc::SocketRunner.stub(:run)
+    ::Protobuf::Rpc::ZmqRunner.stub(:run)
+    ::Protobuf::Rpc::EventedRunner.stub(:run)
+  end
+
+  describe '#start' do
+    let(:base_args) { [ 'start', app_file ] }
+    let(:test_args) { [] }
+    let(:args) { base_args + test_args }
+
+    context 'host option' do
+      let(:test_args) { [ '--host=123.123.123.123' ] }
+
+      it 'sends the host option to the runner' do
+        ::Protobuf::Rpc::SocketRunner.should_receive(:run) do |options|
+          options[:host].should eq '123.123.123.123'
+        end
+        described_class.start(args)
+      end
+    end
+
+    context 'port option' do
+      let(:test_args) { [ '--port=12345' ] }
+
+      it 'sends the port option to the runner' do
+        ::Protobuf::Rpc::SocketRunner.should_receive(:run) do |options|
+          options[:port].should eq 12345
+        end
+        described_class.start(args)
+      end
+    end
+
+    context 'threads option' do
+      let(:test_args) { [ '--threads=500' ] }
+
+      it 'sends the threads option to the runner' do
+        ::Protobuf::Rpc::SocketRunner.should_receive(:run) do |options|
+          options[:threads].should eq 500
+        end
+        described_class.start(args)
+      end
+    end
+
+    context 'backlog option' do
+      let(:test_args) { [ '--backlog=500' ] }
+
+      it 'sends the backlog option to the runner' do
+        ::Protobuf::Rpc::SocketRunner.should_receive(:run) do |options|
+          options[:backlog].should eq 500
+        end
+        described_class.start(args)
+      end
+    end
+
+    context 'threshold option' do
+      let(:test_args) { [ '--threshold=500' ] }
+
+      it 'sends the backlog option to the runner' do
+        ::Protobuf::Rpc::SocketRunner.should_receive(:run) do |options|
+          options[:threshold].should eq 500
+        end
+        described_class.start(args)
+      end
+    end
+
+    context 'log options' do
+      let(:test_args) { [ '--log=mylog.log', '--level=0' ] }
+
+      it 'sends the log file and level options to the runner' do
+        ::Protobuf::Logger.should_receive(:configure) do |options|
+          options[:file].should eq 'mylog.log'
+          options[:level].should eq 0
+        end
+        described_class.start(args)
+      end
+
+      context 'when debugging' do
+        let(:test_args) { [ '--level=3', '--debug' ] }
+
+        it 'overrides the log-level to DEBUG' do
+          ::Protobuf::Logger.should_receive(:configure) do |options|
+            options[:level].should eq ::Logger::DEBUG
+          end
+          described_class.start(args)
+        end
+      end
+    end
+
+    context 'gc options' do
+
+      context 'when gc options are not present' do
+        let(:test_args) { [] }
+
+        it 'sets both request and serialization pausing to false' do
+          described_class.start(args)
+          ::Protobuf.gc_pause_server_request?.should be_false
+        end
+      end
+
+      context 'request pausing' do
+        let(:test_args) { [ '--gc_pause_request' ] }
+
+        it 'sets the configuration option to GC pause server request' do
+          described_class.start(args)
+          ::Protobuf.gc_pause_server_request?.should be_true
+        end
+      end
+    end
+
+    context 'deprecation options' do
       context 'when not given' do
         let(:test_args) { [] }
 
-        it 'sets the deprecation warning flag to its default value' do
+        it 'sets the deprecation warning flag to true when no ENV is present and no command line option' do
+          described_class.start(args)
+          ::Protobuf.print_deprecation_warnings?.should be_true
+        end
+
+        it 'sets the deprecation warning flag to false if ENV["PB_IGNORE_DEPRECATIONS"] is present' do
+          ENV["PB_IGNORE_DEPRECATIONS"] = "1"
           described_class.start(args)
-					::Protobuf.print_deprecation_warnings?.should be_true
+          ::Protobuf.print_deprecation_warnings?.should be_false
+          ENV.delete("PB_IGNORE_DEPRECATIONS")
         end
       end
 
@@ -132,7 +139,7 @@ describe ::Protobuf::CLI do
 
         it 'sets the deprecation warning flag to true' do
           described_class.start(args)
-					::Protobuf.print_deprecation_warnings?.should be_true
+          ::Protobuf.print_deprecation_warnings?.should be_true
         end
       end
 
@@ -141,72 +148,96 @@ describe ::Protobuf::CLI do
 
         it 'sets the deprecation warning flag to false' do
           described_class.start(args)
-					::Protobuf.print_deprecation_warnings?.should be_false
+          ::Protobuf.print_deprecation_warnings?.should be_false
         end
       end
-		end
+    end
 
-		context 'run modes' do
+    context 'run modes' do
 
-			context 'socket' do
-				let(:test_args) { [ '--socket' ] }
+      context 'socket' do
+        let(:test_args) { [ '--socket' ] }
+        let(:runner) { ::Protobuf::Rpc::SocketRunner }
 
-				before do
-					::Protobuf::Rpc::EventedRunner.should_not_receive(:run)
-					::Protobuf::Rpc::ZmqRunner.should_not_receive(:run)
-				end
+        before do
+          ::Protobuf::Rpc::EventedRunner.should_not_receive(:run)
+          ::Protobuf::Rpc::ZmqRunner.should_not_receive(:run)
+        end
+
+        it 'is activated by the --socket switch' do
+          runner.should_receive(:run)
+          described_class.start(args)
+        end
 
-				it 'is activated by the --socket switch' do
-					::Protobuf::Rpc::SocketRunner.should_receive(:run)
-					described_class.start(args)
-				end
+        it 'is activated by PB_SERVER_TYPE=Socket ENV variable' do 
+          ENV['PB_SERVER_TYPE'] = "Socket"
+          runner.should_receive(:run)
+          described_class.start(args)
+          ENV.delete('PB_SERVER_TYPE')
+        end
 
-				it 'configures the connector type to be socket' do
+        it 'configures the connector type to be socket' do
           load "protobuf/socket.rb"
-					::Protobuf.connector_type.should == :socket
-				end
-			end
+          ::Protobuf.connector_type.should == :socket
+        end
+      end
 
-			context 'evented' do
-				let(:test_args) { [ '--evented' ] }
+      context 'evented' do
+        let(:test_args) { [ '--evented' ] }
+        let(:runner) { ::Protobuf::Rpc::EventedRunner }
 
-				before do
-					::Protobuf::Rpc::SocketRunner.should_not_receive(:run)
-					::Protobuf::Rpc::ZmqRunner.should_not_receive(:run)
-				end
+        before do
+          ::Protobuf::Rpc::SocketRunner.should_not_receive(:run)
+          ::Protobuf::Rpc::ZmqRunner.should_not_receive(:run)
+        end
+
+        it 'is activated by the --evented switch' do
+          runner.should_receive(:run)
+          described_class.start(args)
+        end
 
-				it 'is activated by the --evented switch' do
-					::Protobuf::Rpc::EventedRunner.should_receive(:run)
-					described_class.start(args)
-				end
+        it 'is activated by PB_SERVER_TYPE=Evented ENV variable' do 
+          ENV['PB_SERVER_TYPE'] = "Evented"
+          runner.should_receive(:run)
+          described_class.start(args)
+          ENV.delete('PB_SERVER_TYPE')
+        end
 
-				it 'configures the connector type to be evented' do
+        it 'configures the connector type to be evented' do
           load "protobuf/evented.rb"
-					::Protobuf.connector_type.should == :evented
-				end
-			end
+          ::Protobuf.connector_type.should == :evented
+        end
+      end
 
-			context 'zmq' do
-				let(:test_args) { [ '--zmq' ] }
+      context 'zmq' do
+        let(:test_args) { [ '--zmq' ] }
+        let(:runner) { ::Protobuf::Rpc::ZmqRunner }
 
-				before do
-					::Protobuf::Rpc::SocketRunner.should_not_receive(:run)
-					::Protobuf::Rpc::EventedRunner.should_not_receive(:run)
-				end
+        before do
+          ::Protobuf::Rpc::SocketRunner.should_not_receive(:run)
+          ::Protobuf::Rpc::EventedRunner.should_not_receive(:run)
+        end
+
+        it 'is activated by the --zmq switch' do
+          runner.should_receive(:run)
+          described_class.start(args)
+        end
 
-				it 'is activated by the --zmq switch' do
-					::Protobuf::Rpc::ZmqRunner.should_receive(:run)
-					described_class.start(args)
-				end
+        it 'is activated by PB_SERVER_TYPE=Zmq ENV variable' do 
+          ENV['PB_SERVER_TYPE'] = "Zmq"
+          runner.should_receive(:run)
+          described_class.start(args)
+          ENV.delete('PB_SERVER_TYPE')
+        end
 
-				it 'configures the connector type to be zmq' do
+        it 'configures the connector type to be zmq' do
           load "protobuf/zmq.rb"
-					::Protobuf.connector_type.should == :zmq
-				end
-			end
+          ::Protobuf.connector_type.should == :zmq
+        end
+      end
 
-		end
+    end
 
-	end
+  end
 
 end

data/spec/lib/protobuf/rpc/connectors/common_spec.rb

@@ -10,20 +10,23 @@ describe Protobuf::Rpc::Connectors::Common do
     end
   end
 
-  subject{ @subject ||= common_class.new({}) }
+  let(:subject_options) { {} }
+
+  subject { @subject ||= common_class.new(subject_options) }
 
   context "API" do
-    specify{ subject.respond_to?(:any_callbacks?).should be_true }
-    specify{ subject.respond_to?(:data_callback).should be_true }
-    specify{ subject.respond_to?(:error).should be_true }
-    specify{ subject.respond_to?(:fail).should be_true }
-    specify{ subject.respond_to?(:complete).should be_true }
-    specify{ subject.respond_to?(:parse_response).should be_true }
-    specify{ subject.respond_to?(:verify_options).should be_true }
-    specify{ subject.respond_to?(:verify_callbacks).should be_true }
+    specify { subject.respond_to?(:any_callbacks?).should be_true }
+    specify { subject.respond_to?(:request_caller).should be_true }
+    specify { subject.respond_to?(:data_callback).should be_true }
+    specify { subject.respond_to?(:error).should be_true }
+    specify { subject.respond_to?(:fail).should be_true }
+    specify { subject.respond_to?(:complete).should be_true }
+    specify { subject.respond_to?(:parse_response).should be_true }
+    specify { subject.respond_to?(:verify_options!).should be_true }
+    specify { subject.respond_to?(:verify_callbacks).should be_true }
   end
 
-  context "#any_callbacks?" do
+  describe "#any_callbacks?" do
 
     [:@complete_cb, :@success_cb, :@failure_cb].each do |cb|
       it "returns true if #{cb} is provided" do
@@ -42,7 +45,19 @@ describe Protobuf::Rpc::Connectors::Common do
 
   end
 
-  context "#data_callback" do
+  describe '#request_caller' do
+    its(:request_caller) { should eq ::Protobuf.client_host }
+
+    context 'when "client_host" option is given to initializer' do
+      let(:hostname) { 'myhost.myserver.com' }
+      let(:subject_options) { { :client_host => hostname } }
+
+      its(:request_caller) { should_not eq ::Protobuf.client_host }
+      its(:request_caller) { should eq hostname }
+    end
+  end
+
+  describe "#data_callback" do
     it "changes state to use the data callback" do
       subject.data_callback("data")
       subject.instance_variable_get(:@used_data_callback).should be_true
@@ -54,7 +69,28 @@ describe Protobuf::Rpc::Connectors::Common do
     end
   end
 
-  context "#verify_callbacks" do
+  describe '#request_bytes' do
+    let(:service) { Test::ResourceService }
+    let(:method) { :find }
+    let(:request) { '' }
+    let(:client_host) { 'myhost.myservice.com' }
+    let(:subject_options) { { :service => service,
+                              :method => method,
+                              :request => request,
+                              :client_host => client_host } }
+
+    let(:expected) { ::Protobuf::Socketrpc::Request.new({ :service_name => service.name,
+                                                          :method_name => 'find',
+                                                          :request_proto => '',
+                                                          :caller => client_host }) }
+
+    before { subject.stub(:validate_request_type!).and_return(true) }
+    before { subject.should_not_receive(:fail) }
+
+    its(:request_bytes) { should eq expected.serialize_to_string }
+  end
+
+  describe "#verify_callbacks" do
 
     it "sets @failure_cb to #data_callback when no callbacks are defined" do
       subject.verify_callbacks

data/spec/lib/protobuf_spec.rb

@@ -3,6 +3,22 @@ require 'protobuf'
 
 describe ::Protobuf do
 
+  describe '.client_host' do
+    after { ::Protobuf.instance_variable_set(:@_client_host, nil) }
+
+    subject { ::Protobuf.client_host }
+
+    context 'when client_host is not pre-configured' do
+      it { should eq `hostname`.chomp }
+    end
+
+    context 'when client_host is pre-configured' do
+      let(:hostname) { 'override.myhost.com' }
+      before { ::Protobuf.client_host = hostname }
+      it { should eq hostname }
+    end
+  end
+
   describe '.connector_type' do
     before { described_class.instance_variable_set(:@_connector_type, nil) }
 

metadata

@@ -2,7 +2,7 @@
 name: protobuf
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 2.5.0
+  version: 2.5.2
 platform: java
 authors: 
   - BJ Neilsen
@@ -11,7 +11,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-11-28 00:00:00 Z
+date: 2012-12-05 00:00:00 Z
 dependencies: 
   - !ruby/object:Gem::Dependency 
     name: activesupport
@@ -338,7 +338,6 @@ files:
   - lib/protobuf/version.rb
   - lib/protobuf/wire_type.rb
   - lib/protobuf/zmq.rb
-  - proto/rpc.pb.rb
   - proto/rpc.proto
   - protobuf.gemspec
   - spec/benchmark/tasks.rb

data/proto/rpc.pb.rb

@@ -1,48 +0,0 @@
-##
-# This file is auto-generated. DO NOT EDIT!
-#
-require 'protobuf/message'
-
-module Protobuf
-  module Socketrpc
-    ##
-    # Enum Classes
-    #
-    class ErrorReason < ::Protobuf::Enum; end
-    
-    ##
-    # Message Classes
-    #
-    class Request < ::Protobuf::Message; end
-    class Response < ::Protobuf::Message; end
-    
-    ##
-    # Enum Values
-    #
-    ::Protobuf::Socketrpc::ErrorReason.define :BAD_REQUEST_DATA, 0
-    ::Protobuf::Socketrpc::ErrorReason.define :BAD_REQUEST_PROTO, 1
-    ::Protobuf::Socketrpc::ErrorReason.define :SERVICE_NOT_FOUND, 2
-    ::Protobuf::Socketrpc::ErrorReason.define :METHOD_NOT_FOUND, 3
-    ::Protobuf::Socketrpc::ErrorReason.define :RPC_ERROR, 4
-    ::Protobuf::Socketrpc::ErrorReason.define :RPC_FAILED, 5
-    ::Protobuf::Socketrpc::ErrorReason.define :INVALID_REQUEST_PROTO, 6
-    ::Protobuf::Socketrpc::ErrorReason.define :BAD_RESPONSE_PROTO, 7
-    ::Protobuf::Socketrpc::ErrorReason.define :UNKNOWN_HOST, 8
-    ::Protobuf::Socketrpc::ErrorReason.define :IO_ERROR, 9
-    
-    
-    ##
-    # Message Fields
-    #
-    ::Protobuf::Socketrpc::Request.required(::Protobuf::Field::StringField, :service_name, 1)
-    ::Protobuf::Socketrpc::Request.required(::Protobuf::Field::StringField, :method_name, 2)
-    ::Protobuf::Socketrpc::Request.optional(::Protobuf::Field::BytesField, :request_proto, 3)
-    
-    ::Protobuf::Socketrpc::Response.optional(::Protobuf::Field::BytesField, :response_proto, 1)
-    ::Protobuf::Socketrpc::Response.optional(::Protobuf::Field::StringField, :error, 2)
-    ::Protobuf::Socketrpc::Response.optional(::Protobuf::Field::BoolField, :callback, 3, :default => false)
-    ::Protobuf::Socketrpc::Response.optional(::Protobuf::Socketrpc::ErrorReason, :error_reason, 4)
-    
-    
-  end
-end