procodile 1.0.2 → 1.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 29cc9799aaaaa76c72574fc9189d026ed3a16aa1
-  data.tar.gz: 506ce012eb6c52c749701d43a6909d6ef41f670e
+  metadata.gz: 812b0f566074632d4c15caddfd02e6b1ddf8ee88
+  data.tar.gz: 2acf4f380545089801e036b22aebbd1937d5be6b
 SHA512:
-  metadata.gz: 3678666e81aaec26e1991378cd20dc8bf8d285a52ed054948d91abe99db5f82299764ac5fc724a80f0ad14129ca8a45e06c6e1860fe9d0506d36c471f6ee1ed9
-  data.tar.gz: 09323ed2d5bbd94d7213ceb6d544450e78e9d1898597e44728bf5d0c74e9fc2795f013dc2c62f5e82af577104354850931f61c48d41c2dde9825416a838042e9
+  metadata.gz: 38ee04794ce4b93d537f20704cae020dd3f03e5af610f181a3a2c11a1657e5fc48dc486ad759d74cd60187e8859869176dd8d19df1f3ef6bcd7d01ca2e8bd11e
+  data.tar.gz: 57ff3aef3f9e8dcbbe3c0871f68e15e82b1fa18c10e035d891042774340388bf2de595bc1de95e6343e3b5f743e9ebd13a126c9db105efa925ddaaa8c034e1ba

data/bin/procodile

@@ -1,43 +1,29 @@
 #!/usr/bin/env ruby
+$:.unshift(File.expand_path('../../lib', __FILE__))
+
 require 'optparse'
 require 'fileutils'
-$:.unshift(File.expand_path('../../lib', __FILE__))
 require 'procodile'
+require 'procodile/version'
+require 'procodile/error'
+require 'procodile/config'
+require 'procodile/cli'
+
+Thread.abort_on_exception = true
 
-command = ARGV[0]
+command = ARGV[0] || 'help'
+cli = Procodile::CLI.new
 
 options = {}
 begin
   OptionParser.new do |opts|
-    opts.banner = "Usage: procodile [command] [options]"
+    opts.version = Procodile::VERSION
+    opts.banner = "Usage: procodile #{command} [options]"
     opts.on("-r", "--root PATH", "The path to the root of your application") do |root|
       options[:root] = root
     end
-
-    if ['start', 'stop', 'restart'].include?(command)
-      opts.on("-p", "--processes a,b,c", "Only #{command} the listed processes or process types") do |processes|
-        options[:processes] = processes
-      end
-    end
-
-    if command == 'start'
-      opts.on("-f", "--foreground", "Run the supervisor in the foreground") do
-        options[:foreground] = true
-      end
-
-      opts.on("--clean", "Remove all previous pid and sock files before starting") do
-        options[:clean] = true
-      end
-
-      opts.on("-b", "--brittle", "Kill everything when one process exits") do
-        options[:brittle] = true
-      end
-
-      opts.on("-d", "--dev", "Run in development mode") do
-        options[:development] = true
-        options[:brittle] = true
-        options[:foreground] = true
-      end
+    if cli.class.commands[command.to_sym] && option_block = cli.class.commands[command.to_sym][:options]
+      option_block.call(opts, cli)
     end
   end.parse!
 rescue OptionParser::InvalidOption => e
@@ -45,14 +31,10 @@ rescue OptionParser::InvalidOption => e
   exit 1
 end
 
-require 'procodile/error'
-require 'procodile/config'
-require 'procodile/cli'
-
-Thread.abort_on_exception = true
 begin
-  config = Procodile::Config.new(options[:root] ? File.expand_path(options[:root]) : FileUtils.pwd)
-  cli = Procodile::CLI.new(config, options)
+  if command != 'help'
+    cli.config = Procodile::Config.new(options[:root] ? File.expand_path(options[:root]) : FileUtils.pwd)
+  end
   cli.run(command)
 rescue Procodile::Error => e
   $stderr.puts "Error: #{e.message}".color(31)

data/lib/procodile/cli.rb

@@ -1,4 +1,5 @@
 require 'fileutils'
+require 'procodile/version'
 require 'procodile/error'
 require 'procodile/supervisor'
 require 'procodile/signal_handler'
@@ -7,20 +8,93 @@ require 'procodile/control_client'
 module Procodile
   class CLI
 
