control/gen-fan-zone-defs.py

#!/usr/bin/env python

"""
This script reads in fan definition and zone definition YAML
files and generates a set of structures for use by the fan control code.
"""

import os
import sys
import yaml
from argparse import ArgumentParser
from mako.template import Template
from mako.lookup import TemplateLookup


def convertToMap(listOfDict):
    """
    Converts a list of dictionary entries to a std::map initialization list.
    """
    listOfDict = listOfDict.replace('\'', '\"')
    listOfDict = listOfDict.replace('[', '{')
    listOfDict = listOfDict.replace(']', '}')
    listOfDict = listOfDict.replace(':', ',')
    return listOfDict


def genEvent(event):
    """
    Generates the source code of an event and returns it as a string
    """
    e = "SetSpeedEvent{\n"

    e += "Group{\n"
    for group in event['groups']:
        for member in group['members']:
            e += "{\n"
            e += "\"" + member['object'] + "\",\n"
            e += "{\"" + member['interface'] + "\",\n"
            e += " \"" + member['property'] + "\"}\n"
        e += "},\n"
    e += "},\n"

    e += "std::vector<Action>{\n"
    for a in event['action']:
        if len(a['parameters']) != 0:
            e += "make_action(action::" + a['name'] + "(\n"
        else:
            e += "make_action(action::" + a['name'] + "\n"
        for i, p in enumerate(a['parameters']):
            if (i+1) != len(a['parameters']):
                e += p + ",\n"
            else:
                e += p + ")\n"
        e += "),\n"
    e += "},\n"

    e += "TimerConf{\n"
    e += "\t" + event['timer']['interval'] + ",\n"
    e += "\t" + event['timer']['type'] + "\n"
    e += "},\n"

    e += "std::vector<Signal>{\n"
    for s in event['signals']:
        e += "Signal{\n"
        e += "match::" + s['match'] + "(\n"
        for i, mp in enumerate(s['mparams']):
            if (i+1) != len(s['mparams']):
                e += "\"" + mp + "\",\n"
            else:
                e += "\"" + mp + "\"\n"
        e += "),\n"
        e += "make_handler(\n"
        if ('type' in s['sparams']) and (s['sparams']['type'] is not None):
            e += s['signal'] + "<" + s['sparams']['type'] + ">(\n"
        else:
            e += s['signal'] + "(\n"
        for sp in s['sparams']['params']:
            e += s['sparams'][sp] + ",\n"
        if ('type' in s['hparams']) and (s['hparams']['type'] is not None):
            e += ("handler::" + s['handler'] +
                  "<" + s['hparams']['type'] + ">(\n")
        else:
            e += "handler::" + s['handler'] + "(\n)"
        for i, hp in enumerate(s['hparams']['params']):
            if (i+1) != len(s['hparams']['params']):
                e += s['hparams'][hp] + ",\n"
            else:
                e += s['hparams'][hp] + "\n"
        e += "))\n"
        e += ")\n"
    e += "},\n"
    e += "}\n"

    e += "}"

    return e


def getGroups(zNum, zCond, edata, events):
    """
    Extract and construct the groups for the given event.
    """
    groups = []
    for eGroups in edata['groups']:
        if ('zone_conditions' in eGroups) and \
           (eGroups['zone_conditions'] is not None):
            # Zone conditions are optional in the events yaml but skip
            # if this event's condition is not in this zone's conditions
            if all('name' in z and z['name'] is not None and
                   not any(c['name'] == z['name'] for c in zCond)
                   for z in eGroups['zone_conditions']):
                continue

            # Zone numbers are optional in the events yaml but skip if this
            # zone's zone number is not in the event's zone numbers
            if all('zones' in z and z['zones'] is not None and
                   zNum not in z['zones']
                   for z in eGroups['zone_conditions']):
                continue
        eGroup = next(g for g in events['groups']
                      if g['name'] == eGroups['name'])

        group = {}
        members = []
        group['name'] = eGroup['name']
        for m in eGroup['members']:
            member = {}
            member['path'] = eGroup['type']
            member['object'] = (eGroup['type'] + m)
            member['interface'] = eGroups['interface']
            member['property'] = eGroups['property']['name']
            member['type'] = eGroups['property']['type']
            # Add expected group member's property value if given
            if ('value' in eGroups['property']) and \
               (eGroups['property']['value'] is not None):
                    if isinstance(eGroups['property']['value'], str) or \
                            "string" in str(member['type']).lower():
                        member['value'] = (
                            "\"" + eGroups['property']['value'] + "\"")
                    else:
                        member['value'] = eGroups['property']['value']
            members.append(member)
        group['members'] = members
        groups.append(group)
    return groups


