tools/visualize-pdr/pldm_visualise_pdrs.py

#!/usr/bin/env python3

"""Tool to visualize PLDM PDR's"""

import argparse
import hashlib
import json
import os
import shlex
import shutil
import subprocess
import sys
from datetime import datetime

import paramiko
from graphviz import Digraph
from tabulate import tabulate


class Process:
    """Interface definition for interacting with a process created by an
    Executor."""

    def __init__(self, stdout, stderr):
        """Construct a Process object.  Process object clients can read the
        process stdout and stderr with os.read(), and can wait for the
        process to exit.

        Parameters:
            stdout: os.read()able stream representing stdout
            stderr: os.read()able stream representing stderr
        """

        self.stdout = stdout
        self.stderr = stderr

    def wait(self):
        """Wait for the process to finish, and return its exit status."""

        raise NotImplementedError


class Executor:
    """Interface definition for interacting with executors.  An executor is an
    object that can run a program."""

    def exec_command(self, cmd):
        raise NotImplementedError

    def close(self):
        pass


class ParamikoProcess(Process):
    """Concrete implementation of the Process interface that adapts Paramiko
    interfaces to the Process interface requirements."""

    def __init__(self, stdout, stderr):
        super(ParamikoProcess, self).__init__(stdout, stderr)

    def wait(self):
        return self.stderr.channel.recv_exit_status()


class ParamikoExecutor(Executor):
    """Concrete implementation of the Executor interface that uses
    Paramiko to connect to a remote BMC to run the program."""

    def __init__(self, hostname, uname, passwd, port, **kw):
        """This function is responsible for connecting to the BMC via
        ssh and returning an executor object.

        Parameters:
            hostname: hostname/IP address of BMC
            uname: ssh username of BMC
            passwd: ssh password of BMC
            port: ssh port of BMC
        """

        super(ParamikoExecutor, self).__init__()
        self.client = paramiko.SSHClient()
        self.client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
        self.client.connect(
            hostname, username=uname, password=passwd, port=port, **kw
        )

    def exec_command(self, cmd):
        _, stdout, stderr = self.client.exec_command(cmd)
        return ParamikoProcess(stdout, stderr)

    def close(self):
        self.client.close()


class SubprocessProcess(Process):
    def __init__(self, popen):
        self.popen = popen
        super(SubprocessProcess, self).__init__(popen.stdout, popen.stderr)

    def wait(self):
        self.popen.wait()
        return self.popen.returncode


class SubprocessExecutor(Executor):
    def __init__(self):
        super(SubprocessExecutor, self).__init__()

    def exec_command(self, cmd):
        args = shlex.split(cmd)
        args[0] = shutil.which(args[0])
        p = subprocess.Popen(
            args, stdout=subprocess.PIPE, stderr=subprocess.PIPE
        )
        return SubprocessProcess(p)


def prepare_summary_report(state_sensor_pdr, state_effecter_pdr):
    """This function is responsible to parse the state sensor pdr
    and the state effecter pdr dictionaries and creating the
    summary table.

    Parameters:
        state_sensor_pdr: list of state sensor pdrs
        state_effecter_pdr: list of state effecter pdrs

    """

    summary_table = []
    headers = ["sensor_id", "entity_type", "state_set", "states"]
    summary_table.append(headers)
    for value in state_sensor_pdr.values():
        summary_record = []
        sensor_possible_states = ""
        for sensor_state in value["possibleStates[0]"]:
            sensor_possible_states += sensor_state + "\n"
        summary_record.extend(
            [
                value["sensorID"],
                value["entityType"],
                value["stateSetID[0]"],
                sensor_possible_states,
            ]
        )
        summary_table.append(summary_record)
    print("Created at : ", datetime.now().strftime("%Y-%m-%d %H:%M:%S"))
    print(tabulate(summary_table, tablefmt="fancy_grid", headers="firstrow"))

    summary_table = []
    headers = ["effecter_id", "entity_type", "state_set", "states"]
    summary_table.append(headers)
    for value in state_effecter_pdr.values():
        summary_record = []
        effecter_possible_states = ""
        for state in value["possibleStates[0]"]:
            effecter_possible_states += state + "\n"
        summary_record.extend(
            [
                value["effecterID"],
                value["entityType"],
                value["stateSetID[0]"],
                effecter_possible_states,
            ]
        )
        summary_table.append(summary_record)
    print(tabulate(summary_table, tablefmt="fancy_grid", headers="firstrow"))


