ziltoid 1.0.0 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 77f322004f95c4414b3364d2f5197ffda8b7dfd4
-  data.tar.gz: b47765f8f8d5484e7a70e6dd9a94e6b59242aa14
+  metadata.gz: dcb27a64e424602045c22c62ffa2d1f272d0113f
+  data.tar.gz: c3cd9add836c7460ef1c91feded47f5300b47bff
 SHA512:
-  metadata.gz: 3c21b057c2abbe9c46c2b1227bd84ab2e8eea66d8852220e5421b163e98eb97c485ce20e7f9fe812c670e3e98dac881707debb35494062206917164ef6aeedf4
-  data.tar.gz: 22f3f11346e327a60d813098d71e6ca254117f126390ffecb791df8c0125f8808f9f6a218b6b97aecf6a330b400efd46e22e0baa999c5a5453e4f2217167e4dd
+  metadata.gz: 8acc9991ab54b8b22af355f32089e1097ce2e1101c0670b4f9979176560abd155ff56ff61bfd53f8974a01576677af83f668fd23e8def0513048bfb52f9b0958
+  data.tar.gz: cd56cf1a67d3b8199df6baeed68cad43c86ddd4c0beb53037b4c9ba7a78f547239e830f15f16eeb968be9daddc039e6bdacdab103a9a43300e3b003c558160a4

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ziltoid
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.0.1
 platform: ruby
 authors:
 - Stéphane Akkaoui
@@ -9,57 +9,50 @@ authors:
 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
+date: 2018-08-06 00:00:00.000000000 Z
+dependencies: []
+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.
+email:
+- sakkaoui@gmail.com
+- vincent.gabou@gmail.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
+homepage: https://github.com/meuble/ziltoid
 licenses:
 - WTFPL
-metadata: {}
+metadata:
+  bug_tracker_uri: https://github.com/meuble/ziltoid/issues
+  homepage_uri: https://github.com/meuble/ziltoid
+  source_code_uri: https://github.com/meuble/ziltoid
 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
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Ziltoid, crontab based monitoring system

data/README.md

@@ -1,107 +0,0 @@
-# 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

@@ -1,53 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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

@@ -1,106 +0,0 @@
-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

@@ -1,77 +0,0 @@
-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

@@ -1,86 +0,0 @@
-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/ziltoid.gemspec

@@ -1,15 +0,0 @@
-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