blessing 1.0.0

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,16 @@
+source "http://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+
+gem 'unicorn'
+gem 'daemons'
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "rspec", "~> 2.3.0"
+  gem "bundler", "~> 1.0.0"
+  gem "jeweler", "~> 1.6.0"
+  gem "rcov", ">= 0"
+end

data/Gemfile.lock

@@ -0,0 +1,38 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    daemons (1.1.4)
+    diff-lcs (1.1.3)
+    git (1.2.5)
+    jeweler (1.6.4)
+      bundler (~> 1.0)
+      git (>= 1.2.5)
+      rake
+    kgio (2.6.0)
+    rack (1.2.3)
+    raindrops (0.7.0)
+    rake (0.9.2)
+    rcov (0.9.10)
+    rspec (2.3.0)
+      rspec-core (~> 2.3.0)
+      rspec-expectations (~> 2.3.0)
+      rspec-mocks (~> 2.3.0)
+    rspec-core (2.3.1)
+    rspec-expectations (2.3.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.3.0)
+    unicorn (4.1.0)
+      kgio (~> 2.4)
+      rack
+      raindrops (~> 0.6)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.0.0)
+  daemons
+  jeweler (~> 1.6.0)
+  rcov
+  rspec (~> 2.3.0)
+  unicorn

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Laas Toom
+
+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.rdoc

@@ -0,0 +1,50 @@
+= blessing
+
+A group of Unicorns is called a blessing.
+
+Blessing is a script to manage multiple Unicorn Rack servers.
+
+== Install
+
+    gem install blessing
+
+== Run
+
+Blessing CLI script takes at least one argument, which provides a list of Unicorn configuration files and then
+starts Unicorn instances from them.
+
+    blessing /var/www/rails_app/config/unicorn.conf
+
+    blessing /var/www/*/config/unicorn.conf
+
+    blessing /var/vhosts/**/config/unicorn.conf
+
+After starting the servers, Blessing keeps monitoring the given list of configurations and reacts to the following events:
+
+* when a conf file is changed, restarts the corresponding Unicorn instance
+* when a new conf is found (via globbing), starts a new instance
+* when a conf is removed, stops the corresponding instance
+
+== Signalling
+
+Blessing reacts to the following signals:
+
+* _INT_, _TERM_ - shut down Blessing group gracefully
+* _USR1_ - immediately rerun verification cycle
+* _USR2_ - try to resurrect dead Unicorns
+
+== Contributing to blessing
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
+* Fork the project
+* Start a feature/bugfix branch
+* Commit and push until you are happy with your contribution
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+== Copyright
+
+Copyright (c) 2011 Laas Toom. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,49 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "blessing"
+  gem.homepage = "http://github.com/borgand/blessing"
+  gem.license = "MIT"
+  gem.summary = %Q{Manage a group of Unicorn! Rack servers.}
+  gem.description = %Q{A group of Unicorns is called a blessing. Blessing gem provides an easy way to manage multiple Unicorn! Rack servers.}
+  gem.email = "laas.toom@gmail.com"
+  gem.authors = ["Laas Toom"]
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+RSpec::Core::RakeTask.new(:rcov) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "blessing #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+1.0.0

data/bin/blessing

