protobuf 2.0.3 → 2.1.0

data/README.md

@@ -169,6 +169,69 @@ end
 
 This means that the client's `on_failure` callback will be invoked instead of the `on_success` callback. Read more below on client callbacks. One drawback to the `rpc_failed` approach is that it does not short-circuit the rest of the method. This means that you must explicitly return from the method if you do not wish the remainder to be executed.
 
+### Service Filters
+
+Service Filters provides ActionController-style filter support to service instances, specifically adding `before_filter`, `after_filter`, and `around_filter`.
+
+```ruby
+class Foo::UserService < ::Protobuf::Rpc::Service
+  before_filter :start_request_timer
+  after_filter :end_request_timer
+  around_filter :benchmark_request
+
+  # Provide a list of rpc methods to call (or exclude calling) for the given filter(s).
+  # The following two filters are essentially equivalent.
+  before_filter :verify_user_present, :only => [ :update, :delete ]
+  before_filter :verify_user_present, :except => [ :find, :create ]
+
+  # Using if/unless filters options to achieve the same goal, reporting a login after the login has been processed.
+  # Note that you can provide a method name or lambda, but you must return a boolean value.
+  after_filter :report_login, :only => :login, :if => :user_found?
+  after_filter :report_login, :only => :login, :if => lambda { |service| service.response.user_guid.present? }
+  after_filter :report_login, :only => :login, :unless => :user_missing?
+  after_filter :report_login, :only => :login, :unless => lambda { |service| service.response.user_guid.empty? }
+
+  #... rpc instance methods
+
+  private
+
+  def start_request_timer
+    @time_start = Time.now
+  end
+
+  def end_request_timer
+    @time_end = Time.now
+    log_info { ... }
+  end
+
+  def benchmark_request
+    Benchmark.benchmark do
+      yield
+    end
+  end
+end
+```
+
+#### Halting execution of rpc request inside a filter
+
+__Around Filters__ – Inside of an around filter, if you wish to halt request processing and return, simply do not `yield` the block. Since the filter is implemented as an instance method, you can use `rpc_failed` or `respond_with` just like you can in the endpoint methods.
+
+__Before Filters__ – Returning `false` from a before filter will cancel any other filter calls which would run afterwards, as well as canceling invocation of the service method. Note: You must actually return false, not just a "falsey" value such as nil.
+
+__After Filters__ – There is no request shortcutting since the after filter runs after the request. Duh.
+
+#### Filter options
+
+The following options can be applied to any of the filters as the final argument in the filter configuration. (See example above).
+
+__:if__ – The object supplied to `:if` can either be a symbol/string indicating the instance method to call, or, an object that responds to `call`. The method or callable should return true or false indicating if the filter should be invoked or not. Akin to the `if` keyword.
+
+__:unless__ – The opposite of the `:if` option is `:unless`. Accepts the same object types. The method or callable should return true or false indicating if the filter should be invoked or not. Akin to the `unless` keyword.
+
+__:only__ – A string/symbol or Array of strings/symbols values that reference instance methods. The names of these methods should be the rpc method you wish to invoke the filter for. Methods not identified in this list would not have the filter applied.
+
+__:except__ – The opposite of the `:only` option. A string/symbol or Array of strings/symbols values that reference instance methods. The names of these methods should be the rpc method you wish to skip invokation of the given filter. Methods not identified in this list would have the filter applied.
+
 ### Servers
 
 A service is nothing without being hooked up to a socket. It's the nerdy kid waiting by the telephone for someone to call without knowing that the phone company disconnected their house. Sad and pathetic. So hook the phone lines!

data/lib/protobuf/cli.rb

@@ -34,7 +34,6 @@ module Protobuf
     option :print_deprecation_warnings, :type => :boolean, :default => true, :desc => 'Cause use of deprecated fields to be printed or ignored.'
 
     def start(app_file)
-      puts 'RUNNING FROM LOCAL'
       debug_say 'Configuring the rpc_server process'
       @start_aborted = false
 
@@ -159,7 +158,7 @@ module Protobuf
         { :host => options.host,
           :port => options.port,
           :backlog => options.backlog,
-          :treshold => options.threshold,
+          :threshold => options.threshold,
           :threads => options.threads }
       end
 
