SQL Operations Studio Public Preview 1 (0.23) release source code

extensions/mssql/client/src/controllers/mainController.ts

@@ -0,0 +1,168 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+'use strict';
+import vscode = require('vscode');
+import data = require('data');
+import { Constants } from '../models/constants';
+import { Serialization } from '../serialize/serialization';
+import { AzureResourceProvider } from '../resourceProvider/resourceProvider';
+import { CredentialStore } from '../credentialstore/credentialstore';
+import {IExtensionConstants, Telemetry, SharedConstants, SqlToolsServiceClient, VscodeWrapper, Utils, PlatformInformation} from 'extensions-modules';
+import { LanguageClient } from 'dataprotocol-client';
+
+/**
+ * The main controller class that initializes the extension
+ */
+export default class MainController implements vscode.Disposable {
+    private _context: vscode.ExtensionContext;
+    private _vscodeWrapper: VscodeWrapper;
+    private _initialized: boolean = false;
+    private _serialization: Serialization;
+    private _credentialStore: CredentialStore;
+    private static _extensionConstants: IExtensionConstants = new Constants();
+    private _client: SqlToolsServiceClient;
+    /**
+     * The main controller constructor
+     * @constructor
+     */
+    constructor(context: vscode.ExtensionContext,
+                vscodeWrapper?: VscodeWrapper) {
+        this._context = context;
+        this._vscodeWrapper = vscodeWrapper || new VscodeWrapper(MainController._extensionConstants);
+        SqlToolsServiceClient.constants = MainController._extensionConstants;
+        this._client = SqlToolsServiceClient.instance;
+        this._credentialStore = new CredentialStore(this._client);
+        this._serialization = new Serialization(this._client);
+    }
+
+    /**
+     * Disposes the controller
+     */
+    dispose(): void {
+        this.deactivate();
+    }
+
+    /**
+     * Deactivates the extension
+     */
+    public deactivate(): void {
+        Utils.logDebug(SharedConstants.extensionDeactivated, MainController._extensionConstants.extensionConfigSectionName);
+    }
+
+    /**
+     * Initializes the extension
+     */
+    public activate():  Promise<boolean> {
+        return this.initialize();
+    }
+
+    /**
+     * Returns a flag indicating if the extension is initialized
+     */
+    public isInitialized(): boolean {
+        return this._initialized;
+    }
+
+    private createClient( executableFiles: string[]):  Promise<LanguageClient> {
+         return PlatformInformation.getCurrent(SqlToolsServiceClient.constants.getRuntimeId, SqlToolsServiceClient.constants.extensionName).then( platformInfo => {
+            return SqlToolsServiceClient.instance.createClient(this._context, platformInfo.runtimeId, undefined, executableFiles);
+         });
+    }
+
+    private createCredentialClient(): Promise<LanguageClient> {
+        return this.createClient(['MicrosoftSqlToolsCredentials.exe', 'MicrosoftSqlToolsCredentials']);
+    }
+
+    private createSerializationClient(): Promise<LanguageClient> {
+        return this.createClient(['MicrosoftSqlToolsSerialization.exe', 'MicrosoftSqlToolsSerialization']);
+    }
+
+    private createResourceProviderClient(): Promise<LanguageClient> {
+        return this.createClient(['SqlToolsResourceProviderService.exe', 'SqlToolsResourceProviderService']);
+    }
+
+    /**
+     * Initializes the extension
+     */
+    public initialize(): Promise<boolean> {
+        const self = this;
+
+        // initialize language service client
+        return new Promise<boolean>( (resolve, reject) => {
+                const self = this;
+                SqlToolsServiceClient.instance.initialize(self._context).then(serverResult => {
+
+                    // Initialize telemetry
+                    Telemetry.initialize(self._context, new Constants());
+
+                    // telemetry for activation
+                    Telemetry.sendTelemetryEvent('ExtensionActivated', {},
+                        { serviceInstalled: serverResult.installedBeforeInitializing ? 1 : 0 }
+                    );
+
+                    /*
+                    self.createSerializationClient().then(serializationClient => {
+                        let serialization = new Serialization(self._client, serializationClient);
+                        // Serialization
+                        let serializationProvider: data.SerializationProvider = {
+                            handle: 0,
+                            saveAs(saveFormat: string, savePath: string, results: string, appendToFile: boolean): Thenable<data.SaveResultRequestResult> {
+                                return self._serialization.saveAs(saveFormat, savePath, results, appendToFile);
+                            }
+                        };
+                        data.serialization.registerProvider(serializationProvider);
+                    }, error => {
+                        Utils.logDebug('Cannot find Serialization executables. error: ' + error , MainController._extensionConstants.extensionConfigSectionName);
+                    });
+
+                    self.createResourceProviderClient().then(rpClient => {
+                        let resourceProvider = new AzureResourceProvider(self._client, rpClient);
+                        data.resources.registerResourceProvider({
+                            displayName: 'Azure SQL Resource Provider', // TODO Localize
+                            id: 'Microsoft.Azure.SQL.ResourceProvider',
+                            settings: {
+
+                            }
+                        }, resourceProvider);
+                        Utils.logDebug('resourceProvider registered', MainController._extensionConstants.extensionConfigSectionName);
+                    }, error => {
+                        Utils.logDebug('Cannot find ResourceProvider executables. error: ' + error , MainController._extensionConstants.extensionConfigSectionName);
+                    });
+                    */
+
+                    self.createCredentialClient().then(credentialClient => {
+
+                        self._credentialStore.languageClient = credentialClient;
+                        let credentialProvider: data.CredentialProvider = {
+                            handle: 0,
+                            saveCredential(credentialId: string, password: string): Thenable<boolean> {
+                                return self._credentialStore.saveCredential(credentialId, password);
+                            },
+                            readCredential(credentialId: string): Thenable<data.Credential> {
+                                return self._credentialStore.readCredential(credentialId);
+                            },
+                            deleteCredential(credentialId: string): Thenable<boolean> {
+                                return self._credentialStore.deleteCredential(credentialId);
+                            }
+                        };
+                        data.credentials.registerProvider(credentialProvider);
+                        Utils.logDebug('credentialProvider registered', MainController._extensionConstants.extensionConfigSectionName);
+                     }, error => {
+                         Utils.logDebug('Cannot find credentials executables. error: ' + error , MainController._extensionConstants.extensionConfigSectionName);
+                     });
+
+
+
+                    Utils.logDebug(SharedConstants.extensionActivated, MainController._extensionConstants.extensionConfigSectionName);
+                    self._initialized = true;
+                    resolve(true);
+                }).catch(err => {
+                    Telemetry.sendTelemetryEventForException(err, 'initialize', MainController._extensionConstants.extensionConfigSectionName);
+                    reject(err);
+                });
+        });
+    }
+}

