extreme_timeout 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4a13e67993632a9392a673e855283c2861ebdd85
-  data.tar.gz: 2560ded553a334cff47f21ef060529813c802745
+  metadata.gz: 76d98ba4c245814afabec6e1f5fc5a23d3eee686
+  data.tar.gz: 4ce0b834aa9ee9bf52cc087208850cda2a3bee85
 SHA512:
-  metadata.gz: 7cdb2260b5d15f9f83214fbc84ec0ef69728e6772ae59b7167d3f22a289c2c39dc014af56c8e80d7a7a60238e8fb179faa33859a0b966add79a3b5a549991256
-  data.tar.gz: 3fa034f942193b921fdd6e2a3ade11806c2e2858987cff03a72f198c23953db6fd62e9f048b130d92f8f15367a1110d934dab0e0d124e3e75650395827f6fcf7
+  metadata.gz: 7545df380d0d7c3f41b367e4f0019e8f3b224ddae253c6b7158029f61a8e4c336184873038bfdac71d4b15266ca4b7daa10c7ce3c39dbf084b078a9ee9714976
+  data.tar.gz: 31f5f53757e9b8b5129f41ca60f222d1db8b437be343113172bd1b64e137c878947e7cc73924068fa49cd3a5e8c11c87081422a5bf14b29b1dfbd4cd685c6827

data/README.md

@@ -3,32 +3,39 @@
 Do it in 40 seconds, or die.
 
     require 'extreme_timeout'
-    ExtremeTimeout::timeout(40) do
+    ExtremeTimeout::timeout(40, 42) do
       do_something
     end
 
-## Installation
+If `do_something` doesn't return in 40 seconds, ExtremeTimeout forcibly
+terminates the interpreter with exitcode 42.
 
-Add this line to your application's Gemfile:
+## Why do I need this?
 
-    gem 'extreme_timeout'
+Let us assume that we want to set a timeout for some work. You might write a
+code like this:
 
-And then execute:
+    require 'timeout'
+    Timeout::timeout(40) do
+      do_something
+    end
 
-    $ bundle
+It is okay in the normal case. But sometimes you have to get along with a
+C-extension that holds the GVL for a long time. In this case, the code above
+doesn't work as intended. The `timeout` library uses a ruby level thread to
+accomplish its task, and there is no chance to get a control to that thread
+under the situation that some C-extension is working with holding the GVL.
 
-Or install it yourself as:
+## Solution
 
-    $ gem install extreme_timeout
+Run a native thread that is not controlled by the interpreter. Since it is not
+controlled by the interpreter, it can work freely without considering the GVL.
+`ExtremeTimeout` creates a new native thread and sleeps for some seconds and
+terminates the process.
 
 ## Usage
 
-TODO: Write usage instructions here
-
-## Contributing
+You can use this almost same as `timeout` library. Instead of the exception
+class, you should specify the exitcode.
 
-1. Fork it
-2. Create your feature branch (`git checkout -b my-new-feature`)
-3. Commit your changes (`git commit -am 'Add some feature'`)
-4. Push to the branch (`git push origin my-new-feature`)
-5. Create new Pull Request
+    ExtremeTimeout::timeout(timeouse_sec, exitcode=1, &block)

data/ext/extreme_timeout/extconf.rb

@@ -1,2 +1,3 @@
 require 'mkmf'
+have_func('backtrace', 'execinfo.h')
 create_makefile('extreme_timeout')

data/ext/extreme_timeout/extreme_timeout.c

@@ -3,19 +3,73 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <unistd.h>
+#include <signal.h>
+#if defined(HAVE_BACKTRACE) && !defined(__APPLE__)
+# include <execinfo.h>
+#endif
+
+static pthread_mutex_t exitcode_mutex = PTHREAD_MUTEX_INITIALIZER;
+static int exitcode;
 
 struct wait_args {
     unsigned int timeout_sec;
     int exitcode;
+    pthread_t running_thread;
 };
 
