capistrano-sidekiq 2.0.0 → 2.3.0

Sign up to get free protection for your applications and to get access to all the features.
@@ -1,14 +1,4 @@
1
- namespace :load do
2
- task :defaults do
3
- set :sidekiq_monit_conf_dir, '/etc/monit/conf.d'
4
- set :sidekiq_monit_conf_file, -> { "#{sidekiq_service_name}.conf" }
5
- set :sidekiq_monit_use_sudo, true
6
- set :monit_bin, '/usr/bin/monit'
7
- set :sidekiq_monit_default_hooks, true
8
- set :sidekiq_monit_templates_path, 'config/deploy/templates'
9
- set :sidekiq_monit_group, nil
10
- end
11
- end
1
+ git_plugin = self
12
2
 
13
3
  namespace :deploy do
14
4
  before :starting, :check_sidekiq_monit_hooks do
@@ -20,7 +10,6 @@ end
20
10
 
21
11
  namespace :sidekiq do
22
12
  namespace :monit do
23
-
24
13
  task :add_default_hooks do
25
14
  before 'deploy:updating', 'sidekiq:monit:unmonitor'
26
15
  after 'deploy:published', 'sidekiq:monit:monitor'
@@ -30,24 +19,26 @@ namespace :sidekiq do
30
19
  task :config do
31
20
  on roles(fetch(:sidekiq_roles)) do |role|
32
21
  @role = role
33
- upload_sidekiq_template 'sidekiq_monit', "#{fetch(:tmp_dir)}/monit.conf", @role
22
+ git_plugin.upload_sidekiq_template 'sidekiq_monit', "#{fetch(:tmp_dir)}/monit.conf", @role
34
23
 
35
- mv_command = "mv #{fetch(:tmp_dir)}/monit.conf #{fetch(:sidekiq_monit_conf_dir)}/#{fetch(:sidekiq_monit_conf_file)}"
36
- sudo_if_needed mv_command
24
+ git_plugin.switch_user(role) do
25
+ mv_command = "mv #{fetch(:tmp_dir)}/monit.conf #{fetch(:sidekiq_monit_conf_dir)}/#{fetch(:sidekiq_monit_conf_file)}"
37
26
 
38
- sudo_if_needed "#{fetch(:monit_bin)} reload"
27
+ git_plugin.sudo_if_needed mv_command
28
+ git_plugin.sudo_if_needed "#{fetch(:monit_bin)} reload"
29
+ end
39
30
  end
40
31
  end
41
32
 
42
33
  desc 'Monitor Sidekiq monit-service'
43
34
  task :monitor do
44
- on roles(fetch(:sidekiq_roles)) do
45
- fetch(:sidekiq_processes).times do |idx|
35
+ on roles(fetch(:sidekiq_roles)) do |role|
36
+ git_plugin.switch_user(role) do
46
37
  begin
47
- sudo_if_needed "#{fetch(:monit_bin)} monitor #{sidekiq_service_name(idx)}"
38
+ git_plugin.sudo_if_needed "#{fetch(:monit_bin)} monitor #{git_plugin.sidekiq_service_name}"
48
39
  rescue
49
40
  invoke 'sidekiq:monit:config'
50
- sudo_if_needed "#{fetch(:monit_bin)} monitor #{sidekiq_service_name(idx)}"
41
+ git_plugin.sudo_if_needed "#{fetch(:monit_bin)} monitor #{git_plugin.sidekiq_service_name}"
51
42
  end
52
43
  end
53
44
  end
@@ -55,114 +46,82 @@ namespace :sidekiq do
55
46
 
56
47
  desc 'Unmonitor Sidekiq monit-service'
57
48
  task :unmonitor do
58
- on roles(fetch(:sidekiq_roles)) do
59
- fetch(:sidekiq_processes).times do |idx|
49
+ on roles(fetch(:sidekiq_roles)) do |role|
50
+ git_plugin.switch_user(role) do
60
51
  begin
