Port the build to Gradle

Closes gh-19609
Closes gh-19608

spring-boot-project/spring-boot-cli/src/intTest/java/org/springframework/boot/cli/CommandLineIT.java

@@ -0,0 +1,86 @@
+/*
+ * Copyright 2012-2019 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.boot.cli;
+
+import java.io.File;
+import java.io.IOException;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+import org.springframework.boot.cli.infrastructure.CommandLineInvoker;
+import org.springframework.boot.cli.infrastructure.CommandLineInvoker.Invocation;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Integration Tests for the command line application.
+ *
+ * @author Andy Wilkinson
+ * @author Phillip Webb
+ */
+class CommandLineIT {
+
+	private CommandLineInvoker cli;
+
+	@BeforeEach
+	void setup(@TempDir File tempDir) {
+		this.cli = new CommandLineInvoker(tempDir);
+	}
+
+	@Test
+	void hintProducesListOfValidCommands() throws IOException, InterruptedException {
+		Invocation cli = this.cli.invoke("hint");
+		assertThat(cli.await()).isEqualTo(0);
+		assertThat(cli.getErrorOutput()).isEmpty();
+		assertThat(cli.getStandardOutputLines()).hasSize(11);
+	}
+
+	@Test
+	void invokingWithNoArgumentsDisplaysHelp() throws IOException, InterruptedException {
+		Invocation cli = this.cli.invoke();
+		assertThat(cli.await()).isEqualTo(1);
+		assertThat(cli.getErrorOutput()).isEmpty();
+		assertThat(cli.getStandardOutput()).startsWith("usage:");
+	}
+
+	@Test
+	void unrecognizedCommandsAreHandledGracefully() throws IOException, InterruptedException {
+		Invocation cli = this.cli.invoke("not-a-real-command");
+		assertThat(cli.await()).isEqualTo(1);
+		assertThat(cli.getErrorOutput()).contains("'not-a-real-command' is not a valid command");
+		assertThat(cli.getStandardOutput()).isEmpty();
+	}
+
+	@Test
+	void version() throws IOException, InterruptedException {
+		Invocation cli = this.cli.invoke("version");
+		assertThat(cli.await()).isEqualTo(0);
+		assertThat(cli.getErrorOutput()).isEmpty();
+		assertThat(cli.getStandardOutput()).startsWith("Spring CLI v");
+	}
+
+	@Test
+	void help() throws IOException, InterruptedException {
+		Invocation cli = this.cli.invoke("help");
+		assertThat(cli.await()).isEqualTo(1);
+		assertThat(cli.getErrorOutput()).isEmpty();
+		assertThat(cli.getStandardOutput()).startsWith("usage:");
+	}
+
+}

spring-boot-project/spring-boot-cli/src/intTest/java/org/springframework/boot/cli/JarCommandIT.java

