protobuf 2.2.5-java

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

@@ -0,0 +1,60 @@
+require 'protobuf/rpc/server'
+require 'protobuf/rpc/servers/zmq/util'
+module Protobuf
+  module Rpc
+    module Zmq
+
+      class Worker
+        include ::Protobuf::Rpc::Server
+        include ::Protobuf::Rpc::Zmq::Util
+
+        ##
+        # Constructor
+        #
+        def initialize(options = {})
+          host = options[:host]
+          port = options[:port]
+
+          @zmq_context = ::ZMQ::Context.new
+          @socket = @zmq_context.socket(::ZMQ::REP)
+          zmq_error_check(@socket.connect("tcp://#{resolve_ip(host)}:#{port}"))
+
+          @poller = ::ZMQ::Poller.new
+          @poller.register(@socket, ::ZMQ::POLLIN)
+        end
+
+        ##
+        # Instance Methods
+        #
+        def handle_request(socket)
+          @request_data = ''
+          zmq_error_check(socket.recv_string(@request_data))
+          log_debug { sign_message("handling request") } if !@request_data.nil?
+        end
+
+        def run
+          while ::Protobuf::Rpc::Zmq::Server.running? do
+            # poll for 1_000 milliseconds then continue looping
+            # This lets us see whether we need to die
+            @poller.poll(1_000)
+            @poller.readables.each do |socket|
+              initialize_request!
+              handle_request(socket)
+              handle_client unless @request_data.nil?
+            end
+          end
+        ensure
+          @socket.close
+          @zmq_context.terminate
+        end
+
+        def send_data
+          response_data = @response.is_a?(::Protobuf::Message) ? @response.serialize_to_string : @response.to_s
+          @stats.response_size = response_data.size
+          zmq_error_check(@socket.send_string(response_data))
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+module Protobuf
+  module Rpc
+    class ZmqRunner
+
+      def self.stop
+        Protobuf::Rpc::Zmq::Server.stop
+      end
+
+      def self.run(server)
+        server_config = case
+                        when server.is_a?(OpenStruct) then
+                          server.marshal_dump
+                        when server.respond_to?(:to_hash) then
+                          server.to_hash
+                        else
+                          raise "Cannot parser Zmq Server - server options"
+                        end
+
+				yield if block_given?
+        Protobuf::Rpc::Zmq::Server.run(server_config)
+      end
+    end
+
+  end
+end

data/lib/protobuf/rpc/service.rb

