elesai 0.9.3 → 0.10.5

data/lib/elesai/lsi.rb

@@ -1,6 +1,8 @@
+require 'elesai/megacli'
+
 module Elesai
 
-  class LSIArray
+  class LSI
 
     attr_reader :adapters, :virtualdrives, :physicaldrives, :bbus, :enclosures
 
@@ -13,54 +15,58 @@ module Elesai
       @bbus = []
 
       case opts[:hint]
-        when :pd,:physicaldrive
-          PDlist_aAll.new.parse!(self,opts)
-        when :vd,:virtualdrive
-          LDPDinfo_aAll.new.parse!(self,opts)
+        when :physicaldrive
+          Megacli::PDlist_aAll.new.parse!(self,opts)
+        when :virtualdrive
+          Megacli::LDPDinfo_aAll.new.parse!(self,opts)
+        when :adapter
+          Megacli::AdpAllInfo_aAll.new.parse!(self,opts)
         when :bbu
-          AdpBbuCmd_aAll.new.parse!(self,opts)
+          Megacli::AdpBbuCmd_aAll.new.parse!(self,opts)
         else
-          PDlist_aAll.new.parse!(self,opts)
-          LDPDinfo_aAll.new.parse!(self,opts)
-          AdpBbuCmd_aAll.new.parse!(self,opts)
+          Megacli::AdpAllInfo_aAll.new.parse!(self,opts)
+          Megacli::PDlist_aAll.new.parse!(self,opts)
+          Megacli::LDPDinfo_aAll.new.parse!(self,opts)
+          Megacli::AdpBbuCmd_aAll.new.parse!(self,opts)
       end
     end
 
-    def add_adapter(a)
-      @adapters[a[:id]] = a if @adapters[a[:id]].nil?
+    def add(component)
+      case component
+        when Adapter
+          @adapters[component[:id]] = component if @adapters[component[:id]].nil?
+        when VirtualDrive
+          @virtualdrives.push(component)
+        when PhysicalDrive
+          @physicaldrives[component._id] = component if @physicaldrives[component._id].nil?
+          return @physicaldrives[component._id]
+        when BBU
+          @bbus.push(component)
+        else
+          raise StandardError, "invalid component #{component.class}"
+      end
     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 add_bbu(bbu)
-      @bbus.push(bbu)
-    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
 
+      class Section < Hash
+        attr_reader :section
+        def initialize(section)
+          @section = section
+        end
+        def inspect
+          "#{self.class}:#@section:#{self.__id__}"
+        end
+      end
+
       def initialize
         self[:virtualdrives] = []
         self[:physicaldrives] = {}
@@ -71,14 +77,6 @@ module Elesai
         "#{self[:id]}"
       end
 
-      def type
-        :adapter
-      end
-
-      def type_of?(type)
-        self.type == type
-      end
-
       def inspect
         "#{self.class}:#{self.__id__}"
       end
@@ -87,9 +85,15 @@ module Elesai
         self[:physicaldrives][pd._id] = pd unless self[:physicaldrives][pd._id].nil?
       end
 
-    end
+      def add_section(section)
+        self[section.section] = section
+      end
+
+      def to_s
+        "[ADAPTER] %2s  %s  %s %s  %s" % [ self._id,self[:versions][:productname].gsub(/\s+/,'_'),self[:versions][:fwpackagebuild],self[:imageversions][:fwversion],self[:hwconfiguration][:sasaddress] ]
+      end
 
-    ### Virtual Drive
+    end
 
     class VirtualDrive < Hash
 
@@ -116,14 +120,6 @@ module Elesai
         self[:targetid]
       end
 
-      def type
-        :virtualdrive
-      end
-
-      def type_of?(type)
-        self.type == type
-      end
-
       def inspect
         "#{self.class}:#{self.__id__}"
       end
@@ -138,8 +134,6 @@ module Elesai
 
     end
 
