path: root/SConstruct

############################################################################
# Copyright 2016-2017 Intel Corporation
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
############################################################################

"""use scons -k to invoke all builds regardless of unit test failures
"""
import string
import sys
import SCons.Script
import os.path
import subprocess
from subprocess import Popen, PIPE
from parts import *
import re
import tempfile
import shutil
from collections import OrderedDict

def get_parts_versions(env):
    """Get Parts related versions given SCons environment env"""
    return OrderedDict({'python': string.split(sys.version, " ", 1)[0],
                        'scons': str(SCons.__version__),
                        'parts': str(PartsExtensionVersion())})

def get_toolchain_versions(env):
    """Get version of compilation toolchain given SCons environment env"""
    versions = OrderedDict()
    if 'MSVC_VERSION' in env:
        versions['compiler'] = 'MSVC ' + env['MSVC_VERSION']
        cmd = env.subst('echo int main(){return 0;} > a.cpp'
                        ' | $CXX $CCFLAGS a.cpp /link /verbose')
        defaultlib_regexp = r'.*Searching (.*\.lib).*'
    elif 'GCC_VERSION' in env:
        versions['compiler'] = 'GCC ' + env['GCC_VERSION']
        if 'GXX_VERSION' in env:
            versions['compiler'] += ' and GXX ' + env['GXX_VERSION']
            if os.name == 'nt':
                cmd = env.subst('echo int main(){return 0;}'
                                ' | $CXX $CCFLAGS -xc++ -Wl,--verbose -')
            else:
                cmd = env.subst('echo "int main(){return 0;}"'
                                ' | $CXX $CCFLAGS -xc++ -Wl,--verbose -')
        else:
            if os.name == 'nt':
                cmd = env.subst('echo int main(){return 0;}'
                                ' | $CXX $CCFLAGS -xc++ -Wl,--verbose -')
            else:
                cmd = env.subst('echo "int main(){return 0;}"'
                                ' | $CC  $CCFLAGS -xc   -Wl,--verbose -')
        if os.name == 'nt':
            defaultlib_regexp = r'\n.* open (.*) succeeded'
        else:
            defaultlib_regexp = r'[\n(](/.*\.so[-.\da-fA-F]*).*'

    # Intel C compiler always depends from base toolchain
    if 'INTELC_VERSION' in env:
        versions['compiler'] = 'INTELC {0} with {1}'.format(
            env['INTELC_VERSION'],
            versions['compiler'])

    env['ENV']['PATH'] = str(env['ENV']['PATH'])
    temp_dir = tempfile.mkdtemp()
    try:
        proc = subprocess.Popen(cmd,
                                cwd=temp_dir,
                                env=env['ENV'],
                                shell=True,
                                stdout=subprocess.PIPE, stderr=subprocess.PIPE)
        stdout, _ = proc.communicate()
        if proc.returncode != 0:
            versions['default_libs'] = 'failure executing: "{0}"'.format(cmd)
        else:
            default_libs = list(
                set(re.findall(defaultlib_regexp, stdout, re.M)))
            if 'MSVC_VERSION' in env:
                # for windows additionally report versions of Windows Kit used
                runtime_version_set = set()
                for lib_path in default_libs:
                    path_components = os.path.realpath(lib_path).split(os.sep)
                    if 'Windows Kits' in path_components:
                        i = path_components.index('Windows Kits')
                        runtime_version_set.add(
                            'Windows Kits {0} {1}'.format(path_components[i + 1],
                                                          path_components[i + 3]))
                versions['sdk_or_libc'] = '; '.join(list(runtime_version_set))
            else:
                # for posix additionally report versions of libc used
                versions['sdk_or_libc'] = os.path.split(os.path.realpath(
                    next((lib for lib in default_libs if
                          'libc' in lib.lower() and 'libcilk' not in lib.lower()), None)))[1]
            versions['default_libs'] = default_libs
    finally:
        shutil.rmtree(temp_dir)

    return versions


