├── windows
    ├── raid_trapper_checks_task.xml
    ├── lsi_raid.conf
    ├── raid_check.ps1
    ├── raid_discovery.ps1
    └── raid_trapper_checks.ps1
├── template
    ├── LSI_RAID_valuemaps.xml
    └── LSI_RAID_template.xml
├── README.md
└── unix
    ├── raid_discovery.pl
    ├── raid_trapper_check.pl
    └── raid_check.pl


/windows/raid_trapper_checks_task.xml:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Art3mK/Zabbix-LSI-RAID-Monitoring/HEAD/windows/raid_trapper_checks_task.xml


--------------------------------------------------------------------------------
/windows/lsi_raid.conf:
--------------------------------------------------------------------------------
1 | # Check path and add this string to zabbix agent config
2 | # Include=C:\Program Files\zabbix_agent\conf.d\lsi_raid\lsi_raid.conf
3 | UserParameter=hw.raid.physical_disk[*],C:\Windows\System32\WindowsPowerShell\v1.0\powershell.exe -File "C:\Program Files\zabbix_agent\conf.d\lsi_raid\raid_check.ps1" -mode pdisk -item $4 -adapter $1 -enc $2 -pdisk $3
4 | UserParameter=hw.raid.logical_disk[*],C:\Windows\System32\WindowsPowerShell\v1.0\powershell.exe -File "C:\Program Files\zabbix_agent\conf.d\lsi_raid\raid_check.ps1" -mode vdisk -item $3 -adapter $1 -vdisk $2
5 | UserParameter=hw.raid.bbu[*],C:\Windows\System32\WindowsPowerShell\v1.0\powershell.exe -File "C:\Program Files\zabbix_agent\conf.d\lsi_raid\raid_check.ps1" -mode bbu -item $2 -adapter $1
6 | UserParameter=hw.raid.adapter[*],C:\Windows\System32\WindowsPowerShell\v1.0\powershell.exe -File "C:\Program Files\zabbix_agent\conf.d\lsi_raid\raid_check.ps1" -mode adapter -item $2 -adapter $1


--------------------------------------------------------------------------------
/template/LSI_RAID_valuemaps.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <zabbix_export>
 3 |     <version>3.2</version>
 4 |     <date>2017-12-28T11:59:23Z</date>
 5 |     <value_maps>
 6 |         <value_map>
 7 |             <name>LSI RAID BBU &amp; LD Status</name>
 8 |             <mappings>
 9 |                 <mapping>
