1#!/usr/bin/env python
2
3"""
4This script determines the given package's openbmc dependencies from its
5configure.ac file where it downloads, configures, builds, and installs each of
6these dependencies. Then the given package is configured, built, and installed
7prior to executing its unit tests.
8"""
9
10from git import Repo
11from urlparse import urljoin
12from subprocess import check_call, call, CalledProcessError
13import os
14import sys
15import argparse
16import multiprocessing
17import re
18import sets
19import subprocess
20import shutil
21import platform
22
23
24class DepTree():
25    """
26    Represents package dependency tree, where each node is a DepTree with a
27    name and DepTree children.
28    """
29
30    def __init__(self, name):
31        """
32        Create new DepTree.
33
34        Parameter descriptions:
35        name               Name of new tree node.
36        """
37        self.name = name
38        self.children = list()
39
40    def AddChild(self, name):
41        """
42        Add new child node to current node.
43
44        Parameter descriptions:
45        name               Name of new child
46        """
47        new_child = DepTree(name)
48        self.children.append(new_child)
49        return new_child
50
51    def AddChildNode(self, node):
52        """
53        Add existing child node to current node.
54
55        Parameter descriptions:
56        node               Tree node to add
57        """
58        self.children.append(node)
59
60    def RemoveChild(self, name):
61        """
62        Remove child node.
63
64        Parameter descriptions:
65        name               Name of child to remove
66        """
67        for child in self.children:
68            if child.name == name:
69                self.children.remove(child)
70                return
71
72    def GetNode(self, name):
73        """
74        Return node with matching name. Return None if not found.
75
76        Parameter descriptions:
77        name               Name of node to return
78        """
79        if self.name == name:
80            return self
81        for child in self.children:
82            node = child.GetNode(name)
83            if node:
84                return node
85        return None
86
87    def GetParentNode(self, name, parent_node=None):
88        """
89        Return parent of node with matching name. Return none if not found.
90
91        Parameter descriptions:
92        name               Name of node to get parent of
93        parent_node        Parent of current node
94        """
95        if self.name == name:
96            return parent_node
97        for child in self.children:
98            found_node = child.GetParentNode(name, self)
99            if found_node:
100                return found_node
101        return None
102
103    def GetPath(self, name, path=None):
104        """
105        Return list of node names from head to matching name.
106        Return None if not found.
107
108        Parameter descriptions:
109        name               Name of node
110        path               List of node names from head to current node
111        """
112        if not path:
113            path = []
114        if self.name == name:
115            path.append(self.name)
116            return path
117        for child in self.children:
118            match = child.GetPath(name, path + [self.name])
119            if match:
120                return match
121        return None
122
123    def GetPathRegex(self, name, regex_str, path=None):
124        """
125        Return list of node paths that end in name, or match regex_str.
126        Return empty list if not found.
127
128        Parameter descriptions:
129        name               Name of node to search for
130        regex_str          Regex string to match node names
131        path               Path of node names from head to current node
132        """
133        new_paths = []
134        if not path:
135            path = []
136        match = re.match(regex_str, self.name)
137        if (self.name == name) or (match):
138            new_paths.append(path + [self.name])
139        for child in self.children:
140            return_paths = None
141            full_path = path + [self.name]
142            return_paths = child.GetPathRegex(name, regex_str, full_path)
143            for i in return_paths:
144                new_paths.append(i)
145        return new_paths
146
147    def MoveNode(self, from_name, to_name):
148        """
149        Mode existing from_name node to become child of to_name node.
150
151        Parameter descriptions:
152        from_name          Name of node to make a child of to_name
153        to_name            Name of node to make parent of from_name
154        """
155        parent_from_node = self.GetParentNode(from_name)
156        from_node = self.GetNode(from_name)
157        parent_from_node.RemoveChild(from_name)
158        to_node = self.GetNode(to_name)
159        to_node.AddChildNode(from_node)
160
161    def ReorderDeps(self, name, regex_str):
162        """
163        Reorder dependency tree.  If tree contains nodes with names that
164        match 'name' and 'regex_str', move 'regex_str' nodes that are
165        to the right of 'name' node, so that they become children of the
166        'name' node.
167
168        Parameter descriptions:
169        name               Name of node to look for
170        regex_str          Regex string to match names to
171        """
172        name_path = self.GetPath(name)
173        if not name_path:
174            return
175        paths = self.GetPathRegex(name, regex_str)
176        is_name_in_paths = False
177        name_index = 0
178        for i in range(len(paths)):
179            path = paths[i]
180            if path[-1] == name:
181                is_name_in_paths = True
182                name_index = i
183                break
184        if not is_name_in_paths:
185            return
186        for i in range(name_index + 1, len(paths)):
187            path = paths[i]
188            if name in path:
189                continue
190            from_name = path[-1]
191            self.MoveNode(from_name, name)
192
193    def GetInstallList(self):
194        """
195        Return post-order list of node names.
196
197        Parameter descriptions:
198        """
199        install_list = []
200        for child in self.children:
201            child_install_list = child.GetInstallList()
202            install_list.extend(child_install_list)
203        install_list.append(self.name)
204        return install_list
205
206    def PrintTree(self, level=0):
207        """
208        Print pre-order node names with indentation denoting node depth level.
209
210        Parameter descriptions:
211        level              Current depth level
212        """
213        INDENT_PER_LEVEL = 4
214        print ' ' * (level * INDENT_PER_LEVEL) + self.name
215        for child in self.children:
216            child.PrintTree(level + 1)
217
218
219def check_call_cmd(*cmd):
220    """
221    Verbose prints the directory location the given command is called from and
222    the command, then executes the command using check_call.
223
224    Parameter descriptions:
225    dir                 Directory location command is to be called from
226    cmd                 List of parameters constructing the complete command
227    """
228    printline(os.getcwd(), ">", " ".join(cmd))
229    check_call(cmd)
230
231
232def clone_pkg(pkg, branch):
233    """
234    Clone the given openbmc package's git repository from gerrit into
235    the WORKSPACE location
236
237    Parameter descriptions:
238    pkg                 Name of the package to clone
239    branch              Branch to clone from pkg
240    """
241    pkg_dir = os.path.join(WORKSPACE, pkg)
242    if os.path.exists(os.path.join(pkg_dir, '.git')):
243        return pkg_dir
244    pkg_repo = urljoin('https://gerrit.openbmc-project.xyz/openbmc/', pkg)
245    os.mkdir(pkg_dir)
246    printline(pkg_dir, "> git clone", pkg_repo, branch, "./")
247    try:
248        # first try the branch
249        repo_inst = Repo.clone_from(pkg_repo, pkg_dir,
250                branch=branch).working_dir
251    except:
252        printline("Input branch not found, default to master")
253        repo_inst = Repo.clone_from(pkg_repo, pkg_dir,
254                branch="master").working_dir
255    return repo_inst
256
257
258def get_autoconf_deps(pkgdir):
259    """
260    Parse the given 'configure.ac' file for package dependencies and return
261    a list of the dependencies found. If the package is not autoconf it is just
262    ignored.
263
264    Parameter descriptions:
265    pkgdir              Directory where package source is located
266    """
267    configure_ac = os.path.join(pkgdir, 'configure.ac')
268    if not os.path.exists(configure_ac):
269        return []
270
271    configure_ac_contents = ''
272    # Prepend some special function overrides so we can parse out dependencies
273    for macro in DEPENDENCIES.iterkeys():
274        configure_ac_contents += ('m4_define([' + macro + '], [' +
275                macro + '_START$' + str(DEPENDENCIES_OFFSET[macro] + 1) +
276                macro + '_END])\n')
277    with open(configure_ac, "rt") as f:
278        configure_ac_contents += f.read()
279
280    autoconf_process = subprocess.Popen(['autoconf', '-Wno-undefined', '-'],
281            stdin=subprocess.PIPE, stdout=subprocess.PIPE,
282            stderr=subprocess.PIPE)
283    (stdout, stderr) = autoconf_process.communicate(input=configure_ac_contents)
284    if not stdout:
285        print(stderr)
286        raise Exception("Failed to run autoconf for parsing dependencies")
287
288    # Parse out all of the dependency text
289    matches = []
290    for macro in DEPENDENCIES.iterkeys():
291        pattern = '(' + macro + ')_START(.*?)' + macro + '_END'
292        for match in re.compile(pattern).finditer(stdout):
293            matches.append((match.group(1), match.group(2)))
294
295    # Look up dependencies from the text
296    found_deps = []
297    for macro, deptext in matches:
298        for potential_dep in deptext.split(' '):
299            for known_dep in DEPENDENCIES[macro].iterkeys():
300                if potential_dep.startswith(known_dep):
301                    found_deps.append(DEPENDENCIES[macro][known_dep])
302
303    return found_deps
304
305def get_meson_deps(pkgdir):
306    """
307    Parse the given 'meson.build' file for package dependencies and return
308    a list of the dependencies found. If the package is not meson compatible
309    it is just ignored.
310
311    Parameter descriptions:
312    pkgdir              Directory where package source is located
313    """
314    meson_build = os.path.join(pkgdir, 'meson.build')
315    if not os.path.exists(meson_build):
316        return []
317
318    found_deps = []
319    for root, dirs, files in os.walk(pkgdir):
320        if 'meson.build' not in files:
321            continue
322        with open(os.path.join(root, 'meson.build'), 'rt') as f:
323            build_contents = f.read()
324        for match in re.finditer(r"dependency\('([^']*)'.*?\)\n", build_contents):
325            maybe_dep = DEPENDENCIES['PKG_CHECK_MODULES'].get(match.group(1))
326            if maybe_dep is not None:
327                found_deps.append(maybe_dep)
328
329    return found_deps
330
331make_parallel = [
332    'make',
333    # Run enough jobs to saturate all the cpus
334    '-j', str(multiprocessing.cpu_count()),
335    # Don't start more jobs if the load avg is too high
336    '-l', str(multiprocessing.cpu_count()),
337    # Synchronize the output so logs aren't intermixed in stdout / stderr
338    '-O',
339]
340
341def enFlag(flag, enabled):
342    """
343    Returns an configure flag as a string
344
345    Parameters:
346    flag                The name of the flag
347    enabled             Whether the flag is enabled or disabled
348    """
349    return '--' + ('enable' if enabled else 'disable') + '-' + flag
350
351def mesonFeature(val):
352    """
353    Returns the meson flag which signifies the value
354
355    True is enabled which requires the feature.
356    False is disabled which disables the feature.
357    None is auto which autodetects the feature.
358
359    Parameters:
360    val                 The value being converted
361    """
362    if val is True:
363        return "enabled"
364    elif val is False:
365        return "disabled"
366    elif val is None:
367        return "auto"
368    else:
369        raise Exception("Bad meson feature value")
370
371def parse_meson_options(options_file):
372    """
373    Returns a set of options defined in the provides meson_options.txt file
374
375    Parameters:
376    options_file        The file containing options
377    """
378    options_contents = ''
379    with open(options_file, "rt") as f:
380        options_contents += f.read()
381    options = sets.Set()
382    pattern = 'option\\(\\s*\'([^\']*)\''
383    for match in re.compile(pattern).finditer(options_contents):
384        options.add(match.group(1))
385    return options
386
387def build_and_install(pkg, build_for_testing=False):
388    """
389    Builds and installs the package in the environment. Optionally
390    builds the examples and test cases for package.
391
392    Parameter description:
393    pkg                 The package we are building
394    build_for_testing   Enable options related to testing on the package?
395    """
396    os.chdir(os.path.join(WORKSPACE, pkg))
397
398    # Refresh dynamic linker run time bindings for dependencies
399    check_call_cmd('sudo', '-n', '--', 'ldconfig')
400
401    # Build & install this package
402    # Always try using meson first
403    if os.path.exists('meson.build'):
404        meson_options = parse_meson_options("meson_options.txt")
405        meson_flags = [
406            '-Db_colorout=never',
407            '-Dwerror=true',
408            '-Dwarning_level=3',
409        ]
410        if build_for_testing:
411            meson_flags.append('--buildtype=debug')
412        else:
413            meson_flags.append('--buildtype=debugoptimized')
414        if 'tests' in meson_options:
415            meson_flags.append('-Dtests=' + mesonFeature(build_for_testing))
416        if 'examples' in meson_options:
417            meson_flags.append('-Dexamples=' + str(build_for_testing).lower())
418        if MESON_FLAGS.get(pkg) is not None:
419            meson_flags.extend(MESON_FLAGS.get(pkg))
420        try:
421            check_call_cmd('meson', 'setup', '--reconfigure', 'build', *meson_flags)
422        except:
423            shutil.rmtree('build')
424            check_call_cmd('meson', 'setup', 'build', *meson_flags)
425        check_call_cmd('ninja', '-C', 'build')
426        check_call_cmd('sudo', '-n', '--', 'ninja', '-C', 'build', 'install')
427    # Assume we are autoconf otherwise
428    else:
429        conf_flags = [
430            enFlag('silent-rules', False),
431            enFlag('examples', build_for_testing),
432            enFlag('tests', build_for_testing),
433        ]
434        if not TEST_ONLY:
435            conf_flags.extend([
436                enFlag('code-coverage', build_for_testing),
437                enFlag('valgrind', build_for_testing),
438            ])
439        # Add any necessary configure flags for package
440        if CONFIGURE_FLAGS.get(pkg) is not None:
441            conf_flags.extend(CONFIGURE_FLAGS.get(pkg))
442        for bootstrap in ['bootstrap.sh', 'bootstrap', 'autogen.sh']:
443            if os.path.exists(bootstrap):
444                check_call_cmd('./' + bootstrap)
445                break
446        check_call_cmd('./configure', *conf_flags)
447        check_call_cmd(*make_parallel)
448        check_call_cmd('sudo', '-n', '--', *(make_parallel + [ 'install' ]))
449
450def build_dep_tree(pkg, pkgdir, dep_added, head, branch, dep_tree=None):
451    """
452    For each package(pkg), starting with the package to be unit tested,
453    parse its 'configure.ac' file from within the package's directory(pkgdir)
454    for each package dependency defined recursively doing the same thing
455    on each package found as a dependency.
456
457    Parameter descriptions:
458    pkg                 Name of the package
459    pkgdir              Directory where package source is located
460    dep_added           Current dict of dependencies and added status
461    head                Head node of the dependency tree
462    branch              Branch to clone from pkg
463    dep_tree            Current dependency tree node
464    """
465    if not dep_tree:
466        dep_tree = head
467
468    with open("/tmp/depcache", "r") as depcache:
469        cache = depcache.readline()
470
471    # Read out pkg dependencies
472    pkg_deps = []
473    pkg_deps += get_autoconf_deps(pkgdir)
474    pkg_deps += get_meson_deps(pkgdir)
475
476    for dep in sets.Set(pkg_deps):
477        if dep in cache:
478            continue
479        # Dependency package not already known
480        if dep_added.get(dep) is None:
481            # Dependency package not added
482            new_child = dep_tree.AddChild(dep)
483            dep_added[dep] = False
484            dep_pkgdir = clone_pkg(dep,branch)
485            # Determine this dependency package's
486            # dependencies and add them before
487            # returning to add this package
488            dep_added = build_dep_tree(dep,
489                                       dep_pkgdir,
490                                       dep_added,
491                                       head,
492                                       branch,
493                                       new_child)
494        else:
495            # Dependency package known and added
496            if dep_added[dep]:
497                continue
498            else:
499                # Cyclic dependency failure
500                raise Exception("Cyclic dependencies found in "+pkg)
501
502    if not dep_added[pkg]:
503        dep_added[pkg] = True
504
505    return dep_added
506
507def make_target_exists(target):
508    """
509    Runs a check against the makefile in the current directory to determine
510    if the target exists so that it can be built.
511
512    Parameter descriptions:
513    target              The make target we are checking
514    """
515    try:
516        cmd = [ 'make', '-n', target ]
517        with open(os.devnull, 'w') as devnull:
518            check_call(cmd, stdout=devnull, stderr=devnull)
519        return True
520    except CalledProcessError:
521        return False
522
523def run_unit_tests():
524    """
525    Runs the unit tests for the package via `make check`
526    """
527    try:
528        cmd = make_parallel + [ 'check' ]
529        for i in range(0, args.repeat):
530            check_call_cmd(*cmd)
531    except CalledProcessError:
532        for root, _, files in os.walk(os.getcwd()):
533            if 'test-suite.log' not in files:
534                continue
535            check_call_cmd('cat', os.path.join(root, 'test-suite.log'))
536        raise Exception('Unit tests failed')
537
538def run_cppcheck():
539    try:
540        # http://cppcheck.sourceforge.net/manual.pdf
541        ignore_list = ['-i%s' % path for path in os.listdir(os.getcwd()) \
542                       if path.endswith('-src') or path.endswith('-build')]
543        ignore_list.extend(('-itest', '-iscripts'))
544        params = ['cppcheck', '-j', str(multiprocessing.cpu_count()),
545                  '--enable=all']
546        params.extend(ignore_list)
547        params.append('.')
548
549        check_call_cmd(*params)
550    except CalledProcessError:
551        raise Exception('Cppcheck failed')
552
553def is_valgrind_safe():
554    """
555    Returns whether it is safe to run valgrind on our platform
556    """
557    src = 'unit-test-vg.c'
558    exe = './unit-test-vg'
559    with open(src, 'w') as h:
560        h.write('#include <stdlib.h>\n')
561        h.write('#include <string.h>\n')
562        h.write('int main() {\n')
563        h.write('char *heap_str = malloc(16);\n')
564        h.write('strcpy(heap_str, "RandString");\n')
565        h.write('int res = strcmp("RandString", heap_str);\n')
566        h.write('free(heap_str);\n')
567        h.write('return res;\n')
568        h.write('}\n')
569    try:
570        with open(os.devnull, 'w') as devnull:
571            check_call(['gcc', '-O2', '-o', exe, src],
572                       stdout=devnull, stderr=devnull)
573            check_call(['valgrind', '--error-exitcode=99', exe],
574                       stdout=devnull, stderr=devnull)
575        return True
576    except:
577        sys.stderr.write("###### Platform is not valgrind safe ######\n")
578        return False
579    finally:
580        os.remove(src)
581        os.remove(exe)
582
583def is_sanitize_safe():
584    """
585    Returns whether it is safe to run sanitizers on our platform
586    """
587    src = 'unit-test-sanitize.c'
588    exe = './unit-test-sanitize'
589    with open(src, 'w') as h:
590        h.write('int main() { return 0; }\n')
591    try:
592        with open(os.devnull, 'w') as devnull:
593            check_call(['gcc', '-O2', '-fsanitize=address',
594                        '-fsanitize=undefined', '-o', exe, src],
595                       stdout=devnull, stderr=devnull)
596            check_call([exe], stdout=devnull, stderr=devnull)
597        return True
598    except:
599        sys.stderr.write("###### Platform is not sanitize safe ######\n")
600        return False
601    finally:
602        os.remove(src)
603        os.remove(exe)
604
605def meson_setup_exists(setup):
606    """
607    Returns whether the meson build supports the named test setup.
608
609    Parameter descriptions:
610    setup              The setup target to check
611    """
612    try:
613        with open(os.devnull, 'w') as devnull:
614            output = subprocess.check_output(
615                    ['meson', 'test', '-C', 'build',
616                     '--setup', setup, '-t', '0'],
617                    stderr=subprocess.STDOUT)
618    except CalledProcessError as e:
619        output = e.output
620    return not re.search('Test setup .* not found from project', output)
621
622def maybe_meson_valgrind():
623    """
624    Potentially runs the unit tests through valgrind for the package
625    via `meson test`. The package can specify custom valgrind configurations
626    by utilizing add_test_setup() in a meson.build
627    """
628    if not is_valgrind_safe():
629        sys.stderr.write("###### Skipping valgrind ######\n")
630        return
631    if meson_setup_exists('valgrind'):
632        check_call_cmd('meson', 'test', '-C', 'build',
633                       '--setup', 'valgrind')
634    else:
635        check_call_cmd('meson', 'test', '-C', 'build',
636                       '--wrapper', 'valgrind')
637
638def maybe_make_valgrind():
639    """
640    Potentially runs the unit tests through valgrind for the package
641    via `make check-valgrind`. If the package does not have valgrind testing
642    then it just skips over this.
643    """
644    # Valgrind testing is currently broken by an aggressive strcmp optimization
645    # that is inlined into optimized code for POWER by gcc 7+. Until we find
646    # a workaround, just don't run valgrind tests on POWER.
647    # https://github.com/openbmc/openbmc/issues/3315
648    if not is_valgrind_safe():
649        sys.stderr.write("###### Skipping valgrind ######\n")
650        return
651    if not make_target_exists('check-valgrind'):
652        return
653
654    try:
655        cmd = make_parallel + [ 'check-valgrind' ]
656        check_call_cmd(*cmd)
657    except CalledProcessError:
658        for root, _, files in os.walk(os.getcwd()):
659            for f in files:
660                if re.search('test-suite-[a-z]+.log', f) is None:
661                    continue
662                check_call_cmd('cat', os.path.join(root, f))
663        raise Exception('Valgrind tests failed')
664
665def maybe_make_coverage():
666    """
667    Potentially runs the unit tests through code coverage for the package
668    via `make check-code-coverage`. If the package does not have code coverage
669    testing then it just skips over this.
670    """
671    if not make_target_exists('check-code-coverage'):
672        return
673
674    # Actually run code coverage
675    try:
676        cmd = make_parallel + [ 'check-code-coverage' ]
677        check_call_cmd(*cmd)
678    except CalledProcessError:
679        raise Exception('Code coverage failed')
680
681if __name__ == '__main__':
682    # CONFIGURE_FLAGS = [GIT REPO]:[CONFIGURE FLAGS]
683    CONFIGURE_FLAGS = {
684        'phosphor-objmgr': ['--enable-unpatched-systemd'],
685        'sdbusplus': ['--enable-transaction'],
686        'phosphor-logging':
687        ['--enable-metadata-processing',
688         'YAML_DIR=/usr/local/share/phosphor-dbus-yaml/yaml']
689    }
690
691    # MESON_FLAGS = [GIT REPO]:[MESON FLAGS]
692    MESON_FLAGS = {
693    }
694
695    # DEPENDENCIES = [MACRO]:[library/header]:[GIT REPO]
696    DEPENDENCIES = {
697        'AC_CHECK_LIB': {'mapper': 'phosphor-objmgr'},
698        'AC_CHECK_HEADER': {
699            'host-ipmid': 'phosphor-host-ipmid',
700            'blobs-ipmid': 'phosphor-ipmi-blobs',
701            'sdbusplus': 'sdbusplus',
702            'sdeventplus': 'sdeventplus',
703            'gpioplus': 'gpioplus',
704            'phosphor-logging/log.hpp': 'phosphor-logging',
705        },
706        'AC_PATH_PROG': {'sdbus++': 'sdbusplus'},
707        'PKG_CHECK_MODULES': {
708            'phosphor-dbus-interfaces': 'phosphor-dbus-interfaces',
709            'openpower-dbus-interfaces': 'openpower-dbus-interfaces',
710            'ibm-dbus-interfaces': 'ibm-dbus-interfaces',
711            'libipmid': 'phosphor-host-ipmid',
712            'libipmid-host': 'phosphor-host-ipmid',
713            'sdbusplus': 'sdbusplus',
714            'sdeventplus': 'sdeventplus',
715            'gpioplus': 'gpioplus',
716            'phosphor-logging': 'phosphor-logging',
717            'phosphor-snmp': 'phosphor-snmp',
718        },
719    }
720
721    # Offset into array of macro parameters MACRO(0, 1, ...N)
722    DEPENDENCIES_OFFSET = {
723        'AC_CHECK_LIB': 0,
724        'AC_CHECK_HEADER': 0,
725        'AC_PATH_PROG': 1,
726        'PKG_CHECK_MODULES': 1,
727    }
728
729    # DEPENDENCIES_REGEX = [GIT REPO]:[REGEX STRING]
730    DEPENDENCIES_REGEX = {
731        'phosphor-logging': r'\S+-dbus-interfaces$'
732    }
733
734    # Set command line arguments
735    parser = argparse.ArgumentParser()
736    parser.add_argument("-w", "--workspace", dest="WORKSPACE", required=True,
737                        help="Workspace directory location(i.e. /home)")
738    parser.add_argument("-p", "--package", dest="PACKAGE", required=True,
739                        help="OpenBMC package to be unit tested")
740    parser.add_argument("-t", "--test-only", dest="TEST_ONLY",
741                        action="store_true", required=False, default=False,
742                        help="Only run test cases, no other validation")
743    parser.add_argument("-v", "--verbose", action="store_true",
744                        help="Print additional package status messages")
745    parser.add_argument("-r", "--repeat", help="Repeat tests N times",
746                        type=int, default=1)
747    parser.add_argument("-b", "--branch", dest="BRANCH", required=False,
748                        help="Branch to target for dependent repositories",
749                        default="master")
750    args = parser.parse_args(sys.argv[1:])
751    WORKSPACE = args.WORKSPACE
752    UNIT_TEST_PKG = args.PACKAGE
753    TEST_ONLY = args.TEST_ONLY
754    BRANCH = args.BRANCH
755    if args.verbose:
756        def printline(*line):
757            for arg in line:
758                print arg,
759            print
760    else:
761        printline = lambda *l: None
762
763    # First validate code formatting if repo has style formatting files.
764    # The format-code.sh checks for these files.
765    CODE_SCAN_DIR = WORKSPACE + "/" + UNIT_TEST_PKG
766    check_call_cmd("./format-code.sh", CODE_SCAN_DIR)
767
768    # Automake and meson
769    if (os.path.isfile(CODE_SCAN_DIR + "/configure.ac") or
770        os.path.isfile(CODE_SCAN_DIR + '/meson.build')):
771        prev_umask = os.umask(000)
772        # Determine dependencies and add them
773        dep_added = dict()
774        dep_added[UNIT_TEST_PKG] = False
775        # Create dependency tree
776        dep_tree = DepTree(UNIT_TEST_PKG)
777        build_dep_tree(UNIT_TEST_PKG,
778                       os.path.join(WORKSPACE, UNIT_TEST_PKG),
779                       dep_added,
780                       dep_tree,
781                       BRANCH)
782
783        # Reorder Dependency Tree
784        for pkg_name, regex_str in DEPENDENCIES_REGEX.iteritems():
785            dep_tree.ReorderDeps(pkg_name, regex_str)
786        if args.verbose:
787            dep_tree.PrintTree()
788        install_list = dep_tree.GetInstallList()
789        # We don't want to treat our package as a dependency
790        install_list.remove(UNIT_TEST_PKG)
791        # install reordered dependencies
792        for dep in install_list:
793            build_and_install(dep, False)
794        os.chdir(os.path.join(WORKSPACE, UNIT_TEST_PKG))
795        # Run package unit tests
796        build_and_install(UNIT_TEST_PKG, True)
797        if os.path.isfile(CODE_SCAN_DIR + '/meson.build'):
798            if not TEST_ONLY:
799                maybe_meson_valgrind()
800
801                # Run clang-tidy only if the project has a configuration
802                if os.path.isfile('.clang-tidy'):
803                    check_call_cmd('run-clang-tidy-6.0.py', '-p',
804                                   'build')
805                # Run the basic clang static analyzer otherwise
806                else:
807                    os.environ['SCANBUILD'] = 'scan-build-6.0'
808                    check_call_cmd('ninja', '-C', 'build',
809                                   'scan-build')
810
811                # Run tests through sanitizers
812                # b_lundef is needed if clang++ is CXX since it resolves the
813                # asan symbols at runtime only. We don't want to set it earlier
814                # in the build process to ensure we don't have undefined
815                # runtime code.
816                if is_sanitize_safe():
817                    check_call_cmd('meson', 'configure', 'build',
818                                   '-Db_sanitize=address,undefined',
819                                   '-Db_lundef=false')
820                    check_call_cmd('meson', 'test', '-C', 'build',
821                                   '--logbase', 'testlog-ubasan')
822                    # TODO: Fix memory sanitizer
823                    #check_call_cmd('meson', 'configure', 'build',
824                    #               '-Db_sanitize=memory')
825                    #check_call_cmd('meson', 'test', '-C', 'build'
826                    #               '--logbase', 'testlog-msan')
827                    check_call_cmd('meson', 'configure', 'build',
828                                   '-Db_sanitize=none', '-Db_lundef=true')
829                else:
830                    sys.stderr.write("###### Skipping sanitizers ######\n")
831
832                # Run coverage checks
833                check_call_cmd('meson', 'configure', 'build',
834                               '-Db_coverage=true')
835                check_call_cmd('meson', 'test', '-C', 'build')
836                # Only build coverage HTML if coverage files were produced
837                for root, dirs, files in os.walk('build'):
838                    if any([f.endswith('.gcda') for f in files]):
839                        check_call_cmd('ninja', '-C', 'build',
840                                       'coverage-html')
841                        break
842                check_call_cmd('meson', 'configure', 'build',
843                               '-Db_coverage=false')
844            else:
845                check_call_cmd('meson', 'test', '-C', 'build')
846        else:
847            run_unit_tests()
848            if not TEST_ONLY:
849                maybe_make_valgrind()
850                maybe_make_coverage()
851        if not TEST_ONLY:
852            run_cppcheck()
853
854        os.umask(prev_umask)
855
856    # Cmake
857    elif os.path.isfile(CODE_SCAN_DIR + "/CMakeLists.txt"):
858        os.chdir(os.path.join(WORKSPACE, UNIT_TEST_PKG))
859        check_call_cmd('cmake', '-DCMAKE_EXPORT_COMPILE_COMMANDS=ON', '.')
860        check_call_cmd('cmake', '--build', '.', '--', '-j',
861                       str(multiprocessing.cpu_count()))
862        if make_target_exists('test'):
863            check_call_cmd('ctest', '.')
864        if not TEST_ONLY:
865            maybe_make_valgrind()
866            maybe_make_coverage()
867            run_cppcheck()
868            if os.path.isfile('.clang-tidy'):
869                check_call_cmd('run-clang-tidy-6.0.py', '-p', '.')
870
871    else:
872        print "Not a supported repo for CI Tests, exit"
873        quit()
874