capistrano-monit_runit 3.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 705f5e797d5a2516fb2900e85ae3252d732119bc
+  data.tar.gz: 0d0b76890fb55a86ab800ccd445c97ed28d78d1b
+SHA512:
+  metadata.gz: 21406a6ee4f05b0df8bf3bd766eda7bd1fd052d73b3d6c82193ff353700a1ccf9839bedc41088513d564d0455aaa38c0bcf061bc3182679d8ebc32e97bacebca
+  data.tar.gz: 64b1200212abc514a4f7755aa07772e91b7d44c3701bcf43ec1c7949c55cf2881ab482965c003384f27bf8d55a33eb09515f20eb90811855f3c8dcd095b360b0

data/Gemfile

@@ -0,0 +1,7 @@
+source 'http://rubygems.org'
+
+gem 'capistrano', '~> 3.4'
+group :development do
+  gem 'bundler', '~> 1.7'
+  gem 'jeweler', '~> 2.0'
+end

data/Gemfile.lock

@@ -0,0 +1,67 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    addressable (2.3.7)
+    builder (3.2.2)
+    capistrano (3.4.0)
+      i18n
+      rake (>= 10.0.0)
+      sshkit (~> 1.3)
+    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 (3.4.0)
+    highline (1.7.1)
+    i18n (0.7.0)
+    jeweler (2.0.1)
+      builder
+      bundler (>= 1.0)
+      git (>= 1.2.5)
+      github_api
+      highline (>= 1.6.15)
+      nokogiri (>= 1.5.10)
+      rake
+      rdoc
+    jwt (1.4.1)
+    mini_portile (0.6.2)
+    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-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.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)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.7)
+  capistrano (~> 3.4)
+  jeweler (~> 2.0)

data/LICENSE