@@ -0,0 +1,67 @@
+#!/usr/bin/env ruby
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+
+require 'blessing'
+require 'optparse'
+require 'daemons'
+
+opts = Blessing::Leader::DefaultOptions
+daemonize = false
+
+optparse = OptionParser.new do |o|
+  o.banner = "USAGE #{File.basename $0} [options] pattern [pattern2 ...]"
+
+  o.separator ""
+
+  o.separator <<-EOF
+  Blessing takes multiple patterns as its command line arguments,
+  globs them and starts Unicorn! servers on all matching configurations.
+
+  Then it periodically refreshes this list and starts new servers
+  for added files and kills of redundant processes for missing files.
+  EOF
+
+  o.separator ""
+
+  o.on("-d", "--[no-]daemon", "Run as daemon. Default: #{daemonize}"){|v| daemonize = v}
+  o.on("-l FILE", "--log FILE", "Start logging to FILE. Default: STDOUT"){|v| opts[:log] = v}
+  o.on("-r SECS", "--refresh SECS", Integer, "Set the cycle length in seconds. Default: #{opts[:refresh]}"){|v| opts[:refresh] = v}
+  o.on("-v", "--[no-]verbose", "Run verbosely. Default: #{opts[:verbose]}"){|v| opts[:verbose] = v}
+
+  o.separator ""
+
+  o.on("-h", "--help", "Show this message") do
+    puts o
+    exit
+  end
+
+  o.on("--version", "Show version") do
+    puts Blessing.version
+    exit
+  end
+
+  o.separator ""
+
+  o.separator <<-EOF
+  Blessing listens for the following signals
+    INT, TERM - Exit gracefully
+    USR1      - Immediately rerun cycle
+    USR2      - Rerun cycle resurrecting dead Unicorns
+  EOF
+end
+
+optparse.parse!
+
+patterns = ARGV
+
+if patterns.size == 0
+  STDERR.puts "ERROR: Missing argument - at least one configuration file required"
+  exit 1
+end
+
+if daemonize
+  Daemons.daemonize(:app_name => "blessing", :dir_mode => :system)
+end
+
+leader = Blessing::Leader.new patterns, opts
+leader.start

data/blessing.gemspec

@@ -0,0 +1,72 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = "blessing"
+  s.version = "1.0.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Laas Toom"]
+  s.date = "2011-10-18"
+  s.description = "A group of Unicorns is called a blessing. Blessing gem provides an easy way to manage multiple Unicorn! Rack servers."
+  s.email = "laas.toom@gmail.com"
+  s.executables = ["blessing"]
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+    ".rspec",
+    "Gemfile",
+    "Gemfile.lock",
+    "LICENSE.txt",
+    "README.rdoc",
+    "Rakefile",
+    "VERSION",
+    "bin/blessing",
+    "blessing.gemspec",
+    "lib/blessing.rb",
+    "lib/blessing/leader.rb",
+    "lib/blessing/runner.rb",
+    "spec/blessing_leader_spec.rb",
+    "spec/blessing_runner_spec.rb",
+    "spec/spec_helper.rb",
+    "spec/support/matchers/pid_matchers.rb"
+  ]
+  s.homepage = "http://github.com/borgand/blessing"
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = "1.8.10"
+  s.summary = "Manage a group of Unicorn! Rack servers."
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<unicorn>, [">= 0"])
+      s.add_runtime_dependency(%q<daemons>, [">= 0"])
+      s.add_development_dependency(%q<rspec>, ["~> 2.3.0"])
+      s.add_development_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.6.0"])
+      s.add_development_dependency(%q<rcov>, [">= 0"])
+    else
+      s.add_dependency(%q<unicorn>, [">= 0"])
+      s.add_dependency(%q<daemons>, [">= 0"])
+      s.add_dependency(%q<rspec>, ["~> 2.3.0"])
+      s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_dependency(%q<jeweler>, ["~> 1.6.0"])
+      s.add_dependency(%q<rcov>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<unicorn>, [">= 0"])
+    s.add_dependency(%q<daemons>, [">= 0"])
+    s.add_dependency(%q<rspec>, ["~> 2.3.0"])
+    s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+    s.add_dependency(%q<jeweler>, ["~> 1.6.0"])
+    s.add_dependency(%q<rcov>, [">= 0"])
+  end
+end
+

data/lib/blessing.rb

@@ -0,0 +1,8 @@
+require 'blessing/leader'
+require 'blessing/runner'
+
+module Blessing
+  def self.version
+    "Blessing " + File.read(File.join(File.dirname(__FILE__), "..", "VERSION"))
+  end
+end

data/lib/blessing/leader.rb

