wscript

#!/usr/bin/env python
import argparse
import os
import time
from os.path import join
from socket import gethostname
from waflib.extras.test_base import summary
from waflib.extras.symwaf2ic import get_toplevel_path
from waflib.extras.symwaf2ic import describe_project


def depends(dep):
    if getattr(dep.options, 'with_hxcomm_hostarq', True):
        dep('sctrltp')

    dep('rant')
    dep('hate')
    dep('hwdb')
    dep('code-format')
    dep('logger')
    dep('visions-slurm', branch='production')
    dep('flange')
    dep('lib-rcf')
    dep('bss-hw-params')

    def recurse(deps, name, alldeps):
        for subname in deps[name]:
            if subname not in alldeps:
                alldeps.add(subname)
                recurse(deps, subname, alldeps)
    alldeps = set()
    recurse(dep.dependencies, dep.path.abspath(), alldeps)

    global _dependencies
    _dependencies = set(
        ctx.replace(dep.toplevel.abspath() + "/", "").split("/")[0] for ctx  in alldeps)


def options(opt):
    opt.load('compiler_c')
    opt.load('compiler_cxx')
    opt.load('boost')
    opt.load("test_base")
    opt.load("gtest")
    opt.load("doxygen")

    opt.recurse('pyhxcomm')

    hopts = opt.add_option_group('hxcomm options')
    hopts.add_option("--hxcomm-loglevel",
                     choices=["trace", "debug", "info", "warning", "error", "fatal"],
                     default="info",
                     help="Maximal loglevel to compile in.")

    hopts.add_withoption('munge', default=False,
                       help='Toggle build of quiggeldy with munge-based '
                            'authentification support')

    hopts.add_withoption('quiggeldy', default=True,
                       help='Toggle build of quiggeldy-tool '
                            '(has extra dependencies).')

    hopts.add_withoption('hxcomm-python-bindings', default=True,
                        help='Toggle the generation and build of hxcomm python bindings')

    hopts.add_withoption('hxcomm-hostarq', default=True,
                       help='Toggle support for HostARQ-based connections')


def configure(conf):
    conf.load('compiler_c')
    conf.load('compiler_cxx')
    conf.load('boost')
    conf.check_boost(lib='program_options', uselib_store='BOOST4HXCOMMTOOLS')
    conf.load("test_base")
    conf.load("gtest")
    conf.check_cxx(mandatory=True, header_name='cereal/cereal.hpp')
    conf.load("doxygen")

    conf.env.build_with_hostarq = conf.options.with_hxcomm_hostarq

    conf.env.DEFINES_HXCOMM = [
        "HXCOMM_LOG_THRESHOLD=" +
        {'trace':   '0',
         'debug':   '1',
         'info':    '2',
         'warning': '3',
         'error':   '4',
         'fatal':   '5'}[conf.options.hxcomm_loglevel],
        'HXCOMM_REPO_STATE="' + "; ".join([
            describe_project(conf, dep).replace('"', '\\"') for dep in _dependencies] +
            [describe_project(conf, 'hxcomm').replace('"', '\\"') + '"'])
    ]
    if conf.env.build_with_hostarq:
        conf.env.DEFINES_HXCOMM.append('WITH_HXCOMM_HOSTARQ')

    conf.env.CXXFLAGS_HXCOMM = [
        '-fvisibility=hidden',
        '-fvisibility-inlines-hidden',
    ]
    conf.env.LINKFLAGS_HXCOMM = [
        '-fvisibility=hidden',
        '-fvisibility-inlines-hidden',
    ]

    conf.env.build_with_munge = conf.options.with_munge
    if conf.env.build_with_munge:
        conf.check_cxx(lib="munge",
                       header_name="munge.h",
                       msg="Checking for munge",
                       uselib_store="MUNGE")
        conf.env.DEFINES_MUNGE = ["USE_MUNGE_AUTH"]

    conf.env.build_with_quiggeldy = conf.options.with_quiggeldy
    if conf.env.build_with_quiggeldy:
        conf.check_boost(lib='program_options system',
                         uselib_store='BOOST4QUIGGELDY')
        conf.check_cxx(lib="pthread", uselib_store="PTHREAD")

    if getattr(conf.options, 'with_hxcomm_python_bindings', True):
        conf.recurse("pyhxcomm")

    conf.check_cfg(package='yaml-cpp',
                   args=['yaml-cpp >= 0.5.3', '--cflags', '--libs'],
                   uselib_store='YAMLCPP')


