timeout-extensions 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ac5f8d21d026acd98f1d9dd234e7a580a8efa2bc
-  data.tar.gz: fa3e5860cf5f98d836d8e3cb1350913453163dbf
+  metadata.gz: 813e3de49e1c2704e6157e53a823679be242c431
+  data.tar.gz: f729d9543b3b4ffef625bd2e637a10310749dd91
 SHA512:
-  metadata.gz: 326430abdffa6d8a8c21dc101a802cb193545fc1648b2c345c392aca3d899a1b648cf49f0d9e2885387358d8d6667cbd62c95fb012faab8365d5b84f0f20c878
-  data.tar.gz: 50a5b3f7b721d8f181dd533ecf53d2c2b0c4fcb417b8530af6b5fe060e9c5b4de7c5ec90e5d0737e27fb233385440716b6fb6f17e1aca4e9634a3a68ddaf957c
+  metadata.gz: ed58d38698b921144f4553212ff8e1172c65caa9851430df9d07c5fbdfb99b0f25d6182ec7afaba6414ab64f5333e841eda108f95f7f57221d99547720b7d98f
+  data.tar.gz: 38928ed605acb6deb62a6fa3e9d2e341312b0ae963418395626a147cad9d998649679d4d2df1164c746b4fcd3b98a1ab042dce3d282749958bb421ad9ea85287

data/CHANGES.md

@@ -1,3 +1,7 @@
+## 0.1.1 (2016-07-08)
+
+* Use a module to patch ::Thread
+
 ## 0.1.0 (2016-07-02)
 
 * Initial release.

data/Gemfile

@@ -2,6 +2,8 @@ source "https://rubygems.org"
 
 gemspec
 
+gem "celluloid"
+
 group :development, :test do
   gem "rake"
 end

data/README.md

@@ -32,9 +32,9 @@ The Timeout::Extensions gem enhances the Ruby standard library's
 `timeout.rb` API:
 
 ```ruby
-require 'timeout/extensions'
+require 'timeout'
 
-Timeout.new(30) do
+Timeout.timeout(30) do
   # Times out after 30 seconds raising Timeout::Error
 end
 ```
@@ -43,38 +43,136 @@ However, where `timeout.rb` provides one implementation, the Timeout Gem
 provides support for multiple, swappable backends:
 
 ```ruby
-require 'timeout/extensions'
-
-module MyTimeoutThingy
-  # WARNING: don't use this. It's just a strawman example
-  def self.timeout(secs)
-    current = Thread.current
-    sleeper = Thread.start do
-      begin
-        sleep secs
-      rescue => ex
-        current.raise ex
-      else
-        current.raise Timeout::Error, "execution expired" 
-      end
-    end
-    return yield(secs)
-  ensure
-    if sleeper
-      sleeper.kill
-      sleeper.join
+# examples/even_odd.rb
+require "timeout/extensions"
+
+module MyAwesomeJob
+  def self.perform
+    timeout(5) do
+      sleep 5 # perform incredibly heavy job
     end
+  rescue => e                      
+    puts "job failed: #{e.message}"
+  end
+end
+
+module MyOwnTimeout
+  CustomTimeoutError = Class.new(RuntimeError)
+  def self.call(sec, *)
+    puts "pretending to wait for #{sec} seconds..."
+    yield
   end
 end
 
+
+5.times.map do |i|
+  Thread.start do 
+    Thread.current.timeout_handler = MyOwnTimeout
+    MyAwesomeJob.perform
+  end
+end.join(&:join)
+__END__
+
+pretending to wait for 2 seconds...
+pretending to wait for 2 seconds...
+job failed: execution expired
+job failed: execution expired
+job failed: execution expired
+
+```
+
+You can also setup a timeout backend temporarily, for the duration of a block:
+
+```ruby
 Timeout.backend(MyTimeoutThingy) do
-  Timeout.new(30) do
+  Timeout.timeout(30) do
     # Manage timeouts with MyTimeoutThingy instead of timeout.rb
+    # MyTimeoutThingy just responds to #call(sec, ex)
     # Plug in your own backend just this easily!
   end
 end
 ```
 
+This library also supports setting your own sleep implementation:
+
+```ruby
+
+Thread.start do
+  Thread.current.sleep_handler = YourSleepHandler # must also respond to #call(Integer or nil)
+....
+```
+
+
+## Celluloid Support
+
+This gem provides celluloid support out of the box. 
+
+Celluloid has its own actor timeout and sleep methods, which are implemented using the ```timer``` gem and do not block its mailbox. These have to be called inside your celluloid actor context however, thereby limiting the scope of your code:
+
+```ruby
+# examples/celluloid.rb
+require "celluloid"
+
+module MyJob
+  def self.perform
+    puts "performing"
+    sleep 5
+    puts "performed!"
+  end
+end
+
+class Worker
+  include Celluloid
+  
+  def develop
+    MyJob.perform
+  end
+
+  def ten_times_developer
+    10.times.each { async(:develop) }
+  end
+end
+
+Worker.new.async(:ten_times_developer)
+
+sleep
+__END__
+performing
+performed!
+performing
+performed!
+performing
+performed!
+performing
+performed!
+performing
+performed!
+...
+```
+
+But if your had the extension in the first line:
+```
+require 'timeout/extensions/celluloid'
+....
+__END__
+performing
+performing
+performing
+performing
+performing
+performing
+performing
+performing
+performing
+performing
+performed!
+performed!
+performed!
+performed!
+performed!
+....
+```
+
 ## Supported Ruby Versions
 
 This library aims to support and is [tested against][travis] the following Ruby

