mq: Delete unused and obsolete message-io module.

(gnu gnunet mq) seems to be the future.

* Makefile.am (SCM_TESTS): Remove tests/message-io.scm.
* README.org (Message queues): Remove mention of message-io.
* gnu/gnunet/mq/message-io.scm: Delete.
* tests/message-io.scm: Delete.

1 files changed, 0 insertions, 238 deletions

diff --git a/gnu/gnunet/mq/message-io.scm b/gnu/gnunet/mq/message-io.scm
deleted file mode 100644
index b19fb6b..0000000
--- a/gnu/gnunet/mq/message-io.scm
+++ /dev/null
@@ -1,238 +0,0 @@
-;; This file is part of scheme-GNUnet.
-;; Copyright (C) 2021 Maxime Devos
-;;
-;; scheme-GNUnet is free software: you can redistribute it and/or modify it
-;; under the terms of the GNU Affero General Public License as published
-;; by the Free Software Foundation, either version 3 of the License,
-;; or (at your option) any later version.
-;;
-;; scheme-GNUnet is distributed in the hope that it will be useful, but
-;; WITHOUT ANY WARRANTY; without even the implied warranty of
-;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-;; Affero General Public License for more details.
-;;
-;; You should have received a copy of the GNU Affero General Public License
-;; along with this program.  If not, see <http://www.gnu.org/licenses/>.
-;;
-;; SPDX-License-Identifier: AGPL3.0-or-later
-
-;; @author Maxime Devos (scheme-GNUnet)
-;;
-;; @brief Generic interface for sending / receiving messages
-;; TODO perhaps some kind of buffering would be useful.
-;;
-;; What's the impact on performance from having to wait on a fiber
-;; when sending / receving a message?  Maybe put the 'queue' in
-;; message queue when it makes sense.
-;;
-;; TODO integrate with message envelopes.  Maybe change the
-;; definition of envelopes.
-(define-library (gnu gnunet mq message-io)
-  (export <message-input> message-transport->input message-input?
-          read-message-operation
-          read-input-error-operation
-          close-input!
-          wait-for-input-closed-operation
-
-          <message-output> message-transport->output message-output?
-          send-message-operation
-          read-output-error-operation
-          wait-for-output-closed-operation
-          close-output!
-
-          <message-transport> make-message-transport message-transport?
-          wait-for-transport-close-operation
-          notice-input-error-operation
-          notice-output-error-operation
-          close-transport!)
-  (import (only (rnrs base)
-                begin let define lambda assert)
-          (only (fibers operations)
-                wrap-operation)
-          (only (fibers conditions)
-                make-condition signal-condition! wait-operation)
-          (only (fibers channels)
-                make-channel get-operation put-operation)
-          (only (ice-9 atomic)
-                make-atomic-box atomic-box-ref atomic-box-set!)
-          (only (rnrs records syntactic)
-                define-record-type)
-          (only (rnrs conditions)
-                define-condition-type
-                &violation
-                make-message-condition
-                make-who-condition))
-  (begin
-    
-    (define-record-type (<message-transport> make-message-transport message-transport?)
-      (fields (immutable close? transport-close-condition) ; condition
-              (immutable closed? transport-closed-condition) ; condition 
-              (immutable messages transport-messages) ; fibers channel
-              (immutable input-errors transport-input-errors) ; fibers channel
-              (immutable output-errors transport-output-errors) ; fibers channel
-              ;; TODO I don't think atomic boxes are strictly required here.
-              ;; atomic box of (#f or the errors)
-              (immutable input-errors/close transport-input-errors/close)
-              ;; atomic box of (#f or the errors)
-              (immutable output-errors/close transport-output-errors/close))
-      (protocol
-       (lambda (%make)
-         (lambda ()
-           "Return a fresh message transport.
-
-Messages will be sent from the output half-pipe to the input half-pipe.
-By default, closing the half-pipes will do nothing, and the half-pipes
-will remain marked as open.  Use @code{wait-for-transport-close-operation}
-and @code{close-transport!} to react to close requests.
-
-Errors can be sent with @code{notice-input-error-operation} and
-@code{notice-output-error-operation}.  Note that input and output
-errors are separated.
-
-No restrictions are placed upon the types of messages sent."
-           (%make (make-condition)
-                  (make-condition)
-                  (make-channel)
-                  (make-channel)
-                  (make-channel)
-                  (make-atomic-box #f)
-                  (make-atomic-box #f)))))
-      (opaque #t)
-      (sealed #f))
-
-    (define-record-type (<message-input> message-transport->input message-input?)
-      (fields (immutable transport message-input-transport))
-      (protocol
-       (lambda (%make)
-         (lambda (transport)
-           "Return an input queue corresponding to the transport
-@var{transport}.  Currently, this is a fresh object, but that might
-change in the future."
-           (assert (message-transport? transport))
-           (%make transport))))
-      (opaque #t)
-      (sealed #f))
-
-    (define-record-type (<message-output> message-transport->output message-output?)
-      (fields (immutable transport message-output-transport))
-      (protocol
-       (lambda (%make)
-         (lambda (transport)
-           "Return an output queue corresponding to the transport
-@var{transport}.  Currently, this is a fresh object, but that might
-change in the future."
-           (assert (message-transport? transport))
-           (%make transport))))
-      (opaque #t)
-      (sealed #f))
-
-    (define (close-input! in)
-      "Close the input queue @var{in} (asynchronuous).
-@code{wait-for-input-closed-operation} can be used to wait
-until the queue has been closed.  This has the same effect
-as @code{close-output!} on the output queue."
-      (assert (message-input? in))
-      (signal-condition!
-       (transport-close-condition (message-input-transport in))))
-
-    (define (close-output! out)
-      "Close the output queue @var{in} (asynchronuous).
-@code{wait-for-output-closed-operation} can be used to wait
-until the queue has been closed.  This has the same effect
-as @code{close-input!} on the input queue."
-      (assert (message-output? out))
-      (signal-condition!
-       (transport-close-condition (message-output-transport out))))
-
-    (define (read-message-operation in)
-      "Return an operation for reading a message from the input queue @var{in}.
-
-The operation will block until a message has been read, so this should probably
-be combined with @code{wait-for-input-closed-operation} and
-@code{read-input-error-operation}."
-      (assert (message-input? in))
-      (get-operation (transport-messages (message-input-transport in))))
-
-    (define (send-message-operation out msg)
-      "Make an operation for sending a message @var{msg} into the output queue
-@var{out}.
-
-The operation will block until the message has been sent (though it may take
-some time before it ends up on the other side of the network, and some kind
-of output error could happen in-between), so this should probably be combined
-with @code{wait-for-output-closed-operation} and @code{read-output-error-operation}"
-      (assert (message-output? out))
-      (put-operation (transport-messages (message-output-transport out)) msg))
-
-    (define (read-input-error-operation in)
-      "Return an operation for reading the next input error from the
-input queue @var{in}."
-      (assert (message-input? in))
-      (get-operation (transport-input-errors (message-input-transport in))))
-
-    (define (read-output-error-operation out)
-      "Return an operation for reading the next output error from the
-output queue @var{out}."
-      (assert (message-output? out))
-      (get-operation (transport-output-errors (message-output-transport out))))
-
-    (define (wait-for-transport-close-operation transport)
-      "Return an operation for waiting upon a close request
-from the input or output queue."
-      (assert (message-transport? transport))
-      (wait-operation (transport-close-condition transport)))
-
-    (define (close-transport! transport input-errors output-errors)
-      "Close the transport @var{transport}, with some closing input errors
-and closing output errors @var{input-errors} and @var{output-errors}.
-This marks the input and output queues as closed.
-XXX double closes probably should be detected."
-      (assert (message-transport? transport))
-      (atomic-box-set! (transport-input-errors/close transport)
-                       input-errors)
-      (atomic-box-set! (transport-output-errors/close transport)
-                       output-errors)
-      (signal-condition!
-       (transport-closed-condition transport)))
-
-    (define (notice-input-error-operation transport error)
-      "Return an operation for indicating the transport @var{transport}
-noticed an input error @var{error}.  This will block if no fiber is waiting
-for an input error, so this procedure should probably not be used after
-the transport has been closed."
-      (assert (message-transport? transport))
-      (put-operation (transport-input-errors transport) error))
-
-    (define (notice-output-error-operation transport error)
-      "Return an operation for indicating the transport @var{transport}
-noticed an output error @var{error}.   This will block if no fiber is waiting
-for an output error, so this procedure should probably not be used after
-the transport has been closed."
-      (assert (message-transport? transport))
-      (put-operation (transport-output-errors transport) error))
-
-    (define (wait-for-output-closed-operation out)
-      "Return an operation for waiting until the output queue @var{out}
-has been closed.  This has the same effect as waiting until the corresponding
-input queue has been closed, except the return values are presumably different.
-Any output errors happening during the closing are returned in a data structure
-according to the transport."
-      (assert (message-output? out))
-      (let ((transport (message-output-transport out)))
-        (wrap-operation
-         (wait-operation (transport-closed-condition transport))
-         (lambda ()
-           (atomic-box-ref (transport-output-errors/close transport))))))
-
-    (define (wait-for-input-closed-operation in)
-      "Return an operation for waiting until the input queue @var{in}
-has been closed.  This has the same effect as waiting until the corresponding
-output queue has been closed, except the return values are presumably different.
-Any input errors happening during the closing are returned in a data structure
-according to the transport."
-      (assert (message-input? in))
-      (let ((transport (message-input-transport in)))
-        (wrap-operation
-         (wait-operation (transport-closed-condition transport))
-         (lambda ()
-           (atomic-box-ref (transport-input-errors/close transport))))))))