switchMap(action => {
      if (!action.payload || typeof action.payload.filepath !== "string") {
        return of({
          type: "ERROR",
          error: true,
          payload: { error: new Error("updating content needs a payload") }
        }) as any;
      }

      const state: any = state$.value;
      const host: any = selectors.currentHost(state);

      // Dismiss any usage that isn't targeting a jupyter server
      if (host.type !== "jupyter") {
        return empty();
      }

      const { contentRef, filepath, prevFilePath } = action.payload;
      const serverConfig: ServerConfig = selectors.serverConfig(host);

      return contents
        .update(serverConfig, prevFilePath, { path: filepath.slice(1) })
        .pipe(
          tap(xhr => {
            if (xhr.status !== 200) {
              throw new Error(xhr.response);
            }
          }),
          map(() => {
            /*
             * Modifying the url's file name in the browser.
             * This effects back button behavior.
             * Is there a better way to accomplish this?
             */
            window.history.replaceState(
              {},
              filepath,
              urljoin(host.basePath, `/nteract/edit${filepath}`)
            );

            return actions.changeContentNameFulfilled({
              contentRef: action.payload.contentRef,
              filepath: action.payload.filepath,
              prevFilePath
            });
          }),
          catchError((xhrError: any) =>
            of(
              actions.changeContentNameFailed({
                basepath: host.basepath,
                filepath: action.payload.filepath,
                prevFilePath,
                error: xhrError,
                contentRef: action.payload.contentRef
              })
            )
          )
        );
    })

              mergeMap(xhr => {
                // TODO: What does it mean if we have a failed GET on the content
                if (xhr.status !== 200) {
                  throw new Error(xhr.response.toString());
                }
                if (typeof xhr.response === "string") {
                  throw new Error(
                    `jupyter server response invalid: ${xhr.response}`
                  );
                }

                const model = xhr.response;

                const diskDate = new Date(model.last_modified);
                const inMemoryDate = content.lastSaved
                  ? new Date(content.lastSaved)
                  : // FIXME: I'm unsure if we don't have a date if we should default to the disk date
                    diskDate;
                const diffDate = diskDate.getTime() - inMemoryDate.getTime();

                if (Math.abs(diffDate) > 600) {
                  return of(
                    actions.saveFailed({
                      error: new Error("open in another tab possibly..."),
                      contentRef: action.payload.contentRef
                    })
                  );
                }

                return contents.save(serverConfig, filepath, saveModel).pipe(
                  map((xhr: AjaxResponse) => {
                    return actions.saveFulfilled({
                      contentRef: action.payload.contentRef,
                      model: xhr.response
                    });
                  }),
                  catchError((error: Error) =>
                    of(
                      actions.saveFailed({
                        error,
                        contentRef: action.payload.contentRef
                      })
                    )
                  )
                );
              })

      mergeMap(({ response }) => {
        const filepath: string = response.path;

        const sessionPayload: SessionPayload = {
          kernel: {
            id: null,
            name: ks.name
          },
          name: "",
          path: filepath,
          type: "notebook"
        };

        return forkJoin(
          // Get their kernel started up
          sessions.create(serverConfig, sessionPayload),
          // Save the initial notebook document
          contents.save(serverConfig, filepath, {
            content: notebook,
            type: "notebook"
          })
        );
      }),

      (
        action: actions.Save | actions.DownloadContent
      ):
        | Observable<
            | actions.DownloadContentFailed
            | actions.DownloadContentFulfilled
            | actions.SaveFailed
            | actions.SaveFulfilled
          >
        | Observable<never> => {
        const state = state$.value;

        const host = selectors.currentHost(state);
        if (host.type !== "jupyter") {
          // Dismiss any usage that isn't targeting a jupyter server
          return empty();
        }
        const contentRef = action.payload.contentRef;
        const content = selectors.content(state, { contentRef });

        // NOTE: This could save by having selectors for each model type
        //       have toDisk() selectors
        //       It will need to be cased off when we have more than one type
        //       of content we actually save
        if (!content) {
          const errorPayload = {
            error: new Error("Content was not set."),
            contentRef: action.payload.contentRef
          };
          if (action.type === actions.DOWNLOAD_CONTENT) {
            return of(actions.downloadContentFailed(errorPayload));
          }
          return of(actions.saveFailed(errorPayload));
        }

        if (content.type === "directory") {
          // Don't save directories
          return empty();
        }

        let filepath = content.filepath;

        // This could be object for notebook, or string for files
        let serializedData: Notebook | string;
        let saveModel: Partial<contents.Payload> = {};
        if (content.type === "notebook") {
          const appVersion = selectors.appVersion(state);

          // contents API takes notebook as raw JSON whereas downloading takes
          // a string
          serializedData = toJS(
            content.model.notebook.setIn(
              ["metadata", "nteract", "version"],
              appVersion
            )
          );
          saveModel = {
            content: serializedData,
            type: content.type
          };
        } else if (content.type === "file") {
          serializedData = content.model.text;
          saveModel = {
            content: serializedData,
            type: content.type,
            format: "text"
          };
        } else {
          // We shouldn't save directories
          return empty();
        }

        switch (action.type) {
          case actions.DOWNLOAD_CONTENT: {
            // FIXME: Convert this to downloadString, so it works for both files & notebooks
            if (
              content.type === "notebook" &&
              typeof serializedData === "object"
            ) {
              downloadString(
                stringifyNotebook(serializedData),
                filepath || "notebook.ipynb",
                "application/json"
              );
            } else if (
              content.type === "file" &&
              typeof serializedData === "string"
            ) {
              downloadString(
                serializedData,
                filepath,
                content.mimetype || "application/octet-stream"
              );
            } else {
              // This shouldn't happen, is here for safety
              return empty();
            }
            return of(
              actions.downloadContentFulfilled({
                contentRef: action.payload.contentRef
//.........这里部分代码省略.........

export function openNotebook(
  host: JupyterHostRecord,
  ks: KernelspecRecord | KernelspecProps,
  props: {
    appVersion: string;
    baseDir: string;
    appBase: string;
  }
): void {
  const serverConfig: any = selectors.serverConfig(host);

  // The notebook they get to start with
  const notebook: Notebook = {
    cells: [
      {
        cell_type: "code",
        execution_count: null,
        metadata: {},
        outputs: [],
        source: [""]
      }
    ],
    metadata: {
      kernelspec: {
        display_name: ks.displayName,
        language: ks.language,
        name: ks.name
      },
      nteract: {
        version: props.appVersion
      }
    },
    nbformat: 4,
    nbformat_minor: 2
  };

  // NOTE: For the sake of expediency, all the logic to launch a new is
  //       happening here instead of an epic
  contents
    // Create UntitledXYZ.ipynb by letting the server do it
    .create<"notebook">(serverConfig, props.baseDir, {
      type: "notebook"
      // NOTE: The contents API appears to ignore the content field for new
      // notebook creation.
      //
      // It would be nice if it could take it. Instead we'll create a new
      // notebook for the user and redirect them after we've put in the
      // content we want.
      //
      // Amusingly, this could be used for more general templates to, as
      // well as introduction notebooks.
    })
    .pipe(
      // We only expect one response, it's ajax and we want this subscription
      // to finish so we don't have to unsubscribe
      first(),
      mergeMap(({ response }) => {
        const filepath: string = response.path;

        const sessionPayload: SessionPayload = {
          kernel: {
            id: null,
            name: ks.name
          },
          name: "",
          path: filepath,
          type: "notebook"
        };

        return forkJoin(
          // Get their kernel started up
          sessions.create(serverConfig, sessionPayload),
          // Save the initial notebook document
          contents.save(serverConfig, filepath, {
            content: notebook,
            type: "notebook"
          })
        );
      }),
      first(),
      map(([_session, content]) => {
        const { response } = content;

        if (content.status > 299 || typeof response === "string") {
          // hack around this old hack around for creating a notebook
          // from the directory ideally this would be in a proper epic
          // instead of leaky async code here
          const message: string[] = ["Failed to create notebook due to: "];

          if (typeof response === "string") {
            message.push(response);
          } else {
            message.push(JSON.stringify(response));
          }

          alert(message.join(""));

          return;
        }

//.........这里部分代码省略.........