Initial Code Layering (#3788)

* working on formatting

* fixed basic lint errors; starting moving things to their appropriate location

* formatting

* update tslint to match the version of vscode we have

* remove unused code

* work in progress fixing layering

* formatting

* moved connection management service to platform

* formatting

* add missing file

* moving more servies

* formatting

* moving more services

* formatting

* wip

* moving more services

* formatting

* revert back tslint rules

* move css file

* add missing svgs

src/sql/workbench/services/notebook/common/notebookRegistry.ts

@@ -0,0 +1,116 @@
+/*---------------------------------------------------------------------------------------------
+ *  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 { IJSONSchema } from 'vs/base/common/jsonSchema';
+import { ExtensionsRegistry, IExtensionPointUser } from 'vs/workbench/services/extensions/common/extensionsRegistry';
+import { localize } from 'vs/nls';
+import * as platform from 'vs/platform/registry/common/platform';
+import { Event, Emitter } from 'vs/base/common/event';
+
+export const Extensions = {
+	NotebookProviderContribution: 'notebook.providers'
+};
+
+export interface NotebookProviderRegistration {
+	provider: string;
+	fileExtensions: string | string[];
+	standardKernels: string | string[];
+}
+
+let notebookProviderType: IJSONSchema = {
+	type: 'object',
+	default: { provider: '', fileExtensions: [], standardKernels: [] },
+	properties: {
+		provider: {
+			description: localize('carbon.extension.contributes.notebook.provider', 'Identifier of the notebook provider.'),
+			type: 'string'
+		},
+		fileExtensions: {
+			description: localize('carbon.extension.contributes.notebook.fileExtensions', 'What file extensions should be registered to this notebook provider'),
+			oneOf: [
+				{ type: 'string' },
+				{
+					type: 'array',
+					items: {
+						type: 'string'
+					}
+				}
+			]
+		},
+		standardKernels: {
+			description: localize('carbon.extension.contributes.notebook.standardKernels', 'What kernels should be standard with this notebook provider'),
+			oneOf: [
+				{ type: 'string' },
+				{
+					type: 'array',
+					items: {
+						type: 'string'
+					}
+				}
+			]
+		}
+	}
+};
+
+let notebookContrib: IJSONSchema = {
+	description: localize('vscode.extension.contributes.notebook.providers', "Contributes notebook providers."),
+	oneOf: [
+		notebookProviderType,
+		{
+			type: 'array',
+			items: notebookProviderType
+		}
+	]
+};
+
+export interface INotebookProviderRegistry {
+	readonly registrations: NotebookProviderRegistration[];
+	readonly onNewRegistration: Event<{ id: string, registration: NotebookProviderRegistration }>;
+
+	registerNotebookProvider(registration: NotebookProviderRegistration): void;
+}
+
+class NotebookProviderRegistry implements INotebookProviderRegistry {
+	private providerIdToRegistration = new Map<string, NotebookProviderRegistration>();
+	private _onNewRegistration = new Emitter<{ id: string, registration: NotebookProviderRegistration }>();
+	public readonly onNewRegistration: Event<{ id: string, registration: NotebookProviderRegistration }> = this._onNewRegistration.event;
+
+	registerNotebookProvider(registration: NotebookProviderRegistration): void {
+		// Note: this method intentionally overrides default provider for a file type.
+		// This means that any built-in provider will be overridden by registered extensions
+		this.providerIdToRegistration.set(registration.provider, registration);
+		this._onNewRegistration.fire({ id: registration.provider, registration: registration });
+	}
+
+	public get registrations(): NotebookProviderRegistration[] {
+		let registrationArray: NotebookProviderRegistration[] = [];
+		this.providerIdToRegistration.forEach(p => registrationArray.push(p));
+		return registrationArray;
+	}
+}
+
+const notebookProviderRegistry = new NotebookProviderRegistry();
+platform.Registry.add(Extensions.NotebookProviderContribution, notebookProviderRegistry);
+
+
+ExtensionsRegistry.registerExtensionPoint<NotebookProviderRegistration | NotebookProviderRegistration[]>(Extensions.NotebookProviderContribution, [], notebookContrib).setHandler(extensions => {
+
+	function handleExtension(contrib: NotebookProviderRegistration, extension: IExtensionPointUser<any>) {
+		notebookProviderRegistry.registerNotebookProvider(contrib);
+	}
+
+	for (let extension of extensions) {
+		const { value } = extension;
+		if (Array.isArray<NotebookProviderRegistration>(value)) {
+			for (let command of value) {
+				handleExtension(command, extension);
+			}
+		} else {
+			handleExtension(value, extension);
+		}
+	}
+});

src/sql/workbench/services/notebook/common/notebookService.ts

@@ -0,0 +1,106 @@
+/*---------------------------------------------------------------------------------------------
+ *  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 sqlops from 'sqlops';
+
+import { Event } from 'vs/base/common/event';
+import { createDecorator } from 'vs/platform/instantiation/common/instantiation';
+import URI from 'vs/base/common/uri';
+import { IBootstrapParams } from 'sql/services/bootstrap/bootstrapService';
+import { RenderMimeRegistry } from 'sql/parts/notebook/outputs/registry';
+import { ModelFactory } from 'sql/parts/notebook/models/modelFactory';
+import { IConnectionProfile } from 'sql/platform/connection/common/interfaces';
+import { NotebookInput } from 'sql/parts/notebook/notebookInput';
+import { ISingleNotebookEditOperation } from 'sql/workbench/api/common/sqlExtHostTypes';
+import { ICellModel, INotebookModel } from 'sql/parts/notebook/models/modelInterfaces';
+
+export const SERVICE_ID = 'notebookService';
+export const INotebookService = createDecorator<INotebookService>(SERVICE_ID);
+
+export const DEFAULT_NOTEBOOK_PROVIDER = 'builtin';
+export const DEFAULT_NOTEBOOK_FILETYPE = 'IPYNB';
+export const SQL_NOTEBOOK_PROVIDER = 'sql';
+
+export interface INotebookService {
+	_serviceBrand: any;
+
+	readonly onNotebookEditorAdd: Event<INotebookEditor>;
+	readonly onNotebookEditorRemove: Event<INotebookEditor>;
+	onNotebookEditorRename: Event<INotebookEditor>;
+
+	readonly isRegistrationComplete: boolean;
+	readonly registrationComplete: Promise<void>;
+	/**
+	 * Register a metadata provider
+	 */
+	registerProvider(providerId: string, provider: INotebookProvider): void;
+
+	/**
+	 * Register a metadata provider
+	 */
+	unregisterProvider(providerId: string): void;
+
+	getSupportedFileExtensions(): string[];
+
+	getProvidersForFileType(fileType: string): string[];
+
+	/**
+	 * Initializes and returns a Notebook manager that can handle all important calls to open, display, and
+	 * run cells in a notebook.
+	 * @param providerId ID for the provider to be used to instantiate a backend notebook service
+	 * @param uri URI for a notebook that is to be opened. Based on this an existing manager may be used, or
+	 * a new one may need to be created
+	 */
+	getOrCreateNotebookManager(providerId: string, uri: URI): Thenable<INotebookManager>;
+
+	addNotebookEditor(editor: INotebookEditor): void;
+
+	removeNotebookEditor(editor: INotebookEditor): void;
+
+	listNotebookEditors(): INotebookEditor[];
+
+	shutdown(): void;
+
+	getMimeRegistry(): RenderMimeRegistry;
+
+	renameNotebookEditor(oldUri: URI, newUri: URI, currentEditor: INotebookEditor): void;
+}
+
+export interface INotebookProvider {
+	readonly providerId: string;
+	getNotebookManager(notebookUri: URI): Thenable<INotebookManager>;
+	handleNotebookClosed(notebookUri: URI): void;
+}
+
+export interface INotebookManager {
+	providerId: string;
+	readonly contentManager: sqlops.nb.ContentManager;
+	readonly sessionManager: sqlops.nb.SessionManager;
+	readonly serverManager: sqlops.nb.ServerManager;
+}
+
+export interface INotebookParams extends IBootstrapParams {
+	notebookUri: URI;
+	input: NotebookInput;
+	providerId: string;
+	providers: string[];
+	isTrusted: boolean;
+	profile?: IConnectionProfile;
+	modelFactory?: ModelFactory;
+}
+
+export interface INotebookEditor {
+	readonly notebookParams: INotebookParams;
+	readonly id: string;
+	readonly cells?: ICellModel[];
+	readonly modelReady: Promise<INotebookModel>;
+	isDirty(): boolean;
+	isActive(): boolean;
+	isVisible(): boolean;
+	save(): Promise<boolean>;
+	executeEdits(edits: ISingleNotebookEditOperation[]): boolean;
+}

