diskmon 0.0.1

data/Gemfile

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

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Morion Black
+
+MIT License
+
+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,29 @@
+# Diskmon
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'diskmon'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install diskmon
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+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

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/bin/diskmon

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+require "rubygems"
+require "diskmon"
+require "optparse"
+
+OptionParser.new do |opt|
+  opt.separator ""
+  opt.separator "Options:"
+  opt.separator "-------------"
+  opt.on('-a', '--agent', 'Agent mode') { Diskmon::Runner.agent }
+  opt.on('-s', '--server', 'Server mode') { Diskmon::Runner.server }
+  opt.separator ""
+  opt.on_tail('-h', '--help')           { puts opt; exit }
+
+  opt.parse!
+  end

data/diskmon.gemspec

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/diskmon/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Morion Black"]
+  gem.email         = ["morion.estariol@gmail.com"]
+  gem.description   = %q{Gem for collect statistic from disks}
+  gem.summary       = %q{Gem for collect statistic from disks}
+  gem.homepage      = ""
+
+  gem.files         = ["Gemfile", "LICENSE", "README.md", "Rakefile", "bin/diskmon", "diskmon.gemspec", "lib/diskmon.rb", "lib/diskmon/client/collector.rb", "lib/diskmon/client/config.rb", "lib/diskmon/client/harddisk.rb", "lib/diskmon/client/raidcontroller.rb", "lib/diskmon/client/solarismapdev.rb", "lib/diskmon/client/zpoolstree.rb", "lib/diskmon/server/harddisk.rb", "lib/diskmon/server/harddiskreport.rb", "lib/diskmon/version.rb"]
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "diskmon"
+  gem.require_paths = ["lib"]
+  gem.version       = Diskmon::VERSION
+  gem.add_runtime_dependency 'data_mapper'
+  gem.add_runtime_dependency 'sinatra'
+  gem.add_runtime_dependency 'thin'
+end

data/lib/diskmon.rb

@@ -0,0 +1,73 @@
+require "diskmon/version"
+require "diskmon/client/config"
+require "diskmon/client/raidcontroller"
+require "diskmon/client/collector"
+
+require 'sinatra'
+require "thin"
+require 'data_mapper'
+require 'dm-validations'
+require 'pp'
+require "diskmon/server/harddiskreport"
+
+module Diskmon
+
+  module Runner
+
+    CONFIG = "/usr/local/etc/diskmon.conf"
+
+################################################################################
+# Agent mode
+################################################################################
+
+    def self.agent
+
+      cfg = Diskmon::Config.new(CONFIG)
+      p cfg if $DEBUG
+
+      raid_ctl = Diskmon::RaidController.new
+      raid_ctl.get_all_stats
+      m = raid_ctl.serialize
+
+      coll = Diskmon::Collector.new
+      send_result = coll.send_report(cfg.collector_url, cfg.collector_login, cfg.collector_password, m)
+      p send_result
+    end
+
+################################################################################
+# Server mode
+################################################################################
+
+    def self.server
+      set :port, 7777
+
+      DataMapper::Logger.new($stdout, :debug)
+      DataMapper::setup(:default, "sqlite3://#{Dir.pwd}/reports.db")
+
+      $DEBUG = true
+
+      DataMapper.finalize
+
+      Diskmon::HardDiskReport.auto_upgrade!
+
+      post '/report/new' do
+        data = request.body.read
+
+        Kernel.puts "// Report from #{request.env['REMOTE_ADDR']}" if $DEBUG
+
+        @m = Marshal.load(data)
+
+        @m.each do |disk|
+          report = Diskmon::HardDiskReport.create(disk.to_hash)
+          report.checksum = disk.checksum
+
+          report.print if $DEBUG
+
+          report.save
+        end
+
+        "OK"
+      end
+    end
+  end
+end

data/lib/diskmon/client/collector.rb