61
- sudo_if_needed "#{fetch(:monit_bin)} unmonitor #{sidekiq_service_name(idx)}"
52
+ git_plugin.sudo_if_needed "#{fetch(:monit_bin)} unmonitor #{git_plugin.sidekiq_service_name}"
62
53
  rescue
63
54
  # no worries here
64
55
  end
65
56
  end
66
57
  end
67
58
  end
59
+ end
68
60
 
69
- desc 'Start Sidekiq monit-service'
70
- task :start do
71
- on roles(fetch(:sidekiq_roles)) do
72
- fetch(:sidekiq_processes).times do |idx|
73
- sudo_if_needed "#{fetch(:monit_bin)} start #{sidekiq_service_name(idx)}"
74
- end
75
- end
76
- end
77
-
78
- desc 'Stop Sidekiq monit-service'
79
- task :stop do
80
- on roles(fetch(:sidekiq_roles)) do
81
- fetch(:sidekiq_processes).times do |idx|
82
- sudo_if_needed "#{fetch(:monit_bin)} stop #{sidekiq_service_name(idx)}"
83
- end
84
- end
85
- end
86
-
87
- desc 'Restart Sidekiq monit-service'
88
- task :restart do
89
- on roles(fetch(:sidekiq_roles)) do
90
- fetch(:sidekiq_processes).times do |idx|
91
- sudo_if_needed"#{fetch(:monit_bin)} restart #{sidekiq_service_name(idx)}"
92
- end
93
- end
94
- end
95
-
96
- def sidekiq_service_name(index=nil)
97
- fetch(:sidekiq_service_name, "sidekiq_#{fetch(:application)}_#{fetch(:sidekiq_env)}") + (index ? "_#{index}" : '')
98
- end
99
-
100
- def sidekiq_config
101
- if fetch(:sidekiq_config)
102
- "--config #{fetch(:sidekiq_config)}"
103
- end
104
- end
105
-
106
- def sidekiq_concurrency
107
- if fetch(:sidekiq_concurrency)
108
- "--concurrency #{fetch(:sidekiq_concurrency)}"
61
+ desc 'Start Sidekiq monit-service'
62
+ task :start do
63
+ on roles(fetch(:sidekiq_roles)) do |role|
64
+ git_plugin.switch_user(role) do
65
+ git_plugin.sudo_if_needed "#{fetch(:monit_bin)} start #{git_plugin.sidekiq_service_name}"
109
66
  end
110
67
  end
68
+ end
111
69
 
112
- def sidekiq_queues
113
- Array(fetch(:sidekiq_queue)).map do |queue|
114
- "--queue #{queue}"
115
- end.join(' ')
116
- end
117
-
118
- def sidekiq_logfile
119
- if fetch(:sidekiq_log)
120
- "--logfile #{fetch(:sidekiq_log)}"
70
+ desc 'Stop Sidekiq monit-service'
71
+ task :stop do
72
+ on roles(fetch(:sidekiq_roles)) do |role|
73
+ git_plugin.switch_user(role) do
74
+ git_plugin.sudo_if_needed "#{fetch(:monit_bin)} stop #{git_plugin.sidekiq_service_name}"
121
75
  end
122
76
  end
77
+ end
123
78
 
124
- def sidekiq_require
125
- if fetch(:sidekiq_require)
126
- "--require #{fetch(:sidekiq_require)}"
127
- end
79
+ desc 'Restart Sidekiq monit-service'
80
+ task :restart do
81
+ on roles(fetch(:sidekiq_roles)) do |role|
82
+ git_plugin.sudo_if_needed "#{fetch(:monit_bin)} restart #{git_plugin.sidekiq_service_name}"
128
83
  end
84
+ end
129
85
 