@@ -168,6 +167,9 @@ module Protobuf
 
         ::Protobuf::Logger.error { message }
         if exception
+          $stderr.puts "[#{exception.class.name}] #{exception.message}" 
+          $stderr.puts exception.backtrace.join("\n")
+
           ::Protobuf::Logger.error { "[#{exception.class.name}] #{exception.message}" }
           ::Protobuf::Logger.debug { exception.backtrace.join("\n") }
         end

data/lib/protobuf/rpc/client.rb

@@ -103,14 +103,14 @@ module Protobuf
       #     c.on_failure {|err| ... }
       #   end
       #
-      def method_missing(method, *params)
+      def method_missing(method_name, *params)
         service = options[:service]
-        unless service.rpc_method?(method)
-          log_error { sign_message("#{service.name}##{method.to_s} not rpc method, passing to super") }
-          super(method, *params)
+        unless service.rpc_method?(method_name)
+          log_error { sign_message("#{service.name}##{method_name.to_s} not rpc method, passing to super") }
+          super(method_name, *params)
         else
-          log_debug { sign_message("#{service.name}##{method.to_s}") }
-          rpc = service.rpcs[method.to_sym]
+          log_debug { sign_message("#{service.name}##{method_name.to_s}") }
+          rpc = service.rpcs[method_name.to_sym]
 
           options[:request_type] = rpc.request_type
           log_debug { sign_message("Request Type: #{options[:request_type].name}") }
@@ -118,7 +118,7 @@ module Protobuf
           options[:response_type] = rpc.response_type
           log_debug { sign_message("Response Type: #{options[:response_type].name}") }
 
-          options[:method] = method.to_s
+          options[:method] = method_name.to_s
           options[:request] = params[0].is_a?(Hash) ? options[:request_type].new(params[0]) : params[0]
           log_debug { sign_message("Request Data: #{options[:request].inspect}") }
 

data/lib/protobuf/rpc/connectors/common.rb

@@ -51,7 +51,7 @@ module Protobuf
           @stats = Protobuf::Rpc::Stat.new(:CLIENT)
           @stats.server = [@options[:port], @options[:host]]
           @stats.service = @options[:service].name
-          @stats.method = @options[:method].to_s
+          @stats.method_name = @options[:method].to_s
         rescue => ex
           log_exception(ex)
           fail(:RPC_ERROR, "Invalid stats configuration. #{ex.message}")

data/lib/protobuf/rpc/service.rb

@@ -1,17 +1,21 @@
 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
+
+      attr_reader :response, :rpc
 
       DEFAULT_HOST = '127.0.0.1'.freeze
       DEFAULT_PORT = 9399
@@ -130,6 +134,15 @@ module Protobuf
         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.

data/lib/protobuf/rpc/service_dispatcher.rb

@@ -73,12 +73,14 @@ module Protobuf
         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.method(method_name)
+          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

data/lib/protobuf/rpc/service_filters.rb

@@ -0,0 +1,243 @@
+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
+
+        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
+
+        # 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)
+              rv = call_or_send(filter[:callable])
+              return false if stop_on_false_return && rv === 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)
+          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
+
+        # 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, &block)
+          rv = case
+               when callable.respond_to?(:call) then
+                 if callable.arity == 1
+                   callable.call(self, &block)
+                 else
+                   callable.call(&block)
+                 end
+               when respond_to?(callable, true) then
+                 if method(callable).arity == 1
+                   __send__(callable, self, &block)
+                 else
+                   __send__(callable, &block)
+                 end
+               else
+                 raise "Object #{callable} is not callable"
+               end
+
+          return rv
+        end
+
+      end
+
+    end
+  end
+end

data/lib/protobuf/rpc/stat.rb

@@ -5,7 +5,7 @@ module Protobuf
   module Rpc
     class Stat
       attr_accessor :mode, :start_time, :end_time, :request_size, :dispatcher
-      attr_accessor :response_size, :client, :server, :service, :method
+      attr_accessor :response_size, :client, :server, :service, :method_name
 
       MODES = [:SERVER, :CLIENT].freeze
 
@@ -22,8 +22,8 @@ module Protobuf
         @client ? "#{@client[:ip]}:#{@client[:port]}" : nil
       end
 
