Add workingDirectory option for Maven plugin run/start

Add configuration option that specifies the working directory to use to
run/start the application via the Maven plugin.

Closes gh-6243

spring-boot-tools/spring-boot-loader-tools/src/main/java/org/springframework/boot/loader/tools/RunProcess.java

@@ -17,6 +17,7 @@
 package org.springframework.boot.loader.tools;
 
 import java.io.BufferedReader;
+import java.io.File;
 import java.io.IOException;
 import java.io.InputStreamReader;
 import java.lang.reflect.Method;
@@ -41,16 +42,34 @@ public class RunProcess {
 
 	private static final long JUST_ENDED_LIMIT = 500;
 
+	private File workingDirectory;
+
 	private final String[] command;
 
 	private volatile Process process;
 
 	private volatile long endTime;
 
-	public RunProcess(String... command) {
+	/**
+	 * Creates new {@link RunProcess} instance for the specified command
+	 * and working directory.
+	 * @param workingDirectory the working directory of the child process or {@code null}
+	 * to run in the working directory of the current Java process
+	 * @param command the program to execute and it's arguments
+	 */
+	public RunProcess(File workingDirectory, String... command) {
+		this.workingDirectory = workingDirectory;
 		this.command = command;
 	}
 
+	/**
+	 * Creates new {@link RunProcess} instance for the specified command.
+	 * @param command the program to execute and it's arguments
+	 */
+	public RunProcess(String... command) {
+		this(null, command);
+	}
+
 	public int run(boolean waitForProcess, String... args) throws IOException {
 		return run(waitForProcess, Arrays.asList(args));
 	}
@@ -58,6 +77,7 @@ public class RunProcess {
 	protected int run(boolean waitForProcess, Collection<String> args)
 			throws IOException {
 		ProcessBuilder builder = new ProcessBuilder(this.command);
+		builder.directory(workingDirectory);
 		builder.command().addAll(args);
 		builder.redirectErrorStream(true);
 		boolean inheritedIO = inheritIO(builder);

spring-boot-tools/spring-boot-maven-plugin/src/it/run-disable-fork/pom.xml

@@ -23,6 +23,7 @@
 						<configuration>
 							<fork>false</fork>
 							<jvmArguments>-Dfoo=bar</jvmArguments>
+							<workingDirectory>${project.build.sourceDirectory}</workingDirectory>
 						</configuration>
 					</execution>
 				</executions>

spring-boot-tools/spring-boot-maven-plugin/src/it/run-disable-fork/verify.groovy

@@ -3,4 +3,5 @@ import static org.junit.Assert.assertTrue
 def file = new File(basedir, "build.log")
 assertTrue file.text.contains("I haz been run")
 assertTrue file.text.contains("Fork mode disabled, ignoring JVM argument(s) [-Dfoo=bar]")
+assertTrue file.text.contains("Fork mode disabled, ignoring working directory configuration")
 

spring-boot-tools/spring-boot-maven-plugin/src/it/run-working-directory/pom.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+	<modelVersion>4.0.0</modelVersion>
+	<groupId>org.springframework.boot.maven.it</groupId>
+	<artifactId>run-working-directory</artifactId>
+	<version>0.0.1.BUILD-SNAPSHOT</version>
+	<properties>
+		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+	</properties>
+	<build>
+		<plugins>
+			<plugin>
+				<groupId>@project.groupId@</groupId>
+				<artifactId>@project.artifactId@</artifactId>
+				<version>@project.version@</version>
+				<executions>
+					<execution>
+						<phase>package</phase>
+						<goals>
+							<goal>run</goal>
+						</goals>
+						<configuration>
+							<workingDirectory>${project.build.sourceDirectory}</workingDirectory>
+						</configuration>
+					</execution>
+				</executions>
+			</plugin>
+		</plugins>
+	</build>
+</project>

spring-boot-tools/spring-boot-maven-plugin/src/it/run-working-directory/src/main/java/org/test/SampleApplication.java

+/*
+ * Copyright 2012-2016 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
+ *
+ *      http://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.test;
+
+public class SampleApplication {
+
+	public static void main(String[] args) {
+		String workingDirectory =  System.getProperty("user.dir");
+		System.out.println(String.format("I haz been run from %s", workingDirectory));
+	}
+
+}

spring-boot-tools/spring-boot-maven-plugin/src/it/run-working-directory/verify.groovy

+import static org.junit.Assert.assertTrue
+
+def file = new File(basedir, "build.log")
+def workDir = new File(basedir, "src/main/java").getAbsolutePath()
+assertTrue file.text.contains("I haz been run from ${workDir}")
+

spring-boot-tools/spring-boot-maven-plugin/src/main/java/org/springframework/boot/maven/AbstractRunMojo.java

@@ -87,6 +87,14 @@ public abstract class AbstractRunMojo extends AbstractDependencyFilterMojo {
 	@Parameter(property = "run.noverify")
 	private Boolean noverify;
 
+	/**
+	 * The working directory of the application. If specified by default the process
+	 * will be started by forking a new JVM.
+	 * @since 1.5
+	 */
+	@Parameter(property = "run.workingDirectory")
+	private File workingDirectory;
+
 	/**
 	 * JVM arguments that should be associated with the forked process used to run the
 	 * application. On command line, make sure to wrap multiple values between quotes.
@@ -140,8 +148,8 @@ public abstract class AbstractRunMojo extends AbstractDependencyFilterMojo {
 
 	/**
 	 * Flag to indicate if the run processes should be forked. {@code fork} is
-	 * automatically enabled if an agent or jvmArguments are specified, or if devtools is
-	 * present.
+	 * automatically enabled if an agent, jvmArguments or working directory are
+	 * specified, or if devtools is present.
 	 * @since 1.2
 	 */
 	@Parameter(property = "fork")
@@ -185,7 +193,7 @@ public abstract class AbstractRunMojo extends AbstractDependencyFilterMojo {
 	 * @see #logDisabledFork()
 	 */
 	protected boolean enableForkByDefault() {
-		return hasAgent() || hasJvmArgs();
+		return hasAgent() || hasJvmArgs() || hasWorkingDirectorySet();
 	}
 
 	private boolean hasAgent() {
@@ -196,6 +204,10 @@ public abstract class AbstractRunMojo extends AbstractDependencyFilterMojo {
 		return (this.jvmArguments != null && this.jvmArguments.length() > 0);
 	}
 
+	private boolean hasWorkingDirectorySet() {
+		return (this.workingDirectory != null);
+	}
+
 	private void findAgent() {
 		try {
 			if (this.agent == null || this.agent.length == 0) {
@@ -248,6 +260,9 @@ public abstract class AbstractRunMojo extends AbstractDependencyFilterMojo {
 			getLog().warn("Fork mode disabled, ignoring JVM argument(s) ["
 					+ this.jvmArguments + "]");
 		}
+		if (hasWorkingDirectorySet()) {
+			getLog().warn("Fork mode disabled, ignoring working directory configuration");
+		}
 	}
 
 	private void doRunWithForkedJvm(String startClassName)
@@ -258,16 +273,17 @@ public abstract class AbstractRunMojo extends AbstractDependencyFilterMojo {
 		addClasspath(args);
 		args.add(startClassName);
 		addArgs(args);
-		runWithForkedJvm(args);
+		runWithForkedJvm(this.workingDirectory, args);
 	}
 
 	/**
 	 * Run with a forked VM, using the specified command line arguments.
+	 * @param workingDirectory the working directory of the forked JVM
 	 * @param args the arguments (JVM arguments and application arguments)
 	 * @throws MojoExecutionException in case of MOJO execution errors
 	 * @throws MojoFailureException in case of MOJO failures
 	 */
-	protected abstract void runWithForkedJvm(List<String> args)
+	protected abstract void runWithForkedJvm(File workingDirectory, List<String> args)
 			throws MojoExecutionException, MojoFailureException;
 
 	/**

spring-boot-tools/spring-boot-maven-plugin/src/main/java/org/springframework/boot/maven/RunMojo.java

@@ -17,6 +17,7 @@
 package org.springframework.boot.maven;
 
 import java.net.URL;
+import java.io.File;
 import java.net.URLClassLoader;
 import java.util.List;
 
@@ -63,9 +64,9 @@ public class RunMojo extends AbstractRunMojo {
 	}
 
 	@Override
-	protected void runWithForkedJvm(List<String> args) throws MojoExecutionException {
+	protected void runWithForkedJvm(File workingDirectory, List<String> args) throws MojoExecutionException {
 		try {
-			RunProcess runProcess = new RunProcess(new JavaExecutable().toString());
+			RunProcess runProcess = new RunProcess(workingDirectory, new JavaExecutable().toString());
 			Runtime.getRuntime()
 					.addShutdownHook(new Thread(new RunProcessKiller(runProcess)));
 			int exitCode = runProcess.run(true, args.toArray(new String[args.size()]));

spring-boot-tools/spring-boot-maven-plugin/src/main/java/org/springframework/boot/maven/StartMojo.java

@@ -16,6 +16,7 @@
 
 package org.springframework.boot.maven;
 
+import java.io.File;
 import java.io.IOException;
 import java.lang.management.ManagementFactory;
 import java.net.ConnectException;
@@ -87,9 +88,9 @@ public class StartMojo extends AbstractRunMojo {
 	private final Object lock = new Object();
 
 	@Override
-	protected void runWithForkedJvm(List<String> args)
+	protected void runWithForkedJvm(File workingDirectory, List<String> args)
 			throws MojoExecutionException, MojoFailureException {
-		RunProcess runProcess = runProcess(args);
+		RunProcess runProcess = runProcess(args, workingDirectory);
 		try {
 			waitForSpringApplication();
 		}
@@ -103,9 +104,9 @@ public class StartMojo extends AbstractRunMojo {
 		}
 	}
 
-	private RunProcess runProcess(List<String> args) throws MojoExecutionException {
+	private RunProcess runProcess(List<String> args, File workingDirectory) throws MojoExecutionException {
 		try {
-			RunProcess runProcess = new RunProcess(new JavaExecutable().toString());
+			RunProcess runProcess = new RunProcess(workingDirectory, new JavaExecutable().toString());
 			runProcess.run(false, args.toArray(new String[args.size()]));
 			return runProcess;
 		}