130
- def sidekiq_options_per_process
131
- fetch(:sidekiq_options_per_process) || []
132
- end
86
+ def sidekiq_service_name
87
+ fetch(:sidekiq_service_name, "sidekiq_#{fetch(:application)}_#{fetch(:sidekiq_env)}")
88
+ end
133
89
 
134
- def sudo_if_needed(command)
135
- send(use_sudo? ? :sudo : :execute, command)
90
+ def sudo_if_needed(command)
91
+ if use_sudo?
92
+ backend.execute :sudo, command
93
+ else
94
+ backend.execute command
136
95
  end
96
+ end
137
97
 
138
- def use_sudo?
139
- fetch(:sidekiq_monit_use_sudo)
140
- end
98
+ def use_sudo?
99
+ fetch(:sidekiq_monit_use_sudo)
100
+ end
141
101
 
142
- def upload_sidekiq_template(from, to, role)
143
- template = sidekiq_template(from, role)
144
- upload!(StringIO.new(ERB.new(template).result(binding)), to)
145
- end
102
+ def upload_sidekiq_template(from, to, role)
103
+ template = sidekiq_template(from, role)
104
+ backend.upload!(StringIO.new(ERB.new(template).result(binding)), to)
105
+ end
146
106
 
147
- def sidekiq_template(name, role)
148
- local_template_directory = fetch(:sidekiq_monit_templates_path)
107
+ def sidekiq_template(name, role)
108
+ local_template_directory = fetch(:sidekiq_monit_templates_path)
149
109
 
150
- search_paths = [
151
- "#{name}-#{role.hostname}-#{fetch(:stage)}.erb",
152
- "#{name}-#{role.hostname}.erb",
153
- "#{name}-#{fetch(:stage)}.erb",
154
- "#{name}.erb"
155
- ].map { |filename| File.join(local_template_directory, filename) }
110
+ search_paths = [
111
+ "#{name}-#{role.hostname}-#{fetch(:stage)}.erb",
112
+ "#{name}-#{role.hostname}.erb",
113
+ "#{name}-#{fetch(:stage)}.erb",
114
+ "#{name}.erb"
115
+ ].map { |filename| File.join(local_template_directory, filename) }
156
116
 
157
- global_search_path = File.expand_path(
158
- File.join(*%w[.. .. .. generators capistrano sidekiq monit templates], "#{name}.conf.erb"),
159
- __FILE__
160
- )
117
+ global_search_path = File.expand_path(
118
+ File.join(*%w[.. .. .. generators capistrano sidekiq monit templates], "#{name}.conf.erb"),
119
+ __FILE__
120
+ )
161
121
 
162
- search_paths << global_search_path
122
+ search_paths << global_search_path
163
123
 
164
- template_path = search_paths.detect { |path| File.file?(path) }
165
- File.read(template_path)
166
- end
124
+ template_path = search_paths.detect { |path| File.file?(path) }
125
+ File.read(template_path)
167
126
  end
168
127
  end
@@ -6,15 +6,9 @@ end
6
6
 
7
7
  namespace :sidekiq do
8
8
  task :add_default_hooks do
9
- after 'deploy:starting', 'sidekiq:quiet'
9
+ after 'deploy:starting', 'sidekiq:quiet' if Rake::Task.task_defined?('sidekiq:quiet')
10
10
  after 'deploy:updated', 'sidekiq:stop'
11
11
  after 'deploy:published', 'sidekiq:start'
12
12
  after 'deploy:failed', 'sidekiq:restart'
13
13
  end
14
-
15
- desc 'Restart sidekiq'
16
- task :restart do
17
- invoke! 'sidekiq:stop'
18
- invoke! 'sidekiq:start'
19
- end
20
14
  end
@@ -1,41 +1,74 @@
1
+ # frozen_string_literal: true
2
+
1
3
  git_plugin = self
2
4
 
3
5
  namespace :sidekiq do
