Merge pull request #561 from oracle/OWLS-69878_introspector_channel

OWLS-69878: Have the introspector return info about all of the enabled channels of all the servers

Author: rjeberhard

operator/src/main/java/oracle/kubernetes/operator/helpers/ConfigMapHelper.java

@@ -15,6 +15,7 @@
 import java.io.IOException;
 import java.io.StringReader;
 import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
 import oracle.kubernetes.operator.KubernetesConstants;
 import oracle.kubernetes.operator.LabelConstants;
@@ -569,6 +570,7 @@ public static DomainTopology parseDomainTopologyYaml(String topologyYaml) {
   public static class DomainTopology {
     private boolean domainValid;
     private WlsDomainConfig domain;
+    private List<String> validationErrors;
 
     public boolean getDomainValid() {
       return this.domainValid;
@@ -586,5 +588,13 @@ public WlsDomainConfig getDomain() {
     public void setDomain(WlsDomainConfig domain) {
       this.domain = domain;
     }
+
+    public List<String> getValidationErrors() {
+      return validationErrors;
+    }
+
+    public void setValidationErrors(List<String> validationErrors) {
+      this.validationErrors = validationErrors;
+    }
   }
 }

operator/src/main/java/oracle/kubernetes/operator/utils/WlsDomainConfigSupport.java

@@ -126,7 +126,7 @@ static class ServerConfigBuilder {
     }
 
     WlsServerConfig build() {
-      return new WlsServerConfig(name, listenPort, null, null, false, null, null);
+      return new WlsServerConfig(name, listenPort, null, null, false, null, null, null, false);
     }
   }
 

operator/src/main/java/oracle/kubernetes/operator/wlsconfig/WlsDynamicServerConfig.java

@@ -104,7 +104,9 @@ private WlsDynamicServerConfig(
         sslListenPort,
         sslPortEnabled,
         machineName,
-        networkAccessPoints);
+        networkAccessPoints,
+        null,
+        false);
   }
 
   /**

operator/src/main/java/oracle/kubernetes/operator/wlsconfig/WlsServerConfig.java

@@ -20,6 +20,8 @@ public class WlsServerConfig {
   Integer sslListenPort;
   boolean sslPortEnabled;
   String machineName;
+  Integer adminPort;
+  boolean adminPortEnabled;
   List<NetworkAccessPoint> networkAccessPoints;
 
   public WlsServerConfig() {}
@@ -66,7 +68,7 @@ public Integer getSslListenPort() {
    * @return True if the SSL listen port should be enabled, false otherwise
    */
   public boolean isSslPortEnabled() {
-    return sslPortEnabled;
+    return sslListenPort != null;
   }
 
   /**
@@ -97,6 +99,18 @@ public void setClusterName(String clusterName) {
     this.clusterName = clusterName;
   }
 
+  public Integer getAdminPort() {
+    return adminPort;
+  }
+
+  public void setAdminPort(Integer adminPort) {
+    this.adminPort = adminPort;
+  }
+
+  public boolean isAdminPortEnabled() {
+    return adminPort != null;
+  }
+
   /**
    * Creates a WLSServerConfig object using an "servers" or "serverTemplates" item parsed from JSON
    * result from WLS REST call
@@ -125,7 +139,11 @@ static WlsServerConfig create(Map<String, Object> serverConfigMap) {
     // parse the SSL configuration
     Map<String, Object> sslMap = (Map<String, Object>) serverConfigMap.get("SSL");
     Integer sslListenPort = (sslMap == null) ? null : (Integer) sslMap.get("listenPort");
-    boolean sslPortEnabled = (sslMap == null) ? false : (boolean) sslMap.get("enabled");
+    boolean sslPortEnabled = (sslMap != null && sslMap.get("listenPort") != null) ? true : false;
+
+    // parse the administration port
+    Integer adminPort = (Integer) serverConfigMap.get("adminPort");
+    boolean adminPortEnabled = (adminPort != null);
 
     return new WlsServerConfig(
         (String) serverConfigMap.get("name"),
@@ -134,7 +152,9 @@ static WlsServerConfig create(Map<String, Object> serverConfigMap) {
         sslListenPort,
         sslPortEnabled,
         getMachineNameFromJsonMap(serverConfigMap),
-        networkAccessPoints);
+        networkAccessPoints,
+        adminPort,
+        adminPortEnabled);
   }
 
   /**
@@ -147,7 +167,8 @@ static WlsServerConfig create(Map<String, Object> serverConfigMap) {
    * @param sslPortEnabled boolean indicating whether the SSL listen port should be enabled
    * @param machineName Configured machine name for this WLS server
    * @param networkAccessPoints List of NetworkAccessPoint containing channels configured for this
-   *     WLS server
+   * @param adminPort Configured domain wide administration port
+   * @param adminPortEnabled boolean indicating whether administration port should be enabled
    */
   public WlsServerConfig(
       String name,
@@ -156,13 +177,17 @@ public WlsServerConfig(
       Integer sslListenPort,
       boolean sslPortEnabled,
       String machineName,
-      List<NetworkAccessPoint> networkAccessPoints) {
+      List<NetworkAccessPoint> networkAccessPoints,
+      Integer adminPort,
+      boolean adminPortEnabled) {
     this.name = name;
     this.listenPort = listenPort;
     this.listenAddress = listenAddress;
     this.networkAccessPoints = networkAccessPoints;
     this.sslListenPort = sslListenPort;
     this.sslPortEnabled = sslPortEnabled;
+    this.adminPort = adminPort;
+    this.adminPortEnabled = adminPortEnabled;
     this.machineName = machineName;
   }
 
@@ -284,6 +309,8 @@ public boolean equals(Object o) {
         .append(listenPort, that.listenPort)
         .append(listenAddress, that.listenAddress)
         .append(sslListenPort, that.sslListenPort)
+        .append(adminPort, that.adminPort)
+        .append(adminPortEnabled, that.adminPortEnabled)
         .append(machineName, that.machineName)
         .append(networkAccessPoints, that.networkAccessPoints)
         .isEquals();
@@ -297,6 +324,8 @@ public int hashCode() {
         .append(listenAddress)
         .append(sslListenPort)
         .append(sslPortEnabled)
+        .append(adminPort)
+        .append(adminPortEnabled)
         .append(machineName)
         .append(networkAccessPoints)
         .toHashCode();
@@ -310,6 +339,8 @@ public String toString() {
         .append("listenAddress", listenAddress)
         .append("sslListenPort", sslListenPort)
         .append("sslPortEnabled", sslPortEnabled)
+        .append("adminPort", adminPort)
+        .append("adminPortEnabled", adminPortEnabled)
         .append("machineName", machineName)
         .append("networkAccessPoints", networkAccessPoints)
         .toString();

operator/src/main/resources/scripts/introspectDomain.py

@@ -280,6 +280,7 @@ def __init__(self, env):
   def validate(self):
     self.validateAdminServer()
     self.validateClusters()
+    self.validateServerCustomChannelName()
     return self.isValid()
 
   def generate(self):
@@ -340,6 +341,7 @@ def validateNonDynamicCluster(self, cluster):
     self.validateNonDynamicClusterReferencedByAtLeastOneServer(cluster)
     self.validateNonDynamicClusterNotReferencedByAnyServerTemplates(cluster)
     self.validateNonDynamicClusterServersHaveSameListenPort(cluster)
+    self.validateNonDynamicClusterServerHaveSameCustomChannels(cluster)
 
   def validateNonDynamicClusterReferencedByAtLeastOneServer(self, cluster):
     for server in self.env.getDomain().getServers():
@@ -352,20 +354,112 @@ def validateNonDynamicClusterNotReferencedByAnyServerTemplates(self, cluster):
       if template.getCluster() is cluster:
         self.addError("The non-dynamic cluster " + self.name(cluster) + " is referenced by the server template " + self.name(template) + ".")
 
+  LISTEN_PORT = 'listen port'
+  LISTEN_PORT_ENABLED = 'listen port enabled'
+  SSL_LISTEN_PORT = 'ssl listen port'
+  SSL_LISTEN_PORT_ENABLED = 'ssl listen port enabled'
+  ADMIN_LISTEN_PORT = 'admin listen port'
+  ADMIN_LISTEN_PORT_ENABLED = 'admin listen port enabled'
+
+  def getServerClusterPortPropertyValue(server, clusterListenPortProperty):
+    sslListenPort = None
+    if server.getSSL() != None:
+      sslListenPort = server.getSSL().getListenPort()
+    sslListenPortEnabled = None
+    if server.getSSL()!= None:
+      sslListenPortEnabled = server.getSSL().isListenPortEnabled()
+    return {
+             LISTEN_PORT: server.getListenPort(),
+             LISTEN_PORT_ENABLED: server.isListenPortEnabled(),
+             SSL_LISTEN_PORT: sslListenPort,
+             SSL_LISTEN_PORT_ENABLED: sslListenPortEnabled,
+             ADMIN_LISTEN_PORT: server.getAdministrationPort(),
+             ADMIN_LISTEN_PORT_ENABLED: server.isAdministrationPortEnabled()
+     }[clusterListenPortProperty]
+
   def validateNonDynamicClusterServersHaveSameListenPort(self, cluster):
     firstServer = None
-    firstPort = None
+    firstListenPort = None
+    firstListenPortEnabled = None
+    firstSslListenPort = None
+    firstSslListenPortEnabled = None
+    firstAdminPort = None
+    firstAdminPortEnabled = None
+    for server in self.env.getDomain().getServers():
+      if cluster is server.getCluster():
+        listenPort = server.getListenPort()
+        listenPortEnabled = server.isListenPortEnabled()
+        ssl = server.getSSL()
+        sslListenPort = None
+        sslListenPortEnabled = None
+        if ssl is not None:
+              sslListenPort = ssl.getListenPort()
+              sslListenPortEnabled = ssl.isEnabled()
+        adminPort = server.getAdministrationPort()
+        adminPortEnabled = server.isAdministrationPortEnabled()
+        if firstServer is None:
+          firstServer = server
+          firstListenPort = listenPort
+          firstListenPortEnabled = listenPortEnabled
+          firstSslListenPort = sslListenPort
+          firstSslListenPortEnabled = sslListenPortEnabled
+          firstAdminPort = adminPort
+          firstAdminPortEnabled = adminPortEnabled
+        else:
+          if listenPort != firstListenPort:
+            self.addError("The non-dynamic cluster " + self.name(cluster) + "'s server " + self.name(firstServer) + "'s listen port is " + str(firstListenPort) + " but its server " + self.name(server) + "'s listen port is " + str(listenPort) + ". All ports for the same channel in a cluster must be the same.")
+          if listenPortEnabled != firstListenPortEnabled:
+            self.addError("The non-dynamic cluster " + self.name(cluster) + "'s server " + self.name(firstServer) + " has listen port enabled: " + self.booleanToString(firstListenPortEnabled) + " but its server " + self.name(server) + "'s listen port enabled: " + self.booleanToString(listenPortEnabled) + ".  Channels in a cluster must be either all enabled or disabled.")
+          if sslListenPort != firstSslListenPort:
+             self.addError("The non-dynamic cluster " + self.name(cluster) + "'s server " + self.name(firstServer) + "'s ssl listen port is " + str(firstSslListenPort) + " but its server " + self.name(server) + "'s ssl listen port is " + str(sslListenPort) + ".  All ports for the same channel in a cluster must be the same.")
+          if sslListenPortEnabled != firstSslListenPortEnabled:
+            self.addError("The non-dynamic cluster " + self.name(cluster) + "'s server " + self.name(firstServer) + " has ssl listen port enabled: " + self.booleanToString(firstSslListenPortEnabled) + " but its server " + self.name(server) + "'s ssl listen port enabled: " + self.booleanToString(sslListenPortEnabled) + ".  Channels in a cluster must be either all enabled or disabled.")
+          if adminPort != firstAdminPort:
+            self.addError("The non-dynamic cluster " + self.name(cluster) + "'s server " + self.name(firstServer) + "'s ssl listen port is " + str(firstAdminPort) + " but its server " + self.name(server) + "'s ssl listen port is " + str(adminPort) + ".  All ports for the same channel in a cluster must be the same.")
+          if adminPortEnabled != firstAdminPortEnabled:
+            self.addError("The non-dynamic cluster " + self.name(cluster) + "'s server " + self.name(firstServer) + " has ssl listen port enabled: " + self.booleanToString(firstAdminPortEnabled) + " but its server " + self.name(server) + "'s ssl listen port enabled: " + self.booleanToString(adminPortEnabled) + ".  Channels in a cluster must be either all enabled or disabled.")
+
+
+
+  def validateClusterServersListenPortProperty(self, cluster, errorMsg, clusterListenPortProperty):
+    firstServer = None
+    firstListenPortProperty = None
     for server in self.env.getDomain().getServers():
       if cluster is server.getCluster():
-        port = server.getListenPort()
+        listenPortProperty = getServerClusterPortPropertyValue(server, clusterListenPortProperty)
         if firstServer is None:
           firstServer = server
-          firstPort = port
+          firstListenPortProperty = listenPortProperty
         else:
-          if port != firstPort:
-            self.addError("The non-dynamic cluster " + self.name(cluster) + "'s server " + self.name(firstServer) + "'s listen port is " + str(firstPort) + " but its server " + self.name(server) + "'s listen port is " + str(port) + ".  All ports for the same channel in a cluster must be the same, including the default channel and the default SSL channel.")
+          if listenPortProperty != firstListenPortProperty:
+            self.addError(errorMsg.substitute(cluster=self.name(cluster), server1=self.name(firstServer), property=clusterListenPortProperty, value1=str(firstListenPortProperty), server2=self.name(server), value2=str(firstListenPortProperty)))
             return
 
+  def validateNonDynamicClusterServerHaveSameCustomChannels(self, cluster):
+     firstServer = None
+     serverNap = {}
+     for server in self.env.getDomain().getServers():
+       if cluster is server.getCluster():
+         if firstServer is None:
+           for nap in server.getNetworkAccessPoints():
+             serverNap[nap.getName()] = nap.getProtocol() + "~" + str(nap.getListenPort());
+           firstServer = server
+         else:
+           naps = server.getNetworkAccessPoints()
+           if len(naps) != len(serverNap):
+             self.addError("The non-dynamic cluster " + self.name(cluster) + " has mismatched number of network access points in servers " + self.name(firstServer) + " and " + self.name(server) + ". All network access points in a cluster must be the same.")
+             return
+           else:
+             for nap in naps:
+               if nap.getName() in serverNap:
+                 if serverNap[nap.getName()] != nap.getProtocol() + "~" + str(nap.getListenPort()):
+                   self.addError("The non-dynamic cluster " + self.name(cluster) + " has mismatched network access point " + self.name(nap) + " in servers " + self.name(firstServer) + " and " + self.name(server) + ". All network access points in a cluster must be the same.")
+                   return
+               else:
+                 self.addError("The non-dynamic cluster " + self.name(cluster) + " has mismatched network access point " + self.name(nap) + " in servers " + self.name(firstServer) + " and " + self.name(server) + ". All network access points in a cluster must be the same.")
+                 return
+
+
   def validateDynamicCluster(self, cluster):
     self.validateDynamicClusterReferencedByOneServerTemplate(cluster)
     self.validateDynamicClusterDynamicServersDoNotUseCalculatedListenPorts(cluster)
@@ -393,6 +487,14 @@ def validateDynamicClusterDynamicServersDoNotUseCalculatedListenPorts(self, clus
     if cluster.getDynamicServers().isCalculatedListenPorts() == True:
       self.addError("The dynamic cluster " + self.name(cluster) + "'s dynamic servers use calculated listen ports.")
 
+  def validateServerCustomChannelName(self):
+    reservedNames = ['default','defaultSecure','defaultAdmin']
+    for server in self.env.getDomain().getServers():
+      naps = server.getNetworkAccessPoints()
+      for nap in naps:
+        if nap.getName() in reservedNames:
+          self.addError("The custom channel " + self.name(nap) + " is a reserved name.")
+
   def isValid(self):
     return len(self.env.getErrors()) == 0
 
@@ -475,10 +577,21 @@ def getClusteredServers(self, cluster):
   def addClusteredServer(self, cluster, server):
     name=self.name(server)
     self.writeln("- name: " + name)
-    self.writeln("  listenPort: " + str(server.getListenPort()))
+    if server.isListenPortEnabled():
+      self.writeln("  listenPort: " + str(server.getListenPort()))
     self.writeln("  listenAddress: " + self.quote(self.env.toDNS1123Legal(self.env.getDomainUID() + "-" + server.getName())))
+    if server.isAdministrationPortEnabled():
+      self.writeln("  adminPort: " + str(server.getAdministrationPort()))
+    self.addSSL(server)
     self.addNetworkAccessPoints(server)
 
+  def addSSL(self, server):
+    ssl = server.getSSL()
+    if ssl is not None and ssl.isEnabled():
+      self.indent()
+      self.writeln("sslListenPort: " + str(ssl.getListenPort()))
+      self.undent()
+
   def addServerTemplates(self):
     serverTemplates = self.env.getDomain().getServerTemplates()
     if len(serverTemplates) == 0:
@@ -492,7 +605,8 @@ def addServerTemplates(self):
   def addServerTemplate(self, serverTemplate):
     name=self.name(serverTemplate)
     self.writeln("- name: " + name)
-    self.writeln("  listenPort: " + str(serverTemplate.getListenPort()))
+    if serverTemplate.isListenPortEnabled():
+      self.writeln("  listenPort: " + str(serverTemplate.getListenPort()))
     self.writeln("  clusterName: " + self.quote(serverTemplate.getCluster().getName()))
     listenAddress=serverTemplate.getListenAddress()
     if listenAddress is not None:
@@ -546,8 +660,12 @@ def addNonClusteredServers(self):
   def addNonClusteredServer(self, server):
     name=self.name(server)
     self.writeln("- name: " + name)
-    self.writeln("  listenPort: " + str(server.getListenPort()))
+    if server.isListenPortEnabled():
+      self.writeln("  listenPort: " + str(server.getListenPort()))
     self.writeln("  listenAddress: " + self.quote(self.env.toDNS1123Legal(self.env.getDomainUID() + "-" + server.getName())))
+    if server.isAdministrationPortEnabled():
+      self.writeln("  adminPort: " + str(server.getAdministrationPort()))
+    self.addSSL(server)
     self.addNetworkAccessPoints(server)
 
   def addNetworkAccessPoints(self, server):
@@ -567,6 +685,10 @@ def addNetworkAccessPoint(self, nap):
     self.writeln("    listenPort: " + str(nap.getListenPort()))
     self.writeln("    publicPort: " + str(nap.getPublicPort()))
 
+  def booleanToString(self, bool):
+    if bool == 0:
+      return "false"
+    return "true"
 
 class BootPropertiesGenerator(Generator):