-      def method
-        @method ||= @dispatcher.try(:callable_method).try(:name)
+      def method_name
+        @method_name ||= @dispatcher.try(:service).try(:rpc)
       end
 
       def server=(peer)
@@ -52,7 +52,7 @@ module Protobuf
       end
 
       def rpc
-        service && method ? "#{service}##{method}" : nil
+        service && method_name ? "#{service}##{method_name}" : nil
       end
 
       def elapsed_time

data/lib/protobuf/version.rb

@@ -1,4 +1,4 @@
 module Protobuf
-  VERSION = '2.0.3'
+  VERSION = '2.1.0'
   PROTOC_VERSION = '2.4.1'
 end

data/spec/lib/protobuf/cli_spec.rb

@@ -23,7 +23,7 @@ describe ::Protobuf::CLI do
 
 			it 'sends the host option to the runner' do
 				::Protobuf::Rpc::SocketRunner.should_receive(:run) do |options|
-					options.host.should eq '123.123.123.123'
+					options[:host].should eq '123.123.123.123'
 				end
 				described_class.start(args)
 			end
@@ -34,7 +34,18 @@ describe ::Protobuf::CLI do
 
 			it 'sends the port option to the runner' do
 				::Protobuf::Rpc::SocketRunner.should_receive(:run) do |options|
-					options.port.should eq 12345
+					options[:port].should eq 12345
+				end
+				described_class.start(args)
+			end
+		end
+
+		context 'threads option' do
+			let(:test_args) { [ '--threads=500' ] }
+
+			it 'sends the threads option to the runner' do
+				::Protobuf::Rpc::SocketRunner.should_receive(:run) do |options|
+					options[:threads].should eq 500
 				end
 				described_class.start(args)
 			end
@@ -45,7 +56,7 @@ describe ::Protobuf::CLI do
 
 			it 'sends the backlog option to the runner' do
 				::Protobuf::Rpc::SocketRunner.should_receive(:run) do |options|
-					options.backlog.should eq 500
+					options[:backlog].should eq 500
 				end
 				described_class.start(args)
 			end
@@ -56,7 +67,7 @@ describe ::Protobuf::CLI do
 
 			it 'sends the backlog option to the runner' do
 				::Protobuf::Rpc::SocketRunner.should_receive(:run) do |options|
-					options.threshold.should eq 500
+					options[:threshold].should eq 500
 				end
 				described_class.start(args)
 			end

data/spec/lib/protobuf/message_spec.rb

@@ -96,6 +96,7 @@ describe Protobuf::Message do
 
     context 'when tag does not reference a field' do
       it 'returns nil' do
+        pending 'need to implement a range-limiting array sub-class for field access'
         subject.get_field_by_tag(-1).should be_nil
       end
     end

data/spec/lib/protobuf/rpc/service_dispatcher_spec.rb

@@ -18,7 +18,7 @@ describe Protobuf::Rpc::ServiceDispatcher do
 
   context 'creating a new dispatcher' do
     its(:service) { should be_instance_of service_name.constantize }
-    its(:callable_method) { should be_a(Method) }
+    its(:callable_method) { should respond_to(:call)}
     its(:outer_request) { should eq wrapper }
     its(:error) { should be_nil }
 

data/spec/lib/protobuf/rpc/service_filters_spec.rb