@@ -0,0 +1,173 @@
+require 'protobuf/logger'
+require 'protobuf/rpc/client'
+require 'protobuf/rpc/error'
+require 'protobuf/rpc/service_filters'
+
+module Protobuf
+  module Rpc
+
+    # Object to encapsulate the request/response types for a given service method
+    #
+    RpcMethod = Struct.new("RpcMethod", :method, :request_type, :response_type)
+
+    class Service
+      include Protobuf::Rpc::ServiceFilters
+      include Protobuf::Logger::LogMethods
+
+
+      attr_reader :response, :rpc
+
+      DEFAULT_HOST = '127.0.0.1'.freeze
+      DEFAULT_PORT = 9399
+
+      ##
+      # Class Methods
+      #
+
+      # Create a new client for the given service.
+      # See Client#initialize and ClientConnection::DEFAULT_OPTIONS
+      # for all available options.
+      #
+      def self.client(options = {})
+        ::Protobuf::Rpc::Client.new({ :service => self,
+                                      :host => host,
+                                      :port => port }.merge(options))
+      end
+
+      # Allows service-level configuration of location.
+      # Useful for system-startup configuration of a service
+      # so that any Clients using the Service.client sugar
+      # will not have to configure the location each time.
+      #
+      def self.configure(config = {})
+        self.host = config[:host] if config.key?(:host)
+        self.port = config[:port] if config.key?(:port)
+      end
+
+      # The host location of the service.
+      #
+      def self.host
+        @_host ||= DEFAULT_HOST
+      end
+
+      # The host location setter.
+      #
+      def self.host=(new_host)
+        @_host = new_host
+      end
+
+      # Shorthand call to configure, passing a string formatted as hostname:port
+      # e.g. 127.0.0.1:9933
+      # e.g. localhost:0
+      #
+      def self.located_at(location)
+        return if location.nil? || location.downcase.strip !~ /.+:\d+/
+        host, port = location.downcase.strip.split ':'
+        configure(:host => host, :port => port.to_i)
+      end
+
+      # The port of the service on the destination server.
+      #
+      def self.port
+        @_port ||= DEFAULT_PORT
+      end
+
+      # The port location setter.
+      #
+      def self.port=(new_port)
+        @_port = new_port
+      end
+
+      # Define an rpc method with the given request and response types.
+      # This methods is only used by the generated service definitions
+      # and not useful for user code.
+      #
+      def self.rpc(method, request_type, response_type)
+        rpcs[method] = RpcMethod.new(method, request_type, response_type)
+      end
+
+      # Hash containing the set of methods defined via `rpc`.
+      #
+      def self.rpcs
+        @_rpcs ||= {}
+      end
+
+      # Check if the given method name is a known rpc endpoint.
+      #
+      def self.rpc_method?(name)
+        rpcs.key?(name)
+      end
+
+
+      ##
+      # Instance Methods
+      #
+
+      # Initialize a service with the rpc endpoint name and the bytes
+      # for the request.
+      def initialize(rpc, request_bytes)
+        @rpc = rpc
+        @request_bytes = request_bytes
+      end
+
+      # Register a failure callback for use when rpc_failed is invoked.
+      #
+      def on_rpc_failed(callable)
+        @rpc_failed_callback ||= callable
+      end
+
+      # Response object for this rpc cycle. Not assignable.
+      #
+      def response
+        @_response ||= rpcs[@rpc].response_type.new
+      end
+
+      # Convenience method to get back to class method.
+      #
+      def rpc_method?(name)
+        self.class.rpc_method?(name)
+      end
+
+      # Convenience method to get back to class rpcs hash.
+      #
+      def rpcs
+        self.class.rpcs
+      end
+
+      # Get a callable object that will be used by the dispatcher
+      # to invoke the specified rpc method. Facilitates callback dispatch.
+      # The returned lambda is expected to be called at a later time (which
+      # is why we wrap the method call).
+      #
+      def callable_rpc_method(method_name)
+        lambda { run_filters(method_name) }
+      end
+
+      private
+
+      # Request object for this rpc cycle. Not assignable.
+      #
+      def request
+        @_request ||= rpcs[@rpc].request_type.new.parse_from_string(@request_bytes)
+      rescue => e
+        raise BadRequestProto, "Unable to parse request: #{e.message}"
+      end
+
+      # Sugar to make an rpc method feel like a controller method.
+      # If this method is not called, the response will be the memoized
+      # object returned by the response reader.
+      #
+      def respond_with(candidate)
+        @_response = candidate
+      end
+      alias_method :return_from_whence_you_came, :respond_with
+
+      # Automatically fail a service method.
+      #
+      def rpc_failed(message)
+        @rpc_failed_callback.call(message)
+      end
+
+    end
+  end
+end

data/lib/protobuf/rpc/service_dispatcher.rb

