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         dependencies: ["boot_jdk", "gnumake", "jtreg"],
 217         configure_args: ["--with-default-make-target=all", "--enable-jtreg-failure-handler"],
 218         configure_args_32bit: ["--with-target-bits=32", "--with-jvm-variants=client,server"],
 219         configure_args_debug: ["--enable-debug"],
 220         configure_args_slowdebug: ["--with-debug-level=slowdebug"],
 221         organization: "jpg.infra.builddeps"
 222     };
 223 
 224     return common;
 225 };
 226 
 227 /**
 228  * Generates the profiles part of the configuration.
 229  *
 230  * @param input External data to use for generating the configuration
 231  * @param common The common values
 232  * @returns {{}} Profiles part of the configuration
 233  */
 234 var getJibProfilesProfiles = function (input, common) {
 235     var profiles = {};
 236 
 237     // Main SE profiles
 238     var mainProfiles = {
 239 
 240         "linux-x64": {
 241             target_os: "linux",
 242             target_cpu: "x64",
 243             dependencies: concat(common.dependencies, "devkit"),
 244             configure_args: concat(common.configure_args, "--with-zlib=system"),
 245             make_args: common.make_args
 246         },
 247 
 248         "linux-x86": {
 249             target_os: "linux",
 250             target_cpu: "x86",
 251             build_cpu: "x64",
 252             dependencies: concat(common.dependencies, "devkit"),
 253             configure_args: concat(common.configure_args, common.configure_args_32bit,
 254                 "--with-zlib=system"),
 255             make_args: common.make_args
 256         },
 257 
 258         "macosx-x64": {
 259             target_os: "macosx",
 260             target_cpu: "x64",
 261             dependencies: concat(common.dependencies, "devkit"),
 262             configure_args: concat(common.configure_args, "--with-zlib=system"),
 263             make_args: common.make_args
 264         },
 265 
 266         "solaris-x64": {
 267             target_os: "solaris",
 268             target_cpu: "x64",
 269             dependencies: concat(common.dependencies, "devkit", "cups"),
 270             configure_args: concat(common.configure_args, "--with-zlib=system"),
 271             make_args: common.make_args
 272         },
 273 
 274         "solaris-sparcv9": {
 275             target_os: "solaris",
 276             target_cpu: "sparcv9",
 277             dependencies: concat(common.dependencies, "devkit", "cups"),
 278             configure_args: concat(common.configure_args, "--with-zlib=system"),
 279             make_args: common.make_args
 280         },
 281 
 282         "windows-x64": {
 283             target_os: "windows",
 284             target_cpu: "x64",
 285             dependencies: concat(common.dependencies, "devkit", "freetype"),
 286             configure_args: common.configure_args,
 287             make_args: common.make_args
 288         },
 289 
 290         "windows-x86": {
 291             target_os: "windows",
 292             target_cpu: "x86",
 293             build_cpu: "x64",
 294             dependencies: concat(common.dependencies, "devkit", "freetype"),
 295             configure_args: concat(common.configure_args, common.configure_args_32bit),
 296             make_args: common.make_args
 297         }
 298     };
 299     profiles = concatObjects(profiles, mainProfiles);
 300     // Generate debug versions of all the main profiles
 301     profiles = concatObjects(profiles, generateDebugProfiles(common, mainProfiles));
 302     // Generate slowdebug versions of all the main profiles
 303     profiles = concatObjects(profiles, generateSlowdebugProfiles(common, mainProfiles));
 304 
 305     // Generate open only profiles for all the main profiles for JPRT and reference
 306     // implementation builds.
 307     var openOnlyProfiles = generateOpenOnlyProfiles(common, mainProfiles);
 308     // The open only profiles on linux are used for reference builds and should
 309     // produce the compact profile images by default.
 310     var openOnlyProfilesExtra = {
 311         "linux-x64-open": {
 312             configure_args: ["--with-default-make-target=all profiles"],
 313         },
 314 
 315         "linux-x86-open": {
 316             configure_args: ["--with-default-make-target=all profiles"],
 317         }
 318     };
 319     var openOnlyProfiles = concatObjects(openOnlyProfiles, openOnlyProfilesExtra);
 320 
 321     profiles = concatObjects(profiles, openOnlyProfiles);
 322     // Generate debug profiles for the open jprt profiles
 323     profiles = concatObjects(profiles, generateDebugProfiles(common, openOnlyProfiles));
 324 
 325     // Profiles used to run tests. Used in JPRT.
 326     var testOnlyProfiles = {
 327 
 328         "run-test": {
 329             target_os: input.build_os,
 330             target_cpu: input.build_cpu,
 331             dependencies: [ "jtreg", "gnumake" ],
 332             labels: "test"
 333         }
 334     };
 335     profiles = concatObjects(profiles, testOnlyProfiles);
 336 
 337     // Generate the missing platform attributes
 338     profiles = generatePlatformAttributes(profiles);
 339     return profiles;
 340 };
 341 
 342 /**
 343  * Generate the dependencies part of the configuration
 344  *
 345  * @param input External data to use for generating the configuration
 346  * @param common The common values
 347  * @returns {{}} Dependencies part of configuration
 348  */
 349 var getJibProfilesDependencies = function (input, common) {
 350 
 351     var boot_jdk_platform = input.build_os + "-"
 352         + (input.build_cpu == "x86" ? "i586" : input.build_cpu);
 353 
 354     var devkit_platform_revisions = {
 355         linux_x64: "gcc4.9.2-OEL6.4+1.0",
 356         macosx_x64: "Xcode6.3-MacOSX10.9+1.0",
 357         solaris_x64: "SS12u4-Solaris11u1+1.0",
 358         solaris_sparcv9: "SS12u4-Solaris11u1+1.0",
 359         windows_x64: "VS2013SP4+1.0"
 360     };
 361 
 362     var devkit_platform = (input.target_cpu == "x86"
 363         ? input.target_os + "_x64"
 364         : input.target_platform);
 365 
 366     var dependencies = {
 367 
 368         boot_jdk: {
 369             server: "javare",
 370             module: "jdk",
 371             revision: "8",
 372             checksum_file: boot_jdk_platform + "/MD5_VALUES",
 373             file: boot_jdk_platform + "/jdk-8-" + boot_jdk_platform + ".tar.gz",
 374             configure_args: (input.build_os == "macosx"
 375                 ? "--with-boot-jdk=" + input.get("boot_jdk", "install_path") + "/jdk1.8.0.jdk/Contents/Home"
 376                 : "--with-boot-jdk=" + input.get("boot_jdk", "install_path") + "/jdk1.8.0")
 377         },
 378 
 379         devkit: {
 380             organization: common.organization,
 381             ext: "tar.gz",
 382             module: "devkit-" + devkit_platform,
 383             revision: devkit_platform_revisions[devkit_platform]
 384         },
 385 
 386         build_devkit: {
 387             organization: common.organization,
 388             ext: "tar.gz",
 389             module: "devkit-" + input.build_platform,
 390             revision: devkit_platform_revisions[input.build_platform]
 391         },
 392 
 393         cups: {
 394             organization: common.organization,
 395             ext: "tar.gz",
 396             revision: "1.0118+1.0"
 397         },
 398 
 399         jtreg: {
 400             server: "javare",
 401             revision: "4.2",
 402             build_number: "b01",
 403             checksum_file: "MD5_VALUES",
 404             file: "jtreg_bin-4.2.zip",
 405             environment_name: "JT_HOME"
 406         },
 407 
 408         gnumake: {
 409             organization: common.organization,
 410             ext: "tar.gz",
 411             revision: "4.0+1.0",
 412 
 413             module: (input.build_os == "windows"
 414                 ? "gnumake-" + input.build_osenv_platform
 415                 : "gnumake-" + input.build_platform),
 416 
 417             configure_args: (input.build_os == "windows"
 418                 ? "MAKE=" + input.get("gnumake", "install_path") + "/cygwin/bin/make"
 419                 : "MAKE=" + input.get("gnumake", "install_path") + "/bin/make"),
 420 
 421             environment_path: (input.build_os == "windows"
 422                 ? input.get("gnumake", "install_path") + "/cygwin/bin"
 423                 : input.get("gnumake", "install_path") + "/bin")
 424         },
 425 
 426         freetype: {
 427             organization: common.organization,
 428             ext: "tar.gz",
 429             revision: "2.3.4+1.0",
 430             module: "freetype-" + input.target_platform
 431         }
 432     };
 433 
 434     return dependencies;
 435 };
 436 
 437 /**
 438  * Generate the missing platform attributes for profiles
 439  *
 440  * @param profiles Profiles map to generate attributes on
 441  * @returns {{}} New profiles map with platform attributes fully filled in
 442  */
 443 var generatePlatformAttributes = function (profiles) {
 444     var ret = concatObjects(profiles, {});
 445     for (var profile in profiles) {
 446         if (ret[profile].build_os == null) {
 447             ret[profile].build_os = ret[profile].target_os;
 448         }
 449         if (ret[profile].build_cpu == null) {
 450             ret[profile].build_cpu = ret[profile].target_cpu;
 451         }
 452         ret[profile].target_platform = ret[profile].target_os + "_" + ret[profile].target_cpu;
 453         ret[profile].build_platform = ret[profile].build_os + "_" + ret[profile].build_cpu;
 454     }
 455     return ret;
 456 };
 457 
 458 /**
 459  * Generates debug versions of profiles. Clones the given profiles and adds
 460  * debug metadata.
 461  *
 462  * @param common Common values
 463  * @param profiles Profiles map to generate debug profiles for
 464  * @returns {{}} New map of profiles containing debug profiles
 465  */
 466 var generateDebugProfiles = function (common, profiles) {
 467     var newProfiles = {};
 468     for (var profile in profiles) {
 469         var debugProfile = profile + "-debug";
 470         newProfiles[debugProfile] = clone(profiles[profile]);
 471         newProfiles[debugProfile].debug_level = "fastdebug";
 472         newProfiles[debugProfile].labels
 473             = concat(newProfiles[debugProfile].labels || [], "debug"),
 474             newProfiles[debugProfile].configure_args
 475                 = concat(newProfiles[debugProfile].configure_args,
 476                 common.configure_args_debug);
 477     }
 478     return newProfiles;
 479 };
 480 
 481 /**
 482  * Generates slowdebug versions of profiles. Clones the given profiles and adds
 483  * debug metadata.
 484  *
 485  * @param common Common values
 486  * @param profiles Profiles map to generate debug profiles for
 487  * @returns {{}} New map of profiles containing debug profiles
 488  */
 489 var generateSlowdebugProfiles = function (common, profiles) {
 490     var newProfiles = {};
 491     for (var profile in profiles) {
 492         var debugProfile = profile + "-slowdebug";
 493         newProfiles[debugProfile] = clone(profiles[profile]);
 494         newProfiles[debugProfile].debug_level = "slowdebug";
 495         newProfiles[debugProfile].labels
 496             = concat(newProfiles[debugProfile].labels || [], "slowdebug"),
 497             newProfiles[debugProfile].configure_args
 498                 = concat(newProfiles[debugProfile].configure_args,
 499                 common.configure_args_slowdebug);
 500     }
 501     return newProfiles;
 502 };
 503 
 504 /**
 505  * Generates open only versions of profiles. Clones the given profiles and adds
 506  * open metadata.
 507  *
 508  * @param common Common values
 509  * @param profiles Profiles map to generate open only profiles for
 510  * @returns {{}} New map of profiles containing open only profiles
 511  */
 512 var generateOpenOnlyProfiles = function (common, profiles) {
 513     var newProfiles = {};
 514     for (var profile in profiles) {
 515         var openProfile = profile + "-open";
 516         newProfiles[openProfile] = clone(profiles[profile]);
 517         newProfiles[openProfile].labels
 518             = concat(newProfiles[openProfile].labels || [], "open"),
 519             newProfiles[openProfile].configure_args
 520                 = concat(newProfiles[openProfile].configure_args,
 521                 "--enable-openjdk-only");
 522     }
 523     return newProfiles;
 524 };
 525 
 526 /**
 527  * Deep clones an object tree.
 528  *
 529  * @param o Object to clone
 530  * @returns {{}} Clone of o
 531  */
 532 var clone = function (o) {
 533     return JSON.parse(JSON.stringify(o));
 534 };
 535 
 536 /**
 537  * Concatenates all arguments into a new array
 538  *
 539  * @returns {Array.<T>} New array containing all arguments
 540  */
 541 var concat = function () {
 542     return Array.prototype.concat.apply([], arguments);
 543 };
 544 
 545 /**
 546  * Copies all elements in an array into a new array but replacing all
 547  * occurrences of original with replacement.
 548  *
 549  * @param original Element to look for
 550  * @param replacement Element to replace with
 551  * @param a Array to copy
 552  * @returns {Array} New array with all occurrences of original replaced
 553  *                  with replacement
 554  */
 555 var replace = function (original, replacement, a) {
 556     var newA = [];
 557     for (var i in a) {
 558         if (original == a[i]) {
 559             newA.push(replacement);
 560         } else {
 561             newA.push(a[i]);
 562         }
 563     }
 564     return newA;
 565 };
 566 
 567 /**
 568  * Deep concatenation of two objects. For each node encountered, merge
 569  * the contents with the corresponding node in the other object tree,
 570  * treating all strings as array elements.
 571  *
 572  * @param o1 Object to concatenate
 573  * @param o2 Object to concatenate
 574  * @returns {{}} New object tree containing the concatenation of o1 and o2
 575  */
 576 var concatObjects = function (o1, o2) {
 577     var ret = {};
 578     for (var a in o1) {
 579         if (o2[a] == null) {
 580             ret[a] = o1[a];
 581         }
 582     }
 583     for (var a in o2) {
 584         if (o1[a] == null) {
 585             ret[a] = o2[a];
 586         } else {
 587             if (typeof o1[a] == 'string') {
 588                 ret[a] = [o1[a]].concat(o2[a]);
 589             } else if (Array.isArray(o1[a])) {
 590                 ret[a] = o1[a].concat(o2[a]);
 591             } else if (typeof o1[a] == 'object') {
 592                 ret[a] = concatObjects(o1[a], o2[a]);
 593             }
 594         }
 595     }
 596     return ret;
 597 };