parallizer 0.0.4 → 0.1.0

data/README.md

@@ -1,6 +1,6 @@
 # Parallizer - Execute your service layer in parallel
 
-Parallizer executes service methods in parallel, stores the method results, then creates a proxy with those results for your service. Your application then uses the short-lived service proxy (think of a single request for a web application) and executes your methods without again calling the underlying implementation. For applications that make considerable use of web service calls, Parallizer can give you a considerable performance boost.
+Parallizer executes service methods in parallel, stores the method results, and creates a proxy of your service with those results. Your application then uses the short-lived service proxy (think of a single request for a web application) and calls your methods without again executing the underlying implementation. For applications that make considerable use of web service calls, Parallizer can give you a considerable performance boost.
 
 ## Installation
 
@@ -13,51 +13,60 @@ Parallizer executes service methods in parallel, stores the method results, then
 Here's an example service.
 
 ```ruby
+require 'rubygems'
 require 'net/http'
+require 'nokogiri'
 
 class SearchService
-  def search_result_for_foo
-    Net::HTTP.get('www.google.com', '/?q=foo')
+  def top_urls_for_foo
+    parse_search_result_for_urls(Net::HTTP.get('www.google.com', '/search?q=foo'))
   end
   
-  def search_result_for_bar
-    Net::HTTP.get('www.google.com', '/?q=foo')
+  def top_urls_for_bar
+    parse_search_result_for_urls(Net::HTTP.get('www.google.com', '/search?q=bar'))
+  end
+  
+  private
+  
+  def parse_search_result_for_urls(content)
+    Nokogiri::HTML.parse(content).search('h3.r > a').collect(&:attributes).collect{ |attrs| attrs['href'].value }
   end
 end
 
 $search_service = SearchService.new
 ```
 
-Now create a Parallizer for that service and add all of the methods you intend to call. Then execute the service methods in parallel and return a service proxy that has the stored results of the method calls.
+Now create a Parallizer for that service and add all of the methods you intend to call. This begins the execution of the service methods in worker threads. Then create a service proxy that uses the stored results of the method calls.
 
 ```ruby
 require 'parallizer'
 
 parallizer = Parallizer.new($search_service)
-parallizer.add.search_result_for_foo
-parallizer.add.search_result_for_bar
-search_service = parallizer.execute
+parallizer.add.top_urls_for_foo
+parallizer.add.top_urls_for_bar
+search_service = parallizer.create_proxy
 ```
 
-Now use that service proxy in your application logic.
+Now use that service proxy in your application logic. Calls to these methods will not make an HTTP request
+and will not parse HTML. That was done by the parallel worker threads.
 
 ```ruby
-puts search_service.search_result_for_foo
-puts search_service.search_result_for_bar
+puts search_service.top_urls_for_foo
+puts search_service.top_urls_for_bar
 ```
 
 Additional calls in your application logic will not result in an additional call to the underlying service.
 
 ```ruby
 # Called twice, but no extra service call. (Be careful not to mutate the returned object!)
-puts search_service.search_result_for_foo
-puts search_service.search_result_for_foo
+puts search_service.top_urls_for_foo
+puts search_service.top_urls_for_foo
 ```
 
 If there are additional methods on your service that were not parallized, you can still call them.
 
 ```ruby
-puts search_service.search_result_for_foobar # does a Net::HTTP.get call
+puts search_service.top_urls_for_foobar # makes an HTTP request and parses result
 ```
 
 ### Parallizing methods with parameters