def build_loopbackconnection_test(bld):
    """
    Build Loopbackconnection tests for a variety of parameter combinations.
    This is done via defines so that each target's build time is reduced
    and parallel build can be executed.
    """
    loopbackconnection_obj_targets = []
    types = ['uint8_t', 'uint16_t', 'uint32_t', 'uint64_t']
    header_alignments = [1, 3, 8]
    for subword_type in types:
        for phyword_type in types:
            for header_alignment in header_alignments:
                target = 'hxcomm_loopbackconnection_obj_' + subword_type + \
                    '_' + phyword_type + '_' + str(header_alignment)
                bld(
                    target       = target,
                    features     = 'cxx',
                    source       = 'tests/sw/hxcomm/test-loopbackconnection.cpp',
                    defines      = ['SUBWORD_TYPE=' + subword_type,
                                    'PHYWORD_TYPE=' + phyword_type,
                                    'HEADER_ALIGNMENT=' + str(header_alignment)],
                    use          = ['hxcomm', 'hxcomm_tests_helper'],
                )
                loopbackconnection_obj_targets.append(target)
    return loopbackconnection_obj_targets


def build(bld):
    bld.env.BBS_HARDWARE_AVAILABLE = "SLURM_HWDB_YAML" in os.environ
    bld.env.DLSvx_SIM_AVAILABLE = "FLANGE_SIMULATION_RCF_PORT" in os.environ

    use_munge = ["MUNGE"] if bld.env.build_with_munge else []
    use_hostarq = ["arqstream_obj"] if bld.env.build_with_hostarq else []

    bld(target          = 'hxcomm_inc',
        export_includes = 'include'
    )

    hxcomm_excludes =  []
    if not bld.env.build_with_hostarq:
        hxcomm_excludes.append('src/hxcomm/**/arqconnection.cpp')

    bld.shlib(
        target       = 'hxcomm',
        source       = bld.path.ant_glob('src/hxcomm/**/*.cpp', excl=hxcomm_excludes),
        use          = ['hxcomm_inc',
                        'flange', 'rant', 'hate_inc', 'logger_obj',
                        'visions-slurm_inc', 'hwdb4cpp', 'YAMLCPP',
                        'bss-hw-params_inc', 'rcf-sf-only', 'rcf_extensions',
                       ] + use_munge + use_hostarq,
        uselib       = 'HXCOMM',
        install_path = '${PREFIX}/lib',
        export_defines=bld.env.DEFINES_HXCOMM,
    )

    if use_hostarq:
        bld(
            target       = 'hxcomm_example_arq',
            features     = 'cxx cxxprogram',
            source       = ['example/hxcomm_arq.cpp'],
            use          = ['hxcomm', 'BOOST4HXCOMMTOOLS'],
            install_path = '${PREFIX}/bin',
            uselib       = 'HXCOMM',
        )

    bld(
        target       = 'hxcomm_example_sim',
        features     = 'cxx cxxprogram',
        source       = ['example/hxcomm_sim.cpp'],
        use          = ['hxcomm', 'BOOST4HXCOMMTOOLS'],
        install_path = '${PREFIX}/bin',
        uselib       = 'HXCOMM',
    )

    bld(
        target       = 'hxcomm_example_loopback_throughput',
        features     = 'cxx cxxprogram',
        source       = ['example/hxcomm_loopback_throughput.cpp'],
        use          = ['hxcomm', 'BOOST4HXCOMMTOOLS'],
        install_path = '${PREFIX}/bin',
        uselib       = 'HXCOMM',
    )

    bld(
        target       = 'hxcomm_example_zeromock_throughput',
        features     = 'cxx cxxprogram',
        source       = ['example/hxcomm_zeromock_throughput.cpp'],
        use          = ['hxcomm', 'BOOST4HXCOMMTOOLS'],
        install_path = '${PREFIX}/bin',
        uselib       = 'HXCOMM',
    )

    bld(
        target          = 'hxcomm_tests_inc',
        export_includes = 'tests/common/include'
    )

    bld.shlib(
        target       = 'hxcomm_tests_helper',
        features     = 'cxx',
        source       = bld.path.ant_glob('tests/common/src/test-*.cpp'),
        use          = ['hxcomm', 'hxcomm_tests_inc', 'logger_obj'],
    )

    loopbackconnection_obj_targets = build_loopbackconnection_test(bld)

    bld(
        target       = 'hxcomm_swtest',
        features     = 'gtest cxx cxxprogram',
        source       = bld.path.ant_glob('tests/sw/hxcomm/test-*.cpp',
                           excl='tests/sw/hxcomm/test-*_throughput.cpp tests/sw/hxcomm/test-loopbackconnection.cpp'),
        use          = ['hxcomm', 'hxcomm_tests_helper', 'BOOST4HXCOMMTOOLS'] + loopbackconnection_obj_targets,
        test_timeout = 120,
        uselib       = 'HXCOMM',
        test_main    = 'tests/common/src/main.cpp',
    )

    bld(
        target       = 'hxcomm_throughputtest',
        features     = 'gtest cxx cxxprogram',
        source       = bld.path.ant_glob('tests/sw/hxcomm/test-*_throughput.cpp'),
        use          = ['hxcomm', 'hxcomm_tests_helper', 'BOOST4HXCOMMTOOLS'],
        test_main    = 'tests/common/src/main.cpp',
        cxxflags     = ['-O2'],
        # Throughput targets are only valid for HBPHosts and AMTHosts
        skip_run     = not (gethostname().startswith("HBPHost") or
                            gethostname().startswith("AMTHost")),
        uselib       = 'HXCOMM',
    )

    bld(
        target       = 'hxcomm_backendtest',
        features     = 'gtest cxx cxxprogram',
        source       = bld.path.ant_glob('tests/hw/hxcomm/test-*.cpp'),
        skip_run     = not (bld.env.BBS_HARDWARE_AVAILABLE or bld.env.DLSvx_SIM_AVAILABLE),
        test_main    = 'tests/common/src/main.cpp',
        use          = ['hxcomm', 'hxcomm_tests_helper', 'BOOST4HXCOMMTOOLS'],
        test_timeout = 120,
        uselib       = 'HXCOMM',
    )

    bld(target          = 'hxcomm_zeromocktests_inc',
        export_includes = 'tests/hw/hxcomm/connection_zeromock'
    )

    bld(
        target       = 'hxcomm_zeromocktests',
        features     = 'gtest cxx cxxprogram',
        source       = bld.path.ant_glob('tests/hw/hxcomm/test-*.cpp'),
        test_main    = 'tests/common/src/main.cpp',
        use          = ['hxcomm', 'hxcomm_tests_helper', 'hxcomm_zeromocktests_inc', 'BOOST4HXCOMMTOOLS'],
        uselib       = 'HXCOMM',
        test_timeout = 180,
        test_environ = dict(HXCOMM_ENABLE_ZERO_MOCK='1'),
    )

    if bld.env.build_with_quiggeldy:
        use_quiggeldy = ["hxcomm", "BOOST4QUIGGELDY", "PTHREAD"] + use_munge

        project_states = "\\n".join(sorted(map(lambda d: "* " + bld.describe_project(d), _dependencies)))
        quiggeldy_version_string = "* {}\\n{}".format(
            bld.describe_project("hxcomm"), project_states)

        bld(
            target = 'quiggeldy',
            features = 'cxx cxxprogram',
            source = [
                bld.path.find_node('src/tools/quiggeldy_binary.cpp'),
                ],
            use = use_quiggeldy,
            install_path = 'bin',
            defines = ["QUIGGELDY_VERSION_STRING=" + quiggeldy_version_string],
        )
        bld(
            target = 'quiggeldy_mock_client',
            features = 'cxx cxxprogram',
            source = [
                bld.path.find_node('src/tools/quiggeldy_mock_client.cpp'),
                ],
            use = use_quiggeldy,
            uselib       = 'HXCOMM',
            install_path = 'bin',
        )
        bld(
            target = 'viggeldy',
            features = 'cxx cxxprogram',
            source = [
                bld.path.find_node('src/tools/quiggeldy_query_version.cpp'),
                ],
            use = use_quiggeldy,
            uselib       = 'HXCOMM',
            install_path = '${PREFIX}/bin',
        )
        bld.symlink_as("${PREFIX}/bin/quiggeldy_query_version", "viggeldy",
                       name="quiggeldy_query_version", depends_on="viggeldy")
        bld(
            target = 'wriggeldy',
            features = 'cxx cxxprogram',
            source = [
                bld.path.find_node('src/tools/wrap_with_quiggeldy.cpp'),
                ],
            use = use_quiggeldy,
            depends_on = "quiggeldy",
            install_path = 'bin',
        )
        bld.symlink_as("${PREFIX}/bin/wrap_with_quiggeldy", "wriggeldy",
                       name="wrap_with_quiggeldy", depends_on="wriggeldy")

    if bld.env.DOXYGEN:
        bld(
            target = 'doxygen_hxcomm',
            features = 'doxygen',
            doxyfile = bld.root.make_node(join(get_toplevel_path(), "code-format", "doxyfile")),
            doxy_inputs = 'include/hxcomm',
            install_path = 'doc/hxcomm',
            pars = {
                "PROJECT_NAME": "\"HX Communication\"",
                "PREDEFINED": "SYMBOL_VISIBLE=",
                "INCLUDE_PATH": join(get_toplevel_path(), "hxcomm", "include"),
                "OUTPUT_DIRECTORY": join(get_toplevel_path(), "build", "hxcomm", "doc")
            },
        )

    if getattr(bld.options, 'with_hxcomm_python_bindings', True):
        bld.recurse('pyhxcomm')

    # Create test summary (to stdout and XML file)
    bld.add_post_fun(summary)