protobuf-cucumber 3.10.4

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

@@ -0,0 +1,50 @@
+# encoding: utf-8
+
+##
+# This file is auto-generated. DO NOT EDIT!
+#
+require 'protobuf'
+
+module Protobuf
+  module Rpc
+    module DynamicDiscovery
+      ::Protobuf::Optionable.inject(self) { ::Google::Protobuf::FileOptions }
+
+      ##
+      # Enum Classes
+      #
+      class BeaconType < ::Protobuf::Enum
+        define :HEARTBEAT, 0
+        define :FLATLINE, 1
+      end
+
+
+      ##
+      # Message Classes
+      #
+      class Server < ::Protobuf::Message; end
+      class Beacon < ::Protobuf::Message; end
+
+
+      ##
+      # Message Fields
+      #
+      class Server
+        optional :string, :uuid, 1
+        optional :string, :address, 2
+        optional :string, :port, 3
+        optional :int32, :ttl, 4
+        repeated :string, :services, 5
+      end
+
+      class Beacon
+        optional ::Protobuf::Rpc::DynamicDiscovery::BeaconType, :beacon_type, 1
+        optional ::Protobuf::Rpc::DynamicDiscovery::Server, :server, 2
+      end
+
+    end
+
+  end
+
+end
+

data/lib/protobuf/rpc/env.rb

@@ -0,0 +1,60 @@
+module Protobuf
+  module Rpc
+    class Env < Hash
+      # Creates an accessor that simply sets and reads a key in the hash:
+      #
+      #   class Config < Hash
+      #     hash_accessor :app
+      #   end
+      #
+      #   config = Config.new
+      #   config.app = Foo
+      #   config[:app] #=> Foo
+      #
+      #   config[:app] = Bar
+      #   config.app #=> Bar
+      #
+      def self.hash_accessor(*names) #:nodoc:
+        names.each do |name|
+          name_str = name.to_s.freeze
+
+          define_method name do
+            self[name_str]
+          end
+
+          define_method "#{name}=" do |value|
+            self[name_str] = value
+          end
+
+          define_method "#{name}?" do
+            !self[name_str].nil?
+          end
+        end
+      end
+
+      # TODO: Add extra info about the environment (i.e. variables) and other
+      # information that might be useful
+      hash_accessor :client_host,
+                    :encoded_request,
+                    :encoded_response,
+                    :log_signature,
+                    :method_name,
+                    :request,
+                    :request_type,
+                    :request_wrapper,
+                    :response,
+                    :response_type,
+                    :rpc_method,
+                    :rpc_service,
+                    :server,
+                    :service_name,
+                    :worker_id
+
+      def initialize(options = {})
+        merge!(options)
+
+        self['worker_id'] = ::Thread.current.object_id.to_s(16)
+      end
+    end
+  end
+end

data/lib/protobuf/rpc/error.rb

@@ -0,0 +1,28 @@
+require 'protobuf/rpc/rpc.pb'
+
+module Protobuf
+  module Rpc
+    ClientError = Struct.new("ClientError", :code, :message)
+
+    # Base PbError class for client and server errors
+    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) ? ::Protobuf::Socketrpc::ErrorReason.const_get(error_type) : error_type
+        super message
+      end
+
+      def encode
+        to_response.encode
+      end
+
+      def to_response
+        ::Protobuf::Socketrpc::Response.new(:error => message, :error_reason => error_type)
+      end
+    end
+  end
+end
+
+require 'protobuf/rpc/error/server_error'
+require 'protobuf/rpc/error/client_error'

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

@@ -0,0 +1,31 @@
+require 'protobuf/rpc/error'
+
+module Protobuf
+  module Rpc
+
+    class InvalidRequestProto < PbError
+      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')
+        super message, 'BAD_RESPONSE_PROTO'
+      end
+    end
+
+    class UnkownHost < PbError
+      def initialize(message = 'Unknown host or port')
+        super message, 'UNKNOWN_HOST'
+      end
+    end
+
+    class IOError < PbError
+      def initialize(message = 'IO Error occurred')
+        super message, 'IO_ERROR'
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,43 @@
+require 'protobuf/rpc/rpc.pb'
+
+module Protobuf
+  module Rpc
+
+    class BadRequestData < PbError
+      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')
+        super message, 'BAD_REQUEST_PROTO'
+      end
+    end
+
+    class ServiceNotFound < PbError
+      def initialize(message = 'Service class not found')
+        super message, 'SERVICE_NOT_FOUND'
+      end
+    end
+
+    class MethodNotFound < PbError
+      def initialize(message = 'Service method not found')
+        super message, 'METHOD_NOT_FOUND'
+      end
+    end
+
+    class RpcError < PbError
+      def initialize(message = 'RPC exception occurred')
+        super message, 'RPC_ERROR'
+      end
+    end
+
+    class RpcFailed < PbError
+      def initialize(message = 'RPC failed')
+        super message, 'RPC_FAILED'
+      end
+    end
+
+  end
+end

data/lib/protobuf/rpc/middleware.rb

