procodile 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 12da3acd72adc0bf302ddad40c02133f308cf168
+  data.tar.gz: e13faabcbbadce0fd6ac91885c3b5ba937f398db
+SHA512:
+  metadata.gz: 8b61d0f1fb351bf1f05eac2ea0d22accd8ff2ebbe51fd551397ac5c8ee17693ffa36f6a7f3d2e9729774cf1dabac99358930de70c45c0aa2cd95b1d9359ffb06
+  data.tar.gz: b2f481642d8e7015808946d07cf6b7d0c027e1d2b8956518b27a61bd670e851e690fbf98c79cd3ec02b042d6c176c275794abe6ee2139effc234fc60152b65d9

data/bin/procodile

@@ -0,0 +1,30 @@
+#!/usr/bin/env ruby
+require 'optparse'
+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!
+
+$:.unshift(File.expand_path('../../lib', __FILE__))
+
+require 'fileutils'
+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.run(command)
+
+rescue Procodile::Error => e
+  $stderr.puts "\e[31merror: #{e.message}\e[0m"
+  exit 1
+end

data/lib/procodile.rb

@@ -0,0 +1,2 @@
+module Procodile
+end

data/lib/procodile/cli.rb

@@ -0,0 +1,131 @@
+require 'fileutils'
+require 'procodile/error'
+require 'procodile/supervisor'
+require 'procodile/signal_handler'
+
+module Procodile
+  class CLI
+
+    def initialize(config)
+      @config = config
+    end
+
+    def run(command)
+      if self.class.instance_methods(false).include?(command.to_sym) && command != 'run'
+        public_send(command)
+      else
+        raise Error, "Invalid command '#{command}'"
+      end
+    end
+
+    def start
+      if running?
+        raise Error, "#{@config.app_name} already running (PID: #{current_pid})"
+      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
+      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..."
+      else
+        raise Error, "#{@config.app_name} supervisor isn't running"
+      end
+    end
+
+    def stop_supervisor
+      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."
+        else
+          puts "OK. That's fine. You can just run `stop` to stop processes too."
+        end
+
+      else
+        raise Error, "#{@config.app_name} supervisor isn't running"
+      end
+    end
+
+    def restart
+      if running?
+        ::Process.kill('USR1', current_pid)
+        puts "Restarting #{@config.app_name}"
+      else
+        raise Error, "#{@config.app_name} supervisor isn't running"
+      end
+    end
+
+    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}"
+      else
+        puts "#{@config.app_name} supervisor not running"
+      end
+    end
+
+    def kill
+      Dir[File.join(@config.pid_root, '*.pid')].each do |pid_path|
+        name = pid_path.split('/').last.gsub(/\.pid\z/, '')
+        pid = File.read(pid_path).to_i
+        begin
+          ::Process.kill('KILL', pid)
+          puts "Sent KILL to #{pid} (#{name})"
+        rescue Errno::ESRCH
+        end
+        FileUtils.rm(pid_path)
+      end
+    end
+
+    private
+
+    def running?
+      if pid = current_pid
+        ::Process.getpgid(pid) ? true : false
+      else
+        false
+      end
+    rescue Errno::ESRCH
+      false
+    end
+
+    def current_pid
+      if File.exist?(pid_path)
+        pid_file = File.read(pid_path).strip
+        pid_file.length > 0 ? pid_file.to_i : nil
+      else
+        nil
+      end
+    end
+
+    def pid_path
+      File.join(@config.pid_root, 'supervisor.pid')
+    end
+
+    def log_path
+      File.join(@config.log_root, 'supervisor.log')
+    end
+
+  end
+end

data/lib/procodile/config.rb

@@ -0,0 +1,64 @@
+require 'yaml'
+require 'procodile/error'
+require 'procodile/process'
+
+module Procodile
+  class Config
+
+    COLORS = [35, 31, 36, 32, 33, 34]
+
+    attr_reader :root
+
+    def initialize(root)
+      @root = root
+      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 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)
+      end
+    end
+
+    def process_list
+      @processes ||= YAML.load_file(procfile_path)
+    end
+
+    def options
+      @options ||= File.exist?(options_path) ? YAML.load_file(options_path) : {}
+    end
+
+    def process_options
+      @process_options ||= options['processes'] || {}
+    end
+
+    def pid_root
+      File.expand_path(options['pid_root'] || 'pids', @root)
+    end
+
+    def log_root
+      File.expand_path(options['log_root'] || 'log', @root)
+    end
+
+    private
+
+    def procfile_path
+      File.join(@root, 'Procfile')
+    end
+
+    def options_path
+      File.join(@root, 'Procfile.options')
+    end
+
+  end
+end

data/lib/procodile/error.rb

@@ -0,0 +1,4 @@
+module Procodile
+  class Error < StandardError
+  end
+end

data/lib/procodile/instance.rb

@@ -0,0 +1,204 @@
+require 'procodile/logger'
+
+module Procodile
+  class Instance
+
+    attr_accessor :pid
+
+    def initialize(process, id)
+      @process = process
+      @id = id
+      @respawns = 0
+    end
+
+    def description
+      "#{@process.name}.#{@id}"
+    end
+
+    def dead?
+      @dead || false
+    end
+
+    def pid_file_path
+      File.join(@process.config.pid_root, "#{description}.pid")
+    end
+
+    def log_file_path
+      File.join(@process.config.log_root, "#{description}.log")
+    end
+
+    def pid_from_file
+      if File.exist?(pid_file_path)
+        pid = File.read(pid_file_path)
+        pid.length > 0 ? pid.strip.to_i : nil
+      else
+        nil
+      end
+    end
+
+    def running?(force_pid = nil)
+      if force_pid || @pid
+        ::Process.getpgid(force_pid || @pid) ? true : false
+      else
+        false
+      end
+    rescue Errno::ESRCH
+      false
+    end
+
+    def start
+      @stopping = false
+      Dir.chdir(@process.config.root) do
+        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)
+        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)
+      end
+    end
+
+    #
+    # Is this instance supposed to be stopping/be stopped?
+    #
+    def stopping?
+      @stopping || false
+    end
+
+    #
+    # Send this signal the signal to stop and mark the instance in a state that
+    # tells us that we want it to be stopped.
+    #
+    def stop
+      @stopping = true
+      update_pid
+      if self.running?
+        pid = self.pid_from_file
+        Procodile.log(@process.log_color, description, "Sending TERM to #{pid}")
+        ::Process.kill('TERM', pid)
+      else
+        Procodile.log(@process.log_color, description, "Process already stopped")
+      end
+    end
+
+    #
+    # A method that will be called when this instance has been stopped and it isn't going to be
+    # started again
+    #
+    def on_stop
+      FileUtils.rm_f(self.pid_file_path)
+      Procodile.log(@process.log_color, description, "Removed PID file")
+    end
+
+    #
+    # Retarts the process using the appropriate method from the process configuraiton
+    #
+    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'
+        if running?
+          ::Process.kill(@process.restart_mode.upcase, @pid)
+          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
+        end
+      when 'start-term'
+        old_process_pid = @pid
+        start
+        Procodile.log(@process.log_color, description, "Sent TERM signal to old PID #{old_process_pid} (forgetting now)")
+        ::Process.kill('TERM', old_process_pid)
+      when 'term-start'
+        stop
+        Thread.new do
+          # Wait for this process to stop and when it has, run it.
+          sleep 0.5 while running?
+          start
+        end
+      end
+    ensure
+      @restarting = false
+    end
+
+    #
+    # Update the locally cached PID from that stored on the file system.
+    #
+    def update_pid
+      pid_from_file = self.pid_from_file
+      if pid_from_file != @pid
+        @pid = pid_from_file
+        Procodile.log(@process.log_color, description, "PID file changed. Updated pid to #{@pid}")
+        true
+      else
+        false
+      end
+    end
+
+    #
+    # 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
+
+      if self.running?
+        # Everything is OK. The process is running.
+      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")
+          die
+        end
+      end
+    end
+
+    #
+    # Mark this process as dead and tidy up after it
+    #
+    def die
+      on_stop
+      @dead = true
+    end
+
+    #
+    # Can this process be respawned if needed?
+    #
+    def can_respawn?
+      !stopping? && (respawns + 1) <= @process.max_respawns
+    end
+
+    #
+    # Return the number of times this process has been respawned in the last hour
+    #
+    def respawns
+      if @respawns.nil? || @last_respawn.nil? || @last_respawn < (Time.now - @process.respawn_window)
+        0
+      else
+        @respawns
+      end
+    end
+
+    #
+    # Increment the counter of respawns for this process
+    #
+    def add_respawn
+      if @last_respawn && @last_respawn < (Time.now - @process.respawn_window)
+        @respawns = 1
+      else
+        @last_respawn = Time.now
+        @respawns += 1
+      end
+    end
+
+  end
+end

data/lib/procodile/logger.rb

@@ -0,0 +1,22 @@
+require 'logger'
+module Procodile
+
+  def self.mutex
+    @mutex ||= Mutex.new
+  end
+
+  def self.log(color, name, text)
+    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 += message
+        $stdout.puts output
+        $stdout.flush
+      end
+    end
+  end
+
+end

data/lib/procodile/process.rb

@@ -0,0 +1,65 @@
+require 'procodile/instance'
+
+module Procodile
+  class Process
+
+    attr_reader :name
+    attr_reader :command
+    attr_reader :config
+
+    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
+    end
+
+    #
+    # How many instances of this process should be started
+    #
+    def quantity
+      @options['quantity'] || 1
+    end
+
+    #
+    # The maximum number of times this process can be respawned in the given period
+    #
+    def max_respawns
+      @options['max_respawns'] ? @options['max_respawns'].to_i : 5
+    end
+
+    #
+    # The respawn window. One hour by default.
+    #
+    def respawn_window
+      @options['respawn_window'] ? @options['respawn_window'].to_i : 3600
+    end
+
+    #
+    # Defines how this process should be restarted
+    #
+    # start-term = start new instances and send term to children
+    # usr1 = just send a usr1 signal to the current instance
+    # usr2 = just send a usr2 signal to the current instance
+    # term-start = stop the old instances, when no longer running, start a new one
+    #
+    def restart_mode
+      @options['restart_mode'] || 'term-start'
+    end
+
+    #
+    # 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) }
+    end
+
+  end
+end

data/lib/procodile/signal_handler.rb

@@ -0,0 +1,32 @@
+module Procodile
+  class SignalHandler
+
+    def self.queue
+      Thread.main[:signal_queue] ||= []
+    end
+
+    def initialize(*signals)
+      @handlers = {}
+      Thread.new do
+        loop do
+          if signal = self.class.queue.shift
+            if @handlers[signal]
+              @handlers[signal].each(&:call)
+            end
+          end
+          sleep 1
+        end
+      end
+
+      signals.each do |sig|
+        Signal.trap(sig, proc { SignalHandler.queue << sig })
+      end
+    end
+
+    def register(name, &block)
+      @handlers[name] ||= []
+      @handlers[name] << block
+    end
+
+  end
+end

data/lib/procodile/supervisor.rb

@@ -0,0 +1,96 @@
+module Procodile
+  class Supervisor
+
+    # Create a new supervisor instance that will be monitoring the
+    # processes that have been provided.
+    def initialize(config)
+      @config = config
+      @instances = []
+    end
+
+    def start
+      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
+      end
+      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
+    end
+
+    def restart
+      Procodile.log nil, 'system', "Restarting all #{@config.app_name} processes"
+      @instances.each(&:restart)
+    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)"
+        else
+          Procodile.log '37;44', 'status', "#{instance.description} is STOPPED"
+        end
+      end
+    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
+
+          # 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)
+        end
+
+        sleep 5
+      end
+    end
+
+    private
+
+    def remove_dead_instances
+      @instances.reject!(&:dead?)
+    end
+
+    def remove_stopped_instances
+      @instances.reject! do |instance|
+        if instance.running?
+          false
+        else
+          instance.on_stop
+          true
+        end
+      end
+    end
+
+  end
+end

metadata

@@ -0,0 +1,56 @@
+--- !ruby/object:Gem::Specification
+name: procodile
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Adam Cooke
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-10-16 00:00:00.000000000 Z
+dependencies: []
+description: Run Ruby/Rails processes in the background on Linux servers with ease.
+email:
+- me@adamcooke.io
+executables:
+- procodile
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/procodile
+- lib/procodile.rb
+- lib/procodile/cli.rb
+- lib/procodile/config.rb
+- lib/procodile/error.rb
+- lib/procodile/instance.rb
+- lib/procodile/logger.rb
+- lib/procodile/process.rb
+- lib/procodile/signal_handler.rb
+- lib/procodile/supervisor.rb
+homepage: https://github.com/adamcooke/procodile
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: This gem will help you run Ruby processes from a Procfile on Linux servers
+  in the background.
+test_files: []