djinn 0.1.0 → 0.1.1

data/README.rdoc

@@ -1,6 +1,6 @@
 = Djinn
 
-Djinn is a very basic helper for building simple daemons.
+Djinn is a helper for building simple daemons.
 
 In Arabian mythology a Djinn is a supernatural creature which occupies a 
 parallel world to that of mankind.
@@ -12,107 +12,183 @@ http://rdoc.info/projects/craigp/djinn
 == Installation
 
   gem install djinn
+  
+== Quickstart Example
 
-== Non-Rails Example (old non-DSL way, will be deprecated soon-ish)
+Because you might not want to read the wordy version of the documentation, let's 
+dive right in and start by writing a simple Djinn and saving it in a file 
+called _file_djinn.rb_
 
   #!/usr/bin/env ruby
 
   require 'rubygems'
   require 'djinn'
 
-  class Basic
-  
+  class FileDjinn
+
     include Djinn
-  
-    # Not providing a "perform" method falls back to the base method 
-    # in Djinn, which does nothing useful. Make sure your method accepts
-    # a config hash, even if it doesn't use it.
-    def perform options
-      while
-        log "ZOMG! A Djinn?"
-        sleep(5)
-      do
-    end
-  
-    # Strictly optional, lets you do stuff when the Djinn daemon stops.
-    # The call to "super" is required, or your daemon will never die
-    def handle_exit
-      log "Handling a nice graceful exit.."
-      super
+
+    djinn do
+
+      configure do
+        add :output_file do
+          short_switch  "-o"
+          long_switch   "--output-file"
+          description   "File to output stuff to"
+          required      true
+        end
+
+        add_flag :create_file do
+          short_switch  "-c"
+          long_switch   "--create-file"
+          description   "Create output file if it doesn't exist"
+        end
+      end
+
+      start do
+        @file = unless File.exists?(config[:output_file])
+          unless config[:create_file]
+            log "File not found: #{config[:output_file]}"
+            nil
+          else
+            File.open(config[:output_file], 'a')
+          end
+        else
+          File.open(config[:output_file], 'a')
+        end
+        if @file
+          log "Opening output file: #{File.expand_path(@file.path)}"
+          loop do
+            @file.puts "Writing to the file at #{Time.now}"
+            @file.flush
+            sleep(5)
+          end
+        end
+      end
+
+      exit do
+        if @file
+          log "Closing output file.."
+          @file.close
+        end
+      end
     end
-  
+
   end
 
-Run it in the foreground like this:
+  FileDjinn.djinnify
 
-  djinn = Basic.new
-  djinn.run
-  
-But running it in the background is sort of the point. A bit contrived, but
-this is the general idea:
+Now we can try and start it using:
 
-  djinn.start
-  sleep(10)
-  djinn.stop
+  ruby file_djinn.rb
   
-Assuming you didn't sleep there your script would end and the daemon would
-detach and run in the background until it dies or gets killed. You can wrap
-argument parsing around that if you want, or do it in any other way. By default 
-the daemon will look for a config YAML file in same directory as you executed it
-from, named the same as the Djinn class, so in this case *basic.yml*. It will by
-default create the pid and log files in the same way. You can change this by 
-putting it in the config file or supplying an options hash:
+Oops, no luck, but you should see something like:
 
-  options = {
-    'pid_file_path' => 'path/to/pid/file',
-    'log_file_path' => 'path/to/log/file'
-  }
-  
-  djinn.start(options)
+  Missing argument: output_file
+
+  Usage: djinn_file [OPTIONS]
+          --no-daemon                  Don't run in the background
+          --stop                       Stop the Djinn, if possible
+      -o, --output-file OUTPUT_FILE    File to output stuff to
+      -c, --create-file                Create output file if it doesn't exist
+      -h, --help                       Prints this message
+      
+Right, now that we know more about this Djinn, let's try again..
+
+  ruby file_djinn.rb -co test.log --no-daemon
   
-These options will also be passed to your *perform* method, so you can include
-anything you need in the hash as well, or in the YAML file for that matter.
+Our shiny new Djinn is running in the foreground! But lets make it run as a daemon:
+
+  ruby file_djinn.rb -co test.log
   
-It might seem ugly, but the solution is minimal, and so remains flexible I think. 
-The Rails daemon helpers are an implementation on top of this illustrating how it 
-can be tailored to include some option parsing and so forth, and so do a little 
-more for you.
+Awesomesauce. Now, I wonder if we can stop it:
 
-== Non-Rails Example (new DSL awesomesauce)
+  ruby file_djinn.rb --stop
 
