Added server parent nodes in connections + panels views (#DH-22593)

Author: bmingles

src/common/constants.ts

@@ -159,6 +159,7 @@ export const VARIABLE_UNICODE_ICONS = {
 export const CONNECTION_TREE_ITEM_CONTEXT = {
   isConnectionConnected: 'isConnectionConnected',
   isConnectionConnecting: 'isConnectionConnecting',
+  isDHEServerConnectionParent: 'isDHEServerConnectionParent',
   isUri: 'isUri',
 } as const;
 

src/controllers/ServerConnectionTreeDragAndDropController.ts

@@ -1,5 +1,5 @@
 import { MIME_TYPE } from '../common';
-import { getEditorForUri } from '../util';
+import { getEditorForUri, isServerStateNode } from '../util';
 import type { IServerManager } from '../types';
 import type { ServerConnectionNode } from '../types/treeViewTypes';
 
@@ -21,8 +21,13 @@ export class ServerConnectionTreeDragAndDropController
     dataTransfer: vscode.DataTransfer,
     _token: vscode.CancellationToken
   ): Promise<void> => {
-    // Only target connection nodes
-    if (target == null || target instanceof vscode.Uri) {
+    // Only target connection nodes. DHE server group nodes and uri leaf nodes
+    // are not valid editor-connection targets.
+    if (
+      target == null ||
+      target instanceof vscode.Uri ||
+      isServerStateNode(target)
+    ) {
       return;
     }
 

src/providers/ServerConnectionPanelTreeProvider.ts

@@ -2,13 +2,15 @@ import * as vscode from 'vscode';
 import type {
   IPanelService,
   IServerManager,
-  ConnectionState,
   ServerConnectionPanelNode,
 } from '../types';
 import { ServerTreeProviderBase } from './ServerTreeProviderBase';
 import {
+  getConnectionServerTreeItem,
+  getConnectionTreeRootNodes,
   getPanelConnectionTreeItem,
   getPanelVariableTreeItem,
+  isServerStateNode,
   sortByStringProp,
 } from '../util';
 import { getFirstSupportedConsoleType } from '../services';
@@ -27,40 +29,61 @@ export class ServerConnectionPanelTreeProvider extends ServerTreeProviderBase<Se
   private readonly _panelService: IPanelService;
 
   getTreeItem = async (
-    connectionOrVariable: ServerConnectionPanelNode
+    node: ServerConnectionPanelNode
   ): Promise<vscode.TreeItem> => {
-    if (Array.isArray(connectionOrVariable)) {
-      return getPanelVariableTreeItem(connectionOrVariable);
+    // Variable leaf node.
+    if (Array.isArray(node)) {
+      return getPanelVariableTreeItem(node);
+    }
+
+    // DHE server node grouping its worker connections.
+    if (isServerStateNode(node)) {
+      return getConnectionServerTreeItem(node);
     }
 
     const serverLabel = getServerMatchPortIfLocalHost(
       this.serverManager,
-      connectionOrVariable.serverUrl
+      node.serverUrl
     )?.label;
 
-    const workerInfo = await this.serverManager.getWorkerInfo(
-      connectionOrVariable.serverUrl
-    );
+    const workerInfo = await this.serverManager.getWorkerInfo(node.serverUrl);
+
+    // DHE worker nodes are nested under their server node (worker name as the
+    // label); flat DHC connections keep the server label.
+    const isWorkerChild = this.serverManager.getServerForConnection(node) != null;
 
     return getPanelConnectionTreeItem(
-      connectionOrVariable,
+      node,
       getFirstSupportedConsoleType,
       serverLabel,
-      workerInfo?.name
+      workerInfo?.name,
+      isWorkerChild
     );
   };
 
   getChildren = (
-    connectionOrRoot?: ConnectionState
+    elementOrRoot?: ServerConnectionPanelNode
   ): vscode.ProviderResult<ServerConnectionPanelNode[]> => {
-    if (connectionOrRoot == null) {
+    // Root: DHE server nodes + flat DHC connection nodes.
+    if (elementOrRoot == null) {
+      return getConnectionTreeRootNodes(this.serverManager);
+    }
+
+    // Variable leaf nodes have no children.
+    if (Array.isArray(elementOrRoot)) {
+      return [];
+    }
+
+    // DHE server node -> its worker connections.
+    if (isServerStateNode(elementOrRoot)) {
       return this.serverManager
-        .getConnections()
+        .getConnections(elementOrRoot.url)
         .sort(sortByStringProp('serverUrl'));
     }
 
-    return [...this._panelService.getVariables(connectionOrRoot.serverUrl)]
+    // Connection node -> its panel variables.
+    return [...this._panelService.getVariables(elementOrRoot.serverUrl)]
       .sort(sortByStringProp('title'))
-      .map(variable => [connectionOrRoot.serverUrl, variable]);
+      .map(variable => [elementOrRoot.serverUrl, variable]);
   };
 }

src/providers/ServerConnectionTreeProvider.ts

@@ -1,15 +1,13 @@
 import * as vscode from 'vscode';
 import { ServerTreeProviderBase } from './ServerTreeProviderBase';
 import { CONNECTION_TREE_ITEM_CONTEXT, ICON_ID } from '../common';
-import type {
-  IDhcService,
-  ConnectionState,
-  ConsoleType,
-  ServerConnectionNode,
-} from '../types';
+import type { ConsoleType, ServerConnectionNode } from '../types';
 import {
+  getConnectionServerTreeItem,
+  getConnectionTreeRootNodes,
   getConsoleTypeIconId,
   isInstanceOf,
+  isServerStateNode,
   sortByStringProp,
 } from '../util';
 import { DhcService } from '../services';
@@ -20,29 +18,31 @@ import { getServerMatchPortIfLocalHost } from '../mcp/utils';
  */
 export class ServerConnectionTreeProvider extends ServerTreeProviderBase<ServerConnectionNode> {
   getTreeItem = async (
-    connectionOrUri: ServerConnectionNode
+    node: ServerConnectionNode
   ): Promise<vscode.TreeItem> => {
     // Uri node associated with a parent connection node
-    if (connectionOrUri instanceof vscode.Uri) {
+    if (node instanceof vscode.Uri) {
       return {
-        description: connectionOrUri.path,
+        description: node.path,
         contextValue: CONNECTION_TREE_ITEM_CONTEXT.isUri,
         command: {
           command: 'vscode.open',
           title: 'Open Uri',
-          arguments: [connectionOrUri],
+          arguments: [node],
         },
-        resourceUri: connectionOrUri,
+        resourceUri: node,
       };
     }
 
+    // DHE server node grouping its worker connections.
+    if (isServerStateNode(node)) {
+      return getConnectionServerTreeItem(node);
+    }
+
     // Console type (language) drives the node icon rather than the description.
     let consoleType: ConsoleType | undefined;
-    if (
-      isInstanceOf(connectionOrUri, DhcService) &&
-      connectionOrUri.isInitialized
-    ) {
-      [consoleType] = await connectionOrUri.getConsoleTypes();
+    if (isInstanceOf(node, DhcService) && node.isInitialized) {
+      [consoleType] = await node.getConsoleTypes();
     }
 
     // Prefer the persistent query name (what the DHE Query Monitor shows) over
@@ -51,25 +51,33 @@ export class ServerConnectionTreeProvider extends ServerTreeProviderBase<ServerC
     // diverge from their query name; the PQ name is the stable identifier in
     // both cases. Falls back to tagId for plain DHC connections, which have no
     // associated WorkerInfo.
-    const workerInfo = await this.serverManager.getWorkerInfo(
-      connectionOrUri.serverUrl
-    );
-    const description = workerInfo?.name ?? connectionOrUri.tagId ?? '';
+    const workerInfo = await this.serverManager.getWorkerInfo(node.serverUrl);
+    const workerName = workerInfo?.name ?? node.tagId ?? '';
+
+    const hasUris = this.serverManager.hasConnectionUris(node);
 
-    const hasUris = this.serverManager.hasConnectionUris(connectionOrUri);
+    // DHE worker nodes are nested under their server node, so the worker name
+    // becomes the node label and the server label lives on the parent. Flat DHC
+    // connections keep the server label as the node label and show the worker
+    // name as the description.
+    const isWorkerChild = this.serverManager.getServerForConnection(node) != null;
 
     const serverLabel = getServerMatchPortIfLocalHost(
       this.serverManager,
-      connectionOrUri.serverUrl
+      node.serverUrl
     )?.label;
 
-    const label = serverLabel ?? connectionOrUri.serverUrl.host;
+    const label = isWorkerChild
+      ? workerName
+      : (serverLabel ?? node.serverUrl.host);
+
+    const description = isWorkerChild ? undefined : workerName;
 
     // Connection node
     return {
       label,
       description,
-      contextValue: connectionOrUri.isConnected
+      contextValue: node.isConnected
         ? CONNECTION_TREE_ITEM_CONTEXT.isConnectionConnected
         : CONNECTION_TREE_ITEM_CONTEXT.isConnectionConnecting,
       collapsibleState: hasUris
@@ -78,22 +86,34 @@ export class ServerConnectionTreeProvider extends ServerTreeProviderBase<ServerC
       // Show the language (Python/Groovy) icon when idle/connected; show the
       // spinner while busy (connecting or running code).
       iconPath: new vscode.ThemeIcon(
-        connectionOrUri.isRunningCode || !connectionOrUri.isConnected
+        node.isRunningCode || !node.isConnected
           ? ICON_ID.connecting
           : getConsoleTypeIconId(consoleType)
       ),
     };
   };
 
   getChildren = (
-    elementOrRoot?: IDhcService
+    elementOrRoot?: ServerConnectionNode
   ): vscode.ProviderResult<ServerConnectionNode[]> => {
+    // Root: DHE server nodes + flat DHC connection nodes.
     if (elementOrRoot == null) {
+      return getConnectionTreeRootNodes(this.serverManager);
+    }
+
+    // Uri leaf nodes have no children.
+    if (elementOrRoot instanceof vscode.Uri) {
+      return [];
+    }
+
+    // DHE server node -> its worker connections.
+    if (isServerStateNode(elementOrRoot)) {
       return this.serverManager
-        .getConnections()
+        .getConnections(elementOrRoot.url)
         .sort(sortByStringProp('serverUrl'));
     }
 
+    // Connection node -> its editor uris.
     return this.serverManager.getConnectionUris(elementOrRoot);
   };
 
@@ -102,11 +122,16 @@ export class ServerConnectionTreeProvider extends ServerTreeProviderBase<ServerC
    * for `TreeView.reveal` method to work.
    * @param element
    */
-  getParent = (element: ServerConnectionNode): ConnectionState | null => {
+  getParent = (element: ServerConnectionNode): ServerConnectionNode | null => {
     if (element instanceof vscode.Uri) {
       return this.serverManager.getUriConnection(element);
     }
 
-    return null;
+    if (isServerStateNode(element)) {
+      return null;
+    }
+
+    // Connection node -> its parent DHE server (or null for flat DHC).
+    return this.serverManager.getServerForConnection(element) ?? null;
   };
 }

src/services/ServerManager.ts

@@ -695,6 +695,23 @@ export class ServerManager implements IServerManager {
     });
   };
 
+  /**
+   * Get the parent DHE server for a connection. Returns the DHE server state
+   * when the connection is a DHE worker (its `serverUrl` is mapped to a DHE
+   * server URL), or `undefined` for DHC connections, which have no parent
+   * server node in the tree.
+   * @param connection The connection to get the parent server for.
+   * @returns The parent DHE server state, or `undefined`.
+   */
+  getServerForConnection = (
+    connection: ConnectionState
+  ): ServerState | undefined => {
+    const dheServerUrl = this._workerURLToServerURLMap.get(
+      connection.serverUrl
+    );
+    return dheServerUrl == null ? undefined : this.getServer(dheServerUrl);
+  };
+
   /**
    * Get all URIs associated with a connection.
    * @param connection

src/types/serviceTypes.d.ts

@@ -190,6 +190,14 @@ export interface IServerManager extends IDisposable {
   getConnection: (serverUrl: URL) => ConnectionState | undefined;
   getConnections: (serverOrWorkerUrl?: URL) => ConnectionState[];
   getConnectionUris: (connection: ConnectionState) => vscode.Uri[];
+  /**
+   * Get the parent DHE server for a connection. Returns the DHE `ServerState`
+   * when the connection is a DHE worker, or `undefined` for DHC connections
+   * (which have no parent server node in the tree).
+   */
+  getServerForConnection: (
+    connection: ConnectionState
+  ) => ServerState | undefined;
   getDheServiceForWorker: (maybeWorkerUrl: URL) => Promise<IDheService | null>;
   getEditorConnection: (uri: vscode.Uri) => Promise<ConnectionState | null>;
   getWorkerCredentials: (

src/types/treeViewTypes.d.ts

@@ -9,12 +9,13 @@ export type ServerGroupState = 'Managed' | 'Running' | 'Stopped';
 export type ServerNode = ServerGroupState | ServerState;
 export interface ServerTreeView extends vscode.TreeView<ServerNode> {}
 
-export type ServerConnectionNode = ConnectionState | vscode.Uri;
+export type ServerConnectionNode = ServerState | ConnectionState | vscode.Uri;
 
 export interface ServerConnectionTreeView
   extends vscode.TreeView<ServerConnectionNode> {}
 
 export type ServerConnectionPanelNode =
+  | ServerState
   | ConnectionState
   | [URL, VariableDefintion];