capistrano-sidekiq 2.2.0 → 3.0.0.alpha.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2f55ede23a48a3ff9319774a09692f01137ae02ef54b6f27bead18518650973c
-  data.tar.gz: 3587deeffde5524d5390e0fc60e474c0bf1c34c048422a15a30efc8cb5460ca2
+  metadata.gz: 1d2fab3d52e0ca2c2fdb94e71d21d87e543a3f605f4f822b4c8bf2794c5f8144
+  data.tar.gz: 2ede4bc9269188112bef354fc06e2fa7ddb6f1f8de1db57a3dc2cf24da10095f
 SHA512:
-  metadata.gz: 46b1223d92a931beed504100ed25debb4c1b5d0a98a0e60b279c0d283ac5356a5ed5c3d80b87dbe8220cc8faa60999ab3d1266147ff22d1968b8545e313a1f00
-  data.tar.gz: da0d5e2e30b0fefc4a1e37beae281bbbba52417fa4446f13bcff69bb395df9250945797f76a039ae5774574d24ca7b2d563c2f4013fa8726faaa00b3d66c857a
+  metadata.gz: c6651700dda4403c8b3e23d2da8f2d7c685c8ae36311cfdea998a1e731de7b87279ad0a354ba9d9da537f10c6735a2e8277f24f04e4a6748d9f70ce63617232c
+  data.tar.gz: adacca94a04e2a3ae569e4e94152b1b0a75c345a182aa7595776d75f3c7df789942539ea280a1545361b4610e4ba8e8cb23d72962ab1482a8a2ae26f2a3568e0

data/CHANGELOG.md

@@ -1,8 +1,25 @@
 # Changelog
 
-## [2.2.0](https://github.com/seuros/capistrano-sidekiq/tree/2.2.0) (2022-05-16)
+## [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
 
-[Full Changelog](https://github.com/seuros/capistrano-sidekiq/compare/v2.1.0...2.2.0)
+## [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)
+
+**Merged pull requests:**
+
+- fix sidekiq processes naming when count is 1 [\#300](https://github.com/seuros/capistrano-sidekiq/pull/300) ([seuros](https://github.com/seuros))
+- Support multiple processes in `sidekiq:install` [\#299](https://github.com/seuros/capistrano-sidekiq/pull/299) ([lloydwatkin](https://github.com/lloydwatkin))
+- fix: monit config template [\#288](https://github.com/seuros/capistrano-sidekiq/pull/288) ([jpickwell](https://github.com/jpickwell))
+
+## [v2.2.0](https://github.com/seuros/capistrano-sidekiq/tree/v2.2.0) (2022-05-16)
+
+[Full Changelog](https://github.com/seuros/capistrano-sidekiq/compare/v2.1.0...v2.2.0)
 
 **Merged pull requests:**
 
@@ -270,3 +287,7 @@
 - More robust version checking [\#4](https://github.com/seuros/capistrano-sidekiq/pull/4) ([jlecour](https://github.com/jlecour))
 - More explicit start command [\#3](https://github.com/seuros/capistrano-sidekiq/pull/3) ([jlecour](https://github.com/jlecour))
 - Improve pid and log files settings [\#1](https://github.com/seuros/capistrano-sidekiq/pull/1) ([jlecour](https://github.com/jlecour))
+
+
+
+\* *This Changelog was automatically generated by [github_changelog_generator](https://github.com/github-changelog-generator/github-changelog-generator)*

data/README.md

@@ -16,87 +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::Upstart  # tests needed
-    # 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.
-
-## Known issues with Capistrano 3
-
-There is a known bug that prevents sidekiq from starting when pty is true on Capistrano 3.
-```ruby
-set :pty,  false
-```
-
-## 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"
+:sidekiq_config_files, ['sidekiq.yml']
+# multiple configs
+:sidekiq_config_files, ['sidekiq.yml', 'sidekiq-2.yml'] #  you can also set it per server
 ```
 
+## Example
 
-## Customizing the monit sidekiq templates
-
-If you need change some config in redactor, you can
-
-```
-bundle exec rails generate capistrano:sidekiq:monit:template
-```
-
-If your deploy user has no need in `sudo` for using monit, you can disable it as follows:
-
-```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

@@ -1,17 +1,46 @@
+# frozen_string_literal: true
+
 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
-      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', __FILE__)
+    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,3 +1,5 @@
+# frozen_string_literal: true
+
 module Capistrano
-  SidekiqVERSION = '2.2.0'
+  SidekiqVERSION = '3.0.0.alpha.1'
 end

data/lib/capistrano/sidekiq.rb

@@ -1,19 +1,71 @@
+# frozen_string_literal: true
+
 require 'capistrano/bundler'
-require "capistrano/plugin"
+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', __FILE__)
+      eval_rakefile File.expand_path('tasks/sidekiq.rake', __dir__)
     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_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'
@@ -21,11 +73,7 @@ module Capistrano
       # Bundler integration
       append :bundle_bins, 'sidekiq', 'sidekiqctl'
     end
-
   end
 end
 
-require_relative 'sidekiq/helpers'
 require_relative 'sidekiq/systemd'
-require_relative 'sidekiq/upstart'
-require_relative 'sidekiq/monit'

data/lib/capistrano/tasks/systemd.rake

@@ -6,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
@@ -68,226 +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)
-    systemd_file_name = File.join(systemd_path, sidekiq_service_file_name)
-
-    backend.execute :mkdir, '-p', systemd_path if fetch(:sidekiq_service_unit_user) == :user
-
-    temp_file_name = File.join('/tmp', sidekiq_service_file_name)
-    backend.upload!(StringIO.new(ctemplate), temp_file_name)
-    if fetch(:sidekiq_service_unit_user) == :system
-      backend.execute :sudo, :mv, temp_file_name, systemd_file_name
-      backend.execute :sudo, :systemctl, 'daemon-reload'
+  def fetch_systemd_unit_path
+    if fetch(:puma_systemctl_user) == :system
+      "/etc/systemd/system/"
     else
-      backend.execute :mv, temp_file_name, systemd_file_name
-      backend.execute :systemctl, '--user', 'daemon-reload'
+      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
-      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
-      )
+  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
-    "--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
-    "#{fetch(:sidekiq_service_unit_name)}.service"
-  end
-
-  def sidekiq_service_unit_name(process: nil)
-    if process
-      "#{fetch(:sidekiq_service_unit_name)}@#{process}"
-    elsif sidekiq_processes > 1
-      "#{fetch(:sidekiq_service_unit_name)}@{1..#{sidekiq_processes}}"
+  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)
-    file_name = 'sidekiq_systemd_'
-    file_name << (process&.to_s || '%i')
-    "#{file_name}.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