protobuffy 3.6.0 → 4.0.0

data/lib/protobuf/rpc/error.rb

@@ -8,8 +8,8 @@ module Protobuf
     class PbError < StandardError
       attr_reader :error_type
 
-      def initialize(message='An unknown RpcError occurred', error_type='RPC_ERROR')
-        @error_type = error_type.is_a?(String) ? Socketrpc::ErrorReason.const_get(error_type) : error_type
+      def initialize(message = 'An unknown RpcError occurred', error_type = 'RPC_ERROR')
+        @error_type = error_type.is_a?(String) ? ::Protobuf::Socketrpc::ErrorReason.const_get(error_type) : error_type
         super message
       end
 
@@ -18,7 +18,7 @@ module Protobuf
       end
 
       def to_response
-        Socketrpc::Response.new(:error => message, :error_reason => error_type)
+        ::Protobuf::Socketrpc::Response.new(:error => message, :error_reason => error_type)
       end
     end
   end

data/lib/protobuf/rpc/error/client_error.rb

@@ -4,25 +4,25 @@ module Protobuf
   module Rpc
 
     class InvalidRequestProto < PbError
-      def initialize(message='Invalid request type given')
+      def initialize(message = 'Invalid request type given')
         super message, 'INVALID_REQUEST_PROTO'
       end
     end
 
     class BadResponseProto < PbError
-      def initialize(message='Bad response type from server')
+      def initialize(message = 'Bad response type from server')
         super message, 'BAD_RESPONSE_PROTO'
       end
     end
 
     class UnkownHost < PbError
-      def initialize(message='Unknown host or port')
+      def initialize(message = 'Unknown host or port')
         super message, 'UNKNOWN_HOST'
       end
     end
 
     class IOError < PbError
-      def initialize(message='IO Error occurred')
+      def initialize(message = 'IO Error occurred')
         super message, 'IO_ERROR'
       end
     end

data/lib/protobuf/rpc/error/server_error.rb

@@ -4,55 +4,55 @@ module Protobuf
   module Rpc
 
     class BadRequestData < PbError
-      def initialize message='Unable to parse request'
+      def initialize(message = 'Unable to parse request')
         super message, 'BAD_REQUEST_DATA'
       end
     end
 
     class BadRequestProto < PbError
-      def initialize message='Request is of wrong type'
+      def initialize(message = 'Request is of wrong type')
         super message, 'BAD_REQUEST_PROTO'
       end
     end
 
     class ServiceNotFound < PbError
-      def initialize message='Service class not found'
+      def initialize(message = 'Service class not found')
         super message, 'SERVICE_NOT_FOUND'
       end
     end
 
     class MethodNotFound < PbError
-      def initialize message='Service method not found'
+      def initialize(message = 'Service method not found')
         super message, 'METHOD_NOT_FOUND'
       end
     end
 
     class RpcError < PbError
-      def initialize message='RPC exception occurred'
+      def initialize(message = 'RPC exception occurred')
         super message, 'RPC_ERROR'
       end
     end
 
     class RpcFailed < PbError
-      def initialize message='RPC failed'
+      def initialize(message = 'RPC failed')
         super message, 'RPC_FAILED'
       end
     end
 
     class UnauthorizedRequest < PbError
-      def initialize message='The request requires user authentication'
+      def initialize(message = 'The request requires user authentication')
         super message, 'UNAUTHORIZED_REQUEST'
       end
     end
 
     class ForbiddenRequest < PbError
-      def initialize message='User authentificated but does not have permissions'
+      def initialize(message = 'User authentificated but does not have permissions')
         super message, 'FORBIDDEN_REQUEST'
       end
     end
 
     class DataNotFound < PbError
-      def initialize message='Requested data not found'
+      def initialize(message = 'Requested data not found')
         super message, 'DATA_NOT_FOUND'
       end
     end

data/lib/protobuf/rpc/middleware/exception_handler.rb

@@ -2,7 +2,7 @@ module Protobuf
   module Rpc
     module Middleware
       class ExceptionHandler
-        include ::Protobuf::Logger::LogMethods
+        include ::Protobuf::Logging
 
         attr_reader :app
 