src/sql/workbench/services/notebook/common/notebookServiceImpl.ts

@@ -0,0 +1,448 @@
+/*---------------------------------------------------------------------------------------------
+ *  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 { nb } from 'sqlops';
+import { localize } from 'vs/nls';
+import URI from 'vs/base/common/uri';
+import { Registry } from 'vs/platform/registry/common/platform';
+
+import {
+	INotebookService, INotebookManager, INotebookProvider, DEFAULT_NOTEBOOK_PROVIDER,
+	DEFAULT_NOTEBOOK_FILETYPE, INotebookEditor, SQL_NOTEBOOK_PROVIDER
+} from 'sql/workbench/services/notebook/common/notebookService';
+import { RenderMimeRegistry } from 'sql/parts/notebook/outputs/registry';
+import { standardRendererFactories } from 'sql/parts/notebook/outputs/factories';
+import { LocalContentManager } from 'sql/workbench/services/notebook/node/localContentManager';
+import { SessionManager } from 'sql/workbench/services/notebook/common/sessionManager';
+import { Extensions, INotebookProviderRegistry, NotebookProviderRegistration } from 'sql/workbench/services/notebook/common/notebookRegistry';
+import { Emitter, Event } from 'vs/base/common/event';
+import { Memento } from 'vs/workbench/common/memento';
+import { IStorageService } from 'vs/platform/storage/common/storage';
+import { IExtensionService } from 'vs/workbench/services/extensions/common/extensions';
+import { IExtensionManagementService, IExtensionIdentifier } from 'vs/platform/extensionManagement/common/extensionManagement';
+import { Disposable } from 'vs/base/common/lifecycle';
+import { getIdFromLocalExtensionId } from 'vs/platform/extensionManagement/common/extensionManagementUtil';
+import { Deferred } from 'sql/base/common/promise';
+import { SqlSessionManager } from 'sql/workbench/services/notebook/common/sqlSessionManager';
+import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
+import { sqlNotebooksEnabled } from 'sql/parts/notebook/notebookUtils';
+
+export interface NotebookProviderProperties {
+	provider: string;
+	fileExtensions: string[];
+}
+
+interface NotebookProviderCache {
+	[id: string]: NotebookProviderProperties;
+}
+
+interface NotebookProvidersMemento {
+	notebookProviderCache: NotebookProviderCache;
+}
+
+const notebookRegistry = Registry.as<INotebookProviderRegistry>(Extensions.NotebookProviderContribution);
+
+class ProviderDescriptor {
+	private _instanceReady = new Deferred<INotebookProvider>();
+	constructor(private providerId: string, private _instance?: INotebookProvider) {
+		if (_instance) {
+			this._instanceReady.resolve(_instance);
+		}
+	}
+
+	public get instanceReady(): Promise<INotebookProvider> {
+		return this._instanceReady.promise;
+	}
+
+	public get instance(): INotebookProvider {
+		return this._instance;
+	}
+	public set instance(value: INotebookProvider) {
+		this._instance = value;
+		this._instanceReady.resolve(value);
+	}
+}
+
+export class NotebookService extends Disposable implements INotebookService {
+	_serviceBrand: any;
+
+	private _memento = new Memento('notebookProviders');
+	private _mimeRegistry: RenderMimeRegistry;
+	private _providers: Map<string, ProviderDescriptor> = new Map();
+	private _managersMap: Map<string, INotebookManager[]> = new Map();
+	private _onNotebookEditorAdd = new Emitter<INotebookEditor>();
+	private _onNotebookEditorRemove = new Emitter<INotebookEditor>();
+	private _onCellChanged = new Emitter<INotebookEditor>();
+	private _onNotebookEditorRename = new Emitter<INotebookEditor>();
+	private _editors = new Map<string, INotebookEditor>();
+	private _fileToProviders = new Map<string, NotebookProviderRegistration[]>();
+	private _registrationComplete = new Deferred<void>();
+	private _isRegistrationComplete = false;
+
+	constructor(
+		@IStorageService private _storageService: IStorageService,
+		@IExtensionService extensionService: IExtensionService,
+		@IExtensionManagementService extensionManagementService: IExtensionManagementService,
+		@IInstantiationService private _instantiationService: IInstantiationService
+	) {
+		super();
+		this._register(notebookRegistry.onNewRegistration(this.updateRegisteredProviders, this));
+		this.registerBuiltInProvider();
+
+		if (extensionService) {
+			extensionService.whenInstalledExtensionsRegistered().then(() => {
+				this.cleanupProviders();
+				this._isRegistrationComplete = true;
+				this._registrationComplete.resolve();
+			});
+		}
+		if (extensionManagementService) {
+			this._register(extensionManagementService.onDidUninstallExtension(({ identifier }) => this.removeContributedProvidersFromCache(identifier, extensionService)));
+		}
+	}
+
+	private updateRegisteredProviders(p: { id: string; registration: NotebookProviderRegistration; }) {
+		let registration = p.registration;
+
+		if (!this._providers.has(p.id)) {
+			this._providers.set(p.id, new ProviderDescriptor(p.id));
+		}
+		if (registration.fileExtensions) {
+			if (Array.isArray<string>(registration.fileExtensions)) {
+				for (let fileType of registration.fileExtensions) {
+					this.addFileProvider(fileType, registration);
+				}
+			}
+			else {
+				this.addFileProvider(registration.fileExtensions, registration);
+			}
+		}
+	}
+
+	registerProvider(providerId: string, instance: INotebookProvider): void {
+		let providerDescriptor = this._providers.get(providerId);
+		if (providerDescriptor) {
+			// Update, which will resolve the promise for anyone waiting on the instance to be registered
+			providerDescriptor.instance = instance;
+		} else {
+			this._providers.set(providerId, new ProviderDescriptor(providerId, instance));
+		}
+	}
+
+	unregisterProvider(providerId: string): void {
+		this._providers.delete(providerId);
+	}
+
+	get isRegistrationComplete(): boolean {
+		return this._isRegistrationComplete;
+	}
+
+	get registrationComplete(): Promise<void> {
+		return this._registrationComplete.promise;
+	}
+
+	private addFileProvider(fileType: string, provider: NotebookProviderRegistration) {
+		let providers = this._fileToProviders.get(fileType.toUpperCase());
+		if (!providers) {
+			providers = [];
+		}
+		providers.push(provider);
+		this._fileToProviders.set(fileType.toUpperCase(), providers);
+	}
+
+	getSupportedFileExtensions(): string[] {
+		return Array.from(this._fileToProviders.keys());
+	}
+
+	getProvidersForFileType(fileType: string): string[] {
+		fileType = fileType.toUpperCase();
+		let providers = this._fileToProviders.get(fileType);
+
+		return providers ? providers.map(provider => provider.provider) : undefined;
+	}
+
+	public shutdown(): void {
+		this._managersMap.forEach(manager => {
+			manager.forEach(m => {
+				if (m.serverManager) {
+					// TODO should this thenable be awaited?
+					m.serverManager.stopServer();
+				}
+			});
+		});
+	}
+
+	async getOrCreateNotebookManager(providerId: string, uri: URI): Promise<INotebookManager> {
+		if (!uri) {
+			throw new Error(localize('notebookUriNotDefined', 'No URI was passed when creating a notebook manager'));
+		}
+		let uriString = uri.toString();
+		let managers: INotebookManager[] = this._managersMap.get(uriString);
+		// If manager already exists for a given notebook, return it
+		if (managers) {
+			let index = managers.findIndex(m => m.providerId === providerId);
+			if (index && index >= 0) {
+				return managers[index];
+			}
+		}
+		let newManager = await this.doWithProvider(providerId, (provider) => provider.getNotebookManager(uri));
+
+		managers = managers || [];
+		managers.push(newManager);
+		this._managersMap.set(uriString, managers);
+		return newManager;
+	}
+
+	get onNotebookEditorAdd(): Event<INotebookEditor> {
+		return this._onNotebookEditorAdd.event;
+	}
+	get onNotebookEditorRemove(): Event<INotebookEditor> {
+		return this._onNotebookEditorRemove.event;
+	}
+	get onCellChanged(): Event<INotebookEditor> {
+		return this._onCellChanged.event;
+	}
+
+	get onNotebookEditorRename(): Event<INotebookEditor> {
+		return this._onNotebookEditorRename.event;
+	}
+
+	addNotebookEditor(editor: INotebookEditor): void {
+		this._editors.set(editor.id, editor);
+		this._onNotebookEditorAdd.fire(editor);
+	}
+
+	removeNotebookEditor(editor: INotebookEditor): void {
+		if (this._editors.delete(editor.id)) {
+			this._onNotebookEditorRemove.fire(editor);
+		}
+		// Remove the manager from the tracked list, and let the notebook provider know that it should update its mappings
+		this.sendNotebookCloseToProvider(editor);
+	}
+
+	listNotebookEditors(): INotebookEditor[] {
+		let editors = [];
+		this._editors.forEach(e => editors.push(e));
+		return editors;
+	}
+
+	renameNotebookEditor(oldUri: URI, newUri: URI, currentEditor: INotebookEditor): void {
+		let oldUriKey = oldUri.toString();
+		if (this._editors.has(oldUriKey)) {
+			this._editors.delete(oldUriKey);
+			currentEditor.notebookParams.notebookUri = newUri;
+			this._editors.set(newUri.toString(), currentEditor);
+			this._onNotebookEditorRename.fire(currentEditor);
+		}
+	}
+
+	private sendNotebookCloseToProvider(editor: INotebookEditor): void {
+		let notebookUri = editor.notebookParams.notebookUri;
+		let uriString = notebookUri.toString();
+		let manager = this._managersMap.get(uriString);
+		if (manager) {
+			// As we have a manager, we can assume provider is ready
+			this._managersMap.delete(uriString);
+			manager.forEach(m => {
+				let provider = this._providers.get(m.providerId);
+				provider.instance.handleNotebookClosed(notebookUri);
+			});
+		}
+	}
+
+	// PRIVATE HELPERS /////////////////////////////////////////////////////
+	private async doWithProvider<T>(providerId: string, op: (provider: INotebookProvider) => Thenable<T>): Promise<T> {
+		// Make sure the provider exists before attempting to retrieve accounts
+		let provider: INotebookProvider = await this.getProviderInstance(providerId);
+		return op(provider);
+	}
+
+	private async getProviderInstance(providerId: string, timeout?: number): Promise<INotebookProvider> {
+		let providerDescriptor = this._providers.get(providerId);
+		let instance: INotebookProvider;
+
+		// Try get from actual provider, waiting on its registration
+		if (providerDescriptor) {
+			if (!providerDescriptor.instance) {
+				instance = await this.waitOnProviderAvailability(providerDescriptor);
+			} else {
+				instance = providerDescriptor.instance;
+			}
+		}
+
+		// Fall back to default if this failed
+		if (!instance) {
+			providerDescriptor = this._providers.get(DEFAULT_NOTEBOOK_PROVIDER);
+			instance = providerDescriptor ? providerDescriptor.instance : undefined;
+		}
+
+		// Should never happen, but if default wasn't registered we should throw
+		if (!instance) {
+			throw new Error(localize('notebookServiceNoProvider', 'Notebook provider does not exist'));
+		}
+		return instance;
+	}
+
+	private waitOnProviderAvailability(providerDescriptor: ProviderDescriptor, timeout?: number): Promise<INotebookProvider> {
+		// Wait up to 10 seconds for the provider to be registered
+		timeout = timeout || 10000;
+		let promises: Promise<INotebookProvider>[] = [
+			providerDescriptor.instanceReady,
+			new Promise<INotebookProvider>((resolve, reject) => setTimeout(() => resolve(), timeout))
+		];
+		return Promise.race(promises);
+	}
+
+	//Returns an instantiation of RenderMimeRegistry class
+	getMimeRegistry(): RenderMimeRegistry {
+		if (!this._mimeRegistry) {
+			return new RenderMimeRegistry({
+				initialFactories: standardRendererFactories
+			});
+		}
+		return this._mimeRegistry;
+	}
+
+	private get providersMemento(): NotebookProvidersMemento {
+		return this._memento.getMemento(this._storageService) as NotebookProvidersMemento;
+	}
+
+	private cleanupProviders(): void {
+		let knownProviders = Object.keys(notebookRegistry.registrations);
+		let cache = this.providersMemento.notebookProviderCache;
+		for (let key in cache) {
+			if (!knownProviders.includes(key)) {
+				this._providers.delete(key);
+				delete cache[key];
+			}
+		}
+	}
+
+	private registerBuiltInProvider() {
+		if (!sqlNotebooksEnabled()) {
+			let defaultProvider = new BuiltinProvider();
+			this.registerProvider(defaultProvider.providerId, defaultProvider);
+			notebookRegistry.registerNotebookProvider({
+				provider: defaultProvider.providerId,
+				fileExtensions: DEFAULT_NOTEBOOK_FILETYPE,
+				standardKernels: []
+			});
+		} else {
+			let sqlProvider = new SqlNotebookProvider(this._instantiationService);
+			this.registerProvider(sqlProvider.providerId, sqlProvider);
+			notebookRegistry.registerNotebookProvider({
+				provider: sqlProvider.providerId,
+				fileExtensions: DEFAULT_NOTEBOOK_FILETYPE,
+				standardKernels: ['SQL']
+			});
+		}
+	}
+
+	private removeContributedProvidersFromCache(identifier: IExtensionIdentifier, extensionService: IExtensionService) {
+		let extensionid = getIdFromLocalExtensionId(identifier.id);
+		extensionService.getExtensions().then(i => {
+			let extension = i.find(c => c.id === extensionid);
+			if (extension && extension.contributes['notebookProvider']) {
+				let id = extension.contributes['notebookProvider'].providerId;
+				delete this.providersMemento.notebookProviderCache[id];
+			}
+		});
+	}
+}
+
+export class BuiltinProvider implements INotebookProvider {
+	private manager: BuiltInNotebookManager;
+
+	constructor() {
+		this.manager = new BuiltInNotebookManager();
+	}
+
+	public get providerId(): string {
+		return DEFAULT_NOTEBOOK_PROVIDER;
+	}
+
+	getNotebookManager(notebookUri: URI): Thenable<INotebookManager> {
+		return Promise.resolve(this.manager);
+	}
+	handleNotebookClosed(notebookUri: URI): void {
+		// No-op
+	}
+}
+
+export class BuiltInNotebookManager implements INotebookManager {
+	private _contentManager: nb.ContentManager;
+	private _sessionManager: nb.SessionManager;
+
+	constructor() {
+		this._contentManager = new LocalContentManager();
+		this._sessionManager = new SessionManager();
+	}
+
+	public get providerId(): string {
+		return DEFAULT_NOTEBOOK_PROVIDER;
+	}
+
+	public get contentManager(): nb.ContentManager {
+		return this._contentManager;
+	}
+
+	public get serverManager(): nb.ServerManager {
+		return undefined;
+	}
+
+	public get sessionManager(): nb.SessionManager {
+		return this._sessionManager;
+	}
+
+}
+
+export class SqlNotebookProvider implements INotebookProvider {
+	private manager: SqlNotebookManager;
+
+	constructor(private _instantiationService: IInstantiationService) {
+		this.manager = new SqlNotebookManager(this._instantiationService);
+	}
+
+	public get providerId(): string {
+		return SQL_NOTEBOOK_PROVIDER;
+	}
+
+	getNotebookManager(notebookUri: URI): Thenable<INotebookManager> {
+		return Promise.resolve(this.manager);
+	}
+
+	handleNotebookClosed(notebookUri: URI): void {
+		// No-op
+	}
+}
+
+export class SqlNotebookManager implements INotebookManager {
+	private _contentManager: nb.ContentManager;
+	private _sessionManager: nb.SessionManager;
+
+	constructor(private _instantiationService: IInstantiationService) {
+		this._contentManager = new LocalContentManager();
+		this._sessionManager = new SqlSessionManager(this._instantiationService);
+	}
+
+	public get providerId(): string {
+		return SQL_NOTEBOOK_PROVIDER;
+	}
+
+	public get contentManager(): nb.ContentManager {
+		return this._contentManager;
+	}
+
+	public get serverManager(): nb.ServerManager {
+		return undefined;
+	}
+
+	public get sessionManager(): nb.SessionManager {
+		return this._sessionManager;
+	}
+
+}

src/sql/workbench/services/notebook/common/sessionManager.ts

@@ -0,0 +1,216 @@
+/*---------------------------------------------------------------------------------------------
+ *  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 { nb } from 'sqlops';
+import { localize } from 'vs/nls';
+import { FutureInternal } from 'sql/parts/notebook/models/modelInterfaces';
+
+export const noKernel: string = localize('noKernel', 'No Kernel');
+const runNotebookDisabled = localize('runNotebookDisabled', 'Cannot run cells as no kernel has been configured');
+
+let noKernelSpec: nb.IKernelSpec = ({
+	name: noKernel,
+	language: 'python',
+	display_name: noKernel
+});
+
+export class SessionManager implements nb.SessionManager {
+	public get isReady(): boolean {
+		return true;
+	}
+
+	public get ready(): Thenable<void> {
+		return Promise.resolve();
+	}
+
+	public get specs(): nb.IAllKernels {
+		let allKernels: nb.IAllKernels = {
+			defaultKernel: noKernel,
+			kernels: [noKernelSpec]
+		};
+		return allKernels;
+	}
+
+	startNew(options: nb.ISessionOptions): Thenable<nb.ISession> {
+		let session = new EmptySession(options);
+		return Promise.resolve(session);
+	}
+
+	shutdown(id: string): Thenable<void> {
+		return Promise.resolve();
+	}
+}
+
+export class EmptySession implements nb.ISession {
+	private _kernel: EmptyKernel;
+	private _defaultKernelLoaded = false;
+
+	public set defaultKernelLoaded(value) {
+		this._defaultKernelLoaded = value;
+	}
+
+	public get defaultKernelLoaded(): boolean {
+		return this._defaultKernelLoaded;
+	}
+
+	constructor(private options: nb.ISessionOptions) {
+		this._kernel = new EmptyKernel();
+	}
+
+	public get canChangeKernels(): boolean {
+		return true;
+	}
+
+	public get id(): string {
+		return this.options.kernelId || '';
+	}
+
+	public get path(): string {
+		return this.options.path;
+	}
+
+	public get name(): string {
+		return this.options.name || '';
+	}
+
+	public get type(): string {
+		return this.options.type || '';
+	}
+
+	public get status(): nb.KernelStatus {
+		return 'connected';
+	}
+
+	public get kernel(): nb.IKernel {
+		return this._kernel;
+	}
+
+	changeKernel(kernelInfo: nb.IKernelSpec): Thenable<nb.IKernel> {
+		return Promise.resolve(this.kernel);
+	}
+}
+
+class EmptyKernel implements nb.IKernel {
+	public get id(): string {
+		return '-1';
+	}
+
+	public get name(): string {
+		return noKernel;
+	}
+
+	public get supportsIntellisense(): boolean {
+		return false;
+	}
+
+	public get isReady(): boolean {
+		return true;
+	}
+
+	public get ready(): Thenable<void> {
+		return Promise.resolve();
+	}
+
+	public get info(): nb.IInfoReply {
+		let info: nb.IInfoReply = {
+			protocol_version: '',
+			implementation: '',
+			implementation_version: '',
+			language_info: {
+				name: '',
+				version: '',
+			},
+			banner: '',
+			help_links: [{
+				text: '',
+				url: ''
+			}]
+		};
+
+		return info;
+	}
+	getSpec(): Thenable<nb.IKernelSpec> {
+		return Promise.resolve(noKernelSpec);
+	}
+
+	requestExecute(content: nb.IExecuteRequest, disposeOnDone?: boolean): nb.IFuture {
+		return new EmptyFuture();
+	}
+
+	requestComplete(content: nb.ICompleteRequest): Thenable<nb.ICompleteReplyMsg> {
+		let response: Partial<nb.ICompleteReplyMsg> = {};
+		return Promise.resolve(response as nb.ICompleteReplyMsg);
+	}
+
+	interrupt(): Thenable<void> {
+		return Promise.resolve(undefined);
+	}
+}
+
+export class EmptyFuture implements FutureInternal {
+
+
+	get inProgress(): boolean {
+		return false;
+	}
+
+	get msg(): nb.IMessage {
+		return undefined;
+	}
+
+	get done(): Thenable<nb.IShellMessage> {
+		let msg: nb.IShellMessage = {
+			channel: 'shell',
+			type: 'shell',
+			content: runNotebookDisabled,
+			header: undefined,
+			metadata: undefined,
+			parent_header: undefined
+		};
+
+		return Promise.resolve(msg);
+	}
+
+	sendInputReply(content: nb.IInputReply): void {
+		// no-op
+	}
+	dispose() {
+		// No-op
+	}
+
+	setReplyHandler(handler: nb.MessageHandler<nb.IShellMessage>): void {
+		// no-op
+	}
+	setStdInHandler(handler: nb.MessageHandler<nb.IStdinMessage>): void {
+		// no-op
+	}
+	setIOPubHandler(handler: nb.MessageHandler<nb.IIOPubMessage>): void {
+		setTimeout(() => {
+			let msg: nb.IIOPubMessage = {
+				channel: 'iopub',
+				type: 'iopub',
+				header: <nb.IHeader>{
+					msg_id: '0',
+					msg_type: 'error'
+				},
+				content: <nb.IErrorResult>{
+					ename: localize('errorName', 'Error'),
+					evalue: runNotebookDisabled,
+					output_type: 'error'
+				},
+				metadata: undefined,
+				parent_header: undefined
+			};
+			handler.handle(msg);
+		}, 10);
+	}
+	registerMessageHook(hook: (msg: nb.IIOPubMessage) => boolean | Thenable<boolean>): void {
+		// no-op
+	}
+	removeMessageHook(hook: (msg: nb.IIOPubMessage) => boolean | Thenable<boolean>): void {
+		// no-op
+	}
+}

src/sql/workbench/services/notebook/common/sqlSessionManager.ts

@@ -0,0 +1,325 @@
+/*---------------------------------------------------------------------------------------------
+ *  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 { nb, QueryExecuteSubsetResult, IDbColumn, DbCellValue } from 'sqlops';
+import { localize } from 'vs/nls';
+import { FutureInternal } from 'sql/parts/notebook/models/modelInterfaces';
+import QueryRunner, { EventType } from 'sql/platform/query/common/queryRunner';
+import { IConnectionManagementService } from 'sql/platform/connection/common/connectionManagement';
+import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
+import Severity from 'vs/base/common/severity';
+import * as Utils from 'sql/platform/connection/common/utils';
+import { Deferred } from 'sql/base/common/promise';
+import { Disposable } from 'vs/base/common/lifecycle';
+import { mssqlProviderName } from 'sql/platform/connection/common/constants';
+import { IErrorMessageService } from 'sql/platform/errorMessage/common/errorMessageService';
+
+export const sqlKernel: string = localize('sqlKernel', 'SQL');
+export const sqlKernelError: string = localize("sqlKernelError", "SQL kernel error");
+
+let sqlKernelSpec: nb.IKernelSpec = ({
+	name: sqlKernel,
+	language: 'sql',
+	display_name: sqlKernel
+});
+
+export interface SQLData {
+	columns: Array<string>;
+	rows: Array<Array<string>>;
+}
+
+export class SqlSessionManager implements nb.SessionManager {
+	constructor(private _instantiationService: IInstantiationService) { }
+
+	public get isReady(): boolean {
+		return true;
+	}
+
+	public get ready(): Thenable<void> {
+		return Promise.resolve();
+	}
+
+	public get specs(): nb.IAllKernels {
+		let allKernels: nb.IAllKernels = {
+			defaultKernel: sqlKernel,
+			kernels: [sqlKernelSpec]
+		};
+		return allKernels;
+	}
+
+	startNew(options: nb.ISessionOptions): Thenable<nb.ISession> {
+		let session = new SqlSession(options, this._instantiationService);
+		return Promise.resolve(session);
+	}
+
+	shutdown(id: string): Thenable<void> {
+		return Promise.resolve();
+	}
+}
+
+export class SqlSession implements nb.ISession {
+	private _kernel: SqlKernel;
+	private _defaultKernelLoaded = false;
+
+	public set defaultKernelLoaded(value) {
+		this._defaultKernelLoaded = value;
+	}
+
+	public get defaultKernelLoaded(): boolean {
+		return this._defaultKernelLoaded;
+	}
+
+	constructor(private options: nb.ISessionOptions, private _instantiationService: IInstantiationService) {
+		this._kernel = this._instantiationService.createInstance(SqlKernel);
+	}
+
+	public get canChangeKernels(): boolean {
+		return true;
+	}
+
+	public get id(): string {
+		return this.options.kernelId || '';
+	}
+
+	public get path(): string {
+		return this.options.path;
+	}
+
+	public get name(): string {
+		return this.options.name || '';
+	}
+
+	public get type(): string {
+		return this.options.type || '';
+	}
+
+	public get status(): nb.KernelStatus {
+		return 'connected';
+	}
+
+	public get kernel(): nb.IKernel {
+		return this._kernel;
+	}
+
+	changeKernel(kernelInfo: nb.IKernelSpec): Thenable<nb.IKernel> {
+		return Promise.resolve(this.kernel);
+	}
+}
+
+class SqlKernel extends Disposable implements nb.IKernel {
+	private _queryRunner: QueryRunner;
+	private _columns: IDbColumn[];
+	private _rows: DbCellValue[][];
+
+	constructor( @IConnectionManagementService private _connectionManagementService: IConnectionManagementService,
+		@IInstantiationService private _instantiationService: IInstantiationService,
+		@IErrorMessageService private _errorMessageService: IErrorMessageService) {
+		super();
+	}
+
+	public get id(): string {
+		return '-1';
+	}
+
+	public get name(): string {
+		return sqlKernel;
+	}
+
+	public get supportsIntellisense(): boolean {
+		return true;
+	}
+
+	public get isReady(): boolean {
+		// should we be checking on the tools service status here?
+		return true;
+	}
+
+	public get ready(): Thenable<void> {
+		return Promise.resolve();
+	}
+
+	public get info(): nb.IInfoReply {
+		let info: nb.IInfoReply = {
+			protocol_version: '',
+			implementation: '',
+			implementation_version: '',
+			language_info: {
+				name: 'sql',
+				version: '',
+			},
+			banner: '',
+			help_links: [{
+				text: '',
+				url: ''
+			}]
+		};
+
+		return info;
+	}
+	getSpec(): Thenable<nb.IKernelSpec> {
+		return Promise.resolve(sqlKernelSpec);
+	}
+
+	requestExecute(content: nb.IExecuteRequest, disposeOnDone?: boolean): nb.IFuture {
+		if (this._queryRunner) {
+			this._queryRunner.runQuery(content.code);
+		} else {
+			let connections = this._connectionManagementService.getActiveConnections();
+			let connectionProfile = connections.find(connection => connection.providerName === mssqlProviderName);
+			let connectionUri = Utils.generateUri(connectionProfile, 'notebook');
+			this._queryRunner = this._instantiationService.createInstance(QueryRunner, connectionUri, undefined);
+			this._connectionManagementService.connect(connectionProfile, connectionUri).then((result) => {
+				this.addQueryEventListeners(this._queryRunner);
+				this._queryRunner.runQuery(content.code);
+			});
+		}
+
+		return new SQLFuture(this._queryRunner);
+	}
+
+	requestComplete(content: nb.ICompleteRequest): Thenable<nb.ICompleteReplyMsg> {
+		let response: Partial<nb.ICompleteReplyMsg> = {};
+		return Promise.resolve(response as nb.ICompleteReplyMsg);
+	}
+
+	interrupt(): Thenable<void> {
+		return Promise.resolve(undefined);
+	}
+
+	private addQueryEventListeners(queryRunner: QueryRunner): void {
+		this._register(queryRunner.addListener(EventType.COMPLETE, () => {
+			this.queryComplete().catch(error => {
+				this._errorMessageService.showDialog(Severity.Error, sqlKernelError, error);
+			});
+		}));
+		this._register(queryRunner.addListener(EventType.MESSAGE, message => {
+			if (message.isError) {
+				this._errorMessageService.showDialog(Severity.Error, sqlKernelError, message.message);
+			}
+		}));
+	}
+
+	private async queryComplete(): Promise<void> {
+		let batches = this._queryRunner.batchSets;
+		// currently only support 1 batch set 1 resultset
+		if (batches.length > 0) {
+			let batch = batches[0];
+			if (batch.resultSetSummaries.length > 0
+				&& batch.resultSetSummaries[0].rowCount > 0
+			) {
+				let resultset = batch.resultSetSummaries[0];
+				this._columns = resultset.columnInfo;
+				let rows: QueryExecuteSubsetResult;
+				try {
+					rows = await this._queryRunner.getQueryRows(0, resultset.rowCount, batch.id, resultset.id);
+				} catch (e) {
+					return Promise.reject(e);
+				}
+				this._rows = rows.resultSubset.rows;
+			}
+		}
+		// TODO issue #2746 should ideally show a warning inside the dialog if have no data
+	}
+}
+
+export class SQLFuture extends Disposable implements FutureInternal {
+	private _msg: nb.IMessage = undefined;
+
+	constructor(private _queryRunner: QueryRunner) {
+		super();
+	}
+	get inProgress(): boolean {
+		return !this._queryRunner.hasCompleted;
+	}
+
+	get msg(): nb.IMessage {
+		return this._msg;
+	}
+
+	get done(): Thenable<nb.IShellMessage> {
+		let deferred = new Deferred<nb.IShellMessage>();
+		try {
+			this._register(this._queryRunner.onBatchEnd(e => {
+				let msg: nb.IShellMessage = {
+					channel: 'shell',
+					type: 'execute_reply',
+					content: { status: 'ok' },
+					header: undefined,
+					metadata: {},
+					parent_header: undefined
+				};
+				this._msg = msg;
+				deferred.resolve(msg);
+			}));
+		} catch {
+			return Promise.resolve(undefined);
+		}
+		return deferred.promise;
+	}
+
+	sendInputReply(content: nb.IInputReply): void {
+		// no-op
+	}
+
+	setReplyHandler(handler: nb.MessageHandler<nb.IShellMessage>): void {
+		// no-op
+	}
+	setStdInHandler(handler: nb.MessageHandler<nb.IStdinMessage>): void {
+		// no-op
+	}
+	setIOPubHandler(handler: nb.MessageHandler<nb.IIOPubMessage>): void {
+		this._register(this._queryRunner.onBatchEnd(batch => {
+			this._queryRunner.getQueryRows(0, batch.resultSetSummaries[0].rowCount, 0, 0).then(d => {
+				let data: SQLData = {
+					columns: batch.resultSetSummaries[0].columnInfo.map(c => c.columnName),
+					rows: d.resultSubset.rows.map(r => r.map(c => c.displayValue))
+				};
+				let table: HTMLTableElement = document.createElement('table');
+				table.createTHead();
+				table.createTBody();
+				let hrow = <HTMLTableRowElement>table.insertRow();
+				// headers
+				for (let column of data.columns) {
+					let cell = hrow.insertCell();
+					cell.innerHTML = column;
+				}
+
+				for (let row in data.rows) {
+					let hrow = <HTMLTableRowElement>table.insertRow();
+					for (let column in data.columns) {
+						let cell = hrow.insertCell();
+						cell.innerHTML = data.rows[row][column];
+					}
+				}
+				let tableHtml = '<table>' + table.innerHTML + '</table>';
+
+				let msg: nb.IIOPubMessage = {
+					channel: 'iopub',
+					type: 'iopub',
+					header: <nb.IHeader>{
+						msg_id: undefined,
+						msg_type: 'execute_result'
+					},
+					content: <nb.IExecuteResult>{
+						output_type: 'execute_result',
+						metadata: {},
+						execution_count: 0,
+						data: { 'text/html': tableHtml },
+					},
+					metadata: undefined,
+					parent_header: undefined
+				};
+				handler.handle(msg);
+			});
+		}));
+	}
+	registerMessageHook(hook: (msg: nb.IIOPubMessage) => boolean | Thenable<boolean>): void {
+		// no-op
+	}
+	removeMessageHook(hook: (msg: nb.IIOPubMessage) => boolean | Thenable<boolean>): void {
+		// no-op
+	}
+}