-Using the same silly example, you can do this:
+== In More Detail
 
-  #!/usr/bin/env ruby
+Okay, so lets pull that example apart and look at things in a little more detail..
 
-  require 'rubygems'
-  require 'djinn'
+=== Djinn Definition
+
+Transmogrifying an otherwise workaday class into a Djinn is all about the
+Djinn definition DSL. So we'll start with the basics, including the module and
+starting a definition block.
 
-  class Basic
+  class MyDjinn
+  
+    include Djinn
+    
+    djinn do
+    
+    end
   
+  end
+
+Right, now we need to tell it _what_ to do, and _when_. There are three events
+we can hook up to in the lifecycle of a Djinn: *start*, *stop* and *exit*. Doing
+something when the Djinn starts is the most important, since otherwise .. well, it
+just won't do anything. So lets use a simple loop for now:
+
+  class MyDjinn
+
     include Djinn
   
     djinn do
-      on :start do
-        while
-          log "ZOMG! A Djinn?"
+    
+      start do
+        loop do
+          log "Doing something.."
           sleep(5)
         end
       end
-  
-      on :exit do
-        log "Handling a nice graceful exit.."
-      end
+    
     end
+
+  end
+
+We've used another helper method provided to us there, namely *log*. This will
+write a timestamped message for us, either to the log if we're running in the
+background, or to stdout if we're running in the foreground.
+
+Just like that we have a working Djinn, well except for one line, at the bottom
+of the file:
+
+  MyDjinn.djinnify
   
+That will take care of parsing any arguments and running the Djinn. We now have
+working Djinn that will log some entirely useless text to a log file! 
+
+=== Configuration
+
+There are a few options available to us if we want to pass configuration information
+to our Djinn.
+
+First, we can do it using command line switches, which we can define as part of our
+Djinn definition block.
+
+  djinn do
+  
+    configure do
+    
+    end
+    
   end
+  
+  
+= OMG I LOST INTEREST IN WRITING THIS
 
-Much cleaner and prettier, and no horrible *super* required. Available
-actions to the *on* method are :start, :stop and :exit
+(Everything past this point is old shit, will update soon)
+ 
 
-Run it in the foreground in the same way:
+  options = {
+    'pid_file_path' => 'path/to/pid/file',
+    'log_file_path' => 'path/to/log/file'
+  }
+  
+  djinn.start(options)
 
-  djinn = Basic.new
-  djinn.run
+Available actions to the *on* method are :start, :stop and :exit
 
 The actions are executed in the context of the Djinn itself, so you can
 get at the config without having to pass it around:
@@ -122,9 +198,9 @@ get at the config without having to pass it around:
       my_setting = config[:omghax]
     end
   end
-  
+
   ...
-  
+
   djinn.run { :omghax => "Groovy, baby" }
   
 You can also give it a block to work with:
@@ -139,50 +215,15 @@ If you need to man-handle the internals and stuff, it yields itself:
     djinn.config[:omghax] = "Groovy, baby"
   end
   
-Starting in the background is the same as before, call *start* instead of *run*:
-
-  djinn.start
-  
-The Rails Djinns can be built in exactly the same way as this.
-  
 == Rails Example
 
-There's a simple example in the example directory if you check the code out, but
-here's the gist of it.
-
-Assumes a scenario where you have a Book model that keeps a count of how many
-times a book has been read.  
-
-Create a file in RAILS_ROOT/lib or somewhere similar:
-
-  require 'djinn/rails'
-  require 'eventmachine'
-
-  class BookDjinn
-  
-    BOOK_WORKER_INTERVAL = 5
-  
-    include Djinn::Rails
-
-    def perform config
-      EM.run do
-        log "Workers will run every #{BOOK_WORKER_INTERVAL} secs"
-        EM::PeriodicTimer.new(BOOK_WORKER_INTERVAL) do
-          log "There are #{Book.count} book(s) in the database"
-          log "Updating read counts for all books.."
-          Book.all.each &:read!
-        end
-      end
-    end
+The original intention of the gem was to build daemons for my Rails apps, and
+there's a simple example Rails app with a daemon in the example directory if 
+you check the code out of git, but here's the gist of it. Assumes a scenario 
+where you have a Book model that keeps a count of how many times a book has 
+been read..
 
-    def handle_exit
-      EM.stop
-      super
-    end
-
-  end
-  
-(And, the new more awesome way:)
+Create a file in RAILS_ROOT/lib or somewhere similar in your load path:
 
   require 'djinn/rails'
   require 'eventmachine'