def draw_entity_associations(pdr, counter):
    """This function is responsible to create a picture that captures
    the entity association hierarchy based on the entity association
    PDR's received from the BMC.

    Parameters:
        pdr: list of entity association PDR's
        counter: variable to capture the count of PDR's to unflatten
                 the tree

    """

    dot = Digraph(
        "entity_hierarchy",
        node_attr={"color": "lightblue1", "style": "filled"},
    )
    dot.attr(
        label=r"\n\nEntity Relation Diagram < "
        + str(datetime.now().strftime("%Y-%m-%d %H:%M:%S"))
        + ">\n"
    )
    dot.attr(fontsize="20")
    edge_list = []
    for value in pdr.values():
        parentnode = str(value["containerEntityType"]) + str(
            value["containerEntityInstanceNumber"]
        )
        dot.node(
            hashlib.md5(
                (
                    parentnode + str(value["containerEntityContainerID"])
                ).encode()
            ).hexdigest(),
            parentnode,
        )

        for i in range(1, value["containedEntityCount"] + 1):
            childnode = str(value[f"containedEntityType[{i}]"]) + str(
                value[f"containedEntityInstanceNumber[{i}]"]
            )
            cid = str(value[f"containedEntityContainerID[{i}]"])
            dot.node(
                hashlib.md5((childnode + cid).encode()).hexdigest(), childnode
            )

            if [
                hashlib.md5(
                    (
                        parentnode + str(value["containerEntityContainerID"])
                    ).encode()
                ).hexdigest(),
                hashlib.md5((childnode + cid).encode()).hexdigest(),
            ] not in edge_list:
                edge_list.append(
                    [
                        hashlib.md5(
                            (
                                parentnode
                                + str(value["containerEntityContainerID"])
                            ).encode()
                        ).hexdigest(),
                        hashlib.md5((childnode + cid).encode()).hexdigest(),
                    ]
                )
                dot.edge(
                    hashlib.md5(
                        (
                            parentnode
                            + str(value["containerEntityContainerID"])
                        ).encode()
                    ).hexdigest(),
                    hashlib.md5((childnode + cid).encode()).hexdigest(),
                )
    unflattentree = dot.unflatten(stagger=(round(counter / 3)))
    unflattentree.render(
        filename="entity_association_"
        + str(datetime.now().strftime("%Y-%m-%d_%H-%M-%S")),
        view=False,
        cleanup=True,
        format="pdf",
    )


class PLDMToolError(Exception):
    """Exception class intended to be used to hold pldmtool invocation failure
    information such as exit status and stderr.

    """

    def __init__(self, status, stderr):
        msg = "pldmtool failed with exit status {}.\n".format(status)
        msg += "stderr: \n\n{}".format(stderr)
        super(PLDMToolError, self).__init__(msg)
        self.status = status

    def get_status(self):
        return self.status