@@ -0,0 +1,24 @@
+require "net/http"
+
+module Diskmon
+  
+  class Collector
+
+    def send_report(url, login, password, dump)
+      c_uri = URI(url)
+
+      p c_uri if $DEBUG
+
+      c_req = Net::HTTP::Post.new(c_uri.path)
+      c_req.basic_auth(login, password)
+      c_req.body = dump
+      c_req.content_type = 'text/plain'
+
+      res = Net::HTTP.start(c_uri.host, c_uri.port) do |http|
+        http.request(c_req)
+      end
+
+      res.code
+    end
+  end
+end

data/lib/diskmon/client/config.rb

@@ -0,0 +1,19 @@
+require "yaml"
+
+module Diskmon
+  
+  class Config
+
+    def initialize(filepath)
+      h = YAML.load_file(filepath)
+      @collector_url      = h["collector_url"]
+      @collector_login    = h["collector_login"]
+      @collector_password = h["collector_password"]
+    end
+
+    attr_reader :collector_url
+    attr_reader :collector_login
+    attr_reader :collector_password
+
+  end
+end

data/lib/diskmon/client/harddisk.rb

@@ -0,0 +1,43 @@
+module Diskmon
+
+  class HardDisk
+
+    # TODO: convert to bytes
+    # def size(size)
+    #   @size = 
+    # end
+
+    attr_accessor :dri
+    attr_accessor :ctl_id
+    attr_accessor :port
+    attr_accessor :status
+    attr_accessor :unit
+    attr_accessor :type             # sata or sas
+    attr_accessor :vendor_model
+    attr_accessor :smart_status_raw # array of hex numbers
+    attr_accessor :smart_status
+    attr_accessor :size
+
+    attr_accessor :reallocs
+    attr_accessor :age_hours
+    attr_accessor :temperature
+    attr_accessor :serial
+    attr_accessor :spindle_speed    # rpms
+
+    attr_accessor :error_events
+
+    attr_accessor :member_of_zpool
+    attr_accessor :read_errors
+    attr_accessor :write_errors
+    attr_accessor :checksum_errors
+
+    attr_accessor :zpool_health
+    attr_accessor :zpool_last_command
+    attr_accessor :zpool_total_space
+    attr_accessor :zpool_free_space
+
+    attr_accessor :system_device
+    attr_accessor :short_device
+
+  end
+end

data/lib/diskmon/client/raidcontroller.rb