extensions/mssql/client/src/credentialstore/credentialstore.ts

@@ -0,0 +1,73 @@
+/*---------------------------------------------------------------------------------------------
+*  Copyright (c) Microsoft Corporation. All rights reserved.
+*  Licensed under the Source EULA. See License.txt in the project root for license information.
+*--------------------------------------------------------------------------------------------*/
+'use strict';
+
+import * as Contracts from '../models/contracts';
+import { ICredentialStore } from './icredentialstore';
+import { SqlToolsServiceClient, Utils } from 'extensions-modules';
+import { LanguageClient } from 'dataprotocol-client';
+
+/**
+ * Implements a credential storage for Windows, Mac (darwin), or Linux.
+ *
+ * Allows a single credential to be stored per service (that is, one username per service);
+ */
+export class CredentialStore implements ICredentialStore {
+
+    public languageClient: LanguageClient;
+
+    constructor(private _client?: SqlToolsServiceClient) {
+        if (!this._client) {
+            this._client = SqlToolsServiceClient.instance;
+        }
+    }
+
+    /**
+     * Gets a credential saved in the credential store
+     *
+     * @param {string} credentialId the ID uniquely identifying this credential
+     * @returns {Promise<Credential>} Promise that resolved to the credential, or undefined if not found
+     */
+    public readCredential(credentialId: string): Promise<Contracts.Credential> {
+        Utils.logDebug(this.languageClient, 'MainController._extensionConstants');
+        let self = this;
+        let cred: Contracts.Credential = new Contracts.Credential();
+        cred.credentialId = credentialId;
+        return new Promise<Contracts.Credential>( (resolve, reject) => {
+            self._client
+            .sendRequest(Contracts.ReadCredentialRequest.type, cred, this.languageClient)
+            .then(returnedCred => {
+                resolve(<Contracts.Credential>returnedCred);
+            }, err => reject(err));
+        });
+    }
+
+    public saveCredential(credentialId: string, password: any): Promise<boolean> {
+        let self = this;
+        let cred: Contracts.Credential = new Contracts.Credential();
+        cred.credentialId = credentialId;
+        cred.password = password;
+        return new Promise<boolean>( (resolve, reject) => {
+            self._client
+            .sendRequest(Contracts.SaveCredentialRequest.type, cred, this.languageClient)
+            .then(status => {
+                resolve(<boolean>status);
+            }, err => reject(err));
+        });
+    }
+
+    public deleteCredential(credentialId: string): Promise<boolean> {
+        let self = this;
+        let cred: Contracts.Credential = new Contracts.Credential();
+        cred.credentialId = credentialId;
+        return new Promise<boolean>( (resolve, reject) => {
+            self._client
+            .sendRequest(Contracts.DeleteCredentialRequest.type, cred, this.languageClient)
+            .then(status => {
+                resolve(<boolean>status);
+            }, err => reject(err));
+        });
+    }
+}

extensions/mssql/client/src/credentialstore/icredentialstore.ts

