thalerj/openbmctool.py

#!/usr/bin/python3

'''
#================================================================================
#
#    openbmctool.py
#
#    Copyright IBM Corporation 2015-2017. All Rights Reserved
#
#    This program is licensed under the terms of the Eclipse Public License
#    v1.0 as published by the Eclipse Foundation and available at
#    http://www.eclipse.org/legal/epl-v10.html
#
#    U.S. Government Users Restricted Rights:  Use, duplication or disclosure
#    restricted by GSA ADP Schedule Contract with IBM Corp.
#
#================================================================================
'''
import argparse
import requests
import getpass
import json
import os
import urllib3
import time, datetime
# import yaml
import binascii
import subprocess
import platform
import zipfile

#isTTY = sys.stdout.isatty()

"""
     Used to add highlights to various text for displaying in a terminal
       
     @param textToColor: string, the text to be colored
     @param color: string, used to color the text red or green
     @param bold: boolean, used to bold the textToColor
     @return: Buffered reader containing the modified string. 
"""    
def hilight(textToColor, color, bold):
    if(sys.platform.__contains__("win")):
        if(color == "red"):
            os.system('color 04')
        elif(color == "green"):
            os.system('color 02')
        else:
            os.system('color') #reset to default
        return textToColor
    else:
        attr = []
        if(color == "red"):
            attr.append('31')
        elif(color == "green"):
            attr.append('32')
        else:
            attr.append('0')
        if bold:
            attr.append('1')
        else:
            attr.append('0')
        return '\x1b[%sm%s\x1b[0m' % (';'.join(attr),textToColor)

"""
     Error handler various connection errors to bmcs
       
     @param jsonFormat: boolean, used to output in json format with an error code. 
     @param errorStr: string, used to color the text red or green
     @param err: string, the text from the exception 
"""    
def connectionErrHandler(jsonFormat, errorStr, err):
    if errorStr == "Timeout":
        if not jsonFormat:
            return("FQPSPIN0000M: Connection timed out. Ensure you have network connectivity to the bmc")
        else:
            errorMessageStr = ("{\n\t\"event0\":{\n" +
            "\t\t\"CommonEventID\": \"FQPSPIN0000M\",\n"+
            "\t\t\"sensor\": \"N/A\",\n"+
            "\t\t\"state\": \"N/A\",\n" +
            "\t\t\"additionalDetails\": \"N/A\",\n" +
            "\t\t\"Message\": \"Connection timed out. Ensure you have network connectivity to the BMC\",\n" +
            "\t\t\"LengthyDescription\": \"While trying to establish a connection with the specified BMC, the BMC failed to respond in adequate time. Verify the BMC is functioning properly, and the network connectivity to the BMC is stable.\",\n" +
            "\t\t\"Serviceable\": \"Yes\",\n" +
            "\t\t\"CallHomeCandidate\": \"No\",\n" +
            "\t\t\"Severity\": \"Critical\",\n" +
            "\t\t\"EventType\": \"Communication Failure/Timeout\",\n" +
            "\t\t\"VMMigrationFlag\": \"Yes\",\n" +
            "\t\t\"AffectedSubsystem\": \"Interconnect (Networking)\",\n" +
            "\t\t\"timestamp\": \""+str(int(time.time()))+"\",\n" +
            "\t\t\"UserAction\": \"Verify network connectivity between the two systems and the bmc is functional.\"" +
            "\t\n}, \n" +
            "\t\"numAlerts\": \"1\" \n}");
            return(errorMessageStr)
    elif errorStr == "ConnectionError":
        if not jsonFormat:
            return("FQPSPIN0001M: " + str(err))
        else:
            errorMessageStr = ("{\n\t\"event0\":{\n" +
            "\t\t\"CommonEventID\": \"FQPSPIN0001M\",\n"+
            "\t\t\"sensor\": \"N/A\",\n"+
            "\t\t\"state\": \"N/A\",\n" +
            "\t\t\"additionalDetails\": \"" + str(err)+"\",\n" +
            "\t\t\"Message\": \"Connection Error. View additional details for more information\",\n" +
            "\t\t\"LengthyDescription\": \"A connection error to the specified BMC occurred and additional details are provided. Review these details to resolve the issue.\",\n" +
            "\t\t\"Serviceable\": \"Yes\",\n" +
            "\t\t\"CallHomeCandidate\": \"No\",\n" +
            "\t\t\"Severity\": \"Critical\",\n" +
            "\t\t\"EventType\": \"Communication Failure/Timeout\",\n" +
            "\t\t\"VMMigrationFlag\": \"Yes\",\n" +
            "\t\t\"AffectedSubsystem\": \"Interconnect (Networking)\",\n" +
            "\t\t\"timestamp\": \""+str(int(time.time()))+"\",\n" +
            "\t\t\"UserAction\": \"Correct the issue highlighted in additional details and try again\"" +
            "\t\n}, \n" +
            "\t\"numAlerts\": \"1\" \n}");
            return(errorMessageStr)
    else:
        return("Unknown Error: "+ str(err))

"""
     Sets the output width of the columns to display
       
     @param keylist: list, list of strings representing the keys for the dictForOutput 
     @param numcols: the total number of columns in the final output
     @param dictForOutput: dictionary, contains the information to print to the screen
     @param colNames: list, The strings to use for the column headings, in order of the keylist
     @return: A list of the column widths for each respective column. 
"""
def setColWidth(keylist, numCols, dictForOutput, colNames):
    colWidths = []
    for x in range(0, numCols):
        colWidths.append(0)
    for key in dictForOutput:
        for x in range(0, numCols):
            colWidths[x] = max(colWidths[x], len(str(dictForOutput[key][keylist[x]])))
    
    for x in range(0, numCols):
        colWidths[x] = max(colWidths[x], len(colNames[x])) +2
    
    return colWidths

def loadPolicyTable(pathToPolicyTable):
    policyTable = {}
    if(os.path.exists(pathToPolicyTable)):
        with open(pathToPolicyTable, 'r') as stream:
            try:
#                 contents = yaml.load(stream)
                contents =json.load(stream)
                policyTable = contents['events']
            except yaml.YAMLError as err:
                print(err)
    return policyTable

"""
     Logs into the BMC and creates a session
       
     @param host: string, the hostname or IP address of the bmc to log into
     @param username: The user name for the bmc to log into
     @param pw: The password for the BMC to log into
     @param jsonFormat: boolean, flag that will only allow relevant data from user command to be display. This function becomes silent when set to true. 
     @return: Session object
"""
def login(host, username, pw,jsonFormat):
    if(jsonFormat==False):
        print("Attempting login...")
    httpHeader = {'Content-Type':'application/json'}
    mysess = requests.session()
    try:
        r = mysess.post('https://'+host+'/login', headers=httpHeader, json = {"data": [username, pw]}, verify=False, timeout=30)
        loginMessage = json.loads(r.text)
        if (loginMessage['status'] != "ok"):
            print(loginMessage["data"]["description"].encode('utf-8')) 
            sys.exit(1)
#         if(sys.version_info < (3,0)):
#             urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
#         if sys.version_info >= (3,0):
#             requests.packages.urllib3.disable_warnings(requests.packages.urllib3.exceptions.InsecureRequestWarning)
        return mysess
    except(requests.exceptions.Timeout):
        print(connectionErrHandler(jsonFormat, "Timeout", None))
        sys.exit(1)
    except(requests.exceptions.ConnectionError) as err:
        print(connectionErrHandler(jsonFormat, "ConnectionError", err))
        sys.exit(1)

"""
     Logs out of the bmc and terminates the session
       
     @param host: string, the hostname or IP address of the bmc to log out of
     @param username: The user name for the bmc to log out of
     @param pw: The password for the BMC to log out of
     @param session: the active session to use
     @param jsonFormat: boolean, flag that will only allow relevant data from user command to be display. This function becomes silent when set to true. 
"""    
def logout(host, username, pw, session, jsonFormat):
    httpHeader = {'Content-Type':'application/json'}
    r = session.post('https://'+host+'/logout', headers=httpHeader,json = {"data": [username, pw]}, verify=False, timeout=10)
    if(jsonFormat==False):
        if('"message": "200 OK"' in r.text):
            print('User ' +username + ' has been logged out')

