capistrano-pumaio 0.0.18 → 3.0.0

data/lib/capistrano/puma/config.rb

@@ -1,56 +0,0 @@
-require 'capistrano/base_helper/base_helper'
-Capistrano::Configuration.instance(true).load do
-  _cset :puma_runit_service_name, "puma"
-  _cset :puma_workers, 2 # Must use a minimum of 1 worker (cluster mode, else restart/stop fails in the state file?)
-  _cset :puma_min_threads, 2
-  _cset :puma_max_threads, 8
-
-  _cset :puma_bin, 'bundle exec puma'
-  _cset :puma_control, 'bundle exec pumactl'
-
-  # Control files
-  _cset :puma_socket_file,  defer { "#{File.join(fetch(:sockets_path), "puma.sock")}" }
-  _cset :puma_socket_url,   defer { "unix://#{fetch(:puma_socket_file)}" }
-  _cset :puma_pid_file,     defer { File.join(fetch(:pids_path), "puma.pid") }
-  _cset :puma_state_file,   defer { File.join(fetch(:sockets_path), "puma.state") }
-  _cset :puma_control_file, defer { "#{File.join(fetch(:sockets_path), "pumactl.sock")}" }
-  _cset :puma_control_url,  defer { "unix://#{fetch(:puma_control_file)}" }
-
-  _cset :puma_use_preload_app, true # This must be set to false if phased restarts should be used
-
-  _cset :puma_activate_control_app, true
-
-  _cset :puma_on_restart_active, true
-
-  # Logging to path
-  _cset :puma_log_path, defer {"/var/log/service/#{fetch(:user)}/#{fetch(:application)}_#{Capistrano::BaseHelper.environment}/puma"}
-
-  # Configuration files
-  _cset :puma_local_config, File.join(File.expand_path(File.join(File.dirname(__FILE__),"../../../templates", "runit")), "config.rb.erb")
-
-  # The remote location of puma's config file. Used by runit when starting puma
-  _cset :puma_remote_config, defer {File.join(shared_path, "config", "puma.rb")}
-
-  # runit defaults
-  _cset :puma_restart_interval, defer {fetch(:runit_restart_interval)}
-  _cset :puma_restart_count, defer {fetch(:runit_restart_count)}
-  _cset :puma_autorestart_clear_interval, defer {fetch(:runit_autorestart_clear_interval)}
-
-  # runit paths
-  _cset :puma_runit_local_run, File.join(File.expand_path(File.join(File.dirname(__FILE__),"../../../templates", "runit", )), "run.erb")
-  _cset :puma_runit_local_finish, File.join(File.expand_path(File.join(File.dirname(__FILE__),"../../../templates", "runit", )), "finish.erb")
-  _cset :puma_runit_control_q, File.join(File.expand_path(File.join(File.dirname(__FILE__),"../../../templates", "runit")), "control-q.erb")
-  _cset :puma_runit_local_log_run, File.join(File.expand_path(File.join(File.dirname(__FILE__),"../../../templates", "runit")), "log-run.erb")
-
-  # monit configuration
-  _cset :puma_monit_service_name,  defer { "#{fetch(:user)}_#{fetch(:application)}_#{Capistrano::BaseHelper.environment}_puma" }
-  _cset :puma_monit_start_command, defer {"/bin/bash -c '[ ! -h #{Capistrano::RunitBase.service_path(fetch(:puma_runit_service_name))}/run ] || /usr/bin/sv start #{Capistrano::RunitBase.service_path(fetch(:puma_runit_service_name))}'"}
-  _cset :puma_monit_stop_command,  defer {"/usr/bin/sv -w 12 force-stop #{Capistrano::RunitBase.service_path(fetch(:puma_runit_service_name))}"}
-  _cset :puma_monit_memory_alert_threshold, "150.0 MB for 2 cycles"
-  _cset :puma_monit_memory_restart_threshold, "175.0 MB for 3 cycles"
-  _cset :puma_monit_cpu_alert_threshold,   "90% for 2 cycles"
-  _cset :puma_monit_cpu_restart_threshold, "95% for 5 cycles"
-
-  _cset :puma_local_monit_config, File.join(File.expand_path(File.join(File.dirname(__FILE__),"../../../templates", "monit")), "puma.conf.erb")
-
-end

