process_bot 0.1.2 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 918adb2b2275f38d3b22eb926a5da3b021f667d4a7290a3b0b1d9ea7bb56a2c2
-  data.tar.gz: 03c557694d0a91f78f25dc4689f2b99c46b626ebeed5816f8e2e0346e29dd482
+  metadata.gz: 24914d42c043171014a4dacebea43987204236a2dadb14d2fcc4f8bda936e628
+  data.tar.gz: b9248c4189e0d52826728401e940bed7ba46e330fb7f391d587ba00f23b160e3
 SHA512:
-  metadata.gz: 2053d076158df45b723855cee991d47852efb18b34ace65e24005798c7d9d1f1ffff126d1fc7409ba3554e4bfa3bf9855c13dfec5bcfa14ac79aac57d9409acf
-  data.tar.gz: 5622bc3069e029485876c7329bd0658b3bf7b3c4b265a40e51421bab04e0b898367f91c864dbe7caf1de93b317e9ba1fcd4787971fd4dc9e28528bf4f14a8df8
+  metadata.gz: a92b6568aaf9e799f5d318cd63c900185c4f6cacb4578c7f6fc3769933e571b27b7f48f27d7c33a93ce700d5e3990ea53c0f50a5b39c31ae9153130502c770bc
+  data.tar.gz: 3eb45c1dd31b202ac80b0c1b7925e60ed682fd5f42210a768459c6b456d84b9a76cc7618b67ead9f576482ded5b9d47501039d51d158a5125bfab258097c43ff

data/.rubocop.yml

@@ -2,7 +2,7 @@ AllCops:
   DisplayCopNames: true
   DisplayStyleGuide: true
   NewCops: enable
-  TargetRubyVersion: 2.6
+  TargetRubyVersion: 2.7
 
 require:
   - rubocop-performance

data/.ruby-version

@@ -0,0 +1 @@
+2.7.8

data/Gemfile

@@ -5,9 +5,14 @@ source "https://rubygems.org"
 # Specify your gem's dependencies in process_bot.gemspec
 gemspec
 
+gem "pry"
 gem "rake"
 gem "rspec"
-gem "rubocop"
 gem "string-cases"
 
-gem "pry"
+group :development do
+  gem "rubocop"
+  gem "rubocop-performance"
+  gem "rubocop-rake"
+  gem "rubocop-rspec"
+end

data/Gemfile.lock

@@ -1,63 +1,96 @@
 PATH
   remote: .
   specs:
-    process_bot (0.1.2)
+    process_bot (0.1.4)
+      knjrbfw (>= 0.0.116)
 
 GEM
   remote: https://rubygems.org/
   specs:
     ast (2.4.2)
     coderay (1.1.3)
+    datet (0.0.25)
     diff-lcs (1.5.0)
-    json (2.6.2)
+    http2 (0.0.36)
+      string-cases (~> 0)
+    json (2.7.0)
+    knjrbfw (0.0.116)
+      datet
+      http2
+      php4r
+      ruby_process
+      tsafe
+      wref (>= 0.0.8)
+    language_server-protocol (3.17.0.3)
     method_source (1.0.0)
-    parallel (1.22.1)
-    parser (3.1.2.1)
+    parallel (1.23.0)
+    parser (3.2.2.4)
       ast (~> 2.4.1)
-    pry (0.14.1)
+      racc
+    php4r (0.0.4)
+      datet
+      http2
+      string-strtr
+    pry (0.14.2)
       coderay (~> 1.1)
       method_source (~> 1.0)
+    racc (1.7.3)
     rainbow (3.1.1)
-    rake (13.0.6)
-    regexp_parser (2.6.0)
-    rexml (3.2.5)
-    rspec (3.11.0)
-      rspec-core (~> 3.11.0)
-      rspec-expectations (~> 3.11.0)
-      rspec-mocks (~> 3.11.0)
-    rspec-core (3.11.0)
-      rspec-support (~> 3.11.0)
-    rspec-expectations (3.11.0)
+    rake (13.1.0)
+    regexp_parser (2.8.2)
+    rexml (3.2.6)
+    rspec (3.12.0)
+      rspec-core (~> 3.12.0)
+      rspec-expectations (~> 3.12.0)
+      rspec-mocks (~> 3.12.0)
+    rspec-core (3.12.0)
+      rspec-support (~> 3.12.0)
+    rspec-expectations (3.12.0)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.11.0)
-    rspec-mocks (3.11.1)
+      rspec-support (~> 3.12.0)
+    rspec-mocks (3.12.0)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.11.0)
-    rspec-support (3.11.0)
-    rubocop (1.36.0)
+      rspec-support (~> 3.12.0)
+    rspec-support (3.12.0)
+    rubocop (1.58.0)
       json (~> 2.3)
+      language_server-protocol (>= 3.17.0)
       parallel (~> 1.10)
-      parser (>= 3.1.2.1)
+      parser (>= 3.2.2.4)
       rainbow (>= 2.2.2, < 4.0)
       regexp_parser (>= 1.8, < 3.0)
       rexml (>= 3.2.5, < 4.0)
-      rubocop-ast (>= 1.20.1, < 2.0)
+      rubocop-ast (>= 1.30.0, < 2.0)
       ruby-progressbar (~> 1.7)