"""
     prints out the system inventory. deprecated see fruPrint and fruList
       
     @param host: string, the hostname or IP address of the bmc
     @param args: contains additional arguments used by the fru sub command
     @param session: the active session to use
     @param args.json: boolean, if this flag is set to true, the output will be provided in json format for programmatic consumption 
"""   
def fru(host, args, session):
    #url="https://"+host+"/org/openbmc/inventory/system/chassis/enumerate"
    
    #print(url)
    #res = session.get(url, headers=httpHeader, verify=False)
    #print(res.text)
    #sample = res.text
    
    #inv_list = json.loads(sample)["data"]
    
    url="https://"+host+"/xyz/openbmc_project/inventory/enumerate"
    httpHeader = {'Content-Type':'application/json'}
    res = session.get(url, headers=httpHeader, verify=False)
    sample = res.text
#     inv_list.update(json.loads(sample)["data"])
#     
#     #determine column width's
#     colNames = ["FRU Name", "FRU Type", "Has Fault", "Is FRU", "Present", "Version"]
#     colWidths = setColWidth(["FRU Name", "fru_type", "fault", "is_fru", "present", "version"], 6, inv_list, colNames)
#    
#     print("FRU Name".ljust(colWidths[0])+ "FRU Type".ljust(colWidths[1]) + "Has Fault".ljust(colWidths[2]) + "Is FRU".ljust(colWidths[3])+ 
#           "Present".ljust(colWidths[4]) + "Version".ljust(colWidths[5]))
#     format the output
#     for key in sorted(inv_list.keys()):
#         keyParts = key.split("/")
#         isFRU = "True" if (inv_list[key]["is_fru"]==1) else "False"
#         
#         fruEntry = (keyParts[len(keyParts) - 1].ljust(colWidths[0]) + inv_list[key]["fru_type"].ljust(colWidths[1])+
#                inv_list[key]["fault"].ljust(colWidths[2])+isFRU.ljust(colWidths[3])+
#                inv_list[key]["present"].ljust(colWidths[4])+ inv_list[key]["version"].ljust(colWidths[5]))
#         if(isTTY):
#             if(inv_list[key]["is_fru"] == 1):
#                 color = "green"
#                 bold = True
#             else:
#                 color='black'
#                 bold = False
#             fruEntry = hilight(fruEntry, color, bold)
#         print (fruEntry)
    return sample
"""
     prints out all inventory
       
     @param host: string, the hostname or IP address of the bmc
     @param args: contains additional arguments used by the fru sub command
     @param session: the active session to use
     @param args.json: boolean, if this flag is set to true, the output will be provided in json format for programmatic consumption 
     @return returns the total fru list. 
""" 
def fruPrint(host, args, session):   
    url="https://"+host+"/xyz/openbmc_project/inventory/enumerate"
    httpHeader = {'Content-Type':'application/json'}
    res = session.get(url, headers=httpHeader, verify=False)
#     print(res.text)
    frulist = res.text
    url="https://"+host+"/xyz/openbmc_project/software/enumerate"
    res = session.get(url, headers=httpHeader, verify=False)
#     print(res.text)
    frulist = frulist +"\n" + res.text
    
    return frulist

"""
     prints out all inventory or only a specific specified item
       
     @param host: string, the hostname or IP address of the bmc
     @param args: contains additional arguments used by the fru sub command
     @param session: the active session to use
     @param args.json: boolean, if this flag is set to true, the output will be provided in json format for programmatic consumption 
""" 
def fruList(host, args, session):
    if(args.items==True):
        return fruPrint(host, args, session)
    else:
        return "not implemented at this time"


"""
     prints out the status of all FRUs
       
     @param host: string, the hostname or IP address of the bmc
     @param args: contains additional arguments used by the fru sub command
     @param session: the active session to use
     @param args.json: boolean, if this flag is set to true, the output will be provided in json format for programmatic consumption 
"""         
def fruStatus(host, args, session):
    print("fru status to be implemented")

"""
     prints out all sensors
       
     @param host: string, the hostname or IP address of the bmc
     @param args: contains additional arguments used by the sensor sub command
     @param session: the active session to use
     @param args.json: boolean, if this flag is set to true, the output will be provided in json format for programmatic consumption 
"""        
def sensor(host, args, session):
#     url="https://"+host+"/org/openbmc/sensors/enumerate"
    httpHeader = {'Content-Type':'application/json'}
#     print(url)
#     res = session.get(url, headers=httpHeader, verify=False, timeout=20)
#     print(res.text)
    url="https://"+host+"/xyz/openbmc_project/sensors/enumerate"
    res = session.get(url, headers=httpHeader, verify=False, timeout=20)
    
    #Get OCC status
    url="https://"+host+"/org/open_power/control/enumerate"
    occres = session.get(url, headers=httpHeader, verify=False, timeout=20)
    if not args.json:
        colNames = ['sensor', 'type', 'units', 'value', 'target']
        sensors = json.loads(res.text)["data"]
        output = {}
        for key in sensors:
            senDict = {}
            keyparts = key.split("/")
            senDict['sensorName'] = keyparts[-1]
            senDict['type'] = keyparts[-2]
            senDict['units'] = sensors[key]['Unit'].split('.')[-1]
            if('Scale' in sensors[key]): 
                scale = 10 ** sensors[key]['Scale'] 
            else: 
                scale = 1
            senDict['value'] = str(sensors[key]['Value'] * scale)
            if 'Target' in sensors[key]:
                senDict['target'] = str(sensors[key]['Target'])
            else:
                senDict['target'] = 'N/A'
            output[senDict['sensorName']] = senDict
        
        occstatus = json.loads(occres.text)["data"]
        if '/org/open_power/control/occ0' in occstatus:
            occ0 = occstatus["/org/open_power/control/occ0"]['OccActive']
            if occ0 == 1: 
                occ0 = 'Active' 
            else: 
                occ0 = 'Inactive'
            output['OCC0'] = {'sensorName':'OCC0', 'type': 'Discrete', 'units': 'N/A', 'value': occ0, 'target': 'Active'}
            occ1 = occstatus["/org/open_power/control/occ1"]['OccActive']
            if occ1 == 1: 
                occ1 = 'Active' 
            else: 
                occ1 = 'Inactive'
            output['OCC1'] = {'sensorName':'OCC1', 'type': 'Discrete', 'units': 'N/A', 'value': occ0, 'target': 'Active'}
        else:
            output['OCC0'] = {'sensorName':'OCC0', 'type': 'Discrete', 'units': 'N/A', 'value': 'Inactive', 'target': 'Inactive'}
            output['OCC1'] = {'sensorName':'OCC1', 'type': 'Discrete', 'units': 'N/A', 'value': 'Inactive', 'target': 'Inactive'}
        keylist = ['sensorName', 'type', 'units', 'value', 'target']
        colWidth = setColWidth(keylist, len(colNames), output, colNames)
        row = ""
        outputText = ""
        for i in range(len(colNames)):
            if (i != 0): row = row + "| "
            row = row + colNames[i].ljust(colWidth[i])
        outputText += row + "\n"
        sortedKeys = list(output.keys()).sort
        for key in sorted(output.keys()):
            row = ""
            for i in range(len(output[key])):
                if (i != 0): row = row + "| "
                row = row + output[key][keylist[i]].ljust(colWidth[i])
            outputText += row + "\n"
        return outputText
    else:
        return res.text + occres.text
"""
     prints out the bmc alerts
       
     @param host: string, the hostname or IP address of the bmc
     @param args: contains additional arguments used by the sel sub command
     @param session: the active session to use
     @param args.json: boolean, if this flag is set to true, the output will be provided in json format for programmatic consumption 
"""     
def sel(host, args, session):

    url="https://"+host+"/xyz/openbmc_project/logging/entry/enumerate"
    httpHeader = {'Content-Type':'application/json'}
    #print(url)
    res = session.get(url, headers=httpHeader, verify=False, timeout=60)
    return res.text


