ziltoid 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 77f322004f95c4414b3364d2f5197ffda8b7dfd4
+  data.tar.gz: b47765f8f8d5484e7a70e6dd9a94e6b59242aa14
+SHA512:
+  metadata.gz: 3c21b057c2abbe9c46c2b1227bd84ab2e8eea66d8852220e5421b163e98eb97c485ce20e7f9fe812c670e3e98dac881707debb35494062206917164ef6aeedf4
+  data.tar.gz: 22f3f11346e327a60d813098d71e6ca254117f126390ffecb791df8c0125f8808f9f6a218b6b97aecf6a330b400efd46e22e0baa999c5a5453e4f2217167e4dd

data/README.md

@@ -0,0 +1,107 @@
+# ziltoid
+
+Cron based monitoring system.
+
+There are many softwares that aim to watch processes, keeping them alive and clean. Some of them are well known : 
+ - god (http://godrb.com)
+ - monit (http://mmonit.com/monit/)
+ - bluepill (https://github.com/bluepill-rb/bluepill)
+ - ... (https://www.ruby-toolbox.com/categories/server_monitoring)
+
+All have good and bad sides.
+One of the bad side is that each alternative is based on a deamon that compute data and then sleeps for a while. Who is monitoring this particular deamon ? What if this process suddenly stop ?
+Also, you often need root right 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. 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 a an error, and can run any script.
+
+## Usage
+
+The principle of Ziltoid is to use the crontab system. You need to create a script that monitor your processes and then configure it in your crontab to run as frequently as possible (every minutes) :
+
+    * * * * * /bin/bash -l -c 'ruby /path_to_ziltoid.rb'
+
+Ziltoid is here to help you build this script.
+
+### Process
+
+It encapsulates a process and everything Ziltoid might need to monitor it :
+ - start, stop en restart commands
+ - pid file path
+ - RAM and CPU limits
+ 
+You define one like so :
+
+```ruby
+    Ziltoid::Process.new("Lighty", {
+      :pid_file => "/home/ror/http/tmp/lighttpd.pid",
+      :commands => {
+        :start => "/home/ror/bin/lighty start",
+        :stop => "/home/ror/bin/lighty stop"
+      },
+      :limit => {
+        :ram => 256,
+        :cpu => 10
+      }
+    })
+```
+
+Processes are seen as `watchables` by Ziltoid. You can build your own watchable objects and passe them to Ziltoid, as long you can call the following methods on them :
+ - `start`
+ - `stop`
+ - `restart`
+ - `watch`
+
+### Email Notifier
+
+This is a wrapper to email notifications. Every log message of a level higher than Logger::INFO will be sent by email.
+
+You can configure a mail like so :
+
+```ruby
+    Ziltoid::EmailNotifier.new(
+      :via_options => {
+        :address        => 'smtp.ziltoid.com',
+        :port           => '25',
+        :domain         => "ziltoid.com"
+      },
+      :subject => "[Balloonz] Ziltoid message",
+      :to => ['developers@sociabliz.com'],
+      :from => 'ziltoidd@ziltoid.com'
+    )
+```
+
+The `via_options` accept every options supported by the [pony](https://github.com/benprew/pony) library.
+
+You can build your own notifiers (for IRC, XMPP, BaseCamp, Redmine, ....) as long as it respond to the `send` method. This method receives a `message` parameter which is the message to be sent.
+
+### Watcher
+
+This is the main object of Ziltoid. You can think of it as a container. With this container, you plug in a Logger, a Notifier and as many watchables as you want. Then, you run the commande of your choice.
+
+Commands are :
+ - `start`: to start watchable items
+ - `stop`: to stop watchable items
+ - `restart`: to restart watchable items
+ - `watch`: to watch watchable items. IE start them if dead, restart them if of limits
+
+You can see a sample Ziltoid script in the `exemple` folder.
+
+## Drawbacks
+
+Ziltoid is not yet complet. We are working on other watchables, like disk usage and RAM usage.
+We also want to work on a grace system, where we don't count the RAM and CPU at start of process, and where we wait for a certain number of off-limit mesures to restart a process (and allow burst).
+
+One of the bad point of the crontab system is that it doesn't run under the minute. But we think that if our system can't handle a dead process for a minute, there is an issue somewhere (in replication, sizing, ...).
+
+## About Ziltoid
+
+It comes from Devin Townsen famous album "Ziltoid the omniscient".
+Ziltoid is omniscient, watches everything and control everything. Even processes.
+
+Ziltoid is given to you by [The Social Client](http://www.thesocialclient.com), a digital and CRM consultant agency.
+
+## Licencing
+
+Ziltoid is a [Beerware](http://en.wikipedia.org/wiki/Beerware) and is licensed under the terms of the [WTFPL](http://www.wtfpl.net), see the included WTFPL-LICENSE file.
+
+If we meet some day, and you think this stuff is worth it, you can buy us a beer in return.

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,106 @@
+module Ziltoid
+  class Process
+    attr_accessor :name, :ram_limit, :cpu_limit, :start_command, :stop_command, :restart_command, :pid_file
+
+    WAIT_TIME_BEFORE_CHECK = 1.0
+
+    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
+    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 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?
+        Watcher.log("Process #{self.name} is above CPU limit (#{self.cpu_limit.to_f})", Logger::WARN)
+        return restart!
+      end
+      if above_ram_limit?
+        Watcher.log("Process #{self.name} is above RAM limit (#{self.ram_limit.to_f})", Logger::WARN)
+        return restart!
+      end
+    end
+
+    def start!
+      return if Ziltoid::System.pid_alive?(self.pid)
+      Watcher.log("Ziltoid is starting process #{self.name}", Logger::WARN)
+      remove_pid_file
+      %x(#{self.start_command})
+    end
+
+    def stop!
+      Watcher.log("Ziltoid is stoping process #{self.name}", Logger::WARN)
+      memoized_pid = self.pid
+
+      if dead?
+        remove_pid_file
+      else
+
+        thread = Thread.new do
+          %x(#{self.stop_command})
+          sleep(WAIT_TIME_BEFORE_CHECK)
+          if alive?
+            %x(kill #{memoized_pid})
+            sleep(WAIT_TIME_BEFORE_CHECK)
+            if alive?
+              %x(kill -9 #{memoized_pid})
+              sleep(WAIT_TIME_BEFORE_CHECK)
+            end
+          end
+          remove_pid_file if dead?
+        end.join
+
+      end
+    end
+
+    def restart!
+      Watcher.log("Ziltoid is restarting process #{self.name}", Logger::WARN)
+      alive = self.alive?
+      return %x(#{self.restart_command}) if alive && self.restart_command
+      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,86 @@
+require "logger"
+
+module Ziltoid
+  class Watcher
+    attr_accessor :watchlist
+
+    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 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]
+    end
+
+    def add(watchable)
+      self.watchlist[watchable.name] = watchable
+    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

data/lib/ziltoid.rb

@@ -0,0 +1,3 @@
+Dir.glob(File.join(File.dirname(__FILE__), 'ziltoid', '**')).each do |lib|
+  require "#{lib}"
+end

data/ziltoid.gemspec

@@ -0,0 +1,15 @@
+Gem::Specification.new do |s|
+  s.name        = 'ziltoid'
+  s.version     = '1.0.0'
+  s.date        = '2014-12-22'
+  s.summary     = "Ziltoid, crontab based monitoring system"
+  s.description = "Ziltoid, crontab based monitoring system"
+  s.authors     = ["Stéphane Akkaoui", "Vincent Gabou"]
+  s.email       = 'developers@sociabliz.com'
+  s.files       = %w(README.md ziltoid.gemspec) + Dir['lib/**/*.rb']
+  s.add_dependency 'pony'
+
+  s.homepage    =
+    'http://github.com/meuble/ziltoid'
+  s.license       = 'WTFPL'
+end

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification
+name: ziltoid
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Stéphane Akkaoui
+- Vincent Gabou
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-12-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: pony
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Ziltoid, crontab based monitoring system
+email: developers@sociabliz.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- 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
+- ziltoid.gemspec
+homepage: http://github.com/meuble/ziltoid
+licenses:
+- WTFPL
+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.4.2
+signing_key: 
+specification_version: 4
+summary: Ziltoid, crontab based monitoring system
+test_files: []