build.gradle

/*
 * Starcoder - a server to read/write data from/to the stars, written in Go.
 * Copyright (C) 2018 InfoStellar, Inc.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */




import com.google.common.io.CharStreams
import com.google.common.io.LineProcessor

buildscript {
    repositories {
        jcenter()
        mavenCentral()
        gradlePluginPortal()
        maven {
            url 'http://dl.bintray.com/curioswitch/curiostack'
        }
        maven {
            url 'http://palantir.bintray.com/releases'
        }
        mavenLocal()
    }
    dependencies {
        classpath 'org.curioswitch.curiostack:gradle-curiostack-plugin:0.0.162.5'
    }
}

apply plugin: 'org.curioswitch.gradle-curiostack-plugin'
apply plugin: 'org.curioswitch.gradle-golang-plugin'
apply plugin: 'org.curioswitch.gradle-grpc-api-plugin'

repositories {
    jcenter()
    mavenCentral()
}

conda {
    gnuradio {
        version = 'Miniconda2-4.4.10'
        packages = [
                'autoconf',
                'automake',
                'boost',
                'cmake',
                'gcc_linux-64',
                'gfortran_linux-64',
                'gxx_linux-64',
                'git',
                'gsl',
                'libtool',
                'llvm',
                'make',
                'numpy',
                'pkg-config',
                'protobuf',
                'subprocess32',
                'swig',
                'wget',
                'libpng',
        ]
        pythonPackages = [
                'cheetah',
                'construct',
                'google-auth',
                'grpcio',
                'grpcio-testing',
                'lxml',
                'mako',
                'matplotlib',
                'pybombs',
                'requests',
                'ruamel.yaml==0.15.51',
                'stellarstation',
        ]
    }
}

golang {
    conda = 'gnuradio'
}

protobuf {
    generateProtoTasks {
        all().each { task ->
            task.plugins {
                gofast {
                    option 'plugins=grpc'
                    option 'paths=source_relative'
                    option 'Mgoogle/protobuf/duration.proto=github.com/gogo/protobuf/types'
                    option 'Mgoogle/protobuf/timestamp.proto=github.com/gogo/protobuf/types'
                    // Output into root directory for gogradle
                    outputSubDir = '../../../../../api'
                }
            }
        }
    }
    plugins {
        gofast {
            path = project.file("${gopath}/bin/protoc-gen-gofast")
        }
    }
}

sourceSets {
    main {
        proto {
            srcDir 'api'
        }
    }
}

task deleteGeneratedFiles(type: Delete) {
    delete fileTree(project.projectDir) {
        include '**/*.pb.go'
        include '**/*.mock.go'
        include '**/rice-box.go'
    }
}
tasks.clean.dependsOn deleteGeneratedFiles

gcloud {
    clusterBaseName = 'infostellar-starcoder'
    cloudRegion = 'asia-northeast1'
}

// protobuf-gradle-plugin always apply Java plugin, but we don't need it.
tasks.compileJava.enabled = false
tasks.compileTestJava.enabled = false

license {
    header file('LICENSE.header')
    mapping {
        proto = 'SLASHSTAR_STYLE'
    }
}

ext.gnuradioRoot = toolManager.getToolDir('gnuradio')

def condaCommand(command) {
    return """
    . ${gnuradioRoot.resolve('etc/profile.d/conda.sh')} && \\
    conda activate > /dev/null && \\
    ${command}
    """
}

task installProtocGoPlugin(type: org.curioswitch.gradle.golang.tasks.GoTask) {
    args 'get', 'github.com/gogo/protobuf/protoc-gen-gofast@v1.1.1'
}
task installRice(type: org.curioswitch.gradle.golang.tasks.GoTask) {
    args 'get', 'github.com/GeertJohan/go.rice/rice@c02ca9a983da5807ddf7d796784928f5be4afd09'
}

task useRice(type:Exec) {
    dependsOn installRice
    inputs.dir 'flowgraphs'
    outputs.file 'cmd/rice-box.go'

    workingDir project.file('cmd').toString()
    commandLine project.file("${gopath}/bin/rice").toString(), 'embed-go'
}