"""
     converts a boolean value to a human readable string value
       
     @param value: boolean, the value to convert
     @return: A string of "Yes" or "No"
""" 
def boolToString(value):
    if(value):
        return "Yes"
    else:
        return "No"
    
"""
     parses the esel data and gets predetermined search terms
       
     @param eselRAW: string, the raw esel string from the bmc
     @return: A dictionary containing the quick snapshot data unless args.fullEsel is listed then a full PEL log is returned
"""    
def parseESEL(args, eselRAW):
    eselParts = {}
    esel_bin = binascii.unhexlify(''.join(eselRAW.split()[16:]))
    #search terms contains the search term as the key and the return dictionary key as it's value
    searchTerms = { 'Signature Description':'signatureDescription', 'devdesc':'devdesc',
                    'Callout type': 'calloutType', 'Procedure':'procedure'}
    
    with open('/tmp/esel.bin', 'wb') as f:
        f.write(esel_bin)
    errlPath = ""
    #use the right errl file for the machine architecture
    arch = platform.machine()
    if(arch =='x86_64' or arch =='AMD64'):
        if os.path.exists('/opt/ibm/ras/bin/x86_64/errl'):
            errlPath = '/opt/ibm/ras/bin/x86_64/errl'
        elif os.path.exists('errl/x86_64/errl'):
            errlPath = 'errl/x86_64/errl'
        else:
            errlPath = 'x86_64/errl'
    elif (platform.machine()=='ppc64le'):
        if os.path.exists('/opt/ibm/ras/bin/ppc64le/errl'):
            errlPath = '/opt/ibm/ras/bin/ppc64le/errl'
        elif os.path.exists('errl/ppc64le/errl'):
            errlPath = 'errl/ppc64le/errl'
        else:
            errlPath = 'ppc64le/errl'
    else:
        print("machine architecture not supported for parsing eSELs")
        return eselParts
    
    
    
    if(os.path.exists(errlPath)):
        output= subprocess.check_output([errlPath, '-d', '--file=/tmp/esel.bin']).decode('utf-8')
#         output = proc.communicate()[0]
        lines = output.split('\n')
        
        if(hasattr(args, 'fullEsel')):
            return output
        
        for i in range(0, len(lines)):
            lineParts = lines[i].split(':')
            if(len(lineParts)>1): #ignore multi lines, output formatting lines, and other information
                for term in searchTerms:
                    if(term in lineParts[0]):
                        temp = lines[i][lines[i].find(':')+1:].strip()[:-1].strip()
                        if lines[i+1].find(':') != -1:
                            if (len(lines[i+1].split(':')[0][1:].strip())==0):
                                while(len(lines[i][:lines[i].find(':')].strip())>2):
                                    if((i+1) <= len(lines)):
                                        i+=1
                                    else:
                                        i=i-1
                                        break
                                    temp = temp + lines[i][lines[i].find(':'):].strip()[:-1].strip()[:-1].strip()
                        eselParts[searchTerms[term]] = temp
        os.remove('/tmp/esel.bin')
    else:
        print("errl file cannot be found")
    
    return eselParts                

"""
     sorts the sels by timestamp, then log entry number
       
     @param events: Dictionary containing events
     @return: list containing a list of the ordered log entries, and dictionary of keys
""" 
def sortSELs(events):
    logNumList = []
    timestampList = []
    eventKeyDict = {} 
    eventsWithTimestamp = {}
    logNum2events = {}
    for key in events:
        if key == 'numAlerts': continue
        if 'callout' in key: continue
        timestamp = (events[key]['timestamp'])
        if timestamp not in timestampList:
            eventsWithTimestamp[timestamp] = [events[key]['logNum']]
        else:
            eventsWithTimestamp[timestamp].append(events[key]['logNum'])
        #map logNumbers to the event dictionary keys
        eventKeyDict[str(events[key]['logNum'])] = key
        
    timestampList = list(eventsWithTimestamp.keys())
    timestampList.sort()
    for ts in timestampList:
        if len(eventsWithTimestamp[ts]) > 1:
            tmplist = eventsWithTimestamp[ts]
            tmplist.sort()
            logNumList = logNumList + tmplist
        else:
            logNumList = logNumList + eventsWithTimestamp[ts]
    
    return [logNumList, eventKeyDict]

"""
     parses alerts in the IBM CER format, using an IBM policy Table
       
     @param policyTable: dictionary, the policy table entries
     @param selEntries: dictionary, the alerts retrieved from the bmc
     @return: A dictionary of the parsed entries, in chronological order
""" 
def parseAlerts(policyTable, selEntries, args):
    eventDict = {}
    eventNum =""
    count = 0
    esel = ""
    eselParts = {}
    i2cdevice= ""
    
    'prepare and sort the event entries'
    for key in selEntries:
        if 'callout' not in key:
            selEntries[key]['logNum'] = key.split('/')[-1]
            selEntries[key]['timestamp'] = selEntries[key]['Timestamp']
    sortedEntries = sortSELs(selEntries)
    logNumList = sortedEntries[0]
    eventKeyDict = sortedEntries[1]
    
    for logNum in logNumList:
        key = eventKeyDict[logNum]
#     for key in selEntries:
        hasEsel=False
        i2creadFail = False
        if 'callout' in key:
            continue
        else:
            messageID = str(selEntries[key]['Message'])
            addDataPiece = selEntries[key]['AdditionalData']
            calloutIndex = 0
            calloutFound = False
            for i in range(len(addDataPiece)):
                if("CALLOUT_INVENTORY_PATH" in addDataPiece[i]):
                    calloutIndex = i
                    calloutFound = True
                    fruCallout = str(addDataPiece[calloutIndex]).split('=')[1]
                if("CALLOUT_DEVICE_PATH" in addDataPiece[i]):
                    i2creadFail = True
                    i2cdevice = str(addDataPiece[i]).strip().split('=')[1]
                    i2cdevice = '/'.join(i2cdevice.split('/')[-4:])
                    fruCallout = 'I2C'
                    calloutFound = True
                if("ESEL" in addDataPiece[i]):
                    esel = str(addDataPiece[i]).strip().split('=')[1]
                    if args.devdebug:
                        eselParts = parseESEL(args, esel)
                    hasEsel=True
                if("GPU" in addDataPiece[i]):
                    fruCallout = '/xyz/openbmc_project/inventory/system/chassis/motherboard/gpu' + str(addDataPiece[i]).strip()[-1]
                    calloutFound = True
                if("PROCEDURE" in addDataPiece[i]):
                    fruCallout = str(hex(int(str(addDataPiece[i]).split('=')[1])))[2:]
                    calloutFound = True
                    
            if(calloutFound):
                policyKey = messageID +"||" +  fruCallout
            else:
                policyKey = messageID
            event = {}
            eventNum = str(count)
            if policyKey in policyTable:
                for pkey in policyTable[policyKey]:
                    if(type(policyTable[policyKey][pkey])== bool):
                        event[pkey] = boolToString(policyTable[policyKey][pkey])
                    else:
                        if (i2creadFail and pkey == 'Message'):
                            event[pkey] = policyTable[policyKey][pkey] + ' ' +i2cdevice
                        else:
                            event[pkey] = policyTable[policyKey][pkey]
                event['timestamp'] = selEntries[key]['Timestamp']
                event['resolved'] = bool(selEntries[key]['Resolved'])
                if(hasEsel):
                    if args.devdebug:
                        event['eselParts'] = eselParts
                    event['raweSEL'] = esel
                event['logNum'] = key.split('/')[-1]
                eventDict['event' + eventNum] = event
                
            else:
                severity = str(selEntries[key]['Severity']).split('.')[-1]
                if severity == 'Error':
                    severity = 'Critical'
                eventDict['event'+eventNum] = {}
                eventDict['event' + eventNum]['error'] = "error: Not found in policy table: " + policyKey
                eventDict['event' + eventNum]['timestamp'] = selEntries[key]['Timestamp']
                eventDict['event' + eventNum]['Severity'] = severity
                if(hasEsel):
                    if args.devdebug:
                        eventDict['event' +eventNum]['eselParts'] = eselParts
                    eventDict['event' +eventNum]['raweSEL'] = esel
                eventDict['event' +eventNum]['logNum'] = key.split('/')[-1]
                eventDict['event' +eventNum]['resolved'] = bool(selEntries[key]['Resolved'])
                #print("Event entry "+eventNum+": not found in policy table: " + policyKey)
            count += 1
    return eventDict


