jdk-sandbox: comparison test/jdk/tools/jpackage/helpers/jdk/jpackage/test/JPackageCommand.java

equal deleted inserted replaced

-:2c43b89b1679
+:3bf53ffa9ae7
 import java.security.SecureRandom;
 import java.util.*;
 import java.util.function.Consumer;
 import java.util.function.Function;
 import java.util.function.Supplier;
+import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
+import jdk.jpackage.internal.ApplicationLayout;
 import jdk.jpackage.test.Functional.ThrowingConsumer;
+import jdk.jpackage.test.Functional.ThrowingFunction;
 /**
 * jpackage command line with prerequisite actions. Prerequisite actions can be
 * anything. The simplest is to compile test application and pack in a jar for
 * use on jpackage command line.
 public JPackageCommand() {
 actions = new ArrayList<>();
 }
+public JPackageCommand(JPackageCommand cmd) {
+this();
+args.addAll(cmd.args);
+withToolProvider = cmd.withToolProvider;
+saveConsoleOutput = cmd.saveConsoleOutput;
+suppressOutput = cmd.suppressOutput;
+ignoreDefaultRuntime = cmd.ignoreDefaultRuntime;
+immutable = cmd.immutable;
+actionsExecuted = cmd.actionsExecuted;
+}
 JPackageCommand createImmutableCopy() {
-JPackageCommand reply = new JPackageCommand();
+JPackageCommand reply = new JPackageCommand(this);
 reply.immutable = true;
-reply.args.addAll(args);
 return reply;
 }
 public JPackageCommand setArgumentValue(String argName, String newValue) {
 verifyMutable();
 public JPackageCommand addArguments(String name, Path value) {
 return addArguments(name, value.toString());
 }
+public boolean isImagePackageType() {
+return PackageType.IMAGE == getArgumentValue("--package-type",
+() -> null, PACKAGE_TYPES::get);
+}
 public PackageType packageType() {
 // Don't try to be in sync with jpackage defaults. Keep it simple:
 // if no `--package-type` explicitely set on the command line, consider
 // this is operator's fault.
 return getArgumentValue("--package-type",
 }
 public JPackageCommand setFakeRuntime() {
 verifyMutable();
-try {
+ThrowingConsumer<Path> createBulkFile = path -> {
+Files.createDirectories(path.getParent());
+try (FileOutputStream out = new FileOutputStream(path.toFile())) {
+byte[] bytes = new byte[4 * 1024];
+new SecureRandom().nextBytes(bytes);
+out.write(bytes);
+}
+};
+addAction(cmd -> {
 Path fakeRuntimeDir = TKit.workDir().resolve("fake_runtime");
+TKit.trace(String.format("Init fake runtime in [%s] directory",
+fakeRuntimeDir));
 Files.createDirectories(fakeRuntimeDir);
 if (TKit.isWindows() || TKit.isLinux()) {
 // Needed to make WindowsAppBundler happy as it copies MSVC dlls
 // from `bin` directory.
 // Need to make the code in rpm spec happy as it assumes there is
 // always something in application image.
 fakeRuntimeDir.resolve("bin").toFile().mkdir();
 }
-Path bulk = fakeRuntimeDir.resolve(Path.of("bin", "bulk"));
+if (TKit.isOSX()) {
+// Make MacAppImageBuilder happy
+createBulkFile.accept(fakeRuntimeDir.resolve(Path.of(
+"Contents/Home/lib/jli/libjli.dylib")));
+}
 // Mak sure fake runtime takes some disk space.
 // Package bundles with 0KB size are unexpected and considered
 // an error by PackageTest.
-Files.createDirectories(bulk.getParent());
+createBulkFile.accept(fakeRuntimeDir.resolve(Path.of("bin", "bulk")));
-try (FileOutputStream out = new FileOutputStream(bulk.toFile())) {
-byte[] bytes = new byte[4 * 1024];
+cmd.addArguments("--runtime-image", fakeRuntimeDir);
-new SecureRandom().nextBytes(bytes);
+});
-out.write(bytes);
-}
-addArguments("--runtime-image", fakeRuntimeDir);
-} catch (IOException ex) {
-throw new RuntimeException(ex);
-}
 return this;
 }
 JPackageCommand addAction(ThrowingConsumer<JPackageCommand> action) {
 verifyMutable();
 actions.add(ThrowingConsumer.toConsumer(action));
 return this;
 }
+/**
+* Shorthand for {@code helloAppImage(null)}.
+*/
 public static JPackageCommand helloAppImage() {
-return helloAppImage(null);
+JavaAppDesc javaAppDesc = null;
+return helloAppImage(javaAppDesc);
 }
 /**
 * Creates new JPackageCommand instance configured with the test Java app.
 * For the explanation of `javaAppDesc` parameter, see documentation for
-* HelloApp.addTo() method.
+* #JavaAppDesc.parse() method.
 *
 * @param javaAppDesc Java application description
 * @return this
 */
 public static JPackageCommand helloAppImage(String javaAppDesc) {
+final JavaAppDesc appDesc;
+if (javaAppDesc == null) {
+appDesc = null;
+} else {
+appDesc = JavaAppDesc.parse(javaAppDesc);
+}
+return helloAppImage(appDesc);
+}
+public static JPackageCommand helloAppImage(JavaAppDesc javaAppDesc) {
 JPackageCommand cmd = new JPackageCommand();
 cmd.setDefaultInputOutput().setDefaultAppName();
 PackageType.IMAGE.applyTo(cmd);
-HelloApp.addTo(cmd, javaAppDesc);
+new HelloApp(javaAppDesc).addTo(cmd);
 return cmd;
 }
 public JPackageCommand setPackageType(PackageType type) {
 verifyMutable();
 JPackageCommand setDefaultAppName() {
 return addArguments("--name", TKit.getCurrentDefaultAppName());
 }
+/**
+* Returns path to output bundle of configured jpackage command.
+*
+* If this is build image command, returns path to application image directory.
+*/
 public Path outputBundle() {
-final PackageType type = packageType();
+final String bundleName;
-if (PackageType.IMAGE == type) {
+if (isImagePackageType()) {
-return null;
+String dirName = name();
-}
+if (TKit.isOSX()) {
+dirName = dirName + ".app";
-String bundleName = null;
+}
-if (PackageType.LINUX.contains(type)) {
+bundleName = dirName;
+} else if (TKit.isLinux()) {
 bundleName = LinuxHelper.getBundleName(this);
-} else if (PackageType.WINDOWS.contains(type)) {
+} else if (TKit.isWindows()) {
 bundleName = WindowsHelper.getBundleName(this);
-} else if (PackageType.MAC.contains(type)) {
+} else if (TKit.isOSX()) {
 bundleName = MacHelper.getBundleName(this);
+} else {
+throw TKit.throwUnknownPlatformError();
 }
 return outputDir().resolve(bundleName);
 }
 /**
-* Returns path to directory where application will be installed.
+* Returns application layout.
+*
+* If this is build image command, returns application image layout of the
+* output bundle relative to output directory. Otherwise returns layout of
+* installed application relative to the root directory.
+*
+* If this command builds Java runtime, not an application, returns
+* corresponding layout.
+*/
+public ApplicationLayout appLayout() {
+final ApplicationLayout layout;
+if (isRuntime()) {
+layout = ApplicationLayout.javaRuntime();
+} else {
+layout = ApplicationLayout.platformAppImage();
+}
+if (isImagePackageType()) {
+return layout.resolveAt(outputBundle());
+}
+return layout.resolveAt(appInstallationDirectory());
+}
+/**
+* Returns path to directory where application will be installed or null if
+* this is build image command.
 *
 * E.g. on Linux for app named Foo default the function will return
 * `/opt/foo`
 */
 public Path appInstallationDirectory() {
-final PackageType type = packageType();
+if (isImagePackageType()) {
-if (PackageType.IMAGE == type) {
 return null;
 }
-if (PackageType.LINUX.contains(type)) {
+if (TKit.isLinux()) {
 if (isRuntime()) {
 // Not fancy, but OK.
 return Path.of(getArgumentValue("--install-dir", () -> "/opt"),
 LinuxHelper.getPackageName(this));
 }
 // Launcher is in "bin" subfolder of the installation directory.
-return launcherInstallationPath().getParent().getParent();
+return appLauncherPath().getParent().getParent();
 }
-if (PackageType.WINDOWS.contains(type)) {
+if (TKit.isWindows()) {
 return WindowsHelper.getInstallationDirectory(this);
 }
-if (PackageType.MAC.contains(type)) {
+if (TKit.isOSX()) {
 return MacHelper.getInstallationDirectory(this);
 }
-throw throwUnexpectedPackageTypeError();
+throw TKit.throwUnknownPlatformError();
 }
 /**
-* Returns path where application's Java runtime will be installed.
+* Returns path to application's Java runtime.
-* If the command will package Java run-time only, still returns path to
+* If the command will package Java runtime only, returns correct path to
-* runtime subdirectory.
+* runtime directory.
 *
-* E.g. on Linux for app named `Foo` the function will return
+* E.g.:
-* `/opt/foo/runtime`
+* [jpackage --name Foo --package-type rpm] -> `/opt/foo/lib/runtime`
-*/
+* [jpackage --name Foo --package-type app-image --dest bar] -> `bar/Foo/lib/runtime`
-public Path appRuntimeInstallationDirectory() {
+* [jpackage --name Foo --package-type rpm --runtime-image java] -> `/opt/foo`
-if (PackageType.IMAGE == packageType()) {
+*/
-return null;
+public Path appRuntimeDirectory() {
-}
+return appLayout().runtimeDirectory();
-return appInstallationDirectory().resolve(appRuntimePath(packageType()));
+}
-}
+/**
-/**
+* Returns path for application launcher with the given name.
-* Returns path where application launcher will be installed.
+*
-* If the command will package Java run-time only, still returns path to
+* E.g.: [jpackage --name Foo --package-type rpm] -> `/opt/foo/bin/Foo`
-* application launcher.
+* [jpackage --name Foo --package-type app-image --dest bar] ->
-*
+* `bar/Foo/bin/Foo`
-* E.g. on Linux for app named Foo default the function will return
+*
-* `/opt/foo/bin/Foo`
+* @param launcherName name of launcher or {@code null} for the main
-*/
+* launcher
-public Path launcherInstallationPath() {
+*
-final PackageType type = packageType();
+* @throws IllegalArgumentException if the command is configured for
-if (PackageType.IMAGE == type) {
+* packaging Java runtime
-return null;
+*/
-}
+public Path appLauncherPath(String launcherName) {
+verifyNotRuntime();
-if (PackageType.LINUX.contains(type)) {
+if (launcherName == null) {
-return outputDir().resolve(LinuxHelper.getLauncherPath(this));
+launcherName = name();
 }
-if (PackageType.WINDOWS.contains(type)) {
+if (TKit.isWindows()) {
-return appInstallationDirectory().resolve(name() + ".exe");
+launcherName = launcherName + ".exe";
 }
-if (PackageType.MAC.contains(type)) {
+if (isImagePackageType()) {
-return appInstallationDirectory().resolve(Path.of("Contents", "MacOS", name()));
+return appLayout().launchersDirectory().resolve(launcherName);
 }
-throw throwUnexpectedPackageTypeError();
-}
-/**
-* Returns path to application image directory.
-*
-* E.g. if --dest is set to `foo` and --name is set to `bar` the function
-* will return `foo/bar` path on Linux and Windows and `foo/bar.app` on macOS.
-*
-* @throws IllegalArgumentException is command is doing platform packaging
-*/
-public Path appImage() {
-verifyIsOfType(PackageType.IMAGE);
-String dirName = name();
-if (TKit.isOSX()) {
-dirName = dirName + ".app";
-}
-return outputDir().resolve(dirName);
-}
-/**
-* Returns path to application launcher relative to image directory.
-*
-* E.g. if --name is set to `Foo` the function will return `bin/Foo` path on
-* Linux, and `Foo.exe` on Windows.
-*
-* @throws IllegalArgumentException is command is doing platform packaging
-*/
-public Path launcherPathInAppImage() {
-verifyIsOfType(PackageType.IMAGE);
 if (TKit.isLinux()) {
-return Path.of("bin", name());
+LinuxHelper.getLauncherPath(this).getParent().resolve(launcherName);
 }
-if (TKit.isOSX()) {
+return appLayout().launchersDirectory().resolve(launcherName);
-return Path.of("Contents", "MacOS", name());
+}
-}
+/**
-if (TKit.isWindows()) {
+* Shorthand for {@code appLauncherPath(null)}.
-return Path.of(name() + ".exe");
+*/
-}
+public Path appLauncherPath() {
+return appLauncherPath(null);
-throw TKit.throwUnknownPlatformError();
+}
-}
+private void verifyNotRuntime() {
-/**
+if (isRuntime()) {
-* Returns path to runtime directory relative to image directory.
+throw new IllegalArgumentException("Java runtime packaging");
-*
+}
-* @throws IllegalArgumentException if command is configured for platform
+}
-* packaging
-*/
+/**
-public Path appRuntimeDirectoryInAppImage() {
+* Returns path to .cfg file of the given application launcher.
-verifyIsOfType(PackageType.IMAGE);
+*
-return appRuntimePath(packageType());
+* E.g.:
-}
+* [jpackage --name Foo --package-type rpm] -> `/opt/foo/lib/app/Foo.cfg`
+* [jpackage --name Foo --package-type app-image --dest bar] -> `bar/Foo/lib/app/Foo.cfg`
-private static Path appRuntimePath(PackageType type) {
+*
-if (TKit.isLinux()) {
+* @param launcher name of launcher or {@code null} for the main launcher
-return Path.of("lib/runtime");
+*
-}
+* @throws IllegalArgumentException if the command is configured for
-if (TKit.isOSX()) {
+* packaging Java runtime
-return Path.of("Contents/runtime");
+*/
-}
+public Path appLauncherCfgPath(String launcherName) {
+verifyNotRuntime();
-return Path.of("runtime");
+if (launcherName == null) {
-}
+launcherName = name();
+}
-public boolean isFakeRuntimeInAppImage(String msg) {
+return appLayout().appDirectory().resolve(launcherName + ".cfg");
-return isFakeRuntime(appImage().resolve(
+}
-appRuntimeDirectoryInAppImage()), msg);
-}
+public boolean isFakeRuntime(String msg) {
+Path runtimeDir = appRuntimeDirectory();
-public boolean isFakeRuntimeInstalled(String msg) {
-return isFakeRuntime(appRuntimeInstallationDirectory(), msg);
-}
-private static boolean isFakeRuntime(Path runtimeDir, String msg) {
 final Collection<Path> criticalRuntimeFiles;
 if (TKit.isWindows()) {
 criticalRuntimeFiles = WindowsHelper.CRITICAL_RUNTIME_FILES;
 } else if (TKit.isLinux()) {
 criticalRuntimeFiles = LinuxHelper.CRITICAL_RUNTIME_FILES;
 verifyMutable();
 suppressOutput = !v;
 return this;
 }
+public JPackageCommand ignoreDefaultRuntime(boolean v) {
+verifyMutable();
+ignoreDefaultRuntime = v;
+return this;
+}
 public boolean isWithToolProvider() {
 return Optional.ofNullable(withToolProvider).orElse(
 defaultWithToolProvider);
 }
-public void executePrerequisiteActions() {
+public JPackageCommand executePrerequisiteActions() {
 verifyMutable();
 if (!actionsExecuted) {
 actionsExecuted = true;
 if (actions != null) {
 actions.stream().forEach(r -> r.accept(this));
 }
 }
+return this;
+}
+public Executor createExecutor() {
+verifyMutable();
+Executor exec = new Executor()
+.saveOutput(saveConsoleOutput).dumpOutput(!suppressOutput)
+.addArguments(args);
+if (isWithToolProvider()) {
+exec.setToolProvider(JavaTool.JPACKAGE);
+} else {
+exec.setExecutable(JavaTool.JPACKAGE);
+}
+return exec;
 }
 public Executor.Result execute() {
 executePrerequisiteActions();
-if (packageType() == PackageType.IMAGE) {
+if (isImagePackageType()) {
 TKit.deleteDirectoryContentsRecursive(outputDir());
 }
-Executor exec = new Executor()
+return new JPackageCommand(this)
-.saveOutput(saveConsoleOutput).dumpOutput(!suppressOutput)
+.adjustArgumentsBeforeExecution()
-.addArguments(new JPackageCommand().addArguments(
+.createExecutor()
-args).adjustArgumentsBeforeExecution().args);
+.execute();
-if (isWithToolProvider()) {
-exec.setToolProvider(JavaTool.JPACKAGE.asToolProvider());
-} else {
-exec.setExecutable(JavaTool.JPACKAGE);
-}
-return exec.execute();
 }
 public JPackageCommand executeAndAssertHelloAppImageCreated() {
 executeAndAssertImageCreated();
 HelloApp.executeLauncherAndVerifyOutput(this);
 return assertImageCreated();
 }
 public JPackageCommand assertImageCreated() {
 verifyIsOfType(PackageType.IMAGE);
-TKit.assertExecutableFileExists(appImage().resolve(
+TKit.assertDirectoryExists(appRuntimeDirectory());
-launcherPathInAppImage()));
-TKit.assertDirectoryExists(appImage().resolve(
+if (!isRuntime()) {
-appRuntimeDirectoryInAppImage()));
+TKit.assertExecutableFileExists(appLauncherPath());
+TKit.assertFileExists(appLauncherCfgPath(null));
+}
 return this;
 }
 private JPackageCommand adjustArgumentsBeforeExecution() {
-if (!hasArgument("--runtime-image") && !hasArgument("--app-image") && DEFAULT_RUNTIME_IMAGE != null) {
+if (!hasArgument("--runtime-image") && !hasArgument("--app-image") && DEFAULT_RUNTIME_IMAGE != null && !ignoreDefaultRuntime) {
 addArguments("--runtime-image", DEFAULT_RUNTIME_IMAGE);
 }
 if (!hasArgument("--verbose") && TKit.VERBOSE_JPACKAGE) {
 addArgument("--verbose");
 }
 return this;
-}
-private static RuntimeException throwUnexpectedPackageTypeError() {
-throw new IllegalArgumentException("Unexpected package type");
 }
 String getPrintableCommandLine() {
 return new Executor()
 .setExecutable(JavaTool.JPACKAGE)
 public void verifyIsOfType(Collection<PackageType> types) {
 verifyIsOfType(types.toArray(PackageType[]::new));
 }
 public void verifyIsOfType(PackageType ... types) {
-if (!Arrays.asList(types).contains(packageType())) {
+final Set<PackageType> typesSet = Set.of(types);
-throwUnexpectedPackageTypeError();
+if (!hasArgument("--package-type")) {
-}
+if (!isImagePackageType()) {
+if (TKit.isLinux() && typesSet.equals(PackageType.LINUX)) {
+return;
+}
+if (TKit.isWindows() && typesSet.equals(PackageType.WINDOWS)) {
+return;
+}
+if (TKit.isOSX() && typesSet.equals(PackageType.MAC)) {
+return;
+}
+} else if (typesSet.equals(Set.of(PackageType.IMAGE))) {
+return;
+}
+}
+if (!typesSet.contains(packageType())) {
+throw new IllegalArgumentException("Unexpected package type");
+}
+}
+public CfgFile readLaunherCfgFile() {
+return readLaunherCfgFile(null);
+}
+public CfgFile readLaunherCfgFile(String launcherName) {
+verifyIsOfType(PackageType.IMAGE);
+if (isRuntime()) {
+return null;
+}
+return ThrowingFunction.toFunction(CfgFile::readFromFile).apply(
+appLauncherCfgPath(launcherName));
 }
 public static String escapeAndJoin(String... args) {
 return escapeAndJoin(List.of(args));
 }
 }
 private Boolean withToolProvider;
 private boolean saveConsoleOutput;
 private boolean suppressOutput;
+private boolean ignoreDefaultRuntime;
 private boolean immutable;
 private boolean actionsExecuted;
 private final List<Consumer<JPackageCommand>> actions;
 private static boolean defaultWithToolProvider;

branch	JDK-8200758-branch
changeset 58648	3bf53ffa9ae7
parent 58416	f09bf58c1f17
child 58671	3b578a5976df