@@ -0,0 +1,229 @@
+require "diskmon/client/solarismapdev"
+require "diskmon/client/harddisk"
+require "diskmon/client/zpoolstree"
+
+module Diskmon
+
+  class RaidController
+
+    def initialize
+      @vendor  = get_vendor
+      @disks   = []
+    end
+
+    def get_vendor
+      v = `scanpci | grep -i raid`
+
+      case v.downcase
+      when /3ware/   then return :threeware
+      when /adaptec/ then return :adaptec
+      else 
+        return nil
+      end
+    end
+
+    def get_ctl_ids
+
+      ctl_ids = []
+
+      case @vendor
+      
+      when :threeware
+        IO.popen("tw_cli show | grep ^c") do |tw_cli_show_io|
+          tw_cli_show_io.each_line { |l| ctl_ids.push( l.split[0] ) }
+        end
+      when :adaptec
+        IO.popen("arcconf getversion | grep 'Controller #'") do |arcconf_getversion_io|
+          arcconf_getversion_io.each_line { |l| ctl_ids.push( l.split[1][1..-1] ) }
+        end
+      
+      end
+
+      ctl_ids
+    end
+
+    def get_ctl_disks_info(ctl_id)
+      case @vendor
+      when :threeware
+
+        mapdev = Diskmon::SolarisMapDev.new
+
+        # disks overview
+        #
+        IO.popen("tw_cli /#{ctl_id} show drivestatus | grep ^p") do |tw_cli_drives_io|
+          tw_cli_drives_io.each_line do |l|
+            l_arr = l.split
+
+            d = Diskmon::HardDisk.new
+
+            d.ctl_id       = ctl_id[1..-1]   # strip 'c'
+            d.port         = l_arr[0][1..-1] # strip 'p'
+            d.status       = l_arr[1]
+            d.unit         = l_arr[2][1..-1] # strip 'u'
+            d.size         = l_arr[3..4]
+            d.type         = l_arr[5]
+            d.vendor_model = l_arr[8]
+
+            d.dri = "disk://" + Diskmon::Server.get_id + "/" + d.ctl_id + "/" + d.port
+
+            # IO.popen("tw_cli /#{ctl_id}/#{d.port} show smart") do |tw_cli_show_smart_io|
+
+            #   d.smart_status_raw = []
+
+            #   tw_cli_show_smart_io.each_line do |l|
+            #     s = l.split
+            #     d.smart_status_raw.push(s) if l[0,1] =~ /[0-9]/ and not s.empty?
+            #   end
+
+            #   d.smart_status = parse_smart_status(d.smart_status_raw.flatten!)
+              
+            # end # show smart
+         
+            # full stats
+            #
+            IO.popen("tw_cli /c#{d.ctl_id}/p#{d.port} show all | grep '^/c#{d.ctl_id}/p#{d.port}'") do |tw_cli_show_all_io|
+
+              tw_cli_show_all_io.each_line do |l|
+
+                params_arr = l.split
+
+                case params_arr[1]
+                  when "Reallocated" then d.reallocs      = params_arr[4]
+                  when "Power"       then d.age_hours     = params_arr[5]
+                  when "Temperature" then d.temperature   = params_arr[3]
+                  when "Serial"      then d.serial        = params_arr[3]
+                  when "Spindle"     then d.spindle_speed = params_arr[4]
+                end
+              end
+
+            end # show all
+
+            d.system_device   = "c#{d.ctl_id}t#{d.unit}d0"
+            d.short_device    = mapdev.to_short(d.system_device)
+            
+            yield d
+          end
+        end
+
+      when :adaptec
+      end
+    end
+
+    def get_all_stats
+
+      ctl_ids = get_ctl_ids
+
+      zp = Diskmon::ZpoolsTree.new
+
+      if not ctl_ids.empty?
+        ctl_ids.each do |ctl_id|
+          get_ctl_disks_info(ctl_id) do |d| 
+
+            d.member_of_zpool = zp.which_pool(d.system_device)
+            d.read_errors     = zp.read_errors(d.system_device)
+            d.write_errors    = zp.write_errors(d.system_device)
+            d.checksum_errors = zp.checksum_errors(d.system_device)
+
+            d.zpool_health       = zp.get_pool_param(d.member_of_zpool, "health")
+            d.zpool_last_command = zp.get_pool_param(d.member_of_zpool, "last_command")
+            d.zpool_total_space  = zp.get_pool_param(d.member_of_zpool, "total_space")
+            d.zpool_free_space   = zp.get_pool_param(d.member_of_zpool, "free_space")
+
+            @disks.push(d)
+          end
+        end
+      end
+
+      # TODO: /c3 show events
+
+      p @disks if $DEBUG
+
+    end
+
+    def parse_smart_status(smart_arr)
+
+      # TODO: dig smartmontools sources
+
+      smart_attributes = {
+        '00' => 'Zero_Field',
+        '01' => 'Raw_Read_Error_Rate',
+        '03' => 'Spin_Up_Time',
+        '04' => 'Start_Stop_Count',
+        '05' => 'Reallocated_Sector_Ct',
+        '07' => 'Seek_Error_Rate',
+        '09' => 'Power_On_Hours',
+        '0A' => 'Spin_Retry_Count',
+        '0B' => 'Calibration_Retry_Count',
+        '0C' => 'Power_Cycle_Count',
+        'B8' => 'End-to-End_error',
+        'BB' => 'Reported_Uncorrect',
+        'BC' => 'Command_Timeout',
+        'BD' => 'High Fly Writes',
+        'BE' => 'Airflow Temperature',
+        'C0' => 'Power-off_Retract_Count',
+        'C1' => 'Load_Cycle_Count',
+        'C2' => 'Temperature',
+        'C3' => 'Hardware ECC Recovered',
+        'C4' => 'Reallocation Event Count',
+        'C5' => 'Current Pending Sector Count',
+        'C6' => 'Uncorrectable Sector Count',
+        'C7' => 'UltraDMA CRC Error Count',
+        'C8' => 'Multi-Zone Error Rate',
+      }
+
+      smart_parsed = {}
+
+      i = 0 ; while i < 360 do
+
+          if smart_arr[i+2].to_i != 0
+      
+            j = 0 ; while j < 12 do
+              if j == 0
+                smart_param = smart_attributes[smart_arr[i+j+2]]
+                smart_val = ''
+              end
+
+                if j > 4 and j < 11
+                smart_val << smart_arr[i+j+2]
+              end
+
+              j += 1
+            end # while j < 12
+
+            smart_parsed["#{smart_param}"] = smart_val.to_i(10)
+                      
+          end # if smart_arr
+          
+          i += 12
+
+      end # while i
+
+  #    p smart_parsed if $DEBUG
+
+      smart_parsed
+
+    end
+
+    def serialize
+      Marshal.dump(@disks)
+    end
+
+    private :get_vendor
+    private :get_ctl_ids
+    private :get_ctl_disks_info
+
+  end
+
+  ########## Server
+
+  module Server
+
+    # def get_id
+    #   Socket.gethostname.downcase    
+    # end
+
+    def self.get_id
+      `/usr/sbin/zlogin df-storage hostname`.chomp
+    end
+  end
+end