-    def initialize(config, cli_options = {})
-      @config = config
-      @cli_options = cli_options
+    def self.commands
+      @commands ||= {}
+    end
+
+    def self.desc(description)
+      @description = description
+    end
+
+    def self.options(&block)
+      @options = block
+    end
+
+    def self.command(name)
+      commands[name] = {:name => name, :description => @description, :options => @options}
+      @description = nil
+      @options = nil
+    end
+
+    attr_accessor :options
+    attr_accessor :config
+
+    def initialize
+      @options = {}
     end
 
     def run(command)
-      if self.class.instance_methods(false).include?(command.to_sym) && command != 'run'
+      if self.class.commands.keys.include?(command.to_sym)
         public_send(command)
       else
         raise Error, "Invalid command '#{command}'"
       end
     end
 
-    def start
+    #
+    # Help
+    #
+
+    desc "Shows this help output"
+    command def help
+      puts "\e[45;37mWelcome to Procodile v#{Procodile::VERSION}\e[0m"
+      puts "For documentation see https://adam.ac/procodile."
+      puts
+
+      puts "The following commands are supported:"
+      puts
+      self.class.commands.each do |method, options|
+        puts "  \e[34m#{method.to_s.ljust(18, ' ')}\e[0m #{options[:description]}"
+      end
+      puts
+      puts "For details for the options available for each command, use the --help option."
+      puts "For example 'procodile start --help'."
+    end
+
+    #
+    # Start
+    #
+
+    desc "Starts processes and/or the supervisor"
+    options do |opts, cli|
+      opts.on("-p", "--processes a,b,c", "Only start the listed processes or process types") do |processes|
+        cli.options[:processes] = processes
+      end
+
+      opts.on("-f", "--foreground", "Run the supervisor in the foreground") do
+        cli.options[:foreground] = true
+      end
+
+      opts.on("--clean", "Remove all previous pid and sock files before starting") do
+        cli.options[:clean] = true
+      end
+
+      opts.on("-b", "--brittle", "Kill everything when one process exits") do
+        cli.options[:brittle] = true
+      end
+
+      opts.on("--stop-when-none", "Stop the supervisor when all processes are stopped") do
+        cli.options[:stop_when_none] = true
+      end
+
+      opts.on("-d", "--dev", "Run in development mode") do
+        cli.options[:development] = true
+        cli.options[:brittle] = true
+        cli.options[:foreground] = true
+        cli.options[:stop_when_none] = true
+      end
+    end
+    command def start
       if running?
         instances = ControlClient.run(@config.sock_path, 'start_processes', :processes => process_names_from_cli_option)
         if instances.empty?
@@ -34,17 +108,18 @@ module Procodile
       end
 
       run_options = {}
-      run_options[:brittle] = @cli_options[:brittle]
+      run_options[:brittle] = @options[:brittle]
+      run_options[:stop_when_none] = @options[:stop_when_none]
 
       processes = process_names_from_cli_option
 
-      if @cli_options[:clean]
+      if @options[:clean]
         FileUtils.rm_f(File.join(@config.pid_root, '*.pid'))
         FileUtils.rm_f(File.join(@config.pid_root, '*.sock'))
         puts "Removed all old pid & sock files"
       end
 
-      if @cli_options[:foreground]
+      if @options[:foreground]
         File.open(pid_path, 'w') { |f| f.write(::Process.pid) }
         Supervisor.new(@config, run_options).start(:processes => processes)
       else
@@ -62,10 +137,24 @@ module Procodile
       end
     end
 
-    def stop
+    #
+    # Stop
+    #
+
+    desc "Stops processes and/or the supervisor"
+    options do |opts, cli|
+      opts.on("-p", "--processes a,b,c", "Only stop the listed processes or process types") do |processes|
+        cli.options[:processes] = processes
+      end
+
+      opts.on("-s", "--stop-supervisor", "Stop the ") do
+        cli.options[:stop_supervisor] = true
+      end
+    end
+    command def stop
       if running?
         options = {}
-        instances = ControlClient.run(@config.sock_path, 'stop', :processes => process_names_from_cli_option)
+        instances = ControlClient.run(@config.sock_path, 'stop', :processes => process_names_from_cli_option, :stop_supervisor => @options[:stop_supervisor])
         if instances.empty?
           puts "There are no processes to stop."
         else
@@ -78,7 +167,17 @@ module Procodile
       end
     end
 
