Allow for kernel I/O to be disconnected by a client manually

Previously, the kernel I/O would be established at client creation
time and was unable to be disconnected for the lifetime of the
client.  The issue with this was that the same kernel could be used
for different clients at different times, as such a client may receive
unwanted kernel messages at those later times when another client is
connected.  This change allows for a manual disconnect from the
kernel's I/O and connecting to it again at a later time.

* jupyter-client.el (jupyter-connect): New function.
(jupyter-disconnect): Modified to account for change.

* jupyter-kernel-process.el (jupyter-zmq-io): Add connect and
disconnect messages to allow for a client to start and stop the I/O
connection at will.

* jupyter-server-kernel.el (jupyter-websocket-io): Ditto. Removed the
`shutdown` indicator.

Author: nnicandro

jupyter-client.el

@@ -411,8 +411,19 @@ KERNEL is the name of the kernelspec as returned by the
 shell command."
   (jupyter-client (jupyter-get-kernelspec kernel) client-class))
 
+(cl-defmethod jupyter-connect ((client jupyter-kernel-client))
+  "Connect to the I/O of a CLIENT's kernel.
+If the I/O of the CLIENT to the kernel is disconnected, it means
+messages will no longer be received on the client side although
+messages from other client's could still be exchanged between the
+kernel and those others."
+  (jupyter-run-with-io (jupyter-kernel-action-subscriber client)
+    (jupyter-publish (list 'connect))))
+
 (cl-defmethod jupyter-disconnect ((client jupyter-kernel-client))
-  (slot-makeunbound client 'io))
+  "Disconnect from the I/O of a CLIENT's kernel."
+  (jupyter-run-with-io (jupyter-kernel-action-subscriber client)
+    (jupyter-publish (list 'disconnect))))
 
 (cl-defmethod jupyter-client ((spec jupyter-kernelspec) &optional client-class)
   "Return a client connected to kernel created from SPEC.

jupyter-kernel-process.el

@@ -252,6 +252,9 @@ Call the next method if ARGS does not contain a :spec or
                      (jupyter-shutdown kernel)
                      (stop)
                      (setq shutdown t))
+                    ((and op (or 'connect 'disconnect))
+                     (if (eq op 'connect) (stop)
+                       (start)))
                     ('restart
                      (setq shutdown nil)
                      (jupyter-restart kernel)

jupyter-server-kernel.el

@@ -240,15 +240,12 @@ this case FN will be evaluated on KERNEL."
              (reauth-pub (or (gethash server jupyter--reauth-subscribers)
                              (setf (gethash server jupyter--reauth-subscribers)
                                    (jupyter-publisher))))
-             (shutdown nil)
              (kernel-io
               (jupyter-publisher
                 (lambda (event)
                   (pcase event
                     (`(message . ,rest) (jupyter-content rest))
                     (`(send ,channel ,msg-type ,content ,msg-id)
-                     (when shutdown
-                       (error "Attempting to send message to shutdown kernel"))
                      (let ((send
                             (lambda ()
                               (websocket-send-text
@@ -264,8 +261,6 @@ this case FN will be evaluated on KERNEL."
                           (setq ws (funcall make-websocket))
                           (funcall send)))))
                     ('start
-                     (when shutdown
-                       (error "Can't start I/O connection to shutdown kernel"))
                      (unless (websocket-openp ws)
                        (setq ws (funcall make-websocket))))
                     ('stop (websocket-close ws))))))
@@ -313,11 +308,18 @@ this case FN will be evaluated on KERNEL."
                 (pcase action
                   ('interrupt
                    (jupyter-interrupt kernel))
+                  ((and op (or 'connect 'disconnect))
+                   (if (eq op 'disconnect)
+                       (progn
+                         (or (null ws)
+                             (websocket-close ws))
+                         (setq ws (funcall make-websocket)))
+                     (websocket-close ws)
+                     (setq ws nil)))
                   ('shutdown
                    (jupyter-shutdown kernel)
-                   (setq shutdown t)
-                   (when (websocket-openp ws)
-                     (websocket-close ws)))
+                   (websocket-close ws)
+                   (setq ws nil))
                   ('restart
                    (jupyter-restart kernel))
                   (`(action ,fn)