capistrano-sidekiq 0.20.0 → 2.3.0

data/lib/capistrano/tasks/systemd.rake

@@ -0,0 +1,296 @@
+# frozen_string_literal: true
+
+git_plugin = self
+
+namespace :sidekiq do
+  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 '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
+        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-cgls', '--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 'Quiet Sidekiq (stop fetching new tasks from Redis)'
+  task :quiet do
+    on roles fetch(:sidekiq_roles) do |role|
+      git_plugin.switch_user(role) do
+        git_plugin.quiet_sidekiq
+      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 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'
+  task :uninstall do
+    on roles fetch(:sidekiq_roles) do |role|
+      git_plugin.switch_user(role) do
+        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 :sudo, :rm, '-f', File.join(
+          fetch(:service_unit_path, git_plugin.fetch_systemd_unit_path),
+          git_plugin.sidekiq_service_file_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
+    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__
+      )
+    ]
+    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)
+    backend.execute :mkdir, '-p', systemd_path if fetch(:sidekiq_service_unit_user) == :user
+
+    if sidekiq_processes > 1
+      range = 1..sidekiq_processes
+    else
+      range = 0..0
+    end
+    range.each do |index|
+      temp_file_name = File.join('/tmp', sidekiq_service_file_name(index))
+      systemd_file_name = File.join(systemd_path, sidekiq_service_file_name(index))
+      backend.upload!(StringIO.new(ctemplate), temp_file_name)
+
+      if fetch(:sidekiq_service_unit_user) == :system
+        backend.execute :sudo, :mv, temp_file_name, systemd_file_name
+        backend.execute :sudo, :systemctl, 'daemon-reload'
+      else
+        backend.execute :mv, temp_file_name, systemd_file_name
+        backend.execute :systemctl, '--user', 'daemon-reload'
+      end
+    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
+        %i[sudo systemctl]
+      else
+        [:systemctl, '--user']
+      end
+    if process && sidekiq_processes > 1
+      execute_array.push(
+        *args, sidekiq_service_unit_name(process: process)
+        ).flatten
+    else
+      execute_array.push(*args, sidekiq_service_unit_name).flatten
+    end
+    backend.execute(*execute_array, raise_on_non_zero_exit: false)
+  end
+
+  def quiet_sidekiq
+    systemctl_command(:kill, '-s', :TSTP)
+  end
+
+  def switch_user(role, &block)
+    su_user = sidekiq_user
+    if su_user != role.user
+      yield
+    else
+      backend.as su_user, &block
+    end
+  end
+
+  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
+      )
+    end
+    "--config #{config}"
+  end
+
+  def sidekiq_concurrency
+    "--concurrency #{fetch(:sidekiq_concurrency)}" if fetch(:sidekiq_concurrency)
+  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(index = nil)
+    return "#{fetch(:sidekiq_service_unit_name)}.service" if index.to_i.zero?
+    "#{fetch(:sidekiq_service_unit_name)}@#{index}.service"
+  end
+
+  def sidekiq_service_unit_name(process: nil)
+    if process && sidekiq_processes > 1
+      "#{fetch(:sidekiq_service_unit_name)}@#{process}"
+    else
+      fetch(:sidekiq_service_unit_name)
+    end
+  end
+
+  # process = 1 | sidekiq_systemd_1.yaml
+  # process = nil | sidekiq_systemd_%i.yaml
+  def sidekiq_systemd_config_name(process = nil)
+   "sidekiq_systemd_#{(process&.to_s || '%i')}.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/generators/capistrano/sidekiq/monit/templates/sidekiq_monit.conf.erb

@@ -1,10 +1,8 @@
-# Monit configuration for Sidekiq :  <%= fetch(:application) %>
-<% processes_pids.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
-  group <%= fetch(:sidekiq_monit_group, fetch(:application)) %>-sidekiq
-
-<% end %>
+# Monit configuration for Sidekiq
+# Service name: <%= sidekiq_service_name %>
+#
+check process <%= sidekiq_service_name %>
+  matching 'sidekiq .* <%= fetch(:application) %>'
+  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 <%= fetch(:sidekiq_timeout).to_i + 10 %> seconds
+  stop program = "/bin/su - <%= sidekiq_user(role) %> -c 'ps ax | grep "<%= "sidekiq .* #{fetch(:application)}" %>" | 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

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

