< prev index next >
test/jdk/tools/jpackage/helpers/jdk/jpackage/test/JPackageCommand.java
Print this page
*** 28,66 ****
import java.nio.file.Path;
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.incubator.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 final class JPackageCommand extends CommandArguments<JPackageCommand> {
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(this);
reply.immutable = true;
--- 28,69 ----
import java.nio.file.Path;
import java.security.SecureRandom;
import java.util.*;
import java.util.function.Consumer;
import java.util.function.Function;
+ import java.util.function.Predicate;
import java.util.function.Supplier;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import jdk.incubator.jpackage.internal.ApplicationLayout;
import jdk.jpackage.test.Functional.ThrowingConsumer;
import jdk.jpackage.test.Functional.ThrowingFunction;
+ import jdk.jpackage.test.Functional.ThrowingSupplier;
/**
* 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 final class JPackageCommand extends CommandArguments<JPackageCommand> {
public JPackageCommand() {
! prerequisiteActions = new Actions();
! verifyActions = new Actions();
}
public JPackageCommand(JPackageCommand cmd) {
args.addAll(cmd.args);
withToolProvider = cmd.withToolProvider;
saveConsoleOutput = cmd.saveConsoleOutput;
suppressOutput = cmd.suppressOutput;
ignoreDefaultRuntime = cmd.ignoreDefaultRuntime;
+ ignoreDefaultVerbose = cmd.ignoreDefaultVerbose;
immutable = cmd.immutable;
! prerequisiteActions = new Actions(cmd.prerequisiteActions);
! verifyActions = new Actions(cmd.verifyActions);
}
JPackageCommand createImmutableCopy() {
JPackageCommand reply = new JPackageCommand(this);
reply.immutable = true;
*** 202,213 ****
&& !hasArgument("--module")
&& !hasArgument("--app-image");
}
public JPackageCommand setDefaultInputOutput() {
! addArguments("--input", TKit.defaultInputDir());
! addArguments("--dest", TKit.defaultOutputDir());
return this;
}
public JPackageCommand setFakeRuntime() {
verifyMutable();
--- 205,216 ----
&& !hasArgument("--module")
&& !hasArgument("--app-image");
}
public JPackageCommand setDefaultInputOutput() {
! setArgumentValue("--input", TKit.workDir().resolve("input"));
! setArgumentValue("--dest", TKit.workDir().resolve("output"));
return this;
}
public JPackageCommand setFakeRuntime() {
verifyMutable();
*** 219,229 ****
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));
--- 222,232 ----
new SecureRandom().nextBytes(bytes);
out.write(bytes);
}
};
! addPrerequisiteAction(cmd -> {
Path fakeRuntimeDir = TKit.workDir().resolve("fake_runtime");
TKit.trace(String.format("Init fake runtime in [%s] directory",
fakeRuntimeDir));
*** 252,264 ****
});
return this;
}
! JPackageCommand addAction(ThrowingConsumer<JPackageCommand> action) {
verifyMutable();
! actions.add(ThrowingConsumer.toConsumer(action));
return this;
}
/**
* Shorthand for {@code helloAppImage(null)}.
--- 255,273 ----
});
return this;
}
! JPackageCommand addPrerequisiteAction(ThrowingConsumer<JPackageCommand> action) {
! verifyMutable();
! prerequisiteActions.add(action);
! return this;
! }
!
! JPackageCommand addVerifyAction(ThrowingConsumer<JPackageCommand> action) {
verifyMutable();
! verifyActions.add(action);
return this;
}
/**
* Shorthand for {@code helloAppImage(null)}.
*** 361,370 ****
--- 370,385 ----
*
* E.g. on Linux for app named Foo default the function will return
* `/opt/foo`
*/
public Path appInstallationDirectory() {
+ Path unpackedDir = getArgumentValue(UNPACKED_PATH_ARGNAME, () -> null,
+ Path::of);
+ if (unpackedDir != null) {
+ return unpackedDir;
+ }
+
if (isImagePackageType()) {
return null;
}
if (TKit.isLinux()) {
*** 424,434 ****
if (TKit.isWindows()) {
launcherName = launcherName + ".exe";
}
! if (isImagePackageType()) {
return appLayout().launchersDirectory().resolve(launcherName);
}
if (TKit.isLinux()) {
return LinuxHelper.getLauncherPath(this).getParent().resolve(launcherName);
--- 439,449 ----
if (TKit.isWindows()) {
launcherName = launcherName + ".exe";
}
! if (isImagePackageType() || isPackageUnpacked()) {
return appLayout().launchersDirectory().resolve(launcherName);
}
if (TKit.isLinux()) {
return LinuxHelper.getLauncherPath(this).getParent().resolve(launcherName);
*** 494,503 ****
--- 509,531 ----
return true;
}
return false;
}
+ public boolean isPackageUnpacked(String msg) {
+ if (isPackageUnpacked()) {
+ TKit.trace(String.format(
+ "%s because package was unpacked, not installed", msg));
+ return true;
+ }
+ return false;
+ }
+
+ boolean isPackageUnpacked() {
+ return hasArgument(UNPACKED_PATH_ARGNAME);
+ }
+
public static void useToolProviderByDefault() {
defaultWithToolProvider = true;
}
public static void useExecutableByDefault() {
*** 526,553 ****
verifyMutable();
ignoreDefaultRuntime = v;
return this;
}
public boolean isWithToolProvider() {
return Optional.ofNullable(withToolProvider).orElse(
defaultWithToolProvider);
}
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()) {
--- 554,585 ----
verifyMutable();
ignoreDefaultRuntime = v;
return this;
}
+ public JPackageCommand ignoreDefaultVerbose(boolean v) {
+ verifyMutable();
+ ignoreDefaultVerbose = v;
+ return this;
+ }
+
public boolean isWithToolProvider() {
return Optional.ofNullable(withToolProvider).orElse(
defaultWithToolProvider);
}
public JPackageCommand executePrerequisiteActions() {
! prerequisiteActions.run();
! return this;
}
+
+ public JPackageCommand executeVerifyActions() {
+ verifyActions.run();
return this;
}
! private Executor createExecutor() {
Executor exec = new Executor()
.saveOutput(saveConsoleOutput).dumpOutput(!suppressOutput)
.addArguments(args);
if (isWithToolProvider()) {
*** 558,588 ****
return exec;
}
public Executor.Result execute() {
executePrerequisiteActions();
if (isImagePackageType()) {
TKit.deleteDirectoryContentsRecursive(outputDir());
}
! return new JPackageCommand(this)
.adjustArgumentsBeforeExecution()
.createExecutor()
! .execute();
}
! public JPackageCommand executeAndAssertHelloAppImageCreated() {
! executeAndAssertImageCreated();
HelloApp.executeLauncherAndVerifyOutput(this);
! return this;
}
! public JPackageCommand executeAndAssertImageCreated() {
! execute().assertExitCodeIsZero();
! return assertImageCreated();
}
public JPackageCommand assertImageCreated() {
verifyIsOfType(PackageType.IMAGE);
TKit.assertDirectoryExists(appRuntimeDirectory());
--- 590,653 ----
return exec;
}
public Executor.Result execute() {
+ return execute(0);
+ }
+
+ public Executor.Result execute(int expectedExitCode) {
executePrerequisiteActions();
if (isImagePackageType()) {
TKit.deleteDirectoryContentsRecursive(outputDir());
+ } else if (ThrowingSupplier.toSupplier(() -> Files.deleteIfExists(
+ outputBundle())).get()) {
+ TKit.trace(
+ String.format("Deleted [%s] file before running jpackage",
+ outputBundle()));
+ }
+
+ Path resourceDir = getArgumentValue("--resource-dir", () -> null, Path::of);
+ if (resourceDir != null && Files.isDirectory(resourceDir)) {
+ TKit.trace(String.format("Files in [%s] resource dir:",
+ resourceDir));
+ try (var files = Files.walk(resourceDir, 1)) {
+ files.sequential()
+ .filter(Predicate.not(resourceDir::equals))
+ .map(path -> String.format("[%s]", path.getFileName()))
+ .forEachOrdered(TKit::trace);
+ TKit.trace("Done");
+ } catch (IOException ex) {
+ TKit.trace(String.format(
+ "Failed to list files in [%s] resource directory: %s",
+ resourceDir, ex));
+ }
}
! Executor.Result result = new JPackageCommand(this)
.adjustArgumentsBeforeExecution()
.createExecutor()
! .execute(expectedExitCode);
!
! if (result.exitCode == 0) {
! executeVerifyActions();
! }
!
! return result;
}
! public Executor.Result executeAndAssertHelloAppImageCreated() {
! Executor.Result result = executeAndAssertImageCreated();
HelloApp.executeLauncherAndVerifyOutput(this);
! return result;
}
! public Executor.Result executeAndAssertImageCreated() {
! Executor.Result result = execute();
! assertImageCreated();
! return result;
}
public JPackageCommand assertImageCreated() {
verifyIsOfType(PackageType.IMAGE);
TKit.assertDirectoryExists(appRuntimeDirectory());
*** 593,619 ****
}
return this;
}
private JPackageCommand adjustArgumentsBeforeExecution() {
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;
}
! String getPrintableCommandLine() {
! return new Executor()
! .setExecutable(JavaTool.JPACKAGE)
! .addArguments(args)
! .getPrintableCommandLine();
}
public void verifyIsOfType(Collection<PackageType> types) {
verifyIsOfType(types.toArray(PackageType[]::new));
}
--- 658,687 ----
}
return this;
}
+ JPackageCommand setUnpackedPackageLocation(Path path) {
+ verifyIsOfType(PackageType.NATIVE);
+ setArgumentValue(UNPACKED_PATH_ARGNAME, path);
+ return this;
+ }
+
private JPackageCommand adjustArgumentsBeforeExecution() {
if (!hasArgument("--runtime-image") && !hasArgument("--app-image") && DEFAULT_RUNTIME_IMAGE != null && !ignoreDefaultRuntime) {
addArguments("--runtime-image", DEFAULT_RUNTIME_IMAGE);
}
! if (!hasArgument("--verbose") && TKit.VERBOSE_JPACKAGE && !ignoreDefaultVerbose) {
addArgument("--verbose");
}
return this;
}
! public String getPrintableCommandLine() {
! return createExecutor().getPrintableCommandLine();
}
public void verifyIsOfType(Collection<PackageType> types) {
verifyIsOfType(types.toArray(PackageType[]::new));
}
*** 697,713 ****
@Override
protected boolean isMutable() {
return !immutable;
}
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;
private final static Map<String, PackageType> PACKAGE_TYPES = Functional.identity(
() -> {
Map<String, PackageType> reply = new HashMap<>();
--- 765,816 ----
@Override
protected boolean isMutable() {
return !immutable;
}
+ private final class Actions implements Runnable {
+ Actions() {
+ actions = new ArrayList<>();
+ }
+
+ Actions(Actions other) {
+ this();
+ actions.addAll(other.actions);
+ }
+
+ void add(ThrowingConsumer<JPackageCommand> action) {
+ Objects.requireNonNull(action);
+ verifyMutable();
+ actions.add(new Consumer<JPackageCommand>() {
+ @Override
+ public void accept(JPackageCommand t) {
+ if (!executed) {
+ executed = true;
+ ThrowingConsumer.toConsumer(action).accept(t);
+ }
+ }
+ private boolean executed;
+ });
+ }
+
+ @Override
+ public void run() {
+ verifyMutable();
+ actions.forEach(action -> action.accept(JPackageCommand.this));
+ }
+
+ private final List<Consumer<JPackageCommand>> actions;
+ }
+
private Boolean withToolProvider;
private boolean saveConsoleOutput;
private boolean suppressOutput;
private boolean ignoreDefaultRuntime;
+ private boolean ignoreDefaultVerbose;
private boolean immutable;
! private final Actions prerequisiteActions;
! private final Actions verifyActions;
private static boolean defaultWithToolProvider;
private final static Map<String, PackageType> PACKAGE_TYPES = Functional.identity(
() -> {
Map<String, PackageType> reply = new HashMap<>();
*** 727,732 ****
--- 830,837 ----
if (val != null) {
return Path.of(val);
}
return null;
}).get();
+
+ private final static String UNPACKED_PATH_ARGNAME = "jpt-unpacked-folder";
}
< prev index next >