"""
     displays alerts in human readable format
       
     @param events: Dictionary containing events
     @return: 
""" 
def selDisplay(events, args):
    activeAlerts = []
    historyAlerts = []
    sortedEntries = sortSELs(events)
    logNumList = sortedEntries[0]
    eventKeyDict = sortedEntries[1]
    keylist = ['Entry', 'ID', 'Timestamp', 'Serviceable', 'Severity','Message']
    if(args.devdebug):
        colNames = ['Entry', 'ID', 'Timestamp', 'Serviceable', 'Severity','Message',  'eSEL contents']
        keylist.append('eSEL')
    else:
        colNames = ['Entry', 'ID', 'Timestamp', 'Serviceable', 'Severity', 'Message']
    for log in logNumList:
        selDict = {}
        alert = events[eventKeyDict[str(log)]]
        if('error' in alert):
            selDict['Entry'] = alert['logNum']
            selDict['ID'] = 'Unknown'
            selDict['Timestamp'] = datetime.datetime.fromtimestamp(int(alert['timestamp']/1000)).strftime("%Y-%m-%d %H:%M:%S")
            msg = alert['error']
            polMsg = msg.split("policy table:")[0]
            msg = msg.split("policy table:")[1]
            msgPieces = msg.split("||")
            err = msgPieces[0]
            if(err.find("org.open_power.")!=-1):
                err = err.split("org.open_power.")[1]
            elif(err.find("xyz.openbmc_project.")!=-1):
                err = err.split("xyz.openbmc_project.")[1]
            else:
                err = msgPieces[0]
            callout = ""
            if len(msgPieces) >1:
                callout = msgPieces[1]
                if(callout.find("/org/open_power/")!=-1):
                    callout = callout.split("/org/open_power/")[1]
                elif(callout.find("/xyz/openbmc_project/")!=-1):
                    callout = callout.split("/xyz/openbmc_project/")[1]
                else:
                    callout = msgPieces[1]
            selDict['Message'] = polMsg +"policy table: "+ err +  "||" + callout
            selDict['Serviceable'] = 'Unknown'  
            selDict['Severity'] = alert['Severity']
        else:
            selDict['Entry'] = alert['logNum']
            selDict['ID'] = alert['CommonEventID']
            selDict['Timestamp'] = datetime.datetime.fromtimestamp(int(alert['timestamp']/1000)).strftime("%Y-%m-%d %H:%M:%S")
            selDict['Message'] = alert['Message'] 
            selDict['Serviceable'] = alert['Serviceable']  
            selDict['Severity'] = alert['Severity']
        
               
        eselOrder = ['refCode','signatureDescription', 'eselType', 'devdesc', 'calloutType', 'procedure']
        if ('eselParts' in alert and args.devdebug):
            eselOutput = ""
            for item in eselOrder:
                if item in alert['eselParts']:
                    eselOutput = eselOutput + item + ": " + alert['eselParts'][item] + " | "
            selDict['eSEL'] = eselOutput
        else:
            if args.devdebug:
                selDict['eSEL'] = "None"
        
        if not alert['resolved']:
            activeAlerts.append(selDict)
        else:
            historyAlerts.append(selDict)
    mergedOutput = activeAlerts + historyAlerts
    colWidth = setColWidth(keylist, len(colNames), dict(enumerate(mergedOutput)), colNames) 
    
    output = ""
    if(len(activeAlerts)>0):
        row = ""   
        output +="----Active Alerts----\n"
        for i in range(0, len(colNames)):
            if i!=0: row =row + "| "
            row = row + colNames[i].ljust(colWidth[i])
        output += row + "\n"
    
        for i in range(0,len(activeAlerts)):
            row = ""
            for j in range(len(activeAlerts[i])):
                if (j != 0): row = row + "| "
                row = row + activeAlerts[i][keylist[j]].ljust(colWidth[j])
            output += row + "\n"
    
    if(len(historyAlerts)>0): 
        row = ""   
        output+= "----Historical Alerts----\n"   
        for i in range(len(colNames)):
            if i!=0: row =row + "| "
            row = row + colNames[i].ljust(colWidth[i])
        output += row + "\n"
    
        for i in range(0, len(historyAlerts)):
            row = ""
            for j in range(len(historyAlerts[i])):
                if (j != 0): row = row + "| "
                row = row + historyAlerts[i][keylist[j]].ljust(colWidth[j])
            output += row + "\n"
#         print(events[eventKeyDict[str(log)]])
    return output        

"""
     prints out all bmc alerts
       
     @param host: string, the hostname or IP address of the bmc
     @param args: contains additional arguments used by the fru sub command
     @param session: the active session to use
     @param args.json: boolean, if this flag is set to true, the output will be provided in json format for programmatic consumption 
""" 
def selPrint(host, args, session):
    if(args.policyTableLoc is None):
        if os.path.exists('policyTable.json'):
            ptableLoc = "policyTable.json"
        elif os.path.exists('/opt/ibm/ras/lib/policyTable.json'):
            ptableLoc = '/opt/ibm/ras/lib/policyTable.json'
        else:
            ptableLoc = 'lib/policyTable.json'
    else:
        ptableLoc = args.policyTableLoc
    policyTable = loadPolicyTable(ptableLoc)
    rawselEntries = ""
    if(hasattr(args, 'fileloc') and args.fileloc is not None):
        if os.path.exists(args.fileloc):
            with open(args.fileloc, 'r') as selFile:
                selLines = selFile.readlines()
            rawselEntries = ''.join(selLines)
        else:
            print("Error: File not found")
            sys.exit(1) 
    else:
        rawselEntries = sel(host, args, session)
    loadFailed = False
    try:
        selEntries = json.loads(rawselEntries)
    except ValueError:
        loadFailed = True
    if loadFailed:
        cleanSels = json.dumps(rawselEntries).replace('\\n', '')
        #need to load json twice as original content was string escaped a second time
        selEntries = json.loads(json.loads(cleanSels))
    selEntries = selEntries['data']
    cerList = {}
    if 'description' in selEntries:
        if(args.json):
            return("{\n\t\"numAlerts\": 0\n}")
        else:
            return("No log entries found")
        
    else:
        if(len(policyTable)>0):
            events = parseAlerts(policyTable, selEntries, args)
            if(args.json):
                events["numAlerts"] = len(events)
                retValue = str(json.dumps(events, sort_keys=True, indent=4, separators=(',', ': '), ensure_ascii=False))
                return retValue
            elif(hasattr(args, 'fullSel')):
                return events
            else:
                #get log numbers to order event entries sequentially
                return selDisplay(events, args)
        else:
            if(args.json):
                return selEntries
            else:
                print("error: Policy Table not found.")
                return selEntries
"""
     prints out all all bmc alerts, or only prints out the specified alerts
       
     @param host: string, the hostname or IP address of the bmc
     @param args: contains additional arguments used by the fru sub command
     @param session: the active session to use
     @param args.json: boolean, if this flag is set to true, the output will be provided in json format for programmatic consumption 
"""     
def selList(host, args, session):
    return(sel(host, args, session))

