On this page:

 (require mzlib/thread)

(coroutine proc)  coroutine?
  proc : ((any/c . -> . void?) . -> . any/c)
Returns a coroutine object to encapsulate a thread that runs only when allowed. The proc procedure should accept one argument, and proc is run in the coroutine thread when coroutine-run is called. If coroutine-run returns due to a timeout, then the coroutine thread is suspended until a future call to coroutine-run. Thus, proc only executes during the dynamic extent of a coroutine-run call.

The argument to proc is a procedure that takes a boolean, and it can be used to disable suspends (in case proc has critical regions where it should not be suspended). A true value passed to the procedure enables suspends, and #f disables suspends. Initially, suspends are allowed.

(coroutine? v)  any
  v : any/c
Returns #t if v is a coroutine produced by coroutine, #f otherwise.

(coroutine-run until coroutine)  boolean?
  until : (or/c evt? real?)
  coroutine : coroutine?
Allows the thread associated with coroutine to execute for up as long as until milliseconds (of until is a real number) or until is ready (if until is an event). If coroutine’s procedure disables suspends, then the coroutine can run arbitrarily long until it re-enables suspends.

The coroutine-run procedure returns #t if coroutine’s procedure completes (or if it completed earlier), and the result is available via coroutine-result. The coroutine-run procedure returns #f if coroutine’s procedure does not complete before it is suspended after timeout-secs. If coroutine’s procedure raises an exception, then it is re-raised by coroutine-run.

(coroutine-result coroutine)  any
  coroutine : coroutine
Returns the result for coroutine if it has completed with a value (as opposed to an exception), #f otherwise.

(coroutine-kill coroutine)  void?
  coroutine : coroutine?
Forcibly terminates the thread associated with coroutine if it is still running, leaving the coroutine result unchanged.

(consumer-thread f [init])  
thread? procedure?
  f : procedure?
  init : (-> any) = void
Returns two values: a thread descriptor for a new thread, and a procedure with the same arity as f.

When the returned procedure is applied, its arguments are queued to be passed on to f, and #<void> is immediately returned. The thread created by consumer-thread dequeues arguments and applies f to them, removing a new set of arguments from the queue only when the previous application of f has completed; if f escapes from a normal return (via an exception or a continuation), the f-applying thread terminates.

The init argument is a procedure of no arguments; if it is provided, init is called in the new thread immediately after the thread is created.

(run-server port-no    
  accept/break])  void?
  port-no : (integer-in 1 65535)
  conn-proc : (input-port? output-port? . -> . any)
  conn-timeout : (and/c real? (not/c negative?))
  handler : (exn? . -> . any/c) = void
  listen : 
((integer-in 1 65535) (one-of/c 5) (one-of/c #t)
 . -> . listener?)
   = tcp-listen
  close : (listener? . -> . any) = tcp-close
  accept : (listener? . ->* . (input-port? output-port?))
   = tcp-accept
  accept/break : (listener? . ->* . (input-port? output-port?))
   = tcp-accept/enable-break
Executes a TCP server on the port indicated by port-no. When a connection is made by a client, conn is called with two values: an input port to receive from the client, and an output port to send to the client.

Each client connection is managed by a new custodian, and each call to conn occurs in a new thread (managed by the connection’s custodian). If the thread executing conn terminates for any reason (e.g., conn returns), the connection’s custodian is shut down. Consequently, conn need not close the ports provided to it. Breaks are enabled in the connection thread if breaks are enabled when run-server is called.

To facilitate capturing a continuation in one connection thread and invoking it in another, the parameterization of the run-server call is used for every call to handler. In this parameterization and for the connection’s thread, the current-custodian parameter is assigned to the connection’s custodian.

If conn-timeout is not #f, then it must be a non-negative number specifying the time in seconds that a connection thread is allowed to run before it is sent a break signal. Then, if the thread runs longer than (* conn-timeout 2) seconds, then the connection’s custodian is shut down. If conn-timeout is #f, a connection thread can run indefinitely.

If handler is provided, it is passed exceptions related to connections (i.e., exceptions not caught by conn-proc, or exceptions that occur when trying to accept a connection). The default handler ignores the exception and returns #<void>.

The run-server function uses listen, close, accept and accept/break in the same way as it might use tcp-listen, tcp-close, tcp-accept, and tcp-accept/enable-break to accept connections. Provide alternate procedures to use an alternate communication protocol (such as SSL) or to supply optional arguments in the use of tcp-listen. The listener? part of the contract indicates that the procedures must all work on the same kind of listener value.

The run-server procedure loops to serve client connections, so it never returns. If a break occurs, the loop will cleanly shut down the server, but it will not terminate active connections.