package jdk.tools.jlink.internal.plugins;
import java.io.ByteArrayOutputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.UncheckedIOException;
import java.lang.module.ModuleDescriptor;
import java.util.EnumSet;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
import java.util.function.Function;
import java.util.stream.Collectors;
import jdk.tools.jlink.internal.ModuleSorter;
import jdk.tools.jlink.internal.Utils;
import jdk.tools.jlink.plugin.PluginException;
import jdk.tools.jlink.plugin.ResourcePool;
import jdk.tools.jlink.plugin.ResourcePoolBuilder;
import jdk.tools.jlink.plugin.ResourcePoolEntry;
import jdk.tools.jlink.plugin.ResourcePoolModule;
import jdk.tools.jlink.plugin.Plugin;
public final class ReleaseInfoPlugin implements Plugin {
public static final String NAME = "release-info";
public static final String KEYS = "keys";
private final Map<String, String> release = new HashMap<>();
@Override
public Category getType() {
return Category.METAINFO_ADDER;
}
@Override
public String getName() {
return NAME;
}
@Override
public String getDescription() {
return PluginsResourceBundle.getDescription(NAME);
}
@Override
public Set<State> getState() {
return EnumSet.of(State.AUTO_ENABLED, State.FUNCTIONAL);
}
@Override
public boolean hasArguments() {
return true;
}
@Override
public String getArgumentsDescription() {
return PluginsResourceBundle.getArgument(NAME);
}
@Override
public void configure(Map<String, String> config) {
String operation = config.get(NAME);
if (operation == null) {
return;
}
switch (operation) {
case "add": {
config.keySet().stream()
.filter(s -> !NAME.equals(s))
.forEach(s -> release.put(s, config.get(s)));
}
break;
case "del": {
Utils.parseList(config.get(KEYS)).stream().forEach((k) -> {
release.remove(k);
});
}
break;
default: {
Properties props = new Properties();
try (FileInputStream fis = new FileInputStream(operation)) {
props.load(fis);
} catch (IOException exp) {
throw new UncheckedIOException(exp);
}
props.forEach((k, v) -> release.put(k.toString(), v.toString()));
}
break;
}
}
@Override
public ResourcePool transform(ResourcePool in, ResourcePoolBuilder out) {
in.transformAndCopy(Function.identity(), out);
ResourcePoolModule javaBase = in.moduleView().findModule("java.base")
.orElse(null);
if (javaBase == null || javaBase.targetPlatform() == null) {
throw new PluginException("ModuleTarget attribute is missing for java.base module");
}
ModuleDescriptor desc = javaBase.descriptor();
desc.version().ifPresent(v -> release.put("JAVA_VERSION",
quote(parseVersion(v))));
release.put("MODULES", new ModuleSorter(in.moduleView())
.sorted().map(ResourcePoolModule::name)
.collect(Collectors.joining(" ", "\"", "\"")));
out.add(ResourcePoolEntry.create("/java.base/release",
ResourcePoolEntry.Type.TOP,
releaseFileContent()));
return out.build();
}
private static String parseVersion(ModuleDescriptor.Version v) {
return Runtime.Version.parse(v.toString())
.version()
.stream()
.map(Object::toString)
.collect(Collectors.joining("."));
}
private static String quote(String str) {
return "\"" + str + "\"";
}
private byte[] releaseFileContent() {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
try (PrintWriter pw = new PrintWriter(baos)) {
release.entrySet().stream()
.sorted(Map.Entry.comparingByKey())
.forEach(e -> pw.format("%s=%s%n", e.getKey(), e.getValue()));
}
return baos.toByteArray();
}
}