protobuffy 3.1.0

data/lib/protobuf/optionable.rb

@@ -0,0 +1,23 @@
+require 'active_support/concern'
+
+module Protobuf
+  module Optionable
+    extend ::ActiveSupport::Concern
+
+    module ClassMethods
+      def get_option(name)
+        @_optionable_options.try(:[], name)
+      end
+
+      def set_option(name, value = true)
+        @_optionable_options ||= {}
+        @_optionable_options[name] = value
+      end
+    end
+
+    def get_option(name)
+      self.class.get_option(name)
+    end
+
+  end
+end

data/lib/protobuf/rpc/buffer.rb

@@ -0,0 +1,79 @@
+module Protobuf
+  module Rpc
+    class Buffer
+
+      attr_accessor :mode, :data, :size
+
+      MODES = [:read, :write]
+
+      # constantize this so we don't re-initialize the regex every time we need it
+      SIZE_REGEX = /^\d+-/
+
+      def initialize(mode=:read)
+        @flush = false
+        @data = ""
+        @size = 0
+        self.mode = mode
+      end
+
+      def mode=(mode)
+        if MODES.include?(mode)
+          @mode = mode
+        else
+          @mode = :read
+        end
+      end
+
+      def write(force_mode=true)
+        if force_mode and reading?
+          mode = :write
+        elsif not force_mode and reading?
+          raise = 'You chose to write the buffer when in read mode'
+        end
+
+        @size = @data.length
+        "#{@size}-#{@data}"
+      end
+
+      def <<(data)
+        @data << data
+        if reading?
+          get_data_size
+          check_for_flush
+        end
+      end
+
+      def set_data(data)
+        @data = data.to_s
+        @size = @data.size
+      end
+
+      def reading?
+        mode == :read
+      end
+
+      def writing?
+        mode == :write
+      end
+
+      def flushed?
+        @flush
+      end
+
+      def get_data_size
+        if @size == 0 || @data.match(SIZE_REGEX)
+          sliced_size = @data.slice!(SIZE_REGEX)
+          @size = sliced_size.gsub('-', '').to_i unless sliced_size.nil?
+        end
+      end
+
+    private
+
+      def check_for_flush
+        if !@size.nil? && @data.length == @size
+          @flush = true
+        end
+      end
+    end
+  end
+end

data/lib/protobuf/rpc/client.rb

@@ -0,0 +1,168 @@
+require 'forwardable'
+require 'protobuf'
+require 'protobuf/logger'
+require 'protobuf/rpc/error'
+require 'protobuf/rpc/connector'
+
+module Protobuf
+  module Rpc
+    class Client
+      extend Forwardable
+      include Protobuf::Logger::LogMethods
+
+      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 = {})
+        raise "Invalid client configuration. Service must be defined." if options[:service].nil?
+        @connector = Connector.connector_for_client.new(options)
+        log_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
+          raise "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
+          raise "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
+          raise "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]
+        unless service.rpc_method?(method_name)
+          log_error { sign_message("#{service.name}##{method_name.to_s} not rpc method, passing to super") }
+          super(method_name, *params)
+        else
+          log_debug { sign_message("#{service.name}##{method_name.to_s}") }
+          rpc = service.rpcs[method_name.to_sym]
+
+          options[:request_type] = rpc.request_type
+          log_debug { sign_message("Request Type: #{options[:request_type].name}") }
+
+          options[:response_type] = rpc.response_type
+          log_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]
+          log_debug { sign_message("Request Data: #{options[:request].inspect}") }
+
+          # Call client to setup on_success and on_failure event callbacks
+          if block_given?
+            log_debug { sign_message("client setup callback given, invoking") }
+            yield(self)
+          else
+            log_debug { sign_message("no block given for callbacks") }
+          end
+
+          send_request
+        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,21 @@
+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
+        when :http then
+          ::Protobuf::Rpc::Connectors::Http
+        else
+          ::Protobuf::Rpc::Connectors::Socket
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+require 'timeout'
+require 'protobuf/logger'
+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                 => 300,         # The default 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::Logger::LogMethods
+
+        attr_reader :options
+        attr_accessor :success_cb, :failure_cb, :complete_cb
+
+        def initialize(options)
+          @options = DEFAULT_OPTIONS.merge(options)
+        end
+
+        def first_alive_load_balance?
+          ENV.has_key?("PB_FIRST_ALIVE_LOAD_BALANCE") ||
+            options[:first_alive_load_balance]
+        end
+
+        def send_request
+          raise '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.has_key?("PB_RPC_PING_PORT")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,172 @@
+require 'protobuf'
+
+module Protobuf
+  module Rpc
+    module Connectors
+      module Common
+
+        attr_reader :error
+
+        def any_callbacks?
+          return [@complete_cb, @failure_cb, @success_cb].inject(false) do |reduction, cb|
+            reduction = (reduction || !cb.nil?)
+          end
+        end
+
+        def request_caller
+          @options[:client_host] || ::Protobuf.client_host
+        end
+
+        def complete
+          @stats.stop
+          log_info { @stats.to_s }
+          log_debug { sign_message('Response proceessing complete') }
+          @complete_cb.call(self) unless @complete_cb.nil?
+        rescue => e
+          log_error { sign_message('Complete callback error encountered') }
+          log_exception(e)
+          raise
+        end
+
+        def data_callback(data)
+          log_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 fail(code, message)
+          @error =  ClientError.new
+          @error.code = Protobuf::Socketrpc::ErrorReason.fetch(code)
+          @error.message = message
+          log_debug { sign_message("Server failed request (invoking on_failure): #{@error.inspect}") }
+
+          @stats.failure(code)
+          @failure_cb.call(@error) unless @failure_cb.nil?
+        rescue => e
+          log_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)
+          fail(: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
+
+          log_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.has_field?(:error_reason)
+            log_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)
+            fail(response_wrapper.error_reason, response_wrapper.error)
+          else
+            log_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? and not response_wrapper.has_field?(:error_reason)
+              fail(: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
+          fail(: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
+          fail(: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)
+          log_debug { sign_message("Server succeeded request (invoking on_success)") }
+          @stats.success
+          @success_cb.call(response) unless @success_cb.nil?
+        rescue => e
+          log_error { sign_message("Success callback error encountered") }
+          log_exception(e)
+          fail(:RPC_ERROR, "An exception occurred while calling on_success: #{e.message}")
+        ensure
+          complete
+        end
+
+        # Wrap the given block in a timeout of the configured number of seconds.
+        #
+        def timeout_wrap(&block)
+          ::Timeout.timeout(options[:timeout], &block)
+        rescue ::Timeout::Error
+          fail(:RPC_FAILED, "The server took longer than #{options[: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
+            fail(:INVALID_REQUEST_PROTO, "Expected request type to be type of #{expected}, got #{actual} instead")
+          end
+        end
+
+        def verify_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!
+          # 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?
+          end
+        end
+      end
+    end
+  end
+end