epi 0.0.1

data/lib/epi/exceptions.rb

@@ -0,0 +1,10 @@
+require_relative 'exceptions/base'
+require_relative 'exceptions/fatal'
+require_relative 'exceptions/shutdown'
+require_relative 'exceptions/invalid_configuration_file'
+
+module Epi
+  module Exceptions
+
+  end
+end

data/lib/epi/exceptions/base.rb

@@ -0,0 +1,7 @@
+module Epi
+  module Exceptions
+    class Base < RuntimeError
+
+    end
+  end
+end

data/lib/epi/exceptions/fatal.rb

@@ -0,0 +1,12 @@
+module Epi
+  module Exceptions
+    class Fatal < Base
+
+      def initialize(*args)
+        super *args
+        Epi.logger.fatal message
+      end
+
+    end
+  end
+end

data/lib/epi/exceptions/invalid_configuration_file.rb

@@ -0,0 +1,14 @@
+module Epi
+  module Exceptions
+    class InvalidConfigurationFile < Base
+
+      attr_reader :data
+
+      def initialize(message, data)
+        super message
+        @data = data
+      end
+
+    end
+  end
+end

data/lib/epi/exceptions/shutdown.rb

@@ -0,0 +1,7 @@
+module Epi
+  module Exceptions
+    class Shutdown < Base
+
+    end
+  end
+end

data/lib/epi/job.rb

@@ -0,0 +1,110 @@
+require 'forwardable'
+
+module Epi
+  class Job
+    extend Forwardable
+
+    attr_reader :job_description
+    attr_accessor :expected_count
+
+    delegate [:name, :id, :allowed_processes] => :job_description
+
+    def logger
+      Epi.logger
+    end
+
+    def initialize(job_description, state)
+      @job_description = job_description
+      @expected_count = state['expected_count'] || job_description.initial_processes
+      @pids = state['pids']
+      @dying_pids = state['dying_pids']
+    end
+
+    # noinspection RubyStringKeysInHashInspection
+    def state
+      {
+          'expected_count' => expected_count,
+          'pids' => pids,
+          'dying_pids' => dying_pids
+      }
+    end
+
+    # Get a hash of PIDs, with internal process IDs as keys and PIDs as values
+    # @example `{'1a2v3c4d' => 4820}`
+    # @return [Hash]
+    def pids
+      @pids ||= {}
+    end
+
+    # Get a hash of PIDs, with internal process IDs as keys and PIDs as values,
+    # for process that are dying
+    # @example `{'1a2v3c4d' => 4820}`
+    # @return [Hash]
+    def dying_pids
+      @dying_pids ||= {}
+    end
+
+    # Get the data key for the PID file of the given process ID or PID
+    # @param [String|Fixnum] proc_id Example: `'1a2b3c4d'` or `1234`
+    # @return [String|NilClass] Example: `pids/job_id/1ab3c4d.pid`, or `nil` if not found
+    def pid_key(proc_id)
+      proc_id = pids.key(proc_id) if Fixnum === proc_id
+      proc_id && job_description.pid_key(proc_id)
+    end
+
+    # Stops processes that shouldn't run, starts process that should run, and
+    # fires event handlers
+    def sync!
+
+      # Remove non-running PIDs from the list
+      pids.reject { |_, pid| ProcessStatus.pids.include? pid }.each do |proc_id, pid|
+        logger.debug "Lost process #{pid}"
+        pids.delete proc_id
+      end
+
+      # Remove non-running PIDs from the dying list. This is just in case
+      # the daemon crashed before it was able to clean up a dying worker
+      # (i.e. it sent a TERM but didn't get around to sending a KILL)
+      dying_pids.select! { |_, pid| ProcessStatus.pids.include? pid }
+
+      # TODO: clean up processes that never died how they should have
+
+      # Run new processes
+      start_one while running_count < expected_count
+
+      # Kill old processes
+      stop_one while running_count > expected_count
+    end
+
+    def terminate!
+      self.expected_count = 0
+      sync!
+    end
+
+    def running_count
+      pids.count
+    end
+
+    private
+
+    def start_one
+      proc_id, pid = job_description.launch
+      pids[proc_id] = pid
+      Data.write pid_key(proc_id), pid
+    end
+
+    def stop_one
+      proc_id, pid = pids.shift
+      dying_pids[proc_id] = pid
+      work = proc do
+        ProcessStatus[pid].kill job_description.kill_timeout
+      end
+      done = proc do
+        dying_pids.delete proc_id
+        Data.write pid_key(proc_id), nil
+      end
+      EventMachine.defer work, done
+    end
+
+  end
+end

