export function commActionObservable({ kernel }: NewKernelAction) {
const commOpenAction$ = kernel.channels.pipe(
ofMessageType("comm_open"),
map(commOpenAction)
);
const commMessageAction$ = kernel.channels.pipe(
ofMessageType("comm_msg"),
map(commMessageAction)
);
return merge(commOpenAction$, commMessageAction$).pipe(retry());
}
switchMap((action: NewKernelAction) =>
action.kernel.channels.pipe(
ofMessageType("update_display_data"),
map(msg => updateDisplay(msg.content)),
catchError(err =>
of({ type: ERROR_UPDATE_DISPLAY, payload: err, error: true })
)
)
export function acquireKernelInfo(channels: Channels) {
const message = createMessage("kernel_info_request");
const obs = channels.pipe(
childOf(message),
ofMessageType("kernel_info_reply"),
first(),
pluck("content", "language_info"),
map(setLanguageInfo)
);
return Observable.create(observer => {
const subscription = obs.subscribe(observer);
channels.next(message);
return subscription;
});
}
export function executeCellStream(
channels: Channels,
id: string,
message: ExecuteRequest
) {
if (!channels || !channels.pipe) {
return _throw(new Error("kernel not connected"));
}
const executeRequest = message;
// All the streams intended for all frontends
const cellMessages = channels.pipe(childOf(executeRequest));
// All the payload streams, intended for one user
const payloadStream = cellMessages.pipe(payloads());
const cellAction$ = merge(
payloadStream.pipe(map(payload => acceptPayloadMessage(id, payload))),
// All actions for updating cell status
cellMessages.pipe(
kernelStatuses(),
map(status => updateCellStatus(id, status))
),
// Update the input numbering: `[ ]`
cellMessages.pipe(
executionCounts(),
map(ct => updateCellExecutionCount(id, ct))
),
// All actions for new outputs
cellMessages.pipe(outputs(), map(output => appendOutput(id, output))),
// clear_output display message
cellMessages.pipe(ofMessageType("clear_output"), mapTo(clearOutputs(id)))
);
// On subscription, send the message
return Observable.create(observer => {
const subscription = cellAction$.subscribe(observer);
channels.next(executeRequest);
return subscription;
});
}
export function tooltipObservable(
channels: Channels,
editor: CMI,
message: Object
) {
const tip$ = channels.pipe(
childOf(message),
ofMessageType("inspect_reply"),
pluck("content"),
first(),
map(results => ({
dict: results.data
}))
);
// On subscription, send the message
return Observable.create(observer => {
const subscription = tip$.subscribe(observer);
channels.next(message);
return subscription;
});
}
concatMap((action: actions.KillKernelAction) => {
const kernelRef = action.payload.kernelRef;
const kernel = selectors.kernel(state$.value, { kernelRef });
if (!kernel) {
console.warn("tried to kill a kernel that doesn't exist");
return empty();
}
// Ignore the action if the specified kernel is not ZMQ.
if (kernel.type !== "zeromq") {
return empty();
}
const request = shutdownRequest({ restart: false });
// Try to make a shutdown request
// If we don't get a response within X time, force a shutdown
// Either way do the same cleanup
const shutDownHandling = kernel.channels.pipe(
childOf(request),
ofMessageType("shutdown_reply"),
first(),
// If we got a reply, great! :)
map(msg =>
actions.shutdownReplySucceeded({ text: msg.content, kernelRef })
),
// If we don't get a response within 2s, assume failure :(
timeout(1000 * 2),
catchError(err =>
of(actions.shutdownReplyTimedOut({ error: err, kernelRef }))
),
mergeMap(action => {
// End all communication on the channels
kernel.channels.complete();
if (kernel.spawn) {
killSpawn(kernel.spawn);
}
return merge(
// Pass on our intermediate action (whether or not kernel ACK'd shutdown request promptly)
of(action),
// Indicate overall success (channels cleaned up)
of(
actions.killKernelSuccessful({
kernelRef: kernelRef
})
),
// Inform about the state
of(
actions.setExecutionState({
kernelStatus: "shutting down",
kernelRef
})
)
);
}),
catchError(err =>
// Catch all, in case there were other errors here
of(actions.killKernelFailed({ error: err, kernelRef }))
)
);
// On subscription, send the message
return Observable.create(observer => {
const subscription = shutDownHandling.subscribe(observer);
kernel.channels.next(request);
return subscription;
});
})