Quickly create Remote Jupyter Finders

src/kernels/jupyter/finder/remoteKernelFinderController.ts

@@ -3,14 +3,15 @@
 
 import { injectable, inject } from 'inversify';
 import { IKernelFinder, IKernelProvider } from '../../types';
-import { IDisposableRegistry, IExtensionContext } from '../../../platform/common/types';
+import { IDisposableRegistry, IExtensionContext, IFeaturesManager } from '../../../platform/common/types';
 import {
  IOldJupyterSessionManagerFactory,
  IJupyterServerUriStorage,
  IJupyterRemoteCachedKernelValidator,
  IJupyterServerUriEntry,
  IJupyterUriProviderRegistration,
- JupyterServerProviderHandle
+ JupyterServerProviderHandle,
+ IJupyterServerProviderRegistry
 } from '../types';
 import { noop } from '../../../platform/common/utils/misc';
 import { IApplicationEnvironment } from '../../../platform/common/application/types';
@@ -22,7 +23,9 @@ import { IFileSystem } from '../../../platform/common/platform/types';
 import { ContributedKernelFinderKind } from '../../internalTypes';
 import { generateIdFromRemoteProvider } from '../jupyterUtils';
 import { swallowExceptions } from '../../../platform/common/utils/decorators';
-import { IJupyterUriProvider } from '../../../api';
+import { IJupyterUriProvider, JupyterServerCollection, JupyterServerProvider } from '../../../api';
+import { CancellationTokenSource } from 'vscode';
+import { traceError } from '../../../platform/logging';
 
 @injectable()
 export class RemoteKernelFinderController implements IExtensionSyncActivationService {
@@ -42,7 +45,11 @@ export class RemoteKernelFinderController implements IExtensionSyncActivationSer
  @inject(IFileSystem) private readonly fs: IFileSystem,
  @inject(IExtensionContext) private readonly context: IExtensionContext,
  @inject(IJupyterUriProviderRegistration)
- private readonly jupyterPickerRegistration: IJupyterUriProviderRegistration
+ private readonly jupyterPickerRegistration: IJupyterUriProviderRegistration,
+ @inject(IJupyterServerProviderRegistry)
+ private readonly jupyterServerProviderRegistry: IJupyterServerProviderRegistry,
+ @inject(IFeaturesManager)
+ private readonly features: IFeaturesManager
  ) {}
  private readonly handledProviders = new WeakSet<IJupyterUriProvider>();
  activate() {
@@ -55,9 +62,10 @@ export class RemoteKernelFinderController implements IExtensionSyncActivationSer
 
  // Also check for when a URI is removed
  this.serverUriStorage.onDidRemove(this.urisRemoved, this, this.disposables);
-
+ this.jupyterServerProviderRegistry.onDidChangeProviders(this.handleProviderChanges, this, this.disposables);
  // Add in the URIs that we already know about
  this.buildListOfFinders();
+ this.handleProviderChanges().catch(noop);
  }
  private buildListOfFinders() {
  // Add in the URIs that we already know about
@@ -77,6 +85,62 @@ export class RemoteKernelFinderController implements IExtensionSyncActivationSer
  });
  this.buildListOfFinders();
  }
