prepor-protobuf 3.5.0

data/lib/protobuf/rpc/client.rb

@@ -0,0 +1,168 @@
+require 'forwardable'
+require 'protobuf'
+require 'protobuf/logging'
+require 'protobuf/rpc/error'
+require 'protobuf/rpc/connector'
+
+module Protobuf
+  module Rpc
+    class Client
+      extend Forwardable
+      include Protobuf::Logging
+
+      def_delegators :@connector, :options, :complete_cb, :success_cb, :failure_cb
+      attr_reader :connector
+
+      # Create a new client with default options (defined in ClientConnection)
+      # See Service#client for a more convenient way to create a client, as well
+      # as Client#method_missing defined below.
+      #
+      #   request = WidgetFindRequest.new
+      #   client = Client.new({
+      #     :service => WidgetService,
+      #     :method => "find",
+      #     :request_type => "WidgetFindRequest",
+      #     :response_type => "WidgetList",
+      #     :request => request
+      #   })
+      #
+      def initialize(options = {})
+        fail "Invalid client configuration. Service must be defined." if options[:service].nil?
+        @connector = Connector.connector_for_client.new(options)
+        logger.debug { sign_message("Initialized with options: #{options.inspect}") }
+      end
+
+      def log_signature
+        @_log_signature ||= "[client-#{self.class}]"
+      end
+
+      # Set a complete callback on the client to return the object (self).
+      #
+      #   client = Client.new(:service => WidgetService)
+      #   client.on_complete {|obj| ... }
+      #
+      def on_complete(&complete_cb)
+        @connector.complete_cb = complete_cb
+      end
+
+      def on_complete=(callable)
+        if !callable.nil? && !callable.respond_to?(:call) && callable.arity != 1
+          fail "callable must take a single argument and respond to :call"
+        end
+
+        @connector.complete_cb = callable
+      end
+
+      # Set a failure callback on the client to return the
+      # error returned by the service, if any. If this callback
+      # is called, success_cb will NOT be called.
+      #
+      #   client = Client.new(:service => WidgetService)
+      #   client.on_failure {|err| ... }
+      #
+      def on_failure(&failure_cb)
+        @connector.failure_cb = failure_cb
+      end
+
+      def on_failure=(callable)
+        if !callable.nil? && !callable.respond_to?(:call) && callable.arity != 1
+          fail "Callable must take a single argument and respond to :call"
+        end
+
+        @connector.failure_cb = callable
+      end
+
+      # Set a success callback on the client to return the
+      # successful response from the service when it is returned.
+      # If this callback is called, failure_cb will NOT be called.
+      #
+      #   client = Client.new(:service => WidgetService)
+      #   client.on_success {|res| ... }
+      #
+      def on_success(&success_cb)
+        @connector.success_cb = success_cb
+      end
+
+      def on_success=(callable)
+        if !callable.nil? && !callable.respond_to?(:call) && callable.arity != 1
+          fail "Callable must take a single argument and respond to :call"
+        end
+
+        @connector.success_cb = callable
+      end
+
+      # Provides a mechanism to call the service method against the client
+      # which will automatically setup the service_class and method_name
+      # in the wrapper protobuf request.
+      #
+      #   # The :find method is not defined by Client which will trigger method_missing
+      #   Client.new(:service => WidgetService).find do |c|
+      #     # This block will be invoked before the request is made
+      #     # `c` in this case is the client object you created above
+      #     c.on_success {|res| ... }
+      #     c.on_failure {|err| ... }
+      #   end
+      #
+      def method_missing(method_name, *params)
+        service = options[:service]
+        if service.rpc_method?(method_name)
+          logger.debug { sign_message("#{service.name}##{method_name}") }
+          rpc = service.rpcs[method_name.to_sym]
+
+          options[:request_type] = rpc.request_type
+          logger.debug { sign_message("Request Type: #{options[:request_type].name}") }
+
+          options[:response_type] = rpc.response_type
+          logger.debug { sign_message("Response Type: #{options[:response_type].name}") }
+
+          options[:method] = method_name.to_s
+          options[:request] = params[0].is_a?(Hash) ? options[:request_type].new(params[0]) : params[0]
+          logger.debug { sign_message("Request Data: #{options[:request].inspect}") }
+
+          # Call client to setup on_success and on_failure event callbacks
+          if block_given?
+            logger.debug { sign_message("client setup callback given, invoking") }
+            yield(self)
+          else
+            logger.debug { sign_message("no block given for callbacks") }
+          end
+
+          send_request
+        else
+          logger.error { sign_message("#{service.name}##{method_name} not rpc method, passing to super") }
+          super(method_name, *params)
+        end
+      end
+
+      # Send the request to the service.
+      # This method is usually never called directly
+      # but is invoked by method_missing (see docs above).
+      #
+      #   request = WidgetFindRequest.new
+      #   client = Client.new({
+      #     :service => WidgetService,
+      #     :method => "find",
+      #     :request_type => "WidgetFindRequest",
+      #     :response_type => "WidgetList",
+      #     :request => request
+      #   })
+      #
+      #   client.on_success do |res|
+      #     res.widgets.each{|w| puts w.inspect }
+      #   end
+      #
+      #   client.on_failure do |err|
+      #     puts err.message
+      #   end
+      #
+      #   client.send_request
+      #
+      def send_request
+        @connector.send_request
+      end
+
+    end
+
+    ActiveSupport.run_load_hooks(:protobuf_rpc_client, Client)
+  end
+end

