Phoenix Reconnect Integration (#1123)

* Reconnect integration

* git connection issue

* format issue

* Typo issue

* added constants

* Removed math.round for remainingTime

* code refctor for container status check

* disconnect text change

src/Explorer/Notebook/NotebookContainerClient.ts

@@ -59,31 +59,27 @@ export class NotebookContainerClient {
 
     const { notebookServerEndpoint, authToken } = this.getNotebookServerConfig();
     try {
-      const response = await fetch(`${notebookServerEndpoint}api/metrics/memory`, {
-        method: "GET",
-        headers: {
-          Authorization: authToken,
-          "content-type": "application/json",
-        },
-      });
-      if (response.ok) {
-        if (this.clearReconnectionAttemptMessage) {
-          this.clearReconnectionAttemptMessage();
-          this.clearReconnectionAttemptMessage = undefined;
+      if (this.checkStatus()) {
+        const response = await fetch(`${notebookServerEndpoint}api/metrics/memory`, {
+          method: "GET",
+          headers: {
+            Authorization: authToken,
+            "content-type": "application/json",
+          },
+        });
+        if (response.ok) {
+          if (this.clearReconnectionAttemptMessage) {
+            this.clearReconnectionAttemptMessage();
+            this.clearReconnectionAttemptMessage = undefined;
+          }
+          const memoryUsageInfo = await response.json();
+          if (memoryUsageInfo) {
+            return {
+              totalKB: memoryUsageInfo.total,
+              freeKB: memoryUsageInfo.free,
+            };
+          }
         }
-        const memoryUsageInfo = await response.json();
-        if (memoryUsageInfo) {
-          return {
-            totalKB: memoryUsageInfo.total,
-            freeKB: memoryUsageInfo.free,
-          };
-        }
-      } else if (NotebookUtil.isPhoenixEnabled()) {
-        const connectionStatus: ContainerConnectionInfo = {
-          status: ConnectionStatusType.ReConnect,
-        };
-        useNotebook.getState().resetConatinerConnection(connectionStatus);
-        useNotebook.getState().setIsRefreshed(true);
       }
       return undefined;
     } catch (error) {
@@ -97,14 +93,30 @@ export class NotebookContainerClient {
         const connectionStatus: ContainerConnectionInfo = {
           status: ConnectionStatusType.Failed,
         };
-        useNotebook.getState().resetConatinerConnection(connectionStatus);
-        useNotebook.getState().setIsRefreshed(true);
+        useNotebook.getState().resetContainerConnection(connectionStatus);
+        useNotebook.getState().setIsRefreshed(!useNotebook.getState().isRefreshed);
       }
       this.onConnectionLost();
       return undefined;
     }
   }
 
+  private checkStatus(): boolean {
+    if (NotebookUtil.isPhoenixEnabled()) {
+      if (
+        useNotebook.getState().containerStatus?.status &&
+        useNotebook.getState().containerStatus?.status === Constants.ContainerStatusType.InActive
+      ) {
+        const connectionStatus: ContainerConnectionInfo = {
+          status: ConnectionStatusType.ReConnect,
+        };
+        useNotebook.getState().resetContainerConnection(connectionStatus);
+        useNotebook.getState().setIsRefreshed(!useNotebook.getState().isRefreshed);
+        return false;
+      }
+    }
+    return true;
+  }
   public async resetWorkspace(): Promise<void> {
     this.isResettingWorkspace = true;
     try {

src/Explorer/Notebook/notebookClientV2.test.ts

@@ -35,6 +35,7 @@ describe("auto start kernel", () => {
         connectionInfo: {
           authToken: "autToken",
           notebookServerEndpoint: "notebookServerEndpoint",
+          forwardingId: "Id",
         },
         databaseAccountName: undefined,
         defaultExperience: undefined,

src/Explorer/Notebook/useNotebook.ts

@@ -7,7 +7,7 @@ import { getErrorMessage } from "../../Common/ErrorHandlingUtils";
 import * as Logger from "../../Common/Logger";
 import { configContext } from "../../ConfigContext";
 import * as DataModels from "../../Contracts/DataModels";
-import { ContainerConnectionInfo } from "../../Contracts/DataModels";
+import { ContainerConnectionInfo, ContainerInfo } from "../../Contracts/DataModels";
 import { IPinnedRepo } from "../../Juno/JunoClient";
 import { Action, ActionModifiers } from "../../Shared/Telemetry/TelemetryConstants";
 import * as TelemetryProcessor from "../../Shared/Telemetry/TelemetryProcessor";
@@ -35,6 +35,7 @@ interface NotebookState {
   notebookFolderName: string;
   isAllocating: boolean;
   isRefreshed: boolean;
+  containerStatus: ContainerInfo;
   setIsNotebookEnabled: (isNotebookEnabled: boolean) => void;
   setIsNotebooksEnabledForAccount: (isNotebooksEnabledForAccount: boolean) => void;
   setNotebookServerInfo: (notebookServerInfo: DataModels.NotebookWorkspaceConnectionInfo) => void;
@@ -53,8 +54,9 @@ interface NotebookState {
   initializeGitHubRepos: (pinnedRepos: IPinnedRepo[]) => void;
   setConnectionInfo: (connectionInfo: ContainerConnectionInfo) => void;
   setIsAllocating: (isAllocating: boolean) => void;
-  resetConatinerConnection: (connectionStatus: ContainerConnectionInfo) => void;
+  resetContainerConnection: (connectionStatus: ContainerConnectionInfo) => void;
   setIsRefreshed: (isAllocating: boolean) => void;
+  setContainerStatus: (containerStatus: ContainerInfo) => void;
 }
 
 export const useNotebook: UseStore<NotebookState> = create((set, get) => ({
@@ -63,6 +65,7 @@ export const useNotebook: UseStore<NotebookState> = create((set, get) => ({
   notebookServerInfo: {
     notebookServerEndpoint: undefined,
     authToken: undefined,
+    forwardingId: undefined,
   },
   sparkClusterConnectionInfo: {
     userName: undefined,
@@ -83,6 +86,11 @@ export const useNotebook: UseStore<NotebookState> = create((set, get) => ({
   notebookFolderName: undefined,
   isAllocating: false,
   isRefreshed: false,
+  containerStatus: {
+    status: undefined,
+    durationLeftMin: undefined,
+    notebookServerInfo: undefined,
+  },
   setIsNotebookEnabled: (isNotebookEnabled: boolean) => set({ isNotebookEnabled }),
   setIsNotebooksEnabledForAccount: (isNotebooksEnabledForAccount: boolean) => set({ isNotebooksEnabledForAccount }),
   setNotebookServerInfo: (notebookServerInfo: DataModels.NotebookWorkspaceConnectionInfo) =>
@@ -270,13 +278,20 @@ export const useNotebook: UseStore<NotebookState> = create((set, get) => ({
   },
   setConnectionInfo: (connectionInfo: ContainerConnectionInfo) => set({ connectionInfo }),
   setIsAllocating: (isAllocating: boolean) => set({ isAllocating }),
-  resetConatinerConnection: (connectionStatus: ContainerConnectionInfo): void => {
+  resetContainerConnection: (connectionStatus: ContainerConnectionInfo): void => {
     useNotebook.getState().setConnectionInfo(connectionStatus);
     useNotebook.getState().setNotebookServerInfo({
       notebookServerEndpoint: undefined,
       authToken: undefined,
+      forwardingId: undefined,
     });
     useNotebook.getState().setIsAllocating(false);
+    useNotebook.getState().setContainerStatus({
+      status: undefined,
+      durationLeftMin: undefined,
+      notebookServerInfo: undefined,
+    });
   },
   setIsRefreshed: (isRefreshed: boolean) => set({ isRefreshed }),
+  setContainerStatus: (containerStatus: ContainerInfo) => set({ containerStatus }),
 }));