rack-worker 0.0.1.rc2 → 0.0.1.rc3

data/Gemfile

@@ -2,3 +2,11 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in rack-worker.gemspec
 gemspec
+
+group :test do
+  gem 'rr'
+  gem 'turn'
+  gem 'webmock'
+  gem 'rack-test', :require => 'rack/test'
+  gem 'sinatra', :require => 'sinatra/base'
+end

data/README.md

@@ -1,6 +1,25 @@
 # Rack::Worker
 
-TODO: Write a gem description
+  Rack middleware that implements the Worker Pattern.
+
+  It processes GET requests with a worker backend and only serves them straight from a cache.  
+  While processing the request it serves empty HTTP 202 responses.
+  Your web frontend is never blocked processing the request.
+
+
+## How it works
+
+  When GET requests hit your app, the middleware tries to serve them from the cache.
+
+  If the request is not found, it stores the environment data in the cache.  A worker
+  process will then use the `App.call(env)` convention from Rack to run the request through
+  your webapp in the background as if it were a normal Rack request.  The status, headers,
+  and body are then stored in the cache so they can be served.  
+
+  What makes this technique different from a standard HTTP caching approach is that your
+  web server never processes the long HTTP request.  The middleware will return empty 
+  HTTP 202 responses unless the response is found in the cache.  Every request that generates
+  a 202 will only queue one background job per URL.
 
 ## Installation
 
@@ -18,7 +37,36 @@ Or install it yourself as:
 
 ## Usage
 
-TODO: Write usage instructions here
+```ruby
+class  App < Sinatra::Base
+  use Rack::Worker
+
+  get '/long_ass_request' do
+    long_ass_work
+  end
+end
+```
+
+That's it! Now GETs to `/long_ass_request` will be processed in the background and only
+serve HTTP 202 responses until they are processed, after which they will return whatever your
+app would have returned.
+
+If you already have `queue_classic` and `dalli` installed, everything will *just work*.
+
+See configuration for setting an expiry time on records.
+
+## Configuration
+
+```ruby
+  Rack::Worker.cache = Dalli::Client.new(nil, {:expires_in => 300})
+```
+The `cache` can be anything that responds to `get(key)` and `set(key, string)`
+
+```ruby
+  Rack::Worker.queue = QC
+```
+The `queue` can be anything that responds to `enqueue(method, *params)` 
+
 
 ## Contributing
 

data/lib/rack/worker/version.rb

@@ -1,5 +1,5 @@
 module Rack
   class Worker
-    VERSION = '0.0.1.rc2'
+    VERSION = '0.0.1.rc3'
   end
 end

data/lib/rack/worker.rb

@@ -1,4 +1,5 @@
 require 'rack/worker/version'
+require 'json'
 
 module Rack
   class Worker
@@ -40,8 +41,8 @@ module Rack
         else
           unless cache.get("env-#{key}")
             cache.set("env-#{key}", env.to_json)
-            queue.enqueue("#{self.class.name}.process_request", 
-                       @app.class.name, key)
+            name = @app.is_a?(Class) ? @app.name : @app.class.name
+            queue.enqueue("#{self.class.name}.process_request", name, key)
           end
           [202, {"Content-type" => "text/plain"}, []]
         end
@@ -51,7 +52,7 @@ module Rack
     def self.process_request(classname, id)
       env = cache.get("env-#{id}")
       return unless env
-      env = Yajl::Parser.parse(env)
+      env = JSON.parse(env)
       app = classname_to_class(classname) 
       status, headers, body = app.call(env.merge('rack.worker_qc' => true))
       set_response(id, status, headers, body)
@@ -68,11 +69,11 @@ module Rack
     def get_response(key)
       response = cache.get("response-#{key}") 
       return unless response
-      Yajl::Parser.parse(response)
+      JSON.parse(response)
     end
 
     def key(env)
-      env['REQUEST_PATH'] + '?' + env['QUERY_STRING']
+      (env['REQUEST_PATH'] || env['PATH_INFO']) + '?' + env['QUERY_STRING']
     end
   end
 end

data/rack-worker.gemspec

@@ -14,4 +14,6 @@ Gem::Specification.new do |gem|
   gem.name          = "rack-worker"
   gem.require_paths = ["lib"]
   gem.version       = Rack::Worker::VERSION
+
+  gem.add_dependency 'json'
 end

data/test/test_helper.rb

@@ -0,0 +1,14 @@
+require 'bundler'
+Bundler.require :test
+require 'webmock/test_unit'
+require "#{File.dirname(__FILE__)}/../lib/rack-worker"
+
+class Rack::Worker::TestCase < Test::Unit::TestCase
+  include Rack::Test::Methods
+  include RR::Adapters::TestUnit
+
+  def teardown
+    super
+    WebMock.reset!
+  end
+end