def log_versions(env, include_toolchain=True):
    """Log tools and libraries versions given SCons environment env

    Args:
        env: Scons environment.
        include_toolchain: Log version of compilation toolchain if True.
    """

    versions = get_parts_versions(env)
    if include_toolchain:
        versions.update(get_toolchain_versions(env))

    print "**************** VERSIONS *************"
    long_names = {
        'python': 'Python Version',
        'scons': 'SCons  Version',
        'parts': 'Parts  Version',
        'compiler': 'Compiler Version',
        'sdk_or_libc': 'Libc/SDK',
        'default_libs': 'Default Libs'
    }
    for name, value in versions.iteritems():
        if not isinstance(value, list):
            print '* {0}: {1}'.format(long_names.get(name, name), value)
        else:
            print '* {0}:\n* \t{1}'.format(long_names.get(name, name),
                                           '\n* \t'.join(sorted(value)))
    print "***************************************"


def include_parts(part_list, **kwargs):
    for parts_file in part_list:
        if os.path.isfile(DefaultEnvironment().subst(parts_file)):
            Part(parts_file=parts_file, **kwargs)


######## Part groups ####################################################
ipp_parts = ['ext/ipp/ippcp.parts']
utest_parts = ['ext/gtest/gtest.parts',
               'epid/common-testhelper/common-testhelper.parts']
common_parts = ['epid/common/common.parts']
member_parts = ['epid/member/member.parts']
verifier_parts = ['epid/verifier/verifier.parts']
util_parts = ['example/util/util.parts']
example_parts = ['ext/argtable3/argtable3.parts',
                 'example/verifysig/verifysig.parts',
                 'example/signmsg/signmsg.parts',
                 'example/data/data.parts',
                 'example/compressed_data/compressed_data.parts']
sizing_parts = ['example/util/util_static.parts',
                'example/signmsg/signmsg_shared.parts',
                'example/verifysig/verifysig_shared.parts',
                'example/verifysig/verifysig11_shared.parts']
example_static_parts = ['example/util/util_static.parts',
                        'example/signmsg/signmsg_static.parts',
                        'example/verifysig/verifysig_static.parts']
tools_parts = ['tools/revokegrp/revokegrp.parts',
               'tools/revokekey/revokekey.parts',
               'tools/revokesig/revokesig.parts',
               'tools/extractkeys/extractkeys.parts',
               'tools/extractgrps/extractgrps.parts']
testbot_test_parts = ['test/testbot/testbot.parts',
                      'test/testbot/signmsg/signmsg_testbot.parts',
                      'test/testbot/verifysig/verifysig_testbot.parts',
                      'test/testbot/integration/integration_testbot.parts',
                      'test/testbot/ssh_remote/ssh_remote_testbot.parts',
                      'test/testbot/revokegrp/revokegrp_testbot.parts',
                      'test/testbot/revokekey/revokekey_testbot.parts',
                      'test/testbot/revokesig/revokesig_testbot.parts',
                      'test/testbot/extractkeys/extractkeys_testbot.parts',
                      'test/testbot/extractgrps/extractgrps_testbot.parts',
                      'tools/reports/reports.parts']
tss_test_parts = ['test/tss/tss.parts']
package_parts = ['ext/gtest/gtest.parts',
                 'ext/ipp/ippcp.parts',
                 'package.parts']
memory_profiler_parts = ['tools/memory_profiler/memory_profiler.parts']
internal_tools_parts = ['ext/argtable3/argtable3.parts',
                        'tools/ikgfwrapper/ikgfwrapper.parts']
epid_data = ['test/epid_data/epid_data.parts']
perf_benchmark_parts = ['ext/google_benchmark/google_benchmark.parts',
                        'test/performance/performance.parts']
memory_benchmark_parts = ['test/dynamic_memory/dynamic_memory.parts']
######## End Part groups ###############################################
######## Commandline option setup #######################################
product_variants = [
    'production',
    'internal-test',
    'package-epid-sdk',
    'internal-tools',
    'benchmark',
    'tiny',
    'internal-test-tiny'
]

default_variant = 'production'


def is_production():
    return GetOption("product-variant") == 'production'


def is_internal_test():
    return GetOption("product-variant") == 'internal-test'


def is_internal_tools():
    return GetOption("product-variant") == 'internal-tools'


def is_package():
    return GetOption("product-variant") == 'package-epid-sdk'


def is_benchmark():
    return GetOption("product-variant") == 'benchmark'

def is_tiny():
    return GetOption("product-variant") == 'tiny'

def is_internal_test_tiny():
    return GetOption("product-variant") == 'internal-test-tiny'


def use_commercial_ipp():
    return GetOption("use-commercial-ipp")


def use_tss():
    return GetOption("use-tss")


def config_has_instrumentation():
    return any(DefaultEnvironment().isConfigBasedOn(config_name)
               for config_name in ['instr_release'])


