prepor-protobuf 3.5.0

data/lib/protobuf/rpc/service_dispatcher.rb

@@ -0,0 +1,46 @@
+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)
+        @env = env
+
+        env.response = dispatch_rpc_request
+        env
+      end
+
+      def rpc_service
+        @rpc_service ||= env.rpc_service.new(env)
+      end
+
+      private
+
+      # Call the given service method.
+      def dispatch_rpc_request
+        unless rpc_service.respond_to?(method_name)
+          fail MethodNotFound, "#{service_name}##{method_name} is not a publicly defined method."
+        end
+
+        rpc_service.callable_rpc_method(method_name).call
+        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,272 @@
+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) { ->(_service) { return true } }
+          do_invoke = case
+                      when if_check.nil? then
+                        true
+                      else
+                        call_or_send(if_check)
+                      end
+
+          do_invoke
+        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) { ->(_service) { return false } }
+          skip_invoke = case
+                        when unless_check.nil? then
+                          false
+                        else
+                          call_or_send(unless_check)
+                        end
+
+          !skip_invoke
+        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_value = case
+                         when callable.respond_to?(:call) then
+                           callable.call(self, *args, &block)
+                         when respond_to?(callable, true) then
+                           __send__(callable, *args, &block)
+                         else
+                           fail "Object #{callable} is not callable"
+                         end
+
+          return_value
+        end
+
+      end
+
+    end
+  end
+end

data/lib/protobuf/rpc/stat.rb

@@ -0,0 +1,97 @@
+require 'date'
+require 'time'
+require 'protobuf/logging'
+
+module Protobuf
+  module Rpc
+    class Stat
+      attr_accessor :mode, :start_time, :end_time, :request_size, :dispatcher
+      attr_accessor :response_size, :client, :server, :service, :method_name
+
+      MODES = [:SERVER, :CLIENT].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)
+        @server = { :port => peer[0], :ip => peer[1] }
+      end
+
+      def server
+        @server ? "#{@server[:ip]}:#{@server[:port]}" : nil
+      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 to_s
+        [
+          server? ? "[SRV]" : "[CLT]",
+          server? ? client : server,
+          trace_id,
+          rpc,
+          sizes,
+          elapsed_time,
+          @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'
+::Protobuf.connector_type = :socket
+
+require 'protobuf/rpc/servers/socket/server'
+require '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,61 @@
+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|
+    args.with_defaults(:destination => 'lib')
+    args.with_defaults(:source => 'definitions')
+    args.with_defaults(:plugin => 'ruby')
+    args.with_defaults(:file_extension => '.pb.rb')
+
+    unless do_not_clean?
+      force_clean!
+      ::Rake::Task[:clean].invoke(args[:package], args[:destination], args[:file_extension])
+    end
+
+    command = []
+    command << "protoc"
+    command << "--#{args[:plugin]}_out=#{args[:destination]}"
+    command << "-I #{args[:source]}"
+    command << "#{args[:source]}/#{args[:package]}/*.proto"
+    command << "#{args[:source]}/#{args[:package]}/**/*.proto"
+    full_command = command.join(' ')
+
+    puts full_command
+    exec(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