@@ -11,6 +11,10 @@ module Protobuf
         end
 
         def call(env)
+          dup._call(env)
+        end
+
+        def _call(env)
           app.call(env)
         rescue => exception
           log_exception(exception)
@@ -22,7 +26,7 @@ module Protobuf
           env
         end
 
-      private
+        private
 
         # Wrap exceptions in a generic Protobuf errors unless they already are
         #

data/lib/protobuf/rpc/middleware/logger.rb

@@ -8,6 +8,10 @@ module Protobuf
 
         # TODO: Figure out how to control when logs are flushed
         def call(env)
+          dup._call(env)
+        end
+
+        def _call(env)
           instrumenter.start
           instrumenter.flush(env) # Log request stats
 
@@ -19,7 +23,7 @@ module Protobuf
           env
         end
 
-      private
+        private
 
         def instrumenter
           @instrumenter ||= Instrumenter.new
@@ -42,7 +46,7 @@ module Protobuf
           attr_reader :env
 
           def flush(env)
-            Protobuf::Logger.info { to_s(env) }
+            ::Protobuf::Logging.logger.info { to_s(env) }
           end
 
           def start
@@ -63,11 +67,11 @@ module Protobuf
               rpc,
               sizes,
               elapsed_time,
-              @end_time.try(:iso8601)
+              @end_time.try(:iso8601),
             ].compact.join(' - ')
           end
 
-        private
+          private
 
           def elapsed_time
             (@start_time && @end_time ? "#{(@end_time - @start_time).round(4)}s" : nil)

data/lib/protobuf/rpc/middleware/request_decoder.rb

@@ -2,7 +2,7 @@ module Protobuf
   module Rpc
     module Middleware
       class RequestDecoder
-        include ::Protobuf::Logger::LogMethods
+        include ::Protobuf::Logging
 
         attr_reader :app, :env
 
@@ -11,8 +11,13 @@ module Protobuf
         end
 
         def call(env)
+          dup._call(env)
+        end
+
+        def _call(env)
           @env = env
 
+          logger.debug { sign_message("Decoding request: #{env.encoded_request}") }
           env.service_name = service_name
           env.method_name = method_name
           env.request = request
@@ -30,38 +35,29 @@ module Protobuf
           env.log_signature || super
         end
 
-      private
+        private
 
         def method_name
-          @method_name ||= begin
-            method_name = request_wrapper.method_name.underscore.to_sym
-
-            unless service.rpc_method?(method_name)
-              raise MethodNotFound.new("#{service.name}##{method_name} is not a defined RPC method.")
-            end
+          return @method_name unless @method_name.nil?
 
-            method_name
-          end
+          @method_name = request_wrapper.method_name.underscore.to_sym
+          fail MethodNotFound, "#{service.name}##{@method_name} is not a defined RPC method." unless service.rpc_method?(@method_name)
+          @method_name
         end
 
         def request
-          @request ||= begin
-            data = request_wrapper.request_proto
-            rpc_method.request_type.decode(data)
-          end
+          fail if request_wrapper.request_proto.blank?
+          @request ||= rpc_method.request_type.decode(request_wrapper.request_proto)
         rescue => exception
-          raise BadRequestData.new("Unable to decode request: #{exception.message}")
+          raise BadRequestData, "Unable to decode request: #{exception.message}"
         end
 
         # Decode the incoming request object into our expected request object
         #
         def request_wrapper
-          @request_wrapper ||= begin
-            log_debug { sign_message("Decoding request: #{env.encoded_request}") }
-            Socketrpc::Request.decode(env.encoded_request)
-          end
+          @request_wrapper ||= ::Protobuf::Socketrpc::Request.decode(env.encoded_request)
         rescue => exception
-          raise BadRequestData.new("Unable to decode request: #{exception.message}")
+          raise BadRequestData, "Unable to decode request: #{exception.message}"
         end
 
         def rpc_method
@@ -71,7 +67,7 @@ module Protobuf
         def service
           @service ||= service_name.constantize
         rescue NameError
-          raise ServiceNotFound.new("Service class #{service_name} is not defined.")
+          raise ServiceNotFound, "Service class #{service_name} is not defined."
         end
 
         def service_name

data/lib/protobuf/rpc/middleware/response_encoder.rb