+ private mappedProviders = new WeakSet<JupyterServerProvider>();
+ private mappedServers = new Set<string>();
+ @swallowExceptions('Handle Jupyter Provider Changes')
+ private async handleProviderChanges() {
+ if (!this.features.features.enableProposedJupyterServerProviderApi) {
+ return;
+ }
+ const token = new CancellationTokenSource();
+ this.disposables.push(token);
+ await Promise.all(
+ this.jupyterServerProviderRegistry.providers.map(async (collection) => {
+ const serverProvider = collection.serverProvider;
+ if (!serverProvider || this.mappedProviders.has(serverProvider)) {
+ return;
+ }
+ this.mappedProviders.add(serverProvider);
+ if (serverProvider?.onDidChangeServers) {
+ serverProvider?.onDidChangeServers(
+ () => this.lookForServersInCollection(collection),
+ this,
+ this.disposables
+ );
+ }
+ await this.lookForServersInCollection(collection).catch(noop);
+ })
+ );
+ token.dispose();
+ }
+ @swallowExceptions('Check Servers in Jupyter Server Provider')
+ private async lookForServersInCollection(collection: JupyterServerCollection) {
+ const serverProvider = collection.serverProvider;
+ if (!serverProvider) {
+ return;
+ }
+ const token = new CancellationTokenSource();
+ try {
+ const servers = await serverProvider.getJupyterServers(token.token);
+ servers.forEach((server) => {
+ const serverId = `${collection.extensionId}#${collection.id}#${server.id}`;
+ if (this.mappedServers.has(serverId)) {
+ return;
+ }
+ this.mappedServers.add(serverId);
+ const info = {
+ extensionId: collection.extensionId,
+ handle: server.id,
+ id: collection.id
+ };
+ this.createRemoteKernelFinder(info, server.label);
+ });
+ } catch (ex) {
+ traceError(`Failed to get servers for Collection ${collection.id} in ${collection.extensionId}`, ex);
+ } finally {
+ token.dispose();
+ }
+ }
  @swallowExceptions('Failed to create a Remote Kernel Finder')
  private async validateAndCreateFinder(serverUri: IJupyterServerUriEntry) {
  const serverId = generateIdFromRemoteProvider(serverUri.provider);

src/notebooks/controllers/kernelSource/remoteNotebookKernelSourceSelector.ts

@@ -25,7 +25,7 @@ import { IKernelFinder, KernelConnectionMetadata, RemoteKernelConnectionMetadata
 import { IApplicationShell } from '../../../platform/common/application/types';
 import { InteractiveWindowView, JVSC_EXTENSION_ID, JupyterNotebookView } from '../../../platform/common/constants';
 import { disposeAllDisposables } from '../../../platform/common/helpers';
-import { IDisposable } from '../../../platform/common/types';
+import { IDisposable, IFeaturesManager } from '../../../platform/common/types';
 import { Common, DataScience } from '../../../platform/common/utils/localize';
 import {
  IMultiStepInput,
@@ -76,7 +76,9 @@ export class RemoteNotebookKernelSourceSelector implements IRemoteNotebookKernel
  @inject(IJupyterServerUriStorage) private readonly serverUriStorage: IJupyterServerUriStorage,
  @inject(JupyterServerSelector) private readonly serverSelector: JupyterServerSelector,
  @inject(JupyterConnection) private readonly jupyterConnection: JupyterConnection,
- @inject(IConnectionDisplayDataProvider) private readonly displayDataProvider: IConnectionDisplayDataProvider
+ @inject(IConnectionDisplayDataProvider) private readonly displayDataProvider: IConnectionDisplayDataProvider,
+ @inject(IFeaturesManager)
+ private readonly features: IFeaturesManager
  ) {}
  public async selectRemoteKernel(
  notebook: NotebookDocument,
@@ -135,6 +137,7 @@ export class RemoteNotebookKernelSourceSelector implements IRemoteNotebookKernel
  | QuickPickItem
  )[] = [];
 
+ const displayLastUsedTime = !this.features.features.enableProposedJupyterServerProviderApi;
  await Promise.all(
  servers
  .filter((s) => s.serverProviderHandle.id === provider.id)
@@ -145,15 +148,18 @@ export class RemoteNotebookKernelSourceSelector implements IRemoteNotebookKernel
  generateIdFromRemoteProvider(item.provider) ===
  generateIdFromRemoteProvider(server.serverProviderHandle)
  );
- if (token.isCancellationRequested || !lastUsedTime) {
+ if ((token.isCancellationRequested || !lastUsedTime) && displayLastUsedTime) {
  return;
  }
  quickPickServerItems.push({
  type: KernelFinderEntityQuickPickType.KernelFinder,
  kernelFinderInfo: server,
  idAndHandle: server.serverProviderHandle,
  label: server.displayName,
- detail: DataScience.jupyterSelectURIMRUDetail(new Date(lastUsedTime.time)),
+ detail:
+ displayLastUsedTime && lastUsedTime?.time
+ ? DataScience.jupyterSelectURIMRUDetail(new Date(lastUsedTime.time))
+ : undefined,
  buttons: provider.removeHandle
  ? [
  {

src/platform/common/featureManager.ts

@@ -45,7 +45,9 @@ const deprecatedFeatures: DeprecatedFeatureInfo[] = [
 export class FeatureManager implements IFeaturesManager {
  private _onDidChangeFeatures = new Emitter<void>();
  readonly onDidChangeFeatures = this._onDidChangeFeatures.event;
- private _features: IFeatureSet = {};
+ private _features: IFeatureSet = {
+ enableProposedJupyterServerProviderApi: false
+ };
  get features(): IFeatureSet {
  return this._features;
  }
@@ -72,8 +74,11 @@ export class FeatureManager implements IFeaturesManager {
  }
 
  private _updateFeatures() {
+ const enabled = this.workspace
+ .getConfiguration('jupyter')
+ .get<boolean>('enableProposedJupyterServerProviderApi', false);
  this.features = {
- kernelPickerType: 'Insiders'
+ enableProposedJupyterServerProviderApi: enabled === true
  };
  }
 

src/platform/common/types.ts

@@ -52,6 +52,7 @@ export interface IJupyterSettings {
  readonly experiments: IExperiments;
  readonly logging: ILoggingSettings;
  readonly allowUnauthorizedRemoteConnection: boolean;
+ readonly enableProposedJupyterServerProviderApi?: boolean;
  readonly jupyterInterruptTimeout: number;
  readonly jupyterLaunchTimeout: number;
  readonly jupyterLaunchRetries: number;
@@ -257,7 +258,9 @@ export type DeprecatedFeatureInfo = {
  setting?: DeprecatedSettingAndValue;
 };
 
-export interface IFeatureSet {}
+export interface IFeatureSet {
+ enableProposedJupyterServerProviderApi: boolean;
+}
 
 export const IFeaturesManager = Symbol('IFeaturesManager');