def getActions(zNum, zCond, edata, actions, events):
    """
    Extracts and constructs the make_action function call for
    all the actions within the given event.
    """
    action = []
    for eActions in actions['actions']:
        actions = {}
        eAction = next(a for a in events['actions']
                       if a['name'] == eActions['name'])
        actions['name'] = eAction['name']
        params = []
        if ('parameters' in eAction) and \
           (eAction['parameters'] is not None):
            for p in eAction['parameters']:
                param = "static_cast<"
                if type(eActions[p]) is not dict:
                    if p == 'actions':
                        param = "std::vector<Action>{"
                        pActs = getActions(zNum,
                                           zCond,
                                           edata,
                                           eActions,
                                           events)
                        for a in pActs:
                            if (len(a['parameters']) != 0):
                                param += (
                                    "make_action(action::" +
                                    a['name'] +
                                    "(\n")
                                for i, ap in enumerate(a['parameters']):
                                    if (i+1) != len(a['parameters']):
                                        param += (ap + ",")
                                    else:
                                        param += (ap + ")")
                            else:
                                param += ("make_action(action::" + a['name'])
                            param += "),"
                        param += "}"
                    elif p == 'defevents' or p == 'altevents':
                        param = "std::vector<SetSpeedEvent>{\n"
                        for i, e in enumerate(eActions[p]):
                            aEvent = getEvent(zNum, zCond, e, events)
                            if not aEvent:
                                continue
                            if (i+1) != len(eActions[p]):
                                param += genEvent(aEvent) + ",\n"
                            else:
                                param += genEvent(aEvent) + "\n"
                        param += "\t}"
                    elif p == 'property':
                        if isinstance(eActions[p], str) or \
                           "string" in str(eActions[p]['type']).lower():
                            param += (
                                str(eActions[p]['type']).lower() +
                                ">(\"" + str(eActions[p]) + "\")")
                        else:
                            param += (
                                str(eActions[p]['type']).lower() +
                                ">(" + str(eActions[p]['value']).lower() + ")")
                    else:
                        # Default type to 'size_t' when not given
                        param += ("size_t>(" + str(eActions[p]).lower() + ")")
                else:
                    if p == 'timer':
                        param = (
                            "TimerConf{static_cast<std::chrono::seconds>(" +
                            str(eActions[p]['delay']) + "), " +
                            "TimerType::" +
                            str(eActions[p]['type']) + "}")
                    else:
                        param += (str(eActions[p]['type']).lower() + ">(")
                        if p != 'map':
                            if isinstance(eActions[p]['value'], str) or \
                               "string" in str(eActions[p]['type']).lower():
                                param += \
                                    "\"" + str(eActions[p]['value']) + "\")"
                            else:
                                param += \
                                    str(eActions[p]['value']).lower() + ")"
                        else:
                            param += (
                                str(eActions[p]['type']).lower() +
                                convertToMap(str(eActions[p]['value'])) + ")")
                params.append(param)
        actions['parameters'] = params
        action.append(actions)
    return action