-    def restart
+    #
+    # Restart
+    #
+
+    desc "Restart processes"
+    options do |opts, cli|
+      opts.on("-p", "--processes a,b,c", "Only restart the listed processes or process types") do |processes|
+        cli.options[:processes] = processes
+      end
+    end
+    command def restart
       if running?
         options = {}
         instances = ControlClient.run(@config.sock_path, 'restart', :processes => process_names_from_cli_option)
@@ -94,7 +193,12 @@ module Procodile
       end
     end
 
-    def stop_supervisor
+    #
+    # Stop Supervisor
+    #
+
+    desc "Stop the supervisor without stopping processes"
+    command def stop_supervisor
       if running?
         ::Process.kill('TERM', current_pid)
         puts "Supervisor will be stopped in a moment."
@@ -103,49 +207,79 @@ module Procodile
       end
     end
 
-    def reload_config
+    #
+    # Reload Config
+    #
+
+    desc "Reload Procodile configuration"
+    command def reload
       if running?
         ControlClient.run(@config.sock_path, 'reload_config')
-        puts "Reloading config for #{@config.app_name}"
+        puts "Reloaded config for #{@config.app_name}"
       else
         raise Error, "#{@config.app_name} supervisor isn't running"
       end
     end
 
-    def status
+    #
+    # Check process concurrency
+    #
+
+    desc "Check process concurrency"
+    options do |opts, cli|
+      opts.on("--no-reload", "Do not reload the configuration before checking") do |processes|
+        cli.options[:reload] = false
+      end
+    end
+    command def check_concurrency
       if running?
-        stats = ControlClient.run(@config.sock_path, 'status')
-        stats['processes'].each_with_index do |process, index|
-          puts unless index == 0
-          puts "|| ".color(process['log_color']) + process['name'].color(process['log_color'])
-          puts "||".color(process['log_color']) + " Quantity       " + process['quantity'].to_s
-          puts "||".color(process['log_color']) + " Command        " + process['command']
-          puts "||".color(process['log_color']) + " Respawning     " + "#{process['max_respawns']} every #{process['respawn_window']} seconds"
-          puts "||".color(process['log_color']) + " Restart mode   " + process['restart_mode']
-          puts "||".color(process['log_color']) + " Log path       " + (process['log_path'] || "none specified")
-          instances = stats['instances'][process['name']]
-          if instances.empty?
-            puts "||".color(process['log_color']) + " No processes running."
-          else
-            instances.each do |instance|
-              print "|| ".color(process['log_color']) + instance['description'].to_s.ljust(20, ' ').color(process['log_color'])
-              if instance['running']
-                print ' Running '.color("42;37")
-              else
-                print ' Stopped '.color("41;37")
-              end
-              print "     pid " + instance['pid'].to_s.ljust(12, ' ')
-              print instance['respawns'].to_s + " respawns"
-              puts
-            end
+        reply = ControlClient.run(@config.sock_path, 'check_concurrency', :reload => @options[:reload])
+        if reply['started'].empty? && reply['stopped'].empty?
+          puts "Everything looks good!"
+        else
+          reply['started'].each do |instance|
+            puts "Started #{instance['description']}".color(32)
+          end
+
+          reply['stopped'].each do |instance|
+            puts "Stopped #{instance['description']}".color(31)
           end
         end
+      else
+        raise Error, "#{@config.app_name} supervisor isn't running"
+      end
+    end
+
+    #
+    # Status
+    #
+
+    desc "Show the current status of processes"
+    options do |opts, cli|
+      opts.on("--json", "Return the status as a JSON hash") do
+        cli.options[:json] = true
+      end
+    end
+    command def status
+      if running?
+        status = ControlClient.run(@config.sock_path, 'status')
+        if @options[:json]
+          puts status.to_json
+        else
+          require 'procodile/status_cli_output'
+          StatusCLIOutput.new(status).print_all
+        end
       else
         puts "#{@config.app_name} supervisor not running"
       end
     end
 
-    def kill
+    #
+    # Kill
+    #
+
+    desc "Forcefully kill all known processes"
+    command def kill
       Dir[File.join(@config.pid_root, '*.pid')].each do |pid_path|
         name = pid_path.split('/').last.gsub(/\.pid\z/, '')
         pid = File.read(pid_path).to_i
@@ -195,8 +329,8 @@ module Procodile
     end
 
     def process_names_from_cli_option
-      if @cli_options[:processes]
-        processes = @cli_options[:processes].split(',')
+      if @options[:processes]
+        processes = @options[:processes].split(',')
         if processes.empty?
           raise Error, "No process names provided"
         end

