apolo 0.0.3

data/README.md

@@ -0,0 +1,47 @@
+# Apolo
+
+A lightweight framework based on a hexagonal architecture for building automation, monitoring, and metrics plugins in ruby. 
+
+The goals of the framework:
+1. Ruby is an object-oriented language with great support for functional programming, and I want to make the most of that to keep apolo's code easy to change.
+2. Clean and well-organised
+I want a structure that communicates what each part of the system is doing.
+3. DRY - The focus is on the domain classes so I can re-use them for Chef, Nagios, collectd, and what ever else I come across. 
+
+[![Gem Version](http://img.shields.io/gem/v/apolo.svg)][gem]
+[![Build Status](http://img.shields.io/SteelHouseLabs/apolo/apolo.svg)][travis]
+[![Dependency Status](http://img.shields.io/gemnasium/SteelHouseLabs/apolo.svg)][gemnasium]
+[![Code Climate](http://img.shields.io/codeclimate/github/SteelHouseLabs/apolo.svg)][codeclimate]
+
+[gem]: https://rubygems.org/gems/apolo
+[travis]: http://travis-ci.org/SteelHouseLabs/apolo
+[gemnasium]: https://gemnasium.com/SteelHouseLabs/apolo
+[codeclimate]: https://codeclimate.com/github/SteelHouseLabs/apolo
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'apolo'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install apolo
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/apolo/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

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

data/Thorfile

@@ -0,0 +1,29 @@
+$LOAD_PATH.unshift File.expand_path("../lib", __FILE__)
+
+require "bundler"
+require "thor/rake_compat"
+
+class Default < Thor
+  include Thor::RakeCompat
+  Bundler::GemHelper.install_tasks
+
+  desc "build", "Build apolo-#{Apolo::VERSION}.gem into the pkg directory"
+  def build
+    Rake::Task["build"].execute
+  end
+
+  desc "install", "Build and install apolo-#{Apolo::VERSION}.gem into system gems"
+  def install
+    Rake::Task["install"].execute
+  end
+
+  desc "release", "Create tag v#{Apolo::VERSION} and build and push apolo-#{Apolo::VERSION}.gem to Rubygems"
+  def release
+    Rake::Task["release"].execute
+  end
+
+  desc "spec", "Run RSpec code examples"
+  def spec
+    exec "rspec spec"
+  end
+end

data/apolo.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'apolo/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'apolo'
+  spec.version       = Apolo::VERSION
+  spec.authors       = ['Efrén Fuentes', 'Thomas Vincent']
+  spec.email         = ['thomasvincent@steelhouselabs.com']
+  spec.summary       = %q{Metric, Monitoring & automation services framework.}
+  spec.description   = %q{Metric, Monitoring & automation services framework.}
+  spec.homepage      = ''
+  spec.license       = 'Apache 2.0'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = %w[lib]
+  spec.required_rubygems_version = ">= 1.3.5"
+  spec.summary = spec.description
+  spec.test_files = Dir.glob("spec/**/*")
+  spec.add_development_dependency 'bundler', '~> 1.7'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_dependency 'sequel', '~> 4.14'
+  spec.add_dependency 'sqlite3', '~> 1.3'
+  spec.add_dependency 'cupsffi', '~> 0.1'
+  spec.add_dependency "logger-better"
+  spec.add_dependency "tnt"
+end

data/bin/apolo_cpu_socket

@@ -0,0 +1,50 @@
+#!/usr/bin/env ruby
+require 'apolo'
+require 'optparse'
+
+options = { critical: 101, warning: 101 }
+
+begin
+  OptionParser.new do |opts|
+    opts.on('-c', '--critical MAX', 'Max cpu usage percentage for critical') { |v| options[:critical] = v }
+    opts.on('-w', '--warning MAX', 'Max cpu usage percentage for warning') { |v| options[:warning] = v }
+  end.parse!
+rescue Exception => msg
+  puts msg
+  exit
+end
+
+# Supress warning messages.
+original_verbose, $VERBOSE = $VERBOSE, nil
+@@options = options
+# Activate warning messages again.
+$VERBOSE = original_verbose
+
+class CheckCpuSocket < Apolo::Monitor
+  name 'CPU_Socket'
+
+  # Nagios notifier
+  notify Apolo::Notifiers::Nagios, file: 'nagios.cmd',\
+                                   host: 'localhost',\
+                                   service: 'CPU_Socket',\
+                                   warning: @@options[:warning].to_i,\
+                                   critical: @@options[:critical].to_i
+
+  run do
+    # create new CpuSocket for calculations
+    cpu_socket = Apolo::Domains::CpuSocket.new
+
+    # get percentage of usage for each socket
+    cpu_usage = cpu_socket.cpu_usage
+
+    # send notify to nagios
+    (0..cpu_socket.sockets).each do |socket|
+      notify message: "Socket #{socket} usage #{cpu_usage[socket]}", value: cpu_usage[socket]
+    end
+
+  end
+end
+
+# create monitor and run it
+monitor = CheckCpuSocket.new
+monitor.run

data/bin/apolo_cups

@@ -0,0 +1,51 @@
+#!/usr/bin/env ruby
+require 'apolo'
+require 'optparse'
+
+options = { critical: 120, warning: 120 }
+
+begin
+  OptionParser.new do |opts|
+    opts.on('-c', '--critical MAX', 'Max numbers of minutes on queue for critical') { |v| options[:critical] = v }
+    opts.on('-w', '--warning MAX', 'Max numbers of minutes on queue for warning') { |v| options[:warning] = v }
+    opts.on('-p' '--printer name', 'Printer name to check for jobs') { |v| options[:printer] = v }
+  end.parse!
+rescue Exception => msg
+  puts msg
+  exit
+end
+
+# Supress warning messages.
+original_verbose, $VERBOSE = $VERBOSE, nil
+@@options = options
+# Activate warning messages again.
+$VERBOSE = original_verbose
+
+
+class CheckCups < Apolo::Monitor
+  name 'CUPS'
+
+  # Notifiers
+  notify Apolo::Notifiers::Nagios, file: 'nagios.cmd',\
+                                   host: 'localhost',\
+                                   service: 'CUPS',\
+                                   warning: @@options[:warning].to_i,\
+                                   critical: @@options[:critical].to_i
+
+  run do
+    # create new Cups instance
+    cups = Apolo::Domains::Cups.new(@@options[:printer_name])
+
+    # send notify to nagios
+    if cups.jobs_count > 0
+      notify message: "Last job #{cups.minutes} minutes ago: #{cups.job[:id]} - #{cups.job[:dest]} - #{cups.job[:user]} - #{Time.at(cups.job[:creation_time])}", value: cups.minutes
+    else
+      notify message: 'Not jobs found', value: cups.minutes
+    end
+
+  end
+end
+
+# create monitor and run it
+monitor = CheckCups.new
+monitor.run

data/bin/apolo_tcp_sockets

@@ -0,0 +1,49 @@
+#!/usr/bin/env ruby
+require 'apolo'
+require 'optparse'
+
+options = { critical: 120, warning: 120, ipv6: false }
+
+begin
+  OptionParser.new do |opts|
+    opts.on('-c', '--critical MAX', 'Max numbers of open sockets for critical') { |v| options[:critical] = v }
+    opts.on('-w', '--warning MAX', 'Max numbers of open sockets for warning') { |v| options[:warning] = v }
+    opts.on('-6' '--ipv6 (true|false)', 'Use IP6 or not') { options[:ipv6] = true }
+  end.parse!
+rescue Exception => msg
+  puts msg
+  exit
+end
+
+# Supress warning messages.
+original_verbose, $VERBOSE = $VERBOSE, nil
+@@options = options
+# Activate warning messages again.
+$VERBOSE = original_verbose
+
+
+class CheckTCPSockets < Apolo::Monitor
+  name 'TCP_Sockets'
+
+  # Notifiers
+  notify Apolo::Notifiers::Nagios, file: 'nagios.cmd',\
+                                   host: 'localhost',\
+                                   service: 'TCP_Sockets',\
+                                   warning: @@options[:warning].to_i,\
+                                   critical: @@options[:critical].to_i
+
+  run do
+    # get family options
+    family = @@options[:ipv6] ? :INET6 : :INET
+
+    sockets = Apolo::Domains::TCPSockets.connections(family)
+
+    # send notify to nagios
+    notify message: "#{sockets.count} connections #{family}", value: sockets.count
+
+  end
+end
+
+# create monitor and run it
+monitor = CheckTCPSockets.new
+monitor.run

data/lib/apolo.rb

@@ -0,0 +1,6 @@
+require 'apolo/version'
+require 'apolo/monitor'
+require 'apolo/reader'
+require 'apolo/reader_config'
+require 'apolo/notifiers'
+require 'apolo/domains'

data/lib/apolo/domains.rb

@@ -0,0 +1,3 @@
+require 'apolo/domains/cpu_socket'
+require 'apolo/domains/cups'
+require 'apolo/domains/tcp_sockets'

data/lib/apolo/domains/cpu_socket.rb

@@ -0,0 +1,97 @@
+module Apolo
+  module Domains
+    # CpuSocket
+    #
+    # Get information about percentage of usage for each cpu on all sockets
+    class CpuSocket
+      def initialize
+        @init_stats = statistics_of_process
+        sleep 1
+        @end_stats = statistics_of_process
+      end
+
+      # Get number of cpus for each socket
+      #
+      # @return [Integer] the number of cpus for sockets
+      def cpu_socket
+        cpus / (sockets + 1)
+      end
+
+      # Get usage for cpus
+      #
+      # @return [Integer] the usage for cpus
+      def usage_sum(cores, stats)
+        usage_sum = 0
+
+        cores.each do |core|
+          line = stats[core + 1].split(' ')
+          usage_sum = line[1].to_i + line[2].to_i + line[3].to_i
+        end
+
+        usage_sum
+      end
+
+      # Get total of process
+      #
+      # @return [Integer] the total of process
+      def proc_total(cores, stats)
+        proc_total = 0
+        (1..4).each do |i|
+          cores.each do |core|
+            line = stats[core + 1].split(' ')
+            proc_total += line[i].to_i
+          end
+        end
+        proc_total
+      end
+
+      # Get usage for each cpu
+      #
+      # @return [Array] the percentage of usage for each cpu
+      def cpu_usage
+        cpu_usage = []
+        (0..sockets).each do |socket|
+          cores = (socket * cpu_socket..socket * cpu_socket + (cpu_socket - 1))
+
+          init_usage = usage_sum(cores, @init_stats)
+          end_usage = usage_sum(cores, @end_stats)
+
+          proc_usage = end_usage - init_usage
+
+          init_total = proc_total(cores, @init_stats)
+          end_total = proc_total(cores, @end_stats)
+
+          proctotal = (end_total - init_total)
+
+          usage = (proc_usage.to_f / proctotal.to_f)
+
+          cpu_usage[socket] = (100 * usage).to_f
+        end
+        cpu_usage
+      end
+
+      # Get number of sockets
+      #
+      # @return [Integer] the number of sockets on system
+      def sockets
+        File.readlines('/proc/cpuinfo').grep(/^physical id/).last.split(' ')[3].to_i
+      end
+
+      # Get number of cpus
+      #
+      # @return [Integer] the number of cpus on system
+      def cpus
+        File.readlines('/proc/cpuinfo').grep(/^processor/).count
+      end
+
+      private
+
+      # Get statistics of process
+      #
+      # @return [Array] the statistics of process
+      def statistics_of_process
+          File.readlines('/proc/stat')
+      end
+    end
+  end
+end

data/lib/apolo/domains/cups.rb

@@ -0,0 +1,35 @@
+require 'cupsffi'
+
+module Apolo
+  module Domains
+    class Cups
+      attr_accessor :jobs_count, :minutes, :job
+      def initialize(printer_name)
+        if printer_name.nil?
+          printer = CupsPrinter.new(printers.first)
+          @printer_name = printer.name
+        else
+          @printer_name = printer_name
+        end
+
+        get_data
+      end
+
+      def printers
+        CupsPrinter.get_all_printer_names
+      end
+
+      def get_data
+        pointer = FFI::MemoryPointer.new :pointer
+        @jobs_count = CupsFFI::cupsGetJobs(pointer, @printer_name, 0, CupsFFI::CUPS_WHICHJOBS_ACTIVE)
+        @job = CupsFFI::CupsJobS.new(pointer.get_pointer(0))
+
+        if @jobs_count > 0
+          @minutes = (Time.now - Time.at(@job[:creation_time])).to_i / 60
+        else
+          @minutes = 0
+        end
+      end
+    end
+  end
+end

data/lib/apolo/domains/tcp_sockets.rb

@@ -0,0 +1,13 @@
+require 'socket'
+
+module Apolo
+  module Domains
+    class TCPSockets
+      class << self
+        def connections(family)
+          Socket.getaddrinfo('localhost', nil, family)
+        end
+      end
+    end
+  end
+end

data/lib/apolo/monitor.rb

@@ -0,0 +1,143 @@
+module Apolo
+  class Monitor
+    class << self
+      def reader_templates
+        @reader_templates || []
+      end
+
+      def notifier_templates
+        @notifier_templates || []
+      end
+
+      def name_template
+        @name_template || self.to_s
+      end
+
+      def running_template
+        @running_template
+      end
+
+      # Set the name of the app. Can be used by notifiers in order to have
+      # a better description of the service in question.
+      #
+      # @param [String, #read] name The name to be given to a Apolo-based
+      #   class.
+      def name(val = nil)
+        @name_template = val if val
+        @name_template
+      end
+
+      # Register a reader in the list of readers.
+      #
+      # @param [Hash{Scout => String}, #read] reader_description A hash
+      #   containing Reader class as key and its description as a value.
+      #
+      # @yield Block to be evaluated to configure the current {Reader}.
+      def using(reader_description, &block)
+        @reader_templates ||= []
+        @reader_templates << {
+            :reader_description => reader_description,
+            :block => block
+        }
+      end
+
+      # Register a notifier class in the list of notifications.
+      #
+      # @param [Class, #read] class A class that will be used to issue
+      #   a notification. The class must accept a configuration hash in the
+      #   constructor and also implement a #notify method that will receive an
+      #   outpost instance. See {Apolo::Notifiers::Console} for an example.
+      #
+      # @param [Hash, #read] options Options that will be used to configure the
+      #   notification class.
+      def notify(notifier, options={})
+        @notifier_templates ||= []
+        @notifier_templates << {:notifier => notifier, :options => options}
+      end
+
+      def run(&block)
+        @running_template = block
+      end
+    end
+
+    # Returns all the registered readers.
+    attr_reader :readers
+
+    # Returns all the registered notifiers.
+    attr_reader :notifiers
+
+    # Reader/setter for the name of this monitor
+    attr_accessor :name
+
+    # New instance of a Application-based class.
+    def initialize
+      @readers    = Hash.new { |h, k| h[k] = [] }
+      @notifiers  = {}
+      @name       = self.class.name_template
+      @running    = self.class.running_template
+
+      # Register readers
+      self.class.reader_templates.each do |template|
+        add_reader(template[:reader_description], &template[:block])
+      end
+
+      self.class.notifier_templates.each do |template|
+        add_notifier(template[:notifier], template[:options])
+      end
+    end
+
+    # @see Monitor#using
+    def add_reader(reader_description, &block)
+      config = ReaderConfig.new
+      config.instance_exec(&block) if block
+
+      reader_description.each do |reader, description|
+        @readers[reader] << {
+            :description => description,
+            :config => config
+        }
+      end
+    end
+
+    # @see Monitor#notify
+    def add_notifier(notifier_name, options)
+      @notifiers[notifier_name] = options
+    end
+
+    def run
+      instance_exec &@running
+    end
+
+    def notify(data)
+      message = data[:message]
+      value = data[:value]
+
+      unless message && value
+        raise ArgumentError, 'You need to set :message and :value to send notify.'
+      end
+
+      @notifiers.each do |notifier, options|
+        # .dup is NOT reliable
+        options_copy = Marshal.load(Marshal.dump(options))
+        notifier.new(options_copy).notify(@name, message, value)
+      end
+    end
+
+    def get_data(reader_exec)
+      @readers.each do |reader, configurations|
+        if configurations.first[:description] == reader_exec
+          return run_reader(reader, configurations.last[:config])
+        end
+      end
+      raise ArgumentError, "Can't found #{reader_exec} reader."
+    end
+
+    private
+
+    def run_reader(reader, config)
+      reader_instance = reader.new(config)
+
+      reader_instance.execute
+    end
+  end
+end