epi 0.0.1 → 0.1.0

data/lib/epi/job.rb

@@ -15,6 +15,7 @@ module Epi
 
     def initialize(job_description, state)
       @job_description = job_description
+      @triggers = job_description.triggers.map { |t| Trigger.make self, *t }
       @expected_count = state['expected_count'] || job_description.initial_processes
       @pids = state['pids']
       @dying_pids = state['dying_pids']
@@ -76,25 +77,80 @@ module Epi
       stop_one while running_count > expected_count
     end
 
+    def run_triggers!
+      @triggers.each &:try
+    end
+
+    def shutdown!(&callback)
+      count = running_count
+      if count > 0
+        count.times do
+          stop_one do
+            count -= 1
+            callback.call if callback && count == 0
+          end
+        end
+      else
+        callback.call if callback
+      end
+    end
+
     def terminate!
       self.expected_count = 0
       sync!
     end
 
+    def restart!
+      count = expected_count
+      if count > 0
+        self.expected_count = 0
+        sync!
+        self.expected_count = count
+        sync!
+      end
+      self
+    end
+
+    def running_processes
+      pids.map do |proc_id, pid|
+        [proc_id, ProcessStatus[pid] || RunningProcess.new(pid)]
+      end.to_h
+    end
+
     def running_count
       pids.count
     end
 
+    def dying_count
+      dying_pids.count
+    end
+
+    # Replace a running process with a new one
+    # @param pid [Fixnum] PID of the process to replace
+    def replace(pid, &callback)
+      stop_one pid do
+        start_one while running_count < expected_count
+        callback.call if callback
+      end
+    end
+
     private
 
     def start_one
       proc_id, pid = job_description.launch
       pids[proc_id] = pid
       Data.write pid_key(proc_id), pid
+      Jobs.by_pid[pid] = self
     end
 
-    def stop_one
-      proc_id, pid = pids.shift
+    def stop_one(pid = nil, &callback)
+      if pid
+        proc_id = pids.key pid
+        raise Exceptions::Fatal, "Process #{pid} isn't managed by job #{id}" unless proc_id
+        pids.delete proc_id
+      else
+        proc_id, pid = pids.shift
+      end
       dying_pids[proc_id] = pid
       work = proc do
         ProcessStatus[pid].kill job_description.kill_timeout
@@ -102,6 +158,8 @@ module Epi
       done = proc do
         dying_pids.delete proc_id
         Data.write pid_key(proc_id), nil
+        Jobs.by_pid.delete pid
+        callback.call if callback
       end
       EventMachine.defer work, done
     end

data/lib/epi/job_description.rb

@@ -56,11 +56,11 @@ module Epi
       'Must be a non-negative number' unless value.is_a?(Numeric) && value >= 0
     end
 
-    attr_reader :id
+    attr_reader :id, :triggers
 
     def initialize(id)
       @id = id
-      @handlers = {}
+      @triggers = []
       @props = {}
     end
 
@@ -78,15 +78,13 @@ module Epi
     end
 
     def reconfigure
-      @handlers = {}
+      @triggers = []
       yield self
+      # TODO: trigger an update of existing/running jobs
     end
 
-    def on(event, *args, &handler)
-      (@handlers[event] ||= []) << {
-          args: args,
-          handler: handler
-      }
+    def on(trigger_name, *args, &handler)
+      @triggers << [trigger_name, args, handler]
     end
 
     def pid_key(proc_id)

data/lib/epi/jobs.rb

@@ -8,13 +8,14 @@ module Epi
     class << self
       extend Forwardable
 
-      delegate [:[], :[]=, :delete, :each_value, :map] => :@jobs
+      delegate [:[], :[]=, :delete, :each_value, :map, :find, :count] => :@jobs
 
-      attr_reader :configuration_files
+      attr_reader :configuration_files, :by_pid
 
       def reset!
         @configuration_files = {}
         @jobs = {}
+        @by_pid = {}
       end
 
       def beat!
@@ -37,6 +38,13 @@ module Epi
         # Sync each job with its expectations
         each_value &:sync!
 
+        # Snapshot processes again, so that triggers have access to
+        # newly-spawned processes
+        ProcessStatus.take!
+
+        # Run job triggers
+        each_value &:run_triggers!
+
         # Write state of each job to data file
         Data.jobs = map { |id, job| [id.to_s, job.state] }.to_h
         Data.save
@@ -45,6 +53,26 @@ module Epi
         @next_beat = EventMachine.add_timer(5) { beat! } # TODO: make interval configurable
       end
 
+      def shutdown!(&callback)
+        EventMachine.cancel_timer @next_beat if @next_beat
+        ProcessStatus.take!
+        remaining = count
+        if remaining > 0
+          each_value do |job|
+            job.shutdown! do
+              remaining -= 1
+              callback.call if callback && remaining == 0
+            end
+          end
+        else
+          callback.call if callback
+        end
+      end
+
+      def running_process_count
+        each_value.map(&:running_count).reduce(:+) || 0
+      end
+
       def job_descriptions
         configuration_files.values.inject({}) { |all, conf_file| all.merge! conf_file.job_descriptions }
       end

data/lib/epi/launch.rb

@@ -53,7 +53,7 @@ module Epi
 
     # 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}"
+      logger.info "Process #{pid} started: #{`ps -p #{pid} -o command=`.chomp}"
     end
   end
 end

data/lib/epi/logging.rb

@@ -0,0 +1,33 @@
+module Epi
+
+  class << self
+
+    DEFAULT_LEVEL = 'info'
+
+    def logger
+      @logger ||= make_logger
+    end
+
+    def logger=(value)
+      @logger = Logger === value ? value : make_logger(value)
+    end
+
+    private
+
+    def make_logger(target = nil)
+      Logger.new(target || ENV['EPI_LOG'] || default_log_path).tap do |logger|
+        logger.level = log_level
+      end
+    end
+
+    def default_log_path
+      Data.home.join('epi.log').to_s
+    end
+
+    def log_level
+      Logger::Severity.const_get (ENV['EPI_LOG_LEVEL'] || DEFAULT_LEVEL).upcase
+    end
+
+  end
+
+end

data/lib/epi/process_status.rb

@@ -63,7 +63,7 @@ module Epi
 
     def find_by_pid(pid)
       line = @lines[pid]
-      RunningProcess.new(pid, line) if line
+      RunningProcess.new(pid, ps_line: line) if line
     end
 
 

data/lib/epi/running_process.rb

@@ -42,10 +42,11 @@ module Epi
       Epi.logger
     end
 
-    def initialize(pid, ps_line = nil)
-      @pid = pid
+    def initialize(pid, ps_line: nil, job: nil)
+      @pid = pid.to_i
       @ps_line = ps_line
       @props = {}
+      @job = job
       reload! unless ps_line
     end
 
@@ -96,6 +97,12 @@ module Epi
       @started_at ||= Time.parse parts[5..9].join ' '
     end
 
+    # Duration the process has been running (in seconds)
+    # @return [Float]
+    def uptime
+      Time.now - started_at
+    end
+
     # Name of the user that owns the process
     # @return [String]
     def user
@@ -136,17 +143,28 @@ module Epi
       else
         signal = timeout ? 'KILL' : 'TERM'
         logger.info "Sending #{signal} to process #{pid}"
-        Process.kill signal, pid
+        Process.kill signal, pid rescue Errno::ESRCH false
         sleep 0.2 while `ps -p #{pid} > /dev/null 2>&1; echo $?`.chomp.to_i == 0
         logger.info "Process #{pid} terminated by signal #{signal}"
       end
       self
     end
 
+    # Kill a running process immediately and synchronously with kill -9
+    # @return [RunningProcess]
     def kill!
       kill true
     end
 
+    def job
+      @job ||= Jobs.by_pid[pid]
+    end
+
+    def restart!
+      raise Exceptions::Fatal, 'Cannot restart this process because it is not managed by a job' unless job
+      job.replace pid
+    end
+
     private
 
     def parts

data/lib/epi/trigger.rb

@@ -0,0 +1,53 @@
+module Epi
+  class Trigger
+
+    def self.make(job, name, args, handler)
+      klass_name = name.camelize
+      klass = Triggers.const_defined?(klass_name) && Triggers.const_get(klass_name)
+      raise Exceptions::Fatal, "No trigger exists named #{name}" unless Class === klass && klass < self
+      klass.new job, handler, *args
+    end
+
+    attr_reader :job, :args
+
+    def initialize(job, handler, *args)
+      @job = job
+      @handler = handler
+      @args = args
+    end
+
+    def logger
+      Epi.logger
+    end
+
+    def message
+      nil
+    end
+
+    def try
+      case self
+        when ProcessTrigger then job.running_processes.each_value { |process| try_with process }
+        when JobTrigger then try_with nil
+        else nil
+      end
+    end
+
+    def try_with(process)
+      args = [process].reject(&:nil?)
+      if test *args
+        text = "Trigger on job #{job.id}"
+        text << " (PID #{process.pid})" if process
+        text << ": " << message if message
+        logger.info text
+        @handler.call process || job
+      end
+    end
+
+    class JobTrigger < self; end
+    class ProcessTrigger < self; end
+
+  end
+end
+
+Dir[File.expand_path '../triggers/concerns/*.rb', __FILE__].each { |f| require f }
+Dir[File.expand_path '../triggers/*.rb', __FILE__].each { |f| require f }

data/lib/epi/triggers/concerns/comparison.rb

@@ -0,0 +1,43 @@
+module Epi
+  module Triggers
+    module Concerns
+      module Comparison
+
+        def compare(subject)
+          tester.call subject, object
+        end
+
+        private
+
+        def tester
+          @tester ||= choose_tester
+        end
+
+        def op
+          @op ||= args[0]
+        end
+
+        def object
+          @object ||= args[1]
+        end
+
+        def choose_tester
+          case op
+            when :gt then -> a, b { a > b }
+            when :lt then -> a, b { a < b }
+            when :gte then -> a, b { a >= b }
+            when :lte then -> a, b { a <= b }
+            when :eq then -> a, b { a == b }
+            when :not_eq then -> a, b { a != b}
+            when :match then -> a, b { a =~ b }
+            when :not_match then -> a, b { a !~ b }
+            when :like then -> a, b { a === b }
+            when :not_like then -> a, b { !(a === b) }
+            else raise Exceptions::Fatal, "Unknown operation #{op}"
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/epi/triggers/memory.rb

@@ -0,0 +1,16 @@
+module Epi
+  module Triggers
+    class Memory < Trigger::ProcessTrigger
+      include Concerns::Comparison
+
+      def test(process)
+        compare process.physical_memory
+      end
+
+      def message
+        "Physical memory exceeded #{object} bytes"
+      end
+
+    end
+  end
+end

data/lib/epi/triggers/touch.rb

@@ -0,0 +1,37 @@
+module Epi
+  module Triggers
+    class Touch < Trigger::JobTrigger
+
+      def initialize(*args)
+        super *args
+        update
+      end
+
+      def test
+        ino = @ino; mtime = @mtime
+        update
+        ino != @ino || mtime != @mtime
+      end
+
+      def message
+        "Path '#{path}' was touched"
+      end
+
+      private
+
+      def path
+        @path ||= Pathname args.first
+      end
+
+      def update
+        @ino, @mtime = begin
+          stat = path.stat
+          [stat.ino, stat.mtime]
+        rescue Errno::ENOENT
+          [nil, nil]
+        end
+      end
+
+    end
+  end
+end

data/lib/epi/triggers/uptime.rb

@@ -0,0 +1,12 @@
+module Epi
+  module Triggers
+    class Uptime < Trigger::ProcessTrigger
+      include Concerns::Comparison
+
+      def test(process)
+        compare process.uptime
+      end
+
+    end
+  end
+end

data/lib/epi/version.rb

@@ -1,3 +1,3 @@
 module Epi
-  VERSION = '0.0.1'
+  VERSION = '0.1.0'
 end

data/lib/epi.rb

@@ -3,10 +3,12 @@ require 'logger'
 require 'shellwords'
 
 require 'epi/core_ext'
+require 'epi/logging'
 require 'epi/exceptions'
 require 'epi/version'
 require 'epi/cli'
-require 'epi/server'
+require 'epi/connection'
+require 'epi/daemon'
 require 'epi/data'
 require 'epi/process_status'
 require 'epi/running_process'
@@ -15,38 +17,18 @@ require 'epi/jobs'
 require 'epi/configuration_file'
 require 'epi/job_description'
 require 'epi/launch'
+require 'epi/trigger'
 
 module Epi
   ROOT = Pathname File.expand_path('../..', __FILE__)
 
   class << self
 
-    def logger
-      @logger ||= make_logger
-    end
-
-    def logger=(value)
-      @logger = Logger === value ? value : make_logger(value)
-    end
-
     def root?
       @is_root = `whoami`.chomp == 'root' if @is_root.nil?
       @is_root
     end
 
-    private
-
-    def make_logger(target = nil)
-      Logger.new(target || ENV['EPI_LOG'] || STDOUT).tap do |logger|
-        logger.level = Logger::Severity::WARN
-        level = ENV['EPI_LOG_LEVEL']
-        if level
-          level = level.upcase
-          logger.level = Logger::Severity.const_get(level) if Logger::Severity.const_defined? level
-        end
-      end
-    end
-
   end
 
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: epi
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - Neil E. Pearson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-10-22 00:00:00.000000000 Z
+date: 2014-10-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: eventmachine
@@ -24,20 +24,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
-- !ruby/object:Gem::Dependency
-  name: bson
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.3'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.3'
 description: Manage your background processes
 email:
 - neil@helium.net.au
@@ -50,13 +36,29 @@ files:
 - lib/epi.rb
 - lib/epi/cli.rb
 - lib/epi/cli/command.rb
+- lib/epi/cli/commands/concerns/daemon.rb
 - lib/epi/cli/commands/config.rb
+- lib/epi/cli/commands/daemon.rb
+- lib/epi/cli/commands/help.rb
 - lib/epi/cli/commands/job.rb
-- lib/epi/cli/commands/server.rb
+- lib/epi/cli/commands/restart.rb
+- lib/epi/cli/commands/start.rb
 - lib/epi/cli/commands/status.rb
+- lib/epi/cli/commands/stop.rb
 - lib/epi/configuration_file.rb
+- lib/epi/connection.rb
 - lib/epi/core_ext.rb
 - lib/epi/core_ext/inflector.rb
+- lib/epi/daemon.rb
+- lib/epi/daemon/receiver.rb
+- lib/epi/daemon/responder.rb
+- lib/epi/daemon/responders/config.rb
+- lib/epi/daemon/responders/job.rb
+- lib/epi/daemon/responders/shutdown.rb
+- lib/epi/daemon/responders/start.rb
+- lib/epi/daemon/responders/status.rb
+- lib/epi/daemon/responders/stop_all.rb
+- lib/epi/daemon/sender.rb
 - lib/epi/data.rb
 - lib/epi/exceptions.rb
 - lib/epi/exceptions/base.rb
@@ -67,17 +69,14 @@ files:
 - lib/epi/job_description.rb
 - lib/epi/jobs.rb
 - lib/epi/launch.rb
+- lib/epi/logging.rb
 - lib/epi/process_status.rb
 - lib/epi/running_process.rb
-- lib/epi/server.rb
-- lib/epi/server/receiver.rb
-- lib/epi/server/responder.rb
-- lib/epi/server/responders/command.rb
-- lib/epi/server/responders/config.rb
-- lib/epi/server/responders/job.rb
-- lib/epi/server/responders/shutdown.rb
-- lib/epi/server/responders/status.rb
-- lib/epi/server/sender.rb
+- lib/epi/trigger.rb
+- lib/epi/triggers/concerns/comparison.rb
+- lib/epi/triggers/memory.rb
+- lib/epi/triggers/touch.rb
+- lib/epi/triggers/uptime.rb
 - lib/epi/version.rb
 homepage: https://github.com/hx/epi
 licenses:
@@ -104,3 +103,4 @@ signing_key:
 specification_version: 4
 summary: Epinephrine
 test_files: []
+has_rdoc: 

data/lib/epi/cli/commands/server.rb

@@ -1,38 +0,0 @@
-module Epi
-  module Cli
-    module Commands
-      class Server < Command
-
-        def run
-          process = Epi::Server.process
-          raise Exceptions::Fatal, 'You need root privileges to manage this server' if
-              process && process.was_alive? && process.root? && !Epi.root?
-          case args.first
-            when nil, 'start' then startup
-            when 'run' then run_server
-            when 'stop' then shutdown
-            else raise Exceptions::Fatal, 'Unknown server command, use [ start | stop | restart ]'
-          end
-        end
-
-        private
-
-        def startup
-          Epi::Server.ensure_running
-          puts 'Server is running'
-        end
-
-        def shutdown
-          Epi::Server.shutdown
-          puts 'Server has shut down'
-        end
-
-        def run_server
-          Epi::Server.run
-          puts 'Server is running'
-        end
-
-      end
-    end
-  end
-end