data/lib/procodile/config.rb

@@ -21,37 +21,33 @@ module Procodile
       @process_list = nil
       @options = nil
       @process_options = nil
-
-      process_list.each do |name, command|
-        if process = @processes[name]
-          # This command is already in our list. Add it.
-          if process.command != command
-            process.command = command
-            Procodile.log nil, 'system', "#{name} command has changed. Updated."
-          end
-
-          if process_options[name].is_a?(Hash)
-            process.options = process_options[name]
+      @local_options = nil
+      @local_process_options = nil
+
+      if @processes
+        process_list.each do |name, command|
+          if process = @processes[name]
+            # This command is already in our list. Add it.
+            if process.command != command
+              process.command = command
+              Procodile.log nil, 'system', "#{name} command has changed. Updated."
+            end
+            process.options = options_for_process(name)
           else
-            process.options = {}
+            Procodile.log nil, 'system', "#{name} has been added to the Procfile. Adding it."
+            @processes[name] = create_process(name, command, COLORS[@processes.size.divmod(COLORS.size)[1]])
           end
-        else
-          Procodile.log nil, 'system', "#{name} has been added to the Procfile. Adding it."
-          @processes[name] = Process.new(self, name, command, process_options[name] || {})
-          @processes[name].log_color = COLORS[@processes.size.divmod(COLORS.size)[1]]
         end
       end
-
     end
 
     def app_name
-      @app_name ||= options['app_name'] || 'Procodile'
+      @app_name ||= local_options['app_name'] || options['app_name'] || 'Procodile'
     end
 
     def processes
       @processes ||= process_list.each_with_index.each_with_object({}) do |((name, command), index), hash|
-        hash[name] = Process.new(self, name, command, process_options[name] || {})
-        hash[name].log_color = COLORS[index.divmod(COLORS.size)[1]]
+        hash[name] = create_process(name, command, COLORS[index.divmod(COLORS.size)[1]])
       end
     end
 
@@ -67,12 +63,32 @@ module Procodile
       @process_options ||= options['processes'] || {}
     end
 
+    def local_options
+      @local_options ||= File.exist?(local_options_path) ? YAML.load_file(local_options_path) : {}
+    end
+
+    def local_process_options
+      @local_process_options ||= local_options['processes'] || {}
+    end
+
+    def options_for_process(name)
+      (process_options[name] || {}).merge(local_process_options[name] || {})
+    end
+
+    def environment_variables
+      (options['env'] || {}).merge(local_options['env'] || {})
+    end
+
+    def local_environment_variables
+      @local_environment_variables ||= local_options['env'] || {}
+    end
+
     def pid_root
-      @pid_root ||= File.expand_path(options['pid_root'] || 'pids', @root)
+      @pid_root ||= File.expand_path(local_options['pid_root'] || options['pid_root'] || 'pids', @root)
     end
 
     def log_path
-      @log_path ||= File.expand_path(options['log_path'] || 'procodile.log', @root)
+      @log_path ||= File.expand_path(local_options['log_path'] || options['log_path'] || 'procodile.log', @root)
     end
 
     def sock_path
@@ -89,5 +105,15 @@ module Procodile
       File.join(@root, 'Procfile.options')
     end
 
+    def local_options_path
+      File.join(@root, 'Procfile.local')
+    end
+
+    def create_process(name, command, log_color)
+      process = Process.new(self, name, command, options_for_process(name))
+      process.log_color = log_color
+      process
+    end
+
   end
 end

data/lib/procodile/control_session.rb

@@ -1,4 +1,5 @@
 require 'json'
+require 'procodile/version'
 
 module Procodile
   class ControlSession
@@ -30,7 +31,7 @@ module Procodile
     end
 
     def stop(options)
-      instances = @supervisor.stop(:processes => options['processes'])
+      instances = @supervisor.stop(:processes => options['processes'], :stop_supervisor => options['stop_supervisor'])
       "200 " + instances.map(&:to_hash).to_json
     end
 
@@ -44,23 +45,32 @@ module Procodile
       "200"
     end
 
+    def check_concurrency(options)
+      result = @supervisor.check_concurrency(:reload => options['reload'])
+      result = result.each_with_object({}) { |(type, instances), hash| hash[type] = instances.map(&:to_hash) }
+      "200 #{result.to_json}"
+    end
+
+
     def status(options)
       instances = {}
       @supervisor.processes.each do |process, process_instances|
         instances[process.name] = []
         for instance in process_instances
