TypeScript selectors.serverConfig函数代码示例

    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
              })
            )
          )
        );
    })

    concatMap((action: actions.KillKernelAction) => {
      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 serverConfig: ServerConfig = selectors.serverConfig(host);

      const kernel = selectors.currentKernel(state);
      if (!kernel) {
        return of(
          actions.killKernelFailed({
            error: new Error("kernel not available for killing"),
            kernelRef: action.payload.kernelRef
          })
        );
      }

      if (kernel.type !== "websocket" || !kernel.id || !kernel.sessionId) {
        return of(
          actions.killKernelFailed({
            error: new Error(
              "websocket kernel epic can only kill websocket kernels with an id"
            ),
            kernelRef: action.payload.kernelRef
          })
        );
      }

      // TODO: If this was a kernel language change, we shouldn't be using this
      //       kill kernel epic because we need to make sure that creation happens
      //       after deletion
      return sessions.destroy(serverConfig, kernel.sessionId).pipe(
        map(() =>
          actions.killKernelSuccessful({
            kernelRef: action.payload.kernelRef
          })
        ),
        catchError(err =>
          of(
            actions.killKernelFailed({
              error: err,
              kernelRef: action.payload.kernelRef
            })
          )
        )
      );
    })

    mergeMap((action: actions.FetchKernelspecs) => {
      const {
        payload: { hostRef, kernelspecsRef }
      } = action;
      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 serverConfig: ServerConfig = selectors.serverConfig(host);

      return kernelspecs.list(serverConfig).pipe(
        map(data => {
          const defaultKernelName = data.response.default;
          const kernelspecs: { [key: string]: KernelspecProps } = {};
          Object.keys(data.response.kernelspecs).forEach(key => {
            const value = data.response.kernelspecs[key];
            kernelspecs[key] = {
              name: value.name,
              resources: value.resources,
              argv: value.spec.argv,
              displayName: value.spec.display_name,
              env: value.spec.env,
              interruptMode: value.spec.interrupt_mode,
              language: value.spec.language,
              metadata: value.spec.metadata
            };
          });
          return actions.fetchKernelspecsFulfilled({
            hostRef,
            kernelspecsRef,
            defaultKernelName,
            kernelspecs
          });
        }),
        catchError(error => {
          return of(actions.fetchKernelspecsFailed({ kernelspecsRef, error }));
        })
      );
    })

//.........这里部分代码省略.........
          };
        } 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
              })
            );
          }
          case actions.SAVE: {
            const serverConfig: ServerConfig = selectors.serverConfig(host);

            // Check to see if the file was modified since the last time we saved
            // TODO: Determine how we handle what to do
            // Don't bother doing this if the file is new(?)
            return contents.get(serverConfig, filepath, { content: 0 }).pipe(
              // Make sure that the modified time is within some delta
              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);
                }
                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
                      })
                    )
                  )
                );
              })
            );
          }
          default:
            // NOTE: Flow types and our ofType should prevent reaching here, this
            // is here merely as safety
            return empty();
        }
      }

    switchMap((action: actions.LaunchKernelByNameAction) => {
      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 serverConfig: ServerConfig = selectors.serverConfig(host);

      const {
        payload: { kernelSpecName, cwd, kernelRef, contentRef }
      } = action;

      const content = selectors.content(state, { contentRef });
      if (!content || content.type !== "notebook") {
        return empty();
      }

      // TODO: Create a START_SESSION action instead (?)
      const sessionPayload = {
        kernel: {
          id: null,
          name: kernelSpecName
        },
        name: "",
        // TODO: Figure where the leading slash comes from in the content store
        path: content.filepath.replace(/^\/+/g, ""),
        type: "notebook"
      };

      // TODO: Handle failure cases here
      return sessions.create(serverConfig, sessionPayload).pipe(
        mergeMap(data => {
          const session = data.response;

          const sessionId = castToSessionId(session.id);

          const kernel: RemoteKernelProps = Object.assign({}, session.kernel, {
            type: "websocket",
            info: null,
            sessionId,
            cwd,
            channels: kernels.connect(
              serverConfig,
              session.kernel.id,
              sessionId
            ),
            kernelSpecName
          });

          kernel.channels.next(kernelInfoRequest());

          return of(
            actions.launchKernelSuccessful({
              kernel,
              kernelRef,
              contentRef: action.payload.contentRef,
              selectNextKernel: true
            })
          );
        }),
        catchError(error => {
          return of(actions.launchKernelFailed({ error }));
        })
      );
    })