concur 0.0.6 → 0.0.7

data/lib/completer.rb

@@ -0,0 +1,12 @@
+# Decouples execution of tasks from getting completed tasks so you can add tasks for execution to a Completer
+# and retrieve completed tasks (first completed, first out) from it.
+#
+# based on http://download.oracle.com/javase/6/docs/api/java/util/concurrent/CompletionService.html
+
+module Concur
+
+  class Completer
+    
+  end
+
+end

data/lib/executor.rb

@@ -1,8 +1,8 @@
+require 'faraday'
 require_relative 'runnable'
 require_relative 'future'
 require_relative 'thread_pool'
 
-
 module Concur
 
 
@@ -59,8 +59,40 @@ module Concur
     def shutdown
       @thread_pool.shutdown
     end
+
+    def http_request(params, &blk)
+
+      f = StandardFuture.new do
+        conn = Faraday.new(:url => params[:base_url]) do |builder|
+#          builder.use Faraday::Request::UrlEncoded # convert request params as "www-form-urlencoded"
+#          builder.use Faraday::Request::JSON # encode request params as json
+#          builder.use Faraday::Response::Logger # log the request to STDOUT
+          builder.use Faraday::Adapter::NetHttp # make http requests with Net::HTTP
+#
+#          # or, use shortcuts:
+#          builder.request :url_encoded
+#          builder.request :json
+#          builder.response :logger
+#          builder.adapter :net_http
+        end
+        if params[:http_method] == :post
+          response = conn.post params[:path]
+        else
+          response = conn.get params[:path]
+        end
+        if block_given?
+          response = blk.call(response)
+        end
+        response
+      end
+      @thread_pool.process(f)
+      f
+    end
+
+
   end
 
+
   # todo: should maybe have these backends extend Executor and just override what's necessary
   class SingleThreaded
     def process(f)

data/lib/executors/event_machine_executor.rb

@@ -4,17 +4,22 @@ require_relative '../futures/event_machine_future'
 module Concur
   class EventMachineExecutor
 
-
     def initialize
-      @futures = []
-      @em_thread = Thread.new do
-        EventMachine.run do
-          puts 'Starting EventMachineExecutor...'
+      unless EventMachine.reactor_running? # also check EventMachine.reactor_thread? ??
+        @in_thread = true
+        @em_thread = Thread.new do
+          EventMachine.run do
+            puts 'Starting EventMachineExecutor...'
 #          @futures.each do |f|
 #
 #          end
+          end
+          puts 'EventMachine loop done in executor thread'
         end
-        puts 'EventMachine loop done'
+        sleep 0.1 # let EM startup
+      else
+        puts 'Reactor already running...'
+        @in_thread = false
       end
     end
 
@@ -26,9 +31,17 @@ module Concur
     end
 
     def shutdown
-      @em_thread.kill
+      if @in_thread
+        EventMachine.stop
+        @em_thread.kill
+      end
       puts 'shutdown'
     end
 
+    # Abstracts the http client used that is suitable for the executor
+    def http_request(params, &blk)
+      f = EventMachineFuture2.new(params, &blk)
+    end
+
   end
 end

data/lib/future.rb

@@ -28,15 +28,19 @@ module Concur
     end
 
     def run
+      puts 'running StandardFuture'
       begin
         @result = @callable.call
+        puts 'callable called: ' + @result.inspect
       rescue Exception => ex
+        puts 'error occurred'
         @ex = ex
       end
       @mutex.synchronize do # do we even need to synchronize? run should only ever be called once
         @complete = true
-        @cv.broadcast
       end
+      @cv.broadcast
+
     end
 
     def call
@@ -50,9 +54,11 @@ module Concur
     # Returns results. Will wait for thread to complete execution if not already complete.
     def get
 #      @thread.value
-      @mutex.synchronize do
-        unless @complete
-          @cv.wait(@mutex)
+      unless @complete
+        @mutex.synchronize do
+          unless @complete
+            @cv.wait(@mutex)
+          end
         end
       end
       if @ex
@@ -61,4 +67,6 @@ module Concur
       @result
     end
   end
+
+
 end

data/lib/futures/event_machine_future.rb

@@ -43,13 +43,14 @@ module Concur
 
 
     end
+
     def errback &blk
-        @errblk = blk
-      end
+      @errblk = blk
+    end
 
-      def callback &blk
-        @callblk = blk
-      end
+    def callback &blk
+      @callblk = blk
+    end
 
     def errback2 &blk
       puts 'EventMachineFutureCallback.errback'
@@ -69,7 +70,7 @@ module Concur
         if @callblk
           @result = @callblk.call(@callbackable)
         end