afterEvaluate {
    tasks.generateProto.dependsOn installProtocGoPlugin
    tasks.withType(org.curioswitch.gradle.golang.tasks.GoTask).configureEach {task->
        if (task.name.startsWith('goBuild') || task.name == 'goTest') {
            task.dependsOn tasks.generateProto, useRice
            task.execCustomizer {exec->
                exec.environment 'PKG_CONFIG_PATH', "${gnuradioRoot}/lib/pkgconfig"
                exec.environment 'CPLUS_INCLUDE_PATH', "${gnuradioRoot}/include"
            }
        }
    }
}

task setupPrefix(type: org.curioswitch.gradle.conda.tasks.CondaExecTask) {
    onlyIf { !project.file("${gnuradioRoot}/lib/libgnuradio-blocks.so").exists() }

    dependsOn 'toolsSetupGnuradio'

    condaName 'gnuradio'

    command """pybombs auto-config && \\
        pybombs -y recipes add gr-starcoder ${project.file('gr-recipes')} && \\
        pybombs -y recipes add-defaults && \\
        pybombs -y -v prefix init ${gnuradioRoot} -a gnuradio -R gnuradio-nogui && \\
        ${gnuradioRoot}/lib/uhd/utils/uhd_images_downloader.py
    """

    execCustomizer {exec->
        // For some reason, cmake has trouble finding boost in certain situations.
        exec.environment 'BOOST_ROOT', gnuradioRoot
        exec.environment 'PKG_CONFIG_PATH', "${gnuradioRoot}/lib/pkgconfig"

        if (System.getenv('CI')) {
            def stdOutPipedInput = new PipedInputStream()
            def stdOutPipedOutput = new PipedOutputStream(stdOutPipedInput)

            def readerThread = Thread.startDaemon {
                def standardLogPrefixes = ['Cloning', 'Configuring', 'Building', 'Installing']

                def previousLogPrefix = ''

                def reader = new BufferedReader(new InputStreamReader(stdOutPipedInput))
                CharStreams.readLines(reader, new LineProcessor<Void>() {
                    @Override
                    boolean processLine(String line) throws IOException {
                        // Don't print empty lines
                        if (line.trim() == '') {
                            return true
                        }

                        // Don't spam with percentages.
                        if (line.contains("%")) {
                            return true
                        }

                        // Only print cmake logs once per type
                        for (logPrefix in standardLogPrefixes) {
                            if (line.startsWith(logPrefix)) {
                                if (previousLogPrefix == logPrefix) {
                                    return true
                                }
                                previousLogPrefix = logPrefix
                                break
                            }
                        }

                        println line
                        return true
                    }

                    @Override
                    Void getResult() {
                        return null
                    }
                })
            }

            exec.standardOutput = stdOutPipedOutput
        }
    }

    doFirst {
        // Trick cmake into thinking pygtk exists to allow normal grc installation. We don't actually
        // use gtk so this shouldn't cause problems.
        copy {
            from project.file('mockpygtk')
            into "${gnuradioRoot}/lib/python2.7/site-packages/gtk"
        }
    }

    doLast {
        delete "${gnuradioRoot}/src"
    }
}

task compileGrStarcoder(type: org.curioswitch.gradle.conda.tasks.CondaExecTask) {
    dependsOn setupPrefix

    condaName 'gnuradio'

    command """cmake ../../gr-starcoder -DCMAKE_BUILD_TYPE=RelWithDebInfo -DCMAKE_INSTALL_PREFIX=${gnuradioRoot} -Wno-dev && \\
        make
    """

    execCustomizer {exec->
        exec.workingDir project.file('build/starcoder-cmake')
        exec.environment 'PKG_CONFIG_PATH', "${gnuradioRoot}/lib/pkgconfig"
    }

    doFirst {
        project.mkdir('build/starcoder-cmake')
    }
}

task installGrStarcoder(type: org.curioswitch.gradle.conda.tasks.CondaExecTask) {
    dependsOn compileGrStarcoder

    condaName 'gnuradio'

    command 'make install'

    execCustomizer {exec->
        exec.workingDir project.file('build/starcoder-cmake')
        exec.environment 'PKG_CONFIG_PATH', "${gnuradioRoot}/lib/pkgconfig"
    }
}

task testGrStarcoder(type: org.curioswitch.gradle.conda.tasks.CondaExecTask) {
    dependsOn installGrStarcoder

    condaName 'gnuradio'

    command 'make test ARGS=-VV'

    execCustomizer {exec->
        exec.workingDir project.file('build/starcoder-cmake')
        exec.environment 'PKG_CONFIG_PATH', "${gnuradioRoot}/lib/pkgconfig"
    }
}

task compileGrStarcoderUtils(type: org.curioswitch.gradle.conda.tasks.CondaExecTask) {
    dependsOn setupPrefix

    condaName 'gnuradio'

    command """cmake ../../gr-starcoder_utils -DCMAKE_BUILD_TYPE=RelWithDebInfo -DCMAKE_INSTALL_PREFIX=${gnuradioRoot} -Wno-dev && \\
        make
    """

    execCustomizer {exec->
        exec.workingDir project.file('build/starcoder_utils-cmake')
        exec.environment 'PKG_CONFIG_PATH', "${gnuradioRoot}/lib/pkgconfig"
    }

    doFirst {
        project.mkdir('build/starcoder_utils-cmake')
    }
}

task installGrStarcoderUtils(type: org.curioswitch.gradle.conda.tasks.CondaExecTask) {
    dependsOn compileGrStarcoderUtils

    condaName 'gnuradio'

    command 'make install'

    execCustomizer {exec->
        exec.workingDir project.file('build/starcoder_utils-cmake')
        exec.environment 'PKG_CONFIG_PATH', "${gnuradioRoot}/lib/pkgconfig"
    }
}

task testGrStarcoderUtils(type: org.curioswitch.gradle.conda.tasks.CondaExecTask) {
    dependsOn installGrStarcoderUtils

    condaName 'gnuradio'

    command 'make test ARGS=-VV'

    execCustomizer {exec->
        exec.workingDir project.file('build/starcoder_utils-cmake')
        exec.environment 'PKG_CONFIG_PATH', "${gnuradioRoot}/lib/pkgconfig"
    }
}


tasks.test.dependsOn testGrStarcoder
tasks.test.dependsOn testGrStarcoderUtils

task installGrStarcoderFromRecipe(type: org.curioswitch.gradle.conda.tasks.CondaExecTask) {
    dependsOn setupPrefix

    condaName 'gnuradio'

    command 'pybombs -y install gr-starcoder'

    execCustomizer {exec->
        exec.environment 'PKG_CONFIG_PATH', "${gnuradioRoot}/lib/pkgconfig"
        exec.environment 'PYBOMBS_PREFIX', gnuradioRoot
    }
}

task installStarcoder(type: Copy) {
    dependsOn build
    from 'build/exe/current'
    into "${gnuradioRoot}/bin"
}

task install {
    dependsOn installGrStarcoder, installGrStarcoderUtils, installStarcoder
}

task clangFormat(type: org.curioswitch.gradle.conda.tasks.CondaExecTask) {
    dependsOn 'toolsSetupGnuradio'

    def ccFiles = fileTree('.').filter { it.isFile() && it.name.endsWith('.cc') }.files.path.join(' ')
    def hIncFiles = fileTree('./gr-starcoder/include').filter { it.isFile() && it.name.endsWith('.h') }.files.path.join(' ')
    def hLibFiles = fileTree('./gr-starcoder/lib').filter { it.isFile() && it.name.endsWith('.h') }.files.path.join(' ')
    def hIncFilesUtil = fileTree('./gr-starcoder_utils/include').filter { it.isFile() && it.name.endsWith('.h') }.files.path.join(' ')
    def hLibFilesUtil = fileTree('./gr-starcoder_utils/lib').filter { it.isFile() && it.name.endsWith('.h') }.files.path.join(' ')

    condaName 'gnuradio'

    command "clang-format -style=Google -i ${ccFiles} ${hIncFiles} ${hLibFiles} ${hIncFilesUtil} ${hLibFilesUtil}"
}