@@ -0,0 +1,356 @@
+require 'spec_helper'
+
+class FilterTest
+  include Protobuf::Rpc::ServiceFilters
+
+  attr_accessor :called
+
+  # Initialize the hash keys as instance vars
+  def initialize(ivar_hash)
+    @called = []
+    ivar_hash.each_pair do |key, value|
+      self.class.class_eval do
+        attr_accessor key
+      end
+      __send__("#{key}=", value)
+    end
+  end
+
+  def endpoint
+    @called << :endpoint
+  end
+
+  def self.clear_filters!
+    @defined_filters = nil
+    @filters = nil
+  end
+end
+
+describe Protobuf::Rpc::ServiceFilters do
+  subject { FilterTest.new(params) }
+  after(:each) { FilterTest.clear_filters! }
+
+  describe '#before_filter' do
+    let(:params) { { :before_filter_calls => 0 } }
+
+    before(:all) do
+      class FilterTest
+        private
+        def verify_before
+          @called << :verify_before
+          @before_filter_calls += 1
+        end
+
+        def foo
+          @called << :foo
+        end
+      end
+    end
+
+    before do
+      FilterTest.before_filter(:verify_before)
+      FilterTest.before_filter(:verify_before)
+      FilterTest.before_filter(:foo)
+    end
+
+    it 'calls filters in the order they were defined' do
+      subject.__send__(:run_filters, :endpoint)
+      subject.called.should eq [ :verify_before, :foo, :endpoint ]
+      subject.before_filter_calls.should eq 1
+    end
+
+    context 'when filter is configured with "only"' do
+      before(:all) do
+        class FilterTest
+          private
+          def endpoint_with_verify
+            @called << :endpoint_with_verify
+          end
+        end
+      end
+
+      before do
+        FilterTest.clear_filters!
+        FilterTest.before_filter(:verify_before, :only => :endpoint_with_verify)
+      end
+
+      context 'when invoking a method defined in "only" option' do
+        it 'invokes the filter' do
+          subject.__send__(:run_filters, :endpoint_with_verify)
+          subject.called.should eq [ :verify_before, :endpoint_with_verify ]
+        end
+      end
+
+      context 'when invoking a method not defined by "only" option' do
+        it 'does not invoke the filter' do
+          subject.__send__(:run_filters, :endpoint)
+          subject.called.should eq [ :endpoint ]
+        end
+      end
+    end
+
+    context 'when filter is configured with "except"' do
+      before(:all) do
+        class FilterTest
+          private
+          def endpoint_without_verify
+            @called << :endpoint_without_verify
+          end
+        end
+      end
+
+      before do
+        FilterTest.clear_filters!
+        FilterTest.before_filter(:verify_before, :except => :endpoint_without_verify)
+      end
+
+      context 'when invoking a method not defined in "except" option' do
+        it 'invokes the filter' do
+          subject.__send__(:run_filters, :endpoint)
+          subject.called.should eq [ :verify_before, :endpoint ]
+        end
+      end
+
+      context 'when invoking a method defined by "except" option' do
+        it 'does not invoke the filter' do
+          subject.__send__(:run_filters, :endpoint_without_verify)
+          subject.called.should eq [ :endpoint_without_verify ]
+        end
+      end
+    end
+
+    context 'when filter is configured with "if"' do
+      before(:all) do
+        class FilterTest
+          private
+          def check_true; return true; end
+          def check_false; return false; end
+          def verify_before; @called << :verify_before; end
+        end
+      end
+
+      context 'when "if" option is a method that returns true' do
+        before do
+          FilterTest.clear_filters!
+          FilterTest.before_filter(:verify_before, :if => :check_true)
+        end
+
+        it 'invokes the filter' do
+          subject.__send__(:run_filters, :endpoint)
+          subject.called.should eq [ :verify_before, :endpoint ]
+        end
+      end
+
+      context 'when "if" option is a callable that returns true' do
+        before do
+          FilterTest.clear_filters!
+          FilterTest.before_filter(:verify_before, :if => lambda { |service| true })
+        end
+
+        it 'invokes the filter' do
+          subject.__send__(:run_filters, :endpoint)
+          subject.called.should eq [ :verify_before, :endpoint ]
+        end
+      end
+
+      context 'when "if" option is a method that returns false' do
+        before do
+          FilterTest.clear_filters!
+          FilterTest.before_filter(:verify_before, :if => :check_false)
+        end
+
+        it 'skips the filter' do
+          subject.__send__(:run_filters, :endpoint)
+          subject.called.should eq [ :endpoint ]
+        end
+      end
+
+      context 'when "if" option is a callable that returns false' do
+        before do
+          FilterTest.clear_filters!
+          FilterTest.before_filter(:verify_before, :if => lambda { |service| false })
+        end
+
+        it 'skips the filter' do
+          subject.__send__(:run_filters, :endpoint)
+          subject.called.should eq [ :endpoint ]
+        end
+      end
+    end
+
+    context 'when filter is configured with "unless"' do
+      before(:all) do
+        class FilterTest
+          private
+          def check_true; return true; end
+          def check_false; return false; end
+          def verify_before; @called << :verify_before; end
+        end
+      end
+
+      context 'when "unless" option is a method that returns false' do
+        before do
+          FilterTest.clear_filters!
+          FilterTest.before_filter(:verify_before, :unless => :check_false)
+        end
+
+        it 'invokes the filter' do
+          subject.__send__(:run_filters, :endpoint)
+          subject.called.should eq [ :verify_before, :endpoint ]
+        end
+      end
+
+      context 'when "unless" option is a callable that returns true' do
+        before do
+          FilterTest.clear_filters!
+          FilterTest.before_filter(:verify_before, :unless => lambda { |service| false })
+        end
+
+        it 'invokes the filter' do
+          subject.__send__(:run_filters, :endpoint)
+          subject.called.should eq [ :verify_before, :endpoint ]
+        end
+      end
+
+      context 'when "unless" option is a method that returns false' do
+        before do
+          FilterTest.clear_filters!
+          FilterTest.before_filter(:verify_before, :unless => :check_true)
+        end
+
+        it 'skips the filter' do
+          subject.__send__(:run_filters, :endpoint)
+          subject.called.should eq [ :endpoint ]
+        end
+      end
+
+      context 'when "unless" option is a callable that returns false' do
+        before do
+          FilterTest.clear_filters!
+          FilterTest.before_filter(:verify_before, :unless => lambda { |service| true })
+        end
+
+        it 'skips the filter' do
+          subject.__send__(:run_filters, :endpoint)
+          subject.called.should eq [ :endpoint ]
+        end
+      end
+    end
+
+    context 'when filter returns false' do
+      before(:all) do
+        class FilterTest
+          private
+          def short_circuit_filter
+            @called << :short_circuit_filter
+            return false
+          end
+        end
+      end
+
+      before do
+        FilterTest.clear_filters!
+        FilterTest.before_filter(:short_circuit_filter)
+      end
+
+      it 'does not invoke the rpc method' do
+        subject.should_not_receive(:endpoint)
+        subject.__send__(:run_filters, :endpoint)
+        subject.called.should eq [ :short_circuit_filter ]
+      end
+    end
+  end
+
+  describe '#after_filter' do
+    let(:params) { { :after_filter_calls => 0 } }
+
+    before(:all) do
+      class FilterTest
+        private
+        def verify_after
+          @called << :verify_after
+          @after_filter_calls += 1
+        end
+
+        def foo
+          @called << :foo
+        end
+      end
+    end
+
+    before do
+      FilterTest.after_filter(:verify_after)
+      FilterTest.after_filter(:verify_after)
+      FilterTest.after_filter(:foo)
+    end
+
+    it 'calls filters in the order they were defined' do
+      subject.__send__(:run_filters, :endpoint)
+      subject.called.should eq [ :endpoint, :verify_after, :foo ]
+      subject.after_filter_calls.should eq 1
+    end
+  end
+
+  describe '#around_filter' do
+    let(:params) { {} }
+
+    before(:all) do
+      class FilterTest
+        private
+        def outer_around
+          @called << :outer_around_top
+          yield
+          @called << :outer_around_bottom
+        end
+
+        def inner_around
+          @called << :inner_around_top
+          yield
+          @called << :inner_around_bottom
+        end
+      end
+    end
+
+    before do
+      FilterTest.around_filter(:outer_around)
+      FilterTest.around_filter(:inner_around)
+      FilterTest.around_filter(:outer_around)
+      FilterTest.around_filter(:inner_around)
+    end
+
+    it 'calls filters in the order they were defined' do
+      subject.__send__(:run_filters, :endpoint)
+      subject.called.should eq([ :outer_around_top,
+                                 :inner_around_top,
+                                 :endpoint,
+                                 :inner_around_bottom,
+                                 :outer_around_bottom ])
+    end
+
+    context 'when around_filter does not yield' do
+      before do
+        class FilterTest
+          private
+          def inner_around
+            @called << :inner_around
+          end
+        end
+      end
+
+      before do
+        FilterTest.around_filter(:outer_around)
+        FilterTest.around_filter(:inner_around)
+      end
+
+      it 'cancels calling the rest of the filters and the endpoint' do
+        subject.should_not_receive(:endpoint)
+        subject.__send__(:run_filters, :endpoint)
+        subject.called.should eq([ :outer_around_top,
+                                   :inner_around,
+                                   :outer_around_bottom ])
+      end
+
+    end
+  end
+
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: protobuf
 version: !ruby/object:Gem::Version
