capistrano-sidekiq 2.3.1 → 3.0.0.alpha.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 69c753e231935baa29ba10cec37dba7dda56f3b4bc143313ea0704f3be234823
-  data.tar.gz: e95c44603f7696cd95b985f9fcb22918d16653eaf1b2acce45ddaaef48b8425f
+  metadata.gz: 1d2fab3d52e0ca2c2fdb94e71d21d87e543a3f605f4f822b4c8bf2794c5f8144
+  data.tar.gz: 2ede4bc9269188112bef354fc06e2fa7ddb6f1f8de1db57a3dc2cf24da10095f
 SHA512:
-  metadata.gz: 62ec5153286616b7843061a9e447fd43c9c155125152d29695ef894570d6049905c4a65d676aed50b62384bd1c6b440f596c2b2ff2b5e3b3c87d230986e51d7c
-  data.tar.gz: bc0dd086283e7eaaef125571e36fb4124f022bcae0700642705d2f45699f71883351c68d4405be068450af046d3717fb82545fd5aa0c276e36f6dff8ee56d9c1
+  metadata.gz: c6651700dda4403c8b3e23d2da8f2d7c685c8ae36311cfdea998a1e731de7b87279ad0a354ba9d9da537f10c6735a2e8277f24f04e4a6748d9f70ce63617232c
+  data.tar.gz: adacca94a04e2a3ae569e4e94152b1b0a75c345a182aa7595776d75f3c7df789942539ea280a1545361b4610e4ba8e8cb23d72962ab1482a8a2ae26f2a3568e0