4
- desc 'Quiet sidekiq (stop fetching new tasks from Redis)'
5
- task :quiet do
6
- on roles fetch(:sidekiq_roles) do |role|
7
- git_plugin.switch_user(role) do
8
- if fetch(:sidekiq_service_unit_user) == :system
9
- execute :sudo, :systemctl, "reload", fetch(:sidekiq_service_unit_name), raise_on_non_zero_exit: false
10
- else
11
- execute :systemctl, "--user", "reload", fetch(:sidekiq_service_unit_name), raise_on_non_zero_exit: false
6
+ standard_actions = {
7
+ start: 'Start Sidekiq',
8
+ stop: 'Stop Sidekiq (graceful shutdown within timeout, put unfinished tasks back to Redis)',
9
+ status: 'Get Sidekiq Status'
10
+ }
11
+ standard_actions.each do |command, description|
12
+ desc description
13
+ task command do
14
+ on roles fetch(:sidekiq_roles) do |role|
15
+ git_plugin.switch_user(role) do
16
+ git_plugin.systemctl_command(command)
12
17
  end
13
18
  end
14
19
  end
15
20
  end
16
21
 
17
- desc 'Stop sidekiq (graceful shutdown within timeout, put unfinished tasks back to Redis)'
18
- task :stop do
22
+ desc 'Restart Sidekiq (Quiet, Wait till workers finish or 30 seconds, Stop, Start)'
23
+ task :restart do
19
24
  on roles fetch(:sidekiq_roles) do |role|
20
25
  git_plugin.switch_user(role) do
21
- if fetch(:sidekiq_service_unit_user) == :system
22
- execute :sudo, :systemctl, "stop", fetch(:sidekiq_service_unit_name)
23
- else
24
- execute :systemctl, "--user", "stop", fetch(:sidekiq_service_unit_name)
26
+ git_plugin.quiet_sidekiq
27
+ git_plugin.process_block do |process|
28
+ start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
29
+ running = nil
30
+
31
+ # get running workers
32
+ while (running.nil? || running > 0) && git_plugin.duration(start_time) < 30 do
33
+ command_args =
34
+ if fetch(:sidekiq_service_unit_user) == :system
35
+ [:sudo, 'systemd-cgls']
36
+ else
37
+ ['systemd-cgls', '--user']
38
+ end
39
+ # need to pipe through tr -cd... to strip out systemd colors or you
40
+ # get log error messages for non UTF-8 characters.
41
+ command_args.push(
42
+ '-u', "#{git_plugin.sidekiq_service_unit_name(process: process)}.service",
43
+ '|', 'tr -cd \'\11\12\15\40-\176\''
44
+ )
45
+ status = capture(*command_args, raise_on_non_zero_exit: false)
46
+ status_match = status.match(/\[(?<running>\d+) of (?<total>\d+) busy\]/)
47
+ break unless status_match
48
+
49
+ running = status_match[:running]&.to_i
50
+
51
+ colors = SSHKit::Color.new($stdout)
52
+ if running.zero?
53
+ info colors.colorize("✔ Process ##{process}: No running workers. Shutting down for restart!", :green)
54
+ else
55
+ info colors.colorize("⧗ Process ##{process}: Waiting for #{running} workers.", :yellow)
56
+ sleep(1)
57
+ end
58
+ end
59
+
60
+ git_plugin.systemctl_command(:stop, process: process)
61
+ git_plugin.systemctl_command(:start, process: process)
25
62
  end
26
63
  end
27
64
  end
28
65
  end
29
66
 
30
- desc 'Start sidekiq'
31
- task :start do
67
+ desc 'Quiet Sidekiq (stop fetching new tasks from Redis)'
68
+ task :quiet do
32
69
  on roles fetch(:sidekiq_roles) do |role|
33
70
  git_plugin.switch_user(role) do
34
- if fetch(:sidekiq_service_unit_user) == :system
35
- execute :sudo, :systemctl, 'start', fetch(:sidekiq_service_unit_name)
36
- else
37
- execute :systemctl, '--user', 'start', fetch(:sidekiq_service_unit_name)
38
- end
71
+ git_plugin.quiet_sidekiq
39
72
  end
40
73
  end
41
74
  end
@@ -45,26 +78,35 @@ namespace :sidekiq do
45
78
  on roles fetch(:sidekiq_roles) do |role|
46
79
  git_plugin.switch_user(role) do
47
80
  git_plugin.create_systemd_template
48
- if fetch(:sidekiq_service_unit_user) == :system
49
- execute :sudo, :systemctl, "enable", fetch(:sidekiq_service_unit_name)
50
- else
51
- execute :systemctl, "--user", "enable", fetch(:sidekiq_service_unit_name)
52
- execute :loginctl, "enable-linger", fetch(:sidekiq_lingering_user) if fetch(:sidekiq_enable_lingering)
81
+ if git_plugin.config_per_process?
82
+ git_plugin.process_block do |process|
83
+ git_plugin.create_systemd_config_symlink(process)
84
+ end
85
+ end
86
+ git_plugin.systemctl_command(:enable)
87
+
88
+ if fetch(:sidekiq_service_unit_user) != :system && fetch(:sidekiq_enable_lingering)
89
+ execute :loginctl, 'enable-linger', fetch(:sidekiq_lingering_user)
53
90
  end
54
91
  end
55
92
  end
56
93
  end
57
94
 
58
- desc 'UnInstall systemd sidekiq service'
95
+ desc 'Uninstall systemd sidekiq service'
59
96
  task :uninstall do
60
97
  on roles fetch(:sidekiq_roles) do |role|
61
98
  git_plugin.switch_user(role) do
62
- if fetch(:sidekiq_service_unit_user) == :system
63
- execute :sudo, :systemctl, "disable", fetch(:sidekiq_service_unit_name)
64
- else
65
- execute :systemctl, "--user", "disable", fetch(:sidekiq_service_unit_name)
99
+ git_plugin.systemctl_command(:stop)
100
+ git_plugin.systemctl_command(:disable)
101
+ if git_plugin.config_per_process?
102
+ git_plugin.process_block do |process|
103
+ git_plugin.delete_systemd_config_symlink(process)
104
+ end
66
105
  end
67
- execute :rm, '-f', File.join(fetch(:service_unit_path, fetch_systemd_unit_path), fetch(:sidekiq_service_unit_name))
106
+ execute :sudo, :rm, '-f', File.join(
107
+ fetch(:service_unit_path, git_plugin.fetch_systemd_unit_path),
108
+ git_plugin.sidekiq_service_file_name
109
+ )
68
110
  end
69
111
  end
70
112
  end
@@ -79,19 +121,22 @@ namespace :sidekiq do
79
121
  def fetch_systemd_unit_path
80
122
  if fetch(:sidekiq_service_unit_user) == :system
81
123
  # if the path is not standard `set :service_unit_path`
82
- "/etc/systemd/system/"
124
+ '/etc/systemd/system/'
83
125
  else
84
126
  home_dir = backend.capture :pwd
85
- File.join(home_dir, ".config", "systemd", "user")
127
+ File.join(home_dir, '.config', 'systemd', 'user')
86
128
  end
87
129
  end
88
130
 
89
131
  def compiled_template
132
+ local_template_directory = fetch(:sidekiq_service_templates_path)
90
133
  search_paths = [
134
+ File.join(local_template_directory, "#{fetch(:sidekiq_service_unit_name)}.service.capistrano.erb"),
135
+ File.join(local_template_directory, 'sidekiq.service.capistrano.erb'),
91
136
  File.expand_path(
92
- File.join(*%w[.. .. .. generators capistrano sidekiq systemd templates sidekiq.service.capistrano.erb]),
93
- __FILE__
94
- ),
137
+ File.join(*%w[.. .. .. generators capistrano sidekiq systemd templates sidekiq.service.capistrano.erb]),
138
+ __FILE__
139
+ )
95
140
  ]
96
141
  template_path = search_paths.detect { |path| File.file?(path) }
97
142
  template = File.read(template_path)
@@ -101,35 +146,151 @@ namespace :sidekiq do
101
146
  def create_systemd_template
102
147
  ctemplate = compiled_template
103
148
  systemd_path = fetch(:service_unit_path, fetch_systemd_unit_path)
149
+ backend.execute :mkdir, '-p', systemd_path if fetch(:sidekiq_service_unit_user) == :user
104
150
 
105
- if fetch(:sidekiq_service_unit_user) == :user
106
- backend.execute :mkdir, "-p", systemd_path
151
+ if sidekiq_processes > 1
152
+ range = 1..sidekiq_processes
153
+ else
154
+ range = 0..0
107
155
  end
108
- backend.upload!(
109
- StringIO.new(ctemplate),
110
- "/tmp/#{fetch :sidekiq_service_unit_name}.service"
156
+ range.each do |index|
157
+ temp_file_name = File.join('/tmp', sidekiq_service_file_name(index))
158
+ systemd_file_name = File.join(systemd_path, sidekiq_service_file_name(index))
159
+ backend.upload!(StringIO.new(ctemplate), temp_file_name)
160
+
161
+ if fetch(:sidekiq_service_unit_user) == :system
162
+ backend.execute :sudo, :mv, temp_file_name, systemd_file_name
163
+ backend.execute :sudo, :systemctl, 'daemon-reload'
164
+ else
165
+ backend.execute :mv, temp_file_name, systemd_file_name
166
+ backend.execute :systemctl, '--user', 'daemon-reload'
167
+ end
168
+ end
169
+ end
170
+
171
+ def create_systemd_config_symlink(process)
172
+ config = fetch(:sidekiq_config)
173
+ return unless config
174
+
175
+ process_config = config[process - 1]
176
+ if process_config.nil?
177
+ backend.error(
178
+ "No configuration for Process ##{process} found. "\
179
+ 'Please make sure you have 1 item in :sidekiq_config for each process.'
180
+ )
181
+ exit 1
182
+ end
183
+
184
+ base_path = fetch(:deploy_to)
185
+ config_link_base_path = File.join(base_path, 'shared', 'sidekiq_systemd')
186
+ config_link_path = File.join(
187
+ config_link_base_path, sidekiq_systemd_config_name(process)
111
188
  )
112
- if fetch(:sidekiq_service_unit_user) == :system
113
- backend.execute :sudo, :mv, "/tmp/#{fetch :sidekiq_service_unit_name}.service", "#{systemd_path}/#{fetch :sidekiq_service_unit_name}.service"
114
- backend.execute :sudo, :systemctl, "daemon-reload"
189
+ process_config_path = File.join(base_path, 'current', process_config)
190
+
191
+ backend.execute :mkdir, '-p', config_link_base_path
192
+ backend.execute :ln, '-sf', process_config_path, config_link_path
193
+ end
194
+
195
+ def delete_systemd_config_symlink(process)
196
+ config_link_path = File.join(
197
+ fetch(:deploy_to), 'shared', 'sidekiq_systemd',
198
+ sidekiq_systemd_config_name(process)
199
+ )
200
+ backend.execute :rm, config_link_path, raise_on_non_zero_exit: false
201
+ end
202
+
203
+ def systemctl_command(*args, process: nil)
204
+ execute_array =
205
+ if fetch(:sidekiq_service_unit_user) == :system
206
+ %i[sudo systemctl]
207
+ else
208
+ [:systemctl, '--user']
209
+ end
210
+ if process && sidekiq_processes > 1
211
+ execute_array.push(
212
+ *args, sidekiq_service_unit_name(process: process)
213
+ ).flatten
115
214
  else
116
- backend.execute :mv, "/tmp/#{fetch :sidekiq_service_unit_name}.service", "#{systemd_path}/#{fetch :sidekiq_service_unit_name}.service"
117
- backend.execute :systemctl, "--user", "daemon-reload"
215
+ execute_array.push(*args, sidekiq_service_unit_name).flatten
118
216
  end
217
+ backend.execute(*execute_array, raise_on_non_zero_exit: false)
119
218
  end
120
219
 
121
- def switch_user(role)
220
+ def quiet_sidekiq
221
+ systemctl_command(:kill, '-s', :TSTP)
222
+ end
223
+
224
+ def switch_user(role, &block)
122
225
  su_user = sidekiq_user
123
226
  if su_user != role.user
124
227
  yield
125
228
  else
126
- backend.as su_user do
127
- yield
128
- end
229
+ backend.as su_user, &block
129
230
  end
130
231
  end
131
232
 
132
233
  def sidekiq_user
133
234
  fetch(:sidekiq_user, fetch(:run_as))
134
235
  end
236
+
237
+ def sidekiq_config
238
+ config = fetch(:sidekiq_config)
239
+ return unless config
240
+
241
+ if config_per_process?
242
+ config = File.join(
243
+ fetch(:deploy_to), 'shared', 'sidekiq_systemd',
244
+ sidekiq_systemd_config_name
245
+ )
246
+ end
247
+ "--config #{config}"
248
+ end
249
+
250
+ def sidekiq_concurrency
251
+ "--concurrency #{fetch(:sidekiq_concurrency)}" if fetch(:sidekiq_concurrency)
252
+ end
253
+
254
+ def sidekiq_processes
255
+ fetch(:sidekiq_processes, 1)
256
+ end
257
+
258
+ def sidekiq_queues
259
+ Array(fetch(:sidekiq_queue)).map do |queue|
260
+ "--queue #{queue}"
261
+ end.join(' ')
262
+ end
263
+
264
+ def sidekiq_service_file_name(index = nil)
265
+ return "#{fetch(:sidekiq_service_unit_name)}.service" if index.to_i.zero?
266
+ "#{fetch(:sidekiq_service_unit_name)}@#{index}.service"
267
+ end
268
+
269
+ def sidekiq_service_unit_name(process: nil)
270
+ if process && sidekiq_processes > 1
271
+ "#{fetch(:sidekiq_service_unit_name)}@#{process}"
272
+ else
273
+ fetch(:sidekiq_service_unit_name)
274
+ end
275
+ end
276
+
277
+ # process = 1 | sidekiq_systemd_1.yaml
278
+ # process = nil | sidekiq_systemd_%i.yaml
279
+ def sidekiq_systemd_config_name(process = nil)
280
+ "sidekiq_systemd_#{(process&.to_s || '%i')}.yaml"
281
+ end
282
+
283
+ def config_per_process?
284
+ fetch(:sidekiq_config).is_a?(Array)
285
+ end
286
+
287
+ def process_block
288
+ (1..sidekiq_processes).each do |process|
289
+ yield(process)
290
+ end
291
+ end
292
+
293
+ def duration(start_time)
294
+ Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time
295
+ end
135
296
  end
@@ -1,10 +1,8 @@
1
- # Monit configuration for Sidekiq : <%= fetch(:application) %>
2
- <% pid_files.each_with_index do |pid_file, idx| %>
3
- check process <%= sidekiq_service_name(idx) %>
4
- with pidfile "<%= pid_file %>"
5
- 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
6
-
7
- 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
1
+ # Monit configuration for Sidekiq
2
+ # Service name: <%= sidekiq_service_name %>
3
+ #
4
+ check process <%= sidekiq_service_name %>
5
+ matching 'sidekiq .* <%= fetch(:application) %>'
6
+ 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
7
+ 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
8
8
  group <%= fetch(:sidekiq_monit_group) || fetch(:application) %>-sidekiq
9
-
10
- <% end %>