procodile 0.0.2 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a67424151ecf1b1b6fc80cdd93d4989b3bc1f0ba
-  data.tar.gz: 5df9bfac9a606afe8987a6400fa097f0091d99a3
+  metadata.gz: b644b27235abc8fcae9bfd9d7ca9bbd87cd1c0d8
+  data.tar.gz: 82428a6110171a2b783f0a249b8bf6661e02c6e4
 SHA512:
-  metadata.gz: 85cc30d458aa91a9ec06c25412bfced78860f7f2a2f2a74d674e790c811d2d7005d1cfe8812d6fd027013a21919c8126f7d5930bb219db3c6c4e1b09a06e8ad7
-  data.tar.gz: 8d80992dcfb3a8dafda5da5feae9cc4798f6225862583eb520be96c979f29dbd45cab4bc8070274b0a88e5662f27ef4c93fed4248488259454e2624c626a30a3
+  metadata.gz: b4cbe1b3445fbb4fab8afd3cab8e1a90aa03b0e4c24de0daddd9823cdc756831ee096647d5a424e363e36808fb43709c73d5be763b09de5d6f805d7869275e26
+  data.tar.gz: 6363da66bd85396ffbd5bde9ad4ff64464535fd73f1f5b9c29b1a3d32b42ed4d2bf2f0343743d005438db85c730081c0a2827a9b5cc8a216ab9dd5d57a4880a6

data/bin/procodile

@@ -1,5 +1,8 @@
 #!/usr/bin/env ruby
 require 'optparse'
+require 'fileutils'
+$:.unshift(File.expand_path('../../lib', __FILE__))
+require 'procodile'
 
 command = ARGV[0]
 
@@ -11,6 +14,12 @@ begin
       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
@@ -19,23 +28,23 @@ begin
       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
+      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
     end
   end.parse!
 rescue OptionParser::InvalidOption => e
-  $stderr.puts "\e[31merror: #{e.message}\e[0m"
+  $stderr.puts "Error: #{e.message}".color(31)
   exit 1
 end
 
-$:.unshift(File.expand_path('../../lib', __FILE__))
-
-require 'fileutils'
-require 'procodile'
 require 'procodile/error'
 require 'procodile/config'
 require 'procodile/cli'
@@ -46,6 +55,6 @@ begin
   cli = Procodile::CLI.new(config, options)
   cli.run(command)
 rescue Procodile::Error => e
-  $stderr.puts "\e[31merror: #{e.message}\e[0m"
+  $stderr.puts "Error: #{e.message}".color(31)
   exit 1
 end

data/lib/procodile/cli.rb

@@ -33,6 +33,9 @@ module Procodile
         end
       end
 
+      run_options = {}
+      run_options[:brittle] = @cli_options[:brittle]
+
       processes = process_names_from_cli_option
 
       if @cli_options[:clean]
@@ -43,15 +46,15 @@ module Procodile
 
       if @cli_options[:foreground]
         File.open(pid_path, 'w') { |f| f.write(::Process.pid) }
-        Supervisor.new(@config).start(:processes => processes)
+        Supervisor.new(@config, run_options).start(:processes => processes)
       else
         FileUtils.rm_f(File.join(@config.pid_root, "*.pid"))
         pid = fork do
-          STDOUT.reopen(log_path, 'a')
+          STDOUT.reopen(@config.log_path, 'a')
           STDOUT.sync = true
-          STDERR.reopen(log_path, 'a')
+          STDERR.reopen(@config.log_path, 'a')
           STDERR.sync = true
-          Supervisor.new(@config).start(:processes => processes)
+          Supervisor.new(@config, run_options).start(:processes => processes)
         end
         ::Process.detach(pid)
         File.open(pid_path, 'w') { |f| f.write(pid) }
@@ -178,11 +181,7 @@ module Procodile
     end
 
     def pid_path
-      File.join(@config.pid_root, 'supervisor.pid')
-    end
-
-    def log_path
-      File.join(@config.log_root, 'supervisor.log')
+      File.join(@config.pid_root, 'procodile.pid')
     end
 
     def process_names_from_cli_option