@@ -2,7 +2,7 @@ module Protobuf
   module Rpc
     module Middleware
       class ResponseEncoder
-        include ::Protobuf::Logger::LogMethods
+        include ::Protobuf::Logging
 
         attr_reader :app, :env
 
@@ -11,6 +11,10 @@ module Protobuf
         end
 
         def call(env)
+          dup._call(env)
+        end
+
+        def _call(env)
           @env = app.call(env)
 
           env.response = response
@@ -22,12 +26,12 @@ module Protobuf
           env.log_signature || super
         end
 
-      private
+        private
 
         # Encode the response wrapper to return to the client
         #
         def encoded_response
-          log_debug { sign_message("Encoding response: #{response.inspect}") }
+          logger.debug { sign_message("Encoding response: #{response.inspect}") }
 
           env.encoded_response = wrapped_response.encode
         rescue => exception
@@ -35,38 +39,29 @@ module Protobuf
 
           # Rescue encoding exceptions, re-wrap them as generic protobuf errors,
           # and re-raise them
-          raise PbError.new(exception.message)
+          raise PbError, exception.message
         end
 
         # Prod the object to see if we can produce a proto object as a response
         # candidate. Validate the candidate protos.
         def response
-          @response ||= begin
-                          candidate = env.response
-                          case
-                          when candidate.is_a?(Message) then
-                            validate!(candidate)
-                          when candidate.respond_to?(:to_proto) then
-                            validate!(candidate.to_proto)
-                          when candidate.respond_to?(:to_hash) then
-                            env.response_type.new(candidate.to_hash)
-                          when candidate.is_a?(PbError) then
-                            candidate
-                          else
-                            validate!(candidate)
-                          end
-                        end
+          return @response unless @response.nil?
+
+          candidate = env.response
+          return @response = validate!(candidate) if candidate.is_a?(Message)
+          return @response = validate!(candidate.to_proto) if candidate.respond_to?(:to_proto)
+          return @response = env.response_type.new(candidate.to_hash) if candidate.respond_to?(:to_hash)
+          return @response = candidate if candidate.is_a?(PbError)
+
+          @response = validate!(candidate)
         end
 
         # Ensure that the response candidate we've been given is of the type
         # we expect so that deserialization on the client side works.
         #
         def validate!(candidate)
-          actual = candidate.class
-          expected = env.response_type
-
-          if expected != actual
-            raise BadResponseProto.new("Expected response to be of type #{expected.name} but was #{actual.name}")
+          if candidate.class != env.response_type
+            fail BadResponseProto, "Expected response to be of type #{env.response_type.name} but was #{candidate.class.name}"
           end
 
           candidate
@@ -76,10 +71,10 @@ module Protobuf
         # it up so that it's in the correct spot in the response wrapper
         #
         def wrapped_response
-          if response.is_a?(Protobuf::Rpc::PbError)
-            Socketrpc::Response.new(:error => response.message, :error_reason => response.error_type)
+          if response.is_a?(::Protobuf::Rpc::PbError)
+            ::Protobuf::Socketrpc::Response.new(:error => response.message, :error_reason => response.error_type)
           else
-            Socketrpc::Response.new(:response_proto => response.encode)
+            ::Protobuf::Socketrpc::Response.new(:response_proto => response.encode)
           end
         end
       end

data/lib/protobuf/rpc/middleware/statsd.rb

@@ -4,6 +4,8 @@ module Protobuf
   module Rpc
     module Middleware
       class Statsd
+        include ::Protobuf::Logging
+
         def initialize(app)
           @app = app
         end
@@ -23,8 +25,6 @@ module Protobuf
         def statsd_base_path(env)
           if env.service_name && env.method_name
             "rpc-server.#{env.service_name}.#{env.method_name}".gsub('::', '.').downcase
-          else
-            nil
           end
         end
 
@@ -46,7 +46,7 @@ module Protobuf
           statsd_client.timing("#{path}.time", end_time - start_time)
         rescue => e
           # We insert ourself after Exception handler, so no exceptions allowed!
-          Protobuf::Logger.warn { "Error with Statsd middleware: #{e.message}" }
+          logger.warn { "Error with Statsd middleware: #{e.message}" }
         end
         private :record_stats
       end

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

