Adding support for multiple exposed container ports

Framework/KubernetesWorkflow/ContainerRecipeFactory.cs

@@ -132,11 +132,6 @@ namespace KubernetesWorkflow
 
         private Port AddExposedPort(Port port)
         {
-            if (exposedPorts.Any())
-            {
-                throw new NotImplementedException("Current implementation only support 1 exposed port per container recipe. " +
-                    $"Methods for determining container addresses in {nameof(StartupWorkflow)} currently rely on this constraint.");
-            }
             exposedPorts.Add(port);
             return port;
         }

Framework/KubernetesWorkflow/RunnerLocationUtils.cs

@@ -16,18 +16,26 @@ namespace KubernetesWorkflow
         internal static RunnerLocation DetermineRunnerLocation(RunningContainer container)
         {
             if (knownLocation != null) return knownLocation.Value;
+            knownLocation = PingForLocation(container);
+            return knownLocation.Value;
+        }
 
+        private static RunnerLocation PingForLocation(RunningContainer container)
+        {
             if (PingHost(container.Pod.PodInfo.Ip))
             {
-                knownLocation = RunnerLocation.InternalToCluster;
+                return RunnerLocation.InternalToCluster;
-            }
-            else if (PingHost(Format(container.ClusterExternalAddress)))
-            {
-                knownLocation = RunnerLocation.ExternalToCluster;
             }
 
-            if (knownLocation == null) throw new Exception("Unable to determine location relative to kubernetes cluster.");
+            foreach (var port in container.ContainerPorts)
-            return knownLocation.Value;
+            {
+                if (PingHost(Format(port.ExternalAddress)))
+                {
+                    return RunnerLocation.ExternalToCluster;
+                }
+            }
+
+            throw new Exception("Unable to determine location relative to kubernetes cluster.");
         }
 
         private static string Format(Address host)

Framework/KubernetesWorkflow/RunningContainers.cs

@@ -24,37 +24,50 @@ namespace KubernetesWorkflow
 
     public class RunningContainer
     {
-        public RunningContainer(RunningPod pod, ContainerRecipe recipe, Port[] servicePorts, string name, Address clusterExternalAddress, Address clusterInternalAddress)
+        public RunningContainer(RunningPod pod, ContainerRecipe recipe, Port[] servicePorts, string name, ContainerPort[] containerPorts)
         {
             Pod = pod;
             Recipe = recipe;
             ServicePorts = servicePorts;
             Name = name;
-            ClusterExternalAddress = clusterExternalAddress;
+            ContainerPorts = containerPorts;
-            ClusterInternalAddress = clusterInternalAddress;
         }
 
         public string Name { get; }
         public RunningPod Pod { get; }
         public ContainerRecipe Recipe { get; }
         public Port[] ServicePorts { get; }
-        public Address ClusterExternalAddress { get; }
+        public ContainerPort[] ContainerPorts { get; }
-        public Address ClusterInternalAddress { get; }
 
         [JsonIgnore]
         public Address Address
         {
             get
             {
-                if (RunnerLocationUtils.DetermineRunnerLocation(this) == RunnerLocation.InternalToCluster)
+                throw new Exception("a");
-                {
+                //if (RunnerLocationUtils.DetermineRunnerLocation(this) == RunnerLocation.InternalToCluster)
-                    return ClusterInternalAddress;
+                //{
-                }
+                //    return ClusterInternalAddress;
-                return ClusterExternalAddress;
+                //}
+                //return ClusterExternalAddress;
             }
         }
     }
 
+    public class ContainerPort
+    {
+        public ContainerPort(Port port, Address externalAddress, Address internalAddress)
+        {
+            Port = port;
+            ExternalAddress = externalAddress;
+            InternalAddress = internalAddress;
+        }
+
+        public Port Port { get; }
+        public Address ExternalAddress { get; }
+        public Address InternalAddress { get; }
+    }
+
     public static class RunningContainersExtensions
     {
         public static RunningContainer[] Containers(this RunningContainers[] runningContainers)

Framework/KubernetesWorkflow/StartupWorkflow.cs

@@ -118,8 +118,7 @@ namespace KubernetesWorkflow
                 var name = GetContainerName(r, startupConfig);
 
                 return new RunningContainer(runningPod, r, servicePorts, name,
-                    GetContainerExternalAddress(runningPod, servicePorts),
+                    CreateContainerPorts(runningPod, r, servicePorts));
-                    GetContainerInternalAddress(r));
 
             }).ToArray();
         }
@@ -137,35 +136,39 @@ namespace KubernetesWorkflow
             }
         }
 
-        private Address GetContainerExternalAddress(RunningPod pod, Port[] servicePorts)
+        private ContainerPort[] CreateContainerPorts(RunningPod pod, ContainerRecipe recipe, Port[] servicePorts)
         {
-            return new Address(
+            var result = new List<ContainerPort>();
-                pod.Cluster.HostAddress,
+            foreach (var exposedPort in recipe.ExposedPorts)
-                GetServicePort(servicePorts));
+            {
+                result.Add(new ContainerPort(
+                    exposedPort,
+                    GetContainerExternalAddress(pod, servicePorts, exposedPort),
+                    GetContainerInternalAddress(exposedPort)));
+            }
+
+            return result.ToArray();
         }
 
-        private Address GetContainerInternalAddress(ContainerRecipe recipe)
+        private static Address GetContainerExternalAddress(RunningPod pod, Port[] servicePorts, Port exposedPort)
+        {
+            var servicePort = servicePorts.Single(p => p.Tag == exposedPort.Tag);
+
+            return new Address(
+                pod.Cluster.HostAddress,
+                servicePort.Number);
+        }
+
+        private Address GetContainerInternalAddress(Port exposedPort)
         {
             var serviceName = "service-" + numberSource.WorkflowNumber;
-            var port = GetInternalPort(recipe);
+            var port = exposedPort.Number;
 
             return new Address(
                 $"http://{serviceName}.{k8sNamespace}.svc.cluster.local",
                 port);
         }
-
+        
-        private static int GetServicePort(Port[] servicePorts)
-        {
-            if (servicePorts.Any()) return servicePorts.First().Number;
-            return 0;
-        }
-
-        private static int GetInternalPort(ContainerRecipe recipe)
-        {
-            if (recipe.ExposedPorts.Any()) return recipe.ExposedPorts.First().Number;
-            return 0;
-        }
-
         private ContainerRecipe[] CreateRecipes(int numberOfContainers, ContainerRecipeFactory recipeFactory, StartupConfig startupConfig)
         {
             log.Debug();

ProjectPlugins/CodexPlugin/CodexContainerRecipe.cs

@@ -34,13 +34,13 @@ namespace CodexPlugin
             AddEnvVar("CODEX_DATA_DIR", dataDir);
             AddVolume($"codex/{dataDir}", GetVolumeCapacity(config));
 
-            AddInternalPortAndVar("CODEX_DISC_PORT", DiscoveryPortTag);
+            AddExposedPortAndVar("CODEX_DISC_PORT", DiscoveryPortTag);
             AddEnvVar("CODEX_LOG_LEVEL", config.LogLevelWithTopics());
 
             // This makes the node announce itself to its local (pod) IP address.
             AddEnvVar("NAT_IP_AUTO", "true");
 
-            var listenPort = AddInternalPort();
+            var listenPort = AddExposedPort();
             AddEnvVar("CODEX_LISTEN_ADDRS", $"/ip4/0.0.0.0/tcp/{listenPort.Number}");
 
             if (!string.IsNullOrEmpty(config.BootstrapSpr))