capistrano-sidekiq 1.0.3 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2eadf4da0195248e5ce25a260423b32f4f71e7f54b6c0d396b7f5e1c40604aa3
-  data.tar.gz: e682b32cc48da4c50aebfaed702c7dd98a27b04f23747da96289807a32fa105a
+  metadata.gz: 1c3bd1a14a2effd1ef907aaab6d7cb391d25d5125ec22d7ff338f0e98e475e28
+  data.tar.gz: f8a97dcfe1ecdbfecf0ad5ffbb90df8cf5653a4b67f3e6e745cfc91a295c546e
 SHA512:
-  metadata.gz: a2016c2552e53d2eb04e8615b094b7d52b868907db40e196b0b5fa2b13de0121b81f9921e7947d9758fd68a12377a8355de5da4556629e5d4d8b9aa3a3ff3cfd
-  data.tar.gz: eeccd0a9dea2b6a81ed1de9e4a72cf909b1a12e67f9aa06043f0c57e7f13fef8b536b41442eb190a35048a211ed8e8e53162307c5cef2ead88ab84f85f04c5fa
+  metadata.gz: 776cc57678b6b04bb80f94470c90cf7690b44a0cea4ead9abb543c99726104ad2218c87308ba273f7304defd0fe6e61a14bbb1c7b1edb003a8012abb58f7f135
+  data.tar.gz: 0fb423476f90dbece2f3107196392e168b9bfd17e47eef25a94a47fb1f34dab4bb839317aa2f30c1b8acc2d7c23a76e35f7477567c1417d52f111900fd9759ca

data/.tool-versions

@@ -0,0 +1 @@
+ruby 2.6.5

data/README.md

@@ -6,12 +6,6 @@ Sidekiq integration for Capistrano
 
 ## Installation
 
-Add this line to your application's Gemfile:
-
-    gem 'capistrano-sidekiq', github: 'seuros/capistrano-sidekiq'
-
-or:
-
     gem 'capistrano-sidekiq', group: :development
 
 And then execute:
@@ -21,29 +15,34 @@ And then execute:
 
 ## Usage
 ```ruby
-# Capfile
-require 'capistrano/sidekiq'
-require 'capistrano/sidekiq/monit' #to require monit tasks # Only for capistrano3
+    # Capfile
+
+    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::Upstart  # tests needed
+    # or  
+    install_plugin Capistrano::Sidekiq::Monit  # tests needed
 ```
 
 
 Configurable options, shown here with defaults:
 
 ```ruby
+:sidekiq_roles => :app
 :sidekiq_default_hooks => true
 :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')
-:sidekiq_options => nil
-:sidekiq_require => nil
-:sidekiq_tag => nil
-:sidekiq_config => nil # if you have a config/sidekiq.yml, do not forget to set this. 
-:sidekiq_queue => nil
-:sidekiq_timeout => 10
-:sidekiq_roles => :app
-:sidekiq_processes => 1
-:sidekiq_options_per_process => nil
-:sidekiq_concurrency => nil
+
+# sidekiq systemd options
+:sidekiq_service_unit_name => 'sidekiq'
+:sidekiq_service_unit_user => :user # :system
+:sidekiq_enable_lingering => true
+:sidekiq_lingering_user => nil
+
 # sidekiq monit
 :sidekiq_monit_templates_path => 'config/deploy/templates'
 :sidekiq_monit_conf_dir => '/etc/monit/conf.d'
@@ -51,10 +50,8 @@ 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)}_#{fetch(:sidekiq_env)}" + (index ? "_#{index}" : '') 
+:sidekiq_service_name => "sidekiq_#{fetch(:application)}" 
 
-:sidekiq_cmd => "#{fetch(:bundle_cmd, "bundle")} exec sidekiq" # Only for capistrano2.5
-:sidekiqctl_cmd => "#{fetch(:bundle_cmd, "bundle")} exec sidekiqctl" # Only for capistrano2.5
 :sidekiq_user => nil #user to run sidekiq as
 ```
 