data/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## [Unreleased](https://github.com/seuros/capistrano-sidekiq/compare/v2.3.0...master)
+- Rewrite to match capistrano3-puma api
+- Add support for multiple sidekiq configs (processes and queues can be configured with erb)
+- Add support to multiple EnvironmentFile
+- Add support to multiple EnvironmentVariables
+- Default role for sidekiq is now :worker instead of :app
+
 ## [2.3.0](https://github.com/seuros/capistrano-sidekiq/tree/2.3.0) (2022-05-17)
 
 [Full Changelog](https://github.com/seuros/capistrano-sidekiq/compare/v2.2.0...2.3.0)

data/README.md

@@ -16,78 +16,27 @@ And then execute:
 ## Usage
 ```ruby
     # 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::Monit  # tests needed
 ```
 
-
 Configurable options - Please ensure you check your version's branch for the available settings - shown here with defaults:
 
 ```ruby
-:sidekiq_roles => :app
+:sidekiq_roles => :worker
 :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')
 # 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
-:sidekiq_lingering_user => nil
-
-# sidekiq monit
-:sidekiq_monit_templates_path => 'config/deploy/templates'
-:sidekiq_monit_conf_dir => '/etc/monit/conf.d'
-:sidekiq_monit_use_sudo => true
-:monit_bin => '/usr/bin/monit'
-:sidekiq_monit_default_hooks => true
-:sidekiq_monit_group => nil
-:sidekiq_service_name => "sidekiq_#{fetch(:application)}"
-
-:sidekiq_user => nil #user to run sidekiq as
-```
-See `capistrano/sidekiq/helpers.rb` for other undocumented configuration settings.
-
-## Bundler
-
-If you'd like to prepend `bundle exec` to your sidekiq and sidekiqctl calls, modify the SSHKit command maps
-in your deploy.rb file:
-```ruby
-SSHKit.config.command_map[:sidekiq] = "bundle exec sidekiq"
-SSHKit.config.command_map[:sidekiqctl] = "bundle exec sidekiqctl"
-```
-
-
-## Customizing the monit sidekiq templates
-
-If you need change some config in redactor, you can
-
-```
-bundle exec rails generate capistrano:sidekiq:monit:template
+:sidekiq_config_files, ['sidekiq.yml']
+# multiple configs
+:sidekiq_config_files, ['sidekiq.yml', 'sidekiq-2.yml'] #  you can also set it per server
 ```
 
-If your deploy user has no need in `sudo` for using monit, you can disable it as follows:
+## Example
 
-```ruby
-set :sidekiq_monit_use_sudo, false
-```
+A sample application is provided to show how to use this gem at https://github.com/seuros/capistrano-example-app
 
 ## Configuring the log files on systems with less recent Systemd versions
 

data/lib/capistrano/sidekiq/systemd.rb

@@ -2,18 +2,45 @@
 
 module Capistrano
   class Sidekiq::Systemd < Capistrano::Plugin
-    include Sidekiq::Helpers
-
+    include SidekiqCommon
+    def define_tasks
+      eval_rakefile File.expand_path('../tasks/systemd.rake', __dir__)
+    end
     def set_defaults
-      set_if_empty :sidekiq_service_unit_name, 'sidekiq' # This will change in version 3.0.0 to {application}_sidekiq_{stage}
-      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'
+      set_if_empty :systemctl_bin, '/bin/systemctl'
+      set_if_empty :service_unit_user, :user
+      set_if_empty :systemctl_user, fetch(:service_unit_user, :user) == :user
+
+      set_if_empty :sidekiq_service_unit_name, -> { "#{fetch(:application)}_sidekiq_#{fetch(:stage)}" }
+      set_if_empty :sidekiq_lingering_user, -> { fetch(:lingering_user, fetch(:user)) }
+
+      ## Sidekiq could have a stripped down or more complex version of the environment variables
+      set_if_empty :sidekiq_service_unit_env_files, -> { fetch(:service_unit_env_files, []) }
+      set_if_empty :sidekiq_service_unit_env_vars, -> { fetch(:service_unit_env_vars, []) }
+
+      set_if_empty :sidekiq_service_templates_path, fetch(:service_templates_path, 'config/deploy/templates')
     end
 
-    def define_tasks
-      eval_rakefile File.expand_path('../tasks/systemd.rake', __dir__)
+    def systemd_command(*args)
+      command = [fetch(:systemctl_bin)]
+
+      unless fetch(:service_unit_user) == :system
+        command << "--user"
+      end
+
+      command + args
+    end
+
+    def sudo_if_needed(*command)
+      if fetch(:service_unit_user) == :system
+        backend.sudo command.map(&:to_s).join(" ")
+      else
+        backend.execute(*command)
+      end
+    end
+
+    def execute_systemd(*args)
+      sudo_if_needed(*systemd_command(*args))
     end
   end
 end

data/lib/capistrano/sidekiq/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Capistrano
-  SidekiqVERSION = '2.3.1'
+  SidekiqVERSION = '3.0.0.alpha.1'
 end

data/lib/capistrano/sidekiq.rb

@@ -4,6 +4,51 @@ require 'capistrano/bundler'
 require 'capistrano/plugin'
 
 module Capistrano
+  module SidekiqCommon
+    def compiled_template(config_file = "sidekiq.yml")
+      @config_file = config_file
+      local_template_directory = fetch(:sidekiq_service_templates_path)
+      search_paths = [
+        File.join(local_template_directory, 'sidekiq.service.capistrano.erb'),
+        File.expand_path(
+          File.join(*%w[.. templates sidekiq.service.capistrano.erb]),
+          __FILE__
+        )
+      ]
+      template_path = search_paths.detect { |path| File.file?(path) }
+      template = File.read(template_path)
+      ERB.new(template, trim_mode: '-').result(binding)
+    end
+
+    def expanded_bundle_path
+      backend.capture(:echo, SSHKit.config.command_map[:bundle]).strip
+    end
+
+    def sidekiq_config
+      "--config config/#{@config_file}" if @config_file != "sidekiq.yml"
+    end
+
+    def switch_user(role, &block)
+      su_user = sidekiq_user(role)
+      if su_user == role.user
+        yield
+      else
+        as su_user, &block
+      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
+  end
   class Sidekiq < Capistrano::Plugin
     def define_tasks
       eval_rakefile File.expand_path('tasks/sidekiq.rake', __dir__)
@@ -13,9 +58,14 @@ module Capistrano
       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_roles, fetch(:sidekiq_role, :worker)
+      set_if_empty :sidekiq_configs, %w[sidekiq]  # sidekiq.yml
+
       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') }
+      set_if_empty :sidekiq_error_log, -> { File.join(shared_path, 'log', 'sidekiq.log') }
+
+      set_if_empty :sidekiq_config_files, ['sidekiq.yml']
+
       # Rbenv, Chruby, and RVM integration
       append :rbenv_map_bins, 'sidekiq', 'sidekiqctl'
       append :rvm_map_bins, 'sidekiq', 'sidekiqctl'
@@ -26,6 +76,4 @@ module Capistrano
   end
 end
 
-require_relative 'sidekiq/helpers'
 require_relative 'sidekiq/systemd'
-require_relative 'sidekiq/monit'

data/lib/capistrano/tasks/systemd.rake

@@ -1,4 +1,3 @@
-# encoding: UTF-8
 # frozen_string_literal: true
 
 git_plugin = self
@@ -7,59 +6,17 @@ 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'
+    status: 'Get Sidekiq Status',
+    restart: 'Restart Sidekiq'
   }
   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