def getEvent(zone_num, zone_conditions, e, events_data):
    """
    Parses the sections of an event and populates the properties
    that construct an event within the generated source.
    """
    event = {}

    # Add set speed event groups
    grps = getGroups(zone_num, zone_conditions, e, events_data)
    if not grps:
        return
    event['groups'] = grps

    # Add optional set speed actions and function parameters
    event['action'] = []
    if ('actions' in e) and \
       (e['actions'] is not None):
        event['action'] = getActions(zone_num,
                                     zone_conditions,
                                     e,
                                     e,
                                     events_data)

    # Add signal handlers
    signals = []
    for group in event['groups']:
        for member in group['members']:
            for eMatches in e['matches']:
                signal = {}
                eMatch = next(m for m in events_data['matches']
                              if m['name'] == eMatches['name'])
                signal['match'] = eMatch['name']
                params = []
                if ('parameters' in eMatch) and \
                   (eMatch['parameters'] is not None):
                    for p in eMatch['parameters']:
                        params.append(member[str(p)])
                signal['mparams'] = params
                if ('parameters' in eMatch['signal']) and \
                   (eMatch['signal']['parameters'] is not None):
                    eSignal = eMatch['signal']
                else:
                    eSignal = next(s for s in events_data['signals']
                                   if s['name'] == eMatch['signal'])
                signal['signal'] = eSignal['name']
                sparams = {}
                if ('parameters' in eSignal) and \
                   (eSignal['parameters'] is not None):
                    splist = []
                    for p in eSignal['parameters']:
                        sp = str(p)
                        if (sp != 'type'):
                            splist.append(sp)
                            if (sp != 'group'):
                                sparams[sp] = "\"" + member[sp] + "\""
                            else:
                                sparams[sp] = "Group{\n"
                                for m in group['members']:
                                    sparams[sp] += (
                                        "{\n" +
                                        "\"" + str(m['object']) + "\",\n" +
                                        "{\"" + str(m['interface']) + "\"," +
                                        "\"" + str(m['property']) + "\"}\n" +
                                        "},\n")
                                sparams[sp] += "}"
                        else:
                            sparams[sp] = member[sp]
                    sparams['params'] = splist
                signal['sparams'] = sparams
                # Add signal handler
                eHandler = next(h for h in events_data['handlers']
                                if h['name'] == eSignal['handler'])
                signal['handler'] = eHandler['name']
                hparams = {}
                if ('parameters' in eHandler) and \
                   (eHandler['parameters'] is not None):
                    hplist = []
                    for p in eHandler['parameters']:
                        hp = str(p)
                        if (hp != 'type'):
                            hplist.append(hp)
                            if (hp != 'group'):
                                hparams[hp] = "\"" + member[hp] + "\""
                            else:
                                hparams[hp] = "Group{\n"
                                for m in group['members']:
                                    hparams[hp] += (
                                        "{\n" +
                                        "\"" + str(m['object']) + "\",\n" +
                                        "{\"" + str(m['interface']) + "\"," +
                                        "\"" + str(m['property']) + "\"}\n" +
                                        "},\n")
                                hparams[hp] += "}"
                        else:
                            hparams[hp] = member[hp]
                    hparams['params'] = hplist
                signal['hparams'] = hparams
                signals.append(signal)
    event['signals'] = signals

    # Add optional action call timer
    timer = {}
    interval = "static_cast<std::chrono::seconds>"
    if ('timer' in e) and \
       (e['timer'] is not None):
        timer['interval'] = (interval +
                             "(" +
                             str(e['timer']['interval']) +
                             ")")
    else:
        timer['interval'] = (interval +
                             "(" + str(0) + ")")
    timer['type'] = "TimerType::repeating"
    event['timer'] = timer

    return event