@@ -0,0 +1,153 @@
+require 'logger'
+require 'monitor'
+
+module Blessing
+
+  # Blessing::Leader is the main class and entry point
+  class Leader
+
+    DefaultOptions = {
+      # Run as daemon
+      :daemonize => false,
+      # Monitoring refresh cycle legth in seconds
+      :refresh => 10,
+      :verbose => false,
+      :log => STDOUT,
+    }
+
+    attr_accessor :patterns, :config_files, :old_config_files, :runners, :logger
+
+    # Initialize new Blessing::Leader with file list pattern
+    def initialize patterns, opts = {}
+      @options = DefaultOptions.merge(opts)
+      @mutex = Monitor.new
+
+      initialize_logger
+
+      logger.info "Starting Blessing::Leader"
+      @patterns = patterns.is_a?(Array) ? patterns : [patterns]
+      logger.debug "Patterns: #{patterns.inspect}"
+
+      @old_confdig_files = @config_files = []
+      @runners = {}
+
+      # Trap some signals
+      trap("INT"){
+        logger.info "Caught SIGINT"
+        at_exit
+      }
+      trap("TERM"){
+        logger.info "Caught SIGTERM"
+        at_exit
+      }
+      trap("USR1"){
+        # Rerun cycle
+        run_cycle
+      }
+      trap("USR2"){
+        # resurrect dead Unicorns!
+        run_cycle(true)
+      }
+    end
+
+    def initialize_logger
+      @logger = Logger.new @options[:log]
+      @logger.level = @options[:verbose] ? Logger::DEBUG : Logger::INFO
+    end
+
+    # Daemons hook to shut down properly
+    def at_exit
+      logger.info "Shutting down"
+      stop
+    end
+
+    # Start running cycles
+    def start
+      logger.info "Starting cycles"
+      @run_cycles = true
+      while @run_cycles do
+        run_cycle
+        sleep @options[:refresh]
+      end
+    rescue => e
+      if logger && logger.respond_to?(:fatal)
+        logger.fatal "FATAL ERROR: Unexpected error: #{e}"
+        logger.fatal e.backtrace.join("\n")
+      end
+      # Reraise the exception in case somebody else catches it
+      raise e
+    end
+
+    # Stop running cycles
+    def stop
+      @mutex.synchronize do
+        @run_cycles = false
+        logger.debug "Stopping all runners..."
+        stop_runners @config_files
+        logger.info "All runners stopped. Exiting..."
+      end
+    end
+
+    # Main cycle
+    # - refresh file list
+    # - start/stop runners
+    # - verify/reload runners
+    def run_cycle(resurrect=false)
+      @mutex.synchronize do
+        logger.debug "Next cycle"
+        refresh_file_list
+        start_stop_runners
+        reload_runners(resurrect)
+      end
+    end
+
+    # Refresh config file list and preserve old list
+    def refresh_file_list
+      logger.debug "Refreshing file list"
+      # Preserve old file list
+      @old_config_files = @config_files
+
+      files = []
+      @patterns.each{|p| files += Dir.glob(p)}
+      @config_files = files.uniq.sort
+      logger.debug "Found files: #{@config_files.inspect}"
+    end
+
+    # Find differences in old and new config file lists
+    # and start/stop runners as appropriate
+    def start_stop_runners
+      start_runners @config_files - @old_config_files
+      stop_runners @old_config_files - @config_files
+    end
+
+
+    # Start runners for added config files
+    def start_runners(files)
+      logger.debug "Starting runners for: #{files.inspect}" unless files.empty?
+      files.each { |conf|
+        @runners[conf] = runner = Blessing::Runner.new(conf, :leader => self)
+        runner.start
+      }
+    end
+
+    # Stop runners for missing config files
+    def stop_runners(files)
+      logger.debug "Stopping runners for: #{files.inspect}" unless files.empty?
+      files.each { |conf| 
+        if @runners[conf]
+          @runners[conf].stop
+          @runners.delete(conf)
+        end
+      }
+    end
+
+    # Let each runner check itself if reload is needed
+    def reload_runners(resurrect=false)
+      @runners.each_value do |runner|
+        runner.check_reload(resurrect)
+      end
+    end
+
+  end
+
+end

