initial version for lifecycle-java-integ-test

Author: [email protected]

integration-tests/src/test/java/oracle/kubernetes/operator/ITOperator.java

@@ -589,6 +589,63 @@ private Domain testAdvancedUseCasesForADomain(Operator operator, Domain domain)
     return domain;
   }
 
+  /**
+   * Create Operator1 and domainOnPVUsingWLST with admin server and 1 managed server if they are not
+   * running. After verifying the domain is created properly. Change some properties on domain
+   * resources that would cause servers to be restarted and verify that server are indeed restarted.
+   * The properties tested here are: env: "-Dweblogic.StdoutDebugEnabled=false"-->
+   * "-Dweblogic.StdoutDebugEnabled=false"
+   *
+   * @throws Exception
+   */
+  @Test
+  public void testServerRestartByDomainOnPVUsingWLST() throws Exception {
+    Assume.assumeFalse(QUICKTEST);
+    String testMethodName = new Object() {}.getClass().getEnclosingMethod().getName();
+    logTestBegin(testMethodName);
+
+    logger.info("Checking if operator1 and domain are running, if not creating");
+    if (operator1 == null) {
+      operator1 = TestUtils.createOperator(operator1File);
+    }
+
+    Domain domain = null;
+    boolean testCompletedSuccessfully = false;
+    try {
+      // load input yaml to map and add configOverrides
+      Map<String, Object> domainMap = TestUtils.loadYaml(domainonpvwlstFile);
+      domainMap.put("domainUID", "domainlifecycle");
+      domainMap.put("adminNodePort", new Integer("30707"));
+      domainMap.put("t3ChannelPort", new Integer("30081"));
+      domainMap.put("initialManagedServerReplicas", new Integer("1"));
+
+      logger.info("Creating Domain domain& verifing the domain creation");
+      domain = TestUtils.createDomain(domainMap);
+      domain.verifyDomainCreated();
+      // TODO add some comments
+      domain.testDomainServerRestart(
+          "\"-Dweblogic.StdoutDebugEnabled=false\"", "\"-Dweblogic.StdoutDebugEnabled=true\"");
+      logger.info(
+          "About to testServerPodRestart for Domain: "
+              + domainMap.get("domainUID")
+              + " for the env property: StdoutDebugEnabled=true");
+
+    } finally {
+      String domainUidsToBeDeleted = "";
+
+      if (domain != null && (JENKINS || testCompletedSuccessfully)) {
+        domainUidsToBeDeleted = domain.getDomainUid();
+      }
+
+      /* if (!domainUidsToBeDeleted.equals("")) {
+        logger.info("About to delete domains: " + domainUidsToBeDeleted);
+        TestUtils.deleteWeblogicDomainResources(domainUidsToBeDeleted);
+        TestUtils.verifyAfterDeletion(domain);
+      }*/
+    }
+    logger.info("SUCCESS - " + testMethodName);
+  }
+
   private void testBasicUseCases(Domain domain) throws Exception {
     testAdminT3Channel(domain);
     testAdminServerExternalService(domain);

integration-tests/src/test/java/oracle/kubernetes/operator/utils/Domain.java

@@ -844,6 +844,84 @@ private void createPV() throws Exception {
     new PersistentVolume("/scratch/acceptance_test_pv/persistentVolume-" + domainUid, pvMap);
   }
 
+  public void testDomainServerRestart(String oldPropertyString, String newPropertyString)
+      throws Exception {
+    logger.info("Inside testDomainServerPodRestart");
+    boolean result = false;
+    result =
+        TestUtils.findFileContainString(
+            BaseTest.getUserProjectsDir() + "/weblogic-domains/" + domainUid + "/domain.yaml",
+            newPropertyString);
+    logger.info("The search result for " + newPropertyString + " is: " + result); // TODO
+    if (!result) {
+      TestUtils.createNewYamlFile(
+          BaseTest.getUserProjectsDir() + "/weblogic-domains/" + domainUid + "/domain.yaml",
+          BaseTest.getUserProjectsDir() + "/weblogic-domains/" + domainUid + "/domain_new.yaml",
+          oldPropertyString,
+          newPropertyString);
+      logger.info(
+          "Done - generate new domain.yaml for "
+              + domainUid
+              + " oldProperty: "
+              + oldPropertyString
+              + " newProperty: "
+              + newPropertyString);
+
+      // kubectl apply the new generated domain yaml file with changed property
+      StringBuffer command = new StringBuffer();
+      command
+          .append("kubectl apply  -f ")
+          .append(
+              BaseTest.getUserProjectsDir()
+                  + "/weblogic-domains/"
+                  + domainUid
+                  + "/domain_new.yaml");
+      logger.info("kubectl execut with command: " + command.toString());
+      ExecResult exeResult = ExecCommand.exec(command.toString());
+      if (exeResult.exitValue() != 0) {
+        throw new RuntimeException(
+            "FAILED: command to get domain " + command + " failed with " + exeResult.stderr());
+      }
+      if (!exeResult.stdout().contains(domainUid))
+        throw new RuntimeException("FAILURE: domain not found, exiting!");
+
+      // verify the servers in the domain are being restarted in a sequence
+      logger.info(
+          "Checking if admin pod(" + domainUid + "-" + adminServerName + ") is Terminating");
+      TestUtils.checkPodTerminating(domainUid + "-" + adminServerName, domainNS);
+      Thread.sleep(10 * 1000);
+      logger.info("Checking if admin pod(" + domainUid + "-" + adminServerName + ") is Running");
+      TestUtils.checkPodCreated(domainUid + "-" + adminServerName, domainNS);
+      Thread.sleep(10 * 1000);
+
+      if (domainMap.get("serverStartPolicy") == null
+          || (domainMap.get("serverStartPolicy") != null
+              && !domainMap.get("serverStartPolicy").toString().trim().equals("ADMIN_ONLY"))) {
+        // check managed server pods
+        for (int i = 1; i <= initialManagedServerReplicas; i++) {
+          logger.info(
+              "Checking if managed pod("
+                  + domainUid
+                  + "-"
+                  + managedServerNameBase
+                  + i
+                  + ") is Terminating");
+          TestUtils.checkPodTerminating(domainUid + "-" + managedServerNameBase + i, domainNS);
+          Thread.sleep(10 * 1000);
+          logger.info(
+              "Checking if managed pod("
+                  + domainUid
+                  + "-"
+                  + managedServerNameBase
+                  + i
+                  + ") is Running");
+          TestUtils.checkPodCreated(domainUid + "-" + managedServerNameBase + i, domainNS);
+        }
+      }
+    }
+    logger.info("Done - testDomainServerPodRestart");
+  }
+
   private void createSecret() throws Exception {
     Secret secret =
         new Secret(

integration-tests/src/test/java/oracle/kubernetes/operator/utils/TestUtils.java

@@ -4,14 +4,21 @@
 
 package oracle.kubernetes.operator.utils;
 
+import java.io.*;
+import java.io.BufferedReader;
 import java.io.File;
 import java.io.FileInputStream;
+import java.io.FileReader;
 import java.io.FileWriter;
 import java.io.InputStream;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.nio.file.StandardCopyOption;
 import java.security.KeyStore;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.Properties;
+import java.util.Scanner;
 import java.util.logging.Logger;
 import javax.ws.rs.client.Client;
 import javax.ws.rs.client.ClientBuilder;
@@ -54,6 +61,16 @@ public static void checkPodCreated(String podName, String domainNS) throws Excep
     checkCmdInLoop(cmd.toString(), "Running", podName);
   }
 
+  /** @param cmd - kubectl get pod <podname> -n namespace */
+  public static void checkPodTerminating(String podName, String domainNS) throws Exception {
+
+    StringBuffer cmd = new StringBuffer();
+    cmd.append("kubectl get pod ").append(podName).append(" -n ").append(domainNS);
+
+    // check for admin pod
+    checkCmdInLoop(cmd.toString(), "Terminating", podName);
+  }
+
   /**
    * @param cmd - kubectl get service <servicename> -n namespace
    * @throws Exception
@@ -988,4 +1005,62 @@ private static void checkCmdInLoopForDelete(String cmd, String matchStr, String
       }
     }
   }
+
+  // create yaml file with changed property
+  public static void createNewYamlFile(
+      String inputYamlFile, String generatedYamlFile, String oldString, String newString)
+      throws Exception {
+    logger.info("Creating new  " + generatedYamlFile);
+
+    // copy input template file and modify it
+    Files.copy(
+        new File(inputYamlFile).toPath(),
+        Paths.get(generatedYamlFile),
+        StandardCopyOption.REPLACE_EXISTING);
+
+    // read each line in input domain file and replace with intended changed property
+    BufferedReader reader = new BufferedReader(new FileReader(generatedYamlFile));
+    String line = "";
+    StringBuffer changedLines = new StringBuffer();
+    boolean isLineChanged = false;
+    while ((line = reader.readLine()) != null) {
+      if (line.contains(oldString)) {
+        String changedLine = line.replace(line.substring(line.indexOf(oldString)), newString);
+        changedLines.append(changedLine).append("\n");
+        isLineChanged = true;
+      }
+
+      if (!isLineChanged) {
+        changedLines.append(line).append("\n");
+      }
+      isLineChanged = false;
+    }
+    reader.close();
+    // writing to the file
+    Files.write(Paths.get(generatedYamlFile), changedLines.toString().getBytes());
+    logger.info("Done - generate the new yaml file ");
+  }
+
+  public static boolean findFileContainString(String inputYamlFile, String searchString)
+      throws Exception {
+    logger.info("Search File   " + inputYamlFile + " Search String: " + searchString);
+    boolean result = false;
+    File file = new File(inputYamlFile);
+    Scanner in = null;
+    try {
+      in = new Scanner(new FileReader(file));
+      while (in.hasNextLine() && !result) {
+        result = in.nextLine().indexOf(searchString) >= 0;
+      }
+    } catch (IOException e) {
+      e.printStackTrace();
+    } finally {
+      try {
+        in.close();
+      } catch (Exception e) {
+        /* ignore */
+      }
+    }
+    return result;
+  }
 }