jruby-rack-worker 0.9.1 → 0.10.0

data/LICENSE

@@ -186,7 +186,7 @@
       same "printed page" as the copyright notice for easier
       identification within third-party archives.
 
-   Copyright (c) 2010-2012 Karol Bucek
+   Copyright (c) 2010-2013 Karol Bucek
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.

data/README.md

@@ -2,9 +2,9 @@
 
 Thread based workers on top of [jruby-rack](http://github.com/jruby/jruby-rack).
 
-With out of the box thread-safe [JRuby](http://jruby.org) "adapters" for: 
+With out of the box thread-safe [JRuby](http://jruby.org) "adapters" for:
 
-* [Resque](http://github.com/defunkt/resque) (>= 1.20.0)
+* [Resque](http://github.com/defunkt/resque) (>= 1.20.0, ~> 2.0.0 [master])
 * [Delayed::Job](http://github.com/collectiveidea/delayed_job) (~> 2.1, >= 3.0)
 * [Navvy](http://github.com/jeffkreeftmeijer/navvy) (not-maintained)
 
@@ -14,25 +14,25 @@ With out of the box thread-safe [JRuby](http://jruby.org) "adapters" for:
 
 ## Motivation
 
-Ruby attempts to stay pretty close to UNIX and most popular workers have been 
-modeled the "spawn a background process" way. [JRuby](http://jruby.org) brings 
-Java to the table, where "Young Java Knights" are thought to use threads 
-whenever in a need to compute something parallel while serving requests.
+Ruby attempts to stay pretty close to UNIX and most popular workers have been
+modeled the "spawn a background process" way. [JRuby](http://jruby.org) brings
+Java to the table, where "Young Java Knights" are taught to use threads
+whenever in a need to compute something in parallel with serving requests.
 
 There's no right or wrong way of doing this. If you do expect chaos like Resque
-proclaims - have long running jobs that consume a lot of memory they have trouble 
+proclaims - have long running jobs that consume a lot of memory they have trouble
 releasing (e.g. due C extensions) run a separate process for sure.
-But otherwise (after all C exts usually have a native Java alternative on JRuby) 
-having predictable thread-safely written workers, one should be fine with 
+But otherwise (after all C exts usually have a native Java alternative on JRuby)
+having predictable thread-safely written workers, one should be fine with
 running them concurrently as part of the application in a (daemon) thread.
 
 This does have the advantage of keeping the deployment simple and saving some
-precious memory (most notably with `threadsafe!` mode) that would have been 
-eaten by the separate process. Besides, your application might warm up faster 
+precious memory (most notably with `threadsafe!` mode) that would have been
+eaten by the separate process. Besides, your application might warm up faster
 and start benefiting from JRuby's runtime optimalizations slightly sooner ...
 
-On the other hand your jobs should be fairly simple and complete "fast" (in a 
-rate of seconds rather than several minutes or hours) as they will live and 
+On the other hand your jobs should be fairly simple and complete "fast" (in a
+rate of seconds rather than several minutes or hours) as they will live and
 restart with the lifecycle of the deployed application and application server.
 
 
@@ -45,46 +45,64 @@ Configure your worker in **web.xml**, you will need to add a context listener
 that will start (daemon) threads when your application boots and a script to be
 executed (should be an "endless" loop-ing script). Sample configuration :
 
-    <context-param>
-      <param-name>jruby.worker.script</param-name>
-      <param-value> 
-        <!-- any script with an end-less loop : ->
-        require 'delayed/jruby_worker'
-        Delayed::JRubyWorker.new.start
-      </param-value>
-    </context-param>
-
-    <listener>
-      <listener-class>org.kares.jruby.rack.WorkerContextListener</listener-class>
-    </listener>
-
-The `WorkerContextListener` needs to be executed (and thus configured) after the 
-`RailsServletContextListener`/`RackServletContextListener` as it expects the 
+```xml
+  <context-param>
+    <param-name>jruby.worker.script</param-name>
+    <param-value>
+      <!-- any script with an end-less loop : ->
+      require 'delayed/jruby_worker'
+      Delayed::JRubyWorker.new.start
+    </param-value>
+  </context-param>
+
+  <listener>
+    <listener-class>org.kares.jruby.rack.WorkerContextListener</listener-class>
+  </listener>
+```
+
+The `WorkerContextListener` needs to be executed (and thus configured) after the
+`RailsServletContextListener`/`RackServletContextListener` as it expects the
 JRuby-Rack environment to be booter and available.
 
 For built-in worker support (if you're happy with the defaults) simply specify
 the **jruby.worker** context parameter (optionally with custom params supported
 by the worker) e.g. :
 
-    <context-param>
-      <param-name>jruby.worker</param-name>
-      <param-value>resque</param-value>
-    </context-param>
-    <context-param>
-      <param-name>QUEUES</param-name>
-      <param-value>mails,posts</param-value>
-    </context-param>
-    <context-param>
-      <param-name>INTERVAL</param-name>
-      <param-value>2.5</param-value>
-    </context-param>
-
-    <listener>
-      <listener-class>org.kares.jruby.rack.WorkerContextListener</listener-class>
-    </listener>
+```xml
+  <context-param>
+    <param-name>jruby.worker</param-name>
+    <param-value>resque</param-value>
+  </context-param>
+  <context-param>
+    <param-name>QUEUES</param-name>
+    <param-value>mails,posts</param-value>
+  </context-param>
+  <context-param>
+    <param-name>INTERVAL</param-name>
+    <param-value>2.5</param-value>
+  </context-param>
+
+  <listener>
+    <listener-class>org.kares.jruby.rack.WorkerContextListener</listener-class>
+  </listener>
+```
 
 Sample deployment descriptor including optional parameters:
-[web.xml](/kares/jruby-rack-worker/blob/master/src/test/resources/sample.web.xml).
+[web.xml](src/test/resources/sample.web.xml).
+
+### Threads
+
+Number of worker threads as well as their priorities can be configured (by
+default a single worker thread is started with the default NORM priority) :
+
+- *jruby.worker.thread.count* please be sure you do not start too many threads,
+  consider tuning your worker settings if possible first e.g. for DJ/Resque the
+  sleep interval if you feel like the worker is not performing enough work.
+- *jruby.worker.thread.priority* maps to standard (Java) thread priority which
+  is a value <MIN, MAX> where MIN == 1 and MAX == 10 (the NORM priority is 5),
+  this is useful e.g. if you're load gets high (lot of request serving threads)
+  and you do care about requests more than about executing worker code you might
+  consider decreasing the priority (by 1).
 
 ### Warbler
 
@@ -145,13 +163,16 @@ Warbler checks for a *config/web.xml.erb* thus configure the worker there, e.g.
 </web-app>
 ```
 
-If you're deploying a Rails application on JRuby it's highly **recommended** to 
-uncomment `config.threadsafe!`. Otherwise, if unsure or you're code is not 
-thread-safe yet you'll end up polling several JRuby runtimes in a single process, 
-in this case however each worker thread will use (block) an application runtime 
-from the pool (consider it while setting 
+If you're deploying a Rails application on JRuby it's highly **recommended** to
+uncomment `config.threadsafe!`. Otherwise, if unsure or you're code is not
+thread-safe yet you'll end up polling several JRuby runtimes in a single process,
+in this case however each worker thread will use (block) an application runtime
+from the pool (consider it while setting
 `jruby.min.runtimes` and `jruby.max.runtimes` parameters).
 
+### Trinidad
+
+Trinidad provides you with an [extension][1] so you do not have to deal with XML.
 
 ### Custom Workers
 
@@ -170,7 +191,7 @@ got a worker spawning script (e.g. a rake task) start there to write the worker
    class variables are not being used to store worker state)
 
  * refactor your worker's exit code from a (process oriented) signal based `trap`
-   to an `at_exit` hook - which respects the JRuby environment your workers are 
+   to an `at_exit` hook - which respects the JRuby environment your workers are
    going to be running in
 
 Keep in mind that if you do configure to use multiple threads the script will be
@@ -180,8 +201,8 @@ a separate file that you'll require from the script.
 See the [Delayed::Job](/kares/jruby-rack-worker/tree/master/src/main/ruby/delayed)
 JRuby "adapted" worker code for an inspiration.
 
-If you'd like to specify custom parameters you can do so in the deployment 
-descriptor as context init parameters or as java system properties, use the 
+If you'd like to specify custom parameters you can do so in the deployment
+descriptor as context init parameters or as java system properties, use the
 following code to obtain them :
 
 ```ruby
@@ -228,7 +249,8 @@ Build the gem (includes the .jar packaged) :
 
 ## Copyright
 
-Copyright (c) 2012 [Karol Bucek](https://github.com/kares). 
+Copyright (c) 2013 [Karol Bucek](https://github.com/kares).
 See LICENSE (http://www.apache.org/licenses/LICENSE-2.0) for details.
 
-[0]: https://secure.travis-ci.org/kares/jruby-rack-worker.png
+[0]: https://secure.travis-ci.org/kares/jruby-rack-worker.png
+[1]: https://github.com/trinidad/trinidad_worker_extension

data/lib/jruby/rack/worker/version.rb

@@ -1,7 +1,7 @@
 module JRuby
   module Rack
     module Worker
-      VERSION = '0.9.1'
+      VERSION = '0.10.0'
     end
   end
 end

metadata

@@ -1,75 +1,72 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: jruby-rack-worker
-version: !ruby/object:Gem::Version 
-  prerelease: 
-  version: 0.9.1
+version: !ruby/object:Gem::Version
+  prerelease:
+  version: 0.10.0
 platform: ruby
-authors: 
-  - Karol Bucek
-autorequire: 
+authors:
+- Karol Bucek
+autorequire:
 bindir: bin
 cert_chain: []
-
-date: 2013-01-07 00:00:00 Z
-dependencies: 
-  - !ruby/object:Gem::Dependency 
-    name: jruby-rack
-    version_requirements: &id001 !ruby/object:Gem::Requirement 
-      none: false
-      requirements: 
-        - - ">="
-          - !ruby/object:Gem::Version 
-            version: 1.1.10
-    requirement: *id001
-    prerelease: false
-    type: :runtime
+date: 2013-06-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: jruby-rack
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 1.1.10
+    none: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 1.1.10
+    none: false
+  prerelease: false
+  type: :runtime
 description: Implements a thread based worker pattern on top of JRuby-Rack. Useful if you'd like to run background workers within your (deployed) web-application (concurrently in 'native' threads) instead of using separate daemon processes. Provides (thread-safe) implementations for popular worker libraries such as Resque and Delayed::Job, but one can easily write their own 'daemon' scripts as well.
-email: 
-  - self@kares.org
+email:
+- self@kares.org
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
-  - README.md
-  - LICENSE
-  - lib/jruby-rack-worker_0.9.1.jar
-  - lib/jruby_rack_worker.rb
-  - lib/jruby/rack/worker.rb
-  - lib/jruby/rack/worker/env.rb
-  - lib/jruby/rack/worker/logger.rb
-  - lib/jruby/rack/worker/version.rb
+files:
+- LICENSE
+- README.md
+- lib/jruby-rack-worker_0.10.0.jar
+- lib/jruby/rack/worker.rb
+- lib/jruby/rack/worker/env.rb
+- lib/jruby/rack/worker/logger.rb
+- lib/jruby/rack/worker/version.rb
+- lib/jruby_rack_worker.rb
 homepage: http://github.com/kares/jruby-rack-worker
 licenses: []
-
-post_install_message: 
+post_install_message:
 rdoc_options: []
-
-require_paths: 
-  - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      segments:
+      - 0
+      hash: 2
+      version: '0'
   none: false
-  requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 2
-        segments: 
-          - 0
-        version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
   none: false
-  requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: "0"
 requirements: []
-
-rubyforge_project: "[none]"
+rubyforge_project: '[none]'
 rubygems_version: 1.8.24
-signing_key: 
+signing_key:
 specification_version: 3
 summary: Threaded Workers with JRuby-Rack
 test_files: []
-