@@ -74,70 +71,6 @@ SSHKit.config.command_map[:sidekiq] = "bundle exec sidekiq"
 SSHKit.config.command_map[:sidekiqctl] = "bundle exec sidekiqctl"
 ```
 
-## Multiple processes
-
-You can configure sidekiq to start with multiple processes. Just set the proper amount in `sidekiq_processes`.
-
-You can also customize the configuration for every process. If you want to do that, just set
-`sidekiq_options_per_process` with an array of the configuration options that you want in string format.
-This example should boot the first process with the queue `high` and the second one with the queues `default`
-and `low`:
-
-```ruby
-set :sidekiq_processes, 2
-set :sidekiq_options_per_process, ["--queue high", "--queue default --queue low"]
-```
-
-## Different number of processes per role
-
-You can configure how many processes you want to run on each host next way:
-
-```ruby
-set :sidekiq_roles, [:sidekiq_small, :sidekiq_big]
-set :sidekiq_small_processes, 1
-set :sidekiq_big_processes, 4
-server 'example-small.com', roles: [:sidekiq_small]
-server 'example-big.com', roles: [:sidekiq_big]
-```
-
-## Integration with systemd
-
-Set init system to systemd in the cap deploy config:
-
-```ruby
-set :init_system, :systemd
-```
-
-Enable lingering for systemd user account
-
-```
-loginctl enable-linger USERACCOUNT
-```
-
-Install systemd.service template file and enable the service with:
-
-```
-bundle exec cap sidekiq:install
-```
-
-Default name for the service file is `sidekiq-stage.service`. This can be changed as needed, for example:
-
-```ruby
-set :service_unit_name, "sidekiq-#{fetch(:application)}-#{fetch(:stage)}.service"
-```
-
-## Integration with upstart
-
-Set init system to upstart in the cap deploy config:
-
-```ruby
-set :init_system, :upstart
-```
-
-Set upstart service name:
-```ruby
-set :upstart_service_name, 'sidekiq'
-```
 
 ## Customizing the monit sidekiq templates
 

data/capistrano-sidekiq.gemspec

@@ -18,5 +18,6 @@ Gem::Specification.new do |spec|
   spec.require_paths = ['lib']
 
   spec.add_dependency 'capistrano', '>= 3.9.0'
-  spec.add_dependency 'sidekiq', '>= 3.4', "< 6.0"
+  spec.add_dependency 'capistrano-bundler'
+  spec.add_dependency 'sidekiq', '>= 6.0'
 end

data/lib/capistrano/sidekiq/monit.rb

@@ -1 +1,17 @@
-load File.expand_path('../../tasks/monit.rake', __FILE__)
+module Capistrano
+  class Sidekiq::Monit < Capistrano::Plugin
+    def set_defaults
+      set_if_empty :monit_bin, '/usr/bin/monit'
+      set_if_empty :sidekiq_monit_conf_dir, '/etc/monit/conf.d'
+      set_if_empty :sidekiq_monit_conf_file, -> { "#{sidekiq_service_name}.conf" }
+      set_if_empty :sidekiq_monit_use_sudo, true
+      set_if_empty :sidekiq_monit_default_hooks, true
+      set_if_empty :sidekiq_monit_templates_path, 'config/deploy/templates'
+      set_if_empty :sidekiq_monit_group, nil
+    end
+
+    def define_tasks
+      eval_rakefile File.expand_path('../../tasks/monit.rake', __FILE__)
+    end
+  end
+end

data/lib/capistrano/sidekiq/systemd.rb

@@ -0,0 +1,14 @@
+module Capistrano
+  class Sidekiq::Systemd < Capistrano::Plugin
+    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
+    end
+
+    def define_tasks
+      eval_rakefile File.expand_path('../../tasks/systemd.rake', __FILE__)
+    end
+  end
+end

data/lib/capistrano/sidekiq/upstart.rb

@@ -0,0 +1,11 @@
+module Capistrano
+  class Sidekiq::Upstart < Capistrano::Plugin
+    def set_defaults
+      set_if_empty :sidekiq_service_unit_name, 'sidekiq'
+    end
+
+    def define_tasks
+      eval_rakefile File.expand_path('../../tasks/upstart.rake', __FILE__)
+    end
+  end
+end

data/lib/capistrano/sidekiq/version.rb

@@ -1,3 +1,3 @@
 module Capistrano
-  SidekiqVERSION = '1.0.3'
+  SidekiqVERSION = '2.0.0'
 end

data/lib/capistrano/sidekiq.rb

@@ -1 +1,30 @@
-load File.expand_path('../tasks/sidekiq.rake', __FILE__)
+require 'capistrano/bundler'
+require "capistrano/plugin"
+
+module Capistrano
+  class Sidekiq < Capistrano::Plugin
+    def define_tasks
+      eval_rakefile File.expand_path('../tasks/sidekiq.rake', __FILE__)
+    end
+
+    def set_defaults
+      set_if_empty :sidekiq_default_hooks, true
+
+      set_if_empty :sidekiq_env, -> { fetch(:rack_env, fetch(:rails_env, fetch(:rake_env, fetch(:stage)))) }
+      set_if_empty :sidekiq_roles, fetch(:sidekiq_role, :app)
+      set_if_empty :sidekiq_log, -> { File.join(shared_path, 'log', 'sidekiq.log') }
+      set_if_empty :sidekiq_error_log, -> { File.join(shared_path, 'log', 'sidekiq.error.log') }
+      # Rbenv, Chruby, and RVM integration
+      append :rbenv_map_bins, 'sidekiq', 'sidekiqctl'
+      append :rvm_map_bins, 'sidekiq', 'sidekiqctl'
+      append :chruby_map_bins, 'sidekiq', 'sidekiqctl'
+      # Bundler integration
+      append :bundle_bins, 'sidekiq', 'sidekiqctl'
+    end
+
+  end
+end
+
+require_relative 'sidekiq/systemd'
+require_relative 'sidekiq/upstart'
+require_relative 'sidekiq/monit'

data/lib/capistrano/tasks/sidekiq.rake

@@ -1,29 +1,3 @@
-namespace :load do
-  task :defaults do
-    set :sidekiq_default_hooks, true
-
-    set :sidekiq_pid, -> { File.join(shared_path, 'tmp', 'pids', 'sidekiq.pid') }
-    set :sidekiq_env, -> { fetch(:rack_env, fetch(:rails_env, fetch(:stage))) }
-    set :sidekiq_log, -> { File.join(shared_path, 'log', 'sidekiq.log') }
-    set :sidekiq_timeout, 10
-    set :sidekiq_roles, fetch(:sidekiq_role, :app)
-    set :sidekiq_processes, 1
-    set :sidekiq_options_per_process, nil
-    set :sidekiq_user, nil
-    # Rbenv, Chruby, and RVM integration
-    set :rbenv_map_bins, fetch(:rbenv_map_bins).to_a.concat(%w[sidekiq sidekiqctl])
-    set :rvm_map_bins, fetch(:rvm_map_bins).to_a.concat(%w[sidekiq sidekiqctl])
-    set :chruby_map_bins, fetch(:chruby_map_bins).to_a.concat(%w[sidekiq sidekiqctl])
-    # Bundler integration
-    set :bundle_bins, fetch(:bundle_bins).to_a.concat(%w[sidekiq sidekiqctl])
-    # Init system integration
-    set :init_system, -> { nil }
-    # systemd integration
-    set :service_unit_name, "sidekiq-#{fetch(:stage)}.service"
-    set :upstart_service_name, "sidekiq"
-  end
-end
-
 namespace :deploy do
   before :starting, :check_sidekiq_hooks do
     invoke 'sidekiq:add_default_hooks' if fetch(:sidekiq_default_hooks)
@@ -32,255 +6,15 @@ end
 
 namespace :sidekiq do
   task :add_default_hooks do
-    after 'deploy:starting',  'sidekiq:quiet'
-    after 'deploy:updated',   'sidekiq:stop'
+    after 'deploy:starting', 'sidekiq:quiet'
+    after 'deploy:updated', 'sidekiq:stop'
     after 'deploy:published', 'sidekiq:start'
     after 'deploy:failed', 'sidekiq:restart'
   end
 
-  desc 'Quiet sidekiq (stop fetching new tasks from Redis)'
-  task :quiet do
-    on roles fetch(:sidekiq_roles) do |role|
-      switch_user(role) do
-        case fetch(:init_system)
-        when :systemd
-          execute :systemctl, "--user", "reload", fetch(:service_unit_name), raise_on_non_zero_exit: false
-        when :upstart
-          sudo :service, fetch(:upstart_service_name), :reload
-        else
-          if test("[ -d #{release_path} ]")
-            each_process_with_index(reverse: true) do |pid_file, _idx|
-              if pid_file_exists?(pid_file) && process_exists?(pid_file)
-                quiet_sidekiq(pid_file)
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-
-  desc 'Stop sidekiq (graceful shutdown within timeout, put unfinished tasks back to Redis)'
-  task :stop do
-    on roles fetch(:sidekiq_roles) do |role|
-      switch_user(role) do
-        case fetch(:init_system)
-        when :systemd
-          execute :systemctl, "--user", "stop", fetch(:service_unit_name)
-        when :upstart
-          sudo :service, fetch(:upstart_service_name), :stop
-        else
-          if test("[ -d #{release_path} ]")
-            each_process_with_index(reverse: true) do |pid_file, _idx|
-              if pid_file_exists?(pid_file) && process_exists?(pid_file)
-                stop_sidekiq(pid_file)
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-
-  desc 'Start sidekiq'
-  task :start do
-    on roles fetch(:sidekiq_roles) do |role|
-      switch_user(role) do
-        case fetch(:init_system)
-        when :systemd
-          execute :systemctl, '--user', 'start', fetch(:service_unit_name)
-        when :upstart
-          sudo :service, fetch(:upstart_service_name), :start
-        else
-          each_process_with_index do |pid_file, idx|
-            unless pid_file_exists?(pid_file) && process_exists?(pid_file)
-              start_sidekiq(pid_file, idx)
-            end
-          end
-        end
-      end
-    end
-  end
-
   desc 'Restart sidekiq'
   task :restart do
     invoke! 'sidekiq:stop'
     invoke! 'sidekiq:start'
   end
-
-  desc 'Rolling-restart sidekiq'
-  task :rolling_restart do
-    on roles fetch(:sidekiq_roles) do |role|
-      switch_user(role) do
-        each_process_with_index(reverse: true) do |pid_file, idx|
-          if pid_file_exists?(pid_file) && process_exists?(pid_file)
-            stop_sidekiq(pid_file)
-          end
-          start_sidekiq(pid_file, idx)
-        end
-      end
-    end
-  end
-
-  desc 'Delete any pid file not in use'
-  task :cleanup do
-    on roles fetch(:sidekiq_roles) do |role|
-      switch_user(role) do
-        each_process_with_index do |pid_file, _idx|
-          unless process_exists?(pid_file)
-            next unless pid_file_exists?(pid_file)
-            execute "rm #{pid_file}"
-          end
-        end
-      end
-    end
-  end
-
-  # TODO: Don't start if all processes are off, raise warning.
-  desc 'Respawn missing sidekiq processes'
-  task :respawn do
-    invoke 'sidekiq:cleanup'
-    on roles fetch(:sidekiq_roles) do |role|
-      switch_user(role) do
-        each_process_with_index do |pid_file, idx|
-          start_sidekiq(pid_file, idx) unless pid_file_exists?(pid_file)
-        end
-      end
-    end
-  end
-
-  task :install do
-    on roles fetch(:sidekiq_roles) do |role|
-      switch_user(role) do
-        case fetch(:init_system)
-        when :systemd
-          create_systemd_template
-          execute :systemctl, "--user", "enable", fetch(:service_unit_name)
-        end
-      end
-    end
-  end
-
-  task :uninstall do
-    on roles fetch(:sidekiq_roles) do |role|
-      switch_user(role) do
-        case fetch(:init_system)
-        when :systemd
-          execute :systemctl, "--user", "disable", fetch(:service_unit_name)
-          execute :rm, File.join(fetch(:service_unit_path, fetch_systemd_unit_path),fetch(:service_unit_name))
-        end
-      end
-    end
-  end
-
-  def each_process_with_index(reverse: false)
-    pid_file_list = pid_files
-    pid_file_list.reverse! if reverse
-    pid_file_list.each_with_index do |pid_file, idx|
-      within release_path do
-        yield(pid_file, idx)
-      end
-    end
-  end
-
-  def fetch_systemd_unit_path
-    home_dir = capture :pwd
-    File.join(home_dir, ".config", "systemd", "user")
-  end
-
-  def create_systemd_template
-    search_paths = [
-      File.expand_path(
-        File.join(*%w[.. .. .. generators capistrano sidekiq systemd templates sidekiq.service.capistrano.erb]),
-        __FILE__
-      ),
-    ]
-    template_path = search_paths.detect {|path| File.file?(path)}
-    template = File.read(template_path)
-    systemd_path = fetch(:service_unit_path, fetch_systemd_unit_path)
-    execute :mkdir, "-p", systemd_path
-    upload!(
-      StringIO.new(ERB.new(template).result(binding)),
-      "#{systemd_path}/#{fetch :service_unit_name}"
-    )
-    execute :systemctl, "--user", "daemon-reload"
-  end
-
-  def pid_files
-    sidekiq_roles = Array(fetch(:sidekiq_roles)).dup
-    sidekiq_roles.select! { |role| host.roles.include?(role) }
-    sidekiq_roles.flat_map do |role|
-      processes = fetch(:"#{ role }_processes") || fetch(:sidekiq_processes)
-      Array.new(processes) { |idx| fetch(:sidekiq_pid).gsub(/\.pid$/, "-#{idx}.pid") }
-    end
-  end
-
-  def pid_file_exists?(pid_file)
-    test(*("[ -f #{pid_file} ]").split(' '))
-  end
-
-  def process_exists?(pid_file)
-    test(*("kill -0 $( cat #{pid_file} )").split(' '))
-  end
-
-  def quiet_sidekiq(pid_file)
-    begin
-      execute :sidekiqctl, 'quiet', pid_file.to_s
-    rescue SSHKit::Command::Failed
-      # If gems are not installed (first deploy) and sidekiq_default_hooks is active
-      warn 'sidekiqctl not found (ignore if this is the first deploy)'
-    end
-  end
-
-  def stop_sidekiq(pid_file)
-    execute :sidekiqctl, 'stop', pid_file.to_s, fetch(:sidekiq_timeout)
-  end
-
-  def start_sidekiq(pid_file, idx = 0)
-    args = []
-    args.push "--index #{idx}"
-    args.push "--pidfile #{pid_file}"
-    args.push "--environment #{fetch(:sidekiq_env)}"
-    args.push "--logfile #{fetch(:sidekiq_log)}" if fetch(:sidekiq_log)
-    args.push "--require #{fetch(:sidekiq_require)}" if fetch(:sidekiq_require)
-    args.push "--tag #{fetch(:sidekiq_tag)}" if fetch(:sidekiq_tag)
-    Array(fetch(:sidekiq_queue)).each do |queue|
-      args.push "--queue #{queue}"
-    end
-    args.push "--config #{fetch(:sidekiq_config)}" if fetch(:sidekiq_config)
-    args.push "--concurrency #{fetch(:sidekiq_concurrency)}" if fetch(:sidekiq_concurrency)
-    if (process_options = fetch(:sidekiq_options_per_process))
-      args.push process_options[idx]
-    end
-    # use sidekiq_options for special options
-    args.push fetch(:sidekiq_options) if fetch(:sidekiq_options)
-
-    if defined?(JRUBY_VERSION)
-      args.push '>/dev/null 2>&1 &'
-      warn 'Since JRuby doesn\'t support Process.daemon, Sidekiq will not be running as a daemon.'
-    else
-      args.push '--daemon'
-    end
-
-    execute :sidekiq, args.compact.join(' ')
-  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)
-    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

data/lib/capistrano/tasks/systemd.rake

@@ -0,0 +1,135 @@
+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
+        end
+      end
+    end
+  end
+
+  desc 'Stop sidekiq (graceful shutdown within timeout, put unfinished tasks back to Redis)'
+  task :stop 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)
+        end
+      end
+    end
+  end
+
+  desc 'Start sidekiq'
+  task :start 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
+      end
+    end
+  end
+
+  desc 'Install systemd sidekiq service'
+  task :install 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)
+        end
+      end
+    end
+  end
+
+  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)
+        end
+        execute :rm, '-f', File.join(fetch(:service_unit_path, fetch_systemd_unit_path), fetch(:sidekiq_service_unit_name))
+      end
+    end
+  end
+
+  desc 'Generate service_locally'
+  task :generate_service_locally do
+    run_locally do
+      File.write('sidekiq', git_plugin.compiled_template)
+    end
+  end
+
+  def fetch_systemd_unit_path
+    if fetch(:sidekiq_service_unit_user) == :system
+      # if the path is not standard `set :service_unit_path`
+      "/etc/systemd/system/"
+    else
+      home_dir = backend.capture :pwd
+      File.join(home_dir, ".config", "systemd", "user")
+    end
+  end
+
+  def compiled_template
+    search_paths = [
+      File.expand_path(
+          File.join(*%w[.. .. .. generators capistrano sidekiq systemd templates sidekiq.service.capistrano.erb]),
+          __FILE__
+      ),
+    ]
+    template_path = search_paths.detect { |path| File.file?(path) }
+    template = File.read(template_path)
+    ERB.new(template).result(binding)
+  end
+
+  def create_systemd_template
+    ctemplate = compiled_template
+    systemd_path = fetch(:service_unit_path, fetch_systemd_unit_path)
+
+    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"
+    )
+    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, :systemctl, "daemon-reload"
+    else
+      backend.execute :mv, "/tmp/#{fetch :sidekiq_service_unit_name}.service", "#{systemd_path}/#{fetch :sidekiq_service_unit_name}.service"
+      backend.execute :systemctl, "--user", "daemon-reload"
+    end
+  end
+
+  def switch_user(role)
+    su_user = sidekiq_user
+    if su_user != role.user
+      yield
+    else
+      backend.as su_user do
+        yield
+      end
+    end
+  end
+
+  def sidekiq_user
+    fetch(:sidekiq_user, fetch(:run_as))
+  end
+end

data/lib/capistrano/tasks/upstart.rake

@@ -0,0 +1,146 @@
+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, *SUPPRESS_FAILURE
+      end
+    end
+  end
+
+  desc 'Stop sidekiq (graceful shutdown within timeout, put unfinished tasks back to Redis)'
+  task :stop do
+    on roles fetch(:sidekiq_roles) do |role|
+      git_plugin.switch_user(role) do
+        sudo :service, fetch(:sidekiq_service_unit_name), :stop, *SUPPRESS_FAILURE
+      end
+    end
+  end
+
+  desc 'Start sidekiq'
+  task :start do
+    on roles fetch(:sidekiq_roles) do |role|
+      git_plugin.switch_user(role) do
+        sudo :service, fetch(:sidekiq_service_unit_name), :start
+      end
+    end
+  end
+
+  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
+
+  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 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 num_workers
+    fetch(:sidekiq_upstart_num_workers, nil)
+  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
+
+end

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

@@ -4,11 +4,18 @@ After=syslog.target network.target
 
 [Service]
 Type=simple
-Environment=RAILS_ENV=<%= fetch(:rails_env) %>
-WorkingDirectory=<%= fetch(:deploy_to) %>/current
-ExecStart=<%= fetch(:bundler_path, '/usr/local/bin/bundler') %> exec sidekiq -e <%= fetch(:rails_env) %>
+WorkingDirectory=<%= File.join(fetch(:deploy_to), 'current') %>
+ExecStart=<%= SSHKit.config.command_map[:bundle] %> 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) %>
+<%="User=#{sidekiq_user}" if sidekiq_user %>
+<%="EnvironmentFile=#{fetch(:sidekiq_service_unit_env_file)}" if fetch(:sidekiq_service_unit_env_file) %>
+
+<% fetch(:sidekiq_service_unit_env_vars, []).each do |environment_variable| %>
+  <%="Environment=#{environment_variable}" %>
+<% end %>
 
 RestartSec=1
 Restart=on-failure

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: 1.0.3
+  version: 2.0.0
 platform: ruby
 authors:
 - Abdelkader Boudih
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2019-09-02 00:00:00.000000000 Z
+date: 2020-12-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: capistrano
@@ -25,13 +25,24 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 3.9.0
 - !ruby/object:Gem::Dependency
-  name: sidekiq
+  name: capistrano-bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '3.4'
-    - - "<"
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sidekiq
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
       - !ruby/object:Gem::Version
         version: '6.0'
   type: :runtime
@@ -39,9 +50,6 @@ dependencies:
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
-      - !ruby/object:Gem::Version
-        version: '3.4'
-    - - "<"
       - !ruby/object:Gem::Version
         version: '6.0'
 description: Sidekiq integration for Capistrano
@@ -52,6 +60,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".tool-versions"
 - CHANGELOG.md
 - CONTRIBUTORS.md
 - Gemfile
@@ -62,17 +71,23 @@ files:
 - lib/capistrano-sidekiq.rb
 - lib/capistrano/sidekiq.rb
 - lib/capistrano/sidekiq/monit.rb
+- lib/capistrano/sidekiq/systemd.rb
+- lib/capistrano/sidekiq/upstart.rb
 - lib/capistrano/sidekiq/version.rb
 - lib/capistrano/tasks/monit.rake
 - lib/capistrano/tasks/sidekiq.rake
+- lib/capistrano/tasks/systemd.rake
+- lib/capistrano/tasks/upstart.rake
 - 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
@@ -88,7 +103,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubygems_version: 3.0.3
-signing_key: 
+signing_key:
 specification_version: 4
 summary: Sidekiq integration for Capistrano
 test_files: []