def addPrecondition(zNum, zCond, event, events_data):
    """
    Parses the precondition section of an event and populates the necessary
    structures to generate a precondition for a set speed event.
    """
    precond = {}
    # Add set speed event precondition group
    grps = getGroups(zNum, zCond, event['precondition'], events_data)
    if not grps:
        return
    precond['pcgrps'] = grps

    # Add set speed event precondition actions
    pc = []
    pcs = {}
    pcs['name'] = event['precondition']['name']
    epc = next(p for p in events_data['preconditions']
               if p['name'] == event['precondition']['name'])
    params = []
    for p in epc['parameters']:
        param = {}
        if p == 'groups':
            param['type'] = "std::vector<PrecondGroup>"
            param['open'] = "{"
            param['close'] = "}"
            values = []
            for group in precond['pcgrps']:
                for pcgrp in group['members']:
                    value = {}
                    value['value'] = (
                        "PrecondGroup{\"" +
                        str(pcgrp['object']) + "\",\"" +
                        str(pcgrp['interface']) + "\",\"" +
                        str(pcgrp['property']) + "\"," +
                        "static_cast<" +
                        str(pcgrp['type']).lower() + ">")
                    if isinstance(pcgrp['value'], str) or \
                       "string" in str(pcgrp['type']).lower():
                        value['value'] += ("(" + str(pcgrp['value']) + ")}")
                    else:
                        value['value'] += \
                            ("(" + str(pcgrp['value']).lower() + ")}")
                    values.append(value)
            param['values'] = values
        params.append(param)
    pcs['params'] = params
    pc.append(pcs)
    precond['pcact'] = pc

    pcevents = []
    for pce in event['precondition']['events']:
        pcevent = getEvent(zNum, zCond, pce, events_data)
        if not pcevent:
            continue
        pcevents.append(pcevent)
    precond['pcevts'] = pcevents

    # Add precondition signal handlers
    signals = []
    for group in precond['pcgrps']:
        for member in group['members']:
            for eMatches in event['precondition']['matches']:
                signal = {}
                eMatch = next(m for m in events_data['matches']
                              if m['name'] == eMatches['name'])
                signal['match'] = eMatch['name']
                params = []
                if ('parameters' in eMatch) and \
                   (eMatch['parameters'] is not None):
                    for p in eMatch['parameters']:
                        params.append(member[str(p)])
                signal['mparams'] = params
                if ('parameters' in eMatch['signal']) and \
                   (eMatch['signal']['parameters'] is not None):
                    eSignal = eMatch['signal']
                else:
                    eSignal = next(s for s in events_data['signals']
                                   if s['name'] == eMatch['signal'])
                signal['signal'] = eSignal['name']
                sparams = {}
                if ('parameters' in eSignal) and \
                   (eSignal['parameters'] is not None):
                    splist = []
                    for p in eSignal['parameters']:
                        sp = str(p)
                        if (sp != 'type'):
                            splist.append(sp)
                            if (sp != 'group'):
                                sparams[sp] = "\"" + member[sp] + "\""
                            else:
                                sparams[sp] = "Group{\n"
                                for m in group:
                                    sparams[sp] += (
                                        "{\n" +
                                        "\"" + str(m['object']) + "\",\n" +
                                        "{\"" + str(m['interface']) + "\"," +
                                        "\"" + str(m['property']) + "\"}\n" +
                                        "},\n")
                                sparams[sp] += "}"
                        else:
                            sparams[sp] = member[sp]
                    sparams['params'] = splist
                signal['sparams'] = sparams
                # Add signal handler
                eHandler = next(h for h in events_data['handlers']
                                if h['name'] == eSignal['handler'])
                signal['handler'] = eHandler['name']
                hparams = {}
                if ('parameters' in eHandler) and \
                   (eHandler['parameters'] is not None):
                    hplist = []
                    for p in eHandler['parameters']:
                        hp = str(p)
                        if (hp != 'type'):
                            hplist.append(hp)
                            if (hp != 'group'):
                                hparams[hp] = "\"" + member[hp] + "\""
                            else:
                                hparams[hp] = "Group{\n"
                                for m in group:
                                    hparams[hp] += (
                                        "{\n" +
                                        "\"" + str(m['object']) + "\",\n" +
                                        "{\"" + str(m['interface']) + "\"," +
                                        "\"" + str(m['property']) + "\"}\n" +
                                        "},\n")
                                hparams[hp] += "}"
                        else:
                            hparams[hp] = member[hp]
                    hparams['params'] = hplist
                signal['hparams'] = hparams
                signals.append(signal)
    precond['pcsigs'] = signals

    # Add optional action call timer
    timer = {}
    interval = "static_cast<std::chrono::seconds>"
    if ('timer' in event['precondition']) and \
       (event['precondition']['timer'] is not None):
        timer['interval'] = (interval +
                             "(" +
                             str(event['precondition']['timer']['interval']) +
                             ")")
    else:
        timer['interval'] = (interval +
                             "(" + str(0) + ")")
    timer['type'] = "TimerType::repeating"
    precond['pctime'] = timer

    return precond


def getEventsInZone(zone_num, zone_conditions, events_data):
    """
    Constructs the event entries defined for each zone using the events yaml
    provided.
    """
    events = []

    if 'events' in events_data:
        for e in events_data['events']:
            event = {}
            # Add precondition if given
            if ('precondition' in e) and \
               (e['precondition'] is not None):
                event['pc'] = addPrecondition(zone_num,
                                              zone_conditions,
                                              e,
                                              events_data)
            else:
                event = getEvent(zone_num, zone_conditions, e, events_data)
                if not event:
                    continue
            events.append(event)

    return events


def getFansInZone(zone_num, profiles, fan_data):
    """
    Parses the fan definition YAML files to find the fans
    that match both the zone passed in and one of the
    cooling profiles.
    """

    fans = []

    for f in fan_data['fans']:

        if zone_num != f['cooling_zone']:
            continue

        # 'cooling_profile' is optional (use 'all' instead)
        if f.get('cooling_profile') is None:
            profile = "all"
        else:
            profile = f['cooling_profile']

        if profile not in profiles:
            continue

        fan = {}
        fan['name'] = f['inventory']
        fan['sensors'] = f['sensors']
        fan['target_interface'] = f.get(
            'target_interface',
            'xyz.openbmc_project.Control.FanSpeed')
        fans.append(fan)

    return fans


def getConditionInZoneConditions(zone_condition, zone_conditions_data):
    """
    Parses the zone conditions definition YAML files to find the condition
    that match both the zone condition passed in.
    """

    condition = {}

    for c in zone_conditions_data['conditions']:

        if zone_condition != c['name']:
            continue
        condition['type'] = c['type']
        properties = []
        for p in c['properties']:
            property = {}
            property['property'] = p['property']
            property['interface'] = p['interface']
            property['path'] = p['path']
            property['type'] = p['type'].lower()
            property['value'] = str(p['value']).lower()
            properties.append(property)
        condition['properties'] = properties

        return condition