-  version: 2.0.3
+  version: 2.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -10,11 +10,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-10-30 00:00:00.000000000 Z
+date: 2012-11-05 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
-  requirement: !ruby/object:Gem::Requirement
+  requirement: &2152184060 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -22,15 +22,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
+  version_requirements: *2152184060
 - !ruby/object:Gem::Dependency
   name: ffi
-  requirement: !ruby/object:Gem::Requirement
+  requirement: &2152179420 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -38,15 +33,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
+  version_requirements: *2152179420
 - !ruby/object:Gem::Dependency
   name: multi_json
-  requirement: !ruby/object:Gem::Requirement
+  requirement: &2152175780 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -54,15 +44,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
+  version_requirements: *2152175780
 - !ruby/object:Gem::Dependency
   name: thor
-  requirement: !ruby/object:Gem::Requirement
+  requirement: &2152173860 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -70,15 +55,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
+  version_requirements: *2152173860
 - !ruby/object:Gem::Dependency
   name: eventmachine
-  requirement: !ruby/object:Gem::Requirement
+  requirement: &2152172500 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -86,15 +66,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
+  version_requirements: *2152172500
 - !ruby/object:Gem::Dependency
   name: ffi-rzmq
-  requirement: !ruby/object:Gem::Requirement
+  requirement: &2152170080 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -102,15 +77,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
+  version_requirements: *2152170080
 - !ruby/object:Gem::Dependency
   name: perftools.rb