data/lib/capistrano/puma/monit.rb

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

data/lib/capistrano/puma/nginx.rb

@@ -1,128 +0,0 @@
-require 'capistrano/puma/config'
-require 'capistrano/base_helper/monit_base'
-
-Capistrano::Configuration.instance.load do
-
-  # Where your nginx lives. Usually /opt/nginx or /usr/local/nginx for source compiled.
-  _cset :nginx_sites_enabled_path, "/etc/nginx/sites-enabled"
-
-  # simple authorization in nginx recipe
-  # Remember NOT to share your deployment file in case you have sensitive passwords stored in it...
-  # This is added to make it easier to deploy staging sites with a simple htpasswd.
-
-  _cset :nginx_use_simple_auth, false
-  _cset :nginx_simple_auth_message, "Restricted site"
-  _cset :nginx_simple_auth_user, "user"
-  _cset :nginx_simple_auth_password, "password"
-  _cset :nginx_simple_auth_salt, (0...8).map{ ('a'..'z').to_a[rand(26)] }.join
-
-  # Server names. Defaults to application name.
-  _cset :server_names, defer {"#{fetch(:application)}_#{Capistrano::BaseHelper.environment}"}
-
-  # Path to the nginx erb template to be parsed before uploading to remote
-  _cset :nginx_local_config, File.join(File.expand_path(File.join(File.dirname(__FILE__),"../../../templates", "nginx", )), "application.conf.erb")
-
-  # Path to where your remote config will reside (I use a directory sites inside conf)
-  _cset :nginx_remote_config, defer {File.join("#{fetch(:shared_path)}", "config", "nginx_#{fetch(:application)}_#{Capistrano::BaseHelper.environment}.conf")}
-
-  # Path to local htpasswd template file
-  _cset :nginx_local_htpasswd, defer {File.join(File.expand_path(File.join(File.dirname(__FILE__),"../../../templates", "nginx", )), "htpasswd.erb")}
-
-  # Path to remote htpasswd file
-  _cset :nginx_remote_htpasswd, defer {File.join("#{fetch(:shared_path)}", "config", ".htpasswd")}
-
-  _cset :nginx_sites_enabled_symlink, defer {File.join(nginx_sites_enabled_path, "#{fetch(:application)}_#{Capistrano::BaseHelper.environment}")}
-
-  _cset :nginx_uses_http, true
-  _cset :nginx_uses_ssl, false
-  _cset :nginx_port, 80
-
-  _cset :nginx_log_path, File.join("/var", "log", "nginx", "#{fetch(:application)}")
-
-  _cset :nginx_client_max_body_size, "10M"
-
-  _cset :nginx_ssl_port, 443
-  _cset :nginx_ssl_use_simple_auth, false
-  _cset :nginx_ssl_client_max_body_size, "10M"
-  _cset :nginx_ssl_public_crt, File.join("/etc", "certs", "server.crt")
-  _cset :nginx_ssl_private_key, File.join("/etc", "certs", "server.key")
-
-  # Nginx tasks are not *nix agnostic, they assume you're using Debian/Ubuntu.
-  # Override them as needed.
-  namespace :puma do
-    namespace :nginx do
-      desc "Parses and uploads nginx configuration for this app."
-      task :setup, :roles => :app , :except => { :no_release => true } do
-
-        Capistrano::BaseHelper.generate_and_upload_config(fetch(:nginx_local_config), fetch(:nginx_remote_config))
-
-        # if auth is enabled, upload htpasswd file
-        # Since passwords are stored in plaintext in the deployment file, you should use simple auth with care.
-        # It is generally better to implement a full authorization stack like oauth, use devise on rails, or other login/auth system
-        if fetch(:nginx_use_simple_auth) or fetch(:nginx_ssl_use_simple_auth)
-          if Capistrano::CLI.ui.agree("Create .htpasswd configuration file? [Yn]")
-            Capistrano::BaseHelper.generate_and_upload_config(fetch(:nginx_local_htpasswd), fetch(:nginx_remote_htpasswd))
-          else
-            set :nginx_use_simple_auth, false
-            set :nginx_ssl_use_simple_auth, false
-          end
-        end
-
-        # create log path, must sudo since path can have root-only permissions
-        run "#{sudo} mkdir -p /var/log/nginx/#{fetch(:application)} && #{sudo} chown root:www-data /var/log/nginx/#{fetch(:application)}"
-      end
-
-      desc "Enable nginx site for the application"
-      task :enable, :roles => :app , :except => { :no_release => true } do
-        # symlink to nginx site configuration file
-        run("[ -h #{fetch(:nginx_sites_enabled_symlink)} ] || #{sudo} ln -sf #{fetch(:nginx_remote_config)} #{fetch(:nginx_sites_enabled_symlink)}")
-      end
-
-      desc "Disable nginx site for the application"
-      task :disable, :roles => :app , :except => { :no_release => true } do
-        run("[ ! -h #{fetch(:nginx_sites_enabled_symlink)} ] || #{sudo} rm -f #{fetch(:nginx_sites_enabled_symlink)}")
-      end
-
-      desc "Purge nginx site config for the application"
-      task :purge, :roles => :app , :except => { :no_release => true } do
-        run("[ ! -h #{fetch(:nginx_sites_enabled_symlink)} ] || #{sudo} rm -f #{fetch(:nginx_sites_enabled_symlink)}")
-        # must restart nginx to make sure site is disabled when config is purge
-        run "#{sudo} service nginx restart"
-        run "rm -f #{fetch(:nginx_remote_htpasswd)} && rm -f #{fetch(:nginx_remote_config)}"
-      end
-
-    end
-  end
-
-  namespace :nginx do
-    desc "Restart nginx"
-    task :restart, :roles => :app , :except => { :no_release => true } do
-      run "#{sudo} service nginx restart"
-    end
-
-    desc "Stop nginx"
-    task :stop, :roles => :app , :except => { :no_release => true } do
-      run "#{sudo} service nginx stop"
-    end
-
-    desc "Start nginx"
-    task :start, :roles => :app , :except => { :no_release => true } do
-      run "#{sudo} service nginx start"
-    end
-
-    desc "Show nginx status"
-    task :status, :roles => :app , :except => { :no_release => true } do
-      run "#{sudo} service nginx status"
-    end
-
-  end
-
-  after 'deploy:setup' do
-    puma.nginx.setup if Capistrano::CLI.ui.agree("Create nginx configuration file? [Yn]")
-    if Capistrano::CLI.ui.agree("Enable site in nginx? [Yn]")
-      puma.nginx.enable
-      nginx.restart # must restart after enable for nginx to pickup new site
-    end
-  end
-
-end