data/lib/diskmon/client/solarismapdev.rb

@@ -0,0 +1,31 @@
+module Diskmon
+
+  class SolarisMapDev
+
+    def initialize
+
+      @full_dev_to_inst = {}
+
+      # "/pci@7a,0/pci8086,340c@5/pci9005,2b5@0/disk@52,0" 11 "sd"
+      IO.foreach("/etc/path_to_inst") do |l|
+        case l.strip
+        when /"sd"$/
+          full_dev = l.split[0].tr('"','')
+          idx      = l.split[-2]
+          @full_dev_to_inst[full_dev] = "sd#{idx}"
+        end
+      end
+    end
+
+    def to_short(device)
+      begin
+        dev = File.readlink("/dev/rdsk/#{device}").gsub("../../devices", "").split(':')[0]
+      rescue Errno::ENOENT
+        dev = File.readlink("/dev/rdsk/#{device}s0").gsub("../../devices", "").split(':')[0]
+      end
+
+      @full_dev_to_inst[dev]
+    end
+
+  end
+end

data/lib/diskmon/client/zpoolstree.rb

@@ -0,0 +1,82 @@
+module Diskmon
+
+  class ZpoolsTree
+    def initialize
+
+      @disks = {}
+      @pools = {}
+
+      IO.popen("/usr/sbin/zpool status") do |zpool_status_io|
+
+        pool_name = ''
+
+        zpool_status_io.each_line do |l|
+          case l
+          
+          when /pool: /
+            pool_name = l.split[1]
+            @pools[pool_name] = {}
+            @pools[pool_name]["health"]      = `/usr/sbin/zpool get health #{pool_name} | grep #{pool_name}`.split[2]
+            @pools[pool_name]["free_space"]  = `/usr/sbin/zpool get free #{pool_name} | grep #{pool_name}`.split[2]
+            @pools[pool_name]["total_space"] = `/usr/sbin/zpool get allocated #{pool_name} | grep #{pool_name}`.split[2]
+
+            history_events = []
+            
+            IO.popen("/usr/sbin/zpool history #{pool_name}") do |zpool_history_io|
+
+              zpool_history_io.each_line do |l|
+                case l
+                when /^[0-9]/ then history_events.push(l)
+                end
+              end
+
+            end
+
+            @pools[pool_name]["last_command"] = history_events[-1].chomp
+
+          when /c[0-9]t/
+            disk_name = l.split[0]
+
+            @disks[disk_name] = {}
+            @disks[disk_name]["zpool"]           = pool_name
+
+            @disks[disk_name]["read_errors"]     = l.split[2] 
+            @disks[disk_name]["write_errors"]    = l.split[3]
+            @disks[disk_name]["checksum_errors"] = l.split[4]
+
+          end
+
+        end
+      end
+
+      # p @disks if $DEBUG
+      # p @pools if $DEBUG
+
+    end
+
+    def which_pool(device)
+      @disks[device]["zpool"]
+    end
+
+    def read_errors(device)
+      @disks[device]["read_errors"]
+    end
+
+    def write_errors(device)
+      @disks[device]["write_errors"]
+    end
+
+    def checksum_errors(device)
+      @disks[device]["checksum_errors"]
+    end
+
+    # free_space
+    # total_space
+    # last_command
+    # health
+    def get_pool_param(pool, param)
+      @pools[pool][param]
+    end
+
+  end
+end

