import static java.lang.System.exit;
import static java.lang.System.getProperty;
import static java.nio.file.Files.createDirectories;
import static java.nio.file.Files.delete;
import static java.nio.file.Files.exists;
import static java.nio.file.Files.getLastModifiedTime;
import static java.nio.file.Files.getPosixFilePermissions;
import static java.nio.file.Files.list;
import static java.nio.file.Files.newBufferedReader;
import static java.nio.file.Files.newOutputStream;
import static java.nio.file.Files.readAllLines;
import static java.nio.file.Files.setPosixFilePermissions;
import static java.nio.file.Files.walk;
import static java.nio.file.Files.walkFileTree;
import static java.nio.file.Files.write;
import static java.nio.file.attribute.PosixFilePermission.GROUP_EXECUTE;
import static java.nio.file.attribute.PosixFilePermission.OTHERS_EXECUTE;
import static java.nio.file.attribute.PosixFilePermission.OWNER_EXECUTE;
import static java.util.Collections.reverseOrder;
import static java.util.Comparator.comparing;
import static java.util.function.Predicate.not;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.UncheckedIOException;
import java.net.InetAddress;
import java.net.URL;
import java.net.UnknownHostException;
import java.nio.charset.StandardCharsets;
import java.nio.file.FileVisitResult;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.SimpleFileVisitor;
import java.nio.file.attribute.BasicFileAttributes;
import java.nio.file.attribute.FileTime;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Optional;
import java.util.Properties;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Stream;
import java.util.zip.ZipFile;
class pro_wrapper {
private static final String GITHUB_API_RELEASES = "https://github.com/forax/pro/releases";
private static final String GITHUB_DOWNLOAD = "https://github.com/forax/pro/releases/download";
private static final Pattern PATTERN = Pattern.compile("tag/([^\"]+)\"");
private static String platform() {
var osName = getProperty("os.name").toLowerCase();
if (osName.indexOf("win") != -1) {
return "windows";
}
if (osName.indexOf("mac") != -1) {
return "macos";
}
return "linux";
}
private static String shell() {
var osName = getProperty("os.name").toLowerCase();
if (osName.indexOf("win") != -1) {
return "cmd.exe";
}
return Optional.ofNullable(System.getenv("SHELL")).filter(not(String::isEmpty)).orElse("/bin/sh");
}
private static Optional<String> specialBuild() throws IOException {
var specialBuild = System.getenv("PRO_SPECIAL_BUILD");
var path = Path.of("pro_wrapper_settings.txt");
var proSettings = new Properties();
if (exists(path)) {
try(var reader = newBufferedReader(path)) {
proSettings.load(reader);
}
}
return Optional.ofNullable(specialBuild).filter(not(String::isEmpty)).or(
() -> Optional.ofNullable(proSettings.getProperty("PRO_SPECIAL_BUILD")));
}
private static String userHome() {
return System.getProperty("user.home");
}
private static Optional<String> lastestReleaseVersionFromGitHub() throws IOException {
System.out.println("try to find latest release on Github ...");
var url = new URL(GITHUB_API_RELEASES);
try {
InetAddress.getByName(url.getHost()); // is internet accessible ?
} catch(@SuppressWarnings("unused") UnknownHostException e) {
return Optional.empty();
}
try(var input = url.openStream();
var reader = new InputStreamReader(input, StandardCharsets.UTF_8);
var buffered = new BufferedReader(reader, 8192)) {
return buffered.lines()
.flatMap(line -> Optional.of(PATTERN.matcher(line)).filter(Matcher::find).map(matcher -> matcher.group(1)).stream())
.findFirst();
}
}
private static FileTime lastModified(Path path) {
try {
return getLastModifiedTime(path);
} catch (IOException e) {
throw new UncheckedIOException(e);
}
}
private static Optional<String> latestReleaseVersionFromCache(Path cache, String filename) {
System.out.println("try to find latest release in the cache ...");
try {
return walk(cache)
.filter(p -> p.getFileName().toString().equals(filename))
.sorted(reverseOrder(comparing(p -> lastModified(p))))
.findFirst().map(p -> p.getParent().getFileName().toString());
} catch (@SuppressWarnings("unused") IOException | UncheckedIOException e) {
return Optional.empty();
}
}
private static void download(String release, String filename, Path path) throws IOException {
var url = new URL(GITHUB_DOWNLOAD + "/"+ release + "/" + filename);
System.out.println("download " + url + " to " + path);
createDirectories(path.getParent());
try(var input = url.openStream();
var output = newOutputStream(path)) {
int read;
var sum = 0;
var buffer = new byte[8192];
while((read = input.read(buffer)) != -1) {
output.write(buffer, 0, read);
sum += read;
if (sum >= 1_000_000) {
System.out.print(".");
sum = 0;
}
}
}
System.out.println("");
}
private static void setExecutionPermissions(Path path) throws IOException {
var permissions = getPosixFilePermissions(path);
Collections.addAll(permissions, OWNER_EXECUTE, GROUP_EXECUTE, OTHERS_EXECUTE);
setPosixFilePermissions(path, permissions);
}
private static void unpack(Path localPath, Path folder) throws IOException {
System.out.println("unpack pro to " + folder);
createDirectories(folder);
try(var zip = new ZipFile(localPath.toFile())) {
for(var entry: Collections.list(zip.entries())) {
var path = folder.resolve(entry.getName());
if (entry.isDirectory()) {
createDirectories(path);
continue;
}
try(var input = zip.getInputStream(entry);
var output = newOutputStream(path)) {
input.transferTo(output);
}
}
}
// make the commands in pro/bin, and pro/lib executable
for(var cmd: (Iterable<Path>)list(folder.resolve("pro").resolve("bin"))::iterator) {
setExecutionPermissions(cmd);
}
for(var path: (Iterable<Path>)list(folder.resolve("pro").resolve("lib"))::iterator) {
var fileName = path.getFileName().toString();
if (fileName.equals("jexec") || fileName.equals("jspawnhelper")) {
setExecutionPermissions(path);
}
}
}
private static void deleteAllFiles(Path directory) throws IOException {
if (!exists(directory)) {
return;
}
walkFileTree(directory, new SimpleFileVisitor<>() {
@Override
public FileVisitResult postVisitDirectory(Path path, IOException e) throws IOException {
delete(path);
return super.postVisitDirectory(path, e);
}
@Override
public FileVisitResult visitFile(Path path, BasicFileAttributes attrs) throws IOException {
delete(path);
return FileVisitResult.CONTINUE;
}
});
}
private static String firstLine(Path path) throws IOException {
return Optional.of(readAllLines(path)).filter(lines -> !lines.isEmpty()).map(lines -> lines.get(0)).orElse("");
}
private static int exec(String command, String[] args) throws IOException {
var builder = new ProcessBuilder(Stream.of(Stream.of(shell()), Stream.of(command), Arrays.stream(args)).flatMap(x -> x).toArray(String[]::new));
var process = builder.inheritIO().start();
try {
return process.waitFor();
} catch (InterruptedException e) {
throw new IOException(e);
}
}
public interface PathConsumer {
void accept(Path path) throws IOException;
}
private static void retry(Path resource, int times, PathConsumer consumer) throws IOException {
if (times <= 0) {
throw new IllegalArgumentException("times <= 0");
}
IOException exception = null;
var count = times;
do {
try {
consumer.accept(resource);
return;
} catch(IOException e) {
if (exception == null) {
exception = new IOException();
}
exception.addSuppressed(e);
// cleanup
Files.deleteIfExists(resource);
System.out.println("download fails ... retry !");
}
} while(--count != 0);
throw exception;
}
private static int installAndRun(String[] args) throws IOException {
var specialBuild = specialBuild().map(build -> '-' + build).orElse("");
var filename = "pro-" + platform() + specialBuild + ".zip";
var cache = Path.of(userHome(), ".pro", "cache");
var release = lastestReleaseVersionFromGitHub()
.or(() -> latestReleaseVersionFromCache(cache, filename))
.orElseThrow(() -> new IOException("no release found !"));
System.out.println("require " + filename + " release " + release + " ...");
var cachePath = cache.resolve(Path.of(release, filename));
if (!exists(cachePath)) {
retry(cachePath, 3, _cachedPath -> download(release, filename, _cachedPath));
}
var releaseTxt = Path.of("pro", "pro-release.txt");
if (!exists(releaseTxt) || !firstLine(releaseTxt).equals(filename)) {
deleteAllFiles(releaseTxt.getParent());
unpack(cachePath, Path.of("."));
write(releaseTxt, List.of(filename));
}
return exec("pro/bin/pro", args);
}
public static void main(String[] args) {
try {
exit(installAndRun(args));
} catch(IOException e) {
System.err.println("i/o error " + e.getMessage() +
Optional.ofNullable(e.getStackTrace()).filter(stack -> stack.length > 0).map(stack -> " at " + stack[0]).orElse(""));
exit(1);
}
}
}