@@ -241,10 +282,10 @@ Yay, we have a daemon running in the background! To stop it:
   
 That gives you more-or-less everything you need to build something basic
 and monitor it with god or a similar process monitor.
-  
+
 == TODO
 
-Lots.
+Update this documentation.
 
 == Copyright
 

data/README.rdoc.old

@@ -0,0 +1,251 @@
+= Djinn
+
+Djinn is a very basic helper for building simple daemons.
+
+In Arabian mythology a Djinn is a supernatural creature which occupies a 
+parallel world to that of mankind.
+
+== Documentation
+
+http://rdoc.info/projects/craigp/djinn
+
+== Installation
+
+  gem install djinn
+
+== Non-Rails Example (old non-DSL way, will be deprecated soon-ish)
+
+  #!/usr/bin/env ruby
+
+  require 'rubygems'
+  require 'djinn'
+
+  class Basic
+  
+    include Djinn
+  
+    # Not providing a "perform" method falls back to the base method 
+    # in Djinn, which does nothing useful. Make sure your method accepts
+    # a config hash, even if it doesn't use it.
+    def perform options
+      while
+        log "ZOMG! A Djinn?"
+        sleep(5)
+      do
+    end
+  
+    # Strictly optional, lets you do stuff when the Djinn daemon stops.
+    # The call to "super" is required, or your daemon will never die
+    def handle_exit
+      log "Handling a nice graceful exit.."
+      super
+    end
+  
+  end
+
+Run it in the foreground like this:
+
+  djinn = Basic.new
+  djinn.run
+  
+But running it in the background is sort of the point. A bit contrived, but
+this is the general idea:
+
+  djinn.start
+  sleep(10)
+  djinn.stop
+  
+Assuming you didn't sleep there your script would end and the daemon would
+detach and run in the background until it dies or gets killed. You can wrap
+argument parsing around that if you want, or do it in any other way. By default 
+the daemon will look for a config YAML file in same directory as you executed it
+from, named the same as the Djinn class, so in this case *basic.yml*. It will by
+default create the pid and log files in the same way. You can change this by 
+putting it in the config file or supplying an options hash:
+
+  options = {
+    'pid_file_path' => 'path/to/pid/file',
+    'log_file_path' => 'path/to/log/file'
+  }
+  
+  djinn.start(options)
+  
+These options will also be passed to your *perform* method, so you can include
+anything you need in the hash as well, or in the YAML file for that matter.
+  
+It might seem ugly, but the solution is minimal, and so remains flexible I think. 
+The Rails daemon helpers are an implementation on top of this illustrating how it 
+can be tailored to include some option parsing and so forth, and so do a little 
+more for you.
+
+== Non-Rails Example (new DSL awesomesauce)
+
+Using the same silly example, you can do this:
+
+  #!/usr/bin/env ruby
+
+  require 'rubygems'
+  require 'djinn'
+
+  class Basic
+  
+    include Djinn
+  
+    djinn do
+      on :start do
+        while
+          log "ZOMG! A Djinn?"
+          sleep(5)
+        end
+      end
+  
+      on :exit do
+        log "Handling a nice graceful exit.."
+      end
+    end
+  
+  end
+
+Much cleaner and prettier, and no horrible *super* required. Available
+actions to the *on* method are :start, :stop and :exit
+
+Run it in the foreground in the same way:
+
+  djinn = Basic.new
+  djinn.run
+
+The actions are executed in the context of the Djinn itself, so you can
+get at the config without having to pass it around:
+
+  djinn do
+    on :start do
+      my_setting = config[:omghax]
+    end
+  end
+  
+  ...
+  
+  djinn.run { :omghax => "Groovy, baby" }
+  
+You can also give it a block to work with:
+
+  djinn.run do
+    puts "This will happen before calling the :start action"
+  end
+
+If you need to man-handle the internals and stuff, it yields itself:
+
+  djinn.run do |djinn|
+    djinn.config[:omghax] = "Groovy, baby"
+  end
+  
+Starting in the background is the same as before, call *start* instead of *run*:
+
+  djinn.start
+  
+The Rails Djinns can be built in exactly the same way as this.
+  
+== Rails Example
+
+There's a simple example in the example directory if you check the code out, but
+here's the gist of it.
+
+Assumes a scenario where you have a Book model that keeps a count of how many
+times a book has been read.  
+
+Create a file in RAILS_ROOT/lib or somewhere similar:
+
+  require 'djinn/rails'
+  require 'eventmachine'
+
+  class BookDjinn
+  
+    BOOK_WORKER_INTERVAL = 5
+  
+    include Djinn::Rails
+
+    def perform config
+      EM.run do
+        log "Workers will run every #{BOOK_WORKER_INTERVAL} secs"
+        EM::PeriodicTimer.new(BOOK_WORKER_INTERVAL) do
+          log "There are #{Book.count} book(s) in the database"
+          log "Updating read counts for all books.."
+          Book.all.each &:read!
+        end
+      end
+    end
+
+    def handle_exit
+      EM.stop
+      super
+    end
+
+  end
+  
+(And, the new more awesome way:)
+
+  require 'djinn/rails'
+  require 'eventmachine'
+
+  class BookDjinn
+  
+    BOOK_WORKER_INTERVAL = 5
+  
+    include Djinn::Rails
+
+    djinn do
+    
+      on :start do
+        EM.run do
+          log "Workers will run every #{BOOK_WORKER_INTERVAL} secs"
+          EM::PeriodicTimer.new(BOOK_WORKER_INTERVAL) do
+            log "There are #{Book.count} book(s) in the database"
+            log "Updating read counts for all books.."
+            Book.all.each &:read!
+          end
+        end
+      end
+
+      on :exit do
+        EM.stop
+      end
+      
+    end
+
+  end
+
+Right, now you need to start it somehow. The easiest way is to create a file 
+in RAILS_ROOT/scripts and pop this in it:
+
+  #!/usr/bin/env ruby
+  require 'rubygems'
+  require File.join(File.dirname(__FILE__), '../lib/book_djinn')
+  BookDjinn.go ARGV
+ 
+Righto, now start it from RAILS_ROOT:
+
+  ruby script/book_djinn
+  
+Okay, but that defaults to _run_, which starts it in the foreground and also 
+uses the rails development environment by default. Try this:
+
+  ruby script/book_djinn --help
+  
+That should give you a better idea of what's going on, then try this:
+
+  ruby script/book_djinn start -e production
+  
+Yay, we have a daemon running in the background! To stop it:
+
+  ruby script/book_djinn stop
+  
+That gives you more-or-less everything you need to build something basic
+and monitor it with god or a similar process monitor.
+  
+== TODO
+
+Lots.
+
+== Copyright
+
+Copyright (c) 2010 Craig Paterson. See LICENSE for details.