@@ -0,0 +1,23 @@
+/*---------------------------------------------------------------------------------------------
+*  Copyright (c) Microsoft Corporation. All rights reserved.
+*  Licensed under the Source EULA. See License.txt in the project root for license information.
+*--------------------------------------------------------------------------------------------*/
+'use strict';
+
+
+// This code is originally from https://github.com/microsoft/vsts-vscode
+// License: https://github.com/Microsoft/vsts-vscode/blob/master/LICENSE.txt
+
+import { Credential } from '../models/contracts';
+
+/**
+ * A credential store that securely stores sensitive information in a platform-specific manner
+ *
+ * @export
+ * @interface ICredentialStore
+ */
+export interface ICredentialStore {
+    readCredential(credentialId: string): Promise<Credential>;
+    saveCredential(credentialId: string, password: any): Promise<boolean>;
+    deleteCredential(credentialId: string): Promise<boolean>;
+}

extensions/mssql/client/src/models/constants.ts

@@ -0,0 +1,317 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import {IExtensionConstants} from 'extensions-modules/lib/models/contracts/contracts';
+import {Runtime, LinuxDistribution} from 'extensions-modules/lib/models/platform';
+
+// constants
+export class Constants implements IExtensionConstants {
+    public readonly languageId = 'sql';
+    public readonly extensionName = 'mssql';
+    public readonly extensionConfigSectionName = 'mssql';
+    public readonly connectionApplicationName = 'vscode-mssql';
+    public readonly outputChannelName = 'MSSQL';
+    public readonly connectionConfigFilename = 'settings.json';
+    public readonly connectionsArrayName = 'mssql.connections';
+    public readonly cmdRunQuery = 'extension.runQuery';
+    public readonly cmdCancelQuery = 'extension.cancelQuery';
+    public readonly cmdConnect = 'extension.connect';
+    public readonly cmdDisconnect = 'extension.disconnect';
+    public readonly cmdChooseDatabase = 'extension.chooseDatabase';
+    public readonly cmdShowReleaseNotes = 'extension.showReleaseNotes';
+    public readonly cmdShowGettingStarted = 'extension.showGettingStarted';
+    public readonly cmdNewQuery = 'extension.newQuery';
+    public readonly cmdManageConnectionProfiles = 'extension.manageProfiles';
+    public readonly sqlDbPrefix = '.database.windows.net';
+    public readonly defaultConnectionTimeout = 15;
+    public readonly azureSqlDbConnectionTimeout = 30;
+    public readonly azureDatabase = 'Azure';
+    public readonly defaultPortNumber = 1433;
+    public readonly sqlAuthentication = 'SqlLogin';
+    public readonly defaultDatabase = 'master';
+    public readonly errorPasswordExpired = 18487;
+    public readonly errorPasswordNeedsReset = 18488;
+    public readonly maxDisplayedStatusTextLength = 50;
+    public readonly outputContentTypeRoot = 'root';
+    public readonly outputContentTypeMessages = 'messages';
+    public readonly outputContentTypeResultsetMeta = 'resultsetsMeta';
+    public readonly outputContentTypeColumns = 'columns';
+    public readonly outputContentTypeRows = 'rows';
+    public readonly outputContentTypeConfig = 'config';
+    public readonly outputContentTypeSaveResults = 'saveResults';
+    public readonly outputContentTypeOpenLink = 'openLink';
+    public readonly outputContentTypeCopy = 'copyResults';
+    public readonly outputContentTypeEditorSelection = 'setEditorSelection';
+    public readonly outputContentTypeShowError = 'showError';
+    public readonly outputContentTypeShowWarning = 'showWarning';
+    public readonly outputServiceLocalhost = 'http://localhost:';
+    public readonly msgContentProviderSqlOutputHtml = 'dist/html/sqlOutput.ejs';
+    public readonly contentProviderMinFile = 'dist/js/app.min.js';
+    public readonly configLogDebugInfo = 'logDebugInfo';
+    public readonly providerId = 'MSSQL';
+    public readonly installFolderName = 'sqltoolsservice';
+    public readonly telemetryExtensionName = 'carbon-mssql';
+
+    // localizable strings
+    public readonly configMyConnectionsNoServerName = 'Missing server name in user preferences connection: ';
+    public readonly msgLocalWebserviceStaticContent = 'LocalWebService: added static html content path: ';
+    public readonly msgLocalWebserviceStarted = 'LocalWebService listening on port ';
+    public readonly msgRunQueryAllBatchesExecuted = 'runQuery: all batches executed';
+    public readonly msgStartedExecute = 'Started query execution for document "{0}"';
+    public readonly msgFinishedExecute = 'Finished query execution for document "{0}"';
+    public readonly msgRunQueryError = 'runQuery: error: ';
+    public readonly msgRunQueryExecutingBatch = 'runQuery: executeBatch called with SQL: ';
+    public readonly msgRunQueryAddBatchResultsets = 'runQuery: adding resultsets for batch: ';
+    public readonly msgRunQueryAddBatchError = 'runQuery: adding error message for batch: ';
+    public readonly msgRunQueryConnectionActive = 'runQuery: active connection is connected, using it to run query';
+    public readonly msgRunQueryConnectionDisconnected = 'runQuery: active connection is disconnected, reconnecting';
+    public readonly msgRunQueryNoConnection = 'runQuery: no active connection - prompting for user';
+    public readonly msgRunQueryInProgress = 'A query is already running for this editor session. Please cancel this query or wait for its completion.';
+    public readonly runQueryBatchStartMessage = 'Started executing query at ';
+    public readonly runQueryBatchStartLine = 'Line {0}';
+    public readonly msgCancelQueryFailed = 'Canceling the query failed: {0}';
+    public readonly msgCancelQueryNotRunning = 'Cannot cancel query as no query is running.';
+    public readonly msgCancelQuerySuccess = 'Successfully canceled the query.';
+    public readonly msgContentProviderOnContentUpdated = 'Content provider: onContentUpdated called';
+    public readonly msgContentProviderAssociationFailure = 'Content provider: Unable to associate status view for current file';
+    public readonly msgContentProviderOnRootEndpoint = 'LocalWebService: Root end-point called';
+    public readonly msgContentProviderOnResultsEndpoint = 'LocalWebService: ResultsetsMeta endpoint called';
+    public readonly msgContentProviderOnMessagesEndpoint = 'LocalWebService: Messages end-point called';
+    public readonly msgContentProviderOnColumnsEndpoint = 'LocalWebService:  Columns end-point called for index = ';
+    public readonly msgContentProviderOnRowsEndpoint = 'LocalWebService: Rows end-point called for index = ';
+    public readonly msgContentProviderOnClear = 'Content provider: clear called';
+    public readonly msgContentProviderOnUpdateContent = 'Content provider: updateContent called';
+    public readonly msgContentProviderProvideContent = 'Content provider: provideTextDocumentContent called: ';
+    public readonly msgChooseDatabaseNotConnected = 'No connection was found. Please connect to a server first.';
+    public readonly msgChooseDatabasePlaceholder = 'Choose a database from the list below';
+    public readonly msgConnectionError = 'Error {0}: {1}';
+    public readonly msgConnectionError2 = 'Failed to connect: {0}';
+    public readonly msgConnectionErrorPasswordExpired = 'Error {0}: {1} Please login as a different user and change the password using ALTER LOGIN.';
+    public readonly connectionErrorChannelName = 'Connection Errors';
+    public readonly msgPromptCancelConnect = 'Server connection in progress. Do you want to cancel?';
+    public readonly msgPromptClearRecentConnections = 'Confirm to clear recent connections list';
+    public readonly msgOpenSqlFile = 'To use this command, Open a .sql file -or- ' +
+                                      'Change editor language to "SQL" -or- ' +
+                                      'Select T-SQL text in the active SQL editor.';
+    public readonly recentConnectionsPlaceholder = 'Choose a connection profile from the list below';
+    public readonly msgNoConnectionsInSettings = 'To use this command, add connection profile to User Settings.';
+    public readonly labelOpenGlobalSettings = 'Open Global Settings';
+    public readonly labelOpenWorkspaceSettings = 'Open Workspace Settings';
+    public readonly CreateProfileFromConnectionsListLabel = 'Create Connection Profile';
+    public readonly CreateProfileLabel = 'Create';
+    public readonly ClearRecentlyUsedLabel = 'Clear Recent Connections List';
+    public readonly EditProfilesLabel = 'Edit';
+    public readonly RemoveProfileLabel = 'Remove';
+    public readonly ManageProfilesPrompt = 'Manage Connection Profiles';
+    public readonly SampleServerName = '{{put-server-name-here}}';
+    public readonly serverPrompt = 'Server name';
+    public readonly serverPlaceholder = 'hostname\\instance or <server>.database.windows.net';
+    public readonly databasePrompt = 'Database name';
+    public readonly databasePlaceholder = '[Optional] Database to connect (press Enter to connect to <default> database)';
+    public readonly databaseDefaultValue = 'master';
+    public readonly authTypePrompt = 'Authentication Type';
+    public readonly authTypeIntegrated = 'Integrated';
+    public readonly authTypeSql = 'SQL Login';
+    public readonly authTypeAdUniversal = 'Active Directory Universal';
+    public readonly usernamePrompt = 'User name';
+    public readonly usernamePlaceholder = 'User name (SQL Login)';
+    public readonly passwordPrompt = 'Password';
+    public readonly passwordPlaceholder = 'Password (SQL Login)';
+    public readonly msgSavePassword = 'Save Password? If \'No\', password will be required each time you connect';
+    public readonly profileNamePrompt = 'Profile Name';
+    public readonly profileNamePlaceholder = '[Optional] Enter a name for this profile';
+    public readonly filepathPrompt = 'File path';
+    public readonly filepathPlaceholder = 'File name';
+    public readonly filepathMessage = 'File name';
+    public readonly overwritePrompt = 'A file with this name already exists. Do you want to replace the existing file?';
+    public readonly overwritePlaceholder = 'A file with this name already exists';
+    public readonly msgSaveResultInProgress = 'A save request is already executing. Please wait for its completion.';
+    public readonly msgCannotOpenContent = 'Error occurred opening content in editor.';
+    public readonly msgSaveStarted = 'Started saving results to ';
+    public readonly msgSaveFailed = 'Failed to save results. ';
+    public readonly msgSaveSucceeded = 'Successfully saved results to ';
+    public readonly msgSelectProfile = 'Select connection profile';
+    public readonly msgSelectProfileToRemove = 'Select profile to remove';
+    public readonly confirmRemoveProfilePrompt = 'Confirm to remove this profile.';
+    public readonly msgNoProfilesSaved = 'No connection profile to remove.';
+    public readonly msgProfileRemoved = 'Profile removed successfully';
+    public readonly msgProfileCreated = 'Profile created successfully';
+    public readonly msgProfileCreatedAndConnected = 'Profile created and connected';
+    public readonly msgClearedRecentConnections = 'Recent connections list cleared';
+    public readonly msgSelectionIsRequired = 'Selection is required.';
+    public readonly msgIsRequired = ' is required.';
+    public readonly msgRetry = 'Retry';
+    public readonly msgError = 'Error: ';
+    public readonly msgYes = 'Yes';
+    public readonly msgNo = 'No';
+    public readonly defaultDatabaseLabel = '<default>';
+    public readonly notConnectedLabel = 'Disconnected';
+    public readonly notConnectedTooltip = 'Click to connect to a database';
+    public readonly connectingLabel = 'Connecting';
+    public readonly connectingTooltip = 'Connecting to: ';
+    public readonly connectedLabel = 'Connected.';
+    public readonly connectErrorLabel = 'Connection error';
+    public readonly connectErrorTooltip = 'Error connecting to: ';
+    public readonly connectErrorCode = 'Errorcode: ';
+    public readonly connectErrorMessage = 'ErrorMessage: ';
+    public readonly executeQueryLabel = 'Executing query ';
+    public readonly cancelingQueryLabel = 'Canceling query ';
+    public readonly updatingIntelliSenseLabel = 'Updating IntelliSense...';
+    public readonly unfoundResult = 'Data was disposed when text editor was closed; to view data please reexecute query.';
+    public readonly serviceCompatibleVersion = '1.0.0';
+    public readonly serviceNotCompatibleError = 'Client is not compatible with the service layer';
+    public readonly serviceInstallingTo = 'Installing SQL tools service to';
+    public readonly serviceInitializing = 'Initializing SQL tools service for the mssql extension.';
+    public readonly commandsNotAvailableWhileInstallingTheService = 'Note: mssql commands will be available after installing the service.';
+    public readonly serviceInstalled = 'Sql Tools Service installed';
+    public readonly serviceInstallationFailed = 'Failed to install Sql Tools Service';
+    public readonly serviceLoadingFailed = 'Failed to load Sql Tools Service';
+    public readonly invalidServiceFilePath = 'Invalid file path for Sql Tools Service';
+    public readonly extensionNotInitializedError = 'Unable to execute the command while the extension is initializing. Please try again later.';
+    public readonly untitledScheme = 'untitled';
+    public readonly untitledSaveTimeThreshold = 10.0;
+    public readonly renamedOpenTimeThreshold = 10.0;
+    public readonly msgChangeLanguageMode = 'To use this command, you must set the language to \"SQL\". Confirm to change language mode.';
+    public readonly timeToWaitForLanguageModeChange = 10000.0;
+    public readonly msgChangedDatabaseContext = 'Changed database context to \"{0}\" for document \"{1}\"';
+    public readonly msgPromptRetryCreateProfile = 'Error: Unable to connect using the connection information provided. Retry profile creation?';
+    public readonly retryLabel = 'Retry';
+    public readonly msgConnecting = 'Connecting to server \"{0}\" on document \"{1}\".';
+    public readonly msgConnectedServerInfo = 'Connected to server \"{0}\" on document \"{1}\". Server information: {2}';
+    public readonly msgConnectionFailed = 'Error connecting to server \"{0}\". Details: {1}';
+    public readonly msgChangingDatabase = 'Changing database context to \"{0}\" on server \"{1}\" on document \"{2}\".';
+    public readonly msgChangedDatabase = 'Changed database context to \"{0}\" on server \"{1}\" on document \"{2}\".';
+    public readonly msgDisconnected = 'Disconnected on document \"{0}\"';
+    public readonly msgErrorReadingConfigFile = 'Error: Unable to load connection profiles from [{0}]. Check if the file is formatted correctly.';
+    public readonly msgErrorOpeningConfigFile = 'Error: Unable to open connection profile settings file.';
+    public readonly extConfigResultKeys = ['shortcuts', 'messagesDefaultOpen'];
+    public readonly extConfigResultFontFamily = 'resultsFontFamily';
+    public readonly extConfigResultFontSize = 'resultsFontSize';
+    public readonly titleResultsPane = 'Results: {0}';
+    public readonly macOpenSslErrorMessage = `OpenSSL version >=1.0.1 is required to connect.`;
+    public readonly macOpenSslHelpButton = 'Help';
+    public readonly macOpenSslHelpLink = 'https://github.com/Microsoft/vscode-mssql/wiki/OpenSSL-Configuration';
+    public readonly serviceName = 'SQLToolsService';
+    public readonly serviceInitializingOutputChannelName = 'SqlToolsService Initialization';
+    public readonly gettingStartedGuideLink = 'https://aka.ms/mssql-getting-started';
+    public readonly serviceCrashMessage = 'SQL Tools Service component exited unexpectedly. Please restart SQL Operations Studio.';
+    public readonly serviceCrashLink = 'https://github.com/Microsoft/vscode-mssql/wiki/SqlToolsService-Known-Issues';
+    public readonly gettingDefinitionMessage = 'Getting definition ...';
+    public readonly definitionRequestedStatus = 'DefinitionRequested';
+    public readonly definitionRequestCompletedStatus = 'DefinitionRequestCompleted';
+    public readonly updatingIntelliSenseStatus = 'updatingIntelliSense';
+    public readonly intelliSenseUpdatedStatus = 'intelliSenseUpdated';
+
+    /**
+     * Returns a supported .NET Core Runtime ID (RID) for the current platform. The list of Runtime IDs
+     * is available at https://github.com/dotnet/corefx/tree/master/pkg/Microsoft.NETCore.Platforms.
+     */
+    public getRuntimeId(platform: string, architecture: string, distribution: LinuxDistribution): Runtime {
+        switch (platform) {
+            case 'win32':
+                switch (architecture) {
+                    case 'x86': return Runtime.Windows_86;
+                    case 'x86_64': return Runtime.Windows_64;
+                    default:
+                }
+
+                throw new Error(`Unsupported Windows architecture: ${architecture}`);
+
+            case 'darwin':
+                if (architecture === 'x86_64') {
+                    // Note: We return the El Capitan RID for Sierra
+                    return Runtime.OSX;
+                }
+
+                throw new Error(`Unsupported macOS architecture: ${architecture}`);
+
+            case 'linux':
+                if (architecture === 'x86_64') {
+
+                    // First try the distribution name
+                    let runtimeId = Constants.getRuntimeIdHelper(distribution.name, distribution.version);
+
+                    // If the distribution isn't one that we understand, but the 'ID_LIKE' field has something that we understand, use that
+                    //
+                    // NOTE: 'ID_LIKE' doesn't specify the version of the 'like' OS. So we will use the 'VERSION_ID' value. This will restrict
+                    // how useful ID_LIKE will be since it requires the version numbers to match up, but it is the best we can do.
+                    if (runtimeId === Runtime.UnknownRuntime && distribution.idLike && distribution.idLike.length > 0) {
+                        for (let id of distribution.idLike) {
+                            runtimeId = Constants.getRuntimeIdHelper(id, distribution.version);
+                            if (runtimeId !== Runtime.UnknownRuntime) {
+                                break;
+                            }
+                        }
+                    }
+
+                    if (runtimeId !== Runtime.UnknownRuntime && runtimeId !== Runtime.UnknownVersion) {
+                        return runtimeId;
+                    }
+                }
+
+                // If we got here, this is not a Linux distro or architecture that we currently support.
+                throw new Error(`Unsupported Linux distro: ${distribution.name}, ${distribution.version}, ${architecture}`);
+            default :
+                 // If we got here, we've ended up with a platform we don't support  like 'freebsd' or 'sunos'.
+                 // Chances are, VS Code doesn't support these platforms either.
+                 throw Error('Unsupported platform ' + platform);
+        }
+    }
+
+    private static getRuntimeIdHelper(distributionName: string, distributionVersion: string): Runtime {
+        switch (distributionName) {
+            case 'ubuntu':
+                if (distributionVersion.startsWith('14')) {
+                    // This also works for Linux Mint
+                    return Runtime.Ubuntu_14;
+                } else if (distributionVersion.startsWith('16')) {
+                    return Runtime.Ubuntu_16;
+                }
+
+                break;
+            case 'elementary':
+            case 'elementary OS':
+                if (distributionVersion.startsWith('0.3')) {
+                    // Elementary OS 0.3 Freya is binary compatible with Ubuntu 14.04
+                    return Runtime.Ubuntu_14;
+                } else if (distributionVersion.startsWith('0.4')) {
+                    // Elementary OS 0.4 Loki is binary compatible with Ubuntu 16.04
+                    return Runtime.Ubuntu_16;
+                }
+
+                break;
+            case 'linuxmint':
+                if (distributionVersion.startsWith('18')) {
+                    // Linux Mint 18 is binary compatible with Ubuntu 16.04
+                    return Runtime.Ubuntu_16;
+                }
+
+                break;
+            case 'centos':
+            case 'ol':
+                // Oracle Linux is binary compatible with CentOS
+                return Runtime.CentOS_7;
+            case 'fedora':
+                return Runtime.Fedora_23;
+            case 'opensuse':
+                return Runtime.OpenSUSE_13_2;
+            case 'sles':
+                return Runtime.SLES_12_2;
+            case 'rhel':
+                return Runtime.RHEL_7;
+            case 'debian':
+                return Runtime.Debian_8;
+            case 'galliumos':
+                if (distributionVersion.startsWith('2.0')) {
+                    return Runtime.Ubuntu_16;
+                }
+                break;
+            default:
+                return Runtime.UnknownRuntime;
+        }
+
+        return Runtime.UnknownVersion;
+    }
+}