-      unicode-display_width (>= 1.4.0, < 3.0)
-    rubocop-ast (1.21.0)
-      parser (>= 3.1.1.0)
-    rubocop-performance (1.15.0)
+      unicode-display_width (>= 2.4.0, < 3.0)
+    rubocop-ast (1.30.0)
+      parser (>= 3.2.1.0)
+    rubocop-capybara (2.19.0)
+      rubocop (~> 1.41)
+    rubocop-factory_bot (2.24.0)
+      rubocop (~> 1.33)
+    rubocop-performance (1.19.1)
       rubocop (>= 1.7.0, < 2.0)
       rubocop-ast (>= 0.4.0)
     rubocop-rake (0.6.0)
       rubocop (~> 1.0)
-    rubocop-rspec (2.11.1)
-      rubocop (~> 1.19)
-    ruby-progressbar (1.11.0)
+    rubocop-rspec (2.25.0)
+      rubocop (~> 1.40)
+      rubocop-capybara (~> 2.17)
+      rubocop-factory_bot (~> 2.22)
+    ruby-progressbar (1.13.0)
+    ruby_process (0.0.13)
+      string-cases
+      tsafe
+      wref
     string-cases (0.0.4)
-    unicode-display_width (2.3.0)
+    string-strtr (0.0.3)
+    tsafe (0.0.12)
+    unicode-display_width (2.5.0)
+    wref (0.0.8)
 
 PLATFORMS
+  ruby
   x86_64-linux
 
 DEPENDENCIES

data/README.md

@@ -1,8 +1,8 @@
 # ProcessBot
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/process_bot`. To experiment with that code, run `bin/console` for an interactive prompt.
+Run your app through ProcessBot for automatic restart if crashing, but still support normal deployment through Capistrano.
 
-TODO: Delete this and the text above, and describe your gem
+In the future ProcessBot will also watch memory usage and restart processes if leaking memory automatically and gracefully.
 
 ## Installation
 
@@ -12,17 +12,27 @@ Add this line to your application's Gemfile:
 gem 'process_bot'
 ```
 
-And then execute:
-
-    $ bundle install
-
-Or install it yourself as:
+Add to your `Capfile`:
+```ruby
+require "process_bot"
+install_plugin ProcessBot::Capistrano::Sidekiq
+install_plugin ProcessBot::Capistrano::Puma
+```
 
-    $ gem install process_bot
+Add to your `deploy.rb`:
+```ruby
+after "deploy:starting", "process_bot:sidekiq:graceful"
+after "deploy:published", "process_bot:sidekiq:start"
+after "deploy:failed", "process_bot:sidekiq:start"
+```
 
 ## Usage
 
-TODO: Write usage instructions here
+Run commands in the command line like this:
+
+```bash
+cap production process_bot:sidekiq:graceful
+```
 
 ## Development
 

data/exe/process_bot

@@ -18,6 +18,12 @@ while argv_i < ARGV.length
 
   if (match = arg.match(/\A--(.+)\Z/))
     key = match[1].tr("-", "_").to_sym
+
+    if key == :path
+      puts "Path: #{File.realpath("#{__dir__}/..")}"
+      exit
+    end
+
     argv_i += 1
     value = ARGV.fetch(argv_i)
 
@@ -29,8 +35,6 @@ while argv_i < ARGV.length
   argv_i += 1
 end
 
-pp options.options
-
 ProcessBot::Process
   .new(options)
   .execute!

data/lib/process_bot/capistrano/sidekiq.rake

@@ -14,62 +14,51 @@ namespace :load do
     set :sidekiq_options_per_process, nil
     set :sidekiq_user, nil
     # Rbenv, Chruby, and RVM integration
-    set :rbenv_map_bins, fetch(:rbenv_map_bins).to_a.concat(%w[sidekiq sidekiqctl])
-    set :rvm_map_bins, fetch(:rvm_map_bins).to_a.concat(%w[sidekiq sidekiqctl])
-    set :chruby_map_bins, fetch(:chruby_map_bins).to_a.concat(%w[sidekiq sidekiqctl])
+    set :rbenv_map_bins, fetch(:rbenv_map_bins).to_a + ["sidekiq", "sidekiqctl"]
+    set :rvm_map_bins, fetch(:rvm_map_bins).to_a + ["sidekiq", "sidekiqctl"]
+    set :chruby_map_bins, fetch(:chruby_map_bins).to_a + ["sidekiq", "sidekiqctl"]
     # Bundler integration
-    set :bundle_bins, fetch(:bundle_bins).to_a.concat(%w[sidekiq sidekiqctl])
+    set :bundle_bins, fetch(:bundle_bins).to_a + ["sidekiq", "sidekiqctl"]
   end
 end
 
 namespace :process_bot do
   namespace :sidekiq do
-    desc "Quiet sidekiq (stop fetching new tasks from Redis)"
-    task :quiet do
+    desc "Stop Sidekiq and ProcessBot gracefully (stop fetching new tasks from Redis and then quit when nothing is running)"
+    task :graceful do
       on roles fetch(:sidekiq_roles) do |role|
         git_plugin.switch_user(role) do
-          git_plugin.running_sidekiq_processes.each do |sidekiq_process|
-            git_plugin.stop_sidekiq(pid: sidekiq_process.fetch(:pid), signal: "TSTP")
+          git_plugin.running_process_bot_processes.each do |process_bot_process|
+            git_plugin.process_bot_command(process_bot_process, :graceful)
           end
         end
       end
     end
 