data/VERSION

@@ -1 +1 @@
-0.1.0
+0.1.1

data/djinn.gemspec

@@ -5,33 +5,35 @@
 
 Gem::Specification.new do |s|
   s.name = %q{djinn}
-  s.version = "0.1.0"
+  s.version = "0.1.1"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Craig Paterson"]
-  s.date = %q{2010-07-28}
+  s.date = %q{2010-07-30}
   s.description = %q{Helper for creating simple custom daemons}
   s.email = %q{darksavant@gmail.com}
   s.extra_rdoc_files = [
     "LICENSE",
-     "README.rdoc"
+     "README.rdoc",
+     "README.rdoc.old"
   ]
   s.files = [
     ".document",
      ".gitignore",
      "LICENSE",
      "README.rdoc",
+     "README.rdoc.old",
      "Rakefile",
      "VERSION",
      "djinn.gemspec",
      "lib/djinn.rb",
      "lib/djinn/base.rb",
-     "lib/djinn/dsl.rb",
-     "lib/djinn/logging.rb",
-     "lib/djinn/pid_file.rb",
+     "lib/djinn/base/dsl.rb",
+     "lib/djinn/base/logging.rb",
+     "lib/djinn/base/pid_file.rb",
+     "lib/djinn/base/tonic.rb",
      "lib/djinn/rails.rb",
      "lib/djinn/rails/handlers.rb",
-     "lib/djinn/tonic.rb",
      "test/helper.rb",
      "test/test_djinn.rb"
   ]

data/lib/djinn.rb

@@ -1,8 +1,9 @@
-$:.unshift(File.dirname(__FILE__))
+dir = File.expand_path(File.dirname(__FILE__))
+$:.unshift(dir) unless $:.include?(dir)
 
 require 'yaml'
 require 'djinn/base'
-require 'djinn/dsl'
+require 'djinn/base/dsl'
 
 # In Arabian mythology a Djinn is a supernatural creature which occupies a 
 # parallel world to that of mankind

data/lib/djinn/base.rb

@@ -1,23 +1,26 @@
-$:.unshift(File.dirname(__FILE__))
+dir = File.expand_path(File.dirname(__FILE__))
+$:.unshift(dir) unless $:.include?(dir)
 
