Restore last connection date times (#14134)

src/api.internal.d.ts

@@ -62,13 +62,21 @@ declare module './api' {
  * If this is the only quick pick item in the list and this is true, then this item will be selected by default.
  */
  default?: boolean;
+ /**
+ * The Jupyter Server command associated with this quick pick item.
+ */
+ command?: JupyterServerCommand;
  })[]
  >
  | (QuickPickItem & {
  /**
  * If this is the only quick pick item in the list and this is true, then this item will be selected by default.
  */
  default?: boolean;
+ /**
+ * The Jupyter Server command associated with this quick pick item.
+ */
+ command?: JupyterServerCommand;
  })[];
  }
 }

src/api.unstable.d.ts

@@ -115,6 +115,9 @@ declare module './api' {
  */
  default?: boolean;
  })[];
+ /**
+ * @param item The original quick Pick returned by getQuickPickEntryItems will be passed into this method.
+ */
  handleQuickPick?(item: QuickPickItem, backEnabled: boolean): Promise<string | 'back' | undefined>;
  /**
  * Given the handle, returns the Jupyter Server information.

src/kernels/jupyter/connection/jupyterServerProviderRegistry.ts

@@ -99,7 +99,9 @@ class JupyterUriProviderAdaptor extends Disposables implements IJupyterUriProvid
  );
  }
  }
- async getQuickPickEntryItems(value?: string): Promise<(QuickPickItem & { default?: boolean | undefined })[]> {
+ async getQuickPickEntryItems(
+ value?: string
+ ): Promise<(QuickPickItem & { default?: boolean | undefined; command?: JupyterServerCommand })[]> {
  if (!this.provider.commandProvider) {
  throw new Error(`No Jupyter Server Command Provider for ${this.provider.extensionId}#${this.provider.id}`);
  }
@@ -116,8 +118,10 @@ class JupyterUriProviderAdaptor extends Disposables implements IJupyterUriProvid
  return items.map((c) => {
  return {
  label: c.title,
+ detail: c.detail,
  tooltip: c.tooltip,
- default: c.picked === true
+ default: c.picked === true,
+ command: c
  };
  });
  } catch (ex) {
@@ -130,14 +134,21 @@ class JupyterUriProviderAdaptor extends Disposables implements IJupyterUriProvid
  token.dispose();
  }
  }
- async handleQuickPick(item: QuickPickItem, _backEnabled: boolean): Promise<string | undefined> {
+ async handleQuickPick(
+ item: QuickPickItem & { command?: JupyterServerCommand },
+ _backEnabled: boolean
+ ): Promise<string | undefined> {
  if (!this.provider.commandProvider) {
  throw new Error(`No Jupyter Server Command Provider for ${this.provider.extensionId}#${this.provider.id}`);
  }
  const token = new CancellationTokenSource();
  try {
- const items = await this.provider.commandProvider.getCommands('', token.token);
- const command = items.find((c) => c.title === item.label) || this.commands.get(item.label);
+ let command: JupyterServerCommand | undefined =
+ 'command' in item ? (item.command as JupyterServerCommand) : undefined;
+ if (!command) {
+ const items = await this.provider.commandProvider.getCommands('', token.token);
+ command = items.find((c) => c.title === item.label) || this.commands.get(item.label);
+ }
  if (!command) {
  throw new Error(
  `Jupyter Server Command ${item.label} not found in Command Provider ${this.provider.extensionId}#${this.provider.id}`

src/kernels/jupyter/connection/jupyterUriProviderRegistration.ts

@@ -17,7 +17,7 @@ import {
 } from '../types';
 import { sendTelemetryEvent } from '../../../telemetry';
 import { traceError, traceVerbose } from '../../../platform/logging';
-import { IJupyterServerUri, IJupyterUriProvider } from '../../../api';
+import { IJupyterServerUri, IJupyterUriProvider, JupyterServerCommand } from '../../../api';
 import { Disposables } from '../../../platform/common/utils';
 import { IServiceContainer } from '../../../platform/ioc/types';
 import { IExtensionSyncActivationService } from '../../../platform/activation/types';
@@ -252,14 +252,15 @@ class JupyterUriProviderWrapper extends Disposables implements IInternalJupyterU
  };
  });
  }
- public async handleQuickPick(item: QuickPickItem, back: boolean): Promise<string | 'back' | undefined> {
+ public async handleQuickPick(
+ item: QuickPickItem & { original: QuickPickItem & { command?: JupyterServerCommand } },
+ back: boolean
+ ): Promise<string | 'back' | undefined> {
  if (!this.provider.handleQuickPick) {
  return;
  }
- // eslint-disable-next-line @typescript-eslint/no-explicit-any
- if ((item as any).original) {
- // eslint-disable-next-line @typescript-eslint/no-explicit-any
- return this.provider.handleQuickPick((item as any).original, back);
+ if ('original' in item && item.original) {
+ return this.provider.handleQuickPick(item.original, back);
  }
  return this.provider.handleQuickPick(item, back);
  }

src/notebooks/controllers/kernelSource/remoteNotebookKernelSourceSelector.ts

@@ -26,7 +26,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, IFeaturesManager } from '../../../platform/common/types';
+import { IDisposable } from '../../../platform/common/types';
 import { Common, DataScience } from '../../../platform/common/utils/localize';
 import {
  IMultiStepInput,
@@ -80,8 +80,6 @@ export class RemoteNotebookKernelSourceSelector implements IRemoteNotebookKernel
  @inject(JupyterServerSelector) private readonly serverSelector: JupyterServerSelector,
  @inject(JupyterConnection) private readonly jupyterConnection: JupyterConnection,
  @inject(IConnectionDisplayDataProvider) private readonly displayDataProvider: IConnectionDisplayDataProvider,
- @inject(IFeaturesManager)
- private readonly features: IFeaturesManager,
  @inject(IRemoteKernelFinderController)
  private readonly kernelFinderController: IRemoteKernelFinderController,
  @inject(IJupyterUriProviderRegistration)
@@ -144,42 +142,52 @@ export class RemoteNotebookKernelSourceSelector implements IRemoteNotebookKernel
  | QuickPickItem
  )[] = [];
 
- const displayLastUsedTime = !this.features.features.enableProposedJupyterServerProviderApi;
+ const serversAndTimes: { server: IRemoteKernelFinder; time?: number }[] = [];
  await Promise.all(
  servers
  .filter((s) => s.serverProviderHandle.id === provider.id)
  .map(async (server) => {
  // remote server
- const lastUsedTime = displayLastUsedTime
- ? (await this.serverUriStorage.getAll()).find(
- (item) =>
- generateIdFromRemoteProvider(item.provider) ===
- generateIdFromRemoteProvider(server.serverProviderHandle)
- )
- : undefined;
- if ((token.isCancellationRequested || !lastUsedTime) && displayLastUsedTime) {
+ const lastUsedTime = (await this.serverUriStorage.getAll()).find(
+ (item) =>
+ generateIdFromRemoteProvider(item.provider) ===
+ generateIdFromRemoteProvider(server.serverProviderHandle)
+ );
+ if (token.isCancellationRequested) {
  return;
  }
- quickPickServerItems.push({
- type: KernelFinderEntityQuickPickType.KernelFinder,
- kernelFinderInfo: server,
- idAndHandle: server.serverProviderHandle,
- label: server.displayName,
- detail:
- displayLastUsedTime && lastUsedTime?.time
- ? DataScience.jupyterSelectURIMRUDetail(new Date(lastUsedTime.time))
- : undefined,
- buttons: provider.removeHandle
- ? [
- {
- iconPath: new ThemeIcon('trash'),
- tooltip: DataScience.removeRemoteJupyterServerEntryInQuickPick
- }
- ]
- : []
- });
+ serversAndTimes.push({ server, time: lastUsedTime?.time });
  })
  );
+ serversAndTimes.sort((a, b) => {
+ if (!a.time && !b.time) {
+ return a.server.displayName.localeCompare(b.server.displayName);
+ }
+ if (!a.time && b.time) {
+ return 1;
+ }
+ if (a.time && !b.time) {
+ return -1;
+ }
+ return (a.time || 0) > (b.time || 0) ? -1 : 1;
+ });
+ serversAndTimes.forEach(({ server, time }) => {
+ quickPickServerItems.push({
+ type: KernelFinderEntityQuickPickType.KernelFinder,
+ kernelFinderInfo: server,
+ idAndHandle: server.serverProviderHandle,
+ label: server.displayName,
+ detail: time ? DataScience.jupyterSelectURIMRUDetail(new Date(time)) : undefined,
+ buttons: provider.removeHandle
+ ? [
+ {
+ iconPath: new ThemeIcon('close'),
+ tooltip: DataScience.removeRemoteJupyterServerEntryInQuickPick
+ }
+ ]
+ : []
+ });
+ });
 
  if (provider.getQuickPickEntryItems && provider.handleQuickPick) {
  if (quickPickServerItems.length > 0) {

src/platform/common/featureManager.ts

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

src/platform/common/types.ts

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

src/standalone/userJupyterServer/userServerUriProvider.unit.test.ts

@@ -39,10 +39,9 @@ import { disposeAllDisposables } from '../../platform/common/helpers';
 import { JVSC_EXTENSION_ID, Settings, UserJupyterServerPickerProviderId } from '../../platform/common/constants';
 import { assert } from 'chai';
 import { generateIdFromRemoteProvider } from '../../kernels/jupyter/jupyterUtils';
-import { Common, DataScience } from '../../platform/common/utils/localize';
 import { IJupyterPasswordConnectInfo, JupyterPasswordConnect } from './jupyterPasswordConnect';
 import { IFileSystem } from '../../platform/common/platform/types';
-import { JupyterServerCollection } from '../../api';
+import { IJupyterServerUri, JupyterServerCollection } from '../../api';
 
 /* eslint-disable @typescript-eslint/no-explicit-any, , */
 suite('User Uri Provider', () => {
@@ -507,13 +506,6 @@ suite('User Uri Provider', () => {
  if (server instanceof InputFlowAction || server === 'back') {
  throw new Error('Server not returned');
  }
- verify(
- applicationShell.showWarningMessage(
- DataScience.insecureSessionMessage,
- Common.bannerLabelYes,
- Common.bannerLabelNo
- )
- ).never();
  assert.isFalse(secureConnectionStub.called);
  const servers = await provider.getJupyterServers(token);
  assert.isAtLeast(servers.length, 3, '2 migrated urls and one entered');
@@ -529,4 +521,102 @@ suite('User Uri Provider', () => {
  assert.strictEqual(serversInNewStorage.length, 3);
  assert.strictEqual(serversInNewStorage2.length, 3);
  });
+ test('When pre-populating with https url and without password auth, the next step should be the displayName & back from displayName should get out of this UI flow (without displaying the Url picker)', async () => {
+ await testMigration();
+ getPasswordConnectionInfoStub.restore();
+ getPasswordConnectionInfoStub.reset();
+ const urlInputStub = sinon.stub(UserJupyterServerUriInput.prototype, 'getUrlFromUser');
+ urlInputStub.resolves();
+ sinon.stub(JupyterPasswordConnect.prototype, 'getPasswordConnectionInfo').resolves({ requiresPassword: false });
+ const secureConnectionStub = sinon.stub(SecureConnectionValidator.prototype, 'promptToUseInsecureConnections');
+ secureConnectionStub.resolves(false);
+ const displayNameStub = sinon.stub(UserJupyterServerDisplayName.prototype, 'getDisplayName');
+ displayNameStub.rejects(InputFlowAction.back);
+
+ const [cmd] = await provider.getCommands('https://localhost:3333', token);
+ const server = await provider.handleCommand(cmd, token);
+
+ assert.strictEqual(server, 'back');
+ assert.strictEqual(displayNameStub.callCount, 1);
+ assert.strictEqual(urlInputStub.callCount, 0); // Since a url was provided we should never prompt for this, even when clicking back in display name.
+ });
+ test('When pre-populating with https url and without password auth, the next step should be the displayName & cancel from displayName should get out of this UI flow (without displaying the Url picker)', async () => {
+ await testMigration();
+ getPasswordConnectionInfoStub.restore();
+ getPasswordConnectionInfoStub.reset();
+ const urlInputStub = sinon.stub(UserJupyterServerUriInput.prototype, 'getUrlFromUser');
+ urlInputStub.resolves();
+ sinon.stub(JupyterPasswordConnect.prototype, 'getPasswordConnectionInfo').resolves({ requiresPassword: false });
+ const secureConnectionStub = sinon.stub(SecureConnectionValidator.prototype, 'promptToUseInsecureConnections');
+ secureConnectionStub.resolves(false);
+ const displayNameStub = sinon.stub(UserJupyterServerDisplayName.prototype, 'getDisplayName');
+ displayNameStub.rejects(InputFlowAction.cancel);
+
+ const [cmd] = await provider.getCommands('https://localhost:3333', token);
+ const server = await provider.handleCommand(cmd, token);
+
+ assert.isUndefined(server);
+ assert.strictEqual(displayNameStub.callCount, 1);
+ assert.strictEqual(urlInputStub.callCount, 0); // Since a url was provided we should never prompt for this, even when clicking back in display name.
+ });
+ test('When pre-populating with https url and without password auth, and the server is invalid the next step should be the url display', async () => {
+ await testMigration();
+ getPasswordConnectionInfoStub.restore();
+ getPasswordConnectionInfoStub.reset();
+ const urlInputStub = sinon.stub(UserJupyterServerUriInput.prototype, 'getUrlFromUser');
+ let getUrlFromUserCallCount = 0;
+ urlInputStub.callsFake(async (_initialValue, errorMessage, _) => {
+ switch (getUrlFromUserCallCount++) {
+ case 0: {
+ // Originally we should be called with an error message.
+ assert.isOk(errorMessage, 'Error Message should not be empty');
+ return {
+ jupyterServerUri: {
+ baseUrl: 'https://localhost:9999/',
+ displayName: 'ABCD',
+ token: ''
+ },
+ url: 'https://localhost:9999/?token=ABCD'
+ };
+ }
+ case 1: {
+ // There should be no error message displayed,
+ // We should have come here from the back button of the display name.
+ assert.isEmpty(errorMessage, 'Error Message should be empty');
+ // Lets get out of here.
+ throw InputFlowAction.back;
+ }
+ default:
+ throw new Error('Method should not be called again');
+ }
+ });
+ sinon.stub(JupyterPasswordConnect.prototype, 'getPasswordConnectionInfo').resolves({ requiresPassword: false });
+ const displayNameStub = sinon.stub(UserJupyterServerDisplayName.prototype, 'getDisplayName');
+ displayNameStub.rejects(InputFlowAction.back);
+ when(jupyterConnection.validateRemoteUri(anything(), anything(), true)).thenCall(
+ (_, uri: IJupyterServerUri) => {
+ if (!uri) {
+ return;
+ }
+ if (uri.baseUrl.startsWith('https://localhost:9999')) {
+ return;
+ }
+ throw new Error('Remote Connection Failure');
+ }
+ );
+
+ // Steps
+ // 1. First provide a url https://localhost:3333 to a server that is non-existent
+ // 2. Verify the error message is displayed and user is prompted to enter the Url again.
+ // 3. Next verify the user is prompted for a display name
+ // 4. When we click back button on display name ui, ensure we go back to Url ui.
+ // 5. Hitting back button on Url ui should exit out completely
+
+ const [cmd] = await provider.getCommands('https://localhost:3333', token);
+ const server = await provider.handleCommand(cmd, token);
+
+ assert.strictEqual(server, 'back');
+ assert.strictEqual(displayNameStub.callCount, 1);
+ assert.strictEqual(urlInputStub.callCount, 2); // Displayed twice, first time for error message, second time when hit back button from display UI.
+ });
 });