-    desc "Stop Sidekiq (graceful shutdown within timeout, put unfinished tasks back to Redis)"
+    desc "Stop Sidekiq and ProcessBot (graceful shutdown within timeout, put unfinished tasks back to Redis)"
     task :stop do
       on roles fetch(:sidekiq_roles) do |role|
         git_plugin.switch_user(role) do
-          git_plugin.running_sidekiq_processes.each do |sidekiq_process|
-            git_plugin.stop_sidekiq(pid: sidekiq_process.fetch(:pid), signal: "TERM")
+          git_plugin.running_process_bot_processes.each do |process_bot_data|
+            git_plugin.process_bot_command(process_bot_data, :stop)
           end
         end
       end
     end
 
-    desc "Stops Sidekiq after a set amount of time"
-    task :stop_after_time do
-      on roles fetch(:sidekiq_roles) do |role|
-        git_plugin.switch_user(role) do
-          git_plugin.running_sidekiq_processes.each do |sidekiq_process|
-            git_plugin.stop_sidekiq_after_time(pid: sidekiq_process.fetch(:pid), signal: "TERM")
-          end
-        end
-      end
-    end
-
-    desc "Start sidekiq"
+    desc "Start Sidekiq and ProcessBot"
     task :start do
       on roles fetch(:sidekiq_roles) do |role|
         git_plugin.switch_user(role) do
           fetch(:sidekiq_processes).times do |idx|
-            puts "Starting Sidekiq #{idx}"
+            puts "Starting Sidekiq with ProcessBot #{idx}"
             git_plugin.start_sidekiq(idx)
           end
         end
       end
     end
 
-    desc "Restart sidekiq"
+    desc "Restart Sidekiq and ProcessBot"
     task :restart do
       invoke! "process_bot:sidekiq:stop"
       invoke! "process_bot:sidekiq:start"

data/lib/process_bot/capistrano/sidekiq.rb

@@ -1,5 +1,3 @@
-require_relative "sidekiq_helpers"
-
 class ProcessBot::Capistrano::Sidekiq < Capistrano::Plugin
   include ProcessBot::Capistrano::SidekiqHelpers
 

data/lib/process_bot/capistrano/sidekiq_helpers.rb

@@ -1,4 +1,6 @@
-module ProcessBot::Capistrano::SidekiqHelpers
+require "json"
+
+module ProcessBot::Capistrano::SidekiqHelpers # rubocop:disable Metrics/ModuleLength
   def sidekiq_require
     "--require #{fetch(:sidekiq_require)}" if fetch(:sidekiq_require)
   end
@@ -30,41 +32,62 @@ module ProcessBot::Capistrano::SidekiqHelpers
     end
   end
 
-  VALID_SIGNALS = ["TERM", "TSTP"].freeze
-  def stop_sidekiq(pid:, signal:)
-    raise "Invalid PID: #{pid}" unless pid.to_s.match?(/\A\d+\Z/)
-    raise "Invalid signal: #{signal}" unless VALID_SIGNALS.include?(signal)
+  def process_bot_command(process_bot_data, command) # rubocop:disable Metrics/AbcSize
+    raise "No port in process bot data? #{process_bot_data}" unless process_bot_data["port"]
 
-    backend.execute "kill -#{signal} #{pid}"
-  end
+    mode = "exec"
+
+    if mode == "runner"
+      args = {command: command, port: process_bot_data.fetch("port")}
+
+      if command == :graceful && !fetch(:process_bot_wait_for_gracefully_stopped).nil?
+        args["wait_for_gracefully_stopped"] = fetch(:process_bot_wait_for_gracefully_stopped)
+      end
 
-  def stop_sidekiq_after_time(pid:, signal:)
-    raise "Invalid PID: #{pid}" unless pid.to_s.match?(/\A\d+\Z/)
-    raise "Invalid signal: #{signal}" unless VALID_SIGNALS.include?(signal)
+      escaped_args = JSON.generate(args).gsub("\"", "\\\"")
+      rails_runner_command = "require 'process_bot'; ProcessBot::Process.new(ProcessBot::Options.from_args(#{escaped_args})).execute!"
 
-    time = ENV["STOP_AFTER_TIME"] || fetch(:sidekiq_stop_after_time)
-    raise "Invalid time: #{time}" unless time.to_s.match?(/\A\d+\Z/)
+      backend_command = "cd #{release_path} && " \
+        "#{SSHKit.config.command_map.prefix[:bundle].join(" ")} bundle exec rails runner \"#{rails_runner_command}\""
+    elsif mode == "exec"
+      backend_command = "cd #{release_path} && " \
+        "#{SSHKit.config.command_map.prefix[:bundle].join(" ")} bundle exec process_bot " \
+        "--command #{command} " \
+        "--port #{process_bot_data.fetch("port")}"
+
+      if command == :graceful && !fetch(:process_bot_wait_for_gracefully_stopped).nil?
+        backend_command << " --wait-for-gracefully-stopped #{fetch(:process_bot_wait_for_gracefully_stopped)}"
+      end
+    else
+      raise "Unknown mode: #{mode}"
+    end
 
-    backend.execute "screen -dmS stopsidekiq#{pid} bash -c \"sleep #{time} && kill -#{signal} #{pid}\""
+    backend.execute backend_command
   end
 
-  def running_sidekiq_processes
+  def running_process_bot_processes
     sidekiq_app_name = fetch(:sidekiq_app_name, fetch(:application))
     raise "No :sidekiq_app_name was set" unless sidekiq_app_name
 
     begin
