dante 0.0.1 → 0.0.2

data/README.md

@@ -1,12 +1,11 @@
 # Dante
 
-Turn any process into a daemon with ease.
+Turn any ruby into a daemon.
 
-## Why Dante?
+## Description
 
-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.
+Dante is the simplest possible thing that will work to turn arbitrary ruby code into an executable that
+can be started via command line or start/stop a daemon, and will store a pid file for you.
 
 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.
@@ -15,23 +14,34 @@ and no hassle, this gem will be a great way to get started.
 
 Add to your Gemfile:
 
-```
+```ruby
 # Gemfile
 
 gem "dante"
 ```
 
+or to your gemspec:
+
+```ruby
+# mygem.gemspec
+
+Gem::Specification.new do |s|
+  s.add_dependency "dante"
+end
+```
+
 ## 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`:
+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/myapp`:
 
 ```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
+Dante.run('myapp') do |opts|
+  # opts: host, pid_path, port, daemonize, user, group
+  Thin::Server.start('0.0.0.0', opts[:port]) do
     use Rack::CommonLogger
     use Rack::ShowExceptions
     run MyApp
@@ -39,6 +49,12 @@ Dante.run('myapp') do
 end
 ```
 
+Be sure to properly make your bin executable:
+
+```
+chmod +x bin/myapp
+```
+
 This gives your binary several useful things for free:
 
 ```
@@ -48,7 +64,7 @@ This gives your binary several useful things for free:
 will start the app undaemonized in the terminal, handling trapping and stopping the process.
 
 ```
-./bin/myapp -d -P /var/run/myapp.pid
+./bin/myapp -p 8080 -d -P /var/run/myapp.pid
 ```
 
 will daemonize and start the process, storing the pid in the specified pid file.
@@ -65,6 +81,46 @@ will stop all daemonized processes for the specified pid file.
 
 Will return a useful help banner message explaining the simple usage.
 
+## Customization
+
+In many cases, you will need to add custom flags/options or a custom description to your executable. You can do this
+easily by using the `Dante::Runner` directly:
+
+```ruby
+#!/usr/bin/env ruby
+
+require File.expand_path("../../myapp.rb", __FILE__)
+
+# Set default port to 8080
+runner = Dante::Runner.new('myapp', :port => 8080)
+# Sets the description in 'help'
+runner.description = "This is myapp"
+runner.with_options do |opts|
+  opts.on("-t", "--test TEST", String, "Test this thing") do |test|
+    options[:test] = test
+  end
+end
+# Parse command-line options and execute the process
+runner.execute do |opts|
+  # opts: host, pid_path, port, daemonize, user, group
+  Thin::Server.start('0.0.0.0', opts[:port]) do
+    puts opts[:test] # Referencing my custom option
+    use Rack::CommonLogger
+    use Rack::ShowExceptions
+    run MyApp
+  end
+end
+```
+
+Now you would be able to do:
+
+```
+./bin/myapp -t custom
+```
+
+and the `opts` would contain the `:test` option for use in your script. In addition, help will now contain
+your customized description in the banner.
+
 ## God
 
 Dante can be used well in conjunction with the excellent God process manager. Simply, use Dante to daemonize a process
@@ -93,4 +149,8 @@ God.watch do |w|
 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.
+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.
+
+## Copyright
+
+Copyright © 2011 Nathan Esquenazi. See [LICENSE](https://github.com/bazaarlabs/dante/blob/master/LICENSE) for details.

data/dante.gemspec

@@ -20,4 +20,5 @@ Gem::Specification.new do |s|
 
   s.add_development_dependency 'rake'
   s.add_development_dependency 'minitest'
+  s.add_development_dependency 'mocha'
 end

data/lib/dante.rb

@@ -16,12 +16,12 @@ require "dante/runner"
 
 module Dante
 
-  # Forks a process and takes some list of params. I don't really know what this does.
+  # Forks a process and handles option parsing and start/stopping.
   #
   # @example
   #   Dante.run("process-name") { Server.run! }
   #
   def self.run(name, options={}, &blk)
-    Runner.new(name, options, &blk).execute!
+    Runner.new(name, options, &blk).execute
   end
 end

data/lib/dante/runner.rb

@@ -7,7 +7,7 @@ require 'erb'
 
 This is a utility for setting up a binary executable for a service.
 
-# Dante::Runner.run("buffet", :pid_path => "/var/run/buffet.pid") do
+# Dante::Runner.new("buffet", :pid_path => "/var/run/buffet.pid") do
 #   ...startup service here...
 # end
 
@@ -18,7 +18,7 @@ module Dante
     # Signal to application that the process is shutting down
     class Abort < Exception; end
 
-    attr_accessor :options
+    attr_accessor :options, :name, :description
 
     class << self
       def run(*args, &block)
@@ -29,23 +29,30 @@ module Dante
     def initialize(name, defaults={}, &block)
       @name = name
       @startup_command = block
-      self.options = {
+      @options = {
         :host => '0.0.0.0',
         :pid_path => "/var/run/#{@name}.pid"
       }.merge(defaults)
+    end
 
-      parse_options
+    # Accepts options for the process
+    # @runner.with_options { |opts| opts.on(...) }
+    def with_options(&block)
+      @with_options = block
+    end
 
-      if options.include?(:kill)
-        kill_pid(options[:kill] || '*')
-      end
+    # Executes the runner based on options
+    # @runner.execute
+    # @runner.execute { ... }
+    def execute(&block)
+      parse_options
+      kill_pid(options[:kill] || '*') if options.include?(:kill)
 
       Process.euid = options[:user] if options[:user]
       Process.egid = options[:group] if options[:group]
-    end
 
-    # Executes the runner based on options
-    def execute!
+      @startup_command = block if block_given?
+
       if !options[:daemonize]
         start
       else
@@ -65,7 +72,7 @@ module Dante
         exit
       }
 
-      @startup_command.call
+      @startup_command.call(self.options) if @startup_command
     end
 
     def stop
@@ -74,11 +81,12 @@ module Dante
     end
 
     def parse_options
+      headline = [@name, @description].compact.join(" - ")
       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.banner = [headline, "\n\n",
+                      "Usage: #{@name} [-p port] [-P file] [-d] [-k]\n",
+                      "       #{@name} --help\n"].compact.join("")
         opts.separator ""
 
         opts.on("-p", "--port PORT", Integer, "Specify port", "(default: #{options[:port]})") do |v|
@@ -109,6 +117,9 @@ module Dante
           puts "#{opts}\n"
           exit
         end
+
+        # Load options specified through 'with_options'
+        instance_exec(opts, &@with_options) if @with_options
       end.parse!
       options
     end

data/lib/dante/version.rb

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

data/test/runner_test.rb

@@ -5,7 +5,7 @@ describe "dante runner" do
     before do
       @process = TestingProcess.new('a')
       @runner = Dante::Runner.new('test-process') { @process.run_a! }
-      @stdout = capture_stdout { @runner.execute! }
+      @stdout = capture_stdout { @runner.execute }
     end
 
     it "prints correct stdout" do
@@ -21,9 +21,10 @@ describe "dante runner" do
   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! }
+      @run_options = { :daemonize => true, :pid_path => "/tmp/dante.pid", :port => 8080 }
+      @runner = Dante::Runner.new('test-process-2', @run_options) { |opts|
+        @process.run_b!(opts[:port]) }
+      @stdout = capture_stdout { @runner.execute }
       sleep(1)
     end
 
@@ -32,7 +33,7 @@ describe "dante runner" do
       Process.kill "INT", @pid
       sleep(1) # Wait to complete
       @output = File.read(@process.tmp_path)
-      assert_match /Started!!/, @output
+      assert_match /Started on 8080!!/, @output
       assert_match /Abort!!/, @output
       assert_match /Closing!!/, @output
     end
@@ -42,9 +43,70 @@ describe "dante runner" do
       Process.kill "TERM", @pid
       sleep(1) # Wait to complete
       @output = File.read(@process.tmp_path)
-      assert_match /Started!!/, @output
+      assert_match /Started on 8080!!/, @output
       assert_match /Abort!!/, @output
       assert_match /Closing!!/, @output
     end
   end # daemonize
+
+  describe "with execute accepting block" do
+    before do
+      @process = TestingProcess.new('b')
+      @run_options = { :daemonize => true, :pid_path => "/tmp/dante.pid", :port => 8080 }
+      @runner = Dante::Runner.new('test-process-2', @run_options)
+      @stdout = capture_stdout { @runner.execute { |opts| @process.run_b!(opts[:port]) } }
+      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 on 8080!!/, @output
+      assert_match /Abort!!/, @output
+      assert_match /Closing!!/, @output
+    end
+  end # execute with block
+
+  describe "with parsing options" do
+    before do
+      Object.send(:remove_const, 'ARGV'); ARGV = ['-t test_text']
+      @process = TestingProcess.new('a')
+      @runner = Dante::Runner.new('test-process')
+      @runner.with_options do |opts|
+        opts.on("-t", "--test TEST", String, "Test this thing") { |test| options[:test] = test }
+      end
+      @stdout = capture_stdout { @runner.execute { |opts| @process.run_a!(opts[:test]) } }
+    end
+
+    it "prints correct stdout" do
+      assert_match /Starting test-process/, @stdout
+    end
+
+    it "prints correct data" do
+      @output = File.read(@process.tmp_path)
+      assert_match /test_text/, @output
+    end
+
+    it "starts successfully when executed" do
+      @output = File.read(@process.tmp_path)
+      assert_match /Started/, @output
+    end
+  end # options parsing
+
+  describe "with help command" do
+    before do
+      Object.send(:remove_const, 'ARGV'); ARGV = ['--help']
+      @process = TestingProcess.new('a')
+      @runner = Dante::Runner.new('test-process')
+      @runner.description = "Test process banana"
+      @runner.expects(:exit).once.returns(true)
+      @stdout = capture_stdout { @runner.execute { @process.run_a! } }
+    end
+
+    it "prints correct stdout" do
+      assert_match /test-process - Test process banana/, @stdout
+    end
+  end # help
 end

data/test/test_helper.rb

@@ -1,6 +1,7 @@
 require 'rubygems'
 require 'tempfile'
 require 'minitest/autorun'
+require 'mocha'
 $:.unshift File.expand_path("../../lib")
 require 'dante'
 
@@ -32,16 +33,17 @@ class TestingProcess
     @tmp_path = "/tmp/dante-#{name}.log"
   end # initialize
 
-  def run_a!
+  def run_a!(data=nil)
     @tmp = File.new(@tmp_path, 'w')
-    @tmp.print("Started")
+    @tmp.puts("Started")
+    @tmp.puts "Data is: #{data}" if data
     @tmp.close
   end # run_a!
 
-  def run_b!
+  def run_b!(port=9090)
     begin
       @tmp = File.new(@tmp_path, 'w')
-      @tmp.print "Started!!"
+      @tmp.print "Started on #{port}!!"
       sleep(100)
     rescue Dante::Runner::Abort
       @tmp.print "Abort!!"

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: dante
 version: !ruby/object:Gem::Version 
-  hash: 29
+  hash: 27
   prerelease: 
   segments: 
   - 0
   - 0
-  - 1
-  version: 0.0.1
+  - 2
+  version: 0.0.2
 platform: ruby
 authors: 
 - Nathan Esquenazi
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-11-21 00:00:00 -08:00
+date: 2011-11-28 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -46,6 +46,20 @@ dependencies:
         version: "0"
   type: :development
   version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: mocha
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
 description: Turn any process into a demon.
 email: 
 - nesquena@gmail.com