Change domainsNamespaces to an array of Strings

Author: moreaut

kubernetes/charts/weblogic-operator/templates/_domains-namespaces.tpl

@@ -3,15 +3,17 @@
 
 {{- define "operator.domainsNamespaces" }}
 {{- $scope := . -}}
-{{- $domainsNamespaces := merge (dict) .domainsNamespaces -}}
+{{- $args := merge (dict) $scope -}}
+{{- $domainsNamespaces := .domainsNamespaces -}}
 {{- $len := len $domainsNamespaces -}}
 {{- if eq $len 0 -}}
-{{-   $ignore := set $domainsNamespaces "default" (dict) -}}
+{{-   $ignore := set $args "domainsNamespacesList" (list "default") -}}
+{{- else -}}
+{{-   $ignore := set $args "domainsNamespacesList" $domainsNamespaces -}}
 {{- end -}}
-{{- range $key, $element := $domainsNamespaces -}}
-{{-   $args := merge (dict) $element $scope -}}
+{{- range $key := $args.domainsNamespacesList -}}
 {{-   $ignore := set $args "domainsNamespace" $key -}}
-{{- /*   include "operator.domainConfigMap" $args currently the GA operator runtime does this */ -}}
+{{/*- include "operator.domainConfigMap" $args currently the GA operator runtime does this -*/}}
 {{-   include "operator.operatorRoleBinding" $args -}}
 {{- end }}
 {{- end }}

kubernetes/charts/weblogic-operator/templates/_inputs-utils.tpl

@@ -39,6 +39,37 @@ Verify that an input value of a specific kind has been specified.
 {{- end -}}
 {{- end -}}
 
+{{/*
+Verify that a list input value has been specified
+*/}}
+{{- define "operator.verifyListInput" -}}
+{{- $requiredKind := index . 0 -}}
+{{- $scope := index . 1 -}}
+{{- $parent := index . 2 -}}
+{{- $name := index . 3 -}}
+{{- $args := . -}}
+{{- if include "operator.verifyInputKind" (list "slice" $scope $parent $name) -}}
+{{-   $status := dict -}}
+{{-   if hasKey $parent $name -}}
+{{-     $list := index $parent $name -}}
+{{-     range $value := $list -}}
+{{-       $actualKind := kindOf $value -}}
+{{-       if not (eq $requiredKind $actualKind) -}}
+{{-         $errorMsg := cat "The list property" $name "has a" $actualKind "element.  It must only contain" $requiredKind "elements." -}}
+{{-         include "operator.recordValidationError" (list $scope $errorMsg) -}}
+{{-         $ignore := set $status "error" true -}}
+{{-       end -}}
+{{-     end -}}
+{{-   end -}}
+{{-   if not (hasKey $status "error") -}}
+        true
+{{-   end -}}
+{{- else -}}
+{{-   $errorMsg := cat "The" $requiredKind "property" $name "must be specified." -}}
+{{-   include "operator.recordValidationError" (list $scope $errorMsg) -}}
+{{- end -}}
+{{- end -}}
+
 {{/*
 Verify that a string input value has been specified
 */}}
@@ -62,9 +93,9 @@ Verify that an integer input value has been specified
 {{- end -}}
 
 {{/*
-Verify that an object input value has been specified
+Verify that a dictionary input value has been specified
 */}}
-{{- define "operator.verifyObjectInput" -}}
+{{- define "operator.verifyDictInput" -}}
 {{- include "operator.verifyInputKind" (prepend . "map") -}} 
 {{- end -}}
 
@@ -87,6 +118,20 @@ Verify that an enum string input value has been specified
 {{- end -}}
 {{- end -}}
 
+{{/*
+Verify that a list of strings input value has been specified
+*/}}
+{{- define "operator.verifyStringListInput" -}}
+{{- include "operator.verifyListInput" (prepend . "string") -}} 
+{{- end -}}
+
+{{/*
+Verify that a list of dictionaries input value has been specified
+*/}}
+{{- define "operator.verifyDictListInput" -}}
+{{- include "operator.verifyListInput" (prepend . "map") -}} 
+{{- end -}}
+
 {{/*
 Report the validation errors that have been found then kill the helm chart install
 */}}

kubernetes/charts/weblogic-operator/templates/_operator-cm.tpl

@@ -10,12 +10,16 @@ data:
   externalOperatorCert: {{ .externalOperatorCert | quote }}
   {{- end }}
   serviceaccount: {{ .operatorServiceAccount | quote }}