"""
     clears all alerts
       
     @param host: string, the hostname or IP address of the bmc
     @param args: contains additional arguments used by the fru sub command
     @param session: the active session to use
     @param args.json: boolean, if this flag is set to true, the output will be provided in json format for programmatic consumption 
"""      
def selClear(host, args, session):
    url="https://"+host+"/xyz/openbmc_project/logging/action/deleteAll"
    httpHeader = {'Content-Type':'application/json'}
    data = "{\"data\": [] }"
    #print(url)
    res = session.post(url, headers=httpHeader, data=data, verify=False, timeout=30)
    if res.status_code == 200:
        return "The Alert Log has been cleared. Please allow a few minutes for the action to complete."
    else:
        print("Unable to clear the logs, trying to clear 1 at a time")
        sels = json.loads(sel(host, args, session))['data']
        for key in sels:
            if 'callout' not in key:
                logNum = key.split('/')[-1]
                url = "https://"+ host+ "/xyz/openbmc_project/logging/entry/"+logNum+"/action/Delete"
                try:
                    session.post(url, headers=httpHeader, data=data, verify=False, timeout=30)
                except(requests.exceptions.Timeout):
                    return connectionErrHandler(args.json, "Timeout", None)
                    sys.exit(1)
                except(requests.exceptions.ConnectionError) as err:
                    return connectionErrHandler(args.json, "ConnectionError", err)
                    sys.exit(1)
        return ('Sel clearing complete')

def selSetResolved(host, args, session):
    url="https://"+host+"/xyz/openbmc_project/logging/entry/" + str(args.selNum) + "/attr/Resolved"
    httpHeader = {'Content-Type':'application/json'}
    data = "{\"data\": 1 }"
    #print(url)
    res = session.put(url, headers=httpHeader, data=data, verify=False, timeout=30)
    if res.status_code == 200:
        return "Sel entry "+ str(args.selNum) +" is now set to resolved"
    else:
        return "Unable to set the alert to resolved"
    
# """
#      gathers the esels. deprecated
#        
#      @param host: string, the hostname or IP address of the bmc
#      @param args: contains additional arguments used by the fru sub command
#      @param session: the active session to use
#      @param args.json: boolean, if this flag is set to true, the output will be provided in json format for programmatic consumption 
# """     
# def getESEL(host, args, session):
#     selentry= args.selNum
#     url="https://"+host+"/xyz/openbmc_project/logging/entry" + str(selentry)
#     httpHeader = {'Content-Type':'application/json'}
#     print(url)
#     res = session.get(url, headers=httpHeader, verify=False, timeout=20)
#     e = res.json()
#     if e['Message'] != 'org.open_power.Error.Host.Event' and\
#        e['Message'] != 'org.open_power.Error.Host.Event.Event':
#         raise Exception("Event is not from Host: " + e['Message'])
#     for d in e['AdditionalData']:
#         data = d.split("=")
#         tag = data.pop(0)
#         if tag != 'ESEL':
#             continue
#         data = "=".join(data)
#         if args.binary:
#             data = data.split(" ")
#             if '' == data[-1]:
#                 data.pop()
#             data = "".join(map(lambda x: chr(int(x, 16)), data))
#         print(data)

"""
     called by the chassis function. Controls the power state of the chassis, or gets the status
       
     @param host: string, the hostname or IP address of the bmc
     @param args: contains additional arguments used by the fru sub command
     @param session: the active session to use
     @param args.json: boolean, if this flag is set to true, the output will be provided in json format for programmatic consumption 
""" 
def chassisPower(host, args, session):
    if(args.powcmd == 'on'):
        print("Attempting to Power on...:")
        url="https://"+host+"/xyz/openbmc_project/state/host0/attr/RequestedHostTransition"
        httpHeader = {'Content-Type':'application/json',}
        data = '{"data":"xyz.openbmc_project.State.Host.Transition.On"}'
        res = session.put(url, headers=httpHeader, data=data, verify=False, timeout=20)
        return res.text
    elif(args.powcmd == 'off'):
        print("Attempting to Power off...:")
        url="https://"+host+"/xyz/openbmc_project/state/host0/attr/RequestedHostTransition"
        httpHeader = {'Content-Type':'application/json'}
        data = '{"data":"xyz.openbmc_project.State.Host.Transition.Off"}'
        res = session.put(url, headers=httpHeader, data=data, verify=False, timeout=20)
        return res.text
    elif(args.powcmd == 'status'):
        url="https://"+host+"/xyz/openbmc_project/state/chassis0/attr/CurrentPowerState"
        httpHeader = {'Content-Type':'application/json'}
#         print(url)
        res = session.get(url, headers=httpHeader, verify=False, timeout=20)
        chassisState = json.loads(res.text)['data'].split('.')[-1]
        url="https://"+host+"/xyz/openbmc_project/state/host0/attr/CurrentHostState"
        res = session.get(url, headers=httpHeader, verify=False, timeout=20)
        hostState = json.loads(res.text)['data'].split('.')[-1]
        url="https://"+host+"/xyz/openbmc_project/state/bmc0/attr/CurrentBMCState"
        res = session.get(url, headers=httpHeader, verify=False, timeout=20)
        bmcState = json.loads(res.text)['data'].split('.')[-1]
        if(args.json):
            outDict = {"Chassis Power State" : chassisState, "Host Power State" : hostState, "BMC Power State":bmcState}
            return json.dumps(outDict, sort_keys=True, indent=4, separators=(',', ': '), ensure_ascii=False)
        else:
            return "Chassis Power State: " +chassisState + "\nHost Power State: " + hostState + "\nBMC Power State: " + bmcState
    else:
        return "Invalid chassis power command"

"""
     called by the chassis function. Controls the identify led of the chassis. Sets or gets the state
       
     @param host: string, the hostname or IP address of the bmc
     @param args: contains additional arguments used by the fru sub command
     @param session: the active session to use
     @param args.json: boolean, if this flag is set to true, the output will be provided in json format for programmatic consumption 
"""
def chassisIdent(host, args, session):
    if(args.identcmd == 'on'):
        print("Attempting to turn identify light on...:")
        url="https://"+host+"/xyz/openbmc_project/led/groups/enclosure_identify/attr/Asserted"
        httpHeader = {'Content-Type':'application/json',}
        data = '{"data":true}'
        res = session.put(url, headers=httpHeader, data=data, verify=False, timeout=20)
        return res.text
    elif(args.identcmd == 'off'):
        print("Attempting to turn identify light off...:")
        url="https://"+host+"/xyz/openbmc_project/led/groups/enclosure_identify/attr/Asserted"
        httpHeader = {'Content-Type':'application/json'}
        data = '{"data":false}'
        res = session.put(url, headers=httpHeader, data=data, verify=False, timeout=20)
        return res.text
    elif(args.identcmd == 'status'):
        url="https://"+host+"/xyz/openbmc_project/led/groups/enclosure_identify"
        httpHeader = {'Content-Type':'application/json'}
#         print(url)
        res = session.get(url, headers=httpHeader, verify=False, timeout=20)
        status = json.loads(res.text)['data']
        if(args.json):
            return status
        else:
            if status['Asserted'] == 0:
                return "Identify light is off"
            else:
                return "Identify light is blinking"
    else:
        return "Invalid chassis identify command"

"""
     controls the different chassis commands
       
     @param host: string, the hostname or IP address of the bmc
     @param args: contains additional arguments used by the fru sub command
     @param session: the active session to use
     @param args.json: boolean, if this flag is set to true, the output will be provided in json format for programmatic consumption 
""" 
def chassis(host, args, session):
    if(hasattr(args, 'powcmd')):
        result = chassisPower(host,args,session)
    elif(hasattr(args, 'identcmd')):
        result = chassisIdent(host, args, session)
    else:
        return "to be completed"
    return result