+          git_plugin.config_files(role).each do |config_file|
+            git_plugin.execute_systemd(command, git_plugin.sidekiq_service_file_name(config_file))
           end
-
-          git_plugin.systemctl_command(:stop, process: process)
-          git_plugin.systemctl_command(:start, process: process)
         end
       end
     end
@@ -69,229 +26,121 @@ namespace :sidekiq do
   task :quiet do
     on roles fetch(:sidekiq_roles) do |role|
       git_plugin.switch_user(role) do
-        git_plugin.quiet_sidekiq
+        git_plugin.quiet_sidekiq(role)
       end
     end
   end
 
-  desc 'Install systemd sidekiq service'
+  desc 'Install Sidekiq systemd 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
+        git_plugin.create_systemd_template(role)
       end
     end
+    invoke 'sidekiq:enable'
   end
 
-  desc 'Uninstall systemd sidekiq service'
+  desc 'Uninstall Sidekiq systemd service'
   task :uninstall do
+    invoke 'sidekiq:disable'
     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
-        )
+        git_plugin.rm_systemd_service(role)
       end
     end
   end
 
-  desc 'Generate service_locally'
-  task :generate_service_locally do
-    run_locally do
-      File.write('sidekiq', git_plugin.compiled_template)
-    end
-  end
+  desc 'Enable Sidekiq systemd service'
+  task :enable do
+    on roles(fetch(:sidekiq_roles)) do |role|
+      git_plugin.config_files(role).each do |config_file|
+        git_plugin.execute_systemd("enable", git_plugin.sidekiq_service_file_name(config_file))
+      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')
+      if fetch(:systemctl_user) && fetch(:sidekiq_lingering_user)
+        execute :loginctl, "enable-linger", fetch(:puma_lingering_user)
+      end
     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)
+  desc 'Disable Sidekiq systemd service'
+  task :disable do
+    on roles(fetch(:sidekiq_roles)) do |role|
+      git_plugin.config_files(role).each do |config_file|
+        git_plugin.execute_systemd("disable", git_plugin.sidekiq_service_file_name(config_file))
+      end
+    end
   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
+  def fetch_systemd_unit_path
+    if fetch(:puma_systemctl_user) == :system
+      "/etc/systemd/system/"
     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
+      home_dir = backend.capture :pwd
+      File.join(home_dir, ".config", "systemd", "user")
     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
+  def create_systemd_template(role)
+    systemd_path = fetch(:service_unit_path, fetch_systemd_unit_path)
+    backend.execute :mkdir, '-p', systemd_path if fetch(:systemctl_user)
+
+    config_files(role).each do |config_file|
+        ctemplate = compiled_template(config_file)
+        temp_file_name = File.join('/tmp', "sidekiq.#{config_file}.service")
+        systemd_file_name = File.join(systemd_path, sidekiq_service_file_name(config_file))
+        backend.upload!(StringIO.new(ctemplate), temp_file_name)
+        if fetch(:systemctl_user)
+          warn "Moving #{temp_file_name} to #{systemd_file_name}"
+          backend.execute :mv, temp_file_name, systemd_file_name
+        else
+          warn "Installing #{systemd_file_name} as root"
+          backend.execute :sudo, :mv, temp_file_name, systemd_file_name
+        end
     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 rm_systemd_service(role)
+    systemd_path = fetch(:service_unit_path, fetch_systemd_unit_path)
 
-  def systemctl_command(*args, process: nil)
-    execute_array =
-      if fetch(:sidekiq_service_unit_user) == :system
-        %i[sudo systemctl]
+    config_files(role).each do |config_file|
+      systemd_file_name = File.join(systemd_path, sidekiq_service_file_name(config_file))
+      if fetch(:systemctl_user)
+        warn "Deleting #{systemd_file_name}"
+        backend.execute :rm, "-f", systemd_file_name
       else
-        [:systemctl, '--user']
+        warn "Deleting #{systemd_file_name} as root"
+        backend.execute :sudo, :rm, "-f", systemd_file_name
       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
+  def quiet_sidekiq(role)
+    config_files(role).each do |config_file|
+      sidekiq_service = sidekiq_service_unit_name(config_file)
+      warn "Quieting #{sidekiq_service}"
+      execute_systemd("kill -s TSTP", sidekiq_service)
     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}"
+  def sidekiq_service_unit_name(config_file)
+    if config_file != "sidekiq.yml"
+      fetch(:sidekiq_service_unit_name) + "." + config_file.split(".")[0..-2].join(".")
     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 sidekiq_service_file_name(config_file)