data/lib/blessing/runner.rb

@@ -0,0 +1,181 @@
+require 'unicorn/launcher'
+require 'logger'
+
+module Blessing
+
+  # This class holds all handles to a specific Unicorn instance
+  # and through this that Unicorn is manipulated
+  class Runner
+  
+    attr_reader :config_file, :opts
+
+    DEFAULT_OPTS={
+      :unicorn => `which unicorn`,  # Where is unicorn binary
+      :max_restarts => 5,           # How many times to retry restarting
+      :retry_delay => 1,            # How long (secs) sleep between retries
+    }
+
+    def initialize conf, opts = {}
+      @leader = opts.delete(:leader)
+      @config_file = conf
+      logger.info "Initializing Blessing::Runner for #{conf}"
+      @opts = DEFAULT_OPTS.merge opts
+      parse_configuration
+    end
+
+    # Tap on leader logger facility or create one
+    def logger
+      if @leader
+        @leader.logger
+      else
+        # We don't have leader connected, wont clutter stdout with log
+        unless @logger
+          @logger = Logger.new '/dev/null'
+        end
+        @logger
+      end
+    end
+
+    # Gets the modification time of the configuration file
+    def config_modification_time
+      File.stat(@config_file).ctime
+    end
+
+    # Let Unicorn parse it's config file
+    def parse_configuration
+      @config_timestamp = config_modification_time
+      conf_str = File.read @config_file
+
+      # Parse parameters we are interested in
+      [:pid].each do |key|
+        if conf_str =~/#{key} (.*)/
+          @opts[key] = eval $1
+        end
+      end
+    end
+
+    # Detect if the configuration has been modified
+    def config_modified?
+      @config_timestamp != config_modification_time
+    end
+
+    # Starts the actual Unicorn! process
+    def start
+      logger.info "Starting Unicorn! process for #{@config_file.inspect}"
+      fork do
+        # Options to Unicorn! process
+        options ={:config_file => @config_file}
+
+        app = Unicorn.builder('config.ru',{})
+        Unicorn::Launcher.daemonize!(options)
+        Unicorn::HttpServer.new(app,options).start.join
+      end
+      Process.wait
+    end
+
+    # Stops the actual Unicorn! process
+    def stop
+      logger.info "Stopping Unicorn! process for #{@config_file.inspect}"
+      # Lets not panic if the process is already dead
+      begin
+        Process.kill "QUIT", pid
+      rescue => e
+        logger.warn "Process does not exist! PID=#{pid}, conf=#{@config_file.inspect}"
+      end
+    end
+
+    # Reload Unicorn if needed
+    # Ensure it did start up
+    # (This is the main cycle of Leader control)
+    def check_reload(resurrect=false)
+      logger.debug "Verifying #{@config_file.inspect}"
+
+      # See if this Unicorn is alread dead
+      if dead?
+        logger.warn "This Unicorn is dead: PID=#{pid}, conf=#{@config_file.inspect}"
+        unless resurrect
+          return
+        else 
+          logger.warn "Resurrecting..."
+        end
+      end
+
+      # If configuration has changed, reload Unicorn
+      if config_modified?
+        reload
+      end
+
+      # In any case ensure it is running
+      ensure_running
+
+      # if it was dead and is now running, we are successful
+      if dead? && running?
+        logger.warn "Successfully resurrected (necromancy +1)!"
+        @dead = false
+      else
+        logger.warn "Resurrection failed!"
+      end
+    end
+
+    # Reload Unicorn! master process
+    def reload
+      logger.info "Reloading #{@config_file.inspect}"
+      begin
+        Process.kill "HUP", pid
+      rescue => e
+        # TODO: log unexpected error
+      end
+    end
+
+    # Verify the Unicorn! process is running
+    def running?
+      begin
+        Process.kill 0, pid
+        true
+      rescue Errno::ESRCH
+        # just verifying; logging should be done elsewhere
+        false
+      end
+    end
+
+    # is it totally dead?
+    def dead?
+      @dead
+    end
+
+    # Ensure the Unicorn! process is running
+    # restarting it if needed
+    def ensure_running
+      unless success = running?
+        logger.info "Process is not running: pid=#{pid} conf=#{@config_file.inspect}"
+        opts[:max_restarts].times do |i|
+          logger.info "Restarting: try=#{i+1}"
+          start
+          sleep opts[:retry_delay]
+          break if success = running?
+        end
+        if success
+          logger.info "Successfully restarted"
+          # just in case it was dead before
+          @dead = false
+        else
+          logger.warn "Failed to restart in #{opts[:max_restarts]} tries, conf=#{@config_file.inspect}"
+          @dead = true
+        end
+      end
+      success
+    end
+
+    private
+    # Read PID from pid-file
+    def pid
+      if File.exists? opts[:pid]
+        File.read(opts[:pid]).chomp.to_i
+      else
+        logger.warn "PID-file does not exist! Pidfile= #{@opts[:pid].inspect}, conf=#{@config_file.inspect}"
+        nil
+      end
+    end
+
+  end
+end