-require 'tonic'
-require 'pid_file'
-require 'logging'
+require 'base/tonic'
+require 'base/pid_file'
+require 'base/logging'
 
 module Djinn
   # The base class from which all Djinn spring forth
   module Base
         
-    include Djinn::Tonic
-    include Djinn::Logging
+    include Djinn::Base::Tonic
+    include Djinn::Base::Logging
         
     attr_reader :config
     
+    def initialize
+      @config = { :__daemonize => true }
+    end
+    
     # Base implementation does nothing worthwhile, you should override this 
-    # in your own implementation 
+    # in your own implementation.
     def perform config={}
-      trap('TERM') { handle_exit }
-      trap('INT')  { handle_exit }
       while
         log("[#{name}] Djinn is running.. and doing nothing worthwhile.")
         sleep(5)
@@ -25,15 +28,17 @@ module Djinn
     end
 
     # Override this with useful exit code if you need to, but remember to
-    # call *super* or call *exit* yourself, or your Djinn will be immortal 
+    # call *super* or call *exit* yourself, or your Djinn will be immortal.
+    # This is truly terrible code, and will be removed soon.
     def handle_exit
       __exit! if respond_to?(:__exit!)
       exit(0)
     end
 
-    # Starts the Djinn in the background
+    # Starts the Djinn in the background.
     def start config={}, &block
-      @config = (config.empty?) ? load_config : config
+      @config.update(config).update(load_config)
+      #@config = (config.empty?) ? load_config : config
       log "Starting #{name} in the background.."
       logfile = get_logfile(config)
       daemonize(logfile, get_pidfile(config)) do
@@ -41,18 +46,25 @@ module Djinn
         trap('TERM') { handle_exit }
         trap('INT')  { handle_exit }
         (respond_to?(:__start!)) ? __start! : perform(@config)
+        # If this process doesn't loop or otherwise breaks out of 
+        # the loop we still want to clean up after ourselves
+        handle_exit
       end
     end
 
     # Starts the Djinn in the foreground, which is often useful for
-    # testing or other noble pursuits
+    # testing or other noble pursuits.
     def run config={}, &block
-      @config = (config.empty?) ? load_config : config
+      @config.update(config).update(load_config)
+      # @config = (config.empty?) ? load_config : config
       log "Starting #{name} in the foreground.."
       trap('TERM') { handle_exit }
       trap('INT')  { handle_exit }
       yield(self) if block_given?
       (respond_to?(:__start!)) ? __start! : perform(@config)
+      # If this process doesn't loop or otherwise breaks out of 
+      # the loop we still want to clean up after ourselves
+      handle_exit
     end
 
     # Convenience method, really just calls *stop* and then *start* for you :P
@@ -64,7 +76,8 @@ module Djinn
     # Stops the Djinn, unless you change the location of the pid file, in 
     # which case its all about you and the *kill* command
     def stop config={}
-      @config = (config.empty?) ? load_config : config
+      @config.update(config).update(load_config)
+      # @config = (config.empty?) ? load_config : config
       yield(self) if block_given?
       __stop! if respond_to?(:__stop!)
       pidfile = get_pidfile(@config)

data/lib/djinn/base/dsl.rb

