elesai 0.4.0

data/LICENSE

@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2012 by Evernote Corporation, All rights reserved.
+ *
+ * Use of the source code and binary libraries included in this package
+ * is permitted under the following terms:
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.    
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License. You may obtain a 
+ * copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ */

data/README.md

@@ -0,0 +1,81 @@
+# OVERVIEW
+
+*Elesai* is a wrapper around LSI's `MegaCli` utility that provides access to common types of information about the RAID controllers via a `show` action without the need to speak martian. It is a line-oriented tool so that it can be combined with other Unix command-line tools to process and manipulate the data (i.e., `sed`, `awk`, and friends). It also provides a `check` action (currently as a Nagios plugin in both active and passive modes) which monitors the health of the array and its components and reports it accordingly (this is not yet configurable).
+
+# SYNOPSIS
+
+    elesai [global-options] <action> [action-options] [<component>]
+
+where:
+
+* `<action>` is one of `show` or `check`
+* `<component>` is one of `virtualdrive` (or `vd`) or `physicaldrive` (or `pd`) (for `show` action)
+
+Global options include:
+
+* `-d`, `--debug`: enable *debug* mode
+* `-f`, `--fake DIRECTORY`: specifies path to directory containing output of MegaCli invocations:
+	* `ldlist_aall`: output from `MegaCli -pdlist -aall`
+	* `ldpdinfo_aall`: output from `MegaCli -ldpdinfo -aall`
+* `-m`, `--megacli MEGACLI`: path to `MegaCli` binary (if noth in `$PATH`)
+* `-a`, `--about`: display general information about `elesai`
+* `-V`, `--version`: display `elesai`'s version
+
+The `<check>` can have options specific to itself:
+
+* `-M`, `--monitor MONITOR`:            Monitoring system (default: `nagios`)
+* `-m`, `--mode [active|passive]`:      Monitoring mode
+* `-H`, `--nsca_hostname HOSTNAME`:     NSCA hostname to send passive checks
+* `-c`, `--config CONFIG`:              Path to Senedsa (send_nsca) configuration
+* `-S`, `--svc_descr SVC_DESCR`:        Nagios service description
+
+*Elesai* uses [Senedsa](https://rubygems.org/gems/senedsa "Senedsa") for Nagios passive check submission, which can use a configuration file to set options.
+
+# Invocations
+
+## Normal Invocation
+
+    root@boxie:~# elesai show pd | sort -k 4
+    [PD]   e253s3   27       online:spunup     1.82TB   HDD  SATA   0   0   9WM1B7VDST32000644NS SN11
+    [PD]   e252s7   23       online:spunup     1.82TB   HDD  SATA   0   0   9WM1FX1LST32000644NS SN11
+    [PD]   e253s0   24       online:spunup     1.82TB   HDD  SATA   0   0   9WM1GF2NST32000644NS SN11
+    [PD]   e253s1   25       online:spunup     1.82TB   HDD  SATA   0   0   9WM1GY85ST32000644NS SN11
+    [PD]   e252s6   22       online:spunup     1.82TB   HDD  SATA   0   0   9WM1GYKJST32000644NS SN11
+    [PD]   e253s2   26       online:spunup     1.82TB   HDD  SATA   0   0   9WM1HA0NST32000644NS SN11
+    [PD]   e253s5   29       online:spunup     1.82TB   HDD  SATA   0   0   9WM7L834ST32000644NS SN12
+    [PD]   e252s4   12       online:spunup   223.06GB   SSD  SATA   0   0   CVPR138405AQ300EGN INTEL SSDSA2CW300G3 4PC10362
+    [PD]   e252s2    9       online:spunup   223.06GB   SSD  SATA   0   0   CVPR140100MQ300EGN INTEL SSDSA2CW300G3 4PC10362
+    [PD]   e252s0   11       online:spunup   223.06GB   SSD  SATA   0   0   CVPR140201KZ300EGN INTEL SSDSA2CW300G3 4PC10362
+    [PD]   e252s1   10       online:spunup   223.06GB   SSD  SATA   0   0   CVPR141300K9300EGN INTEL SSDSA2CW300G3 4PC10362
+    [PD]   e252s3    8       online:spunup   223.06GB   SSD  SATA   0   0   CVPR141301KG300EGN INTEL SSDSA2CW300G3 4PC10362
+    [PD]   e253s4   30       failed:spunup     1.82TB   HDD  SATA   0   0   9WM5Y4AEST32000644NS SN12
+    [PD]   e252s5   13     hotspare:spunup   223.06GB   SSD  SATA   0   0   CVPR140100TT300EGN INTEL SSDSA2CW300G3 4PC10362
+    
+## Remote Invocation
+
+Pipe output to `elesai`:
+
+	root@boxie:~# ssh server.example.com sudo MegaCli -pdlist -aall | elesai show pd
+	[PD]   e252s0   16       online:spunup   278.46GB   HDD   SAS   0   0  a0  SEAGATE ST3300657SS 00066SJ01W4G
+	[PD]   e252s1   17       online:spunup   278.46GB   HDD   SAS   0   0  a0  SEAGATE ST3300657SS 00066SJ01TTR
+	[PD]   e252s2   20       online:spunup   278.46GB   HDD   SAS   0   0  a0  SEAGATE ST3300657SS 00066SJ02BCX
+	[PD]   e252s3   21       online:spunup   278.46GB   HDD   SAS   0   0  a0  SEAGATE ST3300657SS 00066SJ025LP
+	[PD]   e252s4   18       online:spunup     1.82TB   HDD  SATA   0   0  a0  9WM1G6MXST32000644NS SN11
+	[PD]   e252s5   28       online:spunup     1.82TB   HDD  SATA   0   0  a0  9WM0FFYCST32000644NS SN11
+	[PD]   e252s6   22       online:spunup     1.82TB   HDD  SATA   0   0  a0  9WM1GYKJST32000644NS SN11
+	[PD]   e252s7   23       online:spunup     1.82TB   HDD  SATA   0   0  a0  9WM1FX1LST32000644NS SN11
+	[PD]   e253s0   24       online:spunup     1.82TB   HDD  SATA   0   0  a0  9WM1GF2NST32000644NS SN11
+	[PD]   e253s1   25       online:spunup     1.82TB   HDD  SATA   0   0  a0  9WM1GY85ST32000644NS SN11
+	[PD]   e253s2   26       online:spunup     1.82TB   HDD  SATA   0   0  a0  9WM1HA0NST32000644NS SN11
+	[PD]   e253s3   27       online:spunup     1.82TB   HDD  SATA   0   0  a0  9WM1B7VDST32000644NS SN11
+	[PD]   e253s4   30       online:spunup     1.82TB   HDD  SATA   0   0  a0  9WM5Y4AEST32000644NS SN12
+	[PD]   e253s5   29       online:spunup     1.82TB   HDD  SATA   0   0  a0  9WM7L834ST32000644NS SN12
+	[PD]   e253s6   31  unconfigured(bad):     0.00KB   HDD   SAS   0   0  a0  SEAGATE ST33000650SS 0003Z29182VM
+	[PD]   e253s7   32  unconfigured(bad):     0.00KB   HDD   SAS   0   0  a0  SEAGATE ST33000650SS 0003Z291A3QV
+    
+# STATUS
+
+Very much in progress. The tool does not yet poke MegaCli itself.
+
+
+

data/bin/check_elesai

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+
+lib = File.expand_path(File.dirname(__FILE__) + '/../lib')
+$LOAD_PATH.unshift(lib) if File.directory?(lib) && !$LOAD_PATH.include?(lib)
+
+require 'socket'
+require 'rubygems'
+require 'elesai'
+require 'elesai/cli'
+
+module Elesai
+
+  ID = File.basename($PROGRAM_NAME).to_sym
+
+  app = CLI.new(ARGV)
+  app.run
+
+end

data/bin/elesai

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+
+lib = File.expand_path(File.dirname(__FILE__) + '/../lib')
+$LOAD_PATH.unshift(lib) if File.directory?(lib) && !$LOAD_PATH.include?(lib)
+
+require 'socket'
+require 'rubygems'
+require 'elesai'
+require 'elesai/cli'
+
+module Elesai
+
+  ID = File.basename($PROGRAM_NAME).to_sym
+
+  app = CLI.new(ARGV)
+  app.run
+
+end

data/lib/elesai/about.rb

@@ -0,0 +1,5 @@
+require 'elesai/version'
+module Elesai
+  ME = :elesai
+  ABOUT = "#{ME} v#{VERSION}\nhttps://github.com/evernote/ops-#{ME}\nCopyright (c) 2012 by Evernote Corporation\nLicensed under the Apache License, Version 2.0 (http://www.apache.org/licenses/LICENSE-2.0)"
+end

data/lib/elesai/cli.rb

@@ -0,0 +1,203 @@
+require 'optparse'
+require 'senedsa'
+include Senedsa
+require 'elesai/version'
+require 'elesai/about'
+
+module Elesai
+
+  class CLI
+
+    COMMANDS = %w(show check)
+    COMPONENTS = %w(virtualdrive vd physicaldrive pd)
+    DEFAULT_CONFIG_FILE = File.join(ENV['HOME'],"/.senedsa/config")
+
+    def initialize(arguments)
+      @arguments = arguments
+
+      @global_options = { :debug => false, :megacli => 'MegaCli' }
+      @action_options = { :monitor => 'nagios', :mode => 'active' }
+      @action = nil
+    end
+
+    def run
+      begin
+        parsed_options?
+
+        @log = Elesai::Logger.instance.log
+        @log.level = Log4r::INFO unless @global_options[:debug]
+
+        config_options?
+        arguments_valid?
+        options_valid?
+        process_options
+        process_arguments
+        process_command
+
+      rescue => e #ArgumentError, OptionParser::MissingArgument, Senedsa::SendNsca::ConfigurationError => e
+        output_message e.message, 1
+      end
+    end
+
+    protected
+
+      def parsed_options?
+        opts = OptionParser.new
+
+        opts.banner = "Usage: #{ID} [options] <action> [options]"
+        opts.separator ""
+        opts.separator "Actions:"
+        opts.separator "    show                             Displays component information"
+        opts.separator "    check                            Performs health checks"
+        opts.separator ""
+        opts.separator "General options:"
+        opts.on('-m', '--megacli MEGACLI',                String,              "Path to MegaCli binary")                             { |megacli| @global_options[:megacli] = megacli }
+        opts.on('-f', '--fake DIRECTORY',                 String,              "Path to directory with Megacli output")              { |dir| @global_options[:fake] = dir }
+        opts.on('-d', '--debug',                                               "Enable debug mode")                                  { @global_options[:debug] = true}
+        opts.on('-a', '--about',                                               "Display #{ID} information")                          { output_message ABOUT, 0 }
+        opts.on('-V', '--version',                                             "Display #{ID} version")                              { output_message VERSION, 0 }
+        opts.on_tail('--help',                                                 "Show this message")                                  { @global_options[:HELP] = true }
+
+        actions = {
+            :show => OptionParser.new do |aopts|
+                aopts.banner = "Usage: #{ID} [options] show <component>"
+                aopts.separator ""
+                aopts.separator "      <component> is physicaldisk|pd, virtualdisk|vd"
+              end,
+            :check => OptionParser.new do |aopts|
+                aopts.banner = "Usage: #{ID} [options] check [check_options]"
+                aopts.separator ""
+                aopts.separator "Check Options"
+                aopts.on('-M', '--monitor [nagios]',            [:nagios],            "Monitoring system")                                 { |monitor| @action_options[:monitor] = monitor }
+                aopts.on('-m', '--mode [active|passive]',       [:active, :passive],  "Monitoring mode")                                   { |mode| @action_options[:mode] = mode }
+                aopts.on('-H', '--nsca_hostname HOSTNAME',      String,               "NSCA hostname to send passive checks")              { |nsca_hostname| @action_options[:nsca_hostame] = nsca_hostname }
+                aopts.on('-c', '--config CONFIG',               String,               "Path to Senedsa (send_nsca) configuration" )        { |config| @action_options[:senedsa_config] = config }
+                aopts.on('-S', '--svc_descr SVC_DESR',          String,               "Nagios service description")                        { |svc_descr| @action_options[:svc_descr] = svc_descr }
+              end
+            }
+
+        opts.order!
+        output_message opts, 0 if @arguments.size == 0 or @global_options[:HELP]
+
+        @action = ARGV.shift.to_sym
+        actions[@action].order!
+      end
+
+      def config_options?
+        cfg_file = nil
+        cfg_file = @action_options[:senedsa_config] unless @action_options[:senedsa_config].nil?
+        cfg_file = DEFAULT_CONFIG_FILE if @action_options[:senedsa_config].nil? and File.readable? DEFAULT_CONFIG_FILE
+
+        unless cfg_file.nil?
+          @action_options.merge!(Senedsa::SendNsca.configure(cfg_file))
+          @action_options[:senedsa_config] = cfg_file
+        end
+      end
+
+      def arguments_valid?
+        true
+      end
+
+      def options_valid?
+        case @action
+          when :check
+            raise OptionParser::MissingArgument, "NSCA hostname (-H) must be specified" if @action_options[:nsca_hostname].nil?
+            raise OptionParser::MissingArgument, "service description (-S) must be specified" if @action_options[:svc_descr].nil?
+        end
+      end
+
+      def process_options
+        true
+      end
+
+      def process_arguments
+        @action_options[:hint] = @arguments[0].nil? ? nil : @arguments[0].to_sym
+        true
+      end
+
+      def process_command
+
+        @lsi = LSIArray.new(:megacli => @global_options[:megacli], :fake => @global_options[:fake], :hint => @action_options[:hint])
+
+        case @action
+          when :show then run_show
+          when :check then run_check
+        end
+
+      end
+
+      def run_show
+
+        raise ArgumentError, "missing component" if @arguments.size == 0
+        component = @arguments[0]
+
+        case component
+          when 'virtualdrive', 'vd'
+            @lsi.virtualdrives.each do |virtualdrive|
+              print "#{virtualdrive}\n"
+            end
+          when 'physicaldrive', 'pd'
+            @lsi.physicaldrives.each do |id,physicaldrive|
+              print "#{physicaldrive}\n"
+            end
+          else
+            raise ArgumentError, "invalid component #{component}"
+        end
+      end
+
+      def run_check
+
+        plugin_output = ""
+        plugin_status = ""
+
+        @lsi.physicaldrives.each do |id,physicaldrive|
+          drive_plugin_string = "[PD:#{physicaldrive._id}:#{physicaldrive[:size]}:#{physicaldrive[:mediatype]}:#{physicaldrive[:pdtype]}]"
+          unless physicaldrive[:firmwarestate].state == :online or physicaldrive[:firmwarestate].state == :hotspare
+            plugin_output += " #{drive_plugin_string}:#{physicaldrive[:firmwarestate].state}"
+            plugin_status = :warning if plugin_status.empty?
+          end
+          unless physicaldrive[:mediaerrorcount].to_i == 0
+            plugin_output += " #{drive_plugin_string}:me:#{physicaldrive[:mediaerrorcount]}"
+            plugin_status = :warning if plugin_status.empty?
+          end
+          unless physicaldrive[:predictivefailurecount].to_i == 0
+            plugin_output += " #{drive_plugin_string}:pf:#{physicaldrive[:predictivefailurecount]}"
+            plugin_status = :warning if plugin_status.empty?
+          end
+        end
+
+        plugin_output = "no RAID subsystems errors found" if plugin_output.empty? and plugin_status.empty?
+        plugin_status = :ok if plugin_status.empty?
+
+        case @action_options[:monitor]
+          when 'nagios'
+            case @action_options[:mode]
+              when 'active'
+                puts "#{plugin_status}: #{plugin_output}"
+                exit SendNsca::STATUS[plugin_status]
+              when 'passive'
+                sn = SendNsca.new Socket.gethostname,'raid/lsi'
+                sn.nsca_hostname = @command_opts[:nsca_hostname]
+                begin
+                  sn.send plugin_status , plugin_output
+                rescue SendNsca::SendNscaError => e
+                  $stderr.write "#{ME}: error: send_nsca failed: #{e.message}\n"
+                  exit
+                end
+            end
+        end
+      end
+
+      def output_message(message, exitstatus=nil)
+        m = (! exitstatus.nil? and exitstatus > 0) ? "%s: error: %s" % [ID, message] : message
+        $stderr.write "#{m}\n"
+        exit exitstatus unless exitstatus.nil?
+      end
+
+  end
+end
+
+
+
+
+

data/lib/elesai/logger.rb

@@ -0,0 +1,20 @@
+require 'singleton'
+require 'log4r'
+
+module Elesai
+
+  class Logger
+
+    include Singleton
+
+    attr_reader :log
+
+    def initialize
+      @log = Log4r::Logger.new("elesai")
+      @log.add Log4r::StderrOutputter.new('console', :formatter => Log4r::PatternFormatter.new(:pattern => "%c [%l] %m"), :level => Log4r::DEBUG)
+    end
+
+
+
+  end
+end

data/lib/elesai/lsi.rb

@@ -0,0 +1,210 @@
+module Elesai
+
+  class LSIArray
+
+    attr_reader :adapters, :virtualdrives, :physicaldrives, :enclosures
+
+    def initialize(opts)
+      @adapters = []
+      @virtualdrives = []
+      @physicaldrives = {}
+      @enclosures = []
+      @spans = []
+
+      case opts[:hint]
+        when :pd,:physicaldrive
+          PDlist_aAll.new.parse!(self,opts)
+        when :vd, :virtualdrive
+          puts "vd!"
+          LDPDinfo_aAll.new.parse!(self,opts)
+        else
+          PDlist_aAll.new.parse!(self,opts)
+          LDPDinfo_aAll.new.parse!(self,opts)
+      end
+    end
+
+    def add_adapter(a)
+      @adapters[a[:id]] = a if @adapters[a[:id]].nil?
+    end
+
+    def add_virtualdrive(vd)
+      @virtualdrives.push(vd)
+    end
+
+    def add_physicaldrive(pd)
+      @physicaldrives[pd._id] = pd if @physicaldrives[pd._id].nil?
+      @physicaldrives[pd._id]
+    end
+
+    def to_s
+      lsiarrayout = "LSI Array\n"
+      @adapters.each do |adapter|
+        lsiarrayout += "  adapter #{adapter.id}\n"
+        adapter.virtualdrives.each do |virtualdrive|
+          lsiarrayout += "    +--+ #{virtualdrive.to_str}\n"
+          virtualdrive.physicaldrives.each do |id,physicaldrive|
+            lsiarrayout += "    |  |-- pd #{physicaldrive.to_str}\n"
+          end
+        end
+      end
+      lsiarrayout
+    end
+
+    ### Adapter
+
+    class Adapter < Hash
+
+      def initialize
+        self[:virtualdrives] = []
+        self[:physicaldrives] = {}
+        super
+      end
+
+      def _id
+        "#{self[:id]}"
+      end
+
+      def type
+        :adapter
+      end
+
+      def type_of?(type)
+        self.type == type
+      end
+
+      def inspect
+        "#{self.class}:#{self.__id__}"
+      end
+
+      def add_physicaldrive(pd)
+        self[:physicaldrives][pd._id] = pd unless self[:physicaldrives][pd._id].nil?
+      end
+
+    end
+
+    ### Virtual Drive
+
+    class VirtualDrive < Hash
+
+      STATES = {
+          :optimal              => 'Optimal',
+          :degraded             => 'Degraded',
+          :partial_degraded     => 'Partial Degraded',
+          :failed               => 'Failed',
+          :offline              => 'Offline'
+      }
+
+      class Size < Struct.new(:number, :unit)
+        def to_s ; "%8.2f%s" % [self.number,self.unit] end
+      end
+      class RaidLevel < Struct.new(:primary, :secondary)
+        def to_s ; "raid%s:raid%s" % [self.primary,self.secondary] end
+      end
+
+      def initialize
+        self[:physicaldrives] = []
+      end
+
+      def _id
+        self[:targetid]
+      end
+
+      def type
+        :virtualdrive
+      end
+
+      def type_of?(type)
+        self.type == type
+      end
+
+      def inspect
+        "#{self.class}:#{self.__id__}"
+      end
+
+      def add_physicaldrive(pd)
+
+      end
+
+      def to_s
+        "[VD] %4s %18s %s %s %d" % [ self._id, self[:state], self[:size], self[:raidlevel], self[:physicaldrives].size ]
+      end
+
+    end
+
+    ### Physical Drive
+
+    class PhysicalDrive < Hash
+
+      STATES = {
+          :online               => 'Online',
+          :unconfigured_good    => 'Unconfigured(good)',
+          :hotspare             => 'Hotspare',
+          :failed               => 'Failed',
+          :rebuild              => 'Rebuild',
+          :unconfigured_bad     => 'Unconfigured(bad)',
+          :missing              => 'Missing',
+          :offline              => 'Offline'
+      }
+
+      SPINS = {
+          :spun_up              => 'Spun up'
+      }
+
+      class Size < Struct.new(:number, :unit)
+        def to_s ; "%8.2f%s" % [self.number,self.unit] end
+      end
+      class FirmwareState < Struct.new(:state, :spin)
+        def to_s
+          "#{self.state}:#{self.spin}"
+        end
+      end
+
+      def initialize
+        self[:_adapter] = nil
+        self[:_virtualdrives] = []
+      end
+
+      def _id
+        "e#{self[:enclosuredeviceid].to_s}s#{self[:slotnumber].to_s}".to_sym
+      end
+
+      def type
+        :physicaldrive
+      end
+
+      def type_of?(type)
+        self.type == type
+      end
+
+      def to_s
+        keys = [:deviceid, :firmwarestate, :coercedsize, :mediatype, :pdtype, :mediaerrorcount, :predictivefailurecount,:inquirydata]
+        #"[PD] %8s %4s %19s %8.2f%s %5s %5s %3d %3d   %s" % [ self.id, @deviceid, "#{@state}:#{@spin}", @_size.number, @_size.unit, @mediatype, @pdtype, @mediaerrors, @predictivefailure, @inquirydata  ]
+        "[PD] %8s %4s %19s %s %5s %5s %3d %3d  a%s  %s" % [ self._id, self[:deviceid], self[:firmwarestate], self[:coercedsize], self[:mediatype], self[:pdtype], self[:mediaerrorcount], self[:predictivefailurecount], self[:_adapter]._id, self[:inquirydata] ]
+      end
+
+      def inspect
+        "#{self.class}:#{self.__id__}"
+      end
+
+      def add_adapter(a)
+        self[:_adapter] = a
+      end
+
+      def get_adapter
+        self[:_adapter]
+      end
+
+      def add_virtualdrive(vd)
+         self[:_virtualdrives][vd._id] = vd if self[:_virtualdrives][vd._id].nil?
+      end
+
+      def get_virtualdrive(vd_id)
+        self[:_virtualdrives][vd_id]
+      end
+
+      def get_virtualdrives
+        self[:_virtualdrives]
+      end
+    end
+  end
+end

data/lib/elesai/megacli.rb

@@ -0,0 +1,393 @@
+require 'workflow'
+require 'open3'
+
+module Elesai
+
+  class Megacli
+
+    include Workflow
+
+    ADAPTER_RE = /^Adapter\s+#*(?<value>\d+)/
+    VIRTUALDRIVE_RE = /^Virtual\s+Drive:\s+\d+\s+\((?<key>Target\s+Id):\s+(?<value>\d+)\)/
+    SPAN_RE = /^Span:\s+(?<value>\d+)/
+    PHYSICALDRIVE_RE = /^(?<key>Enclosure\s+Device\s+ID):\s+(?<value>\d+)/
+    ATTRIBUTE_RE = /^(?<key>[A-Za-z0-9()\s#]+):(?<value>.*)/
+    EXIT_RE = /^Exit Code: /
+
+    ### Context
+
+    class Context
+
+      def initialize(current_state,lsi)
+        current_state.meta[:context] = { :stack => [], :adapter => nil, :virtualdrive => nil, :physicaldrive => nil }
+        @context = current_state.meta[:context]
+        @lsi = lsi
+        @log = Elesai::Logger.instance.log
+      end
+
+      def open(component)
+        @log.debug "         * Open #{component.inspect}"
+        @context[:stack].push(component)
+        @context[component.type] = component
+        @log.debug "           + context: #{@context[:stack]}"
+      end
+
+      def flash!(new_state)
+        new_state.meta[:context] = @context
+        @context = nil
+        @context = new_state.meta[:context]
+        @log.debug "         + Flash context: #{@context[:stack]}"
+      end
+
+      def close
+        component = @context[:stack].pop
+        @context[component.type] = nil
+        @log.debug "         * Close #{component.inspect}"
+        if component.type_of? :physicaldrive
+          pd = @lsi.add_physicaldrive(component)
+          pd.add_adapter(adapter)
+          pd.add_virtualdrive(virtualdrive) unless virtualdrive.nil?
+          adapter.add_physicaldrive(pd)
+        elsif component.type_of? :virtualdrive
+          vd = @lsi.add_virtualdrive(component)
+        elsif component.type_of? :adapter
+          @lsi.add_adapter(component)
+        end
+        @log.debug "           + context: #{@context[:stack]}"
+      end
+
+      def current
+        @context[:stack][-1]
+      end
+
+      def adapter
+        @context[:adapter]
+      end
+
+      def virtualdrive
+        @context[:virtualdrive]
+      end
+
+      def physicaldrive
+        @context[:physicaldrive]
+      end
+
+    end
+
+    ### State Machine Handlers
+
+    # Start
+
+    def on_start_exit(new_state, event, *args)
+      @log.debug "      [#{current_state}]: on_exit : #{event} -> #{new_state}; args: #{args}"
+      @context = Context.new(current_state,@lsi)
+    end
+
+    # Adapter
+
+    def adapter_line(adapter,key,value)
+      @log.debug "  [#{current_state}] event adapter_line: new #{adapter.inspect}"
+      adapter[key.to_sym] = value.to_i
+    end
+
+    def on_adapter_entry(old_state, event, *args)
+      @log.debug "        [#{current_state}] on_entry: leaving #{old_state}; args: #{args}"
+
+      @context.close unless @context.current.nil? or @context.current.type_of? :adapter
+      @context.open args[0]
+
+    end
+
+    def on_adapter_exit(new_state, event, *args)
+      @log.debug "      [#{current_state}] on_exit: entering #{new_state}; args: #{args}"
+      @context.flash!(new_state)
+    end
+
+    # Virtual Drive
+
+    def virtualdrive_line(virtualdrive,key,value)
+      @log.debug "  [#{current_state}] event: virtualdrive_line: new #{virtualdrive.inspect}"
+      virtualdrive[key.to_sym] = value.to_i
+    end
+
+    def on_virtualdrive_entry(old_state, event, *args)
+      @log.debug "        [#{current_state}] on_entry: leaving #{old_state}; args: #{args}"
+
+      unless @context.current.nil?
+        if @context.current.type_of? :virtualdrive
+          @context.close
+        end
+      end
+      virtualdrive = args[0]
+      @context.open virtualdrive
+    end
+
+    def on_virtualdrive_exit(new_state, event, *args)
+      @log.debug "      [#{current_state}] on_exit: entering #{new_state}; args: #{args}"
+      @context.flash!(new_state)
+    end
+
+    # Physical Drive
+
+    def physicaldrive_line(physicaldrive,key,value)
+      @log.debug "  [#{current_state}] event: physicaldrive_line: new #{physicaldrive.inspect}"
+      physicaldrive[key.to_sym] = value.to_i
+    end
+
+    def on_physicaldrive_entry(old_state, event, *args)
+      @log.debug "        [#{current_state}] on_entry: leaving #{old_state}; args: #{args}"
+      @context.open args[0]
+    end
+
+    def on_physicaldrive_exit(new_state, event, *args)
+      @log.debug "      [#{current_state}] on_exit: entering #{new_state}; args: #{args}"
+      @context.flash!(new_state)
+    end
+
+    # Attribute
+
+    def attribute_line(key,value)
+      @log.debug "  [#{current_state}] event: attribute_line: #{key} => #{value}"
+    end
+
+    def on_attribute_entry(old_state, event, *args)
+      @log.debug "        [#{current_state}] entry: leaving #{old_state}; args: #{args}"
+
+
+      c = @context.current
+      k = args[0].to_sym
+      v = args[1]
+
+      # Some attributes require special treatment for our purposes
+
+      case k
+        when :coercedsize, :noncoercedsize, :rawsize, :size
+          m = /(?<number>[0-9\.]+)\s+(?<unit>[A-Z]+)/.match(v)
+          v = LSIArray::PhysicalDrive::Size.new(m[:number],m[:unit])
+        when :raidlevel
+          m = /Primary-(?<primary>\d+),\s+Secondary-(?<secondary>\d+)/.match(v)
+          v = LSIArray::VirtualDrive::RaidLevel.new(m[:primary],m[:secondary])
+        when :firmwarestate
+          st,sp = v.gsub(/\s/,'').split(/,/)
+          state = st.gsub(/\s/,'_').downcase.to_sym
+          spin = sp.gsub(/\s/,'_').downcase.to_sym unless sp.nil?
+          v = LSIArray::PhysicalDrive::FirmwareState.new(state,spin)
+        when :state
+          v = v.gsub(/\s/,'_').downcase.to_sym
+        when :mediatype
+          v = v.scan(/[A-Z]/).join
+        when :inquirydata
+          v = v.gsub(/\s+/,' ')
+      end
+      c[k] = v
+    end
+
+    def on_attribute_exit(new_state, event, *args)
+      @log.debug "      [#{current_state}] exit: entering #{new_state} throught event #{event}; args: #{args}"
+      @context.close if @context.current.type_of? :physicaldrive and event != :attribute_line
+
+      @context.flash!(new_state)
+    end
+
+    # Exit
+
+    def exit_line
+      @log.debug "  [#{current_state}] event: exit_line"
+    end
+
+    def on_exit_entry(new_state, event, *args)
+      @log.debug "      [#{current_state}] exit: entering #{new_state} throught event #{event}; args: #{args}"
+      until @context.current.nil? do
+        @context.close
+      end
+    end
+
+    ### Regular Expression Match Handlers
+
+    # Adapter
+
+    def adapter_match(match)
+      @log.debug "ADAPTER! #{match.string}"
+      key = 'id'
+      value = match[:value]
+      adapter_line!(LSIArray::Adapter.new,key,value)
+    end
+
+    # Virtual Drive
+
+    def virtualdrive_match(match)
+      @log.debug "VIRTUALDRIVE! #{match.string}"
+      key = match[:key].gsub(/\s+/,"").downcase
+      value = match[:value]
+      virtualdrive_line!(LSIArray::VirtualDrive.new,key,value)
+    end
+
+    # Physical Drive
+
+    def physicaldrive_match(match)
+      @log.debug "PHYSICALDRIVE! #{match.string}"
+      key = match[:key].gsub(/\s+/,"").downcase
+      value = match[:value]
+      physicaldrive_line!(LSIArray::PhysicalDrive.new,key,value)
+    end
+
+    # Attribute
+
+    def attribute_match(match)
+      @log.debug "ATTRIBUTE! #{match.string}"
+      key = match[:key].gsub(/\s+/,"").downcase
+      value = match[:value].strip
+      attribute_line!(key,value)
+    end
+
+    # Exit
+
+    def exit_match(match)
+      @log.debug "EXIT! #{match.string}"
+      exit_line!
+    end
+
+    ### Parse!
+
+    def parse!(lsi,opts)
+
+      @lsi = lsi
+      @log = Elesai::Logger.instance.log
+
+      if STDIN.tty?
+        if opts[:fake].start_with? '-'
+          megacli = opts[:megacli].nil? ? "Megacli" : opts[:megacli]
+          command = "#{megacli} #{opts[:fake]}"
+          output = Open3.popen3(command) do |stdin, stdout, stderr, wait_thr|
+            stdin.close
+            raise RuntimeError, stderr.gets.chomp unless wait_thr.value.exitstatus == 0
+            stdout.gets
+          end
+        else
+          output = File.read(opts[:fake])
+        end
+      else
+        output = STDIN.read
+      end
+
+      output.each_line do |line|
+        line.strip!
+        next if line == ''
+
+        case line
+          when ADAPTER_RE       then  adapter_match(ADAPTER_RE.match(line))
+          when VIRTUALDRIVE_RE  then  virtualdrive_match(VIRTUALDRIVE_RE.match(line))
+          when PHYSICALDRIVE_RE then  physicaldrive_match(PHYSICALDRIVE_RE.match(line))
+          when EXIT_RE          then  exit_match(EXIT_RE.match(line))
+          when ATTRIBUTE_RE     then  attribute_match(ATTRIBUTE_RE.match(line))
+          else raise StandardError, "cannot parse '#{line}'"
+        end
+
+        @log.debug "\n\n"
+      end
+    end
+
+  end
+
+  class PDlist_aAll < Megacli
+
+    def parse!(lsi,opts)
+      fake = opts[:fake].nil? ? "-pdlist -aall" : File.join(opts[:fake],"pdlist_aall")
+      super lsi, :fake => fake, :megacli => opts[:megacli]
+    end
+
+    workflow do
+
+      state :start do
+        event :adapter_line, :transitions_to => :adapter
+        event :exit_line, :transitions_to => :exit
+      end
+
+      state :adapter do
+        event :adapter_line, :transitions_to => :adapter                 # empty adapter
+        event :physicaldrive_line, :transitions_to => :physicaldrive
+        event :exit_line, :transitions_to => :exit
+      end
+
+      state :physicaldrive do
+        event :attribute_line, :transitions_to => :physicaldrive
+        event :exit_line, :transitions_to => :exit
+        event :adapter_line, :transitions_to => :adapter
+        event :physicaldrive_line, :transitions_to => :physicaldrive
+        event :attribute_line, :transitions_to => :attribute
+      end
+
+      state :attribute do
+        event :attribute_line, :transitions_to => :attribute
+        event :physicaldrive_line, :transitions_to => :physicaldrive
+        event :adapter_line, :transitions_to => :adapter
+        event :exit_line, :transitions_to => :exit
+      end
+
+      state :exit
+
+      on_transition do |from, to, triggering_event, *event_args|
+        #puts self.spec.states[to].class
+        # puts "    transition: #{from} >> #{triggering_event}! >> #{to}: #{event_args.join(' ')}"
+        #puts "                #{current_state.meta}"
+      end
+    end
+
+  end
+
+  class LDPDinfo_aAll < Megacli
+
+    def parse!(lsi,opts)
+      fake = opts[:fake].nil? ? "-ldpdinfo -aall" : File.join(opts[:fake],"ldpdinfo_aall")
+      super lsi, :fake => fake, :megacli => opts[:megacli]
+    end
+
+
+    workflow do
+
+      state :start do
+        event :adapter_line, :transitions_to => :adapter
+        event :exit_line, :transitions_to => :exit
+      end
+
+      state :adapter do
+        event :adapter_line, :transitions_to => :adapter
+        event :attribute_line, :transitions_to => :attribute
+        event :virtualdrive_line, :transitions_to => :virtualdrive
+        event :exit_line, :transitions_to => :exit
+      end
+
+      state :physicaldrive do
+        event :attribute_line, :transitions_to => :physicaldrive
+        event :exit_line, :transitions_to => :exit
+        event :adapter_line, :transitions_to => :adapter
+        event :physicaldrive_line, :transitions_to => :physicaldrive
+        event :attribute_line, :transitions_to => :attribute
+      end
+
+      state :virtualdrive do
+        event :physicaldrive_line, :transitions_to => :physicaldrive
+        event :attribute_line, :transitions_to => :attribute
+      end
+
+      state :attribute do
+        event :attribute_line, :transitions_to => :attribute
+        event :virtualdrive_line, :transitions_to => :virtualdrive
+        event :physicaldrive_line, :transitions_to => :physicaldrive
+        event :adapter_line, :transitions_to => :adapter
+        event :exit_line, :transitions_to => :exit
+      end
+
+      state :exit
+
+      on_transition do |from, to, triggering_event, *event_args|
+        #puts self.spec.states[to].class
+        # puts "    transition: #{from} >> #{triggering_event}! >> #{to}: #{event_args.join(' ')}"
+        #puts "                #{current_state.meta}"
+      end
+    end
+
+  end
+
+
+end

data/lib/elesai/version.rb

@@ -0,0 +1,3 @@
+module Elesai
+  VERSION = "0.4.0"
+end

data/lib/elesai.rb

@@ -0,0 +1,6 @@
+require 'elesai/logger'
+require 'elesai/lsi'
+require 'elesai/megacli'
+
+module Elesai
+end

metadata

@@ -0,0 +1,90 @@
+--- !ruby/object:Gem::Specification
+name: elesai
+version: !ruby/object:Gem::Version
+  version: 0.4.0
+  prerelease: 
+platform: ruby
+authors:
+- Gerardo López-Fernádez
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-06-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: log4r
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.1.9
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.1.9
+- !ruby/object:Gem::Dependency
+  name: senedsa
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+description: Senedsa is a small utility and library wrapper for the Nagios send_nsca.
+email: gerir@evernote.com
+executables:
+- elesai
+- check_elesai
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/elesai/about.rb
+- lib/elesai/cli.rb
+- lib/elesai/logger.rb
+- lib/elesai/lsi.rb
+- lib/elesai/megacli.rb
+- lib/elesai/version.rb
+- lib/elesai.rb
+- bin/check_elesai
+- bin/elesai
+- LICENSE
+- README.md
+homepage: https://github.com/evernote/ops-elesai
+licenses:
+- Apache License, Version 2.0
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.3.5
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Utility and library wrapper for Nagios send_nsca utility
+test_files: []