@@ -0,0 +1,150 @@
+/*
+ * Copyright 2012-2019 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.boot.cli;
+
+import java.io.File;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+import org.springframework.boot.cli.command.archive.JarCommand;
+import org.springframework.boot.cli.infrastructure.CommandLineInvoker;
+import org.springframework.boot.cli.infrastructure.CommandLineInvoker.Invocation;
+import org.springframework.boot.loader.tools.JavaExecutable;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Integration test for {@link JarCommand}.
+ *
+ * @author Andy Wilkinson
+ * @author Stephane Nicoll
+ */
+class JarCommandIT {
+
+	private static final boolean JAVA_9_OR_LATER = isClassPresent("java.security.cert.URICertStoreParameters");
+
+	private CommandLineInvoker cli;
+
+	private File tempDir;
+
+	@BeforeEach
+	void setup(@TempDir File tempDir) {
+		this.cli = new CommandLineInvoker(new File("src/intTest/resources/jar-command"), tempDir);
+		this.tempDir = tempDir;
+	}
+
+	@Test
+	void noArguments() throws Exception {
+		Invocation invocation = this.cli.invoke("jar");
+		invocation.await();
+		assertThat(invocation.getStandardOutput()).isEqualTo("");
+		assertThat(invocation.getErrorOutput())
+				.contains("The name of the " + "resulting jar and at least one source file must be specified");
+	}
+
+	@Test
+	void noSources() throws Exception {
+		Invocation invocation = this.cli.invoke("jar", "test-app.jar");
+		invocation.await();
+		assertThat(invocation.getStandardOutput()).isEqualTo("");
+		assertThat(invocation.getErrorOutput())
+				.contains("The name of the " + "resulting jar and at least one source file must be specified");
+	}
+
+	@Test
+	void jarCreationWithGrabResolver() throws Exception {
+		File jar = new File(this.tempDir, "test-app.jar");
+		Invocation invocation = this.cli.invoke("run", jar.getAbsolutePath(), "bad.groovy");
+		invocation.await();
+		if (!JAVA_9_OR_LATER) {
+			assertThat(invocation.getErrorOutput()).isEqualTo("");
+		}
+		invocation = this.cli.invoke("jar", jar.getAbsolutePath(), "bad.groovy");
+		invocation.await();
+		if (!JAVA_9_OR_LATER) {
+			assertThat(invocation.getErrorOutput()).isEmpty();
+		}
+		assertThat(jar).exists();
+
+		Process process = new JavaExecutable().processBuilder("-jar", jar.getAbsolutePath()).start();
+		invocation = new Invocation(process);
+		invocation.await();
+
+		if (!JAVA_9_OR_LATER) {
+			assertThat(invocation.getErrorOutput()).isEqualTo("");
+		}
+	}
+
+	@Test
+	void jarCreation() throws Exception {
+		File jar = new File(this.tempDir, "test-app.jar");
+		Invocation invocation = this.cli.invoke("jar", jar.getAbsolutePath(), "jar.groovy");
+		invocation.await();
+		if (!JAVA_9_OR_LATER) {
+			assertThat(invocation.getErrorOutput()).isEmpty();
+		}
+		assertThat(jar).exists();
+
+		Process process = new JavaExecutable().processBuilder("-jar", jar.getAbsolutePath()).start();
+		invocation = new Invocation(process);
+		invocation.await();
+
+		if (!JAVA_9_OR_LATER) {
+			assertThat(invocation.getErrorOutput()).isEqualTo("");
+		}
+		assertThat(invocation.getStandardOutput()).contains("Hello World!")
+				.contains("/BOOT-INF/classes!/public/public.txt").contains("/BOOT-INF/classes!/resources/resource.txt")
+				.contains("/BOOT-INF/classes!/static/static.txt").contains("/BOOT-INF/classes!/templates/template.txt")
+				.contains("/BOOT-INF/classes!/root.properties").contains("Goodbye Mama");
+	}
+
+	@Test
+	void jarCreationWithIncludes() throws Exception {
+		File jar = new File(this.tempDir, "test-app.jar");
+		Invocation invocation = this.cli.invoke("jar", jar.getAbsolutePath(), "--include", "-public/**,-resources/**",
+				"jar.groovy");
+		invocation.await();
+		if (!JAVA_9_OR_LATER) {
+			assertThat(invocation.getErrorOutput()).isEmpty();
+		}
+		assertThat(jar).exists();
+
+		Process process = new JavaExecutable().processBuilder("-jar", jar.getAbsolutePath()).start();
+		invocation = new Invocation(process);
+		invocation.await();
+
+		if (!JAVA_9_OR_LATER) {
+			assertThat(invocation.getErrorOutput()).isEqualTo("");
+		}
+		assertThat(invocation.getStandardOutput()).contains("Hello World!").doesNotContain("/public/public.txt")
+				.doesNotContain("/resources/resource.txt").contains("/static/static.txt")
+				.contains("/templates/template.txt").contains("Goodbye Mama");
+	}
+
+	private static boolean isClassPresent(String name) {
+		try {
+			Class.forName(name);
+			return true;
+		}
+		catch (Exception ex) {
+			return false;
+		}
+	}
+
+}

spring-boot-project/spring-boot-cli/src/intTest/java/org/springframework/boot/cli/WarCommandIT.java

@@ -0,0 +1,66 @@
+/*
+ * Copyright 2012-2019 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.boot.cli;
+
+import java.io.File;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+import org.springframework.boot.cli.command.archive.WarCommand;
+import org.springframework.boot.cli.infrastructure.CommandLineInvoker;
+import org.springframework.boot.cli.infrastructure.CommandLineInvoker.Invocation;
+import org.springframework.boot.loader.tools.JavaExecutable;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Integration test for {@link WarCommand}.
+ *
+ * @author Andrey Stolyarov
+ * @author Henri Kerola
+ */
+class WarCommandIT {
+
+	private CommandLineInvoker cli;
+
+	private File tempDir;
+
+	@BeforeEach
+	void setup(@TempDir File tempDir) {
+		this.cli = new CommandLineInvoker(new File("src/intTest/resources/war-command"), tempDir);
+		this.tempDir = tempDir;
+	}
+
+	@Test
+	void warCreation() throws Exception {
+		File war = new File(this.tempDir, "test-app.war");
+		Invocation invocation = this.cli.invoke("war", war.getAbsolutePath(), "war.groovy");
+		invocation.await();
+		assertThat(war.exists()).isTrue();
+		Process process = new JavaExecutable().processBuilder("-jar", war.getAbsolutePath(), "--server.port=0").start();
+		invocation = new Invocation(process);
+		invocation.await();
+		assertThat(invocation.getOutput()).contains("onStart error");
+		assertThat(invocation.getOutput()).contains("Tomcat started");
+		assertThat(invocation.getOutput()).contains("/WEB-INF/lib-provided/tomcat-embed-core");
+		assertThat(invocation.getOutput()).contains("WEB-INF/classes!/root.properties");
+		process.destroy();
+	}
+
+}

