protobuf-cucumber 3.10.4

data/lib/protobuf/rpc/service_dispatcher.rb

@@ -0,0 +1,45 @@
+require 'protobuf/logging'
+
+module Protobuf
+  module Rpc
+    class ServiceDispatcher
+      include ::Protobuf::Logging
+
+      attr_reader :env
+
+      def initialize(_app)
+        # End of the line...
+      end
+
+      def call(env)
+        dup._call(env)
+      end
+
+      def _call(env)
+        @env = env
+
+        env.response = dispatch_rpc_request
+        env
+      end
+
+      def rpc_service
+        @rpc_service ||= env.rpc_service.new(env)
+      end
+
+      private
+
+      def dispatch_rpc_request
+        rpc_service.call(method_name)
+        rpc_service.response
+      end
+
+      def method_name
+        env.method_name
+      end
+
+      def service_name
+        env.service_name
+      end
+    end
+  end
+end

data/lib/protobuf/rpc/service_filters.rb

@@ -0,0 +1,250 @@
+module Protobuf
+  module Rpc
+    module ServiceFilters
+
+      def self.included(other)
+        other.class_eval do
+          extend Protobuf::Rpc::ServiceFilters::ClassMethods
+          include Protobuf::Rpc::ServiceFilters::InstanceMethods
+        end
+      end
+
+      module ClassMethods
+
+        [:after, :around, :before].each do |type|
+          # Setter DSL method for given filter types.
+          #
+          define_method "#{type}_filter" do |*args|
+            set_filters(type, *args)
+          end
+          alias_method "#{type}_action", "#{type}_filter"
+        end
+
+        # Filters hash keyed based on filter type (e.g. :before, :after, :around),
+        # whose values are Sets.
+        #
+        def filters
+          @filters ||= Hash.new { |h, k| h[k] = [] }
+        end
+
+        # Filters hash keyed based on filter type (e.g. :before, :after, :around),
+        # whose values are Sets.
+        #
+        def rescue_filters
+          @rescue_filters ||= {}
+        end
+
+        def rescue_from(*ex_klasses, &block)
+          options = ex_klasses.last.is_a?(Hash) ? ex_klasses.pop : {}
+          callable = options.delete(:with) { block }
+          fail ArgumentError, 'Option :with missing from rescue_from options' if callable.nil?
+          ex_klasses.each { |ex_klass| rescue_filters[ex_klass] = callable }
+        end
+
+        private
+
+        def define_filter(type, filter, options = {})
+          return if filter_defined?(type, filter)
+          filters[type] << options.merge(:callable => filter)
+          remember_filter(type, filter)
+        end
+
+        def defined_filters
+          @defined_filters ||= Hash.new { |h, k| h[k] = Set.new }
+        end
+
+        # Check to see if the filter has been defined.
+        #
+        def filter_defined?(type, filter)
+          defined_filters[type].include?(filter)
+        end
+
+        # Remember that we stored the filter.
+        #
+        def remember_filter(type, filter)
+          defined_filters[type] << filter
+        end
+
+        # Takes a list of actually (or potentially) callable objects.
+        # TODO: add support for if/unless
+        # TODO: add support for only/except sub-filters
+        #
+        def set_filters(type, *args)
+          options = args.last.is_a?(Hash) ? args.pop : {}
+          args.each do |filter|
+            define_filter(type, filter, options)
+          end
+        end
+
+      end
+
+      module InstanceMethods
+
+        private
+
+        # Get back to class filters.
+        #
+        def filters
+          self.class.filters
+        end
+
+        # Predicate which uses the filter options to determine if the filter
+        # should be called. Specifically checks the :if, :unless, :only, and :except
+        # options for every filter. Each option check is expected to return false
+        # if the filter should not be invoked, true if invocation should occur.
+        #
+        def invoke_filter?(rpc_method, filter)
+          invoke_via_only?(rpc_method, filter) &&
+            invoke_via_except?(rpc_method, filter) &&
+            invoke_via_if?(rpc_method, filter) &&
+            invoke_via_unless?(rpc_method, filter)
+        end
+
+        # If the target rpc endpoint method is listed under an :except option,
+        # return false to indicate that the filter should not be invoked. Any
+        # other target rpc endpoint methods not listed should be invoked.
+        # This option is the opposite of :only.
+        #
+        # Value should be a symbol/string or an array of symbols/strings.
+        #
+        def invoke_via_except?(rpc_method, filter)
+          except = [filter.fetch(:except) { [] }].flatten
+          except.empty? || !except.include?(rpc_method)
+        end
+
+        # Invoke the given :if callable (if any) and return its return value.
+        # Used by `invoke_filter?` which expects a true/false
+        # return value to determine if we should invoke the target filter.
+        #
+        # Value can either be a symbol/string indicating an instance method to call
+        # or an object that responds to `call`.
+        #
+        def invoke_via_if?(_rpc_method, filter)
+          if_check = filter.fetch(:if, nil)
+          return true if if_check.nil?
+          call_or_send(if_check)
+        end
+
+        # If the target rpc endpoint method is listed in the :only option,
+        # it should be invoked. Any target rpc endpoint methods not listed in this
+        # option should not be invoked. This option is the opposite of :except.
+        #
+        # Value should be a symbol/string or an array of symbols/strings.
+        #
+        def invoke_via_only?(rpc_method, filter)
+          only = [filter.fetch(:only) { [] }].flatten
+          only.empty? || only.include?(rpc_method)
+        end
+
+        # Invoke the given :unless callable (if any) and return the opposite
+        # of it's return value. Used by `invoke_filter?` which expects a true/false
+        # return value to determine if we should invoke the target filter.
+        #
+        # Value can either be a symbol/string indicating an instance method to call
+        # or an object that responds to `call`.
+        #
+        def invoke_via_unless?(_rpc_method, filter)
+          unless_check = filter.fetch(:unless, nil)
+          return true if unless_check.nil?
+          !call_or_send(unless_check)
+        end
+
+        def rescue_filters
+          self.class.rescue_filters
+        end
+
+        # Loop over the unwrapped filters and invoke them. An unwrapped filter
+        # is either a before or after filter, not an around filter.
+        #
+        def run_unwrapped_filters(unwrapped_filters, rpc_method, stop_on_false_return = false)
+          unwrapped_filters.each do |filter|
+            if invoke_filter?(rpc_method, filter)
+              return_value = call_or_send(filter[:callable])
+              return false if stop_on_false_return && return_value == false
+            end
+          end
+
+          true
+        end
+
+        # Reverse build a chain of around filters. To implement an around chain,
+        # simply build a method that yields control when it expects the underlying
+        # method to be invoked. If the endpoint should not be run (due to some
+        # condition), simply do not yield.
+        #
+        # Around filters are invoked in the order they are defined, outer to inner,
+        # with the inner-most method called being the actual rpc endpoint.
+        #
+        # Let's say you have a class defined with the following filters:
+        #
+        #   class MyService
+        #     around_filter :filter1, :filter2, :filter3
+        #
+        #     def my_endpoint
+        #       # do stuff
+        #     end
+        #   end
+        #
+        # When the my_endpoint method is invoked using Service#callable_rpc_method,
+        # It is similar to this call chain:
+        #
+        #   filter1 do
+        #     filter2 do
+        #       filter3 do
+        #         my_endpoint
+        #       end
+        #     end
+        #   end
+        #
+        def run_around_filters(rpc_method)
+          final = -> { __send__(rpc_method) }
+          filters[:around].reverse.reduce(final) do |previous, filter|
+            if invoke_filter?(rpc_method, filter)
+              -> { call_or_send(filter[:callable], &previous) }
+            else
+              previous
+            end
+          end.call
+        end
+
+        # Entry method to call each filter type in the appropriate order. This should
+        # be used instead of the other run methods directly.
+        #
+        def run_filters(rpc_method)
+          run_rescue_filters do
+            continue = run_unwrapped_filters(filters[:before], rpc_method, true)
+            if continue
+              run_around_filters(rpc_method)
+              run_unwrapped_filters(filters[:after], rpc_method)
+            end
+          end
+        end
+
+        def run_rescue_filters
+          if rescue_filters.keys.empty?
+            yield
+          else
+            begin
+              yield
+            rescue *rescue_filters.keys => ex
+              callable = rescue_filters.fetch(ex.class) do
+                mapped_klass = rescue_filters.keys.find { |child_klass| ex.class < child_klass }
+                rescue_filters[mapped_klass]
+              end
+
+              call_or_send(callable, ex)
+            end
+          end
+        end
+
+        # Call the object if it is callable, otherwise invoke the method using
+        # __send__ assuming that we respond_to it. Return the call's return value.
+        #
+        def call_or_send(callable, *args, &block)
+          return callable.call(self, *args, &block) if callable.respond_to?(:call)
+          __send__(callable, *args, &block)
+        end
+      end
+    end
+  end
+end

