configure

#!/usr/bin/env python2.7

# Copyright 2016 Nidium Inc. All rights reserved.
# Use of this source code is governed by a MIT license
# that can be found in the LICENSE file.

import os

from konstructor import Deps
from konstructor import CommandLine
from konstructor import Build
from konstructor import Builder
from konstructor import Platform
from konstructor import Variables as Vars
from konstructor import Konstruct
from konstructor import Utils
from konstructor import assumeYes
from konstructor import Tests
from konstructor import Log
from konstructor import ROOT

Gyp = Builder.Gyp
DEPEDENCY_REPO = "http://deps.nidium.com"

Platform.setEnviron(
    "CC=%s" % (os.environ.get("CC", "clang")),
    "CXX=%s" % (os.environ.get("CXX", "clang++")),
    "LDFLAGS=%s" % (os.environ.get("LDFLAGS", ""))
)

if Platform.system == "Darwin":
    Platform.setEnviron("MACOSX_DEPLOYMENT_TARGET=10.7")

# We explicitely set "python2.7 gyp_main.py" because "gyp" executable force
# the use of "python" which could be 2.7 or 3 and gyp does not work with python3
Gyp.setExec("python2.7 third-party/gyp/gyp_main.py")

###

@Deps.register("gyp")
def gyp():
    return {
        "location": Deps.GitRepo("https://chromium.googlesource.com/external/gyp", revision="4ec6c4e3a94bd04a6da2858163d40b2429b8aad1")
    }

@Deps.register("c-ares")
def cares():
    makefile = ""
    configure = "./configure --enable-shared=no"
    env = Utils.Env()

    if Konstruct.config("android"):
        env.update(Vars.get("androidEnvClang"))
        env.append("CFLAGS", "-Wno-invalid-source-encoding")
        configure += " --host=%s " % (Vars.get("targetTriplet"))
    elif Platform.system == 'Windows':
        makefile = " -f Makefile.m32"

    return {
        "location": "http://c-ares.haxx.se/download/c-ares-1.12.0.tar.gz",
        "build": [configure, "make" + makefile],
        "env": env,
        "outputs": [".libs/libcares.a"]
    }

@Deps.register("openssl")
def openssl():
    env = Utils.Env()
    configure = ["", "make build_libs"]

    if Konstruct.config("android"):
        # The define OPENSSL_API_COMPAT=0x10100000L prevents OpenSSL from adding deprecated APIs
        # (It also fix a naming conflic with skia sk_free() function)
        configure = ["./config -fPIC -fno-integrated-as -DOPENSSL_API_COMPAT=0x10100000L", "make build_libs"]
        env.update({
            "CROSS_COMPILE": "arm-linux-androideabi-",
            "MACHINE": Vars.get("targetCpu"),
            "ANDROID_DEV": "%s/sysroot/usr/" % (Vars.get("toolchainPath"))
        })
    elif Platform.system == 'Windows':
	    configure[0] = "./Configure mingw -fPIC"
    elif Platform.system == "Darwin":
        configure[0] = "./config -no-shared -DOPENSSL_API_COMPAT=0x10100000L"
    else:
        configure[0] = "./config -fPIC -DOPENSSL_API_COMPAT=0x10100000L"
    return {
        "location": "https://github.com/openssl/openssl/archive/OpenSSL_1_1_0c.tar.gz",
        "build": configure,
        "env": env,
        "outputs": ["libssl(.a|.lib)", "libcrypto(.a|.lib)"]
    }

@Deps.register("zlib")
def zlip():
    env = Utils.Env()

    if Konstruct.config("android"):
        env = Vars.get("androidEnvClang")
        build = ["./configure --static", "make"]
    elif Platform.system == 'Windows':
        build = ["make -f ./win32/Makefile.gcc"]
    else:
        build = ["./configure --static", "make"]
    return {
        "location": "%s/zlib-1.2.11.tar.gz" % (DEPEDENCY_REPO),
        "build": build,
        "env": env,
        "outputs": ["libz.a"]
    }

@Deps.register("gperftools")
def gperftools():
    return {
        "location": "https://github.com/gperftools/gperftools/releases/download/gperftools-2.5/gperftools-2.5.tar.gz",
        "build": ["autoconf", "chmod +x ./configure", "./configure --enable-static --enable-shared", "make"],
        "outputs": [".libs/libprofiler.so.0$"]
    }

@Deps.register("pprof")
def pprof():
    from konstructor import ConfigCache
    return {
        "location": Deps.Command("GOPATH=%s go get github.com/google/pprof" % (os.path.join(Deps.getDir(), "." + ConfigCache.getConfigStr(), "pprof"))),
        "outputs": [{"src": "bin/pprof", "dst": os.path.join(Deps.getDir(), "pprof", "tools")}]
    }

