capistrano-sidekiq 2.0.0.beta4 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5c60b9de8a0a367ebba98dad3f99cbf3cbee2cc975a42cbe56ff35a0785ee964
-  data.tar.gz: e8e4dfed5f061db2fa453215df32293469f9bffa6bc9ff0fa1917cef45b31765
+  metadata.gz: 9b617c393c8abe0fd6379444f85885ae53eab75f4dacb33a186b6b4d7d097d97
+  data.tar.gz: af4b161e8f6131d85f6c12e1795f72bdec58d967dde832b9f1953efaf5245107
 SHA512:
-  metadata.gz: 50b2da50e06404fcd6298d1be4a0f1df560e519c990ed9a92ae5feff1a90addfc359b91e0f17fa9d5032621d8648f91bd2c4b6a36ebac86cdfd014ee2bf67094
-  data.tar.gz: 4892c095fa04edddea3474e974a95dcb219490b26950a82793035471b84e362527cd45988cf945279c4118ef768c56fb471d94ec7f729e80129f4a5342e9f716
+  metadata.gz: 6d1c9c37c0b8c61bbff72a2c1dc8fe236f7268e285771a0da2e8ab0ad20662b38643dd401448c203165e4311a60d093b19b49af484e57fba02516a83adaad49b
+  data.tar.gz: 0c63285e974b438b066057e6b7090b8411b55212b11439ff811ab2dfb8c5ebb5f97a10098989fa11ac87e8dae37251c3a23ed324006327acef0ea34fc59cdf53

data/.tool-versions

@@ -1 +1 @@
-ruby 2.6.5
+ruby 3.1.2

data/README.md

@@ -20,15 +20,15 @@ And then execute:
     require 'capistrano/sidekiq'
     install_plugin Capistrano::Sidekiq  # Default sidekiq tasks
     # Then select your service manager
-    install_plugin Capistrano::Sidekiq::Systemd 
-    # or  
+    install_plugin Capistrano::Sidekiq::Systemd
+    # or
     install_plugin Capistrano::Sidekiq::Upstart  # tests needed
-    # or  
+    # or
     install_plugin Capistrano::Sidekiq::Monit  # tests needed
 ```
 
 
-Configurable options, shown here with defaults:
+Configurable options - Please ensure you check your version's branch for the available settings - shown here with defaults:
 
 ```ruby
 :sidekiq_roles => :app
@@ -36,8 +36,19 @@ Configurable options, shown here with defaults:
 :sidekiq_pid => File.join(shared_path, 'tmp', 'pids', 'sidekiq.pid') # ensure this path exists in production before deploying.
 :sidekiq_env => fetch(:rack_env, fetch(:rails_env, fetch(:stage)))
 :sidekiq_log => File.join(shared_path, 'log', 'sidekiq.log')
+# single config
+:sidekiq_config => 'config/sidekiq.yml'
+# per process config - process 1, process 2,... etc.
+:sidekiq_config => [
+    'config/sidekiq_config1.yml',
+    'config/sidekiq_config2.yml'
+]
+:sidekiq_concurrency => 25
+:sidekiq_queue => %w(default high low)
+:sidekiq_processes => 1 # number of systemd processes you want to start
 
 # sidekiq systemd options
+:sidekiq_service_templates_path => 'config/deploy/templates' # to be used if a custom template is needed (filaname should be #{fetch(:sidekiq_service_unit_name)}.service.capistrano.erb or sidekiq.service.capistrano.erb
 :sidekiq_service_unit_name => 'sidekiq'
 :sidekiq_service_unit_user => :user # :system
 :sidekiq_enable_lingering => true
@@ -50,10 +61,11 @@ Configurable options, shown here with defaults:
 :monit_bin => '/usr/bin/monit'
 :sidekiq_monit_default_hooks => true
 :sidekiq_monit_group => nil
-:sidekiq_service_name => "sidekiq_#{fetch(:application)}" 
+:sidekiq_service_name => "sidekiq_#{fetch(:application)}"
 
 :sidekiq_user => nil #user to run sidekiq as
 ```
+See `capistrano/sidekiq/helpers.rb` for other undocumented configuration settings.
 
 ## Known issues with Capistrano 3
 
@@ -86,6 +98,14 @@ If your deploy user has no need in `sudo` for using monit, you can disable it as
 set :sidekiq_monit_use_sudo, false
 ```
 
+## Configuring the log files on systems with less recent Systemd versions
+
+The template used by this project assumes a recent version of Systemd (v240+, e.g. Ubuntu 20.04).
+
+On systems with a less recent version, the `append:` functionality is not supported, and the Sidekiq log messages are sent to the syslog.
+
+It's possible to workaround this limitation by configuring the system logger to filter the Sidekiq messages; see [wiki](/../../wiki/Configuring-append-mode-log-files-via-Syslog-NG).
+
 ## Contributing
 
 1. Fork it

data/capistrano-sidekiq.gemspec

@@ -1,4 +1,3 @@
-# coding: utf-8
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'capistrano/sidekiq/version'

data/lib/capistrano/sidekiq/helpers.rb

@@ -0,0 +1,60 @@
+module Capistrano
+  module Sidekiq::Helpers
+
+    def sidekiq_require
+      if fetch(:sidekiq_require)
+        "--require #{fetch(:sidekiq_require)}"
+      end
+    end
+
+    def sidekiq_config
+      if fetch(:sidekiq_config)
+        "--config #{fetch(:sidekiq_config)}"
+      end
+    end
+
+    def sidekiq_concurrency
+      if fetch(:sidekiq_concurrency)
+        "--concurrency #{fetch(:sidekiq_concurrency)}"
+      end
+    end
+
+    def sidekiq_queues
+      Array(fetch(:sidekiq_queue)).map do |queue|
+        "--queue #{queue}"
+      end.join(' ')
+    end
+
+    def sidekiq_logfile
+      fetch(:sidekiq_log)
+    end
+
+    def switch_user(role)
+      su_user = sidekiq_user(role)
+      if su_user == role.user
+        yield
+      else
+        as su_user do
+          yield
+        end
+      end
+    end
+
+    def sidekiq_user(role = nil)
+      if role.nil?
+        fetch(:sidekiq_user)
+      else
+        properties = role.properties
+        properties.fetch(:sidekiq_user) || # local property for sidekiq only
+          fetch(:sidekiq_user) ||
+          properties.fetch(:run_as) || # global property across multiple capistrano gems
+          role.user
+      end
+    end
+
+    def expanded_bundle_path
+      backend.capture(:echo, SSHKit.config.command_map[:bundle]).strip
+    end
+
+  end
+end