data/lib/protobuf/rpc/stat.rb

@@ -0,0 +1,119 @@
+require 'date'
+require 'time'
+require 'protobuf/logging'
+require 'protobuf/rpc/rpc.pb'
+
+module Protobuf
+  module Rpc
+    class Stat
+      attr_accessor :mode, :start_time, :end_time, :request_size, :dispatcher
+      attr_accessor :response_size, :client, :service, :method_name, :status
+      attr_reader   :server
+
+      MODES = [:SERVER, :CLIENT].freeze
+
+      ERROR_TRANSLATIONS = {
+        ::Protobuf::Socketrpc::ErrorReason::BAD_REQUEST_DATA => "BAD_REQUEST_DATA",
+        ::Protobuf::Socketrpc::ErrorReason::BAD_REQUEST_PROTO => "BAD_REQUEST_PROTO",
+        ::Protobuf::Socketrpc::ErrorReason::SERVICE_NOT_FOUND => "SERVICE_NOT_FOUND",
+        ::Protobuf::Socketrpc::ErrorReason::METHOD_NOT_FOUND => "METHOD_NOT_FOUND",
+        ::Protobuf::Socketrpc::ErrorReason::RPC_ERROR => "RPC_ERROR",
+        ::Protobuf::Socketrpc::ErrorReason::RPC_FAILED => "RPC_FAILED",
+        ::Protobuf::Socketrpc::ErrorReason::INVALID_REQUEST_PROTO => "INVALID_REQUEST_PROTO",
+        ::Protobuf::Socketrpc::ErrorReason::BAD_RESPONSE_PROTO => "BAD_RESPONSE_PROTO",
+        ::Protobuf::Socketrpc::ErrorReason::UNKNOWN_HOST => "UNKNOWN_HOST",
+        ::Protobuf::Socketrpc::ErrorReason::IO_ERROR => "IO_ERROR",
+      }.freeze
+
+      def initialize(mode = :SERVER)
+        @mode = mode
+        @request_size = 0
+        @response_size = 0
+        start
+      end
+
+      attr_writer :client
+
+      def client
+        @client || nil
+      end
+
+      def elapsed_time
+        (start_time && end_time ? "#{(end_time - start_time).round(4)}s" : nil)
+      end
+
+      def method_name
+        @method_name ||= @dispatcher.try(:service).try(:method_name)
+      end
+
+      def server=(peer)
+        case peer
+        when Array
+          @server = "#{peer[1]}:#{peer[0]}"
+        when String
+          @server = peer
+        end
+      end
+
+      def service
+        @service ||= @dispatcher.try(:service).class.name
+      end
+
+      def sizes
+        if stopped?
+          "#{@request_size}B/#{@response_size}B"
+        else
+          "#{@request_size}B/-"
+        end
+      end
+
+      def start
+        @start_time ||= ::Time.now
+      end
+
+      def stop
+        start unless @start_time
+        @end_time ||= ::Time.now
+      end
+
+      def stopped?
+        !end_time.nil?
+      end
+
+      def rpc
+        service && method_name ? "#{service}##{method_name}" : nil
+      end
+
+      def server?
+        @mode == :SERVER
+      end
+
+      def client?
+        @mode == :CLIENT
+      end
+
+      def status_string
+        return "OK" if status.nil?
+
+        ERROR_TRANSLATIONS.fetch(status, "UNKNOWN_ERROR")
+      end
+
+      def to_s
+        [
+          server? ? "[SRV]" : "[CLT]",
+          server? ? client : server,
+          trace_id,
+          rpc,
+          sizes,
+          elapsed_time,
+          status_string,
+          @end_time.try(:iso8601),
+        ].compact.join(' - ')
+      end
+
+      def trace_id
+        ::Thread.current.object_id.to_s(16)
+      end
+    end
+  end
+end