def buildZoneData(zone_data, fan_data, events_data, zone_conditions_data):
    """
    Combines the zone definition YAML and fan
    definition YAML to create a data structure defining
    the fan cooling zones.
    """

    zone_groups = []

    for group in zone_data:
        conditions = []
        # zone conditions are optional
        if 'zone_conditions' in group and group['zone_conditions'] is not None:
            for c in group['zone_conditions']:

                if not zone_conditions_data:
                    sys.exit("No zone_conditions YAML file but " +
                             "zone_conditions used in zone YAML")

                condition = getConditionInZoneConditions(c['name'],
                                                         zone_conditions_data)

                if not condition:
                    sys.exit("Missing zone condition " + c['name'])

                conditions.append(condition)

        zone_group = {}
        zone_group['conditions'] = conditions

        zones = []
        for z in group['zones']:
            zone = {}

            # 'zone' is required
            if ('zone' not in z) or (z['zone'] is None):
                sys.exit("Missing fan zone number in " + zone_yaml)

            zone['num'] = z['zone']

            zone['full_speed'] = z['full_speed']

            zone['default_floor'] = z['default_floor']

            # 'increase_delay' is optional (use 0 by default)
            key = 'increase_delay'
            zone[key] = z.setdefault(key, 0)

            # 'decrease_interval' is optional (use 0 by default)
            key = 'decrease_interval'
            zone[key] = z.setdefault(key, 0)

            # 'cooling_profiles' is optional (use 'all' instead)
            if ('cooling_profiles' not in z) or \
                    (z['cooling_profiles'] is None):
                profiles = ["all"]
            else:
                profiles = z['cooling_profiles']

            fans = getFansInZone(z['zone'], profiles, fan_data)
            events = getEventsInZone(z['zone'], group['zone_conditions'],
                                     events_data)

            if len(fans) == 0:
                sys.exit("Didn't find any fans in zone " + str(zone['num']))

            zone['fans'] = fans
            zone['events'] = events
            zones.append(zone)

        zone_group['zones'] = zones
        zone_groups.append(zone_group)

    return zone_groups


if __name__ == '__main__':
    parser = ArgumentParser(
        description="Phosphor fan zone definition parser")

    parser.add_argument('-z', '--zone_yaml', dest='zone_yaml',
                        default="example/zones.yaml",
                        help='fan zone definitional yaml')
    parser.add_argument('-f', '--fan_yaml', dest='fan_yaml',
                        default="example/fans.yaml",
                        help='fan definitional yaml')
    parser.add_argument('-e', '--events_yaml', dest='events_yaml',
                        help='events to set speeds yaml')
    parser.add_argument('-c', '--zone_conditions_yaml',
                        dest='zone_conditions_yaml',
                        help='conditions to determine zone yaml')
    parser.add_argument('-o', '--output_dir', dest='output_dir',
                        default=".",
                        help='output directory')
    args = parser.parse_args()

    if not args.zone_yaml or not args.fan_yaml:
        parser.print_usage()
        sys.exit(1)

    with open(args.zone_yaml, 'r') as zone_input:
        zone_data = yaml.safe_load(zone_input) or {}

    with open(args.fan_yaml, 'r') as fan_input:
        fan_data = yaml.safe_load(fan_input) or {}

    events_data = {}
    if args.events_yaml:
        with open(args.events_yaml, 'r') as events_input:
            events_data = yaml.safe_load(events_input) or {}

    zone_conditions_data = {}
    if args.zone_conditions_yaml:
        with open(args.zone_conditions_yaml, 'r') as zone_conditions_input:
            zone_conditions_data = yaml.safe_load(zone_conditions_input) or {}

    zone_config = buildZoneData(zone_data.get('zone_configuration', {}),
                                fan_data, events_data, zone_conditions_data)

    manager_config = zone_data.get('manager_configuration', {})

    if manager_config.get('power_on_delay') is None:
        manager_config['power_on_delay'] = 0

    tmpls_dir = os.path.join(
        os.path.dirname(os.path.realpath(__file__)),
        "templates")
    output_file = os.path.join(args.output_dir, "fan_zone_defs.cpp")
    if sys.version_info < (3, 0):
        lkup = TemplateLookup(
            directories=tmpls_dir.split(),
            disable_unicode=True)
    else:
        lkup = TemplateLookup(
            directories=tmpls_dir.split())
    tmpl = lkup.get_template('fan_zone_defs.mako.cpp')
    with open(output_file, 'w') as output:
        output.write(tmpl.render(zones=zone_config,
                                 mgr_data=manager_config))