-          instances[process.name] << {
-            :description => instance.description,
-            :pid => instance.pid,
-            :running => instance.running?,
-            :respawns => instance.respawns,
-            :command => instance.process.command
-          }
+          instances[process.name] << instance.to_hash
         end
       end
 
       processes = @supervisor.processes.keys.map(&:to_hash)
-      result = {:instances => instances, :processes => processes}
+      result = {
+        :version => Procodile::VERSION,
+        :root => @supervisor.config.root,
+        :app_name => @supervisor.config.app_name,
+        :supervisor => @supervisor.to_hash,
+        :instances => instances,
+        :processes => processes,
+        :environment_variables => @supervisor.config.environment_variables
+      }
       "200 #{result.to_json}"
     end
 

data/lib/procodile/instance.rb

@@ -13,6 +13,7 @@ module Procodile
       @id = id
       @respawns = 0
       @respawnable = true
+      @started_at = nil
     end
 
     #
@@ -22,6 +23,16 @@ module Procodile
       "#{@process.name}.#{@id}"
     end
 
+    #
+    # Return an array of environment variables that should be set
+    #
+    def environment_variables
+      @process.config.environment_variables.merge({
+        'PID_FILE' => self.pid_file_path,
+        'APP_ROOT' => @process.config.root
+      })
+    end
+
     #
     # Should this instance still be monitored by the supervisor?
     #
@@ -64,7 +75,7 @@ module Procodile
     #
     # Start a new instance of this process
     #
-    def start
+    def start(&block)
       @stopping = false
       existing_pid = self.pid_from_file
       if running?(existing_pid)
@@ -72,6 +83,7 @@ module Procodile
         # to monitor this process rather than spawning a new one.
         @pid = existing_pid
         Procodile.log(@process.log_color, description, "Already running with PID #{@pid}")
+        @started_at = File.mtime(self.pid_file_path)
         nil
       else
         if self.process.log_path
@@ -84,10 +96,15 @@ module Procodile
         end
 
         Dir.chdir(@process.config.root)
-        @pid = ::Process.spawn({'PID_FILE' => pid_file_path}, @process.command, :out => log_destination, :err => log_destination, :pgroup => true)
+        @pid = ::Process.spawn(environment_variables, @process.command, :out => log_destination, :err => log_destination, :pgroup => true)
         Procodile.log(@process.log_color, description, "Started with PID #{@pid}")
         File.open(pid_file_path, 'w') { |f| f.write(@pid.to_s + "\n") }
         ::Process.detach(@pid)
+        @started_at = Time.now
+
+        if block_given?
+          block.call(self, return_value)
+        end
 
         return_value
       end
@@ -120,6 +137,7 @@ module Procodile
     # started again
     #
     def on_stop
+      @started_at = nil
       tidy
       unmonitor
     end
@@ -135,7 +153,7 @@ module Procodile
     #
     # Retarts the process using the appropriate method from the process configuraiton
     #
-    def restart
+    def restart(&block)
       Procodile.log(@process.log_color, description, "Restarting using #{@process.restart_mode} mode")
       @restarting = true
       update_pid
@@ -146,11 +164,11 @@ module Procodile
           Procodile.log(@process.log_color, description, "Sent #{@process.restart_mode.upcase} signal to process #{@pid}")
         else
           Procodile.log(@process.log_color, description, "Process not running already. Starting it.")
-          start
+          start(&block)
         end
       when 'start-term'
         old_process_pid = @pid
-        start
+        start(&block)
         Procodile.log(@process.log_color, description, "Sent #{@process.term_signal} signal to old PID #{old_process_pid} (forgetting now)")
         ::Process.kill(@process.term_signal, old_process_pid)
       when 'term-start'
@@ -158,7 +176,7 @@ module Procodile
         Thread.new do
           # Wait for this process to stop and when it has, run it.
           sleep 0.5 while running?
-          start
+          start(&block)
         end
       end
     ensure
@@ -259,7 +277,8 @@ module Procodile
         :description => self.description,
         :pid => self.pid,
         :respawns => self.respawns,
-        :running => self.running?
+        :running => self.running?,
+        :started_at => @started_at ? @started_at.to_i : nil
       }
     end
 

data/lib/procodile/status_cli_output.rb