data/lib/protobuf/socket.rb

@@ -0,0 +1,21 @@
+##
+## Socket Mode
+##
+#
+# Require this file if you wish to run your server and/or client RPC
+# with the raw socket handlers. This is the default run mode for bin/rpc_server.
+#
+# To run with rpc_server either omit any mode switches, or explicitly pass `socket`:
+#
+#   rpc_server myapp.rb
+#   rpc_server --socket myapp.rb
+#
+# To run for client-side only override the require in your Gemfile:
+#
+#   gem 'protobuf', :require => 'protobuf/socket'
+#
+require 'protobuf'
+require 'protobuf/rpc/servers/socket/server'
+require 'protobuf/rpc/connectors/socket'
+
+::Protobuf.connector_type_class = ::Protobuf::Rpc::Connectors::Socket

data/lib/protobuf/tasks.rb

@@ -0,0 +1 @@
+load 'protobuf/tasks/compile.rake'

data/lib/protobuf/tasks/compile.rake

@@ -0,0 +1,80 @@
+require "fileutils"
+
+namespace :protobuf do
+
+  desc "Clean & Compile the protobuf source to ruby classes. Pass PB_NO_CLEAN=1 if you do not want to force-clean first."
+  task :compile, [:package, :source, :destination, :plugin, :file_extension] do |_tasks, args|
+    binpath = ::File.expand_path("../../../../bin", __FILE__)
+
+    args.with_defaults(:destination => "lib")
+    args.with_defaults(:source => "definitions")
+    args.with_defaults(:plugin => "protoc-gen-ruby-protobuf=#{binpath}/protoc-gen-ruby")
+    args.with_defaults(:file_extension => ".pb.rb")
+
+    # The local Ruby generator collides with the builtin Ruby generator
+    #
+    # From the protoc docs:
+    #
+    #   --plugin=EXECUTABLE
+    #
+    #   ...EXECUTABLE may be of the form NAME=PATH, in which case the given plugin name
+    #   is mapped to the given executable even if the executable"s own name differs.
+    #
+    # Use the NAME=PATH form to specify an alternative plugin name that avoids the name collision
+    #
+    plugin_name, _plugin_path = args[:plugin].split("=")
+
+    # The plugin name MUST have the protoc-gen- prefix in order to work, but that prefix is dropped
+    # when using the plugin to generate definitions
+    plugin_name.gsub!("protoc-gen-", "")
+
+    unless do_not_clean?
+      force_clean!
+      ::Rake::Task[:clean].invoke(args[:package], args[:destination], args[:file_extension])
+    end
+
+    command = []
+    command << "protoc"
+    command << "--plugin=#{args[:plugin]}"
+    command << "--#{plugin_name}_out=#{args[:destination]}"
+    command << "-I #{args[:source]}"
+    command << Dir["#{args[:source]}/#{args[:package]}/**/*.proto"].join(" ")
+    full_command = command.join(" ")
+
+    puts full_command
+    system(full_command)
+  end
+
+  desc "Clean the generated *.pb.rb files from the destination package. Pass PB_FORCE_CLEAN=1 to skip confirmation step."
+  task :clean, [:package, :destination, :file_extension] do |_task, args|
+    args.with_defaults(:destination => "lib")
+    args.with_defaults(:file_extension => ".pb.rb")
+
+    file_extension = args[:file_extension].sub(/\*?\.+/, "")
+    files_to_clean = ::File.join(args[:destination], args[:package], "**", "*.#{file_extension}")
+
+    if force_clean? || permission_to_clean?(files_to_clean)
+      ::Dir.glob(files_to_clean).each do |file|
+        ::FileUtils.rm(file)
+      end
+    end
+  end
+
+  def do_not_clean?
+    ! ::ENV.key?("PB_NO_CLEAN")
+  end
+
+  def force_clean?
+    ::ENV.key?("PB_FORCE_CLEAN")
+  end
+
+  def force_clean!
+    ::ENV["PB_FORCE_CLEAN"] = "1"
+  end
+
+  def permission_to_clean?(files_to_clean)
+    puts "Do you really want to remove files matching pattern #{files_to_clean}? (y/n)"
+    ::STDIN.gets.chomp =~ /y(es)?/i
+  end
+
+end