@@ -66,11 +75,18 @@ Parallizing also works on service methods with parameters.
 
 ```ruby
 require 'net/http'
+require 'nokogiri'
 require 'cgi'
 
 class SearchService
-  def search_result(search_term)
-    Net::HTTP.get('www.google.com', "/?q=#{CGI.escape(search_term)}")
+  def top_urls(search_term)
+    parse_search_result_for_urls(Net::HTTP.get('www.google.com', "/search?q=#{CGI.escape(search_term)}"))
+  end
+  
+  private
+  
+  def parse_search_result_for_urls(content)
+    Nokogiri::HTML.parse(content).search('h3.r > a').collect(&:attributes).collect{ |attrs| attrs['href'].value }
   end
 end
 
@@ -83,17 +99,17 @@ The parallel execution and proxy creation.
 require 'parallizer'
 
 parallizer = Parallizer.new($search_service)
-parallizer.add.search_result('foo')
-parallizer.add.search_result('bar')
-search_service = parallizer.execute
+parallizer.add.top_urls('foo')
+parallizer.add.top_urls('bar')
+search_service = parallizer.create_proxy
 ```
 
 Using the service proxy in your application logic.
 
 ```ruby
-puts search_service.search_result('foo') # returns stored value
-puts search_service.search_result('bar') # returns stored value
-puts search_service.search_result('foobar') # does a Net::HTTP.get call
+puts search_service.top_urls('foo') # returns stored value
+puts search_service.top_urls('bar') # returns stored value
+puts search_service.top_urls('foobar') # makes an HTTP request and parses result
 ```
 
 
@@ -108,24 +124,24 @@ require 'parallizer'
 parallizer = Parallizer.new(Net::HTTP)
 parallizer.add.get('www.google.com', '/?q=foo')
 parallizer.add.get('www.google.com', '/?q=bar')
-http_service = parallizer.execute
+http_service = parallizer.create_proxy
 ```
 
 Use the service proxy.
 
 ```ruby
 # use your service proxy