data/lib/capistrano/sidekiq/monit.rb

@@ -1,5 +1,7 @@
 module Capistrano
   class Sidekiq::Monit < Capistrano::Plugin
+    include Sidekiq::Helpers
+
     def set_defaults
       set_if_empty :monit_bin, '/usr/bin/monit'
       set_if_empty :sidekiq_monit_conf_dir, '/etc/monit/conf.d'

data/lib/capistrano/sidekiq/systemd.rb

@@ -1,10 +1,13 @@
 module Capistrano
   class Sidekiq::Systemd < Capistrano::Plugin
+    include Sidekiq::Helpers
+
     def set_defaults
       set_if_empty :sidekiq_service_unit_name, 'sidekiq'
       set_if_empty :sidekiq_service_unit_user, :user # :system
       set_if_empty :sidekiq_enable_lingering, true
       set_if_empty :sidekiq_lingering_user, nil
+      set_if_empty :sidekiq_service_templates_path, 'config/deploy/templates'
     end
 
     def define_tasks

data/lib/capistrano/sidekiq/upstart.rb

@@ -1,5 +1,7 @@
 module Capistrano
   class Sidekiq::Upstart < Capistrano::Plugin
+    include Sidekiq::Helpers
+
     def set_defaults
       set_if_empty :sidekiq_service_unit_name, 'sidekiq'
     end

data/lib/capistrano/sidekiq/version.rb

@@ -1,3 +1,3 @@
 module Capistrano
-  SidekiqVERSION = '2.0.0.beta4'
+  SidekiqVERSION = '2.1.0'
 end

data/lib/capistrano/sidekiq.rb

@@ -25,6 +25,7 @@ module Capistrano
   end
 end
 
+require_relative 'sidekiq/helpers'
 require_relative 'sidekiq/systemd'
 require_relative 'sidekiq/upstart'
 require_relative 'sidekiq/monit'

data/lib/capistrano/tasks/monit.rake

@@ -1,14 +1,4 @@
-namespace :load do
-  task :defaults do
-    set :sidekiq_monit_conf_dir, '/etc/monit/conf.d'
-    set :sidekiq_monit_conf_file, -> { "#{sidekiq_service_name}.conf" }
-    set :sidekiq_monit_use_sudo, true
-    set :monit_bin, '/usr/bin/monit'
-    set :sidekiq_monit_default_hooks, true
-    set :sidekiq_monit_templates_path, 'config/deploy/templates'
-    set :sidekiq_monit_group, nil
-  end
-end
+git_plugin = self
 
 namespace :deploy do
   before :starting, :check_sidekiq_monit_hooks do
@@ -20,7 +10,6 @@ end
 
 namespace :sidekiq do
   namespace :monit do
-
     task :add_default_hooks do
       before 'deploy:updating',  'sidekiq:monit:unmonitor'
       after  'deploy:published', 'sidekiq:monit:monitor'
@@ -30,24 +19,26 @@ namespace :sidekiq do
     task :config do
       on roles(fetch(:sidekiq_roles)) do |role|
         @role = role
-        upload_sidekiq_template 'sidekiq_monit', "#{fetch(:tmp_dir)}/monit.conf", @role
+        git_plugin.upload_sidekiq_template 'sidekiq_monit', "#{fetch(:tmp_dir)}/monit.conf", @role
 
-        mv_command = "mv #{fetch(:tmp_dir)}/monit.conf #{fetch(:sidekiq_monit_conf_dir)}/#{fetch(:sidekiq_monit_conf_file)}"
-        sudo_if_needed mv_command
+        git_plugin.switch_user(role) do
+          mv_command = "mv #{fetch(:tmp_dir)}/monit.conf #{fetch(:sidekiq_monit_conf_dir)}/#{fetch(:sidekiq_monit_conf_file)}"
 
-        sudo_if_needed "#{fetch(:monit_bin)} reload"
+          git_plugin.sudo_if_needed mv_command
+          git_plugin.sudo_if_needed "#{fetch(:monit_bin)} reload"
+        end
       end
     end
 
     desc 'Monitor Sidekiq monit-service'
     task :monitor do
-      on roles(fetch(:sidekiq_roles)) do
-        fetch(:sidekiq_processes).times do |idx|
+      on roles(fetch(:sidekiq_roles)) do |role|
+        git_plugin.switch_user(role) do
           begin
-            sudo_if_needed "#{fetch(:monit_bin)} monitor #{sidekiq_service_name(idx)}"
+            git_plugin.sudo_if_needed "#{fetch(:monit_bin)} monitor #{git_plugin.sidekiq_service_name}"
           rescue
             invoke 'sidekiq:monit:config'
-            sudo_if_needed "#{fetch(:monit_bin)} monitor #{sidekiq_service_name(idx)}"
+            git_plugin.sudo_if_needed "#{fetch(:monit_bin)} monitor #{git_plugin.sidekiq_service_name}"
           end
         end
       end
@@ -55,114 +46,82 @@ namespace :sidekiq do
 
     desc 'Unmonitor Sidekiq monit-service'
     task :unmonitor do
-      on roles(fetch(:sidekiq_roles)) do
-        fetch(:sidekiq_processes).times do |idx|
+      on roles(fetch(:sidekiq_roles)) do |role|
+        git_plugin.switch_user(role) do
           begin
