protobuf-cucumber 3.10.4

data/lib/protobuf/message/serialization.rb

@@ -0,0 +1,85 @@
+require 'stringio'
+require 'protobuf/decoder'
+require 'protobuf/encoder'
+
+module Protobuf
+  class Message
+    module Serialization
+
+      module ClassMethods
+        def decode(bytes)
+          new.decode(bytes)
+        end
+
+        def decode_from(stream)
+          new.decode_from(stream)
+        end
+
+        # Create a new object with the given values and return the encoded bytes.
+        def encode(fields = {})
+          new(fields).encode
+        end
+      end
+
+      def self.included(other)
+        other.extend(ClassMethods)
+      end
+
+      ##
+      # Instance Methods
+      #
+
+      # Decode the given non-stream bytes into this message.
+      #
+      def decode(bytes)
+        decode_from(::StringIO.new(bytes))
+      end
+
+      # Decode the given stream into this message.
+      #
+      def decode_from(stream)
+        ::Protobuf::Decoder.decode_each_field(stream) do |tag, bytes|
+          set_field_bytes(tag, bytes)
+        end
+
+        self
+      end
+
+      # Encode this message
+      #
+      def encode
+        stream = ::StringIO.new
+        stream.set_encoding(::Protobuf::Field::BytesField::BYTES_ENCODING)
+        encode_to(stream)
+        stream.string
+      end
+
+      # Encode this message to the given stream.
+      #
+      def encode_to(stream)
+        ::Protobuf::Encoder.encode(self, stream)
+      end
+
+      ##
+      # Instance Aliases
+      #
+      alias :parse_from_string decode
+      alias :deserialize decode
+      alias :parse_from decode_from
+      alias :deserialize_from decode_from
+      alias :to_s encode
+      alias :bytes encode
+      alias :serialize encode
+      alias :serialize_to_string encode
+      alias :serialize_to encode_to
+
+      private
+
+      def set_field_bytes(tag, bytes)
+        field = _protobuf_message_field[tag]
+        field.set(self, bytes) if field
+      end
+
+    end
+  end
+end

data/lib/protobuf/optionable.rb

@@ -0,0 +1,70 @@
+module Protobuf
+  module Optionable
+    module ClassMethods
+      def get_option(name)
+        name = name.to_s
+        option = optionable_descriptor_class.get_field(name, true)
+        fail ArgumentError, "invalid option=#{name}" unless option
+        unless option.fully_qualified_name.to_s == name
+          # Eventually we'll deprecate the use of simple names of fields completely, but for now make sure people
+          # are accessing options correctly. We allow simple names in other places for backwards compatibility.
+          fail ArgumentError, "must access option using its fully qualified name: #{option.fully_qualified_name.inspect}"
+        end
+        value =
+          if @_optionable_options.try(:key?, name)
+            @_optionable_options[name]
+          else
+            option.default_value
+          end
+        if option.type_class < ::Protobuf::Message
+          option.type_class.new(value)
+        else
+          value
+        end
+      end
+
+      def get_option!(name)
+        get_option(name) if @_optionable_options.try(:key?, name.to_s)
+      end
+
+      private
+
+      def set_option(name, value = true)
+        @_optionable_options ||= {}
+        @_optionable_options[name.to_s] = value
+      end
+    end
+
+    def get_option(name)
+      self.class.get_option(name)
+    end
+
+    def get_option!(name)
+      self.class.get_option!(name)
+    end
+
+    def self.inject(base_class, extend_class = true, &block)
+      unless block_given?
+        fail ArgumentError, 'missing option class block (e.g: ::Google::Protobuf::MessageOptions)'
+      end
+      if extend_class
+        # Check if optionable_descriptor_class is already defined and short circuit if so.
+        # File options are injected per module, and since a module can be defined more than once,
+        # we will get a warning if we try to define optionable_descriptor_class twice.
+        if base_class.respond_to?(:optionable_descriptor_class)
+          # Don't define optionable_descriptor_class twice
+          return  if base_class.optionable_descriptor_class == block.call
+
+          fail 'A class is being defined with two different descriptor classes, something is very wrong'
+        end
+
+        base_class.extend(ClassMethods)
+        base_class.__send__(:include, self)
+        base_class.define_singleton_method(:optionable_descriptor_class, block)
+      else
+        base_class.__send__(:include, ClassMethods)
+        base_class.module_eval { define_method(:optionable_descriptor_class, block) }
+      end
+    end
+  end
+end