@@ -0,0 +1,20 @@
+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
+"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,133 @@
+# Capistrano - Monit and Runit helpers
+
+This libary is a helper library for capistrano tasks that setup [runit](smarden.org/runit/) and [monit](http://mmonit.com/monit) for various services.
+
+Note: This has been updated to support Capistrano >= 3.4. If you still use Capistrano 2.x, see the capistrano2 branch
+
+## Versioning
+
+This gem stays at 3.x for capistrano 3, as it seems logical.
+
+## Sudoing
+
+The setup process requires sudo on some files and folders upon creation.
+
+You must either do the job manually or add this to the sudoers file:
+
+```
+Cmnd_Alias RUNITCAPISTRANO = ,
+deploy  ALL=NOPASSWD: /bin/chmod u+x /etc/sv/*
+deploy  ALL=NOPASSWD: /bin/chmod g+x /etc/sv/*
+deploy  ALL=NOPASSWD: /bin/chown deploy\:root /etc/sv/*
+deploy  ALL=NOPASSWD: /bin/chown -R deploy\:root /etc/sv/*
+deploy  ALL=NOPASSWD: /bin/chown -R deploy\:root /etc/service/*
+deploy  ALL=NOPASSWD: /bin/chown -R syslog\:syslog /var/log/service*
+deploy  ALL=NOPASSWD: /bin/mkdir -p /etc/service/*
+deploy  ALL=NOPASSWD: /bin/mkdir /etc/service/*
+deploy  ALL=NOPASSWD: /bin/mkdir -p /var/log/service*
+deploy  ALL=NOPASSWD: /bin/mkdir -p /etc/sv/*
+deploy  ALL=NOPASSWD: /bin/mkdir /etc/sv/*
+deploy  ALL=NOPASSWD: /bin/rm -rf /etc/service/*
+
+```
+,/bin/chown myuser:mygroup /var/www/html/*,/bin/chmod 755 /var/www/html2/myapp/*.txt
+
+
+## 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.
+
+```
+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)
+```
+
+#### Setup in your deploy file
+
+You can add this to deploy.rb or env.rb in order to automatically monitor/unmonitor tasks
+
+It is important to unmonitor tasks while deploying as they can trigger stops/restarts to the app that monit thinks are "crashes"
+
+```ruby
+before "deploy:started",  "monit:unmonitor"
+after  "deploy:finished", "monit:monitor"
+```
+
+If you want monit to automatically start/stop runit instead of triggering seperately
+
+```ruby
+before "monit:unmonitor", "monit:stop"
+after  "monit:monitor",   "monit:start"
+```
+
+### Runit
+
+All these tasks do runit tasks for all services setup with runit.
+
+```
+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
+```
+
+#### Setup in your deploy file
+
+You can add this to deploy.rb or env.rb in order to automatically start/stop tasks
+
+```ruby
+before "deploy", "runit:stop"
+after  "deploy", "runit:start"
+```
+
+See each gem if you want to start/stop each service separate instead of together.
+
+## 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..)
+
+## 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-2015 Leif Ringstad. See LICENSE.txt for details
+

data/Rakefile

@@ -0,0 +1,39 @@
+# 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-monit_runit'
+  gem.homepage = 'https://github.com/leifcr/capistrano-monit_runit'
+  gem.license = 'MIT'
+  gem.summary = 'Helpers for capistrano recipes using runit/monit'
+  gem.description = 'Helpers for capistrano recipes using runit/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') : ""
+
+#   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 @@
+3.0.0

data/capistrano-monit_runit.gemspec

@@ -0,0 +1,70 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+# stub: capistrano-monit_runit 3.0.0 ruby lib
+
+Gem::Specification.new do |s|
+  s.name = "capistrano-monit_runit"
+  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 = "2015-03-13"
+  s.description = "Helpers for capistrano recipes using runit/monit."
+  s.email = "leifcr@gmail.com"
+  s.extra_rdoc_files = [
+    "LICENSE",
+    "README.md"
+  ]
+  s.files = [
+    "Gemfile",
+    "Gemfile.lock",
+    "LICENSE",
+    "README.md",
+    "Rakefile",
+    "VERSION",
+    "capistrano-monit_runit.gemspec",
+    "lib/capistrano/capistrano-monit_runit.rb",
+    "lib/capistrano/dsl/base_paths.rb",
+    "lib/capistrano/dsl/monit_paths.rb",
+    "lib/capistrano/dsl/runit_paths.rb",
+    "lib/capistrano/helpers/base.rb",
+    "lib/capistrano/helpers/monit.rb",
+    "lib/capistrano/helpers/runit.rb",
+    "lib/capistrano/monit.rb",
+    "lib/capistrano/runit.rb",
+    "lib/capistrano/tasks/base.rake",
+    "lib/capistrano/tasks/monit.rake",
+    "lib/capistrano/tasks/runit.rake",
+    "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-monit_runit"
+  s.licenses = ["MIT"]
+  s.rubygems_version = "2.4.6"
+  s.summary = "Helpers for capistrano recipes using runit/monit"
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 4
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<capistrano>, ["~> 3.4"])
+      s.add_development_dependency(%q<bundler>, ["~> 1.7"])
+      s.add_development_dependency(%q<jeweler>, ["~> 2.0"])
+    else
+      s.add_dependency(%q<capistrano>, ["~> 3.4"])
+      s.add_dependency(%q<bundler>, ["~> 1.7"])
+      s.add_dependency(%q<jeweler>, ["~> 2.0"])
+    end
+  else
+    s.add_dependency(%q<capistrano>, ["~> 3.4"])
+    s.add_dependency(%q<bundler>, ["~> 1.7"])
+    s.add_dependency(%q<jeweler>, ["~> 2.0"])
+  end
+end
+

data/lib/capistrano/dsl/base_paths.rb

@@ -0,0 +1,18 @@
+module Capistrano
+  module DSL
+    ##
+    # Base paths and filenames/folder names for both runit and monit
+    #
+    module BasePaths
+      # user_app_env_path in basehelper 0.x / capistrano 2.x version
+
+      def app_env_folder
+        "#{fetch(:application)}_#{environment}"
+      end
+
+      def user_app_env_file_name
+        "#{fetch(:user)}_#{fetch(:application)}_#{environment}"
+      end
+    end
+  end
+end

data/lib/capistrano/dsl/monit_paths.rb

@@ -0,0 +1,29 @@
+module Capistrano
+  module DSL
+    ##
+    # Paths and filenames for monit
+    module MonitPaths
+
+      # Folder should belong to root:root
+      def monit_etc_path
+        File.join("/etc", "monit")
+      end
+
+      # This folder must be writable by the user group deploy
+      # and ownership should be root:deploy
+      def monit_etc_conf_d_path
+        File.join(monit_etc_path, "conf.d")
+      end
+
+      # This file must have mode 0700 and belong to root!
+      def monit_monitrc_file
+        File.join(monit_etc_path, "monitrc")
+      end
+
+      # The symlink will belong to the deploy user
+      def monit_etc_app_symlink
+        File.join(monit_etc_conf_d_path, "#{user_app_env_file_name}.conf")
+      end
+    end
+  end
+end

data/lib/capistrano/dsl/runit_paths.rb

@@ -0,0 +1,117 @@
+module Capistrano
+  module DSL
+    ##
+    # Paths and filenames for runit
+    #
+    # Main app services are placed under
+    # /etc/sv/username/appname_env
+    #
+    # They are symlinked for enabling / disabling the entire app like this:
+    # /etc/service/username_appname_env --> /etc/sv/username/appname_env
+    #
+    # All services run/finish scripts e.g. puma/delayed job etc are located in
+    # 'shared_folder'/runit/service_name/
+    module RunitPaths
+      # /etc/sv
+      def runit_etc_sv_path
+        File.join('/etc', 'sv')
+      end
+
+      def runit_user_base_path
+        File.join(runit_etc_sv_path, fetch(:user))
+      end
+
+      def runit_base_path
+        File.join(runit_user_base_path, app_env_folder)
+      end
+
+      def runit_base_log_path
+        File.join(runit_base_path, 'log')
+      end
+
+      def runit_run_file
+        File.join(runit_base_path, 'run')
+      end
+
+      def runit_finish_file
+        File.join(runit_base_path, 'finish')
+      end
+
+      def runit_log_run_file
+        File.join(runit_base_log_path, 'run')
+      end
+
+      def runit_var_log_service_path
+        File.join('/var', 'log', 'service')
+      end
+
+      def runit_var_log_service_single_service_path(service_name)
+        File.join(runit_var_log_service_path, user_app_env_underscore, service_name)
+      end
+
+      # /var/log/service/'usr_app_env_folder'/runit
+      def runit_var_log_service_runit_path
+        runit_var_log_service_single_service_path('runit')
+      end
+
+      # /etc/service
+      def runit_etc_service_path
+        File.join('/etc', 'service')
+      end
+
+      def runit_etc_service_app_symlink_name
+        File.join('/etc', 'service', user_app_env_file_name)
+      end
+
+      # Paths and files in shared_folder
+      def runit_service_path(service_name)
+        File.join(fetch(:runit_dir), service_name)
+      end
+
+      def runit_service_log_path(service_name)
+        File.join(runit_service_path(service_name), 'log')
+      end
+
+      def runit_service_control_path(service_name)
+        File.join(runit_service_path(service_name), 'control')
+      end
+
+      def runit_service_control_file(service_name, control_letter)
+        File.join(runit_service_control_path(service_name), control_letter)
+      end
+
+      def runit_service_log_run_file(service_name)
+        File.join(runit_service_log_path(service_name), 'run')
+      end
+
+      def runit_service_run_file(service_name)
+        File.join(runit_service_path(service_name), 'run')
+      end
+
+      def runit_service_finish_file(service_name)
+        File.join(runit_service_path(service_name), 'finish')
+      end
+
+      def runit_service_run_config_file(service_name)
+        File.join(runit_service_path(service_name), "#{service_name}_run")
+      end
+
+      def runit_service_finish_config_file(service_name)
+        File.join(runit_service_path(service_name), "#{service_name}_finish")
+      end
+
+      def create_service_folders(service_name)
+        if test "[ -d #{runit_service_path(service_name)} ]"
+          execute :mkdir, "-p #{runit_service_path(service_name)}"
+        end
+        if test "[ -d #{runit_service_path(service_name)} ]"
+          execute :mkdir, "-p #{runit_service_path(service_name)}"
+        end
+      end
+
+      def service_pid(service_name)
+        File.join(runit_service_path(service_name), 'supervise', 'pid')
+      end
+    end
+  end
+end

data/lib/capistrano/helpers/base.rb

@@ -0,0 +1,60 @@
+module Capistrano
+  module Helpers
+    ##
+    # Helper functions for both runit and monit
+    module Base
+      def user_app_env_underscore
+        "#{fetch(:user)}_#{fetch(:application)}_#{environment}"
+      end
+
+      def user_app_env_underscore_short
+        "#{fetch(:user)[0...1]}_#{environment[0...1]}_#{fetch(:application)}"
+      end
+
+      def user_app_env_underscore_short_char_safe
+        user_app_env_underscore_short.gsub!('-', '_')
+      end
+
+      ##
+      # Automatically sets the environment based on presence of
+      # :stage (multistage)
+      # :rails_env
+      # RAILS_ENV variable;
+      #
+      # Defaults to "production" if not found
+      #
+      def environment # rubocop:disable Metrics/MethodLength
+        if !fetch(:rails_env).nil?
+          fetch(:rails_env)
+        elsif !fetch(:rack_env).nil?
+          fetch(:rack_env)
+        elsif !fetch(:stage).nil?
+          fetch(:stage)
+        else
+          info '---------------------------------------------------------------'
+          info '- Stage, rack or rails environment isn\'t set in               -'
+          info '- :stage, :rails_env or :rack_env, defaulting to \'production\' -'
+          info '---------------------------------------------------------------'
+          'production'
+        end
+      end
+
+      def template_to_s_io(template_file)
+        fail "Cannot find templte #{template_file}" unless File.exist?(template_file)
+        StringIO.new(ERB.new(File.read(template_file)).result(binding))
+      end
+
+      ##
+      # Execute a rake taske using the proper env.
+      # run_rake db:migrate
+      #
+      def run_rake(task)
+        within(current_path) do
+          with rails_env: fetch(:rails_env) do
+            execute :rake, "#{task}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/capistrano/helpers/monit.rb

@@ -0,0 +1,47 @@
+module Capistrano
+  module Helpers
+    ##
+    # Helper functions for monit
+    #
+    module Monit
+      ##
+      # Control / Command monit with given arguments
+      def command_monit(command, arguments = '')
+        execute :sudo, :monit, "#{arguments} #{command}"
+      end
+
+      ##
+      # Control / Command a monit group
+      # namescheme: user_application_environment "#{user}_#{application}_#{environment}"
+      #
+      def command_monit_group(command, arguments = '')
+        command_monit(command, "-g #{fetch(:monit_application_group_name)} #{arguments}")
+      end
+
+      ##
+      # Command a single monit service
+      #
+      # The service name scheme is recommended to be
+      # "#{user}_#{application}_#{environment}_#{service}"
+      #
+      def command_monit_service(command, service_name, arguments = '')
+        execute :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(service_conf_filename)
+        return unless test("[ -h #{File.join(c.fetch(:monit_enabled_path), service_conf_filename)} ]")
+        execute :ln, "-sf #{File.join(c.fetch(:monit_available_path), service_conf_filename)} #{File.join(c.fetch(:monit_enabled_path), service_conf_filename)}" # rubocop:disable Metrics/LineLength:
+      end
+
+      def disable_service(service_conf_filename)
+        execute :rm, "-f #{File.join(c.fetch(:monit_enabled_path), service_conf_filename)}"
+      end
+    end
+  end
+end

data/lib/capistrano/helpers/runit.rb

@@ -0,0 +1,79 @@
+module Capistrano
+  module Helpers
+    module Runit
+      # Any command sent to this function controls _all_ services related to the app
+      def runit_app_services_control(command)
+        return unless test("[ ! -h #{runit_etc_service_app_symlink_name} ]")
+        execute :sudo, :sv, "#{command} #{runit_etc_service_app_symlink_name}"
+      end
+
+      # Begin - single service control functions
+
+      # 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, command, arguments, _ignore_error = false)
+        return unless test "[ ! -h #{runit_service_path(service_name)}/run ]"
+        execute :sv, "#{arguments} #{command} #{runit_service_path(service_name)}"
+      end
+
+      # Will not check if the service exists before trying to force it down
+      def force_control_service(service_name, command, arguments, _ignore_error = false)
+        execute :sv, "#{arguments} #{command} #{runit_service_path(service_name)}"
+      end
+
+      def disable_service(service_name)
+        force_control_service(service_name, 'force-stop', '', true) # force-stop the service before disabling it
+        within(runit_service_path(service_name)) do
+          execute :rm, '-f ./run' if test '[ ! -h ./run ]'
+          execute :rm, '-f ./finish' if test '[ ! -h ./finish ]'
+        end
+      end
+
+      def enable_service(service_name)
+        within(runit_service_path(service_name)) do
+          execute :ln, "-sf #{runit_service_run_config_file} ./run" if test '[ -h ./run ]'
+          execute :ln, "-sf #{runit_service_finish_config_file} ./finish" if test '[ -h ./finish ]'
+        end
+      end
+
+      def purge_service(service_name)
+        execute :rm, "-rf #{runit_service_path(service_name)}"
+      end
+
+      def runit_set_executable_files(service_name) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+        if test("[ -f '#{runit_service_run_config_file(service_name)}']")
+          execute :chmod, "775 #{runit_service_run_config_file(service_name)}"
+        end
+        if test("[ -f '#{runit_service_finish_config_file(service_name)}']")
+          execute :chmod, "775 #{runit_service_finish_config_file(service_name)}"
+        end
+
+        if test("[ -f '#{runit_service_log_run_file(service_name)}']")
+          execute :chmod, "775 #{runit_service_log_run_file(service_name)}"
+        end
+
+        if test("[ -d '#{runit_service_control_path(service_name)}']") # rubocop:disable Style/GuardClause
+          execute :chmod, "775 -R #{runit_service_control_path(service_name)}"
+          # execute :chmod, 'u+x -R runit_service_control_path(service_name)'
+          # execute :chmod, 'g+x -R runit_service_control_path(service_name)'
+        end
+      end
+
+      # End - single service control functions
+    end
+  end
+end

data/lib/capistrano/monit.rb

@@ -0,0 +1,12 @@
+def try_require(library)
+  require "#{library}"
+  rescue LoadError => e
+    puts "Capistrano / Base Helper: Cannot load library: #{library} Error: #{e}"
+end
+
+try_require 'capistrano/dsl/base_paths'
+try_require 'capistrano/dsl/monit_paths'
+try_require 'capistrano/helpers/base'
+try_require 'capistrano/helpers/monit'
+load File.expand_path('../tasks/base.rake', __FILE__)
+load File.expand_path('../tasks/monit.rake', __FILE__)

data/lib/capistrano/runit.rb

@@ -0,0 +1,12 @@
+def try_require(library)
+  require "#{library}"
+  rescue LoadError => e
+    puts "Capistrano / Base Helper: Cannot load library: #{library} Error: #{e}"
+end
+
+try_require 'capistrano/dsl/base_paths'
+try_require 'capistrano/dsl/runit_paths'
+try_require 'capistrano/helpers/base'
+try_require 'capistrano/helpers/runit'
+load File.expand_path('../tasks/base.rake', __FILE__)
+load File.expand_path('../tasks/runit.rake', __FILE__)

data/lib/capistrano/tasks/base.rake

@@ -0,0 +1,6 @@
+namespace :load do
+  task :defaults do
+    set :pids_path,    proc { shared_path.join('pids') }
+    set :sockets_path, proc { shared_path.join('sockets') }
+  end
+end

data/lib/capistrano/tasks/monit.rake

@@ -0,0 +1,223 @@
+# Monit capistrano 3.x tasks
+#
+# Application config and tasks that apply to all services setup
+# with monit for the application
+#
+# Recommendation:
+# Let monit monitor any long-running processes to ensure they keep
+# within the limits set by you.
+
+include Capistrano::DSL::BasePaths
+include Capistrano::DSL::MonitPaths
+include Capistrano::Helpers::Base
+include Capistrano::Helpers::Monit
+
+namespace :load do
+  task :defaults do
+    set :monit_dir,            proc { shared_path.join('monit') }
+    set :monit_available_path, proc { File.join(fetch(:monit_dir), 'available') }
+    set :monit_enabled_path,   proc { File.join(fetch(:monit_dir), 'enabled') }
+    set :monit_application_group_name,  proc { user_app_env_underscore }
+
+    set :monit_mailserver,          'localhost'
+    set :monit_mail_sender,         'monit@$HOST'
+    set :monit_mail_reciever,       nil # if this is nil, alerts are disabled
+    set :monit_use_httpd,           'true'
+    set :monit_httpd_bind_address,  'localhost'
+    set :monit_httpd_allow_address, 'localhost'
+    set :monit_httpd_signature,     'enable' # or enable
+    set :monit_httpd_port,          '2812'
+
+    set :monit_daemon_time,         '60'
+    set :monit_start_delay,         '60'
+
+    set :monit_monitrc_template,           File.join(File.expand_path(File.join(File.dirname(__FILE__), '../../../templates', 'monit')), 'monitrc.erb')  # rubocop:disable Metrics/LineLength:
+    set :monit_application_conf_template,  File.join(File.expand_path(File.join(File.dirname(__FILE__), '../../../templates', 'monit')), 'app_include.conf.erb')  # rubocop:disable Metrics/LineLength:
+
+    set :monit_application_conf_file, proc { File.join(fetch(:monit_dir), 'monit.conf') }
+  end
+end
+
+namespace :monit do
+  desc 'Setup monit for the application'
+  task :setup do
+    on roles(:app) do |host|
+      info "MONIT: Setting up initial monit configuration on #{host}"
+      if test "[ ! -d #{fetch(:monit_dir)} ]"
+        execute :mkdir, "-p #{fetch(:monit_dir)}"
+      end
+      if test "[ ! -d #{fetch(:monit_available_path)} ]"
+        execute :mkdir, "-p #{fetch(:monit_available_path)}"
+      end
+      if test "[ ! -d #{fetch(:monit_enabled_path)} ]"
+        execute :mkdir, "-p #{fetch(:monit_enabled_path)}"
+      end
+    end
+  end
+
+  desc 'Get the config needed to add to sudoers'
+  task :sudoers do
+    run_locally do
+      info '---------------ENTRIES FOR SUDOERS (Monit)---------------------'
+      puts "#{fetch(:user)} ALL=NOPASSWD: /bin/chmod 0700 #{monit_monitrc_file}"
+      puts "#{fetch(:user)} ALL=NOPASSWD: /bin/chmod 0775 #{monit_etc_path}"
+      puts "#{fetch(:user)} ALL=NOPASSWD: /bin/chmod 0700 #{monit_etc_path}"
+      puts "#{fetch(:user)} ALL=NOPASSWD: /bin/mkdir -p #{monit_etc_conf_d_path}"
+      puts "#{fetch(:user)} ALL=NOPASSWD: /bin/chmod 6775 #{monit_etc_conf_d_path}"
+      puts "#{fetch(:user)} ALL=NOPASSWD: /bin/chown #{fetch(:user)}\\:root #{monit_etc_path}"
+      puts "#{fetch(:user)} ALL=NOPASSWD: /bin/chown #{fetch(:user)}\\:root #{monit_etc_conf_d_path}"
+      puts "#{fetch(:user)} ALL=NOPASSWD: /bin/chown #{fetch(:user)}\\:root #{monit_monitrc_file}"
+      puts "#{fetch(:user)} ALL=NOPASSWD: /bin/chown root\\:root #{monit_monitrc_file}"
+      puts "#{fetch(:user)} ALL=NOPASSWD: /usr/bin/monit *"
+      puts "#{fetch(:user)} ALL=NOPASSWD: /usr/sbin/service monit *"
+      info '---------------------------------------------------------------'
+    end
+    # info "#{fetch(:user)} ALL=NOPASSWD: /bin/chown deploy:root #{monit_monitrc_file}"
+  end
+
+  desc 'Setup main monit config file (/etc/monit/monitrc)'
+  task :main_config do
+    on roles(:app) do |host|
+      set :createmonitrc, ask("Create #{monit_monitrc_file} [Y/n]", 'Y')
+      if fetch(:createmonitrc) == 'Y'
+        info "MONIT: Creating #{monit_monitrc_file} on #{host}"
+        if test("[ ! -d #{monit_etc_conf_d_path} ]")
+          execute :sudo, :mkdir, "-p #{monit_etc_conf_d_path}"
+          execute :sudo, :chmod, "6775 #{monit_etc_conf_d_path}"
+          execute :sudo, :chown, "#{fetch(:user)}:root #{monit_etc_conf_d_path}"
+        end
+        execute :sudo, :chown, "#{fetch(:user)}:root #{monit_etc_path}"
+        execute :sudo, :chmod, "0775 #{monit_etc_path}"
+        execute :sudo, :chown, "#{fetch(:user)}:root #{monit_monitrc_file}"
+        upload! template_to_s_io(fetch(:monit_monitrc_template)), monit_monitrc_file
+        execute :sudo, :chmod, "0700 #{monit_monitrc_file}"
+        execute :sudo, :chown, "root:root #{monit_monitrc_file}"
+        execute :sudo, :service, 'monit restart'
+        info "MONIT: Sleeping for #{fetch(:monit_start_delay).to_i} seconds to wait for monit to be ready"
+        sleep(fetch(:monit_start_delay).to_i)
+      end
+    end
+  end
+
+  desc 'Enable monit services for application'
+  task :enable do
+    on roles(:app) do |host|
+      if test("[ ! -h #{monit_etc_app_symlink} ]")
+        info "MONIT: Enabling for #{fetch(:application)} on #{host}"
+        execute :ln, "-sf #{fetch(:monit_application_conf_file)} #{monit_etc_app_symlink}"
+      else
+        info "MONIT: Already enabled for #{fetch(:application)} on #{host}"
+      end
+    end
+  end
+
+  desc 'Disable monit services for application'
+  task :disable do
+    on roles(:app) do |host|
+      if test("[ -h #{monit_etc_app_symlink} ]")
+        info "MONIT: Disabling for #{fetch(:application)} on #{host}"
+        execute :rm, "-ff #{monit_etc_app_symlink}"
+      else
+        info "MONIT: Already disabled for #{fetch(:application)} on #{host}"
+      end
+    end
+  end
+
+  desc 'Purge/remove all monit configurations for the application'
+  task :purge do
+    on roles(:app) do |host|
+      info "MONIT: 'Purging config on #{host}"
+      execute :rm, "-rf #{fetch(:monit_dir)}" if test("[ -d #{fetch(:monit_dir)} ]")
+      execute :rm, "-f #{monit_etc_app_symlink}"
+    end
+  end
+
+  desc 'Monitor the application'
+  task :monitor do
+    on roles(:app) do |host|
+      info "MONIT: Application: Monitoring on #{host}"
+      command_monit_group('monitor')
+    end
+  end
+
+  desc 'Unmonitor the application'
+  task :unmonitor do
+    on roles(:app) do |host|
+      info "MONIT: Application: Unmonitoring on #{host}"
+      command_monit_group('unmonitor')
+    end
+  end
+
+  desc 'Stop monitoring the application permanent (Monit saves state)'
+  task :stop do
+    on roles(:app) do |host|
+      info "MONIT: Application: Stopping on #{host}"
+      command_monit_group('stop')
+    end
+  end
+
+  desc 'Start monitoring the application permanent (Monit saves state)'
+  task :start do
+    on roles(:app) do |host|
+      info "MONIT: Application: Starting on #{host}"
+      command_monit_group('start')
+    end
+  end
+
+  desc 'Restart monitoring the application'
+  task :restart do
+    on roles(:app) do |host|
+      info "MONIT: Application: Restarting on #{host}"
+      command_monit_group('restart')
+    end
+  end
+
+  desc 'Reload monit config (global)'
+  task :reload do
+    on roles(:app) do |host|
+      info "MONIT: Global: Reloading on #{host}"
+      command_monit('reload')
+    end
+  end
+
+  desc 'Status monit (global)'
+  task :status do
+    on roles(:app) do |host|
+      info "MONIT: Global: Status on #{host}"
+      command_monit('status')
+    end
+  end
+
+  desc 'Summary monit (global)'
+  task :summary do
+    on roles(:app) do |host|
+      info "MONIT: Global: Summary for #{host}"
+      command_monit('summary')
+    end
+  end
+
+  desc 'Validate monit (global)'
+  task :validate do
+    on roles(:app) do |host|
+      info "MONIT: Global: Validating config on #{host}"
+      command_monit('validate')
+    end
+  end
+end
+
+# 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'
+
+# This should be done in the app, as the sequence of restarting services can be specific
+# 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'

data/lib/capistrano/tasks/runit.rake

@@ -0,0 +1,172 @@
+# Runit capistrano 3.x tasks
+#
+# Application config and tasks that apply to all services setup
+# with runit for the application
+#
+# Recommendation:
+# Everything that should run as either a service or deamon,
+# can and should use runit
+
+require 'capistrano/dsl/base_paths'
+require 'capistrano/dsl/runit_paths'
+require 'capistrano/helpers/base'
+require 'capistrano/helpers/runit'
+
+include Capistrano::DSL::BasePaths
+include Capistrano::DSL::RunitPaths
+include Capistrano::Helpers::Base
+include Capistrano::Helpers::Runit
+
+namespace :load do
+  task :defaults do
+    set :runit_dir,               proc { shared_path.join('runit') }
+    set :runit_run_template,      File.join(File.expand_path(File.join(File.dirname(__FILE__), '../../../templates')), 'runit', 'run.erb') # rubocop:disable Metrics/LineLength:
+    set :runit_finish_template,   File.join(File.expand_path(File.join(File.dirname(__FILE__), '../../../templates')), 'runit', 'finish.erb') # rubocop:disable Metrics/LineLength:
+    set :runit_log_run_template,  File.join(File.expand_path(File.join(File.dirname(__FILE__), '../../../templates')), 'runit', 'log_run.erb') # rubocop:disable Metrics/LineLength:
+    set :runit_log_user,          'syslog'
+    set :runit_log_group,         'syslog'
+    set :runit_restart_interval,  10
+    set :runit_restart_count,     7
+    set :runit_autorestart_clear_interval, 90
+  end
+end
+
+namespace :runit do
+  desc 'Get the config needed to add to sudoers for all commands'
+  task :sudoers do
+    run_locally do
+      info '---------------ENTRIES FOR SUDOERS (Runit)---------------------'
+      puts "#{fetch(:user)} ALL=NOPASSWD: /bin/mkdir -p #{runit_user_base_path}"
+      puts "#{fetch(:user)} ALL=NOPASSWD: /bin/chown #{fetch(:user)}\\:root #{runit_user_base_path}"
+      puts "#{fetch(:user)} ALL=NOPASSWD: /bin/chmod 6775 #{runit_user_base_path}"
+      puts "#{fetch(:user)} ALL=NOPASSWD: /bin/mkdir -p #{runit_etc_service_path}"
+      puts "#{fetch(:user)} ALL=NOPASSWD: /bin/chown #{fetch(:user)}\\:root #{runit_etc_service_path}"
+      puts "#{fetch(:user)} ALL=NOPASSWD: /bin/chmod 6775 #{runit_etc_service_path}"
+      puts "#{fetch(:user)} ALL=NOPASSWD: /bin/mkdir -p #{runit_var_log_service_path}"
+      puts "#{fetch(:user)} ALL=NOPASSWD: /bin/chown #{fetch(:user)}\\:root #{runit_var_log_service_path}"
+      puts "#{fetch(:user)} ALL=NOPASSWD: /bin/chown -R #{fetch(:user)}\\:#{fetch(:runit_log_group)} #{runit_var_log_service_path}" # rubocop:disable Metrics/LineLength:
+      puts "#{fetch(:user)} ALL=NOPASSWD: /bin/chmod 6775 #{runit_var_log_service_path}"
+      puts "#{fetch(:user)} ALL=NOPASSWD: /usr/bin/sv *"
+      info '---------------------------------------------------------------'
+    end
+    # info "#{fetch(:user)} ALL=NOPASSWD: /bin/chown deploy:root #{monit_monitrc_file}"
+  end
+
+  desc 'Setup runit for the application'
+  task :setup do
+    on roles(:app) do |host|
+      info "RUNIT: Setting up initial runit configuration on #{host}"
+      if test "[ ! -f #{fetch(:runit_dir)}/.env/HOME ]"
+        if test "[ ! -d #{fetch(:runit_dir)}/.env ]"
+          execute :mkdir, "-p '#{fetch(:runit_dir)}/.env'"
+        end
+        upload! StringIO.new('$HOME'), "#{File.join(fetch(:runit_dir), '.env', 'HOME')}"
+      end
+    end
+  end
+
+  namespace :setup do
+    # '[INTERNAL] create /etc/sv folders and upload base templates needed'
+    task :runit_create_app_services do
+      on roles(:app) do |host|
+        # set :pw, ask("Sudo password", '')
+        # execute :echo, "#{fetch(:pw)} | sudo -S ls /"
+        if test("[ ! -d '#{runit_user_base_path}' ]")
+          execute :sudo, :mkdir, "-p '#{runit_user_base_path}'"
+          execute :sudo, :chown, "#{fetch(:user)}:root '#{runit_user_base_path}'"
+          execute :sudo, :chmod, "6775 '#{runit_user_base_path}'"
+        end
+        if test("[ ! -d '#{runit_etc_service_path}' ]")
+          execute :sudo, :mkdir, "-p '#{runit_etc_service_path}'"
+          execute :sudo, :chown, "#{fetch(:user)}:root '#{runit_etc_service_path}'"
+          execute :sudo, :chmod, "6775 '#{runit_etc_service_path}'"
+        end
+        within("#{runit_user_base_path}") do
+          execute :mkdir, "-p #{app_env_folder}"
+        end
+
+        upload! template_to_s_io(fetch(:runit_run_template)), runit_run_file
+        upload! template_to_s_io(fetch(:runit_finish_template)), runit_finish_file
+
+        # Should now work without sudo... ?
+        execute :chmod, "0775 '#{runit_run_file}'"
+        execute :chmod, "0775 '#{runit_finish_file}'"
+        info "RUNIT: Created inital runit services in #{runit_base_path} for #{fetch(:application)} on #{host}"
+      end
+    end
+
+    # [Internal] create log service for app
+    task :runit_create_app_log_services do
+      on roles(:app) do |host|
+        within("#{runit_base_path}") do
+          execute :mkdir, '-p log'
+        end
+        upload! template_to_s_io(fetch(:runit_log_run_template)), runit_log_run_file
+        if test("[ ! -d #{runit_var_log_service_path} ]")
+          execute :sudo, :mkdir, "-p '#{runit_var_log_service_path}'"
+          execute :sudo, :chmod, "6775 '#{runit_var_log_service_path}'"
+          execute :sudo, :chown, "-R #{fetch(:user)}:#{fetch(:runit_log_group)} '#{runit_var_log_service_path}'" # rubocop:disable Metrics/LineLength:
+        end
+        execute :mkdir, "-p #{runit_var_log_service_runit_path}" if test("[ ! -d #{runit_var_log_service_runit_path} ]")
+        execute :chmod, "775 '#{runit_log_run_file}'"
+
+        info "RUNIT: Created inital runit log services in #{runit_base_log_path} for #{fetch(:application)} on #{host}"
+      end
+    end
+  end
+
+  desc 'Disable runit services for application'
+  task :disable do
+    on roles(:app) do |host|
+      if test "[ -h #{runit_etc_service_app_symlink_name} ]"
+        execute :rm, "-rf '#{runit_etc_service_app_symlink_name}'"
+        info "RUNIT disabling on '#{host}'"
+      else
+        info "RUNIT already disabled on '#{host}'"
+      end
+    end
+  end
+
+  desc 'Enable runit services for application'
+  task :enable do
+    on roles(:app) do |host|
+      if test "[ ! -h #{runit_etc_service_app_symlink_name} ]"
+        execute :ln, "-sf '#{runit_base_path}' '#{runit_etc_service_app_symlink_name}'"
+        info "RUNIT enabling on '#{host}'"
+      else
+        info "RUNIT already enabled on '#{host}'"
+      end
+    end
+  end
+
+  desc 'Purge/remove all runit configurations for the application'
+  task :purge do
+    on roles(:app) do |host|
+      execute :rm, "-rf #{runit_etc_service_app_symlink_name}"
+      execute :rm, "-rf #{runit_base_path}"
+      info "RUNIT purging config on '#{host}'"
+    end
+  end
+
+  desc 'Stop all runit services for current application'
+  task :stop do
+    runit_app_services_control('stop')
+  end
+
+  desc 'Start all runit services for current application'
+  task :start do
+    runit_app_services_control('start')
+  end
+
+  desc 'Only start services once. Will not restart if they fail.'
+  task :once do
+    runit_app_services_control('once')
+  end
+end
+
+before 'runit:purge',     'runit:stop'
+
+after 'deploy:updated',   'runit:enable'
+# after 'deploy:setup',     'runit:setup'
+after 'runit:setup',      'runit:setup:runit_create_app_services'
+after 'runit:setup:runit_create_app_services', 'runit:setup:runit_create_app_log_services'

data/templates/monit/app_include.conf.erb

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

data/templates/monit/monitrc.erb

@@ -0,0 +1,23 @@
+set daemon <%= fetch(:monit_daemon_time) %>
+  with start delay <%= fetch(:monit_start_delay) %>
+
+set logfile syslog facility log_daemon
+
+set statefile /var/lib/monit/state
+
+set idfile /var/lib/monit/id
+
+set eventqueue
+    basedir /var/monit  # set the base directory where events will be stored
+    slots 100           # optionaly limit the queue size
+
+<%= fetch(:mail_alert_settings) %>
+
+<% unless fetch(:monit_use_httpd) == "false" %>
+set httpd port <%= fetch(:monit_httpd_port) %>
+  <%= "use address #{fetch(:monit_httpd_bind_address, "localhost")}" unless fetch(:monit_httpd_bind_address).nil? %>
+  <%= "allow #{fetch(:monit_httpd_allow_address)}" unless fetch(:monit_httpd_allow_address).nil? %>
+  <%= "signature #{fetch(:monit_httpd_signature)}" %>
+<% end %>
+
+include /etc/monit/conf.d/*.conf

data/templates/runit/finish.erb

@@ -0,0 +1,12 @@
+#!/bin/sh
+# Finish/quit services for <%= fetch(:application) %> as <%= fetch(:user) %> in env <%= environment %>
+#
+# Announce termination
+#
+echo "Stopping all services for <%= fetch(:application) %> running as <%= fetch(:user) %>"
+
+# Force all services to stop
+sv -w600 force-stop <%= fetch(:runit_dir) %>/*
+
+# "Exit" all services
+sv exit <%= fetch(:runit_dir) %>/*

data/templates/runit/log_run.erb

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

data/templates/runit/run.erb

@@ -0,0 +1,14 @@
+#!/bin/sh -e
+#
+# Run services for <%= fetch(:application) %> as <%= fetch(:user) %> in env <%= environment %>
+#
+
+# Redirect stderr so everything ends up in the log file
+exec 2>&1
+
+# Announce startup
+#
+echo "Starting all services for <%= fetch(:application) %> running as <%= fetch(:user) %>"
+
+# Start all services in folder <%= fetch(:runit_dir) %>
+exec chpst -u <%= fetch(:user) %> runsvdir "<%= fetch(:runit_dir) %>"

metadata

@@ -0,0 +1,111 @@
+--- !ruby/object:Gem::Specification
+name: capistrano-monit_runit
+version: !ruby/object:Gem::Version
+  version: 3.0.0
+platform: ruby
+authors:
+- Leif Ringstad
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-03-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: capistrano
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+description: Helpers for capistrano recipes using runit/monit.
+email: leifcr@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE
+- README.md
+files:
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- VERSION
+- capistrano-monit_runit.gemspec
+- lib/capistrano/capistrano-monit_runit.rb
+- lib/capistrano/dsl/base_paths.rb
+- lib/capistrano/dsl/monit_paths.rb
+- lib/capistrano/dsl/runit_paths.rb
+- lib/capistrano/helpers/base.rb
+- lib/capistrano/helpers/monit.rb
+- lib/capistrano/helpers/runit.rb
+- lib/capistrano/monit.rb
+- lib/capistrano/runit.rb
+- lib/capistrano/tasks/base.rake
+- lib/capistrano/tasks/monit.rake
+- lib/capistrano/tasks/runit.rake
+- 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-monit_runit
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.6
+signing_key: 
+specification_version: 4
+summary: Helpers for capistrano recipes using runit/monit
+test_files: []