Base explorer refreshes on streamed events instead of polling so frequently

src/tree/LocalRootTreeItemBase.ts

@@ -4,8 +4,8 @@
  *--------------------------------------------------------------------------------------------*/
 
 import { isCommandNotSupportedError, ListContainersItem, ListContextItem, ListImagesItem, ListNetworkItem, ListVolumeItem } from "../runtimes/docker";
-import { AzExtParentTreeItem, AzExtTreeItem, AzureWizard, GenericTreeItem, IActionContext, parseError, registerEvent } from "@microsoft/vscode-azext-utils";
-import { ConfigurationChangeEvent, ConfigurationTarget, ThemeColor, ThemeIcon, TreeView, TreeViewVisibilityChangeEvent, WorkspaceConfiguration, window, workspace } from "vscode";
+import { AzExtParentTreeItem, AzExtTreeItem, AzureWizard, GenericTreeItem, IActionContext, parseError } from "@microsoft/vscode-azext-utils";
+import { ConfigurationTarget, ThemeColor, ThemeIcon, WorkspaceConfiguration, workspace } from "vscode";
 import { showDockerInstallNotification } from "../commands/dockerInstaller";
 import { configPrefix } from "../constants";
 import { ext } from "../extensionVariables";
@@ -20,6 +20,7 @@ import { ITreeSettingWizardInfo, ITreeSettingsWizardContext } from "./settings/I
 import { TreeSettingListStep } from "./settings/TreeSettingListStep";
 import { TreeSettingStep } from "./settings/TreeSettingStep";
 import { DatedDockerImage } from "./images/ImagesTreeItem";
+import { TreePrefix } from "./TreePrefix";
 
 type DockerStatus = 'NotInstalled' | 'Installed' | 'Running';
 
@@ -48,7 +49,7 @@ export abstract class LocalRootTreeItemBase<TItem extends AnyContainerObject, TP
         defaultProperty: 'CreatedTime',
     };
 
-    public abstract treePrefix: string;
+    public abstract treePrefix: TreePrefix;
     public abstract configureExplorerTitle: string;
     public abstract childType: LocalChildType<TItem>;
     public abstract childGroupType: LocalChildGroupType<TItem, TProperty>;
@@ -68,7 +69,7 @@ export abstract class LocalRootTreeItemBase<TItem extends AnyContainerObject, TP
     protected failedToConnect: boolean = false;
 
     private _currentItems: TItem[] | undefined;
-    private _itemsFromPolling: TItem[] | undefined;
+    private _cachedItems: TItem[] | undefined;
     private _currentDockerStatus: DockerStatus;
 
     public get contextValue(): string {
@@ -79,51 +80,6 @@ export abstract class LocalRootTreeItemBase<TItem extends AnyContainerObject, TP
         return workspace.getConfiguration(`${configPrefix}.${this.treePrefix}`);
     }
 
-    private get autoRefreshEnabled(): boolean {
-        return window.state.focused && LocalRootTreeItemBase.autoRefreshViews;
-    }
-
-    protected getRefreshInterval(): number {
-        const configOptions: WorkspaceConfiguration = workspace.getConfiguration('docker');
-        return configOptions.get<number>('explorerRefreshInterval', 2000);
-    }
-
-    public registerRefreshEvents(treeView: TreeView<AzExtTreeItem>): void {
-        let intervalId: NodeJS.Timeout;
-        registerEvent('treeView.onDidChangeVisibility', treeView.onDidChangeVisibility, (context: IActionContext, e: TreeViewVisibilityChangeEvent) => {
-            context.errorHandling.suppressDisplay = true;
-            context.telemetry.suppressIfSuccessful = true;
-            context.telemetry.properties.isActivationEvent = 'true';
-
-            if (e.visible) {
-                const refreshInterval: number = this.getRefreshInterval();
-                intervalId = setInterval(
-                    async () => {
-                        if (this.autoRefreshEnabled && await this.hasChanged(context)) {
-                            // Auto refresh could be disabled while invoking the hasChanged()
-                            // So check again before starting the refresh.
-                            if (this.autoRefreshEnabled) {
-                                await this.refresh(context);
-                            }
-                        }
-                    },
-                    refreshInterval);
-            } else {
-                clearInterval(intervalId);
-            }
-        });
-
-        registerEvent('treeView.onDidChangeConfiguration', workspace.onDidChangeConfiguration, async (context: IActionContext, e: ConfigurationChangeEvent) => {
-            context.errorHandling.suppressDisplay = true;
-            context.telemetry.suppressIfSuccessful = true;
-            context.telemetry.properties.isActivationEvent = 'true';
-
-            if (e.affectsConfiguration(`${configPrefix}.${this.treePrefix}`)) {
-                await this.refresh(context);
-            }
-        });
-    }
-
     protected getTreeItemForEmptyList(): AzExtTreeItem[] {
         return [new GenericTreeItem(this, {
             label: localize('vscode-docker.tree.noItemsFound', 'No items found'),
@@ -132,17 +88,12 @@ export abstract class LocalRootTreeItemBase<TItem extends AnyContainerObject, TP
         })];
     }
 