@@ -0,0 +1,68 @@
+# 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_service_unit_name %>
+#   - systemctl {start,stop,restart} <%= sidekiq_service_unit_name %>
+#
+# This file corresponds to a single Sidekiq process.  Add multiple copies
+# to run multiple processes (sidekiq-1, sidekiq-2, etc).
+#
+# Use `journalctl -u <%= sidekiq_service_unit_name %> -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]
+#
+#      !!!!  !!!!  !!!!
+#
+# 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=<%= expanded_bundle_path %> exec sidekiq -e <%= fetch(:sidekiq_env) %> <%= sidekiq_config %> <%= sidekiq_concurrency %> <%= sidekiq_queues %>
+
+# Use `systemctl kill -s TSTP <%= sidekiq_service_unit_name %>` to quiet the Sidekiq process
+<%="User=#{sidekiq_user}" if sidekiq_user %>
+UMask=0002
+
+<%="EnvironmentFile=#{File.join(fetch(:deploy_to), 'current')}/#{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 %>
+
+# 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) %>
+
+SyslogIdentifier=<%= sidekiq_service_unit_name %>
+
+[Install]
+WantedBy=default.target

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: capistrano-sidekiq
 version: !ruby/object:Gem::Version
-  version: 0.20.0
+  version: 2.3.0
 platform: ruby
 authors:
 - Abdelkader Boudih
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2017-08-01 00:00:00.000000000 Z
+date: 2022-05-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: capistrano
@@ -24,20 +24,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 3.9.0
+- !ruby/object:Gem::Dependency
+  name: capistrano-bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        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: '3.4'
+        version: '6.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '3.4'
+        version: '6.0'
 description: Sidekiq integration for Capistrano
 email:
 - terminale@gmail.com
@@ -46,8 +60,8 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
-- CHANGELOG
-- CONTRIBUTORS.md
+- ".tool-versions"
+- CHANGELOG.md
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -55,18 +69,21 @@ 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/version.rb
-- lib/capistrano/tasks/capistrano2.rb
 - lib/capistrano/tasks/monit.rake
 - lib/capistrano/tasks/sidekiq.rake
+- lib/capistrano/tasks/systemd.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
 homepage: https://github.com/seuros/capistrano-sidekiq
 licenses:
 - LGPL-3.0
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -81,9 +98,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.11
-signing_key: 
+rubygems_version: 3.2.22
+signing_key:
 specification_version: 4
 summary: Sidekiq integration for Capistrano
 test_files: []

data/CHANGELOG

@@ -1,28 +0,0 @@
-## Changelog
-- 0.10.0:
-        * Fix Monit tasks
-        * sidekiq:stop task perpertually callable
-- 0.5.4: Add support for custom count of processes per host in monit task @okoriko
-- 0.5.3: Custom count of processes per each host
-- 0.5.0: Multiple processes @mrsimo
-- 0.3.9: Restore daemon flag from Monit template
-- 0.3.8:
-        * Update monit template: use su instead of sudo / permit all Sidekiq options @bensie
-        * Unmonitor monit while deploy @Saicheg
-- 0.3.7:
-        * fix capistrano2 task @tribble
-        * Run Sidekiq as daemon from Monit @dpaluy
-- 0.3.5: Added :sidekiq_tag for capistrano2 @OscarBarrett
-- 0.3.4: fix bug in sidekiq:start for capistrano 2 task
-- 0.3.3: sidekiq:restart after deploy:restart added to default hooks
-- 0.3.2: :sidekiq_queue accept an array
-- 0.3.1: Fix logs @rottman, add concurrency option support @ungsophy
-- 0.3.0: Fix monit task @andreygerasimchuk
-- 0.2.9: Check if current directory exist @alexdunae
-- 0.2.8: Added :sidekiq_queue & :sidekiq_config
-- 0.2.7: Signal usage @penso
-- 0.2.6: sidekiq:start check if sidekiq is running
-- 0.2.5: bug fixes
-- 0.2.4: Fast deploy with :sidekiq_run_in_background
-- 0.2.3: Added monit tasks (alpha)
-- 0.2.0: Added sidekiq:rolling_restart - @jlecour

