procodile 1.0.3 → 1.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 812b0f566074632d4c15caddfd02e6b1ddf8ee88
-  data.tar.gz: 2acf4f380545089801e036b22aebbd1937d5be6b
+  metadata.gz: 6afcf104b9bc4268bc21c634075b7cd4c8ef8d33
+  data.tar.gz: a46fd5857741a36d7d2584a4d4cea4ed07c5dbfa
 SHA512:
-  metadata.gz: 38ee04794ce4b93d537f20704cae020dd3f03e5af610f181a3a2c11a1657e5fc48dc486ad759d74cd60187e8859869176dd8d19df1f3ef6bcd7d01ca2e8bd11e
-  data.tar.gz: 57ff3aef3f9e8dcbbe3c0871f68e15e82b1fa18c10e035d891042774340388bf2de595bc1de95e6343e3b5f743e9ebd13a126c9db105efa925ddaaa8c034e1ba
+  metadata.gz: 85ea38210c9cf42dde381b7ed2a8966578047356cfdd6deed42942ea49f6880a8fb32317b00d98586054925ab7d8acbcc716577db27b1a8796aaa506dd195a7a
+  data.tar.gz: d43970fcd524920fae6d7980546de10c9f0980354d8e80cf33d2569d8d90253ce1cafd7b85d98db865aac982aaf9ca61123492d0f774f798d7ad0d16024cc3fb

data/bin/procodile

@@ -26,7 +26,7 @@ begin
       option_block.call(opts, cli)
     end
   end.parse!
-rescue OptionParser::InvalidOption => e
+rescue OptionParser::InvalidOption, OptionParser::MissingArgument => e
   $stderr.puts "Error: #{e.message}".color(31)
   exit 1
 end

data/lib/procodile/cli.rb

@@ -45,6 +45,12 @@ module Procodile
     # Help
     #
 
+    command def proxy
+      require 'procodile/tcp_proxy'
+      p = Procodile::TCPProxy.new(Supervisor.new(@config, {}))
+      p.run
+    end
+
     desc "Shows this help output"
     command def help
       puts "\e[45;37mWelcome to Procodile v#{Procodile::VERSION}\e[0m"
@@ -71,6 +77,18 @@ module Procodile
         cli.options[:processes] = processes
       end
 
+      opts.on("-t", "--tag TAGNAME", "Tag all started processes with the given tag") do |tag|
+        cli.options[:tag] = tag
+      end
+
+      opts.on("--no-supervisor", "Do not start a supervisor if its not running") do
+        cli.options[:start_supervisor] = false
+      end
+
+      opts.on("--no-processes", "Do not start any processes (only applicable when supervisor is stopped)") do
+        cli.options[:start_processes] = false
+      end
+
       opts.on("-f", "--foreground", "Run the supervisor in the foreground") do
         cli.options[:foreground] = true
       end
@@ -79,61 +97,65 @@ module Procodile
         cli.options[:clean] = true
       end
 
-      opts.on("-b", "--brittle", "Kill everything when one process exits") do
-        cli.options[:brittle] = true
+      opts.on("--no-respawn", "Disable respawning for all processes") do
+        cli.options[:respawn] = false
       end
 
       opts.on("--stop-when-none", "Stop the supervisor when all processes are stopped") do
         cli.options[:stop_when_none] = true
       end
 
+      opts.on("-x", "--proxy", "Enables the Procodile proxy service") do
+        cli.options[:proxy] = true
+      end
+
       opts.on("-d", "--dev", "Run in development mode") do
         cli.options[:development] = true
-        cli.options[:brittle] = true
+        cli.options[:respawn] = false
         cli.options[:foreground] = true
         cli.options[:stop_when_none] = true
+        cli.options[:proxy] = 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?
-          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
+      if supervisor_running?
+        if @options[:foreground]
+          raise Error, "Cannot be started in the foreground because supervisor already running"
         end
-      end
 
-      run_options = {}
-      run_options[:brittle] = @options[:brittle]
-      run_options[:stop_when_none] = @options[:stop_when_none]
+        if @options.has_key?(:respawn)
+          raise Error, "Cannot disable respawning because supervisor is already running"
+        end
 
-      processes = process_names_from_cli_option
+        if @options[:stop_when_none]
+          raise Error, "Cannot stop supervisor when none running because supervisor is already running"
+        end
 
-      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 @options[:proxy]
+          raise Error, "Cannot enable the proxy when the supervisor is running"
+        end
 
-      if @options[:foreground]
-        File.open(pid_path, 'w') { |f| f.write(::Process.pid) }
-        Supervisor.new(@config, run_options).start(:processes => processes)
+        instances = ControlClient.run(@config.sock_path, 'start_processes', :processes => process_names_from_cli_option, :tag => @options[:tag])
+        if instances.empty?
+          puts "No processes to start."
+        else
+          instances.each do |instance|
+            puts "Started".color(32) + " #{instance['description']} (PID: #{instance['pid']})"
+          end
+        end
+        return
       else
