procodile 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 12da3acd72adc0bf302ddad40c02133f308cf168
-  data.tar.gz: e13faabcbbadce0fd6ac91885c3b5ba937f398db
+  metadata.gz: a67424151ecf1b1b6fc80cdd93d4989b3bc1f0ba
+  data.tar.gz: 5df9bfac9a606afe8987a6400fa097f0091d99a3
 SHA512:
-  metadata.gz: 8b61d0f1fb351bf1f05eac2ea0d22accd8ff2ebbe51fd551397ac5c8ee17693ffa36f6a7f3d2e9729774cf1dabac99358930de70c45c0aa2cd95b1d9359ffb06
-  data.tar.gz: b2f481642d8e7015808946d07cf6b7d0c027e1d2b8956518b27a61bd670e851e690fbf98c79cd3ec02b042d6c176c275794abe6ee2139effc234fc60152b65d9
+  metadata.gz: 85cc30d458aa91a9ec06c25412bfced78860f7f2a2f2a74d674e790c811d2d7005d1cfe8812d6fd027013a21919c8126f7d5930bb219db3c6c4e1b09a06e8ad7
+  data.tar.gz: 8d80992dcfb3a8dafda5da5feae9cc4798f6225862583eb520be96c979f29dbd45cab4bc8070274b0a88e5662f27ef4c93fed4248488259454e2624c626a30a3

data/bin/procodile

@@ -1,29 +1,50 @@
 #!/usr/bin/env ruby
 require 'optparse'
+
+command = ARGV[0]
+
 options = {}
-OptionParser.new do |opts|
-  opts.banner = "Usage: procodile [options]"
-  opts.on("-r", "--root PATH", "The path to the root of your application") do |root|
-    options[:root] = root
-  end
-end.parse!
+begin
+  OptionParser.new do |opts|
+    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 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
+    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
+  end.parse!
+rescue OptionParser::InvalidOption => e
+  $stderr.puts "\e[31merror: #{e.message}\e[0m"
+  exit 1
+end
 
 $:.unshift(File.expand_path('../../lib', __FILE__))
 
 require 'fileutils'
+require 'procodile'
 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)
-  command = ARGV[0]
-
-  cli = Procodile::CLI.new(config)
+  cli = Procodile::CLI.new(config, options)
   cli.run(command)
-
 rescue Procodile::Error => e
   $stderr.puts "\e[31merror: #{e.message}\e[0m"
   exit 1

data/lib/procodile.rb

@@ -1,2 +1,8 @@
 module Procodile
 end
+
+class String
+  def color(color)
+    "\e[#{color}m#{self}\e[0m"
+  end
+end

data/lib/procodile/cli.rb

@@ -2,12 +2,14 @@ require 'fileutils'
 require 'procodile/error'
 require 'procodile/supervisor'
 require 'procodile/signal_handler'
+require 'procodile/control_client'
 
 module Procodile
   class CLI
 
-    def initialize(config)
+    def initialize(config, cli_options = {})
       @config = config
+      @cli_options = cli_options
     end
 
     def run(command)
@@ -20,56 +22,88 @@ module Procodile
 
     def start
       if running?
-        raise Error, "#{@config.app_name} already running (PID: #{current_pid})"
+        instances = ControlClient.run(@config.sock_path, 'start_processes', :processes => process_names_from_cli_option)
+        if instances.empty?
+          raise Error, "No processes were started. The type you entered might already be running or isn't defined."
+        else
+          instances.each do |instance|
+            puts "Started #{instance['description']} (PID: #{instance['pid']})"
+          end
+          return
+        end
+      end
+
+      processes = process_names_from_cli_option
+
+      if @cli_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
-      FileUtils.rm_f(File.join(@config.pid_root, "*.pid"))
-      pid = fork do
-        STDOUT.reopen(log_path, 'a')
-        STDOUT.sync = true
-        STDERR.reopen(log_path, 'a')
-        STDERR.sync = true
-        supervisor = Supervisor.new(@config)
-        signal_handler = SignalHandler.new('TERM', 'USR1', 'USR2', 'INT', 'HUP')
-        signal_handler.register('TERM') { supervisor.stop }
-        signal_handler.register('USR1') { supervisor.restart }
-        signal_handler.register('USR2') { supervisor.status }
-        signal_handler.register('INT') { supervisor.stop_supervisor }
-        supervisor.start
+
+      if @cli_options[:foreground]
+        File.open(pid_path, 'w') { |f| f.write(::Process.pid) }
+        Supervisor.new(@config).start(:processes => processes)
+      else
+        FileUtils.rm_f(File.join(@config.pid_root, "*.pid"))
+        pid = fork do
+          STDOUT.reopen(log_path, 'a')
+          STDOUT.sync = true
+          STDERR.reopen(log_path, 'a')
+          STDERR.sync = true
+          Supervisor.new(@config).start(:processes => processes)
+        end
+        ::Process.detach(pid)
+        File.open(pid_path, 'w') { |f| f.write(pid) }
+        puts "Started #{@config.app_name} supervisor with PID #{pid}"
       end
