tools/elog-gen.py

#!/usr/bin/env python3

r"""
This script will parse error log yaml file(s) and generate
a header file which will then be used by the error logging client and
server to collect and validate the error information generated by the
openbmc software components.

This code uses a mako template to provide the basic template of the header
file we're going to generate.  We then call it with information from the
yaml to generate the header file.
"""

from mako.template import Template
from optparse import OptionParser
import yaml
import sys
import os


def order_inherited_errors(i_errors, i_parents):
    # the ordered list of errors
    errors = list()
    has_inheritance = False
    for error in i_errors:
        if i_parents[error] is not None:
            has_inheritance = True
            break

    if has_inheritance:
        # Order the error codes list such that an error is never placed
        # before it's parent. This way generated code can ensure parent
        # definitions precede child error definitions.
        while len(errors) < len(i_errors):
            for error in i_errors:
                if error in errors:
                    # already ordererd
                    continue
                if (not i_parents[error]) or (i_parents[error] in errors):
                    # parent present, or has no parent, either way this error
                    # can be added
                    errors.append(error)
    else:
        # no inherited errors
        errors = i_errors

    return errors


def check_error_inheritance(i_errors, i_parents):
    for error in i_errors:
        if i_parents[error] and (i_parents[error] not in i_errors):
            print(
                error
                + " inherits "
                + i_parents[error]
                + " but the latter is not defined"
            )
            return False
    return True


# Return the yaml files with their directory structure plus the file name
# without the yaml extension, which will be used to set the namespaces.
# Ex: file xyz/openbmc_project/Error/Callout/Device.errors.yaml
# will have namespce xyz/openbmc_project/Error/Callout/Device
def get_error_yaml_files(i_yaml_dir, i_test_dir):
    yaml_files = dict()
    if i_yaml_dir != "None":
        for root, dirs, files in os.walk(i_yaml_dir):
            for files in [
                file for file in files if file.endswith(".errors.yaml")
            ]:
                splitdir = root.split(i_yaml_dir)[1] + "/" + files[:-12]
                if splitdir.startswith("/"):
                    splitdir = splitdir[1:]
                yaml_files[(os.path.join(root, files))] = splitdir
    for root, dirs, files in os.walk(i_test_dir):
        for files in [file for file in files if file.endswith(".errors.yaml")]:
            splitdir = root.split(i_test_dir)[1] + "/" + files[:-12]
            yaml_files[(os.path.join(root, files))] = splitdir
    return yaml_files


def get_meta_yaml_file(i_error_yaml_file):
    # the meta data will be defined in file name where we replace
    # <Interface>.errors.yaml with <Interface>.metadata.yaml
    meta_yaml = i_error_yaml_file.replace("errors", "metadata")
    return meta_yaml


def get_cpp_type(i_type):
    typeMap = {
        "boolean": "bool",
        "int8": "int8_t",
        "int16": "int16_t",
        "int32": "int32_t",
        "int64": "int64_t",
        "uint8": "uint8_t",
        "uint16": "uint16_t",
        "uint32": "uint32_t",
        "uint64": "uint64_t",
        "double": "double",
        # const char* aids usage of constexpr
        "string": "const char*",
    }

    return typeMap[i_type]


def gen_elog_hpp(
    i_yaml_dir, i_test_dir, i_output_hpp, i_template_dir, i_elog_mako
):
    r"""
    Read  yaml file(s) under input yaml dir, grab the relevant data and call
    the mako template to generate the output header file.

    Description of arguments:
    i_yaml_dir                  directory containing base error yaml files
    i_test_dir                  directory containing test error yaml files
    i_output_hpp                name of the to be generated output hpp
    i_template_dir              directory containing error mako templates
    i_elog_mako                 error mako template to render
    """

    # Input parameters to mako template
    errors = list()  # Main error codes
    error_msg = dict()  # Error msg that corresponds to error code
    error_lvl = dict()  # Error code log level (debug, info, error, ...)
    meta = dict()  # The meta data names associated (ERRNO, FILE_NAME, ...)
    meta_data = dict()  # The meta data info (type, format)
    parents = dict()
    metadata_process = dict()  # metadata that have the 'process' keyword set

    # Verify the input mako file
    template_path = os.path.join(i_template_dir, i_elog_mako)
    if not (os.path.isfile(template_path)):
        print("Cannot find input template file " + template_path)
        exit(1)
    template_path = os.path.abspath(template_path)

    error_yamls = get_error_yaml_files(i_yaml_dir, i_test_dir)

    for error_yaml in error_yamls:
        # Verify the error yaml file
        if not (os.path.isfile(error_yaml)):
            print("Cannot find input yaml file " + error_yaml)
            exit(1)

        # Verify the metadata yaml file
        meta_yaml = get_meta_yaml_file(error_yaml)

        get_elog_data(
            error_yaml,
            meta_yaml,
            error_yamls[error_yaml],
            # Last arg is a tuple
            (
                errors,
                error_msg,
                error_lvl,
                meta,
                meta_data,
                parents,
                metadata_process,
            ),
        )

    if not check_error_inheritance(errors, parents):
        print("Error - failed to validate error inheritance")
        exit(1)

    errors = order_inherited_errors(errors, parents)

    # Load the mako template and call it with the required data
    yaml_dir = i_yaml_dir.strip("./")
    yaml_dir = yaml_dir.strip("../")
    template = Template(filename=template_path)
    f = open(i_output_hpp, "w")
    f.write(
        template.render(
            errors=errors,
            error_msg=error_msg,
            error_lvl=error_lvl,
            meta=meta,
            meta_data=meta_data,
            parents=parents,
            metadata_process=metadata_process,
        )
    )
    f.close()