@@ -0,0 +1,25 @@
+require 'middleware'
+
+require 'protobuf/rpc/middleware/exception_handler'
+require 'protobuf/rpc/middleware/logger'
+require 'protobuf/rpc/middleware/request_decoder'
+require 'protobuf/rpc/middleware/response_encoder'
+require 'protobuf/rpc/middleware/runner'
+
+module Protobuf
+  module Rpc
+    def self.middleware
+      @middleware ||= ::Middleware::Builder.new(:runner_class => ::Protobuf::Rpc::Middleware::Runner)
+    end
+
+    # Ensure the middleware stack is initialized
+    middleware
+  end
+
+  Rpc.middleware.use(Rpc::Middleware::ExceptionHandler)
+  Rpc.middleware.use(Rpc::Middleware::RequestDecoder)
+  Rpc.middleware.use(Rpc::Middleware::Logger)
+  Rpc.middleware.use(Rpc::Middleware::ResponseEncoder)
+
+  ActiveSupport.run_load_hooks(:protobuf_rpc_middleware, Rpc)
+end

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

@@ -0,0 +1,40 @@
+module Protobuf
+  module Rpc
+    module Middleware
+      class ExceptionHandler
+        include ::Protobuf::Logging
+
+        attr_reader :app
+
+        def initialize(app)
+          @app = app
+        end
+
+        def call(env)
+          dup._call(env)
+        end
+
+        def _call(env)
+          app.call(env)
+        rescue => exception
+          log_exception(exception)
+
+          # Rescue exceptions, re-wrap them as generic Protobuf errors,
+          # and encode them
+          env.response = wrap_exception(exception)
+          env.encoded_response = env.response.encode
+          env
+        end
+
+        private
+
+        # Wrap exceptions in a generic Protobuf errors unless they already are
+        #
+        def wrap_exception(exception)
+          exception = RpcFailed.new(exception.message) unless exception.is_a?(PbError)
+          exception
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,95 @@
+module Protobuf
+  module Rpc
+    module Middleware
+      class Logger
+        def initialize(app)
+          @app = app
+        end
+
+        # 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
+
+          env = @app.call(env)
+
+          instrumenter.stop
+          instrumenter.flush(env) # Log response stats
+
+          env
+        end
+
+        private
+
+        def instrumenter
+          @instrumenter ||= Instrumenter.new
+        end
+
+        # TODO: Replace this with ActiveSupport::Notifications and log subscribers
+        # TODO: Consider adopting Rails-style logging so we can track serialization
+        # time as well as ActiveRecord time, etc.:
+        #
+        #     Started GET "/" for 127.0.0.1 at 2014-02-12 09:40:29 -0700
+        #     Processing by ReleasesController#index as HTML
+        #       Rendered releases/_release.html.erb (0.0ms)
+        #       Rendered releases/_release.html.erb (0.0ms)
+        #       Rendered releases/_release.html.erb (0.0ms)
+        #       Rendered releases/_release.html.erb (0.0ms)
+        #       Rendered releases/index.html.erb within layouts/application (11.0ms)
+        #     Completed 200 OK in 142ms (Views: 117.6ms | ActiveRecord: 1.7ms)
+        #
+        class Instrumenter
+          attr_reader :env
+
+          def flush(env)
+            ::Protobuf::Logging.logger.info { to_s(env) }
+          end
+
+          def start
+            @start_time = ::Time.now.utc
+          end
+
+          def stop
+            @end_time = ::Time.now.utc
+          end
+
+          def to_s(env)
+            @env = env
+
+            [
+              "[SRV]",
+              env.client_host,
+              env.worker_id,
+              rpc,
+              sizes,
+              elapsed_time,
+              @end_time.try(:iso8601),
+            ].compact.join(' - ')
+          end
+
+          private
+
+          def elapsed_time
+            (@start_time && @end_time ? "#{(@end_time - @start_time).round(4)}s" : nil)
+          end
+
+          def rpc
+            env.service_name && env.method_name ? "#{env.service_name}##{env.method_name}" : nil
+          end
+
+          def sizes
+            if env.encoded_response?
+              "#{env.encoded_request.size}B/#{env.encoded_response.size}B"
+            else
+              "#{env.encoded_request.size}B/-"
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,79 @@
+module Protobuf
+  module Rpc
+    module Middleware
+      class RequestDecoder
+        include ::Protobuf::Logging
+
+        attr_reader :app, :env
+
+        def initialize(app)
+          @app = app
+        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
+          env.request_wrapper = request_wrapper
+          env.client_host = request_wrapper.caller
+
+          env.rpc_service = service
+          env.rpc_method = rpc_method
+          env.request_type = rpc_method.request_type
+          env.response_type = rpc_method.response_type
+
+          app.call(env)
+        end
+
+        def log_signature
+          env.log_signature || super
+        end
+
+        private
+
+        def method_name
+          return @method_name unless @method_name.nil?
+
+          @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 ||= rpc_method.request_type.decode(request_wrapper.request_proto)
+        rescue => exception
+          raise BadRequestData, "Unable to decode request: #{exception.message}"
+        end
+
+        # Decode the incoming request object into our expected request object
+        #
+        def request_wrapper
+          @request_wrapper ||= ::Protobuf::Socketrpc::Request.decode(env.encoded_request)
+        rescue => exception
+          raise BadRequestData, "Unable to decode request: #{exception.message}"
+        end
+
+        def rpc_method
+          @rpc_method ||= service.rpcs[method_name]
+        end
+
+        def service
+          @service ||= service_name.constantize
+        rescue NameError
+          raise ServiceNotFound, "Service class #{service_name} is not defined."
+        end
+
+        def service_name
+          @service_name ||= request_wrapper.service_name
+        end
+      end
+    end
+  end
+end