watchmonkey_cli 1.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 553a66c3a760e64c80ac8af012b7119721aaf521
+  data.tar.gz: fec50a69b3321cfd2c5d38b9e78d65218471e5bd
+SHA512:
+  metadata.gz: ca30f9f9e6702f400c3d05bdf81fca702adc04b52126ad15d71c21472a30d5076d761f7a9877120a54768fd0091934856882901b13891758f9d2156e44e80e88
+  data.tar.gz: 95df3dba388da9fddc6fd44bf7c9ff6a38480c42db424de3a75307a0949537da4d60d7f3400aac3970eeb43e9fd8f4049ae94be267394d926f0c8c3d51c20449

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in dle.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016, Sven Pachnit aka. 2called-chaos
+
+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,45 @@
+# Watchmonkey CLI
+
+Coming soon.
+
+---
+
+## Help
+If you need help or have problems [open an issue](https://github.com/2called-chaos/watchmonkey_cli/issues/new).
+
+
+## Features
+  * Colors!
+
+
+
+## Requirements
+  * Ruby >= 2.0
+  * Unixoid OS (such as Ubuntu/Debian, OS X, maybe others) or Windows 7/8 (not recommended)
+  * something you want to monitor
+
+
+
+## Installation
+  * `gem install watchmonkey_cli`
+  * `watchmonkey --generate-config [name=default]`
+
+
+## Deactivate configs
+If you want to deactivate configs entirely just rename the file to start with two underscores (e.g.: `__example.rb`).
+
+
+## Contributing
+  Contributions are very welcome! Either report errors, bugs and propose features or directly submit code:
+
+  1. Fork it
+  2. Create your feature branch (`git checkout -b my-new-feature`)
+  3. Commit your changes (`git commit -am 'Added some feature'`)
+  4. Push to the branch (`git push origin my-new-feature`)
+  5. Create new Pull Request
+
+
+
+## Legal
+* © 2016, Sven Pachnit (www.bmonkeys.net)
+* watchmonkey_cli is licensed under the MIT license.

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/VERSION

@@ -0,0 +1 @@
+1.4

data/bin/watchmonkey

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+require "watchmonkey_cli"
+begin
+  WatchmonkeyCli::Application.dispatch(ENV, ARGV)
+rescue Interrupt
+  puts("\n\nInterrupted")
+  exit 1
+end

data/bin/watchmonkey.sh

@@ -0,0 +1,14 @@
+#!/bin/bash
+
+# That's __FILE__ in BASH :)
+# From: http://stackoverflow.com/questions/59895/can-a-bash-script-tell-what-directory-its-stored-in
+SOURCE="${BASH_SOURCE[0]}"
+while [ -h "$SOURCE" ]; do # resolve $SOURCE until the file is no longer a symlink
+  MCLDIR="$( cd -P "$( dirname "$SOURCE" )" && pwd )"
+  SOURCE="$(readlink "$SOURCE")"
+  [[ $SOURCE != /* ]] && SOURCE="$MCLDIR/$SOURCE" # if $SOURCE was a relative symlink, we need to resolve it relative to the path where the symlink file was located
+done
+PROJECT_ROOT="$( cd -P "$( dirname "$SOURCE" )"/.. && pwd )"
+
+# Actually run script
+cd $PROJECT_ROOT && bundle exec ruby bin/watchmonkey "$@"

data/lib/watchmonkey_cli/application/colorize.rb

@@ -0,0 +1,22 @@
+module WatchmonkeyCli
+  class Application
+    module Colorize
+      COLORMAP = {
+        black: 30,
+        red: 31,
+        green: 32,
+        yellow: 33,
+        blue: 34,
+        magenta: 35,
+        cyan: 36,
+        white: 37,
+      }
+
+      def colorize str, color = :yellow
+        ccode = COLORMAP[color.to_sym] || raise(ArgumentError, "Unknown color #{color}!")
+        @opts[:colorize] ? "\e[#{ccode}m#{str}\e[0m" : "#{str}"
+      end
+      alias_method :c, :colorize
+    end
+  end
+end

data/lib/watchmonkey_cli/application/configuration.rb

@@ -0,0 +1,55 @@
+module WatchmonkeyCli
+  class Application
+    class Configuration
+      module AppHelper
+        def config_directory
+          "#{wm_cfg_path}/configs"
+        end
+
+        def config_files
+          Dir["#{config_directory}/**/*.rb"].reject do |file|
+            file.gsub(config_directory, "").split("/").any?{|fp| fp.start_with?("__") }
+          end
+        end
+
+        def config_filename name = "default"
+          "#{config_directory}/#{name}.rb"
+        end
+
+        def load_configs!
+          config_files.each {|f| Configuration.new(self, f) }
+        end
+
+        def generate_config name = "default"
+          FileUtils.mkdir_p(config_directory)
+          File.open(config_filename(name), "w", encoding: "utf-8") do |f|
+            f << File.read("#{File.dirname(__FILE__)}/configuration.tpl", encoding: "utf-8")
+          end
+        end
+      end
+
+      def initialize app, file
+        @app = app
+        @file = file
+        begin
+          eval File.read(file, encoding: "utf-8"), binding, file
+        rescue
+          app.error "Invalid config file #{file}"
+          raise
+        end
+      end
+
+      def ssh_connection name, opts = {}, &b
+        @app.fetch_connection(:ssh, name, opts, &b)
+      end
+
+      def method_missing meth, *args, &block
+        if c = @app.checkers[meth.to_s]
+          c.enqueue(*args)
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/watchmonkey_cli/application/configuration.tpl

@@ -0,0 +1,142 @@
+# This is a Ruby file!
+
+# =================================
+# = Step 1: Setup SSH connections =
+# =================================
+
+# Synopsis: ssh_connection <name> <net-ssh options>
+# For a list of options see:
+#     http://net-ssh.github.io/net-ssh/Net/SSH.html#method-c-start
+# The default options are { config: false }
+ssh_connection :my_server, host_name: "example.com", user: "wheel", password: "secur3"
+
+# Key authentication (if you don't specify any keys the default locations might be used)
+ssh_connection :my_server, host_name: "example.com", user: "wheel", keys_only: true, keys: ["/home/itsme/.ssh/id_rsa"]
+
+# Therefore you might get away with just
+ssh_connection :my_server, host_name: "example.com", user: "wheel"
+
+# There are also two shortcuts you can use...
+ssh_connection :my_server, "wheel@example.com" # no additional options possible
+ssh_connection :my_server, host: "wheel@example.com", port: 23 # additional options possible
+
+
+
+
+# ==========================
+# = Step 2: Monitor stuff! =
+# ==========================
+
+
+# -----
+# SSL expiration
+# -----
+# Check if a SSL certificate is about to expire.
+# Default threshold is 1.month
+ssl_expiration "https://example.com", threshold: 3.months
+
+
+# -----
+# WWW availability
+# -----
+# Check if a website is reachable and responses properly.
+# Available options:
+#
+#     status    HTTP status code or array of status codes
+#       body    String (include check) or regular expression
+#    headers    { header => value }
+#                 * keys are lowercased!
+#                 * value might be string (equal check) or regular expression
+#
+# Note: If page is https and ssl_expiration is not false
+#       SSL expiration will automatically be checked.
+#       You can pass options by setting ssl_expiration to a Hash.
+
+www_availability "http://example.com", status: 200, body: "<title>Example.com</title>", headers: { "content-type" => "text/html; charset=utf-8" }
+
+# SSL expiration
+www_availability "https://example.com", ssl_expiration: false
+www_availability "https://example.com", ssl_expiration: { threshold: 4.weeks }
+
+
+# -----
+# FTP availability
+# -----
+# Login to an FTP account via net/ftp to check it's functionality.
+# Just a port check is not enough!
+ftp_availability "ftp.example.com", user: "somebody", password: "thatiusedtoknow"
+
+
+# -----
+# MySQL replication
+# -----
+# Check the health of a MySQL replication.
+# Host might be :local/false/nil which will test locally (without SSH)
+# Available options: user(root), password, host(127.0.0.1), port(3306), sbm_threshold(60)
+# SBM refers to "Seconds Behind Master"
+mysql_replication :my_server, user: "replication_user", password: "pushit"
+
+
+# -----
+# *nix file_exist
+# -----
+# Check if a file exists or not.
+# Host might be :local/false/nil which will test locally (without SSH)
+# You can change the default message (The file ... does not exist) with the message option.
+unix_file_exists :my_server, "/etc/passwd", message: "There is no passwd, spooky!"
+
+
+# -----
+# *nix df
+# -----
+# Checks if disks are running low on free space.
+# Host might be :local/false/nil which will test locally (without SSH)
+# Available options: min_percent(25)
+unix_df :my_server
+unix_df :my_server, min_percent: 50
+
+
+# -----
+# *nix memory
+# -----
+# Checks if memory is running low.
+# Host might be :local/false/nil which will test locally (without SSH)
+# Available options: min_percent(25)
+unix_memory :my_server
+unix_memory :my_server, min_percent: 50
+
+
+# -----
+# *nix load
+# -----
+# Checks if system load is to high.
+# Host might be :local/false/nil which will test locally (without SSH)
+# Available options: limits([4, 2, 1.5])
+unix_load :my_server
+unix_load :my_server, limits: [3, 2, 1]
+
+
+# -----
+# *nix mdadm
+# -----
+# Checks if mdadm raids are intact or checking.
+# Host might be :local/false/nil which will test locally (without SSH)
+# Available options: log_checking(true)
+unix_mdadm :my_server
+unix_mdadm :my_server, log_checking: false
+
+
+# -----
+# *nix defaults
+# -----
+# Combines unix_load, unix_memory, unix_df and unix_mdadm.
+# You can pass options or disable individual checkers by passing
+# a hash whose keys are named after checkers.
+unix_defaults :my_server
+unix_defaults :my_server, unix_mdadm: false, unix_df: { min_percent: 10 }
+
+# There are also the following shortcuts:
+unix_defaults :my_server, load: [1, 2, 3]  # Array(3) or false
+unix_defaults :my_server, memory_min: 10   # Fixnum or false
+unix_defaults :my_server, df_min: 10       # Fixnum or false
+unix_defaults :my_server, mdadm: false     # true or false

data/lib/watchmonkey_cli/application/dispatch.rb

@@ -0,0 +1,86 @@
+module WatchmonkeyCli
+  class Application
+    module Dispatch
+      def dispatch action = (@opts[:dispatch] || :help)
+        if respond_to?("dispatch_#{action}")
+          send("dispatch_#{action}")
+        else
+          abort("unknown action #{action}", 1)
+        end
+      end
+
+      def dispatch_help
+        puts @optparse.to_s
+      end
+
+      def dispatch_generate_config
+        cfg_name = @opts[:config_name] || "default"
+        cfg_file = config_filename(cfg_name)
+        puts c("Generating example config `#{cfg_name}'")
+        if File.exist?(cfg_file)
+          abort "Conflict, file already exists: #{cfg_file}", 1
+        else
+          generate_config(cfg_name)
+          puts c("Writing #{cfg_file}...", :green)
+        end
+      end
+
+      def dispatch_index
+        Thread.abort_on_exception = true
+        trap_signals
+        init_checkers!
+        load_configs!
+        dump_and_exit! if @opts[:dump]
+        start_checkers!
+        @running = true
+        spawn_threads_and_run!
+        @threads.each(&:join)
+        # puts config_directory
+        # puts config_files.inspect
+      ensure
+        @running = false
+        stop_checkers!
+        close_connections!
+        release_signals
+      end
+
+      def dispatch_info
+        your_version = Gem::Version.new(WatchmonkeyCli::VERSION)
+        puts c ""
+        puts c("     Your version: ", :yellow) << c("#{your_version}", :magenta)
+
+        print c("  Current version: ", :yellow)
+        if @opts[:check_for_updates]
+          require "net/http"
+          print c("checking...", :blue)
+
+          begin
+            current_version = Gem::Version.new Net::HTTP.get_response(URI.parse(WatchmonkeyCli::UPDATE_URL)).body.strip
+
+            if current_version > your_version
+              status = c("#{current_version} (consider update)", :red)
+            elsif current_version < your_version
+              status = c("#{current_version} (ahead, beta)", :green)
+            else
+              status = c("#{current_version} (up2date)", :green)
+            end
+          rescue
+            status = c("failed (#{$!.message})", :red)
+          end
+
+          print "#{"\b" * 11}#{" " * 11}#{"\b" * 11}" # reset line
+          puts status
+        else
+          puts c("check disabled", :red)
+        end
+
+        # more info
+        puts c ""
+        puts c "  Watchmonkey CLI is brought to you by #{c "bmonkeys.net", :green}"
+        puts c "  Contribute @ #{c "github.com/2called-chaos/watchmonkey_cli", :cyan}"
+        puts c "  Eat bananas every day!"
+        puts c ""
+      end
+    end
+  end
+end

data/lib/watchmonkey_cli/application.rb

@@ -0,0 +1,255 @@
+module WatchmonkeyCli
+  class Application
+    attr_reader :opts, :checkers, :connections, :threads, :queue, :hooks, :processed
+    include Helpers
+    include Colorize
+    include Dispatch
+    include Configuration::AppHelper
+    include Checker::AppHelper
+
+    # =========
+    # = Setup =
+    # =========
+    def self.dispatch *a
+      new(*a) do |app|
+        app.load_config
+        app.parse_params
+        begin
+          app.dispatch
+          app.haltpoint
+        rescue Interrupt
+          app.abort("Interrupted", 1)
+        ensure
+          app.fire(:wm_shutdown)
+          app.debug "#{Thread.list.length} threads remain..."
+        end
+      end
+    end
+
+    def initialize env, argv
+      @env, @argv = env, argv
+      @connections = {}
+      @hooks = {}
+      @monitor = Monitor.new
+      @threads = []
+      @queue = Queue.new
+      @processed = 0
+      @running = false
+      @opts = {
+        dump: false,             # (internal) if true app will dump itself and exit before running any checks
+        dispatch: :index,        # (internal) action to dispatch
+        check_for_updates: true, # -z flag
+        colorize: true,          # -m flag
+        debug: false,            # -d flag
+        threads: 10,             # -t flag
+        loop_forever: false,     # (internal) loop forever (app mode)
+        loop_wait_empty: 1,      # (internal) time to wait in thread if queue is empty
+        silent: false,           # -s flag
+        quiet: false,            # -q flag
+      }
+      init_params
+      yield(self)
+    end
+
+    def init_params
+      @optparse = OptionParser.new do |opts|
+        opts.banner = "Usage: watchmonkey [options]"
+
+        opts.separator(c "# Application options", :blue)
+        opts.on("--generate-config [myconfig]", "Generates a example config in ~/.watchmonkey") {|s| @opts[:dispatch] = :generate_config; @opts[:config_name] = s }
+        opts.on("-l", "--log [file]", "Log to file, defaults to ~/.watchmonkey/logs/watchmonkey.log") {|s| @opts[:logfile] = s || logger_filename }
+        opts.on("-t", "--threads [NUM]", Integer, "Amount of threads to be used for checking (default: 10)") {|s| @opts[:threads] = s }
+        opts.on("-s", "--silent", "Only print errors and infos") { @opts[:silent] = true }
+        opts.on("-q", "--quiet", "Only print errors") { @opts[:quiet] = true }
+
+        opts.separator("\n" << c("# General options", :blue))
+        opts.on("-d", "--debug", "Enable debug output") { @opts[:debug] = true }
+        opts.on("-m", "--monochrome", "Don't colorize output") { @opts[:colorize] = false }
+        opts.on("-h", "--help", "Shows this help") { @opts[:dispatch] = :help }
+        opts.on("-v", "--version", "Shows version and other info") { @opts[:dispatch] = :info }
+        opts.on("-z", "Do not check for updates on GitHub (with -v/--version)") { @opts[:check_for_updates] = false }
+        opts.on("--dump-core", "for developers") { @opts[:dump] = true }
+      end
+    end
+
+    def parse_params
+      @optparse.parse!(@argv)
+    rescue OptionParser::ParseError => e
+      abort(e.message)
+      dispatch(:help)
+      exit 1
+    end
+
+    def running?
+      @running
+    end
+
+    def load_config
+      return unless File.exist?(wm_cfg_configfile)
+      eval File.read(wm_cfg_configfile, encoding: "utf-8"), binding, wm_cfg_configfile
+    end
+
+    def debug msg
+      puts c("[DEBUG] #{msg}", :black) if @opts[:debug]
+    end
+
+    def abort msg, exit_code = 1
+      puts c("[ABORT] #{msg}", :red)
+      exit(exit_code)
+    end
+
+    def error msg
+      warn c(msg, :red)
+    end
+
+    def hook *which, &hook_block
+      which.each do |w|
+        @hooks[w.to_sym] ||= []
+        @hooks[w.to_sym] << hook_block
+      end
+    end
+
+    def fire which, *args
+      return if @disable_event_firing
+      sync { debug "[Event] Firing #{which} (#{@hooks[which].try(:length) || 0} handlers) #{args.map(&:class)}" }
+      @hooks[which] && @hooks[which].each{|h| h.call(*args) }
+    end
+
+    def fetch_connection type, id, opts = {}, &initializer
+      if !@connections[type] || !@connections[type][id]
+        @connections[type] ||= {}
+        case type
+        when :loopback
+          @connections[type][id] = LoopbackConnection.new(id, opts, &initializer)
+        when :ssh
+          @connections[type][id] = SshConnection.new(id, opts, &initializer)
+        else
+          raise NotImplementedError, "unknown connection type `#{type}'!"
+        end
+      end
+      @connections[type][id]
+    end
+
+    def close_connections!
+      @connections.each do |type, clist|
+        clist.each{|id, con| con.close! }
+      end
+    end
+
+    def sync &block
+      @monitor.synchronize(&block)
+    end
+
+    def spawn_threads_and_run!
+      if @opts[:threads] > 1
+        debug "Spawning #{@opts[:threads]} consumer threads..."
+        @opts[:threads].times do
+          @threads << Thread.new do
+            Thread.current.abort_on_exception = true
+            _queueoff
+          end
+        end
+      else
+        debug "Running threadless..."
+        _queueoff
+      end
+    end
+
+    def enqueue checker, *a, &block
+      sync do
+        cb = block || checker.method(:check!)
+        evreg = @disable_event_registration
+        fire(:enqueue, checker, a, cb) unless evreg
+        @queue << [checker, a, ->(*a) {
+          begin
+            result = Checker::Result.new(checker, *a)
+            checker.debug(result.str_running)
+            checker.safe(result.str_safe) { cb.call(result, *a) }
+            fire(:result_dump, result, a, checker)
+            result.dump!
+          ensure
+            fire(:dequeue, checker, a) unless evreg
+          end
+        }]
+      end
+    end
+
+    def enqueue_sub checker, which, *args
+      sync do
+        if sec = @checkers[which.to_s]
+          begin
+            # ef_was = @disable_event_firing
+            er_was = @disable_event_registration
+            # @disable_event_firing = true
+            @disable_event_registration = true
+            sec.enqueue(*args)
+          ensure
+            # @disable_event_firing = ef_was
+            @disable_event_registration = er_was
+          end
+        end
+      end
+    end
+
+    def _queueoff
+      while !@queue.empty? || @opts[:loop_forever]
+        break if $wm_runtime_exiting
+        item = queue.pop(true) rescue false
+        if item
+          Thread.current[:working] = true
+          fire(:wm_work_start, Thread.current)
+          sync { @processed += 1 }
+          item[2].call(*item[1])
+          Thread.current[:working] = false
+          fire(:wm_work_end, Thread.current)
+        end
+        sleep @opts[:loop_wait_empty] if @opts[:loop_forever] && @opts[:loop_wait_empty] && @queue.empty?
+      end
+    end
+
+    def wm_cfg_path
+      ENV["WM_CFGDIR"].presence || File.expand_path("~/.watchmonkey")
+    end
+
+    def wm_cfg_configfile
+      "#{wm_cfg_path}/config.rb"
+    end
+
+    def logger_filename
+      "#{wm_cfg_path}/logs/watchmonkey.log"
+    end
+
+    def logger
+      sync do
+        @logger ||= begin
+          FileUtils.mkdir_p(File.dirname(@opts[:logfile]))
+          Logger.new(@opts[:logfile], 10, 1024000)
+        end
+      end
+    end
+
+    def trap_signals
+      debug "Trapping INT signal..."
+      Signal.trap("INT") do
+        $wm_runtime_exiting = true
+        puts "Interrupting..."
+      end
+    end
+
+    def release_signals
+      debug "Releasing INT signal..."
+      Signal.trap("INT", "DEFAULT")
+    end
+
+    def haltpoint
+      raise Interrupt if $wm_runtime_exiting
+    end
+
+    def dump_and_exit!
+      puts "   Queue: #{@queue.length}"
+      puts " AppOpts: #{@opts}"
+      puts "Checkers: #{@checkers.keys.join(",")}"
+      exit 9
+    end
+  end
+end