raad 0.3.1

data/CHANGELOG.md

@@ -0,0 +1,2 @@
+# 0.3.1, 08-24-2011
+- initial release. support for MRI 1.8 & 1.9 only

data/LICENSE.md

@@ -0,0 +1,77 @@
+# Raad
+
+Raad - Ruby as a Daemon lightweight service wrapper
+Authored by Colin Surprenant, [@colinsurprenant][twitter], [colin.surprenant@needium.com][needium], [colin.surprenant@gmail.com][gmail], [http://github.com/colinsurprenant][github]
+
+  Copyright 2011 PraizedMedia Inc. 
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+-------------------------------------------------------------------------------
+
+  Portions of this code are from the Thin project (https://github.com/macournoyer/thin) and under the following license:
+  Ruby License, http://www.ruby-lang.org/en/LICENSE.txt.
+
+-------------------------------------------------------------------------------
+
+  Portions of this code are from the Goliath project (https://github.com/postrank-labs/goliath/) and under the following license:
+  Copyright (c) 2011 PostRank Inc.
+
+  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 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.
+
+-------------------------------------------------------------------------------
+
+  Portions of this code are from the Sinatra project (https://github.com/bmizerany/sinatra) and under the following license:
+  Copyright (c) 2007, 2008, 2009, 2010, 2011 Blake Mizerany 
+
+  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.
+
+
+[needium]: colin.surprenant@needium.com
+[gmail]: colin.surprenant@gmail.com
+[twitter]: http://twitter.com/colinsurprenant
+[github]: http://github.com/colinsurprenant

data/README.md

@@ -0,0 +1,98 @@
+# Raad v0.3.1
+
+Raad - Ruby as a Daemon lightweight service wrapper.
+
+Raad is a non-intrusive, lightweight, simple Ruby daemon maker. Basically A simple class which implements
+the start and stop methods, can be used seemslessy as a daemon or a normal console app.
+
+Raad provides daemon control using the start/stop commands. Your code can optionnally use the Raad
+logging module. 
+
+## Example
+Create a class with a start and a stop method. Just by requiring 'raad', your class will be 
+wrapped by Raad and daemonizable.
+
+    require 'raad'
+
+    class SimpleDaemon
+      def start
+        @stopped = false
+        while !@stopped
+          Raad::Logger.info("simple_daemon running")
+          sleep(1)
+        end
+      end
+
+      def stop
+        @stopped = true
+        Raad::Logger.info("simple_daemon stopped")
+      end
+    end
+
+    run it in console mode, ^C will stop it, calling the stop method
+    $ ruby simple_daemon.rb start
+
+    run it daemonized, by default ./simple_daemon.log and ./simple_daemon.pid will be created
+    $ ruby simple_daemon.rb -d start
+
+    stop daemon, removing ./simple_daemon.pid
+    $ ruby simple_daemon.rb stop 
+
+## Documentation
+
+### Supported rubies
+Raad has only been tested on MRI 1.8 and 1.9. 
+
+### Command line options
+    usage: ruby <service>.rb [options] start|stop
+
+    Raad common options:
+        -e, --environment NAME           set the execution environment (default: development)
+        -l, --log FILE                   log to file (default: in console mode: no, daemonized: <service>.log)
+        -s, --stdout                     log to stdout (default: in console mode: true, daemonized: false)
+        -c, --config FILE                config file (default: ./config/<service>.rb)
+        -d, --daemonize                  run daemonized in the background (default: false)
+        -P, --pid FILE                   pid file when daemonized (default: <service>.pid)
+        -r, --redirect FILE              redirect stdout to FILE when daemonized (default: no)
+        -n, --name NAME                  daemon process name (default: <service>)
+        -v, --verbose                    enable verbose logging (default: false)
+        -h, --help                       display help message
+
+Note that the command line options will always override any config file settings if present.
+### Config file usage
+tbd.
+
+### Logging
+tbd.
+
+### Adding custom command line options
+tbd.
+
+### Stop sequence details
+tbd.
+
+## TODO
+- better doc, more examples
+- specs
+- JRuby support
+
+## Dependencies
+The Log4r gem (~> 1.1.9) is required.
+
+## Author
+Authored by Colin Surprenant, [@colinsurprenant][twitter], [colin.surprenant@needium.com][needium], [colin.surprenant@gmail.com][gmail], [http://github.com/colinsurprenant][github]
+
+## Acknoledgements
+Thanks to the Thin ([https://github.com/macournoyer/thin][thin]), Goliath ([https://github.com/postrank-labs/goliath/][goliath]) 
+and Sinatra ([https://github.com/bmizerany/sinatra][sinatra]) projects for providing inspiration and/or code!
+
+## License
+Raada is distributed under the Apache License, Version 2.0. See the LICENSE.md file.
+
+[needium]: colin.surprenant@needium.com
+[gmail]: colin.surprenant@gmail.com
+[twitter]: http://twitter.com/colinsurprenant
+[github]: http://github.com/colinsurprenant
+[thin]: https://github.com/macournoyer/thin
+[goliath]: https://github.com/postrank-labs/goliath/
+[sinatra]: https://github.com/bmizerany/sinatra

data/lib/raad.rb

@@ -0,0 +1,7 @@
+require 'raad/version'
+require 'raad/env'
+require 'raad/logger'
+require 'raad/configuration'
+require 'raad/unix_daemon'
+require 'raad/runner'
+require 'raad/service'

data/lib/raad/configuration.rb

@@ -0,0 +1,46 @@
+module Raad
+  module Configuration
+    extend self
+
+    def self.init(&block)
+      instance_eval(&block) 
+    end
+
+    def [](key)
+      config[key]
+    end
+
+    # Loads a configuration file and eval its content in the service object context
+    #
+    # @param file [String] The file to load, if not set will use ./config/{servive_name}
+    # @return [Nil]
+    def load(file = nil)
+      return unless File.exists?(file)
+      self.instance_eval(IO.read(file))
+    end
+
+    private
+
+    # cosmetic alias for config dsl
+    def configuration(&block)
+      Configuration.init(&block)
+    end
+
+    def set(key, value)
+      config[key] = value
+    end
+
+    def config
+      @config ||= Hash.new
+    end
+
+    def method_missing(sym, *args)
+      if sym.to_s =~ /(.+)=$/
+        config[$1] = args.first
+      else
+        config[sym]
+      end
+    end
+
+  end
+end

data/lib/raad/env.rb

@@ -0,0 +1,54 @@
+module Raad
+  
+  @env = :development
+
+  # Retrieves the current environment
+  #
+  # @return [Symbol] the current environment
+  def env
+    @env
+  end
+
+  # Sets the current environment
+  #
+  # @param [String or Symbol] env the environment [development|production|stage|test]
+  def env=(env)
+    case(env.to_s)
+    when 'dev', 'development' then @env = :development
+    when 'prod', 'production' then @env = :production
+    when 'stage', 'staging' then @env = :stage
+    when 'test' then @env = :test
+    end
+  end
+
+  # Determines if we are in the production environment
+  #
+  # @return [Boolean] true if current environemnt is production, false otherwise
+  def production?
+    @env == :production
+  end
+
+  # Determines if we are in the development environment
+  #
+  # @return [Boolean] true if current environemnt is development, false otherwise
+  def development?
+    @env == :development
+  end
+
+  # Determines if we are in the staging environment
+  #
+  # @return [Boolean] true if current environemnt is staging, false otherwise
+  def stage?
+    @env == :stage
+  end
+
+  # Determines if we are in the test environment
+  #
+  # @return [Boolean] true if current environemnt is test, false otherwise
+  def test?
+    @env == :test
+  end
+
+  module_function :env, :env=, :production?, :development?, :stage?, :test?
+
+end

data/lib/raad/logger.rb

@@ -0,0 +1,64 @@
+require 'log4r'
+
+module Raad
+  module Logger
+    
+    extend self
+    
+    # Sets up the logging for the runner
+    # @return [Logger] The logger object
+    def setup(options = {})
+      @log = Log4r::Logger.new('raad')
+
+      log_format = Log4r::PatternFormatter.new(:pattern => "[#{Process.pid}:%l] %d :: %m")
+      setup_file_logger(@log, log_format, options[:file]) if options[:file]
+      setup_stdout_logger(@log, log_format) if options[:stdout]
+
+      @verbose = !!options[:verbose]
+
+      @log.level = @verbose ? Log4r::DEBUG : Log4r::INFO
+      @log
+    end
+
+    def level=(l)
+      levels = {
+        :debug => Log4r::DEBUG,
+        :info => Log4r::INFO,
+        :warn => Log4r::WARN,
+        :error => Log4r::ERROR,
+      }
+      @log.level = @verbose ? Log4r::DEBUG : levels[l]
+    end
+
+    private 
+     
+    # setup file logging
+    #
+    # @param log [Logger] The logger to add file logging too
+    # @param log_format [Log4r::Formatter] The log format to use
+    # @return [Nil]
+    def setup_file_logger(log, log_format, file)
+      FileUtils.mkdir_p(File.dirname(file))
+
+      @log.add(Log4r::FileOutputter.new('fileOutput', {
+        :filename => file,
+        :trunc => false,
+        :formatter => log_format
+      }))
+    end
+
+    # setup stdout logging
+    #
+    # @param log [Logger] The logger to add stdout logging too
+    # @param log_format [Log4r::Formatter] The log format to use
+    # @return [Nil]
+    def setup_stdout_logger(log, log_format)
+      @log.add(Log4r::StdoutOutputter.new('console', :formatter => log_format))
+    end
+    
+    def method_missing(sym, *args)
+      @log.send(sym, *args)
+    end
+
+  end
+end

data/lib/raad/runner.rb

@@ -0,0 +1,185 @@
+require 'optparse'
+require 'thread'
+
+module Raad
+  class Runner
+    include Daemonizable
+
+    SECOND = 1
+    SOFT_STOP_TIMEOUT = 58 * SECOND
+    HARD_STOP_TIMEOUT = 60 * SECOND
+
+    # The pid file for the server
+    # @return [String] The file to write the servers pid file into
+    attr_accessor :pid_file
+
+    # The application
+    # @return [Object] The service to execute
+    attr_accessor :service
+
+    # The parsed options
+    # @return [Hash] The options parsed by the runner
+    attr_reader :options
+
+    # Create a new Runner
+    #
+    # @param argv [Array] The command line arguments
+    # @param service [Object] The service to execute
+    def initialize(argv, service)
+      create_options_parser(service).parse!(argv)
+
+      options[:command] = argv[0].to_s.downcase
+      unless ['start', 'stop'].include?(options[:command])
+        puts(">> start|stop command is required")
+        exit!
+      end
+
+      @service = service
+      @service_name = nil
+      @logger_options = nil
+      @pid_file = nil
+      @service_thread = nil
+      @stopped = false
+    end
+
+    def run
+      # first load config if present
+      Configuration.load(options[:config] || File.expand_path("./config/#{default_service_name}.rb"))
+
+      # then set vars which depends on configuration
+      @service_name = options[:name] || Configuration.daemon_name || default_service_name
+
+      # ajust "dynamic defaults"
+      unless options[:log_file]
+        options[:log_file] = (options[:daemonize] ? File.expand_path("#{@service_name}.log") : nil)
+      end
+      unless options[:log_stdout]
+        options[:log_stdout] = !options[:daemonize]
+      end
+
+      @logger_options = {
+        :file => options.delete(:log_file),
+        :stdout => options.delete(:log_stdout),
+        :verbose => options.delete(:verbose),
+      }
+      @pid_file = options.delete(:pid_file) || "./#{@service_name}.pid"
+
+      # setup logging
+      Logger.setup(@logger_options)
+      Logger.level = Configuration.log_level if Configuration.log_level
+
+      if options[:command] == 'stop'
+        puts(">> Raad service wrapper v#{VERSION} stopping")
+        send_signal('TERM', HARD_STOP_TIMEOUT) # if not stopped afer HARD_STOP_TIMEOUT, SIGKILL will be sent
+        exit!
+      end
+      puts(">> Raad service wrapper v#{VERSION} starting")
+
+      Dir.chdir(File.expand_path(File.dirname("./"))) unless Raad.test?
+
+      jruby = (defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby')
+      raise("daemonize not supported in JRuby") if options[:daemonize] && jruby
+      
+      options[:daemonize] ? daemonize(@service_name, options[:redirect]) {run_service} : run_service
+    end
+
+    private
+
+    def default_service_name
+      service.class.to_s.split('::').last.gsub(/(.)([A-Z])/,'\1_\2').downcase!
+    end
+
+    # Create the options parser
+    #
+    # @return [OptionParser] Creates the options parser for the runner with the default options
+    def create_options_parser(service)
+      @options ||= {
+        :daemonize => false,
+        :verbose => false,
+      }
+
+      options_parser ||= OptionParser.new do |opts|
+        opts.banner = "usage: ruby <service>.rb [options] start|stop"
+
+        opts.separator ""
+        opts.separator "Raad common options:"
+    
+        opts.on('-e', '--environment NAME', "set the execution environment (default: #{Raad.env.to_s})") { |val| Raad.env = val }
+
+        opts.on('-l', '--log FILE', "log to file (default: in console mode: no, daemonized: <service>.log)") { |file| @options[:log_file] = file }
+        opts.on('-s', '--stdout', "log to stdout (default: in console mode: true, daemonized: false)") { |v| @options[:log_stdout] = v }
+
+        opts.on('-c', '--config FILE', "config file (default: ./config/<service>.rb)") { |v| @options[:config] = v }
+        opts.on('-d', '--daemonize', "run daemonized in the background (default: #{@options[:daemonize]})") { |v| @options[:daemonize] = v }
+        opts.on('-P', '--pid FILE', "pid file when daemonized (default: <service>.pid)") { |file| @options[:pid_file] = file }
+        opts.on('-r', '--redirect FILE', "redirect stdout to FILE when daemonized (default: no)") { |v| @options[:redirect] = v }
+        opts.on('-n', '--name NAME', "daemon process name (default: <service>)") { |v| @options[:name] = v }
+        opts.on('-v', '--verbose', "enable verbose logging (default: #{@options[:verbose]})") { |v| @options[:verbose] = v }
+
+        opts.on('-h', '--help', 'display help message') { show_options(opts) }
+      end
+      service.respond_to?(:options_parser) ? service.options_parser(options_parser) : options_parser
+    end
+
+    # Output the servers options
+    #
+    # @param opts [OptionsParser] The options parser
+    # @return [exit] This will exit Ruby
+    def show_options(opts)
+      puts(opts)
+      exit!
+    end
+
+    # Run the server
+    #
+    # @return [Nil]
+    def run_service
+      Logger.info("starting #{@service_name} service in #{Raad.env.to_s} mode")
+
+      at_exit do
+        Logger.info(">> Raad service wrapper stopped")
+      end
+
+      # by default exit on SIGTERM and SIGINT
+      [:INT, :TERM, :QUIT].each do |sig|
+        trap(sig) {stop_service}
+      end
+
+      @service_thread = Thread.new do
+        Thread.current.abort_on_exception = true
+        service.start
+      end
+      while @service_thread.join(SECOND).nil?
+        if @stopped
+          Logger.info("stopping #{@service_name} service")
+          service.stop if service.respond_to?(:stop)
+          wait_or_kill_service
+          return
+        end
+      end
+
+      unless @stopped
+        Logger.info("stopping #{@service_name} service")
+        service.stop if service.respond_to?(:stop)
+      end
+    end
+
+    def stop_service
+      @stopped = true
+    end
+
+    def wait_or_kill_service
+      try = 0; join = nil
+      while (try += 1) <= SOFT_STOP_TIMEOUT && join.nil? do
+        join = @service_thread.join(SECOND)
+        Logger.debug("waiting for service to stop #{try}/#{SOFT_STOP_TIMEOUT}") if join.nil?
+      end
+      if join.nil?
+        Logger.error("stop timeout exhausted, killing service thread")
+        @service_thread.kill
+        @service_thread.join
+      end
+    end
+     
+  end
+end

data/lib/raad/service.rb

@@ -0,0 +1,70 @@
+module Raad
+
+  # The main execution class for Raad. This will execute in the at_exit
+  # handler to run the server.
+  class Service
+
+    # Set of caller regex's to be skippe when looking for our API file
+    CALLERS_TO_IGNORE = [ # :nodoc:
+      /\/raad(\/(service))?\.rb$/, # all raad code
+      /rubygems\/custom_require\.rb$/,    # rubygems require hacks
+      /bundler(\/runtime)?\.rb/,          # bundler require hacks
+      /<internal:/                        # internal in ruby >= 1.9.2
+    ]
+
+    # @todo add rubinius (and hopefully other VM impls) ignore patterns ...
+    CALLERS_TO_IGNORE.concat(RUBY_IGNORE_CALLERS) if defined?(RUBY_IGNORE_CALLERS)
+
+    # Like Kernel#caller but excluding certain magic entries and without
+    # line / method information; the resulting array contains filenames only.
+    def self.caller_files
+      caller_locations.map { |file, line| file }
+    end
+
+    # Like caller_files, but containing Arrays rather than strings with the
+    # first element being the file, and the second being the line.
+    def self.caller_locations
+      caller(1).
+        map    { |line| line.split(/:(?=\d|in )/)[0,2] }.
+        reject { |file, line| CALLERS_TO_IGNORE.any? { |pattern| file =~ pattern } }
+    end
+
+    # Find the service_file that was used to execute the service
+    #
+    # @return [String] The service file
+    def self.service_file
+      c = caller_files.first
+      c = $0 if !c || c.empty?
+      c
+    end
+
+    # Execute the service
+    #
+    # @return [Nil]
+    def self.run!
+      file = File.basename(service_file, '.rb')
+      service = Object.module_eval(camel_case(file)).new
+
+      runner = Raad::Runner.new(ARGV, service)
+      runner.run
+    end
+
+    private
+
+    # Convert a string to camel case
+    #
+    # @param str [String] The string to convert
+    # @return [String] The camel cased string
+    def self.camel_case(str)
+      return str if str !~ /_/ && str =~ /[A-Z]+.*/
+
+      str.split('_').map { |e| e.capitalize }.join
+    end
+  end
+
+  at_exit do
+    if $!.nil? && $0 == Raad::Service.service_file
+      Service.run!
+    end
+  end
+end

data/lib/raad/unix_daemon.rb

@@ -0,0 +1,111 @@
+require 'etc'
+require 'timeout'
+
+module Process
+
+  def running?(pid)
+    Process.getpgid(pid) != -1
+  rescue Errno::EPERM
+    true
+  rescue Errno::ESRCH
+    false
+  end
+
+  module_function :running?
+end
+
+# Raised when the pid file already exist starting as a daemon.
+class PidFileExist < RuntimeError; end
+
+# module Daemonizable requires that the including class defines the @pid_file instance variable
+module Daemonizable
+    
+  def pid
+    File.exist?(@pid_file) ? open(@pid_file).read.to_i : nil
+  end
+  
+  def daemonize(name, stdout_file)
+    remove_stale_pid_file
+    pwd = Dir.pwd
+
+    # do the double fork dance
+    Process.fork do
+      Process.setsid
+      exit if fork
+      $0 = name # set process name
+
+      File.umask(0000) # file mode creation mask to 000 to allow creation of files with any required permission late
+      Dir.chdir(pwd)
+      write_pid_file
+
+      # redirect stdout into a log
+      STDIN.reopen('/dev/null')
+      stdout_file ? STDOUT.reopen(stdout_file, "a") : STDOUT.reopen('/dev/null', 'a')
+      STDERR.reopen(STDOUT)
+
+      at_exit do
+        remove_pid_file
+      end
+
+      yield
+    end
+  end
+
+  def send_signal(signal, timeout = 60)
+    if pid = read_pid_file
+      puts(">> sending #{signal} signal to process #{pid}")
+      Process.kill(signal, pid)
+      Timeout.timeout(timeout) do
+        sleep 0.1 while Process.running?(pid)
+      end
+    else
+      puts(">> can't stop process, no pid found in #{@pid_file}")
+    end
+  rescue Timeout::Error
+    force_kill
+  rescue Interrupt
+    force_kill
+  rescue Errno::ESRCH # No such process
+    force_kill
+  end
+  
+  def force_kill
+    if pid = read_pid_file
+      puts(">> sending KILL signal to process #{pid}")
+      Process.kill("KILL", pid)
+      File.delete(@pid_file) if File.exist?(@pid_file)
+    else
+      puts(">> can't stop process, no pid found in #{@pid_file}")
+    end
+  end
+  
+  def read_pid_file
+    if File.file?(@pid_file) && pid = File.read(@pid_file)
+      pid.to_i
+    else
+      nil
+    end
+  end
+
+  def remove_pid_file
+    File.delete(@pid_file) if @pid_file && File.exists?(@pid_file)
+  end
+
+  def write_pid_file
+    puts(">> writing pid to #{@pid_file}")
+    open(@pid_file,"w") { |f| f.write(Process.pid) }
+    File.chmod(0644, @pid_file)
+  end
+
+  def remove_stale_pid_file
+    if File.exist?(@pid_file)
+      if pid && Process.running?(pid)
+        raise PidFileExist, "#{@pid_file} exists and process #{pid} is runnig. stop the process or delete #{@pid_file}"
+      else
+        puts(">> deleting stale pid file #{@pid_file}")
+        remove_pid_file
+      end
+    end
+  end
+
+end

data/lib/raad/version.rb

@@ -0,0 +1,3 @@
+module Raad
+  VERSION = "0.3.1"
+end unless defined?(Raad::VERSION)

metadata

@@ -0,0 +1,97 @@
+--- !ruby/object:Gem::Specification 
+name: raad
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.3.1
+platform: ruby
+authors: 
+- Colin Surprenant
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-08-24 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rubyforge
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 2.5.0
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: log4r
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 1.1.9
+  type: :runtime
+  version_requirements: *id003
+description: Ruby as a Daemon lightweight service wrapper
+email: 
+- colin.surprenant@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/raad/configuration.rb
+- lib/raad/env.rb
+- lib/raad/logger.rb
+- lib/raad/runner.rb
+- lib/raad/service.rb
+- lib/raad/unix_daemon.rb
+- lib/raad/version.rb
+- lib/raad.rb
+- README.md
+- CHANGELOG.md
+- LICENSE.md
+homepage: http://github.com/praized/raad
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: 1.3.0
+requirements: []
+
+rubyforge_project: raad
+rubygems_version: 1.8.9
+signing_key: 
+specification_version: 3
+summary: Ruby as a Daemon
+test_files: []
+