fix: Use connected connection model options VSCODE-234 (#255)

Author: Anemy

package-lock.json

@@ -19,9 +19,29 @@ import playgroundSearchTemplate from '../templates/playgroundSearchTemplate';
 import playgroundTemplate from '../templates/playgroundTemplate';
 import { StatusView } from '../views';
 import TelemetryService from '../telemetry/telemetryService';
+import { ConnectionOptions } from '../types/connectionOptionsType';
 
 const log = createLogger('playground controller');
 
+const getSSLFilePathsFromConnectionModel = (
+  connectionModelDriverOptions: ConnectionOptions
+): {
+  sslCA?: string | string[];
+  sslCert?: string | string[];
+  sslKey?: string | string[];
+} => {
+  const sslFilePaths = {};
+  ['sslCA', 'sslCert', 'sslKey'].forEach((key) => {
+    if (connectionModelDriverOptions[key]) {
+      sslFilePaths[key] = connectionModelDriverOptions[key] as (
+        string | string[]
+      );
+    }
+  });
+
+  return sslFilePaths;
+};
+
 /**
  * This controller manages playground.
  */
@@ -36,7 +56,6 @@ export default class PlaygroundController {
   _partialExecutionCodeLensProvider: PartialExecutionCodeLensProvider;
   _outputChannel: OutputChannel;
   _connectionString?: string;
-  _connectionOptions?: EJSON.SerializableTypes;
   _selectedText?: string;
   _codeToEvaluate = '';
   _isPartialRun: boolean;
@@ -135,11 +154,11 @@ export default class PlaygroundController {
       selectedText.length > 0 &&
       selectedText.length >= lastSelectedLine.length
     ) {
-      this._partialExecutionCodeLensProvider?.refresh(
+      this._partialExecutionCodeLensProvider.refresh(
         new vscode.Range(firstLine, 0, firstLine, 0)
       );
     } else {
-      this._partialExecutionCodeLensProvider?.refresh();
+      this._partialExecutionCodeLensProvider.refresh();
     }
   }
 
@@ -148,26 +167,40 @@ export default class PlaygroundController {
   }
 
   async _connectToServiceProvider(): Promise<void> {
-    const model = this._connectionController
-      .getActiveConnectionModel()
-      ?.getAttributes({ derived: true });
-
-    this._connectionString = undefined;
-    this._connectionOptions = undefined;
-
     await this._languageServerController.disconnectFromServiceProvider();
 
-    if (model && model.driverUrlWithSsh) {
-      this._connectionString = model.driverUrlWithSsh;
-      this._connectionOptions = model.driverOptions ? model.driverOptions : {};
+    const dataService = this._connectionController.getActiveDataService();
+    const connectionId = this._connectionController.getActiveConnectionId();
+    const connectionModel = this._connectionController
+      .getActiveConnectionModel();
+    if (!dataService || !connectionId || !connectionModel) {
+      this._activeConnectionCodeLensProvider.refresh();
 
-      await this._languageServerController.connectToServiceProvider({
-        connectionString: this._connectionString,
-        connectionOptions: this._connectionOptions
-      });
+      return;
     }
 
-    this._activeConnectionCodeLensProvider?.refresh();
+    const connectionDetails = dataService.getConnectionOptions();
+    const connectionString = connectionDetails.url;
+    // We pass file paths to the language server since it doesn't
+    // handle being passsed buffers well.
+    // With driver version 4.0 we should be able to remove any use
+    // of buffers and just pass file paths.
+    const sslOptionsFilePaths = getSSLFilePathsFromConnectionModel(
+      connectionModel.getAttributes({ derived: true }).driverOptions
+    );
+
+    const connectionOptions: ConnectionOptions = {
+      ...connectionDetails.options,
+      ...sslOptionsFilePaths
+    };
+
+    await this._languageServerController.connectToServiceProvider({
+      connectionId,
+      connectionString,
+      connectionOptions
+    });
+
+    this._activeConnectionCodeLensProvider.refresh();
   }
 
   async _createPlaygroundFileWithContent(
@@ -241,12 +274,21 @@ export default class PlaygroundController {
   }
 
   async _evaluate(codeToEvaluate: string): Promise<ShellExecuteAllResult> {
+    const connectionId = this._connectionController.getActiveConnectionId();
+
+    if (!connectionId) {
+      return Promise.reject(
+        new Error('Please connect to a database before running a playground.')
+      );
+    }
+
     this._statusView.showMessage('Getting results...');
 
     // Send a request to the language server to execute scripts from a playground.
-    const result: ShellExecuteAllResult = await this._languageServerController.executeAll(
-      codeToEvaluate
-    );
+    const result: ShellExecuteAllResult = await this._languageServerController.executeAll({
+      codeToEvaluate,
+      connectionId
+    });
 
     this._statusView.hideMessage();
     this._telemetryService.trackPlaygroundCodeExecuted(
@@ -267,7 +309,7 @@ export default class PlaygroundController {
   }
 
   _evaluateWithCancelModal(): Promise<ShellExecuteAllResult> {
-    if (!this._connectionString) {
+    if (!this._connectionController.isCurrentlyConnected()) {
       return Promise.reject(
         new Error('Please connect to a database before running a playground.')
       );
@@ -372,7 +414,7 @@ export default class PlaygroundController {
       .getConfiguration('mdb')
       .get('confirmRunAll');
 
-    if (!this._connectionString) {
+    if (!this._connectionController.isCurrentlyConnected()) {
       vscode.window.showErrorMessage(
         'Please connect to a database before running a playground.'
       );

src/editors/playgroundController.ts

@@ -1,6 +1,5 @@
 import * as vscode from 'vscode';
 import * as path from 'path';
-import { EJSON } from 'bson';
 import {
   LanguageClient,
   LanguageClientOptions,
@@ -15,6 +14,7 @@ import { createLogger } from '../logging';
 import { PlaygroundExecuteParameters } from '../types/playgroundType';
 import { ServerCommands } from './serverCommands';
 import type { ShellExecuteAllResult } from '../types/playgroundType';
+import { ConnectionOptions } from '../types/connectionOptionsType';
 
 const log = createLogger('LanguageServerController');
 let socket: WebSocket | null;
@@ -123,11 +123,11 @@ export default class LanguageServerController {
       this._context.extensionPath
     );
 
-    this._client.onNotification('showInformationMessage', (messsage) => {
+    this._client.onNotification(ServerCommands.SHOW_INFO_MESSAGE, (messsage) => {
       vscode.window.showInformationMessage(messsage);
     });
 
-    this._client.onNotification('showErrorMessage', (messsage) => {
+    this._client.onNotification(ServerCommands.SHOW_ERROR_MESSAGE, (messsage) => {
       vscode.window.showErrorMessage(messsage);
     });
   }
@@ -141,7 +141,9 @@ export default class LanguageServerController {
     this._client.stop();
   }
 
-  async executeAll(codeToEvaluate: string): Promise<ShellExecuteAllResult> {
+  async executeAll(
+    playgroundExecuteParameters: PlaygroundExecuteParameters
+  ): Promise<ShellExecuteAllResult> {
     this._isExecutingInProgress = true;
 
     await this._client.onReady();
@@ -154,9 +156,7 @@ export default class LanguageServerController {
     // and return results to the playground controller when ready
     const result: ShellExecuteAllResult = await this._client.sendRequest(
       ServerCommands.EXECUTE_ALL_FROM_PLAYGROUND,
-      {
-        codeToEvaluate
-      } as PlaygroundExecuteParameters,
+      playgroundExecuteParameters,
       this._source.token
     );
 
@@ -166,8 +166,9 @@ export default class LanguageServerController {
   }
 
   async connectToServiceProvider(params: {
-    connectionString?: string;
-    connectionOptions?: EJSON.SerializableTypes;
+    connectionId: string,
+    connectionString: string;
+    connectionOptions: ConnectionOptions
   }): Promise<void> {
     await this._client.onReady();
     await this._client.sendRequest(

src/language/languageServerController.ts

@@ -20,6 +20,7 @@ export type ShellCompletionItem = {
 
 export default class MongoDBService {
   _connection: Connection;
+  _connectionId?: string;
   _connectionString?: string;
   _connectionOptions?: ConnectionOptions;
   _cachedDatabases: CompletionItem[] | [] = [];
@@ -92,16 +93,18 @@ export default class MongoDBService {
   }
 
   async connectToServiceProvider(params: {
-    connectionString?: string;
-    connectionOptions?: ConnectionOptions;
+    connectionId: string;
+    connectionString: string;
+    connectionOptions: ConnectionOptions;
   }): Promise<boolean> {
     this._clearCurrentSessionConnection();
     this._clearCurrentSessionFields();
     this._clearCurrentSessionDatabases();
     this._clearCurrentSessionCollections();
 
+    this._connectionId = params.connectionId;
     this._connectionString = params.connectionString;
-    this._connectionOptions = params.connectionOptions || {};
+    this._connectionOptions = params.connectionOptions;
 
     if (!this._connectionString) {
       return Promise.resolve(false);
@@ -153,6 +156,15 @@ export default class MongoDBService {
         return resolve(undefined);
       }
 
+      if (this._connectionId !== executionParameters.connectionId) {
+        this._connection.sendNotification(
+          ServerCommands.SHOW_ERROR_MESSAGE,
+          'The playground\'s active connection does not match the extension\'s active connection. Please reconnect and try again.'
+        );
+
+        return resolve(undefined);
+      }
+
       try {
         // Use Node worker threads to run a playground to be able to cancel infinite loops.
         //
@@ -192,7 +204,10 @@ export default class MongoDBService {
             this._connection.console.log(
               `MONGOSH execute all error: ${util.inspect(error)}`
             );
-            this._connection.sendNotification('showErrorMessage', printableError.message);
+            this._connection.sendNotification(
+              ServerCommands.SHOW_ERROR_MESSAGE,
+              printableError.message
+            );
           }
 
           worker.terminate().then(() => {
@@ -204,7 +219,7 @@ export default class MongoDBService {
         token.onCancellationRequested(async () => {
           this._connection.console.log('PLAYGROUND cancellation requested');
           this._connection.sendNotification(
-            'showInformationMessage',
+            ServerCommands.SHOW_INFO_MESSAGE,
             'The running playground operation was canceled.'
           );
 

src/language/mongoDBService.ts

@@ -6,7 +6,9 @@ export enum ServerCommands {
   GET_FIELDS_FROM_SCHEMA = 'GET_FIELDS_FROM_SCHEMA',
   GET_LIST_DATABASES = 'GET_LIST_DATABASES',
   GET_LIST_COLLECTIONS = 'GET_LIST_COLLECTIONS',
-  SET_EXTENSION_PATH = 'SET_EXTENSION_PATH'
+  SET_EXTENSION_PATH = 'SET_EXTENSION_PATH',
+  SHOW_ERROR_MESSAGE = 'SHOW_ERROR_MESSAGE',
+  SHOW_INFO_MESSAGE = 'SHOW_INFO_MESSAGE'
 }
 
 export type PlaygroundRunParameters = {