-        FileUtils.rm_f(File.join(@config.pid_root, "*.pid"))
-        pid = fork do
-          STDOUT.reopen(@config.log_path, 'a')
-          STDOUT.sync = true
-          STDERR.reopen(@config.log_path, 'a')
-          STDERR.sync = true
-          Supervisor.new(@config, run_options).start(:processes => processes)
+        # The supervisor isn't actually running. We need to start it before processes can be
+        # begin being processed
+        if @options[:start_supervisor] == false
+          raise Error, "Supervisor is not running and cannot be started because --no-supervisor is set"
+        else
+          start_supervisor do |supervisor|
+            unless @options[:start_processes] == false
+              supervisor.start_processes(process_names_from_cli_option, :tag => @options[:tag])
+            end
+          end
         end
-        ::Process.detach(pid)
-        File.open(pid_path, 'w') { |f| f.write(pid) }
-        puts "Started #{@config.app_name} supervisor with PID #{pid}"
       end
     end
 
@@ -147,23 +169,27 @@ module Procodile
         cli.options[:processes] = processes
       end
 
-      opts.on("-s", "--stop-supervisor", "Stop the ") do
+      opts.on("-s", "--stop-supervisor", "Stop the supervisor process when all processes are stopped") do
         cli.options[:stop_supervisor] = true
       end
     end
     command def stop
-      if running?
+      if supervisor_running?
         options = {}
         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."
+          puts "No processes were stopped."
         else
           instances.each do |instance|
-            puts "Stopping #{instance['description']} (PID: #{instance['pid']})"
+            puts "Stopped".color(31) + " #{instance['description']} (PID: #{instance['pid']})"
           end
         end
+
+        if @options[:stop_supervisor]
+          puts "Supervisor will be stopped when processes are stopped."
+        end
       else
-        raise Error, "#{@config.app_name} supervisor isn't running"
+        raise Error, "Procodile supervisor isn't running"
       end
     end
 
@@ -176,34 +202,34 @@ module Procodile
       opts.on("-p", "--processes a,b,c", "Only restart the listed processes or process types") do |processes|
         cli.options[:processes] = processes
       end
+
+      opts.on("-t", "--tag TAGNAME", "Tag all started processes with the given tag") do |tag|
+        cli.options[:tag] = tag
+      end
     end
     command def restart
-      if running?
-        options = {}
-        instances = ControlClient.run(@config.sock_path, 'restart', :processes => process_names_from_cli_option)
+      if supervisor_running?
+        instances = ControlClient.run(@config.sock_path, 'restart', :processes => process_names_from_cli_option, :tag => @options[:tag])
         if instances.empty?
           puts "There are no processes to restart."
         else
-          instances.each do |instance|
-            puts "Restarting #{instance['description']} (PID: #{instance['pid']})"
+          instances.each do |old_instance, new_instance|
+            if old_instance && new_instance
+              if old_instance['description'] == new_instance['description']
+                puts "Restarted".color(35) + " #{old_instance['description']}"
+              else
+                puts "Restarted".color(35) + " #{old_instance['description']} -> #{new_instance['description']}"
+              end
+            elsif old_instance
+              puts "Stopped".color(31) + " #{old_instance['description']}"
+            elsif new_instance
+              puts "Started".color(32) + " #{new_instance['description']}"
+            end
+            $stdout.flush
           end
         end
       else
-        raise Error, "#{@config.app_name} supervisor isn't running"
-      end
-    end
-
-    #
-    # 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."
-      else
-        raise Error, "#{@config.app_name} supervisor isn't running"
+        raise Error, "Procodile supervisor isn't running"
       end
     end
 
@@ -213,11 +239,11 @@ module Procodile
 
     desc "Reload Procodile configuration"
     command def reload
-      if running?
+      if supervisor_running?
         ControlClient.run(@config.sock_path, 'reload_config')
-        puts "Reloaded config for #{@config.app_name}"
+        puts "Reloaded Procodile config"
       else
-        raise Error, "#{@config.app_name} supervisor isn't running"
+        raise Error, "Procodile supervisor isn't running"
       end
     end
 
@@ -232,21 +258,21 @@ module Procodile
       end
     end
     command def check_concurrency
-      if running?
+      if supervisor_running?
         reply = ControlClient.run(@config.sock_path, 'check_concurrency', :reload => @options[:reload])
         if reply['started'].empty? && reply['stopped'].empty?
-          puts "Everything looks good!"
+          puts "Processes are running as configured"
         else
           reply['started'].each do |instance|
-            puts "Started #{instance['description']}".color(32)
+            puts "Started".color(32) + " #{instance['description']} (PID: #{instance['pid']})"
           end
 
           reply['stopped'].each do |instance|