def process_pldmtool_output(process):
    """Ensure pldmtool runs without error and if it does fail, detect that and
    show the pldmtool exit status and it's stderr.

    A simpler implementation would just wait for the pldmtool exit status
    prior to attempting to decode it's stdout.  Instead, optimize for the
    no error case and allow the json decoder to consume pldmtool stdout as
    soon as it is available (in parallel).  This results in the following
    error scenarios:
        - pldmtool fails and the decoder fails
          Ignore the decoder fail and throw PLDMToolError.
        - pldmtool fails and the decoder doesn't fail
          Throw PLDMToolError.
        - pldmtool doesn't fail and the decoder does fail
          This is a pldmtool bug - re-throw the decoder error.

    Parameters:
        process: A Process object providing process control functions like
                 wait, and access functions such as reading stdout and
                 stderr.

    """

    status = 0
    try:
        data = json.load(process.stdout)
        # it's unlikely, but possible, that pldmtool failed but still wrote a
        # valid json document - so check for that.
        status = process.wait()
        if status == 0:
            return data
    except json.decoder.JSONDecodeError:
        # pldmtool wrote an invalid json document.  Check to see if it had
        # non-zero exit status.
        status = process.wait()
        if status == 0:
            # pldmtool didn't have non zero exit status, so it wrote an invalid
            # json document and the JSONDecodeError is the correct error.
            raise

    # pldmtool had a non-zero exit status, so throw an error for that, possibly
    # discarding a spurious JSONDecodeError exception.
    raise PLDMToolError(status, "".join(process.stderr))


def get_pdrs_one_at_a_time(executor):
    """Using pldmtool, generate (record handle, PDR) tuples for each record in
    the PDR repository.

    Parameters:
        executor: executor object for running pldmtool

    """

    command_fmt = "pldmtool platform getpdr -d {}"
    record_handle = 0
    while True:
        process = executor.exec_command(command_fmt.format(str(record_handle)))
        pdr = process_pldmtool_output(process)
        yield record_handle, pdr
        record_handle = pdr["nextRecordHandle"]
        if record_handle == 0:
            break


def get_all_pdrs_at_once(executor):
    """Using pldmtool, generate (record handle, PDR) tuples for each record in
    the PDR repository.  Use pldmtool platform getpdr --all.

    Parameters:
        executor: executor object for running pldmtool

    """

    process = executor.exec_command("pldmtool platform getpdr -a")
    all_pdrs = process_pldmtool_output(process)

    # Explicitly request record 0 to find out what the real first record is.
    process = executor.exec_command("pldmtool platform getpdr -d 0")
    pdr_0 = process_pldmtool_output(process)
    record_handle = pdr_0["recordHandle"]

    while True:
        for pdr in all_pdrs:
            if pdr["recordHandle"] == record_handle:
                yield record_handle, pdr
                record_handle = pdr["nextRecordHandle"]
                if record_handle == 0:
                    return
        raise RuntimeError(
            "Dangling reference to record {}".format(record_handle)
        )


def get_pdrs(executor):
    """Using pldmtool, generate (record handle, PDR) tuples for each record in
    the PDR repository.  Use pldmtool platform getpdr --all or fallback on
    getting them one at a time if pldmtool doesn't support the --all
    option.

    Parameters:
        executor: executor object for running pldmtool

    """
    try:
        for record_handle, pdr in get_all_pdrs_at_once(executor):
            yield record_handle, pdr
        return
    except PLDMToolError as e:
        # No support for the -a option
        if e.get_status() != 106:
            raise
    except json.decoder.JSONDecodeError as e:
        # Some versions of pldmtool don't print valid json documents with -a
        if e.msg != "Extra data":
            raise

    for record_handle, pdr in get_pdrs_one_at_a_time(executor):
        yield record_handle, pdr