@Deps.register("gtest")
def gtest():
    flags = ""

    if Platform.system == "Darwin":
        flags = "-DCMAKE_CXX_FLAGS='-std=c++11 -stdlib=libc++'"

    return {
        "location": Deps.GitRepo("https://github.com/google/googletest.git", revision="d225acc90bc3a8c420a9bcd1f033033c1ccd7fe0"),
        "build": ["cmake %s ." % flags, "make"],
        "outputs": ["googlemock/libgmock.a", "googlemock/libgmock_main.a", "googlemock/gtest/libgtest.a", "googlemock/gtest/libgtest_main.a"]
    }

def setupAndroidSDK():
    import shutil

    # The android-sdk should be placed in a "tools" directory
    # (compatibility with various build system)
    src = os.path.join(Deps.getDir(), "android-sdk")
    dst = os.path.join(src, "tools")

    if not os.path.exists(dst):
        Log.debug("Moving android tools in subdirectory (%s)" % (dst))
        Utils.mkdir(dst)

        for f in os.listdir(src):
            shutil.move(os.path.join(src, f), dst)

    # Install the platform-tools, build tools, NDK and android libs
    sdkManager = (os.path.join(dst, "bin", "sdkmanager"))
    Log.info("Downloading android tools, this make take a while, be patient...")
    Utils.run("chmod +x %s" % sdkManager)
    Utils.run(sdkManager + " platform-tools")
    Utils.run(sdkManager + " ndk-bundle")
    Utils.run(sdkManager + " \"build-tools;25.0.2\"")
    Utils.run(sdkManager + " \"platforms;android-25\"")

    # Setup NDK toolchain
    androidNdkPath = Vars.get("androidNdkPath")
    toolchainPath = Vars.get("toolchainPath")
    if os.path.isdir(toolchainPath):
        Log.debug("Removing previous android toolchain")
        Utils.rmdir(toolchainPath)

    Utils.run("chmod +x %s/build/tools/make_standalone_toolchain.py" % (androidNdkPath))
    Utils.run("%s/build/tools/make_standalone_toolchain.py \
            --api=%d --install-dir=%s --arch=arm \
            --stl=libc++" % (androidNdkPath, Vars.get("androidNDKAPIVersion"), toolchainPath))

@Deps.register("android-sdk")
def androidNDK():
    NDKAPIVersion = 21
    SDKAPIVersion = 25

    toolchainPath = ROOT + "/tools/android-toolchain/"
    androidSdkPath = Deps.getDir() + "/android-sdk/"
    androidNdkPath = androidSdkPath + "/ndk-bundle/"

    Vars.set("toolchainPath", toolchainPath);
    Vars.set("androidNDKAPIVersion", NDKAPIVersion)
    Vars.set("androidSDKAPIVersion", SDKAPIVersion)
    Vars.set("androidNdkPath", androidNdkPath)
    Vars.set("androidSdkPath", androidSdkPath)

    Platform.setEnviron(
        "PATH=%s:%s/bin/" % (os.environ.get("PATH", ""), toolchainPath),
        "ANDROID_SDK_ROOT=%s" % (androidSdkPath),
        "ANDROID_NDK_ROOT=%s" % (androidNdkPath),
    )

    Vars.set("androidEnvGcc", Utils.Env({
        "CC": "%s/bin/arm-linux-androideabi-gcc" % toolchainPath,
        "CXX": "%s/bin/arm-linux-androideabi-g++" % toolchainPath,
        "AR": "%s/bin/arm-linux-androideabi-ar" % toolchainPath,
        "RANLIB": "%s/bin/arm-linux-androideabi-ranlib" % toolchainPath,
        "LD": "%s/bin/arm-linux-androideabi-ld.gold" % toolchainPath,
        # With android ndk R13 gcc has incorrect include path. Fix that.
        # See : https://github.com/android-ndk/ndk/issues/215
        "CXXFLAGS": "-nostdinc %s" % (os.environ.get("CXXFLAGS", "")) +
            " -I%s/include/c++/4.9.x" % (Vars.get("toolchainPath")) +
            " -I%s/include/c++/4.9.x/arm-linux-androideabi" % (Vars.get("toolchainPath")) +
            " -I%s/lib/gcc/arm-linux-androideabi/4.9.x/include" % (Vars.get("toolchainPath")) +
            " -I%s/lib/gcc/arm-linux-androideabi/4.9.x/include-fixed" % (Vars.get("toolchainPath")) +
            " -I%s/sysroot/usr/local/include" % (Vars.get("toolchainPath")) +
            " -I%s/sysroot/usr/include" % (Vars.get("toolchainPath"))
    }))

    Vars.set("androidEnvClang", Utils.Env({
        "CC": "%s/bin/arm-linux-androideabi-clang" % toolchainPath,
        "CXX": "%s/bin/arm-linux-androideabi-clang++" % toolchainPath,
        "AR": "%s/bin/arm-linux-androideabi-ar" % toolchainPath,
        "RANLIB": "%s/bin/arm-linux-androideabi-ranlib" % toolchainPath,
        "LD": "%s/bin/arm-linux-androideabi-ld.gold" % toolchainPath
    }))

    return {
        "location": "https://dl.google.com/android/repository/tools_r25.2.3-linux.zip",
        "build": [setupAndroidSDK]
    }

#####

@CommandLine.option("--debug", default=False)
def debug(debug):
    if debug:
        Vars.set("debug", True)
        Gyp.setConfiguration("Debug");
        Konstruct.setConfigs(["debug"])

@CommandLine.option("--third-party-path", default="")
def gypConfig(thirdPartyPath):
    if thirdPartyPath:
        Deps.setDir(thirdPartyPath)
        # Gyp needs a relative path
        Gyp.set("third_party", os.path.relpath(thirdPartyPath))
        Gyp.setExec(os.path.join(thirdPartyPath, "gyp", "gyp"))

@CommandLine.option("--module", default="")
def module(module):
    if not module:
        return

    Deps.set(Deps.Konstruct(module, module + "/configure"))

@CommandLine.option("--unit-tests", nargs="?", const="all", default=None)
def testNetwork(unitTests):
    if not unitTests:
        return

    head, tail = os.path.split(os.getcwd())
    cwd = os.path.dirname(os.path.realpath(__file__))

    #Builder.Gyp.set("asan", 1)

    if unitTests:
        Gyp.set("unit_test", 1)
        Deps.set("gtest")

        Tests.register([
            "build/tests/network-unittests"
        ], builders=[Gyp("%s/gyp/network-unittests.gyp" % cwd)])

    @Konstruct.hook("postBuild")
    def runNetworkTest(success):
        exitCode = 0 if Tests.runTest(success) else 4
        Utils.exit(code=exitCode)

@CommandLine.option("--asan", default=False)
def asan(asan):
    if asan:
        Gyp.set("asan", 1)

@CommandLine.option("--android", default=False)
def android(android):
    if not android:
        return

    if Platform.system != "Linux":
        Utils.exit("Building nidium for Android is only supported on Linux")

    Konstruct.setConfigs(["android"])

    Gyp.set("target_cpu", Vars.get("target_cpu", "arm"));
    Gyp.set("target_os", "android");
    Gyp.setOutputFormat("ninja-android")

    Vars.set("targetTriplet", "arm-linux-androideabi")
    Vars.set("targetArch", "arm")
    Vars.set("targetCpu", "armv7")

    # Add android-sdk dependency just before preparing/building
    # all deps so it will be the first dependency to be
    # downloaded/build since all dependecies depends on it
    @Konstruct.hook("start")
    def androidPreBuild():
        Deps.append("android-sdk")

    @Konstruct.hook("preBuild")
    def androidPreBuild():
        Platform.setEnviron(Vars.get("androidEnvClang"))

#####

Deps.set("gyp", "c-ares", "openssl", "zlib")
Vars.set("depsRepo", DEPEDENCY_REPO)

@CommandLine.option("--mac-sdk-version", default="")
def macSdkVersion(version):
    if version:
        Gyp.set("mac_sdk_version", version)

def findAppleSDK(type='macosx'):
    import re
    type = type.lower()
    if type not in [ 'macosx', 'iphoneos', 'iphonesimulator']:
        Log.error("Invalid Apple SDK type %s" % type)
        exit()

    cmd = 'xcodebuild -showsdks'
    code, output = Utils.run(cmd, failExit=True, returnOutput=True)
    if code != 0 or output is None:
        return None

    output = output.split("\n")
    sdks = []
    for line in output:
        if type in line:
            v = re.search(type + "([0-9\.]+)", line)
            if v is not None:
                sdks.append(v.group(1))

    return sdks[len(sdks) - 1]

if Platform.system == "Darwin":
    sdk = findAppleSDK()
    if sdk is None:
       Utils.exit("No macos SDK detected. Make sure Xcode is correctly installed and configured")
    Gyp.set("mac_sdk_version", sdk)

if __name__ == '__main__':
    Gyp.setArgs("--depth ./ --include=gyp/config.gypi --include=gyp/common.gypi")
    Build.add(Gyp("gyp/network.gyp"));
    Konstruct.start()