@@ -0,0 +1,130 @@
+require 'protobuf/logger'
+
+module Protobuf
+  module Rpc
+    class ServiceDispatcher
+
+      include ::Protobuf::Logger::LogMethods
+
+      attr_accessor :service, :service_klass, :callable_method, :outer_request
+      attr_accessor :definition, :response, :error
+
+      def initialize(wrapper_request)
+        self.error = nil
+        self.outer_request = wrapper_request
+
+        init_service
+        init_method if service_klass.present?
+        register_rpc_failed if service.present?
+      end
+
+      # Call the given service method. If we get to this point and an error
+      # has already occurred, do not invoke the method and simply respond.
+      #
+      def invoke!
+        unless error?
+          callable_method.call
+          validate_response
+        end
+
+        return error || response
+      end
+
+      # We're successful if the error is not populated.
+      #
+      def success?
+        error.nil?
+      end
+
+      # We're in error if the error is populated.
+      #
+      def error?
+        ! success?
+      end
+
+      private
+
+      def assign_error(error_klass, message)
+        self.error = error_klass.new(message)
+      end
+
+      # Prod the object to see if we can produce a proto object as a response
+      # candidate. Either way, return the candidate for validation.
+      def coerced_response
+        candidate = service.response
+
+        case
+        when candidate.is_a?(::Protobuf::Message) then
+          # no-op
+        when candidate.respond_to?(:to_proto) then
+          candidate = candidate.to_proto
+        when candidate.respond_to?(:to_proto_hash) then
+          candidate = definition.response_type.new(candidate.to_proto_hash)
+        when candidate.respond_to?(:to_hash) then
+          candidate = definition.response_type.new(candidate.to_hash)
+        end
+
+        candidate
+      end
+
+      # Get the method for the current request.
+      #
+      def init_method
+        method_name = outer_request.method_name.underscore.to_sym
+        if service_klass.rpc_method?(method_name)
+          self.service = service_klass.new(method_name, outer_request.request_proto)
+          self.callable_method = service.callable_rpc_method(method_name)
+          self.definition = service.rpcs[method_name]
+        else
+          assign_error(MethodNotFound, "#{service.class.name}##{method_name} is not a defined rpc method.")
+        end
+      rescue NameError => e
+        # FIXME I think this is no longer applicable since the method extract
+        # is now wrapped in a lambda (@see Service#callable_rpc_method).
+        log_exception(e)
+        assign_error(MethodNotFound, "#{service.class.name}##{method_name} is not implemented.")
+      end
+
+      # Constantize the service for this request. Initialization of the service
+      # happens when we verify that the method is callable for this service.
+      #
+      def init_service
+        self.service_klass = outer_request.service_name.constantize
+      rescue NameError => e
+        log_exception(e)
+        assign_error(ServiceNotFound, "Service class #{outer_request.service_name} is not defined.")
+      end
+
+      # Make sure we get rpc errors back.
+      #
+      def register_rpc_failed
+        service.on_rpc_failed(method(:rpc_failed_callback))
+      end
+
+      # Receive the failure message from the service. This method is registered
+      # as the callable to the service when an `rpc_failed` call is invoked.
+      #
+      def rpc_failed_callback(message)
+        assign_error(RpcFailed, (message.respond_to?(:message) ? message.message : message))
+        log_error { sign_message("RPC Failed: #{error.message}") }
+      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_response
+        candidate = coerced_response
+        expected = definition.response_type
+        actual = candidate.class
+
+        if expected == actual
+          self.response = candidate
+        else
+          assign_error(BadResponseProto, "Response proto changed from #{expected.name} to #{actual.name}")
+        end
+      end
+
+    end
+  end
+end
+

data/lib/protobuf/rpc/service_filters.rb

@@ -0,0 +1,267 @@
+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
+        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 }
+          raise 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)
+          return 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
+          return 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) { lambda { |service| return true } }
+          do_invoke = case
+                      when if_check.nil? then
+                        true
+                      else
+                        call_or_send(if_check)
+                      end
+
+          return 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
+          return 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) { lambda { |service| return false } }
+          skip_invoke = case
+                        when unless_check.nil? then
+                          false
+                        else
+                          call_or_send(unless_check)
+                        end
+
+          return ! 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
+
+          return 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 = lambda { __send__(rpc_method) }
+          filters[:around].reverse.inject(final) { |previous, filter|
+            if invoke_filter?(rpc_method, filter)
+              lambda { call_or_send(filter[:callable], &previous) }
+            else
+              previous
+            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
+              call_or_send(rescue_filters[ex.class], 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
+                           raise "Object #{callable} is not callable"
+                         end
+
+          return return_value
+        end
+
+      end
+
+    end
+  end
+end