extensions/mssql/client/src/models/contracts.ts

@@ -0,0 +1,104 @@
+/*---------------------------------------------------------------------------------------------
+*  Copyright (c) Microsoft Corporation. All rights reserved.
+*  Licensed under the Source EULA. See License.txt in the project root for license information.
+*--------------------------------------------------------------------------------------------*/
+'use strict';
+
+import {RequestType} from 'dataprotocol-client';
+import * as data from 'data';
+
+// DEV-NOTE: Still finalizing what we'll need as part of this interface
+/**
+ * Contains necessary information for serializing and saving results
+ * @param {string} saveFormat the format / type that the results will be saved in
+ * @param {string} savePath path the results will be saved to
+ * @param {string} results either a subset or all of the results we wish to save to savePath
+ * @param {boolean} appendToFile Whether we should append or overwrite the file in savePath
+*/
+export class SaveResultsInfo {
+
+
+    constructor(public saveFormat: string, public savePath: string, public results: string,
+                public appendToFile: boolean) {
+    }
+}
+
+export namespace SaveAsRequest {
+    export const type: RequestType<SaveResultsInfo, data.SaveResultRequestResult, void> = { get method(): string { return 'query/saveAs'; } };
+}
+
+// --------------------------------- < Read Credential Request > -------------------------------------------------
+
+// Read Credential request message callback declaration
+export namespace ReadCredentialRequest {
+    export const type: RequestType<Credential, Credential, void> = { get method(): string { return 'credential/read'; } };
+}
+
+/**
+ * Parameters to initialize a connection to a database
+ */
+export class Credential {
+    /**
+     * Unique ID identifying the credential
+     */
+    public credentialId: string;
+
+    /**
+     * password
+     */
+    public password: string;
+}
+
+// --------------------------------- </ Read Credential Request > -------------------------------------------------
+
+// --------------------------------- < Save Credential Request > -------------------------------------------------
+
+// Save Credential request message callback declaration
+export namespace SaveCredentialRequest {
+    export const type: RequestType<Credential, boolean, void> = { get method(): string { return 'credential/save'; } };
+}
+// --------------------------------- </ Save Credential Request > -------------------------------------------------
+
+
+// --------------------------------- < Delete Credential Request > -------------------------------------------------
+
+// Delete Credential request message callback declaration
+export namespace DeleteCredentialRequest {
+    export const type: RequestType<Credential, boolean, void> = { get method(): string { return 'credential/delete'; } };
+}
+// --------------------------------- </ Delete Credential Request > -------------------------------------------------
+
+// ------------------------------- < Resource Events > ------------------------------------
+export namespace CreateFirewallRuleRequest {
+	export const type: RequestType<CreateFirewallRuleParams, CreateFirewallRuleResponse, void> = { get method(): string { return 'resource/createFirewallRule'; } };
+}
+
+export namespace HandleFirewallRuleRequest {
+	export const type: RequestType<HandleFirewallRuleParams, HandleFirewallRuleResponse, void> = { get method(): string { return 'resource/handleFirewallRule'; } };
+}
+
+// Firewall rule interfaces
+export interface CreateFirewallRuleParams {
+	account: data.Account;
+	serverName: string;
+	startIpAddress: string;
+	endIpAddress: string;
+	securityTokenMappings: {};
+}
+
+export interface CreateFirewallRuleResponse {
+	result: boolean;
+	errorMessage: string;
+}
+
+export interface HandleFirewallRuleParams {
+	errorCode: number;
+	errorMessage: string;
+	connectionTypeId: string;
+}
+
+export interface HandleFirewallRuleResponse {
+	result: boolean;
+	ipAddress: string;
+}
+

