allow /openNotebook handler to read from a url

brettfo · colombod · commit 3e516a050faa · 2021-05-25T22:11:46.000+01:00
diff --git a/README.md b/README.md
@@ -39,6 +39,10 @@ There are several ways to get started using .NET with Jupyter, including Jupyter
 
 You can find additional documentation [here](./docs/README.md).
 
+## Test Script
+
+Open the VS Code extension test script in [VS Code - Insiders](vscode-insiders://ms-dotnettools.dotnet-interactive-vscode/openNotebook?url=https%3A%2F%2Fraw.githubusercontent.com%2Fdotnet%2Finteractive%2Fmain%2FNotebookTestScript.dib).
+
 ## Packages
 
 We provide a number of packages that can be used to write custom [extensions](./docs/extending-dotnet-interactive.md) for .NET Interactive or to build your own interactive experiences.
diff --git a/src/dotnet-interactive-vscode/common/vscode/extension.ts b/src/dotnet-interactive-vscode/common/vscode/extension.ts
@@ -13,7 +13,7 @@ import { StdioKernelTransport } from '../stdioKernelTransport';
 import { registerLanguageProviders } from './languageProvider';
 import { registerAcquisitionCommands, registerKernelCommands, registerFileCommands } from './commands';
 
-import { getSimpleLanguage, isDotnetInteractiveLanguage, isJupyterNotebookViewType } from '../interactiveNotebook';
+import { getSimpleLanguage, isDotnetInteractiveLanguage, isJupyterNotebookViewType, jupyterViewType } from '../interactiveNotebook';
 import { InteractiveLaunchOptions, InstallInteractiveArgs } from '../interfaces';
 
 import { executeSafe, getWorkingDirectoryForNotebook, isDotNetUpToDate, processArguments } from '../utilities';
@@ -62,36 +62,6 @@ export async function activate(context: vscode.ExtensionContext) {
     // this must happen early, because some following functions use the acquisition command
     registerAcquisitionCommands(context, diagnosticsChannel);
 
-    vscode.window.registerUriHandler({
-        handleUri(uri: vscode.Uri): vscode.ProviderResult<void> {
-            const params = new URLSearchParams(uri.query);
-            switch (uri.path) {
-                case '/newNotebook':
-                    // Examples:
-                    //   vscode://ms-dotnettools.dotnet-interactive-vscode/newNotebook?as=dib
-                    //   vscode://ms-dotnettools.dotnet-interactive-vscode/newNotebook?as=ipynb
-                    const asType = params.get('as');
-                    vscode.commands.executeCommand('dotnet-interactive.acquire').then(() => {
-                        const commandName = asType === 'ipynb'
-                            ? 'dotnet-interactive.newNotebookIpynb'
-                            : 'dotnet-interactive.newNotebookDib';
-                        vscode.commands.executeCommand(commandName).then(() => { });
-                    });
-                    break;
-                case '/openNotebook':
-                    // Example
-                    //   vscode://ms-dotnettools.dotnet-interactive-vscode/openNotebook?path=C%3A%5Cpath%5Cto%5Cnotebook.dib
-                    const path = params.get('path');
-                    if (path) {
-                        vscode.commands.executeCommand('dotnet-interactive.acquire').then(() => {
-                            vscode.commands.executeCommand('dotnet-interactive.openNotebook', vscode.Uri.file(path)).then(() => { });
-                        });
-                    }
-                    break;
-            }
-        }
-    });
-
     async function kernelTransportCreator(notebookUri: vscodeLike.Uri): Promise<contracts.KernelTransport> {
         if (!await checkForDotNetSdk(minDotNetSdkVersion!)) {
             const message = 'Unable to find appropriate .NET SDK.';
@@ -150,6 +120,41 @@ export async function activate(context: vscode.ExtensionContext) {
     };
     const clientMapper = new ClientMapper(clientMapperConfig);
 
+    vscode.window.registerUriHandler({
+        handleUri(uri: vscode.Uri): vscode.ProviderResult<void> {
+            const params = new URLSearchParams(uri.query);
+            switch (uri.path) {
+                case '/newNotebook':
+                    // Examples:
+                    //   vscode://ms-dotnettools.dotnet-interactive-vscode/newNotebook?as=dib
+                    //   vscode://ms-dotnettools.dotnet-interactive-vscode/newNotebook?as=ipynb
+                    const asType = params.get('as');
+                    vscode.commands.executeCommand('dotnet-interactive.acquire').then(() => {
+                        const commandName = asType === 'ipynb'
+                            ? 'dotnet-interactive.newNotebookIpynb'
+                            : 'dotnet-interactive.newNotebookDib';
+                        vscode.commands.executeCommand(commandName).then(() => { });
+                    });
+                    break;
+                case '/openNotebook':
+                    // Open a local notebook
+                    //   vscode://ms-dotnettools.dotnet-interactive-vscode/openNotebook?path=C%3A%5Cpath%5Cto%5Cnotebook.dib
+                    // New untitled notebook from remote source
+                    //   vscode://ms-dotnettools.dotnet-interactive-vscode/openNotebook?url=http%3A%2F%2Fexample.com%2Fnotebook.dib
+                    const notebookPath = params.get('path');
+                    const url = params.get('url');
+                    if (notebookPath) {
+                        vscode.commands.executeCommand('dotnet-interactive.acquire').then(() => {
+                            vscode.commands.executeCommand('dotnet-interactive.openNotebook', vscode.Uri.file(notebookPath)).then(() => { });
+                        });
+                    } else if (url) {
+                        versionSpecificFunctions.openNotebookFromUrl(url, clientMapper, diagnosticsChannel).then(() => { });
+                    }
+                    break;
+            }
+        }
+    });
+
     registerKernelCommands(context, clientMapper);
 
     const hostVersionSuffix = isInsidersBuild() ? 'Insiders' : 'Stable';
diff --git a/src/dotnet-interactive-vscode/insiders/src/notebookSerializers.ts b/src/dotnet-interactive-vscode/insiders/src/notebookSerializers.ts
@@ -16,21 +16,14 @@ import { createUri } from './common/utilities';
 abstract class DotNetNotebookSerializer implements vscode.NotebookSerializer {
 
     private serializerId = '*DOTNET-INTERACTIVE-NOTEBOOK-SERIALIZATION*';
-    private disposable: vscode.Disposable;
     private eol: Eol;
 
     constructor(
-        notebookType: string,
         private readonly clientMapper: ClientMapper,
         private readonly outputChannel: OutputChannelAdapter,
         private readonly extension: string,
     ) {
         this.eol = getEol();
-        this.disposable = vscode.notebook.registerNotebookSerializer(notebookType, this);
-    }
-
-    dispose(): void {
-        this.disposable.dispose();
     }
 
     async deserializeNotebook(content: Uint8Array, token: vscode.CancellationToken): Promise<vscode.NotebookData> {
@@ -88,13 +81,31 @@ function toNotebookCell(cell: vscode.NotebookCellData): contracts.NotebookCell {
 
 export class DotNetDibNotebookSerializer extends DotNetNotebookSerializer {
     constructor(clientMapper: ClientMapper, outputChannel: OutputChannelAdapter) {
-        super('dotnet-interactive', clientMapper, outputChannel, '.dib');
+        super(clientMapper, outputChannel, '.dib');
+    }
+
+    static registerNotebookSerializer(context: vscode.ExtensionContext, notebookType: string, clientMapper: ClientMapper, outputChannel: OutputChannelAdapter) {
+        const serializer = new DotNetDibNotebookSerializer(clientMapper, outputChannel);
+        const notebookSerializer = vscode.notebook.registerNotebookSerializer(notebookType, serializer);
+        context.subscriptions.push(notebookSerializer);
     }
 }
 
 export class DotNetLegacyNotebookSerializer extends DotNetNotebookSerializer {
     constructor(clientMapper: ClientMapper, outputChannel: OutputChannelAdapter) {
-        super('dotnet-interactive-legacy', clientMapper, outputChannel, '.dib');
+        super(clientMapper, outputChannel, '.dib');
+    }
+
+    static registerNotebookSerializer(context: vscode.ExtensionContext, notebookType: string, clientMapper: ClientMapper, outputChannel: OutputChannelAdapter) {
+        const serializer = new DotNetLegacyNotebookSerializer(clientMapper, outputChannel);
+        const notebookSerializer = vscode.notebook.registerNotebookSerializer(notebookType, serializer);
+        context.subscriptions.push(notebookSerializer);
+    }
+}
+
+export class DotNetJupyterNotebookSerializer extends DotNetNotebookSerializer {
+    constructor(clientMapper: ClientMapper, outputChannel: OutputChannelAdapter) {
+        super(clientMapper, outputChannel, '.ipynb');
     }
 }
 
diff --git a/src/dotnet-interactive-vscode/insiders/src/versionSpecificFunctions.ts b/src/dotnet-interactive-vscode/insiders/src/versionSpecificFunctions.ts
@@ -1,6 +1,7 @@
 // Copyright (c) .NET Foundation and contributors. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
+import * as path from 'path';
 import * as vscode from 'vscode';
 import * as contracts from './common/interfaces/contracts';
 import * as vscodeLike from './common/interfaces/vscode-like';
@@ -14,6 +15,7 @@ import * as notebookSerializers from './notebookSerializers';
 import { ClientMapper } from './common/clientMapper';
 import { OutputChannelAdapter } from './common/vscode/OutputChannelAdapter';
 import { ErrorOutputCreator } from './common/interactiveClient';
+import fetch from 'node-fetch';
 
 export function registerWithVsCode(context: vscode.ExtensionContext, clientMapper: ClientMapper, outputChannel: OutputChannelAdapter, createErrorOutput: ErrorOutputCreator, ...preloadUris: vscode.Uri[]) {
     const config = {
@@ -22,8 +24,8 @@ export function registerWithVsCode(context: vscode.ExtensionContext, clientMappe
         createErrorOutput,
     };
     context.subscriptions.push(new notebookControllers.DotNetNotebookKernel(config));
-    context.subscriptions.push(new notebookSerializers.DotNetDibNotebookSerializer(clientMapper, outputChannel));
-    context.subscriptions.push(new notebookSerializers.DotNetLegacyNotebookSerializer(clientMapper, outputChannel));
+    notebookSerializers.DotNetDibNotebookSerializer.registerNotebookSerializer(context, 'dotnet-interactive', clientMapper, outputChannel);
+    notebookSerializers.DotNetLegacyNotebookSerializer.registerNotebookSerializer(context, 'dotnet-interactive-legacy', clientMapper, outputChannel);
 }
 
 export function endExecution(cell: vscode.NotebookCell, success: boolean) {
@@ -80,3 +82,35 @@ export async function createNewBlankNotebook(extension: string, _openNotebook: (
     const notebook = await vscode.notebook.openNotebookDocument(viewType, content);
     const _editor = await vscode.window.showNotebookDocument(notebook);
 }
+
+export async function openNotebookFromUrl(notebookUrl: string, clientMapper: ClientMapper, diagnosticsChannel: OutputChannelAdapter): Promise<void> {
+    await vscode.commands.executeCommand('dotnet-interactive.acquire');
+    const extension = path.extname(notebookUrl);
+    let serializer: notebookSerializers.DotNetDibNotebookSerializer | undefined = undefined;
+    let viewType: string | undefined = undefined;
+    switch (extension) {
+        case '.dib':
+        case '.dotnet-interactive':
+            serializer = new notebookSerializers.DotNetDibNotebookSerializer(clientMapper, diagnosticsChannel);
+            viewType = 'dotnet-interactive';
+            break;
+        case '.ipynb':
+            serializer = new notebookSerializers.DotNetJupyterNotebookSerializer(clientMapper, diagnosticsChannel);
+            viewType = 'jupyter-notebook';
+            break;
+    }
+
+    if (serializer && viewType) {
+        try {
+            const response = await fetch(notebookUrl);
+            const arrayBuffer = await response.arrayBuffer();
+            const content = new Uint8Array(arrayBuffer);
+            const cancellationTokenSource = new vscode.CancellationTokenSource();
+            const notebookData = await serializer.deserializeNotebook(content, cancellationTokenSource.token);
+            const notebook = await vscode.notebook.openNotebookDocument(viewType, notebookData);
+            const _editor = await vscode.window.showNotebookDocument(notebook);
+        } catch (e) {
+            vscode.window.showWarningMessage(`Unable to read notebook from '${notebookUrl}': ${e}`);
+        }
+    }
+}
diff --git a/src/dotnet-interactive-vscode/stable/src/versionSpecificFunctions.ts b/src/dotnet-interactive-vscode/stable/src/versionSpecificFunctions.ts
@@ -62,3 +62,7 @@ function getNewNotebookName(extension: string): string {
     } while (workspaceHasUnsavedNotebookWithName(filename));
     return filename;
 }
+
+export async function openNotebookFromUrl(notebookUrl: string, clientMapper: ClientMapper, diagnosticsChannel: OutputChannelAdapter): Promise<void> {
+    // NOOP
+}

Original file line number	Diff line number	Diff line change
`@@ -62,3 +62,7 @@ function getNewNotebookName(extension: string): string {`
`62`	`62`	`} while (workspaceHasUnsavedNotebookWithName(filename));`
`63`	`63`	`return filename;`
`64`	`64`	`}`
	`65`	`+`
	`66`	`+export async function openNotebookFromUrl(notebookUrl: string, clientMapper: ClientMapper, diagnosticsChannel: OutputChannelAdapter): Promise<void> {`
	`67`	`+ // NOOP`
	`68`	`+}`