silw 0.0.1

data/lib/silw/command.rb

@@ -0,0 +1,25 @@
+module Silw
+  class Command
+    def initialize(auth_options={})
+      @username = auth_options[:authentication][:username]
+      @password = auth_options[:authentication][:password]
+      pub_key = File.expand_path(@password)
+      if File.exists?(pub_key)
+        @pub_key = pub_key
+      end
+      raise RuntimeError unless @password or @pub_key
+    end
+
+    # see: http://ruby-metaprogramming.rubylearning.com/html/ruby_metaprogramming_3.html
+    def run(command, remotes={})
+      plugin = Kernel.const_get("Silw::Plugins::#{command.capitalize}").new
+      plugin.instance_variable_set(:@username, @username)
+      if @pub_key
+        plugin.instance_variable_set(:@pub_key, @pub_key)
+      else
+        plugin.instance_variable_set(:@password, @password)
+      end
+      plugin.run(remotes)
+    end
+  end
+end

data/lib/silw/helpers.rb

@@ -0,0 +1,54 @@
+module Silw
+  module Helpers
+    def h(*args)
+      escape_html(*args)
+    end
+
+    def find_template(views, name, engine, &block)
+      Array(views).each { |v| super(v, name, engine, &block) }
+    end
+
+    def base_url
+      "#{env['rack.url_scheme']}://#{env['HTTP_HOST']}/"
+    end
+
+    def partial(thing, locals = {})
+      name = case thing
+        when String then thing
+        else thing.class.to_s.demodulize.underscore
+      end
+      haml :"partials/_#{name}", :locals => { name.to_sym => thing }.merge(locals)
+    end
+
+    def url_for(thing, options = {})
+      url = thing.respond_to?(:to_url) ? thing.to_url : thing.to_s
+      url = "#{base_url.sub(/\/$/, '')}#{url}" if options[:absolute]
+      url
+    end
+
+    def production?
+      settings.environment.to_sym == :production
+    end
+
+    def user_logged_in?
+      session[:auth].present?
+    end
+
+    def link_to(title, target = "", options = {})
+      options[:href] = target.respond_to?(:to_url) ? target.to_url : target
+      options[:data] ||= {}
+      [:method, :confirm].each { |a| options[:data][a] = options.delete(a) }
+      haml "%a#{options} #{title}"
+    end
+    
+    def like_filesize(nr)
+      {
+        'B'  => 1024,
+        'KB' => 1024 * 1024,
+        'MB' => 1024 * 1024 * 1024,
+        'GB' => 1024 * 1024 * 1024 * 1024,
+        'TB' => 1024 * 1024 * 1024 * 1024 * 1024
+      }.each_pair{|e, s| return "#{(nr.to_f / (s / 1024)).round(2)}#{e}" if nr < s }
+    end
+  end
+end

data/lib/silw/plugin.rb

@@ -0,0 +1,19 @@
+require "silw/command"
+
+module Silw
+  class Plugin < Command
+    attr :username, :password, :pub_key
+
+    def run
+      puts "implement me"
+    end
+
+    def self.inherited(base)
+      subclasses << base
+    end
+
+    def self.subclasses
+      @subclasses ||= []
+    end
+  end
+end

data/lib/silw/plugins/cpu.rb

@@ -0,0 +1,55 @@
+require 'net/sftp'
+
+# CPU info - report the total CPU usage for a remote system.
+# For more details about 'proc/stat' see:
+# - http://www.linuxhowtos.org/System/procstat.htm
+# 
+# @return - a JSON containing the total CPU usage as a percentage 
+module Silw
+  module Plugins
+    class Cpu
+      attr_accessor :cpu_stats
+      CpuStats = Struct.new :user, :nice, :system, :idle, :iowait, 
+                            :irq, :softirq, :steal, :guest, :guest_nice,
+                            :total
+
+      def run(args)
+        host = args[:at]
+
+        if fixture_cpu_at_t0 = args[:fixture_cpu_at_t0] and fixture_cpu_at_t1 = args[:fixture_cpu_at_t1]
+          cpu_stats = parse_stats File.read(fixture_cpu_at_t0), File.read(fixture_cpu_at_t1) 
+        else
+          cpu_at_t0 = get_stat(host)
+          sleep 0.5
+          cpu_at_t1 = get_stat(host)
+          cpu_stats = parse_stats cpu_at_t0, cpu_at_t1 
+        end
+
+        {:host => host, :cpu => cpu_stats}
+      end
+
+      private #methods
+      def proc_stat_struct(cpu_times)
+        parts = cpu_times.split(/\n/).first.split
+        times = parts[1..-1].map(&:to_i)
+        CpuStats[*times].tap {|r| r[:total] = times.reduce(:+)}
+      end
+
+      def parse_stats(cpu_at_t0, cpu_at_t1)
+        cpu0 = proc_stat_struct cpu_at_t0
+        cpu1 = proc_stat_struct cpu_at_t1
+        idle  = cpu1.idle - cpu0.idle
+        total = cpu1.total - cpu0.total
+        usage = total - idle
+        # {:cpu_usage => ("%.1f%%" % (100.0 * usage / total))}
+        {:usage => (100.0 * usage / total).round}
+      end
+
+      def get_stat(remote, opts={})
+        Net::SFTP.start(remote, @username, :keys => @pub_key ) do |scp|
+          return scp.download!('/proc/stat').split('\n').first
+        end
+      end
+    end
+  end
+end

