eznemo 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 14365e43e3184d7e2a7d8978b8a8c4fe76d57596
+  data.tar.gz: 2d7ca0b5a7fe4f8acdc9b2fa0a87020497b85317
+SHA512:
+  metadata.gz: a75aa47b2879c4e018d1613f07db5f604831985d5e3b9b0d2f629ad0e78ad7049305af989f8c9aceb3dda1a5f7b3c31619bfe76eb40e822c9373abef741fe149
+  data.tar.gz: 452ce77dbd521523f4c7ecd417a6554f1c7d55026b4dcd53cfdc5d0ce855e4a6d9292c27c9767a826546d83b769d7c5d10356064dbeb937f72d9a12904dfa231

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Ken J.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

data/README.md

@@ -0,0 +1,112 @@
+# eznemo
+
+A Ruby gem. It's a simple monitoring engine and stores results in a database. Runs on EventMachine.
+
+For reports and alerts, analyze the results in the database.
+
+## Requirements
+
+- Ruby 2.0.0 <=
+- eventmachine 1.0 <=
+
+### Data Storage Options
+
+Currently, only support MySQL, so you'll also need the following gem:
+
+- mysql2 0.4 <=
+
+## Getting Started
+
+### Install
+
+```
+$ gem install eznemo
+```
+
+### Use
+
+```
+$ eznemo start -c config.yml
+```
+
+### Examples
+
+Config file.
+
+```yaml
+---
+:datastore:
+  :type: :mysql
+  :options:
+    :host: '127.0.0.1'
+    :username: 'user'
+    :password: 'paSsw0rd'
+    :database: 'eznemo'
+:checks:
+  :tags:
+    - tag1
+    - tag2
+:monitor:
+    :path: '/bin/ping'
+    :min_interval: 10
+    :timeout: 5
+    :cmd_opts: '-s 102'
+```
+
+## Data Structure
+
+### Checks
+
+```ruby
+{
+  id: 123,   # auto_increment
+  name: 'Check name',
+  hostname: '192.168.0.111',
+  interval: 60,   # frequecy this check is run in seconds
+  type: 'ping',   # or other monitor plugin name
+  state: true,   # true means active
+  tags: '["tag1", "tag2"]',
+  options: '-S 192.168.0.11'
+}
+```
+
+### Results
+
+```ruby
+{
+  check_id: 123,   # from checks
+  timestamp: '2016-04-01 10:00:00 -07:00',
+  status: true,   # true means OK
+  response_ms: 0.012,   # in milliseconds
+  status_desc: 'OK'   # short description of the result
+}
+```
+
+### MySQL
+
+```sql
+CREATE TABLE `checks` (
+  `id` int(11) unsigned NOT NULL AUTO_INCREMENT,
+  `name` varchar(255) NOT NULL DEFAULT '',
+  `hostname` varchar(255) NOT NULL DEFAULT '',
+  `interval` int(11) NOT NULL,
+  `type` varchar(255) NOT NULL DEFAULT '',
+  `state` tinyint(1) NOT NULL,
+  `tags` text,
+  `options` text,
+  PRIMARY KEY (`id`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8;
+
+CREATE TABLE `results` (
+  `id` int(11) NOT NULL AUTO_INCREMENT,
+  `check_id` int(11) NOT NULL,
+  `timestamp` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  `status` tinyint(1) NOT NULL,
+  `response_ms` float NOT NULL DEFAULT '0',
+  `status_desc` varchar(255) NOT NULL DEFAULT '',
+  PRIMARY KEY (`id`),
+  KEY `check_id` (`check_id`),
+  KEY `timestamp` (`timestamp`),
+  KEY `status` (`status`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8;
+```

data/bin/eznemo

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+require 'kajiki'
+require 'eznemo'
+
+
+opts = Kajiki.preset_options(:simple, {config: true})
+
+Kajiki.run(opts) do |cmd|
+  case cmd
+  when 'start'
+    EzNemo::Reactor.run!(opts)
+  end
+end

data/eznemo.gemspec

@@ -0,0 +1,23 @@
+$LOAD_PATH.unshift(File.expand_path('../lib', __FILE__))
+require 'eznemo/version'
+
+
+Gem::Specification.new do |s|
+  s.name          = 'eznemo'
+  s.version       = EzNemo::Version
+  s.authors       = ['Ken J.']
+  s.email         = ['kenjij@gmail.com']
+  s.description   = %q{Simple network monitoring}
+  s.summary       = %q{Simple network monitoring implemented with Ruby.}
+  s.homepage      = 'https://github.com/kenjij/eznemo'
+  s.license       = 'MIT'
+
+  s.files         = `git ls-files`.split($/)
+  s.executables   = s.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  s.require_paths = ['lib']
+
+  s.required_ruby_version = '>= 2.0.0'
+
+  s.add_runtime_dependency 'kajiki', '~> 1.1'
+  s.add_runtime_dependency 'eventmachine', '~> 1.0'
+end

data/lib/eznemo/config.rb

@@ -0,0 +1,18 @@
+require 'yaml'
+
+module EzNemo
+
+  # Load YAML config file
+  # @param path [String] config file
+  # @return [Object] config; a shared instance
+  def self.load_config(path)
+    raise 'config file missing' unless path
+    @config ||= YAML.load_file(path)
+  end
+
+  # see #self.load_config
+  def self.config
+    @config
+  end
+
+end

data/lib/eznemo/datastore.rb

@@ -0,0 +1,15 @@
+module EzNemo
+
+  # @return [Object] data storage object; a shared instance
+  def self.datastore
+    @datastore ||= DataStore.new
+  end
+
+  # Storage for checks and results
+  class DataStore
+
+    include EzNemo::StorageAdapter
+
+  end
+
+end

data/lib/eznemo/monitor/ping.rb

@@ -0,0 +1,115 @@
+module EzNemo
+
+  # ICMP ping plugin
+  class Ping
+
+    DEFAULT_MIN_INTERVAL = 10
+    DEFAULT_TIMEOUT = 5
+
+    attr_reader :monitor
+    attr_reader :config
+
+    def initialize
+      os = RbConfig::CONFIG['host_os']
+      case
+      when os.include?('darwin')
+        @os = 'bsd'
+      when os.include?('linux')
+        @os = 'linux'
+      end
+    end
+
+    # Gets called by Monitor at regisration
+    # @return [Symbol]
+    def name
+      return :ping
+    end
+
+    # Gets called by Monitor after regisration
+    # @param mon [Object] parent Monitor object
+    def registered(mon)
+      @monitor = mon
+      @config = EzNemo.config[:monitor][:ping] if EzNemo.config[:monitor]
+      @config ||= {}
+      @config[:path] ||= 'ping'
+      @config[:min_interval] ||= DEFAULT_MIN_INTERVAL
+      @config[:timeout] ||= DEFAULT_TIMEOUT
+    end
+
+    # Add a check using this plugin
+    # @param check [Hash]
+    def add_check(check)
+      min = config[:min_interval]
+      check[:interval] = min if check[:interval] < min
+      EM.add_periodic_timer(check[:interval]) do
+        self.send("#{@os}_ping", check)
+      end
+    end
+
+    def linux_ping(check)
+      result = {
+        timestamp: Time.now,
+        check_id: check[:id]
+      }
+      path = config[:path]
+      timeout = config[:timeout]
+      options = "#{config[:cmd_opts]} #{check[:options]}"
+      hostname = check[:hostname]
+      cmd = "#{path} -c 1 -nqW #{timeout} #{options} #{hostname}"
+      EM.system(cmd) do |output, status|
+        case status.exitstatus
+        when 0
+          expr = /=\s*([0-9\.]+)/
+          expr =~ output
+          result[:status] = 1
+          result[:response_ms] = $1.to_f
+          result[:status_desc] = 'OK'
+        when 1
+          result[:status] = 0
+          result[:response_ms] = 0
+          result[:status_desc] = 'NG'
+        else
+          output = 'see log' if output.nil? || output.size == 0
+          result[:status] = 0
+          result[:response_ms] = 0
+          result[:status_desc] = "ERROR: #{output}".chomp
+        end
+        monitor.report(result)
+      end
+    end
+
+    def bsd_ping(check)
+      result = {
+        timestamp: Time.now,
+        check_id: check[:id]
+      }
+      timeout = config[:timeout] * 1000
+      options = "#{config[:cmd_opts]} #{check[:option]}"
+      hostname = check[:hostname]
+      cmd = "#{path} -c 1 -nqW #{timeout} #{options} #{hostname}"
+      EM.system(cmd) do |output, status|
+        case status.exitstatus
+        when 0
+          expr = /=\s*([0-9\.]+)/
+          expr =~ output
+          result[:status] = 1
+          result[:response_ms] = $1.to_f
+          result[:status_desc] = 'OK'
+        when 2
+          result[:status] = 0
+          result[:response_ms] = 0
+          result[:status_desc] = 'NG'
+        else
+          result[:status] = 0
+          result[:response_ms] = 0
+          result[:status_desc] = "ERROR: #{output}".chomp
+        end
+        monitor.report(result)
+      end
+    end
+
+  end
+
+  monitor.register(Ping.new)
+
+end

data/lib/eznemo/monitor.rb

@@ -0,0 +1,50 @@
+require 'json'
+
+module EzNemo
+
+  # The shared Monitor instance
+  # @return [EzNemo::Monitor]
+  def self.monitor
+    @monitor ||= Monitor.new
+  end
+
+  # Maintains an array of all the monitor plugins
+  class Monitor
+
+    def initialize
+      @plugins = {}
+    end
+
+    # Registers a plugin; usually called by the plugin itself
+    # @param plugin [Object]
+    def register(plugin)
+      @plugins[plugin.name] = plugin
+      plugin.registered(self)
+    end
+
+    # Starts check loops in the reactor
+    # @param checks [Array<Hash, ...>]
+    def start_checks(checks)
+      cfg_tags = EzNemo.config[:checks][:tags]
+      i = 0
+      checks.each do |c|
+        if cfg_tags
+          c[:tags] ? tags = JSON.parse(c[:tags]) : tags = []
+          next if (cfg_tags & tags).empty?
+        end
+        p = @plugins[c[:type].to_sym]
+        p.add_check(c)
+        i += 1
+      end
+      puts "#{i} checks activated."
+    end
+
+    # Report result; usually called by the plugin
+    # @param result [Hash] :check_id, :timestamp, :status, :response_ms, :status_desc
+    def report(result)
+      EzNemo.datastore.store_result(result)
+    end
+
+  end
+
+end

data/lib/eznemo/mysql.rb

@@ -0,0 +1,85 @@
+require 'mysql2/em'
+
+
+module EzNemo
+
+  # Defines DataStorage class for MySQL
+  module StorageAdapter
+
+    # Number of records it queues up before writing
+    QUEUE_SIZE = 20
+
+    def initialize
+      @results = []
+      @opts = EzNemo.config[:datastore][:options]
+      @opts[:flags] = Mysql2::Client::MULTI_STATEMENTS
+    end
+
+    # Creates and returns new instance of {Mysql2::Client}
+    # @return [Mysql2::Client]
+    def database
+      Mysql2::Client.new(@opts)
+    end
+
+    # Creates and returns new instance of {Mysql2::EM::Client}
+    # @return [Mysql2::EM::Client]
+    def emdatabase
+      Mysql2::EM::Client.new(@opts)
+    end
+
+    # Returns all active checks
+    # @return [Array<Hash, ...>]
+    def checks
+      q = 'SELECT * FROM checks WHERE state = true'
+      database.query(q, {symbolize_keys: true, cast_booleans: true})
+    end
+
+    # Stores a result; into queue first
+    # @param result [Hash] (see {EzNemo::Monitor#report})
+    def store_result(result)
+      @results << result
+      if @results.count >= QUEUE_SIZE
+        write_results
+      end
+    end
+
+    # Write the results to storage from queue
+    # @param sync [Boolean] use EM (async) if false
+    # @return [Object] Mysql2 client instance
+    def write_results(sync = false)
+      return nil if @results.empty?
+      sync ? db = database : db = emdatabase
+      stmt = ''
+      @results.each do |r|
+        r[:status_desc] = db.escape(r[:status_desc])
+        cols = r.keys.join(',')
+        vals = r.values.join("','")
+        stmt << "INSERT INTO results (#{cols}) VALUES ('#{vals}');"
+      end
+      @results.clear
+      if sync
+        db.query(stmt)
+      else
+        defer = db.query(stmt)
+        defer.callback do
+        end
+        defer.errback do |r|
+          puts r.message
+          db.close if db.ping
+        end
+      end
+      db
+    end
+
+    # Flush queue to storage
+    def flush
+      if write_results(true)
+        puts "Flushed."
+      else
+        puts "Nothing to flush."
+      end
+    end
+
+  end
+
+end

data/lib/eznemo/version.rb

@@ -0,0 +1,5 @@
+module EzNemo
+
+  Version = '0.0.2'
+
+end

data/lib/eznemo.rb

@@ -0,0 +1,53 @@
+require 'eznemo/config'
+require 'eznemo/version'
+require 'eventmachine'
+
+module EzNemo
+
+  # EventMachine reactor
+  class Reactor
+
+    # Start reactor
+    # @param opts [Hash] from command line
+    # @return [Object]
+    def self.run!(opts)
+      r = Reactor.new(opts)
+      r.run
+      r
+    end
+
+    # Usually called by #self.run!
+    def initialize(opts)
+      c = EzNemo.load_config(opts[:config])
+
+      require "eznemo/#{c[:datastore][:type].to_s}"
+      require 'eznemo/datastore'
+
+      require 'eznemo/monitor'
+      require 'eznemo/monitor/ping'
+    end
+
+    # Usually called by #self.run!
+    def run
+      ds = EzNemo.datastore
+
+      Signal.trap('INT') do
+        puts 'Interrupted. Flushing...'
+        ds.flush
+        exit
+      end
+
+      Signal.trap('SIGTERM') do
+        puts 'Stopping...'
+        ds.flush
+        exit
+      end
+      
+      EM.run do
+        EzNemo.monitor.start_checks(ds.checks)
+      end
+    end
+
+  end
+
+end

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification
+name: eznemo
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Ken J.
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-04-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: kajiki
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: eventmachine
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: Simple network monitoring
+email:
+- kenjij@gmail.com
+executables:
+- eznemo
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- bin/eznemo
+- eznemo.gemspec
+- lib/eznemo.rb
+- lib/eznemo/config.rb
+- lib/eznemo/datastore.rb
+- lib/eznemo/monitor.rb
+- lib/eznemo/monitor/ping.rb
+- lib/eznemo/mysql.rb
+- lib/eznemo/version.rb
+homepage: https://github.com/kenjij/eznemo
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.3
+signing_key: 
+specification_version: 4
+summary: Simple network monitoring implemented with Ruby.
+test_files: []