dante 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in dante.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Miso
+
+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,96 @@
+# Dante
+
+Turn any process into a daemon with ease.
+
+## Why Dante?
+
+Dante is the simplest possible thing that can work to turn arbitrary ruby code into a 'robust' binary that
+can be started normally or as a daemon, and will store a pid file automatically. Dante also allows a process
+to be stopped just as easily using a standardized set of command line options.
+
+If you need to create a ruby executable and you want standard daemon start/stop with pid files
+and no hassle, this gem will be a great way to get started.
+
+## Installation
+
+Add to your Gemfile:
+
+```
+# Gemfile
+
+gem "dante"
+```
+
+## Usage
+
+Dante is meant to be used from any "bin" executable. For instance, to create a binary for a web server, create a file in `bin/mysite`:
+
+```ruby
+#!/usr/bin/env ruby
+
+require File.expand_path("../../myapp.rb", __FILE__)
+
+Dante.run('myapp') do
+  Thin::Server.start('0.0.0.0', port) do
+    use Rack::CommonLogger
+    use Rack::ShowExceptions
+    run MyApp
+  end
+end
+```
+
+This gives your binary several useful things for free:
+
+```
+./bin/myapp
+```
+
+will start the app undaemonized in the terminal, handling trapping and stopping the process.
+
+```
+./bin/myapp -d -P /var/run/myapp.pid
+```
+
+will daemonize and start the process, storing the pid in the specified pid file.
+
+```
+./bin/myapp -k -P /var/run/myapp.pid
+```
+
+will stop all daemonized processes for the specified pid file.
+
+```
+./bin/myapp --help
+```
+
+Will return a useful help banner message explaining the simple usage.
+
+## God
+
+Dante can be used well in conjunction with the excellent God process manager. Simply, use Dante to daemonize a process
+and then you can easily use God to monitor:
+
+```ruby
+# /etc/god/myapp.rb
+
+God.watch do |w|
+  w.name            = "myapp"
+  w.interval        = 30.seconds
+  w.start           = "ruby /path/to/myapp/bin/myapp -d"
+  w.stop            = "ruby /path/to/myapp/bin/myapp -k"
+  w.start_grace     = 15.seconds
+  w.restart_grace   = 15.seconds
+  w.pid_file        = "/var/run/myapp.pid"
+
+  w.behavior(:clean_pid_file)
+
+  w.start_if do |start|
+    start.condition(:process_running) do |c|
+      c.interval = 5.seconds
+      c.running = false
+    end
+  end
+end
+```
+
+and that's all. Of course now you can also easily daemonize as well as start/stop the process on the command line as well.

data/Rakefile

@@ -0,0 +1,15 @@
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+# require 'yard'
+
+task :test do
+  Rake::TestTask.new do |t|
+    t.libs.push "lib"
+    t.test_files = FileList[File.expand_path('../test/**/*_test.rb', __FILE__)]
+    t.verbose = true
+  end
+end
+
+# task :doc do
+#  YARD::CLI::Yardoc.new.run
+# end

data/dante.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "dante/version"
+
+Gem::Specification.new do |s|
+  s.name        = "dante"
+  s.version     = Dante::VERSION
+  s.authors     = ["Nathan Esquenazi"]
+  s.email       = ["nesquena@gmail.com"]
+  s.homepage    = "https://github.com/bazaarlabs/dante"
+  s.summary     = %q{Turn any process into a demon}
+  s.description = %q{Turn any process into a demon.}
+
+  s.rubyforge_project = "dante"
+
+  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 'rake'
+  s.add_development_dependency 'minitest'
+end

data/lib/dante.rb

@@ -0,0 +1,27 @@
+$:.unshift File.expand_path(File.dirname(__FILE__))
+require "dante/version"
+require "dante/runner"
+
+=begin
+
+  Dante.run("process-name") do
+    begin
+      # ...something here
+    rescue Abort
+      # ...shutdown here
+    end
+  end
+
+=end
+
+module Dante
+
+  # Forks a process and takes some list of params. I don't really know what this does.
+  #
+  # @example
+  #   Dante.run("process-name") { Server.run! }
+  #
+  def self.run(name, options={}, &blk)
+    Runner.new(name, options, &blk).execute!
+  end
+end

data/lib/dante/runner.rb