@@ -0,0 +1,77 @@
+module Procodile
+  class StatusCLIOutput
+
+    def initialize(status)
+      @status = status
+    end
+
+    def print_all
+      print_header
+      print_processes
+    end
+
+    def print_header
+      puts "Procodile Version   " + @status['version'].to_s.color(34)
+      puts "Application Root    " + "#{@status['root']}".color(34)
+      puts "Supervisor PID      " + "#{@status['supervisor']['pid']}".color(34)
+      if time = @status['supervisor']['started_at']
+        time = Time.at(time)
+        puts "Started             " + "#{time.to_s}".color(34)
+      end
+      if @status['environment_variables'] && !@status['environment_variables'].empty?
+        @status['environment_variables'].each_with_index do |(key, value), index|
+          if index == 0
+            print "Environment Vars    "
+          else
+            print "                    "
+          end
+          print key.color(34)
+          puts " " + value.to_s
+        end
+      end
+    end
+
+    def print_processes
+      puts
+      @status['processes'].each_with_index do |process, index|
+        puts unless index == 0
+        puts "|| ".color(process['log_color']) + process['name'].color(process['log_color'])
+        puts "||".color(process['log_color']) + " Quantity            " + process['quantity'].to_s
+        puts "||".color(process['log_color']) + " Command             " + process['command']
+        puts "||".color(process['log_color']) + " Respawning          " + "#{process['max_respawns']} every #{process['respawn_window']} seconds"
+        puts "||".color(process['log_color']) + " Restart mode        " + process['restart_mode']
+        puts "||".color(process['log_color']) + " Log path            " + (process['log_path'] || "none specified")
+        instances = @status['instances'][process['name']]
+        if instances.empty?
+          puts "||".color(process['log_color']) + " No processes running."
+        else
+          instances.each do |instance|
+            print "|| => ".color(process['log_color']) + instance['description'].to_s.ljust(17, ' ').color(process['log_color'])
+            if instance['running']
+              print 'Running'.color("32")
+            else
+              print 'Stopped'.color("31")
+            end
+            print "   " + formatted_timestamp(instance['started_at']).ljust(10, ' ')
+            print "   pid: " + instance['pid'].to_s.ljust(7, ' ')
+            print "   respawns: " + instance['respawns'].to_s.ljust(7, ' ')
+            puts
+          end
+        end
+      end
+    end
+
+    private
+
+    def formatted_timestamp(timestamp)
+      return '' if timestamp.nil?
+      timestamp = Time.at(timestamp)
+      if timestamp > (Time.now - (60 * 60 * 24))
+        timestamp.strftime("%H:%M")
+      else
+        timestamp.strftime("%d/%m/%Y")
+      end
+    end
+
+  end
+end

data/lib/procodile/supervisor.rb

@@ -5,6 +5,7 @@ module Procodile
 
     attr_reader :config
     attr_reader :processes
+    attr_reader :started_at
 
     def initialize(config, run_options = {})
       @config = config
@@ -13,7 +14,7 @@ module Procodile
       @readers = {}
       @signal_handler = SignalHandler.new('TERM', 'USR1', 'USR2', 'INT', 'HUP')
       @signal_handler.register('TERM') { stop_supervisor }
-      @signal_handler.register('INT') { stop }
+      @signal_handler.register('INT') { stop(:stop_supervisor => true) }
       @signal_handler.register('USR1') { restart }
       @signal_handler.register('USR2') { status }
       @signal_handler.register('HUP') { reload_config }
@@ -30,10 +31,12 @@ module Procodile
       end
       start_processes(options[:processes])
       watch_for_output
+      @started_at = Time.now
       loop { supervise; sleep 3 }
     end
 
     def start_processes(types = [])
+      reload_config
       Array.new.tap do |instances_started|
         @config.processes.each do |name, process|
           next if types && !types.include?(name.to_s) # Not a process we want
@@ -45,17 +48,19 @@ module Procodile
     end
 
     def stop(options = {})
+      if options[:stop_supervisor]
+        @run_options[:stop_when_none] = true
+      end
+
       Array.new.tap do |instances_stopped|
         if options[:processes].nil?
-          return if @stopping
-          @stopping = true
           Procodile.log nil, "system", "Stopping all #{@config.app_name} processes"
-            @processes.each do |_, instances|
-              instances.each do |instance|
-                instance.stop
-                instances_stopped << instance
-              end
+          @processes.each do |_, instances|
+            instances.each do |instance|
+              instance.stop
+              instances_stopped << instance
             end
