capistrano-delayed_job 0.0.10 → 3.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2b95413e5274f5875c7b1f3e298018d3bb8cd8f9
+  data.tar.gz: 0d3b77d3f0a09e7c12d3e885eb0cc173ae23825f
+SHA512:
+  metadata.gz: 158f213b44956c7b7be5e5852cdd98a5f1da1e144e6acf96f20e88b0d4efbe508731d4a8f3f8aa871ae1de82d2721aeb4220ad99c7f8fc93a3fdfac8a070d6f2
+  data.tar.gz: 5a7d97214d8b3ca2bf39732712c8348a606ef6afacd45faec4192b48496c3b61c0da4b3e15d6d6161db902b359b5e1becd848a13536dce7d25b18fe6c69b9d11

data/Gemfile

@@ -1,9 +1,10 @@
 source 'http://rubygems.org'
 
-gem "capistrano",     ">= 2.15.5"
-gem 'capistrano-base_helper', ">= 0.0.11"
+gem 'capistrano', '~> 3.4'
+gem 'activesupport', '>= 3.0'
+gem 'capistrano-monit_runit', '~> 3.0.1'
 
 group :development do
-  gem "bundler", ">= 1.3.0"
-  gem "jeweler", "~> 1.8.6"
+  gem 'bundler', '~> 1.7'
+  gem 'jeweler', '~> 2.0'
 end

data/Gemfile.lock

@@ -1,69 +1,82 @@
 GEM
   remote: http://rubygems.org/
   specs:
-    addressable (2.3.5)
+    activesupport (4.2.0)
+      i18n (~> 0.7)
+      json (~> 1.7, >= 1.7.7)
+      minitest (~> 5.1)
+      thread_safe (~> 0.3, >= 0.3.4)
+      tzinfo (~> 1.1)
+    addressable (2.3.7)
     builder (3.2.2)
-    capistrano (2.15.5)
-      highline
-      net-scp (>= 1.0.0)
-      net-sftp (>= 2.0.0)
-      net-ssh (>= 2.0.14)
-      net-ssh-gateway (>= 1.1.0)
-    capistrano-base_helper (0.0.11)
-      capistrano (>= 2.15.5)
-    faraday (0.8.8)
-      multipart-post (~> 1.2.0)
-    git (1.2.5)
-    github_api (0.10.1)
-      addressable
-      faraday (~> 0.8.1)
-      hashie (>= 1.2)
-      multi_json (~> 1.4)
-      nokogiri (~> 1.5.2)
+    capistrano (3.4.0)
+      i18n
+      rake (>= 10.0.0)
+      sshkit (~> 1.3)
+    capistrano-monit_runit (3.0.1)
+      activesupport (>= 3.0)
+      capistrano (~> 3.4)
+    colorize (0.7.5)
+    descendants_tracker (0.0.4)
+      thread_safe (~> 0.3, >= 0.3.1)
+    faraday (0.9.1)
+      multipart-post (>= 1.2, < 3)
+    git (1.2.9.1)
+    github_api (0.12.3)
+      addressable (~> 2.3)
+      descendants_tracker (~> 0.0.4)
+      faraday (~> 0.8, < 0.10)
+      hashie (>= 3.3)
+      multi_json (>= 1.7.5, < 2.0)
+      nokogiri (~> 1.6.3)
       oauth2
-    hashie (2.0.5)
-    highline (1.6.19)
-    httpauth (0.2.0)
-    jeweler (1.8.6)
+    hashie (3.4.0)
+    highline (1.7.1)
+    i18n (0.7.0)
+    jeweler (2.0.1)
       builder
-      bundler (~> 1.0)
+      bundler (>= 1.0)
       git (>= 1.2.5)
-      github_api (= 0.10.1)
+      github_api
       highline (>= 1.6.15)
-      nokogiri (= 1.5.10)
+      nokogiri (>= 1.5.10)
       rake
       rdoc
-    json (1.8.0)
-    jwt (0.1.8)
-      multi_json (>= 1.5)
-    multi_json (1.7.7)
-    multi_xml (0.5.4)
-    multipart-post (1.2.0)
-    net-scp (1.1.2)
+    json (1.8.2)
+    jwt (1.4.1)
+    mini_portile (0.6.2)
+    minitest (5.5.1)
+    multi_json (1.11.0)
+    multi_xml (0.5.5)
+    multipart-post (2.0.0)
+    net-scp (1.2.1)
       net-ssh (>= 2.6.5)
-    net-sftp (2.1.2)
-      net-ssh (>= 2.6.5)
-    net-ssh (2.6.8)
-    net-ssh-gateway (1.2.0)
-      net-ssh (>= 2.6.5)
-    nokogiri (1.5.10)
-    oauth2 (0.9.2)
-      faraday (~> 0.8)
-      httpauth (~> 0.2)
-      jwt (~> 0.1.4)
-      multi_json (~> 1.0)
+    net-ssh (2.9.2)
+    nokogiri (1.6.6.2)
+      mini_portile (~> 0.6.0)
+    oauth2 (1.0.0)
+      faraday (>= 0.8, < 0.10)
+      jwt (~> 1.0)
+      multi_json (~> 1.3)
       multi_xml (~> 0.5)
       rack (~> 1.2)