data/lib/capistrano/puma/runit.rb

@@ -1,145 +0,0 @@
-# Puma - Runit
-require 'capistrano/puma/config'
-require 'capistrano/base_helper/runit_base'
-
-Capistrano::Configuration.instance(true).load do
-  after "deploy:setup", "puma: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", "puma:runit:enable"
-  before "puma:runit:setup", "puma:flush_sockets"
-  before "puma:runit:setup", "puma:setup"
-  before "puma:runit:quit", "puma:runit:stop"
-
-  namespace :puma do
-
-    desc "Setup Puma configuration"
-    task :setup, :roles => :app do
-      Capistrano::BaseHelper.prepare_path(File.join(fetch(:shared_path), "sockets"), fetch(:user), fetch(:group))
-
-      # Create puma configuration file
-      Capistrano::BaseHelper::generate_and_upload_config(fetch(:puma_local_config), fetch(:puma_remote_config))
-    end
-
-    desc "Flush Puma sockets, as they can end up 'hanging around'"
-    task :flush_sockets, :roles => :app do
-      run "rm -f #{fetch(:puma_socket_file)}; rm -f #{fetch(:puma_control_file)}"
-    end
-
-    namespace :runit do
-      desc "Setup Puma runit-service"
-      task :setup, :roles => :app do
-
-
-        # Create runit config
-        Capistrano::RunitBase.create_service_dir(puma_runit_service_name)
-        Capistrano::BaseHelper::generate_and_upload_config(puma_runit_local_run, Capistrano::RunitBase.remote_run_config_path(puma_runit_service_name))
-        Capistrano::BaseHelper::generate_and_upload_config(puma_runit_local_finish, Capistrano::RunitBase.remote_finish_config_path(puma_runit_service_name))
-
-        #must use quit script for stop as well
-        Capistrano::BaseHelper::generate_and_upload_config(puma_runit_control_q, Capistrano::RunitBase.remote_control_path(puma_runit_service_name, "q"))
-        Capistrano::BaseHelper::generate_and_upload_config(puma_runit_control_q, Capistrano::RunitBase.remote_control_path(puma_runit_service_name, "s"))
-        Capistrano::BaseHelper::generate_and_upload_config(puma_runit_local_log_run, Capistrano::RunitBase.remote_service_log_run_path(puma_runit_service_name))
-
-        # Make scripts executable
-        Capistrano::RunitBase.make_service_scripts_executeable(puma_runit_service_name)
-        # Set correct permissions/owner on log path
-        Capistrano::RunitBase.create_and_permissions_on_path(fetch(:puma_log_path))
-      end
-
-      desc "Enable Puma runit-service"
-      task :enable, :roles => :app do
-        Capistrano::RunitBase.enable_service(puma_runit_service_name)
-      end
-
-      desc "Disable Puma runit-service"
-      task :disable, :roles => :app do
-        Capistrano::RunitBase.disable_service(puma_runit_service_name)
-      end
-
-      desc "Start Puma runit-service"
-      task :start, :roles => :app do
-        Capistrano::RunitBase.start_service(puma_runit_service_name)
-      end
-
-      desc "Start Puma runit-service only ONCE (no supervision...)"
-      task :once, :roles => :app do
-        Capistrano::RunitBase.start_service_once(puma_runit_service_name)
-      end
-
-      desc "Stop Puma runit-service"
-      task :stop, :roles => :app, :on_error => :continue do
-        # have to use force-stop on failed stop, since puma might not terminate properly
-        # will wait 25 seconds for puma to shut down, to allow it to serve any on-going requests
-        Capistrano::RunitBase.control_service(puma_runit_service_name, "force-stop", false, "-w 25")
-      end
-
-      desc "Quit the puma runit-service"
-      task :quit, :roles => :app, :on_error => :continue do
-        Capistrano::RunitBase.control_service(puma_runit_service_name, "quit")
-      end
-
-      desc "Restart Puma runit-service"
-      task :restart, :roles => :app do
-        result     = nil
-        started    = false
-
-        # It is not possible to see if a restart is in progress using the pumactl tool as of now.
-
-        # restarting = false
-        # # check if puma is already performing a restart
-        # invoke_command("cd #{fetch(:current_path)}; [[ $(#{fetch(:puma_control)} -S #{fetch(:puma_state_file)} status) == *restart* ]] && echo 'restarting';true") do |ch, stream, out|
-        #   result = (/restart/ =~ out)
-        # end
-        # restarting = true unless result.nil?
-        # result     = nil
-
-        # if restarting == false
-          # check if it is running
-          invoke_command("cd #{fetch(:current_path)}; [[ $(#{fetch(:puma_control)} -S #{fetch(:puma_state_file)} status) == *started* ]] && echo 'started';true") do |ch, stream, out|
-            result = (/started/ =~ out)
-          end
-          started = true unless result.nil?
-
-          if started == true
-            logger.info("\nRestarting puma")
-            # Send USR2 to puma in order to restart it....
-            Capistrano::RunitBase.control_service(puma_runit_service_name, "2")
-          else
-            logger.important("\nStarting puma, (wasn't running before)")
-            Capistrano::RunitBase.start_service(puma_runit_service_name)
-          end
-        # end
-      end
-
-      desc "Phased Restart of Puma"
-      task :phased_restart, :roles => :app do
-        result     = nil
-        started    = false
-
-        # check if it is running
-        invoke_command("cd #{fetch(:current_path)}; [[ $(#{fetch(:puma_control)} -S #{fetch(:puma_state_file)} status) == *started* ]] && echo 'started';true") do |ch, stream, out|
-          result = (/started/ =~ out)
-        end
-        started = true unless result.nil?
-
-        if started == true
-          # Send USR1 to puma in order to restart it....
-          logger.info("\nPhased restart of puma")
-          Capistrano::RunitBase.control_service(puma_runit_service_name, "1")
-        else
-          logger.important("\nStarting puma, (wasn't running before)")
-          Capistrano::RunitBase.start_service(puma_runit_service_name)
-        end
-      end
-
-      desc "Purge Puma runit configuration"
-      task :purge, :roles => :app, :on_error => :continue do
-        Capistrano::RunitBase.force_control_service(puma_runit_service_name, "force-stop", true)
-        Capistrano::RunitBase.purge_service(puma_runit_service_name)
-      end
-
-    end
-  end
-end