"""
     Downloads a dump file from the bmc
       
     @param host: string, the hostname or IP address of the bmc
     @param args: contains additional arguments used by the collectServiceData sub command
     @param session: the active session to use
     @param args.json: boolean, if this flag is set to true, the output will be provided in json format for programmatic consumption 
"""
def bmcDumpRetrieve(host, args, session):
    httpHeader = {'Content-Type':'application/json'}
    dumpNum = args.dumpNum
    if (args.dumpSaveLoc is not None):
        saveLoc = args.dumpSaveLoc
    else:
        saveLoc = '/tmp'
    url ='https://'+host+'/download/dump/' + str(dumpNum)
    try:
        r = session.get(url, headers=httpHeader, stream=True, verify=False, timeout=20)
        if (args.dumpSaveLoc is not None):
            if os.path.exists(saveLoc):
                if saveLoc[-1] != os.path.sep:
                    saveLoc = saveLoc + os.path.sep
                filename = saveLoc + host+'-dump' + str(dumpNum) + '.tar.xz'
                
            else:
                return 'Invalid save location specified'
        else:
            filename = '/tmp/' + host+'-dump' + str(dumpNum) + '.tar.xz'

        with open(filename, 'wb') as f:
                    for chunk in r.iter_content(chunk_size =1024):
                        if chunk:
                            f.write(chunk)
        return 'Saved as ' + filename
        
    except(requests.exceptions.Timeout):
        return connectionErrHandler(args.json, "Timeout", None)
        sys.exit(1)
    except(requests.exceptions.ConnectionError) as err:
        return connectionErrHandler(args.json, "ConnectionError", err)
        sys.exit(1)

"""
     Lists the number of dump files on the bmc
       
     @param host: string, the hostname or IP address of the bmc
     @param args: contains additional arguments used by the collectServiceData sub command
     @param session: the active session to use
     @param args.json: boolean, if this flag is set to true, the output will be provided in json format for programmatic consumption 
"""
def bmcDumpList(host, args, session):    
    httpHeader = {'Content-Type':'application/json'}
    url ='https://'+host+'/xyz/openbmc_project/dump/list'
    try:
        r = session.get(url, headers=httpHeader, verify=False, timeout=20)
        dumpList = json.loads(r.text)
        return r.text
    except(requests.exceptions.Timeout):
        return connectionErrHandler(args.json, "Timeout", None)
        sys.exit(1)
    except(requests.exceptions.ConnectionError) as err:
        return connectionErrHandler(args.json, "ConnectionError", err)
        sys.exit(1)          
 

"""
     Deletes BMC dump files from the bmc
       
     @param host: string, the hostname or IP address of the bmc
     @param args: contains additional arguments used by the collectServiceData sub command
     @param session: the active session to use
     @param args.json: boolean, if this flag is set to true, the output will be provided in json format for programmatic consumption 
"""
def bmcDumpDelete(host, args, session):
    httpHeader = {'Content-Type':'application/json'}
    dumpList = []
    successList = []
    failedList = []
    if args.dumpNum is not None:
        if isinstance(args.dumpNum, list):
            dumpList = args.dumpNum
        else:
            dumpList.append(args.dumpNum)
        for dumpNum in dumpList:
            url ='https://'+host+'/xyz/openbmc_project/dump/entry/'+str(dumpNum)+'/action/Delete'
            try:
                r = session.post(url, headers=httpHeader, json = {"data": []}, verify=False, timeout=30)
                if r.status_code == 200:
                    successList.append(str(dumpNum))
                    #return('Dump ' + str(dumpNum) + ' deleted')
                else:
                    failedList.append(str(dumpNum))
                    #return('Unable to delete dump ' + str(dumpNum))
            except(requests.exceptions.Timeout):
                return connectionErrHandler(args.json, "Timeout", None)
#                 sys.exit(1)
            except(requests.exceptions.ConnectionError) as err:
                return connectionErrHandler(args.json, "ConnectionError", err)
#                 sys.exit(1)
        output = "Successfully deleted dumps: " + ', '.join(successList)
        if(len(failedList)>0):
            output+= '\nFailed to delete dumps: ' + ', '.join(failedList)
        return output
    else:
        return 'You must specify an entry number to delete'

"""
     Deletes All BMC dump files from the bmc
       
     @param host: string, the hostname or IP address of the bmc
     @param args: contains additional arguments used by the collectServiceData sub command
     @param session: the active session to use
     @param args.json: boolean, if this flag is set to true, the output will be provided in json format for programmatic consumption 
"""
def bmcDumpDeleteAll(host, args, session):
    dumpList = json.loads(bmcDumpList(host, args, session))['data']
    d = vars(args)
    dumpNums = []
    for dump in dumpList:
        if '/xyz/openbmc_project/dump/internal/manager' not in dump:
            dumpNums.append(int(dump.strip().split('/')[-1]))
    d['dumpNum'] = dumpNums
    
    return bmcDumpDelete(host, args, session)
    
"""
     Creates a bmc dump file
       
     @param host: string, the hostname or IP address of the bmc
     @param args: contains additional arguments used by the collectServiceData sub command
     @param session: the active session to use
     @param args.json: boolean, if this flag is set to true, the output will be provided in json format for programmatic consumption 
"""
def bmcDumpCreate(host, args, session):
    httpHeader = {'Content-Type':'application/json'}
    url = 'https://'+host+'/xyz/openbmc_project/dump/action/CreateDump'
    try:
        r = session.post(url, headers=httpHeader, json = {"data": []}, verify=False, timeout=30)
        if('"message": "200 OK"' in r.text and not args.json):
            return ('Dump successfully created')
        else:
            return ('Failed to create dump')
    except(requests.exceptions.Timeout):
        return connectionErrHandler(args.json, "Timeout", None)
    except(requests.exceptions.ConnectionError) as err:
        return connectionErrHandler(args.json, "ConnectionError", err)
        
   
    