-{{- $domainsNamespaces := merge (dict) .domainsNamespaces -}}
+{{- $scope := . -}}
+{{- $args := merge (dict) $scope -}}
+{{- $domainsNamespaces := .domainsNamespaces -}}
 {{- $len := len $domainsNamespaces -}}
 {{- if eq $len 0 -}}
-{{-   $ignore := set $domainsNamespaces "default" (dict) -}}
+{{-   $ignore := set $args "domainsNamespacesList" (list "default") -}}
+{{- else -}}
+{{-   $ignore := set $args "domainsNamespacesList" $domainsNamespaces -}}
 {{- end }}
-  targetNamespaces: {{ keys $domainsNamespaces | sortAlpha | join "," }}
+  targetNamespaces: {{ $domainsNamespaces | uniq | sortAlpha | join "," | quote }}
 kind: "ConfigMap"
 metadata:
   labels:

kubernetes/charts/weblogic-operator/templates/_validate-inputs.tpl

@@ -49,13 +49,9 @@
 {{-         $ignore := include "operator.verifyIntegerInput" (list $scope $scope "externalDebugHttpPort") -}}
 {{-       end -}}
 {{-     end -}}
-{{-     if include "operator.verifyObjectInput" (list $scope $scope "domainsNamespaces") -}}
-{{-       $domainsNamespaces := $scope.domainsNamespaces -}}
-{{-       range $key, $element := $domainsNamespaces -}}
-{{-         $ignore := include "operator.verifyObjectInput" (list $scope $domainsNamespaces $key) -}}
-{{-       end -}}
-{{-     end -}}
+{{-     $ignore := include "operator.verifyStringListInput" (list $scope $scope "domainsNamespaces") -}}
 {{-   end -}}
 {{- end -}}
+{{- $ignore := include "operator.verifyDictListInput" (list $scope $scope "extraResources") -}}
 {{- include "operator.reportValidationErrors" $scope -}}
 {{- end -}}

kubernetes/charts/weblogic-operator/values.yaml

@@ -19,16 +19,16 @@ operatorNamespace: "weblogic-operator"
 # The name must be lowercase
 operatorServiceAccount: "weblogic-operator"
 
-# domainsNamespaces specifies a dictionary of WebLogic Domain namespaces which the operator manages (same as targetNamespaces but in dictionary format)
-# The names must be lowercase.  The values must be empty dictionaries.
+# domainsNamespaces specifies list of WebLogic Domain namespaces which the operator manages
+# The names must be lowercase.
 # The customer is responsible for creating these namespaces.
 #
 # Example : In the configuration below, the helm installation will manage namespace1 and namespace2.
 #
 # createDomainsNamespace: true
 # domainsNamespaces:
-#   namespace1: {}
-#   namespace2: {}
+#   - namespace1
+#   - namespace2
 domainsNamespaces: {}
 
 # operatorImage specifies the docker image containing the operator code.
@@ -59,7 +59,7 @@ operatorImagePullPolicy: "IfNotPresent"
 externalRestOption: NONE
 
 # externalRestHttpsPort specifies the node port that should be allocated for the external operator REST https interface.
-# This parameter is required if 'externalRestEnabled' is 'true'.
+# This parameter is required if 'externalRestOption' is not 'NONE'.
 # Otherwise, it is ignored.
 externalRestHttpsPort: 31001
 
@@ -105,7 +105,7 @@ internalRestOption: SELF_SIGNED_CERT
 #   DNS:internal-weblogic-operator-service.OPERATOR_NAMESPACE
 #   DNS:internal-weblogic-operator-service.OPERATOR_NAMESPACE.svc
 #   DNS:internal-weblogic-operator-service.OPERATOR_NAMESPACE.svc.cluster.local"
-# where OPERTOR_NAMESPACE is the name of the operator's namespace.
+# where OPERATOR_NAMESPACE is the name of the operator's namespace.
 #internalOperatorCert:
 
 # The customer supplied private key to use for the internal operator REST
@@ -157,4 +157,4 @@ elkIntegrationEnabled: false
 #   metadata: ...
 #   spec: ...
 #
-extraResources: {}
+extraResources: []

kubernetes/src/test/java/oracle/kubernetes/operator/helm/HelmOperatorValues.java

@@ -10,8 +10,10 @@
 import static oracle.kubernetes.operator.helm.MapUtils.loadFromMap;
 import static oracle.kubernetes.operator.helm.MapUtils.loadIntegerFromMap;
 
+import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
 import oracle.kubernetes.operator.utils.OperatorValues;
 import org.apache.commons.codec.binary.Base64;