data/templates/runit/config.rb.erb

@@ -1,20 +0,0 @@
-# Puma configuration for: <% c = Capistrano::BaseHelper::get_capistrano_instance %>
-# <%= "#{c.fetch(:application)} running as #{c.fetch(:user)} in environment #{Capistrano::BaseHelper.environment}" %>
-workers <%= c.fetch(:puma_workers) %>
-threads <%= c.fetch(:puma_min_threads) %>, <%= c.fetch(:puma_max_threads) %>
-bind '<%= c.fetch(:puma_socket_url) %>'
-pidfile '<%= c.fetch(:puma_pid_file) %>'
-state_path '<%= c.fetch(:puma_state_file) %>'
-environment '<%= "#{Capistrano::BaseHelper.environment}" %>'
-<%= "activate_control_app '#{c.fetch(:puma_control_url)}'" if c.fetch(:puma_activate_control_app) %>
-
-# In some cases preloading the app is best to avoid some infinite restart loops, however, it cannot be used in
-# combination with phased restart.
-<%= "preload_app!" if c.fetch(:puma_use_preload_app) %>
-
-directory '<%= File.join(c.fetch(:deploy_to), "current") %>'
-
-# TODO - fix restart block!
-# <%= "on_restart do"              if c.fetch(:puma_on_restart_active) %>
-# <%= "  puts \"Restarting puma\"" if c.fetch(:puma_on_restart_active) %>
-# <%= "end"                        if c.fetch(:puma_on_restart_active) %>

data/templates/runit/control-q.erb

@@ -1,8 +0,0 @@
-#!/bin/bash --login
-<% c = Capistrano::BaseHelper.get_capistrano_instance %>
-# Announcing stop/abort
-echo "<%= "User: #{c.fetch(:user)} Application: #{c.fetch(:application)} Service: #{c.fetch(:puma_runit_service_name)}" %> stopping..."
-
-# The command used when puma is asked to quit/stop/exit, overridden here, as runit normal signal will not work with puma
-cd '<%= c.current_path %>'
-RAILS_ENV=<%= Capistrano::BaseHelper.environment %> exec <%= c.fetch(:puma_control) %> -S <%= c.fetch(:puma_state_file) %> stop

data/templates/runit/log-run.erb

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