data/spec/blessing_leader_spec.rb

@@ -0,0 +1,192 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+require 'tmpdir'
+require 'fileutils'
+
+describe Blessing::Leader do
+
+  before(:each) do
+    @tmpdir = Dir.mktmpdir('blessing_test')
+  end
+
+  after(:each) do
+    FileUtils.rm_rf @tmpdir
+  end
+
+  context "File globbing" do
+
+    it "Takes shell glob pattern and preserves it" do
+      pattern = "/tmp/**/*.conf"
+      leader = Blessing::Leader.new pattern, :log => '/dev/null'
+      leader.patterns.should == [pattern]
+    end
+
+    it "takes multiple patterns" do
+      patterns = %w(/tmp/**/1.conf /tmp/**/2.conf)
+      leader = Blessing::Leader.new patterns, :log => '/dev/null', :log => '/dev/null'
+      leader.patterns.should == patterns
+    end
+
+  end
+
+  context "Renew config files" do
+
+    it "finds a list of files corresponding to the pattern" do
+      files = []
+      3.times do |i|
+        files << name = File.join(@tmpdir,"unicorn_#{i}.conf")
+        FileUtils.touch name
+      end
+      leader = Blessing::Leader.new("#{@tmpdir}/**/unicorn_*.conf", :log => '/dev/null')
+      leader.refresh_file_list
+      leader.config_files.should == files.sort
+    end
+
+    it "finds a unique list of files corresponding to multiple patterns" do
+      files = []
+      3.times do |i|
+        files << name = File.join(@tmpdir,"unicorn_#{i}.conf")
+        FileUtils.touch name
+      end
+      leader = Blessing::Leader.new(%W(#{@tmpdir}/**/unicorn_1.conf #{@tmpdir}/**/unicorn_*.conf), :log => '/dev/null')
+      leader.refresh_file_list
+      leader.config_files.should == files.sort
+    end
+
+
+    it "refreshes file list and preserves old list" do
+      old_files = []
+      3.times do |i|
+        old_files << name = File.join(@tmpdir,"unicorn_#{i}.conf")
+        FileUtils.touch name
+      end
+      leader = Blessing::Leader.new("#{@tmpdir}/**/unicorn_*.conf", :log => '/dev/null')
+      leader.refresh_file_list
+
+      # Remove one file and add one file
+      new_files = old_files.dup
+      File.unlink(new_files.delete_at(1))
+      new_files << name = File.join(@tmpdir,"unicorn_4.conf")
+      FileUtils.touch name
+
+      leader.refresh_file_list
+
+      # Leader#old_config_files is private
+      leader.old_config_files.should == old_files
+      leader.config_files.should == new_files
+    end
+
+    it "compares old conf list to the new and starts and stops Runners as neccessary" do
+      old_config_files = (1..2).map{|i| File.join(@tmpdir,"unicorn_#{i}.conf")}
+      config_files = (2..3).map{|i| File.join(@tmpdir,"unicorn_#{i}.conf")}
+      runner_mock = double(Blessing::Runner)
+
+      leader = Blessing::Leader.new "#{@tmpdir}/**/unicorn_*.conf", :log => '/dev/null'
+      leader.old_config_files = old_config_files
+      leader.config_files = config_files
+
+      leader.should_receive(:stop_runners).with([File.join(@tmpdir,"unicorn_1.conf")])
+      leader.should_receive(:start_runners).with([File.join(@tmpdir,"unicorn_3.conf")])
+
+      leader.start_stop_runners
+
+    end
+
+    it "does not start/stop any runners if no config files change" do
+      conf = "#{@tmpdir}/unicorn_conf"
+      mock_runner = double(Blessing::Runner)
+      mock_runner.should_not_receive(:start)
+      mock_runner.should_not_receive(:stop)
+
+      leader = Blessing::Leader.new "", :log => '/dev/null'
+      leader.config_files = leader.old_config_files = [conf]
+      leader.runners[conf] = mock_runner
+
+      leader.should_receive(:start_runners).with([])
+      leader.should_receive(:stop_runners).with([])
+
+      leader.start_stop_runners
+    end
+
+  end
+
+  context "Process monitoring" do
+    it "starts Runners" do
+      mock_runner = double(Blessing::Runner)
+      mock_runner.should_receive(:start)
+      Blessing::Runner.should_receive(:new).and_return(mock_runner)
+
+      leader = Blessing::Leader.new("", :log => '/dev/null')
+
+      leader.start_runners(["#{@tmpdir}/unicorn_conf"])
+    end
+
+    it "stops Runners" do
+      mock_runner = double(Blessing::Runner)
+      mock_runner.should_receive(:stop)
+      conf = "#{@tmpdir}/unicorn_conf"
+
+      leader = Blessing::Leader.new("", :log => '/dev/null')
+      leader.runners[conf] = mock_runner
+      
+      leader.stop_runners([conf])
+      # Stopped runners should be removed from queue
+      leader.runners.should == {}
+    end
+
+    it "asks Runners to check if reload is necessary" do
+      mock_runner = double(Blessing::Runner)
+      mock_runner.should_receive(:check_reload)
+
+      leader = Blessing::Leader.new("", :log => '/dev/null')
+      conf = "#{@tmpdir}/unicorn.conf"
+      leader.config_files = [conf]
+      leader.runners[conf] = mock_runner
+
+      leader.reload_runners
+    end
+
+  end
+
+  context "Main API" do
+    it "does refresh-start-stop-reload cycle" do
+      leader = Blessing::Leader.new("", :log => '/dev/null')
+      leader.should_receive(:refresh_file_list)
+      leader.should_receive(:start_stop_runners)
+      leader.should_receive(:reload_runners)
+
+      leader.run_cycle
+    end
+
+    it "when started, runs cycle every X seconds, until stopped" do
+      leader = Blessing::Leader.new "", :refresh => 1, :log => '/dev/null'
+      count = 1
+      leader.stub(:run_cycle) do
+        leader.stop if count <= 0
+        count -= 1
+      end
+      leader.should_receive(:run_cycle).twice
+      leader.start
+
+    end
+
+    it "stops all runners when stopped" do
+      leader = Blessing::Leader.new "", :log => '/dev/null'
+      leader.should_receive(:stop_runners)
+      leader.stop
+    end
+
+  end
+
+  context "Logging" do
+    it "creates logger facility" do
+      leader = Blessing::Leader.new "", :log => '/dev/null'
+      leader.logger.should respond_to :debug
+      leader.logger.should respond_to :info
+      leader.logger.should respond_to :warn
+      leader.logger.should respond_to :error
+      leader.logger.should respond_to :fatal
+    end
+  end
+end
+

data/spec/blessing_runner_spec.rb

@@ -0,0 +1,156 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+require 'tmpdir'
+require 'fileutils'
+
+describe Blessing::Runner do
+  before(:all) do
+    @tmpdir = Dir.mktmpdir('blessing_test')
+    @conf = make_sample_config(@tmpdir)
+  end
+
+  after(:all) do
+    FileUtils.rm_rf @tmpdir
+  end
+
+  context "Read configuration" do
+
+    it "takes config file as argument to new" do
+      runner = Blessing::Runner.new(@conf)
+      runner.config_file.should == @conf
+    end
+
+
+
+    it "parses conf files for pid file and working_directory location" do
+      runner = Blessing::Runner.new(@conf)
+      pid = File.join(File.dirname(@conf), "/tmp/pids/unicorn.pid")
+      runner.opts[:pid].should == pid
+    end
+
+    it "starts and stops Unicorn process" do
+      runner = Blessing::Runner.new(@conf)
+      runner.start
+      runner.opts[:pid].should contain_a_pid_number
+      runner.opts[:pid].should point_to_running_process
+
+      runner.stop
+      # give it time to die
+      sleep 1
+
+      runner.opts[:pid].should_not point_to_running_process
+      runner.opts[:pid].should_not contain_a_pid_number
+    end
+
+    it "reloads Unicorn process" do
+      runner = Blessing::Runner.new(@conf)
+
+      runner.should_receive(:pid).and_return(12345)
+      Process.should_receive(:kill).once
+      runner.reload
+
+    end
+
+    it "verifies that Unicorn process is running" do
+      runner = Blessing::Runner.new(@conf)
+
+      pid = 12345
+      runner.should_receive(:pid).and_return(pid)
+      Process.should_receive(:kill).with(0, pid).and_return(true)
+      runner.running?.should be_true
+
+      pid = 22345
+      runner.should_receive(:pid).and_return(pid)
+      Process.should_receive(:kill).with(0, pid) { raise Errno::ESRCH, "TestException" }
+      runner.running?.should_not be_true
+    end
+
+    it "restarts stopped Unicorn process" do
+      runner = Blessing::Runner.new(@conf)
+
+      runner.opts[:retry_delay] = 0
+      runner.should_receive(:running?).exactly(:once).and_return(false)
+      runner.should_receive(:running?).once.and_return(true)
+      runner.should_receive(:start)
+
+      runner.ensure_running.should be_true
+    end
+
+    it "stops trying to restart if too many failures" do
+      runner = Blessing::Runner.new(@conf)
+
+      max_tries = 3
+      runner.opts[:max_restarts] = max_tries
+      runner.opts[:retry_delay] = 0
+
+      runner.should_receive(:running?).exactly(max_tries + 1).times.and_return(false)
+      runner.should_receive(:start).exactly(max_tries).times
+
+      runner.ensure_running.should_not be_true
+      runner.dead?.should be_true
+    end
+
+    it "won't touch dead Unicorn" do
+      runner = Blessing::Runner.new @conf, :refresh => 0
+      runner.should_receive(:dead?).and_return(true)
+
+      runner.check_reload.should_not be_true
+    end
+
+    it "resurrects" do
+      runner = Blessing::Runner.new @conf, :refresh => 0
+      runner.instance_eval("@dead = true")
+      runner.should_receive(:ensure_running)
+      runner.should_receive(:running?).and_return(true)
+
+      runner.check_reload(true)
+      runner.dead?.should be_false
+    end
+
+    it "detects that configuration file has been modified" do
+      runner = Blessing::Runner.new(@conf)
+
+      runner.config_modified?.should_not be_true
+      sleep 1
+      FileUtils.touch @conf
+      runner.config_modified?.should be_true
+    end
+  end
+
+  context "main monitoring cycle" do 
+
+    it "reloads if needed and ensures Unicorn is running" do
+      runner = Blessing::Runner.new(@conf)
+      runner.should_receive(:config_modified?).and_return(true)
+      runner.should_receive(:reload)
+      runner.should_receive(:ensure_running)
+
+      runner.check_reload
+    end
+
+  end
+
+  context "logging" do
+    it "connects to leader logger" do
+      logger = double
+      logger.stub(:debug)
+      logger.stub(:notice)
+      logger.stub(:info)
+      logger.stub(:warn)
+      logger.stub(:error)
+      logger.stub(:fatal)
+
+      leader = double(Blessing::Leader)
+      leader.stub(:logger){logger}
+
+
+      runner = Blessing::Runner.new(@conf, :leader => leader)
+      runner.logger.should respond_to :debug
+    end
+
+    it "creates logger if leader not connected" do
+      runner = Blessing::Runner.new @conf
+      runner.logger.should respond_to :debug
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,46 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'rspec'
+require 'blessing'
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+
+  # Create sampel configuration with minimal Rack app
+  def make_sample_config basedir
+    config = File.join(basedir, "unicorn.conf")
+    rackup = File.join(basedir, "config.ru")
+
+    FileUtils.mkdir_p File.join(basedir, 'tmp', 'pids')
+
+    File.open config, "w" do |f|
+      f.puts <<EOF
+worker_processes 4
+working_directory "#{basedir}"
+listen '#{basedir}/tmp/unicorn.sock', :backlog => 512
+timeout 30
+pid "#{basedir}/tmp/pids/unicorn.pid"
+
+preload_app true
+  if GC.respond_to?(:copy_on_write_friendly=)
+  GC.copy_on_write_friendly = true
+end
+EOF
+    end
+
+    File.open rackup, "w" do |f|
+      f.puts <<EOF
+ip = lambda do |env|
+  [200, {"Content-Type" => "text/plain"}, [env["REMOTE_ADDR"]]]
+end
+   
+run ip
+EOF
+    end
+
+    return config
+  end
+end

data/spec/support/matchers/pid_matchers.rb

@@ -0,0 +1,24 @@
+# Validate that the file contains numeric pid
+RSpec::Matchers.define :contain_a_pid_number do
+  match do |actual|
+    if File.exists? actual
+      pid = File.read(actual).chomp
+      pid.to_i.to_s == pid.chomp
+    else
+      false
+    end
+  end
+end
+
+# Check that the pid is still running
+RSpec::Matchers.define :point_to_running_process do
+  match do |actual|
+    begin
+      pid = File.read(actual).chomp.to_i
+      res = Process.kill 0, pid
+      true
+    rescue
+      false
+    end
+  end
+end

metadata

@@ -0,0 +1,135 @@
+--- !ruby/object:Gem::Specification
+name: blessing
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Laas Toom
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-10-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: unicorn
+  requirement: &2177673060 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *2177673060
+- !ruby/object:Gem::Dependency
+  name: daemons
+  requirement: &2177671740 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *2177671740
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &2177669440 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.3.0
+  type: :development
+  prerelease: false
+  version_requirements: *2177669440
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: &2177668660 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: *2177668660
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: &2177667980 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.6.0
+  type: :development
+  prerelease: false
+  version_requirements: *2177667980
+- !ruby/object:Gem::Dependency
+  name: rcov
+  requirement: &2177667100 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2177667100
+description: A group of Unicorns is called a blessing. Blessing gem provides an easy
+  way to manage multiple Unicorn! Rack servers.
+email: laas.toom@gmail.com
+executables:
+- blessing
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.rdoc
+files:
+- .document
+- .rspec
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.rdoc
+- Rakefile
+- VERSION
+- bin/blessing
+- blessing.gemspec
+- lib/blessing.rb
+- lib/blessing/leader.rb
+- lib/blessing/runner.rb
+- spec/blessing_leader_spec.rb
+- spec/blessing_runner_spec.rb
+- spec/spec_helper.rb
+- spec/support/matchers/pid_matchers.rb
+homepage: http://github.com/borgand/blessing
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -3814883158345661566
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Manage a group of Unicorn! Rack servers.
+test_files: []