-    rack (1.5.2)
-    rake (10.1.0)
-    rdoc (4.0.1)
-      json (~> 1.4)
+    rack (1.6.0)
+    rake (10.4.2)
+    rdoc (4.2.0)
+    sshkit (1.7.1)
+      colorize (>= 0.7.0)
+      net-scp (>= 1.1.2)
+      net-ssh (>= 2.8.0)
+    thread_safe (0.3.5)
+    tzinfo (1.2.2)
+      thread_safe (~> 0.1)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
-  bundler (>= 1.3.0)
-  capistrano (>= 2.15.5)
-  capistrano-base_helper (>= 0.0.11)
-  jeweler (~> 1.8.6)
+  activesupport (>= 3.0)
+  bundler (~> 1.7)
+  capistrano (~> 3.4)
+  capistrano-monit_runit (~> 3.0.1)
+  jeweler (~> 2.0)

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2013 Leif Ringstad
+Copyright (c) 2013-2015 Leif Ringstad
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -2,20 +2,35 @@
 
 This gem provides recipes for [Delayed Job](https://github.com/collectiveidea/delayed_job) to setup [runit](smarden.org/runit/) and [monit](http://mmonit.com/monit)
 
+## Versioning
+
+Use 3.x for capistrano 3
+
+For capistrano2, see the capistrano2 branch (will not be updated)
+
 ## Usage
 
 Add it to your Gemfile without requiring it
 
 ```ruby
-gem 'capistrano-delayed_job', :require => false
+gem 'capistrano-delayed_job', require: false
 ```
 
-In your deploy.rb:
+Now run ```bundle install```
+
+Add this to your Capfile:
 
 ```ruby
 require 'capistrano/delayed_job'
 ```
 
+Create a new file in in /etc/sudoers.d/ and add the output of the following commands:
+
+```
+cap production runit:sudoers
+cap production monit:sudoers
+```
+
 ### Monit
 
 ```

data/Rakefile

@@ -6,7 +6,7 @@ begin
   Bundler.setup(:default, :development)
 rescue Bundler::BundlerError => e
   $stderr.puts e.message
-  $stderr.puts "Run `bundle install` to install missing gems"
+  $stderr.puts 'Run `bundle install` to install missing gems'
   exit e.status_code
 end
 require 'rake'
@@ -14,24 +14,26 @@ require 'rake'
 require 'jeweler'
 Jeweler::Tasks.new do |gem|
   # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
-  gem.name = "capistrano-delayed_job"
-  gem.homepage = "https://github.com/leifcr/capistrano-delayed_job"
-  gem.license = "MIT"
-  gem.summary = %Q{Capistrano recipes for Delayed Job using runit and monit}
-  gem.description = %Q{Capistrano recipes for Delayed Job using runit and monit.}
-  gem.email = "leifcr@gmail.com"
-  gem.authors = ["Leif Ringstad"]
-  gem.files.exclude ".ruby-*"
+  gem.name = 'capistrano-delayed_job'
+  gem.homepage = 'https://github.com/leifcr/capistrano-delayed_job'
+  gem.license = 'MIT'
+  gem.summary = 'Capistrano recipes for Delayed Job using runit and monit'
+  gem.description = 'Capistrano recipes for Delayed Job using runit and monit.'
+  gem.email = 'leifcr@gmail.com'
+  gem.authors = ['Leif Ringstad']
+  gem.files.exclude '.ruby-*'
+  gem.files.exclude '*.sublime-project'
+  gem.files.exclude '.rubocop.yml'
   # dependencies defined in Gemfile
 end
 Jeweler::RubygemsDotOrgTasks.new
 
 # require 'rdoc/task'
 # Rake::RDocTask.new do |rdoc|
-#   version = File.exist?('VERSION') ? File.read('VERSION') : ""
+#   version = File.exist?('VERSION') ? File.read('VERSION') : ''
 
 #   rdoc.rdoc_dir = 'rdoc'
-#   rdoc.title = "capistrano-empty #{version}"
+#   rdoc.title = 'capistrano-empty #{version}'
 #   rdoc.rdoc_files.include('README*')
 #   rdoc.rdoc_files.include('lib/**/*.rb')
-# end
+# end

data/VERSION

@@ -1 +1 @@
-0.0.10
+3.0.0

data/capistrano-delayed_job.gemspec

@@ -2,14 +2,16 @@
 # DO NOT EDIT THIS FILE DIRECTLY
 # Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
 # -*- encoding: utf-8 -*-
+# stub: capistrano-delayed_job 3.0.0 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "capistrano-delayed_job"
-  s.version = "0.0.10"
+  s.version = "3.0.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.require_paths = ["lib"]
   s.authors = ["Leif Ringstad"]
-  s.date = "2013-08-02"
+  s.date = "2015-03-26"
   s.description = "Capistrano recipes for Delayed Job using runit and monit."
   s.email = "leifcr@gmail.com"
   s.extra_rdoc_files = [
@@ -25,39 +27,44 @@ Gem::Specification.new do |s|
     "VERSION",
     "capistrano-delayed_job.gemspec",
     "lib/capistrano/delayed_job.rb",
-    "lib/capistrano/delayed_job/config.rb",
-    "lib/capistrano/delayed_job/monit.rb",
-    "lib/capistrano/delayed_job/runit.rb",
+    "lib/capistrano/helpers/delayed_job/monit.rb",
+    "lib/capistrano/helpers/delayed_job/runit.rb",
+    "lib/capistrano/helpers/delayed_job/template_paths.rb",
+    "lib/capistrano/tasks/config.rake",
+    "lib/capistrano/tasks/monit.rake",
+    "lib/capistrano/tasks/runit.rake",
     "templates/monit/delayed_job.conf.erb",
     "templates/runit/finish.erb",
-    "templates/runit/log-run.erb",
+    "templates/runit/log/run.erb",
     "templates/runit/run.erb"
   ]
   s.homepage = "https://github.com/leifcr/capistrano-delayed_job"
   s.licenses = ["MIT"]
-  s.require_paths = ["lib"]
-  s.rubygems_version = "1.8.25"
+  s.rubygems_version = "2.4.6"
   s.summary = "Capistrano recipes for Delayed Job using runit and monit"
 
   if s.respond_to? :specification_version then
-    s.specification_version = 3
+    s.specification_version = 4
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<capistrano>, [">= 2.15.5"])
-      s.add_runtime_dependency(%q<capistrano-base_helper>, [">= 0.0.11"])
-      s.add_development_dependency(%q<bundler>, [">= 1.3.0"])
-      s.add_development_dependency(%q<jeweler>, ["~> 1.8.6"])
+      s.add_runtime_dependency(%q<capistrano>, ["~> 3.4"])
+      s.add_runtime_dependency(%q<activesupport>, [">= 3.0"])
+      s.add_runtime_dependency(%q<capistrano-monit_runit>, ["~> 3.0.1"])
+      s.add_development_dependency(%q<bundler>, ["~> 1.7"])
+      s.add_development_dependency(%q<jeweler>, ["~> 2.0"])
     else
-      s.add_dependency(%q<capistrano>, [">= 2.15.5"])
-      s.add_dependency(%q<capistrano-base_helper>, [">= 0.0.11"])
-      s.add_dependency(%q<bundler>, [">= 1.3.0"])
-      s.add_dependency(%q<jeweler>, ["~> 1.8.6"])
+      s.add_dependency(%q<capistrano>, ["~> 3.4"])
+      s.add_dependency(%q<activesupport>, [">= 3.0"])
+      s.add_dependency(%q<capistrano-monit_runit>, ["~> 3.0.1"])
+      s.add_dependency(%q<bundler>, ["~> 1.7"])
+      s.add_dependency(%q<jeweler>, ["~> 2.0"])
     end
   else
-    s.add_dependency(%q<capistrano>, [">= 2.15.5"])
-    s.add_dependency(%q<capistrano-base_helper>, [">= 0.0.11"])
-    s.add_dependency(%q<bundler>, [">= 1.3.0"])
-    s.add_dependency(%q<jeweler>, ["~> 1.8.6"])
+    s.add_dependency(%q<capistrano>, ["~> 3.4"])
+    s.add_dependency(%q<activesupport>, [">= 3.0"])
+    s.add_dependency(%q<capistrano-monit_runit>, ["~> 3.0.1"])
+    s.add_dependency(%q<bundler>, ["~> 1.7"])
+    s.add_dependency(%q<jeweler>, ["~> 2.0"])
   end
 end
 

data/lib/capistrano/delayed_job.rb

@@ -2,10 +2,12 @@ def try_require(library)
   begin
     require "#{library}"
   rescue LoadError => e
-    puts "Capistrano-Delayed Job: Cannot load library: #{library} Error: #{e}"
+    puts "Capistrano-DelayedJob: Cannot load library: #{library} Error: #{e}"
   end
 end
 
-try_require 'capistrano/delayed_job/config'
-try_require 'capistrano/delayed_job/runit'
-try_require 'capistrano/delayed_job/monit'
+try_require 'capistrano/monit'
+try_require 'capistrano/runit'
+load File.expand_path('../tasks/config.rake', __FILE__)
+load File.expand_path('../tasks/monit.rake', __FILE__)
+load File.expand_path('../tasks/runit.rake', __FILE__)

data/lib/capistrano/helpers/delayed_job/monit.rb

@@ -0,0 +1,38 @@
+module Capistrano
+  module Helpers
+    module DelayedJob
+      ##
+      # Module Monit provides helpers for Monit/Puma combination
+      ##
+      module Monit
+        module_function
+
+        def delayed_job_pid_file(worker_number)
+          service_pid("#{fetch(:delayed_job_runit_base_service_name)}_#{worker_number}")
+        end
+
+        def delayed_job_monit_service_name(worker_number)
+          "#{fetch(:delayed_job_monit_base_service_name)}_#{worker_number}"
+        end
+
+        def delayed_job_monit_start_command(worker_number)
+          "/bin/bash -c '[ ! -h #{runit_service_path(delayed_job_monit_service_name(worker_number))}/run ] || /usr/bin/sv start #{runit_service_path(delayed_job_monit_service_name(worker_number))}'" # rubocop:disable Metrics/LineLength
+        end
+
+        def delayed_job_monit_stop_command(worker_number)
+          # Give delayed job 60 seconds to finish any jobs it's currently handling.
+          # (Tasks that are longer than 60 seconds should be split!)
+          "/usr/bin/sv -w 60 force-stop #{runit_service_path(delayed_job_monit_service_name(worker_number))}" # rubocop:disable Metrics/LineLength
+        end
+
+        def available_configuration_with_path(worker_number)
+          File.join(fetch(:monit_available_path), "#{fetch(:delayed_job_runit_base_service_name)}_#{worker_number}.conf")
+        end
+
+        def available_configuration_file(worker_number)
+          "#{fetch(:delayed_job_runit_base_service_name)}_#{worker_number}.conf"
+        end
+      end
+    end
+  end
+end

data/lib/capistrano/helpers/delayed_job/runit.rb

@@ -0,0 +1,28 @@
+module Capistrano
+  module Helpers
+    module DelayedJob
+      ##
+      # Module Monit provides helpers for Monit/Puma combination
+      ##
+      module Runit
+        module_function
+
+        def delayed_job_runit_service_name(worker_number)
+          "#{fetch(:delayed_job_runit_base_service_name)}_#{worker_number}"
+        end
+
+        def delayed_job_log_path(worker_number)
+          runit_var_log_service_single_service_path(delayed_job_runit_service_name(worker_number))
+        end
+
+        def available_configuration_with_path(worker_number)
+          File.join(fetch(:monit_available_path), "#{fetch(:delayed_job_runit_service_name)}_#{worker_number}.conf")
+        end
+
+        def available_configuration_file(worker_number)
+          "#{fetch(:delayed_job_runit_service_name)}_#{worker_number}.conf"
+        end
+      end
+    end
+  end
+end

data/lib/capistrano/helpers/delayed_job/template_paths.rb

@@ -0,0 +1,16 @@
+module Capistrano
+  module Helpers
+    module DelayedJob
+      ##
+      # Paths for templates
+      #
+      module TemplatePaths
+        module_function
+
+        def template_base_path
+          File.expand_path(File.join(File.dirname(__FILE__), '../../../../templates'))
+        end
+      end
+    end
+  end
+end

data/lib/capistrano/tasks/config.rake

@@ -0,0 +1,41 @@
+require 'capistrano/helpers/base'
+require 'capistrano/helpers/delayed_job/template_paths'
+include Capistrano::Helpers::Base
+
+namespace :load do
+  task :defaults do
+    set :delayed_job_runit_base_service_name, 'delayed_job'
+
+    # The number of workers to run
+    # Will create X number of runit services/monit monitors.
+    # Remember to purge/remove config before changing this value down
+    # Default to 2 workers
+    set :delayed_job_workers, 2
+
+    # The binary to trigger delayed job
+    set :delayed_job_bin, 'bundle exec rake jobs:work'
+
+    # runit defaults
+    set :delayed_job_restart_interval, proc { fetch(:runit_restart_interval) }
+    set :delayed_job_restart_count, proc { fetch(:runit_restart_count) }
+    set :delayed_job_autorestart_clear_interval, proc { fetch(:runit_autorestart_clear_interval) }
+
+    # runit templates
+    set :delayed_job_runit_run_template, File.join(Capistrano::Helpers::DelayedJob::TemplatePaths.template_base_path, 'runit', 'run.erb') # rubocop:disable Metrics/LineLength
+    set :delayed_job_runit_finish_template, File.join(Capistrano::Helpers::DelayedJob::TemplatePaths.template_base_path, 'runit', 'finish.erb') # rubocop:disable Metrics/LineLength
+    set :delayed_job_runit_log_run_template, File.join(Capistrano::Helpers::DelayedJob::TemplatePaths.template_base_path, 'runit', 'log', 'run.erb') # rubocop:disable Metrics/LineLength
+
+    # monit configuration
+    set :delayed_job_monit_base_service_name,  proc { "#{user_app_env_underscore}_delayed_job" }
+    # Each worker would be likely to use at least 60-70mb ram for an app with many gems
+    set :delayed_job_monit_memory_alert_threshold,    '100.0 MB for 2 cycles'
+    # Give the delayed_job_workers some headroom
+    set :delayed_job_monit_memory_restart_threshold,  '150.0 MB for 3 cycles'
+    set :delayed_job_monit_cpu_alert_threshold,       '90% for 2 cycles'
+    set :delayed_job_monit_cpu_restart_threshold,     '95% for 5 cycles'
+
+    set :delayed_job_monit_config_template, File.join(Capistrano::Helpers::DelayedJob::TemplatePaths.template_base_path, 'monit', 'delayed_job.conf.erb') # rubocop:disable Metrics/LineLength
+
+    set :monit_application_delayed_job_group_name,  proc { "#{user_app_env_underscore}_delayed_job" }
+  end
+end

data/lib/capistrano/tasks/monit.rake

@@ -0,0 +1,81 @@
+require 'capistrano/dsl/base_paths'
+require 'capistrano/dsl/runit_paths'
+require 'capistrano/helpers/base'
+require 'capistrano/helpers/monit'
+require 'capistrano/helpers/delayed_job/monit'
+include Capistrano::DSL::BasePaths
+include Capistrano::DSL::RunitPaths
+include Capistrano::Helpers::Base
+include Capistrano::Helpers::Monit
+include Capistrano::Helpers::DelayedJob::Monit
+
+namespace :delayed_job do
+  namespace :monit do
+    desc 'MONIT: Setup Delayed Job service'
+    task :setup do
+      on roles(:app) do |host|
+        (1..fetch(:delayed_job_workers)).each do |n|
+          info "MONIT: Uploading configuration for Delayed Job worker #{n} for #{fetch(:application)} on #{host}"
+          # Upload configuration
+          set :tmp_delayed_job_monit_service_name, delayed_job_monit_service_name(n)
+          set :tmp_worker_number, n
+          set :tmp_delayed_job_pid_file, delayed_job_pid_file(n)
+          upload! template_to_s_io(fetch(:delayed_job_monit_config_template)), available_configuration_with_path(n)
+        end
+      end
+    end
+
+    desc 'MONIT: Enable services for Delayed Job'
+    task :enable do
+      on roles(:app) do |host|
+        (1..fetch(:delayed_job_workers)).each do |n|
+          info "MONIT: Enabling service for Delayed Job worker #{n} for #{fetch(:application)} on #{host}"
+          enable_monitor(available_configuration_file(n))
+        end
+      end
+    end
+
+    desc 'MONIT: Disable and Stop services for Delayed Job'
+    task :disable do
+      on roles(:app) do |host|
+        (1..fetch(:delayed_job_workers)).each do |n|
+          info "MONIT: Disabling service for Delayed Job worker #{n} for #{fetch(:application)} on #{host}"
+          disable_monitor(available_configuration_file(n))
+        end
+      end
+    end
+
+    %w(start stop restart monitor unmonitor).each do |cmd|
+      desc "MONIT: #{cmd.capitalize} Delayed Job"
+      task cmd.to_sym do
+        on roles(:app) do |host|
+          (1..fetch(:delayed_job_workers)).each do |n|
+            info "MONIT: #{cmd} Delayed Job worker #{n} for #{fetch(:application)} on #{host}"
+            command_monit(cmd, available_configuration_file(n))
+          end
+        end
+      end
+    end
+
+    desc 'MONIT: Purge Delayed Job configuration'
+    task :purge do
+      on roles(:app) do |host|
+        (1..fetch(:delayed_job_workers)).each do |n|
+          info "MONIT: Purging config for Delayed Job worker #{n} for #{fetch(:application)} on #{host}"
+        end
+      end
+    end
+  end
+end
+
+after 'monit:setup', 'delayed_job:monit:setup'
+# after 'delayed_job:monit:setup', 'delayed_job:monit:enable'
+after 'delayed_job:monit:enable', 'monit:reload'
+
+before 'delayed_job:monit:disable', 'delayed_job:monit:unmonitor'
+after 'delayed_job:monit:disable', 'monit:reload'
+
+# start service after update in case it has not been stopped
+# This shouldn't be necessary, as monit should pick up a non-running service.
+# Starting it here might trigger double starting if monit is triggered simultaniously.
+# after "deploy:update", "delayed_job:monit:start"

data/lib/capistrano/tasks/runit.rake

@@ -0,0 +1,149 @@
+require 'capistrano/dsl/base_paths'
+require 'capistrano/dsl/runit_paths'
+require 'capistrano/helpers/base'
+require 'capistrano/helpers/runit'
+require 'capistrano/helpers/delayed_job/runit'
+
+include Capistrano::DSL::BasePaths
+include Capistrano::DSL::RunitPaths
+include Capistrano::Helpers::Base
+include Capistrano::Helpers::Runit
+include Capistrano::Helpers::DelayedJob::Runit
+
+# require 'capistrano/runit'
+namespace :delayed_job do
+  desc 'Setup Delayed Job configuration'
+  task :setup do
+    on roles(:app) do
+      execute :mkdir, "-p #{fetch(:sockets_path)}" if test("[ ! -d '#{fetch(:sockets_path)}' ]")
+      upload! template_to_s_io(fetch(:puma_config_template)), fetch(:puma_config_file)
+    end
+  end
+
+  namespace :runit do
+    desc 'Setup Delayed Job runit-service'
+    task :setup do
+      on roles(:app) do
+        (1..fetch(:delayed_job_workers)).each do |n|
+          # Create runit config
+          if test("[ ! -d '#{runit_service_path(delayed_job_runit_service_name(n))}' ]")
+            execute :mkdir, "-p '#{runit_service_path(delayed_job_runit_service_name(n))}'"
+          end
+
+          set :tmp_delayed_job_runit_service_name, delayed_job_runit_service_name(n)
+          set :tmp_worker_number, n
+
+          upload! template_to_s_io(fetch(:delayed_job_runit_run_template)), runit_service_run_config_file(delayed_job_runit_service_name(n)) # rubocop:disable Metrics/LineLength
+          upload! template_to_s_io(fetch(:delayed_job_runit_finish_template)), runit_service_finish_config_file(delayed_job_runit_service_name(n)) # rubocop:disable Metrics/LineLength
+
+          # Log scripts for runit service
+          if test("[ ! -d '#{runit_service_log_path(delayed_job_runit_service_name(n))}' ]")
+            execute :mkdir, "-p '#{runit_service_log_path(delayed_job_runit_service_name(n))}'"
+          end
+
+          set :tmp_delayed_job_log_path, delayed_job_log_path(n)
+
+          upload! template_to_s_io(fetch(:delayed_job_runit_log_run_template)), runit_service_log_run_file(delayed_job_runit_service_name(n)) # rubocop:disable Metrics/LineLength
+
+          # Make scripts executable
+          runit_set_executable_files(delayed_job_runit_service_name(n))
+
+          # Create log paths for the service
+          if test("[ ! -d '#{runit_var_log_service_single_service_path(delayed_job_runit_service_name(n))}' ]")
+            execute :mkdir, "-p '#{runit_var_log_service_single_service_path(delayed_job_runit_service_name(n))}'"
+          end
+        end
+      end
+    end
+
+    desc 'Enable Delayed Job runit-services'
+    task :enable do
+      on roles(:app) do
+        (1..fetch(:delayed_job_workers)).each do |n|
+          enable_service(delayed_job_runit_service_name(n))
+        end
+      end
+    end
+
+    desc 'Disable Delayed Job runit-services'
+    task :disable do
+      on roles(:app) do
+        (1..fetch(:delayed_job_workers)).each do |n|
+          disable_service(delayed_job_runit_service_name(n))
+        end
+      end
+    end
+
+    desc 'Start Delayed Job runit-services'
+    task :start do
+      on roles(:app) do
+        (1..fetch(:delayed_job_workers)).each do |n|
+          control_service(delayed_job_runit_service_name(n), 'start')
+        end
+      end
+    end
+
+    desc 'Start Delayed Job runit-services only ONCE (no supervision...)'
+    task :once do
+      on roles(:app) do
+        (1..fetch(:delayed_job_workers)).each do |n|
+          control_service(delayed_job_runit_service_name(n), 'once')
+        end
+      end
+    end
+
+    desc 'Stop Delayed Job runit-services'
+    # :on_error => :continue  should be added when cap3 equivalent has been figured out
+    task :stop do
+      on roles(:app) do
+        # will wait 45 seconds for delayed job to shut down/finish current jobs, to allow it to
+        # Process ongoing tasks.
+        (1..fetch(:delayed_job_workers)).each do |n|
+          begin
+            control_service(delayed_job_runit_service_name(n), 'force-stop', '-w 45')
+          rescue
+          end
+        end
+      end
+    end
+
+    desc 'Quit the Delayed Job runit-services'
+    # :on_error => :continue  should be added when cap3 equivalent has been figured out
+    task :quit do
+      on roles(:app) do
+        (1..fetch(:delayed_job_workers)).each do |n|
+          control_service(delayed_job_runit_service_name(n), 'quit')
+        end
+      end
+    end
+
+    desc 'Restart Delayed Job runit-services'
+    task :restart do
+      on roles(:app) do
+        (1..fetch(:delayed_job_workers)).each do |n|
+          control_service(delayed_job_runit_service_name(n), 'restart')
+        end
+      end
+    end
+
+    desc 'Purge Delayed Job runit configuration'
+    # :on_error => :continue  should be added when cap3 equivalent has been figured out
+    task :purge do
+      on roles(:app) do
+        (1..fetch(:delayed_job_workers)).each do |n|
+          disable_service(delayed_job_runit_service_name(n))
+          purge_service(delayed_job_runit_service_name(n))
+        end
+      end
+    end
+  end
+end
+
+after 'runit:setup', 'delayed_job:runit:setup'
+
+# enable service after update in case it has been disabled
+# Service should probably be started as well?
+after 'deploy:updated', 'delayed_job:runit:enable'
+# before 'delayed_job:runit:setup', 'delayed_job:flush_sockets'
+before 'delayed_job:runit:setup', 'delayed_job:setup'
+before 'delayed_job:runit:quit', 'delayed_job:runit:stop'

data/templates/monit/delayed_job.conf.erb

@@ -1,16 +1,17 @@
-# Monit configuration for Delayed Job
-# <% c = Capistrano::BaseHelper::get_capistrano_instance %>
-# <%= "#{c.fetch(:application)} running as #{c.fetch(:user)} in environment #{Capistrano::BaseHelper.environment}" %>
+# Monit configuration for:
+# Delayed Job worker <%= fetch(:tmp_worker_number) %>
+# Application: <%= "#{fetch(:application)} running as #{fetch(:user)} in environment #{environment}" %>
 #
-# Service name: <%= c.fetch(:delayed_job_monit_service_name) %>
+# Service name: <%= fetch(:tmp_delayed_job_monit_service_name) %>
 #
-check process <%= c.fetch(:delayed_job_monit_service_name) %>
-    with pidfile <%= c.fetch(:delayed_job_pid_file) %>
-    start program = "<%= c.fetch(:delayed_job_monit_start_command) %>"
-    stop program = "<%= c.fetch(:delayed_job_monit_stop_command) %>"
-    <%= "if mem is greater than #{c.fetch(:delayed_job_monit_memory_alert_threshold)} then alert"     unless c.fetch(:delayed_job_monit_memory_alert_threshold).nil? %>
-    <%= "if mem is greater than #{c.fetch(:delayed_job_monit_memory_restart_threshold)} then restart" unless c.fetch(:delayed_job_monit_memory_restart_threshold).nil? %>
-    <%= "if cpu is greater than #{c.fetch(:delayed_job_monit_cpu_alert_threshold)} then alert"        unless c.fetch(:delayed_job_monit_cpu_alert_threshold).nil? %>
-    <%= "if cpu is greater than #{c.fetch(:delayed_job_monit_cpu_restart_threshold)} then restart"    unless c.fetch(:delayed_job_monit_cpu_restart_threshold).nil? %>
+check process <%= fetch(:tmp_delayed_job_monit_service_name) %>
+    with pidfile <%= fetch(:tmp_delayed_job_pid_file) %>
+    start program = "<%= delayed_job_monit_start_command(fetch(:tmp_worker_number)) %>"
+    stop program = "<%= delayed_job_monit_stop_command(fetch(:tmp_worker_number)) %>"
+    <%= "if mem is greater than #{fetch(:delayed_job_monit_memory_alert_threshold)} then alert"     unless fetch(:delayed_job_monit_memory_alert_threshold).nil? %>
+    <%= "if mem is greater than #{fetch(:delayed_job_monit_memory_restart_threshold)} then restart" unless fetch(:delayed_job_monit_memory_restart_threshold).nil? %>
+    <%= "if cpu is greater than #{fetch(:delayed_job_monit_cpu_alert_threshold)} then alert"        unless fetch(:delayed_job_monit_cpu_alert_threshold).nil? %>
+    <%= "if cpu is greater than #{fetch(:delayed_job_monit_cpu_restart_threshold)} then restart"    unless fetch(:delayed_job_monit_cpu_restart_threshold).nil? %>
 
-    group <%= c.fetch(:monit_application_group_name) %>
+    group <%= fetch(:monit_application_delayed_job_group_name) %>
+    group <%= fetch(:monit_application_group_name) %>

data/templates/runit/finish.erb

@@ -1,17 +1,18 @@
 #!/bin/bash
 #
+# Delayed_Job worker <%= fetch(:tmp_worker_number) %> running on <%= fetch(:application) %> running as <%= fetch(:user) %>
+#
 # This finish file is originally from:
 # https://github.com/erwbgy/puppet-runit/blob/fde6006e6d400f0c99b6ff0b1b63094207dc8783/templates/service/finish.erb
 # Thanks to erwbgy!
 #
-# <% c = Capistrano::BaseHelper::get_capistrano_instance %>
 # Variable name setup
 <%
-exit_code   = "EXIT_CODE_#{Capistrano::BaseHelper.user_app_env_underscore_short_char_safe}_#{c.fetch(:delayed_job_runit_service_name)}".upcase
-exit_status = "EXIT_STATUS_#{Capistrano::BaseHelper.user_app_env_underscore_short_char_safe}_#{c.fetch(:delayed_job_runit_service_name)}".upcase
-min_auto_restart_interval         = "MIN_AUTO_RESTART_INTERVAL_#{Capistrano::BaseHelper.user_app_env_underscore_short_char_safe}_#{c.fetch(:delayed_job_runit_service_name)}".upcase
-max_auto_restart_count            = "MAX_AUTO_RESTART_COUNT_#{Capistrano::BaseHelper.user_app_env_underscore_short_char_safe}_#{c.fetch(:delayed_job_runit_service_name)}".upcase
-auto_restart_count_clear_interval = "AUTO_RESTART_COUNT_CLEAR_INTERVAL_#{Capistrano::BaseHelper.user_app_env_underscore_short_char_safe}_#{c.fetch(:delayed_job_runit_service_name)}".upcase
+exit_code   = "EXIT_CODE_#{user_app_env_underscore_short_char_safe}_#{fetch(:tmp_delayed_job_runit_service_name)}".upcase
+exit_status = "EXIT_STATUS_#{user_app_env_underscore_short_char_safe}_#{fetch(:tmp_delayed_job_runit_service_name)}".upcase
+min_auto_restart_interval         = "MIN_AUTO_RESTART_INTERVAL_#{user_app_env_underscore_short_char_safe}_#{fetch(:tmp_delayed_job_runit_service_name)}".upcase
+max_auto_restart_count            = "MAX_AUTO_RESTART_COUNT_#{user_app_env_underscore_short_char_safe}_#{fetch(:tmp_delayed_job_runit_service_name)}".upcase
+auto_restart_count_clear_interval = "AUTO_RESTART_COUNT_CLEAR_INTERVAL_#{user_app_env_underscore_short_char_safe}_#{fetch(:tmp_delayed_job_runit_service_name)}".upcase
 %>
 #
 # The following variables are set by Runit:
@@ -52,14 +53,14 @@ auto_restart_count_clear_interval = "AUTO_RESTART_COUNT_CLEAR_INTERVAL_#{Capistr
 <%= "#{exit_status}" %>=$2
 
 # The minimum delay (in seconds) between automatic restarts
-<%= "#{min_auto_restart_interval}" %>=<%= c.fetch(:delayed_job_restart_interval) %>
+<%= "#{min_auto_restart_interval}" %>=<%= fetch(:delayed_job_restart_interval) %>
 
 # The maximum number of automatic restarts allowed
-<%= "#{max_auto_restart_count}" %>=<%= c.fetch(:delayed_job_restart_count) %>
+<%= "#{max_auto_restart_count}" %>=<%= fetch(:delayed_job_restart_count) %>
 
 # Reset the restart count if <%= "#{auto_restart_count_clear_interval}" %> seconds
 # have elapsed since the last automatic restart.
-<%= "#{auto_restart_count_clear_interval}" %>=<%= c.fetch(:delayed_job_autorestart_clear_interval) %>
+<%= "#{auto_restart_count_clear_interval}" %>=<%= fetch(:delayed_job_autorestart_clear_interval) %>
 
 export <%= "#{exit_code}" %>
 export <%= "#{exit_status}" %>
@@ -69,7 +70,7 @@ export <%= "#{auto_restart_count_clear_interval }" %>
 
 ### Normally no changes should be made after this point
 
-echo "<%= "User: #{c.fetch(:user)} Application: #{c.fetch(:application)} Service: #{c.fetch(:delayed_job_runit_service_name)}" %> finish; exit code: $<%= "#{exit_code}" %>; exit status: $<%= "#{exit_status}" %>"
+echo "<%= "User: #{fetch(:user)} Application: #{fetch(:application)} Service: #{fetch(:tmp_delayed_job_runit_service_name)}" %> finish; exit code: $<%= "#{exit_code}" %>; exit status: $<%= "#{exit_status}" %>"
 
 if test $<%= "#{exit_code}" %> -eq 0 -a $<%= "#{exit_status}" %> -eq 0
 then
@@ -92,7 +93,7 @@ echo $NOW > last_finish
 # have elapsed since the last automatic restart.
 if test $INTERVAL -gt $<%= "#{auto_restart_count_clear_interval}" %>
 then
-    echo "NOTICE: <%= "User: #{c.fetch(:user)} Application: #{c.fetch(:application)} Service: #{c.fetch(:delayed_job_runit_service_name)}" %>"
+    echo "NOTICE: <%= "User: #{fetch(:user)} Application: #{fetch(:application)} Service: #{fetch(:tmp_delayed_job_runit_service_name)}" %>"
     echo "The last automatic restart was $INTERVAL seconds ago."
     echo "Since this is greater than $<%= "#{auto_restart_count_clear_interval}" %> the restart count is being reset."
     rm -f restart_count
@@ -112,7 +113,7 @@ echo $RESTART_COUNT > restart_count
 # Check that we have not exceeded the maximum number of automatic restarts
 if test $RESTART_COUNT -gt $<%= "#{max_auto_restart_count}" %>
 then
-    echo "WARNING: <%= "User: #{c.fetch(:user)} Application: #{c.fetch(:application)} Service: #{c.fetch(:delayed_job_runit_service_name)}" %>"
+    echo "WARNING: <%= "User: #{fetch(:user)} Application: #{fetch(:application)} Service: #{fetch(:tmp_delayed_job_runit_service_name)}" %>"
     echo "Reached the limit of $<%= "#{max_auto_restart_count}" %> automatic restarts."
     echo "The last automatic restart was within $<%= "#{auto_restart_count_clear_interval}" %> seconds."
     echo "Manual intervention required.  No further automatic restarts will be attempted."
@@ -125,7 +126,7 @@ then
     SLEEP_TIME=$(expr $<%= "#{min_auto_restart_interval}" %> - $INTERVAL)
     if test $SLEEP_TIME -gt 0
     then
-        echo "NOTICE: Restart attempt $RESTART_COUNT for <%= "User: #{c.fetch(:user)} Application: #{c.fetch(:application)} Service: #{c.fetch(:delayed_job_runit_service_name)}" %>"
+        echo "NOTICE: Restart attempt $RESTART_COUNT for <%= "User: #{fetch(:user)} Application: #{fetch(:application)} Service: #{fetch(:tmp_delayed_job_runit_service_name)}" %>"
         echo "$INTERVAL seconds have elapsed since the last automatic restart."
         echo "Sleeping for $SLEEP_TIME seconds before the next automatic restart ..."
         sleep $SLEEP_TIME

data/templates/runit/log/run.erb

@@ -0,0 +1,9 @@
+#!/bin/sh -e
+# Log output for delayed_job worker <%= fetch(:tmp_worker_number) %> running on <%= fetch(:application) %> running as <%= fetch(:user) %>
+# make sure the log directory exists
+mkdir -p "<%= fetch(:tmp_delayed_job_log_path) %>"
+# change path to the log directory
+cd "<%= fetch(:tmp_delayed_job_log_path) %>"
+# start logging
+# exec chpst -u syslog svlogd -tt "<%= fetch(:tmp_delayed_job_log_path) %>"
+exec svlogd -tt "<%= fetch(:tmp_delayed_job_log_path) %>"

data/templates/runit/run.erb

@@ -1,14 +1,15 @@
 #!/bin/bash --login
 # Start delayed job using rake
-<% c = Capistrano::BaseHelper::get_capistrano_instance %>
+# Delayed_Job worker <%= fetch(:tmp_worker_number) %> running on <%= fetch(:application) %> running as <%= fetch(:user) %>
+
 # Redirect stderr so everything ends up in the log file
 exec 2>&1
 
 # Announce start
-echo "<%= "User: #{c.fetch(:user)} Application: #{c.fetch(:application)} Service: #{c.fetch(:delayed_job_runit_service_name)}" %> starting..."
+echo "<%= "User: #{fetch(:user)} Application: #{fetch(:application)} Service: #{fetch(:tmp_delayed_job_runit_service_name)}" %> starting..."
 
 # Change path to current path
-cd '<%= c.current_path %>'
+cd '<%= current_path %>'
 
 # Start delayed job
-RAILS_ENV=<%= Capistrano::BaseHelper.environment %> exec <%= c.fetch(:delayed_job_bin) %>
+RAILS_ENV=<%= environment %> exec <%= fetch(:delayed_job_bin) %>

metadata

@@ -1,80 +1,85 @@
 --- !ruby/object:Gem::Specification
 name: capistrano-delayed_job
 version: !ruby/object:Gem::Version
-  version: 0.0.10
-  prerelease: 
+  version: 3.0.0
 platform: ruby
 authors:
 - Leif Ringstad
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-08-02 00:00:00.000000000 Z
+date: 2015-03-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: capistrano
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.15.5
+        version: '3.4'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.15.5
+        version: '3.4'
 - !ruby/object:Gem::Dependency
-  name: capistrano-base_helper
+  name: activesupport
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.0.11
+        version: '3.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.0.11
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: capistrano-monit_runit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.0.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.0.1
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.3.0
+        version: '1.7'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.3.0
+        version: '1.7'
 - !ruby/object:Gem::Dependency
   name: jeweler
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.8.6
+        version: '2.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.8.6
+        version: '2.0'
 description: Capistrano recipes for Delayed Job using runit and monit.
 email: leifcr@gmail.com
 executables: []
@@ -91,39 +96,38 @@ files:
 - VERSION
 - capistrano-delayed_job.gemspec
 - lib/capistrano/delayed_job.rb
-- lib/capistrano/delayed_job/config.rb
-- lib/capistrano/delayed_job/monit.rb
-- lib/capistrano/delayed_job/runit.rb
+- lib/capistrano/helpers/delayed_job/monit.rb
+- lib/capistrano/helpers/delayed_job/runit.rb
+- lib/capistrano/helpers/delayed_job/template_paths.rb
+- lib/capistrano/tasks/config.rake
+- lib/capistrano/tasks/monit.rake
+- lib/capistrano/tasks/runit.rake
 - templates/monit/delayed_job.conf.erb
 - templates/runit/finish.erb
-- templates/runit/log-run.erb
+- templates/runit/log/run.erb
 - templates/runit/run.erb
 homepage: https://github.com/leifcr/capistrano-delayed_job
 licenses:
 - MIT
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: -2659159965666790878
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.25
+rubygems_version: 2.4.6
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Capistrano recipes for Delayed Job using runit and monit
 test_files: []

data/lib/capistrano/delayed_job/config.rb

@@ -1,35 +0,0 @@
-require 'capistrano/base_helper/base_helper'
-Capistrano::Configuration.instance(true).load do
-  _cset :delayed_job_runit_service_name, "delayed_job"
-  _cset :delayed_job_workers, 1 # More than 1 is not implemented yet.
-
-  _cset :delayed_job_bin, 'bundle exec rake jobs:work'
-
-  _cset :delayed_job_pid_file,    defer {Capistrano::RunitBase::service_pid(fetch(:delayed_job_runit_service_name))}
-
-  # Logging to path
-  _cset :delayed_job_log_path, defer {"/var/log/service/#{fetch(:user)}/#{fetch(:application)}_#{Capistrano::BaseHelper.environment}/delayed_job"}
-
-  # runit defaults
-  _cset :delayed_job_restart_interval, defer {fetch(:runit_restart_interval)}
-  _cset :delayed_job_restart_count, defer {fetch(:runit_restart_count)}
-  _cset :delayed_job_autorestart_clear_interval, defer {fetch(:runit_autorestart_clear_interval)}
-
-    # runit paths
-  _cset :delayed_job_runit_local_run,     File.join(File.expand_path(File.join(File.dirname(__FILE__),"../../../templates", "runit", )), "run.erb")
-  _cset :delayed_job_runit_local_finish,  File.join(File.expand_path(File.join(File.dirname(__FILE__),"../../../templates", "runit", )), "finish.erb")
-  _cset :delayed_job_runit_control_q,     File.join(File.expand_path(File.join(File.dirname(__FILE__),"../../../templates", "runit")), "control-q.erb")
-  _cset :delayed_job_runit_local_log_run, File.join(File.expand_path(File.join(File.dirname(__FILE__),"../../../templates", "runit")), "log-run.erb")
-
-  # monit configuration
-  _cset :delayed_job_monit_service_name,  defer { "#{fetch(:user)}_#{fetch(:application)}_#{Capistrano::BaseHelper.environment}_delayed_job" }
-  _cset :delayed_job_monit_start_command, defer {"/bin/bash -c '[ ! -h #{Capistrano::RunitBase.service_path(fetch(:delayed_job_runit_service_name))}/run ] || /usr/bin/sv start #{Capistrano::RunitBase.service_path(fetch(:delayed_job_runit_service_name))}'"}
-  _cset :delayed_job_monit_stop_command,  defer {"/usr/bin/sv -w 12 force-stop #{Capistrano::RunitBase.service_path(fetch(:delayed_job_runit_service_name))}"}
-  _cset :delayed_job_monit_memory_alert_threshold, "100.0 MB for 2 cycles"   # Each worker would be likely to use at least 60-70mb ram for an app with many gems
-  _cset :delayed_job_monit_memory_restart_threshold, "150.0 MB for 3 cycles" # Give the delayed_job_workers some headroom
-  _cset :delayed_job_monit_cpu_alert_threshold,   "90% for 2 cycles"
-  _cset :delayed_job_monit_cpu_restart_threshold, "95% for 5 cycles"
-
-  _cset :delayed_job_local_monit_config, File.join(File.expand_path(File.join(File.dirname(__FILE__),"../../../templates", "monit")), "delayed_job.conf.erb")
-
-end

data/lib/capistrano/delayed_job/monit.rb

@@ -1,71 +0,0 @@
-# Delayed Job - Monit
-# Setup and management of Monit for Delayed Job
-#
-
-require 'capistrano/delayed_job/config'
-require 'capistrano/base_helper/monit_base'
-
-Capistrano::Configuration.instance(true).load do
-  after "monit:setup", "delayed_job:monit:setup"
-  after "delayed_job:monit:setup", "delayed_job:monit:enable"
-  after "delayed_job:monit:enable", "monit:reload"
-
-  before "delayed_job:monit.disable", "delayed_job:monit:unmonitor"
-  after  "delayed_job:monit:disable", "monit:reload"
-
-  # start service after update in case it has not been stopped
-  # after "deploy:update", "delayed_job:monit:start"
-  # Not needed?
-
-  namespace :delayed_job do
-    namespace :monit do
-      desc "Setup Delayed Job monit-service"
-      task :setup, :roles => [:app, :web, :db] do
-        # Upload configuration
-        Capistrano::BaseHelper::generate_and_upload_config(delayed_job_local_monit_config, File.join(fetch(:monit_available_path), "#{fetch(:delayed_job_runit_service_name)}.conf"))
-        # Enable monitor
-      end
-    
-      desc "Enable monit services for Delayed Job"
-      task :enable, :roles => [:app, :web, :db] do
-        Capistrano::MonitBase::Service.enable("#{fetch(:delayed_job_runit_service_name)}.conf")
-      end
-
-      desc "Disable and stop monit services for Delayed Job"
-      task :disable, :roles => [:app, :web, :db] do
-        Capistrano::MonitBase::Service.disable("#{fetch(:delayed_job_runit_service_name)}.conf")
-      end
-
-      desc "Start monit services for Delayed Job (will also try to start the service)"
-      task :start, :roles => [:app, :web, :db] do
-        Capistrano::MonitBase::Service.command_monit("start", fetch(:delayed_job_monit_service_name))
-      end
-
-      desc "Stop monit services for Delayed Job (will also stop the service)"
-      task :stop, :roles => [:app, :web, :db] do
-        Capistrano::MonitBase::Service.command_monit("stop", fetch(:delayed_job_monit_service_name))
-      end
-
-      desc "Restart monit services for Delayed Job"
-      task :restart, :roles => [:app, :web, :db] do
-        Capistrano::MonitBase::Service.command_monit("restart", fetch(:delayed_job_monit_service_name))
-      end
-
-      desc "Monitor Delayed Job"
-      task :monitor, :roles => [:app, :web, :db] do
-        Capistrano::MonitBase::Service.command_monit("monitor", fetch(:delayed_job_monit_service_name))
-      end
-
-      desc "Unmonitor Delayed Job"
-      task :unmonitor, :roles => [:app, :web, :db] do
-        Capistrano::MonitBase::Service.command_monit("unmonitor", fetch(:delayed_job_monit_service_name))
-      end
-
-      desc "Purge Delayed Job monit configuration"
-      task :unmonitor, :roles => [:app, :web, :db], :on_error => :continue do
-      end      
-
-    end
-
-  end
-end

data/lib/capistrano/delayed_job/runit.rb

@@ -1,78 +0,0 @@
-# Delayed Job - Runit
-
-require 'capistrano/delayed_job/config'
-require 'capistrano/base_helper/runit_base'
-
-Capistrano::Configuration.instance(true).load do
-  after "deploy:setup", "delayed_job:runit:setup"
-
-  # enable service after update in case it has not been setup or is disabled
-  # Service should probably be started as well?
-  after "deploy:update", "delayed_job:runit:enable"
-  before "delayed_job:runit:quit", "delayed_job:runit:stop"
-
-  namespace :delayed_job do
-    namespace :runit do
-      desc "Setup Delayed Job runit-service"
-      task :setup, :roles => :app do
-        # Create runit config
-        Capistrano::RunitBase.create_service_dir(delayed_job_runit_service_name)
-        Capistrano::BaseHelper::generate_and_upload_config(delayed_job_runit_local_run, Capistrano::RunitBase.remote_run_config_path(delayed_job_runit_service_name))
-        Capistrano::BaseHelper::generate_and_upload_config(delayed_job_runit_local_finish, Capistrano::RunitBase.remote_finish_config_path(delayed_job_runit_service_name))
-
-        # Log run script
-        Capistrano::BaseHelper::generate_and_upload_config(delayed_job_runit_local_log_run, Capistrano::RunitBase.remote_service_log_run_path(delayed_job_runit_service_name))
-
-        # Make scripts executable
-        Capistrano::RunitBase.make_service_scripts_executeable(delayed_job_runit_service_name)
-
-        # Set correct permissions/owner on log path
-        Capistrano::RunitBase.create_and_permissions_on_path(fetch(:delayed_job_log_path))
-      end 
-      
-      desc "Enable Delayed Job runit-service"
-      task :enable, :roles => :app do
-        Capistrano::RunitBase.enable_service(delayed_job_runit_service_name)
-      end
-
-      desc "Disable Delayed Job runit-service"
-      task :disable, :roles => :app do
-        Capistrano::RunitBase.disable_service(delayed_job_runit_service_name)
-      end
-
-      desc "Start Delayed Job runit-service"
-      task :start, :roles => :app do
-        Capistrano::RunitBase.start_service(delayed_job_runit_service_name)
-      end
-
-      desc "Start Delayed Job runit-service only ONCE (no supervision...)"
-      task :once, :roles => :app do
-        Capistrano::RunitBase.start_service_once(delayed_job_runit_service_name)
-      end
-
-      desc "Stop Delayed Job runit-service"
-      task :stop, :roles => :app, :on_error => :continue do
-        # have to use force-stop on failed stop, since delayed_job might not terminate properly
-        # will wait 25 seconds for delayed_job to shut down, to allow it to serve any on-going requests
-        Capistrano::RunitBase.control_service(delayed_job_runit_service_name, "force-stop", false, "-w 25")
-      end
-
-      desc "Quit the Delayed Job runit-service"
-      task :quit, :roles => :app, :on_error => :continue do
-        Capistrano::RunitBase.control_service(delayed_job_runit_service_name, "quit")
-      end
-
-      desc "Restart Delayed Job runit-service"
-      task :restart, :roles => :app do
-        Capistrano::RunitBase.control_service(delayed_job_runit_service_name, "restart")
-      end
-      
-      desc "Purge Delayed Job runit configuration"
-      task :purge, :roles => :app, :on_error => :continue do
-        Capistrano::RunitBase.force_control_service(delayed_job_runit_service_name, "force-stop", true)
-        Capistrano::RunitBase.purge_service(delayed_job_runit_service_name)
-      end
-      
-    end
-  end
-end

data/templates/runit/log-run.erb

@@ -1,10 +0,0 @@
-#!/bin/sh -e
-<% c = Capistrano::BaseHelper::get_capistrano_instance %>
-# Log output for delayed_job running on <%= c.fetch(:application) %> running as <%= c.fetch(:user) %>
-# make sure the log directory exists
-mkdir -p "<%= c.fetch(:delayed_job_log_path) %>"
-# change path to the log directory
-cd "<%= c.fetch(:delayed_job_log_path) %>"
-# start logging
-# exec chpst -u syslog svlogd -tt "<%= c.fetch(:delayed_job_log_path) %>"
-exec svlogd -tt "<%= c.fetch(:delayed_job_log_path) %>"