spring-boot-project/spring-boot-cli/src/intTest/java/org/springframework/boot/cli/infrastructure/CommandLineInvoker.java

@@ -0,0 +1,217 @@
+/*
+ * Copyright 2012-2019 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.boot.cli.infrastructure;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.PrintWriter;
+import java.io.StringReader;
+import java.io.StringWriter;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.nio.file.StandardCopyOption;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipInputStream;
+
+import org.springframework.boot.testsupport.BuildOutput;
+import org.springframework.util.Assert;
+import org.springframework.util.StreamUtils;
+
+/**
+ * Utility to invoke the command line in the same way as a user would, i.e. via the shell
+ * script in the package's bin directory.
+ *
+ * @author Andy Wilkinson
+ * @author Phillip Webb
+ */
+public final class CommandLineInvoker {
+
+	private final File workingDirectory;
+
+	private final File temp;
+
+	public CommandLineInvoker(File temp) {
+		this(new File("."), temp);
+	}
+
+	public CommandLineInvoker(File workingDirectory, File temp) {
+		this.workingDirectory = workingDirectory;
+		this.temp = temp;
+	}
+
+	public Invocation invoke(String... args) throws IOException {
+		return new Invocation(runCliProcess(args));
+	}
+
+	private Process runCliProcess(String... args) throws IOException {
+		Path m2 = this.temp.toPath().resolve(".m2");
+		Files.createDirectories(m2);
+		Files.copy(Paths.get("src", "intTest", "resources", "settings.xml"), m2.resolve("settings.xml"),
+				StandardCopyOption.REPLACE_EXISTING);
+		List<String> command = new ArrayList<>();
+		command.add(findLaunchScript().getAbsolutePath());
+		command.addAll(Arrays.asList(args));
+		ProcessBuilder processBuilder = new ProcessBuilder(command).directory(this.workingDirectory);
+		processBuilder.environment().put("JAVA_OPTS", "-Duser.home=" + this.temp);
+		return processBuilder.start();
+	}
+
+	private File findLaunchScript() throws IOException {
+		File unpacked = new File(this.temp, "unpacked-cli");
+		if (!unpacked.isDirectory()) {
+			File zip = new File(new BuildOutput(getClass()).getRootLocation(), "distributions")
+					.listFiles((pathname) -> pathname.getName().endsWith("-bin.zip"))[0];
+			try (ZipInputStream input = new ZipInputStream(new FileInputStream(zip))) {
+				ZipEntry entry;
+				while ((entry = input.getNextEntry()) != null) {
+					File file = new File(unpacked, entry.getName());
+					if (entry.isDirectory()) {
+						file.mkdirs();
+					}
+					else {
+						file.getParentFile().mkdirs();
+						try (FileOutputStream output = new FileOutputStream(file)) {
+							StreamUtils.copy(input, output);
+							if (entry.getName().endsWith("/bin/spring")) {
+								file.setExecutable(true);
+							}
+						}
+					}
+				}
+			}
+		}
+		File bin = new File(unpacked.listFiles()[0], "bin");
+		File launchScript = new File(bin, isWindows() ? "spring.bat" : "spring");
+		Assert.state(launchScript.exists() && launchScript.isFile(),
+				() -> "Could not find CLI launch script " + launchScript.getAbsolutePath());
+		return launchScript;
+	}
+
+	private boolean isWindows() {
+		return File.separatorChar == '\\';
+	}
+
+	/**
+	 * An ongoing Process invocation.
+	 */
+	public static final class Invocation {
+
+		private final StringBuffer err = new StringBuffer();
+
+		private final StringBuffer out = new StringBuffer();
+
+		private final StringBuffer combined = new StringBuffer();
+
+		private final Process process;
+
+		private final List<Thread> streamReaders = new ArrayList<>();
+
+		public Invocation(Process process) {
+			this.process = process;
+			this.streamReaders
+					.add(new Thread(new StreamReadingRunnable(this.process.getErrorStream(), this.err, this.combined)));
+			this.streamReaders
+					.add(new Thread(new StreamReadingRunnable(this.process.getInputStream(), this.out, this.combined)));
+			for (Thread streamReader : this.streamReaders) {
+				streamReader.start();
+			}
+		}
+
+		public String getOutput() {
+			return postProcessLines(getLines(this.combined));
+		}
+
+		public String getErrorOutput() {
+			return postProcessLines(getLines(this.err));
+		}
+
+		public String getStandardOutput() {
+			return postProcessLines(getStandardOutputLines());
+		}
+
+		public List<String> getStandardOutputLines() {
+			return getLines(this.out);
+		}
+
+		private String postProcessLines(List<String> lines) {
+			StringWriter out = new StringWriter();
+			PrintWriter printOut = new PrintWriter(out);
+			for (String line : lines) {
+				if (!line.startsWith("Maven settings decryption failed")) {
+					printOut.println(line);
+				}
+			}
+			return out.toString();
+		}
+
+		private List<String> getLines(StringBuffer buffer) {
+			BufferedReader reader = new BufferedReader(new StringReader(buffer.toString()));
+			return reader.lines().filter((line) -> !line.startsWith("Picked up ")).collect(Collectors.toList());
+		}
+
+		public int await() throws InterruptedException {
+			for (Thread streamReader : this.streamReaders) {
+				streamReader.join();
+			}
+			return this.process.waitFor();
+		}
+
+		/**
+		 * {@link Runnable} to copy stream output.
+		 */
+		private final class StreamReadingRunnable implements Runnable {
+
+			private final InputStream stream;
+
+			private final StringBuffer[] outputs;
+
+			private final byte[] buffer = new byte[4096];
+
+			private StreamReadingRunnable(InputStream stream, StringBuffer... outputs) {
+				this.stream = stream;
+				this.outputs = outputs;
+			}
+
+			@Override
+			public void run() {
+				int read;
+				try {
+					while ((read = this.stream.read(this.buffer)) > 0) {
+						for (StringBuffer output : this.outputs) {
+							output.append(new String(this.buffer, 0, read));
+						}
+					}
+				}
+				catch (IOException ex) {
+					// Allow thread to die
+				}
+			}
+
+		}
+
+	}
+
+}