-      ::Process.detach(pid)
-      File.open(pid_path, 'w') { |f| f.write(pid) }
-      puts "Started #{@config.app_name} supervisor with PID #{pid}"
     end
 
     def stop
       if running?
-        ::Process.kill('TERM', current_pid)
-        puts "Stopping #{@config.app_name} processes & supervisor..."
+        options = {}
+        instances = ControlClient.run(@config.sock_path, 'stop', :processes => process_names_from_cli_option)
+        if instances.empty?
+          puts "There are no processes to stop."
+        else
+          instances.each do |instance|
+            puts "Stopping #{instance['description']} (PID: #{instance['pid']})"
+          end
+        end
       else
         raise Error, "#{@config.app_name} supervisor isn't running"
       end
     end
 
-    def stop_supervisor
+    def restart
       if running?
-        puts "This will stop the supervisor only. Any processes that it started will no longer be managed."
-        puts "They will need to be stopped manually. \e[34mDo you wish to continue? (yes/NO)\e[0m"
-        if ['y', 'yes'].include?($stdin.gets.to_s.strip.downcase)
-          ::Process.kill('INT', current_pid)
-          puts "We've asked it to stop. It'll probably be done in a moment."
+        options = {}
+        instances = ControlClient.run(@config.sock_path, 'restart', :processes => process_names_from_cli_option)
+        if instances.empty?
+          puts "There are no processes to restart."
         else
-          puts "OK. That's fine. You can just run `stop` to stop processes too."
+          instances.each do |instance|
+            puts "Restarting #{instance['description']} (PID: #{instance['pid']})"
+          end
         end
+      else
+        raise Error, "#{@config.app_name} supervisor isn't running"
+      end
+    end
 
+    def stop_supervisor
+      if running?
+        ::Process.kill('TERM', current_pid)
+        puts "Supervisor will be stopped in a moment."
       else
         raise Error, "#{@config.app_name} supervisor isn't running"
       end
     end
 
-    def restart
+    def reload_config
       if running?
-        ::Process.kill('USR1', current_pid)
-        puts "Restarting #{@config.app_name}"
+        ControlClient.run(@config.sock_path, 'reload_config')
+        puts "Reloading config for #{@config.app_name}"
       else
         raise Error, "#{@config.app_name} supervisor isn't running"
       end
@@ -77,9 +111,22 @@ module Procodile
 
     def status
       if running?
-        puts "#{@config.app_name} running (PID: #{current_pid})"
-        ::Process.kill('USR2', current_pid)
-        puts "Instance status details added to #{log_path}"
+        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']
+          stats['instances'][process['name']].each do |instance|
+            print "|| ".color(process['log_color']) + instance['description'].to_s.ljust(20, ' ').color(process['log_color'])
+            print "pid " + instance['pid'].to_s.ljust(12, ' ')
+            print (instance['running'] ? 'Running' : 'Stopped').to_s.ljust(15, ' ')
+            print instance['respawns'].to_s + " respawns"
+            puts
+          end
+        end
       else
         puts "#{@config.app_name} supervisor not running"
       end
@@ -100,6 +147,17 @@ module Procodile
 
     private
 
+    def send_to_socket(command, options = {})
+
+      socket = UNIXSocket.new(@config.sock_path)
+      # Get the connection confirmation
+      connection = socket.gets
+      return false unless connection == 'READY'
+      # Send a command.
+    ensure
+      socket.close rescue nil
+    end
+
     def running?
       if pid = current_pid
         ::Process.getpgid(pid) ? true : false
@@ -127,5 +185,23 @@ module Procodile
       File.join(@config.log_root, 'supervisor.log')
     end
 
