- refactored 'queryContainerPortMapping' into 'getPortBindings'

- update dynamic ports in the run service
- cleaned up compiler warnings
- allow 'HostIp' to be bound as maven property and exported
- introduced 'PortMapping.Writer' to handle property file writing

Signed-off-by: Jae Gangemi <jgangemi@gmail.com>

doc/changelog.md

@@ -6,7 +6,9 @@
   - Allow 'build' and/or 'run' configuration to be skipped (#207)
   - Refactored to use 'inspect' instead of 'list' for checking the existence of an image (#230)
   - Refactored ApacheHttpClientDelegate to avoid leaking connections (#232)
-
+  - Introduced global `portPropertyFile` setting (#90)
+  - Allow the container's host ip to be bound to a maven property and exported
+
 * **0.13.2**
   - "run" directives can be added to the Dockerfile (#191)
   - Support user information in wait URL (#211)

doc/manual.md

@@ -136,6 +136,10 @@ parentheses.
   container logs. This configuration can be overwritten by individual
   run configurations and described below. The format is described in
   the [section](#log-configuration) below. 
+* **portPropertyFile** if given, specifies a global file into which the
+  mapped properties should be written to. The format of this file and
+  its purpose are also described [below](#port-mapping). Please note, this field takes precidence
+  over any `portPropertyFile` value specified in an `image` configuration.    
 * **sourceDirectory** (`docker.source.dir`) specifies the default directory that contains
   the assembly descriptor(s) used by the plugin. The default value is `src/main/docker`. This
   option is only relevant for the `docker:build` goal.
@@ -622,17 +626,17 @@ equivalent to the port mapping when using the Docker CLI with option
 <ports>
   <port>18080:8080</port> 
   <port>host.port:80</port> 
+  <port>host.ip@host.port:80</port> 
 <ports>
 ```
 
-A `port` stanza may take one of two forms:
+A `port` stanza may take one of four forms:
 
-* A tuple consisting of two numeric values separated by a `:`. This
-  form will result in an explicit mapping between the docker host and
-  the corresponding port inside the container. In the above example,
-  port 18080 would be exposed on the docker host and mapped to port
-  8080 in the running container. 
-* A tuple consisting of a string and a numeric value separated by a
+* **18080:8080** : A tuple consisting of two numeric values separated by a `:`. This 
+  form will result in an explicit mapping between the docker host and the corresponding 
+  port inside the container. In the above example, port 18080 would be exposed on the 
+  docker host and mapped to port 8080 in the running container. 
+* **host.port:80** A tuple consisting of a string and a numeric value separated by a
   `:`. In this form, the string portion of the tuple will correspond
   to a Maven property. If the property is undefined when the `start`
   task executes, a port will be dynamically selected by Docker in the
@@ -647,6 +651,9 @@ A `port` stanza may take one of two forms:
   expression similar to `<value>${host.port}</value>`. This can be
   used to pin a port from the outside when doing some initial testing
   similar to `mvn -Dhost.port=10080 docker:start`
+* **host.ip+18080:80** Similar to above except the `host.ip` is mapped and it cannot be set 
+   using a system property.
+* **host.ip+host.port:80** Bind `host.ip` and `host.port` to maven properties.
 
 Both forms of the `port` stanza also support binding to a specific ip 
 address on the docker host.
@@ -655,6 +662,7 @@ address on the docker host.
 <ports>
   <port>1.2.3.4:80:80</port>
   <port>1.2.3.4:host.port:80</port>
+  <port>1.2.3.4:host.ip+host.port:80</port>
 </ports>
 ```
 

src/main/java/org/jolokia/docker/maven/AbstractDockerMojo.java

@@ -129,6 +129,11 @@ public abstract class AbstractDockerMojo extends AbstractMojo implements Context
     /** @parameter property = "docker.registry" */
     private String registry;
 
+    /**
+     * @parameter
+     */
+    protected String portPropertyFile;
+
     // Authentication information
     /** @parameter */
     Map authConfig;

src/main/java/org/jolokia/docker/maven/StartMojo.java

@@ -7,22 +7,29 @@
  * CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under
  * the License.
  */
-
-import java.util.*;
+import java.util.ArrayList;
+import java.util.Properties;
 import java.util.concurrent.TimeoutException;
 import java.util.regex.Pattern;
 
 import org.apache.commons.lang3.text.StrSubstitutor;
 import org.apache.maven.plugin.MojoExecutionException;
 import org.codehaus.plexus.util.StringUtils;
-import org.jolokia.docker.maven.access.*;
+import org.jolokia.docker.maven.access.DockerAccess;
+import org.jolokia.docker.maven.access.DockerAccessException;
+import org.jolokia.docker.maven.access.PortMapping;
 import org.jolokia.docker.maven.access.log.LogCallback;
 import org.jolokia.docker.maven.access.log.LogGetHandle;
-import org.jolokia.docker.maven.config.*;
+import org.jolokia.docker.maven.config.ImageConfiguration;
+import org.jolokia.docker.maven.config.LogConfiguration;
+import org.jolokia.docker.maven.config.RunImageConfiguration;
+import org.jolokia.docker.maven.config.WaitConfiguration;
 import org.jolokia.docker.maven.log.LogDispatcher;
 import org.jolokia.docker.maven.service.QueryService;
 import org.jolokia.docker.maven.service.RunService;
-import org.jolokia.docker.maven.util.*;
+import org.jolokia.docker.maven.util.StartOrderResolver;
+import org.jolokia.docker.maven.util.Timestamp;
+import org.jolokia.docker.maven.util.WaitUtil;
 
 
 /**
@@ -51,11 +58,14 @@ public class StartMojo extends AbstractDockerMojo {
     public synchronized void executeInternal(final DockerAccess dockerAccess) throws DockerAccessException, MojoExecutionException {
         getPluginContext().put(CONTEXT_KEY_START_CALLED, true);
 
+        Properties projProperties = project.getProperties();
+
         QueryService queryService = serviceHub.getQueryService();
         RunService runService = serviceHub.getRunService();
-
-        LogDispatcher dispatcher = getLogDispatcher(dockerAccess);
 
+        LogDispatcher dispatcher = getLogDispatcher(dockerAccess);
+        PortMapping.Writer portMappingWriter = new PortMapping.Writer(portPropertyFile);
+
         boolean success = false;
         try {
             for (StartOrderResolver.Resolvable resolvable : runService.getImagesConfigsInOrder(queryService, getImages())) {
@@ -69,47 +79,40 @@ public synchronized void executeInternal(final DockerAccess dockerAccess) throws
                                        getConfiguredRegistry(imageConfig),imageConfig.getBuildConfiguration() == null);
 
                 RunImageConfiguration runConfig = imageConfig.getRunConfiguration();
-                PortMapping portMapping = runService.getPortMapping(runConfig, project.getProperties());
+                PortMapping portMapping = runService.getPortMapping(runConfig, projProperties);
 
-                String containerId = runService.createAndStartContainer(imageConfig, portMapping, project.getProperties());
+                String containerId = runService.createAndStartContainer(imageConfig, portMapping, projProperties);
 
                 if (showLogs(imageConfig)) {
                     dispatcher.trackContainerLog(containerId, getContainerLogSpec(containerId, imageConfig));
                 }
 
-                // Set maven properties for dynamically assigned ports.
-                updateDynamicPortProperties(dockerAccess, containerId, runConfig, portMapping, project.getProperties());
+                portMappingWriter.add(portMapping, runConfig.getPortPropertyFile());
 
                 // Wait if requested
-                waitIfRequested(dockerAccess,imageConfig, project.getProperties(), containerId);
+                waitIfRequested(dockerAccess,imageConfig, projProperties, containerId);
             }
             if (follow) {
                 runService.addShutdownHookForStoppingContainers(keepContainer,removeVolumes);
                 wait();
             }
+
+            portMappingWriter.write();
             success = true;
         } catch (InterruptedException e) {
             log.warn("Interrupted");
             Thread.currentThread().interrupt();
             throw new MojoExecutionException("interrupted", e);
         } finally {
             if (!success) {
+                log.error("Error occurred during container startup, shutting down...");
                 runService.stopStartedContainers(keepContainer, removeVolumes);
             }
         }
     }
-
-    private void updateDynamicPortProperties(DockerAccess docker, String containerId, RunImageConfiguration runConfig, PortMapping mappedPorts, Properties properties) throws DockerAccessException, MojoExecutionException {
-        if (mappedPorts.containsDynamicPorts()) {
-            mappedPorts.updateVariablesWithDynamicPorts(docker.queryContainerPortMapping(containerId));
-            propagatePortVariables(mappedPorts, runConfig.getPortPropertyFile(),properties);
-        }
-    }
-
 
     // ========================================================================================================
 
-
     private void waitIfRequested(DockerAccess docker, ImageConfiguration imageConfig, Properties projectProperties, String containerId) throws MojoExecutionException {
         RunImageConfiguration runConfig = imageConfig.getRunConfiguration();
         WaitConfiguration wait = runConfig.getWaitConfiguration();
@@ -176,26 +179,6 @@ public void cleanUp() {
         };
     }
 
-    // Store dynamically mapped ports
-    private void propagatePortVariables(PortMapping mappedPorts, String portPropertyFile, Properties properties) throws MojoExecutionException {
-        Properties props = new Properties();
-        Map<String, Integer> dynamicPorts = mappedPorts.getPortVariables();
-        for (Map.Entry<String, Integer> entry : dynamicPorts.entrySet()) {
-            String var = entry.getKey();
-            String val = "" + entry.getValue();
-            properties.setProperty(var, val);
-            props.setProperty(var, val);
-        }
-
-        // However, this can be to late since properties in pom.xml are resolved during the "validate" phase
-        // (and we are running later probably in "pre-integration" phase. So, in order to bring the dynamically
-        // assigned ports to the integration tests a properties file is written. Not nice, but works. Blame it
-        // to maven to not allow late evaluation or any other easy way to inter-plugin communication
-        if (portPropertyFile != null) {
-            EnvUtil.writePortProperties(props, portPropertyFile);
-        }
-    }
-
     protected boolean showLogs(ImageConfiguration imageConfig) {
         if (showLogs != null) {
             if (showLogs.equalsIgnoreCase("true")) {
@@ -219,4 +202,5 @@ protected boolean showLogs(ImageConfiguration imageConfig) {
         }
         return false;
     }
+
 }

src/main/java/org/jolokia/docker/maven/access/ContainerHostConfig.java

@@ -77,7 +77,7 @@ public ContainerHostConfig links(List<String> links) {
     }
 
     public ContainerHostConfig portBindings(PortMapping portMapping) {
-        Map<String, Integer> portMap = portMapping.getPortsMap();
+        Map<String, Integer> portMap = portMapping.getContainerPortToHostPortMap();
         if (!portMap.isEmpty()) {
             JSONObject portBindings = new JSONObject();
             Map<String, String> bindToMap = portMapping.getBindToHostMap();

src/main/java/org/jolokia/docker/maven/access/DockerAccess.java

@@ -78,17 +78,6 @@ public interface DockerAccess {
      */
     void stopContainer(String containerId) throws DockerAccessException;
 
-    /**
-     * Query the port mappings for a certain container.
-     *
-     * @param containerId id of the container to query.
-     * @return mapped ports where the keys of this map are the container ports including the protocol (e.g. "8080/tcp")
-     *         and the values are the mapped, potentially dynamically chosen, host ports (e.g. 49000).
-     *         The returned map is never null but can be empty.
-     * @throws DockerAccessException if the query failed.
-     */
-    Map<String, Integer> queryContainerPortMapping(String containerId) throws DockerAccessException;
-
     /**
      * Get logs for a container up to now synchronously.
      *