@@ -1,10 +1,13 @@
+# encoding: utf-8
+
 ##
 # This file is auto-generated. DO NOT EDIT!
 #
-require 'protobuf/message'
+require 'protobuf'
 
 module Protobuf
   module Socketrpc
+    ::Protobuf::Optionable.inject(self) { ::Google::Protobuf::FileOptions }
 
     ##
     # Enum Classes

data/lib/protobuf/rpc/server.rb

@@ -1,5 +1,5 @@
 require 'protobuf'
-require 'protobuf/logger'
+require 'protobuf/logging'
 require 'protobuf/rpc/rpc.pb'
 require 'protobuf/rpc/buffer'
 require 'protobuf/rpc/env'

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

@@ -8,7 +8,7 @@ module Protobuf
     module Http
       class Server
         include ::Protobuf::Rpc::Server
-        include ::Protobuf::Logger::LogMethods
+        include ::Protobuf::Logging
 
         # TODO: more comprehensive mapping?
         HTTP_STATUSES = {
@@ -24,8 +24,8 @@ module Protobuf
           Protobuf::Socketrpc::ErrorReason::INVALID_REQUEST_PROTO => 500,
           Protobuf::Socketrpc::ErrorReason::BAD_RESPONSE_PROTO => 500,
           Protobuf::Socketrpc::ErrorReason::UNKNOWN_HOST => 500,
-          Protobuf::Socketrpc::ErrorReason::IO_ERROR => 500
-        }
+          Protobuf::Socketrpc::ErrorReason::IO_ERROR => 500,
+        }.freeze
 
         def initialize(options = {})
           @options = options
@@ -36,11 +36,13 @@ module Protobuf
         end
 
         def call(env)
-          path_components = env['PATH_INFO'].split("/").map{ |x| CGI::unescape(x) }.compact.reject{ |x| x.empty? }
+          path_components = env['PATH_INFO'].split("/")
+                                            .map { |x| CGI.unescape(x) }
+                                            .compact.reject(&:empty?)
           if path_components.length < 2
             return protobuf_http_response 400,
-              :error => "Expected path format /CLASS/METHOD",
-              :reason => Protobuf::Socketrpc::ErrorReason::INVALID_REQUEST_PROTO
+                                          :error => "Expected path format /CLASS/METHOD",
+                                          :reason => Protobuf::Socketrpc::ErrorReason::INVALID_REQUEST_PROTO
           end
 
           service_name = path_components[0..-2].join("::")
@@ -53,26 +55,26 @@ module Protobuf
             :caller => env['HTTP_X_PROTOBUF_CALLER'] || ''
           )
 
-          encoded_request = rpc_request.encode()
+          encoded_request = rpc_request.encode
 
           begin
             encoded_response = handle_request(encoded_request, env)
-          rescue Exception => e
+          rescue StandardError => e
             return protobuf_http_response 500,
-              :error => "Handle request failed: #{e.to_s}",
-              :reason => Protobuf::Socketrpc::ErrorReason::RPC_ERROR
+                                          :error => "Handle request failed: #{e}",
+                                          :reason => Protobuf::Socketrpc::ErrorReason::RPC_ERROR
           end
 
           rpc_response = Protobuf::Socketrpc::Response.decode(encoded_response)
 
-          if rpc_response[:error].length > 0
-            status = HTTP_STATUSES[rpc_response[:error_reason]] or 500
+          if rpc_response[:error].present?
+            status = HTTP_STATUSES[rpc_response[:error_reason]] || 500
             return protobuf_http_response status,
-              :error => rpc_response[:error],
-              :reason => rpc_response[:error_reason]
+                                          :error => rpc_response[:error],
+                                          :reason => rpc_response[:error_reason]
           end
-          
-          return protobuf_http_response 200, :body => rpc_response['response_proto']
+
+          protobuf_http_response 200, :body => rpc_response['response_proto']
         end
 
         def protobuf_http_response(status, options)
@@ -93,7 +95,7 @@ module Protobuf
         end
 
         def running?
-          !!@running
+          !!@running # rubocop:disable Style/DoubleNegation
         end
 
         def stop