extensions/mssql/client/src/mssqlMain.ts

@@ -0,0 +1,30 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+'use strict';
+
+import vscode = require('vscode');
+import MainController from './controllers/mainController';
+
+let controller: MainController = undefined;
+
+export function activate(context: vscode.ExtensionContext) {
+	controller = new MainController(context);
+	context.subscriptions.push(controller);
+	controller.activate();
+}
+
+// this method is called when your extension is deactivated
+export function deactivate(): void {
+    if (controller) {
+        controller.deactivate();
+    }
+}
+
+/**
+ * Exposed for testing purposes
+ */
+export function getController(): MainController {
+    return controller;
+}

extensions/mssql/client/src/resourceprovider/resourceprovider.ts

@@ -0,0 +1,63 @@
+/*---------------------------------------------------------------------------------------------
+*  Copyright (c) Microsoft Corporation. All rights reserved.
+*  Licensed under the Source EULA. See License.txt in the project root for license information.
+*--------------------------------------------------------------------------------------------*/
+'use strict';
+
+import * as Contracts from '../models/contracts';
+import { SqlToolsServiceClient } from 'extensions-modules';
+import { LanguageClient } from 'dataprotocol-client';
+import * as data from 'data';
+
+
+/**
+ * Implements a credential storage for Windows, Mac (darwin), or Linux.
+ *
+ * Allows a single credential to be stored per service (that is, one username per service);
+ */
+export class AzureResourceProvider implements data.ResourceProvider {
+
+    public languageClient: LanguageClient;
+
+    constructor(private _client?: SqlToolsServiceClient, langClient?: LanguageClient) {
+        if (!this._client) {
+            this._client = SqlToolsServiceClient.instance;
+        }
+        this.languageClient = langClient;
+    }
+
+    public createFirewallRule(account: data.Account, firewallruleInfo: data.FirewallRuleInfo): Thenable<data.CreateFirewallRuleResponse> {
+        let self = this;
+        return new Promise<data.CreateFirewallRuleResponse>((resolve, reject) => {
+            self._client.
+            sendRequest(Contracts.CreateFirewallRuleRequest.type, self.asCreateFirewallRuleParams(account, firewallruleInfo), self.languageClient)
+            .then(response => {
+                resolve(response);
+            }, err => reject(err));
+        });
+    }
+
+    public handleFirewallRule(errorCode: number, errorMessage: string, connectionTypeId: string): Thenable<data.HandleFirewallRuleResponse> {
+        let self = this;
+        return new Promise<data.HandleFirewallRuleResponse>((resolve, reject) => {
+            let params: Contracts.HandleFirewallRuleParams = { errorCode: errorCode, errorMessage: errorMessage, connectionTypeId: connectionTypeId };
+
+            self._client.
+            sendRequest(Contracts.HandleFirewallRuleRequest.type, params, self.languageClient)
+            .then(response => {
+                resolve(response);
+            }, err => reject(err));
+        });
+    }
+
+    private asCreateFirewallRuleParams(account: data.Account, params: data.FirewallRuleInfo): Contracts.CreateFirewallRuleParams {
+        return {
+            account: account,
+            serverName: params.serverName,
+            startIpAddress: params.startIpAddress,
+            endIpAddress: params.endIpAddress,
+            securityTokenMappings: params.securityTokenMappings
+        };
+    }
+}
+