data/examples/celluloid.rb

@@ -0,0 +1,25 @@
+require "timeout/extensions/celluloid"
+
+module MyJob
+  def self.perform
+    puts "performing"
+    sleep 5
+    puts "performed!"
+  end
+end
+
+class Worker
+  include Celluloid
+
+  def develop
+    MyJob.perform
+  end
+
+  def ten_times_developer
+    10.times.each { async(:develop) }
+  end
+end
+
+Worker.new.async(:ten_times_developer)
+
+sleep

data/examples/even_odd.rb

@@ -0,0 +1,26 @@
+require "timeout/extensions"
+
+module MyAwesomeJob
+  def self.perform
+    timeout(2) do
+      sleep 3 # perform incredibly heavy job
+    end
+  rescue => e
+    puts "job failed: #{e.message}"
+  end
+end
+
+module MyOwnTimeout
+  CustomTimeoutError = Class.new(RuntimeError)
+  def self.call(sec, *)
+    puts "pretending to wait for #{sec} seconds..."
+    yield
+  end
+end
+
+Array(5.times).map do |i|
+  Thread.start do
+    Thread.current.timeout_handler = MyOwnTimeout if i.odd?
+    MyAwesomeJob.perform
+  end
+end.map(&:join)

data/lib/timeout/extensions.rb

@@ -1,4 +1,5 @@
 require "timeout/extensions/version"
+require "timeout"
 
 # Core extensions to Thread
 #
@@ -48,3 +49,15 @@ module Timeout::Extensions
   #
   ::Object.prepend KernelMethods
 end
+
+module Timeout
+  def self.backend(handler)
+    default_handler = Thread.current.timeout_handler
+    begin
+      Thread.current.timeout_handler = handler
+      yield
+    ensure
+      Thread.current.timeout_handler = default_handler
+    end
+  end
+end

data/lib/timeout/extensions/celluloid.rb

@@ -0,0 +1,52 @@
+require "timeout/extensions"
+require "celluloid"
+module Celluloid
+  module TimeoutExtensions
+    def timeout_handler
+      @timeout_handler ||= Celluloid.method(:timeout)
+    end
+
+    def sleep_handler
+      @sleep_handler ||= Celluloid.method(:sleep)
+    end
+  end
+
+  # Reopening the thread class to define the time handlers and pointing them to celluloid respective methodsx
+  class Thread
+    include TimeoutExtensions
+  end
+
+  ####################
+  #
+  # Celluloid Monkey-Patch Alert!!!!
+  # I would really like to remove this but, but I first need this pull request accepted:
+  # https://github.com/celluloid/celluloid/pull/491
+  #
+  # These methods have kept the same functionality for quite some time, therefore are quite stable,
+  # I just moved the locations and updated/corrected the method signatures.
+  #
+  ###################
+
+  def self.timeout(duration, klass = nil)
+    bt = caller
+    task = Task.current
+    klass ||= TaskTimeout
+    timers = Thread.current[:celluloid_actor].timers
+    timer = timers.after(duration) do
+      exception = klass.new("execution expired")
+      exception.set_backtrace bt
+      task.resume exception
+    end
+    yield
+  ensure
+    timer.cancel if timer
+  end
+
+  class Actor
+    # Using the module method now instead of doing everything by itself.
+    def timeout(*args)
+      Celluloid.timeout(*args) { yield }
+    end
+    private :timeout
+  end
+end

data/lib/timeout/extensions/version.rb

@@ -1,3 +1,3 @@
 module Timeout::Extensions
-  VERSION = "0.1.0".freeze
+  VERSION = "0.1.1".freeze
 end

data/spec/timeout_spec.rb

@@ -0,0 +1,16 @@
+require "spec_helper"
+
+RSpec.describe Timeout do
+  describe ".backend" do
+    let(:handler) { double(:handler) }
+    it "allows to switch timeout backends on the fly" do
+      expect(Thread.current.timeout_handler).to be_nil
+      Timeout.backend(handler) do
+        expect(Thread.current.timeout_handler).to be(handler)
+        expect(handler).to receive(:call).with(2)
+        Timeout.timeout(2) {}
+      end
+      expect(Thread.current.timeout_handler).to be_nil
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: timeout-extensions
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Tony Arcieri
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-07-03 00:00:00.000000000 Z
+date: 2016-07-08 00:00:00.000000000 Z
 dependencies: []
 description: A timeout extension for Ruby which plugs into multiple timeout backends
 email:
@@ -27,11 +27,15 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- examples/celluloid.rb
+- examples/even_odd.rb
 - lib/timeout/extensions.rb
+- lib/timeout/extensions/celluloid.rb
 - lib/timeout/extensions/version.rb
 - log/.gitkeep
 - spec/spec_helper.rb
 - spec/timeout/extensions_spec.rb
+- spec/timeout_spec.rb
 - timeout-extensions.gemspec
 homepage: https://github.com/celluloid/timeout-extensions
 licenses:
@@ -60,3 +64,4 @@ summary: Extensions to the Ruby standard library's timeout API
 test_files:
 - spec/spec_helper.rb
 - spec/timeout/extensions_spec.rb
+- spec/timeout_spec.rb