rack_after_reply 0.0.1

data/CHANGELOG

@@ -0,0 +1,3 @@
+== 0.0.1 2011-05-10
+
+ * Hi.

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) George Ogata
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.markdown

@@ -0,0 +1,46 @@
+# Rack After Reply
+
+A hook for Rack apps which fires after the response has been sent, and
+the socket to the client has been closed.
+
+This is the ideal time to perform delayable, non-backgroundable tasks,
+such as garbage collection, stats gathering, flushing logs, etc.
+without affecting response times at all.
+
+## Usage
+
+Simply add your callbacks to `env['rack_after_reply.callbacks']`.
+
+    use Rack::ContentLength
+    use Rack::ContentType, 'text/plain'
+    run lambda { |env|
+      env['rack_after_reply.callbacks'] << lambda { ... }
+      [200, {}, ['hi']]
+    }
+
+## Support
+
+Rack After Request works with these web servers:
+
+ * [Mongrel](https://github.com/fauna/mongrel)
+ * [Passenger](http://www.modrails.com)
+ * [Thin](https://github.com/macournoyer/thin)
+ * [Unicorn](http://unicorn.bogomips.org)
+ * WEBrick (distributed with Ruby)
+
+To request support for other web servers, [open a ticket][issues] or
+submit a patch.
+
+[issues]: http://github.com/oggy/rack_after_reply/issues
+
+## Contributing
+
+ * [Bug reports](https://github.com/oggy/rack_after_reply/issues)
+ * [Source](https://github.com/oggy/rack_after_reply)
+ * Patches: Fork on Github, send pull request.
+   * Ensure patch includes tests.
+   * Leave the version alone, or bump it in a separate commit.
+
+## Copyright
+
+Copyright (c) George Ogata. See LICENSE for details.

data/Rakefile

@@ -0,0 +1 @@
+require 'ritual'

data/lib/rack_after_reply.rb

@@ -0,0 +1,39 @@
+require 'rack'
+
+module RackAfterReply
+  CALLBACKS_KEY = 'rack_after_reply.callbacks'.freeze
+
+  autoload :AppProxy, 'rack_after_reply/app_proxy'
+  autoload :Adapter, 'rack_after_reply/adapter'
+  autoload :RequestHandler, 'rack_after_reply/request_handler'
+
+  class << self
+    #
+    # Apply extensions for all loaded web servers.
+    #
+    def apply
+      Adapter::Thin.apply if defined?(::Thin)
+      Adapter::Mongrel.apply if defined?(::Mongrel)
+      Adapter::Passenger.apply if defined?(::PhusionPassenger)
+      Adapter::WEBrick.apply if defined?(::WEBrick)
+      Adapter::Unicorn.apply if defined?(::Unicorn)
+    end
+
+    def freedom_patch(mod, method) # :nodoc:
+      # Prevent infinite recursion if we've already done it.
+      return if mod.method_defined?("#{method}_without_rack_after_reply")
+
+      mod.module_eval do
+        alias_method "#{method}_without_rack_after_reply", method
+        alias_method method, "#{method}_with_rack_after_reply"
+      end
+    end
+
+    def freedom_extend(object, method) # :nodoc:
+      klass = (class << object; self; end)
+      freedom_patch(klass, method)
+    end
+  end
+end
+
+RackAfterReply.apply

data/lib/rack_after_reply/adapter.rb

@@ -0,0 +1,10 @@
+module RackAfterReply
+  module Adapter
+    autoload :Base, 'rack_after_reply/adapter/base'
+    autoload :Mongrel, 'rack_after_reply/adapter/mongrel'
+    autoload :Passenger, 'rack_after_reply/adapter/passenger'
+    autoload :Thin, 'rack_after_reply/adapter/thin'
+    autoload :Unicorn, 'rack_after_reply/adapter/unicorn'
+    autoload :WEBrick, 'rack_after_reply/adapter/webrick'
+  end
+end

data/lib/rack_after_reply/adapter/base.rb

@@ -0,0 +1,15 @@
+module RackAfterReply
+  module Adapter
+    class Base
+      def self.apply
+        return if defined?(@applied)
+        instance.apply
+        @applied = true
+      end
+
+      def self.instance
+        @instance ||= new
+      end
+    end
+  end
+end

data/lib/rack_after_reply/adapter/mongrel.rb

@@ -0,0 +1,25 @@
+module RackAfterReply
+  module Adapter
+    class Mongrel < Base
+      def apply
+        Rack::Handler::Mongrel.module_eval do
+          include RackAfterReply::RequestHandler
+
+          def initialize_with_rack_after_reply(app)
+            app = AppProxy.new(self, app)
+            initialize_without_rack_after_reply(app)
+          end
+          RackAfterReply.freedom_patch self, :initialize
+
+          def process_with_rack_after_reply(request, response)
+            process_without_rack_after_reply(request, response)
+          ensure
+            response.socket.close
+            fire_rack_after_reply
+          end
+          RackAfterReply.freedom_patch self, :process
+        end
+      end
+    end
+  end
+end

data/lib/rack_after_reply/adapter/passenger.rb

@@ -0,0 +1,23 @@
+module RackAfterReply
+  module Adapter
+    class Passenger < Base
+      def apply
+        PhusionPassenger::Rack::RequestHandler.module_eval do
+          include RackAfterReply::RequestHandler
+
+          def initialize_with_rack_after_reply(owner_pipe, app, options = {})
+            app = AppProxy.new(self, app)
+            initialize_without_rack_after_reply(owner_pipe, app, options)
+          end
+          RackAfterReply.freedom_patch self, :initialize
+
+          def accept_and_process_next_request_with_rack_after_reply(socket_wrapper, channel, buffer)
+            accept_and_process_next_request_without_rack_after_reply(socket_wrapper, channel, buffer)
+            fire_rack_after_reply
+          end
+          RackAfterReply.freedom_patch self, :accept_and_process_next_request
+        end
+      end
+    end
+  end
+end

data/lib/rack_after_reply/adapter/thin.rb

@@ -0,0 +1,17 @@
+module RackAfterReply
+  module Adapter
+    class Thin < Base
+      def apply
+        ::Thin::Connection.module_eval do
+          def pre_process_with_rack_after_reply
+            callbacks = []
+            @request.env[RackAfterReply::CALLBACKS_KEY] = callbacks
+            EM.next_tick { callbacks.each {|c| c.call} }
+            pre_process_without_rack_after_reply
+          end
+          RackAfterReply.freedom_patch self, :pre_process
+        end
+      end
+    end
+  end
+end

data/lib/rack_after_reply/adapter/unicorn.rb

@@ -0,0 +1,23 @@
+module RackAfterReply
+  module Adapter
+    class Unicorn < Base
+      def apply
+        ::Unicorn::HttpServer.module_eval do
+          include RackAfterReply::RequestHandler
+
+          def process_client_with_rack_after_reply(client)
+            # We can't install the AppProxy in #initialize, because
+            # the HttpServer is already instantiated by the time we
+            # typically run. Wrap it here exactly once.
+            self.app = AppProxy.new(self, app) unless @rack_after_reply_wrapped
+            @rack_after_reply_wrapped = true
+
+            process_client_without_rack_after_reply(client)
+            fire_rack_after_reply
+          end
+          RackAfterReply.freedom_patch(self, :process_client)
+        end
+      end
+    end
+  end
+end

data/lib/rack_after_reply/adapter/webrick.rb

@@ -0,0 +1,47 @@
+module RackAfterReply
+  module Adapter
+    class WEBrick < Base
+      def apply
+        # Rack::Handler::WEBrick#service returns before the socket is closed,
+        # and if we close it ourselves, WEBrick will close it again causing a
+        # bomb. We can access the socket through the response argument, though,
+        # so we hook into its #close method.
+        Rack::Handler::WEBrick.module_eval do
+          include RackAfterReply::RequestHandler
+
+          def initialize_with_rack_after_reply(server, app)
+            app = AppProxy.new(self, app)
+            initialize_without_rack_after_reply(server, app)
+          end
+          RackAfterReply.freedom_patch self, :initialize
+
+          def service_with_rack_after_reply(request, response)
+            response.extend ResponseExtension
+            response.rack_after_reply_handler = self
+            service_without_rack_after_reply(request, response)
+          end
+          RackAfterReply.freedom_patch self, :service
+        end
+      end
+
+      module ResponseExtension
+        def send_response(socket)
+          socket.extend SocketExtension
+          socket.rack_after_reply_handler = rack_after_reply_handler
+          super
+        end
+
+        attr_accessor :rack_after_reply_handler
+      end
+
+      module SocketExtension
+        def close
+          super
+          rack_after_reply_handler.fire_rack_after_reply
+        end
+
+        attr_accessor :rack_after_reply_handler
+      end
+    end
+  end
+end

data/lib/rack_after_reply/app_proxy.rb

@@ -0,0 +1,32 @@
+module RackAfterReply
+  #
+  # Wraps a Rack app to intercept the rack environment passed to #call
+  # for access by the request handler after the socket is closed.
+  #
+  class AppProxy
+    def initialize(request_handler, app)
+      @request_handler = request_handler
+      @app = app
+    end
+
+    def call(env)
+      callbacks = []
+      env[RackAfterReply::CALLBACKS_KEY] = callbacks
+      @request_handler.rack_after_reply_callbacks = callbacks
+      @app.call(env)
+    end
+
+    def method_missing(name, *args, &block)
+      class_eval <<-EOS
+        def #{name}(*args, &block)
+          @app.#{name}(*args, &block)
+        end
+      EOS
+      send(name, *args, &block)
+    end
+
+    def respond_to?(name, include_private=false)
+      super || @app.respond_to?(name, include_private)
+    end
+  end
+end

data/lib/rack_after_reply/request_handler.rb

@@ -0,0 +1,18 @@
+module RackAfterReply
+  module RequestHandler
+    attr_accessor :rack_after_reply_callbacks
+
+    def fire_rack_after_reply
+      # Ensure we only fire the hook once. Passenger runs its request
+      # handler when shutting down, causing an infinite loop if we
+      # don't check for this.
+      rack_after_reply_callbacks or
+        return
+
+      rack_after_reply_callbacks.each do |callback|
+        callback.call
+      end
+      self.rack_after_reply_callbacks = nil
+    end
+  end
+end

data/lib/rack_after_reply/version.rb

@@ -0,0 +1,11 @@
+module RackAfterReply
+  VERSION = [0, 0, 1]
+
+  class << VERSION
+    include Comparable
+
+    def to_s
+      join('.')
+    end
+  end
+end

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification 
+name: rack_after_reply
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- George Ogata
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-05-10 00:00:00 -04:00
+default_executable: 
+dependencies: []
+
+description: 
+email: 
+- george.ogata@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.markdown
+files: 
+- lib/rack_after_reply/adapter/base.rb
+- lib/rack_after_reply/adapter/mongrel.rb
+- lib/rack_after_reply/adapter/passenger.rb
+- lib/rack_after_reply/adapter/thin.rb
+- lib/rack_after_reply/adapter/unicorn.rb
+- lib/rack_after_reply/adapter/webrick.rb
+- lib/rack_after_reply/adapter.rb
+- lib/rack_after_reply/app_proxy.rb
+- lib/rack_after_reply/request_handler.rb
+- lib/rack_after_reply/version.rb
+- lib/rack_after_reply.rb
+- LICENSE
+- README.markdown
+- Rakefile
+- CHANGELOG
+has_rdoc: true
+homepage: http://github.com/oggy/rack_after_reply
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 1
+      - 3
+      - 6
+      version: 1.3.6
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Rack hook which fires after the socket to the client is closed.
+test_files: []
+