+    ## Remove the extension
+    config_file = config_file.split('.')[0..-1].join('.')
 
-  def config_per_process?
-    fetch(:sidekiq_config).is_a?(Array)
-  end
-
-  def process_block
-    (1..sidekiq_processes).each do |process|
-      yield(process)
-    end
+    "#{sidekiq_service_unit_name(config_file)}.service"
   end
 
-  def duration(start_time)
-    Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time
+  def config_files(role)
+    role.properties.fetch(:sidekiq_config_files) ||
+      fetch(:sidekiq_config_files)
   end
 end

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

@@ -0,0 +1,45 @@
+# 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.
+
+# Then run:
+#   - systemctl enable <%= sidekiq_service_unit_name(@config_file) %>
+#   - systemctl {start,stop,restart} <%= sidekiq_service_unit_name(@config_file) %>
+#
+# Use `journalctl -u <%= sidekiq_service_unit_name(@config_file) %> -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
+
+[Service]
+Type=notify
+# If your Sidekiq process locks up, systemd's watchdog will restart it within seconds.
+WatchdogSec=10
+<%="User=#{sidekiq_user}" if fetch(:sidekiq_systemctl_user) == :system %>
+WorkingDirectory=<%= current_path %>
+ExecStart=<%= expanded_bundle_path %> exec sidekiq -e <%= fetch(:sidekiq_env) %> <%= sidekiq_config %>
+
+# Use `systemctl kill -s TSTP <% sidekiq_service_unit_name(@config_file) %>` to quiet the Sidekiq process
+UMask=0002
+
+<%- Array(fetch(:sidekiq_service_unit_env_files)).each do |file| %>
+<%="EnvironmentFile=#{file}" %>
+<% end -%>
+<% Array(fetch(:sidekiq_service_unit_env_vars)).each do |environment_variable| %>
+<%="Environment=\"#{environment_variable}\"" %>
+<% end -%>
+
+# if we crash, restart
+RestartSec=1
+Restart=on-failure
+
+<%="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(@config_file) %>
+[Install]
+WantedBy=<%=(fetch(:sidekiq_systemctl_user) == :system) ? "multi-user.target" : "default.target"%>

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: capistrano-sidekiq
 version: !ruby/object:Gem::Version
-  version: 2.3.1
+  version: 3.0.0.alpha.1
 platform: ruby
 authors:
 - Abdelkader Boudih
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-07-11 00:00:00.000000000 Z
+date: 2022-10-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: capistrano
@@ -44,14 +44,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '6.0'
+        version: 6.0.6
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '6.0'
+        version: 6.0.6
 description: Sidekiq integration for Capistrano
 email:
 - terminale@gmail.com
@@ -59,31 +59,24 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".gitignore"
-- ".tool-versions"
 - CHANGELOG.md
-- Gemfile
 - LICENSE.txt
 - README.md
-- Rakefile
-- 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/monit.rake
 - lib/capistrano/tasks/sidekiq.rake
 - lib/capistrano/tasks/systemd.rake
+- lib/capistrano/templates/sidekiq.service.capistrano.erb
 - 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: "\n    Version 3.0.0 is a major release. Please see README.md,
+  breaking changes are listed in CHANGELOG.md\n  "
 rdoc_options: []
 require_paths:
 - lib
@@ -91,14 +84,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.0.0
+      version: 2.5.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
-rubygems_version: 3.4.10
+rubygems_version: 3.1.6
 signing_key: 
 specification_version: 4
 summary: Sidekiq integration for Capistrano

data/.gitignore

@@ -1,19 +0,0 @@
-*.gem
-*.rbc
-.bundle
-.config
-.yardoc
-Gemfile.lock
-InstalledFiles
-_yardoc
-coverage
-doc/
-lib/bundler/man
-pkg
-rdoc
-spec/reports
-test/tmp
-test/version_tmp
-tmp
-.idea
-*.iml

data/.tool-versions

@@ -1 +0,0 @@
-ruby 2.7.6

data/Gemfile

@@ -1,8 +0,0 @@
-source 'https://rubygems.org'
-
-# Specify your gem's dependencies in capistrano-sidekiq.gemspec
-gemspec
-
-gem "bump", "~> 0.10.0"
-
-gem "github_changelog_generator", "~> 1.16"

data/Rakefile

@@ -1,9 +0,0 @@
-require "bundler/gem_tasks"
-require 'github_changelog_generator/task'
-
-GitHubChangelogGenerator::RakeTask.new :changelog do |config|
-  config.user = 'seuros'
-  config.project = 'capistrano-sidekiq'
-  config.issues = false
-  config.future_release = '2.3.0'
-end

