Add Verrazzano application status button and dialog (#168)

Author: rakillen

electron/app/js/ipcRendererPreload.js

@@ -213,6 +213,8 @@ contextBridge.exposeInMainWorld(
           'openssl-generate-certs',
           'validate-k8s-namespaces-exist',
           'validate-wko-domain-exist',
+          'validate-vz-application-exist',
+          'vz-get-application-status',
           'get-wrc-home-directory',
           'get-wrc-app-image',
           'wrc-get-home-default-value',

electron/app/js/kubectlUtils.js

@@ -156,6 +156,14 @@ async function getWkoDomainStatus(kubectlExe, domainUID, domainNamespace, option
   });
 }
 
+// Currently, this call returns the status of the domain component with domainUID, similar to getWkoDomainStatus.
+// In future releases, there may be additional information about the application and other components.
+async function getApplicationStatus(kubectlExe, application, domainUID, namespace, options) {
+  const results = await getWkoDomainStatus(kubectlExe, domainUID, namespace, options);
+  results['application'] = application;
+  return results;
+}
+
 async function getOperatorStatus(kubectlExe, operatorNamespace, options) {
   const args = [ 'get', 'pods', '-n', operatorNamespace, '-o', 'json'];
   const httpsProxyUrl = getHttpsProxyUrl();
@@ -312,6 +320,32 @@ async function validateDomainExist(kubectlExe, options, domain, namespace) {
   return Promise.resolve(result);
 }
 
+async function validateApplicationExist(kubectlExe, options, application, namespace) {
+  const httpsProxyUrl = getHttpsProxyUrl();
+  const bypassProxyHosts = getBypassProxyHosts();
+  const env = getKubectlEnvironment(options, httpsProxyUrl, bypassProxyHosts);
+
+  const result = {
+    isSuccess: true,
+    isValid: true,
+  };
+
+  const args = [ 'get', 'appconfig', application, '-n', namespace ];
+
+  try {
+    await executeFileCommand(kubectlExe, args, env);
+  } catch (err) {
+    if (isNotFoundError(err)) {
+      result.isValid = false;
+    } else {
+      result.isSuccess = false;
+      result.reason = getErrorMessage(err);
+      return Promise.resolve(result);
+    }
+  }
+  return Promise.resolve(result);
+}
+
 async function isOperatorAlreadyInstalled(kubectlExe, operatorName, operatorNamespace, options) {
   // We are currently using kubectl to see if the operator deployment exists.  The operator deployment
   // name is always weblogic-operator...
@@ -958,6 +992,7 @@ module.exports = {
   getK8sConfigView,
   getK8sClusterInfo,
   getWkoDomainStatus,
+  getApplicationStatus,
   getOperatorStatus,
   getOperatorVersionFromDomainConfigMap,
   getOperatorLogs,
@@ -966,6 +1001,7 @@ module.exports = {
   getKubernetesObjectsFromAllNamespaces,
   validateNamespacesExist,
   validateDomainExist,
+  validateApplicationExist,
   verifyClusterConnectivity,
   verifyVerrazzanoPlatformOperatorRollout,
 };

electron/app/locales/en/electron.json

@@ -322,6 +322,7 @@
   "kubectl-tlsfile-failed-error-message": "Unable to verify TLS file {{filePath}} exists: {{error}}",
   "kubectl-get-vz-install-failed-error-message": "Unable to get Verrazzano installation: {{error}}",
   "kubectl-get-named-vz-install-error-message": "Unable to get Verrazzano installation with name {{name}}: {{error}}",
+  "kubectl-get-vz-application-status-error-message": "Unable to get Verrazzano application status: {{error}}",
 
   "helm-not-specified-error-message": "Helm executable path was not provided",
   "helm-not-exists-error-message": "Helm executable {{filePath}} does not exist",

electron/app/locales/en/webui.json

@@ -1301,6 +1301,7 @@
   "flow-validate-k8s-domain-in-progress": "Validating domain {{domain}} exists",
   "flow-get-domain-status-name": "Get Domain Status",
   "flow-getting-k8s-domain-status-in-progress": "Getting domain {{domain}} status",
+  "flow-getting-vz-application-status-in-progress": "Getting Application Status",
   "flow-checking-operator-version-in-progress": "Checking operator version",
   "flow-checking-vz-already-installed-in-progress": "Checking if Verrazzano is already installed.",
   "flow-install-verrazzano-name": "Install Verrazzano",
@@ -1310,6 +1311,10 @@
   "flow-verrazzano-undeploy-component-name": "Undeploy Verrazzano Component",
   "flow-verrazzano-deploy-application-name": "Deploy Verrazzano Application",
   "flow-verrazzano-undeploy-application-name": "Undeploy Verrazzano Application",
+  "flow-verrazzano-get-application-status-name": "Get Application Status",
+  "flow-validate-vz-application-namespace-in-progress": "Validating application namespace {{namespace}} exists",
+  "flow-validate-vz-application-in-progress": "Validating application {{application}} exists",
+  "flow-validate-vz-domain-in-progress": "Validating domain UID {{domain}} exists",
 
   "add-archive-file-title": "Add Archive File",
   "add-archive-file-replace-message": "This will replace the existing archive, continue?",
@@ -1517,6 +1522,8 @@
 
   "vz-application-page-button-deployApplication": "Deploy Application",
   "vz-application-page-hints-deployApplication": "Deploy Application to Verrazzano",
+  "vz-application-page-button-applicationStatus": "Get Application Status",
+  "vz-application-page-hints-applicationStatus": "Check Application Deployment Status",
   "vz-application-page-button-undeployApplication": "Undeploy Application",
   "vz-application-page-hints-undeployApplication": "Undeploy Application from Verrazzano",
 
@@ -1692,6 +1699,15 @@
   "vz-application-undeployer-undeploy-failed-error-message":"Unable to undeploy Verrazzano application {{name}} from Kubernetes namespace {{namespace}}: {{error}}.",
   "vz-application-undeployer-undeploy-catch-all-error-message": "Verrazzano application undeployment from Kubernetes failed with an unexpected error: {{error}}",
 
+  "vz-application-status-checker-get-status-failed-title-message": "Get Application Status Failed",
+  "vz-application-status-checker-get-status-failed-error-message": "Unable to get the application status due to an error: {{error}}.",
+  "vz-application-status-checker-application-not-exist-error-message": "Unable to get the application status because the application {{application}} does not exist.",
+  "vz-application-status-checker-ns-not-exist-error-message": "Unable to get the application status because the application namespace {{namespace}} does not exist.",
+  "vz-application-status-checker-domain-not-exist-error-message": "Unable to get the application status because the domain UID {{domain}} does not exist.",
+
+  "vz-application-status-title": "Application Status for \"{{application}}\"",
+  "vz-application-status-domain-title": "Domain \"{{domain}}\"",
+
   "app-update-title": "Application Update",
   "app-update-new-release": "A new release is available: {{releaseName}}",
   "app-update-release-notes": "Release Notes",

electron/app/main.js

@@ -757,6 +757,14 @@ class Main {
       return kubectlUtils.validateDomainExist(kubectlExe, kubectlOptions, domain, namespace);
     });
 
+    ipcMain.handle('validate-vz-application-exist', async (event, kubectlExe, kubectlOptions, application, namespace) => {
+      return kubectlUtils.validateApplicationExist(kubectlExe, kubectlOptions, application, namespace);
+    });
+
+    ipcMain.handle('vz-get-application-status', async (event, kubectlExe, application, namespace, options) => {
+      return kubectlUtils.getApplicationStatus(kubectlExe, application, namespace, options);
+    });
+
     ipcMain.handle('is-wko-installed', async (event, kubectlExe, operatorName, operatorNamespace, kubectlOptions) => {
       return kubectlUtils.isOperatorAlreadyInstalled(kubectlExe, operatorName, operatorNamespace, kubectlOptions);
     });

webui/src/css/app.css

@@ -705,6 +705,18 @@ h6.wkt-panel-heading {
   color: red !important;
 }
 
+.wkt-status-paragraph {
+  margin: 1rem 0 0 0;
+}
+
+.wkt-status-paragraph.domainError {
+  color:red;
+}
+
+.wkt-status-paragraph.preformat {
+  white-space: pre-wrap;
+}
+
 .wkt-dialog-content {
   box-sizing: border-box;
   display: flex;

webui/src/js/utils/k8s-domain-actions-base.js

@@ -38,6 +38,137 @@ function (WktActionsBase, project, wktConsole, i18n, projectIo, dialogHelper) {
       }
       return Promise.resolve(true);
     }
+
+    // create a data structure with readable details about domain status.
+    // wkoDomainStatus is the domainStatus value from the k8s-get-wko-domain-status IPC result.
+    buildDomainStatus(wkoDomainStatus, operatorMajorVersion) {
+      const status = wkoDomainStatus.status;
+      let result = {isSuccess: true, domainOverallStatus: 'Unknown'};
+
+      if (typeof status !== 'undefined' && 'conditions' in status && status['conditions'].length > 0) {
+        const conditions = status['conditions'];
+        // default status
+        result['domainOverallStatus'] = i18n.t('k8s-domain-status-checker-domain-status-unknown');
+        conditions.sort((a, b) => {
+          if (a.lastTransitionTime < b.lastTransitionTime) {
+            return 1;
+          }
+          if (a.lastTransitionTime > b.lastTransitionTime) {
+            return -1;
+          }
+          return 0;
+        });
+
+        if (operatorMajorVersion < 4) {
+          const hasErrors = this.hasErrorConditions(conditions);
+          const latestCondition = conditions[0];
+
+          if (hasErrors.error) {
+            //  There seems to be a problem in the operator where the latest condition is progressing but
+            // there is an error previously but
+            result['domainOverallStatus'] = i18n.t('k8s-domain-status-checker-domain-status-failed',
+              {reason: hasErrors.reason});
+          } else if (latestCondition.type === 'Failed') {
+            result['domainOverallStatus'] = i18n.t('k8s-domain-status-checker-domain-status-failed',
+              {reason: latestCondition.reason});
+          } else if (latestCondition.type === 'Progressing') {
+            // Progressing maybe the domain is coming up, maybe the introspector is running
+            result['domainOverallStatus'] = i18n.t('k8s-domain-status-checker-domain-status-progressing',
+              {reason: latestCondition.reason});
+          } else if (latestCondition.type === 'Available') {
+            result['domainOverallStatus'] = 'Progressing';
+            if (status['clusters'].length > 0) {
+              const clusters = status['clusters'];
+              let ready = true;
+              clusters.forEach((cluster) => {
+                if (Number(cluster['replicasGoal']) !== Number(cluster['readyReplicas'])) {
+                  ready = false;
+                }
+              });
+
+              if (ready) {
+                result['domainOverallStatus'] = i18n.t('k8s-domain-status-checker-domain-status-complete');
+              } else {
+                result['domainOverallStatus'] = i18n.t('k8s-domain-status-checker-domain-status-available',
+                  {reason: latestCondition.reason});
+              }
+            } else {
+              // remain in progressing
+            }
+          }
+        } else {
+          ///
+          const hasErrors = this.hasErrorConditions(conditions);
+          const completeCondition = this.getCompletedCondition(conditions);
+          const availableCondition = this.getAvailableCondition(conditions);
+          const latestCondition = conditions[0];
+
+          if (hasErrors.error) {
+            result['domainOverallStatus'] = i18n.t('k8s-domain-status-checker-domain-status-failed',
+              {reason: hasErrors.reason});
+          } else if (completeCondition.status === 'True' && availableCondition.status === 'True') {
+            result['domainOverallStatus'] = i18n.t('k8s-domain-status-checker-domain-status-complete');
+          } else {
+            // Assume this is introspection progressing
+
+            if (completeCondition.status === 'False' && !this.hasAvailableCondition(conditions)) {
+              result['domainOverallStatus'] = i18n.t('k8s-domain-status-checker-domain-status-progressing',
+                {reason: latestCondition.reason});
+            } else if (completeCondition.status === 'False' && availableCondition.status === 'False') {
+              result['domainOverallStatus'] = i18n.t('k8s-domain-status-checker-domain-status-available',
+                {reason: latestCondition.reason});
+            } else {
+              // should never happened?
+              result['domainOverallStatus'] = i18n.t('k8s-domain-status-checker-domain-status-unknown',
+                {reason: latestCondition.reason});
+            }
+          }
+        }
+
+      } else {
+        // status not defined or no conditions - error in operator or namespace is not monitored
+        result['domainOverallStatus'] = i18n.t('k8s-domain-status-checker-domain-status-unknown');
+      }
+      return result;
+    }
+
+    hasErrorConditions(conditions) {
+      for (const condition of conditions) {
+        if (condition.type === 'Failed') {
+          return {error: true, reason: condition.reason};
+        }
+      }
+      return {error: false, reason: ''};
+    }
+
+    getCompletedCondition(conditions) {
+      const defaultCondition = {type: 'Completed', status: 'False'};
+      for (const condition of conditions) {
+        if (condition.type === 'Completed') {
+          return condition;
+        }
+      }
+      return defaultCondition;
+    }
+
+    getAvailableCondition(conditions) {
+      const defaultCondition = {type: 'Available', status: 'False'};
+      for (const condition of conditions) {
+        if (condition.type === 'Available') {
+          return condition;
+        }
+      }
+      return defaultCondition;
+    }
+
+    hasAvailableCondition(conditions) {
+      for (const condition of conditions) {
+        if (condition.type === 'Available') {
+          return true;
+        }
+      }
+      return false;
+    }
   }
 
   return K8sDomainActionsBase;