@@ -0,0 +1,191 @@
+require 'optparse'
+
+module Djinn
+  module Base
+    # Defines the awesomesauce DSL defining your Djinn
+    module Dsl
+        
+      # Start your Djinn definition
+      def djinn &block
+        @definition = DslDefinitionHelper.new(&block)
+        @definition.actions.each do |action, proc|
+          module_eval do
+            define_method "__#{action}!".intern do |*args|
+              instance_exec(&proc)
+            end
+          end
+        end
+      end
+      
+      # Create an instance of your Djinn, interpret any command line switches
+      # defined in your configuration block, and starts the Djinn in the
+      # background
+      def djinnify config={}
+        djinn = new
+        @definition.prepare(djinn.config.update(config))
+        unless djinn.config[:__stop]
+          if djinn.config[:__daemonize]
+            djinn.start
+          else
+            djinn.run
+          end
+        else
+          djinn.stop
+        end
+      end
+      
+      # Used internally to read configuration blocks
+      class ConfigHelper
+        
+        attr_accessor :config
+        
+        def initialize &block
+          @config_items = []
+          instance_eval(&block)
+        end
+        
+        # Add a posix-style switch to your Djinn
+        def add key, &block
+          @config_items << ConfigItem.new(:posix, key, &block)
+        end
+        
+        # Add a simple flag switch to your daemon
+        def add_flag key, &block
+          @config_items << ConfigItem.new(:flag, key, &block)
+        end
+        
+        # Parses the configuration items created by executing the
+        # configuration block
+        def parse_config!(config)
+          opts = OptionParser.new do |opts|
+            opts.banner = "Usage: djinn_file [OPTIONS]"
+            opts.on("--no-daemon", "Don't run in the background") do
+              config[:__daemonize] = false
+            end
+            opts.on("--stop", "Stop the Djinn, if possible") do
+              config[:__stop] = true
+            end
+            opts.on_tail("-h", "--help", "Prints this message") do
+              puts opts
+              exit(0)
+            end
+            @config_items.each { |c| c.parse!(opts, config) }
+          end
+          opts.parse!
+          @config_items.each do |ci|
+            if ci.required?
+              puts "Missing argument: #{ci.key}\n\n#{opts}"
+              exit(1)
+            end unless config.include?(ci.key) or config.include?(:__stop)
+          end
+        rescue OptionParser::InvalidOption => e
+          puts e.message
+          exit(1)
+        end
+        
+      end
+      
+      # A helper class to hold individual configuration items
+      class ConfigItem
+        
+        attr_reader :key
+        
+        def initialize t, key, &block
+          @type, @key = t, key
+          instance_eval(&block)
+        end
+        
+        # Short configuration switch 
+        def short_switch s
+          @short_switch = s
+          @short_switch = "-#{@short_switch}" unless @short_switch =~ /^-/
+        end
+        
+        # Long configuration switch
+        def long_switch s
+          @long_switch = s
+          @long_switch = "--#{@long_switch}" unless @long_switch =~ /^--/
+        end
+               
+        # Description of the switch 
+        def description d
+          @description = d
+        end
+        
+        # Sets whether the switch is required
+        def required r
+          @required = r
+        end
+        
+        # Checks whether the switch is required
+        def required?
+          @required
+        end
+                
+        # Parse the individual configuration option
+        def parse! opts, config
+          @long_switch = "#{@long_switch} #{@key.to_s.upcase}" if @type == :posix and \
+            defined?(@key) && @key
+          switches = []
+          switches << (defined?(@short_switch) && @short_switch) ? @short_switch : nil
+          switches << (defined?(@long_switch) && @long_switch) ? @long_switch : nil
+          opts.on(switches[0], switches[1], @description) do |o|
+            config[@key] = o
+          end
+        end
+        
+      end
+
+      # A helper class for interpretting the definition block of a Djinn
+      class DslDefinitionHelper
+      
+        attr_accessor :actions, :config_helper
+      
+        def initialize &block
+          @actions = {}
+          instance_eval(&block)
+        end
+      
+        # Define configuration for a Djinn, adding ARGV switches that
+        # can be interpreted and acted on in your actions 
+        def configure &block
+          @config_helper = ConfigHelper.new(&block)
+        end
+      
+        # Define an action that will be performed by a Djinn
+        def on action, &block
+          acceptable_actions = %w(start stop exit)
+          raise DjinnActionError.new("\"#{action}\" is unrecognized, please use one of: #{acceptable_actions.join(', ')}") \
+            unless acceptable_actions.include?(action.to_s)
+          @actions[action] = block
+        end
+                
+        # Runs when the Djinn starts
+        def start &block
+          @actions[:start] = block
+        end
+        
+        # Runs when Djinn exits
+        def exit &block
+          @actions[:exit] = block
+        end
+        
+        # Runs when the Djinn stops
+        def stop &block
+          @actions[:stop] = block
+        end
+        
+        # Preare the Djinn configuration based on informations passed in
+        # in the configuration block
+        def prepare(config)
+          @config_helper.parse_config!(config)
+        end
+      
+      end
+    
+      # This error means you screwed something up in your action definition 
+      class DjinnActionError < Exception; end
+  
+    end
+  end
+end

data/lib/djinn/base/logging.rb

@@ -0,0 +1,35 @@
+module Djinn
+  module Base
+    # Logging Helper Class of Awesomeness
+    module Logging
+      
+      # Log something to STDOUT, or wherever it's been redirected to
+      def log msg
+        puts "#{Time.now.strftime("%m/%d/%Y %H:%M:%S")}: #{msg}"
+        STDOUT.flush
+      end
+  
+      # Make some text *green*
+      def green text
+        colorize 32, text
+      end
+
+      # Make some text *red*
+      def red text
+        colorize 31, text
+      end
+  
+      # Make some text *cyan*
+      def cyan text
+        colorize 36, text
+      end
+
+      private
+
+        def colorize color, text
+          "\033[#{color}m#{text}\033[0m"
+        end
+  
+    end
+  end
+end