-      processes_output = backend.capture("ps a | egrep 'sidekiq ([0-9]+\.[0-9]+\.[0-9]+) #{Regexp.escape(sidekiq_app_name)}'")
+      processes_output = backend.capture("ps a | grep ProcessBot | grep sidekiq | grep -v '/usr/bin/SCREEN' | grep '#{Regexp.escape(sidekiq_app_name)}'")
     rescue SSHKit::Command::Failed
       # Fails when output is empty (when no processes found through grep)
-      puts "No Sidekiq processes found"
+      puts "No ProcessBot Sidekiq processes found"
       return []
     end
 
+    parse_process_bot_process_from_ps(processes_output)
+  end
+
+  def parse_process_bot_process_from_ps(processes_output)
     processes = []
-    processes_output.scan(/^\s*(\d+)\s+(\S+)\s+(\S+)\s+(\S+)\s+(.+)$/).each do |process_output|
-      sidekiq_pid = process_output[0]
+    processes_output.scan(/^\s*(\d+)\s+(\S+)\s+(\S+)\s+(\S+)\s+ProcessBot (\{([^\n]+?)\})$/).each do |process_output|
+      process_bot_data = JSON.parse(process_output[4])
+      process_bot_pid = process_output[0]
+      process_bot_data["process_bot_pid"] = process_bot_pid
 
-      processes << {pid: sidekiq_pid}
+      processes << process_bot_data
     end
 
     processes
@@ -86,7 +109,7 @@ module ProcessBot::Capistrano::SidekiqHelpers
     backend.capture(:echo, SSHKit.config.command_map[:bundle]).strip
   end
 
-  def start_sidekiq(idx = 0) # rubocop:disable Metrics/AbcSize
+  def start_sidekiq(idx = 0) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
     releases = backend.capture(:ls, "-x", releases_path).split
     releases << release_timestamp.to_s if release_timestamp
     releases.uniq
@@ -95,13 +118,19 @@ module ProcessBot::Capistrano::SidekiqHelpers
     raise "Invalid release timestamp: #{release_timestamp}" unless latest_release_version
 
     args = [
+      "--command", "start",
       "--id", "sidekiq-#{latest_release_version}-#{idx}",
+      "--application", fetch(:sidekiq_app_name, fetch(:application)),
       "--handler", "sidekiq",
       "--bundle-prefix", SSHKit.config.command_map.prefix[:bundle].join(" "),
       "--sidekiq-environment", fetch(:sidekiq_env),
-      "--port", 7050 + idx
+      "--port", idx + 7050,
+      "--release-path", release_path
     ]
-    args += ["--log-file-path", fetch(:sidekiq_log)] if fetch(:sidekiq_log)
+
+    # Use screen for logging everything which is why this is disabled
+    # args += ["--log-file-path", fetch(:sidekiq_log)] if fetch(:sidekiq_log)
+
     args += ["--sidekiq-require", fetch(:sidekiq_require)] if fetch(:sidekiq_require)
     args += ["--sidekiq-tag", fetch(:sidekiq_tag)] if fetch(:sidekiq_tag)
     args += ["--sidekiq-queues", Array(fetch(:sidekiq_queue)).join(",")] if fetch(:sidekiq_queue)
@@ -112,13 +141,18 @@ module ProcessBot::Capistrano::SidekiqHelpers
     end
     args += fetch(:sidekiq_options) if fetch(:sidekiq_options)
 
-    screen_args = ["-dmS sidekiq-#{idx}-#{latest_release_version}"]
-    screen_args << "-L -Logfile #{fetch(:sidekiq_log)}" if fetch(:sidekiq_log)
+    screen_args = ["-dmS process-bot--sidekiq--#{idx}-#{latest_release_version}"]
+
+    if (process_bot_sidekiq_log = fetch(:process_bot_sidekig_log))
+      screen_args << "-L -Logfile #{process_bot_sidekiq_log}_#{latest_release_version}_#{idx}.log"
+    elsif fetch(:sidekiq_log)
+      screen_args << "-L -Logfile #{fetch(:sidekiq_log)}"
+    end
 
     process_bot_args = args.compact.map { |arg| "\"#{arg}\"" }
 
     command = "/usr/bin/screen #{screen_args.join(" ")} " \
-      "bash -c 'cd #{release_path} && #{SSHKit.config.command_map.prefix[:bundle].join(" ")} bundle exec process_bot #{process_bot_args.join(" ")}'"
+      "bash -c 'cd #{release_path} && exec #{SSHKit.config.command_map.prefix[:bundle].join(" ")} bundle exec process_bot #{process_bot_args.join(" ")}'"
 
     puts "WARNING: A known bug prevents Sidekiq from starting when pty is set (which it is)" if fetch(:pty)
     puts "ProcessBot Sidekiq command: #{command}"

data/lib/process_bot/capistrano.rb

@@ -1,4 +1,5 @@
 class ProcessBot::Capistrano
   autoload :Puma, "#{__dir__}/capistrano/puma"
   autoload :Sidekiq, "#{__dir__}/capistrano/sidekiq"
+  autoload :SidekiqHelpers, "#{__dir__}/capistrano/sidekiq_helpers"
 end

data/lib/process_bot/client_socket.rb

@@ -0,0 +1,41 @@
+require "socket"
+
+class ProcessBot::ClientSocket
+  attr_reader :options
+
+  def initialize(options:)
+    @options = options
+  end
+
+  def client
+    @client ||= Socket.tcp("localhost", options.fetch(:port).to_i, connect_timeout: 2)
+  end
+
+  def close
+    client.close
+  end
+
+  def logger
+    @logger ||= ProcessBot::Logger.new(options: options)
+  end
+
+  def send_command(data) # rubocop:disable Metrics/AbcSize
+    logger.log "Sending: #{data}"
+    client.puts(JSON.generate(data))
+    response_raw = client.gets
+
+    # Happens if process is interrupted
+    return :nil if response_raw.nil?
+
+    response = JSON.parse(response_raw)
+
+    return :success if response.fetch("type") == "success"
+
+    if response.fetch("type") == "error"
+      error = RuntimeError.new("Command raised an error: #{response.fetch("message")}")
+      error.set_backtrace(response.fetch("backtrace") + Thread.current.backtrace)
+
+      raise error
+    end
+  end
+end

data/lib/process_bot/control_socket.rb

@@ -1,3 +1,5 @@
+require "socket"
+
 class ProcessBot::ControlSocket
   attr_reader :options, :process, :server
 
@@ -6,14 +8,25 @@ class ProcessBot::ControlSocket
     @process = process
   end
 
+  def logger
+    @logger ||= ProcessBot::Logger.new(options: options)
+  end
+
   def port
     options.fetch(:port).to_i
   end
 
   def start
-    require "socket"
+    @server = TCPServer.new("localhost", port)
+    run_client_loop
 
-    @server = TCPServer.new(port)
+    logger.logs "TCPServer started"
+
+    options.events.call(:on_socket_opened, port: port)
+  end
+
+  def stop
+    server.close
   end
 
   def run_client_loop
@@ -26,14 +39,48 @@ class ProcessBot::ControlSocket
     end
   end
 
-  def handle_client(client)
-    command = JSON.parse(client.gets)
-    type = command.fetch("type")
+  def handle_client(client) # rubocop:disable Metrics/AbcSize
+    loop do
+      data = client.gets
+      break if data.nil? # Client disconnected
+
+      command = JSON.parse(data)
+      command_type = command.fetch("command")
+
+      if command_type == "graceful" || command_type == "stop"
+        begin
+          command_options = if command["options"]
+            symbolize_keys(command.fetch("options"))
+          else
+            {}
+          end
+
+          logger.logs "Command #{command_type} with options #{command_options}"
 
-    if type == "stop"
-      process.stop
-    else
-      client.puts(JSON.generate(type: "error", message: "Unknown type: #{type}"))
+          process.__send__(command_type, **command_options)
+          client.puts(JSON.generate(type: "success"))
+        rescue => e # rubocop:disable Style/RescueStandardError
+          logger.logs e.message, type: :stderr
+          logger.logs e.backtrace, type: :stderr
+
+          client.puts(JSON.generate(type: "error", message: e.message, backtrace: e.backtrace))
+
+          raise e
+        end
+      else
+        client.puts(JSON.generate(type: "error", message: "Unknown command: #{command_type}", backtrace: Thread.current.backtrace))
+      end
+    end
+  end
+
+  def symbolize_keys(hash)
+    new_hash = {}
+    hash.each do |key, value|
+      next if key == "port"
+
+      new_hash[key.to_sym] = value
     end
+
+    new_hash
   end
 end

data/lib/process_bot/logger.rb

@@ -1,22 +1,38 @@
 class ProcessBot::Logger
-  attr_reader :fp_log, :options
+  attr_reader :options
 
   def initialize(options:)
     @options = options
+  end
+
+  def log(output, type: :stdout)
+    if type == :stdout || (type == :debug && options[:debug])
+      $stdout.print output
+    elsif type == :stderr
+      $stderr.print output
+    else
+      raise "Unknown type: #{type}"
+    end
+
+    return unless log_to_file?
 
-    open_file
+    fp_log.write(output)
+    fp_log.flush
   end
 
-  def log(output)
-    fp_log&.write(output)
-    fp_log&.flush
+  def logs(output, **args)
+    log("#{output}\n", **args)
   end
 
   def log_file_path
     options.fetch(:log_file_path)
   end
 
-  def open_file
-    @fp_log = File.open(log_file_path, "a")
+  def log_to_file?
+    options.present?(:log_file_path)
+  end
+
+  def fp_log
+    @fp_log ||= File.open(log_file_path, "a") if log_to_file?
   end
 end

data/lib/process_bot/options.rb

@@ -1,12 +1,73 @@
 class ProcessBot::Options
   attr_reader :options
 
+  def self.from_args(args)
+    options = ProcessBot::Options.new
+
+    args.each do |key, value|
+      options.set(key, value)
+    end
+
+    options
+  end
+
   def initialize(options = {})
     @options = options
   end
 
-  def fetch(*args, **opts, &blk)
-    options.fetch(*args, **opts, &blk)
+  def [](key)
+    options[key]
+  end
+
+  def events
+    @events ||= begin
+      require "knjrbfw"
+
+      event_handler = ::Knj::Event_handler.new
+      event_handler.add_event(name: :on_process_started)
+      event_handler.add_event(name: :on_socket_opened)
+      event_handler
+    end
+  end
+
+  def fetch(...)
+    options.fetch(...)
+  end
+
+  def application_basename
+    @application_basename ||= begin
+      app_path_parts = release_path.split("/")
+
+      if release_path.include?("/releases/")
+        app_path_parts.pop(2)
+      elsif release_path.end_with?("/current")
+        app_path_parts.pop
+      end
+
+      app_path_parts.last
+    end
+  end
+
+  def possible_process_titles
+    possible_names = []
+
+    # Sidekiq name can by current Rails root base name
+    possible_names << application_basename
+
+    # Sidekiq name can be set tag name (but we wrongly read application for some reason?)
+    possible_names << options.fetch(:application)
+
+    possible_names
+  end
+
+  def possible_process_titles_joined_regex
+    possible_process_titles_joined_regex = ""
+    possible_process_titles.each_with_index do |possible_name, index|
+      possible_process_titles_joined_regex << "|" if index >= 1
+      possible_process_titles_joined_regex << Regexp.escape(possible_name)
+    end
+
+    possible_process_titles_joined_regex
   end
 
   def present?(key)