-  requirement: !ruby/object:Gem::Requirement
+  requirement: &2152151800 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -118,15 +88,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
+  version_requirements: *2152151800
 - !ruby/object:Gem::Dependency
   name: pry
-  requirement: !ruby/object:Gem::Requirement
+  requirement: &2152144100 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -134,15 +99,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
+  version_requirements: *2152144100
 - !ruby/object:Gem::Dependency
   name: pry-nav
-  requirement: !ruby/object:Gem::Requirement
+  requirement: &2152143260 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -150,15 +110,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
+  version_requirements: *2152143260
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: !ruby/object:Gem::Requirement
+  requirement: &2152142540 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -166,15 +121,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
+  version_requirements: *2152142540
 - !ruby/object:Gem::Dependency
   name: rake-compiler
-  requirement: !ruby/object:Gem::Requirement
+  requirement: &2152141860 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -182,15 +132,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
+  version_requirements: *2152141860
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: !ruby/object:Gem::Requirement
+  requirement: &2152140260 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -198,15 +143,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
+  version_requirements: *2152140260
 - !ruby/object:Gem::Dependency
   name: simplecov
-  requirement: !ruby/object:Gem::Requirement
+  requirement: &2152139460 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -214,15 +154,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
+  version_requirements: *2152139460
 - !ruby/object:Gem::Dependency
   name: yard
-  requirement: !ruby/object:Gem::Requirement
+  requirement: &2152138580 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -230,12 +165,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
+  version_requirements: *2152138580
 description: Google Protocol Buffers v2.4.1 Serialization and RPC implementation for
   Ruby.
 email:
@@ -413,6 +343,7 @@ files:
 - lib/protobuf/rpc/servers/zmq_runner.rb
 - lib/protobuf/rpc/service.rb
 - lib/protobuf/rpc/service_dispatcher.rb
+- lib/protobuf/rpc/service_filters.rb
 - lib/protobuf/rpc/stat.rb
 - lib/protobuf/socket.rb
 - lib/protobuf/version.rb
@@ -445,6 +376,7 @@ files:
 - spec/lib/protobuf/rpc/servers/zmq/util_spec.rb
 - spec/lib/protobuf/rpc/servers/zmq/worker_spec.rb
 - spec/lib/protobuf/rpc/service_dispatcher_spec.rb
+- spec/lib/protobuf/rpc/service_filters_spec.rb
 - spec/lib/protobuf/rpc/service_spec.rb
 - spec/lib/protobuf_spec.rb
 - spec/spec_helper.rb
