ibm_checkvdiskhostmaps

#!/usr/bin/python2.7
#
# Description: Check vDisk - Hosts mappings
# Author:      Christophe Drevet-Droguet

import sys

# Parsing arguments
import argparse
parser = argparse.ArgumentParser(description='Check vDisk - Hosts mappings')
parser.add_argument('device', metavar='DEVICE',
               help='Hostname of the storage cluster')
parser.add_argument('--version', action='version', version='%(prog)s 0.4')
parser.add_argument('--host', default='.*',
               help='Regular expression to select hosts mappings (default: .*)')
actiongroup = parser.add_argument_group('Action')
actiongroup.add_argument('-m', '--missing', action='store_true',
               help='Check missing vDisks (default)')
actiongroup.add_argument('-d', '--vdisk', action='store_true',
               help='Check by vDisk')
actiongroup.add_argument('-s', '--scsi', action='store_true',
               help='Check by SCSI ID')
args = parser.parse_args()

print("Checking mappings on " + str(args.device))
if args.host != '.*':
    print("  with host patterns: " + str(args.host))
if not args.missing and not args.scsi and not args.vdisk:
    args.missing = True
if args.missing:
    print("  for missing vDisks")
if args.scsi:
    print("  by SCSI ID")
if args.vdisk:
    print("  by vDisk")

# Getting mappings
from subprocess import check_output
import re

output = check_output(["ssh", args.device, "lshostvdiskmap", "-nohdr", "-delim", ":"])
mappings = []
fields = ['host_id', 'host_name', 'scsi_id', 'vdisk_id', 'vdisk_name', 'vdisk_uid', 'io_group_id', 'io_group_name']
for line in output.split():
    mapping = dict(zip(fields, line.split(':')))
    if re.match(args.host + '$', mapping['host_name']):
        mappings.append(mapping)

# Store by SCSI and vDisk ID
byvdiskid = {}
byscsiid = {}
byhost = {}
for mapping in mappings:
    entries = []
    if mapping['vdisk_id'] in byvdiskid:
        entries = byvdiskid[mapping['vdisk_id']]
    entries.append(mapping)
    byvdiskid.update({mapping['vdisk_id']: entries})

    entries = []
    if mapping['scsi_id'] in byscsiid:
        entries = byscsiid[mapping['scsi_id']]
    entries.append(mapping)
    byscsiid.update({mapping['scsi_id']: entries})

    if mapping['host_name'] in byhost:
        entries = byhost[mapping['host_name']]
    else:
        entries = []
    entries.append(mapping['vdisk_id'])
    byhost.update({mapping['host_name']: entries})

# Detect missing devices
missing = []
for vdiskid in byvdiskid:
    vdisk = byvdiskid[vdiskid][0]['vdisk_name']
    for host in byhost.keys():
        if vdiskid not in byhost[host]:
            missing.append((host, vdiskid))

# Print missing devices
if args.missing and missing != []:
    print("Missing {} mappings on {}".format(len(missing), len(byscsiid)))
    sortmissing = sorted(missing)
    for entry in sortmissing:
        print('WARNING: vDisk {} not mapped to {}'.format(byvdiskid[entry[1]][0]['vdisk_name'], entry[0]))

# Detect and print conflicts
if args.scsi:
    scsiidconflicts = {}
    for scsiid, entries in byscsiid.iteritems():
        vdiskid = entries[0]['vdisk_id']
        for entry in entries:
            if entry['vdisk_id'] != vdiskid:
                scsiidconflicts.update({scsiid: entries})
    
    sortconflicts = sorted(scsiidconflicts.keys(), key=lambda x: int(x))
    print('{} conflicts on {} SCSI ID'.format(len(sortconflicts), len(byscsiid)))
    for conflict in sortconflicts:
        print('SCSI ID {} used for different vDisks:'.format(conflict))
        for entry in scsiidconflicts[conflict]:
            print('   {} on {} and iogroup {}'.format(entry['vdisk_name'],
                                                      entry['host_name'],
                                                      entry['io_group_name']))
if args.vdisk:
    vdiskidconflicts = {}
    for vdiskid, entries in byvdiskid.iteritems():
        scsiid = entries[0]['scsi_id']
        for entry in entries:
            if entry['scsi_id'] != scsiid:
                vdiskidconflicts.update({vdiskid: entries})
    
    sortconflicts = sorted(vdiskidconflicts.keys(), key=lambda x: int(x))
    print('{} conflicts on {} vDisks'.format(len(sortconflicts), len(byvdiskid)))
    for conflict in sortconflicts:
        print('vDisk {} uses different SCSI IDs:'.format(vdiskidconflicts[conflict][0]['vdisk_name']))
        for entry in vdiskidconflicts[conflict]:
            print('   {} on {} and iogroup {}'.format(entry['scsi_id'],
                                                      entry['host_name'],
                                                      entry['io_group_name']))