Add kill method to poller

Author: opieter-aws

packages/core/src/codewhisperer/activation.ts

@@ -498,6 +498,7 @@ export async function activate(context: ExtContext): Promise<void> {
 export async function shutdown() {
     RecommendationHandler.instance.reportUserDecisions(-1)
     await CodeWhispererTracker.getTracker().shutdown()
+    AuthUtil.instance.regionProfileManager.globalStatePoller.kill()
 }
 
 function toggleIssuesVisibility(visibleCondition: (issue: CodeScanIssue, filePath: string) => boolean) {

packages/core/src/codewhisperer/region/regionProfileManager.ts

@@ -38,6 +38,9 @@ const endpoints = createConstantMap({
     'eu-central-1': 'https://q.eu-central-1.amazonaws.com/',
 })
 
+const getRegionProfile = () =>
+    globals.globalState.tryGet<{ [label: string]: RegionProfile }>('aws.amazonq.regionProfiles', Object, {})
+
 /**
  * 'user' -> users change the profile through Q menu
  * 'auth' -> users change the profile through webview profile selector page
@@ -80,6 +83,17 @@ export class RegionProfileManager {
         }
     })(this.listRegionProfile.bind(this))
 
+    // This is a poller that handles synchornization of selected region profiles between different IDE windows.
+    // It checks for changes in global state of region profile, invoking the change handler to switch profiles
+    public globalStatePoller = GlobalStatePoller.create({
+        getState: getRegionProfile,
+        changeHandler: async () => {
+            const profile = this.loadPersistedRegionProfle()
+            void this._switchRegionProfile(profile[this.authProvider.profileName], 'reload')
+        },
+        pollIntervalInMs: 2000,
+    })
+
     get activeRegionProfile() {
         if (this.authProvider.isBuilderIdConnection()) {
             return undefined
@@ -121,18 +135,7 @@ export class RegionProfileManager {
         return this._profiles
     }
 
-    constructor(private readonly authProvider: IAuthProvider) {
-        const getProfileFunction = () =>
-            globals.globalState.tryGet<{ [label: string]: RegionProfile }>('aws.amazonq.regionProfiles', Object, {})
-        const profileChangedHandler = async () => {
-            const profile = this.loadPersistedRegionProfle()
-            void this._switchRegionProfile(profile[this.authProvider.profileName], 'reload')
-        }
-
-        // This is a poller that handles synchornization of selected region profiles between different IDE windows.
-        // It checks for changes in global state of region profile, invoking the change handler to switch profiles
-        GlobalStatePoller.create(getProfileFunction, profileChangedHandler)
-    }
+    constructor(private readonly authProvider: IAuthProvider) {}
 
     async getProfiles(): Promise<RegionProfile[]> {
         return this.cache.getResource()
@@ -309,13 +312,7 @@ export class RegionProfileManager {
     }
 
     private loadPersistedRegionProfle(): { [label: string]: RegionProfile } {
-        const previousPersistedState = globals.globalState.tryGet<{ [label: string]: RegionProfile }>(
-            'aws.amazonq.regionProfiles',
-            Object,
-            {}
-        )
-
-        return previousPersistedState
+        return getRegionProfile()
     }
 
     async persistSelectRegionProfile() {
@@ -325,11 +322,7 @@ export class RegionProfileManager {
         }
 
         // persist connectionId to profileArn
-        const previousPersistedState = globals.globalState.tryGet<{ [label: string]: RegionProfile }>(
-            'aws.amazonq.regionProfiles',
-            Object,
-            {}
-        )
+        const previousPersistedState = getRegionProfile()
 
         previousPersistedState[this.authProvider.profileName] = this.activeRegionProfile
         await globals.globalState.update('aws.amazonq.regionProfiles', previousPersistedState)

packages/core/src/codewhisperer/util/authUtil.ts

@@ -277,7 +277,7 @@ export class AuthUtil implements IAuthProvider {
         })
     }
 
-    private async cacheChangedHandler(event: string) {
+    private async cacheChangedHandler(event: 'create' | 'delete') {
         if (event === 'delete') {
             await this.logout()
         } else if (event === 'create') {

packages/core/src/shared/globalState.ts

@@ -319,20 +319,29 @@ export class GlobalState implements vscode.Memento {
     }
 }
 
+export interface GlobalStatePollerProps {
+    getState: () => any
+    changeHandler: () => void
+    pollIntervalInMs: number
+}
+
 /**
  * Utility class that polls a state value at regular intervals and triggers a callback when the state changes.
  *
  * This class can be used to monitor changes in global state and react to those changes.
  */
 export class GlobalStatePoller {
     protected oldValue: any
+    protected pollIntervalInMs: number
     protected getState: () => any
     protected changeHandler: () => void
+    protected intervalId?: NodeJS.Timeout
 
-    constructor(getState: () => any, changeHandler: () => void) {
-        this.getState = getState
-        this.changeHandler = changeHandler
-        this.oldValue = getState()
+    constructor(props: GlobalStatePollerProps) {
+        this.getState = props.getState
+        this.changeHandler = props.changeHandler
+        this.pollIntervalInMs = props.pollIntervalInMs
+        this.oldValue = this.getState()
     }
 
     /**
@@ -342,24 +351,32 @@ export class GlobalStatePoller {
      * @param changeHandler - Callback function that is invoked when the state changes
      * @returns A new GlobalStatePoller instance that has already started polling
      */
-    static create(getState: () => any, changeHandler: () => void) {
-        const instance = new GlobalStatePoller(getState, changeHandler)
+    static create(props: GlobalStatePollerProps) {
+        const instance = new GlobalStatePoller(props)
         instance.poll()
         return instance
     }
 
     /**
-     * Starts polling the state value at 1 second intervals.
-     * When a change is detected, the changeHandler callback is invoked.
+     * Starts polling the state value. When a change is detected, the changeHandler callback is invoked.
      */
-    poll() {
-        const interval = 1000 // ms
-        setInterval(() => {
+    private poll() {
+        this.intervalId = setInterval(() => {
             const newValue = this.getState()
             if (this.oldValue !== newValue) {
                 this.oldValue = newValue
                 this.changeHandler()
             }
-        }, interval)
+        }, this.pollIntervalInMs)
+    }
+
+    /**
+     * Stops the polling interval.
+     */
+    kill() {
+        if (this.intervalId) {
+            clearInterval(this.intervalId)
+            this.intervalId = undefined
+        }
     }
 }