-    public clearPollingCache(): void {
-        this._itemsFromPolling = undefined;
-    }
-
     public async loadMoreChildrenImpl(clearCache: boolean, context: IActionContext): Promise<AzExtTreeItem[]> {
         try {
             // eslint-disable-next-line @typescript-eslint/no-floating-promises
             ext.activityMeasurementService.recordActivity('overallnoedit');
 
-            this._currentItems = this._itemsFromPolling || await this.getSortedItems(context);
-            this.clearPollingCache();
+            this._currentItems = await this.getCachedItems(context, clearCache);
             this.failedToConnect = false;
             this._currentDockerStatus = 'Running';
         } catch (error) {
@@ -356,47 +307,17 @@ export abstract class LocalRootTreeItemBase<TItem extends AnyContainerObject, TP
         return result;
     }
 
-    private async getSortedItems(context: IActionContext): Promise<TItem[]> {
-        if (ext.treeInitError === undefined) {
-            const items: TItem[] = await this.getItems(context) || [];
-            return items.sort((a, b) => getTreeId(a).localeCompare(getTreeId(b)));
-        } else {
-            throw ext.treeInitError;
-        }
-    }
-
-    private async hasChanged(context: IActionContext): Promise<boolean> {
-        let pollingDockerStatus: DockerStatus;
-        let isDockerStatusChanged = false;
-
-        try {
-            this._itemsFromPolling = await this.getSortedItems(context);
-            pollingDockerStatus = 'Running';
-        } catch (error) {
-            this.clearPollingCache();
-            pollingDockerStatus = await runtimeInstallStatusProvider.isRuntimeInstalled() ? 'Installed' : 'NotInstalled';
-            isDockerStatusChanged = pollingDockerStatus !== this._currentDockerStatus;
-        }
-
-        const hasChanged = !this.areArraysEqual(this._currentItems, this._itemsFromPolling) || isDockerStatusChanged;
-        this._currentDockerStatus = pollingDockerStatus;
-        return hasChanged;
-    }
-
-    protected areArraysEqual(array1: TItem[] | undefined, array2: TItem[] | undefined): boolean {
-        if (array1 === array2) {
-            return true;
-        } else if (array1 && array2) {
-            if (array1.length !== array2.length) {
-                return false;
+    private async getCachedItems(context: IActionContext, clearCache: boolean): Promise<TItem[]> {
+        if (clearCache || !this._cachedItems) {
+            if (ext.treeInitError === undefined) {
+                const items: TItem[] = await this.getItems(context) || [];
+                this._cachedItems = items.sort((a, b) => getTreeId(a).localeCompare(getTreeId(b)));
             } else {
-                return !array1.some((item1, index) => {
-                    return getTreeId(item1) !== getTreeId(array2[index]);
-                });
+                throw ext.treeInitError;
             }
-        } else {
-            return false;
         }
+
+        return this._cachedItems;
     }
 
     private showDockerInstallNotificationIfNeeded(): void {

src/tree/RefreshManager.ts

@@ -0,0 +1,169 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See LICENSE.md in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { AzExtTreeItem, callWithTelemetryAndErrorHandling, IActionContext, parseError, registerCommand } from '@microsoft/vscode-azext-utils';
+import * as vscode from 'vscode';
+import { ext } from '../extensionVariables';
+import { localize } from '../localize';
+import { isCancellationError } from '../runtimes/docker';
+import { AllTreePrefixes, TreePrefix } from './TreePrefix';
+
+const pollingIntervalMs = 60 * 1000; // One minute
+const eventListenerTries = 3; // The event listener will try at most 3 times to connect for events
+
+type RefreshTarget = AzExtTreeItem | TreePrefix;
+type RefreshReason = 'interval' | 'event' | 'config' | 'manual';
+
+export class RefreshManager extends vscode.Disposable {
+    private readonly refreshEmitter = new vscode.EventEmitter<[RefreshTarget, RefreshReason]>();
+    private readonly disposables: vscode.Disposable[] = [];
+    private readonly cts: vscode.CancellationTokenSource = new vscode.CancellationTokenSource();
+
+    public constructor() {
+        super(() => vscode.Disposable.from(...this.disposables).dispose());
+
+        this.disposables.push(
+            this.refreshEmitter.event(async ([target, reason]) => {
+                await this.refresh(target, reason);
+            })
+        );
+
+        // VSCode does *not* cancel by default on disposal of a CancellationTokenSource, so we need to manually cancel
+        this.disposables.unshift(new vscode.Disposable(() => this.cts.cancel()));
+
+        this.setupRefreshOnInterval();
+        this.setupRefreshOnRuntimeEvent();
+        this.setupRefreshOnConfigurationChange();
+        this.setupRefreshOnCommand();
+    }
+
+    private setupRefreshOnInterval(): void {
+        const timer = setInterval(async () => {
+            for (const view of AllTreePrefixes) {
+                this.refreshEmitter.fire([view, 'interval']);
+            }
+        }, pollingIntervalMs);
+
+        // Put the interval emitter at the front so it gets disposed earlier
+        this.disposables.push(new vscode.Disposable(
+            () => clearInterval(timer)
+        ));
+    }
+
+    private setupRefreshOnRuntimeEvent(): void {
+        void callWithTelemetryAndErrorHandling('vscode-docker.tree.eventRefresh', async (context: IActionContext) => {
+            context.errorHandling.suppressDisplay = true;
+            context.telemetry.suppressIfSuccessful = true;
+
+            // Try at most `eventListenerTries` times to (re)connect to the event stream
+            for (let i = 0; i < eventListenerTries; i++) {
+                try {
+                    // TODO: finish this
+                    const eventGenerator = 'foo' as unknown as AsyncGenerator<{ Type: string }>;
+
+                    for await (const event of eventGenerator) {
+                        switch (event.Type) {
+                            case 'container':
+                                this.refreshEmitter.fire(['containers', 'event']);
+                                break;
+                            case 'network':
+                                this.refreshEmitter.fire(['networks', 'event']);
+                                break;
+                            case 'image':
+                                this.refreshEmitter.fire(['images', 'event']);
+                                break;
+                            case 'volume':
+                                this.refreshEmitter.fire(['volumes', 'event']);
+                                break;
+                            case 'context':
+                                this.refreshEmitter.fire(['contexts', 'event']);
+                                break;
+                            default:
+                                // Ignore other events
+                                break;
+                        }
+                    }
+                } catch (err) {
+                    const error = parseError(err);
+
+                    if (isCancellationError(err) || error.isUserCancelledError) {
+                        // Cancelled, so don't try again and don't rethrow--this is a normal termination pathway
+                        return;
+                    } else if (i < eventListenerTries - 1) {
+                        // Still in the retry loop
+                        continue;
+                    } else {
+                        // Emit a message and rethrow to get telemetry
+                        ext.outputChannel.appendLine(
+                            localize('vscode-docker.tree.refreshManager.eventSetupFailure', 'Failed to set up event listener: {0}', error.message)
+                        );
+
+                        throw error;
+                    }
+                }
+            }
+        });
+
+    }
+
+    private setupRefreshOnConfigurationChange(): void {
+        this.disposables.push(
+            vscode.workspace.onDidChangeConfiguration((e: vscode.ConfigurationChangeEvent) => {
+                for (const view of AllTreePrefixes) {
+                    if (e.affectsConfiguration(`docker.${view}`)) {
+                        this.refreshEmitter.fire([view, 'config']);
+                    }
+                }
+            })
+        );
+    }
+
+    private setupRefreshOnCommand(): void {
+        for (const view of AllTreePrefixes) {
+            // Because `registerCommand` pushes the disposables onto the `ext.context.subscriptions` array, we don't need to keep track of them
+            registerCommand(`vscode-docker.${view}.refresh`, () => {
+                this.refreshEmitter.fire([view, 'manual']);
+            });
+        }
+    }
+
+    private refresh(target: RefreshTarget, reason: 'interval' | 'event' | 'config' | 'manual'): Promise<void> {
+        return callWithTelemetryAndErrorHandling('vscode-docker.tree.refresh', async (context: IActionContext) => {
+            context.telemetry.properties.refreshReason = reason;
+            context.errorHandling.suppressDisplay = true;
+
+            if (isAzExtTreeItem(target)) {
+                context.telemetry.properties.refreshTarget = 'node';
+                return await target.refresh(context);
+            } else if (typeof target === 'string') {
+                context.telemetry.properties.refreshTarget = target;
+                switch (target) {
+                    case 'containers':
+                        return await ext.containersRoot.refresh(context);
+                    case 'networks':
+                        return await ext.networksRoot.refresh(context);
+                    case 'images':
+                        return await ext.imagesRoot.refresh(context);
+                    case 'registries':
+                        return await ext.registriesRoot.refresh(context);
+                    case 'volumes':
+                        return await ext.volumesRoot.refresh(context);
+                    case 'contexts':
+                        return await ext.contextsRoot.refresh(context);
+                    default:
+                        throw new RangeError(`Unexpected view type: ${target}`);
+                }
+            } else {
+                context.telemetry.properties.refreshTarget = 'none';
+            }
+        });
+    }
+}
+
+// TODO: temp: this function is available in newer versions of @microsoft/vscode-azext-utils, use it when available
+function isAzExtTreeItem(maybeTreeItem: unknown): maybeTreeItem is AzExtTreeItem {
+    return typeof maybeTreeItem === 'object' &&
+        !!(maybeTreeItem as AzExtTreeItem).fullId;
+}

src/tree/TreePrefix.ts

@@ -0,0 +1,15 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See LICENSE.md in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+/**
+ * The prefix names for each of the tree views
+ * Note: the help tree is intentionally excluded because it has no refresh nor config capabilities
+ */
+export const AllTreePrefixes = ['containers', 'networks', 'images', 'registries', 'volumes', 'contexts'] as const;
+
+/**
+ * A union type representing the tree prefix options
+ */
+export type TreePrefix = (typeof AllTreePrefixes)[number];

src/tree/containers/ContainersTreeItem.ts

@@ -15,13 +15,14 @@ import { ITreeArraySettingInfo, ITreeSettingInfo } from "../settings/ITreeSettin
 import { ContainerGroupTreeItem } from "./ContainerGroupTreeItem";
 import { ContainerProperty, containerProperties, getContainerPropertyValue, NonComposeGroupName } from "./ContainerProperties";
 import { ContainerTreeItem } from "./ContainerTreeItem";
+import { TreePrefix } from "../TreePrefix";
 
 export type DockerContainerInfo = ListContainersItem & {
     showFiles: boolean;
 };
 
 export class ContainersTreeItem extends LocalRootTreeItemBase<DockerContainerInfo, ContainerProperty> {
-    public treePrefix: string = 'containers';
+    public treePrefix: TreePrefix = 'containers';
     public label: string = localize('vscode-docker.tree.containers.label', 'Containers');
     public configureExplorerTitle: string = localize('vscode-docker.tree.containers.configure', 'Configure containers explorer');
 
@@ -98,28 +99,6 @@ export class ContainersTreeItem extends LocalRootTreeItemBase<DockerContainerInf
         return super.getTreeItemForEmptyList();
     }
 
-    protected areArraysEqual(array1: DockerContainerInfo[] | undefined, array2: DockerContainerInfo[] | undefined): boolean {
-        if (!super.areArraysEqual(array1, array2)) {
-            // If they aren't the same according to the base class implementation, they are definitely not the same according to this either
-            return false;
-        }
-
-        // If they are both undefined, return true
-        // If only one is undefined, return false
-        // This matches the behavior of the base class implementation, and guards against null refs below
-        if (array1 === undefined && array2 === undefined) {
-            return true;
-        } else if (array1 === undefined || array2 === undefined) {
-            return false;
-        }
-
-        // Containers' labels/descriptions (status in particular) can change. If they do, we want to cause a refresh. But, we also don't want to change the tree ID based on status (in `getTreeId()` in LocalRootTreeItemBase.ts).
-        return !array1.some((item, index) => {
-            return this.getTreeItemLabel(item) !== this.getTreeItemLabel(array2[index]) ||
-                this.getTreeItemDescription(item) !== this.getTreeItemDescription(array2[index]);
-        });
-    }
-
     private isNewContainerUser(): boolean {
         return ext.context.globalState.get<boolean>('vscode-docker.container.newContainerUser', true);
     }