| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you 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. |
| */ |
| apply plugin: 'java' |
| apply plugin: 'groovy' |
| apply plugin: 'download-task' |
| |
| final String VERBOSE = "verbose" |
| final String BOM = "bigtop.mk" |
| |
| //HashMap <String, String> |
| def BOM_map = [ |
| APACHE_MIRROR: "http://apache.osuosl.org", |
| APACHE_ARCHIVE: "http://archive.apache.org/dist", |
| BASE_DIR: projectDir.absolutePath, |
| BUILD_DIR: projectDir.absolutePath + "/build", |
| OUTPUT_DIR: projectDir.absolutePath + "/output", |
| DIST_DIR: projectDir.absolutePath + "/dist", |
| DL_DIR: projectDir.absolutePath + "/dl", |
| BIGTOP_BOM: '', |
| BIGTOP_BUILD_STAMP: '' |
| ] |
| |
| def final BIGTOP_BOM = 'BIGTOP_BOM' |
| |
| def final BASE_DIR = BOM_map['BASE_DIR'] |
| def final REPO_DIR = "${BOM_map['BASE_DIR']}/bigtop-repos" |
| def final BUILD_DIR = BOM_map['BUILD_DIR'] |
| def final OUTPUT_DIR = BOM_map['OUTPUT_DIR'] |
| def final DIST_DIR = BOM_map['DIST_DIR'] |
| def final DL_DIR = BOM_map['DL_DIR'] |
| def final BIGTOP_BUILD_STAMP = System.getenv('BIGTOP_BUILD_STAMP') ?: BOM_map['BIGTOP_BUILD_STAMP'] |
| |
| def targets = [] |
| def components = [] |
| |
| // Package building and logic around it |
| |
| def touchTargetFile = { fileName -> |
| // to comply with make build |
| GFileUtils.touch new File(fileName) |
| } |
| def ifExists = { url -> |
| if (url == null) return |
| URLConnection uCon = new URL(url).openConnection() |
| return (uCon as HttpURLConnection).responseCode == 200 |
| } |
| def getDate() { |
| new Date().format('E, dd MMM yyyy HH:mm:ss Z') |
| } |
| |
| task showHelp << { |
| targets.each { target -> |
| println (target + "\n\t[" + tasks.findAll { alltask -> alltask.name.startsWith(target)}*.name.join(", ") + "]") |
| } |
| } |
| |
| def genTasks = { target, variable -> |
| task "${target}-download" (dependsOn: "${target}_vardefines") << { |
| description "Download $target artifacts" |
| |
| def final TARBALL_SRC = BOM_map[variable + '_TARBALL_SRC'] |
| def final DOWNLOAD_DST = BOM_map[variable + '_DOWNLOAD_DST'] |
| def final DOWNLOAD_URL = BOM_map[variable + '_DOWNLOAD_URL'] |
| |
| if (!DOWNLOAD_DST) |
| return |
| |
| mkdir(DL_DIR) |
| if (TARBALL_SRC?.isEmpty() || new File(DOWNLOAD_DST)?.exists() || new File(BOM_map[variable + '_TARGET_DL'])?.exists()) { |
| println "\tFile $DOWNLOAD_DST appears to be already downloaded. Exiting..." |
| return |
| } |
| download { |
| src DOWNLOAD_URL |
| dest DOWNLOAD_DST |
| } |
| touchTargetFile(BOM_map[variable + '_TARGET_DL']) |
| } |
| task "${target}-tar" (dependsOn: ["${target}_vardefines", "${target}-download"]) << { |
| if (new File(BOM_map[variable + '_TARGET_TAR'])?.exists()) { |
| println "\tNothing to do. Exiting..." |
| return |
| } |
| description "Preparing a tarball for $target artifacts" |
| def final TAR_DIR = BOM_map[variable + '_TAR_DIR'] |
| def final TARBALL_SRC = BOM_map[variable + '_TARBALL_SRC'] ?: "" |
| def final DOWNLOAD_DST = BOM_map[variable + '_DOWNLOAD_DST'] ?: "" |
| def final SEED_TAR = BOM_map[variable + '_SEED_TAR'] |
| def UNPACK = "tar -xzf" |
| def PATCHES = "" |
| |
| if (TARBALL_SRC.empty) |
| PATCHES="/dev/null" |
| if (TARBALL_SRC.endsWith('.zip')) { |
| PATCHES="/dev/null" |
| UNPACK = "unzip" |
| } |
| delete(TAR_DIR); mkdir(TAR_DIR) |
| println "PATCHES are $PATCHES" |
| if (!PATCHES.empty) { |
| println "Non-empty patches" |
| if (!TARBALL_SRC.empty) { |
| exec { |
| workingDir TAR_DIR |
| commandLine "$UNPACK $DOWNLOAD_DST".split(' ') |
| } |
| def unpacked = new File(TAR_DIR) |
| if (unpacked.list().size() == 1) { |
| def TOP_LEVEL_DIR = unpacked.list()[0] |
| fileTree ("$TAR_DIR/$TOP_LEVEL_DIR") { |
| include '**/*' |
| }.copy { into TAR_DIR } |
| delete(TOP_LEVEL_DIR) |
| } |
| } else { |
| copy { |
| from 'LICENSE' |
| into TAR_DIR |
| } |
| } |
| /* |
| // TODO fix the patching |
| (cd $(BASE_DIR)/bigtop-packages/src/common/$($(PKG)_NAME); cat $$PATCHES)| \ |
| (cd $($(PKG)_TAR_DIR) ; patch -p0 ; cd .. ; tar czf $($(PKG)_SEED_TAR) *) ;\ |
| */ |
| def command = [ |
| '-c', 'tar', '"', |
| '-czf', |
| SEED_TAR, |
| '*', '"' |
| ] |
| exec { |
| workingDir "$TAR_DIR/.." |
| commandLine "tar -czf $SEED_TAR ${new File("$TAR_DIR/..").list().join(' ')}".split(' ') |
| } |
| } else { |
| println "Copy $DOWNLOAD_DST to $SEED_TAR" |
| copy { |
| from DOWNLOAD_DST |
| into BOM_map['BUILD_DIR'] + "/$target/tar/" |
| rename TARBALL_SRC, SEED_TAR |
| } |
| } |
| touchTargetFile(BOM_map[variable + '_TARGET_TAR']) |
| } |
| |
| // Keeping the reference to deb task to be used later for correct sequencing |
| Task tdeb = task "$target-deb" (dependsOn: "${target}-sdeb") << { |
| if (new File(BOM_map[variable + '_TARGET_DEB'])?.exists()) { |
| println "\tNothing to do. Exiting..." |
| return |
| } |
| description "Buildind DEB for $target artifacts" |
| def final PKG_NAME = BOM_map[variable + '_NAME'] |
| def final PKG_RELEASE = BOM_map[variable + '_PKG_RELEASE'] |
| def final PKG_VERSION = BOM_map[variable + '_PKG_VERSION'] |
| def final PKG_OUTPUT_DIR = BOM_map[variable + '_OUTPUT_DIR'] |
| def final BASE_VERSION = BOM_map[variable + '_BASE_VERSION'] |
| def final RELEASE_VERSION = BOM_map[variable + '_RELEASE_VERSION'] |
| def final SRCDEB = "${PKG_NAME}_$PKG_VERSION${BIGTOP_BUILD_STAMP}-${PKG_RELEASE}.dsc" |
| |
| exec { |
| workingDir PKG_OUTPUT_DIR |
| commandLine "dpkg-source -x $SRCDEB".split(' ') |
| } |
| // Order of debuild parameters is important; hence specifying explicitely rather |
| // than in an array of args |
| def command = """debuild \ |
| --preserve-envvar PATH \ |
| --preserve-envvar JAVA32_HOME \ |
| --preserve-envvar JAVA64_HOME \ |
| --preserve-envvar FORREST_HOME \ |
| --preserve-envvar MAVEN3_HOME \ |
| --preserve-envvar MAVEN_OPTS \ |
| --preserve-envvar JAVA_HOME \ |
| --preserve-envvar SCALA_HOME \ |
| --set-envvar=${variable}_BASE_VERSION=$BASE_VERSION \ |
| --set-envvar=${variable}_VERSION=$PKG_VERSION$BIGTOP_BUILD_STAMP \ |
| --set-envvar=${variable}_RELEASE=$RELEASE_VERSION \ |
| -uc -us -b |
| """ |
| exec { |
| workingDir "$PKG_OUTPUT_DIR/$PKG_NAME-$PKG_VERSION$BIGTOP_BUILD_STAMP" |
| commandLine command.split(' ') |
| } |
| delete ("$PKG_OUTPUT_DIR/$PKG_NAME-$PKG_VERSION$BIGTOP_BUILD_STAMP") |
| touchTargetFile(BOM_map[variable + '_TARGET_DEB']) |
| } |
| // Guarantee that tasks are ran in the order set by BOM file |
| if (targets.size() > 0) |
| tdeb.mustRunAfter "${targets.get(targets.size() - 1)}-deb" |
| task "$target-sdeb" (dependsOn: ["${target}_vardefines", "${target}-tar"]) << { |
| if (new File(BOM_map[variable + '_TARGET_SDEB'])?.exists()) { |
| println "\tNothing to do. Exiting..." |
| return |
| } |
| description "Buildind SDEB for $target artifacts" |
| def final PKG_BUILD_DIR = BOM_map[variable + '_BUILD_DIR'] |
| def final PKG_NAME = BOM_map[variable + '_NAME'] |
| def final SEED_TAR = BOM_map[variable + '_SEED_TAR'] |
| def final PKG_VERSION = BOM_map[variable + '_PKG_VERSION'] |
| def final RELEASE_VERSION = BOM_map[variable + '_RELEASE_VERSION'] |
| def final PKG_OUTPUT_DIR = BOM_map[variable + '_OUTPUT_DIR'] |
| delete ("$PKG_BUILD_DIR/deb") |
| def final DEB_BLD_DIR = "$PKG_BUILD_DIR/deb/$PKG_NAME-${PKG_VERSION}${BIGTOP_BUILD_STAMP}" |
| mkdir (DEB_BLD_DIR) |
| copy { |
| from SEED_TAR |
| into "$PKG_BUILD_DIR/deb/" |
| rename BOM_map[variable + '_TARBALL_DST'], "${PKG_NAME}_${PKG_VERSION}${BIGTOP_BUILD_STAMP}.orig.tar.gz" |
| } |
| exec { |
| workingDir DEB_BLD_DIR |
| commandLine "tar --strip-components 1 -xvf $DEB_BLD_DIR/../${PKG_NAME}_${PKG_VERSION}${BIGTOP_BUILD_STAMP}.orig.tar.gz".split(' ') |
| } |
| fileTree ("${BASE_DIR}/bigtop-packages/src/deb/$PKG_NAME") { |
| include '**/*' |
| }.copy { into "$DEB_BLD_DIR/debian" } |
| copy { |
| from "${BASE_DIR}/bigtop-packages/src/templates/init.d.tmpl" |
| into "$DEB_BLD_DIR/debian" |
| } |
| fileTree ("$BASE_DIR/bigtop-packages/src/common/$PKG_NAME") { |
| include '**/*' |
| }.copy { into "$DEB_BLD_DIR/debian" } |
| // Prepeare bom file with all the versions |
| def bomWriter = new File("$DEB_BLD_DIR/debian/bigtop.bom").newWriter() |
| BOM_map[BIGTOP_BOM].split(" ").each { bomWriter << "$it\n"} |
| bomWriter.close() |
| // Create changelog |
| def changelog = new File("$DEB_BLD_DIR/debian/changelog").newWriter() |
| changelog << "$PKG_NAME ($PKG_VERSION$BIGTOP_BUILD_STAMP-$RELEASE_VERSION) stable; urgency=low\n" |
| changelog << " Clean build\n" |
| changelog << " -- Bigtop <dev@bigtop.apache.org> ${getDate()}\n" |
| changelog.close() |
| // Deleting obsolete files |
| delete fileTree (dir: "$DEB_BLD_DIR/debian", includes: ['*.ex', '*.EX', '*.~']) |
| // Creating source package |
| exec { |
| workingDir DEB_BLD_DIR |
| commandLine "dpkg-buildpackage -uc -us -sa -S".split(' ') |
| } |
| mkdir(PKG_OUTPUT_DIR) |
| fileTree (dir: "$DEB_BLD_DIR/..", includes: ['*.dsc', '*.diff.gz', '*.debian.tar.gz', "*_source.changes", "*.orig.tar.gz"]).copy { |
| into PKG_OUTPUT_DIR |
| } |
| touchTargetFile(BOM_map[variable + '_TARGET_SDEB']) |
| } |
| task "$target-apt" (dependsOn: "$target-deb") << { |
| if (new File(BOM_map[variable + '_TARGET_APT'])?.exists()) { |
| println "\tNothing to do. Exiting..." |
| return |
| } |
| description "Creating APT repository for $target packages" |
| def final PKG_NAME = BOM_map[variable + '_NAME'] |
| def final PKG_RELEASE = BOM_map[variable + '_PKG_RELEASE'] |
| def final PKG_VERSION = BOM_map[variable + '_PKG_VERSION'] |
| def final PKG_OUTPUT_DIR = BOM_map[variable + '_OUTPUT_DIR'] |
| mkdir("$OUTPUT_DIR/apt/conf") |
| copy { |
| from "$REPO_DIR/apt/distributions" |
| into "$OUTPUT_DIR/apt/conf" |
| } |
| fileTree (PKG_OUTPUT_DIR) { |
| include "*.changes" |
| }.each { changeFile -> |
| exec { |
| workingDir BUILD_DIR |
| commandLine "reprepro -Vb $OUTPUT_DIR/apt include bigtop $changeFile".split(' ') |
| } |
| } |
| touchTargetFile(BOM_map["${variable}_TARGET_APT"]) |
| } |
| |
| // Keeping the reference to task to be used later for correct sequencing |
| Task trpm = task "$target-rpm" (dependsOn: ["${target}-srpm"]) << { |
| if (new File(BOM_map[variable + '_TARGET_RPM'])?.exists()) { |
| println "\tNothing to do. Exiting..." |
| return |
| } |
| description "Buildind RPM for $target artifacts" |
| def final PKG_BUILD_DIR = BOM_map[variable + '_BUILD_DIR'] |
| def final PKG_NAME = BOM_map[variable + '_NAME'] |
| def final PKG_NAME_FOR_PKG = PKG_NAME.replaceAll("-", "_") |
| def final PKG_OUTPUT_DIR = BOM_map[variable + '_OUTPUT_DIR'] |
| def final PKG_VERSION = BOM_map[variable + '_PKG_VERSION'] |
| def final BASE_VERSION = BOM_map[variable + '_BASE_VERSION'] |
| def final RELEASE_VERSION = BOM_map[variable + '_RELEASE_VERSION'] |
| def RELEASE_DIST = "rpmbuild --eval '%{?dist}' 2>/dev/null".execute().text.trim().replaceAll("'",'') |
| def SRCRPM="$PKG_OUTPUT_DIR/$PKG_NAME-${PKG_VERSION}$BIGTOP_BUILD_STAMP-${RELEASE_VERSION}${RELEASE_DIST}.src.rpm" |
| |
| def command = [ |
| '--define', "_topdir $PKG_BUILD_DIR/rpm/", |
| '--define', "${PKG_NAME_FOR_PKG}_base_version $BASE_VERSION", |
| '--define', "${PKG_NAME_FOR_PKG}_version ${PKG_VERSION}${BIGTOP_BUILD_STAMP}", |
| '--define', "${PKG_NAME_FOR_PKG}_release $RELEASE_VERSION%{?dist}", |
| '--rebuild', SRCRPM, |
| ] |
| exec { |
| workingDir BASE_DIR |
| executable 'rpmbuild' |
| args command |
| } |
| fileTree ("$PKG_BUILD_DIR/rpm/RPMS") { |
| include '**/*' |
| }.copy { into PKG_OUTPUT_DIR } |
| touchTargetFile(BOM_map[variable + '_TARGET_RPM']) |
| } |
| // Guarantee that tasks are ran in the order set by BOM file |
| if (targets.size() > 0) |
| trpm.mustRunAfter "${targets.get(targets.size() - 1)}-rpm" |
| task "$target-srpm" (dependsOn: ["${target}_vardefines" , "${target}-tar"]) << { |
| if (new File(BOM_map[variable + '_TARGET_SRPM'])?.exists()) { |
| println "\tNothing to do. Exiting..." |
| return |
| } |
| description "Buildind SRPM for $target artifacts" |
| def final PKG_BUILD_DIR = BOM_map[variable + '_BUILD_DIR'] |
| def final PKG_NAME = BOM_map[variable + '_NAME'] |
| def final SEED_TAR = BOM_map[variable + '_SEED_TAR'] |
| def final PKG_VERSION = BOM_map[variable + '_PKG_VERSION'] |
| def final RELEASE_VERSION = BOM_map[variable + '_RELEASE_VERSION'] |
| def final PKG_NAME_FOR_PKG = PKG_NAME.replaceAll("-", "_") |
| def final BASE_VERSION = BOM_map[variable + '_BASE_VERSION'] |
| def final PKG_OUTPUT_DIR = BOM_map[variable + '_OUTPUT_DIR'] |
| delete ("$PKG_BUILD_DIR/rpm") |
| fileTree ("${BASE_DIR}/bigtop-packages/src/rpm/$PKG_NAME") { |
| include '**/*' |
| }.copy { into "$PKG_BUILD_DIR/rpm" } |
| copy { |
| from SEED_TAR |
| into "$PKG_BUILD_DIR/rpm/SOURCES" |
| } |
| copy { |
| from "${BASE_DIR}/bigtop-packages/src/templates/init.d.tmpl" |
| into "$PKG_BUILD_DIR/rpm/SOURCES" |
| } |
| fileTree ("$BASE_DIR/bigtop-packages/src/common/$PKG_NAME") { |
| include '**/*' |
| }.copy { into "$PKG_BUILD_DIR/rpm/SOURCES" } |
| // Writing bigtop.bom files with all the versions |
| def bomWriter = new File("$PKG_BUILD_DIR/rpm/SOURCES/bigtop.bom").newWriter() |
| BOM_map[BIGTOP_BOM].split(" ").each { bomWriter << "$it\n"} |
| bomWriter.close() |
| def command = [ |
| '--define', "_topdir $PKG_BUILD_DIR/rpm/", |
| '--define', "${PKG_NAME_FOR_PKG}_base_version $BASE_VERSION", |
| '--define', "${PKG_NAME_FOR_PKG}_version ${PKG_VERSION}${BIGTOP_BUILD_STAMP}", |
| '--define', "${PKG_NAME_FOR_PKG}_release $RELEASE_VERSION%{?dist}", |
| '-bs', '--nodeps', "--buildroot=${PKG_BUILD_DIR}/rpm/INSTALL", |
| "${PKG_BUILD_DIR}/rpm/SPECS/${PKG_NAME}.spec", |
| ] |
| exec { |
| workingDir BASE_DIR |
| executable 'rpmbuild' |
| args command |
| } |
| mkdir(PKG_OUTPUT_DIR) |
| def RELEASE_DIST = "rpmbuild --eval '%{?dist}' 2>/dev/null".execute().text.trim().replaceAll("'",'') |
| copy { |
| from "$PKG_BUILD_DIR/rpm/SRPMS/${PKG_NAME}-${PKG_VERSION}${BIGTOP_BUILD_STAMP}-${RELEASE_VERSION}${RELEASE_DIST}.src.rpm" |
| into PKG_OUTPUT_DIR |
| } |
| touchTargetFile(BOM_map[variable + '_TARGET_SRPM']) |
| } |
| task "$target-yum" (dependsOn: "$target-rpm") << { |
| if (new File(BOM_map[variable + '_TARGET_YUM'])?.exists()) { |
| println "\tNothing to do. Exiting..." |
| return |
| } |
| description "Creating YUM repository for $target packages" |
| exec { |
| workingDir BUILD_DIR |
| commandLine "createrepo -o $OUTPUT_DIR $OUTPUT_DIR".split(' ') |
| } |
| touchTargetFile(BOM_map["${variable}_TARGET_YUM"]) |
| } |
| task "$target-version" << { |
| println "Base: ${BOM_map[variable + '_BASE_VERSION']}" |
| } |
| task "${target}_vardefines" << { |
| BOM_map[variable + '_NAME'] = target |
| BOM_map[variable + '_PKG_NAME'] = "${variable}_NAME" |
| BOM_map[variable + '_PKG_RELEASE'] = '1' |
| |
| BOM_map[variable + '_BUILD_DIR'] = BOM_map['BUILD_DIR'] + "/$target" |
| BOM_map[variable + '_OUTPUT_DIR'] = BOM_map['OUTPUT_DIR'] + "/$target" |
| BOM_map[variable + '_SOURCE_DIR'] = BOM_map['BUILD_DIR'] + "/source" |
| BOM_map[variable + '_TAR_DIR'] = BOM_map['BUILD_DIR'] + "/$target/tar/${target}-${BOM_map[variable + '_BASE_VERSION']}" |
| BOM_map[variable + '_SEED_TAR'] = BOM_map['BUILD_DIR'] + "/$target/tar/" + BOM_map[variable + '_TARBALL_DST'] |
| |
| BOM_map[variable + '_DOWNLOAD_URL'] = |
| (BOM_map[variable + '_SITE'] != null && BOM_map[variable + '_TARBALL_SRC'] != null) ? |
| BOM_map[variable + '_SITE'] + '/' + BOM_map[variable + '_TARBALL_SRC'] : null |
| BOM_map[variable + '_DOWNLOAD_DST'] = (BOM_map[variable + '_TARBALL_SRC'] != null) ? |
| DL_DIR + '/' + BOM_map[variable + '_TARBALL_SRC'] : null |
| |
| // test that the download url will return http 200. If it does not, use the ARCHIVE url instead of the MIRROR SITE url |
| if (!ifExists(BOM_map[variable + '_DOWNLOAD_URL'])) { |
| BOM_map[variable + '_DOWNLOAD_URL'] = BOM_map[variable + '_ARCHIVE'] + '/' + BOM_map[variable + '_TARBALL_SRC'] |
| } |
| |
| BOM_map[variable + '_TARGET_DL'] = BOM_map[variable + '_BUILD_DIR'] + '/.download' |
| BOM_map[variable + '_TARGET_TAR'] = BOM_map[variable + '_BUILD_DIR'] + '/.tar' |
| BOM_map[variable + '_TARGET_SRPM'] = BOM_map[variable + '_BUILD_DIR'] + '/.srpm' |
| BOM_map[variable + '_TARGET_RPM'] = BOM_map[variable + '_BUILD_DIR'] + '/.rpm' |
| BOM_map[variable + '_TARGET_YUM'] = BOM_map[variable + '_BUILD_DIR'] + '/.yum' |
| BOM_map[variable + '_TARGET_SDEB'] = BOM_map[variable + '_BUILD_DIR'] + '/.sdeb' |
| BOM_map[variable + '_TARGET_DEB'] = BOM_map[variable + '_BUILD_DIR'] + '/.deb' |
| BOM_map[variable + '_TARGET_APT'] = BOM_map[variable + '_BUILD_DIR'] + '/.apt' |
| BOM_map[variable + '_TARGET_RELNOTES'] = BOM_map[variable + '_BUILD_DIR'] + '/.relnotes' |
| |
| if (System.getProperty(VERBOSE)) { |
| BOM_map.keySet().findAll{ it.startsWith (variable) }. each { k -> |
| println "$k ${BOM_map.get(k)}" |
| } |
| } |
| } |
| |
| task "$target-info" (dependsOn: "${target}_vardefines") << { |
| println "Info for package $target" |
| println " Will download from URL: ${BOM_map[variable + '_DOWNLOAD_URL']}" |
| println " To destination file: ${BOM_map[variable + '_DOWNLOAD_DST']}" |
| println " Then unpack into ${BOM_map[variable + '_SOURCE_DIR']}" |
| println " And create a seed tarball ${BOM_map[variable + '_SEED_TAR']}" |
| |
| //TODO more about patches |
| println "Version: " + BOM_map[variable + '_BASE_VERSION'] |
| //TODO more about stamping |
| } |
| task "$target-relnotes" << { |
| description "Preparing release notes for $target. No yet implemented!!!" |
| } |
| task "$target-clean" (dependsOn: "${target}_vardefines") << { |
| def blDir = BOM_map[variable + '_BUILD_DIR'] |
| def outDir = BOM_map[variable + '_OUTPUT_DIR'] |
| description "Removing $target component $blDir and $outDir" |
| delete(blDir) |
| delete(BOM_map[variable + '_OUTPUT_DIR']) |
| } |
| task "$target-help" << { |
| println (target + "\n\t[" + tasks.findAll { alltask -> alltask.name.startsWith(target)}*.name.join(", ") + "]") |
| } |
| } |
| |
| def readBOM = { |
| |
| def buildUtils = new org.apache.bigtop.BuildUtils() |
| def bomfile = new File(BOM) |
| def envs = [] |
| |
| bomfile.eachLine { |
| if (!it.startsWith("#") && !it.isEmpty()) { |
| if (it.startsWith("\$(eval")) { |
| // should either match $(eval $(call PACKAGE,xxxx,XXXX)) |
| def pattern = ~/.*call PACKAGE,(\w+[-\w+]*),(\w+)/ |
| def m = it =~ pattern |
| def variable = "" |
| if (m.size() == 1) { |
| def target = m[0][1] |
| variable = m[0][2] |
| genTasks(target, variable) |
| targets.add(target) |
| } else { |
| // or match $(eval BIGTOP_BOM += XXXX_VERSION=$(XXXX_VERSION)) |
| pattern = ~/.*BIGTOP_BOM \+= (\w+)_VERSION=\$\((\w+)_VERSION\)\).*/ |
| m = it =~ pattern |
| print m.size() |
| assert(m.size() == 1) |
| assert( m[0][1]== m[0][2]) |
| variable = m[0][1] |
| } |
| // Store the component name in the list |
| components.add(variable) |
| return |
| } |
| envs = it?.split("=") |
| def value = buildUtils.evaluateBOM(BOM_map, envs[1]) |
| value = System.getProperty(envs[0]) ?: value |
| BOM_map.put(envs[0], value) |
| } |
| } |
| } |
| |
| // We need to make sure that all dynamic tasks are available for invocation |
| project.afterEvaluate { |
| readBOM() |
| def bomVersions = "" |
| components.each { component -> |
| bomVersions += "${component + '_VERSION'}=${BOM_map[component + '_BASE_VERSION']} " |
| } |
| BOM_map[BIGTOP_BOM] = bomVersions |
| if (System.getProperty(VERBOSE))println "BIGTOP_BOM:\n${BOM_map[BIGTOP_BOM]}" |
| // Putting all targets of different types into one common target |
| task "srpm" (dependsOn: tasks.findAll { alltask -> alltask.name.endsWith("-srpm")}*.name) << { } |
| task "rpm" (dependsOn: tasks.findAll { alltask -> alltask.name.endsWith("-rpm")}*.name) << { } |
| task "yum" (dependsOn: tasks.findAll { alltask -> alltask.name.endsWith("-yum")}*.name) << { } |
| task "sdeb" (dependsOn: tasks.findAll { alltask -> alltask.name.endsWith("-sdeb")}*.name) << { } |
| task "deb" (dependsOn: tasks.findAll { alltask -> alltask.name.endsWith("-deb")}*.name) << { } |
| task "apt" (dependsOn: tasks.findAll { alltask -> alltask.name.endsWith("-apt")}*.name) << { } |
| |
| task clean (overwrite: true, dependsOn: tasks.findAll { alltask -> alltask.name.endsWith("-clean")}*.name) << { |
| description "Cleaning all components' build and output directories. Overwrites standard clean task" |
| } |
| task allclean (dependsOn: clean ) << { |
| description "Removing $BUILD_DIR, $OUTPUT_DIR, and $DIST_DIR" |
| delete (BUILD_DIR) |
| delete (OUTPUT_DIR) |
| delete (DIST_DIR) |
| } |
| task realclean (dependsOn: allclean) << { |
| description "Removing $BUILD_DIR, $OUTPUT_DIR, $DIST_DIR, and $DL_DIR" |
| delete (DL_DIR) |
| } |
| |
| task "all" (dependsOn: [srpm, sdeb]) |
| } |
| |
| defaultTasks 'showHelp' |