data/lib/epi/job_description.rb

@@ -0,0 +1,107 @@
+require 'shellwords'
+require 'securerandom'
+
+module Epi
+  class JobDescription
+
+    def self.property(method, default = nil, &validator)
+      define_method method do
+        @props.key?(method) ? @props[method] : default
+      end
+      define_method :"#{method}=" do |value|
+        if validator
+          result = validator.call(value)
+          raise Exceptions::Fatal, "Invalid value '#{value}' of type #{value.class.name} for #{method}: #{result}" if result
+        end
+        @props[method] = value
+      end
+    end
+
+    property :name do |value|
+      'Must be a non-blank string' unless String === value && !value.strip.empty?
+    end
+
+    property :directory do |value|
+      'Must be a valid relative or absolute directory path' unless String === value && value =~ /\A[^\0]+\z/
+    end
+
+    property :environment, {} do |value|
+      'Must be a hash' unless Hash === value
+    end
+
+    property :command do |value|
+      'Must be a non-blank string' unless String === value && !value.strip.empty?
+    end
+
+    property :initial_processes, 1 do |value|
+      'Must be a non-negative integer' unless Fixnum === value && value >= 0
+    end
+
+    property :allowed_processes, 0..10 do |value|
+      'Must be a range including a positive integer, and no negatives' unless
+          Range === value && value.max >= 1 && value.min >= 0
+    end
+
+    %i[stdout stderr].each do |pipe|
+      property pipe do |value|
+        'Must be a path to a file descriptor' unless String === value && value =~ /\A[^\0]+\z/
+      end
+    end
+
+    property :user do |value|
+      'Must be a non-blank string' unless String === value && !value.strip.empty?
+    end
+
+    property :kill_timeout, 20 do |value|
+      'Must be a non-negative number' unless value.is_a?(Numeric) && value >= 0
+    end
+
+    attr_reader :id
+
+    def initialize(id)
+      @id = id
+      @handlers = {}
+      @props = {}
+    end
+
+    def launch
+      proc_id = generate_id
+      opts = {
+          cwd: directory,
+          user: user,
+          env: {PIDFILE: pid_path(proc_id)}.merge(environment || {}),
+          stdout: stdout,
+          stderr: stderr
+      }
+      pid = Epi.launch command, **opts
+      [proc_id, pid]
+    end
+
+    def reconfigure
+      @handlers = {}
+      yield self
+    end
+
+    def on(event, *args, &handler)
+      (@handlers[event] ||= []) << {
+          args: args,
+          handler: handler
+      }
+    end
+
+    def pid_key(proc_id)
+      "pids/#{id}/#{proc_id}.pid"
+    end
+
+    def pid_path(proc_id)
+      Data.home + pid_key(proc_id)
+    end
+
+    private
+
+    def generate_id
+      SecureRandom.hex 4
+    end
+
+  end
+end

data/lib/epi/jobs.rb

@@ -0,0 +1,83 @@
+require 'forwardable'
+
+module Epi
+
+  # Manages running jobs
+  module Jobs
+
+    class << self
+      extend Forwardable
+
+      delegate [:[], :[]=, :delete, :each_value, :map] => :@jobs
+
+      attr_reader :configuration_files
+
+      def reset!
+        @configuration_files = {}
+        @jobs = {}
+      end
+
+      def beat!
+
+        # Cancel any scheduled beats
+        EventMachine.cancel_timer @next_beat if @next_beat
+
+        # Make sure configuration files have been read
+        refresh_config!
+
+        # Snapshot currently running processes
+        ProcessStatus.take!
+
+        # Get rid of jobs for config files that have been removed
+        clean_configuration_files!
+
+        # Create new jobs
+        make_new_jobs!
+
+        # Sync each job with its expectations
+        each_value &:sync!
+
+        # Write state of each job to data file
+        Data.jobs = map { |id, job| [id.to_s, job.state] }.to_h
+        Data.save
+
+        # Schedule the next beat
+        @next_beat = EventMachine.add_timer(5) { beat! } # TODO: make interval configurable
+      end
+
+      def job_descriptions
+        configuration_files.values.inject({}) { |all, conf_file| all.merge! conf_file.job_descriptions }
+      end
+
+      def refresh_config!
+        Data.configuration_paths.each do |path|
+          configuration_files[path] ||= ConfigurationFile.new(path)
+        end
+        configuration_files.each_value &:read
+      end
+
+      private
+
+      def clean_configuration_files!
+        to_remove = configuration_files.keys - Data.configuration_paths
+        to_remove.each do |path|
+          configuration_files.delete(path).job_descriptions.each_key do |job_id|
+            job = delete(job_id)
+            job.terminate! if job
+          end
+        end
+      end
+
+      def make_new_jobs!
+        job_descriptions.each do |name, description|
+          self[name] ||= Epi::Job.new(description, Data.jobs[name] || {})
+        end
+      end
+
+    end
+
+    # Set up class variables
+    reset!
+
+  end
+end

data/lib/epi/launch.rb

@@ -0,0 +1,59 @@
+module Epi
+  # Run a system command in the background, and allow it to keep running
+  # after Ruby has exited.
+  # @param command [String|Array] The command to run, either as a pre-escaped string,
+  #   or an array of non-escaped strings (a command and zero or more arguments).
+  # @param env [Hash] Environment variables to be passed to the command, in addition
+  #   to those inherited from the current environment
+  # @param user [String|NilClass] If supplied, command will be run through `su` as
+  #   this user.
+  # @param cwd [String|NilClass] If supplied, command will be run from this
+  #   directory.
+  # @param stdout [String|TrueClass|FalseClass|NilClass] Where to redirect standard
+  #   output; either a file path, or `true` for no redirection, or `false`/`nil` to
+  #   redirect to `/dev/null`
+  # @param stderr [String|TrueClass|FalseClass|NilClass] Where to redirect standard
+  #   error; either a file path, or `true` for no redirection, or `false`/`nil` to
+  #   redirect to `/dev/null`
+  # @return [Fixnum] The PID of the started process
+  def self.launch(command, env: {}, user: nil, cwd: nil, stdout: true, stderr: true)
+
+    # Prevent hang-up
+    cmd = 'nohup '
+
+    # The main command and its arguments
+    if String === command
+
+      # Pre-escaped string
+      cmd << command
+    else
+
+      # Command and arguments that need to be escaped
+      command.each { |part| cmd << ' ' << Shellwords.escape(part) }
+    end
+
+    # Include `su` command if a user is given
+    cmd = "su #{user} -c #{cmd}" if user
+
+    # STDOUT and STDERR redirection
+    {:>> => stdout, :'2>>' => stderr}.each do |arrow, dest|
+      cmd << " #{arrow} #{dest || '/dev/null'}" unless TrueClass === dest
+    end
+
+    # Run in background, and return PID of backgrounded process
+    cmd << ' & echo $!'
+
+    # Include the working directory
+    cmd = "cd #{Shellwords.escape cwd} && (#{cmd})" if cwd
+
+    # Convert environment variables to strings, and merge them with the current environment
+    env = ENV.to_h.merge(env).map { |k, v| [k.to_s, v.to_s] }.to_h
+
+    logger.debug "Starting `#{cmd}`"
+
+    # Run the command and read the resulting PID from its STDOUT
+    IO.popen(env, cmd) { |p| p.read }.to_i.tap do |pid|
+      logger.debug "Process #{pid} started: #{`ps -p #{pid} -o command=`.chomp}"
+    end
+  end
+end

data/lib/epi/process_status.rb

@@ -0,0 +1,71 @@
+require 'forwardable'
+
+module Epi
+  class ProcessStatus
+
+    class << self
+      extend Forwardable
+
+      def reset!
+        @last = nil
+      end
+
+      # Current running processes
+      # @return [self]
+      def now
+        new
+      end
+
+      # Take a snapshot of current running processes
+      # @return [self]
+      def take!
+        @last = now
+      end
+
+      # The last snapshot taken by {#take}
+      # @return [self]
+      def last
+        @last ||= take!
+      end
+
+      delegate [:[], :pids] => :last
+
+    end
+
+    # Lookup a running process by its PID
+    # @param pid [String|Numeric] PID of the process to lookup
+    # @return [RunningProcess|NilClass]
+    def [](pid)
+      pid = pid.to_i
+      @running_processes[pid] ||= find_by_pid(pid)
+    end
+
+    # Get a list of PIDs of running processes
+    # @return [Array] An array of PIDs as `Fixnum`s
+    def pids
+      @pids ||= @lines.keys
+    end
+
+    private
+
+    def initialize
+
+      # Cached running processes
+      @running_processes = {}
+
+      # Run `ps`
+      result = %x(ps x -o #{RunningProcess::PS_FORMAT})
+
+      # Split into lines, and get rid of the first (heading) line
+      @lines = result.lines[1..-1].map { |line| [line.lstrip.split(/\s/, 2).first.to_i, line] }.to_h
+
+    end
+
+    def find_by_pid(pid)
+      line = @lines[pid]
+      RunningProcess.new(pid, line) if line
+    end
+
+
+  end
+end