data/lib/djinn/base/pid_file.rb

@@ -0,0 +1,41 @@
+module Djinn
+  module Base
+    # pid files are what bind your Djinn to the material plane
+    class PidFile
+
+      attr_reader :file
+
+      def initialize(file)
+        @file = file 
+      end
+
+      def pid
+        File.exists?(@file) and IO.read(@file).to_i
+      end
+
+      def remove
+        File.unlink(@file) if pid
+      end
+
+      def create
+        File.open(@file, "w") { |f| f.write($$) }
+      end
+
+      def ensure_empty
+        _pid = self.pid
+        if _pid
+          $stdout.puts <<-MSG
+It looks like this Djinn is already running, not starting.
+Alternatively, you could just have an orphaned pid file,
+try running this command to check:
+
+    ps aux | grep #{_pid}
+            MSG
+          exit 1
+        end
+      end
+
+    end
+  end
+end
+

data/lib/djinn/base/tonic.rb

@@ -0,0 +1,51 @@
+module Djinn
+  module Base
+    # This play on words kills me everytime. I'm that lame.
+    module Tonic
+  
+      # Send your Djinn off to frolic in the ether
+      def daemonize(logfile, pidfile, &block)
+        pidfile.ensure_empty
+        puts "Djinn is leaving process #{$$}"
+      
+        srand # split rand streams between spawning and daemonized process
+      
+        fork do
+          puts "Daemonizing on process #{$$}" 
+          # puts system("ps aux | grep #{$$}")
+    
+          #Dir.chdir "/" # release old working directory
+          File.umask 0000 # ensure sensible umask
+    
+          # Making sure all file descriptors are closed
+          ObjectSpace.each_object(IO) do |io|
+            unless [STDIN, STDOUT, STDERR].include?(io)
+              begin
+                io.close unless io.closed?
+              rescue ::Exception
+              end
+            end
+          end
+        
+          pidfile.create # write PID file
+        
+          # detach from controlling terminal
+          unless sess_id = Process.setsid
+            raise 'Cannot detach from controlling terminal'
+          end
+    
+          # redirect IO
+          STDIN.reopen('/dev/null')
+          STDOUT.reopen(logfile, 'a')
+          STDERR.reopen(STDOUT)
+    
+          yield
+    
+        end
+    
+      end
+  
+    end
+  end
+end
+

data/lib/djinn/rails.rb

@@ -1,10 +1,11 @@
-$:.unshift(File.join(File.dirname(__FILE__)))
+dir = File.expand_path(File.dirname(__FILE__))
+$:.unshift(dir) unless $:.include?(dir)
 
 require 'yaml'
 
 require 'base'
 require 'rails/handlers'
-require 'dsl'
+require 'base/dsl'
 
 module Djinn
   # The basis for all Djinn that want to soar among the Rails stars
@@ -14,9 +15,9 @@ module Djinn
 
     def self.included(base)
       base.__send__(:extend, Djinn::Rails::Handlers)
-      base.__send__(:extend, Djinn::Dsl)
+      base.__send__(:extend, Djinn::Base::Dsl)
     end
-        
+            
     RAILS_ROOT = File.expand_path(Dir.pwd) unless defined?(RAILS_ROOT)
     
     private

data/lib/djinn/rails/handlers.rb

@@ -4,12 +4,16 @@ module Djinn
       
       require 'optparse'
       
-      def go args=[]
+      def djinnify_rails args=[]
         action = parse_args(args)
         self.new.__send__(action.intern) do
           load_rails unless %w(stop restart).include?(action)
         end
       end
+            
+      def go args=[]
+        djinnify_rails(args)
+      end
     
       private
   

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: djinn
 version: !ruby/object:Gem::Version 
-  hash: 27
+  hash: 25
   prerelease: false
   segments: 
   - 0
   - 1
-  - 0
-  version: 0.1.0
+  - 1
+  version: 0.1.1
 platform: ruby
 authors: 
 - Craig Paterson
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-07-28 00:00:00 +02:00
+date: 2010-07-30 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -43,22 +43,24 @@ extensions: []
 extra_rdoc_files: 
 - LICENSE
 - README.rdoc
+- README.rdoc.old
 files: 
 - .document
 - .gitignore
 - LICENSE
 - README.rdoc
+- README.rdoc.old
 - Rakefile
 - VERSION
 - djinn.gemspec
 - lib/djinn.rb
 - lib/djinn/base.rb