-            sudo_if_needed "#{fetch(:monit_bin)} unmonitor #{sidekiq_service_name(idx)}"
+            git_plugin.sudo_if_needed "#{fetch(:monit_bin)} unmonitor #{git_plugin.sidekiq_service_name}"
           rescue
             # no worries here
           end
         end
       end
     end
+  end
 
-    desc 'Start Sidekiq monit-service'
-    task :start do
-      on roles(fetch(:sidekiq_roles)) do
-        fetch(:sidekiq_processes).times do |idx|
-          sudo_if_needed "#{fetch(:monit_bin)} start #{sidekiq_service_name(idx)}"
-        end
-      end
-    end
-
-    desc 'Stop Sidekiq monit-service'
-    task :stop do
-      on roles(fetch(:sidekiq_roles)) do
-        fetch(:sidekiq_processes).times do |idx|
-          sudo_if_needed "#{fetch(:monit_bin)} stop #{sidekiq_service_name(idx)}"
-        end
-      end
-    end
-
-    desc 'Restart Sidekiq monit-service'
-    task :restart do
-      on roles(fetch(:sidekiq_roles)) do
-        fetch(:sidekiq_processes).times do |idx|
-          sudo_if_needed"#{fetch(:monit_bin)} restart #{sidekiq_service_name(idx)}"
-        end
-      end
-    end
-
-    def sidekiq_service_name(index=nil)
-      fetch(:sidekiq_service_name, "sidekiq_#{fetch(:application)}_#{fetch(:sidekiq_env)}") + (index ? "_#{index}" : '')
-    end
-
-    def sidekiq_config
-      if fetch(:sidekiq_config)
-        "--config #{fetch(:sidekiq_config)}"
-      end
-    end
-
-    def sidekiq_concurrency
-      if fetch(:sidekiq_concurrency)
-        "--concurrency #{fetch(:sidekiq_concurrency)}"
+  desc 'Start Sidekiq monit-service'
+  task :start do
+    on roles(fetch(:sidekiq_roles)) do |role|
+      git_plugin.switch_user(role) do
+        git_plugin.sudo_if_needed "#{fetch(:monit_bin)} start #{git_plugin.sidekiq_service_name}"
       end
     end
+  end
 
-    def sidekiq_queues
-      Array(fetch(:sidekiq_queue)).map do |queue|
-        "--queue #{queue}"
-      end.join(' ')
-    end
-
-    def sidekiq_logfile
-      if fetch(:sidekiq_log)
-        "--logfile #{fetch(:sidekiq_log)}"
+  desc 'Stop Sidekiq monit-service'
+  task :stop do
+    on roles(fetch(:sidekiq_roles)) do |role|
+      git_plugin.switch_user(role) do
+        git_plugin.sudo_if_needed "#{fetch(:monit_bin)} stop #{git_plugin.sidekiq_service_name}"
       end
     end
+  end
 
-    def sidekiq_require
-      if fetch(:sidekiq_require)
-        "--require #{fetch(:sidekiq_require)}"
-      end
+  desc 'Restart Sidekiq monit-service'
+  task :restart do
+    on roles(fetch(:sidekiq_roles)) do |role|
+      git_plugin.sudo_if_needed "#{fetch(:monit_bin)} restart #{git_plugin.sidekiq_service_name}"
     end
+  end
 
-    def sidekiq_options_per_process
-      fetch(:sidekiq_options_per_process) || []
-    end
+  def sidekiq_service_name
+    fetch(:sidekiq_service_name, "sidekiq_#{fetch(:application)}_#{fetch(:sidekiq_env)}")
+  end
 
-    def sudo_if_needed(command)
-      send(use_sudo? ? :sudo : :execute, command)
+  def sudo_if_needed(command)
+    if use_sudo?
+      backend.execute :sudo, command
+    else
+      backend.execute command
     end
+  end
 
-    def use_sudo?
-      fetch(:sidekiq_monit_use_sudo)
-    end
+  def use_sudo?
+    fetch(:sidekiq_monit_use_sudo)
+  end
 
-    def upload_sidekiq_template(from, to, role)
-      template = sidekiq_template(from, role)
-      upload!(StringIO.new(ERB.new(template).result(binding)), to)
-    end
+  def upload_sidekiq_template(from, to, role)
+    template = sidekiq_template(from, role)
+    backend.upload!(StringIO.new(ERB.new(template).result(binding)), to)
+  end
 
-    def sidekiq_template(name, role)
-      local_template_directory = fetch(:sidekiq_monit_templates_path)
+  def sidekiq_template(name, role)
+    local_template_directory = fetch(:sidekiq_monit_templates_path)
 
-      search_paths = [
-        "#{name}-#{role.hostname}-#{fetch(:stage)}.erb",
-        "#{name}-#{role.hostname}.erb",
-        "#{name}-#{fetch(:stage)}.erb",
-        "#{name}.erb"
-      ].map { |filename| File.join(local_template_directory, filename) }
+    search_paths = [
+      "#{name}-#{role.hostname}-#{fetch(:stage)}.erb",
+      "#{name}-#{role.hostname}.erb",
+      "#{name}-#{fetch(:stage)}.erb",
+      "#{name}.erb"
+    ].map { |filename| File.join(local_template_directory, filename) }
 
-      global_search_path = File.expand_path(
-        File.join(*%w[.. .. .. generators capistrano sidekiq monit templates], "#{name}.conf.erb"),
-        __FILE__
-      )
+    global_search_path = File.expand_path(
+      File.join(*%w[.. .. .. generators capistrano sidekiq monit templates], "#{name}.conf.erb"),
+      __FILE__
+    )
 
-      search_paths << global_search_path
+    search_paths << global_search_path
 
-      template_path = search_paths.detect { |path| File.file?(path) }
-      File.read(template_path)
-    end
+    template_path = search_paths.detect { |path| File.file?(path) }
+    File.read(template_path)
   end
 end