-            puts "Stopped #{instance['description']}".color(31)
+            puts "Stopped".color(31) + " #{instance['description']} (PID: #{instance['pid']})"
           end
         end
       else
-        raise Error, "#{@config.app_name} supervisor isn't running"
+        raise Error, "Procodile supervisor isn't running"
       end
     end
 
@@ -261,7 +287,7 @@ module Procodile
       end
     end
     command def status
-      if running?
+      if supervisor_running?
         status = ControlClient.run(@config.sock_path, 'status')
         if @options[:json]
           puts status.to_json
@@ -270,7 +296,7 @@ module Procodile
           StatusCLIOutput.new(status).print_all
         end
       else
-        puts "#{@config.app_name} supervisor not running"
+        raise Error, "Procodile supervisor isn't running"
       end
     end
 
@@ -294,18 +320,7 @@ 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?
+    def supervisor_running?
       if pid = current_pid
         ::Process.getpgid(pid) ? true : false
       else
@@ -334,17 +349,53 @@ module Procodile
         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.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
 
+    def start_supervisor(&after_start)
+      run_options = {}
+      run_options[:respawn] = @options[:respawn]
+      run_options[:stop_when_none] = @options[:stop_when_none]
+      run_options[:proxy] = @options[:proxy]
+
+      processes = process_names_from_cli_option
+
+      if @options[:clean]
+        FileUtils.rm_rf(Dir[File.join(@config.pid_root, '*')])
+        puts "Emptied PID directory"
+      end
+
+      if !Dir[File.join(@config.pid_root, "*")].empty?
+        raise Error, "The PID directory (#{@config.pid_root}) is not empty. Cannot start unless things are clean."
+      end
+
+      $0="[procodile] #{@config.app_name} (#{@config.root})"
+      if @options[:foreground]
+        File.open(pid_path, 'w') { |f| f.write(::Process.pid) }
+        Supervisor.new(@config, run_options).start(&after_start)
+      else
+        FileUtils.rm_f(File.join(@config.pid_root, "*.pid"))
+        pid = fork do
+          STDOUT.reopen(@config.log_path, 'a')
+          STDOUT.sync = true
+          STDERR.reopen(@config.log_path, 'a')
+          STDERR.sync = true
+          Supervisor.new(@config, run_options).start(&after_start)
+        end
+        ::Process.detach(pid)
+        File.open(pid_path, 'w') { |f| f.write(pid) }
+        puts "Started Procodile supervisor with PID #{pid}"
+      end
+    end
+
   end
 end

data/lib/procodile/config.rb

@@ -15,6 +15,10 @@ module Procodile
         raise Error, "Procfile not found at #{procfile_path}"
       end
       FileUtils.mkdir_p(pid_root)
+
+      @processes = process_list.each_with_index.each_with_object({}) do |((name, command), index), hash|
+        hash[name] = create_process(name, command, COLORS[index.divmod(COLORS.size)[1]])
+      end
     end
 
     def reload
@@ -27,6 +31,7 @@ module Procodile
       if @processes
         process_list.each do |name, command|
           if process = @processes[name]
+            process.removed = false
             # This command is already in our list. Add it.
             if process.command != command
               process.command = command
@@ -38,6 +43,15 @@ module Procodile
             @processes[name] = create_process(name, command, COLORS[@processes.size.divmod(COLORS.size)[1]])
           end
         end
+
+        removed_processes = @processes.keys - process_list.keys
+        removed_processes.each do |process_name|
+          if p = @processes[process_name]
+            p.removed = true
+            @processes.delete(process_name)
+            Procodile.log nil, 'system', "#{process_name} has been removed to the Procfile. It will be removed when it is stopped."
+          end
+        end
       end
     end
 
@@ -46,13 +60,11 @@ module Procodile
     end
 
     def processes
-      @processes ||= process_list.each_with_index.each_with_object({}) do |((name, command), index), hash|
-        hash[name] = create_process(name, command, COLORS[index.divmod(COLORS.size)[1]])
-      end
+      @processes ||= {}
     end
 
     def process_list
-      @process_list ||= YAML.load_file(procfile_path)
+      @process_list ||= YAML.load_file(procfile_path) || {}
     end
 
     def options
@@ -92,7 +104,7 @@ module Procodile
     end
 
     def sock_path
-      File.join(pid_root, 'supervisor.sock')
+      File.join(pid_root, 'procodile.sock')
     end
 
     private

data/lib/procodile/control_server.rb

@@ -4,6 +4,13 @@ require 'procodile/control_session'
 module Procodile
   class ControlServer
 
+    def self.start(supervisor)
+      Thread.new do
+        socket = ControlServer.new(supervisor)
+        socket.listen
+      end
+    end
+
     def initialize(supervisor)
       @supervisor = supervisor
     end

data/lib/procodile/control_session.rb

@@ -14,7 +14,6 @@ module Procodile
       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', "Error: #{e.message}".color(31)
@@ -26,7 +25,7 @@ module Procodile
     end
 
     def start_processes(options)
-      instances = @supervisor.start_processes(options['processes'])
+      instances = @supervisor.start_processes(options['processes'], :tag => options['tag'])
       "200 " + instances.map(&:to_hash).to_json
     end
 
@@ -36,8 +35,8 @@ module Procodile
     end
 
     def restart(options)
-      instances = @supervisor.restart(:processes => options['processes'])
-      "200 " + instances.map(&:to_hash).to_json
+      instances = @supervisor.restart(:processes => options['processes'], :tag => options['tag'])
+      "200 " + instances.map { |a| a.map { |i| i ? i.to_hash : nil } }.to_json
     end
 
     def reload_config(options)

data/lib/procodile/instance.rb

@@ -6,13 +6,14 @@ module Procodile
     attr_accessor :pid
     attr_reader :id
     attr_accessor :process
-    attr_accessor :respawnable
+    attr_reader :tag
+    attr_reader :port
 
-    def initialize(process, id)
+    def initialize(supervisor, process, id)
+      @supervisor = supervisor
       @process = process
       @id = id
       @respawns = 0
-      @respawnable = true
       @started_at = nil
     end
 
@@ -23,21 +24,33 @@ module Procodile
       "#{@process.name}.#{@id}"
     end
 
+    #
+    # Return the status of this instance
+    #
+    def status
+      if stopped?
+        'Stopped'
+      elsif stopping?
+        'Stopping'
+      elsif running?
+        'Running'
+      elsif failed?
+        'Failed'
+      else
+        'Unknown'
+      end
+    end
+
     #
     # Return an array of environment variables that should be set
     #
     def environment_variables
-      @process.config.environment_variables.merge({
+      vars = @process.environment_variables.merge({
         'PID_FILE' => self.pid_file_path,
         'APP_ROOT' => @process.config.root
       })
-    end
-
-    #
-    # Should this instance still be monitored by the supervisor?
-    #
-    def unmonitored?
-      @monitored == false
+      vars['PORT'] = @port.to_s if @port
+      vars
     end
 
     #
@@ -62,9 +75,9 @@ module Procodile
     #
     # 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
+    def running?
+      if @pid
+        ::Process.getpgid(@pid) ? true : false
       else
         false
       end
@@ -75,38 +88,39 @@ module Procodile
     #
     # Start a new instance of this process
     #
-    def start(&block)
-      @stopping = false
-      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
+    def start
+      if stopping?
+        Procodile.log(@process.log_color, description, "Process is stopped/stopping therefore cannot be started again.")
+        return false
+      end
+
+      update_pid
+      if running?
         Procodile.log(@process.log_color, description, "Already running with PID #{@pid}")
-        @started_at = File.mtime(self.pid_file_path)
         nil
       else
+
+        if @process.proxy? && @supervisor.tcp_proxy
+          allocate_port
+        end
+
         if self.process.log_path
           log_destination = File.open(self.process.log_path, 'a')
-          return_value = nil
+          io = nil
         else
           reader, writer = IO.pipe
           log_destination = writer
-          return_value = reader
+          io = reader
         end
-
+        @tag = @supervisor.tag.dup if @supervisor.tag
         Dir.chdir(@process.config.root)
         @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}")
+        log_destination.close
         File.open(pid_file_path, 'w') { |f| f.write(@pid.to_s + "\n") }
+        @supervisor.add_instance(self, io)
         ::Process.detach(@pid)
+        Procodile.log(@process.log_color, description, "Started with PID #{@pid}" + (@tag ? " (tagged with #{@tag})" : ''))
         @started_at = Time.now
-
-        if block_given?
-          block.call(self, return_value)
-        end
-
-        return_value
       end
     end
 
@@ -114,7 +128,21 @@ module Procodile
     # Is this instance supposed to be stopping/be stopped?
     #
     def stopping?
-      @stopping || false
+      @stopping ? true : false
+    end
+
+    #
+    # Is this stopped?
+    #
+    def stopped?
+      @stopped || false
+    end
+
+    #
+    # Has this failed?
+    #
+    def failed?
+      @failed ? true : false
     end
 
     #
@@ -122,7 +150,7 @@ module Procodile
     # tells us that we want it to be stopped.
     #
     def stop
-      @stopping = true
+      @stopping = Time.now
       update_pid
       if self.running?
         Procodile.log(@process.log_color, description, "Sending #{@process.term_signal} to #{@pid}")
@@ -138,8 +166,8 @@ module Procodile
     #
     def on_stop
       @started_at = nil
+      @stopped = true
       tidy
-      unmonitor
     end
 
     #
@@ -153,9 +181,8 @@ module Procodile
     #
     # Retarts the process using the appropriate method from the process configuraiton
     #
-    def restart(&block)
+    def restart
       Procodile.log(@process.log_color, description, "Restarting using #{@process.restart_mode} mode")
-      @restarting = true
       update_pid
       case @process.restart_mode
       when 'usr1', 'usr2'
@@ -164,23 +191,24 @@ 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(&block)
+          on_stop
+          @process.create_instance(@supervisor).start
         end
+        self
       when 'start-term'
-        old_process_pid = @pid
-        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)
+        new_instance = @process.create_instance(@supervisor)
+        new_instance.start
+        stop
+        new_instance
       when 'term-start'
         stop
+        new_instance = @process.create_instance(@supervisor)
         Thread.new do
-          # Wait for this process to stop and when it has, run it.
           sleep 0.5 while running?
-          start(&block)
+          new_instance.start
         end
+        new_instance
       end
-    ensure
-      @restarting = false
     end
 
     #
@@ -190,6 +218,7 @@ module Procodile
       pid_from_file = self.pid_from_file
       if pid_from_file && pid_from_file != @pid
         @pid = pid_from_file
+        @started_at = File.mtime(self.pid_file_path)
         Procodile.log(@process.log_color, description, "PID file changed. Updated pid to #{@pid}")
         true
       else
@@ -200,10 +229,8 @@ module Procodile
     #
     # Check the status of this process and handle as appropriate.
     #
-    def check
-      # Don't do any checking if we're in the midst of a restart
-      return if @restarting
-      return if unmonitored?
+    def check(options = {})
+      return if failed?
 
       if self.running?
         # Everything is OK. The process is running.
@@ -213,7 +240,7 @@ module Procodile
         # the file in case the process has changed itself.
         return check if update_pid
 
-        if @respawnable
+        if @supervisor.allow_respawning?
           if can_respawn?
             Procodile.log(@process.log_color, description, "Process has stopped. Respawning...")
             start
@@ -221,24 +248,17 @@ 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, "It will not be respawned automatically any longer and will no longer be managed.".color(31))
+            @failed = Time.now
             tidy
-            unmonitor
           end
         else
           Procodile.log(@process.log_color, description, "Process has stopped. Respawning not available.")
+          @failed = Time.now
           tidy
-          unmonitor
         end
       end
     end
 
-    #
-    # Mark this process as dead and tidy up after it
-    #
-    def unmonitor
-      @monitored = false
-    end
-
     #
     # Can this process be respawned if needed?
     #
@@ -277,10 +297,31 @@ module Procodile
         :description => self.description,
         :pid => self.pid,
         :respawns => self.respawns,
+        :status => self.status,
         :running => self.running?,
-        :started_at => @started_at ? @started_at.to_i : nil
+        :started_at => @started_at ? @started_at.to_i : nil,
+        :tag => self.tag,
+        :port => @port
       }
     end
 
+
+    #
+    # Find a port number for this instance to listen on. We just check that nothing is already listening on it.
+    # The process is expected to take it straight away if it wants it.
+    #
+    def allocate_port
+      until @port
+        possible_port = rand(10000) + 20000
+        begin
+          server = TCPServer.new('127.0.0.1', possible_port)
+          server.close
+          return @port = possible_port
+        rescue
+          # Nah.
+        end
+      end
+    end
+
   end
 end

data/lib/procodile/process.rb

@@ -3,11 +3,14 @@ require 'procodile/instance'
 module Procodile
   class Process
 
+    MUTEX = Mutex.new
+
     attr_reader :config
     attr_reader :name
     attr_accessor :command
     attr_accessor :options
     attr_accessor :log_color
+    attr_accessor :removed
 
     def initialize(config, name, command, options = {})
       @config = config
@@ -15,6 +18,29 @@ module Procodile
       @command = command
       @options = options
       @log_color = 0
+      @instance_index = 0
+    end
+
+    #
+    # Increase the instance index and return
+    #
+    def get_instance_id
+      MUTEX.synchronize do
+        @instance_index = 0 if @instance_index == 10000
+        @instance_index += 1
+      end
+    end
+
+    #
+    # Return all environment variables for this process
+    #
+    def environment_variables
+      global_variables = @config.environment_variables
+      process_vars = @config.process_options[@name] ? @config.process_options[@name]['env'] || {} : {}
+      process_local_vars = @config.local_process_options[@name] ? @config.local_process_options[@name]['env'] || {} : {}
+      global_variables.merge(process_vars.merge(process_local_vars)).each_with_object({}) do |(key, value), hash|
+        hash[key.to_s] = value.to_s
+      end
     end
 
     #
@@ -65,11 +91,40 @@ module Procodile
       @options['restart_mode'] || 'term-start'
     end
 
+    #
+    # Is this process enabled for proxying?
+    #
+    def proxy?
+      @options.has_key?('proxy_port')
+    end
+
+    #
+    # Return the port for the proxy to listen on for this process type
+    #
+    def proxy_port
+      proxy? ? @options['proxy_port'].to_i : nil
+    end
+
+    #
+    # Return the port for the proxy to listen on for this process type
+    #
+    def proxy_address
+      proxy? ? @options['proxy_address'] || '127.0.0.1' : nil
+    end
+
+
     #
     # Generate an array of new instances for this process (based on its quantity)
     #
-    def generate_instances(quantity = self.quantity, start_number = 1)
-      quantity.times.map { |i| Instance.new(self, i + start_number) }
+    def generate_instances(supervisor, quantity = self.quantity)
+      quantity.times.map { |i| create_instance(supervisor) }
+    end
+
+    #
+    # Create a new instance
+    #
+    def create_instance(supervisor)
+      Instance.new(supervisor, self, get_instance_id)
     end
 
     #
@@ -84,7 +139,10 @@ module Procodile
         :respawn_window => self.respawn_window,
         :command => self.command,
         :restart_mode => self.restart_mode,
-        :log_path => self.log_path
+        :log_path => self.log_path,
+        :removed => self.removed ? true : false,
+        :proxy_port => proxy_port,
+        :proxy_address => proxy_address
       }
     end
 

data/lib/procodile/status_cli_output.rb

@@ -41,20 +41,19 @@ module Procodile
         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")
+        puts "||".color(process['log_color']) + " Address/Port        " + (process['proxy_port'] ? "#{process['proxy_address']}:#{process['proxy_port']}" : "none")
         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 instance['status'].ljust(10, ' ')
             print "   " + formatted_timestamp(instance['started_at']).ljust(10, ' ')
-            print "   pid: " + instance['pid'].to_s.ljust(7, ' ')
-            print "   respawns: " + instance['respawns'].to_s.ljust(7, ' ')
+            print "   " + instance['pid'].to_s.ljust(6, ' ')
+            print "   " + instance['respawns'].to_s.ljust(4, ' ')
+            print "   " + (instance['port'] || "-").to_s.ljust(6, ' ')
+            print "   " + (instance['tag'] || "-").to_s
             puts
           end
         end

data/lib/procodile/supervisor.rb

@@ -1,4 +1,5 @@
 require 'procodile/control_server'
+require 'procodile/tcp_proxy'
 
 module Procodile
   class Supervisor
@@ -6,6 +7,8 @@ module Procodile
     attr_reader :config
     attr_reader :processes
     attr_reader :started_at
+    attr_reader :tag
+    attr_reader :tcp_proxy
 
     def initialize(config, run_options = {})
       @config = config
@@ -20,28 +23,34 @@ module Procodile
       @signal_handler.register('HUP') { reload_config }
     end
 
-    def start(options = {})
-      Procodile.log nil, "system", "#{@config.app_name} supervisor started with PID #{::Process.pid}"
-      if @run_options[:brittle]
-        Procodile.log nil, "system", "Running in brittle mode"
+    def allow_respawning?
+      @run_options[:respawn] != false
+    end
+
+    def start(&after_start)
+      Procodile.log nil, "system", "Procodile supervisor started with PID #{::Process.pid}"
+      if @run_options[:respawn] == false
+        Procodile.log nil, "system", "Automatic respawning is disabled"
       end
-      Thread.new do
-        socket = ControlServer.new(self)
-        socket.listen
+      ControlServer.start(self)
+      if @run_options[:proxy]
+        Procodile.log nil, "system", "Proxy is enabled"
+        @tcp_proxy = TCPProxy.start(self)
       end
-      start_processes(options[:processes])
       watch_for_output
       @started_at = Time.now
+      after_start.call(self) if block_given?
       loop { supervise; sleep 3 }
     end
 
-    def start_processes(types = [])
+    def start_processes(types = nil, options = {})
+      @tag = options[:tag]
       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
-          next if @processes[process] && !@processes[process].empty?   # Process type already running
-          instances = start_instances(process.generate_instances)
+          next if types && !types.include?(name.to_s)                   # Not a process we want
+          next if @processes[process] && !@processes[process].empty?    # Process type already running
+          instances = process.generate_instances(self).each(&:start)
           instances_started.push(*instances)
         end
       end
@@ -51,7 +60,7 @@ module Procodile
       if options[:stop_supervisor]
         @run_options[:stop_when_none] = true
       end
-
+      reload_config
       Array.new.tap do |instances_stopped|
         if options[:processes].nil?
           Procodile.log nil, "system", "Stopping all #{@config.app_name} processes"
@@ -73,53 +82,48 @@ module Procodile
     end
 
     def restart(options = {})
+      @tag = options[:tag]
       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 { |_, io| add_reader(instance, io) }
-              instances_restarted << instance
-            end
-          end
-          instances_restarted.push(*check_instance_quantities[:started])
+          instances = @processes.values.flatten
         else
           instances = process_names_to_instances(options[:processes])
           Procodile.log nil, "system", "Restarting #{instances.size} process(es)"
-          instances.each do |instance|
-            instance.restart { |_, io| add_reader(instance, io) }
-            instances_restarted << instance
-          end
-          instances_restarted.push(*check_instance_quantities(options[:processes])[:started])
         end
+
+        # Stop any processes that are no longer wanted at this point
+        instances_restarted.push(*check_instance_quantities(:stopped, options[:processes])[:stopped].map { |i| [i, nil]})
+
+        instances.each do |instance|
+          next if instance.stopping?
+          new_instance = instance.restart
+          instances_restarted << [instance, new_instance]
+        end
+
+        # Start any processes that are needed at this point
+        instances_restarted.push(*check_instance_quantities(:started, options[:processes])[:started].map { |i| [nil, i]})
       end
     end
 
     def stop_supervisor
-      Procodile.log nil, 'system', "Stopping #{@config.app_name} supervisor"
-      FileUtils.rm_f(File.join(@config.pid_root, 'supervisor.pid'))
+      Procodile.log nil, 'system', "Stopping Procodile supervisor"
+      FileUtils.rm_f(File.join(@config.pid_root, 'procodile.pid'))
       ::Process.exit 0
     end
 
     def supervise
-      # Tidy up any instances that we no longer wish to be managed. They will
-      # be removed from the list.
-      remove_unmonitored_instances
-
-      # Remove processes that have been stopped
+      # Tell instances that have been stopped that they have been stopped
       remove_stopped_instances
 
+      # Remove removed processes
+      remove_removed_processes
+
       # Check all instances that we manage and let them do their things.
       @processes.each do |_, instances|
         instances.each do |instance|
           instance.check
-          if instance.unmonitored?
-            if @run_options[:brittle]
-              Procodile.log nil, "system", "Stopping everything because a process has died in brittle mode."
-              return stop
-            end
-          end
         end
       end
 
@@ -162,16 +166,31 @@ module Procodile
       }
     end
 
-    private
-
     def add_reader(instance, io)
-      return unless io
       @readers[io] = instance
       @signal_handler.notice
     end
 
+    def add_instance(instance, io = nil)
+      add_reader(instance, io) if io
+      @processes[instance.process] ||= []
+      unless @processes[instance.process].include?(instance)
+        @processes[instance.process] << instance
+      end
+    end
+
+    def remove_instance(instance)
+      if @processes[instance.process]
+        @processes[instance.process].delete(instance)
+        @readers.delete(instance)
+      end
+    end
+
+    private
+
     def watch_for_output
       Thread.new do
+        buffer = {}
         loop do
           io = IO.select([@signal_handler.pipe[:reader]] + @readers.keys, nil, nil, 30)
           @signal_handler.handle
@@ -184,13 +203,19 @@ module Procodile
               end
 
               if reader.eof?
+                reader.close
+                buffer.delete(reader)
                 @readers.delete(reader)
               else
-                data = reader.gets
-                if instance = @readers[reader]
-                  Procodile.log instance.process.log_color, instance.description, "=> ".color(instance.process.log_color) + data
-                else
-                  Procodile.log nil, 'unknown', data
+                buffer[reader] ||= ""
+                buffer[reader] << reader.read_nonblock(4096)
+                while buffer[reader].index("\n")
+                  line, buffer[reader] = buffer[reader].split("\n", 2)
+                  if instance = @readers[reader]
+                    Procodile.log instance.process.log_color, instance.description, "=> ".color(instance.process.log_color) + line
+                  else
+                    Procodile.log nil, 'unknown', data
+                  end
                 end
               end
             end
@@ -199,45 +224,36 @@ module Procodile
       end
     end
 
-    def check_instance_quantities(processes = nil)
+    def check_instance_quantities(type = :both, 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))
+          active_instances = instances.select(&:running?)
+
+          if type == :both || type == :stopped
+            if active_instances.size > process.quantity
+              quantity_to_stop = active_instances.size - process.quantity
+              Procodile.log nil, "system", "Stopping #{quantity_to_stop} #{process.name} process(es)"
+              status[:stopped] = active_instances.last(quantity_to_stop).each(&:stop)
+            end
           end
-        end
-      end
-    end
 
-    def start_instances(instances)
-      instances.each do |instance|
-        if @run_options[:brittle]
-          instance.respawnable = false
-        end
-        instance.start { |_, io| add_reader(instance, io) }
-        @processes[instance.process] ||= []
-        @processes[instance.process] << instance
-      end
-    end
+          if type == :both || type == :started
+            if active_instances.size < process.quantity
+              quantity_needed = process.quantity - active_instances.size
+              Procodile.log nil, "system", "Starting #{quantity_needed} more #{process.name} process(es)"
+              status[:started] = process.generate_instances(self, quantity_needed).each(&:start)
+            end
+          end
 
-    def remove_unmonitored_instances
-      @processes.each do |_, instances|
-        instances.reject!(&:unmonitored?)
+        end
       end
     end
 
     def remove_stopped_instances
       @processes.each do |_, instances|
         instances.reject! do |instance|
-          if !instance.running? && instance.stopping?
+          if instance.stopping? && !instance.running?
             instance.on_stop
             true
           else
@@ -247,6 +263,19 @@ module Procodile
       end
     end
 
+    def remove_removed_processes
+      @processes.reject! do |process, instances|
+        if process.removed && instances.empty?
+          if @tcp_proxy
+            @tcp_proxy.remove_process(process)
+          end
+          true
+        else
+          false
+        end
+      end
+    end
+
     def process_names_to_instances(names)
       names.each_with_object([]) do |name, array|
         if name =~ /\A(.*)\.(\d+)\z/

data/lib/procodile/tcp_proxy.rb

@@ -0,0 +1,112 @@
+module Procodile
+  class TCPProxy
+
+    def self.start(supervisor)
+      proxy = new(supervisor)
+      proxy.start
+      proxy
+    end
+
+    def initialize(supervisor)
+      @supervisor = supervisor
+      @thread = nil
+      @listeners = {}
+      @stopped_processes = []
+      @sp_reader, @sp_writer = IO.pipe
+    end
+
+    def start
+      @supervisor.config.processes.each { |_, p| add_process(p) }
+      Thread.new do
+        listen
+        Procodile.log nil, 'proxy', "Stopped listening on all ports"
+      end
+    end
+
+    def add_process(process)
+      if process.proxy?
+        @listeners[TCPServer.new(process.proxy_address, process.proxy_port)] = process
+        Procodile.log nil, 'proxy', "Proxying traffic on #{process.proxy_address}:#{process.proxy_port} to #{process.name}".color(32)
+        @sp_writer.write_nonblock('.')
+      end
+    rescue => e
+      Procodile.log nil, 'proxy', "Exception: #{e.class}: #{e.message}"
+      Procodile.log nil, 'proxy', e.backtrace[0,5].join("\n")
+    end
+
+    def remove_process(process)
+      @stopped_processes << process
+      @sp_writer.write_nonblock('.')
+    end
+
+    def listen
+      loop do
+        io = IO.select([@sp_reader] + @listeners.keys, nil, nil, 30)
+        if io && io.first
+          io.first.each do |io|
+            if io == @sp_reader
+              io.read_nonblock(999)
+              next
+            end
+
+            Thread.new(io.accept, io) do |client, server|
+              handle_client(client, server)
+            end
+          end
+        end
+
+        @stopped_processes.reject do |process|
+          if io = @listeners.key(process)
+            Procodile.log nil, 'proxy', "Stopped proxy listener for #{process.name}"
+            io.close
+            @listeners.delete(io)
+          end
+          true
+        end
+      end
+    rescue => e
+      Procodile.log nil, 'proxy', "Exception: #{e.class}: #{e.message}"
+      Procodile.log nil, 'proxy', e.backtrace[0,5].join("\n")
+    end
+
+    def handle_client(client, server)
+      process = @listeners[server]
+      instances = @supervisor.processes[process] || []
+      if instances.empty?
+        Procodile.log nil, 'proxy', "There are no processes running for #{process.name}"
+      else
+        instance = instances[rand(instances.size)]
+        backend_socket = TCPSocket.new('127.0.0.1', instance.port) rescue nil
+        if backend_socket.nil?
+          Procodile.log nil, 'proxy', "Could not connect to #{instance.description}:#{instance.port}"
+          return
+        end
+        readers = {:backend => backend_socket, :client => client}
+        loop do
+          io = IO.select(readers.values, nil, nil, 0.5)
+          if io && io.first
+            io.first.each do |io|
+              readers.keys.each do |key|
+                next unless readers[key] == io
+                opposite_side = key == :client ? :backend : :client
+                if io.eof?
+                  readers[opposite_side].shutdown(Socket::SHUT_WR) rescue nil
+                  readers.delete(opposite_side)
+                else
+                  readers[opposite_side].write(io.readpartial(1024)) rescue nil
+                end
+              end
+            end
+          end
+        end
+      end
+    rescue => e
+      Procodile.log nil, 'proxy', "Exception: #{e.class}: #{e.message}"
+      Procodile.log nil, 'proxy', e.backtrace[0,5].join("\n")
+    ensure
+      backend_socket.close rescue nil
+      client.close rescue nil
+    end
+
+  end
+end

data/lib/procodile/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: procodile
 version: !ruby/object:Gem::Version
-  version: 1.0.3
+  version: 1.0.4
 platform: ruby
 authors:
 - Adam Cooke
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-10-18 00:00:00.000000000 Z
+date: 2016-10-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -46,6 +46,7 @@ files:
 - lib/procodile/signal_handler.rb
 - lib/procodile/status_cli_output.rb
 - lib/procodile/supervisor.rb
+- lib/procodile/tcp_proxy.rb
 - lib/procodile/version.rb
 homepage: https://github.com/adamcooke/procodile
 licenses: