Mini Shell
#!/opt/imh-python/bin/python3
# $Id: megaclisas-status,v 1.68 2016/10/21 14:38:56 root Exp root $
#
# Written by Adam Cecile <gandalf@NOSPAM.le-vert.net>
# Modified by Vincent S. Cojot <vincent@NOSPAM.cojot.name>
#
import os
import re
import sys
if sys.platform == 'win32':
import ctypes
def_megaclipath = "/opt/MegaRAID/MegaCli/MegaCli64"
# Non-Nagios Mode defaults
nagiosmode = False
nagiosoutput = ''
nagiosgoodarray = 0
nagiosbadarray = 0
nagiosgooddisk = 0
nagiosbaddisk = 0
# Sane defaults
printarray = True
printcontroller = True
debugmode = False
notempmode = False
totaldrivenumber = 0
# Hardcode a max of 16 HBA and 128 LDs for now. LDTable must be initialized to accept populating list of LD's into each ctlr's list.
MaxNumHBA = 64
MaxNumLD = 128
LDTable = [[] * MaxNumHBA for i in range(MaxNumLD)]
NestedLDTable = [[False for i in range(MaxNumHBA)] for j in range(MaxNumLD)]
# Outputs is a 'dict' of all MegaCLI outputs so we can re-use them during loops..
Outputs = {}
# Startup
def print_usage():
print('Usage: megaraid-status [--nagios|--debug|--notemp]')
# We need root access to query
if __name__ == '__main__':
try:
root_or_admin = os.geteuid() == 0
except AttributeError:
root_or_admin = ctypes.windll.shell32.IsUserAnAdmin() != 0
if not root_or_admin:
print('# This script requires Administrator privileges')
sys.exit(5)
# Check command line arguments to enable nagios or not
if len(sys.argv) > 2:
print_usage()
sys.exit(1)
if len(sys.argv) > 1:
if sys.argv[1] == '--nagios':
nagiosmode = True
elif sys.argv[1] == '--debug':
debugmode = True
elif sys.argv[1] == '--notemp':
notempmode = True
else:
print_usage()
sys.exit(1)
# Functions
def dbgprint(msg):
if debugmode:
sys.stderr.write(str('# DEBUG : ' + msg + '\n'))
def is_exe(fpath):
return os.path.isfile(fpath) and os.access(fpath, os.X_OK)
def which(program):
import os
fpath, fname = os.path.split(program)
if fpath:
if is_exe(program):
return program
else:
# Add some defaults
os.environ["PATH"] += os.pathsep + '/opt/MegaRAID/MegaCli'
os.environ["PATH"] += os.pathsep + '/ms/dist/hwmgmt/bin'
os.environ["PATH"] += os.pathsep + os.path.dirname(
os.path.realpath(sys.argv[0])
)
for path in os.environ["PATH"].split(os.pathsep):
dbgprint('Looking in PATH ' + str(path))
path = path.strip('"')
exe_file = os.path.join(path, program)
if is_exe(exe_file):
dbgprint('Found "' + program + '" at ' + exe_file)
return exe_file
return None
# Find MegaCli
for megabin in "MegaCli64", "MegaCli", "megacli", "MegaCli.exe":
dbgprint('Looking for ' + str(megabin) + ' in PATH next..')
megaclipath = which(megabin)
if megaclipath != None:
dbgprint('Will use MegaCLI from here: ' + str(megaclipath))
break
# Check binary exists (and +x), if not print an error message
if megaclipath != None:
if os.path.exists(megaclipath) and os.access(megaclipath, os.X_OK):
pass
else:
if nagiosmode:
print('UNKNOWN - Cannot find ' + megaclipath)
else:
print(
'Cannot find '
+ megaclipath
+ 'in your PATH. Please install it.'
)
sys.exit(3)
else:
print(
'Cannot find "MegaCli64","MegaCli" or "megacli" or "MegaCli.exe" in your PATH. Please install it.'
)
sys.exit(3)
#### pdb.set_trace()
def returnWdthFromArrayCol(glarray, idx):
maxwdth = 0
for glrow in glarray:
if len(glrow[idx]) > maxwdth:
maxwdth = len(glrow[idx])
return maxwdth
# Get command output
def getOutput(cmd):
lines = []
if cmd in Outputs:
dbgprint("Got Cached value: " + str(cmd))
lines = Outputs[cmd]
else:
dbgprint("Not a Cached value: " + str(cmd))
output = os.popen(cmd)
for line in output:
if not re.match(r'^$', line.strip()):
lines.append(line.strip())
Outputs[cmd] = lines
return lines
def returnControllerNumber(output):
for line in output:
if re.match(r'^Controller Count.*$', line.strip()):
return int(line.split(':')[1].strip().strip('.'))
def returnTotalDriveNumber(output):
for line in output:
if re.match(r'Number of Physical Drives on Adapter.*$', line.strip()):
return int(line.split(':')[1].strip())
def returnRebuildProgress(output):
percent = 0
tmpstr = ''
for line in output:
if re.match(
r'^Rebuild Progress on Device at Enclosure.*, Slot .* Completed ',
line.strip(),
):
tmpstr = line.split('Completed')[1].strip()
percent = int(tmpstr.split('%')[0].strip())
return percent
def returnConfDriveNumber(output):
# Count the configured drives
confdrives = 0
for line in output:
if re.match(r'.*Number of PDs:.*$', line.strip()):
confdrives += int(line.split(':')[2].strip())
return int(confdrives)
def returnUnConfDriveNumber(output):
# Count the configured drives
confdrives = 0
for line in output:
if re.match(r'^Firmware state: Unconfigured.*$', line.strip()):
confdrives += 1
return int(confdrives)
def returnControllerModel(output):
for line in output:
if re.match(r'^Product Name.*$', line.strip()):
return line.split(':')[1].strip()
def returnMemorySize(output):
for line in output:
if re.match(r'^Memory Size.*$', line.strip()):
return line.split(':')[1].strip()
def returnFirmwareVersion(output):
for line in output:
if re.match(r'^FW Package Build.*$', line.strip()):
return line.split(':')[1].strip()
def returnROCTemp(output):
ROCtemp = ''
tmpstr = ''
if notempmode:
return 'N/A'
else:
for line in output:
if re.match(r'^ROC temperature :.*$', line.strip()):
tmpstr = line.split(':')[1].strip()
ROCtemp = re.sub(' +.*$', '', tmpstr)
if ROCtemp != '':
return str(str(ROCtemp) + 'C')
else:
return 'N/A'
def returnBBUPresence(output):
BBU = ''
tmpstr = ''
for line in output:
if re.match(r'^BBU +:.*$', line.strip()):
tmpstr = line.split(':')[1].strip()
BBU = re.sub(' +.*$', '', tmpstr)
break
if BBU != '':
return str(BBU)
else:
return 'N/A'
def returnBBUStatus(output):
BBUStatus = ''
tmpstr = ''
for line in output:
if re.match(r'^ *Battery Replacement required +:.*$', line.strip()):
tmpstr = line.split(':')[1].strip()
BBUStatus = re.sub(' +.*$', '', tmpstr)
break
if BBUStatus == 'Yes':
return 'REPL'
else:
return 'Good'
def returnArrayNumber(output):
i = 0
for line in output:
if re.match(r'^(CacheCade )?Virtual Drive:.*$', line.strip()):
i += 1
return i
def returnHBAPCIInfo(output):
busprefix = '0000'
busid = ''
devid = ''
functionid = ''
pcipath = ''
for line in output:
if re.match(r'^Bus Number.*:.*$', line.strip()):
busid = str(line.strip().split(':')[1].strip()).zfill(2)
if re.match(r'^Device Number.*:.*$', line.strip()):
devid = str(line.strip().split(':')[1].strip()).zfill(2)
if re.match(r'^Function Number.*:.*$', line.strip()):
functionid = str(line.strip().split(':')[1].strip()).zfill(1)
if busid:
pcipath = str(busprefix + ':' + busid + ':' + devid + '.' + functionid)
dbgprint("Array PCI path : " + pcipath)
return str(pcipath)
else:
return None
def returnHBAInfo(table, output, controllerid):
controllermodel = 'Unknown'
controllerram = 'Unknown'
controllerrev = 'Unknown'
controllertemp = ''
controllermodel = returnControllerModel(output)
controllerram = returnMemorySize(output)
controllerrev = returnFirmwareVersion(output)
controllertemp = returnROCTemp(output)
controllerbbu = returnBBUPresence(output)
if controllerbbu == 'Present':
cmd = '%s -AdpBbuCmd -GetBbuStatus -a%d -NoLog' % (
megaclipath,
controllerid,
)
output = getOutput(cmd)
controllerbbu = returnBBUStatus(output)
if controllermodel != 'Unknown':
table.append(
[
'c' + str(controllerid),
controllermodel,
controllerram,
str(controllertemp),
str(controllerbbu),
str('FW: ' + controllerrev),
]
)
def returnArrayInfo(output, controllerid, arrayid, arrayindex):
id = 'c' + str(controllerid) + 'u' + str(arrayid)
operationlinennumber = False
linenumber = 0
targetid = ''
raidtype = ''
raidlvl = ''
size = ''
state = 'N/A'
strpsz = ''
dskcache = 'N/A'
properties = ''
spandepth = 0
diskperspan = 0
cachecade_info = 'None'
for line in output:
if re.match(
r'^(CacheCade )?Virtual Drive:.*(Target Id: [0-9]+).*$',
line.strip(),
):
# Extract the SCSI Target ID
targetid = line.strip().split(':')[2].split(')')[0].strip()
elif re.match(r'^RAID Level.*?:.*$', line.strip()):
# Extract the primary raid type, decide on X0 RAID level later when we hit Span Depth
raidlvl = int(
line.strip().split(':')[1].split(',')[0].split('-')[1].strip()
)
elif re.match(r'^Size.*?:.*$', line.strip()):
# Size reported in MB
if re.match(r'^.*MB$', line.strip().split(':')[1]):
size = line.strip().split(':')[1].strip('MB').strip()
if float(size) > 1000:
size = str(int(round(float(size) / 1000))) + 'G'
else:
size = str(int(round(float(size)))) + 'M'
# Size reported in TB
elif re.match(r'^.*TB$', line.strip().split(':')[1]):
size = line.strip().split(':')[1].strip('TB').strip()
size = str(int(round(float(size) * 1000))) + 'G'
# Size reported in GB (default)
else:
size = line.strip().split(':')[1].strip('GB').strip()
size = str(int(round(float(size)))) + 'G'
elif re.match(r'^Span Depth.*?:.*$', line.strip()):
# If Span Depth is greater than 1 chances are we have a RAID 10, 50 or 60
spandepth = line.strip().split(':')[1].strip()
elif re.match(r'^State.*?:.*$', line.strip()):
state = line.strip().split(':')[1].strip()
elif re.match(r'^Strip Size.*?:.*$', line.strip()):
strpsz = line.strip().split(':')[1].strip()
elif re.match(r'^Number Of Drives per span.*:.*$', line.strip()):
diskperspan = int(line.strip().split(':')[1].strip())
elif re.match(r'^Current Cache Policy.*?:.*$', line.strip()):
props = line.strip().split(':')[1].strip()
if re.search('ReadAdaptive', props):
properties += 'ADRA'
if re.search('ReadAhead', props):
properties += 'RA'
if re.match('ReadAheadNone', props):
properties += 'NORA'
if re.search('WriteBack', props):
properties += ',WB'
if re.match('WriteThrough', props):
properties += ',WT'
elif re.match(r'^Disk Cache Policy.*?:.*$', line.strip()):
props = line.strip().split(':')[1].strip()
if re.search('Disabled', props):
dskcache = 'Disabled'
if re.search('Disk.s Default', props):
dskcache = 'Default'
if re.search('Enabled', props):
dskcache = 'Enabled'
elif re.match(r'^Ongoing Progresses.*?:.*$', line.strip()):
operationlinennumber = linenumber
elif re.match(r'Cache Cade Type\s*:.*$', line):
cachecade_info = "Type : " + line.strip().split(':')[1].strip()
elif re.match(r'^Target Id of the Associated LDs\s*:.*$', line):
associated = []
for array in line.split(':')[1].strip().split(','):
if array.isdigit():
associated.append('c%du%d' % (controllerid, int(array)))
if len(associated) >= 1:
cachecade_info = "Associated : %s" % (', '.join(associated))
linenumber += 1
# If there was an ongoing operation, find the relevant line in the previous output
if operationlinennumber:
inprogress = output[operationlinennumber + 1]
else:
inprogress = 'None'
# Compute the RAID level
NestedLDTable[int(controllerid)][int(arrayindex)] = False
if raidlvl == '':
raidtype = 'N/A'
else:
if int(spandepth) >= 2:
raidtype = str('RAID-' + str(raidlvl) + '0')
NestedLDTable[controllerid][int(arrayindex)] = True
else:
if raidlvl == 1:
if diskperspan > 2:
raidtype = 'RAID-10'
NestedLDTable[controllerid][int(arrayindex)] = True
else:
raidtype = str('RAID-' + str(raidlvl))
else:
raidtype = str('RAID-' + str(raidlvl))
dbgprint(
'RAID Level: '
+ str(raidlvl)
+ ' Span Depth: '
+ str(spandepth)
+ ' Disk Per Span: '
+ str(diskperspan)
+ ' Raid Type: '
+ str(raidtype)
)
return [
id,
raidtype,
size,
strpsz,
properties,
dskcache,
state,
targetid,
cachecade_info,
inprogress,
]
def returnDiskInfo(output, controllerid):
arrayid = False
arrayindex = -1
sarrayid = 'Unknown'
diskid = False
oldenclid = False
enclid = False
spanid = False
slotid = False
lsidid = 'Unknown'
table = []
fstate = 'Offline'
substate = 'Unknown'
model = 'Unknown'
speed = 'Unknown'
dsize = 'Unknown'
temp = 'Unk0C'
percent = 0
for line in output:
if re.match(r'^Span: [0-9]+ - Number of PDs:', line.strip()):
spanid = line.split(':')[1].strip()
spanid = re.sub(' - Number of PDs.*', '', spanid)
elif re.match(r'Enclosure Device ID: .*$', line.strip()):
# We match here early in the analysis so reset the vars if this is a new disk we're reading..
oldenclid = enclid
enclid = line.split(':')[1].strip()
if oldenclid != False:
fstate = 'Offline'
model = 'Unknown'
speed = 'Unknown'
temp = 'Unk0C'
slotid = False
lsidid = 'Unknown'
elif re.match(r'^Coerced Size: ', line.strip()):
dsize = line.split(':')[1].strip()
dsize = re.sub(r' \[.*\.*$', '', dsize)
dsize = re.sub('[0-9][0-9] GB', ' Gb', dsize)
elif re.match(
r'^(CacheCade )?Virtual (Disk|Drive): [0-9]+.*$', line.strip()
):
arrayindex += 1
arrayid = line.split('(')[0].split(':')[1].strip()
elif re.match(r'PD: [0-9]+ Information.*$', line.strip()):
diskid = line.split()[1].strip()
elif re.match(r'^Device Id: .*$', line.strip()):
lsidid = line.split(':')[1].strip()
elif re.match(r'Slot Number: .*$', line.strip()):
slotid = line.split(':')[1].strip()
elif re.match(r'Firmware state: .*$', line.strip()):
fstate = line.split(':')[1].strip()
subfstate = re.sub(r'\(.*', '', fstate)
dbgprint('Firmware State: ' + str(fstate) + ' ' + str(subfstate))
elif re.match(r'Inquiry Data: .*$', line.strip()):
model = line.split(':')[1].strip()
model = re.sub(' +', ' ', model)
# Sub code
manuf = re.sub(' .*', '', model)
dtype = re.sub(manuf + ' ', '', model)
dtype = re.sub(' .*', '', dtype)
hwserial = re.sub('.*' + dtype + ' *', '', model)
elif re.match(r'^Media Type: .*$', line.strip()):
mtype = line.split(':')[1].strip()
if mtype == 'Hard Disk Device':
mtype = 'HDD'
else:
if mtype == 'Solid State Device':
mtype = 'SSD'
else:
mtype = 'N/A'
elif re.match(r'Device Speed: .*$', line.strip()):
speed = line.split(':')[1].strip()
elif re.match(r'Drive Temperature :.*$', line.strip()):
if notempmode:
temp = 'N/A'
else:
# Drive temp is amongst the last few lines matched, decide here if we add information to the table..
temp = line.split(':')[1].strip()
temp = re.sub(r' \(.*\)', '', temp)
if model != 'Unknown':
dbgprint(
'Disk Info: '
+ str(arrayid)
+ ' '
+ str(diskid)
+ ' '
+ str(oldenclid)
)
if subfstate == 'Rebuild':
cmd = (
r'%s pdrbld -showprog -physdrv\[%s:%s\] -a%d -NoLog'
% (megaclipath, enclid, slotid, controllerid)
)
output = getOutput(cmd)
percent = returnRebuildProgress(output)
fstate = str('Rebuilding (%d%%)' % (percent))
if (NestedLDTable[controllerid][int(arrayindex)] == True) and (
spanid != False
):
sarrayid = str(arrayid) + "s" + spanid
else:
sarrayid = str(arrayid)
table.append(
[
sarrayid,
str(diskid),
mtype,
model,
dsize,
fstate,
speed,
temp,
enclid,
slotid,
lsidid,
]
)
return table
def returnUnconfDiskInfo(output, controllerid):
arrayid = False
diskid = False
olddiskid = False
enclid = False
slotid = False
lsidid = 'Unknown'
table = []
fstate = 'Offline'
substate = 'Unknown'
model = 'Unknown'
speed = 'Unknown'
mtype = 'Unknown'
dsize = 'Unknown'
temp = 'Unk0C'
for line in output:
if re.match(r'Enclosure Device ID: .*$', line.strip()):
# We match here early in the analysis so reset the vars if this is a new disk we're reading..
oldenclid = enclid
enclid = line.split(':')[1].strip()
if oldenclid != False:
arrayid = False
fstate = 'Offline'
model = 'Unknown'
speed = 'Unknown'
temp = 'Unk0C'
slotid = False
lsidid = 'Unknown'
elif re.match(r'^Coerced Size: ', line.strip()):
dsize = line.split(':')[1].strip()
dsize = re.sub(r' \[.*\.*$', '', dsize)
dsize = re.sub('[0-9][0-9] GB', ' Gb', dsize)
elif re.match(
r'^Drive.s position: DiskGroup: [0-9]+,.*$', line.strip()
):
arrayid = line.split(',')[1].split(':')[1].strip()
elif re.match(r'^Device Id: [0-9]+.*$', line.strip()):
diskid = line.split(':')[1].strip()
elif re.match(r'^Device Id: .*$', line.strip()):
lsidid = line.split(':')[1].strip()
elif re.match(r'Slot Number: .*$', line.strip()):
slotid = line.split(':')[1].strip()
elif re.match(r'Firmware state: .*$', line.strip()):
fstate = line.split(':')[1].strip()
subfstate = re.sub(r'\(.*', '', fstate)
dbgprint('Firmware State: ' + str(fstate) + ' ' + str(subfstate))
elif re.match(r'Inquiry Data: .*$', line.strip()):
model = line.split(':')[1].strip()
model = re.sub(' +', ' ', model)
manuf = re.sub(' .*', '', model)
dtype = re.sub(manuf + ' ', '', model)
dtype = re.sub(' .*', '', dtype)
hwserial = re.sub('.*' + dtype + ' *', '', model)
elif re.match(r'^Media Type: .*$', line.strip()):
mtype = line.split(':')[1].strip()
if mtype == 'Hard Disk Device':
mtype = 'HDD'
else:
if mtype == 'Solid State Device':
mtype = 'SSD'
else:
mtype = 'N/A'
elif re.match(r'Device Speed: .*$', line.strip()):
speed = line.split(':')[1].strip()
elif re.match(r'Drive Temperature :.*$', line.strip()):
temp = line.split(':')[1].strip()
temp = re.sub(r'\(.*\)', '', temp)
# Drive temp is amongst the last few lines matched, decide here if we add information to the table..
if arrayid == False:
if subfstate == 'Unconfigured':
dbgprint(
'Unconfigured Disk: Arrayid: '
+ str(arrayid)
+ ' DiskId: '
+ str(diskid)
+ ' '
+ str(olddiskid)
+ ' '
+ str(fstate)
)
elif subfstate == 'Online, Spun Up':
dbgprint(
'Online Disk: Arrayid: '
+ str(arrayid)
+ ' DiskId: '
+ str(diskid)
+ ' '
+ str(olddiskid)
+ ' '
+ str(fstate)
)
table.append(
[
mtype,
model,
dsize,
fstate,
speed,
temp,
enclid,
slotid,
lsidid,
]
)
return table
def returnForeignDisks(controllerid):
cmd = "%s -CfgForeign -Dsply -a%d" % (megaclipath, controllerid)
foreignout = getOutput(cmd)
foreigndisks = []
for line in foreignout:
result = re.search(r"Slot Number: (.*)", line)
if result:
matches = result.groups()
foreigndisks.append(matches[0])
return foreigndisks
cmd = '%s -adpCount -NoLog' % (megaclipath)
output = getOutput(cmd)
controllernumber = returnControllerNumber(output)
bad = False
# List available controller
if printcontroller:
if controllernumber:
if not nagiosmode:
print('-- Controller information --')
i = 0
controllerid = 0
mlen = 0
hbainfo = []
while controllerid < controllernumber:
cmd = '%s -AdpAllInfo -a%d -NoLog' % (megaclipath, controllerid)
output = getOutput(cmd)
returnHBAInfo(hbainfo, output, controllerid)
controllerid += 1
mlen = returnWdthFromArrayCol(hbainfo, 1)
controllerid = 0
for hba in hbainfo:
hbafmt = str(
'%-5s | %-' + str(mlen) + 's | %-6s | %-4s | %-6s | %-12s '
)
# Header
if i == 0:
if not nagiosmode:
print(
hbafmt
% (
"-- ID",
"H/W Model",
"RAM",
"Temp",
"BBU",
"Firmware",
)
)
if not nagiosmode:
print(hbafmt % (hba[0], hba[1], hba[2], hba[3], hba[4], hba[5]))
i += 1
if not nagiosmode:
print('')
else:
print("No MegaRAID or PERC adapter detected on your system!")
exit(1)
if printarray:
if not nagiosmode:
print('-- Array information --')
controllerid = 0
pcipath = ''
diskpath = ''
i = 0
j = 0
mlen = 0
rlen = 0
clen = 0
while controllerid < controllernumber:
arrayindex = 0
cmd = '%s -LDInfo -lall -a%d -NoLog' % (megaclipath, controllerid)
output = getOutput(cmd)
arraynumber = returnArrayNumber(output)
# We need to explore each HBA to look for gaps in LD's
ldid = 0
ldcount = 0
while ldcount < arraynumber:
cmd = '%s -LDInfo -l%d -a%d -NoLog' % (
megaclipath,
ldid,
controllerid,
)
output = getOutput(cmd)
for line in output:
if re.match(
r'^Adapter.*Virtual Drive .* Does not Exist', line.strip()
):
ldid += 1
elif re.match(r'^(CacheCade )?Virtual Drive:', line.strip()):
LDTable[controllerid].append(ldid)
# NestedLDTable[controllerid][int(arrayindex)] = False
ldcount += 1
ldid += 1
while arrayindex < arraynumber:
ldid = LDTable[controllerid][arrayindex]
cmd = '%s -LDInfo -l%d -a%d -NoLog' % (
megaclipath,
ldid,
controllerid,
)
output = getOutput(cmd)
arrayinfo = returnArrayInfo(output, controllerid, ldid, arrayindex)
if len(arrayinfo[1]) > rlen:
rlen = len(arrayinfo[1])
if len(arrayinfo[4]) > mlen:
mlen = len(arrayinfo[4])
if len(arrayinfo[8]) > clen:
clen = len(arrayinfo[8])
arrayindex += 1
controllerid += 1
controllerid = 0
while controllerid < controllernumber:
arrayindex = 0
cmd = '%s -AdpGetPciInfo -a%d -NoLog' % (megaclipath, controllerid)
output = getOutput(cmd)
pcipath = returnHBAPCIInfo(output)
cmd = '%s -LDInfo -lall -a%d -NoLog' % (megaclipath, controllerid)
output = getOutput(cmd)
arraynumber = returnArrayNumber(output)
while arrayindex < arraynumber:
ldid = LDTable[controllerid][arrayindex]
cmd = '%s -LDInfo -l%d -a%d -NoLog' % (
megaclipath,
ldid,
controllerid,
)
output = getOutput(cmd)
arrayinfo = returnArrayInfo(output, controllerid, ldid, arrayindex)
if pcipath:
diskprefix = str(
'/dev/disk/by-path/pci-' + pcipath + '-scsi-0:'
)
for j in range(8):
diskpath = (
diskprefix + str(j) + ':' + str(arrayinfo[7]) + ':0'
)
if os.path.exists(diskpath):
arrayinfo[7] = os.path.realpath(diskpath)
else:
arrayinfo[7] = 'N/A'
# Pad the string length, just to make sure it's aligned with the headers...
if rlen < len("Type"):
rlen = len("Type")
if mlen < len("Flags"):
mlen = len("Flags")
if clen < len("CacheCade"):
clen = len("CacheCade")
ldfmt = str(
'%-5s | %-'
+ str(rlen)
+ 's | %7s | %7s | %'
+ str(mlen)
+ 's | %8s | %8s | %8s | %-'
+ str(clen)
+ 's |%-12s '
)
# Header
if i == 0:
if not nagiosmode:
print(
ldfmt
% (
"-- ID",
"Type",
"Size",
"Strpsz",
"Flags",
"DskCache",
"Status",
"OS Path",
"CacheCade",
"InProgress",
)
)
if not nagiosmode:
print(
ldfmt
% (
arrayinfo[0],
arrayinfo[1],
arrayinfo[2],
arrayinfo[3],
arrayinfo[4],
arrayinfo[5],
arrayinfo[6],
arrayinfo[7],
arrayinfo[8],
arrayinfo[9],
)
)
dbgprint("Array state : " + arrayinfo[6])
if arrayinfo[6] not in ['Optimal', 'N/A']:
bad = True
nagiosbadarray = nagiosbadarray + 1
else:
nagiosgoodarray = nagiosgoodarray + 1
arrayindex += 1
i += 1
controllerid += 1
if not nagiosmode:
print('')
controllerid = 0
while controllerid < controllernumber:
cmd = '%s -PDGetNum -a%d -NoLog' % (megaclipath, controllerid)
output = getOutput(cmd)
totaldrivenumber += returnTotalDriveNumber(output)
controllerid += 1
if totaldrivenumber:
if not nagiosmode:
print('-- Disk information --')
i = 0
dlen = 0
mlen = 0
flen = 0
controllerid = 0
while controllerid < controllernumber:
arrayid = 0
cmd = '%s -LDInfo -lall -a%d -NoLog' % (megaclipath, controllerid)
output = getOutput(cmd)
arraynumber = returnArrayNumber(output)
#### BUG: -LdPdInfo shows all PD on the adapter, not just for said LD..
#### while arrayid <= arraynumber:
cmd = '%s -LdPdInfo -a%d -NoLog' % (megaclipath, controllerid)
output = getOutput(cmd)
arraydisk = returnDiskInfo(output, controllerid)
for array in arraydisk:
dbgprint(
'Disk c'
+ str(controllerid)
+ 'u'
+ array[0]
+ 'p'
+ array[1]
+ ' status : '
+ array[5]
)
if array[5] not in ['Online', 'Online, Spun Up']:
bad = True
nagiosbaddisk = nagiosbaddisk + 1
else:
nagiosgooddisk = nagiosgooddisk + 1
if returnWdthFromArrayCol(arraydisk, 0) > dlen:
dlen = returnWdthFromArrayCol(arraydisk, 0)
if returnWdthFromArrayCol(arraydisk, 3) > mlen:
mlen = returnWdthFromArrayCol(arraydisk, 3)
if returnWdthFromArrayCol(arraydisk, 5) > flen:
flen = returnWdthFromArrayCol(arraydisk, 5)
controllerid += 1
controllerid = 0
while controllerid < controllernumber:
arrayid = 0
cmd = '%s -LDInfo -lall -a%d -NoLog' % (megaclipath, controllerid)
output = getOutput(cmd)
arraynumber = returnArrayNumber(output)
#### BUG: -LdPdInfo shows all PD on the adapter, not just for said LD..
#### while arrayid <= arraynumber:
cmd = '%s -LdPdInfo -a%d -NoLog' % (megaclipath, controllerid)
output = getOutput(cmd)
arraydisk = returnDiskInfo(output, controllerid)
# Adjust print format with width computed above
drvfmt = (
"%-"
+ str(dlen + 5)
+ "s | %-4s | %-"
+ str(mlen)
+ "s | %-8s | %-"
+ str(flen)
+ "s | %-8s | %-4s | %-8s | %-8s"
)
for array in arraydisk:
# Header
if i == 0:
if not nagiosmode:
print(
drvfmt
% (
"-- ID",
"Type",
"Drive Model",
"Size",
"Status",
"Speed",
"Temp",
"Slot ID",
"LSI Device ID",
)
)
# Drive information
if not nagiosmode:
print(
drvfmt
% (
str(
'c'
+ str(controllerid)
+ 'u'
+ array[0]
+ 'p'
+ array[1]
), # c0p0
array[2], # HDD/SDD
array[3], # Model Information (Variable len)
array[4], # Size
array[5], # Status (Variable len)
array[6], # Speed
array[7], # Temp
str('[' + array[8] + ':' + array[9] + ']'), # Slot ID
array[10],
)
) # LSI ID
i = i + 1
controllerid += 1
if not nagiosmode:
print('')
controllerid = 0
totalconfdrivenumber = 0
totalunconfdrivenumber = 0
totaldrivenumber = 0
while controllerid < controllernumber:
cmd = '%s -LdPdInfo -a%d -NoLog' % (megaclipath, controllerid)
output = getOutput(cmd)
totalconfdrivenumber += returnConfDriveNumber(output)
cmd = '%s -PDGetNum -a%d -NoLog' % (megaclipath, controllerid)
output = getOutput(cmd)
totaldrivenumber += returnTotalDriveNumber(output)
cmd = '%s -PDList -a%d -NoLog' % (megaclipath, controllerid)
output = getOutput(cmd)
totalunconfdrivenumber += returnUnConfDriveNumber(output)
controllerid += 1
dbgprint('Total Drives in system : ' + str(totaldrivenumber))
dbgprint('Total Configured Drives : ' + str(totalconfdrivenumber))
dbgprint('Total Unconfigured Drives : ' + str(totalunconfdrivenumber))
if totalunconfdrivenumber:
if not nagiosmode:
print('-- Unconfigured Disk information --')
controllerid = 0
while controllerid < controllernumber:
foreigndisks = returnForeignDisks(controllerid)
arrayid = 0
cmd = '%s -LDInfo -lall -a%d -NoLog' % (megaclipath, controllerid)
output = getOutput(cmd)
arraynumber = returnArrayNumber(output)
#### BUG: -LdPdInfo shows all PD on the adapter, not just for given LD..
#### while arrayid <= arraynumber:
cmd = '%s -PDList -a%d -NoLog' % (megaclipath, controllerid)
output = getOutput(cmd)
arraydisk = returnUnconfDiskInfo(output, controllerid)
for array in arraydisk:
dbgprint('Disk c' + str(controllerid) + 'uXpY status : ' + array[3])
if array[3] not in [
'Online',
'Unconfigured(good), Spun Up',
'Unconfigured(good), Spun down',
'JBOD',
'Hotspare, Spun Up',
'Hotspare, Spun down',
]:
bad = True
nagiosbaddisk = nagiosbaddisk + 1
else:
nagiosgooddisk = nagiosgooddisk + 1
if array[7] in foreigndisks:
array[3] = array[3] + " (Foreign)"
mlen = returnWdthFromArrayCol(arraydisk, 1)
flen = returnWdthFromArrayCol(arraydisk, 3)
# Adjust print format with widths computed above
drvfmt = (
"%-7s | %-4s | %-"
+ str(mlen)
+ "s | %-8s | %-"
+ str(flen + 2)
+ "s | %-8s | %-4s | %-8s | %-8s"
)
i = 0
for array in arraydisk:
# Header
if i == 0:
if not nagiosmode:
print(
drvfmt
% (
"-- ID",
"Type",
"Drive Model",
"Size",
"Status",
"Speed",
"Temp",
"Slot ID",
"LSI Device ID",
)
)
# Drive information
if not nagiosmode:
print(
drvfmt
% (
str('c' + str(controllerid) + 'uXpY'), # cXpY
array[0], # HDD/SDD
array[1], # Model Information (Variable len)
array[2], # Size
array[3], # Status (Variable len)
array[4], # Speed
array[5], # Temp
str('[' + array[6] + ':' + array[7] + ']'), # Slot ID
array[8],
)
) # LSI ID
i = i + 1
controllerid += 1
if not nagiosmode:
print('')
if nagiosmode:
if bad:
print(
'RAID ERROR - Arrays: OK:'
+ str(nagiosgoodarray)
+ ' Bad:'
+ str(nagiosbadarray)
+ ' - Disks: OK:'
+ str(nagiosgooddisk)
+ ' Bad:'
+ str(nagiosbaddisk)
)
sys.exit(2)
else:
print(
'RAID OK - Arrays: OK:'
+ str(nagiosgoodarray)
+ ' Bad:'
+ str(nagiosbadarray)
+ ' - Disks: OK:'
+ str(nagiosgooddisk)
+ ' Bad:'
+ str(nagiosbaddisk)
)
else:
if bad:
print('\nThere is at least one disk/array in a NOT OPTIMAL state.')
sys.exit(1)
Zerion Mini Shell 1.0