def variant_dirname():
    s = GetOption("product-variant")
    if s == 'production':
        return 'epid-sdk'
    elif s == 'package-epid-sdk':
        return 'epid-sdk'
    elif s == 'tiny':
        return 'epid-sdk'
    else:
        return s


AddOption("--product-variant", "--prod-var", nargs=1,
          help=("Select product variant to build. Possible "
                "options are: {0}. The default is {1} if no option "
                "is specified").format(", ".join(product_variants),
                                       default_variant),
          action='store', dest='product-variant', type='choice',
          choices=product_variants, default=default_variant)

AddOption("--use-commercial-ipp",
          help=("Link with commercial IPP. The IPPCRYPTOROOT environment "
                "variable must be set."),
          action='store_true', dest='use-commercial-ipp',
          default=False)

AddOption("--use-tss",
          help=("Link with TPM TSS. The TSSROOT environment variable "
                "must be set."),
          action='store_true', dest='use-tss',
          default=False)

AddOption("--ipp-shared",
          help=("Build /ext/ipp as shared library."),
          action='store_true', dest='ipp-shared',
          default=False)

AddOption("--enable-sanitizers",
          help=("Build with sanitizers (https://github.com/google/sanitizers)."),
          action='store_true', dest='sanitizers',
          default=False)

AddOption("--sanitizers-recover",
          help=("Configure sanititzers to recover and continue execution "
                "on error found. Only applicable when sanitizers are enabled."
                "See --enable-sanitizers option."),
          action='store_true', dest='sanitizers-recover',
          default=False)


SetOptionDefault("PRODUCT_VARIANT", variant_dirname())

######## End Commandline option setup ###################################


# fix for parts 0.10.8 until we get better logic to extract ${CC}
SetOptionDefault('PARTS_USE_SHORT_TOOL_NAMES', 1)


def enable_sanitizers(recover):
    """
        Configures compiler to enable sanitizers.
        Adds sanitizer options to default scons environment such
        that it affects all parts.
    Args:
        recover: Enable sanitizers recovery from errors found when True.
    """
    env = DefaultEnvironment()
    error_msg = None
    try:
       major = int(env.subst('$GCC_VERSION').partition('.')[0])
    except ValueError:
       major = 0

    if major >= 6 and env['TARGET_OS'] == 'posix':
        if 'INTELC_VERSION' not in env:
            ccflags = ['-fsanitize=address,undefined', '-fno-sanitize=alignment',
                       '-fno-sanitize=shift', '-fno-omit-frame-pointer']
            if recover:
                ccflags = ccflags + ['-fsanitize-recover=all', '-fsanitize-recover=address']
            else:
                ccflags = ccflags + ['-fno-sanitize-recover']
            # Extends default flags with sanitizer options
            SetOptionDefault('CCFLAGS', ccflags)
            SetOptionDefault('LIBS', ['asan', 'ubsan'])
        else:
            error_msg = """
                Build with sanitizers is not supported for Intel(R) C++ Compiler.
                Try scons --toolchain=gcc_6 --target=posix
                """
    else:
        # User experience with sanitizers in GCC 4.8 is not great. Use at least GCC 6.x.
        error_msg = """
            Build with sanitizers is only supported for GCC version greater than
            6.x targeting posix OS. Current GCC version is "{0}" and OS target is "{1}".
            Try scons --toolchain=gcc_6 --target=posix
            """.format(env.get('GCC_VERSION', 'unknown'), env.get('TARGET_OS', 'unknown'))
    if error_msg is not None:
        env.PrintError(error_msg)


def set_default_production_options():
    SetOptionDefault('CONFIG', 'release')

    SetOptionDefault('TARGET_VARIANT', '${TARGET_OS}-${TARGET_ARCH}')

    SetOptionDefault('INSTALL_ROOT',
                     '#_install/${PRODUCT_VARIANT}')

    SetOptionDefault('INSTALL_TOOLS_BIN',
                     '$INSTALL_ROOT/tools')

    SetOptionDefault('INSTALL_SAMPLE_BIN',
                     '$INSTALL_ROOT/example')

    SetOptionDefault('INSTALL_EPID_INCLUDE',
                     '$INSTALL_ROOT/include/epid')

    SetOptionDefault('INSTALL_IPP_INCLUDE',
                     '$INSTALL_ROOT/include/ext/ipp/include')

    SetOptionDefault('INSTALL_TEST_BIN',
                     '$INSTALL_ROOT/test')

    SetOptionDefault('INSTALL_LIB',
                     '$INSTALL_ROOT/lib/${TARGET_VARIANT}')

    SetOptionDefault('INSTALL_SAMPLE_DATA',
                     '$INSTALL_ROOT/example')

    SetOptionDefault('INSTALL_TOOLS_DATA',
                     '$INSTALL_ROOT/tools')

    SetOptionDefault('PACKAGE_DIR',
                     '#_package')

    SetOptionDefault('PACKAGE_ROOT',
                     '#_package/${PRODUCT_VARIANT}')

    SetOptionDefault('ROOT',
                     '#')

    SetOptionDefault('PACKAGE_NAME',
                     '{PRODUCT_VARIANT}')


if GetOption("sanitizers"):
    enable_sanitizers(GetOption("sanitizers-recover"))

if is_production():
    set_default_production_options()
    ipp_mode = ['install_lib']
    if use_commercial_ipp():
        ipp_mode.append('use_commercial_ipp')
    sdk_mode = ['install_lib']
    if use_tss():
        sdk_mode.append('use_tss')
    if GetOption('ipp-shared'):
        ipp_mode.append('build_ipp_shared')
    include_parts(ipp_parts, mode=ipp_mode,
                  INSTALL_INCLUDE='${INSTALL_IPP_INCLUDE}')
    include_parts(utest_parts + common_parts +
                  member_parts + verifier_parts,
                  mode=sdk_mode,
                  INSTALL_INCLUDE='${INSTALL_EPID_INCLUDE}')
    include_parts(util_parts + example_parts,
                  INSTALL_INCLUDE='${INSTALL_EPID_INCLUDE}',
                  INSTALL_BIN='${INSTALL_SAMPLE_BIN}',
                  INSTALL_DATA='${INSTALL_SAMPLE_DATA}')
    include_parts(tools_parts,
                  INSTALL_BIN='${INSTALL_TOOLS_BIN}',
                  INSTALL_DATA='${INSTALL_TOOLS_DATA}')
    Default('all')
    Default('utest::')
    if not use_tss():
        Default('run_utest::')

if is_internal_test():
    set_default_production_options()
    sdk_mode = []
    if use_tss():
        sdk_mode.append('use_tss')
        include_parts(tss_test_parts)
    include_parts(ipp_parts)
    include_parts(utest_parts + common_parts +
                  member_parts + verifier_parts,
                  mode=sdk_mode)
    include_parts(util_parts + example_parts,
                  INSTALL_BIN='${INSTALL_SAMPLE_BIN}',
                  INSTALL_DATA='${INSTALL_SAMPLE_DATA}')
    include_parts(sizing_parts,
                  INSTALL_BIN='${INSTALL_SAMPLE_BIN}')
    include_parts(tools_parts, INSTALL_BIN='${INSTALL_TOOLS_BIN}')
    include_parts(testbot_test_parts)
    Default('all')

if is_internal_tools():
    set_default_production_options()
    include_parts(ipp_parts + utest_parts + common_parts + verifier_parts + member_parts + util_parts)
    include_parts(internal_tools_parts + memory_profiler_parts,
                  INSTALL_BIN='${INSTALL_TOOLS_BIN}')
    Default('ikgfwrapper', 'memory_profiler')
    Default('run_utest::memory_profiler::')