data/lib/protobuf/rpc/connector.rb

@@ -0,0 +1,19 @@
+require 'protobuf'
+
+module Protobuf
+  module Rpc
+    class Connector
+
+      # Returns a connector class for the pre-defined connector_type.
+      def self.connector_for_client
+        case ::Protobuf.connector_type
+        when :zmq then
+          ::Protobuf::Rpc::Connectors::Zmq
+        else
+          ::Protobuf::Rpc::Connectors::Socket
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+require 'timeout'
+require 'protobuf/logging'
+require 'protobuf/rpc/rpc.pb'
+require 'protobuf/rpc/buffer'
+require 'protobuf/rpc/error'
+require 'protobuf/rpc/stat'
+require 'protobuf/rpc/connectors/common'
+
+module Protobuf
+  module Rpc
+    module Connectors
+      DEFAULT_OPTIONS = {
+        :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)
+        :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                 => nil,         # The timeout for the request, also handled by client.rb
+        :client_host             => nil,         # The hostname or address of this client
+        :first_alive_load_balance => false,      # Do we want to use check_avail frames before request
+      }
+
+      class Base
+        include Protobuf::Logging
+
+        attr_reader :options
+        attr_accessor :success_cb, :failure_cb, :complete_cb
+
+        def initialize(options)
+          @options = DEFAULT_OPTIONS.merge(options)
+          @stats = ::Protobuf::Rpc::Stat.new(:CLIENT)
+        end
+
+        def first_alive_load_balance?
+          ENV.key?("PB_FIRST_ALIVE_LOAD_BALANCE") ||
+            options[:first_alive_load_balance]
+        end
+
+        def send_request
+          fail 'If you inherit a Connector from Base you must implement send_request'
+        end
+
+        def ping_port
+          @ping_port ||= ENV["PB_RPC_PING_PORT"]
+        end
+
+        def ping_port_enabled?
+          ENV.key?("PB_RPC_PING_PORT")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,176 @@
+require 'protobuf'
+
+module Protobuf
+  module Rpc
+    module Connectors
+      module Common
+
+        attr_reader :error
+
+        def any_callbacks?
+          [@complete_cb, @failure_cb, @success_cb].any?
+        end
+
+        def request_caller
+          @options[:client_host] || ::Protobuf.client_host
+        end
+
+        def complete
+          @stats.stop
+          logger.info { @stats.to_s }
+          logger.debug { sign_message('Response proceessing complete') }
+          @complete_cb.call(self) unless @complete_cb.nil?
+        rescue => e
+          logger.error { sign_message('Complete callback error encountered') }
+          log_exception(e)
+          raise
+        end
+
+        def data_callback(data)
+          logger.debug { sign_message('Using data_callback') }
+          @used_data_callback = true
+          @data = data
+        end
+
+        # All failures should be routed through this method.
+        #
+        # @param [Symbol] code The code we're using (see ::Protobuf::Socketrpc::ErrorReason)
+        # @param [String] message The error message
+        def failure(code, message)
+          @error =  ClientError.new
+          @error.code = Protobuf::Socketrpc::ErrorReason.fetch(code)
+          @error.message = message
+          logger.debug { sign_message("Server failed request (invoking on_failure): #{@error.inspect}") }
+
+          @failure_cb.call(@error) unless @failure_cb.nil?
+        rescue => e
+          logger.error { sign_message("Failure callback error encountered") }
+          log_exception(e)
+          raise
+        ensure
+          complete
+        end
+
+        def initialize_stats
+          @stats = ::Protobuf::Rpc::Stat.new(:CLIENT)
+          @stats.server = [@options[:port], @options[:host]]
+          @stats.service = @options[:service].name
+          @stats.method_name = @options[:method].to_s
+        rescue => ex
+          log_exception(ex)
+          failure(:RPC_ERROR, "Invalid stats configuration. #{ex.message}")
+        end
+
+        def log_signature
+          @_log_signature ||= "[client-#{self.class}]"
+        end
+
+        def parse_response
+          # Close up the connection as we no longer need it
+          close_connection
+
+          logger.debug { sign_message("Parsing response from server (connection closed)") }
+
+          # Parse out the raw response
+          @stats.response_size = @response_data.size unless @response_data.nil?
+          response_wrapper = Protobuf::Socketrpc::Response.decode(@response_data)
+
+          # Determine success or failure based on parsed data
+          if response_wrapper.field?(:error_reason)
+            logger.debug { sign_message("Error response parsed") }
+
+            # fail the call if we already know the client is failed
+            # (don't try to parse out the response payload)
+            failure(response_wrapper.error_reason, response_wrapper.error)
+          else
+            logger.debug { sign_message("Successful response parsed") }
+
+            # Ensure client_response is an instance
+            parsed = @options[:response_type].decode(response_wrapper.response_proto.to_s)
+
+            if parsed.nil? && !response_wrapper.field?(:error_reason)
+              failure(:BAD_RESPONSE_PROTO, 'Unable to parse response from server')
+            else
+              verify_callbacks
+              succeed(parsed)
+              return @data if @used_data_callback
+            end
+          end
+        end
+
+        def post_init
+          send_data unless error?
+        rescue => e
+          failure(:RPC_ERROR, "Connection error: #{e.message}")
+        end
+
+        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.encode(fields)
+        rescue => e
+          failure(:INVALID_REQUEST_PROTO, "Could not set request proto: #{e.message}")
+        end
+
+        def setup_connection
+          initialize_stats
+          @request_data = request_bytes
+          @stats.request_size = request_bytes.size
+        end
+
+        def succeed(response)
+          logger.debug { sign_message("Server succeeded request (invoking on_success)") }
+          @success_cb.call(response) unless @success_cb.nil?
+        rescue => e
+          logger.error { sign_message("Success callback error encountered") }
+          log_exception(e)
+          failure(:RPC_ERROR, "An exception occurred while calling on_success: #{e.message}")
+        ensure
+          complete
+        end
+
+        def timeout
+          if options[:timeout]
+            options[:timeout]
+          else
+            300 # seconds
+          end
+        end
+
+        # Wrap the given block in a timeout of the configured number of seconds.
+        #
+        def timeout_wrap(&block)
+          ::Timeout.timeout(timeout, &block)
+        rescue ::Timeout::Error
+          failure(:RPC_FAILED, "The server took longer than #{timeout} seconds to respond")
+        end
+
+        def validate_request_type!
+          unless @options[:request].class == @options[:request_type]
+            expected = @options[:request_type].name
+            actual = @options[:request].class.name
+            failure(:INVALID_REQUEST_PROTO, "Expected request type to be type of #{expected}, got #{actual} instead")
+          end
+        end
+
+        def verify_callbacks
+          unless any_callbacks?
+            logger.debug { sign_message("No callbacks set, using data_callback") }
+            @success_cb = @failure_cb = method(:data_callback)
+          end
+        end
+
+        def verify_options!
+          # Verify the options that are necessary and merge them in
+          [:service, :method, :host, :port].each do |opt|
+            failure(:RPC_ERROR, "Invalid client connection configuration. #{opt} must be a defined option.") if @options[opt].nil?
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+require 'protobuf/rpc/connectors/base'
+
+module Protobuf
+  module Rpc
+    module Connectors
+      class Socket < Base
+        include Protobuf::Rpc::Connectors::Common
+        include Protobuf::Logging
+
+        def send_request
+          timeout_wrap do
+            setup_connection
+            connect_to_rpc_server
+            post_init
+            read_response
+          end
+        end
+
+        def log_signature
+          @_log_signature ||= "[client-#{self.class}]"
+        end
+
+        private
+
+        def close_connection
+          @socket.close
+          logger.debug { sign_message('Connector closed')  }
+        end
+
+        def connect_to_rpc_server
+          @socket ||= TCPSocket.new(options[:host], options[:port])
+          logger.debug { sign_message("Connection established #{options[:host]}:#{options[:port]}") }
+        end
+
+        # Method to determine error state, must be used with Connector api
+        def error?
+          return true if @error
+          logger.debug { sign_message("Error state : #{@socket.closed?}")  }
+          @socket.closed?
+        end
+
+        def read_data
+          size_io = StringIO.new
+
+          until (size_reader = @socket.getc) == "-"
+            size_io << size_reader
+          end
+          str_size_io = size_io.string
+
+          "#{str_size_io}-#{@socket.read(str_size_io.to_i)}"
+        end
+
+        def read_response
+          logger.debug { sign_message("error? is #{error?}") }
+          return if error?
+          response_buffer = ::Protobuf::Rpc::Buffer.new(:read)
+          response_buffer << read_data
+          @response_data = response_buffer.data
+          parse_response if response_buffer.flushed?
+        end
+
+        def send_data
+          return if error?
+          request_buffer = ::Protobuf::Rpc::Buffer.new(:write)
+          request_buffer.set_data(@request_data)
+          @socket.write(request_buffer.write)
+          @socket.flush
+          logger.debug { sign_message("write closed") }
+        end
+      end
+    end
+  end
+end