1 /*
   2  * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 /*
  27  * This file defines build profiles for the JIB tool and others.
  28  *
  29  * A build profile defines a set of configuration options and external
  30  * dependencies that we for some reason or other care about specifically.
  31  * Typically, build profiles are defined for the build configurations we
  32  * build regularly.
  33  *
  34  * Contract against this file from the tools that use it, is to provide
  35  * a function on the form:
  36  *
  37  * getJibProfiles(input)
  38  *
  39  * which returns an object graph describing the profiles and their
  40  * dependencies. The name of the function is based on the name of this
  41  * file, minus the extension and the '-', camel cased and prefixed with
  42  * 'get'.
  43  *
  44  *
  45  * The parameter 'input' is an object that optionally contains  some data.
  46  * Optionally because a tool may read the configuration for different purposes.
  47  * To initially get a list of available profiles, the active profile may not
  48  * yet be known for instance.
  49  *
  50  * Data that may be set on the input object:
  51  *
  52  * input.profile = <name of active profile>
  53  *
  54  * If the active profile is set, the following data from it must also
  55  * be provided:
  56  *
  57  * input.profile
  58  * input.target_os
  59  * input.target_cpu
  60  * input.build_os
  61  * input.build_cpu
  62  * input.target_platform
  63  * input.build_platform
  64  * // The build_osenv_* variables describe the unix layer on Windows systems,
  65  * // i.e. Cygwin, which may also be 32 or 64 bit.
  66  * input.build_osenv
  67  * input.build_osenv_cpu
  68  * input.build_osenv_platform
  69  *
  70  * For more complex nested attributes, there is a method "get":
  71  *
  72  * input.get("<dependency>", "<attribute>")
  73  *
  74  * Valid attributes are:
  75  * install_path
  76  * download_path
  77  * download_dir
  78  *
  79  *
  80  * The output data generated by this configuration file has the following
  81  * format:
  82  *
  83  * data: {
  84  *   // Identifies the version of this format to the tool reading it
  85  *   format_version: "1.0",
  86  *
  87  *   // Name of base outputdir. JIB assumes the actual output dir is formed
  88  *   // by adding the configuration name: <output_basedir>/<config-name>
  89  *   output_basedir: "build",
  90  *   // Configure argument to use to specify configuration name
  91  *   configuration_configure_arg:
  92  *   // Make argument to use to specify configuration name
  93  *   configuration_make_arg:
  94  *
  95  *   profiles: {
  96  *     <profile-name>: {
  97  *       // Name of os the profile is built to run on
  98  *       target_os; <string>
  99  *       // Name of cpu the profile is built to run on
 100  *       target_cpu; <string>
 101  *       // Combination of target_os and target_cpu for convenience
 102  *       target_platform; <string>
 103  *       // Name of os the profile is built on
 104  *       build_os; <string>
 105  *       // Name of cpu the profile is built on
 106  *       build_cpu; <string>
 107  *       // Combination of build_os and build_cpu for convenience
 108  *       build_platform; <string>
 109  *
 110  *       // List of dependencies needed to build this profile
 111  *       dependencies: <Array of strings>
 112  *
 113  *       // List of configure args to use for this profile
 114  *       configure_args: <Array of strings>
 115  *
 116  *       // List of free form labels describing aspects of this profile
 117  *       labels: <Array of strings>
 118  *     }
 119  *   }
 120  *
 121  *   // Dependencies use a Maven like deployment structure
 122  *   dependencies: {
 123  *     <dependency-name>: {
 124  *       // Organization part of path defining this dependency
 125  *       organization: <string>
 126  *       // File extension for this dependency
 127  *       ext: <string>
 128  *       // Module part of path for defining this dependency,
 129  *       // defaults to <dependency-name>
 130  *       module: <string>
 131  *       // Revision part of path for defining this dependency
 132  *       revision: <string>
 133  *
 134  *       // List of configure args to add when using this dependency,
 135  *       // defaults to
 136  *       // "--with-<dependency-name>=input.get("<dependency-name", "install_path")"
 137  *       configure_args: <array of strings>
 138  *
 139  *       // Name of environment variable to set when using this dependency
 140  *       // when running make
 141  *       environment_name: <string>
 142  *       // Value of environment variable to set when using this dependency
 143  *       // when running make
 144  *       environment_value: <string>
 145  *
 146  *       // Value to add to the PATH variable when using this dependency,
 147  *       // applies to both make and configure
 148  *       environment_path: <string>
 149  *     }
 150  *
 151  *     <dependency-name>: {
 152  *       // For certain dependencies where a legacy distribution mechanism is
 153  *       // already in place, the "javare" server layout is also supported
 154  *       // Indicate that an alternate server source and layout should be used
 155  *       server: "javare"
 156  *
 157  *       // For "javare", a combination of module, revision,
 158  *       // build number (optional), files and checksum file is possible for
 159  *       // artifacts following the standard layout.
 160  *       module: <string>
 161  *       revision: <string>
 162  *       build_number: <string>
 163  *       checksum_file: <string>
 164  *       file: <string>
 165  *
 166  *       // For other files, use checksum path and path instead
 167  *       checksum_path: <string>
 168  *       path: <string>
 169  *     }
 170  *   }
 171  * }
 172  */
 173 
 174 /**
 175  * Main entry to generate the profile configuration
 176  *
 177  * @param input External data to use for generating the configuration
 178  * @returns {{}} Profile configuration
 179  */
 180 var getJibProfiles = function (input) {
 181 
 182     var data = {};
 183 
 184     // Identifies the version of this format to the tool reading it
 185     data.format_version = "1.0";
 186 
 187     // Organization is used when uploading/publishing build results
 188     data.organization = "com.oracle.jpg.jdk";
 189 
 190     // The base directory for the build output. JIB will assume that the
 191     // actual build directory will be <output_basedir>/<configuration>
 192     data.output_basedir = "build";
 193     // The configure argument to use to specify the name of the configuration
 194     data.configuration_configure_arg = "--with-conf-name=";
 195     // The make argument to use to specify the name of the configuration
 196     data.configuration_make_arg = "CONF_NAME=";
 197 
 198     // Define some common values
 199     var common = getJibProfilesCommon(input);
 200     // Generate the profiles part of the configuration
 201     data.profiles = getJibProfilesProfiles(input, common);
 202     // Generate the dependencies part of the configuration
 203     data.dependencies = getJibProfilesDependencies(input, common);
 204 
 205     return data;
 206 };
 207 
 208 /**
 209  * Generates some common values
 210  *
 211  * @param input External data to use for generating the configuration
 212  * @returns Common values
 213  */
 214 var getJibProfilesCommon = function (input) {
 215     var common = {};
 216 
 217     common.dependencies = ["boot_jdk", "gnumake", "jtreg"],
 218     common.default_make_targets = ["product-bundles", "test-bundles"],
 219     common.default_make_targets_debug = common.default_make_targets;
 220     common.default_make_targets_slowdebug = common.default_make_targets;
 221     common.configure_args = ["--enable-jtreg-failure-handler"],
 222     common.configure_args_32bit = ["--with-target-bits=32"],
 223     common.configure_args_debug = ["--enable-debug"],
 224     common.configure_args_slowdebug = ["--with-debug-level=slowdebug"],
 225     common.organization = "jpg.infra.builddeps"
 226 
 227     return common;
 228 };
 229 
 230 /**
 231  * Generates the profiles part of the configuration.
 232  *
 233  * @param input External data to use for generating the configuration
 234  * @param common The common values
 235  * @returns {{}} Profiles part of the configuration
 236  */
 237 var getJibProfilesProfiles = function (input, common) {
 238     var profiles = {};
 239 
 240     // Main SE profiles
 241     var mainProfiles = {
 242 
 243         "linux-x64": {
 244             target_os: "linux",
 245             target_cpu: "x64",
 246             dependencies: concat(common.dependencies, "devkit"),
 247             configure_args: concat(common.configure_args, "--with-zlib=system"),
 248             default_make_targets: concat(common.default_make_targets, "docs-bundles")
 249         },
 250 
 251         "linux-x86": {
 252             target_os: "linux",
 253             target_cpu: "x86",
 254             build_cpu: "x64",
 255             dependencies: concat(common.dependencies, "devkit"),
 256             configure_args: concat(common.configure_args, common.configure_args_32bit,
 257                 "--with-jvm-variants=minimal,server", "--with-zlib=system"),
 258             default_make_targets: common.default_make_targets
 259         },
 260 
 261         "macosx-x64": {
 262             target_os: "macosx",
 263             target_cpu: "x64",
 264             dependencies: concat(common.dependencies, "devkit"),
 265             configure_args: concat(common.configure_args, "--with-zlib=system"),
 266             default_make_targets: common.default_make_targets
 267         },
 268 
 269         "solaris-x64": {
 270             target_os: "solaris",
 271             target_cpu: "x64",
 272             dependencies: concat(common.dependencies, "devkit", "cups"),
 273             configure_args: concat(common.configure_args, "--with-zlib=system"),
 274             default_make_targets: common.default_make_targets
 275         },
 276 
 277         "solaris-sparcv9": {
 278             target_os: "solaris",
 279             target_cpu: "sparcv9",
 280             dependencies: concat(common.dependencies, "devkit", "cups"),
 281             configure_args: concat(common.configure_args, "--with-zlib=system"),
 282             default_make_targets: common.default_make_targets
 283         },
 284 
 285         "windows-x64": {
 286             target_os: "windows",
 287             target_cpu: "x64",
 288             dependencies: concat(common.dependencies, "devkit", "freetype"),
 289             configure_args: concat(common.configure_args),
 290             default_make_targets: common.default_make_targets
 291         },
 292 
 293         "windows-x86": {
 294             target_os: "windows",
 295             target_cpu: "x86",
 296             build_cpu: "x64",
 297             dependencies: concat(common.dependencies, "devkit", "freetype"),
 298             configure_args: concat(common.configure_args, common.configure_args_32bit),

 299             default_make_targets: common.default_make_targets
 300         }
 301     };
 302     profiles = concatObjects(profiles, mainProfiles);
 303     // Generate debug versions of all the main profiles
 304     profiles = concatObjects(profiles, generateDebugProfiles(common, mainProfiles));
 305     // Generate slowdebug versions of all the main profiles
 306     profiles = concatObjects(profiles, generateSlowdebugProfiles(common, mainProfiles));
 307 
 308     // Generate open only profiles for all the main profiles for JPRT and reference
 309     // implementation builds.
 310     var openOnlyProfiles = generateOpenOnlyProfiles(common, mainProfiles);
 311     // The open only profiles on linux are used for reference builds and should
 312     // produce the compact profile images by default. This adds "profiles" as an
 313     // extra default target.
 314     var openOnlyProfilesExtra = {
 315         "linux-x64-open": {
 316             default_make_targets: "profiles"
 317         },
 318 
 319         "linux-x86-open": {
 320             default_make_targets: "profiles"
 321         }
 322     };
 323     var openOnlyProfiles = concatObjects(openOnlyProfiles, openOnlyProfilesExtra);
 324 
 325     profiles = concatObjects(profiles, openOnlyProfiles);
 326     // Generate debug profiles for the open jprt profiles
 327     profiles = concatObjects(profiles, generateDebugProfiles(common, openOnlyProfiles));
 328 
 329     // Profiles used to run tests. Used in JPRT.
 330     var testOnlyProfiles = {
 331 
 332         "run-test": {
 333             target_os: input.build_os,
 334             target_cpu: input.build_cpu,
 335             dependencies: [ "jtreg", "gnumake" ],
 336             labels: "test"
 337         }
 338     };
 339     profiles = concatObjects(profiles, testOnlyProfiles);
 340 
 341     // Generate the missing platform attributes
 342     profiles = generatePlatformAttributes(profiles);
 343     profiles = generateDefaultMakeTargetsConfigureArg(common, profiles);
 344     return profiles;
 345 };
 346 
 347 /**
 348  * Generate the dependencies part of the configuration
 349  *
 350  * @param input External data to use for generating the configuration
 351  * @param common The common values
 352  * @returns {{}} Dependencies part of configuration
 353  */
 354 var getJibProfilesDependencies = function (input, common) {
 355 
 356     var boot_jdk_platform = input.build_os + "-"
 357         + (input.build_cpu == "x86" ? "i586" : input.build_cpu);
 358 
 359     var devkit_platform_revisions = {
 360         linux_x64: "gcc4.9.2-OEL6.4+1.0",
 361         macosx_x64: "Xcode6.3-MacOSX10.9+1.0",
 362         solaris_x64: "SS12u4-Solaris11u1+1.0",
 363         solaris_sparcv9: "SS12u4-Solaris11u1+1.0",
 364         windows_x64: "VS2013SP4+1.0"
 365     };
 366 
 367     var devkit_platform = (input.target_cpu == "x86"
 368         ? input.target_os + "_x64"
 369         : input.target_platform);
 370 
 371     var dependencies = {
 372 
 373         boot_jdk: {
 374             server: "javare",
 375             module: "jdk",
 376             revision: "8",
 377             checksum_file: boot_jdk_platform + "/MD5_VALUES",
 378             file: boot_jdk_platform + "/jdk-8-" + boot_jdk_platform + ".tar.gz",
 379             configure_args: (input.build_os == "macosx"
 380                 ? "--with-boot-jdk=" + input.get("boot_jdk", "install_path") + "/jdk1.8.0.jdk/Contents/Home"
 381                 : "--with-boot-jdk=" + input.get("boot_jdk", "install_path") + "/jdk1.8.0")
 382         },
 383 
 384         devkit: {
 385             organization: common.organization,
 386             ext: "tar.gz",
 387             module: "devkit-" + devkit_platform,
 388             revision: devkit_platform_revisions[devkit_platform]
 389         },
 390 
 391         build_devkit: {
 392             organization: common.organization,
 393             ext: "tar.gz",
 394             module: "devkit-" + input.build_platform,
 395             revision: devkit_platform_revisions[input.build_platform]
 396         },
 397 
 398         cups: {
 399             organization: common.organization,
 400             ext: "tar.gz",
 401             revision: "1.0118+1.0"
 402         },
 403 
 404         jtreg: {
 405             server: "javare",
 406             revision: "4.2",
 407             build_number: "b02",
 408             checksum_file: "MD5_VALUES",
 409             file: "jtreg_bin-4.2.zip",
 410             environment_name: "JT_HOME"
 411         },
 412 
 413         gnumake: {
 414             organization: common.organization,
 415             ext: "tar.gz",
 416             revision: "4.0+1.0",
 417 
 418             module: (input.build_os == "windows"
 419                 ? "gnumake-" + input.build_osenv_platform
 420                 : "gnumake-" + input.build_platform),
 421 
 422             configure_args: (input.build_os == "windows"
 423                 ? "MAKE=" + input.get("gnumake", "install_path") + "/cygwin/bin/make"
 424                 : "MAKE=" + input.get("gnumake", "install_path") + "/bin/make"),
 425 
 426             environment_path: (input.build_os == "windows"
 427                 ? input.get("gnumake", "install_path") + "/cygwin/bin"
 428                 : input.get("gnumake", "install_path") + "/bin")
 429         },
 430 
 431         freetype: {
 432             organization: common.organization,
 433             ext: "tar.gz",
 434             revision: "2.3.4+1.0",
 435             module: "freetype-" + input.target_platform
 436         }
 437     };
 438 
 439     return dependencies;
 440 };
 441 
 442 /**
 443  * Generate the missing platform attributes for profiles
 444  *
 445  * @param profiles Profiles map to generate attributes on
 446  * @returns {{}} New profiles map with platform attributes fully filled in
 447  */
 448 var generatePlatformAttributes = function (profiles) {
 449     var ret = concatObjects(profiles, {});
 450     for (var profile in profiles) {
 451         if (ret[profile].build_os == null) {
 452             ret[profile].build_os = ret[profile].target_os;
 453         }
 454         if (ret[profile].build_cpu == null) {
 455             ret[profile].build_cpu = ret[profile].target_cpu;
 456         }
 457         ret[profile].target_platform = ret[profile].target_os + "_" + ret[profile].target_cpu;
 458         ret[profile].build_platform = ret[profile].build_os + "_" + ret[profile].build_cpu;
 459     }
 460     return ret;
 461 };
 462 
 463 /**
 464  * Generates debug versions of profiles. Clones the given profiles and adds
 465  * debug metadata.
 466  *
 467  * @param common Common values
 468  * @param profiles Profiles map to generate debug profiles for
 469  * @returns {{}} New map of profiles containing debug profiles
 470  */
 471 var generateDebugProfiles = function (common, profiles) {
 472     var newProfiles = {};
 473     for (var profile in profiles) {
 474         var debugProfile = profile + "-debug";
 475         newProfiles[debugProfile] = clone(profiles[profile]);
 476         newProfiles[debugProfile].debug_level = "fastdebug";
 477         newProfiles[debugProfile].default_make_targets
 478             = common.default_make_targets_debug;
 479         newProfiles[debugProfile].labels
 480             = concat(newProfiles[debugProfile].labels || [], "debug"),
 481             newProfiles[debugProfile].configure_args
 482                 = concat(newProfiles[debugProfile].configure_args,
 483                 common.configure_args_debug);
 484     }
 485     return newProfiles;
 486 };
 487 
 488 /**
 489  * Generates slowdebug versions of profiles. Clones the given profiles and adds
 490  * debug metadata.
 491  *
 492  * @param common Common values
 493  * @param profiles Profiles map to generate debug profiles for
 494  * @returns {{}} New map of profiles containing debug profiles
 495  */
 496 var generateSlowdebugProfiles = function (common, profiles) {
 497     var newProfiles = {};
 498     for (var profile in profiles) {
 499         var debugProfile = profile + "-slowdebug";
 500         newProfiles[debugProfile] = clone(profiles[profile]);
 501         newProfiles[debugProfile].debug_level = "slowdebug";
 502         newProfiles[debugProfile].default_make_targets
 503             = common.default_make_targets_slowdebug;
 504         newProfiles[debugProfile].labels
 505             = concat(newProfiles[debugProfile].labels || [], "slowdebug"),
 506             newProfiles[debugProfile].configure_args
 507                 = concat(newProfiles[debugProfile].configure_args,
 508                 common.configure_args_slowdebug);
 509     }
 510     return newProfiles;
 511 };
 512 
 513 /**
 514  * Generates open only versions of profiles. Clones the given profiles and adds
 515  * open metadata.
 516  *
 517  * @param common Common values
 518  * @param profiles Profiles map to generate open only profiles for
 519  * @returns {{}} New map of profiles containing open only profiles
 520  */
 521 var generateOpenOnlyProfiles = function (common, profiles) {
 522     var newProfiles = {};
 523     for (var profile in profiles) {
 524         var openProfile = profile + "-open";
 525         newProfiles[openProfile] = clone(profiles[profile]);
 526         newProfiles[openProfile].labels
 527             = concat(newProfiles[openProfile].labels || [], "open"),
 528             newProfiles[openProfile].configure_args
 529                 = concat(newProfiles[openProfile].configure_args,
 530                 "--enable-openjdk-only");
 531     }
 532     return newProfiles;
 533 };
 534 
 535 /**
 536  * The default_make_targets attribute on a profile is not a real Jib attribute.
 537  * This function rewrites that attribute into the corresponding configure arg.
 538  * Calling this function multiple times on the same profiles object is safe.
 539  *
 540  * @param common Common values
 541  * @param profiles Profiles map to rewrite profiles for
 542  * @returns {{}} New map of profiles with the make targets converted
 543  */
 544 var generateDefaultMakeTargetsConfigureArg = function (common, profiles) {
 545     var ret = concatObjects(profiles, {});
 546     for (var profile in ret) {
 547         if (ret[profile]["default_make_targets"] != null) {
 548             var targetsString = concat(ret[profile].default_make_targets).join(" ");
 549             // Iterate over all configure args and see if --with-default-make-target
 550             // is already there and change it, otherwise add it.
 551             var found = false;
 552             for (var arg in ret[profile].configure_args) {
 553                 if (arg.startsWith("--with-default-make-target")) {
 554                     found = true;
 555                     arg.replace(/=.*/, "=" + targetsString);
 556                 }
 557             }
 558             if (!found) {
 559                 ret[profile].configure_args = concat(
 560                     ret[profile].configure_args,
 561                     "--with-default-make-target=" + targetsString);
 562             }
 563         }
 564     }
 565     return ret;
 566 }
 567 
 568 /**
 569  * Deep clones an object tree.
 570  *
 571  * @param o Object to clone
 572  * @returns {{}} Clone of o
 573  */
 574 var clone = function (o) {
 575     return JSON.parse(JSON.stringify(o));
 576 };
 577 
 578 /**
 579  * Concatenates all arguments into a new array
 580  *
 581  * @returns {Array.<T>} New array containing all arguments
 582  */
 583 var concat = function () {
 584     return Array.prototype.concat.apply([], arguments);
 585 };
 586 
 587 /**
 588  * Copies all elements in an array into a new array but replacing all
 589  * occurrences of original with replacement.
 590  *
 591  * @param original Element to look for
 592  * @param replacement Element to replace with
 593  * @param a Array to copy
 594  * @returns {Array} New array with all occurrences of original replaced
 595  *                  with replacement
 596  */
 597 var replace = function (original, replacement, a) {
 598     var newA = [];
 599     for (var i in a) {
 600         if (original == a[i]) {
 601             newA.push(replacement);
 602         } else {
 603             newA.push(a[i]);
 604         }
 605     }
 606     return newA;
 607 };
 608 
 609 /**
 610  * Deep concatenation of two objects. For each node encountered, merge
 611  * the contents with the corresponding node in the other object tree,
 612  * treating all strings as array elements.
 613  *
 614  * @param o1 Object to concatenate
 615  * @param o2 Object to concatenate
 616  * @returns {{}} New object tree containing the concatenation of o1 and o2
 617  */
 618 var concatObjects = function (o1, o2) {
 619     var ret = {};
 620     for (var a in o1) {
 621         if (o2[a] == null) {
 622             ret[a] = o1[a];
 623         }
 624     }
 625     for (var a in o2) {
 626         if (o1[a] == null) {
 627             ret[a] = o2[a];
 628         } else {
 629             if (typeof o1[a] == 'string') {
 630                 ret[a] = [o1[a]].concat(o2[a]);
 631             } else if (Array.isArray(o1[a])) {
 632                 ret[a] = o1[a].concat(o2[a]);
 633             } else if (typeof o1[a] == 'object') {
 634                 ret[a] = concatObjects(o1[a], o2[a]);
 635             }
 636         }
 637     }
 638     return ret;
 639 };
--- EOF ---