data/lib/protobuf/rpc/buffer.rb

@@ -0,0 +1,78 @@
+module Protobuf
+  module Rpc
+    class Buffer
+
+      attr_accessor :mode, :data, :size
+
+      MODES = [:read, :write].freeze
+
+      # 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)
+        @mode =
+          if MODES.include?(mode)
+            mode
+          else
+            :read
+          end
+      end
+
+      def write(force_mode = true)
+        if force_mode && reading?
+          self.mode = :write
+        elsif !force_mode && reading?
+          fail '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) # rubocop:disable Style/AccessorMethodName
+        @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 # rubocop:disable Style/AccessorMethodName
+        if @size == 0 || @data.match(SIZE_REGEX)
+          sliced_size = @data.slice!(SIZE_REGEX)
+          @size = sliced_size.delete('-').to_i unless sliced_size.nil?
+        end
+      end
+
+      private
+
+      def check_for_flush
+        @flush = true if !@size.nil? && @data.length == @size
+      end
+    end
+  end
+end

data/lib/protobuf/rpc/client.rb

@@ -0,0 +1,140 @@
+require 'forwardable'
+require 'protobuf'
+require 'protobuf/logging'
+require 'protobuf/rpc/error'
+
+module Protobuf
+  module Rpc
+    class Client
+      extend Forwardable
+      include Protobuf::Logging
+
+      def_delegators :@connector, :options, :complete_cb, :success_cb, :failure_cb, :send_request
+      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 = ::Protobuf.connector_type_class.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
+
+    end
+
+    ActiveSupport.run_load_hooks(:protobuf_rpc_client, Client)
+  end
+end

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

@@ -0,0 +1,221 @@
+require 'timeout'
+require 'protobuf/logging'
+require 'protobuf/rpc/rpc.pb'
+require 'protobuf/rpc/buffer'
+require 'protobuf/rpc/error'
+require 'protobuf/rpc/stat'
+
+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
+      }.freeze
+
+      class Base
+        include Protobuf::Logging
+
+        attr_reader :options, :error
+        attr_accessor :success_cb, :failure_cb, :complete_cb, :stats
+
+        def initialize(options)
+          @options = DEFAULT_OPTIONS.merge(options)
+          @stats = ::Protobuf::Rpc::Stat.new(:CLIENT)
+        end
+
+        def any_callbacks?
+          [@complete_cb, @failure_cb, @success_cb].any?
+        end
+
+        def close_connection
+          fail 'If you inherit a Connector from Base you must implement close_connection'
+        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
+          @stats.status = @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 first_alive_load_balance?
+          ENV.key?("PB_FIRST_ALIVE_LOAD_BALANCE") ||
+            options[:first_alive_load_balance]
+        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)
+          @stats.server = response_wrapper.server if response_wrapper.field?(:server)
+
+          # 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 ping_port
+          @ping_port ||= ENV["PB_RPC_PING_PORT"]
+        end
+
+        def ping_port_enabled?
+          ENV.key?("PB_RPC_PING_PORT")
+        end
+
+        def request_bytes
+          validate_request_type!
+          return ::Protobuf::Socketrpc::Request.encode(request_fields)
+        rescue => e
+          failure(:INVALID_REQUEST_PROTO, "Could not set request proto: #{e.message}")
+        end
+
+        def request_caller
+          @options[:client_host] || ::Protobuf.client_host
+        end
+
+        def request_fields
+          { :service_name => @options[:service].name,
+            :method_name => @options[:method].to_s,
+            :request_proto => @options[:request],
+            :caller => request_caller }
+        end
+
+        def send_request
+          fail 'If you inherit a Connector from Base you must implement send_request'
+        end
+
+        def setup_connection
+          initialize_stats
+          @request_data = request_bytes
+          @stats.request_size = @request_data.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