data/lib/procodile/config.rb

@@ -14,9 +14,7 @@ module Procodile
       unless File.exist?(procfile_path)
         raise Error, "Procfile not found at #{procfile_path}"
       end
-
       FileUtils.mkdir_p(pid_root)
-      FileUtils.mkdir_p(log_root)
     end
 
     def reload
@@ -73,8 +71,8 @@ module Procodile
       @pid_root ||= File.expand_path(options['pid_root'] || 'pids', @root)
     end
 
-    def log_root
-      @log_root ||= File.expand_path(options['log_root'] || 'log', @root)
+    def log_path
+      @log_path ||= File.expand_path(options['log_path'] || 'procodile.log', @root)
     end
 
     def sock_path

data/lib/procodile/control_session.rb

@@ -16,7 +16,7 @@ module Procodile
           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"
+          Procodile.log nil, 'control', "Error: #{e.message}".color(31)
           "500 #{e.message}"
         end
       else

data/lib/procodile/instance.rb

@@ -6,11 +6,13 @@ module Procodile
     attr_accessor :pid
     attr_reader :id
     attr_accessor :process
+    attr_accessor :respawnable
 
     def initialize(process, id)
       @process = process
       @id = id
       @respawns = 0
+      @respawnable = true
     end
 
     #
@@ -34,13 +36,6 @@ module Procodile
       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
     #
@@ -77,13 +72,24 @@ 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}")
+        nil
       else
-        log_file = File.open(self.log_file_path, 'a')
+        if self.process.log_path
+          log_destination = File.open(self.process.log_path, 'a')
+          return_value = nil
+        else
+          reader, writer = IO.pipe
+          log_destination = writer
+          return_value = reader
+        end
+
         Dir.chdir(@process.config.root)
-        @pid = ::Process.spawn({'PID_FILE' => pid_file_path}, @process.command, :out => log_file, :err => log_file, :pgroup => true)
+        @pid = ::Process.spawn({'PID_FILE' => pid_file_path}, @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)
+
+        return_value
       end
     end
 
@@ -164,7 +170,7 @@ module Procodile
     #
     def update_pid
       pid_from_file = self.pid_from_file
-      if pid_from_file != @pid
+      if pid_from_file && pid_from_file != @pid
         @pid = pid_from_file
         Procodile.log(@process.log_color, description, "PID file changed. Updated pid to #{@pid}")
         true
@@ -174,26 +180,34 @@ module Procodile
     end
 
     #
-    # Check the status of this process and handle as appropriate
+    # 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?
 
       if self.running?
         # Everything is OK. The process is running.
+        true
       else
         # If the process isn't running any more, update the PID in our memory from
         # the file in case the process has changed itself.
         return check if update_pid
 
-        if can_respawn?
-          Procodile.log(@process.log_color, description, "Process has stopped. Respawning...")
-          start
-          add_respawn
-        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")
+        if @respawnable
+          if can_respawn?
+            Procodile.log(@process.log_color, description, "Process has stopped. Respawning...")
+            start
+            add_respawn
+          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)
+            tidy
+            unmonitor
+          end
+        else
+          Procodile.log(@process.log_color, description, "Process has stopped. Respawning not available.")
           tidy
           unmonitor
         end

data/lib/procodile/logger.rb

@@ -9,9 +9,7 @@ module Procodile
     mutex.synchronize do
       text.to_s.lines.map(&:chomp).each do |message|
         output  = ""
-        output += "\e[#{color}m" if color
-        output += "#{Time.now.strftime("%H:%M:%S")} #{name.ljust(15, ' ')} |"
-        output += "\e[0m "
+        output += "#{Time.now.strftime("%H:%M:%S")} #{name.ljust(15, ' ')} | ".color(color)
         output += message
         $stdout.puts output
         $stdout.flush

data/lib/procodile/process.rb

@@ -38,6 +38,14 @@ module Procodile
       @options['respawn_window'] ? @options['respawn_window'].to_i : 3600
     end
 
+    #
+    # Return the path where log output for this process should be written to. If
+    # none, output will be written to the supervisor log.
+    #
+    def log_path
+      @options['log_path'] ? File.expand_path(@options['log_path'], @config.root) : nil
+    end
+
     #
     # Defines how this process should be restarted
     #
@@ -68,7 +76,8 @@ module Procodile
         :max_respawns => self.max_respawns,
         :respawn_window => self.respawn_window,
         :command => self.command,
-        :restart_mode => self.restart_mode
+        :restart_mode => self.restart_mode,
+        :log_path => self.log_path
       }
     end
 

data/lib/procodile/signal_handler.rb

@@ -1,26 +1,28 @@
 module Procodile
   class SignalHandler
 
+    attr_reader :pipe
+
     def self.queue
       Thread.main[:signal_queue] ||= []
     end
 
     def initialize(*signals)
       @handlers = {}
+      reader, writer = IO.pipe
+      @pipe = {:reader => reader, :writer => writer}
+      signals.each do |sig|
+        Signal.trap(sig, proc { SignalHandler.queue << sig ; notice })
+      end
+    end
+
+    def start
       Thread.new do
         loop do
-          if signal = self.class.queue.shift
-            if @handlers[signal]
-              @handlers[signal].each(&:call)
-            end
-          end
+          handle
           sleep 1
         end
       end
-
-      signals.each do |sig|
-        Signal.trap(sig, proc { SignalHandler.queue << sig })
-      end
     end
 
     def register(name, &block)
@@ -28,5 +30,17 @@ module Procodile
       @handlers[name] << block
     end
 
+    def notice
+      @pipe[:writer].write_nonblock('.')
+    end
+
+    def handle
+      if signal = self.class.queue.shift
+        if @handlers[signal]
+          @handlers[signal].each(&:call)
+        end
+      end
+    end
+
   end
 end

data/lib/procodile/supervisor.rb

@@ -6,27 +6,31 @@ module Procodile
     attr_reader :config
     attr_reader :processes
 
-    # Create a new supervisor instance that will be monitoring the
-    # processes that have been provided.
-    def initialize(config)
+    def initialize(config, run_options = {})
       @config = config
+      @run_options = run_options
       @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 }
+      @readers = {}
+      @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(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"
+      end
       Thread.new do
         socket = ControlServer.new(self)
         socket.listen
       end
       start_processes(options[:processes])
-      supervise
+      watch_for_output
+      loop { supervise; sleep 3 }
     end
 
     def start_processes(types = [])
@@ -92,26 +96,30 @@ module Procodile
     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
-
-        # Remove processes that have been stopped
-        remove_stopped_instances
+      # Tidy up any instances that we no longer wish to be managed. They will
+      # be removed from the list.
+      remove_unmonitored_instances
 
-        # Check all instances that we manage and let them do their things.
-        @processes.each do |_, instances|
-          instances.each(&:check)
-        end
+      # Remove processes that have been stopped
+      remove_stopped_instances
 
-        # 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
+      # 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
 
-        sleep 5
+      # 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
     end
 
@@ -123,6 +131,30 @@ module Procodile
 
     private
 
+    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.eof?
+                @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
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+
     def check_instance_quantities
       @processes.each do |process, instances|
         if instances.size > process.quantity
@@ -140,13 +172,17 @@ module Procodile
 
     def start_instances(instances)
       instances.each do |instance|
-        instance.start
+        if @run_options[:brittle]
+          instance.respawnable = false
+        end
+        io = instance.start
+        @readers[io] = instance if io
         @processes[instance.process] ||= []
         @processes[instance.process] << instance
       end
     end
 
-    def remove_dead_instances
+    def remove_unmonitored_instances
       @processes.each do |_, instances|
         instances.reject!(&:unmonitored?)
       end.reject! { |_, instances| instances.empty? }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: procodile
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 1.0.0
 platform: ruby
 authors:
 - Adam Cooke