@@ -15,6 +76,10 @@ class ProcessBot::Options
     false
   end
 
+  def release_path
+    @release_path ||= fetch(:release_path)
+  end
+
   def set(key, value)
     options[key] = value
   end

data/lib/process_bot/process/handlers/sidekiq.rb

@@ -1,16 +1,38 @@
 class ProcessBot::Process::Handlers::Sidekiq
-  attr_reader :options
+  attr_reader :options, :process
 
-  def initialize(options)
-    @options = options
+  def initialize(process)
+    @process = process
+    @options = process.options
+  end
+
+  def current_pid
+    process.current_pid
+  end
+
+  def daemonize
+    logger.logs "Daemonize!"
+
+    pid = Process.fork do
+      Process.daemon
+      yield
+    end
 
-    set_defaults
+    Process.detach(pid) if pid
+  end
+
+  def false_value?(value)
+    !value || value == "false"
   end
 
   def fetch(*args, **opts)
     options.fetch(*args, **opts)
   end
 
+  def logger
+    @logger ||= ProcessBot::Logger.new(options: options)
+  end
+
   def set_option(key, value)
     raise "Unknown option for Sidekiq handler: #{key}" unless options.key?(key)
 
@@ -21,35 +43,95 @@ class ProcessBot::Process::Handlers::Sidekiq
     options.set(*args, **opts)
   end
 
-  def set_defaults
-    set :sidekiq_default_hooks, true
-    set :sidekiq_pid, -> { File.join(shared_path, "tmp", "pids", "sidekiq.pid") }
-    set :sidekiq_timeout, 10
-    set :sidekiq_roles, fetch(:sidekiq_role, :app)
-    set :sidekiq_processes, 1
-    set :sidekiq_options_per_process, nil
-  end
-
-  def command # rubocop:disable Metrics/AbcSize
+  def start_command # rubocop:disable Metrics/AbcSize
     args = []
 
     options.options.each do |key, value|
-      if (match = key.to_s.match(/\Asidekiq-(.+)\Z/))
-        sidekiq_key = match[1]
-
-        if sidekiq_key == "queue"
-          value.split(",").each do |queue|
-            args.push "--queue #{value}"
-          end
-        else
-          args.push "--#{sidekiq_key} #{value}"
+      next unless (match = key.to_s.match(/\Asidekiq_(.+)\Z/))
+
+      sidekiq_key = match[1]
+
+      if sidekiq_key == "queue"
+        value.split(",").each do |queue|
+          args.push "--queue #{queue}"
         end
+      else
+        args.push "--#{sidekiq_key} #{value}"
       end
     end
 
-    command = ""
+    command = "bash -c 'cd #{options.fetch(:release_path)} && exec "
     command << "#{options.fetch(:bundle_prefix)} " if options.present?(:bundle_prefix)
     command << "bundle exec sidekiq #{args.compact.join(' ')}"
+    command << "'"
     command
   end