-        blk.call(@result)        
+        blk.call(@result)
       end
       @callbackable.callback &proc
     end
@@ -86,10 +87,134 @@ module Concur
 #    end
   end
 
+  class HttpResponseWrapper
+    def initialize(em_http)
+      @em_http = em_http
+    end
+
+    def headers
+      @em_http.response_header
+    end
+
+    def body
+      @em_http.response
+    end
+
+    def status
+      @em_http.response_header.status
+    end
+
+  end
+
+  class EventMachineFuture2
+    require 'em-http'
+    include Concur::Future
+
+    attr_accessor :ex, :result
+
+    def initialize(http_data, &block)
+      @http_data = http_data
+      if block_given?
+        @blk = block
+      end
+
+      puts 'http_data=' + http_data.inspect
+
+      req = EventMachine::HttpRequest.new(http_data[:base_url])
+
+      opts = {:timeout => http_data[:timeout], :head => http_data[:headers]} #, :ssl => true
+
+      if http_data[:http_method] == :post
+        http = req.post opts.merge(:path=>http_data[:path], :body=>http_data[:body])
+      elsif http_data[:http_method] == :put
+        http = req.put opts.merge(:path=>http_data[:path], :body=>http_data[:body])
+      elsif http_data[:http_method] == :head
+        http = req.head opts.merge(:path=>http_data[:path])
+      elsif  http_data[:http_method] == :delete
+        http = req.delete opts.merge(:path=>http_data[:path])
+      else
+        http = req.get opts.merge(:path=>http_data[:path], :query=>http_data[:query])
+      end
+
+      if http.error.empty?
+        http.errback {
+          begin
+            puts 'Uh oh'
+            p http.response_header.status
+            p http.response_header
+            p http.response
+            @ex = StandardError.new("ERROR: #{http.response_header.status} #{http.response}")
+          rescue => ex
+            @ex = ex
+          end
+          self.complete
+        }
+        http.callback {
+          begin
+            puts 'success callback'
+#            puts 'status=' + http.response_header.status
+#            puts 'response header=' + http.response_header
+            if @blk
+              @result = @blk.call(HttpResponseWrapper.new(http))
+            else
+              @result = HttpResponseWrapper.new(http)
+            end
+          rescue => ex
+            @ex = ex
+          end
+          self.complete
+        }
+      else
+        p http.error.inspect
+        @ex = StandardError.new(http.error)
+        self.complete
+      end
+
+
+    end
+
+
+    def complete
+      @complete = true
+    end
+
+    def complete?
+      @complete
+    end
+
+    # Returns results. Will wait for thread to complete execution if not already complete.
+    def get
+#      @thread.value
+#      if !@complete
+#        # todo: gotta be a better way
+##          puts 'sleeping'
+##          sleep 0.1
+#        @fiber = Fiber.new do
+#          while !@complete
+#            sleep 0.1
+#          end
+#          Fiber.yield # give back control
+#        end
+#        @fiber.resume # start fiber
+#      end
+      while !@complete
+        sleep 0.1
+      end
+      return get_response
+    end
+
+    def get_response
+      if @ex
+        raise @ex
+      end
+      @result
+    end
+  end
+
   class EventMachineFuture
     include Concur::Future
 
-    attr_accessor :ex,:result
+    attr_accessor :ex, :result
 
     def initialize(callable, &block)
 
@@ -101,12 +226,11 @@ module Concur
       end
     end
 
-
     def run
       puts 'EMFuture.run'
       p @callable
       begin
-        @callbackable = @callable.call
+        @callbackable = @callable.call(self)
         puts 'done @callable.call ' + @callbackable.inspect
       rescue Exception => ex
         @ex = ex
@@ -122,7 +246,8 @@ module Concur
         @ex = EventMachineError.new(http)
         complete
       }