-    ### Physical Drive
-
     class PhysicalDrive < Hash
 
       STATES = {
@@ -175,14 +169,6 @@ module Elesai
         "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  ]
@@ -214,49 +200,41 @@ module Elesai
       end
     end
 
-    ### BBU
-
     class BBU < Hash
 
       class NumberUnit < Struct.new(:number, :unit)
         def to_s ; "%d%s" % [self.number,self.unit] end
       end
 
-      class Stub < Hash
+      class Section < Hash
+        attr_reader :section
+        def initialize(section)
+          @section = section
+        end
         def inspect
-          "#{self.class}:#{self.__id__}"
+          "#{self.class}:#{@section.capitalize}:#{self.__id__}"
         end
       end
-      class Status < Stub; end
-      class FirmwareStatus < Stub; end
-      class DesignInfo < Stub; end
-      class Properties < Stub; end
-      class CapacityInfo < Stub; end
-      class GasGaugeStatus < Stub; end
 
       def initialize
-        self[:status] = Status.new
-        self[:firmwarestatus] = FirmwareStatus.new
-        self[:designinfo] = DesignInfo.new
-        self[:properties] = Properties.new
-        self[:capacityinfo] = CapacityInfo.new
-        self[:gasgaugestatus] = GasGaugeStatus.new
-        self[:capacityinfo][:absolutestateofcharge] = '-'
       end
 
       def _id
         self[:id]
       end
 
+      def add_section(section)
+        self[section.section] = section
+      end
+
       def inspect
         "#{self.class}:#{self.__id__}"
       end
 
       def to_s
-        self[:capacityinfo][:absolutestateofcharge] = '-' unless self[:batterytype] == "iBBU"
-        self[:capacityinfo][:remainingcapacity] = '-' unless self[:batterytype] == "iBBU"
-        "[BBU] %s %-5s %-4s %-11s %3s:%-8s  %s:%s  %s:%s  %7s:%-4s  %s" % [self[:id],self[:batterytype],self[:designinfo][:devicechemistry],self[:firmwarestatus][:chargingstatus],self[:firmwarestatus][:learncycleactive],self[:firmwarestatus][:learncyclestatus],self[:voltage].gsub(/\s/,''),self[:firmwarestatus][:voltage],self[:temperature].gsub(/\s/,''),self[:firmwarestatus][:temperature],self[:capacityinfo][:remainingcapacity],self[:capacityinfo][:absolutestateofcharge],self[:properties][:nextlearntime]]
-        #puts self[:firmwarestatus].keys
+        capacityinfo_absolutestateofcharge = self[:batterytype] == 'iBBU' ? self[:capacityinfo][:absolutestateofcharge] : '-'
+        capacityinfo_remainingcapacity = self[:batterytype] == 'iBBU' ? self[:capacityinfo][:remainingcapacity] : '-'
+        "[BBU] %s %-5s %-4s %-11s %3s:%-8s  %s:%s  %s:%s  %7s:%-4s  %s" % [self[:id],self[:batterytype],self[:designinfo][:devicechemistry],self[:firmwarestatus][:chargingstatus],self[:firmwarestatus][:learncycleactive],self[:firmwarestatus][:learncyclestatus],self[:voltage].gsub(/\s/,''),self[:firmwarestatus][:voltage],self[:temperature].gsub(/\s/,''),self[:firmwarestatus][:temperature],capacityinfo_remainingcapacity,capacityinfo_absolutestateofcharge,self[:properties][:nextlearntime]]
       end
     end
   end

data/lib/elesai/megacli/_adpallinfo_aall.rb

@@ -0,0 +1,102 @@
+module Elesai; module Megacli
+
+  class AdpAllInfo_aAll <  Megacli
+
+    def initialize
+      @megacli = { :adapter                     => { :re => /^Adapter\s+#*(?<value>\d+)/,                         :method => self.method(:adapter_match)    },
+                   :versions                    => { :re => /^Versions/,                                          :method => self.method(:section_match)    },
+                   :mfgdata                     => { :re => /^Mfg\.\s+Data/,                                      :method => self.method(:section_match)    },
+                   :imageversions               => { :re => /^Image Versions in Flash/,                           :method => self.method(:section_match)    },
+                   :pendingvensions             => { :re => /^Pending Images in Flash/,                           :method => self.method(:section_match)    },
+                   :pciinfo                     => { :re => /^PCI Info/,                                          :method => self.method(:section_match)    },
+                   :hwconfiguration             => { :re => /^HW Configuration/,                                  :method => self.method(:section_match)    },
+                   :setttings                   => { :re => /^Settings/,                                          :method => self.method(:section_match)    },
+                   :capabilities                => { :re => /^Capabilities/,                                      :method => self.method(:section_match)    },
+                   :status                      => { :re => /^Status/,                                            :method => self.method(:section_match)    },
+                   :limitations                 => { :re => /^Limitations/,                                       :method => self.method(:section_match)    },
+                   :devicepresent               => { :re => /^Device Present/,                                    :method => self.method(:section_match)    },
+                   :supportedadapteroperations  => { :re => /^Supported Adapter Operations/,                      :method => self.method(:section_match)    },
+                   :supportedvdoperations       => { :re => /^Supported VD Operations/,                           :method => self.method(:section_match)    },
+                   :supportedddoperations       => { :re => /^Supported PD Operations/,                           :method => self.method(:section_match)    },
+                   :errorcounters               => { :re => /^Error Counters/,                                    :method => self.method(:section_match)    },
+                   :clusterinformation          => { :re => /^ClusterInformation/,                                :method => self.method(:section_match)    },
+                   :defaultsettings             => { :re => /^Default Settings/,                                  :method => self.method(:section_match)    },
+                   :exit                        => { :re => /^Exit Code: /,                                       :method => self.method(:exit_match)       },
+                   :attribute                   => { :re => /^(?<key>[A-Za-z0-9()\s#'-.&]+)([:|=](?<value>.*))?/, :method => self.method(:attribute_match)  }
+      }.freeze
+      @command_arguments = "-adpallinfo -aall".freeze
+      @command_output_file = "adpallinfo_aall".freeze
+    end
+
+    def parse!(lsi,opts)
+      fake = opts[:fake].nil? ? @command_arguments : File.join(opts[:fake],@command_output_file)
+      super lsi, :fake => fake, :megacli => opts[:megacli]
+    end
+
+    # State Machine
+
+    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 :section_line, :transitions_to => :section
+        event :exit_line, :transitions_to => :exit
+      end
+
+      state :section do
+        event :exit_line, :transitions_to => :exit
+        event :adapter_line, :transitions_to => :adapter
+        event :attribute_line, :transitions_to => :attribute
+      end
+
+      state :attribute do
+        event :attribute_line, :transitions_to => :attribute
+        event :section_line, :transitions_to => :section
+        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
+
+    ### Match Handlers
+
+    def section_match(k,match)
+      @log.debug "ADPINFO_SECTION! #{k} -> #{match.string}"
+      section_line!(LSI::Adapter::Section.new(k))
+    end
+
+    ### Line Handlers
+
+    def section_line(section)
+      @log.debug "  [#{current_state}] event: section_line: new #{section.inspect}"
+    end
+
+    def on_section_entry(old_state, event, *args)
+      @log.debug "     [#{current_state}] on_entry: leaving #{old_state}; args: #{args}"
+      unless @context.current.nil?
+        @context.close if Elesai::LSI::Adapter::Section === @context.current
+      end
+      @context.current.add_section(args[0])
+      @context.open(args[0])
+    end
+
+    def on_section_exit(new_state, event, *args)
+      @log.debug "      [#{current_state}] on_exit: entering #{new_state}; args: #{args}"
+      @context.flash!(new_state)
+    end
+
+  end
+
+end end

data/lib/elesai/megacli/_adpbbucmd_aall.rb

@@ -0,0 +1,107 @@
+module Elesai; module Megacli
+
+  class AdpBbuCmd_aAll < Megacli
+
+    def initialize
+      @megacli = {  :bbu            => { :re => /^BBU status for Adapter:\s+(?<value>\d+)/,         :method => self.method(:bbu_match)       },
+                    :firmwarestatus => { :re => /^BBU Firmware Status:/,                            :method => self.method(:section_match)   },
+                    :designinfo     => { :re => /^BBU Design Info for Adapter:\s+(?<value>\d+)/,    :method => self.method(:section_match)   },
+                    :properties     => { :re => /^BBU Properties for Adapter:\s+(?<value>\d+)/,     :method => self.method(:section_match)   },
+                    :gasgaugestatus => { :re => /^GasGuageStatus:/,                                 :method => self.method(:section_match)   },
+                    :capacityinfo   => { :re => /^BBU Capacity Info for Adapter:\s+(?<value>\d+)/,  :method => self.method(:section_match)   },
+                    :exit           => { :re => /^Exit Code: /,                                     :method => self.method(:exit_match)      },
+                    :attribute      => { :re => /^(?<key>[A-Za-z0-9()\s#'-.&]+)[:|=](?<value>.*)/,  :method => self.method(:attribute_match) }
+      }.freeze
+      @command_arguments = "-adpbbucmd -aall".freeze
+      @command_output_file = "adpbbucmd_aall".freeze
+    end
+
+    def parse!(lsi,opts)
+      fake = opts[:fake].nil? ? @command_arguments : File.join(opts[:fake],@command_output_file)
+      super lsi, :fake => fake, :megacli => opts[:megacli]
+    end
+
+    # State Machine
+
+    workflow do
+
+      state :start do
+        event :bbu_line,            :transitions_to => :bbu
+        event :exit_line,           :transitions_to => :exit
+      end
+
+      state :bbu do
+        event :attribute_line,      :transitions_to => :attribute
+        event :section_line,        :transitions_to => :section
+      end
+
+      state :section do
+        event :exit_line, :transitions_to => :exit
+        event :attribute_line, :transitions_to => :attribute
+      end
+
+      state :attribute do
+        event :attribute_line,      :transitions_to => :attribute
+        event :section_line,        :transitions_to => :section
+        event :exit_line,           :transitions_to => :exit
+      end
+
+      state :exit
+
+    end
+
+    # Regular Expression Match Handlers
+
+    def bbu_match(k,match)
+      @log.debug "BBU! #{match.string}"
+      key = 'id'
+      value = match[:value]
+      adapter_line(LSI::Adapter.new,key,value)
+      bbu_line!(LSI::BBU.new,key,value)
+    end
+
+    def section_match(k,match)
+      @log.debug "ADPINFO_SECTION! #{k} -> #{match.string}"
+      section_line!(LSI::BBU::Section.new(k))
+    end
+
+    ### Line Handlers
+
+    def bbu_line(bbu,key,value)
+      @log.debug "  [#{current_state}] event: bbu_line: new #{bbu.inspect}"
+      bbu[key.to_sym] = value.to_i
+    end
+
+    def on_bbu_entry(old_state, event, *args)
+      @log.debug "        [#{current_state}] on_entry: leaving #{old_state}; args: #{args}"
+      @context.open args[0]
+    end
+
+    def on_bbu_exit(new_state, event, *args)
+      @log.debug "      [#{current_state}] on_exit: entering #{new_state}; args: #{args}"
+      @context.flash!(new_state)
+    end
+
+    def section_line(section)
+      @log.debug "  [#{current_state}] event: section_line: new #{section.inspect}"
+    end
+
+    def on_section_entry(old_state, event, *args)
+      @log.debug "     [#{current_state}] on_entry: leaving #{old_state}; args: #{args}"
+      unless @context.current.nil?
+        @context.close if Elesai::LSI::BBU::Section === @context.current
+      end
+      @context.current.add_section(args[0])
+      @context.open(args[0])
+    end
+
+    def on_section_exit(new_state, event, *args)
+      @log.debug "      [#{current_state}] on_exit: entering #{new_state}; args: #{args}"
+      @context.flash!(new_state)
+    end
+
+  end
+
+end end
+
+

data/lib/elesai/megacli/_ldpdinfo_aall.rb

@@ -0,0 +1,140 @@
+module Elesai; module Megacli
+
+  class LDPDinfo_aAll < Megacli
+
+    def initialize
+      @megacli = { :adapter       => { :re => /^Adapter\s+#*(?<value>\d+)/,                                         :method => self.method(:adapter_match) },
+                   :virtualdrive  => { :re => /^Virtual\s+Drive:\s+\d+\s+\((?<key>Target\s+Id):\s+(?<value>\d+)\)/, :method => self.method(:virtualdrive_match) },
+                   :physicaldrive => { :re => /^(?<key>Enclosure\s+Device\s+ID):\s+(?<value>\d+)/,                  :method => self.method(:physicaldrive_match) },
+                   :exit          => { :re => /^Exit Code: /,                                                       :method => self.method(:exit_match) },
+                   :attribute     => { :re => /^(?<key>[A-Za-z0-9()\s#'-.&]+)[:|=](?<value>.*)/,                    :method => self.method(:attribute_match) }
+      }.freeze
+      @command_arguments = "-ldpdinfo -aall".freeze
+      @command_output_file = "ldpdinfo_aall".freeze
+    end
+
+    def parse!(lsi,opts)
+      fake = opts[:fake].nil? ? @command_arguments : File.join(opts[:fake],@command_output_file)
+      super lsi, :fake => fake, :megacli => opts[:megacli]
+    end
+
+    # Regular Expression Match Handlers
+
+    def virtualdrive_match(k,match)
+      @log.debug "VIRTUALDRIVE! #{match.string}"
+      key = match[:key].gsub(/\s+/,"").downcase
+      value = match[:value]
+      virtualdrive_line!(LSI::VirtualDrive.new,key,value)
+    end
+
+    def physicaldrive_match(k,match)
+      @log.debug "PHYSICALDRIVE! #{match.string}"
+      key = match[:key].gsub(/\s+/,"").downcase
+      value = match[:value]
+      physicaldrive_line!(LSI::PhysicalDrive.new,key,value)
+    end
+
+    # Line Handlers
+
+    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 Elesai::LSI::Adapter === @context.current
+      @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
+
+    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 Elesai::LSI::VirtualDrive === @context.current
+          @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
+
+    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; end