+
+  def graceful(**args)
+    wait_for_gracefully_stopped = args.fetch(:wait_for_gracefully_stopped, true)
+    process.set_stopped
+
+    unless current_pid
+      warn "Sidekiq not running with a PID"
+      return
+    end
+
+    Process.kill("TSTP", current_pid)
+
+    if false_value?(wait_for_gracefully_stopped)
+      logger.logs "Dont wait for gracefully stopped - doing that in fork..."
+
+      daemonize do
+        wait_for_no_jobs_and_stop_sidekiq
+        exit
+      end
+    else
+      logger.logs "Wait for gracefully stopped..."
+      wait_for_no_jobs_and_stop_sidekiq
+    end
+  end
+
+  def stop(**_args)
+    process.set_stopped
+
+    unless current_pid
+      warn "#{handler_name} not running with a PID"
+      return
+    end
+
+    Process.kill("TERM", current_pid)
+  end
+
+  def wait_for_no_jobs # rubocop:disable Metrics/AbcSize
+    loop do
+      found_process = false
+
+      Knj::Unix_proc.list("grep" => current_pid) do |process|
+        process_command = process.data.fetch("cmd")
+        process_pid = process.data.fetch("pid").to_i
+        next unless process_pid == current_pid
+
+        found_process = true
+        sidekiq_regex = /\Asidekiq (\d+).(\d+).(\d+) (#{options.possible_process_titles_joined_regex}) \[(\d+) of (\d+)(\]|) (.+?)(\]|)\Z/
+        match = process_command.match(sidekiq_regex)
+        raise "Couldnt match Sidekiq command: #{process_command} with Sidekiq regex: #{sidekiq_regex}" unless match
+
+        running_jobs = match[5].to_i
+
+        logger.logs "running_jobs: #{running_jobs}"
+
+        return if running_jobs.zero? # rubocop:disable Lint/NonLocalExitFromIterator
+      end
+
+      raise "Couldn't find running process with PID #{current_pid}" unless found_process
+
+      sleep 1
+    end
+  end
+
+  def wait_for_no_jobs_and_stop_sidekiq
+    logger.logs "Wait for no jobs and Stop sidekiq"
+    wait_for_no_jobs
+    stop
+  end
 end

data/lib/process_bot/process/runner.rb

@@ -1,5 +1,7 @@
+require "knjrbfw"
+
 class ProcessBot::Process::Runner
-  attr_reader :command, :exit_status, :logger, :monitor, :options, :stop_time
+  attr_reader :command, :exit_status, :logger, :monitor, :options, :pid, :stop_time, :subprocess_pid
 
   def initialize(command:, logger:, options:)
     @command = command
@@ -9,8 +11,12 @@ class ProcessBot::Process::Runner
     @output = []
   end
 
-  def output(output:, type:) # rubocop:disable Lint/UnusedMethodArgument
-    logger.log(output)
+  def output(output:, type:)
+    logger.log(output, type: type)
+  end
+
+  def running?
+    !stop_time
   end
 
   def run # rubocop:disable Metrics/AbcSize
@@ -20,8 +26,8 @@ class ProcessBot::Process::Runner
     require "pty"
 
     PTY.spawn(command, err: stderr_writer.fileno) do |stdout, _stdin, pid|
-      @pid = pid
-      logger.log "Command running with PID #{pid}: #{command}"
+      @subprocess_pid = pid
+      logger.logs "Command running with PID #{pid}: #{command}"
 
       stdout_reader_thread = Thread.new do
         stdout.each_char do |chunk|
@@ -32,7 +38,7 @@ class ProcessBot::Process::Runner
       rescue Errno::EIO
         # Process done
       ensure
-        status = Process::Status.wait(@pid, 0)
+        status = Process::Status.wait(subprocess_pid, 0)
 
         @exit_status = status.exitstatus
         stderr_writer.close
@@ -46,10 +52,56 @@ class ProcessBot::Process::Runner
         end
       end
 
+      find_sidekiq_pid
+
       stdout_reader_thread.join
       stderr_reader_thread.join
 
       @stop_time = Time.new
     end
   end
+
+  def subprocess_pgid
+    @subprocess_pgid ||= Process.getpgid(subprocess_pid)
+  end
+
+  def sidekiq_app_name
+    options.fetch(:application)
+  end
+
+  def find_sidekiq_pid # rubocop:disable Metrics/AbcSize
+    Thread.new do
+      while running? && !pid
+        Knj::Unix_proc.list("grep" => "sidekiq") do |process|
+          cmd = process.data.fetch("cmd")
+
+          if /sidekiq ([0-9]+\.[0-9]+\.[0-9]+) (#{options.possible_process_titles_joined_regex})/.match?(cmd)
+            sidekiq_pid = process.data.fetch("pid").to_i
+
+            begin
+              sidekiq_pgid = Process.getpgid(sidekiq_pid)
+            rescue Errno::ESRCH
+              # Process no longer running
+            end
+
+            if subprocess_pgid == sidekiq_pgid
+              puts "FOUND PID: #{sidekiq_pid}"
+
+              @pid = sidekiq_pid
+              options.events.call(:on_process_started, pid: pid)
+
+              break
+            else
+              puts "PGID didn't match - Sidekiq: #{sidekiq_pgid} Own: #{subprocess_pgid}"
+            end
+          end
+        end
+
+        unless pid
+          puts "Waiting 1 second before trying to find Sidekiq PID again"
+          sleep 1
+        end
+      end
+    end
+  end
 end

data/lib/process_bot/process.rb

@@ -1,35 +1,79 @@
+require "forwardable"
+require "json"
+require "string-cases"
+
 class ProcessBot::Process
+  extend Forwardable
+
+  def_delegator :handler_instance, :graceful
+  def_delegator :handler_instance, :stop
+
   autoload :Handlers, "#{__dir__}/process/handlers"
   autoload :Runner, "#{__dir__}/process/runner"
 
-  attr_reader :options, :stopped
+  attr_reader :current_pid, :current_process_title, :options, :port, :stopped
 
   def initialize(options)
     @options = options
     @stopped = false
-  end
 
-  def logger
-    @logger ||= ProcessBot::Logger.new(options: options)
+    options.events.connect(:on_process_started, &method(:on_process_started)) # rubocop:disable Performance/MethodObjectAsBlock
+    options.events.connect(:on_socket_opened, &method(:on_socket_opened)) # rubocop:disable Performance/MethodObjectAsBlock
+
+    logger.logs("ProcessBot 1 - Options: #{options.options}")
   end
 
-  def start_control_socket
-    @control_socket = ProcessBot::ControlSocket.new(options: options, process: self)
-    @control_socket.start
+  def execute!
+    command = options.fetch(:command)
+
+    if command == "start"
+      start
+    elsif command == "graceful" || command == "stop"
+      client.send_command(command: command, options: options.options)
+    else
+      raise "Unknown command: #{command}"
+    end
   end
 
-  def stop
-    @stopped = true
+  def client
+    @client ||= ProcessBot::ClientSocket.new(options: options)
   end
 
   def handler_class
     @handler_class ||= begin
-      require_relative "process/handlers/#{options.fetch(:handler)}"
-      ProcessBot::Process::Handlers.const_get(StringCases.snake_to_camel(options.fetch(:handler)))
+      require_relative "process/handlers/#{handler_name}"
+      ProcessBot::Process::Handlers.const_get(StringCases.snake_to_camel(handler_name))
     end
   end
 
-  def execute!
+  def handler_instance
+    @handler_instance ||= handler_class.new(self)
+  end
+
+  def handler_name
+    @handler_name ||= options.fetch(:handler)
+  end
+
+  def logger
+    @logger ||= ProcessBot::Logger.new(options: options)
+  end
+
+  def on_process_started(_event_name, pid:)
+    @current_pid = pid
+    update_process_title
+  end
+
+  def on_socket_opened(_event_name, port:)
+    @port = port
+    update_process_title
+  end
+
+  def start_control_socket
+    @control_socket = ProcessBot::ControlSocket.new(options: options, process: self)
+    @control_socket.start
+  end
+
+  def start
     start_control_socket
 
     loop do
@@ -38,15 +82,24 @@ class ProcessBot::Process
       if stopped
         break
       else
-        puts "Process stopped - starting again after 1 sec"
+        logger.logs "Process stopped - starting again after 1 sec"
         sleep 1
       end
     end
   end
 
+  def set_stopped
+    @stopped = true
+  end
+
   def run
-    handler_instance = handler_class.new(options)
-    runner = ProcessBot::Process::Runner.new(command: handler_instance.command, logger: logger, options: options)
+    runner = ProcessBot::Process::Runner.new(command: handler_instance.start_command, logger: logger, options: options)
     runner.run
   end
+
+  def update_process_title
+    process_args = {application: options[:application], handler: handler_name, id: options[:id], pid: current_pid, port: port}
+    @current_process_title = "ProcessBot #{JSON.generate(process_args)}"
+    Process.setproctitle(current_process_title)
+  end
 end

data/lib/process_bot/version.rb

@@ -1,3 +1,3 @@
 module ProcessBot
-  VERSION = "0.1.2"
+  VERSION = "0.1.4".freeze
 end

data/lib/process_bot.rb

@@ -4,6 +4,7 @@ module ProcessBot
   class Error < StandardError; end
 
   autoload :Capistrano, "#{__dir__}/process_bot/capistrano"
+  autoload :ClientSocket, "#{__dir__}/process_bot/client_socket"
   autoload :ControlSocket, "#{__dir__}/process_bot/control_socket"
   autoload :Logger, "#{__dir__}/process_bot/logger"
   autoload :Options, "#{__dir__}/process_bot/options"

data/peak_flow.yml

@@ -1,4 +1,20 @@
 rvm: true
-script:
-  - bundle exec rspec
-  - bundle exec rubocop
+builds:
+  build_1:
+    environment:
+      RUBY_VERSION: 2.7.8
+    name: Ruby 2.7.8
+    script:
+      - bundle exec rspec
+  build_2:
+    environment:
+      RUBY_VERSION: 3.2.2
+    name: Ruby 3.2.2
+    script:
+      - bundle exec rspec
+  build_3:
+    environment:
+      RUBY_VERSION: 2.7.8
+    name: Rubocop
+    script:
+      - bundle exec rubocop

data/process_bot.gemspec

@@ -12,7 +12,7 @@ Gem::Specification.new do |spec|
   spec.description = "Run and control processes."
   spec.homepage = "https://github.com/kaspernj/process_bot"
   spec.license = "MIT"
-  spec.required_ruby_version = ">= 2.6.0"
+  spec.required_ruby_version = ">= 2.7.0"
 
   spec.metadata["allowed_push_host"] = "https://rubygems.org"
 
@@ -31,15 +31,7 @@ Gem::Specification.new do |spec|
   spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  # Uncomment to register a new dependency of your gem
-  # spec.add_dependency "example-gem", "~> 1.0"
+  spec.add_dependency "knjrbfw", ">= 0.0.116"
 
-  spec.add_development_dependency "rubocop"
-  spec.add_development_dependency "rubocop-performance"
-  spec.add_development_dependency "rubocop-rake"
-  spec.add_development_dependency "rubocop-rspec"
-
-  # For more information and examples about making a new gem, check out our
-  # guide at: https://bundler.io/guides/creating_gem.html
   spec.metadata["rubygems_mfa_required"] = "true"
 end

metadata

@@ -1,71 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: process_bot
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.4
 platform: ruby
 authors:
 - kaspernj
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-10-18 00:00:00.000000000 Z
+date: 2023-12-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: rubocop
+  name: knjrbfw
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
+        version: 0.0.116
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: rubocop-performance
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: rubocop-rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: rubocop-rspec
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.0.116
 description: Run and control processes.
 email:
 - k@spernj.org
@@ -76,6 +34,7 @@ extra_rdoc_files: []
 files:
 - ".rspec"
 - ".rubocop.yml"
+- ".ruby-version"
 - CHANGELOG.md
 - Gemfile
 - Gemfile.lock
@@ -91,6 +50,7 @@ files:
 - lib/process_bot/capistrano/sidekiq.rake
 - lib/process_bot/capistrano/sidekiq.rb
 - lib/process_bot/capistrano/sidekiq_helpers.rb
+- lib/process_bot/client_socket.rb
 - lib/process_bot/control_socket.rb
 - lib/process_bot/logger.rb
 - lib/process_bot/options.rb
@@ -119,14 +79,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.6.0
+      version: 2.7.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
+rubygems_version: 3.4.17
 signing_key: 
 specification_version: 4
 summary: Run and control processes.