-      @result = (http.callback2 {|result|
+      @result = (http.callback2 { |result|
+        puts 'completion errback'
         @result = result
         complete
       })
@@ -146,7 +271,7 @@ module Concur
     # Returns results. Will wait for thread to complete execution if not already complete.
     def get
 #      @thread.value
-      while not @complete
+      while !@complete
         # todo: gotta be a better way
         puts 'sleeping'
         sleep 0.5
@@ -161,4 +286,5 @@ module Concur
       @result
     end
   end
+
 end

metadata

@@ -2,7 +2,7 @@
 name: concur
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.0.6
+  version: 0.0.7
 platform: ruby
 authors: 
 - Travis Reeder
@@ -10,9 +10,30 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-05-02 00:00:00 Z
-dependencies: []
-
+date: 2011-05-23 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: eventmachine
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: faraday
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
 description: A concurrency library for Ruby inspired by java.util.concurrency. By http://www.appoxy.com
 email: travis@appoxy.com
 executables: []
@@ -22,6 +43,7 @@ extensions: []
 extra_rdoc_files: 
 - README.markdown
 files: 
+- lib/completer.rb
 - lib/concur.rb
 - lib/executor.rb
 - lib/executors/event_machine_executor.rb
@@ -31,8 +53,6 @@ files:
 - lib/runnable.rb
 - lib/thread_pool.rb
 - README.markdown
-- test/executor_spec.rb
-- test/job.rb
 homepage: http://github.com/appoxy/concur/
 licenses: []
 
@@ -60,6 +80,5 @@ rubygems_version: 1.7.2
 signing_key: 
 specification_version: 3
 summary: A concurrency library for Ruby inspired by java.util.concurrency. By http://www.appoxy.com
-test_files: 
-- test/executor_spec.rb
-- test/job.rb
+test_files: []
+

data/test/executor_spec.rb

@@ -1,87 +0,0 @@
-require 'rspec'
-require 'neverblock'
-
-require_relative '../lib/concur'
-require_relative 'job'
-
-@@durations = []
-
-def run_jobs(name, executor, times, options={})
-  puts "Running #{name}..."
-  start_time = Time.now
-
-  jobs = []
-  times.times do |i|
-    job = Job.new(i, options)
-    jobs << executor.execute(job)
-  end
-  jobs.each do |j|
-    puts "result=#{j.get}"
-  end
-  concurrent_duration = Time.now - start_time
-o = "#{name} duration=" + concurrent_duration.to_s
-  puts o
-  @@durations << o
-  concurrent_duration
-end
-
-describe Concur::Executor do
-  describe "#score" do
-    it "runs faster in parallel" do
-      times = 10
-
-      job = Job.new(1)
-      puts 'runnable? ' + job.is_a?(Concur::Runnable).to_s
-      non_concurrent_duration = 0
-#
-      executor = Concur::Executor.new_single_threaded_executor
-      non_concurrent_duration =run_jobs("non concurrent", executor, times)
-      executor.shutdown
-
-      executor = Concur::Executor.new_multi_threaded_executor
-      concurrent_duration = run_jobs("multi thread", executor, times)
-      concurrent_duration.should be < (non_concurrent_duration/2)
-      executor.shutdown
-
-      executor = Concur::Executor.new_thread_pool_executor(10)
-      pooled_duration = run_jobs("thread pool", executor, times)
-      pooled_duration.should be < (non_concurrent_duration/2)
-      executor.shutdown
-
-      # Don't think I know how to use NeverBlock properly
-#      executor = Concur::Executor.new_neverblock_executor(10)
-#      neverblock_duration = run_jobs("never blocked", executor, times)
-#      neverblock_duration.should be < (non_concurrent_duration/2)
-#      executor.shutdown
-
-      executor = Concur::Executor.new_eventmachine_executor()
-      em_duration = run_jobs("eventmachine", executor, times, :em=>true)
-      em_duration.should be < (non_concurrent_duration/2)
-      executor.shutdown
-
-      @@durations.each do |s|
-        puts s
-      end
-
-    end
-  end
-end
-
-describe Concur::Future do
-
-  describe "#new" do
-
-    it "can accept blocks" do
-      future = Concur::Future.new do
-        puts "i'm in the block"
-        "result of block"
-      end
-      puts 'get=' + future.get
-      future.get.should == "result of block"
-    end
-
-  end
-
-end
-
-

data/test/job.rb

@@ -1,51 +0,0 @@
-require_relative '../lib/runnable'
-require 'rest-client'
-require 'eventmachine'
-
-class Job
-  include Concur::Runnable
-
-  def initialize(i, options={})
-    @i = i
-    if options[:em]
-      @em = true
-    end
-  end
-
-  def em_request(url)
-    puts 'emrequest for ' + url
-    http = EventMachine::Protocols::HttpClient.request(
-        :host => url,
-        :port => 80,
-        :request => "/"
-    )
-    http.callback { |response|
-      puts response[:status]
-      puts response[:headers]
-      puts response[:content]
-    }
-  end
-
-  def run
-    puts "Starting #{@i}... em? #{@em}"
-#    sleep 1
-    urls = ["www.yahoo.com", "www.microsoft.com"] # , "www.github.com"
-    if @em
-      urls.each do |u|
-        em_request(u)
-      end
-    else
-      urls.each do |u|
-        get(u)
-      end
-    end
-    puts "Finished #{@i}"
-    "response #{@i}"
-  end
-
-  def get(url)
-    puts 'getting ' + url
-    RestClient.get "http://#{url}"
-  end
-
-end