@@ -51,9 +53,9 @@ private void setElkIntegrationEnabled(Boolean enabled) {
 
   @SuppressWarnings("unchecked")
   private void loadDomainsNamespacesFromMap(Map<String, Object> map) {
-    Map<String, ?> domainsNamespaces = (Map<String, ?>) map.get("domainsNamespaces");
+    List<String> domainsNamespaces = (List<String>) map.get("domainsNamespaces");
     if (domainsNamespaces != null) {
-      String[] namespaces = domainsNamespaces.keySet().toArray(new String[0]);
+      String[] namespaces = domainsNamespaces.toArray(new String[0]);
       Arrays.sort(namespaces);
       setTargetNamespaces(String.join(",", namespaces));
     }
@@ -90,11 +92,11 @@ Map<String, Object> createMap() {
   private void addDomainsNamespaces(HashMap<String, Object> map) {
     String targetNamespaces = getTargetNamespaces();
     if (targetNamespaces.length() > 0) {
-      Map<String, Map> namespaceEntries = new HashMap<>();
+      List<String> namespaces = new ArrayList<>();
       for (String namespace : targetNamespaces.split(",")) {
-        namespaceEntries.put(namespace, new HashMap());
+        namespaces.add(namespace);
       }
-      map.put("domainsNamespaces", namespaceEntries);
+      map.put("domainsNamespaces", namespaces);
     }
   }
 

kubernetes/src/test/java/oracle/kubernetes/operator/helm/HelmOperatorValuesTest.java

@@ -8,12 +8,15 @@
 import static org.hamcrest.Matchers.both;
 import static org.hamcrest.Matchers.equalTo;
 import static org.hamcrest.Matchers.hasEntry;
+import static org.hamcrest.Matchers.hasItem;
+import static org.hamcrest.Matchers.hasItems;
 import static org.hamcrest.Matchers.hasKey;
 import static org.hamcrest.Matchers.not;
 import static org.junit.Assert.assertThat;
 
+import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
-import java.util.Map;
+import java.util.List;
 import org.junit.Test;
 
 public class HelmOperatorValuesTest {
@@ -374,19 +377,19 @@ public void whenTargetNamespacesNotDefined_createdMapLacksValue() {
   public void whenSingleTargetNamespaceDefined_createdMapContainsValue() {
     operatorValues.targetNamespaces(stringValue);
 
-    assertThat(getDomainsNamespaces(), hasKey(stringValue));
+    assertThat(getDomainsNamespaces(), hasItem(stringValue));
   }
 
   @SuppressWarnings("unchecked")
-  private Map<String, Map> getDomainsNamespaces() {
-    return (Map<String, Map>) operatorValues.createMap().get("domainsNamespaces");
+  private List<String> getDomainsNamespaces() {
+    return (List<String>) operatorValues.createMap().get("domainsNamespaces");
   }
 
   @Test
   public void whenMultipleTargetNamespaceDefined_createdMapContainsValue() {
     operatorValues.targetNamespaces("aaa,bbb");
 
-    assertThat(getDomainsNamespaces(), both(hasKey("aaa")).and(hasKey("bbb")));
+    assertThat(getDomainsNamespaces(), hasItems("aaa", "bbb"));
   }
 
   @Test
@@ -400,7 +403,7 @@ public void whenCreatedFromMapWithoutDomainsNamespaces_hasEmptyString() {
   public void whenCreatedFromMapWithSingleNamespace_hasSpecifiedValue() {
     HelmOperatorValues values =
         new HelmOperatorValues(
-            ImmutableMap.of("domainsNamespaces", ImmutableMap.of("namespace1", ImmutableMap.of())));
+            ImmutableMap.of("domainsNamespaces", ImmutableList.of("namespace1")));
 
     assertThat(values.getTargetNamespaces(), equalTo("namespace1"));
   }
@@ -409,9 +412,7 @@ public void whenCreatedFromMapWithSingleNamespace_hasSpecifiedValue() {
   public void whenCreatedFromMapWithMultipleNamespaces_hasSpecifiedValue() {
     HelmOperatorValues values =
         new HelmOperatorValues(
-            ImmutableMap.of(
-                "domainsNamespaces",
-                ImmutableMap.of("namespace1", ImmutableMap.of(), "namespace2", ImmutableMap.of())));
+            ImmutableMap.of("domainsNamespaces", ImmutableList.of("namespace1", "namespace2")));
 
     assertThat(values.getTargetNamespaces(), equalTo("namespace1,namespace2"));
   }