spring-boot-project/spring-boot-cli/src/intTest/resources/jar-command/bad.groovy

@@ -0,0 +1,6 @@
+@GrabResolver(name='clojars.org', root='https://clojars.org/repo')
+@Grab('redis.embedded:embedded-redis:0.2')
+
+@Component
+class EmbeddedRedis {
+}

spring-boot-project/spring-boot-cli/src/intTest/resources/jar-command/jar.groovy

@@ -0,0 +1,27 @@
+package org.test
+
+@EnableGroovyTemplates
+@Component
+class Example implements CommandLineRunner {
+
+	@Autowired
+	private MyService myService
+
+	void run(String... args) {
+		println "Hello ${this.myService.sayWorld()}"
+		println getClass().getResource('/public/public.txt')
+		println getClass().getResource('/resources/resource.txt')
+		println getClass().getResource('/static/static.txt')
+		println getClass().getResource('/templates/template.txt')
+		println getClass().getResource('/root.properties')
+		println template('template.txt', [world:'Mama'])
+	}
+}
+
+@Service
+class MyService {
+
+	String sayWorld() {
+		return 'World!'
+	}
+}

spring-boot-project/spring-boot-cli/src/intTest/resources/jar-command/templates/template.txt

@@ -0,0 +1 @@
+Goodbye ${world}

spring-boot-project/spring-boot-cli/src/intTest/resources/run-command/quiet.groovy

@@ -0,0 +1,10 @@
+package org.test
+
+@Component
+class Example implements CommandLineRunner {
+
+	void run(String... args) {
+		print "Ssshh"
+	}
+
+}

spring-boot-project/spring-boot-cli/src/intTest/resources/settings.xml

@@ -0,0 +1,23 @@
+<settings>
+        <localRepository>../../../../build/local-m2-repository</localRepository>
+        <profiles>
+                <profile>
+                        <id>cli-test-repo</id>
+                        <activation>
+                                <activeByDefault>true</activeByDefault>
+                        </activation>
+                        <repositories>
+                                <repository>
+                                        <id>local.central</id>
+                                        <url>file:../../../../build/test-repository</url>
+                                        <releases>
+                                                <enabled>true</enabled>
+                                        </releases>
+                                        <snapshots>
+                                                <enabled>true</enabled>
+                                        </snapshots>
+                                </repository>
+                        </repositories>
+                </profile>
+        </profiles>
+</settings>

spring-boot-project/spring-boot-cli/src/intTest/resources/war-command/war.groovy

@@ -0,0 +1,17 @@
+package org.test
+
+@RestController
+class WarExample implements CommandLineRunner {
+
+	@RequestMapping("/")
+	public String hello() {
+		return "Hello"
+	}
+
+	void run(String... args) {
+		println getClass().getResource('/org/apache/tomcat/InstanceManager.class')
+		println getClass().getResource('/root.properties')
+		throw new RuntimeException("onStart error")
+	}
+
+}