hupper 0.0.1

data/.gitignore

@@ -0,0 +1,6 @@
+*~
+/.rspec
+/Gemfile.lock
+*.gem
+.bundle
+pkg/*

data/Gemfile

@@ -0,0 +1,4 @@
+source :rubygems
+
+# Specify your gem's dependencies in Hupper.gemspec
+gemspec

data/Hupper.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "hupper"
+
+Gem::Specification.new do |s|
+  s.name        = "hupper"
+  s.version     = Hupper::VERSION
+  s.authors     = ["Alexander Staubo"]
+  s.email       = ["alex@origo.no"]
+  s.homepage    = ""
+  s.summary     = s.description = %q{Hupper is a tiny library that provides a generic mechanism to execute snippets of code before and after forking processes.}
+
+  s.rubyforge_project = "hupper"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency "rspec"
+end

data/LICENSE

@@ -0,0 +1,7 @@
+Copyright © 2011 Alexander Staubo
+
+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.md

@@ -0,0 +1,60 @@
+Hupper
+======
+
+Hupper is a tiny library that provides a generic mechanism to execute snippets of code before and after forking processes. 
+
+According to Unix semantics, files and sockets must be closed and reopened when passing the boundary between the parent and the child process.
+
+Hupper lets an application or library to fork its process without having to know about all such dependencies.
+
+Hupper is ideally combined with [Unicorn](http://unicorn.bogomips.org/). See below for an example.
+
+Typical usage
+-------------
+
+Here's an example that controls ActiveRecord's connection:
+
+    Hupper.on_initialize do
+      ActiveRecord::Base.establish_connection
+    end
+
+    Hupper.on_release do
+      ActiveRecord::Base.connection.disconnect!
+    end
+
+Now you can do:
+
+    Hupper.release!
+    Process.fork do
+      Hupper.initialize!
+      #
+      # ... implement child process
+      #
+    end
+
+Using with Unicorn
+------------------
+
+In your `unicorn.rb` configuration file, put:
+
+    before_fork do |server, worker|
+      Hupper.release!
+    end
+
+    after_fork do |server, worker|
+      Hupper.initialize!
+    end
+
+Using SIGHUP
+------------
+
+In order to respond to the standard Unix signal `SIGHUP`:
+
+    Hupper.hook_signal!
+
+When the application receives `SIGHUP`, the release handles will be called first, followed by the initialize handlers.
+
+License
+-------
+
+Licensed under the MIT license. See `LICENSE` file.

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/hupper.rb

@@ -0,0 +1,62 @@
+require 'thread'
+
+# Hupper is a simple mechanism
+module Hupper
+
+  VERSION = '0.0.1'
+
+  class << self
+
+    # Register an initialization block and call it.
+    def on_initialize(&block)
+      MUTEX.synchronize do
+        @@on_initialize_blocks.push(block)
+      end
+      return yield block
+    end
+
+    # Register a shutdown block and call it.
+    def on_release(&block)
+      MUTEX.synchronize do
+        @@on_release_blocks.push(block)
+      end
+      nil
+    end
+
+    def initialize!
+      MUTEX.synchronize { @@on_initialize_blocks.dup }.each do |block|
+        block.call
+      end
+    end
+
+    def release!
+      MUTEX.synchronize { @@on_release_blocks.dup }.each do |block|
+        block.call
+      end
+    end
+
+    # Hooks +SIGHUP+ signal.
+    def hook_signal!(signal_name = 'HUP')
+      unless @@previous_hup_handler
+        @@current_hup_handler = proc {
+          release!
+          initialize!
+          if @@previous_hup_handler.is_a?(Proc) and @@previous_hup_handler != @@current_hup_handler
+            @@previous_hup_handler.call
+          end
+        }
+        @@previous_hup_handler = Signal.trap(signal_name, &@@current_hup_handler)
+      end
+    end
+
+    private
+
+      @@on_initialize_blocks ||= []
+      @@on_release_blocks ||= []
+      @@previous_hup_handler ||= nil
+
+      MUTEX = Mutex.new
+
+  end
+
+end

data/spec/hupper_spec.rb

@@ -0,0 +1,96 @@
+require 'spec_helper'
+
+describe Hupper do
+
+  describe "#on_initialize" do
+    it 'returns block result' do
+      Hupper.on_initialize { 42 }.should == 42
+    end
+
+    it 'runs block' do
+      list = []
+      Hupper.on_initialize { list << 42 }
+      list.should == [42]
+    end
+  end
+
+  describe "#on_release" do
+    it 'returns nil' do
+      Hupper.on_release { 42 }.should == nil
+    end
+
+    it 'does not run block' do
+      list = []
+      Hupper.on_release { list << 42 }
+      list.should == []
+    end
+  end
+
+  describe "#initialize!" do
+    it 'works with no blocks' do
+      lambda { Hupper.initialize! }.should_not raise_error
+    end
+
+    it 'runs registered blocks' do
+      list = []
+      Hupper.on_initialize { list << 42 }
+      Hupper.initialize!
+      list.should == [42, 42]
+    end
+  end
+
+  describe "#release!" do
+    it 'works with no blocks' do
+      lambda { Hupper.release! }.should_not raise_error
+    end
+
+    it 'runs registered blocks' do
+      block = proc { }
+      block.should_receive(:call).exactly(1).times
+      Hupper.on_release(&block)
+      Hupper.release!
+    end
+  end
+
+  describe "#hook_signal!" do
+    it 'hooks signal' do
+      Signal.should_receive(:trap).with('HUP')
+      Hupper.hook_signal!
+    end
+
+    it 'calls #initialize! and #release! on signal' do
+      Hupper.class_variable_set('@@previous_hup_handler', nil)
+      Hupper.class_variable_set('@@current_hup_handler', nil)
+
+      registered_block = nil
+      Signal.should_receive(:trap) { |*args, &block| 
+        registered_block = block
+      }
+
+      Hupper.hook_signal!
+
+      Hupper.should_receive(:initialize!).once
+      Hupper.should_receive(:release!).once
+      registered_block.call
+    end
+
+    it 'chains previous signal handler' do
+      Hupper.class_variable_set('@@previous_hup_handler', nil)
+      Hupper.class_variable_set('@@current_hup_handler', nil)
+
+      previous_block = proc { }
+      Signal.trap('HUP', &previous_block)
+
+      registered_block = nil
+      Signal.should_receive(:trap) { |*args, &block| 
+        registered_block = block
+        previous_block
+      }
+      Hupper.hook_signal!
+
+      previous_block.should_receive(:call).once
+      registered_block.call
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+$:.unshift(File.expand_path('../../lib', __FILE__))
+
+require 'hupper'

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification 
+name: hupper
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Alexander Staubo
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-12-02 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
+description: Hupper is a tiny library that provides a generic mechanism to execute snippets of code before and after forking processes.
+email: 
+- alex@origo.no
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- Hupper.gemspec
+- LICENSE
+- README.md
+- Rakefile
+- lib/hupper.rb
+- spec/hupper_spec.rb
+- spec/spec_helper.rb
+homepage: ""
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: hupper
+rubygems_version: 1.8.6
+signing_key: 
+specification_version: 3
+summary: Hupper is a tiny library that provides a generic mechanism to execute snippets of code before and after forking processes.
+test_files: 
+- spec/hupper_spec.rb
+- spec/spec_helper.rb