+          end
         else
           instances = process_names_to_instances(options[:processes])
           Procodile.log nil, "system", "Stopping #{instances.size} process(es)"
@@ -68,23 +73,25 @@ module Procodile
     end
 
     def restart(options = {})
-      @config.reload
+      reload_config
       Array.new.tap do |instances_restarted|
         if options[:processes].nil?
           Procodile.log nil, "system", "Restarting all #{@config.app_name} processes"
           @processes.each do |_, instances|
             instances.each do |instance|
-              instance.restart
+              instance.restart { |_, io| add_reader(instance, io) }
               instances_restarted << instance
             end
           end
+          instances_restarted.push(*check_instance_quantities[:started])
         else
           instances = process_names_to_instances(options[:processes])
           Procodile.log nil, "system", "Restarting #{instances.size} process(es)"
           instances.each do |instance|
-            instance.restart
+            instance.restart { |_, io| add_reader(instance, io) }
             instances_restarted << instance
           end
+          instances_restarted.push(*check_instance_quantities(options[:processes])[:started])
         end
       end
     end
@@ -116,29 +123,66 @@ module Procodile
         end
       end
 
-      # If the processes go away, we can stop the supervisor now
-      if @processes.all? { |_,instances| instances.size == 0 }
-        Procodile.log nil, "system", "All processes have stopped"
-        stop_supervisor
+      if @run_options[:stop_when_none]
+        # If the processes go away, we can stop the supervisor now
+        if @processes.all? { |_,instances| instances.size == 0 }
+          Procodile.log nil, "system", "All processes have stopped"
+          stop_supervisor
+        end
       end
     end
 
     def reload_config
       Procodile.log nil, "system", "Reloading configuration"
       @config.reload
-      check_instance_quantities
+    end
+
+    def check_concurrency(options = {})
+      Procodile.log nil, "system", "Checking process concurrency"
+      reload_config unless options[:reload] == false
+      result = check_instance_quantities
+      if result[:started].empty? && result[:stopped].empty?
+        Procodile.log nil, "system", "Process concurrency looks good"
+      else
+        unless result[:started].empty?
+          Procodile.log nil, "system", "Concurrency check started #{result[:started].map(&:description).join(', ')}"
+        end
+
+        unless result[:stopped].empty?
+          Procodile.log nil, "system", "Concurrency check stopped #{result[:stopped].map(&:description).join(', ')}"
+        end
+      end
+      result
+    end
+
+    def to_hash
+      {
+        :started_at => @started_at ? @started_at.to_i : nil,
+        :pid => ::Process.pid
+      }
     end
 
     private
 
+    def add_reader(instance, io)
+      return unless io
+      @readers[io] = instance
+      @signal_handler.notice
+    end
+
     def watch_for_output
       Thread.new do
         loop do
           io = IO.select([@signal_handler.pipe[:reader]] + @readers.keys, nil, nil, 30)
           @signal_handler.handle
+
           if io
             io.first.each do |reader|
-              next if reader == @signal_handler.pipe[:reader]
+              if reader == @signal_handler.pipe[:reader]
+                @signal_handler.pipe[:reader].read_nonblock(999) rescue nil
+                next
+              end
+
               if reader.eof?
                 @readers.delete(reader)
               else
@@ -155,17 +199,20 @@ module Procodile
       end
     end
 
-    def check_instance_quantities
-      @processes.each do |process, instances|
-        if instances.size > process.quantity
-          quantity_to_stop = instances.size - process.quantity
-          Procodile.log nil, "system", "Stopping #{quantity_to_stop} #{process.name} process(es)"
-          instances.last(quantity_to_stop).each(&:stop)
-        elsif instances.size < process.quantity
-          quantity_needed = process.quantity - instances.size
-          start_id = instances.last ? instances.last.id + 1 : 1
-          Procodile.log nil, "system", "Starting #{quantity_needed} more #{process.name} process(es) (start with #{start_id})"
-          start_instances(process.generate_instances(quantity_needed, start_id))
+    def check_instance_quantities(processes = nil)
+      {:started => [], :stopped => []}.tap do |status|
+        @processes.each do |process, instances|
+          next if processes && !processes.include?(process.name)
+          if instances.size > process.quantity
+            quantity_to_stop = instances.size - process.quantity
+            Procodile.log nil, "system", "Stopping #{quantity_to_stop} #{process.name} process(es)"
+            status[:stopped] = instances.last(quantity_to_stop).each(&:stop)
+          elsif instances.size < process.quantity
+            quantity_needed = process.quantity - instances.size
+            start_id = instances.last ? instances.last.id + 1 : 1
+            Procodile.log nil, "system", "Starting #{quantity_needed} more #{process.name} process(es) (start with #{start_id})"
+            status[:started] = start_instances(process.generate_instances(quantity_needed, start_id))
+          end
         end
       end
     end