data/CONTRIBUTORS.md

@@ -1,11 +0,0 @@
-## Contributors
-
-- [Jérémy Lecour] (https://github.com/jlecour)
-- [Fabien Penso] (https://github.com/penso)
-- [Alex Dunae] (https://github.com/alexdunae)
-- [andreygerasimchuk] (https://github.com/andreygerasimchuk)
-- [Saicheg] (https://github.com/Saicheg)
-- [Alex Yakubenko] (https://github.com/alexyakubenko)
-- [Robert Strobl] (https://github.com/rstrobl)
-- [Eurico Doirado] (https://github.com/okoriko)
-- [Huang Bin](https://github.com/hbin)

data/lib/capistrano/tasks/capistrano2.rb

@@ -1,147 +0,0 @@
-Capistrano::Configuration.instance.load do
-
-  _cset(:sidekiq_default_hooks) { true }
-
-  _cset(:sidekiq_pid) { File.join(shared_path, 'pids', 'sidekiq.pid') }
-  _cset(:sidekiq_env) { fetch(:rack_env, fetch(:rails_env, 'production')) }
-  _cset(:sidekiq_tag) { nil }
-  _cset(:sidekiq_log) { File.join(shared_path, 'log', 'sidekiq.log') }
-
-  _cset(:sidekiq_config) { "#{current_path}/config/sidekiq.yml" }
-  _cset(:sidekiq_options) { nil }
-  _cset(:sidekiq_queue) { nil }
-  _cset(:sidekiq_concurrency) { nil }
-
-  _cset(:sidekiq_cmd) { "#{fetch(:bundle_cmd, 'bundle')} exec sidekiq" }
-  _cset(:sidekiqctl_cmd) { "#{fetch(:bundle_cmd, 'bundle')} exec sidekiqctl" }
-
-  _cset(:sidekiq_timeout) { 10 }
-  _cset(:sidekiq_role) { :app }
-
-  _cset(:sidekiq_processes) { 1 }
-  _cset(:sidekiq_options_per_process) { nil }
-
-  _cset(:sidekiq_user) { nil }
-
-  if fetch(:sidekiq_default_hooks)
-    before 'deploy:update_code', 'sidekiq:quiet'
-    after 'deploy:stop', 'sidekiq:stop'
-    after 'deploy:start', 'sidekiq:start'
-    before 'deploy:restart', 'sidekiq:restart'
-  end
-
-  namespace :sidekiq do
-    def for_each_process(sidekiq_role, &block)
-      sidekiq_processes = fetch(:"#{ sidekiq_role }_processes") rescue 1
-      sidekiq_processes.times do |idx|
-        pid_file = fetch(:sidekiq_pid).gsub(/\.pid$/, "-#{idx}.pid")
-        yield(pid_file, idx)
-      end
-    end
-
-    def for_each_role
-      sidekiq_roles = fetch(:sidekiq_role)
-
-      sidekiq_roles = if sidekiq_roles.respond_to?(:to_ary)
-                        sidekiq_roles.to_ary
-                      else
-                        [sidekiq_roles]
-                      end
-
-      sidekiq_roles.to_ary.each do |sidekiq_role|
-        puts "executing on ##{ sidekiq_role }" if sidekiq_roles.size > 1
-        yield(sidekiq_role)
-      end
-    end
-
-    def run_as(cmd)
-      opts = {
-        roles: sidekiq_role
-      }
-      su_user = fetch(:sidekiq_user)
-      opts[:shell] = "su - #{su_user}" if su_user
-      run cmd, opts
-    end
-
-    def quiet_process(pid_file, idx, sidekiq_role)
-      run_as "if [ -d #{current_path} ] && [ -f #{pid_file} ] && kill -0 `cat #{pid_file}`> /dev/null 2>&1; then cd #{current_path} && #{fetch(:sidekiqctl_cmd)} quiet #{pid_file} ; else echo 'Sidekiq is not running'; fi"
-    end
-
-    def stop_process(pid_file, idx, sidekiq_role)
-      run_as "if [ -d #{current_path} ] && [ -f #{pid_file} ] && kill -0 `cat #{pid_file}`> /dev/null 2>&1; then cd #{current_path} && #{fetch(:sidekiqctl_cmd)} stop #{pid_file} #{fetch :sidekiq_timeout} ; else echo 'Sidekiq is not running'; fi"
-    end
-
-    def start_process(pid_file, idx, sidekiq_role)
-      args = []
-      args.push "--index #{idx}"
-      args.push "--pidfile #{pid_file}"
-      args.push "--environment #{fetch(:sidekiq_env)}"
-      args.push "--tag #{fetch(:sidekiq_tag)}" if fetch(:sidekiq_tag)
-      args.push "--logfile #{fetch(:sidekiq_log)}" if fetch(:sidekiq_log)
-      args.push "--config #{fetch(:sidekiq_config)}" if fetch(:sidekiq_config)
-      args.push "--concurrency #{fetch(:sidekiq_concurrency)}" if fetch(:sidekiq_concurrency)
-      fetch(:sidekiq_queue).each do |queue|
-        args.push "--queue #{queue}"
-      end if fetch(:sidekiq_queue)
-
-      if process_options = fetch(:sidekiq_options_per_process)
-        args.push process_options[idx]
-      end
-
-      args.push fetch(:sidekiq_options)
-
-      if defined?(JRUBY_VERSION)
-        args.push '>/dev/null 2>&1 &'
-        logger.info 'Since JRuby doesn\'t support Process.daemon, Sidekiq will not be running as a daemon.'
-      else
-        args.push '--daemon'
-      end
-
-      run_as "if [ -d #{current_path} ] && [ ! -f #{pid_file} ] || ! kill -0 `cat #{pid_file}` > /dev/null 2>&1; then cd #{current_path} ; #{fetch(:sidekiq_cmd)} #{args.compact.join(' ')} ; else echo 'Sidekiq is already running'; fi"
-    end
-
-    desc 'Quiet sidekiq (stop accepting new work)'
-    task :quiet, roles: lambda { fetch(:sidekiq_role) }, on_no_matching_servers: :continue do
-      for_each_role do |sidekiq_role|
-        for_each_process(sidekiq_role) do |pid_file, idx|
-          quiet_process(pid_file, idx, sidekiq_role)
-        end
-      end
-    end
-
-    desc 'Stop sidekiq'
-    task :stop, roles: lambda { fetch(:sidekiq_role) }, on_no_matching_servers: :continue do
-      for_each_role do |sidekiq_role|
-        for_each_process(sidekiq_role) do |pid_file, idx|
-          stop_process(pid_file, idx, sidekiq_role)
-        end
-      end
-    end
-
-    desc 'Start sidekiq'
-    task :start, roles: lambda { fetch(:sidekiq_role) }, on_no_matching_servers: :continue do
-      for_each_role do |sidekiq_role|
-        for_each_process(sidekiq_role) do |pid_file, idx|
-          start_process(pid_file, idx, sidekiq_role)
-        end
-      end
-    end
-
-    desc 'Rolling-restart sidekiq'
-    task :rolling_restart, roles: lambda { fetch(:sidekiq_role) }, on_no_matching_servers: :continue do
-      for_each_role do |sidekiq_role|
-        for_each_process(sidekiq_role) do |pid_file, idx|
-          stop_process(pid_file, idx, sidekiq_role)
-          start_process(pid_file, idx, sidekiq_role)
-        end
-      end
-    end
-
-    desc 'Restart sidekiq'
-    task :restart, roles: lambda { fetch(:sidekiq_role) }, on_no_matching_servers: :continue do
-      stop
-      start
-    end
-
-  end
-end