rails_daemons 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 341d44fec654ca5a7bd975916ab575d877103b1c
+  data.tar.gz: 171b1b87e26e5468321c4683e82e93bf598fb643
+SHA512:
+  metadata.gz: 1623e1db2fea6fc3f69f4b2ca4680453c4ab59a8eda59dfd117394b62ba5aeac725f2dcef972122bebe397622a829790f01a42007318343f601076c404261a90
+  data.tar.gz: 3cdabbaeb5782b96c560296afb3b2e488fda08d62fb2d6cf4f090bf0d6b3509328b289ad3970a29de81928fb378f2e755604775d22e4f841e54eb142f9fb9432

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.ruby-gemset

@@ -0,0 +1 @@
+rails_daemons

data/.ruby-version

@@ -0,0 +1 @@
+2.1.5

data/Capfile

@@ -0,0 +1,25 @@
+# Load DSL and Setup Up Stages
+require 'capistrano/setup'
+
+# Includes default deployment tasks
+require 'capistrano/deploy'
+
+# Includes tasks from other gems included in your Gemfile
+#
+# For documentation on these, see for example:
+#
+#   https://github.com/capistrano/rvm
+#   https://github.com/capistrano/rbenv
+#   https://github.com/capistrano/chruby
+#   https://github.com/capistrano/bundler
+#   https://github.com/capistrano/rails/tree/master/assets
+#   https://github.com/capistrano/rails/tree/master/migrations
+#
+# require 'capistrano/rvm'
+# require 'capistrano/rbenv'
+# require 'capistrano/chruby'
+# require 'capistrano/bundler'
+# require 'capistrano/rails/assets'
+# require 'capistrano/rails/migrations'
+
+require 'rails_daemons/capistrano'

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Sergey Malykh
+
+MIT License
+
+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,218 @@
+# RailsDaemons
+
+Background workers for Rails. The gem is designed to safely handling exceptions occured in workers. Daemons restarts gracefully to achieve zerro downtime. RailsDaemons includes [Capistrano](https://github.com/capistrano/capistrano) and [Monit](https://mmonit.com/monit/) support. The gem also supports logrotate by safely handling signal USR1.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'rails_daemons'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install rails_daemons
+
+## Capistrano integration
+    
+Add ```require 'rails_daemons/capistrano'``` to Capfile
+
+This will get available commands:
+
+```
+  cap production daemon:start[<worker_name>]
+  cap production daemon:restart[<worker_name>]
+  cap production daemon:stop[<worker_name>]
+```
+
+## Background worker controls
+    
+```
+  bundle exec daemon start <worker_name>
+  bundle exec daemon restart <worker_name>
+  bundle exec daemon stop <worker_name>
+```
+
+## Worker construction
+
+Create background worker.
+
+```ruby
+  class ParserWorker
+    include RailsDaemons::Worker
+
+    def work
+      # your work here
+    end
+  end
+```
+
+Also you can specify:
+
+  * ```tick``` - delay between daemon cycles (in seconds, default 1.0)
+  * ```start``` - work that should be done once on the daemon`s start (and restart)
+  * ```shutdown``` - work that should be done before the daemon`s stop (either on exception or regular stop)
+
+Example usage (with Mongoid):
+
+  ```ruby
+    # app/models/parsing.rb
+    class Parsing
+      include Mongoid::Document
+
+      field :url
+      field :state, default: 'pending'
+
+      scope :pending, ->() { where( state: 'pending' ) }
+      scope :running, ->() { where( state: 'running' ) }
+
+      class << self
+        def start
+          [ 'http://www.example.com' ].each do |url|
+            create!( url: url )
+          end
+        end
+      end
+
+      def process( logger ) 
+        set( state: 'running' )
+
+        # do the job
+
+      rescue => e
+        logger.info e.inspect
+        
+        set( state: 'halted' )
+      end
+    end
+
+    # app/daemons/parser_worker.rb
+    class ParserWorker
+      include RailsDaemons::Worker
+
+      def tick
+        3 # in seconds
+      end
+
+      # daemon start
+      def start
+        require 'mechanize'
+        require 'rufus-scheduler'
+
+        scheduler = Rufus::Scheduler.new
+
+        scheduler.every '12h' do
+          Parsing.start # create parsing jobs every 12 hours
+        end
+      end
+
+      # main work
+      def work
+        Parsing.pending.each do |parsing|
+          t = Thread.new do
+            parsing.process( $logger )
+          end
+
+          # exceptions handled in method ```process``` (just for an example)
+          t.abort_on_exception = false
+        end
+      end
+
+      # stop the daemon
+      def shutdown
+        Parsing.running.each do |parsing|
+          parsing.set( state: 'stopped' )
+        end
+      end
+    end  
+
+  ```
+
+## Monit integration:
+
+Put the following code to /etc/init.d/<worker_name>, replace <worker_name> with you name.
+
+```
+#!/bin/bash
+### BEGIN INIT INFO
+# Provides:          <worker_name>
+# Required-Start:    $all
+# Required-Stop:     $network $local_fs $syslog
+# Default-Start:     2 3 4 5
+# Default-Stop:      0 1 6
+# Short-Description: Start daemon at boot
+# Description:       Enable daemon at boot time.
+### END INIT INFO
+
+set -u
+set -e
+
+# Change these to match your app:
+APP_NAME=app
+ENV=production
+USER=user
+APP_ROOT="/home/$USER/$APP_NAME/current"
+
+SET_PATH="cd $APP_ROOT; rvm use `cat $APP_ROOT/.ruby-version`@`cat $APP_ROOT/.ruby-gemset`"
+OUT=">> $APP_ROOT/log/worker_name.$ENV.monit.log 2>&1"
+
+cd $APP_ROOT || exit 1
+
+case ${1-help} in
+start)
+  su - $USER -c "$SET_PATH; RAILS_ENV=$ENV bundle exec daemon start <worker_name> $OUT"
+  ;;
+stop)
+  su - $USER -c "$SET_PATH; RAILS_ENV=$ENV bundle exec daemon stop <worker_name> $OUT"
+  ;;
+restart|reload)
+  su - $USER -c "$SET_PATH; RAILS_ENV=$ENV bundle exec daemon restart <worker_name> $OUT"
+  ;;
+*)
+  echo >&2 "Usage: $0 <start|stop|restart>"
+  exit 1
+  ;;
+esac 
+```
+
+Monit task:
+
+```
+check process <worker_name> with pidfile /<path_to_project>/current/tmp/pids/<worker_name>.production.pid
+  start program = "/etc/init.d/<worker_name> start"
+  stop program = "/etc/init.d/<worker_name> stop"
+  if changed pid for 3 times within 5 cycles then restart
+  if 5 restarts within 5 cycles then timeout
+```
+
+## Logrotate integration
+
+```
+/<path_to_project>/shared/log/*.log
+{
+        su <user> <group>
+        daily
+        missingok
+        rotate 360
+        compress
+        delaycompress
+        notifempty
+    dateext
+        create 0660 <user> <group>
+        postrotate
+                [ ! -f /<path_to_project>/shared/tmp/pids/unicorn.pid ] || kill -USR1 `cat /<path_to_project>/shared/tmp/pids/unicorn.pid`
+                [ ! -f /<path_to_project>/shared/tmp/pids/<worker_name>.production.pid ] || kill -USR1 `cat /<path_to_project>/shared/tmp/pids/<worker_name>.production.pid`
+        endscript
+}
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/Thorfile

@@ -0,0 +1,14 @@
+# https://shvets.github.io/blog/2013/12/14/using_thor_as_rake_replacement.html
+unless defined? Thor::Runner
+  require 'bundler'
+
+  gems = Bundler::Definition.build(Bundler.default_gemfile, Bundler.default_lockfile, nil).requested_specs
+
+  gem = gems.find { |gem| gem.name == 'thor' }
+
+  load "#{ENV['GEM_HOME']}/gems/#{gem.name}-#{gem.version}/bin/thor"
+end
+
+Dir.glob("lib/rails_daemons/tasks/*.thor") do |name|
+  Thor::Util.load_thorfile(name)
+end

data/bin/daemon

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+# -*- mode: ruby -*-
+require 'rails_daemons/thor'
+RailsDaemons::Daemon.start

data/lib/rails_daemons.rb

@@ -0,0 +1,6 @@
+require "rails_daemons/version"
+require "rails_daemons/railtie" if defined?(Rails)
+require "rails_daemons/worker"
+
+module RailsDaemons
+end

data/lib/rails_daemons/capistrano.rb

@@ -0,0 +1,7 @@
+require 'capistrano/version'
+
+if defined?(Capistrano::Version) && Gem::Version.new(Capistrano::Version).release < Gem::Version.new("3.0")
+  raise "RailsDaemons requires Capistrano 3.x"
+end
+
+load File.expand_path("../tasks/rails_daemons.cap", __FILE__)

data/lib/rails_daemons/railtie.rb

@@ -0,0 +1,4 @@
+module RailsDaemons
+  class Railtie < Rails::Railtie
+  end
+end

data/lib/rails_daemons/tasks/rails_daemons.cap

@@ -0,0 +1,40 @@
+namespace :daemon do
+  desc 'Start background worker'
+  task :start, :worker_name do |task, args|
+    raise 'Worked is not specified' if args[:worker_name].nil?
+    
+    on roles(:app) do
+      within release_path do
+        with rails_env: fetch(:rails_env) do
+          execute :bundle, :exec, :daemon, "start #{args[:worker_name]}"
+        end
+      end
+    end
+  end
+
+  desc 'Restart background worker'
+  task :restart, :worker_name do |task, args|
+    raise 'Worked is not specified' if args[:worker_name].nil?
+
+    on roles(:app) do
+      within release_path do
+        with rails_env: fetch(:rails_env) do
+          execute :bundle, :exec, :daemon, "restart #{args[:worker_name]}"
+        end
+      end
+    end
+  end
+
+  desc 'Stop background worker'
+  task :stop, :worker_name do |task, args|
+    raise 'Worked is not specified' if args[:worker_name].nil?
+
+    on roles(:app) do
+      within release_path do
+        with rails_env: fetch(:rails_env) do
+          execute :bundle, :exec, :daemon, "stop #{args[:worker_name]}"
+        end
+      end
+    end
+  end
+end

data/lib/rails_daemons/tasks/rails_daemons.thor

@@ -0,0 +1,33 @@
+require 'thor/rails'
+
+module ::RailsDaemons
+  class Daemon < Thor
+    include Thor::Rails
+    namespace :daemon
+
+    no_commands do
+      def get_daemon( name )
+        RailsDaemons.qualified_const_get( name.camelize )
+      rescue NameError => e
+        puts "Unknown daemon '#{name}'"
+      end
+    end
+
+    desc "start <worker_name>", "Start background worker"
+    def start( name )
+      daemon = get_daemon( name )
+      return if daemon.nil?
+      daemon.new.daemonize
+    end
+
+    desc "restart <worker_name>", "Restart background worker (alias for start command)"
+    def restart( name )
+      invoke :start, [ name ]
+    end
+
+    desc "stop <worker_name>", "Stop background worker"
+    def stop( name )
+      get_daemon( name ).stop
+    end
+  end
+end

data/lib/rails_daemons/thor.rb

@@ -0,0 +1,2 @@
+require 'thor'
+Thor::Util.load_thorfile File.expand_path("../tasks/rails_daemons.thor", __FILE__)

data/lib/rails_daemons/utils.rb

@@ -0,0 +1,25 @@
+module RailsDaemons
+  module Utils
+    extend self
+
+    def join( *paths )
+      # TODO: remove this dirty code
+      return Rails.root.join( *paths ) if Rails.root.to_s !~ /.*\/releases\/\d{14}/
+      
+      paths = [ '..', '..', 'current' ] + paths
+  
+      path = Rails.root.join( *paths )
+      FileUtils.mkdir_p( File.dirname( path ) )
+      path
+    end
+
+    def logger( file_name )
+      logger = Logger.new( join( 'log', file_name ) )
+      logger.level = Logger::INFO
+      logger.datetime_format = "%Y-%m-%d %H:%M:%S"
+      logger.formatter = Logger::Formatter.new
+
+      logger
+    end
+  end
+end

data/lib/rails_daemons/version.rb

@@ -0,0 +1,3 @@
+module RailsDaemons
+  VERSION = "1.0.0"
+end

data/lib/rails_daemons/worker.rb

@@ -0,0 +1,214 @@
+require 'rails_daemons/utils'
+require 'unicorn/util'
+require 'active_support/concern'
+
+module RailsDaemons
+  module Worker
+    extend ActiveSupport::Concern
+
+    included do 
+      def daemonize
+        pid = fork do
+          $logger = Utils.logger( "#{self.class.worker_name}.#{Rails.env}.log" )
+          $logger.level = Logger::INFO
+
+          working
+        end
+
+        Process.detach( pid )
+
+        puts "#{self.class.worker_name} (#{pid}) started."
+      end
+
+      def working
+        $stop_working = false
+        $reopening = false
+
+        Signal.trap "INT" do
+          Thread.new do
+            shutdowning
+          end
+        end
+
+        Signal.trap "USR1" do
+          $reopening = true
+        end
+
+        stop_old_worker
+
+        starting
+
+        loop do
+          reopen_logs if $reopening
+          break if $stop_working
+
+          work
+
+          sleep tick
+        end
+      end
+
+      def reopen_logs
+        pid = self.class.get_pid
+
+        logger.info "Reopen logs #{self.class.worker_name} (#{pid})"
+
+        Unicorn::Util.reopen_logs
+
+        logger.info "Logs reopened #{self.class.worker_name} (#{pid})"
+
+        $reopening = false
+      end
+
+      def logger
+        $logger
+      end
+
+      def starting
+        $0 = "RAILS_ENV=#{Rails.env} " + Utils.join( '' ).to_s + " bundle exec thor daemon:start #{self.class}"
+
+        redirect_io
+        start
+        store_pid
+      end
+
+      def redirect_io
+        # https://github.com/ghazel/daemons/blob/d09e132ea67001ba4d6bf6481fb53c4bd4fd9195/lib/daemons/daemonize.rb#L241
+        begin; STDIN.reopen "/dev/null"; rescue ::Exception; end
+
+        begin
+          STDOUT.reopen( Utils.join( 'log', "#{self.class.worker_name}.#{Rails.env}.out.log" ), "a" )
+          STDOUT.sync = true
+        rescue ::Exception
+          begin; STDOUT.reopen "/dev/null"; rescue ::Exception; end
+        end
+
+        begin; STDERR.reopen STDOUT; rescue ::Exception; end
+        STDERR.sync = true
+      end
+
+      def start
+        puts "Start #{self.class.name}"
+      end
+
+      def work
+        raise 'Not implemented! Write your own work'
+      end
+
+      def tick
+        1.0
+      end
+
+      def shutdowning
+        pid = self.class.get_pid
+
+        logger.info "Graceful shutdown #{self.class.worker_name} (#{pid})"
+        $stop_working = true
+
+        shutdown
+
+        puts "#{self.class.worker_name} (#{pid}) stopped."
+
+        exit 0
+
+      rescue => e
+        logger.error "exiting #{self.class.worker_name}, unable to stop gracefully"
+        logger.error e.message
+        logger.error e.backtrace.join( "\n" )
+
+        File.remove( self.class.pid_file ) if File.exists?( self.class.pid_file )
+
+        exit 1
+      end
+
+      def shutdown
+      end
+
+      def stop_old_worker
+        return unless File.file?( self.class.pid_file )
+
+        pid = self.class.get_pid
+
+        unless self.class.running?( pid )
+          logger.info "Stale pid file (#{pid}), deleting"
+          File.delete( self.class.pid_file )
+
+          return
+        end
+
+        logger.info "Killing old worker (#{pid})"
+        Process.kill( "INT", pid )
+
+        # wait for die
+        32.times do
+          sleep 3
+
+          unless self.class.running?( pid )
+            logger.info "Old worker (#{pid}) died by himself"
+
+            return
+          end
+        end
+
+        return unless self.class.running?( pid )
+
+        logger.error "Old worker (#{pid}) isn't going to die, doing kill -9"
+
+        Process.kill( "KILL", pid )
+        File.delete( self.class.pid_file )
+      end
+
+      def store_pid
+        FileUtils.mkdir_p( File.dirname( self.class.pid_file ) )
+        IO.write( self.class.pid_file, Process.pid.to_s )
+      end
+    end
+
+    module ClassMethods
+      def daemonize
+        self.new.daemonize
+      end
+
+      def stop
+        pid = get_pid
+
+        if running?( pid )
+          Process.kill( 'INT', pid )
+        else
+          puts "Worker #{name} (#{pid}) not running"
+        end
+      end
+
+      def get_pid
+        return unless File.exists?( pid_file )
+        File.read( pid_file ).to_i
+      end
+
+      def pid_file
+        Utils.join( 'tmp', 'pids', "#{worker_name}.#{Rails.env}.pid" )
+      end
+
+      def worker_name
+        name.underscore
+      end
+
+      def running?( pid )
+        return false if pid.blank?
+
+        # https://github.com/ghazel/daemons/blob/d09e132ea67001ba4d6bf6481fb53c4bd4fd9195/lib/daemons/pid.rb#L17
+        # Check if process is in existence
+        # The simplest way to do this is to send signal '0'
+        # (which is a single system call) that doesn't actually
+        # send a signal
+        begin
+          Process.kill(0, pid)
+          return true
+        rescue Errno::ESRCH
+          return false
+        rescue ::Exception # for example on EPERM (process exists but does not belong to us)
+          return true
+        end
+      end
+    end
+  end
+end

data/rails_daemons.gemspec

@@ -0,0 +1,25 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rails_daemons/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "rails_daemons"
+  spec.version       = RailsDaemons::VERSION
+  spec.authors       = ["Sergey Malykh"]
+  spec.email         = ["xronos.i.am@gmail.com"]
+  spec.description   = %q{Daemons for Rails. Can be restarted on the host by Thor or remotely by Capistrano, monitored by Monit}
+  spec.summary       = %q{Daemons for Rails}
+  spec.homepage      = "https://github.com/xronos-i-am/rails_daemons"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "capistrano", '~> 3.3'
+  spec.add_development_dependency "bundler"
+
+  spec.add_dependency "unicorn"
+  spec.add_dependency "thor-rails"
+end

metadata

@@ -0,0 +1,122 @@
+--- !ruby/object:Gem::Specification
+name: rails_daemons
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Sergey Malykh
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-01-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: capistrano
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: unicorn
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: thor-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Daemons for Rails. Can be restarted on the host by Thor or remotely by
+  Capistrano, monitored by Monit
+email:
+- xronos.i.am@gmail.com
+executables:
+- daemon
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".ruby-gemset"
+- ".ruby-version"
+- Capfile
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- Thorfile
+- bin/daemon
+- lib/rails_daemons.rb
+- lib/rails_daemons/capistrano.rb
+- lib/rails_daemons/railtie.rb
+- lib/rails_daemons/tasks/rails_daemons.cap
+- lib/rails_daemons/tasks/rails_daemons.thor
+- lib/rails_daemons/thor.rb
+- lib/rails_daemons/utils.rb
+- lib/rails_daemons/version.rb
+- lib/rails_daemons/worker.rb
+- rails_daemons.gemspec
+homepage: https://github.com/xronos-i-am/rails_daemons
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.4
+signing_key: 
+specification_version: 4
+summary: Daemons for Rails
+test_files: []