@@ -175,8 +222,7 @@ module Procodile
         if @run_options[:brittle]
           instance.respawnable = false
         end
-        io = instance.start
-        @readers[io] = instance if io
+        instance.start { |_, io| add_reader(instance, io) }
         @processes[instance.process] ||= []
         @processes[instance.process] << instance
       end

data/lib/procodile/version.rb

@@ -0,0 +1,3 @@
+module Procodile
+  VERSION = '1.0.3'
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: procodile
 version: !ruby/object:Gem::Version
-  version: 1.0.2
+  version: 1.0.3
 platform: ruby
 authors:
 - Adam Cooke
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-10-17 00:00:00.000000000 Z
+date: 2016-10-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -34,8 +34,6 @@ extra_rdoc_files: []
 files:
 - bin/procodile
 - lib/procodile.rb
-- lib/procodile/capistrano2.rb
-- lib/procodile/capistrano3.rb
 - lib/procodile/cli.rb
 - lib/procodile/config.rb
 - lib/procodile/control_client.rb
@@ -46,7 +44,9 @@ files:
 - lib/procodile/logger.rb
 - lib/procodile/process.rb
 - lib/procodile/signal_handler.rb
+- lib/procodile/status_cli_output.rb
 - lib/procodile/supervisor.rb
+- lib/procodile/version.rb
 homepage: https://github.com/adamcooke/procodile
 licenses:
 - MIT

data/lib/procodile/capistrano2.rb

@@ -1,39 +0,0 @@
-Capistrano::Configuration.instance(:must_exist).load do
-
-  namespace :procodile do
-
-    task :start, :roles => fetch(:procodile_roles, [:app]) do
-      run procodile_command('start')
-    end
-
-    task :stop, :roles => fetch(:procodile_roles, [:app]) do
-      run procodile_command('stop')
-    end
-
-    task :restart, :roles => fetch(:procodile_roles, [:app]) do
-      run procodile_command('restart')
-    end
-
-    task :status, :roles => fetch(:procodile_roles, [:app]) do
-      run procodile_command('status')
-    end
-
-    after 'deploy:start', 'procodile:start'
-    after 'deploy:stop', 'procodile:stop'
-    after 'deploy:restart', 'procodile:restart'
-
-    def procodile_command(command, options = "")
-      binary = fetch(:procodile_binary, 'procodile')
-      if processes = fetch(:processes, nil)
-        options = "-p #{processes} " + options
-      end
-      command = "#{binary} #{command} -r #{current_path} #{options}"
-      if user = fetch(:procodile_user, nil)
-        "sudo -u #{user} #{command}"
-      else
-        command
-      end
-    end
-
-  end
-end

data/lib/procodile/capistrano3.rb

@@ -1,40 +0,0 @@
-namespace :procodile do
-  desc 'Start procodile processes'
-  task :start do
-    on roles(fetch(:procodile_roles, [:app])) do
-      execute procodile_command(:start)
-    end
-  end
-
-  desc 'Stop procodile processes'
-  task :stop do
-    on roles(fetch(:procodile_roles, [:app])) do
-      execute procodile_command(:stop)
-    end
-  end
-
-  desc 'Restart procodile processes'
-  task :restart do
-    on roles(fetch(:procodile_roles, [:app])) do
-      execute procodile_command(:restart)
-    end
-  end
-
-  after 'deploy:start', "procodile:start"
-  after 'deploy:stop', "procodile:stop"
-  after 'deploy:restart', "procodile:restart"
-
-  def procodile_command(command, options = "")
-    binary = fetch(:procodile_binary, 'procodile')
-    if processes = fetch(:processes, nil)
-      options = "-p #{processes} " + options
-    end
-    command = "#{binary} #{command} -r #{current_path} #{options}"
-    if user = fetch(:procodile_user, nil)
-      "sudo -u #{user} #{command}"
-    else
-      command
-    end
-  end
-
-end