extensions/mssql/client/src/serialize/iserialization.ts

@@ -0,0 +1,18 @@
+/*---------------------------------------------------------------------------------------------
+*  Copyright (c) Microsoft Corporation. All rights reserved.
+*  Licensed under the Source EULA. See License.txt in the project root for license information.
+*--------------------------------------------------------------------------------------------*/
+'use strict';
+
+import { SaveResultsInfo } from '../models/contracts';
+import * as data from 'data';
+
+/**
+ * Serializer for saving results into a different format
+ *
+ * @export
+ * @interface ISerialization
+ */
+export interface ISerialization {
+    saveAs(saveFormat: string, savePath: string, results: string, appendToFile: boolean): Promise<data.SaveResultRequestResult>;
+}

extensions/mssql/client/src/serialize/serialization.ts

@@ -0,0 +1,41 @@
+/*---------------------------------------------------------------------------------------------
+*  Copyright (c) Microsoft Corporation. All rights reserved.
+*  Licensed under the Source EULA. See License.txt in the project root for license information.
+*--------------------------------------------------------------------------------------------*/
+'use strict';
+
+import * as Contracts from '../models/contracts';
+import { ISerialization } from './iserialization';
+import { SqlToolsServiceClient } from 'extensions-modules';
+import * as data from 'data';
+import { LanguageClient } from 'dataprotocol-client';
+
+/**
+ * Implements serializer for query results
+ */
+export class Serialization implements ISerialization {
+
+    constructor(private _client?: SqlToolsServiceClient, private _languageClient?: LanguageClient) {
+        if (!this._client) {
+            this._client = SqlToolsServiceClient.instance;
+        }
+    }
+
+    /**
+     * Saves results as a specified path
+     *
+     * @param {string} credentialId the ID uniquely identifying this credential
+     * @returns {Promise<ISaveResultsInfo>} Promise that resolved to the credential, or undefined if not found
+     */
+    public saveAs(saveFormat: string, savePath: string, results: string, appendToFile: boolean): Promise<data.SaveResultRequestResult> {
+        let self = this;
+        let resultsInfo: Contracts.SaveResultsInfo  = new Contracts.SaveResultsInfo(saveFormat, savePath, results, appendToFile);
+        return new Promise<data.SaveResultRequestResult>( (resolve, reject) => {
+            self._client
+            .sendRequest(Contracts.SaveAsRequest.type, resultsInfo, this._languageClient)
+            .then(result => {
+                resolve(<data.SaveResultRequestResult>result);
+            }, err => reject(err));
+        });
+    }
+}

extensions/mssql/client/src/typings/ref.d.ts

@@ -0,0 +1,8 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+/// <reference path='../../../../../src/vs/vscode.d.ts'/>
+/// <reference path='../../../../../src/sql/data.d.ts'/>
+/// <reference types='@types/node'/>