capistrano-pumaio 0.0.18 → 3.0.0

data/lib/capistrano/tasks/monit.rake

@@ -0,0 +1,66 @@
+require 'capistrano/helpers/base'
+require 'capistrano/helpers/monit'
+require 'capistrano/helpers/puma/monit'
+require 'capistrano/dsl/base_paths'
+include Capistrano::DSL::BasePaths
+include Capistrano::Helpers::Base
+include Capistrano::Helpers::Monit
+include Capistrano::Helpers::Puma::Monit
+
+namespace :puma do
+  namespace :monit do
+    desc 'MONIT: Setup Puma service'
+    task :setup do
+      on roles(:app) do |host|
+        info "MONIT: Uploading configuration for puma for #{fetch(:application)} on #{host}"
+        # Upload configuration
+        upload! template_to_s_io(fetch(:puma_monit_config_template)), available_configuration_with_path
+      end
+    end
+
+    desc 'MONIT: Enable services for Puma'
+    task :enable do
+      on roles(:app) do |host|
+        info "MONIT: Enabling service for puma for application #{fetch(:application)} on #{host}"
+        enable_monitor(available_configuration_file )
+      end
+    end
+
+    desc 'MONIT: Disable and Stop services for  Puma'
+    task :disable do
+      on roles(:app) do |host|
+        info "MONIT: Disabling service for puma for application #{fetch(:application)} on #{host}"
+        disable_monitor(available_configuration_file)
+      end
+    end
+
+    %w(start stop restart monitor unmonitor).each do |cmd|
+      desc "MONIT: #{cmd.capitalize} puma"
+      task cmd.to_sym do
+        on roles(:app) do |host|
+          info "MONIT: #{cmd} #{fetch(:puma_monit_service_name)} on #{host}"
+          command_monit(cmd, fetch(:puma_monit_service_name))
+        end
+      end
+    end
+
+    desc 'MONIT: Purge Puma configuration'
+    task :purge do
+      on roles(:app) do |host|
+        info "MONIT: Purging config for #{fetch(:puma_monit_service_name)} on #{host}"
+      end
+    end
+  end
+end
+
+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
+# This shouldn't be necessary, as monit should pick up a non-running service.
+# Starting it here might trigger double starting if monit is triggered simultaniously.
+# after "deploy:update", "puma:monit:start"

data/lib/capistrano/tasks/nginx.rake

@@ -0,0 +1,119 @@
+require 'capistrano/dsl/base_paths'
+require 'capistrano/helpers/base'
+require 'capistrano/helpers/puma/nginx'
+include Capistrano::DSL::BasePaths
+include Capistrano::Helpers::Base
+include Capistrano::Helpers::Puma::Nginx
+
+namespace :puma do
+  namespace :nginx do
+    desc 'Get the config needed to add to sudoers for nginx commands'
+    task :sudoers do
+      run_locally do
+        info '---------------ENTRIES FOR SUDOERS (Nginx)---------------------'
+        puts '#---------------ENTRIES FOR SUDOERS (Nginx)---------------------'
+        puts "#{fetch(:user)} ALL=NOPASSWD: /bin/mkdir -p #{fetch(:nginx_log_path)}"
+        puts "#{fetch(:user)} ALL=NOPASSWD: /bin/chown -R #{fetch(:user)}\\:root #{fetch(:nginx_log_path)}"
+        puts "#{fetch(:user)} ALL=NOPASSWD: /bin/chmod 6775 #{fetch(:nginx_log_path)}"
+        puts "#{fetch(:user)} ALL=NOPASSWD: /bin/chown #{fetch(:user)}\\:root #{fetch(:nginx_sites_enabled_path)}"
+        puts "#{fetch(:user)} ALL=NOPASSWD: /usr/sbin/service nginx *"
+        puts '#---------------------------------------------------------------'
+        info '---------------------------------------------------------------'
+      end
+      # info "#{fetch(:user)} ALL=NOPASSWD: /bin/chown deploy:root #{monit_monitrc_file}"
+    end
+
+    desc 'Generates and uploads nginx configuration for this app to the App server(s)'
+    # task :setup, :roles => :app , :except => { :no_release => true } do
+    task :setup do
+      # Will setup nginx on the application server, as single-host app/web server is used behind load balancer
+      # Nginx is used for talking over socket to puma instead of opening puma to the 'world'
+      on roles(:app) do |host|
+        info "NGINX: Setting up for puma for #{fetch(:application)} on #{host}"
+        upload! template_to_s_io(fetch(:nginx_config_template)), fetch(:nginx_remote_config)
+        if (fetch(:nginx_use_simple_auth)) || fetch(:nginx_ssl_use_simple_auth)
+          set :pw, ask('', '')
+          set :create_httpwd, ask('Create .httpasswd configuration file [Yn]', 'Y')
+          # 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(:create_httpwd)
+            set :nginx_simple_auth_password, default_pw_generator if fetch(:nginx_simple_auth_password).nil?
+            upload! template_to_s_io(fetch(:nginx_htpasswd_template)), fetch(:nginx_remote_htpasswd)
+          else
+            set :nginx_use_simple_auth, false
+            set :nginx_ssl_use_simple_auth, false
+          end
+        end
+        # create log path
+        # /var/log/nginx must be writable by 'deploy' user, usually this can be acomplished by adding the deploy user to
+        # the www-data group
+        execute :sudo, :mkdir, "-p #{fetch(:nginx_log_path)}"
+        execute :sudo, :chown, "-R #{fetch(:user)}:root #{fetch(:nginx_log_path)}"
+        execute :sudo, :chmod, "6775 #{fetch(:nginx_log_path)}"
+        execute :mkdir, "-p #{fetch(:nginx_app_log_path)}"
+      end
+    end
+
+    desc 'Enable nginx site for the application'
+    task :enable do
+      on roles(:app) do |host|
+        if test("[ ! -h #{fetch(:nginx_sites_enabled_symlink)} ]")
+          info "NGINX: Enabling application #{fetch(:application)} on #{host}"
+          # Make sure deploy user can symlink site
+          execute :sudo, :chown, "#{fetch(:user)}:root #{fetch(:nginx_sites_enabled_path)}"
+          execute :ln, "-sf #{fetch(:nginx_remote_config)} #{fetch(:nginx_sites_enabled_symlink)}"
+        else
+          info "NGINX: Already enabled application #{fetch(:application)} on #{host}"
+        end
+      end
+    end
+
+    desc 'Disable nginx site for the application'
+    task :disable do
+      on roles(:app) do |host|
+        if test("[ -h #{fetch(:nginx_sites_enabled_symlink)} ]")
+          info "NGINX: Disabling application #{fetch(:application)} on #{host}"
+          # Make sure deploy user can unsymlink site
+          execute :sudo, :chown, "#{fetch(:user)}:root #{fetch(:nginx_sites_enabled_path)}"
+          execute :rm, "-f #{fetch(:nginx_sites_enabled_symlink)}"
+        else
+          info "NGINX: Already disabled application #{fetch(:application)} on #{host}"
+        end
+      end
+    end
+
+    desc 'Purge nginx site config for the application'
+    task :purge do
+      on roles(:app) do |host|
+        info "NGINX: Purging configuration for #{fetch(:application)} on #{host}"
+        execute :rm, "-f #{fetch(:nginx_sites_enabled_symlink)}" if test("[ -h #{fetch(:nginx_sites_enabled_symlink)} ]")
+        execute :rm, "-f #{fetch(:nginx_remote_htpasswd)}"
+        execute :rm, "-f #{fetch(:nginx_remote_config)}"
+        # must restart nginx to make sure site is disabled when config is purge
+        execute :sudo, :service, 'nginx restart'
+      end
+    end
+  end
+end
+
+namespace :nginx do
+  %w(start stop restart status).each do |nginx_cmd|
+    desc "Nginx/Puma: #{nginx_cmd.capitalize}"
+    task nginx_cmd.to_sym do
+      on roles(:app) do |host|
+        info "NGINX: Performing #{nginx_cmd} for #{fetch(:application)} on #{host}"
+        execute :sudo, :service, "nginx #{nginx_cmd}"
+      end
+    end
+  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

data/lib/capistrano/tasks/nginx_config.rake

@@ -0,0 +1,63 @@
+require 'active_support'
+require 'active_support/core_ext/string/filters'
+require 'capistrano/helpers/puma/template_paths'
+require 'capistrano/helpers/base'
+include Capistrano::Helpers::Base
+
+namespace :load do
+  task :defaults do
+    # Where your nginx lives. Usually /opt/nginx or /usr/local/nginx for source compiled.
+    set :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.
+
+    set :nginx_use_simple_auth, false
+    set :nginx_simple_auth_message, 'Restricted site'
+    set :nginx_simple_auth_user, 'user'
+    set :nginx_simple_auth_password, nil # if set to nil, it will automatically be generated
+    set :nginx_simple_auth_salt, (0...8).map { ('a'..'z').to_a[rand(26)] }.join
+
+    # Server names. Defaults to application name.
+    set :server_names, proc { app_env_underscore }
+
+    # Path to the nginx erb template to be parsed before uploading to remote
+    set :nginx_config_template, File.join(Capistrano::Helpers::Puma::TemplatePaths.template_base_path, 'nginx', 'application.conf.erb') # rubocop:disable Metrics/LineLength
+
+    # Path to where your remote config will reside (I use a directory sites inside conf)
+    set :nginx_remote_config, proc { shared_path.join('config', "nginx_#{app_env_underscore}.conf") }
+
+    # Path to local htpasswd template file
+    set :nginx_htpasswd_template, File.join(Capistrano::Helpers::Puma::TemplatePaths.template_base_path, 'nginx', 'htpasswd.erb')
+
+    # Path to remote htpasswd file
+    set :nginx_remote_htpasswd, proc { shared_path.join('config', '.htpasswd') }
+
+    set :nginx_sites_enabled_symlink, proc { File.join(fetch(:nginx_sites_enabled_path), app_env_underscore) }
+
+    set :nginx_uses_http, true
+    set :nginx_uses_ssl, false
+    set :nginx_port, 80
+
+    set :nginx_log_path, proc { File.join('/var', 'log', 'nginx') }
+
+    set :nginx_app_log_path, proc { File.join(fetch(:nginx_log_path), fetch(:application).squish.downcase.gsub(/[\s|-]/, '_')) }
+
+    set :nginx_client_max_body_size, '10M'
+
+    set :nginx_ssl_port, 443
+    set :nginx_ssl_use_simple_auth, false
+    set :nginx_ssl_client_max_body_size, '10M'
+    set :nginx_ssl_public_crt, File.join('/etc', 'certs', 'server.crt')
+    set :nginx_ssl_private_key, File.join('/etc', 'certs', 'server.key')
+
+    set :nginx_puma_server_url, proc { "unix:#{fetch(:puma_socket_file)}" }
+    set :nginx_puma_server_timeout, proc { 'fail_timeout=0' }
+
+    # Supply a block of text to add to the nginx config file before hitting puma server (rewrites etc)
+    set :nginx_extra_rules, nil
+    # Same as above but for ssl
+    set :nginx_extra_rules_ssl, nil
+  end
+end

data/lib/capistrano/tasks/runit.rake

@@ -0,0 +1,179 @@
+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
+
+# require 'capistrano/runit'
+namespace :puma do
+  desc 'Setup Puma configuration'
+  task :setup do
+    on roles(:app) do
+      execute :mkdir, "-p #{fetch(:sockets_path)}" if test("[ ! -d '#{fetch(:sockets_path)}' ]")
+      execute :mkdir, "-p '#{fetch(:puma_remote_config_folder)}'" if test("[ ! -d '#{fetch(:puma_remote_config_folder)}' ]")
+      upload! template_to_s_io(fetch(:puma_config_template)), fetch(:puma_config_file)
+    end
+  end
+
+  desc 'Flush Puma sockets, as they can end up \'hanging around\''
+  task :flush_sockets do
+    on roles(:app) do
+      execute :rm, "-f '#{fetch(:puma_socket_file)}'"
+      execute :rm, "-f '#{fetch(:puma_control_file)}'"
+    end
+  end
+
+  namespace :runit do
+    desc 'Setup Puma runit-service'
+    task :setup do
+      on roles(:app) do
+        # Create runit config
+        if test("[ ! -d '#{runit_service_path(fetch(:puma_runit_service_name))}' ]")
+          execute :mkdir, "-p '#{runit_service_path(fetch(:puma_runit_service_name))}'"
+        end
+
+        upload! template_to_s_io(fetch(:puma_runit_run_template)), runit_service_run_config_file(fetch(:puma_runit_service_name)) # rubocop:disable Metrics/LineLength
+        upload! template_to_s_io(fetch(:puma_runit_finish_template)), runit_service_finish_config_file(fetch(:puma_runit_service_name)) # rubocop:disable Metrics/LineLength
+
+        # must use quit script for stop as well, to ensure quit and stop performs equally
+        if test("[ ! -d '#{runit_service_control_path(fetch(:puma_runit_service_name))}' ]")
+          execute :mkdir, "-p '#{runit_service_control_path(fetch(:puma_runit_service_name))}'"
+        end
+        upload! template_to_s_io(fetch(:puma_runit_control_q_template)), runit_service_control_file(fetch(:puma_runit_service_name), 'q') # rubocop:disable Metrics/LineLength
+        upload! template_to_s_io(fetch(:puma_runit_control_q_template)), runit_service_control_file(fetch(:puma_runit_service_name), 's') # rubocop:disable Metrics/LineLength
+
+        # Log scripts for runit service
+        if test("[ ! -d '#{runit_service_log_path(fetch(:puma_runit_service_name))}' ]")
+          execute :mkdir, "-p '#{runit_service_log_path(fetch(:puma_runit_service_name))}'"
+        end
+
+        upload! template_to_s_io(fetch(:puma_runit_log_run_template)), runit_service_log_run_file(fetch(:puma_runit_service_name)) # rubocop:disable Metrics/LineLength
+
+        # Make scripts executable
+        runit_set_executable_files(fetch(:puma_runit_service_name))
+
+        # Create log paths for the service
+        if test("[ ! -d '#{runit_var_log_service_single_service_path(fetch(:puma_runit_service_name))}' ]")
+          execute :mkdir, "-p '#{runit_var_log_service_single_service_path(fetch(:puma_runit_service_name))}'"
+        end
+      end
+    end
+
+    desc 'Enable Puma runit-service'
+    task :enable do
+      on roles(:app) do
+        enable_service(fetch(:puma_runit_service_name))
+      end
+    end
+
+    desc 'Disable Puma runit-service'
+    task :disable do
+      on roles(:app) do
+        disable_service(fetch(:puma_runit_service_name))
+      end
+    end
+
+    desc 'Start Puma runit-service'
+    task :start do
+      on roles(:app) do
+        control_service(fetch(:puma_runit_service_name), 'start')
+      end
+    end
+
+    desc 'Start Puma runit-service only ONCE (no supervision...)'
+    task :once do
+      on roles(:app) do
+        control_service(fetch(:puma_runit_service_name), 'once')
+      end
+    end
+
+    desc 'Stop Puma runit-service'
+    # :on_error => :continue  should be added when cap3 equivalent has been figured out
+    task :stop do
+      on roles(:app) do
+        # have to use force-stop on failed stop, since puma might not terminate properly depending on current
+        # 'slow' clients.
+        # will wait 30 seconds for puma to shut down, to allow it to serve any on-going requests
+        begin
+          control_service(fetch(:puma_runit_service_name), 'force-stop', '-w 30')
+        rescue
+        end
+      end
+    end
+
+    desc 'Quit the puma runit-service'
+    # :on_error => :continue  should be added when cap3 equivalent has been figured out
+    task :quit do
+      on roles(:app) do
+        control_service(fetch(:puma_runit_service_name), 'quit')
+      end
+    end
+
+    desc 'Restart Puma runit-service'
+    task :restart do
+      on roles(:app) do
+        # It is not possible to see if a restart is in progress using the pumactl tool as of now.
+
+        started    = false
+        restarting = false
+        within(current_path) do
+          a = capture(fetch(:puma_control), "-S #{fetch(:puma_state_file)} status)")
+          started = a.includes?('started')
+          restarting = a.includes?('restarting')
+        end
+
+        if (started == true) && (restarting == false)
+          info("\nRestarting puma")
+          # Send USR2 to puma in order to restart it....
+          control_service(fetch(:puma_runit_service_name), '2')
+        elsif restarting == false
+          info("\nStarting puma, (wasn't running before)")
+          control_service(fetch(:puma_runit_service_name), 'start')
+        end
+        # end
+      end
+    end
+
+    desc 'Phased Restart of Puma'
+    task :phased_restart do
+      on roles(:app) do
+        started = false
+        within(current_path) do
+          a = capture(fetch(:puma_control), "-S #{fetch(:puma_state_file)} status)")
+          started = a.includes?('started')
+        end
+
+        if started == true
+          # Send USR1 to puma in order to restart it....
+          info("\nPhased restart of puma")
+          control_service(fetch(:puma_runit_service_name), '1')
+        else
+          important("\nStarting puma, (wasn't running before)")
+          control_service(fetch(:puma_runit_service_name), 'start')
+        end
+      end
+    end
+
+    desc 'Purge Puma runit configuration'
+    # :on_error => :continue  should be added when cap3 equivalent has been figured out
+    task :purge do
+      on roles(:app) do
+        disable_service(fetch(:puma_runit_service_name))
+        purge_service(fetch(:puma_runit_service_name))
+      end
+    end
+  end
+end
+
+after 'runit:setup', 'puma:runit:setup'
+
+# enable service after update in case it has been disabled
+# Service should probably be started as well?
+after 'deploy:updated', 'puma:runit:enable'
+before 'puma:runit:setup', 'puma:flush_sockets'
+before 'puma:runit:setup', 'puma:setup'
+before 'puma:runit:quit', 'puma:runit:stop'

data/templates/monit/puma.conf.erb

@@ -1,16 +1,15 @@
 # Monit configuration for Puma
-# <% c = Capistrano::BaseHelper::get_capistrano_instance %>
-# <%= "#{c.fetch(:application)} running as #{c.fetch(:user)} in environment #{Capistrano::BaseHelper.environment}" %>
+# <%= "#{fetch(:application)} running as #{fetch(:user)} in environment #{environment}" %>
 #
-# Service name: <%= c.fetch(:puma_monit_service_name) %>
+# Service name: <%= fetch(:puma_monit_service_name) %>
 #
-check process <%= c.fetch(:puma_monit_service_name) %>
-    with pidfile <%= c.fetch(:puma_pid_file) %>
-    start program = "<%= c.fetch(:puma_monit_start_command) %>"
-    stop program = "<%= c.fetch(:puma_monit_stop_command) %>"
-    if mem is greater than <%= c.fetch(:puma_monit_memory_alert_threshold) %> then alert
-    if mem is greater than <%= c.fetch(:puma_monit_memory_restart_threshold) %> then restart
-    if cpu is greater than <%= c.fetch(:puma_monit_cpu_alert_threshold) %> then alert         
-    if cpu is greater than <%= c.fetch(:puma_monit_cpu_restart_threshold) %> then restart
+check process <%= fetch(:puma_monit_service_name) %>
+    with pidfile <%= fetch(:puma_pid_file) %>
+    start program = "<%= fetch(:puma_monit_start_command) %>"
+    stop program = "<%= fetch(:puma_monit_stop_command) %>"
+    if mem is greater than <%= fetch(:puma_monit_memory_alert_threshold) %> then alert
+    if mem is greater than <%= fetch(:puma_monit_memory_restart_threshold) %> then restart
+    if cpu is greater than <%= fetch(:puma_monit_cpu_alert_threshold) %> then alert
+    if cpu is greater than <%= fetch(:puma_monit_cpu_restart_threshold) %> then restart
 
-    group <%= c.fetch(:monit_application_group_name) %>
+    group <%= fetch(:monit_application_group_name) %>