def get_elog_data(i_elog_yaml, i_elog_meta_yaml, i_namespace, o_elog_data):
    r"""
    Parse the error and metadata yaml files in order to pull out
    error metadata.

    Use default values if metadata yaml file is not found.

    Description of arguments:
    i_elog_yaml                 error yaml file
    i_elog_meta_yaml            metadata yaml file
    i_namespace                 namespace data
    o_elog_data                 error metadata
    """
    (
        errors,
        error_msg,
        error_lvl,
        meta,
        meta_data,
        parents,
        metadata_process,
    ) = o_elog_data
    ifile = yaml.safe_load(open(i_elog_yaml))

    # for all the errors in error yaml file
    for error in ifile:
        if "name" not in error:
            print(
                "Error - Did not find name in entry %s in file %s "
                % (str(error), i_elog_yaml)
            )
            exit(1)
        fullname = i_namespace.replace("/", ".") + (".") + error["name"]
        errors.append(fullname)

        if "description" in error:
            error_msg[fullname] = error["description"].strip()

        # set default values
        error_lvl[fullname] = "ERR"
        parents[fullname] = None

        # check if meta data yaml file is found
        if not os.path.isfile(i_elog_meta_yaml):
            continue
        mfile = yaml.safe_load(open(i_elog_meta_yaml))

        # Find the meta data entry
        match = None
        for meta_entry in mfile:
            if meta_entry["name"] == error["name"]:
                match = meta_entry
                break

        if match is None:
            continue

        error_lvl[fullname] = match.get("level", "ERR")

        # Get 0th inherited error (current support - single inheritance)
        if "inherits" in match:
            parents[fullname] = match["inherits"][0]

        # Put all errors in meta[] even the meta is empty
        # so that child errors could inherits such error without meta
        tmp_meta = []
        if "meta" in match:
            # grab all the meta data fields and info
            for i in match["meta"]:
                str_short = i["str"].split("=")[0]
                tmp_meta.append(str_short)
                meta_data[str_short] = {}
                meta_data[str_short]["str"] = i["str"]
                meta_data[str_short]["str_short"] = str_short
                meta_data[str_short]["type"] = get_cpp_type(i["type"])
                if ("process" in i) and (i["process"] is True):
                    metadata_process[str_short] = fullname + "." + str_short
        meta[fullname] = tmp_meta

    # Debug
    # for i in errors:
    #   print "ERROR: " + errors[i]
    #   print " MSG:  " + error_msg[errors[i]]
    #   print " LVL:  " + error_lvl[errors[i]]
    #   print " META: "
    #   print meta[i]


def main(i_args):
    parser = OptionParser()

    parser.add_option(
        "-m",
        "--mako",
        dest="elog_mako",
        default="elog-gen-template.mako.hpp",
        help="input mako template file to use",
    )

    parser.add_option(
        "-o",
        "--output",
        dest="output_hpp",
        default="elog-errors.hpp",
        help="output hpp to generate, elog-errors.hpp default",
    )

    parser.add_option(
        "-y",
        "--yamldir",
        dest="yamldir",
        default="None",
        help="Base directory of yaml files to process",
    )

    parser.add_option(
        "-u",
        "--testdir",
        dest="testdir",
        default="./tools/example/",
        help="Unit test directory of yaml files to process",
    )

    parser.add_option(
        "-t",
        "--templatedir",
        dest="templatedir",
        default="phosphor-logging/templates/",
        help="Base directory of files to process",
    )

    (options, args) = parser.parse_args(i_args)

    gen_elog_hpp(
        options.yamldir,
        options.testdir,
        options.output_hpp,
        options.templatedir,
        options.elog_mako,
    )


# Only run if it's a script
if __name__ == "__main__":
    main(sys.argv[1:])