Do a one-off transfer of existing values for python.pythonPath setting to new Interpreter storage if in DeprecatePythonPath experiment (microsoft#11053)

* Added functionality * Added tests to interpreter path service * Added tests for activation manager * News entry * Fix bug * Correct activation manager tests * Add tests for the new API method * Update unit tests

Author: Kartik Raj

news/1 Enhancements/11052.md

@@ -0,0 +1 @@
+Do a one-off transfer of existing values for `python.pythonPath` setting to new Interpreter storage if in DeprecatePythonPath experiment.

src/client/activation/activationManager.ts

@@ -66,6 +66,12 @@ export class ExtensionActivationManager implements IExtensionActivationManager {
  return;
  }
  this.activatedWorkspaces.add(key);
+
+ if (this.experiments.inExperiment(DeprecatePythonPath.experiment)) {
+ await this.interpreterPathService.copyOldInterpreterStorageValuesToNew(resource);
+ }
+ this.experiments.sendTelemetryIfInExperiment(DeprecatePythonPath.control);
+
  // Get latest interpreter list in the background.
  this.interpreterService.getInterpreters(resource).ignoreErrors();
 

src/client/common/interpreterPathService.ts

@@ -9,6 +9,7 @@ import { ConfigurationChangeEvent, ConfigurationTarget, Event, EventEmitter, Uri
 import { IWorkspaceService } from './application/types';
 import { PythonSettings } from './configSettings';
 import { isTestExecution } from './constants';
+import { FileSystemPaths } from './platform/fs-paths';
 import {
  IDisposable,
  IDisposableRegistry,
@@ -21,6 +22,9 @@ import {
  Resource
 } from './types';
 
+export const workspaceKeysForWhichTheCopyIsDone_Key = 'workspaceKeysForWhichTheCopyIsDone_Key';
+export const workspaceFolderKeysForWhichTheCopyIsDone_Key = 'workspaceFolderKeysForWhichTheCopyIsDone_Key';
+export const isGlobalSettingCopiedKey = 'isGlobalSettingCopiedKey';
 export const defaultInterpreterPathSetting: keyof IPythonSettings = 'defaultInterpreterPath';
 const CI_PYTHON_PATH = getCIPythonPath();
 
@@ -32,13 +36,18 @@ export function getCIPythonPath(): string {
 }
 @injectable()
 export class InterpreterPathService implements IInterpreterPathService {
+ public get onDidChange(): Event<InterpreterConfigurationScope> {
+ return this._didChangeInterpreterEmitter.event;
+ }
  public _didChangeInterpreterEmitter = new EventEmitter<InterpreterConfigurationScope>();
+ private fileSystemPaths: FileSystemPaths;
  constructor(
  @inject(IPersistentStateFactory) private readonly persistentStateFactory: IPersistentStateFactory,
  @inject(IWorkspaceService) private readonly workspaceService: IWorkspaceService,
  @inject(IDisposableRegistry) disposables: IDisposable[]
  ) {
  disposables.push(this.workspaceService.onDidChangeConfiguration(this.onDidChangeConfiguration.bind(this)));
+ this.fileSystemPaths = FileSystemPaths.withDefaults();
  }
 
  public async onDidChangeConfiguration(event: ConfigurationChangeEvent) {
@@ -88,8 +97,11 @@ export class InterpreterPathService implements IInterpreterPathService {
  resource = PythonSettings.getSettingsUriAndTarget(resource, this.workspaceService).uri;
  if (configTarget === ConfigurationTarget.Global) {
  const pythonConfig = this.workspaceService.getConfiguration('python');
- await pythonConfig.update('defaultInterpreterPath', pythonPath, true);
- this._didChangeInterpreterEmitter.fire({ uri: undefined, configTarget });
+ const globalValue = pythonConfig.inspect<string>('defaultInterpreterPath')!.globalValue;
+ if (globalValue !== pythonPath) {
+ await pythonConfig.update('defaultInterpreterPath', pythonPath, true);
+ this._didChangeInterpreterEmitter.fire({ uri: undefined, configTarget });
+ }
  return;
  }
  if (!resource) {
@@ -100,12 +112,10 @@ export class InterpreterPathService implements IInterpreterPathService {
  settingKey,
  undefined
  );
- await persistentSetting.updateValue(pythonPath);
- this._didChangeInterpreterEmitter.fire({ uri: resource, configTarget });
- }
-
- public get onDidChange(): Event<InterpreterConfigurationScope> {
- return this._didChangeInterpreterEmitter.event;
+ if (persistentSetting.value !== pythonPath) {
+ await persistentSetting.updateValue(pythonPath);
+ this._didChangeInterpreterEmitter.fire({ uri: resource, configTarget });
+ }
  }
 
  public getSettingKey(
@@ -118,10 +128,74 @@ export class InterpreterPathService implements IInterpreterPathService {
  settingKey = `WORKSPACE_FOLDER_INTERPRETER_PATH_${folderKey}`;
  } else {
  settingKey = this.workspaceService.workspaceFile
- ? `WORKSPACE_INTERPRETER_PATH_${this.workspaceService.workspaceFile.fsPath}`
+ ? `WORKSPACE_INTERPRETER_PATH_${this.fileSystemPaths.normCase(
+ this.workspaceService.workspaceFile.fsPath
+ )}`
  : // Only a single folder is opened, use fsPath of the folder as key
  `WORKSPACE_FOLDER_INTERPRETER_PATH_${folderKey}`;
  }
  return settingKey;
  }
+
+ public async copyOldInterpreterStorageValuesToNew(resource: Resource): Promise<void> {
+ resource = PythonSettings.getSettingsUriAndTarget(resource, this.workspaceService).uri;
+ const oldSettings = this.workspaceService.getConfiguration('python', resource).inspect<string>('pythonPath')!;
+ await Promise.all([
+ this._copyWorkspaceFolderValueToNewStorage(resource, oldSettings.workspaceFolderValue),
+ this._copyWorkspaceValueToNewStorage(resource, oldSettings.workspaceValue),
+ this._moveGlobalSettingValueToNewStorage(oldSettings.globalValue)
+ ]);
+ }
+
+ public async _copyWorkspaceFolderValueToNewStorage(resource: Resource, value: string | undefined): Promise<void> {
+ // Copy workspace folder setting into the new storage if it hasn't been copied already
+ const workspaceFolderKey = this.workspaceService.getWorkspaceFolderIdentifier(resource);
+ const flaggedWorkspaceFolderKeysStorage = this.persistentStateFactory.createGlobalPersistentState<string[]>(
+ workspaceFolderKeysForWhichTheCopyIsDone_Key,
+ []
+ );
+ const flaggedWorkspaceFolderKeys = flaggedWorkspaceFolderKeysStorage.value;
+ const shouldUpdateWorkspaceFolderSetting = !flaggedWorkspaceFolderKeys.includes(workspaceFolderKey);
+ if (shouldUpdateWorkspaceFolderSetting) {
+ await this.update(resource, ConfigurationTarget.WorkspaceFolder, value);
+ await flaggedWorkspaceFolderKeysStorage.updateValue([workspaceFolderKey, ...flaggedWorkspaceFolderKeys]);
+ }
+ }
+
+ public async _copyWorkspaceValueToNewStorage(resource: Resource, value: string | undefined): Promise<void> {
+ // Copy workspace setting into the new storage if it hasn't been copied already
+ const workspaceKey = this.workspaceService.workspaceFile
+ ? this.fileSystemPaths.normCase(this.workspaceService.workspaceFile.fsPath)
+ : undefined;
+ if (!workspaceKey) {
+ return;
+ }
+ const flaggedWorkspaceKeysStorage = this.persistentStateFactory.createGlobalPersistentState<string[]>(
+ workspaceKeysForWhichTheCopyIsDone_Key,
+ []
+ );
+ const flaggedWorkspaceKeys = flaggedWorkspaceKeysStorage.value;
+ const shouldUpdateWorkspaceSetting = !flaggedWorkspaceKeys.includes(workspaceKey);
+ if (shouldUpdateWorkspaceSetting) {
+ await this.update(resource, ConfigurationTarget.Workspace, value);
+ await flaggedWorkspaceKeysStorage.updateValue([workspaceKey, ...flaggedWorkspaceKeys]);
+ }
+ }
+
+ public async _moveGlobalSettingValueToNewStorage(value: string | undefined) {
+ // Move global setting into the new storage if it hasn't been moved already
+ const isGlobalSettingCopiedStorage = this.persistentStateFactory.createGlobalPersistentState<boolean>(
+ isGlobalSettingCopiedKey,
+ false
+ );
+ const shouldUpdateGlobalSetting = !isGlobalSettingCopiedStorage.value;
+ if (shouldUpdateGlobalSetting) {
+ await this.update(undefined, ConfigurationTarget.Global, value);
+ // Make sure to delete the original setting after copying it
+ await this.workspaceService
+ .getConfiguration('python')
+ .update('pythonPath', undefined, ConfigurationTarget.Global);
+ await isGlobalSettingCopiedStorage.updateValue(true);
+ }
+ }
 }

src/client/common/types.ts

@@ -638,4 +638,5 @@ export interface IInterpreterPathService {
  get(resource: Resource): string;
  inspect(resource: Resource): InspectInterpreterSettingType;
  update(resource: Resource, configTarget: ConfigurationTarget, value: string | undefined): Promise<void>;
+ copyOldInterpreterStorageValuesToNew(resource: Uri | undefined): Promise<void>;
 }

src/client/interpreter/autoSelection/constants.ts

@@ -6,5 +6,5 @@
 export const unsafeInterpreterPromptKey = 'unsafeInterpreterPromptKey';
 export const unsafeInterpretersKey = 'unsafeInterpretersKey';
 export const safeInterpretersKey = 'safeInterpretersKey';
-export const flaggedWorkspacesKeysStorageKey = 'flaggedWorkspacesKeysStorageKey';
+export const flaggedWorkspacesKeysStorageKey = 'flaggedWorkspacesKeysInterpreterSecurityStorageKey';
 export const learnMoreOnInterpreterSecurityURI = 'https://aka.ms/AA7jfor';