data/test/worker_test.rb

@@ -0,0 +1,110 @@
+require 'test_helper'
+
+module QueueTest
+  def test_processes_request_in_queue
+    Rack::Worker.cache = Object.new
+    mock(Rack::Worker.cache).get('response-/foo?') { false }
+    mock(Rack::Worker.cache).get('env-/foo?') { false }
+    mock(Rack::Worker.cache).get('env-/foo?') { {'rack.input' => []}.to_json }
+    mock(Rack::Worker.cache).set('env-/foo?', is_a(String))
+    mock(Rack::Worker.cache).set('response-/foo?', is_a(String))
+
+    mock_queue = Object.new
+    def mock_queue.enqueue(function_call, *args)
+      eval("#{function_call} *args")
+    end
+    Rack::Worker.queue = mock_queue
+
+    get '/foo'
+    assert_equal 202, last_response.status
+  end
+end
+
+class WorkerTest < Rack::Worker::TestCase
+  include QueueTest
+  class TestClassApp
+    def self.call(env)
+      [200, {"Content-Type" => "text/test"}, ['Hello, world']]
+    end
+  end
+
+  def app
+    Rack::Builder.new do
+      use Rack::Worker
+      run TestClassApp
+    end
+  end
+
+  def test_returns_empty_202_and_queues_when_not_in_cache_or_queue
+    Rack::Worker.cache = Object.new
+    mock(Rack::Worker.cache).get('response-/foo?') { false }
+    mock(Rack::Worker.cache).get('env-/foo?')      { false }
+    stub(Rack::Worker.cache).set
+
+    Rack::Worker.queue = Object.new
+    mock(Rack::Worker.queue).enqueue('Rack::Worker.process_request', is_a(String), '/foo?')
+
+    get '/foo' 
+    assert_equal 202, last_response.status
+    assert_equal '', last_response.body
+  end
+
+  def test_returns_empty_202_and_does_not_queue_when_not_in_cache_and_in_queue
+    Rack::Worker.cache = Object.new
+    mock(Rack::Worker.cache).get('response-/foo?') { false }
+    mock(Rack::Worker.cache).get('env-/foo?')      { true }
+
+    get '/foo' 
+    assert_equal 202, last_response.status
+    assert_equal '', last_response.body
+  end
+
+  def test_returns_response_in_queue
+    json = "{\"Hello\":\"World\"}"
+    Rack::Worker.cache = Object.new
+    mock(Rack::Worker.cache).get('response-/foo?') do
+      [302, {"Content-Type" => "application/json"}, [json]].to_json
+    end
+
+    get '/foo'
+    assert_equal 302, last_response.status
+    assert_equal 'application/json', last_response.headers['Content-Type']
+    assert_equal json, last_response.body
+  end
+
+end
+
+class SinatraTest < Rack::Worker::TestCase 
+  include QueueTest
+
+  class TestClassApp < Sinatra::Base
+    get '*' do
+      headers 'Content-Type' => 'text/test'
+      'Hello, world'
+    end
+  end
+
+  def app
+    Rack::Builder.new do
+      use Rack::Worker
+      run TestClassApp
+    end
+  end
+end
+
+class SinatraUseTest < Rack::Worker::TestCase 
+  include QueueTest
+
+  class TestClassApp < Sinatra::Base
+    use Rack::Worker
+
+    get '*' do
+      headers 'Content-Type' => 'text/test'
+      'Hello, world'
+    end
+  end
+
+  def app
+    TestClassApp
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rack-worker
 version: !ruby/object:Gem::Version
-  version: 0.0.1.rc2
+  version: 0.0.1.rc3
   prerelease: 6
 platform: ruby
 authors:
@@ -10,7 +10,18 @@ autorequire:
 bindir: bin
 cert_chain: []
 date: 2012-04-12 00:00:00.000000000 Z
-dependencies: []
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: &70334749515180 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70334749515180
 description: Rack middleware that implements the Worker Pattern
 email:
 - christopher.continanza@gmail.com
@@ -27,6 +38,8 @@ files:
 - lib/rack/worker.rb
 - lib/rack/worker/version.rb
 - rack-worker.gemspec
+- test/test_helper.rb
+- test/worker_test.rb
 homepage: ''
 licenses: []
 post_install_message: 
@@ -53,4 +66,6 @@ specification_version: 3
 summary: Processes GET requests with a worker backend and only serves them straight
   from a cache.  Your web frontend is never blocked processing the request. Implementation
   of the Worker Pattern
-test_files: []
+test_files:
+- test/test_helper.rb
+- test/worker_test.rb