capistrano-base_helper 0.0.3

data/Gemfile

@@ -0,0 +1,9 @@
+source 'http://rubygems.org'
+
+gem "capistrano",     ">= 2.15.5"
+
+group :development do
+  gem "bundler", ">= 1.3.0"
+  gem "jeweler", "~> 1.8.6"
+  # gem "rdoc", ">=2.4"
+end

data/Gemfile.lock

@@ -0,0 +1,66 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    addressable (2.3.5)
+    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)
+    faraday (0.8.7)
+      multipart-post (~> 1.1)
+    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)
+      oauth2
+    hashie (2.0.5)
+    highline (1.6.19)
+    httpauth (0.2.0)
+    jeweler (1.8.6)
+      builder
+      bundler (~> 1.0)
+      git (>= 1.2.5)
+      github_api (= 0.10.1)
+      highline (>= 1.6.15)
+      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.1)
+      net-ssh (>= 2.6.5)
+    net-sftp (2.1.2)
+      net-ssh (>= 2.6.5)
+    net-ssh (2.6.7)
+    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)
+      multi_xml (~> 0.5)
+      rack (~> 1.2)
+    rack (1.5.2)
+    rake (10.1.0)
+    rdoc (4.0.1)
+      json (~> 1.4)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (>= 1.3.0)
+  capistrano (>= 2.15.5)
+  jeweler (~> 1.8.6)

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2013 Leif Ringstad
+
+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,97 @@
+# Capistrano - Base helpers
+
+This libary is a helper library for capistrano tasks that setup monit/runit for various services.
+
+## Services for Monit and Runit
+
+Services created:
+
+* _[capistrano-puma](https://github.com/leifcr/capistrano-puma)_ for [Puma](http://puma.io)
+* _[capistrano-delayed_job](https://github.com/leifcr/capistrano-delayed_job)_ for [Delayed Job](https://github.com/collectiveidea/delayed_job)
+
+It is fairly easy to create new service. Fork/clone either capistrano-puma or capistrano-delayed_job and create a new service based on either.
+
+All services should have their own repository, as it makes it easier when deploying to choose what services you need for the application you are deploying.
+
+## Capistrano tasks
+
+Tasks that work on your entire application and not just on a single service.
+
+_Note: The tasks will not work unless you have installed any monit services_
+
+### Monit
+
+All these tasks do monit tasks for all services setup with monit.
+
+```ruby
+cap monit:disable               # Disable monit services for application
+cap monit:enable                # Enable monit services for application
+cap monit:main_config           # Setup main monit config file (/etc/monit/monitrc)
+cap monit:monitor               # Monitor the application
+cap monit:purge                 # Purge/remove all monit configurations for the application
+cap monit:reload                # Reload monit config (global)
+cap monit:restart               # Restart monitoring the application
+cap monit:setup                 # Setup monit folders and configuration
+cap monit:start                 # Start monitoring the application permanent (Monit saves state)
+cap monit:status                # Status monit (global)
+cap monit:stop                  # Stop monitoring the application permanent (Monit saves state)
+```
+
+### Runit
+
+All these tasks do runit tasks for all services setup with runit.
+
+```ruby
+cap runit:disable               # Disable runit services for application
+cap runit:enable                # Enable runit services for application
+cap runit:once                  # Only start services once.
+cap runit:purge                 # Purge/remove all runit configurations for the application
+cap runit:setup                 # Setup runit for the application
+cap runit:start                 # Start all runit services for current application
+cap runit:stop                  # Stop all runit services for current application
+```
+
+## Assumptions
+
+There are some assumptions when using this with capistrano.
+The following variables must be set 
+
+* _:application_ - The application name
+* _:user_ - The username which is running the deployed application (usually deploy..)
+* _:group_ - The groupname which is running the deployed application (usually deploy..)
+
+
+## Helpers
+
+Upload a configuration file:
+
+```ruby
+# Generate a config file by parsing an ERB template and uploading the file. Both paths should be absolute
+Capistrano::BaseHelper::generate_and_upload_config(local_file, remote_file, use_sudo=false)
+```
+
+Run a rake task:
+```ruby
+# Execute a rake taske using bundle and the proper env.
+Capistrano::BaseHelper::run_rake(task)
+```
+
+Ask the user a message to agree/disagree
+```ruby
+Capistrano::BaseHelper::ask(message)
+```
+
+See base_helper/base_helper.rb for further documentation.
+And for runit info, base_helper/runit_base.rb for further documentation.
+
+## Contributing
+
+* Fork the project
+* Make a feature addition or bug fix
+* Please test the feature or bug fix, or write tests for it
+* Make a pull request
+
+## Copyright
+
+(c) 2013 Leif Ringstad. See LICENSE.txt for details
+

data/Rakefile

@@ -0,0 +1,37 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+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-base_helper"
+  gem.homepage = "https://github.com/leifcr/capistrano-base-helper"
+  gem.license = "MIT"
+  gem.summary = %Q{Helpers for capistrano recipes using runit/monit}
+  gem.description = %Q{Helpers for capistrano recipes using runit/monit. Currently: capistrano-puma and capistrano-delayed_job}
+  gem.email = "leifcr@gmail.com"
+  gem.authors = ["Leif Ringstad"]
+  gem.files.exclude ".ruby-*"
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+# require 'rdoc/task'
+# Rake::RDocTask.new do |rdoc|
+#   version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+#   rdoc.rdoc_dir = 'rdoc'
+#   rdoc.title = "capistrano-empty #{version}"
+#   rdoc.rdoc_files.include('README*')
+#   rdoc.rdoc_files.include('lib/**/*.rb')
+# end

data/VERSION

@@ -0,0 +1 @@
+0.0.3

data/capistrano-base_helper/base_helper.rb

@@ -0,0 +1,138 @@
+Capistrano::Configuration.instance(true).load do
+  _cset :pids_path, File.join(fetch(:shared_path), "pids")
+  _cset :sockets_path, File.join(fetch(:shared_path), "sockets")
+  namespace :base_helper do
+    desc "[internal] set the capistrano instance in Capistrano::BaseHelper module"
+    task :set_capistrano_instance do
+      Capistrano::BaseHelper::set_capistrano_instance(self)
+    end    
+  end
+  
+  on :start, "base_helper:set_capistrano_instance"
+end
+
+module Capistrano
+  module BaseHelper
+    @@capistrano_instance
+    module_function
+
+    def set_capistrano_instance(cap_instance)
+      @@capistrano_instance = cap_instance
+    end
+
+    def get_capistrano_instance
+      @@capistrano_instance
+    end
+
+    def user_app_env_underscore
+      "#{get_capistrano_instance.fetch(:user)}_#{get_capistrano_instance.fetch(:application)}_#{environment}"
+    end
+
+    def user_app_env_path
+      File.join(get_capistrano_instance.fetch(:user), "#{get_capistrano_instance.fetch(:application)}_#{environment}")
+    end
+
+    ## 
+    # Automatically sets the environment based on presence of
+    # :stage (multistage)
+    # :rails_env 
+    # RAILS_ENV variable; 
+    # 
+    # Defaults to "production" if not found
+    #
+    def environment
+      if @@capistrano_instance.exists?(:rails_env)
+        @@capistrano_instance.fetch(:rails_env)
+      elsif @@capistrano_instance.exists?(:rack_env)
+        @@capistrano_instance.fetch(:rack_env)        
+      elsif @@capistrano_instance.exists?(:stage)
+        @@capistrano_instance.fetch(:stage)
+      elsif(ENV['RAILS_ENV'])
+        ENV['RAILS_ENV']
+      else
+        puts "------------------------------------------------------------------"
+        puts "- Stage, rack or rails environment isn't set in                  -"
+        puts "- :stage or :rails_env or :rack_env, defaulting to 'production'  -"
+        puts "------------------------------------------------------------------"
+        "production"
+      end
+    end
+
+    ##
+    # parse a erb template and return the result
+    #
+    def parse_config(file)
+      require 'erb'  #render not available in Capistrano 2
+      template  = File.read(file)          # read it
+      returnval = ERB.new(template).result(binding)   # parse it
+      return returnval
+    end
+
+    ##
+    # Prompts the user for a message to agree/decline
+    #
+    def ask(message, default=true)
+      Capistrano::CLI.ui.agree(message)
+    end
+
+    ## 
+    # Generate a config file by parsing an ERB template and uploading the file
+    # Fetches local file and uploads it to remote_file
+    # Make sure your user has the right permissions.
+    # 
+    # @local_file full path to local file
+    # @remote_file full path to remote file
+    # @use_sudo use sudo or not...
+    # 
+    def generate_and_upload_config(local_file, remote_file, use_sudo=false)
+      temp_file  = '/tmp/' + File.basename(local_file)
+      erb_buffer =  Capistrano::BaseHelper::parse_config(local_file)
+      # write temp file
+      File.open(temp_file, 'w+') { |f| f << erb_buffer }
+      # upload temp file
+      @@capistrano_instance.upload temp_file, temp_file, :via => :scp
+      # create any folders required,
+      # move temporary file to remote file
+      @@capistrano_instance.run "#{use_sudo ? "sudo" : ""} mkdir -p #{Pathname.new(remote_file).dirname}; #{use_sudo ? "sudo" : ""} mv #{temp_file} #{remote_file}"
+      # remove temp file
+      `rm #{temp_file}`
+    end
+
+    ##
+    # Execute a rake taske using bundle and the proper env.
+    # run_rake db:migrate
+    #
+    def run_rake(task)
+      @@capistrano_instance.run "cd #{@@capistrano_instance.current_path} && RAILS_ENV=#{Capistrano::BaseHelper.environment} bundle exec rake #{task}"
+    end
+
+    ##
+    # Prepare a path with the given user and group name
+    # @path the path to prepare
+    # @user the user to chown the path
+    # @group the group to chown the path
+    # @use_sudo true/false for using sudo for all the commands
+
+    def prepare_path(path, user, group, use_sudo = false)
+      commands = []
+      commands << "#{use_sudo ? "sudo" : ""} mkdir -p #{path}"
+      commands << "#{use_sudo ? "sudo" : ""} chown #{user}:#{group} #{path} -R" 
+      commands << "#{use_sudo ? "sudo" : ""} chmod +rw #{path}"
+      @@capistrano_instance.run commands.join(" &&")
+    end
+
+    ##
+    # Check for file existance
+    # See http://stackoverflow.com/questions/1661586/how-can-you-check-to-see-if-a-file-exists-on-the-remote-server-in-capistrano
+    # Credits: Patrick Reagen / Knocte
+    def remote_file_exists?(path)
+      results = []
+      @@capistrano_instance.invoke_command("if [ -e '#{path}' ]; then echo -n 'true'; fi") do |ch, stream, out|
+        results << (out == 'true')
+      end
+
+      results == [true]
+    end
+    
+  end
+end

data/capistrano-base_helper/monit_base.rb

@@ -0,0 +1,207 @@
+# TODO: PLACE monit files like this
+# shared_path/monit/available
+# shared_path/monit/enabled
+# shared_path/monit/application.conf <-- in this: include shared_path/monit/enabled
+# files can then belong to user instead of root, and sudo is avoided for some apps
+
+Capistrano::Configuration.instance(true).load do
+  _cset :monit_dir,            defer { File.join(shared_path, "monit") }
+  _cset :monit_available_path, defer { File.join(monit_dir, "available") }
+  _cset :monit_enabled_path,   defer { File.join(monit_dir, "enabled") }
+  _cset :monit_etc_path,       File.join("/etc", "monit") 
+  _cset :monit_etc_conf_d_path,  defer { File.join(monit_etc_path, "conf.d") }
+  _cset :monit_application_group_name,  defer { "#{fetch(:user)}_#{fetch(:application)}_#{Capistrano::BaseHelper.environment}" }
+
+  _cset :monit_mailserver,      "localhost"
+  _cset :monit_mail_sender,     "monit@$HOST"
+  _cset :monit_mail_reciever,   nil # if this is nil, alerts are disabled
+  _cset :monit_use_httpd,       "true"
+  _cset :monit_httpd_bind_address,  "localhost"
+  _cset :monit_httpd_allow_address, "localhost"
+  _cset :monit_httpd_signature,     "enable" # or enable
+  _cset :monit_httpd_port, "2812"
+
+  _cset :monit_daemon_time, "60"
+  _cset :monit_start_delay, "60"
+
+  #after "deploy:update", "monit:enable"
+  after "deploy:setup", "monit:setup"
+  before "monit:setup",  "monit:main_config"
+
+  after "monit:setup", "monit:enable"
+  after "monit:enable", "monit:reload"
+
+  # must trigger monitor AFTER deploy
+  after "deploy", "monit:monitor"
+  # must trigger unmonitor BEFORE deploy
+  before "deploy", "monit:unmonitor"
+
+  before "monit:disable", "monit:unmonitor"
+  after "monit:disable", "monit:reload"
+  
+  before "monit:purge", "monit:unmonitor"
+
+  namespace :monit do
+
+    desc "Setup monit folders and configuration"
+    task :setup, :roles => [:app, :db, :web] do
+      # conf file that will include application specific configurations will be placed here:
+      run "[ -d #{fetch(:monit_dir)} ] || mkdir -p #{fetch(:monit_dir)}"
+      # dir to store each services monit configs
+      run "[ -d #{fetch(:monit_available_path)} ] || mkdir -p #{fetch(:monit_available_path)}"
+      # dir for all symlinked enabled applications
+      run "[ -d #{fetch(:monit_enabled_path)} ] || mkdir -p #{fetch(:monit_enabled_path)}"
+
+      # create include configuration (used when booting the system)
+      local_config  = File.join(File.expand_path(File.join(File.dirname(__FILE__),"../templates", "monit")), "app_include.conf.erb")
+      remote_config = File.join(fetch(:monit_dir), "monit.conf")
+
+      Capistrano::BaseHelper::generate_and_upload_config(local_config, remote_config)
+    end
+
+    desc "Setup main monit config file (/etc/monit/monitrc)"
+    task :main_config, :roles => [:app, :db, :web] do
+      if Capistrano::CLI.ui.agree("Setup /etc/monit/monitrc ?")
+         # create monitrc file
+        local_config  = File.join(File.expand_path(File.join(File.dirname(__FILE__),"../templates", "monit")), "monitrc.erb")
+        remote_config = File.join("/etc","monit","monitrc")
+
+        Capistrano::BaseHelper::generate_and_upload_config(local_config, remote_config, true)
+
+        commands = []
+        commands << "sudo chmod 700 /etc/monit/monitrc"
+        commands << "sudo chown root:root /etc/monit/monitrc"
+        run commands.join(" && ")
+        # restart monit, as main config is now updated
+        run "sudo service monit restart"
+        puts "----------------------------------------"
+        puts "Sleeping for #{(fetch(:monit_daemon_time).to_i + fetch(:monit_start_delay).to_i + 2)} seconds to wait for monit to be ready"
+        puts "----------------------------------------"
+        sleep (fetch(:monit_daemon_time).to_i + fetch(:monit_start_delay).to_i + 2)
+      end
+    end
+
+    desc "Enable monit services for application"
+    task :enable, :roles => [:app, :db, :web] do
+      real_conf   = File.join(fetch(:monit_dir), "monit.conf")
+      symlink   = File.join(fetch(:monit_etc_conf_d_path), "#{Capistrano::BaseHelper.user_app_env_underscore}.conf")
+      # symlink to include file
+      run("[ -h #{symlink} ] || sudo ln -sf #{real_conf} #{symlink}")
+    end
+ 
+    desc "Disable monit services for application"
+    task :disable, :roles => [:app, :db, :web] do
+      symlink   = File.join(fetch(:monit_etc_conf_d_path), "#{Capistrano::BaseHelper.user_app_env_underscore}.conf")
+      run("[ ! -h #{symlink} ] || sudo rm -f #{symlink}")
+    end
+
+    desc "Purge/remove all monit configurations for the application"
+    task :purge, :roles => [:app, :db, :web] do
+        symlink   = File.join(fetch(:monit_etc_conf_d_path), "#{Capistrano::BaseHelper.user_app_env_underscore}.conf")
+      run("[ ! -h #{symlink} ]   || sudo rm -f #{symlink}")
+      run("[ ! -d #{fetch(:monit_dir)} ] || sudo rm -f #{fetch(:monit_dir)}")
+    end
+
+    desc "Monitor the application"
+    task :monitor, :roles => [:app, :db, :web] do
+      Capistrano::MonitBase::Application::command_monit_group(fetch(:monit_application_group_name), "monitor")
+    end 
+
+    desc "Unmonitor the application"
+    task :unmonitor, :roles => [:app, :db, :web] do
+      Capistrano::MonitBase::Application::command_monit_group(fetch(:monit_application_group_name), "unmonitor")
+    end 
+
+    desc "Stop monitoring the application permanent (Monit saves state)"
+    task :stop, :roles => [:app, :db, :web] do
+      Capistrano::MonitBase::Application::command_monit_group(fetch(:monit_application_group_name), "stop")
+    end 
+
+    desc "Start monitoring the application permanent (Monit saves state)"
+    task :start, :roles => [:app, :db, :web] do
+      Capistrano::MonitBase::Application::command_monit_group(fetch(:monit_application_group_name), "start")
+    end
+
+    desc "Restart monitoring the application"
+    task :restart, :roles => [:app, :db, :web] do
+      Capistrano::MonitBase::Application::command_monit_group(fetch(:monit_application_group_name), "restart")
+    end
+
+    desc "Reload monit config (global)"
+    task :reload, :roles => [:app, :db, :web] do
+      Capistrano::MonitBase::Application::command_monit("reload")
+    end
+
+    desc "Status monit (global)"
+    task :status, :roles => [:app, :db, :web], :on_error => :continue do
+      Capistrano::MonitBase::Application::command_monit("status")
+    end
+
+    desc "Summary monit (global)"
+    task :summary, :roles => [:app, :db, :web], :on_error => :continue do
+      Capistrano::MonitBase::Application::command_monit("summary")
+    end
+
+    desc "Validate monit (global)"
+    task :validate, :roles => [:app, :db, :web], :on_error => :continue do
+      Capistrano::MonitBase::Application::command_monit("validate")
+    end
+
+  end
+end
+
+module Capistrano
+  module MonitBase
+    module Application
+      module_function
+
+      ##
+      # Control / Command a monit group
+      # namescheme: user_application_environment "#{user}_#{application}_#{environment}"
+      #
+      def command_monit_group(application_group_name, command, arguments = "")
+        Capistrano::MonitBase::Application.command_monit(command, "-g #{application_group_name} #{arguments}")
+      end
+
+      ##
+      # Control / Command monit with given arguments
+      def command_monit(command, arguments="")
+        Capistrano::BaseHelper.get_capistrano_instance.run("sudo monit #{arguments} #{command}")
+      end
+
+    end
+
+    module Service
+      module_function
+
+      ##
+      # Command a single monit service
+      #
+      # The service name scheme is recommended to be 
+      # "#{user}_#{application}_#{environment}_#{service}" 
+      #
+      def command_monit(command, service_name="", arguments="")
+        c = Capistrano::BaseHelper.get_capistrano_instance
+        service_name = "#{c.fetch(:user)}_#{c.fetch(:application)}_#{c.fetch(:environment)}_#{c.fetch(:service)}" if service_name == ""
+        c.run("sudo monit #{arguments} #{command} #{service_name}")
+      end
+
+      ##
+      # The service name is the same as the conf file name for the service.
+      # E.g. puma.conf
+      #
+      # This will symlink the service to enabled service, but not start or reload monit configuration 
+      #
+      def enable(service_conf_filename)
+        c = Capistrano::BaseHelper.get_capistrano_instance
+        c.run("[ -h #{File.join(c.fetch(:monit_enabled_path), service_conf_filename)} ] || ln -sf #{File.join(c.fetch(:monit_available_path), service_conf_filename)} #{File.join(c.fetch(:monit_enabled_path), service_conf_filename)}")
+      end
+
+      def disable(service_conf_filename)
+        c = Capistrano::BaseHelper.get_capistrano_instance
+        c.run("rm -f #{File.join(c.fetch(:monit_enabled_path), service_conf_filename)}")
+      end
+    end  
+  end
+end
+

data/capistrano-base_helper/runit_base.rb

@@ -0,0 +1,250 @@
+Capistrano::Configuration.instance(true).load do
+  _cset :runit_dir, defer { "#{shared_path}/runit" }
+  _cset :runit_local_run,     File.join(File.expand_path(File.join(File.dirname(__FILE__),"../templates")), "runit",  "run.erb")
+  _cset :runit_local_finish,  File.join(File.expand_path(File.join(File.dirname(__FILE__),"../templates")), "runit",  "finish.erb")
+  _cset :runit_local_log_run, File.join(File.expand_path(File.join(File.dirname(__FILE__),"../templates")), "runit",  "log_run.erb")
+  _cset :runit_remote_run,     defer {File.join("/etc", "sv", Capistrano::BaseHelper.user_app_env_path, "run")}
+  _cset :runit_remote_finish,  defer {File.join("/etc", "sv", Capistrano::BaseHelper.user_app_env_path, "finish")}
+  _cset :runit_remote_log_run, defer {File.join("/etc", "sv", Capistrano::BaseHelper.user_app_env_path, "log", "run")}
+  _cset :runit_log_user, "syslog"
+  _cset :runit_log_group, "syslog"
+
+  after "deploy:update", "runit:enable"
+  after "deploy:setup", "runit:setup"
+
+  namespace :runit do
+    desc "Setup runit for the application"
+    task :setup, :roles => [:app, :db, :web] do
+      run "[ -d #{fetch(:runit_dir)}/.env ] || mkdir -p #{fetch(:runit_dir)}/.env"
+      run "echo $HOME > #{fetch(:runit_dir)}/.env/HOME"
+      # setup to run as user
+      Capistrano::RunitBase.app_services_create
+    end
+
+    desc "Disable runit services for application"
+    task :disable, :roles => [:app, :db, :web] do
+      Capistrano::BaseHelper.get_capistrano_instance.run("sudo sv force-stop #{user}_#{application}; true")
+      Capistrano::RunitBase.app_services_disable(fetch(:application), fetch(:user))
+    end
+
+    desc "Enable runit services for application"
+    task :enable, :roles => [:app, :db, :web] do
+      Capistrano::RunitBase.app_services_enable(fetch(:application), fetch(:user))
+    end
+
+    desc "Purge/remove all runit configurations for the application"
+    task :purge, :roles => [:app, :db, :web] do
+      Capistrano::BaseHelper.get_capistrano_instance.run("sudo sv force-stop #{user}_#{application}; true")
+      Capistrano::RunitBase.app_services_purge(fetch(:application), fetch(:user))
+    end
+
+    desc "Stop all runit services for current application"
+    task :stop, :roles => [:app, :db, :web] do
+      Capistrano::RunitBase.app_services_stop(fetch(:application), fetch(:user))
+    end
+
+    desc "Start all runit services for current application"
+    task :start, :roles => [:app, :db, :web] do
+      Capistrano::RunitBase.app_services_start(fetch(:application), fetch(:user))
+    end
+
+    desc "Only start services once. Will not restart if they fail."
+    task :once, :roles => [:app, :db, :web] do
+      Capistrano::RunitBase.app_services_once(fetch(:application), fetch(:user))
+    end
+
+  end
+end
+
+module Capistrano
+  module RunitBase
+    module_function
+
+    def service_path(service_name)
+      "#{Capistrano::BaseHelper.get_capistrano_instance.fetch(:runit_dir)}/#{service_name}"
+    end
+
+    def create_service_dir(service_name)
+      Capistrano::BaseHelper.get_capistrano_instance.run("[ -d #{service_path(service_name)} ] || mkdir -p #{service_path(service_name)}")
+    end
+
+    def service_pid(service_name)
+      File.join(service_path(service_name), "supervise", "pid")
+    end
+
+    # BEGIN - ALL services functions (functions that affects all services for the app)
+
+    def app_services_create_log_service
+      c = Capistrano::BaseHelper.get_capistrano_instance
+      commands = []
+      commands << "sudo mkdir -p #{File.join("/etc", "sv", Capistrano::BaseHelper.user_app_env_path, "log")}"
+      commands << "sudo chown #{c.fetch(:user)}:root #{File.join("/etc", "sv", Capistrano::BaseHelper.user_app_env_path, "log")}"
+      commands << "sudo mkdir -p '#{File.join("/var", "log", "service", Capistrano::BaseHelper.user_app_env_path, "runit")}'"
+      commands << "sudo chown -R #{c.fetch(:runit_log_user)}:#{c.fetch(:runit_log_group)} '#{File.join("/var", "log", "service", Capistrano::BaseHelper.user_app_env_path, "runit")}'"
+
+      c.run(commands.join(" && "))
+      Capistrano::BaseHelper.generate_and_upload_config( Capistrano::BaseHelper::get_capistrano_instance.fetch(:runit_local_log_run), Capistrano::BaseHelper::get_capistrano_instance.fetch(:runit_remote_log_run), true )
+      commands = []
+      commands << "sudo chmod u+x '#{File.join("/etc", "sv", Capistrano::BaseHelper.user_app_env_path, "log", "run")}'"
+      commands << "sudo chmod g+x '#{File.join("/etc", "sv", Capistrano::BaseHelper.user_app_env_path, "log", "run")}'"
+      commands << "sudo chown #{c.fetch(:user)}:root '#{File.join("/etc", "sv", Capistrano::BaseHelper.user_app_env_path, "log", "run")}'"
+      c.run(commands.join(" && ")) 
+    end
+
+    ##
+    # application name should be "app-environment" or similar in case you deploy staging/production to same host
+    def app_services_create
+      # SEE http://off-the-stack.moorman.nu/posts/5-user-services-with-runit/ for info on scripts
+      c = Capistrano::BaseHelper.get_capistrano_instance
+      c.run("sudo mkdir -p '#{File.join("/etc", "sv", Capistrano::BaseHelper.user_app_env_path)}'")
+      
+      commands = []
+      commands << "sudo chown #{c.fetch(:user)}:root /etc/sv/#{c.fetch(:user)}"
+      commands << "sudo chown #{c.fetch(:user)}:root /etc/sv/#{Capistrano::BaseHelper.user_app_env_path}"
+      c.run(commands.join(" && "))
+      Capistrano::BaseHelper.generate_and_upload_config( Capistrano::BaseHelper::get_capistrano_instance.fetch(:runit_local_run), Capistrano::BaseHelper::get_capistrano_instance.fetch(:runit_remote_run), true )
+      Capistrano::BaseHelper.generate_and_upload_config( Capistrano::BaseHelper::get_capistrano_instance.fetch(:runit_local_finish), Capistrano::BaseHelper::get_capistrano_instance.fetch(:runit_remote_finish), true )
+
+      commands = []
+      commands << "sudo chmod u+x '#{File.join("/etc", "sv", Capistrano::BaseHelper.user_app_env_path, "run")}'"
+      commands << "sudo chmod u+x '#{File.join("/etc", "sv", Capistrano::BaseHelper.user_app_env_path, "finish")}'"
+      commands << "sudo chmod g+x '#{File.join("/etc", "sv", Capistrano::BaseHelper.user_app_env_path, "run")}'"
+      commands << "sudo chmod g+x '#{File.join("/etc", "sv", Capistrano::BaseHelper.user_app_env_path, "finish")}'"
+      commands << "sudo chown #{c.fetch(:user)}:root '#{File.join("/etc", "sv", Capistrano::BaseHelper.user_app_env_path, "run")}'"
+      commands << "sudo chown #{c.fetch(:user)}:root '#{File.join("/etc", "sv", Capistrano::BaseHelper.user_app_env_path, "finish")}'"
+      c.run(commands.join(" && "))
+
+      Capistrano::RunitBase.app_services_create_log_service
+    end
+
+    def app_services_enable(application, user)
+      Capistrano::BaseHelper.get_capistrano_instance.run("[ -h /etc/service/#{user}_#{application}_#{Capistrano::BaseHelper.environment} ] || sudo ln -sf /etc/sv/#{Capistrano::BaseHelper.user_app_env_path} /etc/service/#{user}_#{application}_#{Capistrano::BaseHelper.environment}")
+    end
+
+    def app_services_disable(application, user)
+      Capistrano::BaseHelper.get_capistrano_instance.run("[ ! -h /etc/service/#{user}_#{application}_#{Capistrano::BaseHelper.environment} ] || sudo rm -f /etc/service/#{user}_#{application}_#{Capistrano::BaseHelper.environment}")
+    end
+
+    def app_services_purge(application, user)
+      # this should stop ALL services running for the given application
+      # true is appended to ignore any errors failing to stop the services
+      commands = []
+      commands << "sudo rm -f /etc/service/#{user}_#{application}_#{Capistrano::BaseHelper.environment}"
+      commands << "sudo rm -rf /etc/sv/#{Capistrano::BaseHelper.user_app_env_path}"
+      Capistrano::BaseHelper.get_capistrano_instance.run(commands.join(" && "))
+    end
+
+    def app_services_stop(application, user, ignore_error = false)
+      app_services_control(application, user, "stop", ignore_error)
+    end
+
+    def app_services_start(application, user, ignore_error = false)
+      app_services_control(application, user, "start", ignore_error)
+    end
+
+    def app_services_once(application, user, ignore_error = false)
+      app_services_control(application, user, "once", ignore_error)
+    end
+
+    def app_services_control(application, user, command, ignore_error = false)
+      Capistrano::BaseHelper.get_capistrano_instance.run("[ ! -h /etc/service/#{user}_#{application} ] || sudo sv #{command} #{user}_#{application}; #{"true" if ignore_error != false}")
+    end
+
+    # END - ALL services functions (functions that affects all services for the app)
+
+
+    # BEGIN - Single service functions (functions that affects a single given service)
+
+    def start_service_once(service_name)
+      control_service(service_name, "once")
+    end
+
+    def start_service(service_name)
+      control_service(service_name, "start")
+    end
+
+    def stop_service(service_name)
+      control_service(service_name, "stop")
+    end
+
+    def restart_service(service_name)
+      control_service(service_name, "restart")
+    end
+
+    def control_service(service_name, service_control_function, ignore_error = false, arguments = "")
+      Capistrano::BaseHelper.get_capistrano_instance.run("[ ! -h #{service_path(service_name)}/run ] || sv #{arguments} #{service_control_function} #{service_path(service_name)}")  
+    end
+
+    # Will not check if the service exists before trying to force it down
+    def force_control_service(service_name, service_control_function, ignore_error = false)
+      Capistrano::BaseHelper.get_capistrano_instance.run("sv #{service_control_function} #{service_path(service_name)}; #{"true" if ignore_error != false}")  
+    end
+
+    def disable_service(service_name)
+      force_control_service(service_name, "force-stop", true) # force-stop the service before disabling it
+      Capistrano::BaseHelper.get_capistrano_instance.run("[ ! -h #{service_path(service_name)}/run ] || rm -f #{service_path(service_name)}/run && rm -f #{service_path(service_name)}/finish")
+    end
+
+    def enable_service(service_name, symlink_finish = nil)
+      Capistrano::BaseHelper.get_capistrano_instance.run("cd #{service_path(service_name)} && [ -h ./run ] || ln -sf #{remote_run_config_path(service_name)} ./run")
+      Capistrano::BaseHelper.get_capistrano_instance.run("cd #{service_path(service_name)} && [ -h ./finish ] || ln -sf #{remote_finish_config_path(service_name)} ./finish") unless symlink_finish.nil?
+    end
+
+    def purge_service(service_name)
+      Capistrano::BaseHelper.get_capistrano_instance.run("rm -rf #{service_path(service_name)}")
+    end
+
+    def remote_run_config_path(service_name)
+      File.join(service_path(service_name), "#{service_name}_run")
+    end
+
+    def remote_finish_config_path(service_name)
+      File.join(service_path(service_name), "#{service_name}_finish")
+    end
+
+    def remote_control_path(service_name, control_letter)
+      File.join(remote_control_path_root(service_name), control_letter)
+    end
+
+    def remote_control_path_root(service_name)
+      File.join(service_path(service_name), "control")
+    end
+
+    def remote_service_log_run_path(service_name)
+      File.join(service_path(service_name), "log", "run")
+    end
+
+    def make_service_scripts_executeable(service_name)
+      commands = []
+      if Capistrano::BaseHelper::remote_file_exists?(Capistrano::RunitBase.remote_run_config_path(service_name))
+        commands << "chmod u+x #{Capistrano::RunitBase.remote_run_config_path(service_name)}"
+        commands << "chmod g+x #{Capistrano::RunitBase.remote_run_config_path(service_name)}"
+      end
+      if Capistrano::BaseHelper::remote_file_exists?(Capistrano::RunitBase.remote_service_log_run_path(service_name))
+        commands << "chmod u+x #{Capistrano::RunitBase.remote_service_log_run_path(service_name)}"
+        commands << "chmod g+x #{Capistrano::RunitBase.remote_service_log_run_path(service_name)}"
+      end
+      if Capistrano::BaseHelper::remote_file_exists?(Capistrano::RunitBase.remote_control_path_root(service_name))
+        commands << "chmod u+x -R #{Capistrano::RunitBase.remote_control_path_root(service_name)}"
+        commands << "chmod g+x -R #{Capistrano::RunitBase.remote_control_path_root(service_name)}"
+      end
+      Capistrano::BaseHelper.get_capistrano_instance.run commands.join(" ; ")
+    end
+
+    # note that the user running the runit service MUST be a member of the group or the same as the log user
+    # If not, the log service will not work
+    def create_and_permissions_on_path(log_path, user = nil, group = nil)
+      user  = Capistrano::BaseHelper.get_capistrano_instance.fetch(:user) if user.nil?
+      group = "syslog" if group.nil?
+      # will use sudo
+      commands = []
+      commands << "sudo mkdir -p #{log_path}"
+      commands << "sudo chown -R #{user}:#{group} #{log_path}"
+      commands << "sudo chmod u+w #{log_path}"
+      commands << "sudo chmod g+w #{log_path}"
+      Capistrano::BaseHelper.get_capistrano_instance.run commands.join(" && ")
+    end
+
+    # END - Single service functions (functions that affects a single given service)
+  end
+end

data/capistrano-base_helper.gemspec

@@ -0,0 +1,61 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = "capistrano-base_helper"
+  s.version = "0.0.3"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Leif Ringstad"]
+  s.date = "2013-07-05"
+  s.description = "Helpers for capistrano recipes using runit/monit. Currently: capistrano-puma and capistrano-delayed_job"
+  s.email = "leifcr@gmail.com"
+  s.extra_rdoc_files = [
+    "LICENSE",
+    "README.md"
+  ]
+  s.files = [
+    "Gemfile",
+    "Gemfile.lock",
+    "LICENSE",
+    "README.md",
+    "Rakefile",
+    "VERSION",
+    "capistrano-base_helper.gemspec",
+    "capistrano-base_helper.rb",
+    "capistrano-base_helper/base_helper.rb",
+    "capistrano-base_helper/monit_base.rb",
+    "capistrano-base_helper/runit_base.rb",
+    "templates/monit/app_include.conf.erb",
+    "templates/monit/monitrc.erb",
+    "templates/runit/finish.erb",
+    "templates/runit/log_run.erb",
+    "templates/runit/run.erb"
+  ]
+  s.homepage = "https://github.com/leifcr/capistrano-base-helper"
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = "1.8.25"
+  s.summary = "Helpers for capistrano recipes using runit/monit"
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<capistrano>, [">= 2.15.5"])
+      s.add_development_dependency(%q<bundler>, [">= 1.3.0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.8.6"])
+    else
+      s.add_dependency(%q<capistrano>, [">= 2.15.5"])
+      s.add_dependency(%q<bundler>, [">= 1.3.0"])
+      s.add_dependency(%q<jeweler>, ["~> 1.8.6"])
+    end
+  else
+    s.add_dependency(%q<capistrano>, [">= 2.15.5"])
+    s.add_dependency(%q<bundler>, [">= 1.3.0"])
+    s.add_dependency(%q<jeweler>, ["~> 1.8.6"])
+  end
+end
+

data/capistrano-base_helper.rb

@@ -0,0 +1,11 @@
+def try_require(library)
+  begin
+    require "#{library}"
+  rescue LoadError => e
+    puts "Capistrano-Base Helper: Cannot load library: #{library} Error: #{e}"
+  end
+end
+
+try_require 'capistrano-base_helper/base_helper'
+try_require 'capistrano-base_helper/runit_base'
+try_require 'capistrano-base_helper/monit_base'

data/templates/monit/app_include.conf.erb

@@ -0,0 +1,2 @@
+<% c = Capistrano::BaseHelper::get_capistrano_instance %>
+include <%= c.fetch(:monit_enabled_path) %>/*.conf

data/templates/monit/monitrc.erb

@@ -0,0 +1,29 @@
+<% c = Capistrano::BaseHelper::get_capistrano_instance %>
+set daemon <%= c.fetch(:monit_daemon_time) %>
+  with start delay <%= c.fetch(:monit_start_delay) %>
+
+set logfile syslog facility log_daemon
+
+set mailserver <%= c.fetch(:monit_mailserver) %>
+
+set eventqueue
+    basedir /var/monit  # set the base directory where events will be stored
+#    slots 1000          # optionaly limit the queue size
+
+set mail-format {
+  from: <%= c.fetch(:monit_mail_sender) %>
+  subject: $SERVICE $EVENT $HOST
+  message: Monit $ACTION $SERVICE at $DATE on $HOST: $DESCRIPTION.
+}
+<% unless c.fetch(:monit_mail_reciever).nil? %>
+set alert <%= c.fetch(:monit_mail_reciever) %> NOT ON { action, instance, pid, ppid }
+<% end %>
+
+<% unless c.fetch(:monit_use_httpd) == "false" %>
+set httpd port <%= c.fetch(:monit_httpd_port) %>
+  <%= "use address #{c.fetch(:monit_httpd_bind_address, "localhost")}" unless c.fetch(:monit_httpd_bind_address).nil? %> 
+  <%= "allow #{c.fetch(:monit_httpd_allow_address)}" unless c.fetch(:monit_httpd_allow_address).nil? %>
+  <%= "signature #{c.fetch(:monit_httpd_signature)}" %>
+<% end %>
+
+include /etc/monit/conf.d/*.conf

data/templates/runit/finish.erb

@@ -0,0 +1,6 @@
+#!/bin/sh
+# <% c = Capistrano::BaseHelper::get_capistrano_instance %>
+# Finish/quit services for <%= c.fetch(:application) %> as <%= c.fetch(:user) %> in env <%= Capistrano::BaseHelper.environment %>
+#
+sv -w600 force-stop '<%= c.fetch(:runit_dir) %>/*'
+sv exit '<%= c.fetch(:runit_dir) %>/*'

data/templates/runit/log_run.erb

@@ -0,0 +1,12 @@
+#!/bin/sh
+# <% c = Capistrano::BaseHelper::get_capistrano_instance %>
+# Log output for <%= c.fetch(:application) %> as <%= c.fetch(:user) %> in env <%= Capistrano::BaseHelper.environment %>
+#
+# make sure the log directory exists
+mkdir -p "<%= File.join("/var", "log", "service", Capistrano::BaseHelper.user_app_env_path, "runit") %>"
+# make sure the right owner is on the log directory
+chown -R <%= "#{c.fetch(:runit_log_user)}:#{c.fetch(:runit_log_group)}" %> "<%= File.join("/var", "log", "service", Capistrano::BaseHelper.user_app_env_path, "runit") %>"
+# change path to the log directory
+cd "<%= File.join("/var", "log", "service", Capistrano::BaseHelper.user_app_env_path, "runit") %>"
+# start logging
+exec chpst -u <%= c.fetch(:runit_log_user)%> svlogd -tt "<%= File.join("/var", "log", "service", Capistrano::BaseHelper.user_app_env_path, "runit") %>"

data/templates/runit/run.erb

@@ -0,0 +1,6 @@
+#!/bin/sh -e
+# <% c = Capistrano::BaseHelper::get_capistrano_instance %>
+# Run services for <%= c.fetch(:application) %> as <%= c.fetch(:user) %> in env <%= Capistrano::BaseHelper.environment %>
+#
+exec 2>&1 
+exec chpst -u <%= c.fetch(:user) %> runsvdir "<%= c.fetch(:runit_dir) %>"

metadata

@@ -0,0 +1,115 @@
+--- !ruby/object:Gem::Specification
+name: capistrano-base_helper
+version: !ruby/object:Gem::Version
+  version: 0.0.3
+  prerelease: 
+platform: ruby
+authors:
+- Leif Ringstad
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-07-05 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
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.15.5
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.3.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.3.0
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.8.6
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.8.6
+description: ! 'Helpers for capistrano recipes using runit/monit. Currently: capistrano-puma
+  and capistrano-delayed_job'
+email: leifcr@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE
+- README.md
+files:
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- VERSION
+- capistrano-base_helper.gemspec
+- capistrano-base_helper.rb
+- capistrano-base_helper/base_helper.rb
+- capistrano-base_helper/monit_base.rb
+- capistrano-base_helper/runit_base.rb
+- templates/monit/app_include.conf.erb
+- templates/monit/monitrc.erb
+- templates/runit/finish.erb
+- templates/runit/log_run.erb
+- templates/runit/run.erb
+homepage: https://github.com/leifcr/capistrano-base-helper
+licenses:
+- MIT
+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: 2652667416411912074
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.25
+signing_key: 
+specification_version: 3
+summary: Helpers for capistrano recipes using runit/monit
+test_files: []