Group clusters by provider in the explorer

Signed-off-by: azerr <[email protected]>

Author: angelozerr

src/client/index.ts

@@ -15,7 +15,7 @@ export class ClientAccessor implements Disposable {
     }
 
     public get(clusterId: string): Client {
-        if (!this.clientsById.hasOwnProperty(clusterId)) {
+        if (!this.has(clusterId)) {
             const cluster = this.clusterSettings.get(clusterId);
 
             if (!cluster) {
@@ -28,6 +28,10 @@ export class ClientAccessor implements Disposable {
         return this.clientsById[clusterId];
     }
 
+    public has(clusterId: string): boolean {
+        return this.clientsById.hasOwnProperty(clusterId);
+    }
+
     public getSelectedClusterClient(): Client | undefined {
         const selectedCluster = this.clusterSettings.selected;
 
@@ -39,7 +43,7 @@ export class ClientAccessor implements Disposable {
     }
 
     public remove(clusterId: string): void {
-        if (!this.clientsById.hasOwnProperty(clusterId)) {
+        if (!this.has(clusterId)) {
             return;
         }
 

src/explorer/kafkaExplorer.ts

@@ -94,7 +94,7 @@ export class KafkaExplorer implements vscode.Disposable, vscode.TreeDataProvider
         if (!clusterItem) {
             return;
         }
-        this.selectItem(clusterItem);
+        await this.selectItem(clusterItem);
     }
 
     /**
@@ -112,11 +112,24 @@ export class KafkaExplorer implements vscode.Disposable, vscode.TreeDataProvider
         if (!topicItem) {
             return;
         }
-        this.selectItem(topicItem);
+        await this.selectItem(topicItem);
     }
 
-    private selectItem(item: NodeBase): void {
-        this.tree?.reveal(item, {
+    private async selectItem(item: NodeBase): Promise<void> {
+        // Expand all parent items
+        let parent = item.getParent();
+        const children = [];
+        while(parent && !(parent instanceof KafkaModel)) {
+            children.unshift(parent);
+            parent = parent.getParent();
+        }
+        for (const child of children) {
+            await this.tree?.reveal(child, {
+                expand: true,
+            });
+        }
+        // select the item
+        await this.tree?.reveal(item, {
             select: true,
             expand: true,
             focus: true

src/explorer/models/cluster.ts

@@ -9,14 +9,45 @@ import { ConsumerGroupsItem } from "./consumerGroups";
 import { KafkaModel } from "./kafka";
 import { Disposable } from "vscode";
 import { GlyphChars } from "../../constants";
+import { ClusterProvider, defaultClusterProviderId } from "../../kafka-extensions/registry";
+import { ClusterSettings } from "../../settings/clusters";
 
 const TOPIC_INDEX = 1;
 
+export class ClusterProviderItem extends NodeBase implements Disposable {
+
+    public contextValue = "clusterProvider";
+    public collapsibleState = vscode.TreeItemCollapsibleState.Collapsed;
+
+    constructor(private clientAccessor: ClientAccessor, public readonly clusterProvider: ClusterProvider, parent: KafkaModel) {
+        super(parent);
+        this.label = clusterProvider.name;
+    }
+
+    async computeChildren(): Promise<NodeBase[]> {
+        const clusters = this.getParent().clusterSettings.getAll();
+        return clusters
+            .filter((c) => c.clusterProviderId === this.clusterProvider.id || (c.clusterProviderId === undefined && this.clusterProvider.id === defaultClusterProviderId))
+            .map((c) => {
+                return new ClusterItem(this.getParent().clusterSettings, this.clientAccessor, c, this);
+            });
+    }
+
+    getParent(): KafkaModel {
+        return <KafkaModel>super.getParent();
+    }
+
+    public dispose(): void {
+        this.children?.forEach(child => (<ClusterItem>child).dispose());
+    }
+
+}
+
 export class ClusterItem extends NodeBase implements Disposable {
     public contextValue = "cluster";
     public collapsibleState = vscode.TreeItemCollapsibleState.Collapsed;
 
-    constructor(private clientAccessor: ClientAccessor, public readonly cluster: Cluster, parent: KafkaModel) {
+    constructor(private clusterSettings: ClusterSettings, private clientAccessor: ClientAccessor, public readonly cluster: Cluster, parent: KafkaModel | ClusterProviderItem) {
         super(parent);
         this.label = cluster.name;
         this.description = cluster.bootstrap;
@@ -33,10 +64,6 @@ export class ClusterItem extends NodeBase implements Disposable {
             new ConsumerGroupsItem(this)];
     }
 
-    getParent(): KafkaModel {
-        return <KafkaModel>super.getParent();
-    }
-
     getTreeItem(): vscode.TreeItem {
         const treeItem = super.getTreeItem();
         // to prevent from tree expansion after a refresh, we need to force the id to a static value
@@ -53,11 +80,11 @@ export class ClusterItem extends NodeBase implements Disposable {
     }
 
     public get selected(): boolean {
-        return (this.getParent().clusterSettings.selected?.name === this.cluster.name);
+        return (this.clusterSettings.selected?.name === this.cluster.name);
     }
 
     public dispose(): void {
-        this.client.dispose();
+        this.clientAccessor.remove(this.cluster.id);
     }
 
     async findTopictemByName(topicName: string): Promise<NodeBase | TopicItem | undefined> {

src/explorer/models/kafka.ts

@@ -1,42 +1,59 @@
 import { Disposable, TreeItemCollapsibleState } from "vscode";
-import { ClientAccessor } from "../../client";
+import { ClientAccessor, Cluster } from "../../client";
+import { getClusterProviders } from "../../kafka-extensions/registry";
 import { ClusterSettings } from "../../settings";
-import { ClusterItem } from "./cluster";
+import { ClusterItem, ClusterProviderItem } from "./cluster";
 import { NodeBase } from "./nodeBase";
 
 export class KafkaModel extends NodeBase implements Disposable {
 
     public contextValue = "";
     public collapsibleState = TreeItemCollapsibleState.Collapsed;
 
+    private clusterProviders = getClusterProviders();
     constructor(
         public readonly clusterSettings: ClusterSettings,
         protected clientAccessor: ClientAccessor) {
         super(undefined);
     }
 
     public async computeChildren(): Promise<NodeBase[]> {
-        const clusters = this.clusterSettings.getAll();
-        return clusters.map((c) => {
-            return new ClusterItem(this.clientAccessor, c, this);
-        });
+        if (this.clusterProviders.length <= 1) {
+            const clusters = this.clusterSettings.getAll();
+            return clusters.map((c) => {
+                return new ClusterItem(this.clusterSettings, this.clientAccessor, c, this);
+            });
+        } else {
+            return this.clusterProviders.map((p) => {
+                return new ClusterProviderItem(this.clientAccessor, p, this);
+            });
+        }
     }
 
     public dispose(): void {
-        this.children?.forEach(child => (<ClusterItem>child).dispose());
+        this.children?.forEach(child => (<Disposable><unknown>child).dispose());
     }
 
     async findClusterItemByName(clusterName: string): Promise<NodeBase | ClusterItem | undefined> {
-        return this.getChildren()
-            .then(clusters =>
-                clusters.find(child => (<ClusterItem>child).cluster.name === clusterName)
-            );
+        return this.findClusterItemBy((cluster) => (cluster.name === clusterName));
     }
 
     async findClusterItemById(clusterId: string): Promise<NodeBase | ClusterItem | undefined> {
-        return this.getChildren()
-            .then(clusters =>
-                clusters.find(child => (<ClusterItem>child).cluster.id === clusterId)
-            );
+        return this.findClusterItemBy((cluster) => (cluster.id === clusterId));
     }
+
+    async findClusterItemBy(predicate: (cluster: Cluster) => boolean): Promise<NodeBase | ClusterItem | undefined> {
+        const children = await this.getChildren();
+        if (this.clusterProviders.length <= 1) {
+            return children.find(child => predicate((<ClusterItem>child).cluster));
+        }
+        for (const child of children) {
+            const clusters = await (<ClusterProviderItem>child).getChildren();
+            const cluster = clusters.find(c => predicate((<ClusterItem>c).cluster));
+            if (cluster) {
+                return cluster;
+            }
+        }
+    }
+
 }

src/kafka-extensions/registry.ts

@@ -92,7 +92,7 @@ function isKafkaExtensionParticipant(arg: any): boolean {
     return (arg as KafkaExtensionParticipant).getClusterProviderParticipant !== undefined;
 }
 
-const defaultClusterProviderId = 'vscode-kafka.manual';
+export const defaultClusterProviderId = 'vscode-kafka.manual';
 
 let providers: Map<string, ClusterProvider> = new Map();