+    def process_names_from_cli_option
+      if @cli_options[:processes]
+        processes = @cli_options[:processes].split(',')
+        if processes.empty?
+          raise Error, "No process names provided"
+        end
+        processes.each do |process|
+          process_name, _ = process.split('.', 2)
+          unless @config.process_list.keys.include?(process_name.to_s)
+            raise Error, "Process '#{process_name}' is not configured. You may need to reload your config."
+          end
+        end
+        processes
+      else
+        nil
+      end
+    end
+
   end
 end

data/lib/procodile/config.rb

@@ -19,19 +19,46 @@ module Procodile
       FileUtils.mkdir_p(log_root)
     end
 
+    def reload
+      @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]
+          else
+            process.options = {}
+          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
-      options['app_name'] || 'Procodile'
+      @app_name ||= options['app_name'] || 'Procodile'
     end
 
     def processes
-      process_list.each_with_index.each_with_object({}) do |((name, command), index), hash|
-        options = {'log_color' => COLORS[index.divmod(COLORS.size)[1]]}.merge(process_options[name] || {})
-        hash[name] = Process.new(self, name, command, options)
+      @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]]
       end
     end
 
     def process_list
-      @processes ||= YAML.load_file(procfile_path)
+      @process_list ||= YAML.load_file(procfile_path)
     end
 
     def options
@@ -43,11 +70,15 @@ module Procodile
     end
 
     def pid_root
-      File.expand_path(options['pid_root'] || 'pids', @root)
+      @pid_root ||= File.expand_path(options['pid_root'] || 'pids', @root)
     end
 
     def log_root
-      File.expand_path(options['log_root'] || 'log', @root)
+      @log_root ||= File.expand_path(options['log_root'] || 'log', @root)
+    end
+
+    def sock_path
+      File.join(pid_root, 'supervisor.sock')
     end
 
     private

data/lib/procodile/control_client.rb

@@ -0,0 +1,50 @@
+require 'json'
+require 'socket'
+
+module Procodile
+  class ControlClient
+
+    def initialize(sock_path, &block)
+      @socket = UNIXSocket.new(sock_path)
+      if block_given?
+        begin
+          block.call(self)
+        ensure
+          disconnect
+        end
+      end
+    end
+
+    def self.run(sock_path, command, options = {})
+      socket = self.new(sock_path)
+      socket.run(command, options)
+    ensure
+      socket.disconnect rescue nil
+    end
+
+    def run(command, options = {})
+      @socket.puts("#{command} #{options.to_json}")
+      code, reply = @socket.gets.strip.split(/\s+/, 2)
+      if code.to_i == 200
+        if reply && reply.length > 0
+          JSON.parse(reply)
+        else
+          true
+        end
+      else
+        raise Error, "Error from control server: #{code} (#{reply.inspect})"
+      end
+    end
+
+    def disconnect
+      @socket.close rescue nil
+    end
+
+    private
+
+    def parse_response(data)
+      code, message = data.split(/\s+/, 2)
+    end
+
+  end
+end

data/lib/procodile/control_server.rb

@@ -0,0 +1,29 @@
+require 'socket'
+require 'procodile/control_session'
+
+module Procodile
+  class ControlServer
+
+    def initialize(supervisor)
+      @supervisor = supervisor
+    end
+
+    def listen
+      socket = UNIXServer.new(@supervisor.config.sock_path)
+      Procodile.log nil, 'control', "Listening at #{@supervisor.config.sock_path}"
+      loop do
+        client = socket.accept
+        session = ControlSession.new(@supervisor, client)
+        while line = client.gets
+          if response = session.receive_data(line.strip)
+            client.puts response
+          end
+        end
+        client.close
+      end
+    ensure
+      FileUtils.rm_f(@supervisor.config.sock_path)
+    end
+
+  end
+end

data/lib/procodile/control_session.rb