-http_service.get('www.google.com', '/?q=foo') # returns stored value
-http_service.get('www.google.com', '/?q=bar') # returns stored value
-http_service.get('www.google.com', '/?q=foobar') # does a Net::HTTP.get call
+http_service.get('www.google.com', '/search?q=foo') # returns stored value
+http_service.get('www.google.com', '/search?q=bar') # returns stored value
+http_service.get('www.google.com', '/search?q=foobar') # makes an HTTP request and parses result
 ```
 
 
 # Credits
 
-[Parallizer](https://github.com/michaelgpearce/parallizer) is maintained by [Michael Pearce](http://github.com/michaelgpearce) and is funded by [BookRenter.com](http://www.bookrenter.com "BookRenter.com").
+[Parallizer](https://github.com/michaelgpearce/parallizer) is maintained by [Michael Pearce](http://github.com/michaelgpearce) and is funded by [Rafter](http://www.rafter.com "Rafter").
 
-![BookRenter.com Logo](http://assets0.bookrenter.com/images/header/bookrenter_logo.gif "BookRenter.com")
+![Rafter Logo](http://rafter-logos.s3.amazonaws.com/rafter_github_logo.png "Rafter")
 
 # Copyright
 

data/VERSION

@@ -1 +1 @@
-0.0.4
+0.1.0

data/lib/parallizer.rb

@@ -1,56 +1,60 @@
-require 'set'
 require 'work_queue'
 require 'parallizer/proxy'
 require 'parallizer/method_call_notifier'
 
 class Parallizer
-  attr_accessor :calls, :client
+  attr_reader :calls, :call_infos, :client, :proxy
   
   def initialize(client)
-    self.client = client
-    self.calls = Set.new
+    @client = client
+    @call_infos = {}
   end
   
   def add
     MethodCallNotifier.new do |*args|
-      self.calls.add(args)
+      add_call(*args)
     end
   end
   
-  def add_call(method_name, *args)
-    calls.add([method_name.to_sym, *args])
-  end
-  
-  def execute
-    Parallizer.execute_all(self).first
+  def calls
+    @call_infos.keys
   end
   
-  def self.work_queue
-    # TODO: share the work queue among calling threads
-    Thread.current[:parallizer_work_queue] ||= WorkQueue.new(10)
-  end
-  
-  def self.execute_all(*parallizers)
-    parallizers_execution_results = {}
-    parallizers.each do |parallizer|
-      execution_results = {}
-      parallizers_execution_results[parallizer] = execution_results
-      
-      parallizer.calls.each do |name_and_args|
-        Parallizer.work_queue.enqueue_b do
-          begin
-            execution_results[name_and_args] = {:result => parallizer.client.send(*name_and_args)}
-          rescue Exception => e
-            execution_results[name_and_args] = {:exception => e}
-          end
+  def add_call(method_name, *args)
+    raise ArgumentError, "Cannot add calls after proxy has been generated" if @proxy
+    
+    method_name_and_args = [method_name.to_sym, *args]
+    
+    call_info = {
+      :complete? => false,
+      :result => nil,
+      :exception => nil,
+      :condition_variable => ConditionVariable.new,
+      :mutex => Mutex.new
+    }
+    call_infos[method_name_and_args] = call_info
+    
+    Parallizer.work_queue.enqueue_b do
+      call_info[:mutex].synchronize do
+        begin
+          call_info[:result] = client.send(*method_name_and_args)
+        rescue Exception => e
+          call_info[:exception] = e
+        ensure
+          call_info[:complete?] = true
+          call_info[:condition_variable].signal
         end
       end
     end
+  end
+  
+  def create_proxy
+    raise ArgumentError, "Cannot create another proxy" if @proxy
     
-    Parallizer.work_queue.join
-
-    return parallizers_execution_results.collect do |parallizer, execution_results|
-      Parallizer::Proxy.new(parallizer.client, execution_results)
-    end
+    Parallizer::Proxy.new(client, call_infos)
+  end
+  
+  def self.work_queue
+    @parallizer_work_queue ||= WorkQueue.new(10)
   end
 end

data/lib/parallizer/proxy.rb

@@ -1,27 +1,38 @@
+require 'thread'
 require 'set'
 
 class Parallizer
   class Proxy
-    def initialize(client, execution_results)
+    def initialize(client, call_infos)
       @client = client
-      @execution_results = execution_results
+      @call_infos = call_infos
     end
 
     def method_missing(name, *args, &block)
-      if @execution_results.key?([name, *args])
-        value = @execution_results[[name, *args]]
-        if value[:exception]
-          raise value[:exception]
-        else
-          value[:result]
+      value = nil
+      
+      if call_info = @call_infos[[name, *args]]
+        call_info[:mutex].synchronize do
+          if !call_info[:complete?]
+            # not done, so lets wait for signal of completion
+            call_info[:condition_variable].wait(call_info[:mutex])
+          end
+          # we now have our result from the worker thread
+          
+          raise call_info[:exception] if call_info[:exception]
+          
+          value = call_info[:result]
         end
       else
-        @client.send(*[name, *args], &block)
+        # pass through to client since not added
+        value = @client.send(*[name, *args], &block)
       end
+      
+      value
     end
   
     def respond_to?(name, include_private = false, &block)
-      @execution_methods ||= Set.new(@execution_results.keys.collect(&:first))
+      @execution_methods ||= Set.new(@call_infos.keys.collect(&:first))
     
       if @execution_methods.include?(name.to_sym)
         true

data/parallizer.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = "parallizer"
-  s.version = "0.0.4"
+  s.version = "0.1.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Michael Pearce"]
-  s.date = "2012-07-30"
+  s.date = "2012-08-04"
   s.description = "Execute your service layer in parallel."
   s.email = "michael.pearce@bookrenter.com"
   s.extra_rdoc_files = [
@@ -27,10 +27,10 @@ Gem::Specification.new do |s|
     "lib/parallizer/method_call_notifier.rb",
     "lib/parallizer/proxy.rb",
     "parallizer.gemspec",
+    "test/helper.rb",
     "test/parallizer/method_call_notifier_test.rb",
     "test/parallizer/proxy_test.rb",
-    "test/parallizer_test.rb",
-    "test/test_helper.rb"
+    "test/parallizer_test.rb"
   ]
   s.homepage = "http://github.com/michaelgpearce/parallizer"
   s.licenses = ["MIT"]

data/test/parallizer/method_call_notifier_test.rb

@@ -1,4 +1,4 @@
-require 'test_helper'
+require 'helper'
 
 class Parallizer::MethodCallNotifierTest < Test::Unit::TestCase
   context ".method_missing" do

data/test/parallizer/proxy_test.rb

@@ -1,4 +1,4 @@
-require 'test_helper'
+require 'helper'
 
 class Parallizer::ProxyTest < Test::Unit::TestCase
   DEFAULT_RETURN_VALUE = "return value"
@@ -12,53 +12,82 @@ class Parallizer::ProxyTest < Test::Unit::TestCase
   context ".method_missing" do
     setup do
       @client = TestObject.new
+      @call_key = []
+      @call_info = {:result => nil, :exception => nil, :complete? => true,
+        :condition_variable => ConditionVariable.new, :mutex => Mutex.new }
+    end
+    
+    execute do
+      call_infos = { @call_key => @call_info }
+      proxy = Parallizer::Proxy.new(@client, call_infos)
+      proxy.send(*@call_key) rescue $!
     end
     
     context "with method that exists on client" do
-      context "with method and arg in execute results" do
+      context "with method and arg call info" do
         setup do
-          @method_result = "some value"
-          @method_arg = "some arg"
-          @execution_results = {[:a_method, @method_arg] => {:result => @method_result}}
+          @call_key += [:a_method, "some value"]
         end
-
-        should "return value from execution_results" do
-          assert_equal @method_result, Parallizer::Proxy.new(@client, @execution_results).a_method(@method_arg)
+        
+        context "with not complete?" do
+          setup do
+            @call_info[:complete?] = false
+            @call_info[:condition_variable].expects(:wait).with(@call_info[:mutex])
+            @call_info[:result] = 'this is a value'
+          end
+          
+          should do
+            assert_equal @call_info[:result], @execute_result
+          end
         end
-
-        context "with exception in execute results" do
+        
+        context "with complete? call info" do
           setup do
-            @execution_results = {[:a_method, @method_arg] => {:exception => Exception.new("an exception")}}
+            @call_info[:complete?] = true
           end
           
-          should "raise exception" do
-            assert_raises Exception, "an exception" do
-              Parallizer::Proxy.new(@client, @execution_results).a_method(@method_arg)
+          context "with an exception" do
+            setup do
+              @call_info[:exception] = StandardError.new('An Exception')
+            end
+            
+            should "raise exception" do
+              assert_equal @call_info[:exception], @execute_result
+            end
+          end
+          
+          context "with a result" do
+            setup do
+              @call_info[:result] = "a result"
+            end
+            
+            should "return result" do
+              assert_equal @call_info[:result], @execute_result
             end
           end
         end
       end
       
-      context "with method and arg not in execute result" do
+      context "with no method and arg not in execute result" do
         setup do
-          @execution_results = {[:a_method, :unknown] => "unknown"}
+          @call_key += [:a_method, "some parameter"]
+          @call_info = nil
         end
-
+        
         should "return value from client object" do
-          assert_equal DEFAULT_RETURN_VALUE, Parallizer::Proxy.new(@client, @execution_results).a_method(:not_unknown)
+          assert_equal DEFAULT_RETURN_VALUE, @execute_result
         end
       end
     end
     
     context "with method that does not exist on client" do
       setup do
-        @execution_results = {[:a_method, @method_arg] => {:result => @method_result}}
+        @call_key += [:unknown_method, "some parameter"]
+        @call_info = nil
       end
       
       should "raise exception" do
-        assert_raises NoMethodError, "an exception" do
-          Parallizer::Proxy.new(@client, @execution_results).unknown_method()
-        end
+        assert_equal NoMethodError, @execute_result.class
       end
     end
   end
@@ -66,8 +95,10 @@ class Parallizer::ProxyTest < Test::Unit::TestCase
   context ".respond_to?" do
     setup do
       client = TestObject.new
-      execution_results = {[:a_method, 'valid argument'] => {:result => 'valid result'}}
-      @proxy = Parallizer::Proxy.new(client, execution_results)
+      call_key = [:a_method, 'valid argument']
+      call_info = {:result => nil, :exception => nil, :complete? => true,
+        :condition_variable => ConditionVariable.new, :mutex => Mutex.new }
+      @proxy = Parallizer::Proxy.new(client, { call_key => call_info })
     end
     
     should "respond to proxy method as symbol" do

data/test/parallizer_test.rb

@@ -1,4 +1,4 @@
-require 'test_helper'
+require 'helper'
 
 class ParallizerTest < Test::Unit::TestCase
   class TestObject
@@ -43,7 +43,17 @@ class ParallizerTest < Test::Unit::TestCase
     end
     
     execute do
-      @parallizer.add_call(@method, 'arg')
+      @parallizer.add_call(@method, 'arg') rescue $!
+    end
+    
+    context "with proxy already created" do
+      setup do
+        @parallizer.instance_variable_set(:@proxy, mock('proxy'))
+      end
+      
+      should "raise ArgumentError" do
+        assert_equal ArgumentError, @execute_result.class
+      end
     end
     
     context "with string method name added" do
@@ -67,14 +77,14 @@ class ParallizerTest < Test::Unit::TestCase
     end
   end
   
-  context ".execute" do
+  context ".create_proxy" do
     setup do
       @client = TestObject.new
       @parallizer = Parallizer.new(@client)
     end
     
     execute do
-      @proxy = @parallizer.execute
+      @proxy = @parallizer.create_proxy rescue $!
     end
     
     context "with existing method on client" do
@@ -90,30 +100,16 @@ class ParallizerTest < Test::Unit::TestCase
         assert_equal Thread.current, @proxy.another_method
       end
     end
-  end
-  
-  context ".execute_all" do
-    setup do
-      @client1 = TestObject.new
-      @parallizer1 = Parallizer.new(@client1)
-      @parallizer1.add_call(:a_method, 'arg')
-      @client2 = AnotherTestObject.new
-      @parallizer2 = Parallizer.new(@client2)
-      @parallizer2.add_call(:a_method)
-    end
-
-    execute do
-      @proxy1, @proxy2 = Parallizer.execute_all(@parallizer1, @parallizer2)
-    end
-
-    should "execute methods with add_call in a separate thread" do
-      assert_not_equal Thread.current, @proxy1.a_method('arg')
-      assert_not_equal Thread.current, @proxy2.a_method
-    end
-
-    should "execute methods not added with add_call in current thread" do
-      assert_equal Thread.current, @proxy1.another_method
-      assert_equal Thread.current, @proxy2.another_method
+    
+    context "with proxy already created" do
+      setup do
+        @parallizer.instance_variable_set(:@proxy, mock('proxy'))
+      end
+      
+      should "raise ArgumentError" do
+        assert_equal ArgumentError, @execute_result.class
+      end
     end
+    
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: parallizer
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-07-30 00:00:00.000000000 Z
+date: 2012-08-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -109,10 +109,10 @@ files:
 - lib/parallizer/method_call_notifier.rb
 - lib/parallizer/proxy.rb
 - parallizer.gemspec
+- test/helper.rb
 - test/parallizer/method_call_notifier_test.rb
 - test/parallizer/proxy_test.rb
 - test/parallizer_test.rb
-- test/test_helper.rb
 homepage: http://github.com/michaelgpearce/parallizer
 licenses:
 - MIT
@@ -128,7 +128,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -1557478882810554134
+      hash: -894887093549594031
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements: