ziltoid 1.0.1 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: dcb27a64e424602045c22c62ffa2d1f272d0113f
-  data.tar.gz: c3cd9add836c7460ef1c91feded47f5300b47bff
+  metadata.gz: 20d41ee7c21c5543faea2a88d7cabc1ab9636abd
+  data.tar.gz: 85dc0a7c9005ef96c15d66874d096c23eade24f3
 SHA512:
-  metadata.gz: 8acc9991ab54b8b22af355f32089e1097ce2e1101c0670b4f9979176560abd155ff56ff61bfd53f8974a01576677af83f668fd23e8def0513048bfb52f9b0958
-  data.tar.gz: cd56cf1a67d3b8199df6baeed68cad43c86ddd4c0beb53037b4c9ba7a78f547239e830f15f16eeb968be9daddc039e6bdacdab103a9a43300e3b003c558160a4
+  metadata.gz: 148418049387dc672aa32aeec694f009c250ce0ec7ba2aa0232a353d32fe6c56c936a9b568a00bb1062db0866f76ef28644d2c64858581d24ee9c555bf8eb88e
+  data.tar.gz: b3028c71a803a81e6361d822c9a738b22966e0127641dad6b9c6295f2093fe1befe7b542d0c147f7031d459b0d6b29ee7bbcfa96a287181e79c10f62ca05184f

data/lib/ziltoid/command_parser.rb

@@ -0,0 +1,53 @@
+require 'ostruct'
+require 'optparse'
+
+module Ziltoid
+  class CommandParser
+
+    ALLOWED_COMMANDS = ["watch", "start", "stop", "restart"]
+
+    # Returns a structure describing the options.
+    def self.parse(args)
+      runnable = OpenStruct.new
+
+      helptext = <<-HELP
+        Available commands are :
+           watch :       watches all processes
+           start :       starts all processes
+           stop  :       stops all processes
+           restart :     restarts all processes
+      HELP
+
+      opt_parser = OptionParser.new do |opts|
+        # Printing generic help at the top of commands summary
+        opts.banner = "Usage: ziltoid.rb [options]"
+        opts.separator ""
+        opts.separator helptext
+        opts.separator ""
+        opts.separator "Common options :"
+
+        # No argument, shows at tail. This will print a commands summary.
+        opts.on_tail("-h", "--help", "Show this message") do
+          puts opts
+          exit
+        end
+      end
+
+      # Retrieves all arguments except option-like ones (e.g. '-h' or '-v')
+      opt_parser.parse!(args)
+      # Fetches the first argument as the intended command
+      command = args.shift
+
+      # Making sure the command is valid, otherwise print commands summary
+      if command && ALLOWED_COMMANDS.include?(command)
+        runnable.command = command
+      else
+        puts opt_parser.help
+        exit
+      end
+
+      runnable
+    end  # parse()
+
+  end
+end

data/lib/ziltoid/email_notifier.rb

@@ -0,0 +1,24 @@
+require 'pony'
+
+module Ziltoid
+  class EmailNotifier
+    attr_accessor :via_options, :from, :to, :subject
+
+    def initialize(options)
+      self.via_options = options[:via_options]
+      self.to = options[:to]
+      self.from = options[:from]
+      self.subject = options[:subject]
+    end
+
+    def send(message)
+      Pony.mail(
+        :to => self.to,
+        :via => :smtp,
+        :via_options => self.via_options,
+        :from => self.from,
+        :subject => self.subject, :body => message
+      )
+    end
+  end
+end

data/lib/ziltoid/process.rb

@@ -0,0 +1,182 @@
+module Ziltoid
+  class Process
+    attr_accessor :name, :ram_limit, :cpu_limit, :start_command, :stop_command, :restart_command, :pid_file, :start_grace_time, :stop_grace_time, :ram_grace_time, :cpu_grace_time, :restart_grace_time
+
+    WAIT_TIME_BEFORE_CHECK = 1.0
+    ALLOWED_STATES = ["started", "stopped", "restarted", "above_cpu_limit", "above_ram_limit"]
+    PREDOMINANT_STATES = ["started", "stopped", "restarted"]
+
+    def initialize(name, options = {})
+      self.name = name
+      self.ram_limit = options[:limit] ? options[:limit][:ram] : nil
+      self.cpu_limit = options[:limit] ? options[:limit][:cpu] : nil
+      self.pid_file = options[:pid_file] || "~/.ziltoid/#{name}.pid"
+
+      if options[:commands]
+        self.start_command = options[:commands][:start] || nil
+        self.stop_command = options[:commands][:stop] || nil
+        self.restart_command = options[:commands][:restart] || nil
+      end
+
+      if options[:grace_times]
+        self.start_grace_time = options[:grace_times][:start] || 0
+        self.stop_grace_time = options[:grace_times][:stop] || 0
+        self.restart_grace_time = options[:grace_times][:restart] || 0
+        self.ram_grace_time = options[:grace_times][:ram] || 0
+        self.cpu_grace_time = options[:grace_times][:cpu] || 0
+      end
+    end
+
+    def pid
+      if self.pid_file && File.exist?(self.pid_file)
+        str = File.read(pid_file)
+        str.to_i if str.size > 0
+      end
+    end
+
+    def alive?
+      Ziltoid::System.pid_alive?(self.pid)
+    end
+
+    def dead?
+      !alive?
+    end
+
+    def remove_pid_file
+      if self.pid_file && File.exist?(self.pid_file)
+        File.delete(self.pid_file)
+      end
+    end
+
+    def above_cpu_limit?(include_children = true)
+      Ziltoid::System.cpu_usage(self.pid, include_children) > self.cpu_limit.to_f
+    end
+
+    def above_ram_limit?(include_children = true)
+      Ziltoid::System.ram_usage(self.pid, include_children) > self.ram_limit.to_i * 1024
+    end
+
+    def state
+      state_hash = Ziltoid::Watcher.read_state[self.name]
+      state_hash["state"] if state_hash
+    end
+
+    def updated_at
+      state_hash = Ziltoid::Watcher.read_state[self.name]
+      state_hash["updated_at"] if state_hash
+    end
+
+    def processable?(target_state)
+      current_state = self.state
+      # started, stopped and restarted are 'predominant' current states,
+      # we never proceed unless the corresponding grace time is over
+      Watcher.log("Current state : #{current_state} - updated_at : #{self.updated_at.to_i} - target_state : #{target_state}")
+      return false if pending_grace_time?
+      return true if PREDOMINANT_STATES.include?(target_state)
+
+      # above_cpu_limit and above_ram_limit grace times are different,
+      # they represent a time a process has to be in that state to actually be processed (restarted most likely)
+      case target_state
+      when "above_cpu_limit"
+        current_state == target_state && self.updated_at.to_i < Time.now.to_i - self.cpu_grace_time.to_i
+      when "above_ram_limit"
+        current_state == target_state && self.updated_at.to_i < Time.now.to_i - self.ram_grace_time.to_i
+      end
+    end
+
+    def pending_grace_time?
+      current_state = self.state
+      PREDOMINANT_STATES.include?(current_state) && self.updated_at.to_i > Time.now.to_i - self.send("#{current_state.gsub(/p?ed/, '')}_grace_time").to_i
+    end
+
+    def update_state(state)
+      process_states = Ziltoid::Watcher.read_state
+      return nil unless ALLOWED_STATES.include?(state)
+      memoized_process_state = process_states[self.name]
+
+      process_states[self.name] = {
+        "state" => state,
+        "updated_at" => memoized_process_state && memoized_process_state["state"] == state ? memoized_process_state["updated_at"].to_i : Time.now.to_i
+      }
+      Ziltoid::Watcher.write_state(process_states)
+    end
+
+    def watch!
+      Watcher.log("Ziltoid is watching process #{self.name}")
+      if !alive?
+        Watcher.log("Process #{self.name} is dead", Logger::WARN)
+        return start!
+      end
+      if above_cpu_limit?
+        update_state("above_cpu_limit") unless pending_grace_time?
+        if processable?("above_cpu_limit")
+          Watcher.log("Process #{self.name} is above CPU limit (#{self.cpu_limit.to_f})", Logger::WARN)
+          return restart!
+        end
+      end
+      if above_ram_limit?
+        update_state("above_ram_limit") unless pending_grace_time?
+        if processable?("above_ram_limit")
+          Watcher.log("Process #{self.name} is above RAM limit (#{self.ram_limit.to_f})", Logger::WARN)
+          return restart!
+        end
+      end
+    end
+
+    def start!
+      return if Ziltoid::System.pid_alive?(self.pid)
+      return unless processable?("started")
+
+      Watcher.log("Ziltoid is starting process #{self.name}", Logger::WARN)
+      remove_pid_file
+      system(self.start_command)
+      update_state("started")
+    end
+
+    def stop!
+      return unless processable?("stopped")
+
+      Watcher.log("Ziltoid is stoping process #{self.name}", Logger::WARN)
+      memoized_pid = self.pid
+
+      if dead?
+        remove_pid_file
+      else
+
+        Thread.new do
+          system(self.stop_command)
+          sleep(WAIT_TIME_BEFORE_CHECK)
+          if alive?
+            system("kill #{memoized_pid}")
+            sleep(WAIT_TIME_BEFORE_CHECK)
+            if alive?
+              system("kill -9 #{memoized_pid}")
+              sleep(WAIT_TIME_BEFORE_CHECK)
+            end
+          end
+          if dead?
+            remove_pid_file
+            update_state("stopped")
+          end
+        end.join
+
+      end
+    end
+
+    def restart!
+      return unless processable?("restarted")
+
+      Watcher.log("Ziltoid is restarting process #{self.name}", Logger::WARN)
+      alive = self.alive?
+
+      if alive && self.restart_command
+        update_state("restarted")
+        return system("#{self.restart_command}")
+      end
+
+      stop! if alive
+      return start!
+    end
+
+  end
+end

data/lib/ziltoid/system.rb

@@ -0,0 +1,77 @@
+module Ziltoid
+
+  module System
+
+    # The position of each field in ps output
+    PS_FIELDS = [:pid, :ppid, :cpu, :ram]
+
+    module_function
+
+    def pid_alive?(pid)
+      return false if pid.nil?
+      begin
+        ::Process.kill(0, pid)
+        true
+      rescue Errno::EPERM # no permission, but it is definitely alive
+        true
+      rescue Errno::ESRCH
+        false
+      end
+    end
+
+    def ps_aux
+      # BSD style ps invocation
+      processes = `ps axo pid,ppid,pcpu,rss`.split("\n")
+
+      processes.inject({}) do |result, process|
+        info = process.split(/\s+/)
+        info.delete_if { |p_info| p_info.strip.empty? }
+        info.map! { |p_info| p_info.gsub(",", ".") }
+
+        info = PS_FIELDS.each_with_index.inject({}) do |info_hash, (field, field_index)|
+          info_hash[field] = info[field_index]
+          info_hash
+        end
+
+        pid = info[:pid].strip.to_i
+        result[pid] = info
+        result
+      end
+    end
+
+    def cpu_usage(pid, include_children = true)
+      ps = ps_aux
+      return unless ps[pid]
+      cpu_used = ps[pid][:cpu].to_f
+
+      get_children(pid).each do |child_pid|
+        cpu_used += ps[child_pid][:cpu].to_f if ps[child_pid]
+      end if include_children
+
+      cpu_used
+    end
+
+    def ram_usage(pid, include_children = true)
+      ps = ps_aux
+      return unless ps[pid]
+      mem_used = ps[pid][:ram].to_i
+
+      get_children(pid).each do |child_pid|
+        mem_used += ps[child_pid][:ram].to_i if ps[child_pid]
+      end if include_children
+
+      mem_used
+    end
+
+    def get_children(parent_pid)
+      child_pids = []
+      ps_aux.each_pair do |_pid, info|
+        child_pids << info[:pid].to_i if info[:ppid].to_i == parent_pid.to_i
+      end
+      grand_children = child_pids.map { |pid| get_children(pid) }.flatten
+      child_pids.concat grand_children
+    end
+
+  end
+
+end

data/lib/ziltoid/watcher.rb

@@ -0,0 +1,108 @@
+require "logger"
+require "json"
+
+module Ziltoid
+  class Watcher
+    attr_accessor :watchlist
+
+    def initialize(options = {})
+      self.watchlist ||= {}
+      @@logger = options[:logger] || Logger.new($stdout)
+      @@logger.progname = options[:progname] || "Ziltoid"
+      @@logger.level = options[:log_level] || Logger::INFO
+      @@notifiers = options[:notifiers] if options[:notifiers]
+      @@state_file = options[:state_file] || File.join(File.dirname(__FILE__), "..", "state.ziltoid")
+    end
+
+    def add(watchable)
+      self.watchlist[watchable.name] = watchable
+    end
+
+    def logger
+      Ziltoid::Watcher.logger
+    end
+
+    def self.logger
+      @@logger
+    end
+
+    def notifiers
+      Ziltoid::Watcher.notifiers
+    end
+
+    def self.notifiers
+      @@notifiers ||= []
+      return @@notifiers
+    end
+
+    def self.log(message, level = Logger::INFO)
+      @@logger ||= Logger.new($stdout)
+      @@logger.add(level, message)
+      if level > Logger::INFO
+        self.notifiers.each do |n|
+          n.send(message)
+        end
+      end
+    end
+
+    def state_file
+      Ziltoid::Watcher.state_file
+    end
+
+    def self.state_file
+      @@state_file
+    end
+
+    def self.read_state
+      json = File.read(state_file) if File.exist?(state_file)
+      json = "{}" if json.nil? || json.empty?
+      JSON.load(json)
+    end
+
+    def self.write_state(state = {})
+      File.open(state_file, "w+") do |file|
+        file.puts JSON.generate(state)
+      end
+    end
+
+    def run!(command = :watch)
+      watchlist.values.each do |watchable|
+        watchable.send("#{command}!".to_sym)
+      end
+    end
+
+    def watch!
+      Watcher.log("Ziltoid is now on duty : watching all watchables !")
+      run!(:watch)
+    end
+
+    def start!
+      Watcher.log("Ziltoid is now on duty : all watchables starting !")
+      run!(:start)
+    end
+
+    def stop!
+      Watcher.log("Ziltoid is now on duty : all watchables stoping !")
+      run!(:stop)
+    end
+
+    def restart!
+      Watcher.log("Ziltoid is now on duty : all watchables restarting !")
+      run!(:restart)
+    end
+
+    def run(command = :watch)
+      case command
+      when :watch
+        watch!
+      when :start
+        start!
+      when :stop
+        stop!
+      when :restart
+        restart!
+      end
+    end
+
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ziltoid
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.0.2
 platform: ruby
 authors:
 - Stéphane Akkaoui
@@ -10,17 +10,25 @@ autorequire:
 bindir: bin
 cert_chain: []
 date: 2018-08-06 00:00:00.000000000 Z
-dependencies: []
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: pony
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
 description: |2
     There are many software applications that aim to watch processes, and keep them alive and clean. Some of them are well known: god, monit, bluepill.
     All have good and bad sides. One of the bad sides is that each alternative is based on a deamon that computes data and then sleeps for a while. Who is monitoring this particular deamon ? What if this process suddenly stops ? Also, you often need root rights to run those tools. On some hosting environments (mainly in shared hosting), this is an issue.
-
-    Ziltoid is an attempt to solve those issues using the crontab system, which comes with many good sides :
-   - it's on every system
-   - it launches a task periodically then waits for an amount of time
-   - it doesn't need monitoring
-   - it can send emails to warn of an error
-   - and it can run any script.
+    Ziltoid is an attempt to solve those issues using the crontab system, which comes with many good sides : it's on every system, it launches a task periodically then waits for an amount of time, it doesn't need monitoring, it can send emails to warn of an error and it can run any script.
 email:
 - sakkaoui@gmail.com
 - vincent.gabou@gmail.com>
@@ -29,6 +37,11 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/ziltoid.rb
+- lib/ziltoid/command_parser.rb
+- lib/ziltoid/email_notifier.rb
+- lib/ziltoid/process.rb
+- lib/ziltoid/system.rb
+- lib/ziltoid/watcher.rb
 homepage: https://github.com/meuble/ziltoid
 licenses:
 - WTFPL