data/lib/capistrano/tasks/sidekiq.rake

@@ -6,15 +6,9 @@ end
 
 namespace :sidekiq do
   task :add_default_hooks do
-    after 'deploy:starting', 'sidekiq:quiet'
+    after 'deploy:starting', 'sidekiq:quiet' if Rake::Task.task_defined?('sidekiq:quiet')
     after 'deploy:updated', 'sidekiq:stop'
     after 'deploy:published', 'sidekiq:start'
     after 'deploy:failed', 'sidekiq:restart'
   end
-
-  desc 'Restart sidekiq'
-  task :restart do
-    invoke! 'sidekiq:stop'
-    invoke! 'sidekiq:start'
-  end
 end

data/lib/capistrano/tasks/systemd.rake

@@ -1,41 +1,73 @@
 git_plugin = self
 
 namespace :sidekiq do
-  desc 'Quiet sidekiq (stop fetching new tasks from Redis)'
-  task :quiet do
-    on roles fetch(:sidekiq_roles) do |role|
-      git_plugin.switch_user(role) do
-        if fetch(:sidekiq_service_unit_user) == :system
-          execute :sudo, :systemctl, "reload", fetch(:sidekiq_service_unit_name), raise_on_non_zero_exit: false
-        else
-          execute :systemctl, "--user", "reload", fetch(:sidekiq_service_unit_name), raise_on_non_zero_exit: false
+
+  standard_actions = {
+    start: 'Start Sidekiq',
+    stop: 'Stop Sidekiq (graceful shutdown within timeout, put unfinished tasks back to Redis)',
+    status: 'Get Sidekiq Status'
+  }
+  standard_actions.each do |command, description|
+    desc description
+    task command do
+      on roles fetch(:sidekiq_roles) do |role|
+        git_plugin.switch_user(role) do
+          git_plugin.systemctl_command(command)
         end
       end
     end
   end
 
-  desc 'Stop sidekiq (graceful shutdown within timeout, put unfinished tasks back to Redis)'
-  task :stop do
+  desc 'Restart Sidekiq (Quiet, Wait till workers finish or 30 seconds, Stop, Start)'
+  task :restart do
     on roles fetch(:sidekiq_roles) do |role|
       git_plugin.switch_user(role) do
-        if fetch(:sidekiq_service_unit_user) == :system
-          execute :sudo, :systemctl, "stop", fetch(:sidekiq_service_unit_name)
-        else
-          execute :systemctl, "--user", "stop", fetch(:sidekiq_service_unit_name)
+        git_plugin.quiet_sidekiq
+        git_plugin.process_block do |process|
+          start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          running = nil
+
+          # get running workers
+          while (running.nil? || running > 0) && git_plugin.duration(start_time) < 30 do
+            command_args =
+            if fetch(:sidekiq_service_unit_user) == :system
+              [:sudo, 'systemd-cgls']
+            else
+              ['systemd-clgs', '--user']
+            end
+            # need to pipe through tr -cd... to strip out systemd colors or you
+            # get log error messages for non UTF-8 characters.
+            command_args.push(
+              '-u', "#{git_plugin.sidekiq_service_unit_name(process: process)}.service",
+              '|', 'tr -cd \'\11\12\15\40-\176\''
+            )
+            status = capture(*command_args, raise_on_non_zero_exit: false)
+            status_match = status.match(/\[(?<running>\d+) of (?<total>\d+) busy\]/)
+            break unless status_match
+
+            running = status_match[:running]&.to_i
+
+            colors = SSHKit::Color.new($stdout)
+            if running.zero?
+              info colors.colorize("✔ Process ##{process}: No running workers. Shutting down for restart!", :green)
+            else
+              info colors.colorize("⧗ Process ##{process}: Waiting for #{running} workers.", :yellow)
+              sleep(1)
+            end
+          end
+
+          git_plugin.systemctl_command(:stop, process: process)
+          git_plugin.systemctl_command(:start, process: process)
         end
       end
     end
   end
 
-  desc 'Start sidekiq'
-  task :start do
+  desc 'Quiet Sidekiq (stop fetching new tasks from Redis)'
+  task :quiet do
     on roles fetch(:sidekiq_roles) do |role|
       git_plugin.switch_user(role) do
-        if fetch(:sidekiq_service_unit_user) == :system
-          execute :sudo, :systemctl, 'start', fetch(:sidekiq_service_unit_name)
-        else
-          execute :systemctl, '--user', 'start', fetch(:sidekiq_service_unit_name)
-        end
+        git_plugin.quiet_sidekiq
       end
     end
   end
@@ -45,26 +77,35 @@ namespace :sidekiq do
     on roles fetch(:sidekiq_roles) do |role|
       git_plugin.switch_user(role) do
         git_plugin.create_systemd_template
-        if fetch(:sidekiq_service_unit_user) == :system
-          execute :sudo, :systemctl, "enable", fetch(:sidekiq_service_unit_name)
-        else
-          execute :systemctl, "--user", "enable", fetch(:sidekiq_service_unit_name)
-          execute :loginctl, "enable-linger", fetch(:sidekiq_lingering_user) if fetch(:sidekiq_enable_lingering)
+        if git_plugin.config_per_process?
+          git_plugin.process_block do |process|
+            git_plugin.create_systemd_config_symlink(process)
+          end
+        end
+        git_plugin.systemctl_command(:enable)
+
+        if fetch(:sidekiq_service_unit_user) != :system && fetch(:sidekiq_enable_lingering)
+          execute :loginctl, "enable-linger", fetch(:sidekiq_lingering_user)
         end
       end
     end
   end
 
-  desc 'UnInstall systemd sidekiq service'
+  desc 'Uninstall systemd sidekiq service'
   task :uninstall do
     on roles fetch(:sidekiq_roles) do |role|
       git_plugin.switch_user(role) do