data/lib/silw/plugins/diskio.rb

@@ -0,0 +1,70 @@
+require 'net/sftp'
+require 'json'
+
+module Silw
+  module Plugins
+
+    # verify the disk usage on a remote host using the contents of
+    # /proc/diskstats file.
+    # See: https://www.kernel.org/doc/Documentation/ABI/testing/procfs-diskstats
+    #
+    # return a JSON containing the disk [read, write] stats
+    class Diskio
+      attr_accessor :diskstats
+
+      def run(args)
+        host = args[:at]
+
+        if fixture_name = args[:fixture]
+          diskstats = parse_diskstats File.read(fixture_name)
+        else
+          diskio_then = parse_diskstats get_diskstats(host)
+          sleep 1
+          diskio_now = parse_diskstats get_diskstats(host)
+
+          # disk [read, write] stats
+          diskstats = [diskio_now[0]-diskio_then[0], diskio_now[1]-diskio_then[1]]
+        end
+
+        {:host => host, :diskio => diskstats}
+      end
+
+      private
+      def parse_diskstats(txt)
+        diskstats = txt.split(/\n/).collect { |x| x.strip }
+        rowcount = diskstats.count
+
+        rowcount.times do |i|
+           diskstats[i] = diskstats[i].gsub(/\s+/m, ' ').split(' ')
+         end
+
+         columns_array = []
+         rowcount.times do |i|
+           columns_array << [diskstats[i][3],diskstats[i][7]]
+         end
+
+         columncount = columns_array[0].count
+
+         total_read_writes = []
+         columncount.times do |i|
+           total_read_writes[i] = 0
+         end
+
+         columncount.times do |j|
+           rowcount.times do |k|
+             total_read_writes[j] = columns_array[k][j].to_i + total_read_writes[j]
+           end
+         end
+
+        total_read_writes
+      end
+
+
+      def get_diskstats(remote)
+        Net::SFTP.start(remote, @username, :keys => @pub_key) do |scp|
+          return scp.download!('/proc/diskstats')
+        end
+      end
+    end
+  end
+end

data/lib/silw/plugins/mem.rb

@@ -0,0 +1,43 @@
+require 'net/sftp'
+
+module Silw
+  module Plugins
+
+    # Meminfo - report the memory stats collected from a remote system.
+    # For more details about meminfo see this featured article: /proc/meminfo Explained, at:
+    #  - http://www.redhat.com/advice/tips/meminfo.html
+    #
+    # @return - a JSON containing the main memory stats
+    class Mem
+      attr_accessor :mem
+
+      def run(args)        
+        host = args[:at]
+
+        if fixture_name = args[:fixture]
+          mem = parse_meminfo File.read(fixture_name)
+        else
+          mem = parse_meminfo get_meminfo(host)
+        end
+
+        {:host => host, :mem => mem}
+      end
+      
+      private
+      def parse_meminfo(txt)
+        meminfo   = txt.split(/\n/).collect{|x| x.strip}
+        memtotal  = meminfo[0].gsub(/[^0-9]/, "").to_f
+        memfree   = meminfo[1].gsub(/[^0-9]/, "").to_f
+        memactive = meminfo[5].gsub(/[^0-9]/, "").to_f
+        {:total => memtotal.round, :active => memactive.round, :free => memfree.round, 
+         :usagepercentage => ((memactive * 100) / memtotal).round}
+      end
+
+      def get_meminfo(remote, opts={})
+        Net::SFTP.start(remote, @username, :keys => @pub_key ) do |scp|
+          return scp.download!('/proc/meminfo')
+        end
+      end
+    end
+  end
+end

data/lib/silw/server.rb