-- lib/djinn/dsl.rb
-- lib/djinn/logging.rb
-- lib/djinn/pid_file.rb
+- lib/djinn/base/dsl.rb
+- lib/djinn/base/logging.rb
+- lib/djinn/base/pid_file.rb
+- lib/djinn/base/tonic.rb
 - lib/djinn/rails.rb
 - lib/djinn/rails/handlers.rb
-- lib/djinn/tonic.rb
 - test/helper.rb
 - test/test_djinn.rb
 has_rdoc: true

data/lib/djinn/dsl.rb

@@ -1,40 +0,0 @@
-module Djinn
-  # Defines the awesomesauce DSL for a whole new generation of Djinn
-  module Dsl
-  
-    # Start your Djinn definition
-    def djinn &block
-      @dsl_helper = DslHelper.new(&block)
-      @dsl_helper.actions.each do |action, proc|
-        module_eval do
-          define_method "__#{action}!".intern do |*args|
-            instance_exec(&proc)
-          end
-        end
-      end
-    end
-
-    class DslHelper
-      
-      attr_accessor :actions
-      
-      def initialize &block
-        @actions = {}
-        instance_eval(&block)
-      end
-      
-      # Define an action that will be performed by a Djinn
-      def on action, &block
-        acceptable_actions = %w(start stop exit)
-        raise DslActionError.new("\"#{action}\" is unrecognized, please use one of: #{acceptable_actions.join(', ')}") \
-          unless acceptable_actions.include?(action.to_s)
-        @actions[action] = block
-      end
-      
-    end
-    
-    # This error means you screwed something up in your action definition 
-    class DslActionError < Exception; end
-  
-  end
-end

data/lib/djinn/logging.rb

@@ -1,33 +0,0 @@
-module Djinn
-  # Logging Helper Class of Awesomeness
-  module Logging
-      
-    # Log something to STDOUT, or wherever it's been redirected to
-    def log msg
-      puts "#{Time.now.strftime("%m/%d/%Y %H:%M:%S")}: #{msg}"
-      STDOUT.flush
-    end
-  
-    # Make some text *green*
-    def green text
-      colorize 32, text
-    end
-
-    # Make some text *red*
-    def red text
-      colorize 31, text
-    end
-  
-    # Make some text *cyan*
-    def cyan text
-      colorize 36, text
-    end
-
-    private
-
-      def colorize color, text
-        "\033[#{color}m#{text}\033[0m"
-      end
-  
-  end
-end

data/lib/djinn/pid_file.rb

@@ -1,31 +0,0 @@
-module Djinn
-  # pid files are what bind your Djinn to the material plane
-  class PidFile
-
-    attr_reader :file
-
-    def initialize(file)
-      @file = file 
-    end
-
-    def pid
-      File.exists?(@file) and IO.read(@file).to_i
-    end
-
-    def remove
-      File.unlink(@file) if pid
-    end
-
-    def create
-      File.open(@file, "w") { |f| f.write($$) }
-    end
-
-    def ensure_empty(msg = nil)
-      if self.pid
-        $stdout.puts msg if msg
-        exit 1
-      end
-    end
-
-  end
-end

data/lib/djinn/tonic.rb

@@ -1,49 +0,0 @@
-module Djinn
-  # This play on words kills me everytime. I'm that lame.
-  module Tonic
-  
-    # Send your Djinn off to frolic in the ether
-    def daemonize(logfile, pidfile, &block)
-      pidfile.ensure_empty("It looks like I'm already running. Not starting.")
-      puts "Djinn is leaving process #{$$}"
-      
-      srand # split rand streams between spawning and daemonized process
-      
-      fork do
-        puts "Daemonizing on process #{$$}" 
-        # puts system("ps aux | grep #{$$}")
-    
-        #Dir.chdir "/" # release old working directory
-        File.umask 0000 # ensure sensible umask
-    
-        puts 'Making sure all file descriptors are closed'
-        ObjectSpace.each_object(IO) do |io|
-          unless [STDIN, STDOUT, STDERR].include?(io)
-            begin
-              io.close unless io.closed?
-            rescue ::Exception
-            end
-          end
-        end
-        
-        pidfile.create # write PID file
-        
-        # detach from controlling terminal
-        unless sess_id = Process.setsid
-          raise 'Cannot detach from controlling terminal'
-        end
-    
-        # redirect IO
-        STDIN.reopen('/dev/null')
-        STDOUT.reopen(logfile, 'a')
-        STDERR.reopen(STDOUT)
-    
-        yield
-    
-      end
-    
-    end
-  
-  end
-end
-