@@ -0,0 +1,68 @@
+require 'json'
+
+module Procodile
+  class ControlSession
+
+    def initialize(supervisor, client)
+      @supervisor = supervisor
+      @client = client
+    end
+
+    def receive_data(data)
+      command, options = data.split(/\s+/, 2)
+      options = JSON.parse(options)
+      if self.class.instance_methods(false).include?(command.to_sym) && command != 'receive_data'
+        begin
+          Procodile.log nil, 'control', "Received #{command} command"
+          public_send(command, options)
+        rescue Procodile::Error => e
+          Procodile.log nil, 'control', "\e[31mError: #{e.message}\e[0m"
+          "500 #{e.message}"
+        end
+      else
+        "404 Invaid command"
+      end
+    end
+
+    def start_processes(options)
+      instances = @supervisor.start_processes(options['processes'])
+      "200 " + instances.map(&:to_hash).to_json
+    end
+
+    def stop(options)
+      instances = @supervisor.stop(:processes => options['processes'])
+      "200 " + instances.map(&:to_hash).to_json
+    end
+
+    def restart(options)
+      instances = @supervisor.restart(:processes => options['processes'])
+      "200 " + instances.map(&:to_hash).to_json
+    end
+
+    def reload_config(options)
+      @supervisor.reload_config
+      "200"
+    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
+          }
+        end
+      end
+
+      processes = @supervisor.processes.keys.map(&:to_hash)
+      result = {:instances => instances, :processes => processes}
+      "200 #{result.to_json}"
+    end
+
+  end
+end

data/lib/procodile/instance.rb

@@ -4,6 +4,8 @@ module Procodile
   class Instance
 
     attr_accessor :pid
+    attr_reader :id
+    attr_accessor :process
 
     def initialize(process, id)
       @process = process
@@ -11,22 +13,37 @@ module Procodile
       @respawns = 0
     end
 
+    #
+    # Return a description for this instance
+    #
     def description
       "#{@process.name}.#{@id}"
     end
 
-    def dead?
-      @dead || false
+    #
+    # Should this instance still be monitored by the supervisor?
+    #
+    def unmonitored?
+      @monitored == false
     end
 
+    #
+    # Return the path to this instance's PID file
+    #
     def pid_file_path
       File.join(@process.config.pid_root, "#{description}.pid")
     end
 
+    #
+    # Return the path to this instance's log file
+    #
     def log_file_path
       File.join(@process.config.log_root, "#{description}.log")
     end
 
+    #
+    # Return the PID that is in the instances process PID file
+    #
     def pid_from_file
       if File.exist?(pid_file_path)
         pid = File.read(pid_file_path)
@@ -36,6 +53,9 @@ module Procodile
       end
     end
 
+    #
+    # Is this process running? Pass an option to check the given PID instead of the instance
+    #
     def running?(force_pid = nil)
       if force_pid || @pid
         ::Process.getpgid(force_pid || @pid) ? true : false
@@ -46,11 +66,21 @@ module Procodile
       false
     end
 
+    #
+    # Start a new instance of this process
+    #
     def start
       @stopping = false
-      Dir.chdir(@process.config.root) do
+      existing_pid = self.pid_from_file
+      if running?(existing_pid)
+        # If the PID in the file is already running, we should just just continue
+        # to monitor this process rather than spawning a new one.
+        @pid = existing_pid
+        Procodile.log(@process.log_color, description, "Already running with PID #{@pid}")
+      else
         log_file = File.open(self.log_file_path, 'a')
-        @pid = ::Process.spawn({'PID_FILE' => pid_file_path}, @process.command, :out => log_file, :err => log_file)
+        Dir.chdir(@process.config.root)
+        @pid = ::Process.spawn({'PID_FILE' => pid_file_path}, @process.command, :out => log_file, :err => log_file, :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)
@@ -72,8 +102,7 @@ module Procodile
       @stopping = true
       update_pid
       if self.running?
-        pid = self.pid_from_file
-        Procodile.log(@process.log_color, description, "Sending TERM to #{pid}")
+        Procodile.log(@process.log_color, description, "Sending TERM to #{@pid}")
         ::Process.kill('TERM', pid)
       else
         Procodile.log(@process.log_color, description, "Process already stopped")
@@ -85,6 +114,14 @@ module Procodile
     # started again
     #
     def on_stop
+      tidy
+      unmonitor
+    end
+
+    #
+    # Tidy up when this process isn't needed any more
+    #
+    def tidy
       FileUtils.rm_f(self.pid_file_path)
       Procodile.log(@process.log_color, description, "Removed PID file")
     end
@@ -157,7 +194,8 @@ module Procodile
         elsif respawns >= @process.max_respawns
           Procodile.log(@process.log_color, description, "\e[41;37mWarning:\e[0m\e[31m this process has been respawned #{respawns} times and keeps dying.\e[0m")
           Procodile.log(@process.log_color, description, "\e[31mIt will not be respawned automatically any longer and will no longer be managed.\e[0m")
-          die
+          tidy
+          unmonitor
         end
       end
     end
@@ -165,9 +203,8 @@ module Procodile
     #
     # Mark this process as dead and tidy up after it
     #
-    def die
-      on_stop
-      @dead = true
+    def unmonitor
+      @monitored = false
     end
 
     #
@@ -200,5 +237,17 @@ module Procodile
       end
     end
 
+    #
+    # Return this instance as a hash
+    #
+    def to_hash
+      {
+        :description => self.description,
+        :pid => self.pid,
+        :respawns => self.respawns,
+        :running => self.running?
+      }
+    end
+
   end
 end

data/lib/procodile/process.rb

@@ -3,22 +3,18 @@ require 'procodile/instance'
 module Procodile
   class Process
 
-    attr_reader :name
-    attr_reader :command
     attr_reader :config
+    attr_reader :name
+    attr_accessor :command
+    attr_accessor :options
+    attr_accessor :log_color
 
     def initialize(config, name, command, options = {})
       @config = config
       @name = name
       @command = command
       @options = options
-    end
-
-    #
-    # Return the color for this process
-    #
-    def log_color
-      @options['log_color'] || 0
+      @log_color = 0
     end
 
     #
@@ -57,8 +53,23 @@ module Procodile
     #
     # Generate an array of new instances for this process (based on its quantity)
     #
-    def generate_instances
-      quantity.times.map { |i| Instance.new(self, i + 1) }
+    def generate_instances(quantity = self.quantity, start_number = 1)
+      quantity.times.map { |i| Instance.new(self, i + start_number) }
+    end
+
+    #
+    # Return a hash
+    #
+    def to_hash
+      {
+        :name => self.name,
+        :log_color => self.log_color,
+        :quantity => self.quantity,
+        :max_respawns => self.max_respawns,
+        :respawn_window => self.respawn_window,
+        :command => self.command,
+        :restart_mode => self.restart_mode
+      }
     end
 
   end

data/lib/procodile/supervisor.rb

@@ -1,93 +1,186 @@
+require 'procodile/control_server'
+
 module Procodile
   class Supervisor
 
+    attr_reader :config
+    attr_reader :processes
+
     # Create a new supervisor instance that will be monitoring the
     # processes that have been provided.
     def initialize(config)
       @config = config
-      @instances = []
+      @processes = {}
+      signal_handler = SignalHandler.new('TERM', 'USR1', 'USR2', 'INT', 'HUP')
+      signal_handler.register('TERM') { stop_supervisor }
+      signal_handler.register('INT') { stop }
+      signal_handler.register('USR1') { restart }
+      signal_handler.register('USR2') { status }
+      signal_handler.register('HUP') { reload_config }
     end
 
-    def start
+    def start(options = {})
       Procodile.log nil, "system", "#{@config.app_name} supervisor started with PID #{::Process.pid}"
-      @config.processes.each do |name, process|
-        process.generate_instances.each do |instance|
-          instance.start
-          @instances << instance
-        end
+      Thread.new do
+        socket = ControlServer.new(self)
+        socket.listen
       end
+      start_processes(options[:processes])
       supervise
     end
 
-    def stop
-      return if @stopping
-      @stopping = true
-      Procodile.log nil, "system", "Stopping all #{@config.app_name} processes"
-      @instances.each(&:stop)
-    end
-
-    def stop_supervisor
-      Procodile.log nil, 'system', "Stopping #{@config.app_name} supervisor"
-      FileUtils.rm_f(File.join(@config.pid_root, 'supervisor.pid'))
-      ::Process.exit 0
+    def start_processes(types = [])
+      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
+          next if @processes.keys.include?(process)   # Process type already running
+          instances = start_instances(process.generate_instances)
+          instances_started.push(*instances)
+        end
+      end
     end
 
-    def restart
-      Procodile.log nil, 'system', "Restarting all #{@config.app_name} processes"
-      @instances.each(&:restart)
+    def stop(options = {})
+      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
+            end
+        else
+          instances = process_names_to_instances(options[:processes])
+          Procodile.log nil, "system", "Stopping #{instances.size} process(es)"
+          instances.each do |instance|
+            instance.stop
+            instances_stopped << instance
+          end
+        end
+      end
     end
 
-    def status
-      Procodile.log '37;44', 'status', "Status as at: #{Time.now.utc.to_s}"
-      @instances.each do |instance|
-        if instance.running?
-          Procodile.log '37;44', 'status', "#{instance.description} is RUNNING (pid #{instance.pid}). Respawned #{instance.respawns} time(s)"
+    def restart(options = {})
+      @config.reload
+      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
+              instances_restarted << instance
+            end
+          end
         else
-          Procodile.log '37;44', 'status', "#{instance.description} is STOPPED"
+          instances = process_names_to_instances(options[:processes])
+          Procodile.log nil, "system", "Restarting #{instances.size} process(es)"
+          instances.each do |instance|
+            instance.restart
+            instances_restarted << instance
+          end
         end
       end
     end
 
+    def stop_supervisor
+      Procodile.log nil, 'system', "Stopping #{@config.app_name} supervisor"
+      FileUtils.rm_f(File.join(@config.pid_root, 'supervisor.pid'))
+      ::Process.exit 0
+    end
+
     def supervise
       loop do
         # Tidy up any instances that we no longer wish to be managed. They will
         # be removed from the list.
         remove_dead_instances
 
-        if @stopping
-          # If the system is stopping, we'll remove any instances that have already
-          # stopped and trigger their on_stop callback.
-          remove_stopped_instances
+        # Remove processes that have been stopped
+        remove_stopped_instances
 
-          # When all the instances we manage have gone away, we can stop ourself.
-          if @instances.size > 0
-            Procodile.log nil, "system", "Waiting for #{@instances.size} processes to stop"
-          else
-            Procodile.log nil, "system", "All processes have stopped"
-            stop_supervisor
-          end
-        else
-          # Check all instances that we manage and let them do their things.
-          @instances.each(&:check)
+        # Check all instances that we manage and let them do their things.
+        @processes.each do |_, instances|
+          instances.each(&:check)
+        end
+
+        # If the processes go away, we can stop the supervisor now
+        if @processes.size == 0
+          Procodile.log nil, "system", "All processes have stopped"
+          stop_supervisor
         end
 
         sleep 5
       end
     end
 
+    def reload_config
+      Procodile.log nil, "system", "Reloading configuration"
+      @config.reload
+      check_instance_quantities
+    end
+
     private
 
+    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))
+        end
+      end
+    end
+
+    def start_instances(instances)
+      instances.each do |instance|
+        instance.start
+        @processes[instance.process] ||= []
+        @processes[instance.process] << instance
+      end
+    end
+
     def remove_dead_instances
-      @instances.reject!(&:dead?)
+      @processes.each do |_, instances|
+        instances.reject!(&:unmonitored?)
+      end.reject! { |_, instances| instances.empty? }
     end
 
     def remove_stopped_instances
-      @instances.reject! do |instance|
-        if instance.running?
-          false
+      @processes.each do |_, instances|
+        instances.reject! do |instance|
+          if !instance.running? && instance.stopping?
+            instance.on_stop
+            true
+          else
+            false
+          end
+        end
+      end.reject! { |_, instances| instances.empty? }
+    end
+
+    def process_names_to_instances(names)
+      names.each_with_object([]) do |name, array|
+        if name =~ /\A(.*)\.(\d+)\z/
+          process_name, id = $1, $2
+          @processes.each do |process, instances|
+            next unless process.name == process_name
+            instances.each do |instance|
+              next unless instance.id == id.to_i
+              array << instance
+            end
+          end
         else
-          instance.on_stop
-          true
+          @processes.each do |process, instances|
+            next unless process.name == name
+            instances.each { |i| array << i}
+          end
         end
       end
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: procodile
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Adam Cooke
@@ -9,7 +9,21 @@ autorequire:
 bindir: bin
 cert_chain: []
 date: 2016-10-16 00:00:00.000000000 Z
-dependencies: []
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Run Ruby/Rails processes in the background on Linux servers with ease.
 email:
 - me@adamcooke.io
@@ -22,6 +36,9 @@ files:
 - lib/procodile.rb
 - lib/procodile/cli.rb
 - lib/procodile/config.rb
+- lib/procodile/control_client.rb
+- lib/procodile/control_server.rb
+- lib/procodile/control_session.rb
 - lib/procodile/error.rb
 - lib/procodile/instance.rb
 - lib/procodile/logger.rb