@@ -0,0 +1,46 @@
+require "sinatra/content_for"
+
+module Silw
+  class Server < Sinatra::Base
+    STATIC_PATHS = ["/favicon.ico", "/img"]
+
+    app_dir = File.dirname(File.expand_path(__FILE__))
+
+    set :views,         "#{app_dir}/views"
+    set :public_folder, "#{app_dir}/public"
+
+    use Rack::ShowExceptions
+    use Rack::MethodOverride
+
+    use Rack::StaticCache,
+      urls: STATIC_PATHS,
+      root: File.expand_path('./public/', __FILE__)
+
+    use Rack::Session::Cookie,  
+      key: '<#>&wksjuIuwo!',
+      domain: "localhost",
+      path: '/',
+      expire_after: 14400,
+      secret: '*987^514('
+    
+    helpers Sinatra::ContentFor
+    helpers Silw::Helpers
+
+    include Rack::Utils
+    
+    configure do
+      disable :protection
+      enable  :logging
+    end
+
+    get '/' do
+      # "Hello World! :#{settings.agents}:"
+      haml :index
+    end
+
+    # 404
+    not_found do
+      haml :"404"
+    end
+  end
+end

data/lib/silw/version.rb

@@ -0,0 +1,3 @@
+module Silw
+  VERSION = "0.0.1"
+end

data/lib/silw/views/index.haml

@@ -0,0 +1,30 @@
+.row
+  .span7
+    -unless settings.agents.empty?
+      .well
+        - settings.agents.each_value do |agent|
+          %table.table-striped
+            %thead
+              %tr
+                %th(width="20%" align="right" nowrap)
+                  .span2
+                    %span.label.label-important= agent.host
+                %th
+                -unless agent.plugins.empty?
+                  -agent.plugins.each_key do |k|
+                    %th(align="left")
+                      %span.label.label= k
+            %tbody
+              -unless agent.plugins.empty?
+                %tr
+                  %td(valign="top")
+                    %small.label.label-inverse= agent.time
+                  %td
+                    %span 
+                         
+                  -agent.plugins.each do |k, v|
+                    %td(valign="top")
+                      = partial k.to_s, :plugin => v
+    -else
+      pending ...
+

data/lib/silw/views/layout.haml

@@ -0,0 +1,50 @@
+!!! 5
+%html
+  %head
+    %title= "SILW"
+    %meta{ :"http-equiv" => "content-type", :content => "text/html; charset=UTF-8" }
+    %meta{ :name => "viewport", :content => "width=device-width, initial-scale=1.0" }
+    %link{ :href => "//netdna.bootstrapcdn.com/twitter-bootstrap/2.3.2/css/bootstrap-combined.min.css",
+      :media => "screen", :rel => "stylesheet", :type => "text/css" }
+  %body
+    .container-fluid
+      %header
+        %h2
+          %a{:href => '/'} SILW
+        %p.muted
+          Various system metrics frequently aggregated from multiple remote instances.
+        %p
+          autorefresh on/off
+          %button#button.btn.btn-mini
+            %a#refresh-switch(href="#")
+              %i.icon-stop
+      = yield
+
+      %footer
+        %p        
+
+    %script{ :type => 'text/javascript', :src => "//ajax.googleapis.com/ajax/libs/jquery/1.7.2/jquery.min.js" }
+    %script{ :type => 'text/javascript', :src => "//netdna.bootstrapcdn.com/twitter-bootstrap/2.3.2/js/bootstrap.min.js" }
+    :javascript
+      $(document).ready(function () {
+        var interval = 10;   //number of seconds before page refresh
+        var refresh = function() {
+          setTimeout(function() {
+            if( $("#refresh-switch > i").attr("class").match(/^icon-(.*)$/)[1] === "stop"){
+              location.reload(true);
+              $("#refresh-switch > i").attr("class", "icon-stop");
+            }
+           }, interval * 1000);
+        };
+
+        $("#button").click(function(e) {
+          if( $("#refresh-switch > i").attr("class").match(/^icon-(.*)$/)[1] === "stop"){
+            $("#refresh-switch > i").attr("class", "icon-play");
+            clearInterval(refresh);
+          }else{
+            location.reload(true);
+          }
+        });
+
+        refresh();
+      });

data/lib/silw/views/partials/_cpu.haml

@@ -0,0 +1,9 @@
+%ul.unstyled
+  - if plugin.is_a?(Hash)
+    - plugin.each_entry do |k, v|
+      %li
+        %small
+          %strong= "#{k}:"
+          %span= "#{v}%"
+  -else
+    %small.muted=plugin

data/lib/silw/views/partials/_diskio.haml

@@ -0,0 +1,12 @@
+%ul.unstyled
+  - unless plugin.nil?
+    %li
+      %small
+        %strong= "reads:"
+        %span= "#{plugin[0]}"
+    %li
+      %small
+        %strong= "writes:"
+        %span= "#{plugin[1]}"
+  -else
+    %small.muted=plugin

data/lib/silw/views/partials/_mem.haml

@@ -0,0 +1,12 @@
+%ul.unstyled
+  - if plugin.is_a?(Hash)
+    - plugin.each_entry do |k, v|
+      %li
+        %small
+          %strong= "#{k}:"
+          -if k.match(/^usage/)
+            %span= "#{v}%"
+          -else
+            %span= like_filesize(v)
+  -else
+    %small.muted=plugin