"""
     Collects all data needed for service from the BMC
       
     @param host: string, the hostname or IP address of the bmc
     @param args: contains additional arguments used by the collectServiceData sub command
     @param session: the active session to use
     @param args.json: boolean, if this flag is set to true, the output will be provided in json format for programmatic consumption 
"""
def collectServiceData(host, args, session):
    #create a bmc dump
    dumpcount = len(json.loads(bmcDumpList(host, args, session))['data'])
    try:
        dumpcreated = bmcDumpCreate(host, args, session)
    except Exception as e:
        print('failed to create a bmc dump')
    
    
    #Collect Inventory
    try:
        args.silent = True
        myDir = '/tmp/' + host + "--" + datetime.datetime.now().strftime("%Y-%m-%d_%H.%M.%S")
        os.makedirs(myDir)
        filelist = []
        frulist = fruPrint(host, args, session)
        with open(myDir +'/inventory.txt', 'w') as f:
            f.write(frulist)
        print("Inventory collected and stored in " + myDir + "/inventory.txt")
        filelist.append(myDir+'/inventory.txt')
    except Exception as e:
        print("Failed to collect inventory")
    
    #Read all the sensor and OCC status
    try:
        sensorReadings = sensor(host, args, session)
        with open(myDir +'/sensorReadings.txt', 'w') as f:
            f.write(sensorReadings)
        print("Sensor readings collected and stored in " +myDir + "/sensorReadings.txt")
        filelist.append(myDir+'/sensorReadings.txt')
    except Exception as e:
        print("Failed to collect sensor readings")
    
    #Collect all of the LEDs status
    try:
        url="https://"+host+"/xyz/openbmc_project/led/enumerate"
        httpHeader = {'Content-Type':'application/json'}
        leds = session.get(url, headers=httpHeader, verify=False, timeout=20)
        with open(myDir +'/ledStatus.txt', 'w') as f:
            f.write(leds.text)
        print("System LED status collected and stored in "+myDir +"/ledStatus.txt")
        filelist.append(myDir+'/ledStatus.txt')
    except Exception as e:
        print("Failed to collect LED status")
    
    #Collect the bmc logs
    try:
        sels = selPrint(host,args,session)
        with open(myDir +'/SELshortlist.txt', 'w') as f:
            f.write(str(sels))
        print("sel short list collected and stored in "+myDir +"/SELshortlist.txt")
        filelist.append(myDir+'/SELshortlist.txt')
        time.sleep(2)
        
        d = vars(args)
        d['json'] = True
        d['fullSel'] = True
        parsedfullsels = json.loads(selPrint(host, args, session))
        d['fullEsel'] = True
        sortedSELs = sortSELs(parsedfullsels)
        with open(myDir +'/parsedSELs.txt', 'w') as f:
            for log in sortedSELs[0]:
                esel = ""
                parsedfullsels[sortedSELs[1][str(log)]]['timestamp'] = datetime.datetime.fromtimestamp(int(parsedfullsels[sortedSELs[1][str(log)]]['timestamp']/1000)).strftime("%Y-%m-%d %H:%M:%S")
                if ('raweSEL' in parsedfullsels[sortedSELs[1][str(log)]] and args.devdebug):
                    esel = parsedfullsels[sortedSELs[1][str(log)]]['raweSEL'] 
                    del parsedfullsels[sortedSELs[1][str(log)]]['raweSEL'] 
                f.write(json.dumps(parsedfullsels[sortedSELs[1][str(log)]],sort_keys=True, indent=4, separators=(',', ': ')))
                if(args.devdebug and esel != ""):
                    f.write(parseESEL(args, esel))
        print("fully parsed sels collected and stored in "+myDir +"/parsedSELs.txt")
        filelist.append(myDir+'/parsedSELs.txt')
    except Exception as e:
        print("Failed to collect system event logs")
        print(e)
    
    #collect RAW bmc enumeration
    try:    
        url="https://"+host+"/xyz/openbmc_project/enumerate"
        print("Attempting to get a full BMC enumeration")
        fullDump = session.get(url, headers=httpHeader, verify=False, timeout=120)
        with open(myDir +'/bmcFullRaw.txt', 'w') as f:
            f.write(fullDump.text)
        print("RAW BMC data collected and saved into "+myDir +"/bmcFullRaw.txt")
        filelist.append(myDir+'/bmcFullRaw.txt')
    except Exception as e:
        print("Failed to collect bmc full enumeration")
     
    #collect the dump files 
    waitingForNewDump = True
    count = 0;
    while(waitingForNewDump):   
        dumpList = json.loads(bmcDumpList(host, args, session))['data']
        if len(dumpList) > dumpcount:
            waitingForNewDump = False
            break;
        elif(count>30):
            print("Timed out waiting for bmc to make a new dump file. Dump space may be full.")
            break;
        else:
            time.sleep(2)
        count += 1
    try:    
        print('Collecting bmc dump files')
        d['dumpSaveLoc'] = myDir
        dumpList = json.loads(bmcDumpList(host, args, session))['data']
        for dump in dumpList:
            if '/xyz/openbmc_project/dump/internal/manager' not in dump:
                d['dumpNum'] = int(dump.strip().split('/')[-1])
                print('retrieving dump file ' + str(d['dumpNum']))
                filename = bmcDumpRetrieve(host, args, session).split('Saved as ')[-1]
                filelist.append(filename)
                time.sleep(2)
    except Exception as e:
        print("Failed to collect bmc dump files")
        print(e)
        
    #create the zip file
    try:    
        filename = myDir.split('/tmp/')[-1] + '.zip'
        zf = zipfile.ZipFile(myDir+'/' + filename, 'w')
        for myfile in filelist:
            zf.write(myfile, os.path.basename(myfile))
        zf.close()
    except Exception as e:
        print("Failed to create zip file with collected information")
    return "data collection complete"

"""
     handles various bmc level commands, currently bmc rebooting
       
     @param host: string, the hostname or IP address of the bmc
     @param args: contains additional arguments used by the bmc sub command
     @param session: the active session to use
     @param args.json: boolean, if this flag is set to true, the output will be provided in json format for programmatic consumption 
"""         
def bmc(host, args, session):
    if(args.info):
        return "To be completed"
    if(args.type is not None):
        return bmcReset(host, args, session)
    
"""
     controls resetting the bmc. warm reset reboots the bmc, cold reset removes the configuration and reboots. 
       
     @param host: string, the hostname or IP address of the bmc
     @param args: contains additional arguments used by the bmcReset sub command
     @param session: the active session to use
     @param args.json: boolean, if this flag is set to true, the output will be provided in json format for programmatic consumption 
""" 
def bmcReset(host, args, session):
    if(args.type == "warm"):
        print("\nAttempting to reboot the BMC...:")
        url="https://"+host+"/xyz/openbmc_project/state/bmc0/attr/RequestedBMCTransition"
        httpHeader = {'Content-Type':'application/json'}
        data = '{"data":"xyz.openbmc_project.State.BMC.Transition.Reboot"'
        res = session.post(url, headers=httpHeader, data=data, verify=False, timeout=20)
        return res.text
    elif(args.type =="cold"):
        return "cold reset not available at this time."
    else:
        return "invalid command"
"""
     creates the parser for the command line along with help for each command and subcommand
       
     @return: returns the parser for the command line
""" 
def createCommandParser():
    parser = argparse.ArgumentParser(description='Process arguments')
    parser.add_argument("-H", "--host", required=True, help='A hostname or IP for the BMC')
    parser.add_argument("-U", "--user", required=True, help='The username to login with')
    #parser.add_argument("-v", "--verbose", help='provides more detail')
    group = parser.add_mutually_exclusive_group()
    group.add_argument("-A", "--askpw", action='store_true', help='prompt for password')
    group.add_argument("-P", "--PW", help='Provide the password in-line')
    parser.add_argument('-j', '--json', action='store_true', help='output json data only')
    parser.add_argument('-t', '--policyTableLoc', help='The location of the policy table to parse alerts')
    parser.add_argument('-c', '--CerFormat', action='store_true', help=argparse.SUPPRESS)
    parser.add_argument('-T', '--procTime', action='store_true', help= argparse.SUPPRESS)
    subparsers = parser.add_subparsers(title='subcommands', description='valid subcommands',help="sub-command help")
    
    #fru command
    parser_inv = subparsers.add_parser("fru", help='Work with platform inventory')
    #fru print
    inv_subparser = parser_inv.add_subparsers(title='subcommands', description='valid inventory actions', help="valid inventory actions")
    inv_print = inv_subparser.add_parser("print", help="prints out a list of all FRUs")
    inv_print.set_defaults(func=fruPrint)
    #fru list [0....n]
    inv_list = inv_subparser.add_parser("list", help="print out details on selected FRUs. Specifying no items will list the entire inventory")
    inv_list.add_argument('items', nargs='?', help="print out details on selected FRUs. Specifying no items will list the entire inventory")
    inv_list.set_defaults(func=fruList)
    #fru status
    inv_status = inv_subparser.add_parser("status", help="prints out the status of all FRUs")
    inv_status.set_defaults(func=fruStatus)
    #parser_inv.add_argument('status', action='store_true', help="Lists the status of all BMC detected components")
    #parser_inv.add_argument('num', type=int, action='store_true', help="The number of the FRU to list")
    #inv_status.set_defaults(func=fruStatus)
    
    #sensors command
    parser_sens = subparsers.add_parser("sensors", help="Work with platform sensors")
    sens_subparser=parser_sens.add_subparsers(title='subcommands', description='valid sensor actions', help='valid sensor actions')
    #sensor print
    sens_print= sens_subparser.add_parser('print', help="prints out a list of all Sensors.")
    sens_print.set_defaults(func=sensor)
    #sensor list[0...n]
    sens_list=sens_subparser.add_parser("list", help="Lists all Sensors in the platform. Specify a sensor for full details. ")
    sens_list.add_argument("sensNum", nargs='?', help="The Sensor number to get full details on" )
    sens_list.set_defaults(func=sensor)
    
    
    #sel command
    parser_sel = subparsers.add_parser("sel", help="Work with platform alerts")
    sel_subparser = parser_sel.add_subparsers(title='subcommands', description='valid SEL actions', help = 'valid SEL actions')
    
    #sel print
    sel_print = sel_subparser.add_parser("print", help="prints out a list of all sels in a condensed list")
    sel_print.add_argument('-d', '--devdebug', action='store_true', help=argparse.SUPPRESS)
    sel_print.add_argument('-v', '--verbose', action='store_true', help="Changes the output to being very verbose")
    sel_print.add_argument('-f', '--fileloc', help='Parse a file instead of the BMC output')
    sel_print.set_defaults(func=selPrint)
    #sel list
    sel_list = sel_subparser.add_parser("list", help="Lists all SELs in the platform. Specifying a specific number will pull all the details for that individual SEL")
    sel_list.add_argument("selNum", nargs='?', type=int, help="The SEL entry to get details on")
    sel_list.set_defaults(func=selList)
    
    sel_get = sel_subparser.add_parser("get", help="Gets the verbose details of a specified SEL entry")
    sel_get.add_argument('selNum', type=int, help="the number of the SEL entry to get")
    sel_get.set_defaults(func=selList)
    
    sel_clear = sel_subparser.add_parser("clear", help="Clears all entries from the SEL")
    sel_clear.set_defaults(func=selClear)
    
    sel_setResolved = sel_subparser.add_parser("resolve", help="Sets the sel entry to resolved")
    sel_setResolved.add_argument('selNum', type=int, help="the number of the SEL entry to resolve")
    sel_setResolved.set_defaults(func=selSetResolved)
    
    parser_chassis = subparsers.add_parser("chassis", help="Work with chassis power and status")
    chas_sub = parser_chassis.add_subparsers(title='subcommands', description='valid subcommands',help="sub-command help")
    
    parser_chassis.add_argument('status', action='store_true', help='Returns the current status of the platform')
    parser_chassis.set_defaults(func=chassis)
    
    parser_chasPower = chas_sub.add_parser("power", help="Turn the chassis on or off, check the power state")
    parser_chasPower.add_argument('powcmd',  choices=['on','off', 'status'], help='The value for the power command. on, off, or status')
    parser_chasPower.set_defaults(func=chassisPower)
    
    #control the chassis identify led
    parser_chasIdent = chas_sub.add_parser("identify", help="Control the chassis identify led")
    parser_chasIdent.add_argument('identcmd', choices=['on', 'off', 'status'], help='The control option for the led: on, off, blink, status')
    parser_chasIdent.set_defaults(func=chassisIdent)
    
    #collect service data
    parser_servData = subparsers.add_parser("collect_service_data", help="Collect all bmc data needed for service")
    parser_servData.add_argument('-d', '--devdebug', action='store_true', help=argparse.SUPPRESS)
    parser_servData.set_defaults(func=collectServiceData)
    
    #work with bmc dumps
    parser_bmcdump = subparsers.add_parser("dump", help="Work with bmc dump files")
    bmcDump_sub = parser_bmcdump.add_subparsers(title='subcommands', description='valid subcommands',help="sub-command help")
    dump_Create = bmcDump_sub.add_parser('create', help="Create a bmc dump")
    dump_Create.set_defaults(func=bmcDumpCreate)
    

    dump_list = bmcDump_sub.add_parser('list', help="list all bmc dump files")
    dump_list.set_defaults(func=bmcDumpList)
    
    parserdumpdelete = bmcDump_sub.add_parser('delete', help="Delete bmc dump files")
    parserdumpdelete.add_argument("-n", "--dumpNum", nargs='*', type=int, help="The Dump entry to delete")
