build.wake

# Copyright 2019 SiFive, Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You should have received a copy of LICENSE.Apache2 along with
# this software. If not, you may obtain a copy at
#
#    https://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.

package build_wake

from wake import _

# Useful build variants (arguments to all)
def toVariant = match _
    "default" -> Pass (Pair "native-cpp14-release" "native-c11-release")
    "static" -> Pass (Pair "native-cpp14-static" "native-c11-static")
    "debug" -> Pass (Pair "native-cpp14-debug" "native-c11-debug")
    "wasm" -> Pass (Pair "wasm-cpp14-release" "wasm-c11-release")
    s -> Fail "Unknown build target ({s})".makeError

export def build: List String => Result String Error = match _
    "tarball", Nil ->
        tarball Unit
        | rmap (\_ "TARBALL")
    "wasm", Nil ->
        require Pass variant = toVariant "wasm"

        buildLSP variant
        | rmap format
    kind, Nil ->
        require Pass variant = toVariant kind

        all variant
        | rmap (\_ "BUILD")
    _ -> Fail "no target specified (try: build default/debug/tarball)".makeError

export def install: List String => Result String Error = match _
    dest, kind, Nil ->
        doInstall (in cwd dest) kind
        | rmap (\_ "INSTALL")
    dest, Nil ->
        doInstall (in cwd dest) "default"
        | rmap (\_ "INSTALL")
    _ -> Fail "no directory specified (try: install /opt/local)".makeError

def bootstrapTarget targetFn variant =
    require Pass paths = targetFn variant

    require Some _ = getenv "BOOTSTRAP_WAKE"
    else Pass paths

    def cppSuffixRegex =
        (".", variant.getPairFirst, Nil)
        | cat
        | quote

    def cSuffixRegex =
        (".", variant.getPairSecond, Nil)
        | cat
        | quote

    def getInstallName path =
        path.getPathName
        | replace cppSuffixRegex ""
        | replace cSuffixRegex ""

    def doInstall path =
        def location = getInstallName path

        def installed =
            makeExecPlan ("cp", path.getPathName, location, Nil) (path,)
            | setPlanLabel "Bootstrap {location}"
            | runJobWith defaultRunner
            | getJobOutputs

        match installed
            Pass (first, Nil) -> Pass first
            _ -> Fail "Unexpected arity in  bootstrap install".makeError

    paths
    | map doInstall
    | findFail

# Build all wake targets
def targets =
    buildWake,
    buildWakeBox,
    buildFuseDaemon,
    buildShim,
    buildHash,
    buildBSP,
    (bootstrapTarget buildLSP),
    buildWakeFormat,
    (bootstrapTarget buildJobCache),
    Nil

def all variant =
    require Pass x =
        map (_ variant) targets
        | findFail

    Pass (flatten x)

# Install wake into a target location
def doInstall dest kind =
    # kick off in parallel, but rsc, rsc_tool, and rsc_migration cannot be built at the same
    # time right now. Force them to be serial relative to each other.
    def install_rsc_bins =
        require Pass rsc_migration = buildRSCMigration Unit
        require Pass rsc_migration = installAs "{dest}/bin/wake-rsc-migration" rsc_migration
        require Pass rsc = buildRSC Unit
        require Pass rsc = installAs "{dest}/bin/wake-rsc" rsc
        require Pass rsc_tool = buildRSCTool Unit
        require Pass rsc_tool = installAs "{dest}/bin/wake-rsc-tool" rsc_tool

        Pass (Triple rsc rsc_tool rsc_migration)

    def install_log_viewer =
        buildWakeLogViewer Unit
        | rmapPass (installAs "{dest}/bin/wake-log-viewer")

    def install_datfiles =
        sources "{@here}/share" `.*`
        | rmapPass (\files findFailFn (installIn dest ".") files)

    def install_readme =
        source "README.md"
        | rmapPass (\file installIn "{dest}/share/doc/wake" "." file)

    require Pass variant = toVariant kind

    def releaseBin exe = installAs "{dest}/{replace `\.[^.]*$` '' exe.getPathName}" exe

    def install_binfiles =
        all variant
        | rmapPass (\files findFailFn releaseBin files)

    # Join on the installs now that everything has been kicked off
    require Pass readme = install_readme
    require Pass datfiles = install_datfiles
    require Pass binfiles = install_binfiles

    # Rust builds are slow, delay blocking on them for as long as possible
    require Pass (Triple rsc rsc_tool rsc_migration) = install_rsc_bins
    require Pass log_viewer = install_log_viewer

    (readme, log_viewer, rsc, rsc_tool, rsc_migration, binfiles ++ datfiles)
    | Pass

# Replace @VERSION@ with 'release'
def setVersion release file =
    require Pass in = source "{file}.in"

    def script =
        """
        set -e
        sed "s/@VERSION@/%{release}/g" "%{in.getPathName}" > "%{file}.tmp"
        mv "%{file}.tmp" "%{file}"
        """

    makeShellPlan script (in, Nil)
    | setPlanLabel "release: replace placeholder with version number"
    | runJobWith defaultRunner
    | getJobOutput

# Create a release tarball
def tarball Unit =
    def releaseResult = buildAs Unit
    def timeResult = buildOn Unit

    require Pass release = releaseResult
    require Pass time = timeResult

    # Create debian + RedHat package files
    require Pass changelog = setVersion release "debian/changelog"
    require Pass spec = setVersion release "wake.spec"

    # Identify those sources files to include in the tarball
    require Pass allSources = sources "." `.*`

    def excludeGlobs =
        "**/.gitignore",
        ".circleci/**",
        "debian/**",
        ".github/**",
        ".vscode/**",
        ".clang-format",
        ".dockerignore",
        ".git-blame-ignore-revs",
        ".gitattributes",
        ".wakemanifest",
        "wake.spec.in",

    def matchesAnyGlob path =
        excludeGlobs
        | map globToRegExp
        | exists (matches _ path.getPathName)

    def Pair rejects srcs =
        allSources
        | splitBy matchesAnyGlob

    def _ =
        def files = (rejects | map (\x (("  ", x.getPathName, Nil) | cat)))
        def msg = "Files below are excluded from tarball", files

        msg
        | map (printlnLevel logInfo _)

    def Pair testPaths wakePaths = splitBy (matches `tests/.*` _.getPathName) srcs

    def wakeSourcesString =
        wakePaths
        | map (_.getPathName.format)
        | foldr (_, ",\n    ", _) Nil
        | cat

    def testSourcesString =
        testPaths
        | map (getPathName _ | format | replace `^"tests/` '"{@here}/')
        | foldr (_, ",\n    ", _) Nil
        | cat

    def manifestStr =
        """
        # Generated by 'wake tarball Unit':
        package build_wake

        from wake import source , Nil

        publish releaseAs =
            '%{release}', Nil

        publish releaseOn =
            '%{time}', Nil

        publish source =
            %{wakeSourcesString}Nil
        """

    def testsManifestStr =
        """
        # Generated by 'wake tarball Unit':
        package test_wake

        from wake import source , Nil

        publish source =
            %{testSourcesString}Nil
        """

    # Create a manifest which describes the release and source files
    require Pass manifest = write "manifest.wake" manifestStr
    require Pass testManifest = write "tests/manifest.wake" testsManifestStr

    # Execute tar to create a tarball of manifest + sources
    require Pass tarball =
        def cmd =
            def gnutar = which "gnutar"
            def tar = if gnutar ==* "gnutar" then which "tar" else gnutar

            def files =
                map getPathName (manifest, testManifest, spec, srcs)
                | sortBy scmp

            tar,
            "--mtime={time}",
            "--transform=s@^@wake-{release}/@",
            "--owner=0",
            "--group=0",
            "--numeric-owner",
            "-cJf",
            "wake_{release}.tar.xz",
            files

        makeExecPlan cmd (manifest, testManifest, spec, srcs)
        | setPlanLabel "release: package wake source tarball"
        # Since this includes the current time, it's not going to benefit from caching.
        | setPlanKeep False
        | runJobWith defaultRunner
        | getJobOutput

    Pass (tarball, changelog, Nil)

export def static _: Result Path Error =
    def filesResult = doInstall "tmp" "static"
    def releaseResult = buildAs Unit
    def timeResult = buildOn Unit

    require Pass release = releaseResult
    require Pass time = timeResult
    require Pass files = filesResult

    def cmd =
        which "tar",
        "--mtime={time}",
        "--transform=s@^tmp/@wake-{release}/@",
        "--owner=0",
        "--group=0",
        "--numeric-owner",
        "-cJf",
        "wake-static_{release}.tar.xz",
        map getPathName files | sortBy scmp

    makeExecPlan cmd files
    | setPlanLabel "release: package wake-static tarball"
    # Since this includes the current time, it's not going to benefit from caching.
    | setPlanKeep False
    | runJobWith defaultRunner
    | getJobOutput

from test_wake import topic wakeTestBinary
from test_wake import topic wakeUnitTestBinary

publish wakeTestBinary =
    defaultWake, Nil

publish wakeUnitTestBinary =
    buildWakeUnit, Nil

def defaultWake Unit =
    require Pass wakeVisible = doInstall "tmp" "default"

    Pass (Pair "tmp/bin/wake" wakeVisible)