-        if fetch(:sidekiq_service_unit_user) == :system
-          execute :sudo, :systemctl, "disable", fetch(:sidekiq_service_unit_name)
-        else
-          execute :systemctl, "--user", "disable", fetch(:sidekiq_service_unit_name)
+        git_plugin.systemctl_command(:stop)
+        git_plugin.systemctl_command(:disable)
+        if git_plugin.config_per_process?
+          git_plugin.process_block do |process|
+            git_plugin.delete_systemd_config_symlink(process)
+          end
         end
-        execute :rm, '-f', File.join(fetch(:service_unit_path, fetch_systemd_unit_path), fetch(:sidekiq_service_unit_name))
+        execute :sudo, :rm, '-f', File.join(
+          fetch(:service_unit_path, git_plugin.fetch_systemd_unit_path),
+          git_plugin.sidekiq_service_file_name
+        )
       end
     end
   end
@@ -87,7 +128,10 @@ namespace :sidekiq do
   end
 
   def compiled_template
+    local_template_directory = fetch(:sidekiq_service_templates_path)
     search_paths = [
+      File.join(local_template_directory, "#{fetch(:sidekiq_service_unit_name)}.service.capistrano.erb"),
+      File.join(local_template_directory, 'sidekiq.service.capistrano.erb'),
       File.expand_path(
           File.join(*%w[.. .. .. generators capistrano sidekiq systemd templates sidekiq.service.capistrano.erb]),
           __FILE__
@@ -101,23 +145,78 @@ namespace :sidekiq do
   def create_systemd_template
     ctemplate = compiled_template
     systemd_path = fetch(:service_unit_path, fetch_systemd_unit_path)
+    systemd_file_name = File.join(systemd_path, sidekiq_service_file_name)
 
     if fetch(:sidekiq_service_unit_user) == :user
       backend.execute :mkdir, "-p", systemd_path
     end
-    backend.upload!(
-        StringIO.new(ctemplate),
-        "/tmp/#{fetch :sidekiq_service_unit_name}.service"
-    )
+
+    temp_file_name = File.join('/tmp', sidekiq_service_file_name)
+    backend.upload!(StringIO.new(ctemplate), temp_file_name)
     if fetch(:sidekiq_service_unit_user) == :system
-      backend.execute :sudo, :mv, "/tmp/#{fetch :sidekiq_service_unit_name}.service", "#{systemd_path}/#{fetch :sidekiq_service_unit_name}.service"
+      backend.execute :sudo, :mv, temp_file_name, systemd_file_name
       backend.execute :sudo, :systemctl, "daemon-reload"
     else
-      backend.execute :sudo, :mv, "/tmp/#{fetch :sidekiq_service_unit_name}.service", "#{systemd_path}/#{fetch :sidekiq_service_unit_name}.service"
+      backend.execute :mv, temp_file_name, systemd_file_name
       backend.execute :systemctl, "--user", "daemon-reload"
     end
   end
 
+  def create_systemd_config_symlink(process)
+    config = fetch(:sidekiq_config)
+    return unless config
+
+    process_config = config[process - 1]
+    if process_config.nil?
+      backend.error(
+        "No configuration for Process ##{process} found. "\
+        'Please make sure you have 1 item in :sidekiq_config for each process.'
+      )
+      exit 1
+    end
+
+    base_path = fetch(:deploy_to)
+    config_link_base_path = File.join(base_path, 'shared', 'sidekiq_systemd')
+    config_link_path = File.join(
+      config_link_base_path, sidekiq_systemd_config_name(process)
+    )
+    process_config_path = File.join(base_path, 'current', process_config)
+
+    backend.execute :mkdir, '-p', config_link_base_path
+    backend.execute :ln, '-sf', process_config_path, config_link_path
+  end
+
+  def delete_systemd_config_symlink(process)
+    config_link_path = File.join(
+      fetch(:deploy_to),  'shared', 'sidekiq_systemd',
+      sidekiq_systemd_config_name(process)
+    )
+    backend.execute :rm, config_link_path, raise_on_non_zero_exit: false
+  end
+
+  def systemctl_command(*args, process: nil)
+    execute_array =
+      if fetch(:sidekiq_service_unit_user) == :system
+        [:sudo, :systemctl]
+      else
+        [:systemctl, '--user']
+      end
+
+    if process
+      execute_array.push(
+        *args, sidekiq_service_unit_name(process: process)
+        ).flatten
+      backend.execute(*execute_array, raise_on_non_zero_exit: false)
+    else
+      execute_array.push(*args, sidekiq_service_unit_name).flatten
+      backend.execute(*execute_array, raise_on_non_zero_exit: false)
+    end
+  end
+
+  def quiet_sidekiq
+    systemctl_command(:kill, '-s', :TSTP)
+  end
+
   def switch_user(role)
     su_user = sidekiq_user
     if su_user != role.user
@@ -132,4 +231,70 @@ namespace :sidekiq do
   def sidekiq_user
     fetch(:sidekiq_user, fetch(:run_as))
   end
+
+  def sidekiq_config
+    config = fetch(:sidekiq_config)
+    return unless config
+
+    if config_per_process?
+      config = File.join(
+        fetch(:deploy_to), 'shared', 'sidekiq_systemd',
+        sidekiq_systemd_config_name
+      )
+      "--config #{config}"
+    else
+      "--config #{config}"
+    end
+  end
+
+  def sidekiq_concurrency
+    if fetch(:sidekiq_concurrency)
+      "--concurrency #{fetch(:sidekiq_concurrency)}"
+    end
+  end
+
+  def sidekiq_processes
+    fetch(:sidekiq_processes, 1)
+  end
+
+  def sidekiq_queues
+    Array(fetch(:sidekiq_queue)).map do |queue|
+      "--queue #{queue}"
+    end.join(' ')
+  end
+
+  def sidekiq_service_file_name
+    "#{fetch(:sidekiq_service_unit_name)}@.service"
+  end
+
+  def sidekiq_service_unit_name(process: nil)
+    if process
+      "#{fetch(:sidekiq_service_unit_name)}@#{process}"
+    else
+      "#{fetch(:sidekiq_service_unit_name)}@{1..#{sidekiq_processes}}"
+    end
+  end
+
+  # process = 1 | sidekiq_systemd_1.yaml
+  # process = nil | sidekiq_systemd_%i.yaml
+  def sidekiq_systemd_config_name(process = nil)
+    file_name = 'sidekiq_systemd_'
+    file_name << (process&.to_s || '%i')
+    "#{file_name}.yaml"
+  end
+
+  def config_per_process?
+    fetch(:sidekiq_config).is_a?(Array)
+  end
+
+  def process_block
+    (1..sidekiq_processes).each do |process|
+      yield(process)
+    end
+  end
+
+  def duration(start_time)
+    Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time
+  end
+
 end

data/lib/capistrano/tasks/upstart.rake

@@ -1,9 +1,13 @@
+git_plugin = self
+
+SUPPRESS_FAILURE = %w[|| echo NO_RUNNING_INSTANCE].freeze
+
 namespace :sidekiq do
   desc 'Quiet sidekiq (stop fetching new tasks from Redis)'
   task :quiet do
     on roles fetch(:sidekiq_roles) do |role|
       git_plugin.switch_user(role) do
-        sudo :service, fetch(:sidekiq_service_unit_name), :reload
+        sudo :service, fetch(:sidekiq_service_unit_name), :reload, *SUPPRESS_FAILURE
       end
     end
   end
@@ -12,7 +16,7 @@ namespace :sidekiq do
   task :stop do
     on roles fetch(:sidekiq_roles) do |role|
       git_plugin.switch_user(role) do
-        sudo :service, fetch(:sidekiq_service_unit_name), :stop
+        sudo :service, fetch(:sidekiq_service_unit_name), :stop, *SUPPRESS_FAILURE
       end
     end
   end
@@ -26,22 +30,76 @@ namespace :sidekiq do
     end
   end
 
-  def switch_user(role)
-    su_user = sidekiq_user(role)
-    if su_user == role.user
-      yield
-    else
-      as su_user do
-        yield
+  desc 'Install upstart sidekiq service'
+  task :install do
+    on roles fetch(:sidekiq_roles) do |role|
+      git_plugin.switch_user(role) do
+        git_plugin.create_upstart_template
+      end
+    end
+  end
+
+  desc 'UnInstall upstart sidekiq service'
+  task :uninstall do
+    on roles fetch(:sidekiq_roles) do |role|
+      git_plugin.switch_user(role) do
+        execute :rm, '-f', File.join(fetch(:service_unit_path, fetch_upstart_unit_path), fetch(:sidekiq_service_unit_name))
       end
     end
   end
 
-  def sidekiq_user(role)
-    properties = role.properties
-    properties.fetch(:sidekiq_user) || # local property for sidekiq only
-        fetch(:sidekiq_user) ||
-        properties.fetch(:run_as) || # global property across multiple capistrano gems
-        role.user
+  desc 'Generate service_locally'
+  task :generate_service_locally do
+    run_locally do
+      File.write('sidekiq.conf', git_plugin.compiled_template)
+    end
   end
+
+  def fetch_upstart_unit_path
+    if fetch(:sidekiq_service_unit_user) == :system
+      # if the path is not standard `set :service_unit_path`
+      "/etc/init"
+    else
+      home_dir = backend.capture :pwd
+      File.join(home_dir, '.config', 'upstart')
+    end
+  end
+
+  def compiled_template
+    search_paths = [
+      File.expand_path(
+        File.join(*%w[.. .. .. generators capistrano sidekiq upstart templates sidekiq.conf.erb]),
+        __FILE__
+      ),
+    ]
+    template_path = search_paths.detect { |path| File.file?(path) }
+    template = File.read(template_path)
+    ERB.new(template).result(binding)
+  end
+
+  def create_upstart_template
+    ctemplate = compiled_template
+    upstart_path = fetch(:service_unit_path, fetch_upstart_unit_path)
+
+    if fetch(:sidekiq_service_unit_user) != :system
+      backend.execute :mkdir, "-p", upstart_path
+    end
+    conf_filename = "#{fetch :sidekiq_service_unit_name}.conf"
+    backend.upload!(
+      StringIO.new(ctemplate),
+      "/tmp/#{conf_filename}"
+    )
+    if fetch(:sidekiq_service_unit_user) == :system
+      backend.execute :sudo, :mv, "/tmp/#{conf_filename}", "#{upstart_path}/#{conf_filename}"
+      backend.execute :sudo, :initctl,  'reload-configuration'
+    else
+      backend.execute :sudo, :mv, "/tmp/#{conf_filename}", "#{upstart_path}/#{conf_filename}"
+      #backend.execute :sudo, :initctl,  'reload-configuration' #TODO
+    end
+  end
+
+  def num_workers
+    fetch(:sidekiq_upstart_num_workers, nil)
+  end
+
 end

data/lib/generators/capistrano/sidekiq/monit/templates/sidekiq_monit.conf.erb

@@ -1,10 +1,6 @@
 # Monit configuration for Sidekiq :  <%= fetch(:application) %>
-<% pid_files.each_with_index do |pid_file, idx| %>
-check process <%= sidekiq_service_name(idx) %>
-  with pidfile "<%= pid_file %>"
-  start program = "/bin/su - <%= sidekiq_user(@role) %> -c 'cd <%= current_path %> && <%= SSHKit.config.command_map[:sidekiq] %> <%= sidekiq_config %> --index <%= idx %> --pidfile <%= pid_file %> --environment <%= fetch(:sidekiq_env) %> <%= sidekiq_concurrency %> <%= sidekiq_logfile %> <%= sidekiq_require %> <%= sidekiq_queues %> <%= sidekiq_options_per_process[idx] %> -d'" with timeout 30 seconds
-
-  stop program = "/bin/su - <%= sidekiq_user(@role) %> -c 'cd <%= current_path %> && <%= SSHKit.config.command_map[:sidekiqctl] %> stop <%= pid_file %>'" with timeout <%= fetch(:sidekiq_timeout).to_i + 10  %> seconds
+  check process <%= sidekiq_service_name %>
+  matching 'sidekiq .* <%= fetch(:full_app_name) %>'
+  start program = "/bin/su - <%= sidekiq_user(role) %> -c 'cd <%= current_path %> && <%= SSHKit.config.command_map[:bundle] %> exec sidekiq -e <%= fetch(:sidekiq_env) %> <%= sidekiq_config %> <%= sidekiq_concurrency %> <%= sidekiq_require %> <%= sidekiq_queues %> <%= sidekiq_logfile ? ">> #{sidekiq_logfile} 2>&1" : nil %> &'" with timeout 30 seconds
+  stop program = "/bin/su - <%= sidekiq_user(role) %> -c 'ps -ax | grep "<%= "sidekiq .* #{fetch(:full_app_name)}" %>" | grep -v grep | awk "{print \$1}" | xargs --no-run-if-empty kill'" with timeout <%= fetch(:sidekiq_timeout).to_i + 10  %> seconds
   group <%= fetch(:sidekiq_monit_group) || fetch(:application) %>-sidekiq
-
-<% end %>

data/lib/generators/capistrano/sidekiq/systemd/templates/sidekiq.service.capistrano.erb

@@ -1,25 +1,69 @@
+# Source: https://github.com/mperham/sidekiq/blob/master/examples/systemd/sidekiq.service
+#
+# This file tells systemd how to run Sidekiq as a 24/7 long-running daemon.
+#
+# Customize this file based on your bundler location, app directory, etc.
+# Customize and copy this into /usr/lib/systemd/system (CentOS) or /lib/systemd/system (Ubuntu).
+# Then run:
+#   - systemctl enable sidekiq
+#   - systemctl {start,stop,restart} sidekiq
+#
+# This file corresponds to a single Sidekiq process.  Add multiple copies
+# to run multiple processes (sidekiq-1, sidekiq-2, etc).
+#
+# Use `journalctl -u sidekiq -rn 100` to view the last 100 lines of log output.
+#
 [Unit]
 Description=sidekiq for <%= "#{fetch(:application)} (#{fetch(:stage)})" %>
+# start us only once the network and logging subsystems are available,
+# consider adding redis-server.service if Redis is local and systemd-managed.
 After=syslog.target network.target
 
+# See these pages for lots of options:
+#
+#   https://www.freedesktop.org/software/systemd/man/systemd.service.html
+#   https://www.freedesktop.org/software/systemd/man/systemd.exec.html
+#
+# THOSE PAGES ARE CRITICAL FOR ANY LINUX DEVOPS WORK; read them multiple
+# times! systemd is a critical tool for all developers to know and understand.
+#
 [Service]
-Type=simple
+#
+#      !!!!  !!!!  !!!!
+#
+# As of v6.0.6, Sidekiq automatically supports systemd's `Type=notify` and watchdog service
+# monitoring. If you are using an earlier version of Sidekiq, change this to `Type=simple`
+# and remove the `WatchdogSec` line.
+#
+#      !!!!  !!!!  !!!!
+#
+Type=notify
+# If your Sidekiq process locks up, systemd's watchdog will restart it within seconds.
+WatchdogSec=10
+
 WorkingDirectory=<%= File.join(fetch(:deploy_to), 'current') %>
-ExecStart=<%= SSHKit.config.command_map[:bundler] %> exec sidekiq -e <%= fetch(:sidekiq_env) %>
-ExecReload=/bin/kill -TSTP $MAINPID
-ExecStop=/bin/kill -TERM $MAINPID
-<%="StandardOutput=append:#{fetch(:sidekiq_log)}" if fetch(:sidekiq_log) %>
-<%="StandardError=append:#{fetch(:sidekiq_error_log)}" if fetch(:sidekiq_error_log) %>
+ExecStart=<%= expanded_bundle_path %> exec sidekiq -e <%= fetch(:sidekiq_env) %> <%= sidekiq_config %> <%= sidekiq_concurrency %> <%= sidekiq_queues %>
+
+# Use `systemctl kill -s TSTP sidekiq` to quiet the Sidekiq process
+
 <%="User=#{sidekiq_user}" if sidekiq_user %>
-<%="EnvironmentFile=#{fetch(:sidekiq_service_unit_env_file)}" if fetch(:sidekiq_service_unit_env_file) %>
+UMask=0002
 
-<% fetch(:sidekiq_service_unit_env_vars, []).each do |environment_variable| %>
-  <%="Environment=#{environment_variable}" %>
-<% end %>
+<%="EnvironmentFile=#{File.join(fetch(:deploy_to), 'current')}/#{fetch(:sidekiq_service_unit_env_file)}" if fetch(:sidekiq_service_unit_env_file) %>
 
+# Greatly reduce Ruby memory fragmentation and heap usage
+# https://www.mikeperham.com/2018/04/25/taming-rails-memory-bloat/
+Environment=MALLOC_ARENA_MAX=2
+
+# if we crash, restart
 RestartSec=1
 Restart=on-failure
 
+# output goes to /var/log/syslog (Ubuntu) or /var/log/messages (CentOS)
+<%="StandardOutput=append:#{fetch(:sidekiq_log)}" if fetch(:sidekiq_log) %>
+<%="StandardError=append:#{fetch(:sidekiq_error_log)}" if fetch(:sidekiq_error_log) %>
+
+# This will default to "bundler" if we don't specify it
 SyslogIdentifier=sidekiq
 
 [Install]

data/lib/generators/capistrano/sidekiq/upstart/templates/sidekiq.conf.erb

@@ -0,0 +1,78 @@
+# /etc/init/sidekiq.conf - Sidekiq config | https://github.com/mperham/sidekiq/blob/master/examples/upstart/sidekiq.conf
+
+# This example config should work with Ubuntu 12.04+.  It
+# allows you to manage multiple Sidekiq instances with
+# Upstart, Ubuntu's native service management tool.
+#
+# See workers.conf for how to manage all Sidekiq instances at once.
+#
+# Save this config as /etc/init/sidekiq.conf then manage sidekiq with:
+#   sudo start <%= fetch(:sidekiq_service_unit_name) %> index=0
+#   sudo stop <%= fetch(:sidekiq_service_unit_name) %> index=0
+#   sudo status <%= fetch(:sidekiq_service_unit_name) %> index=0
+#
+# Hack Upstart's reload command to 'quiet' Sidekiq:
+#
+#   sudo reload <%= fetch(:sidekiq_service_unit_name) %> index=0
+#
+# or use the service command:
+#   sudo service <%= fetch(:sidekiq_service_unit_name) %> {start,stop,restart,status}
+#
+
+description "Sidekiq for <%= "#{fetch(:application)} (#{fetch(:stage)})" %>"
+
+# This script is not meant to start on bootup, workers.conf
+# will start all sidekiq instances explicitly when it starts.
+#start on runlevel [2345]
+#stop on runlevel [06]
+<% if sidekiq_user %>
+
+# change to match your deployment user
+setuid <%= sidekiq_user %>
+setgid <%= sidekiq_user %>
+env HOME=/home/<%= sidekiq_user %>
+<% end %>
+
+# Greatly reduce Ruby memory fragmentation and heap usage
+# https://www.mikeperham.com/2018/04/25/taming-rails-memory-bloat/
+env MALLOC_ARENA_MAX=2
+
+respawn
+respawn limit 3 30
+
+# TERM is used when stopping sidekiq. Without declaring these as
+# normal exit codes, it just respawns.
+normal exit 0 TERM
+
+# Older versions of Upstart might not support the reload command and need
+# this commented out.
+reload signal TSTP
+
+# Upstart waits 5 seconds by default to kill a process. Increase timeout to
+# give sidekiq process enough time to exit.
+kill timeout 30
+<% if num_workers %>
+
+instance $index
+<% end %>
+script
+# this script runs in /bin/sh by default
+# respawn as bash so we can source in rbenv
+exec /bin/bash <<'EOT'
+  # Pick your poison :) Or none if you're using a system wide installed Ruby.
+  # rbenv
+  # source /home/apps/.bash_profile
+  # OR
+  # source /home/apps/.profile
+  # OR system:
+  # source /etc/profile.d/rbenv.sh
+  #
+  # rvm
+  # source /home/apps/.rvm/scripts/rvm
+
+  # Logs out to /var/log/upstart/<%= fetch(:sidekiq_service_unit_name) %>.log by default
+
+  cd <%= File.join(fetch(:deploy_to), 'current') %>
+  exec <%= SSHKit.config.command_map[:bundle] %> exec sidekiq -e <%= fetch(:sidekiq_env) %> <%= sidekiq_config %> <%= sidekiq_concurrency %> <%= sidekiq_queues %>
+EOT
+end script

data/lib/generators/capistrano/sidekiq/upstart/templates/workers.conf.erb

@@ -0,0 +1,37 @@
+# /etc/init/workers.conf - manage a set of Sidekiqs | https://github.com/mperham/sidekiq/blob/master/examples/upstart/workers.conf
+
+# This example config should work with Ubuntu 14.10 and below  It
+# allows you to manage multiple Sidekiq instances with
+# Upstart, Ubuntu's native service management tool.
+#
+# See sidekiq.conf for how to manage a single Sidekiq instance.
+#
+# Use "stop workers" to stop all Sidekiq instances.
+# Use "start workers" to start all instances.
+# Use "restart workers" to restart all instances.
+# Crazy, right?
+#
+
+description "manages the set of sidekiq processes"
+
+# This starts upon bootup and stops on shutdown
+start on runlevel [2345]
+stop on runlevel [06]
+
+# Set this to the number of Sidekiq processes you want
+# to run on this machine
+env NUM_WORKERS=2
+
+pre-start script
+  for i in `seq 1 ${NUM_WORKERS}`
+  do
+    start sidekiq index=$i
+  done
+end script
+
+post-stop script
+  for i in `seq 1 ${NUM_WORKERS}`
+  do
+    stop sidekiq index=$i
+  done
+end script

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: capistrano-sidekiq
 version: !ruby/object:Gem::Version
-  version: 2.0.0.beta4
+  version: 2.1.0
 platform: ruby
 authors:
 - Abdelkader Boudih
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-06-08 00:00:00.000000000 Z
+date: 2022-05-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: capistrano
@@ -70,6 +70,7 @@ files:
 - capistrano-sidekiq.gemspec
 - lib/capistrano-sidekiq.rb
 - lib/capistrano/sidekiq.rb
+- lib/capistrano/sidekiq/helpers.rb
 - lib/capistrano/sidekiq/monit.rb
 - lib/capistrano/sidekiq/systemd.rb
 - lib/capistrano/sidekiq/upstart.rb
@@ -81,11 +82,13 @@ files:
 - lib/generators/capistrano/sidekiq/monit/template_generator.rb
 - lib/generators/capistrano/sidekiq/monit/templates/sidekiq_monit.conf.erb
 - lib/generators/capistrano/sidekiq/systemd/templates/sidekiq.service.capistrano.erb
+- lib/generators/capistrano/sidekiq/upstart/templates/sidekiq.conf.erb
+- lib/generators/capistrano/sidekiq/upstart/templates/workers.conf.erb
 homepage: https://github.com/seuros/capistrano-sidekiq
 licenses:
 - LGPL-3.0
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -96,12 +99,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 2.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
-rubygems_version: 3.0.3
-signing_key: 
+rubygems_version: 3.2.22
+signing_key:
 specification_version: 4
 summary: Sidekiq integration for Capistrano
 test_files: []