#     parserdumpdelete.add_argument('deleteAll', choices=['all'], help="Delete all entries")
    parserdumpdelete.set_defaults(func=bmcDumpDelete)
    
    bmcDumpDelsub = parserdumpdelete.add_subparsers(title='subcommands', description='valid subcommands',help="sub-command help")
    deleteAllDumps = bmcDumpDelsub.add_parser('all', help='Delete all bmc dump files')
    deleteAllDumps.set_defaults(func=bmcDumpDeleteAll)
    
    parser_dumpretrieve = bmcDump_sub.add_parser('retrieve', help='Retrieve a dump file')
    parser_dumpretrieve.add_argument("dumpNum", type=int, help="The Dump entry to delete")
    parser_dumpretrieve.add_argument("-s", "--dumpSaveLoc", help="The location to save the bmc dump file")
    parser_dumpretrieve.set_defaults(func=bmcDumpRetrieve)
    
    
    #esel command ###notused###
#     esel_parser = subparsers.add_parser("esel", help ="Work with an ESEL entry")
#     esel_subparser = esel_parser.add_subparsers(title='subcommands', description='valid SEL actions', help = 'valid SEL actions')
#     esel_get = esel_subparser.add_parser("get", help="Gets the details of an ESEL entry")
#     esel_get.add_argument('selNum', type=int, help="the number of the SEL entry to get")
#     esel_get.set_defaults(func=getESEL)
    
    
    parser_bmc = subparsers.add_parser('bmc', help="Work with the bmc")
    bmc_sub = parser_bmc.add_subparsers(title='subcommands', description='valid subcommands',help="sub-command help")
    parser_BMCReset = bmc_sub.add_parser('reset', help='Reset the bmc' )
    parser_BMCReset.add_argument('type', choices=['warm','cold'], help="Warm: Reboot the BMC, Cold: CLEAR config and reboot bmc")
#     parser_BMCReset.add_argument('cold', action='store_true', help="Reboot the BMC and CLEAR the configuration")
    parser_bmc.add_argument('info', action='store_true', help="Displays information about the BMC hardware, including device revision, firmware revision, IPMI version supported, manufacturer ID, and information on additional device support.")
    parser_bmc.set_defaults(func=bmc)
#     parser_BMCReset.set_defaults(func=bmcReset)
    
    #add alias to the bmc command
    parser_mc = subparsers.add_parser('mc', help="Work with the management controller")
    mc_sub = parser_mc.add_subparsers(title='subcommands', description='valid subcommands',help="sub-command help")
    parser_MCReset = mc_sub.add_parser('reset', help='Reset the bmc' )
    parser_MCReset.add_argument('type', choices=['warm','cold'], help="Reboot the BMC")
    #parser_MCReset.add_argument('cold', action='store_true', help="Reboot the BMC and CLEAR the configuration")
    parser_mc.add_argument('info', action='store_true', help="Displays information about the BMC hardware, including device revision, firmware revision, IPMI version supported, manufacturer ID, and information on additional device support.")
    parser_mc.set_defaults(func=bmc)
    #parser_MCReset.set_defaults(func=bmcReset)
    return parser

"""
     main function for running the command line utility as a sub application
       
""" 
def main(argv=None):

    
    parser = createCommandParser()
    
    #host power on/off
    #reboot bmc
    #host current state
    #chassis power
    #error collection - nonipmi
    #clear logs
    #bmc state
    
    args = parser.parse_args(argv)
    if (args.askpw):
        pw = getpass.getpass()
    elif(args.PW is not None):
        pw = args.PW
    else:
        print("You must specify a password")
        sys.exit()
        
    totTimeStart = int(round(time.time()*1000))

    if(sys.version_info < (3,0)):
        urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
    if sys.version_info >= (3,0):
        requests.packages.urllib3.disable_warnings(requests.packages.urllib3.exceptions.InsecureRequestWarning)
    if (hasattr(args, 'fileloc') and args.fileloc is not None):
        mysess = None
    else: 
        logintimeStart = int(round(time.time()*1000))
        mysess = login(args.host, args.user, pw, args.json)
        logintimeStop = int(round(time.time()*1000))
    
    commandTimeStart = int(round(time.time()*1000))  
    output = args.func(args.host, args, mysess)
    commandTimeStop = int(round(time.time()*1000))
    print(output)
    if (mysess is not None):
        logout(args.host, args.user, pw, mysess, args.json)  
    if(args.procTime):     
        print("Total time: " + str(int(round(time.time()*1000))- totTimeStart))
        print("loginTime: " + str(logintimeStop - logintimeStart))
        print("command Time: " + str(commandTimeStop - commandTimeStart))

"""
     main function when called from the command line
        
""" 
if __name__ == '__main__':
    import sys
    
    isTTY = sys.stdout.isatty()
    assert sys.version_info >= (2,7)
    main()