protobuf 1.1.0.beta1 → 1.1.0.beta2

data/Gemfile

@@ -1,3 +1,3 @@
 source :rubygems
 
-gemspec
+gemspec

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    protobuf (1.1.0.beta1)
+    protobuf (1.1.0.beta2)
       eventmachine (~> 0.12.10)
       eventually (~> 0.1.0)
       json_pure (~> 1.6.4)

data/Rakefile

@@ -1 +1,5 @@
+$:.push File.expand_path("./", File.dirname(__FILE__))
+$:.push File.expand_path("./spec", File.dirname(__FILE__))
+
 require "bundler/gem_tasks"
+require "benchmark/tasks"

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

@@ -11,8 +11,8 @@ module Protobuf
       DEFAULT_OPTIONS = {
         :service        => nil,           # Service to invoke
         :method         => nil,           # Service method to call
-        :host           => 'localhost',   # A default host (usually overridden)
-        :port           => '9938',        # A default port (usually overridden)
+        :host           => '127.0.0.1',   # A default host (usually overridden)
+        :port           => '9399',        # A default port (usually overridden)
         :request        => nil,           # The request object sent by the client
         :request_type   => nil,           # The request type expected by the client
         :response_type  => nil,           # The response type expected by the client

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

@@ -5,12 +5,12 @@ module Protobuf
   module Rpc
     module Connectors
       class EventMachine < Base
-        
+
         def send_request
           ensure_em_running do 
             f = Fiber.current
- 
-            EM.schedule do
+
+            EM.next_tick do
               log_debug "[#{log_signature}] Scheduling EventMachine client request to be created on next tick"
               cnxn = EMClient.connect(options, &ensure_cb)
               cnxn.on_success(&success_cb) if success_cb
@@ -22,7 +22,7 @@ module Protobuf
             async? ? true : set_timeout_and_validate_fiber
           end
         end
-        
+
         # Returns a callable that ensures any errors will be returned to the client
         # 
         # If a failure callback was set, just use that as a direct assignment
@@ -36,11 +36,20 @@ module Protobuf
         def log_signature
           @log_signature ||= "client-#{self.class}"
         end
-      
+
         private
 
         def ensure_em_running(&blk)
-          EM.reactor_running? ? yield : EM.fiber_run { blk.call; EM.stop }
+          if EM.reactor_running? 
+            @global_reactor = true
+            yield
+          else 
+            @global_reactor = false
+            EM.fiber_run do 
+              blk.call
+              EM.stop
+            end
+          end
         end
 
         def resume_fiber(fib)
@@ -54,6 +63,7 @@ module Protobuf
           message = 'Synchronous client failed: %s' % ex.message
           err = Protobuf::Rpc::ClientError.new(Protobuf::Socketrpc::ErrorReason::RPC_ERROR, message)
           ensure_cb.call(err)
+          EM.stop if !@global_reactor
         end
 
         def set_timeout_and_validate_fiber
@@ -61,6 +71,7 @@ module Protobuf
             message = 'Client timeout of %d seconds expired' % @options[:timeout]
             err = Protobuf::Rpc::ClientError.new(Protobuf::Socketrpc::ErrorReason::RPC_ERROR, message)
             ensure_cb.call(err)
+            EM.stop if !@global_reactor
           end
 
           Fiber.yield
@@ -68,7 +79,8 @@ module Protobuf
           message = "Synchronous calls must be in 'EM.fiber_run' block" 
           err = Protobuf::Rpc::ClientError.new(Protobuf::Socketrpc::ErrorReason::RPC_ERROR, message)
           ensure_cb.call(err)
-        end
+          EM.stop if !@global_reactor
+       end
 
       end
     end

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

@@ -61,7 +61,6 @@ module Protobuf
         def send_data(data)
           @socket.write(data)
           @socket.flush
-          @socket.close_write
           log_debug "[client-#{self.class}] write closed" 
         end
 

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

@@ -9,7 +9,6 @@ module Protobuf
       # Initialize a new read buffer for storing client request info
       def post_init
         log_debug '[server] Post init, new read buffer created'
-        
         @stats = Protobuf::Rpc::Stat.new(:SERVER, true)
         @stats.client = Socket.unpack_sockaddr_in(get_peername)
         

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

@@ -9,7 +9,18 @@ module Protobuf
 
       def self.run(server)
         Protobuf::Logger.info "SocketServer Running"
-        Protobuf::Rpc::SocketServer.run(server.host, server.port, server.backlog, server.threshold) if !Protobuf::Rpc::SocketServer.running?
+        server_config = case 
+                        when server.is_a?(OpenStruct) then 
+                          server.marshal_dump
+                        when server.is_a?(Hash) then
+                          server
+                        when server.respond_to?(:to_hash) then
+                          server.to_hash
+                        else
+                          raise "Cannot parser Socket Server - server options"
+                        end
+
+        Protobuf::Rpc::SocketServer.run(server_config)
       end
     end
 

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

@@ -6,96 +6,97 @@ module Protobuf
       include Protobuf::Rpc::Server
       include Protobuf::Logger::LogMethods
 
-      class << self
 
-        def cleanup? 
-          # every 10 connections run a cleanup routine after closing the response
-          @threads.size > (@thread_threshold - 1) && (@threads.size % @thread_threshold) == 0
-        end
+      def self.cleanup? 
+        # every 10 connections run a cleanup routine after closing the response
+        @threads.size > (@thread_threshold - 1) && (@threads.size % @thread_threshold) == 0
+      end
 
-        def cleanup_threads
-          log_debug "[#{log_signature}] Thread cleanup - #{@threads.size} - start"
+      def self.cleanup_threads
+        log_debug "[#{log_signature}] Thread cleanup - #{@threads.size} - start"
 
-          @threads = @threads.select do |t| 
-            if t[:thread].alive? 
-              true  
-            else
-              t[:thread].join
-              @working.delete(t[:socket])
-              false
-            end
+        @threads = @threads.select do |t| 
+          if t[:thread].alive? 
+            true  
+          else
+            t[:thread].join
+            @working.delete(t[:socket])
+            false
           end
-
-          log_debug "[#{log_signature}] Thread cleanup - #{@threads.size} - complete"
         end
 
-        def log_signature
-          @log_signature ||= "server-#{self}"
-        end
+        log_debug "[#{log_signature}] Thread cleanup - #{@threads.size} - complete"
+      end
 
-        def new_worker(socket)
-          Thread.new(socket) do |sock|
-            Protobuf::Rpc::SocketServer::Worker.new(sock) do |s|
-              s.close
-            end
+      def self.log_signature
+        @log_signature ||= "server-#{self}"
+      end
+
+      def self.new_worker(socket)
+        Thread.new(socket) do |sock|
+          Protobuf::Rpc::SocketServer::Worker.new(sock) do |s|
+            s.close
           end
         end
+      end
 
-        # TODO make listen/backlog part of config
-        def run(host = "127.0.0.1", port = 9399, backlog = 100, thread_threshold = 100)
-          log_debug "[#{log_signature}] Run"
-          @running = true
-          @threads = []
-          @thread_threshold = thread_threshold
-          @server = TCPServer.new(host, port)
-          @server.listen(backlog)
-          @working = []
-          @listen_fds = [@server]
-
-          while running?
-            log_debug "[#{log_signature}] Waiting for connections"
-
-            if ready_cnxns = IO.select(@listen_fds, [], [], 20)
-              cnxns = ready_cnxns.first
-              cnxns.each do |client|
-                case 
-                when !running? then
-                  # no-op
-                when client == @server then 
-                  log_debug "[#{log_signature}] Accepted new connection"
-                  client, sockaddr = @server.accept
-                  @listen_fds << client
-                else 
-                  if !@working.include?(client)
-                    @working << @listen_fds.delete(client)
-                    log_debug "[#{log_signature}] Working" 
-                    @threads << { :thread => new_worker(client), 
-                                  :socket => client }
-
-                    cleanup_threads if cleanup?
-                  end
+      def self.run(opts = {})
+        log_debug "[#{log_signature}] Run"
+        host = opts.fetch(:host, "127.0.0.1")
+        port = opts.fetch(:port, 9399)
+        backlog = opts.fetch(:backlog, 100)
+        thread_threshold = opts.fetch(:thread_threshold, 100)
+        auto_collect_timeout = opts.fetch(:auto_collect_timeout, 20)
+
+        @running = true
+        @threads = []
+        @thread_threshold = thread_threshold
+        @server = TCPServer.new(host, port)
+        @server.listen(backlog)
+        @working = []
+        @listen_fds = [@server]
+
+        while running?
+          log_debug "[#{log_signature}] Waiting for connections"
+
+          if ready_cnxns = IO.select(@listen_fds, [], [], auto_collect_timeout)
+            cnxns = ready_cnxns.first
+            cnxns.each do |client|
+              case 
+              when !running? then
+                # no-op
+              when client == @server then 
+                log_debug "[#{log_signature}] Accepted new connection"
+                client, sockaddr = @server.accept
+                @listen_fds << client
+              else 
+                if !@working.include?(client)
+                  @working << @listen_fds.delete(client)
+                  log_debug "[#{log_signature}] Working" 
+                  @threads << { :thread => new_worker(client), :socket => client }
+
+                  cleanup_threads if cleanup?
                 end
               end
-            else
-              # Run a cleanup if select times out while waiting
-              cleanup_threads if @threads.size > 1
             end
+          else
+            # Run a cleanup if select times out while waiting
+            cleanup_threads if @threads.size > 1
           end
-
-        rescue 
-          # Closing the server causes the loop to raise an exception here
-          raise if running?
         end
 
-        def running?
-          @running
-        end
+      rescue 
+        # Closing the server causes the loop to raise an exception here
+        raise if running?
+      end
 
-        def stop 
-          @running = false
-          @server.close
-        end
+      def self.running?
+        @running
+      end
 
+      def self.stop 
+        @running = false
+        @server.close if @server
       end
 
       class Worker 

data/lib/protobuf/rpc/service.rb

@@ -16,8 +16,8 @@ module Protobuf
       private :request, :response, :response=
       
       DEFAULT_LOCATION = {
-        :host => 'localhost',
-        :port => 9939
+        :host => '127.0.0.1',
+        :port => 9399 
       }
       
       # Class methods are intended for use on the client-side.

data/lib/protobuf/version.rb

@@ -1,3 +1,3 @@
 module Protobuf
-  VERSION = '1.1.0.beta1'
+  VERSION = '1.1.0.beta2'
 end

data/spec/benchmark/tasks.rb

@@ -0,0 +1,126 @@
+require 'benchmark'
+require 'helper/all'
+require 'proto/test_service_impl'
+
+namespace :benchmark do
+  include SilentConstants
+
+  def benchmark_wrapper(global_bench = nil)
+    if global_bench
+      yield global_bench
+    else
+      Benchmark.bm(10) do |bench|
+        yield bench
+      end
+    end
+  end
+
+  def em_client_em_server(number_tests, test_length, global_bench = nil)
+    EM.stop if EM.reactor_running?
+
+    EventMachine.fiber_run do 
+      StubServer.new do |server|
+        client = Spec::Proto::TestService.client(:async => false)
+
+        benchmark_wrapper(global_bench) do |bench|
+          bench.report("ES / EC") do 
+            (1..number_tests.to_i).each { client.find(:name => "Test Name" * test_length.to_i, :active => true) }
+          end
+        end
+      end
+
+      EM.stop
+    end
+  end
+
+  def em_client_sock_server(number_tests, test_length, global_bench = nil)
+    EM.stop if EM.reactor_running?
+
+    EventMachine.fiber_run do
+      StubServer.new(:server => Protobuf::Rpc::SocketServer, :port => 9399) do |server| 
+        client = Spec::Proto::TestService.client(:async => false, :port => 9399)
+
+        benchmark_wrapper(global_bench) do |bench|
+          bench.report("SS / EC") do 
+            (1..number_tests.to_i).each { client.find(:name => "Test Name" * test_length.to_i, :active => true) }
+          end
+        end
+      end
+
+      EM.stop
+    end
+  end
+
+  def sock_client_sock_server(number_tests, test_length, global_bench = nil)
+    EM.stop if EM.reactor_running?
+
+    StubServer.new(:server => Protobuf::Rpc::SocketServer, :port => 9399) do |server| 
+      with_constants "Protobuf::ConnectorType" => "Socket" do
+        client = Spec::Proto::TestService.client(:async => false, :port => 9399)
+
+        benchmark_wrapper(global_bench) do |bench|
+          bench.report("SS / SC") do 
+            (1..number_tests.to_i).each { client.find(:name => "Test Name" * test_length.to_i, :active => true) }
+          end
+        end
+      end
+    end
+  end
+
+  def sock_client_em_server(number_tests, test_length, global_bench = nil)
+    EM.stop if EM.reactor_running?
+    em_thread = Thread.new { EM.run }
+    Thread.pass until EM.reactor_running?
+
+    StubServer.new(:port => 9399) do |server| 
+      with_constants "Protobuf::ConnectorType" => "Socket" do
+        client = Spec::Proto::TestService.client(:async => false, :port => 9399)
+
+        benchmark_wrapper(global_bench) do |bench|
+          bench.report("ES / SC") do 
+            (1..number_tests.to_i).each { client.find(:name => "Test Name" * test_length.to_i, :active => true) }
+          end
+        end
+      end
+    end
+
+    EM.stop
+    Thread.kill(em_thread) if em_thread
+  end
+
+  desc "benchmark EventMachine client with EventMachine server"
+  task :em_client_em_server, [:number, :length] do |t, args|
+    args.with_defaults(:number => 1000, :length => 100)
+    em_client_em_server(args[:number], args[:length])
+  end
+
+  desc "benchmark EventMachine client with Socket server"
+  task :em_client_sock_server, [:number, :length] do |t, args|
+    args.with_defaults(:number => 1000, :length => 100)
+    em_client_sock_server(args[:number], args[:length])
+  end
+
+  desc "benchmark Socket client with Socket server"
+  task :sock_client_sock_server, [:number, :length] do |t, args|
+    args.with_defaults(:number => 1000, :length => 100)
+    sock_client_sock_server(args[:number], args[:length])
+  end
+
+  desc "benchmark Socket client with EventMachine server"
+  task :sock_client_em_server, [:number, :length] do |t, args|
+    args.with_defaults(:number => 1000, :length => 100)
+    sock_client_em_server(args[:number], args[:length])
+  end
+
+  desc "benchmark server performance"
+  task :servers, [:number, :length] do |t, args|
+    args.with_defaults(:number => 1000, :length => 100)
+
+    Benchmark.bm(10) do |bench|
+      em_client_em_server(args[:number], args[:length], bench)
+      em_client_sock_server(args[:number], args[:length], bench)
+      sock_client_sock_server(args[:number], args[:length], bench)
+      sock_client_em_server(args[:number], args[:length], bench)
+    end
+  end
+end

data/spec/helper/server.rb

@@ -1,19 +1,19 @@
 require 'ostruct'
 require 'protobuf/common/logger'
 require 'protobuf/rpc/server'
+require 'protobuf/rpc/servers/socket_server'
+require 'protobuf/rpc/servers/socket_runner'
 require 'spec/proto/test_service_impl'
 
 module StubProtobufServerFactory
   def self.build(delay)
     new_server = Class.new(Protobuf::Rpc::EventedServer) do
-      class << self
-        def sleep_interval
-          @sleep_interval
-        end
+      def self.sleep_interval
+        @sleep_interval
+      end
 
-        def sleep_interval=(si)
-          @sleep_interval = si
-        end
+      def self.sleep_interval=(si)
+        @sleep_interval = si
       end
 
       def post_init
@@ -36,7 +36,7 @@ class StubServer
     @running = true
     @options = OpenStruct.new({
         :host => "127.0.0.1", 
-        :port => 9939, 
+        :port => 9399, 
         :delay => 0, 
         :server => Protobuf::Rpc::EventedServer
       }.merge(opts))
@@ -51,7 +51,9 @@ class StubServer
     if @options.server == Protobuf::Rpc::EventedServer
       start_em_server
     else
-      Protobuf::Rpc::SocketRunner.run(@options)
+      @sock_server = Thread.new(@options) { |opt| Protobuf::Rpc::SocketRunner.run(opt) }
+      @sock_server.abort_on_exception = true # Set for testing purposes
+      Thread.pass until Protobuf::Rpc::SocketServer.running?
     end
     log_debug "[stub-server] Server started #{@options.host}:#{@options.port}"
   rescue => ex
@@ -67,9 +69,10 @@ class StubServer
 
   def stop
     if @options.server == Protobuf::Rpc::EventedServer
-      EventMachine.stop_server(@server_handle)
+      EventMachine.stop_server(@server_handle) if @server_handle
     else
       Protobuf::Rpc::SocketRunner.stop
+      Thread.kill(@sock_server) if @sock_server
     end
     @running = false
   end

data/spec/spec_helper.rb

@@ -26,9 +26,9 @@ end
 
 class ::Protobuf::Rpc::Client
   def == other
-   connector.options == other.options && \
-   success_cb == other.success_cb && \
-   failure_cb == other.failure_cb
+    connector.options == other.options && \
+      success_cb == other.success_cb && \
+      failure_cb == other.failure_cb
   end
 end
 

data/spec/unit/rpc/client_spec.rb

@@ -9,7 +9,7 @@ describe Protobuf::Rpc::Client do
         StubServer.new(:delay => 3) do |server|
           client = Spec::Proto::TestService.client(:async => false)
           start = now
-          
+
           client.find(:name => "Test Name", :active => true) do |c|
             c.on_success do |succ|
               succ.name.should eq("Test Name")
@@ -68,40 +68,73 @@ describe Protobuf::Rpc::Client do
       subject.should raise_error(RuntimeError, /timeout/i)
     end
 
+    context "without reactor_running?" do 
+
+      it "throws a timeout when client timeout is exceeded" do
+        subject = Proc.new do
+          StubServer.new(:delay => 2) do |server|
+            client = Spec::Proto::TestService.client(:async => false, :timeout => 1)
+            client.find(:name => "Test Name", :active => true)
+          end
+        end
+
+        subject.should raise_error(RuntimeError, /timeout/i)
+      end
+
+      it "calls failure_cb & throws a timeout when client timeout is exceeded" do
+        failure_message = nil
+
+        subject = Proc.new do
+          StubServer.new(:delay => 2) do |server|
+            client = Spec::Proto::TestService.client(:async => false, :timeout => 1)
+            client.find(:name => "Test Name", :active => true) do |c|
+              c.on_failure do |f|
+                failure_message = f.message
+              end
+            end
+          end
+        end
+
+        subject.call
+        failure_message.should match(/timeout/)
+      end
+
+    end
+
   end
-  
+
   context 'when creating a client from a service' do
-    
+
     it 'should be able to get a client through the Service#client helper method' do
       Spec::Proto::TestService.client(:port => 9191).should eq(Protobuf::Rpc::Client.new(:service => Spec::Proto::TestService, :port => 9191))
     end
-    
+
     it "should be able to override a service location's host and port" do
       Spec::Proto::TestService.located_at 'somewheregreat.com:12345'
       clean_client = Spec::Proto::TestService.client
       clean_client.options[:host].should eq('somewheregreat.com')
       clean_client.options[:port].should eq(12345)
-      
+
       updated_client = Spec::Proto::TestService.client(:host => 'amazing.com', :port => 54321)
       updated_client.options[:host].should eq('amazing.com')
       updated_client.options[:port].should eq(54321)
     end
-    
+
     it 'should be able to define the syncronicity of the client request' do
       client = Spec::Proto::TestService.client(:async => false)
       client.options[:async].should be_false
       client.async?.should be_false
-      
+
       client = Spec::Proto::TestService.client(:async => true)
       client.options[:async].should be_true
       client.async?.should be_true
     end
-    
+
     it 'should be able to define which service to create itself for' do
       client = Protobuf::Rpc::Client.new :service => Spec::Proto::TestService
       client.options[:service].should eq(Spec::Proto::TestService)
     end
-    
+
     it 'should have a hard default for host and port on a service that has not been configured' do
       reset_service_location Spec::Proto::TestService
       client = Spec::Proto::TestService.client
@@ -110,33 +143,33 @@ describe Protobuf::Rpc::Client do
     end
 
   end
-  
+
   context 'when calling methods on a service client' do
-    
+
     # NOTE: we are assuming the service methods are accurately 
     # defined inside spec/proto/test_service.rb,
     # namely the :find method
-    
+
     it 'should respond to defined service methods' do
       client = Spec::Proto::TestService.client
       client.should_receive(:send_request).and_return(nil)
       expect { client.find(nil) }.should_not raise_error
     end
-    
+
     it 'raises a NameError when accessing a var that does not exist' do
       pending
     end
-    
+
     it 'should be able to set and get local variables within client response blocks' do
       outer_value = 'OUTER'
       inner_value = 'INNER'
       client = Spec::Proto::TestService.client(:async => true)
-      
+
       EM.should_receive(:reactor_running?).and_return(true)
-      EM.stub!(:schedule) do
+      EM.stub!(:next_tick) do
         client.success_cb.call(inner_value)
       end
-      
+
       client.find(nil) do |c|
         c.on_success do |response|
           outer_value.should eq('OUTER')
@@ -145,11 +178,11 @@ describe Protobuf::Rpc::Client do
       end
       outer_value.should eq(inner_value)
     end
-    
+
   end
-  
+
   context 'when receiving request objects' do
-    
+
     it 'should be able to create the correct request object if passed a hash' do
       client = Spec::Proto::TestService.client
       client.should_receive(:send_request)
@@ -158,7 +191,7 @@ describe Protobuf::Rpc::Client do
       client.options[:request].name.should eq('Test Name')
       client.options[:request].active.should eq(false)
     end
-    
+
   end
- 
+
 end

data/spec/unit/rpc/servers/socket_server_spec.rb

@@ -34,7 +34,6 @@ describe Protobuf::Rpc::SocketServer do
   end
 
   context "Eventmachine client" do 
-
     it "calls the service in the client request" do 
       with_constants "Protobuf::ConnectorType" => "Evented" do
         client = Spec::Proto::TestService.client(:async => false, :port => 9399, :host => "127.0.0.1")

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: protobuf
 version: !ruby/object:Gem::Version
-  version: 1.1.0.beta1
+  version: 1.1.0.beta2
   prerelease: 6
 platform: ruby
 authors:
@@ -10,11 +10,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-01-23 00:00:00.000000000Z
+date: 2012-01-30 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: eventmachine
-  requirement: &2152750680 !ruby/object:Gem::Requirement
+  requirement: &2152749580 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -22,10 +22,10 @@ dependencies:
         version: 0.12.10
   type: :runtime
   prerelease: false
-  version_requirements: *2152750680
+  version_requirements: *2152749580
 - !ruby/object:Gem::Dependency
   name: eventually
-  requirement: &2152749760 !ruby/object:Gem::Requirement
+  requirement: &2152748440 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -33,10 +33,10 @@ dependencies:
         version: 0.1.0
   type: :runtime
   prerelease: false
-  version_requirements: *2152749760
+  version_requirements: *2152748440
 - !ruby/object:Gem::Dependency
   name: json_pure
-  requirement: &2152748660 !ruby/object:Gem::Requirement
+  requirement: &2152747240 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -44,10 +44,10 @@ dependencies:
         version: 1.6.4
   type: :runtime
   prerelease: false
-  version_requirements: *2152748660
+  version_requirements: *2152747240
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &2152747040 !ruby/object:Gem::Requirement
+  requirement: &2152745900 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -55,10 +55,10 @@ dependencies:
         version: 0.8.7
   type: :development
   prerelease: false
-  version_requirements: *2152747040
+  version_requirements: *2152745900
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &2152746040 !ruby/object:Gem::Requirement
+  requirement: &2152744960 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -66,10 +66,10 @@ dependencies:
         version: 2.8.0
   type: :development
   prerelease: false
-  version_requirements: *2152746040
+  version_requirements: *2152744960
 - !ruby/object:Gem::Dependency
   name: yard
-  requirement: &2152744940 !ruby/object:Gem::Requirement
+  requirement: &2152743380 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -77,10 +77,10 @@ dependencies:
         version: 0.7.4
   type: :development
   prerelease: false
-  version_requirements: *2152744940
+  version_requirements: *2152743380
 - !ruby/object:Gem::Dependency
   name: redcarpet
-  requirement: &2152743520 !ruby/object:Gem::Requirement
+  requirement: &2152737180 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -88,10 +88,10 @@ dependencies:
         version: 1.17.2
   type: :development
   prerelease: false
-  version_requirements: *2152743520
+  version_requirements: *2152737180
 - !ruby/object:Gem::Dependency
   name: simplecov
-  requirement: &2152742800 !ruby/object:Gem::Requirement
+  requirement: &2152736600 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -99,7 +99,7 @@ dependencies:
         version: 0.5.4
   type: :development
   prerelease: false
-  version_requirements: *2152742800
+  version_requirements: *2152736600
 description: ! 'Ruby implementation for Protocol Buffers. Works with other protobuf
   rpc implementations (e.g. Java, Python, C++).
 
@@ -180,6 +180,7 @@ files:
 - proto/rpc.proto
 - protobuf.gemspec
 - script/mk_parser
+- spec/benchmark/tasks.rb
 - spec/functional/embedded_service_spec.rb
 - spec/helper/all.rb
 - spec/helper/server.rb
@@ -275,6 +276,7 @@ specification_version: 3
 summary: Ruby implementation for Protocol Buffers. Works with other protobuf rpc implementations
   (e.g. Java, Python, C++).
 test_files:
+- spec/benchmark/tasks.rb
 - spec/functional/embedded_service_spec.rb
 - spec/helper/all.rb
 - spec/helper/server.rb