def fetch_pdrs_from_bmc(executor):
    """This is the core function that would fire the getPDR pldmtool command
    and it then agreegates the data received from all the calls into the
    respective dictionaries based on the PDR Type.

    Parameters:
        executor: executor object for running pldmtool

    """

    entity_association_pdr = {}
    state_sensor_pdr = {}
    state_effecter_pdr = {}
    state_effecter_pdr = {}
    numeric_pdr = {}
    fru_record_set_pdr = {}
    tl_pdr = {}
    for handle_number, my_dic in get_pdrs(executor):
        if sys.stdout.isatty():
            sys.stdout.write(
                "Fetching PDR's from BMC : %8d\r" % (handle_number)
            )
            sys.stdout.flush()
        if my_dic["PDRType"] == "Entity Association PDR":
            entity_association_pdr[handle_number] = my_dic
        if my_dic["PDRType"] == "State Sensor PDR":
            state_sensor_pdr[handle_number] = my_dic
        if my_dic["PDRType"] == "State Effecter PDR":
            state_effecter_pdr[handle_number] = my_dic
        if my_dic["PDRType"] == "FRU Record Set PDR":
            fru_record_set_pdr[handle_number] = my_dic
        if my_dic["PDRType"] == "Terminus Locator PDR":
            tl_pdr[handle_number] = my_dic
        if my_dic["PDRType"] == "Numeric Effecter PDR":
            numeric_pdr[handle_number] = my_dic
    executor.close()

    total_pdrs = (
        len(entity_association_pdr.keys())
        + len(tl_pdr.keys())
        + len(state_effecter_pdr.keys())
        + len(numeric_pdr.keys())
        + len(state_sensor_pdr.keys())
        + len(fru_record_set_pdr.keys())
    )
    print("\nSuccessfully fetched " + str(total_pdrs) + " PDR's")
    print("Number of FRU Record PDR's : ", len(fru_record_set_pdr.keys()))
    print("Number of TerminusLocator PDR's : ", len(tl_pdr.keys()))
    print("Number of State Sensor PDR's : ", len(state_sensor_pdr.keys()))
    print("Number of State Effecter PDR's : ", len(state_effecter_pdr.keys()))
    print("Number of Numeric Effecter PDR's : ", len(numeric_pdr.keys()))
    print(
        "Number of Entity Association PDR's : ",
        len(entity_association_pdr.keys()),
    )
    return (
        entity_association_pdr,
        state_sensor_pdr,
        state_effecter_pdr,
        len(fru_record_set_pdr.keys()),
    )


def main():
    """Create a summary table capturing the information of all the PDR's
    from the BMC & also create a diagram that captures the entity
    association hierarchy."""

    parser = argparse.ArgumentParser(prog="pldm_visualise_pdrs.py")
    parser.add_argument("--bmc", type=str, help="BMC IPAddress/BMC Hostname")
    parser.add_argument("--user", type=str, help="BMC username")
    parser.add_argument("--password", type=str, help="BMC Password")
    parser.add_argument("--port", type=int, help="BMC SSH port", default=22)
    args = parser.parse_args()

    extra_cfg = {}
    if args.bmc:
        try:
            with open(os.path.expanduser("~/.ssh/config")) as f:
                ssh_config = paramiko.SSHConfig()
                ssh_config.parse(f)
                host_config = ssh_config.lookup(args.bmc)
                if host_config:
                    if "hostname" in host_config:
                        args.bmc = host_config["hostname"]
                    if "user" in host_config and args.user is None:
                        args.user = host_config["user"]
                    if "proxycommand" in host_config:
                        extra_cfg["sock"] = paramiko.ProxyCommand(
                            host_config["proxycommand"]
                        )
        except FileNotFoundError:
            pass

        executor = ParamikoExecutor(
            args.bmc, args.user, args.password, args.port, **extra_cfg
        )
    elif shutil.which("pldmtool"):
        executor = SubprocessExecutor()
    else:
        sys.exit(
            "Can't find any PDRs: specify remote BMC with --bmc or "
            "install pldmtool."
        )

    (
        association_pdr,
        state_sensor_pdr,
        state_effecter_pdr,
        counter,
    ) = fetch_pdrs_from_bmc(executor)
    draw_entity_associations(association_pdr, counter)
    prepare_summary_report(state_sensor_pdr, state_effecter_pdr)


if __name__ == "__main__":
    main()