@@ -514,7 +446,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -107413867811287521
+      hash: 2922389583391730892
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -523,12 +455,92 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -107413867811287521
+      hash: 2922389583391730892
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 1.8.15
 signing_key: 
 specification_version: 3
 summary: Google Protocol Buffers v2.4.1 Serialization and RPC implementation for Ruby.
-test_files: []
+test_files:
+- spec/benchmark/tasks.rb
+- spec/functional/embedded_service_spec.rb
+- spec/functional/evented_server_spec.rb
+- spec/functional/socket_server_spec.rb
+- spec/functional/zmq_server_spec.rb
+- spec/lib/protobuf/cli_spec.rb
+- spec/lib/protobuf/enum_spec.rb
+- spec/lib/protobuf/enum_value_spec.rb
+- spec/lib/protobuf/logger_spec.rb
+- spec/lib/protobuf/message/encoder_spec.rb
+- spec/lib/protobuf/message_spec.rb
+- spec/lib/protobuf/rpc/client_spec.rb
+- spec/lib/protobuf/rpc/connector_spec.rb
+- spec/lib/protobuf/rpc/connectors/base_spec.rb
+- spec/lib/protobuf/rpc/connectors/common_spec.rb
+- spec/lib/protobuf/rpc/connectors/socket_spec.rb
+- spec/lib/protobuf/rpc/connectors/zmq_spec.rb
+- spec/lib/protobuf/rpc/servers/evented_server_spec.rb
+- spec/lib/protobuf/rpc/servers/socket_server_spec.rb
+- spec/lib/protobuf/rpc/servers/zmq/broker_spec.rb
+- spec/lib/protobuf/rpc/servers/zmq/server_spec.rb
+- spec/lib/protobuf/rpc/servers/zmq/util_spec.rb
+- spec/lib/protobuf/rpc/servers/zmq/worker_spec.rb
+- spec/lib/protobuf/rpc/service_dispatcher_spec.rb
+- spec/lib/protobuf/rpc/service_filters_spec.rb
+- spec/lib/protobuf/rpc/service_spec.rb
+- spec/lib/protobuf_spec.rb
+- spec/spec_helper.rb
+- spec/support/all.rb
+- spec/support/server.rb
+- spec/support/test/enum.pb.rb
+- spec/support/test/enum.proto
+- spec/support/test/resource.pb.rb
+- spec/support/test/resource.proto
+- spec/support/test/resource_service.rb
+- spec/support/test_app_file.rb
+- spec/support/tolerance_matcher.rb
+- test/data/data.bin
+- test/data/data_source.py
+- test/data/types.bin
+- test/data/types_source.py
+- test/data/unk.png
+- test/proto/addressbook.pb.rb
+- test/proto/addressbook.proto
+- test/proto/addressbook_base.pb.rb
+- test/proto/addressbook_base.proto
+- test/proto/addressbook_ext.pb.rb
+- test/proto/addressbook_ext.proto
+- test/proto/collision.pb.rb
+- test/proto/collision.proto
+- test/proto/ext_collision.pb.rb
+- test/proto/ext_collision.proto
+- test/proto/ext_range.pb.rb
+- test/proto/ext_range.proto
+- test/proto/float_default.proto
+- test/proto/lowercase.pb.rb
+- test/proto/lowercase.proto
+- test/proto/merge.pb.rb
+- test/proto/merge.proto
+- test/proto/nested.pb.rb
+- test/proto/nested.proto
+- test/proto/optional_field.pb.rb
+- test/proto/optional_field.proto
+- test/proto/packed.pb.rb
+- test/proto/packed.proto
+- test/proto/rpc.proto
+- test/proto/types.pb.rb
+- test/proto/types.proto
+- test/test_addressbook.rb
+- test/test_enum_value.rb
+- test/test_extension.rb
+- test/test_lowercase.rb
+- test/test_message.rb
+- test/test_optional_field.rb
+- test/test_packed_field.rb
+- test/test_parse.rb
+- test/test_repeated_types.rb
+- test/test_serialize.rb
+- test/test_standard_message.rb
+- test/test_types.rb
 has_rdoc: