Initial Move from Azure DevOps to GitHub

src/Explorer/Controls/Notebook/NotebookAppMessageHandler.ts

@@ -0,0 +1,80 @@
+/**
+ * Message handler to communicate with NotebookApp iframe
+ */
+import Q from "q";
+import * as _ from "underscore";
+
+import { HashMap } from "../../../Common/HashMap";
+import { CachedDataPromise } from "../../../Common/MessageHandler";
+import * as Constants from "../../../Common/Constants";
+import {
+  MessageTypes,
+  FromNotebookMessage,
+  FromNotebookResponseMessage,
+  FromDataExplorerMessage
+} from "../../../Terminal/NotebookAppContracts";
+
+export class NotebookAppMessageHandler {
+  private requestMap: HashMap<CachedDataPromise<any>>;
+
+  constructor(private targetIFrameWindow: Window) {
+    this.requestMap = new HashMap();
+  }
+
+  public handleCachedDataMessage(message: FromNotebookMessage): void {
+    const messageContent = message && (message.message as FromNotebookResponseMessage);
+    if (
+      message == null ||
+      messageContent == null ||
+      messageContent.id == null ||
+      !this.requestMap.has(messageContent.id)
+    ) {
+      return;
+    }
+
+    const cachedDataPromise = this.requestMap.get(messageContent.id);
+    if (messageContent.error != null) {
+      cachedDataPromise.deferred.reject(messageContent.error);
+    } else {
+      cachedDataPromise.deferred.resolve(messageContent.data);
+    }
+    this.runGarbageCollector();
+  }
+
+  public sendCachedDataMessage<TResponseDataModel>(
+    messageType: MessageTypes,
+    params?: any
+  ): Q.Promise<TResponseDataModel> {
+    let cachedDataPromise: CachedDataPromise<TResponseDataModel> = {
+      deferred: Q.defer<TResponseDataModel>(),
+      startTime: new Date(),
+      id: _.uniqueId()
+    };
+    this.requestMap.set(cachedDataPromise.id, cachedDataPromise);
+    this.sendMessage({ type: messageType, params: params, id: cachedDataPromise.id });
+
+    //TODO: Use telemetry to measure optimal time to resolve/reject promises
+    return cachedDataPromise.deferred.promise.timeout(
+      Constants.ClientDefaults.requestTimeoutMs,
+      "Timed out while waiting for response from portal"
+    );
+  }
+
+  public sendMessage(data: FromDataExplorerMessage): void {
+    if (!this.targetIFrameWindow) {
+      console.error("targetIFrame not defined. This is not expected");
+      return;
+    }
+
+    this.targetIFrameWindow.postMessage(data, window.location.href || window.document.referrer);
+  }
+
+  protected runGarbageCollector() {
+    this.requestMap.keys().forEach((key: string) => {
+      const promise: Q.Promise<any> = this.requestMap.get(key).deferred.promise;
+      if (promise.isFulfilled() || promise.isRejected()) {
+        this.requestMap.delete(key);
+      }
+    });
+  }
+}

src/Explorer/Controls/Notebook/NotebookTerminalComponent.less

@@ -0,0 +1,13 @@
+@import "../../../../less/Common/Constants";
+
+.notebookTerminalContainer {
+  padding: @DefaultSpace;
+  height: 100%;
+  width: 100%;
+
+  iframe {
+    border: none;
+    height: 100%;
+    width: 100%;
+  }
+}

src/Explorer/Controls/Notebook/NotebookTerminalComponent.test.tsx

@@ -0,0 +1,158 @@
+import * as DataModels from "../../../Contracts/DataModels";
+import { NotebookTerminalComponent } from "./NotebookTerminalComponent";
+
+const createTestDatabaseAccount = (): DataModels.DatabaseAccount => {
+  return {
+    id: "testId",
+    kind: "testKind",
+    location: "testLocation",
+    name: "testName",
+    properties: {
+      cassandraEndpoint: null,
+      documentEndpoint: "https://testDocumentEndpoint.azure.com/",
+      gremlinEndpoint: null,
+      tableEndpoint: null
+    },
+    tags: "testTags",
+    type: "testType"
+  };
+};
+
+const createTestMongo32DatabaseAccount = (): DataModels.DatabaseAccount => {
+  return {
+    id: "testId",
+    kind: "testKind",
+    location: "testLocation",
+    name: "testName",
+    properties: {
+      cassandraEndpoint: null,
+      documentEndpoint: "https://testDocumentEndpoint.azure.com/",
+      gremlinEndpoint: null,
+      tableEndpoint: null
+    },
+    tags: "testTags",
+    type: "testType"
+  };
+};
+
+const createTestMongo36DatabaseAccount = (): DataModels.DatabaseAccount => {
+  return {
+    id: "testId",
+    kind: "testKind",
+    location: "testLocation",
+    name: "testName",
+    properties: {
+      cassandraEndpoint: null,
+      documentEndpoint: "https://testDocumentEndpoint.azure.com/",
+      gremlinEndpoint: null,
+      tableEndpoint: null,
+      mongoEndpoint: "https://testMongoEndpoint.azure.com/"
+    },
+    tags: "testTags",
+    type: "testType"
+  };
+};
+
+const createTestCassandraDatabaseAccount = (): DataModels.DatabaseAccount => {
+  return {
+    id: "testId",
+    kind: "testKind",
+    location: "testLocation",
+    name: "testName",
+    properties: {
+      cassandraEndpoint: "https://testCassandraEndpoint.azure.com/",
+      documentEndpoint: null,
+      gremlinEndpoint: null,
+      tableEndpoint: null
+    },
+    tags: "testTags",
+    type: "testType"
+  };
+};
+
+const createTerminal = (): NotebookTerminalComponent => {
+  return new NotebookTerminalComponent({
+    notebookServerInfo: {
+      authToken: "testAuthToken",
+      notebookServerEndpoint: "https://testNotebookServerEndpoint.azure.com/"
+    },
+    databaseAccount: createTestDatabaseAccount()
+  });
+};
+
+const createMongo32Terminal = (): NotebookTerminalComponent => {
+  return new NotebookTerminalComponent({
+    notebookServerInfo: {
+      authToken: "testAuthToken",
+      notebookServerEndpoint: "https://testNotebookServerEndpoint.azure.com/mongo"
+    },
+    databaseAccount: createTestMongo32DatabaseAccount()
+  });
+};
+
+const createMongo36Terminal = (): NotebookTerminalComponent => {
+  return new NotebookTerminalComponent({
+    notebookServerInfo: {
+      authToken: "testAuthToken",
+      notebookServerEndpoint: "https://testNotebookServerEndpoint.azure.com/mongo"
+    },
+    databaseAccount: createTestMongo36DatabaseAccount()
+  });
+};
+
+const createCassandraTerminal = (): NotebookTerminalComponent => {
+  return new NotebookTerminalComponent({
+    notebookServerInfo: {
+      authToken: "testAuthToken",
+      notebookServerEndpoint: "https://testNotebookServerEndpoint.azure.com/cassandra"
+    },
+    databaseAccount: createTestCassandraDatabaseAccount()
+  });
+};
+
+describe("NotebookTerminalComponent", () => {
+  it("getTerminalParams: Test for terminal", () => {
+    const terminal: NotebookTerminalComponent = createTerminal();
+    const params: Map<string, string> = terminal.getTerminalParams();
+
+    expect(params).toEqual(
+      new Map<string, string>([["terminal", "true"]])
+    );
+  });
+
+  it("getTerminalParams: Test for Mongo 3.2 terminal", () => {
+    const terminal: NotebookTerminalComponent = createMongo32Terminal();
+    const params: Map<string, string> = terminal.getTerminalParams();
+
+    expect(params).toEqual(
+      new Map<string, string>([
+        ["terminal", "true"],
+        ["terminalEndpoint", new URL(terminal.props.databaseAccount.properties.documentEndpoint).host]
+      ])
+    );
+  });
+
+  it("getTerminalParams: Test for Mongo 3.6 terminal", () => {
+    const terminal: NotebookTerminalComponent = createMongo36Terminal();
+    const params: Map<string, string> = terminal.getTerminalParams();
+
+    expect(params).toEqual(
+      new Map<string, string>([
+        ["terminal", "true"],
+        ["terminalEndpoint", new URL(terminal.props.databaseAccount.properties.mongoEndpoint).host]
+      ])
+    );
+  });
+
+  it("getTerminalParams: Test for Cassandra terminal", () => {
+    const terminal: NotebookTerminalComponent = createCassandraTerminal();
+    const params: Map<string, string> = terminal.getTerminalParams();
+
+    expect(params).toEqual(
+      new Map<string, string>([
+        ["terminal", "true"],
+        ["terminalEndpoint", new URL(terminal.props.databaseAccount.properties.cassandraEndpoint).host]
+      ])
+    );
+  });
+});

src/Explorer/Controls/Notebook/NotebookTerminalComponent.tsx

@@ -0,0 +1,90 @@
+/**
+ * Wrapper around Notebook server terminal
+ */
+
+import * as React from "react";
+import * as DataModels from "../../../Contracts/DataModels";
+import { Logger } from "../../../Common/Logger";
+import { NotificationConsoleUtils } from "../../../Utils/NotificationConsoleUtils";
+import { ConsoleDataType } from "../../Menus/NotificationConsole/NotificationConsoleComponent";
+import { StringUtils } from "../../../Utils/StringUtils";
+
+export interface NotebookTerminalComponentProps {
+  notebookServerInfo: DataModels.NotebookWorkspaceConnectionInfo;
+  databaseAccount: DataModels.DatabaseAccount;
+}
+
+export class NotebookTerminalComponent extends React.Component<NotebookTerminalComponentProps> {
+  constructor(props: NotebookTerminalComponentProps) {
+    super(props);
+  }
+
+  public render(): JSX.Element {
+    return (
+      <div className="notebookTerminalContainer">
+        <iframe
+          title="Terminal to Notebook Server"
+          src={NotebookTerminalComponent.createNotebookAppSrc(this.props.notebookServerInfo, this.getTerminalParams())}
+        />
+      </div>
+    );
+  }
+
+  public getTerminalParams(): Map<string, string> {
+    let params: Map<string, string> = new Map<string, string>();
+    params.set("terminal", "true");
+
+    const terminalEndpoint: string = this.tryGetTerminalEndpoint();
+    if (terminalEndpoint) {
+      params.set("terminalEndpoint", terminalEndpoint);
+    }
+
+    return params;
+  }
+
+  public tryGetTerminalEndpoint(): string | null {
+    let terminalEndpoint: string | null;
+
+    const notebookServerEndpoint: string = this.props.notebookServerInfo.notebookServerEndpoint;
+    if (StringUtils.endsWith(notebookServerEndpoint, "mongo")) {
+      let mongoShellEndpoint: string = this.props.databaseAccount.properties.mongoEndpoint;
+      if (!mongoShellEndpoint) {
+        // mongoEndpoint is only available for Mongo 3.6 and higher.
+        // Fallback to documentEndpoint otherwise.
+        mongoShellEndpoint = this.props.databaseAccount.properties.documentEndpoint;
+      }
+      terminalEndpoint = mongoShellEndpoint;
+    } else if (StringUtils.endsWith(notebookServerEndpoint, "cassandra")) {
+      terminalEndpoint = this.props.databaseAccount.properties.cassandraEndpoint;
+    }
+
+    if (terminalEndpoint) {
+      return new URL(terminalEndpoint).host;
+    }
+    return null;
+  }
+
+  public static createNotebookAppSrc(
+    serverInfo: DataModels.NotebookWorkspaceConnectionInfo,
+    params: Map<string, string>
+  ): string {
+    if (!serverInfo.notebookServerEndpoint) {
+      const error = "Notebook server endpoint not defined. Terminal will fail to connect to jupyter server.";
+      Logger.logError(error, "NotebookTerminalComponent/createNotebookAppSrc");
+      NotificationConsoleUtils.logConsoleMessage(ConsoleDataType.Error, error);
+      return "";
+    }
+
+    params.set("server", serverInfo.notebookServerEndpoint);
+    if (serverInfo.authToken && serverInfo.authToken.length > 0) {
+      params.set("token", serverInfo.authToken);
+    }
+
+    let result: string = "terminal.html?";
+    for (let key of params.keys()) {
+      result += `${key}=${encodeURIComponent(params.get(key))}&`;
+    }
+
+    return result;
+  }
+}