@@ -0,0 +1,153 @@
+require 'fileutils'
+require 'optparse'
+require 'yaml'
+require 'erb'
+
+=begin
+
+This is a utility for setting up a binary executable for a service.
+
+# Dante::Runner.run("buffet", :pid_path => "/var/run/buffet.pid") do
+#   ...startup service here...
+# end
+
+=end
+
+module Dante
+  class Runner
+    # Signal to application that the process is shutting down
+    class Abort < Exception; end
+
+    attr_accessor :options
+
+    class << self
+      def run(*args, &block)
+        self.new(*args, &block)
+      end
+    end
+
+    def initialize(name, defaults={}, &block)
+      @name = name
+      @startup_command = block
+      self.options = {
+        :host => '0.0.0.0',
+        :pid_path => "/var/run/#{@name}.pid"
+      }.merge(defaults)
+
+      parse_options
+
+      if options.include?(:kill)
+        kill_pid(options[:kill] || '*')
+      end
+
+      Process.euid = options[:user] if options[:user]
+      Process.egid = options[:group] if options[:group]
+    end
+
+    # Executes the runner based on options
+    def execute!
+      if !options[:daemonize]
+        start
+      else
+        daemonize
+      end
+    end
+
+    def start
+      puts "Starting #{@name} service..."
+
+      trap("INT") {
+        stop
+        exit
+      }
+      trap("TERM"){
+        stop
+        exit
+      }
+
+      @startup_command.call
+    end
+
+    def stop
+      raise Abort
+      sleep(1)
+    end
+
+    def parse_options
+      OptionParser.new do |opts|
+        opts.summary_width = 25
+        opts.banner = ["#{@name} (#{VERSION})\n\n",
+                      "Usage: #{@name} [-P file] [-d] [-k port]\n",
+                      "       #{@name} --help\n"].join("")
+        opts.separator ""
+
+        opts.on("-p", "--port PORT", Integer, "Specify port", "(default: #{options[:port]})") do |v|
+          options[:port] = v
+        end
+
+        opts.on("-P", "--pid FILE", String, "save PID in FILE when using -d option.", "(default: #{options[:pid_path]})") do |v|
+          options[:pid_path] = File.expand_path(v)
+        end
+
+        opts.on("-d", "--daemon", "Daemonize mode") do |v|
+          options[:daemonize] = v
+        end
+
+        opts.on("-k", "--kill [PORT]", String, "Kill specified running daemons - leave blank to kill all.") do |v|
+          options[:kill] = v
+        end
+
+        opts.on("-u", "--user USER", String, "User to run as") do |user|
+          options[:user] = user
+        end
+
+        opts.on("-G", "--group GROUP", String, "Group to run as") do |group|
+          options[:group] = group
+        end
+
+        opts.on_tail("-?", "--help", "Display this usage information.") do
+          puts "#{opts}\n"
+          exit
+        end
+      end.parse!
+      options
+    end
+
+    private
+
+    def store_pid(pid)
+     FileUtils.mkdir_p(File.dirname(options[:pid_path]))
+     File.open(options[:pid_path], 'w'){|f| f.write("#{pid}\n")}
+    end
+
+    def kill_pid(k)
+      Dir[options[:pid_path]].each do |f|
+        begin
+        puts f
+        pid = IO.read(f).chomp.to_i
+        FileUtils.rm f
+        Process.kill(9, pid)
+        puts "killed PID: #{pid}"
+        rescue => e
+          puts "Failed to kill! #{k}: #{e}"
+        end
+      end
+      exit
+    end
+
+    def daemonize
+      pid = fork do
+        exit if fork
+        Process.setsid
+        exit if fork
+        store_pid(Process.pid)
+        File.umask 0000
+        STDIN.reopen "/dev/null"
+        STDOUT.reopen "/dev/null", "a"
+        STDERR.reopen STDOUT
+        start
+      end
+    end
+
+  end
+end

data/lib/dante/version.rb

@@ -0,0 +1,3 @@
+module Dante
+  VERSION = "0.0.1"
+end

data/test/dante_test.rb

@@ -0,0 +1,16 @@
+require File.expand_path('../test_helper', __FILE__)
+
+describe "dante module" do
+  before do
+    @process = TestingProcess.new('a')
+  end
+
+  it "can run jobs using #run method" do
+    capture_stdout do
+      Dante.run('test-process') { @process.run_a! }
+    end
+    @output = File.read(@process.tmp_path)
+    assert_match /Started/, @output
+  end
+
+end