+static void
+stacktrace_dumper(int signum)
+{
+    #define MAX_TRACES 1024
+    static void *trace[MAX_TRACES];
+    int n;
+    VALUE backtrace_arr;
+
+    backtrace_arr = rb_make_backtrace();
+    fprintf(stderr,
+            "-- Ruby level backtrace --------------------------------------\n");
+    rb_io_puts(1, &backtrace_arr, rb_stderr);
+    fprintf(stderr, "\n");
+
+    fprintf(stderr,
+            "-- C level backtrace -----------------------------------------\n");
+#if defined(HAVE_BACKTRACE) && !defined(__APPLE__)
+    n = backtrace(trace, MAX_TRACES);
+    backtrace_symbols_fd(trace, n, STDERR_FILENO);
+#elif defined(HAVE_BACKTRACE) && defined(__APPLE__)
+    fprintf(stderr,
+            "C level backtrace is unavailable due to the bug in the OSX's environment.\nSee r39301 and r39808 of CRuby for the details.\n");
+#else
+    fprintf(stderr,
+            "C level backtrace is unavailable because backtrace(3) is unavailable.\n")
+#endif
+    exit(exitcode);
+}
+
+static void
+set_stacktrace_dumper(void)
+{
+    struct sigaction sa;
+    sigfillset(&sa.sa_mask);
+    sa.sa_handler = stacktrace_dumper;
+    sigaction(SIGCONT, &sa, NULL);
+}
+
 void *
 sleep_thread_main(void *_arg)
 {
     struct wait_args *arg = _arg;
     sleep(arg->timeout_sec);
-    fprintf(stderr, "Process exits(ExtremeTimeout::timeout)");
-    exit(arg->exitcode);
+    fprintf(stderr, "Process exits(ExtremeTimeout::timeout)\n");
+    fflush(stderr);
+
+    pthread_mutex_lock(&exitcode_mutex);
+    exitcode = arg->exitcode;
+    set_stacktrace_dumper();
+    if (pthread_kill(arg->running_thread, SIGCONT) == 0) {
+        pthread_join(arg->running_thread, NULL);
+    }
+    return NULL;
 }
 
 VALUE
@@ -49,6 +103,7 @@ timeout(int argc, VALUE *argv, VALUE self)
 
     arg.timeout_sec = timeout_sec;
     arg.exitcode = exitcode;
+    arg.running_thread = pthread_self();
     if (pthread_create(&thread, NULL, sleep_thread_main, &arg) != 0) {
         rb_raise(rb_eRuntimeError, "pthread_create was failed");
     }

data/extreme_timeout.gemspec

@@ -1,7 +1,7 @@
 # coding: utf-8
 Gem::Specification.new do |spec|
   spec.name          = "extreme_timeout"
-  spec.version       = "0.2.1"
+  spec.version       = "0.3.0"
   spec.authors       = ["Masaya SUZUKI"]
   spec.email         = ["draftcode@gmail.com"]
   spec.description   = "Timeout from the outside of the GVL"

data/spec/extreme_timeout_spec.rb

@@ -1,5 +1,4 @@
 require 'spec_helper'
-require 'extreme_timeout'
 
 describe ExtremeTimeout do
   describe '.timeout' do
@@ -32,14 +31,47 @@ describe ExtremeTimeout do
       expect { ExtremeTimeout::timeout(3) }.to raise_error(ArgumentError)
     end
 
+    def redirectio_fork(&block)
+      stdout_r, stdout_w = IO.pipe
+      stderr_r, stderr_w = IO.pipe
+      pid = fork do
+        $stdout.reopen(stdout_w)
+        $stderr.reopen(stderr_w)
+        block.call
+      end
+      stdout_w.close
+      stderr_w.close
+      return pid, stdout_r, stderr_r
+    end
+
     it 'exits the process when timeout' do
-      pending "This test will terminate the whole rspec process"
-      ExtremeTimeout::timeout(1) { sleep }
+      pid, = redirectio_fork do
+        ExtremeTimeout::timeout(1) { sleep }
+      end
+      Timeout.timeout(3) do
+        pid, status = Process.waitpid2(pid)
+        expect(status.exitstatus).to eq(1)
+      end
     end
 
     it 'exits the process with the exit code specified when timeout' do
-      pending "This test will terminate the whole rspec process"
-      ExtremeTimeout::timeout(1, 5) { sleep }
+      pid, = redirectio_fork do
+        ExtremeTimeout::timeout(1, 5) { sleep }
+      end
+      Timeout.timeout(3) do
+        pid, status = Process.waitpid2(pid)
+        expect(status.exitstatus).to eq(5)
+      end
+    end
+
+    it 'outputs timeout message to stderr' do
+      pid, stdout, stderr = redirectio_fork do
+        ExtremeTimeout::timeout(1) { sleep }
+      end
+      Timeout.timeout(3) do
+        Process.waitpid(pid)
+        expect(stderr.read).to start_with("Process exits(ExtremeTimeout::timeout)\n")
+      end
     end
   end
 end

data/spec/spec_helper.rb

@@ -4,6 +4,9 @@
 # loaded once.
 #
 # See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+require 'extreme_timeout'
+require 'timeout'
+
 ext = File.expand_path('../../ext', __FILE__)
 $LOAD_PATH.unshift(ext) unless $LOAD_PATH.include?(ext)
 RSpec.configure do |config|

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: extreme_timeout
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors:
 - Masaya SUZUKI
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-10-17 00:00:00.000000000 Z
+date: 2013-12-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler