protobuf-cucumber 3.10.4

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

@@ -0,0 +1,83 @@
+module Protobuf
+  module Rpc
+    module Middleware
+      class ResponseEncoder
+        include ::Protobuf::Logging
+
+        attr_reader :app, :env
+
+        def initialize(app)
+          @app = app
+        end
+
+        def call(env)
+          dup._call(env)
+        end
+
+        def _call(env)
+          @env = app.call(env)
+
+          env.response = response
+          env.encoded_response = encoded_response
+          env
+        end
+
+        def log_signature
+          env.log_signature || super
+        end
+
+        private
+
+        # Encode the response wrapper to return to the client
+        #
+        def encoded_response
+          logger.debug { sign_message("Encoding response: #{response.inspect}") }
+
+          env.encoded_response = wrapped_response.encode
+        rescue => exception
+          log_exception(exception)
+
+          # Rescue encoding exceptions, re-wrap them as generic protobuf errors,
+          # and re-raise them
+          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
+          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)
+          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
+        end
+
+        # The middleware stack returns either an error or response proto. Package
+        # it up so that it's in the correct spot in the response wrapper
+        #
+        def wrapped_response
+          if response.is_a?(::Protobuf::Rpc::PbError)
+            ::Protobuf::Socketrpc::Response.new(:error => response.message, :error_reason => response.error_type, :server => env.server)
+          else
+            ::Protobuf::Socketrpc::Response.new(:response_proto => response.encode, :server => env.server)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+require 'middleware/runner'
+
+module Protobuf
+  module Rpc
+    module Middleware
+      class Runner < ::Middleware::Runner
+        # Override the default middleware runner so we can ensure that the
+        # service dispatcher is the last thing called in the stack.
+        #
+        def initialize(stack)
+          stack << Protobuf::Rpc::ServiceDispatcher
+
+          super(stack)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+# encoding: utf-8
+
+##
+# This file is auto-generated. DO NOT EDIT!
+#
+require 'protobuf'
+
+module Protobuf
+  module Socketrpc
+    ::Protobuf::Optionable.inject(self) { ::Google::Protobuf::FileOptions }
+
+    ##
+    # Enum Classes
+    #
+    class ErrorReason < ::Protobuf::Enum
+      define :BAD_REQUEST_DATA, 0
+      define :BAD_REQUEST_PROTO, 1
+      define :SERVICE_NOT_FOUND, 2
+      define :METHOD_NOT_FOUND, 3
+      define :RPC_ERROR, 4
+      define :RPC_FAILED, 5
+      define :INVALID_REQUEST_PROTO, 6
+      define :BAD_RESPONSE_PROTO, 7
+      define :UNKNOWN_HOST, 8
+      define :IO_ERROR, 9
+    end
+
+
+    ##
+    # Message Classes
+    #
+    class Request < ::Protobuf::Message; end
+    class Response < ::Protobuf::Message; end
+    class Header < ::Protobuf::Message; end
+
+
+    ##
+    # Message Fields
+    #
+    class Request
+      required :string, :service_name, 1
+      required :string, :method_name, 2
+      optional :bytes, :request_proto, 3
+      optional :string, :caller, 4
+      repeated ::Protobuf::Socketrpc::Header, :headers, 5
+    end
+
+    class Response
+      optional :bytes, :response_proto, 1
+      optional :string, :error, 2
+      optional :bool, :callback, 3, :default => false
+      optional ::Protobuf::Socketrpc::ErrorReason, :error_reason, 4
+      optional :string, :server, 5
+    end
+
+    class Header
+      required :string, :key, 1
+      optional :string, :value, 2
+    end
+
+  end
+
+end
+

data/lib/protobuf/rpc/rpc_method.rb

@@ -0,0 +1,16 @@
+module Protobuf
+  module Rpc
+    class RpcMethod
+      ::Protobuf::Optionable.inject(self, false) { ::Google::Protobuf::MethodOptions }
+
+      attr_reader :method, :request_type, :response_type
+
+      def initialize(method, request_type, response_type, &options_block)
+        @method = method
+        @request_type = request_type
+        @response_type = response_type
+        instance_eval(&options_block) if options_block
+      end
+    end
+  end
+end

data/lib/protobuf/rpc/server.rb

@@ -0,0 +1,39 @@
+require 'protobuf'
+require 'protobuf/logging'
+require 'protobuf/rpc/rpc.pb'
+require 'protobuf/rpc/buffer'
+require 'protobuf/rpc/env'
+require 'protobuf/rpc/error'
+require 'protobuf/rpc/middleware'
+require 'protobuf/rpc/service_dispatcher'
+
+module Protobuf
+  module Rpc
+    module Server
+      def gc_pause
+        ::GC.disable if ::Protobuf.gc_pause_server_request?
+
+        yield
+
+        ::GC.enable if ::Protobuf.gc_pause_server_request?
+      end
+
+      # Invoke the service method dictated by the proto wrapper request object
+      #
+      def handle_request(request_data, env_data = {})
+        # Create an env object that holds different parts of the environment and
+        # is available to all of the middlewares
+        env = Env.new(env_data.merge('encoded_request' => request_data, 'log_signature' => log_signature))
+
+        # Invoke the middleware stack, the last of which is the service dispatcher
+        env = Rpc.middleware.call(env)
+
+        env.encoded_response
+      end
+
+      def log_signature
+        @_log_signature ||= "[server-#{self.class.name}]"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,121 @@
+require 'set'
+
+require 'protobuf/rpc/servers/socket/worker'
+
+module Protobuf
+  module Rpc
+    module Socket
+      class Server
+        include ::Protobuf::Logging
+
+        AUTO_COLLECT_TIMEOUT = 5 # seconds
+
+        private
+
+        attr_accessor :threshold, :host, :port, :backlog
+        attr_writer :running
+
+        public
+
+        attr_reader :running
+        alias :running? running
+
+        def initialize(options)
+          self.running = false
+          self.host = options.fetch(:host)
+          self.port = options.fetch(:port)
+          self.backlog = options.fetch(:backlog, 100)
+          self.threshold = options.fetch(:threshold, 100)
+        end
+
+        def threads
+          @threads ||= []
+        end
+
+        def working
+          @working ||= Set.new
+        end
+
+        def cleanup?
+          # every `threshold` connections run a cleanup routine after closing the response
+          !threads.empty? && threads.size % threshold == 0
+        end
+
+        def cleanup_threads
+          logger.debug { sign_message("Thread cleanup - #{threads.size} - start") }
+
+          threads.delete_if do |hash|
+            unless (thread = hash.fetch(:thread)).alive?
+              thread.join
+              working.delete(hash.fetch(:socket))
+            end
+          end
+
+          logger.debug { sign_message("Thread cleanup - #{threads.size} - complete") }
+        end
+
+        def log_signature
+          @_log_signature ||= "[server-#{self.class.name}]"
+        end
+
+        def new_worker(socket)
+          Thread.new(socket) do |sock|
+            ::Protobuf::Rpc::Socket::Worker.new(sock, &:close)
+          end
+        end
+
+        def run
+          logger.debug { sign_message("Run") }
+
+          server = ::TCPServer.new(host, port)
+          fail "The server was unable to start properly." if server.closed?
+
+          begin
+            server.listen(backlog)
+            listen_fds = [server]
+            self.running = true
+
+            while running?
+              logger.debug { sign_message("Waiting for connections") }
+              ready_cnxns = begin
+                IO.select(listen_fds, [], [], AUTO_COLLECT_TIMEOUT)
+              rescue IOError
+                nil
+              end
+
+              if ready_cnxns
+                ready_cnxns.first.each do |client|
+                  case
+                  when !running?
+                    # no-op
+                  when client == server
+                    logger.debug { sign_message("Accepted new connection") }
+                    client, _sockaddr = server.accept
+                    listen_fds << client
+                  else
+                    unless working.include?(client)
+                      working << listen_fds.delete(client)
+                      logger.debug { sign_message("Working") }
+                      threads << { :thread => new_worker(client), :socket => client }
+
+                      cleanup_threads if cleanup?
+                    end
+                  end
+                end
+              elsif threads.size > 1
+                # Run a cleanup if select times out while waiting
+                cleanup_threads
+              end
+            end
+          ensure
+            server.close
+          end
+        end
+
+        def stop
+          self.running = false
+        end
+      end
+    end
+  end
+end

data/lib/protobuf/rpc/servers/socket/worker.rb

@@ -0,0 +1,56 @@
+require 'protobuf/rpc/server'
+require 'protobuf/logging'
+
+module Protobuf
+  module Rpc
+    module Socket
+      class Worker
+        include ::Protobuf::Rpc::Server
+        include ::Protobuf::Logging
+
+        def initialize(sock, &complete_cb)
+          @socket = sock
+          @complete_cb = complete_cb
+
+          data = read_data
+          return unless data
+
+          gc_pause do
+            encoded_response = handle_request(data)
+            send_data(encoded_response)
+          end
+        end
+
+        def read_data
+          size_io = StringIO.new
+
+          until (size_reader = @socket.getc) == "-"
+            size_io << size_reader
+          end
+          str_size_io = size_io.string
+
+          @socket.read(str_size_io.to_i)
+        end
+
+        def send_data(data)
+          fail 'Socket closed unexpectedly' unless socket_writable?
+          response_buffer = Protobuf::Rpc::Buffer.new(:write)
+          response_buffer.set_data(data)
+
+          @socket.write(response_buffer.write)
+          @socket.flush
+
+          @complete_cb.call(@socket)
+        end
+
+        def log_signature
+          @_log_signature ||= "[server-#{self.class}-#{object_id}]"
+        end
+
+        def socket_writable?
+          ! @socket.nil? && ! @socket.closed?
+        end
+      end
+    end
+  end
+end

data/lib/protobuf/rpc/servers/socket_runner.rb

@@ -0,0 +1,46 @@
+module Protobuf
+  module Rpc
+    class SocketRunner
+
+      private
+
+      attr_accessor :server
+
+      public
+
+      def initialize(options)
+        options = case
+                  when options.is_a?(OpenStruct) then
+                    options.marshal_dump
+                  when options.respond_to?(:to_hash) then
+                    options.to_hash.symbolize_keys
+                  else
+                    fail "Cannot parser Socket Server - server options"
+                  end
+
+        self.server = ::Protobuf::Rpc::Socket::Server.new(options)
+      end
+
+      def run
+        yield if block_given?
+        server.run
+      end
+
+      def running?
+        server.running?
+      end
+
+      def stop
+        server.stop
+      end
+    end
+  end
+end
+
+module Protobuf
+  module Rpc
+    module Servers # bad file namespacing
+      SocketRunner = ::Protobuf::Rpc::SocketRunner
+    end
+  end
+end