data/lib/diskmon/server/harddisk.rb

@@ -0,0 +1,19 @@
+require 'digest'
+
+module Diskmon
+  
+  class HardDisk
+
+    # credit: http://stackoverflow.com/a/5031637
+    def to_hash
+      Hash[instance_variables.map { |var| [var[1..-1].to_sym, instance_variable_get(var)] }]
+    end
+
+    def checksum
+      as_str = ''
+      instance_variables.sort.map { |k| as_str << "#{k}=#{instance_variable_get(k)};" }
+      p as_str if $DEBUG
+      Digest::MD5.hexdigest(as_str)
+    end
+  end
+end

data/lib/diskmon/server/harddiskreport.rb

@@ -0,0 +1,50 @@
+require "data_mapper"
+
+module Diskmon
+    
+  class HardDiskReport
+    include DataMapper::Resource
+
+    property :dri                 , String
+    property :ctl_id              , String
+    property :port                , String
+    property :status              , String
+    property :unit                , String
+    property :type                , String
+    property :vendor_model        , String
+    property :smart_status_raw    , String
+    property :smart_status        , String
+    property :size                , String
+    property :reallocs            , String
+    property :age_hours           , String
+    property :temperature         , String
+    property :serial              , String
+    property :spindle_speed       , String
+    property :error_events        , String
+    property :member_of_zpool     , String
+    property :disk_space_used     , String
+
+    property :error_events        , String
+                                     
+    property :member_of_zpool     , String
+    property :read_errors         , String
+    property :write_errors        , String
+    property :checksum_errors     , String
+                                     
+    property :zpool_health        , String
+    property :zpool_last_command  , String
+    property :zpool_total_space   , String
+    property :zpool_free_space    , String
+                                     
+    property :system_device       , String
+    property :short_device        , String
+
+    property :created_at          , EpochTime
+    property :checksum            , String, :key => true, :unique => true
+
+    def print
+      instance_variables.sort.map { |k| printf( "%-20s => %s\n", k, instance_variable_get(k) ) }    
+    end
+
+  end
+end

data/lib/diskmon/version.rb

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

metadata

@@ -0,0 +1,110 @@
+--- !ruby/object:Gem::Specification
+name: diskmon
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Morion Black
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-07-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: data_mapper
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sinatra
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: thin
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Gem for collect statistic from disks
+email:
+- morion.estariol@gmail.com
+executables:
+- diskmon
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- bin/diskmon
+- diskmon.gemspec
+- lib/diskmon.rb
+- lib/diskmon/client/collector.rb
+- lib/diskmon/client/config.rb
+- lib/diskmon/client/harddisk.rb
+- lib/diskmon/client/raidcontroller.rb
+- lib/diskmon/client/solarismapdev.rb
+- lib/diskmon/client/zpoolstree.rb
+- lib/diskmon/server/harddisk.rb
+- lib/diskmon/server/harddiskreport.rb
+- lib/diskmon/version.rb
+homepage: ''
+licenses: []
+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: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Gem for collect statistic from disks
+test_files: []