10 |                     <value>0</value>
11 |                     <newvalue>Optimal</newvalue>
12 |                 </mapping>
13 |                 <mapping>
14 |                     <value>1</value>
15 |                     <newvalue>Failed</newvalue>
16 |                 </mapping>
17 |             </mappings>
18 |         </value_map>
19 |         <value_map>
20 |             <name>LSI RAID PhysDrv Status</name>
21 |             <mappings>
22 |                 <mapping>
23 |                     <value>0</value>
24 |                     <newvalue>(Online|Hostpare|Unconfigured good)</newvalue>
25 |                 </mapping>
26 |                 <mapping>
27 |                     <value>1</value>
28 |                     <newvalue>Failed</newvalue>
29 |                 </mapping>
30 |                 <mapping>
31 |                     <value>2</value>
32 |                     <newvalue>Rebuild</newvalue>
33 |                 </mapping>
34 |             </mappings>
35 |         </value_map>
36 |     </value_maps>
37 | </zabbix_export>
38 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Zabbix template for Intel/LSI/Symbios RAID Controllers
 2 | 
 3 | [Topic](https://www.zabbix.com/forum/showthread.php?t=41439) on zabbix forum
 4 | 
 5 | ## LSI_RAID_valuemaps
 6 | Zabbix value mappings for "Template LSI RAID". Should be imported before template via "Administration" -> "General" -> "Value mapping" -> "Import".
 7 | 
 8 | ### Available items:
 9 | **LSI RAID BBU & LD Status**
10 | - 0 -> Optimal
11 | - 1 -> Failed
12 |  
13 | **LSI RAID PhysDrv Status**
14 | - 0 -> (Online|Hostpare|Unconfigured good)
15 | - 1 -> Failed
16 | - 2 -> Rebuild
17 | 
18 | ## LSI_RAID_template
19 | Zabbix template "Template LSI RAID". Should be imported after Zabbix value mappings via "Configuration" -> "Templates" -> "Import".
20 | 
21 | ### Available items:
22 | **Adapter**
23 | - Adapter model
24 | - Firmware version
25 | 
26 | **Battery Backup Unit**
27 | - BBU State (+trigger)
28 | - BBU State of charge (+trigger)
29 | - BBU manufacture date (disabled by default)
30 | - BBU design capacity (disabled by default)
31 | - BBU current capacity (disabled by default)
32 | 
33 | **Physical drives**
34 | - Firmware state (+trigger)
35 | - Predictive errors (+trigger)
36 | - Media errors (+trigger)
37 | - Size
38 | - Model
39 | 
40 | **Logical volumes**
41 | - Volume state (+trigger)
42 | - Volume size
43 | 
44 | ## Scripts
45 | 3 scripts are available for windows (powershell) and unix (perl) servers
46 | 
47 | ### RAID Discovery script
48 | This script is used for Low Level Discovery of RAID configuration. Scripts uses zabbix_sender and agent configuration file to report RAID configuration to zabbix.
49 | ### RAID checks script
50 | This script is used by zabbix agent to check "non critical" items, such as adapter model, physical drive size, etc. But this script also supports checking of all items from template (i.e. you can change type for all items from 'Zabbix trapper' to 'Zabbix Agent'). I've created "trapper" version of this script, because zabbix agent very often reports that some item is not supported (I noticed that problem only on Windows servers). Probably there are some locking occurs, when zabbix agent checks a lot of items at the same time.
51 | ### RAID "trapper" check script
52 | This scrips reports all values for "critical" items at once. Currently it reports BBU state and state of charge, physical drives state, predictive and media erros, logical volumes states. All other checks are performed by zabbix agent using RAID checks scripts and userparameters.
53 | 
54 | Discovery and "trapper" scripts are executed by system scheduler.
55 | 
56 | ## Agent userparameters:
57 | 
58 | ### Windows
59 | 
60 |     UserParameter=hw.raid.physical_disk[*],C:\Windows\System32\WindowsPowerShell\v1.0\powershell.exe -File "C:\Program Files\zabbix_agent\raid_check.ps1" -mode pdisk -item $4 -adapter $1 -enc $2 -pdisk $3
61 |     UserParameter=hw.raid.logical_disk[*],C:\Windows\System32\WindowsPowerShell\v1.0\powershell.exe -File "C:\Program Files\zabbix_agent\raid_check.ps1" -mode vdisk -item $3 -adapter $1 -vdisk $2
62 |     UserParameter=hw.raid.bbu[*],C:\Windows\System32\WindowsPowerShell\v1.0\powershell.exe -File "C:\Program Files\zabbix_agent\raid_check.ps1" -mode bbu -item $2 -adapter $1
63 |     UserParameter=hw.raid.adapter[*],C:\Windows\System32\WindowsPowerShell\v1.0\powershell.exe -File "C:\Program Files\zabbix_agent\raid_check.ps1" -mode adapter -item $2 -adapter $1
64 | 
65 | ### Unix/Linux
66 | 
67 |     UserParameter=hw.raid.physical_disk[*],/usr/bin/perl -w /etc/zabbix/scripts/raid_check.pl -mode pdisk -item $4 -adapter $1 -enclosure $2 -pdisk $3
68 |     UserParameter=hw.raid.logical_disk[*],/usr/bin/perl -w /etc/zabbix/scripts/raid_check.pl -mode vdisk -item $3 -adapter $1 -vdisk $2
69 |     UserParameter=hw.raid.bbu[*],/usr/bin/perl -w /etc/zabbix/scripts/raid_check.pl -mode bbu -item $2 -adapter $1
70 |     UserParameter=hw.raid.adapter[*],/usr/bin/perl -w /etc/zabbix/scripts/raid_check.pl -mode adapter -item $2 -adapter $1
71 | 
72 | For agents on unix servers RAID tool should be executed via sudo, add this to sudoers file:
73 | 
74 |     Defaults:zabbix !requiretty
75 |     # path to your tool can be different
76 |     zabbix  ALL=NOPASSWD:/opt/MegaRAID/CmdTool2/CmdTool2
77 | 
78 | ## Scheduled Tasks
79 | 
80 | The script raid_trapper_checks must be run via cron/scheduled tasks. There is a trigger defined that alerts when the data is older than 10 minutes, so the script should be executed every 5 minutes or so.
81 | 
82 | ### Windows
83 | 
84 | Adapt the paths in `raid_trapper_checks_task.xml` to your needs and import it in the Task Scheduler.
85 | 
86 | ### Linux/Unix
87 | 
88 |     # crontab -e -u zabbix
89 |     * */5 * * * perl /path/to/your/raid_trapper_check.pl
90 | 
91 | I'm not a programmer, so code review will be appreciated :)
92 | 


--------------------------------------------------------------------------------
/windows/raid_check.ps1:
--------------------------------------------------------------------------------
  1 | Param(
  2 |         [parameter(Position=0,Mandatory=$true)]
  3 |         [ValidateSet("pdisk", "vdisk", "bbu", "adapter")]
  4 |         [alias("m")]
  5 |         [String]
  6 |         $mode
  7 |     ,
  8 |         [parameter()]
  9 |         [ValidateNotNullOrEmpty()]
 10 |         [alias("p","item")]
 11 |         [string]
 12 |         $mode_item
 13 |     ,
 14 |         [parameter(Mandatory=$true)]
 15 |         [ValidateRange(0,5)]
 16 |         [alias("a","adp")]
 17 |         [int]
 18 |         $adapter
 19 |     ,
 20 |         [parameter()]
 21 |         [ValidateRange(0,4096)]
 22 |         [alias("e","enc")]
 23 |         [int]
 24 |         $enclosure_id
 25 |     ,
 26 |         [parameter()]
 27 |         [ValidateRange(0,256)]
 28 |         [alias("pdisk")]
 29 |         [int]
 30 |         $disk_id
 31 |     ,
 32 |         [parameter()]
 33 |         [ValidateRange(0,256)]
 34 |         [alias("vdisk")]
 35 |         [int]
 36 |         $vdisk_id
 37 | )
 38 | 
 39 | $CLI = "C:\raid\CmdTool2_64.exe"
 40 | 
 41 | function pdisk_item($item,$adapter,$enclosure_id,$disk_id) {
 42 |     $regex = ''
 43 |     switch ($item) {
 44 |         'firmware_state'    { $regex = "Firmware state:\s(.*)" }
 45 |         'raw_size'          { $regex = "Raw Size:\s+(\d+\.\d+\s..)" }
 46 |         'predictive_errors' { $regex = "Predictive Failure Count:\s(.*)" }
 47 |         'inquiry_data'      { $regex = "Inquiry Data:\s+(.*)" }
 48 |         'media_errors'      { $regex = "Media Error Count:\s(.*)" }
 49 |     }
 50 | 
 51 |     if ($enclosure_id -eq 2989) { $enclosure_id = '' }
 52 |     $output = (& $CLI -pdinfo -PhysDrv["$enclosure_id":"$disk_id"] -a $adapter -NoLog | Select-String $regex -AllMatches | % { $_.Matches } | % { $_.groups[1].value })
 53 |     if ($item -eq 'firmware_state') {
 54 |         if ($output -Match '^(Unconfigured\(good\).*|Online,\sSpun.*|Hotspare,\sSpun.*)$') {
 55 |             $output = 0
 56 |         }
 57 |         elseif ($output -Match '^Rebuild') {
 58 |             $output = 2
 59 |         }
 60 |         else {
 61 |             $output = 1
 62 |         }
 63 |     }
 64 |     write-host $output
 65 | }
 66 | 
 67 | function vdisk_item($item,$adapter,$vd) {
 68 |     $regex = ''
 69 |     switch ($item) {
 70 |         'vd_state'      { $regex = "^State\s+:\s(.*)$" }
 71 |         'vd_size'       { $regex = "^Size\s+:\s(\d+\.\d+\s..)" }
 72 |     }
 73 | 
 74 |     $output = (& $CLI -LDinfo -L $vd -a $adapter -NoLog | Select-String $regex -AllMatches | % { $_.Matches } | % { $_.groups[1].value })
 75 |     if ($item -eq 'vd_state') {
 76 |         if ($output -Match '^Optimal$') { $output = 0 } else { $output = 1 }
 77 |     }
 78 |     write-host $output
 79 | }
 80 | 
 81 | function bbu_item($item,$adapter){
 82 |     $regex      = ''
 83 |     $command    = ''
 84 |     switch ($item) {
 85 |         'bbu_state'         { $command = '-GetBbuStatus';       $regex = "Battery State\s*:\s(.*)$";                                    $wanted_group = 1 }
 86 |         'design_capacity'   { $command = '-GetBBUDesignInfo';   $regex = "Design\sCapacity:\s(\d+)\s(mAh|J)";                           $wanted_group = 1 }
 87 |         'full_capacity'     { $command = '-GetBBUCapacityInfo'; $regex = "(Full\sCharge\sCapacity|.*Pack\senergy\s*):\s(\d+)\s(mAh|J)"; $wanted_group = 2 }
 88 |         'state_of_charge'   { $command = '-GetBBUCapacityInfo'; $regex = "Absolute\sState\sof\scharge\s*:\s(\d+).*%";                   $wanted_group = 1 }
 89 |         'date_manufactured' { $command = '-GetBBUDesignInfo';   $regex = "Date\sof\sManufacture\s*:\s(.*)$";                            $wanted_group = 1 }
 90 |     }
 91 |     if ($bbu_state -Match '^(Optimal|Operational)$') { $bbu_state = 0 } else { $bbu_state = 1 }
 92 |     $output = (& $CLI -AdpBbuCmd $command -a $adapter -NoLog | Select-String $regex | % {$_.Matches} | % { $_.groups[$wanted_group].value })
 93 |     if ($item -eq 'bbu_state') {
 94 |         if ($output -Match '^(Optimal|Operational)$') { $output = 0 } else { $output = 1 }
 95 |     }
 96 |     write-host $output
 97 | }
 98 | 
 99 | function adapter_item($item,$adapter){
100 |     $regex      = ''
101 |     switch ($item) {
102 |         'fw_version'        { $regex = "^\s*FW\sPackage\sBuild:\s(.*)$" }
103 |         'product_name'      { $regex = "^\s*Product\sName\s*:\s(.*)$"   }
104 |     }
105 | 
106 |     $output = (& $CLI -AdpAllInfo -a $adapter -NoLog | Select-String $regex  | % {$_.Matches} | % { $_.groups[1].value })
107 |     write-host $output
108 | }
109 | 
110 | ### Start doing our job
111 | 
112 | switch ($mode) {
113 |     "pdisk"     { pdisk_item $mode_item $adapter $enclosure_id $disk_id }
114 |     "vdisk"     { vdisk_item $mode_item $adapter $vdisk_id }
115 |     "bbu"       { bbu_item $mode_item $adapter }
116 |     "adapter"   { adapter_item $mode_item $adapter }
117 | }
118 | 


--------------------------------------------------------------------------------
/unix/raid_discovery.pl:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/perl -w
  2 | 
  3 | use strict;
  4 | use warnings;
  5 | 
  6 | my $cli             = '/opt/MegaRAID/MegaCli/MegaCli64';
  7 | my $zabbix_config   = '/etc/zabbix_agentd.conf';
  8 | my $zabbix_sender   = '/usr/bin/zabbix_sender';
  9 | my $tmp_path        = '/tmp/raid-discovery-zsend-data.tmp';
 10 | my %enclosures      = ();
 11 | my %adapters        = ();
 12 | my %battery_units   = ();
 13 | my %physical_drives = ();
 14 | my %virtual_drives  = ();
 15 | 
 16 | my $adp_count   = `$cli -AdpCount -NoLog`;
 17 | # Controller Count: 1.
 18 | if ($adp_count =~ m/.*Controller\sCount:\s(\d)\.*/i) {
 19 |     $adp_count = $1;
 20 | } else {
 21 |     print "Didn't find any adapter, check regex or $cli\n";
 22 |     exit(1);
 23 | }
 24 | 
 25 | for (my $adapter = 0; $adapter < $adp_count; $adapter++) {
 26 |     my $pd_num = `$cli -pdGetNum -a $adapter -NoLog`;
 27 |     # Number of Physical Drives on Adapter 0: 6
 28 |     if ($pd_num =~ m/.*Number\sof\sPhysical\sDrives\son\sAdapter\s$adapter:\s(\d+)\n.*/) {
 29 |         $pd_num = $1;
 30 |         if ($pd_num == 0) {
 31 |             print "No physical disks found on adapter $adapter\n";
 32 |             next;
 33 |         } else {
 34 |             $adapters{$adapter} = "{ \"{#ADAPTER_ID}\":\"$adapter\" }";
 35 |         }
 36 |     }
 37 | 
 38 |     my $number_of_lds = `$cli -LDGetNum -a $adapter -NoLog`;
 39 |     # Number of Virtual Drives Configured on Adapter 0: 3
 40 |     if ($number_of_lds=~ m/.*Number\sof\sVirtual\sDrives\sConfigured\son\sAdapter\s$adapter:\s(\d+)/) {
 41 |         $number_of_lds = $1;
 42 |         if ($number_of_lds == 0) {
 43 |             print "No virtual disks found on adapter $adapter\n";
 44 |             next;
 45 |         }
 46 |         my @vd_list     = `$cli -LDinfo -Lall -a $adapter -NoLog`;
 47 |         my $vdrive_id   = -1;
 48 |         foreach my $line (@vd_list) {
 49 |             if ($line =~ m/^\s*Virtual\sDrive:\s(\d+)\s.*$/) {
 50 |                 $vdrive_id = $1;
 51 |                 $virtual_drives{"$adapter$vdrive_id"} = "{ \"{#VDRIVE_ID}\":\"$vdrive_id\", \"{#ADAPTER_ID}\":\"$adapter\" }";
 52 |             } else {
 53 |                 next;
 54 |             }
 55 |         }
 56 |     }
 57 | 
 58 |     my $bbu_info = `$cli -AdpBbuCmd -GetBbuStatus -a $adapter -NoLog`;
 59 |     if (!($bbu_info =~ m/.*Get BBU Status Failed.*/)) {
 60 |         $battery_units{$adapter} = "{ \"{#ADAPTER_ID}\":\"$adapter\" }";
 61 |     }
 62 | 
 63 |     my @pd_list = `$cli -pdlist -a $adapter -NoLog`;
 64 |     my $check_next_line = 0;
 65 |     my $enclosure_id    = -1;
 66 |     # Determine Slot Number for each drive on current enclosure
 67 |     foreach my $line (@pd_list) {
 68 |         if ($line =~ m/^Enclosure\sDevice\sID:\s(\d+)$/) {
 69 |             $enclosure_id       = $1;
 70 |             $check_next_line    = 1;
 71 |         } elsif ($line =~ m/^\s*Enclosure\sDevice\sID:\sN\/A$/) {
 72 |             # This can happen, if embedded raid controller is in use, there are drives and logical disks, but no enclosures
 73 |             $enclosure_id       = 2989; # 0xBAD, :( magic hack
 74 |             $check_next_line    = 1;
 75 |         } elsif (($line =~ m/^Slot\sNumber:\s(\d+)$/) && $check_next_line) {
 76 |             $physical_drives{"$adapter$enclosure_id$1"} = "{ \"{#ENCLOSURE_ID}\":\"$enclosure_id\", \"{#PDRIVE_ID}\":\"$1\", \"{#ADAPTER_ID}\":\"$adapter\" }";
 77 |             $check_next_line    = 0;
 78 |         } else {
 79 |             next;
 80 |         }
 81 |     }
 82 | }
 83 | 
 84 | open(ZSEND_FILE,">$tmp_path") or die "Can't open $tmp_path: $!";
 85 | 
 86 | my $phd_count = keys %physical_drives;
 87 | my $lds_count = keys %virtual_drives;
 88 | 
 89 | if (($phd_count != 0) && ($lds_count != 0)) {
 90 |     my $i = 1;
 91 |     print ZSEND_FILE "- hw.raid.discovery.pdisks { \"data\":[";
 92 |     foreach my $drive (keys %physical_drives) {
 93 |         if ($i < $phd_count) {
 94 |             print ZSEND_FILE "$physical_drives{$drive},";
 95 |             $i++;
 96 |         } else {
 97 |             print ZSEND_FILE "$physical_drives{$drive}]}\n";
 98 |         }
 99 |     }
100 |     $i = 1;
101 |     print ZSEND_FILE "- hw.raid.discovery.vdisks { \"data\":[";
102 |     foreach my $vdrive (keys %virtual_drives) {
103 |         if ($i < $lds_count) {
104 |             print ZSEND_FILE "$virtual_drives{$vdrive},";
105 |             $i++;
106 |         } else {
107 |             print ZSEND_FILE "$virtual_drives{$vdrive}]}\n";
108 |         }
109 |     }
110 |     $i = 1;
111 |     my $bbu_count = keys %battery_units;
112 |     if ($bbu_count != 0) {
113 |         print ZSEND_FILE "- hw.raid.discovery.bbu { \"data\":[";
114 |             foreach my $bbu (keys %battery_units) {
115 |                 if ($i < $bbu_count) {
116 |                     print ZSEND_FILE "$battery_units{$bbu},";
117 |                     $i++;
118 |                 } else {
119 |                     print ZSEND_FILE "$battery_units{$bbu}]}\n";
120 |                 }
121 |             }
122 |     }
123 |     $i = 1;
124 |     my $adp_count = keys %adapters;
125 |     if ($adp_count != 0) {
126 |         print ZSEND_FILE "- hw.raid.discovery.adapters { \"data\":[";
127 |         foreach my $adapter (keys %adapters) {
128 |             if ($i < $adp_count) {
129 |                 print ZSEND_FILE "$adapters{$adapter},";
130 |                 $i++;
131 |             } else {
132 |                 print ZSEND_FILE "$adapters{$adapter}]}\n";
133 |             }
134 |         }
135 |     }
136 | }
137 | close (ZSEND_FILE) or die "Can't close $tmp_path: $!";
138 | 
139 | my @cmd_args = ($zabbix_sender,'-c',$zabbix_config,'-i',$tmp_path);
140 | system(@cmd_args);


--------------------------------------------------------------------------------
/unix/raid_trapper_check.pl:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/perl -w
  2 | 
  3 | use strict;
  4 | use warnings;
  5 | 
  6 | my $cli             = '/opt/MegaRAID/CmdTool2/CmdTool2';
  7 | my $zabbix_config   = '/etc/zabbix_agentd.conf';
  8 | my $zabbix_sender   = '/usr/bin/zabbix_sender';
  9 | my $tmp_path        = '/tmp/raid-discovery-zsend-trapper-data.tmp';
 10 | my %enclosures      = ();
 11 | 
 12 | my $adp_count   = `$cli -AdpCount -NoLog`;
 13 | # Controller Count: 1.
 14 | if ($adp_count =~ m/.*Controller\sCount:\s(\d)\.*/i) {
 15 |     $adp_count = $1;
 16 | } else {
 17 |     print "Didn't find any adapter, check regex or $cli\n";
 18 |     exit(1);
 19 | }
 20 | 
 21 | unlink $tmp_path if (-e $tmp_path);
 22 | 
 23 | for (my $adapter = 0; $adapter < $adp_count; $adapter++) {
 24 |     my $pd_num = `$cli -pdGetNum -a $adapter -NoLog`;
 25 |     # Number of Physical Drives on Adapter 0: 6
 26 |     if ($pd_num =~ m/.*Number\sof\sPhysical\sDrives\son\sAdapter\s$adapter:\s(\d+)\n.*/) {
 27 |         $pd_num = $1;
 28 |         if ($pd_num == 0) {
 29 |             print "No physical disks found on adapter $adapter\n";
 30 |             next;
 31 |         }
 32 |     }
 33 | 
 34 |     my $number_of_lds = `$cli -LDGetNum -a $adapter -NoLog`;
 35 |     # Number of Virtual Drives Configured on Adapter 0: 3
 36 |     if ($number_of_lds=~ m/.*Number\sof\sVirtual\sDrives\sConfigured\son\sAdapter\s$adapter:\s(\d+)/) {
 37 |         $number_of_lds = $1;
 38 |         if ($number_of_lds == 0) {
 39 |             print "No virtual disks found on adapter $adapter\n";
 40 |             next;
 41 |         }
 42 |     }
 43 | 
 44 |     open(ZSEND_FILE,">>$tmp_path") or die "Can't open $tmp_path: $!";
 45 | 
 46 |     my $bbu_info = `$cli -AdpBbuCmd -GetBbuStatus -a $adapter -NoLog`;
 47 |     if (!($bbu_info =~ m/.*Get BBU Status Failed.*/)) {
 48 |         my @bbu_data = `$cli -AdpBBUCMD -a $adapter -NoLog`;
 49 | 
 50 |         foreach my $line (@bbu_data) {
 51 |             if ($line =~ m/Battery State\s*:\s(.*)$/) {
 52 |                 my $bbu_state = 1;
 53 |                 $bbu_state = 0 if ($1 =~ m/^(Optimal|Operational)$/);
 54 |                 print ZSEND_FILE "- hw.raid.bbu[$adapter,\"bbu_state\"] \"$bbu_state\"\n";
 55 |             } elsif (($line =~ m/(?:Relative|Absolute)\sState\sof\sCharge\s*:\s(\d+).*%/i)) {
 56 |                 my $state_of_charge = $1;
 57 |                 print ZSEND_FILE "- hw.raid.bbu[$adapter,\"state_of_charge\"] \"$state_of_charge\"\n";
 58 |             } else {
 59 |                 next;
 60 |             }
 61 |         }
 62 |     }
 63 | 
 64 |     my @vd_list = `$cli -LDinfo -Lall -a $adapter -NoLog`;
 65 |     my $check_next_line = -1;
 66 |     my $vdrive_id       = -1;
 67 |     foreach my $line (@vd_list) {
 68 |         if ($line =~ m/^\s*Virtual\sDrive:\s(\d+)\s.*$/) {
 69 |             $vdrive_id  = $1;
 70 |             $check_next_line = 1;
 71 |         } elsif (($line =~ m/^\s*State\s+:\s(.*)$/) && ($check_next_line != -1) && ($vdrive_id != -1)) {
 72 |             my $state = 1;
 73 |             $state = 0 if ($1 =~ m/^Optimal$/);
 74 |             print ZSEND_FILE "- hw.raid.logical_disk[$adapter,$vdrive_id,\"vd_state\"] \"$state\"\n";
 75 |             $check_next_line = -1;
 76 |             $vdrive_id       = -1;
 77 |         } else {
 78 |             next;
 79 |         }
 80 |     }
 81 | 
 82 |     my @pd_list = `$cli -pdlist -a $adapter -NoLog`;
 83 |     $check_next_line = 0;
 84 |     my $enclosure_id    = -1;
 85 |     my $drive_id        = -1;
 86 |     # Determine Slot Number for each drive on current enclosure
 87 |     foreach my $line (@pd_list) {
 88 |         if ($line =~ m/^Enclosure\sDevice\sID:\s(\d+)$/) {
 89 |             $enclosure_id           = $1;
 90 |             $check_next_line        = 1;
 91 |         } if ($line =~ m/^Enclosure\sDevice\sID:\sN\/A$/) {
 92 |             # This can happen, if embedded raid controller is in use, there are drives and logical disks, but no enclosures
 93 |             $enclosure_id           = 2989; # 0xBAD, :( magic hack
 94 |             $check_next_line        = 1;
 95 |         } elsif (($line =~ m/^Slot\sNumber:\s(\d+)$/) && $check_next_line && ($enclosure_id != -1)) {
 96 |             $drive_id               = $1;
 97 |             $check_next_line        = 1;
 98 |         } elsif (($line =~ m/^Media Error Count:\s(.*)/) && $check_next_line && ($drive_id != -1)) {
 99 |             my $media_errors        = $1;
100 |             print ZSEND_FILE        "- hw.raid.physical_disk[$adapter,$enclosure_id,$drive_id,\"media_errors\"] \"$media_errors\"\n";
101 |             $check_next_line        = 1;
102 |         } elsif (($line =~ m/^Predictive Failure Count:\s(.*)/) && $check_next_line && ($drive_id != -1)) {
103 |             my $predictive_errors   = $1;
104 |             print ZSEND_FILE        "- hw.raid.physical_disk[$adapter,$enclosure_id,$drive_id,\"predictive_errors\"] \"$predictive_errors\"\n";
105 |             $check_next_line        = 1;
106 |         } elsif (($line =~ m/^Firmware state:\s(.*)/) && $check_next_line && ($drive_id != -1)) {
107 |             my $firmware_state;
108 |             if ($1 =~ m/^(Unconfigured\(good\).*|Online,\sSpun.*|Hotspare,\sSpun.*)$/) {
109 |                 $firmware_state     = 0;
110 |             }
111 |             elsif ($1 =~ m/^Rebuild/) {
112 |                 $firmware_state     = 2;
113 |             }
114 |             else {
115 |                 $firmware_state     = 1;
116 |             }
117 |             print ZSEND_FILE        "- hw.raid.physical_disk[$adapter,$enclosure_id,$drive_id,\"firmware_state\"] \"$firmware_state\"\n";
118 |             $check_next_line        = 0;
119 |             $drive_id               = -1;
120 |             $enclosure_id           = -1;
121 |         } else {
122 |             next;
123 |         }
124 |     }
125 |     close (ZSEND_FILE) or die "Can't close $tmp_path: $!";
126 | }
127 | 
128 | my @cmd_args = ($zabbix_sender,'-c',$zabbix_config,'-i',$tmp_path);
129 | system(@cmd_args);
130 | 


--------------------------------------------------------------------------------
/unix/raid_check.pl:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/perl -w
  2 | 
  3 | use strict;
  4 | use warnings;
  5 | use Getopt::Long;
  6 | use Switch;
  7 | 
  8 | my ($mode,$mode_item,$adapter,$enclosure_id,$disk_id,$vdisk_id);
  9 | 
 10 | GetOptions (
 11 |     "mode=s"        => \$mode,
 12 |     "item=s"        => \$mode_item,
 13 |     "adapter=i"     => \$adapter,
 14 |     "enclosure:i"   => \$enclosure_id,
 15 |     "pdisk:i"       => \$disk_id,
 16 |     "vdisk:i"       => \$vdisk_id
 17 | ) or die("Error in command line arguments\n");
 18 | 
 19 | my $cli = '/usr/bin/sudo /opt/MegaRAID/CmdTool2/CmdTool2';
 20 | 
 21 | die("Mode is not defined. Use --mode paramater") if !defined $mode;
 22 | die("Adapter is not defined. Use --adapter paramater") if !defined $adapter;
 23 | 
 24 | switch ($mode) {
 25 |     case 'pdisk'    { &pdisk_item(item=>$mode_item,adapter=>$adapter,enclosure=>$enclosure_id,disk=>$disk_id) }
 26 |     case 'vdisk'    { &vdisk_item(item=>$mode_item,adapter=>$adapter,vd=>$vdisk_id) }
 27 |     case 'bbu'      { &bbu_item(item=>$mode_item,adapter=>$adapter) }
 28 |     case 'adapter'  { &adapter_item(item=>$mode_item,adapter=>$adapter) }
 29 |     else            { die("Unknown mode, use pdisk, vdisk, bbu or adapter mode") }
 30 | }
 31 | 
 32 | sub pdisk_item() {
 33 |     my %options     = @_;
 34 |     my $item        = $options{item} if defined $options{item} or die("use --item to define which item should be checked");
 35 |     my $enclosure   = $options{enclosure} if defined $options{enclosure} or die("use --enclosure to define enclosure on adapter");
 36 |     my $adapter     = $options{adapter} if defined $options{adapter} or die("use --adapter to define which adapter should be checked");
 37 |     my $disk        = $options{disk} if defined $options{disk} or die("use --pdisk to define which physical disk should be checked");
 38 | 
 39 |     my $regex       = '';
 40 |     my $item_found  = 0;
 41 |     my $output      = '';
 42 | 
 43 |     switch ($item) {
 44 |         case 'firmware_state'       { $regex = '^Firmware state:\s(.*)' }
 45 |         case 'raw_size'             { $regex = '^Raw Size:\s+(\d+\.\d+\s..)' }
 46 |         case 'predictive_errors'    { $regex = '^Predictive Failure Count:\s(.*)' }
 47 |         case 'inquiry_data'         { $regex = '^Inquiry Data:\s+(.*)' }
 48 |         case 'media_errors'         { $regex = '^Media Error Count:\s(.*)' }
 49 |         else                        { die("Unknown item $item for physical disk check") }
 50 |     }
 51 | 
 52 |     my @cli_output = `$cli -pdinfo -PhysDrv[$enclosure_id:$disk_id] -a $adapter -NoLog`;
 53 | 
 54 |     foreach my $line (@cli_output) {
 55 |         if ($line =~ $regex) {
 56 |             $output = $1;
 57 |             $item_found=1;
 58 |             last;
 59 |         }
 60 |     }
 61 |     if ($item_found) {
 62 |         if ($item eq 'firmware_state') {
 63 |             if ($output =~ m/^(Unconfigured\(good\).*|Online,\sSpun.*|Hotspare,\sSpun.*)$/) {
 64 |                 $output = 0;
 65 |             }
 66 |             elsif ($output =~ m/^Rebuild/) {
 67 |                 $output = 2;
 68 |             }
 69 |             else {
 70 |                 $output = 1;
 71 |             }
 72 |         }
 73 |         print $output;
 74 |     }
 75 | }
 76 | 
 77 | sub vdisk_item() {
 78 |     my %options     = @_;
 79 |     my $item        = $options{item} if defined $options{item} or die("use --item to define which item should be checked");
 80 |     my $adapter     = $options{adapter} if defined $options{adapter} or die("use --adapter to define which adapter should be checked");
 81 |     my $vd          = $options{vd} if defined $options{vd} or die("use --vdisk to define which virtual disk should be checked");
 82 |     my $item_found  = 0;
 83 |     my $regex       = '';
 84 |     my $output      = '';
 85 | 
 86 |     switch ($item) {
 87 |         case 'vd_state'         { $regex = '^State\s+:\s(.*)$' }
 88 |         case 'vd_size'          { $regex = '^Size\s+:\s(\d+\.\d+\s..)' }
 89 |         else                    { die("Unknown item $item for virtual disk check") }
 90 |     }
 91 | 
 92 |     my @cli_output = `$cli -LDinfo -L $vd -a $adapter -NoLog`;
 93 | 
 94 |     foreach my $line (@cli_output) {
 95 |         if ($line =~ $regex) {
 96 |             $output = $1;
 97 |             $item_found = 1;
 98 |             last;
 99 |         }
100 |     }
101 |     if ($item_found) {
102 |         if ($item eq 'vd_state') { if ($output =~ m/^Optimal$/) { $output = 0 } else { $output = 1 } }
103 |         print $output;
104 |     }
105 | }
106 | 
107 | sub bbu_item() {
108 |     my %options         = @_;
109 |     my $item            = $options{item} if defined $options{item} or die("use --item to define which item should be checked");
110 |     my $adapter         = $options{adapter} if defined $options{adapter} or die("use --adapter to define which adapter should be checked");
111 |     my $regex           = '';
112 |     my $command         = '';
113 |     my $output          = '';
114 |     my $wanted_group    = -1;
115 |     my $item_found      = 0;
116 | 
117 |     switch ($item) {
118 |         case 'bbu_state'            { $command = '-GetBbuStatus';       $regex = 'Battery State\s*:\s(.*)$';                                    $wanted_group = 1; }
119 |         case 'design_capacity'      { $command = '-GetBBUDesignInfo';   $regex = 'Design\sCapacity:\s(\d+)\smAh';                               $wanted_group = 1; }
120 |         case 'full_capacity'        { $command = '-GetBBUCapacityInfo'; $regex = '(Full\sCharge\sCapacity|.*Pack\senergy\s*):\s(\d+)\s(mAh|J)'; $wanted_group = 2; }
121 |         case 'state_of_charge'      { $command = '-GetBBUCapacityInfo'; $regex = 'Absolute\sState\sof\scharge\s*:\s(\d+).*%';                   $wanted_group = 1; }
122 |         case 'date_manufactured'    { $command = '-GetBBUDesignInfo';   $regex = 'Date\sof\sManufacture\s*:\s(.*)$';                            $wanted_group = 1; }
123 |         else                        { die("Unknown item $item for battery unit check") }
124 |     }
125 | 
126 |     my @cli_output = `$cli -AdpBbuCmd $command -a $adapter -NoLog`;
127 |     foreach my $line (@cli_output) {
128 |         if ($line =~ $regex) {
129 |             $output = $1 if $wanted_group == 1;
130 |             $output = $2 if $wanted_group == 2;
131 |             $item_found=1;
132 |             last;
133 |         }
134 |     }
135 |     if ($item_found) {
136 |         if ($item eq 'bbu_state') { if ($output =~ m/^(Optimal|Operational)$/) { $output = 0 } else { $output = 1 } }
137 |         print $output;
138 |     }
139 | }
140 | 
141 | sub adapter_item() {
142 |     my %options         = @_;
143 |     my $item            = $options{item} if defined $options{item} or die("use --item to define which item should be checked");
144 |     my $adapter         = $options{adapter} if defined $options{adapter} or die("use --adapter to define which adapter should be checked");
145 |     my $regex           = '';
146 |     my $item_found      = 0;
147 | 
148 |     switch ($item) {
149 |         case 'fw_version'   { $regex = '^\s*FW\sPackage\sBuild:\s(.*)$' }
150 |         case 'product_name' { $regex = '^\s*Product\sName\s*:\s(.*)$' }
151 |         else                { die("Unknown item $item for adapter check") }
152 |     }
153 | 
154 |     my @cli_output = `$cli -AdpAllInfo -a $adapter -NoLog`;
155 |     foreach my $line (@cli_output) {
156 |         if ($line =~ $regex) {
157 |             print $1;
158 |             $item_found=1;
159 |             last;
160 |         }
161 |     }
162 | }
163 | 


--------------------------------------------------------------------------------
/windows/raid_discovery.ps1:
--------------------------------------------------------------------------------
  1 | $CLI                    = 'C:\Program Files\zabbix_agent\conf.d\lsi_raid\MegaCli64.exe'
  2 | $sender                 = 'C:\Program Files\zabbix_agent\zabbix_sender.exe'
  3 | $agent_config           = 'C:\Program Files\zabbix_agent\zabbix_agentd.win.conf'
  4 | 
  5 | $number_of_adapters     = [int](& $CLI -adpCount -NoLog | Select-String "Controller Count: (\d+)" -AllMatches | % {$_.Matches} | % {$_.groups[1].value})
  6 | $physical_drives        = @{}
  7 | $virtual_drives         = @{}
  8 | $battery_units          = @{}
  9 | $adapters               = @{}
 10 | for ($adapter = 0; $adapter -lt $number_of_adapters;$adapter++) {
 11 |     # check number of physical disks on this adapter
 12 |     $number_of_disks = [int](& $CLI -pdGetNum -a $adapter -NoLog | Select-String "Number of Physical Drives on Adapter $adapter\: (\d)" -AllMatches | % {$_.Matches} | % {$_.groups[1].value})
 13 |     if ($number_of_disks -eq 0) {
 14 |         write-host "No physical disks found on adapter $adapter. Skipping this adapter"
 15 |         Continue
 16 |     }
 17 | 
 18 |     # check number of configured RAID volumes
 19 |     $number_of_lds = [int](& $CLI -LDGetNum -a $adapter -NoLog | Select-String "Number of Virtual Drives Configured on Adapter $adapter\:\s(\d+)" -AllMatches | % {$_.Matches} | % {$_.groups[1].value})
 20 |     if ($number_of_lds -eq 0) {
 21 |         write-host "No virtual disks found on adapter $adapter. Skipping this adapter"
 22 |         Continue
 23 |     }
 24 | 
 25 |     # check IDs for configured RAID volumes (IDs could be sequential, or not)
 26 |     $tmp_file = Join-Path ${env:temp} "raid_vdrives-$(Get-Date -Format yyyy-MM-dd-HH-mm-ss).tmp"
 27 |     & $CLI -LDinfo -Lall -a $adapter -NoLog | Out-File $tmp_file
 28 |     [regex]$regex_vd_id = "^\s*Virtual\sDrive:\s(\d+)\s.*$"
 29 |     $reader             = [System.IO.File]::OpenText($tmp_file)
 30 |     $vdrive_id          = -1;
 31 |     try {
 32 |         for(;;) {
 33 |             $line = $reader.ReadLine()
 34 |             if ($line -eq $null) { break }
 35 |             if (($regex_vd_id.isMatch($line)) -eq $True) {
 36 |                 $vdrive_id          = $regex_vd_id.Matches($line) | % {$_.groups[1].value}
 37 |                 $virtual_drives.Add("$adapter-$vdrive_id","{ `"{#VDRIVE_ID}`":`"$vdrive_id`", `"{#ADAPTER_ID}`":`"$adapter`" }")
 38 |             } else {
 39 |                 Continue
 40 |             }
 41 |         }
 42 |     }
 43 |     finally {
 44 |         $reader.Close()
 45 |     }
 46 |     remove-item $tmp_file
 47 | 
 48 |     # List Battery unit
 49 |     $bbu_is_missing = (& $CLI -AdpBbuCmd -GetBbuStatus -a $adapter -NoLog | Select-String ".*Get BBU Status Failed.*" | % {$_.Matches})
 50 |     if (!$bbu_is_missing) {
 51 |         $battery_units.Add($adapter,"{ `"{#ADAPTER_ID}`":`"$adapter`" }")
 52 |     }
 53 | 
 54 |     # List physical drives
 55 |     $enclosure_number = [int](& $CLI -EncInfo -a $adapter -NoLog | Select-String "Number of enclosures on adapter $adapter -- (\d)" -AllMatches | % {$_.Matches} | % {$_.groups[1].value})
 56 |     $enclosures = @{}
 57 |     if (($enclosure_number -eq 0) -and ($number_of_disks -eq 0)) {
 58 |         write-host "No enclosures/drives detected, skipping adapter"
 59 |         Continue
 60 |     } else {
 61 |         # Detected enclosure (or no enclosure, but drives), try to add current adapter to adapters list
 62 |         if (!($adapters.ContainsKey($adapter))) {
 63 |             $adapters.Add($adapter,"{ `"{#ADAPTER_ID}`":`"$adapter`" }")
 64 |         }
 65 |         # ========
 66 |         # List all physical drives
 67 |         # ========
 68 |         $check_next_line        = 0
 69 |         [regex]$regex_enc       = "^\s*Enclosure\sDevice\sID:\s(\d+)$"
 70 |         [regex]$regex_enc_na    = "^\s*Enclosure\sDevice\sID:\sN\/A$"
 71 |         [regex]$regex_slot      = "^\s*Slot\sNumber:\s(\d+)$"
 72 | 
 73 |         $tmp_file   = Join-Path ${env:temp} "raid_enclosures-$(Get-Date -Format yyyy-MM-dd-HH-mm-ss).tmp"
 74 |         & $CLI -pdlist -a $adapter -NoLog | Out-File $tmp_file
 75 |         $reader     = [System.IO.File]::OpenText($tmp_file)
 76 | 
 77 |         # Determine Slot Number for each drive on enclosure
 78 |         $enclosure_id = -1;
 79 |         try {
 80 |             for(;;) {
 81 |                 $line = $reader.ReadLine()
 82 |                 if ($line -eq $null) { break }
 83 |                 # Line contains enc id, next line is slot id
 84 |                 if (($regex_enc.isMatch($line)) -eq $True) {
 85 |                     $enclosure_id       = $regex_enc.Matches($line) | % {$_.groups[1].value}
 86 |                     $check_next_line    = 1
 87 |                 } elseif (($regex_enc_na.isMatch($line)) -eq $True) {
 88 |                     # This can happen, if embedded raid controller is in use, there are drives and logical disks, but no enclosures
 89 |                     $enclosure_id       = 2989 # 0xBAD, :( magic hack
 90 |                     $check_next_line    = 1
 91 |                 } elseif ((($regex_slot.isMatch($line)) -eq $True) -and ($check_next_line -eq 1) -and ($enclosure_id -ne -1)) {
 92 |                     $drive_id           = $regex_slot.Matches($line) | % {$_.groups[1].value}
 93 |                     $physical_drives.Add("$adapter-$enclosure_id-$drive_id","{ `"{#ENCLOSURE_ID}`":`"$enclosure_id`", `"{#PDRIVE_ID}`":`"$drive_id`", `"{#ADAPTER_ID}`":`"$adapter`" }")
 94 |                     $check_next_line    = 0
 95 |                     $enclosure_id       = -1
 96 |                 } else {
 97 |                     Continue
 98 |                 }
 99 |             }
100 |         }
101 |         finally {
102 |             $reader.Close()
103 |         }
104 |         remove-item $tmp_file
105 |     }
106 | }
107 | 
108 | # create file with json
109 | $zsend_data = Join-Path $(Split-Path -Parent $CLI) 'zsend_data.txt'
110 | 
111 | if (($physical_drives.Count -ne 0) -and ($virtual_drives.Count -ne 0)) {
112 |     $writer = new-object io.streamwriter($zsend_data,$False)
113 |     $i = 1
114 |     $writer.Write('- hw.raid.discovery.pdisks { "data":[')
115 |     foreach ($physical_drive in $physical_drives.Keys) {
116 |         if ($i -lt $physical_drives.Count) {
117 |             $string = "$($physical_drives.Item($physical_drive)),"
118 |         } else {
119 |             $string = "$($physical_drives.Item($physical_drive)) ]}"
120 |         }
121 |         $i++
122 |         $writer.Write($string)
123 |     }
124 |     $writer.WriteLine('')
125 |     $writer.Write('- hw.raid.discovery.vdisks { "data":[')
126 |     $i = 1
127 |     foreach ($virtual_drive in $virtual_drives.Keys) {
128 |         if ($i -lt $virtual_drives.Count) {
129 |             $string = "$($virtual_drives.Item($virtual_drive)),"
130 |         } else {
131 |             $string = "$($virtual_drives.Item($virtual_drive)) ]}"
132 |         }
133 |         $i++
134 |         $writer.Write($string)
135 |     }
136 |     $i = 1
137 |     if ($battery_units.Count -ne 0) {
138 |         $writer.WriteLine('')
139 |         $writer.Write('- hw.raid.discovery.bbu { "data":[')
140 |         foreach ($battery_unit in $battery_units.Keys) {
141 |             if ($i -lt $battery_units.Count) {
142 |                 $string = "$($battery_units.Item($battery_unit)),"
143 |             } else {
144 |                 $string = "$($battery_units.Item($battery_unit)) ]}"
145 |             }
146 |             $i++
147 |             $writer.Write($string)
148 |         }
149 |     }
150 |     $i = 1
151 |     if ($adapters.Count -ne 0) {
152 |         $writer.WriteLine('')
153 |         $writer.Write('- hw.raid.discovery.adapters { "data":[')
154 |         foreach ($adapter in $adapters.Keys) {
155 |             if ($i -lt $adapters.Count) {
156 |                 $string = "$($adapters.Item($adapter)),"
157 |             } else {
158 |                 $string = "$($adapters.Item($adapter)) ]}"
159 |             }
160 |             $i++
161 |             $writer.Write($string)
162 |         }
163 |     }
164 |     $writer.WriteLine('')
165 |     $writer.Close()
166 | }
167 | 
168 | & $sender -c $agent_config -i $zsend_data


--------------------------------------------------------------------------------
/windows/raid_trapper_checks.ps1:
--------------------------------------------------------------------------------
  1 | $CLI                = 'C:\Program Files\zabbix_agent\scripts\hw.raid\CmdTool2_64.exe'
  2 | $sender             = 'C:\Program Files\zabbix_agent\zabbix_sender.exe'
  3 | $agent_config       = 'C:\Program Files\zabbix_agent\zabbix_agentd.win.conf'
  4 | 
  5 | $number_of_adapters = [int](& $CLI -adpCount -NoLog | Select-String "Controller Count: (\d+)" -AllMatches | % {$_.Matches} | % {$_.groups[1].value})
  6 | $physical_drives    = @()
  7 | $virtual_drives     = @()
  8 | $zsend_data         = Join-Path $(Split-Path -Parent $CLI) 'zsend_trapper_data.txt'
  9 | 
 10 | if (Test-Path $zsend_data) { remove-item $zsend_data }
 11 | 
 12 | for ($adapter = 0; $adapter -lt $number_of_adapters;$adapter++) {
 13 |     # check number of physical disks on this adapter
 14 |     $number_of_disks = [int](& $CLI -pdGetNum -a $adapter -NoLog | Select-String "Number of Physical Drives on Adapter $adapter\: (\d)" -AllMatches | % {$_.Matches} | % {$_.groups[1].value})
 15 |     if ($number_of_disks -eq 0) {
 16 |         write-host "No physical disks found on adapter $adapter. Skipping this adapter"
 17 |         Continue
 18 |     }
 19 | 
 20 |     # check number of configured RAID volumes
 21 |     $number_of_lds = [int](& $CLI -LDGetNum -a $adapter -NoLog | Select-String "Number of Virtual Drives Configured on Adapter $adapter\:\s(\d+)" -AllMatches | % {$_.Matches} | % {$_.groups[1].value})
 22 |     if ($number_of_lds -eq 0) {
 23 |         write-host "No virtual disks found on adapter $adapter. Skipping this adapter"
 24 |         Continue
 25 |     }
 26 | 
 27 |     # List Battery unit
 28 |     $bbu_is_missing = (& $CLI -AdpBbuCmd -GetBbuStatus -a $adapter -NoLog | Select-String ".*Get BBU Status Failed.*" | % {$_.Matches})
 29 |     if (!$bbu_is_missing) {
 30 |         $tmp_file = Join-Path ${env:temp} "raid_bbu-$(Get-Date -Format yyyy-MM-dd-HH-mm-ss).tmp"
 31 |         & $CLI -AdpBBUCMD -a $adapter -NoLog | Out-File $tmp_file
 32 |         $reader = [System.IO.File]::OpenText($tmp_file)
 33 |         [regex]$regex_bbu_state         = "Battery State\s*:\s(.*)$"
 34 |         [regex]$regex_state_of_charge   = "Absolute\sState\sof\scharge\s*:\s(\d+).*%"
 35 |         try {
 36 |             $writer = new-object io.streamwriter($zsend_data,$True)
 37 |             for(;;) {
 38 |                 $line = $reader.ReadLine()
 39 |                 if ($line -eq $null) {
 40 |                     break
 41 |                 } elseif (($regex_bbu_state.isMatch($line)) -eq $True) {
 42 |                     $bbu_state          = $regex_bbu_state.Matches($line) | % {$_.groups[1].value}
 43 |                     if ($bbu_state -Match '^(Optimal|Operational)$') { $bbu_state = 0 } else { $bbu_state = 1 }
 44 |                     $writer.WriteLine("- hw.raid.bbu[$adapter,`"bbu_state`"] `"$bbu_state`"")
 45 |                 } elseif ((($regex_state_of_charge.isMatch($line)) -eq $True)) {
 46 |                     $state_of_charge    = $regex_state_of_charge.Matches($line) | % {$_.groups[1].value}
 47 |                     $writer.WriteLine("- hw.raid.bbu[$adapter,`"state_of_charge`"] `"$state_of_charge`"")
 48 |                 } else { Continue }
 49 |             }
 50 |         }
 51 |         finally {
 52 |             $reader.Close()
 53 |             $writer.Close()
 54 |             remove-item $tmp_file
 55 |         }
 56 |     }
 57 | 
 58 |     # List RAID Volumes and its states
 59 |     $tmp_file = Join-Path ${env:temp} "raid_vdrives-$(Get-Date -Format yyyy-MM-dd-HH-mm-ss).tmp"
 60 |     & $CLI -LDinfo -Lall -a $adapter -NoLog | Out-File $tmp_file
 61 |     [regex]$regex_vd_id         = "^\s*Virtual\sDrive:\s(\d+)\s.*$"
 62 |     [regex]$regex_vd_state      = "^\s*State\s+:\s(.*)$"
 63 |     $reader = [System.IO.File]::OpenText($tmp_file)
 64 |     $check_next_line = 0
 65 |     $vdrive_id  = -1;
 66 |     try {
 67 |         $writer = new-object io.streamwriter($zsend_data,$True)
 68 |         for(;;) {
 69 |             $line = $reader.ReadLine()
 70 |             if ($line -eq $null) { break }
 71 |             if (($regex_vd_id.isMatch($line)) -eq $True) {
 72 |                 $vdrive_id          = $regex_vd_id.Matches($line) | % {$_.groups[1].value}
 73 |                 $check_next_line    = 1
 74 |             } elseif ((($regex_vd_state.isMatch($line)) -eq $True) -and ($check_next_line -eq 1) -and ($vdrive_id -ne -1)) {
 75 |                 $state              = $regex_vd_state.Matches($line) | % {$_.groups[1].value}
 76 |                 if ($state -Match '^Optimal$') { $state = 0 } else { $state = 1 }
 77 |                 $writer.WriteLine("- hw.raid.logical_disk[$adapter,$vdrive_id,`"vd_state`"] `"$state`"")
 78 |                 $check_next_line    = -1
 79 |                 $vdrive_id          = -1
 80 |             } else {
 81 |                 Continue
 82 |             }
 83 |         }
 84 |     }
 85 |     finally {
 86 |         $reader.Close()
 87 |         $writer.Close()
 88 |     }
 89 |     remove-item $tmp_file
 90 | 
 91 |     # List physical drives
 92 |     $enclosure_number = [int](& $CLI -EncInfo -a $adapter -NoLog | Select-String "Number of enclosures on adapter $adapter -- (\d)" -AllMatches | % {$_.Matches} | % {$_.groups[1].value})
 93 |     $enclosures = @{}
 94 |     if (($enclosure_number -eq 0) -and ($number_of_disks -eq 0)) {
 95 |         write-host "No enclosures/disks detected, skipping adapter"
 96 |         Continue
 97 |     } else {
 98 |         # ========
 99 |         # List all physical drives and its states
100 |         # ========
101 |         $tmp_file = Join-Path ${env:temp} "raid_enclosures-$(Get-Date -Format yyyy-MM-dd-HH-mm-ss).tmp"
102 |         & $CLI -pdlist -a $adapter -NoLog | Out-File $tmp_file
103 |         $reader = [System.IO.File]::OpenText($tmp_file)
104 |         $check_next_line = 0
105 |         [regex]$regex_enc               = "^\s*Enclosure\sDevice\sID:\s(\d+)$"
106 |         [regex]$regex_enc_na            = "^\s*Enclosure\sDevice\sID:\sN\/A$"
107 |         [regex]$regex_slot              = "^\s*Slot\sNumber:\s(\d+)$"
108 |         [regex]$regex_media_errors      = "Media Error Count:\s(.*)"
109 |         [regex]$regex_predictive_errors = "Predictive Failure Count:\s(.*)"
110 |         [regex]$regex_firmware_state    = "Firmware state:\s(.*)"
111 |         # Determine Slot Number for each drive on enclosure
112 |         $enclosure_id   = -1;
113 |         $drive_id       = -1
114 |         try {
115 |             $writer = new-object io.streamwriter($zsend_data,$True)
116 |             for(;;) {
117 |                 $line = $reader.ReadLine()
118 |                 if ($line -eq $null) { break }
119 |                 # Line contains enc id, next line is slot id
120 |                 if (($regex_enc.isMatch($line)) -eq $True) {
121 |                     $enclosure_id = $regex_enc.Matches($line) | % {$_.groups[1].value}
122 |                     $check_next_line = 1
123 |                 } elseif (($regex_enc_na.isMatch($line)) -eq $True) {
124 |                     # This can happen, if embedded raid controller is use, there are drives and logical disks, but no enclosures
125 |                     $enclosure_id = 2989 # 0xBAD, :( magic hack
126 |                     $check_next_line = 1
127 |                 } elseif ((($regex_slot.isMatch($line)) -eq $True) -and ($check_next_line -eq 1) -and ($enclosure_id -ne -1)) {
128 |                     $drive_id = $regex_slot.Matches($line) | % {$_.groups[1].value}
129 |                     $check_next_line = 1
130 |                 } elseif    (
131 |                                 ($check_next_line -eq 1) -and
132 |                                 ($drive_id -ne -1) -and
133 |                                 ($enclosure_id -ne -1) -and
134 |                                 (($regex_media_errors.isMatch($line)) -eq $True)
135 |                             ) {
136 |                         $media_errors = $regex_media_errors.Matches($line) | % {$_.groups[1].value}
137 |                         $writer.WriteLine("- hw.raid.physical_disk[$adapter,$enclosure_id,$drive_id,`"media_errors`"] $media_errors")
138 |                         $check_next_line = 1
139 |                 } elseif    (
140 |                                 ($check_next_line -eq 1) -and
141 |                                 ($drive_id -ne -1) -and
142 |                                 ($enclosure_id -ne -1) -and
143 |                                 (($regex_predictive_errors.isMatch($line)) -eq $True)
144 |                             ) {
145 |                         $predictive_errors = $regex_predictive_errors.Matches($line) | % {$_.groups[1].value}
146 |                         $writer.WriteLine("- hw.raid.physical_disk[$adapter,$enclosure_id,$drive_id,`"predictive_errors`"] $predictive_errors")
147 |                         $check_next_line = 1
148 |                 } elseif    (
149 |                                 ($check_next_line -eq 1) -and
150 |                                 ($drive_id -ne -1) -and
151 |                                 ($enclosure_id -ne -1) -and
152 |                                 (($regex_firmware_state.isMatch($line)) -eq $True)
153 |                             ) {
154 |                         $firmware_state = $regex_firmware_state.Matches($line) | % {$_.groups[1].value}
155 |                         if ($firmware_state -match '^(Unconfigured\(good\).*|Online,\sSpun.*|Hotspare,\sSpun.*)$') {
156 |                             $firmware_state = 0
157 |                         }
158 |                         elseif ($firmware_state -match '^Rebuild') {
159 |                             $firmware_state = 2
160 |                         }
161 |                         else {
162 |                             $firmware_state = 1
163 |                         }
164 |                         $writer.WriteLine("- hw.raid.physical_disk[$adapter,$enclosure_id,$drive_id,`"firmware_state`"] `"$firmware_state`"")
165 |                         $check_next_line = 1
166 |                 } else { Continue }
167 |             }
168 |         }
169 |         finally {
170 |             $reader.Close()
171 |             $writer.Close()
172 |         }
173 |         remove-item $tmp_file
174 |     }
175 | }
176 | 
177 | & $sender -c $agent_config -i $zsend_data
178 | 


--------------------------------------------------------------------------------
/template/LSI_RAID_template.xml:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="UTF-8"?>
  2 | <zabbix_export>
  3 |     <version>2.0</version>
  4 |     <date>2014-02-10T14:00:39Z</date>
  5 |     <groups>
  6 |         <group>
  7 |             <name>Templates</name>
  8 |         </group>
  9 |     </groups>
 10 |     <templates>
 11 |         <template>
 12 |             <template>Template LSI RAID</template>
 13 |             <name>Template LSI RAID (agent + trapper)</name>
 14 |             <groups>
 15 |                 <group>
 16 |                     <name>Templates</name>
 17 |                 </group>
 18 |             </groups>
 19 |             <applications>
 20 |                 <application>
 21 |                     <name>LSI RAID adapter</name>
 22 |                 </application>
 23 |                 <application>
 24 |                     <name>LSI RAID BBU</name>
 25 |                 </application>
 26 |                 <application>
 27 |                     <name>LSI RAID Logical Volume</name>
 28 |                 </application>
 29 |                 <application>
 30 |                     <name>LSI RAID Physical Volume</name>
 31 |                 </application>
 32 |             </applications>
 33 |             <items/>
 34 |             <discovery_rules>
 35 |                 <discovery_rule>
 36 |                     <name>RAID discovery adapters</name>
 37 |                     <type>2</type>
 38 |                     <snmp_community/>
 39 |                     <snmp_oid/>
 40 |                     <key>hw.raid.discovery.adapters</key>
 41 |                     <delay>0</delay>
 42 |                     <status>0</status>
 43 |                     <allowed_hosts/>
 44 |                     <snmpv3_contextname/>
 45 |                     <snmpv3_securityname/>
 46 |                     <snmpv3_securitylevel>0</snmpv3_securitylevel>
 47 |                     <snmpv3_authprotocol>0</snmpv3_authprotocol>
 48 |                     <snmpv3_authpassphrase/>
 49 |                     <snmpv3_privprotocol>0</snmpv3_privprotocol>
 50 |                     <snmpv3_privpassphrase/>
 51 |                     <delay_flex/>
 52 |                     <params/>
 53 |                     <ipmi_sensor/>
 54 |                     <authtype>0</authtype>
 55 |                     <username/>
 56 |                     <password/>
 57 |                     <publickey/>
 58 |                     <privatekey/>
 59 |                     <port/>
 60 |                     <filter>:</filter>
 61 |                     <lifetime>30</lifetime>
 62 |                     <description/>
 63 |                     <item_prototypes>
 64 |                         <item_prototype>
 65 |                             <name>Adapter {#ADAPTER_ID} firmware</name>
 66 |                             <type>0</type>
 67 |                             <snmp_community/>
 68 |                             <multiplier>0</multiplier>
 69 |                             <snmp_oid/>
 70 |                             <key>hw.raid.adapter[{#ADAPTER_ID},&quot;fw_version&quot;]</key>
 71 |                             <delay>86400</delay>
 72 |                             <history>7</history>
 73 |                             <trends>365</trends>
 74 |                             <status>0</status>
 75 |                             <value_type>1</value_type>
 76 |                             <allowed_hosts/>
 77 |                             <units/>
 78 |                             <delta>0</delta>
 79 |                             <snmpv3_contextname/>
 80 |                             <snmpv3_securityname/>
 81 |                             <snmpv3_securitylevel>0</snmpv3_securitylevel>
 82 |                             <snmpv3_authprotocol>0</snmpv3_authprotocol>
 83 |                             <snmpv3_authpassphrase/>
 84 |                             <snmpv3_privprotocol>0</snmpv3_privprotocol>
 85 |                             <snmpv3_privpassphrase/>
 86 |                             <formula>1</formula>
 87 |                             <delay_flex/>
 88 |                             <params/>
 89 |                             <ipmi_sensor/>
 90 |                             <data_type>0</data_type>
 91 |                             <authtype>0</authtype>
 92 |                             <username/>
 93 |                             <password/>
 94 |                             <publickey/>
 95 |                             <privatekey/>
 96 |                             <port/>
 97 |                             <description/>
 98 |                             <inventory_link>0</inventory_link>
 99 |                             <applications>
100 |                                 <application>
101 |                                     <name>LSI RAID adapter</name>
102 |                                 </application>
103 |                             </applications>
104 |                             <valuemap/>
105 |                             <logtimefmt/>
106 |                         </item_prototype>
107 |                         <item_prototype>
108 |                             <name>Adapter {#ADAPTER_ID} model</name>
109 |                             <type>0</type>
110 |                             <snmp_community/>
111 |                             <multiplier>0</multiplier>
112 |                             <snmp_oid/>
113 |                             <key>hw.raid.adapter[{#ADAPTER_ID},&quot;product_name&quot;]</key>
114 |                             <delay>86400</delay>
115 |                             <history>7</history>
116 |                             <trends>365</trends>
117 |                             <status>0</status>
118 |                             <value_type>1</value_type>
119 |                             <allowed_hosts/>
120 |                             <units/>
121 |                             <delta>0</delta>
122 |                             <snmpv3_contextname/>
123 |                             <snmpv3_securityname/>
124 |                             <snmpv3_securitylevel>0</snmpv3_securitylevel>
125 |                             <snmpv3_authprotocol>0</snmpv3_authprotocol>
126 |                             <snmpv3_authpassphrase/>
127 |                             <snmpv3_privprotocol>0</snmpv3_privprotocol>
128 |                             <snmpv3_privpassphrase/>
129 |                             <formula>1</formula>
130 |                             <delay_flex/>
131 |                             <params/>
132 |                             <ipmi_sensor/>
133 |                             <data_type>0</data_type>
134 |                             <authtype>0</authtype>
135 |                             <username/>
136 |                             <password/>
137 |                             <publickey/>
138 |                             <privatekey/>
139 |                             <port/>
140 |                             <description/>
141 |                             <inventory_link>0</inventory_link>
142 |                             <applications>
143 |                                 <application>
144 |                                     <name>LSI RAID adapter</name>
145 |                                 </application>
146 |                             </applications>
147 |                             <valuemap/>
148 |                             <logtimefmt/>
149 |                         </item_prototype>
150 |                     </item_prototypes>
151 |                     <trigger_prototypes/>
152 |                     <graph_prototypes/>
153 |                     <host_prototypes/>
154 |                 </discovery_rule>
155 |                 <discovery_rule>
156 |                     <name>RAID discovery bbu</name>
157 |                     <type>2</type>
158 |                     <snmp_community/>
159 |                     <snmp_oid/>
160 |                     <key>hw.raid.discovery.bbu</key>
161 |                     <delay>0</delay>
162 |                     <status>0</status>
163 |                     <allowed_hosts/>
164 |                     <snmpv3_contextname/>
165 |                     <snmpv3_securityname/>
166 |                     <snmpv3_securitylevel>0</snmpv3_securitylevel>
167 |                     <snmpv3_authprotocol>0</snmpv3_authprotocol>
168 |                     <snmpv3_authpassphrase/>
169 |                     <snmpv3_privprotocol>0</snmpv3_privprotocol>
170 |                     <snmpv3_privpassphrase/>
171 |                     <delay_flex/>
172 |                     <params/>
173 |                     <ipmi_sensor/>
174 |                     <authtype>0</authtype>
175 |                     <username/>
176 |                     <password/>
177 |                     <publickey/>
178 |                     <privatekey/>
179 |                     <port/>
180 |                     <filter>:</filter>
181 |                     <lifetime>30</lifetime>
182 |                     <description/>
183 |                     <item_prototypes>
184 |                         <item_prototype>
185 |                             <name>BBU current capacity on adapter:{#ADAPTER_ID}</name>
186 |                             <type>0</type>
187 |                             <snmp_community/>
188 |                             <multiplier>0</multiplier>
189 |                             <snmp_oid/>
190 |                             <key>hw.raid.bbu[{#ADAPTER_ID},&quot;full_capacity&quot;]</key>
191 |                             <delay>300</delay>
192 |                             <history>7</history>
193 |                             <trends>365</trends>
194 |                             <status>1</status>
195 |                             <value_type>3</value_type>
196 |                             <allowed_hosts/>
197 |                             <units/>
198 |                             <delta>0</delta>
199 |                             <snmpv3_contextname/>
200 |                             <snmpv3_securityname/>
201 |                             <snmpv3_securitylevel>0</snmpv3_securitylevel>
202 |                             <snmpv3_authprotocol>0</snmpv3_authprotocol>
203 |                             <snmpv3_authpassphrase/>
204 |                             <snmpv3_privprotocol>0</snmpv3_privprotocol>
205 |                             <snmpv3_privpassphrase/>
206 |                             <formula>1</formula>
207 |                             <delay_flex/>
208 |                             <params/>
209 |                             <ipmi_sensor/>
210 |                             <data_type>0</data_type>
211 |                             <authtype>0</authtype>
212 |                             <username/>
213 |                             <password/>
214 |                             <publickey/>
215 |                             <privatekey/>
216 |                             <port/>
217 |                             <description/>
218 |                             <inventory_link>0</inventory_link>
219 |                             <applications>
220 |                                 <application>
221 |                                     <name>LSI RAID BBU</name>
222 |                                 </application>
223 |                             </applications>
224 |                             <valuemap/>
225 |                             <logtimefmt/>
226 |                         </item_prototype>
227 |                         <item_prototype>
228 |                             <name>BBU design capacity on adapter:{#ADAPTER_ID}</name>
229 |                             <type>0</type>
230 |                             <snmp_community/>
231 |                             <multiplier>0</multiplier>
232 |                             <snmp_oid/>
233 |                             <key>hw.raid.bbu[{#ADAPTER_ID},&quot;design_capacity&quot;]</key>
234 |                             <delay>86400</delay>
235 |                             <history>1</history>
236 |                             <trends>365</trends>
237 |                             <status>1</status>
238 |                             <value_type>3</value_type>
239 |                             <allowed_hosts/>
240 |                             <units/>
241 |                             <delta>0</delta>
242 |                             <snmpv3_contextname/>
243 |                             <snmpv3_securityname/>
244 |                             <snmpv3_securitylevel>0</snmpv3_securitylevel>
245 |                             <snmpv3_authprotocol>0</snmpv3_authprotocol>
246 |                             <snmpv3_authpassphrase/>
247 |                             <snmpv3_privprotocol>0</snmpv3_privprotocol>
248 |                             <snmpv3_privpassphrase/>
249 |                             <formula>1</formula>
250 |                             <delay_flex/>
251 |                             <params/>
252 |                             <ipmi_sensor/>
253 |                             <data_type>0</data_type>
254 |                             <authtype>0</authtype>
255 |                             <username/>
256 |                             <password/>
257 |                             <publickey/>
258 |                             <privatekey/>
259 |                             <port/>
260 |                             <description/>
261 |                             <inventory_link>0</inventory_link>
262 |                             <applications>
263 |                                 <application>
264 |                                     <name>LSI RAID BBU</name>
265 |                                 </application>
266 |                             </applications>
267 |                             <valuemap/>
268 |                             <logtimefmt/>
269 |                         </item_prototype>
270 |                         <item_prototype>
271 |                             <name>BBU on adapter {#ADAPTER_ID}:manufacture date</name>
272 |                             <type>0</type>
273 |                             <snmp_community/>
274 |                             <multiplier>0</multiplier>
275 |                             <snmp_oid/>
276 |                             <key>hw.raid.bbu[{#ADAPTER_ID},&quot;date_manufactured&quot;]</key>
277 |                             <delay>86400</delay>
278 |                             <history>7</history>
279 |                             <trends>365</trends>
280 |                             <status>1</status>
281 |                             <value_type>1</value_type>
282 |                             <allowed_hosts/>
283 |                             <units/>
284 |                             <delta>0</delta>
285 |                             <snmpv3_contextname/>
286 |                             <snmpv3_securityname/>
287 |                             <snmpv3_securitylevel>0</snmpv3_securitylevel>
288 |                             <snmpv3_authprotocol>0</snmpv3_authprotocol>
289 |                             <snmpv3_authpassphrase/>
290 |                             <snmpv3_privprotocol>0</snmpv3_privprotocol>
291 |                             <snmpv3_privpassphrase/>
292 |                             <formula>1</formula>
293 |                             <delay_flex/>
294 |                             <params/>
295 |                             <ipmi_sensor/>
296 |                             <data_type>0</data_type>
297 |                             <authtype>0</authtype>
298 |                             <username/>
299 |                             <password/>
300 |                             <publickey/>
301 |                             <privatekey/>
302 |                             <port/>
303 |                             <description/>
304 |                             <inventory_link>0</inventory_link>
305 |                             <applications>
306 |                                 <application>
307 |                                     <name>LSI RAID BBU</name>
308 |                                 </application>
309 |                             </applications>
310 |                             <valuemap/>
311 |                             <logtimefmt/>
312 |                         </item_prototype>
313 |                         <item_prototype>
314 |                             <name>BBU state of charge on adapter:{#ADAPTER_ID}</name>
315 |                             <type>2</type>
316 |                             <snmp_community/>
317 |                             <multiplier>0</multiplier>
318 |                             <snmp_oid/>
319 |                             <key>hw.raid.bbu[{#ADAPTER_ID},&quot;state_of_charge&quot;]</key>
320 |                             <delay>0</delay>
321 |                             <history>7</history>
322 |                             <trends>365</trends>
323 |                             <status>0</status>
324 |                             <value_type>3</value_type>
325 |                             <allowed_hosts/>
326 |                             <units>%</units>
327 |                             <delta>0</delta>
328 |                             <snmpv3_contextname/>
329 |                             <snmpv3_securityname/>
330 |                             <snmpv3_securitylevel>0</snmpv3_securitylevel>
331 |                             <snmpv3_authprotocol>0</snmpv3_authprotocol>
332 |                             <snmpv3_authpassphrase/>
333 |                             <snmpv3_privprotocol>0</snmpv3_privprotocol>
334 |                             <snmpv3_privpassphrase/>
335 |                             <formula>1</formula>
336 |                             <delay_flex/>
337 |                             <params/>
338 |                             <ipmi_sensor/>
339 |                             <data_type>0</data_type>
340 |                             <authtype>0</authtype>
341 |                             <username/>
342 |                             <password/>
343 |                             <publickey/>
344 |                             <privatekey/>
345 |                             <port/>
346 |                             <description/>
347 |                             <inventory_link>0</inventory_link>
348 |                             <applications>
349 |                                 <application>
350 |                                     <name>LSI RAID BBU</name>
351 |                                 </application>
352 |                             </applications>
353 |                             <valuemap/>
354 |                             <logtimefmt/>
355 |                         </item_prototype>
356 |                         <item_prototype>
357 |                             <name>BBU state on adapter:{#ADAPTER_ID}</name>
358 |                             <type>2</type>
359 |                             <snmp_community/>
360 |                             <multiplier>0</multiplier>
361 |                             <snmp_oid/>
362 |                             <key>hw.raid.bbu[{#ADAPTER_ID},&quot;bbu_state&quot;]</key>
363 |                             <delay>0</delay>
364 |                             <history>7</history>
365 |                             <trends>365</trends>
366 |                             <status>0</status>
367 |                             <value_type>3</value_type>
368 |                             <allowed_hosts/>
369 |                             <units/>
370 |                             <delta>0</delta>
371 |                             <snmpv3_contextname/>
372 |                             <snmpv3_securityname/>
373 |                             <snmpv3_securitylevel>0</snmpv3_securitylevel>
374 |                             <snmpv3_authprotocol>0</snmpv3_authprotocol>
375 |                             <snmpv3_authpassphrase/>
376 |                             <snmpv3_privprotocol>0</snmpv3_privprotocol>
377 |                             <snmpv3_privpassphrase/>
378 |                             <formula>1</formula>
379 |                             <delay_flex/>
380 |                             <params/>
381 |                             <ipmi_sensor/>
382 |                             <data_type>0</data_type>
383 |                             <authtype>0</authtype>
384 |                             <username/>
385 |                             <password/>
386 |                             <publickey/>
387 |                             <privatekey/>
388 |                             <port/>
389 |                             <description/>
390 |                             <inventory_link>0</inventory_link>
391 |                             <applications>
392 |                                 <application>
393 |                                     <name>LSI RAID BBU</name>
394 |                                 </application>
395 |                             </applications>
396 |                             <valuemap>
397 |                                 <name>LSI RAID BBU &amp; LD Status</name>
398 |                             </valuemap>
399 |                             <logtimefmt/>
400 |                         </item_prototype>
401 |                     </item_prototypes>
402 |                     <trigger_prototypes>
403 |                         <trigger_prototype>
404 |                             <expression>{Template LSI RAID:hw.raid.bbu[{#ADAPTER_ID},&quot;bbu_state&quot;].last()}=1</expression>
405 |                             <name>BBU is not in optimal state on adapter:{#ADAPTER_ID}</name>
406 |                             <url/>
407 |                             <status>0</status>
408 |                             <priority>4</priority>
409 |                             <description>Backup Battery Unit on RAID adapter is not in operational state. RAID volumes performance can be degraded</description>
410 |                             <type>0</type>
411 |                         </trigger_prototype>
412 |                         <trigger_prototype>
413 |                             <expression>{Template LSI RAID:hw.raid.bbu[{#ADAPTER_ID},&quot;state_of_charge&quot;].avg(#3)}&lt;55</expression>
414 |                             <name>BBU on adapter:{#ADAPTER_ID} charge capacity degraded</name>
415 |                             <url/>
416 |                             <status>0</status>
417 |                             <priority>2</priority>
418 |                             <description/>
419 |                             <type>0</type>
420 |                         </trigger_prototype>
421 |                         <trigger_prototype>
422 |                             <expression>{Template LSI RAID:hw.raid.bbu[{#ADAPTER_ID},&quot;bbu_state&quot;].nodata(720)}=1</expression>
423 |                             <name>RAID info is outdated on {HOST.NAME}</name>
424 |                             <url/>
425 |                             <status>0</status>
426 |                             <priority>5</priority>
427 |                             <description>RAID INFO not updated more than 10 minutes. Check task scheduler on host and connectivity</description>
428 |                             <type>0</type>
429 |                         </trigger_prototype>
430 |                     </trigger_prototypes>
431 |                     <graph_prototypes/>
432 |                     <host_prototypes/>
433 |                 </discovery_rule>
434 |                 <discovery_rule>
435 |                     <name>RAID discovery pdisks</name>
436 |                     <type>2</type>
437 |                     <snmp_community/>
438 |                     <snmp_oid/>
439 |                     <key>hw.raid.discovery.pdisks</key>
440 |                     <delay>0</delay>
441 |                     <status>0</status>
442 |                     <allowed_hosts/>
443 |                     <snmpv3_contextname/>
444 |                     <snmpv3_securityname/>
445 |                     <snmpv3_securitylevel>0</snmpv3_securitylevel>
446 |                     <snmpv3_authprotocol>0</snmpv3_authprotocol>
447 |                     <snmpv3_authpassphrase/>
448 |                     <snmpv3_privprotocol>0</snmpv3_privprotocol>
449 |                     <snmpv3_privpassphrase/>
450 |                     <delay_flex/>
451 |                     <params/>
452 |                     <ipmi_sensor/>
453 |                     <authtype>0</authtype>
454 |                     <username/>
455 |                     <password/>
456 |                     <publickey/>
457 |                     <privatekey/>
458 |                     <port/>
459 |                     <filter>:</filter>
460 |                     <lifetime>30</lifetime>
461 |                     <description/>
462 |                     <item_prototypes>
463 |                         <item_prototype>
464 |                             <name>Disk Media errors Adapter:{#ADAPTER_ID},ENC:{#ENCLOSURE_ID},Disk:{#PDRIVE_ID}</name>
465 |                             <type>2</type>
466 |                             <snmp_community/>
467 |                             <multiplier>0</multiplier>
468 |                             <snmp_oid/>
469 |                             <key>hw.raid.physical_disk[{#ADAPTER_ID},{#ENCLOSURE_ID},{#PDRIVE_ID},&quot;media_errors&quot;]</key>
470 |                             <delay>0</delay>
471 |                             <history>7</history>
472 |                             <trends>365</trends>
473 |                             <status>0</status>
474 |                             <value_type>3</value_type>
475 |                             <allowed_hosts/>
476 |                             <units/>
477 |                             <delta>0</delta>
478 |                             <snmpv3_contextname/>
479 |                             <snmpv3_securityname/>
480 |                             <snmpv3_securitylevel>0</snmpv3_securitylevel>
481 |                             <snmpv3_authprotocol>0</snmpv3_authprotocol>
482 |                             <snmpv3_authpassphrase/>
483 |                             <snmpv3_privprotocol>0</snmpv3_privprotocol>
484 |                             <snmpv3_privpassphrase/>
485 |                             <formula>1</formula>
486 |                             <delay_flex/>
487 |                             <params/>
488 |                             <ipmi_sensor/>
489 |                             <data_type>0</data_type>
490 |                             <authtype>0</authtype>
491 |                             <username/>
492 |                             <password/>
493 |                             <publickey/>
494 |                             <privatekey/>
495 |                             <port/>
496 |                             <description/>
497 |                             <inventory_link>0</inventory_link>
498 |                             <applications>
499 |                                 <application>
500 |                                     <name>LSI RAID Physical Volume</name>
501 |                                 </application>
502 |                             </applications>
503 |                             <valuemap/>
504 |                             <logtimefmt/>
505 |                         </item_prototype>
506 |                         <item_prototype>
507 |                             <name>Disk model Adapter:{#ADAPTER_ID},ENC:{#ENCLOSURE_ID},Disk:{#PDRIVE_ID}</name>
508 |                             <type>0</type>
509 |                             <snmp_community/>
510 |                             <multiplier>0</multiplier>
511 |                             <snmp_oid/>
512 |                             <key>hw.raid.physical_disk[{#ADAPTER_ID},{#ENCLOSURE_ID},{#PDRIVE_ID},&quot;inquiry_data&quot;]</key>
513 |                             <delay>86400</delay>
514 |                             <history>7</history>
515 |                             <trends>365</trends>
516 |                             <status>0</status>
517 |                             <value_type>4</value_type>
518 |                             <allowed_hosts/>
519 |                             <units/>
520 |                             <delta>0</delta>
521 |                             <snmpv3_contextname/>
522 |                             <snmpv3_securityname/>
523 |                             <snmpv3_securitylevel>0</snmpv3_securitylevel>
524 |                             <snmpv3_authprotocol>0</snmpv3_authprotocol>
525 |                             <snmpv3_authpassphrase/>
526 |                             <snmpv3_privprotocol>0</snmpv3_privprotocol>
527 |                             <snmpv3_privpassphrase/>
528 |                             <formula>1</formula>
529 |                             <delay_flex/>
530 |                             <params/>
531 |                             <ipmi_sensor/>
532 |                             <data_type>0</data_type>
533 |                             <authtype>0</authtype>
534 |                             <username/>
535 |                             <password/>
536 |                             <publickey/>
537 |                             <privatekey/>
538 |                             <port/>
539 |                             <description/>
540 |                             <inventory_link>0</inventory_link>
541 |                             <applications>
542 |                                 <application>
543 |                                     <name>LSI RAID Physical Volume</name>
544 |                                 </application>
545 |                             </applications>
546 |                             <valuemap/>
547 |                             <logtimefmt/>
548 |                         </item_prototype>
549 |                         <item_prototype>
550 |                             <name>Disk predictive errors Adapter:{#ADAPTER_ID},ENC:{#ENCLOSURE_ID},Disk:{#PDRIVE_ID}</name>
551 |                             <type>2</type>
552 |                             <snmp_community/>
553 |                             <multiplier>0</multiplier>
554 |                             <snmp_oid/>
555 |                             <key>hw.raid.physical_disk[{#ADAPTER_ID},{#ENCLOSURE_ID},{#PDRIVE_ID},&quot;predictive_errors&quot;]</key>
556 |                             <delay>0</delay>
557 |                             <history>7</history>
558 |                             <trends>365</trends>
559 |                             <status>0</status>
560 |                             <value_type>3</value_type>
561 |                             <allowed_hosts/>
562 |                             <units/>
563 |                             <delta>0</delta>
564 |                             <snmpv3_contextname/>
565 |                             <snmpv3_securityname/>
566 |                             <snmpv3_securitylevel>0</snmpv3_securitylevel>
567 |                             <snmpv3_authprotocol>0</snmpv3_authprotocol>
568 |                             <snmpv3_authpassphrase/>
569 |                             <snmpv3_privprotocol>0</snmpv3_privprotocol>
570 |                             <snmpv3_privpassphrase/>
571 |                             <formula>1</formula>
572 |                             <delay_flex/>
573 |                             <params/>
574 |                             <ipmi_sensor/>
575 |                             <data_type>0</data_type>
576 |                             <authtype>0</authtype>
577 |                             <username/>
578 |                             <password/>
579 |                             <publickey/>
580 |                             <privatekey/>
581 |                             <port/>
582 |                             <description/>
583 |                             <inventory_link>0</inventory_link>
584 |                             <applications>
585 |                                 <application>
586 |                                     <name>LSI RAID Physical Volume</name>
587 |                                 </application>
588 |                             </applications>
589 |                             <valuemap/>
590 |                             <logtimefmt/>
591 |                         </item_prototype>
592 |                         <item_prototype>
593 |                             <name>Disk size Adapter:{#ADAPTER_ID},ENC:{#ENCLOSURE_ID},Disk:{#PDRIVE_ID}</name>
594 |                             <type>0</type>
595 |                             <snmp_community/>
596 |                             <multiplier>0</multiplier>
597 |                             <snmp_oid/>
598 |                             <key>hw.raid.physical_disk[{#ADAPTER_ID},{#ENCLOSURE_ID},{#PDRIVE_ID},&quot;raw_size&quot;]</key>
599 |                             <delay>86400</delay>
600 |                             <history>7</history>
601 |                             <trends>365</trends>
602 |                             <status>0</status>
603 |                             <value_type>1</value_type>
604 |                             <allowed_hosts/>
605 |                             <units/>
606 |                             <delta>0</delta>
607 |                             <snmpv3_contextname/>
608 |                             <snmpv3_securityname/>
609 |                             <snmpv3_securitylevel>0</snmpv3_securitylevel>
610 |                             <snmpv3_authprotocol>0</snmpv3_authprotocol>
611 |                             <snmpv3_authpassphrase/>
612 |                             <snmpv3_privprotocol>0</snmpv3_privprotocol>
613 |                             <snmpv3_privpassphrase/>
614 |                             <formula>1</formula>
615 |                             <delay_flex/>
616 |                             <params/>
617 |                             <ipmi_sensor/>
618 |                             <data_type>0</data_type>
619 |                             <authtype>0</authtype>
620 |                             <username/>
621 |                             <password/>
622 |                             <publickey/>
623 |                             <privatekey/>
624 |                             <port/>
625 |                             <description/>
626 |                             <inventory_link>0</inventory_link>
627 |                             <applications>
628 |                                 <application>
629 |                                     <name>LSI RAID Physical Volume</name>
630 |                                 </application>
631 |                             </applications>
632 |                             <valuemap/>
633 |                             <logtimefmt/>
634 |                         </item_prototype>
635 |                         <item_prototype>
636 |                             <name>Disk state Adapter:{#ADAPTER_ID},ENC:{#ENCLOSURE_ID},Disk:{#PDRIVE_ID}</name>
637 |                             <type>2</type>
638 |                             <snmp_community/>
639 |                             <multiplier>0</multiplier>
640 |                             <snmp_oid/>
641 |                             <key>hw.raid.physical_disk[{#ADAPTER_ID},{#ENCLOSURE_ID},{#PDRIVE_ID},&quot;firmware_state&quot;]</key>
642 |                             <delay>0</delay>
643 |                             <history>7</history>
644 |                             <trends>365</trends>
645 |                             <status>0</status>
646 |                             <value_type>3</value_type>
647 |                             <allowed_hosts/>
648 |                             <units/>
649 |                             <delta>0</delta>
650 |                             <snmpv3_contextname/>
651 |                             <snmpv3_securityname/>
652 |                             <snmpv3_securitylevel>0</snmpv3_securitylevel>
653 |                             <snmpv3_authprotocol>0</snmpv3_authprotocol>
654 |                             <snmpv3_authpassphrase/>
655 |                             <snmpv3_privprotocol>0</snmpv3_privprotocol>
656 |                             <snmpv3_privpassphrase/>
657 |                             <formula>1</formula>
658 |                             <delay_flex/>
659 |                             <params/>
660 |                             <ipmi_sensor/>
661 |                             <data_type>0</data_type>
662 |                             <authtype>0</authtype>
663 |                             <username/>
664 |                             <password/>
665 |                             <publickey/>
666 |                             <privatekey/>
667 |                             <port/>
668 |                             <description/>
669 |                             <inventory_link>0</inventory_link>
670 |                             <applications>
671 |                                 <application>
672 |                                     <name>LSI RAID Physical Volume</name>
673 |                                 </application>
674 |                             </applications>
675 |                             <valuemap>
676 |                                 <name>LSI RAID PhysDrv Status</name>
677 |                             </valuemap>
678 |                             <logtimefmt/>
679 |                         </item_prototype>
680 |                     </item_prototypes>
681 |                     <trigger_prototypes>
682 |                         <trigger_prototype>
683 |                             <expression>{Template LSI RAID:hw.raid.physical_disk[{#ADAPTER_ID},{#ENCLOSURE_ID},{#PDRIVE_ID},&quot;media_errors&quot;].last(0)}#0</expression>
684 |                             <name>Disk have media errors Adapter:{#ADAPTER_ID},ENC:{#ENCLOSURE_ID},Disk:{#PDRIVE_ID}</name>
685 |                             <url/>
686 |                             <status>0</status>
687 |                             <priority>2</priority>
688 |                             <description/>
689 |                             <type>0</type>
690 |                         </trigger_prototype>
691 |                         <trigger_prototype>
692 |                             <expression>{Template LSI RAID:hw.raid.physical_disk[{#ADAPTER_ID},{#ENCLOSURE_ID},{#PDRIVE_ID},&quot;predictive_errors&quot;].last(0)}#0</expression>
693 |                             <name>Disk have predictive errors Adapter:{#ADAPTER_ID},ENC:{#ENCLOSURE_ID},Disk:{#PDRIVE_ID}</name>
694 |                             <url/>
695 |                             <status>0</status>
696 |                             <priority>2</priority>
697 |                             <description/>
698 |                             <type>0</type>
699 |                         </trigger_prototype>
700 |                         <trigger_prototype>
701 |                             <expression>{Template LSI RAID:hw.raid.physical_disk[{#ADAPTER_ID},{#ENCLOSURE_ID},{#PDRIVE_ID},&quot;firmware_state&quot;].last()}=1</expression>
702 |                             <name>Disk state Adapter:{#ADAPTER_ID},ENC:{#ENCLOSURE_ID},Disk:{#PDRIVE_ID} is not Optimal</name>
703 |                             <url/>
704 |                             <status>0</status>
705 |                             <priority>4</priority>
706 |                             <description/>
707 |                             <type>0</type>
708 |                         </trigger_prototype>
709 |                         <trigger_prototype>
710 |                             <expression>{Template LSI RAID:hw.raid.physical_disk[{#ADAPTER_ID},{#ENCLOSURE_ID},{#PDRIVE_ID},&quot;firmware_state&quot;].last()}=2</expression>
711 |                             <name>Disk state Adapter:{#ADAPTER_ID},ENC:{#ENCLOSURE_ID},Disk:{#PDRIVE_ID} is Rebuild</name>
712 |                             <url/>
713 |                             <status>0</status>
714 |                             <priority>2</priority>
715 |                             <description/>
716 |                             <type>0</type>
717 |                         </trigger_prototype>
718 |                     </trigger_prototypes>
719 |                     <graph_prototypes/>
720 |                     <host_prototypes/>
721 |                 </discovery_rule>
722 |                 <discovery_rule>
723 |                     <name>RAID discovery vdisks</name>
724 |                     <type>2</type>
725 |                     <snmp_community/>
726 |                     <snmp_oid/>
727 |                     <key>hw.raid.discovery.vdisks</key>
728 |                     <delay>0</delay>
729 |                     <status>0</status>
730 |                     <allowed_hosts/>
731 |                     <snmpv3_contextname/>
732 |                     <snmpv3_securityname/>
733 |                     <snmpv3_securitylevel>0</snmpv3_securitylevel>
734 |                     <snmpv3_authprotocol>0</snmpv3_authprotocol>
735 |                     <snmpv3_authpassphrase/>
736 |                     <snmpv3_privprotocol>0</snmpv3_privprotocol>
737 |                     <snmpv3_privpassphrase/>
738 |                     <delay_flex/>
739 |                     <params/>
740 |                     <ipmi_sensor/>
741 |                     <authtype>0</authtype>
742 |                     <username/>
743 |                     <password/>
744 |                     <publickey/>
745 |                     <privatekey/>
746 |                     <port/>
747 |                     <filter>:</filter>
748 |                     <lifetime>30</lifetime>
749 |                     <description/>
750 |                     <item_prototypes>
751 |                         <item_prototype>
752 |                             <name>RAID Volume size Adapter:{#ADAPTER_ID},ID:{#VDRIVE_ID}</name>
753 |                             <type>0</type>
754 |                             <snmp_community/>
755 |                             <multiplier>0</multiplier>
756 |                             <snmp_oid/>
757 |                             <key>hw.raid.logical_disk[{#ADAPTER_ID},{#VDRIVE_ID},&quot;vd_size&quot;]</key>
758 |                             <delay>86400</delay>
759 |                             <history>7</history>
760 |                             <trends>365</trends>
761 |                             <status>0</status>
762 |                             <value_type>4</value_type>
763 |                             <allowed_hosts/>
764 |                             <units/>
765 |                             <delta>0</delta>
766 |                             <snmpv3_contextname/>
767 |                             <snmpv3_securityname/>
768 |                             <snmpv3_securitylevel>0</snmpv3_securitylevel>
769 |                             <snmpv3_authprotocol>0</snmpv3_authprotocol>
770 |                             <snmpv3_authpassphrase/>
771 |                             <snmpv3_privprotocol>0</snmpv3_privprotocol>
772 |                             <snmpv3_privpassphrase/>
773 |                             <formula>1</formula>
774 |                             <delay_flex/>
775 |                             <params/>
776 |                             <ipmi_sensor/>
777 |                             <data_type>0</data_type>
778 |                             <authtype>0</authtype>
779 |                             <username/>
780 |                             <password/>
781 |                             <publickey/>
782 |                             <privatekey/>
783 |                             <port/>
784 |                             <description/>
785 |                             <inventory_link>0</inventory_link>
786 |                             <applications>
787 |                                 <application>
788 |                                     <name>LSI RAID Logical Volume</name>
789 |                                 </application>
790 |                             </applications>
791 |                             <valuemap/>
792 |                             <logtimefmt/>
793 |                         </item_prototype>
794 |                         <item_prototype>
795 |                             <name>RAID Volume state Adapter:{#ADAPTER_ID},ID:{#VDRIVE_ID}</name>
796 |                             <type>2</type>
797 |                             <snmp_community/>
798 |                             <multiplier>0</multiplier>
799 |                             <snmp_oid/>
800 |                             <key>hw.raid.logical_disk[{#ADAPTER_ID},{#VDRIVE_ID},&quot;vd_state&quot;]</key>
801 |                             <delay>0</delay>
802 |                             <history>7</history>
803 |                             <trends>365</trends>
804 |                             <status>0</status>
805 |                             <value_type>3</value_type>
806 |                             <allowed_hosts/>
807 |                             <units/>
808 |                             <delta>0</delta>
809 |                             <snmpv3_contextname/>
810 |                             <snmpv3_securityname/>
811 |                             <snmpv3_securitylevel>0</snmpv3_securitylevel>
812 |                             <snmpv3_authprotocol>0</snmpv3_authprotocol>
813 |                             <snmpv3_authpassphrase/>
814 |                             <snmpv3_privprotocol>0</snmpv3_privprotocol>
815 |                             <snmpv3_privpassphrase/>
816 |                             <formula>1</formula>
817 |                             <delay_flex/>
818 |                             <params/>
819 |                             <ipmi_sensor/>
820 |                             <data_type>0</data_type>
821 |                             <authtype>0</authtype>
822 |                             <username/>
823 |                             <password/>
824 |                             <publickey/>
825 |                             <privatekey/>
826 |                             <port/>
827 |                             <description/>
828 |                             <inventory_link>0</inventory_link>
829 |                             <applications>
830 |                                 <application>
831 |                                     <name>LSI RAID Logical Volume</name>
832 |                                 </application>
833 |                             </applications>
834 |                             <valuemap>
835 |                                 <name>LSI RAID BBU &amp; LD Status</name>
836 |                             </valuemap>
837 |                             <logtimefmt/>
838 |                         </item_prototype>
839 |                     </item_prototypes>
840 |                     <trigger_prototypes>
841 |                         <trigger_prototype>
842 |                             <expression>{Template LSI RAID:hw.raid.logical_disk[{#ADAPTER_ID},{#VDRIVE_ID},&quot;vd_state&quot;].last()}=1</expression>
843 |                             <name>RAID Volume Adapter:{#ADAPTER_ID},ID:{#VDRIVE_ID} state is not Optimal</name>
844 |                             <url/>
845 |                             <status>0</status>
846 |                             <priority>4</priority>
847 |                             <description/>
848 |                             <type>0</type>
849 |                         </trigger_prototype>
850 |                     </trigger_prototypes>
851 |                     <graph_prototypes/>
852 |                     <host_prototypes/>
853 |                 </discovery_rule>
854 |             </discovery_rules>
855 |             <macros/>
856 |             <templates/>
857 |             <screens/>
858 |         </template>
859 |     </templates>
860 | </zabbix_export>
861 | 


--------------------------------------------------------------------------------