Connect My Computer: Join cluster

web/packages/teleterm/src/mainProcess/agentRunner/agentRunner.test.ts

@@ -84,7 +84,11 @@ test('status updates are sent on a successful start', async () => {
   );
 
   try {
+    expect(agentRunner.getState(rootClusterUri)).toBeUndefined();
     const agentProcess = await agentRunner.start(rootClusterUri);
+    expect(agentRunner.getState(rootClusterUri)).toStrictEqual({
+      status: 'not-started',
+    } as AgentProcessState);
     await new Promise((resolve, reject) => {
       const timeout = setTimeout(
         () => reject('Process start timed out.'),
@@ -95,16 +99,18 @@ test('status updates are sent on a successful start', async () => {
         clearTimeout(timeout);
       });
     });
-    expect(updateSender).toHaveBeenCalledWith(rootClusterUri, {
-      status: 'running',
-    } as AgentProcessState);
+    const runningState: AgentProcessState = { status: 'running' };
+    expect(agentRunner.getState(rootClusterUri)).toStrictEqual(runningState);
+    expect(updateSender).toHaveBeenCalledWith(rootClusterUri, runningState);
 
     await agentRunner.kill(rootClusterUri);
-    expect(updateSender).toHaveBeenCalledWith(rootClusterUri, {
+    const exitedState: AgentProcessState = {
       status: 'exited',
       code: null,
       signal: 'SIGTERM',
-    } as AgentProcessState);
+    };
+    expect(agentRunner.getState(rootClusterUri)).toBeUndefined(); // the agent has been killed and removed
+    expect(updateSender).toHaveBeenCalledWith(rootClusterUri, exitedState);
 
     expect(updateSender).toHaveBeenCalledTimes(2);
   } finally {
@@ -131,10 +137,12 @@ test('status updates are sent on a failed start', async () => {
     await new Promise(resolve => agentProcess.on('error', resolve));
 
     expect(updateSender).toHaveBeenCalledTimes(1);
-    expect(updateSender).toHaveBeenCalledWith(rootClusterUri, {
+    const errorState: AgentProcessState = {
       status: 'error',
       message: expect.stringContaining('ENOENT'),
-    } as AgentProcessState);
+    };
+    expect(agentRunner.getState(rootClusterUri)).toStrictEqual(errorState);
+    expect(updateSender).toHaveBeenCalledWith(rootClusterUri, errorState);
   } finally {
     await agentRunner.killAll();
   }

web/packages/teleterm/src/mainProcess/agentRunner/agentRunner.ts

@@ -28,7 +28,13 @@ const MAX_STDERR_LINES = 10;
 
 export class AgentRunner {
   private logger = new Logger('AgentRunner');
-  private agentProcesses = new Map<RootClusterUri, ChildProcess>();
+  private agentProcesses = new Map<
+    RootClusterUri,
+    {
+      process: ChildProcess;
+      state: AgentProcessState;
+    }
+  >();
 
   constructor(
     private settings: RuntimeSettings,
@@ -45,7 +51,6 @@ export class AgentRunner {
   async start(rootClusterUri: RootClusterUri): Promise<ChildProcess> {
     if (this.agentProcesses.has(rootClusterUri)) {
       await this.kill(rootClusterUri);
-      this.logger.warn(`Killed agent process for ${rootClusterUri}`);
     }
 
     const { agentBinaryPath } = this.settings;
@@ -61,29 +66,45 @@ export class AgentRunner {
     ].filter(Boolean);
 
     this.logger.info(
-      `Starting agent from ${agentBinaryPath} with arguments ${args.join(' ')}`
+      `Starting agent for ${rootClusterUri} from ${agentBinaryPath} with arguments ${args.join(
+        ' '
+      )}`
     );
 
     const agentProcess = spawn(agentBinaryPath, args, {
       windowsHide: true,
     });
 
+    this.agentProcesses.set(rootClusterUri, {
+      process: agentProcess,
+      state: { status: 'not-started' },
+    });
     this.addListeners(rootClusterUri, agentProcess);
-    this.agentProcesses.set(rootClusterUri, agentProcess);
 
     return agentProcess;
   }
 
+  getState(rootClusterUri: RootClusterUri): AgentProcessState | undefined {
+    return this.agentProcesses.get(rootClusterUri)?.state;
+  }
+
   async kill(rootClusterUri: RootClusterUri): Promise<void> {
-    await terminateWithTimeout(this.agentProcesses.get(rootClusterUri));
-    this.agentProcesses.delete(rootClusterUri);
+    const agent = this.agentProcesses.get(rootClusterUri);
+    if (agent) {
+      await terminateWithTimeout(
+        this.agentProcesses.get(rootClusterUri).process
+      );
+      this.agentProcesses.delete(rootClusterUri);
+      this.logger.info(`Killed agent for ${rootClusterUri}`);
+    }
+    this.logger.warn(`Cannot get an agent to kill for ${rootClusterUri}`);
   }
 
   async killAll(): Promise<void> {
     const processes = Array.from(this.agentProcesses.entries());
     await Promise.all(
       processes.map(async ([rootClusterUri, agent]) => {
-        await terminateWithTimeout(agent);
+        await terminateWithTimeout(agent.process);
         this.agentProcesses.delete(rootClusterUri);
       })
     );
@@ -102,15 +123,15 @@ export class AgentRunner {
     });
 
     const spawnHandler = () => {
-      this.sendProcessState(rootClusterUri, {
+      this.updateProcessState(rootClusterUri, {
         status: 'running',
       });
     };
 
     const errorHandler = (error: Error) => {
       process.off('spawn', spawnHandler);
 
-      this.sendProcessState(rootClusterUri, {
+      this.updateProcessState(rootClusterUri, {
         status: 'error',
         message: `${error}`,
       });
@@ -124,7 +145,7 @@ export class AgentRunner {
       process.off('error', errorHandler);
       process.off('spawn', spawnHandler);
 
-      this.sendProcessState(rootClusterUri, {
+      this.updateProcessState(rootClusterUri, {
         status: 'exited',
         code,
         signal,
@@ -136,6 +157,17 @@ export class AgentRunner {
     process.once('error', errorHandler);
     process.once('exit', exitHandler);
   }
+
+  private updateProcessState(
+    rootClusterUri: RootClusterUri,
+    state: AgentProcessState
+  ): void {
+    const agent = this.agentProcesses.get(rootClusterUri);
+    if (agent) {
+      agent.state = state;
+    }
+    this.sendProcessState(rootClusterUri, state);
+  }
 }
 
 function limitProcessOutputLines(output: string): string {

web/packages/teleterm/src/mainProcess/fixtures/mocks.ts

@@ -20,6 +20,7 @@ import { createMockFileStorage } from 'teleterm/services/fileStorage/fixtures/mo
 // teleterm/services/config/index.ts reexports the config service client which depends on electron.
 // Importing electron breaks the fixtures if that's done from within storybook.
 import { createConfigService } from 'teleterm/services/config/configService';
+import { AgentProcessState } from 'teleterm/mainProcess/types';
 
 export class MockMainProcessClient implements MainProcessClient {
   configService: ReturnType<typeof createConfigService>;
@@ -95,6 +96,10 @@ export class MockMainProcessClient implements MainProcessClient {
     return Promise.resolve();
   }
 
+  getAgentState(): AgentProcessState {
+    return { status: 'not-started' };
+  }
+
   subscribeToAgentUpdate() {
     return { cleanup: () => undefined };
   }

web/packages/teleterm/src/mainProcess/mainProcess.ts

@@ -339,6 +339,18 @@ export default class MainProcess {
       }
     );
 
+    ipcMain.on(
+      'main-process-connect-my-computer-get-agent-state',
+      (
+        event,
+        args: {
+          rootClusterUri: RootClusterUri;
+        }
+      ) => {
+        event.returnValue = this.agentRunner.getState(args.rootClusterUri);
+      }
+    );
+
     subscribeToTerminalContextMenuEvent();
     subscribeToTabContextMenuEvent();
     subscribeToConfigServiceEvents(this.configService);

web/packages/teleterm/src/mainProcess/mainProcessClient.ts

@@ -92,6 +92,12 @@ export default function createMainProcessClient(): MainProcessClient {
         clusterProperties
       );
     },
+    getAgentState(clusterProperties: { rootClusterUri: RootClusterUri }) {
+      return ipcRenderer.sendSync(
+        'main-process-connect-my-computer-get-agent-state',
+        clusterProperties
+      );
+    },
     subscribeToAgentUpdate: (rootClusterUri, listener) => {
       const onChange = (
         _,

web/packages/teleterm/src/ui/ConnectMyComputer/connectMyComputerContext.tsx

@@ -44,9 +44,14 @@ export const ConnectMyComputerContextProvider: FC<{
   rootClusterUri: RootClusterUri;
 }> = props => {
   const { mainProcessClient, connectMyComputerService } = useAppContext();
-  const [agentState, setAgentState] = useState<AgentProcessState>(() => ({
-    status: 'not-started',
-  }));
+  const [agentState, setAgentState] = useState<AgentProcessState>(
+    () =>
+      mainProcessClient.getAgentState({
+        rootClusterUri: props.rootClusterUri,
+      }) || {
+        status: 'not-started',
+      }
+  );
 
   const runAgentAndWaitForNodeToJoin = useCallback(async () => {
     await connectMyComputerService.runAgent(props.rootClusterUri);