data/test/runner_test.rb

@@ -0,0 +1,50 @@
+require File.expand_path('../test_helper', __FILE__)
+
+describe "dante runner" do
+  describe "with no daemonize" do
+    before do
+      @process = TestingProcess.new('a')
+      @runner = Dante::Runner.new('test-process') { @process.run_a! }
+      @stdout = capture_stdout { @runner.execute! }
+    end
+
+    it "prints correct stdout" do
+      assert_match /Starting test-process/, @stdout
+    end
+
+    it "starts successfully when executed" do
+      @output = File.read(@process.tmp_path)
+      assert_match /Started/, @output
+    end
+  end # no daemonize
+
+  describe "with daemonize flag" do
+    before do
+      @process = TestingProcess.new('b')
+      @run_options = { :daemonize => true, :pid_path => "/tmp/dante.pid" }
+      @runner = Dante::Runner.new('test-process-2', @run_options) { @process.run_b! }
+      @stdout = capture_stdout { @runner.execute! }
+      sleep(1)
+    end
+
+    it "can properly handles aborts and starts / stops on INT" do
+      refute_equal 0, @pid = `cat /tmp/dante.pid`.to_i
+      Process.kill "INT", @pid
+      sleep(1) # Wait to complete
+      @output = File.read(@process.tmp_path)
+      assert_match /Started!!/, @output
+      assert_match /Abort!!/, @output
+      assert_match /Closing!!/, @output
+    end
+
+    it "can properly handles aborts and starts / stops on TERM" do
+      refute_equal 0, @pid = `cat /tmp/dante.pid`.to_i
+      Process.kill "TERM", @pid
+      sleep(1) # Wait to complete
+      @output = File.read(@process.tmp_path)
+      assert_match /Started!!/, @output
+      assert_match /Abort!!/, @output
+      assert_match /Closing!!/, @output
+    end
+  end # daemonize
+end

data/test/test_helper.rb

@@ -0,0 +1,54 @@
+require 'rubygems'
+require 'tempfile'
+require 'minitest/autorun'
+$:.unshift File.expand_path("../../lib")
+require 'dante'
+
+## Kernel Extensions
+require 'stringio'
+
+module Kernel
+  # Redirect standard out, standard error and the buffered logger for sprinkle to StringIO
+  # capture_stdout { any_commands; you_want } => "all output from the commands"
+  def capture_stdout
+    return yield if ENV['DEBUG'] # Skip if debug mode
+
+    out = StringIO.new
+    $stdout = out
+    $stderr = out
+    yield
+    return out.string
+  ensure
+    $stdout = STDOUT
+    $stderr = STDERR
+  end
+end
+
+# Process fixture
+class TestingProcess
+  attr_reader :tmp_path
+
+  def initialize(name)
+    @tmp_path = "/tmp/dante-#{name}.log"
+  end # initialize
+
+  def run_a!
+    @tmp = File.new(@tmp_path, 'w')
+    @tmp.print("Started")
+    @tmp.close
+  end # run_a!
+
+  def run_b!
+    begin
+      @tmp = File.new(@tmp_path, 'w')
+      @tmp.print "Started!!"
+      sleep(100)
+    rescue Dante::Runner::Abort
+      @tmp.print "Abort!!"
+      exit
+    ensure
+      @tmp.print "Closing!!"
+      @tmp.close
+    end
+  end # run_b!
+end # TestingProcess

metadata

@@ -0,0 +1,108 @@
+--- !ruby/object:Gem::Specification 
+name: dante
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Nathan Esquenazi
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-11-21 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rake
+  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
+- !ruby/object:Gem::Dependency 
+  name: minitest
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+description: Turn any process into a demon.
+email: 
+- nesquena@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- dante.gemspec
+- lib/dante.rb
+- lib/dante/runner.rb
+- lib/dante/version.rb
+- test/dante_test.rb
+- test/runner_test.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: https://github.com/bazaarlabs/dante
+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: dante
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: Turn any process into a demon
+test_files: 
+- test/dante_test.rb
+- test/runner_test.rb
+- test/test_helper.rb