data/capistrano-sidekiq.gemspec

@@ -1,22 +0,0 @@
-lib = File.expand_path('../lib', __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'capistrano/sidekiq/version'
-
-Gem::Specification.new do |spec|
-  spec.name = 'capistrano-sidekiq'
-  spec.version = Capistrano::SidekiqVERSION
-  spec.authors = ['Abdelkader Boudih']
-  spec.email = ['terminale@gmail.com']
-  spec.summary = %q{Sidekiq integration for Capistrano}
-  spec.description = %q{Sidekiq integration for Capistrano}
-  spec.homepage = 'https://github.com/seuros/capistrano-sidekiq'
-  spec.license = 'LGPL-3.0'
-
-  spec.required_ruby_version     = '>= 2.0.0'
-  spec.files = `git ls-files`.split($/)
-  spec.require_paths = ['lib']
-
-  spec.add_dependency 'capistrano', '>= 3.9.0'
-  spec.add_dependency 'capistrano-bundler'
-  spec.add_dependency 'sidekiq', '>= 6.0'
-end

data/lib/capistrano/sidekiq/helpers.rb

@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-
-module Capistrano
-  module Sidekiq::Helpers
-
-    def sidekiq_require
-      "--require #{fetch(:sidekiq_require)}" if fetch(:sidekiq_require)
-    end
-
-    def sidekiq_config
-      "--config #{fetch(:sidekiq_config)}" if fetch(:sidekiq_config)
-    end
-
-    def sidekiq_concurrency
-      "--concurrency #{fetch(:sidekiq_concurrency)}" if fetch(:sidekiq_concurrency)
-    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, &block)
-      su_user = sidekiq_user(role)
-      if su_user == role.user
-        yield
-      else
-        as su_user, &block
-      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,21 +0,0 @@
-# frozen_string_literal: true
-
-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'
-      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', __dir__)
-    end
-  end
-end

data/lib/capistrano/tasks/monit.rake

@@ -1,127 +0,0 @@
-git_plugin = self
-
-namespace :deploy do
-  before :starting, :check_sidekiq_monit_hooks do
-    if fetch(:sidekiq_default_hooks) && fetch(:sidekiq_monit_default_hooks)
-      invoke 'sidekiq:monit:add_default_hooks'
-    end
-  end
-end
-
-namespace :sidekiq do
-  namespace :monit do
-    task :add_default_hooks do
-      before 'deploy:updating',  'sidekiq:monit:unmonitor'
-      after  'deploy:published', 'sidekiq:monit:monitor'
-    end
-
-    desc 'Config Sidekiq monit-service'
-    task :config do
-      on roles(fetch(:sidekiq_roles)) do |role|
-        @role = role
-        git_plugin.upload_sidekiq_template 'sidekiq_monit', "#{fetch(:tmp_dir)}/monit.conf", @role
-
-        git_plugin.switch_user(role) do
-          mv_command = "mv #{fetch(:tmp_dir)}/monit.conf #{fetch(:sidekiq_monit_conf_dir)}/#{fetch(:sidekiq_monit_conf_file)}"
-
-          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 |role|
-        git_plugin.switch_user(role) do
-          begin
-            git_plugin.sudo_if_needed "#{fetch(:monit_bin)} monitor #{git_plugin.sidekiq_service_name}"
-          rescue
-            invoke 'sidekiq:monit:config'
-            git_plugin.sudo_if_needed "#{fetch(:monit_bin)} monitor #{git_plugin.sidekiq_service_name}"
-          end
-        end
-      end
-    end
-
-    desc 'Unmonitor Sidekiq monit-service'
-    task :unmonitor do
-      on roles(fetch(:sidekiq_roles)) do |role|
-        git_plugin.switch_user(role) do
-          begin
-            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 |role|
-      git_plugin.switch_user(role) do
-        git_plugin.sudo_if_needed "#{fetch(:monit_bin)} start #{git_plugin.sidekiq_service_name}"
-      end
-    end
-  end
-
-  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
-
-  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_service_name
-    fetch(:sidekiq_service_name, "sidekiq_#{fetch(:application)}_#{fetch(:sidekiq_env)}")
-  end
-
-  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 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)
-
-    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__
-    )
-
-    search_paths << global_search_path
-
-    template_path = search_paths.detect { |path| File.file?(path) }
-    File.read(template_path)
-  end
-end

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

@@ -1,68 +0,0 @@
-# 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