if is_benchmark():
    set_default_production_options()
    MODE = []
    if config_has_instrumentation():
        MODE.append('use_memory_profiler')
    ipp_mode = []
    if use_commercial_ipp():
        ipp_mode.append('use_commercial_ipp')

    # install ipp static and ipp shared builds into separate locations
    if GetOption('ipp-shared'):
        ipp_mode.append('build_ipp_shared')
        SetOptionDefault('INSTALL_TEST_BIN',
                         '$INSTALL_ROOT/test_ipp_shared')
        SetOptionDefault('INSTALL_LIB',
                         '$INSTALL_ROOT/lib_ipp_shared')
    else:
        SetOptionDefault('INSTALL_LIB',
                         '$INSTALL_ROOT/lib')

    # do not allow file links to keep previous builds intact
    SetOptionDefault('CCOPY_LOGIC', 'copy')

    include_parts(ipp_parts, config_independent=True, mode=MODE + ipp_mode,
                  INSTALL_BIN='${INSTALL_TEST_BIN}')
    include_parts(example_static_parts + utest_parts + perf_benchmark_parts +
                  common_parts + verifier_parts +
                  sizing_parts + epid_data,
                  config_independent=True,
                  mode=MODE,
                  INSTALL_BIN='${INSTALL_TEST_BIN}')

    member_mode = ['install_lib']
    member_cfg = ('embedded' if not DefaultEnvironment().isConfigBasedOn(
        'debug') and not config_has_instrumentation() else DefaultEnvironment().subst('$CONFIG'))
    Part(parts_file='epid/common/tinycommon.parts', CONFIG=member_cfg)
    Part(parts_file='epid/member/tinymember.parts', CONFIG=member_cfg,
         config_independent=True, mode=MODE + member_mode, INSTALL_BIN='${INSTALL_TEST_BIN}')

    if config_has_instrumentation():
        include_parts(memory_benchmark_parts + memory_profiler_parts,
                      config_independent=True,
                      mode=MODE,
                      INSTALL_BIN='${INSTALL_TEST_BIN}')

    Default('build::')

if is_package():
    set_default_production_options()
    include_parts(package_parts,
                  mode=['install_package'],
                  INSTALL_TOP_LEVEL='${PACKAGE_ROOT}')
    Default('package')

if is_tiny():
    set_default_production_options()
    ### Member
    Part(parts_file='ext/gtest/gtest.parts')
    member_mode = ['install_lib']
    member_cfg = ('embedded'
                  if not DefaultEnvironment().isConfigBasedOn('debug')
                  else DefaultEnvironment().subst('$CONFIG'))
    Part(parts_file='epid/common/tinycommon.parts', CONFIG=member_cfg)
    Part(parts_file='epid/member/tinymember.parts', CONFIG=member_cfg,
         config_independent=True, mode=member_mode)
    Default('member::')
    Default('run_utest::member::')
    ### Verifier, samples and tools
    verifier_mode = ['install_lib']
    ipp_mode = ['install_lib']
    if use_commercial_ipp():
        ipp_mode.append('use_commercial_ipp')
    if GetOption('ipp-shared'):
        ipp_mode.append('build_ipp_shared')
    include_parts(ipp_parts, mode=ipp_mode,
                  INSTALL_INCLUDE='${INSTALL_IPP_INCLUDE}')
    Part(parts_file='epid/common-testhelper/common-testhelper.parts',
         config_independent=True)
    include_parts(common_parts + verifier_parts,
                  mode=verifier_mode,
                  INSTALL_INCLUDE='${INSTALL_EPID_INCLUDE}')
    include_parts(util_parts + example_parts,
                  INSTALL_INCLUDE='${INSTALL_EPID_INCLUDE}',
                  INSTALL_BIN='${INSTALL_SAMPLE_BIN}',
                  INSTALL_DATA='${INSTALL_SAMPLE_DATA}')
    include_parts(tools_parts,
                  INSTALL_BIN='${INSTALL_TOOLS_BIN}',
                  INSTALL_DATA='${INSTALL_TOOLS_DATA}')
    Default('all')
    Default('utest::')

if is_internal_test_tiny():
    set_default_production_options()
    sdk_mode = []
    ### Member
    Part(parts_file='ext/gtest/gtest.parts')
    member_cfg = ('embedded'
                  if not DefaultEnvironment().isConfigBasedOn('debug')
                  else DefaultEnvironment().subst('$CONFIG'))
    Part(parts_file='epid/common/tinycommon.parts', CONFIG=member_cfg)
    Part(parts_file='epid/member/tinymember.parts', CONFIG=member_cfg,
         config_independent=True, mode=sdk_mode)
    ### Verifier, samples and tools
    include_parts(ipp_parts)
    Part(parts_file='epid/common-testhelper/common-testhelper.parts',
         config_independent=True)
    include_parts(common_parts + verifier_parts,
                  mode=sdk_mode)
    include_parts(util_parts + example_parts,
                  INSTALL_BIN='${INSTALL_SAMPLE_BIN}',
                  INSTALL_DATA='${INSTALL_SAMPLE_DATA}')
    include_parts(tools_parts, INSTALL_BIN='${INSTALL_TOOLS_BIN}')
    include_parts(testbot_test_parts)
    Default('build::')

log_versions(DefaultEnvironment(), not is_package())