TCP

// TCP is how most programs talk over a network: a web browser and a server, a database and its
// clients. One side listens on a port; the other connects to it; then each has a stream it can
// write bytes into and read the other side's bytes from, in order and without loss.
//
// The `Net` package gives each side a type. A `TcpListener` is bound to an address and accepts
// connections, one `TcpStream` each; a client makes its `TcpStream` with `Connect`. A stream is
// an `Io` reader and writer, so `WriteAll`, `ReadLineFrom` and everything else from the files
// lessons works on it. Every failure is an `IoError`, with kinds such as `ConnectionRefused`.
//
// A stream is only bytes: TCP keeps no message boundaries, so the two sides agree on their own.
// Here each message is one line. Both sides run in this one program — the server in `Main`, the
// client on a second thread — and talk over the loopback address, 127.0.0.1, which never leaves
// the machine.
import Allocator::SystemAllocator;
import Io::{ IoError, IoErrorKind, PrintLine, ReadLineFrom, WriteAll };
import Net::{ IpAddress, Ipv4Address, ShutdownDirection, SocketAddress, TcpListener, TcpStream };
import Text::{ StringBuilder, ToAsciiUpper };
import Thread::Spawn;

// The client: connect, send three lines, read a reply to each, then say it has finished.
// It returns how many replies it read, so it prints nothing and the output stays in order.
func Client(server: SocketAddress) -> uint {
    var stream = TcpStream::Connect(server) catch { else => return 0 };
    let messages: char8[..][3] = ["hello\n", "how are you?\n", "bye\n"];
    var reply = StringBuilder(SystemAllocator());
    var replies: uint = 0;
    for message in messages {
        WriteAll(stream, message) catch { else => return replies };
        ReadLineFrom(stream, reply) catch { else => return replies };
        replies = replies + 1;
        reply.Clear();
    }
    // Shutting down the writing half tells the server no more is coming; the stream itself
    // closes when `stream` is dropped at the end of the function.
    stream.Shutdown(ShutdownDirection::Write) catch { else => return replies };
    return replies;
}

func Main() -> ! IoError {
    // Port 0 asks the system for any free port; `LocalAddress` says which one it chose. It
    // differs between runs, so this program never prints it.
    let loopback = IpAddress::FromIpv4(Ipv4Address::Localhost());
    let listener = TcpListener::Bind(SocketAddress::New(loopback, 0))?;
    let address = listener.LocalAddress()?;
    PrintLine("server: listening on 127.0.0.1, port chosen? {}", address.port != 0);

    // The client runs on its own thread, so the server can wait for it here.
    var client = Spawn(Client, address) catch { else => fail IoError::Of(IoErrorKind::Other) };

    // `Accept` waits for a connection and hands back a stream for it.
    var stream = listener.Accept()?;
    let peer = stream.PeerAddress()?;
    PrintLine("server: a client connected from loopback? {}", peer.ip.IsLoopback());

    // Read a line, answer it, and go on until the client shuts its side down.
    var line = StringBuilder(SystemAllocator());
    while true {
        match ReadLineFrom(stream, line) {
            .Success(_) => {},
            .Failure(error) if error.IsEnd() => break,
            .Failure(error) => fail error
        }
        let loud = ToAsciiUpper(SystemAllocator(), line.View()) catch {
            else => fail IoError::Of(IoErrorKind::Other)
        };
        PrintLine("server: received [{}], replying [{}]", line.View(), loud);
        WriteAll(stream, loud.Bytes())?;
        WriteAll(stream, "\n")?;
        line.Clear();
    }
    PrintLine("server: the client has finished");
    PrintLine("client: read {} replies", client.Join());

    // A stream is a reader and a writer, but it is not copied — each one owns its connection:
    //
    //     let other = stream;
    //         error: move-only value 'stream' requires an explicit '<-' in initialization
}