feat: TCP socket support using LibUV

[algebraic-dev]

This PR introduces TCP socket support using the LibUV library, enabling asynchronous I/O operations with it.

[leanprover-community-bot]

Mathlib CI status (docs):

• ❗ Batteries/Mathlib CI will not be attempted unless your PR branches off the nightly-with-mathlib branch. Try git rebase 9b629cc81f01642200eb0762da39b2935652754c --onto 9b74c07767dc50645efa00356a7724e7f7176227. (2025-01-23 05:57:38)
• ❗ Batteries/Mathlib CI will not be attempted unless your PR branches off the nightly-with-mathlib branch. Try git rebase 104b3519d79f5996dd6d325cba18d94a4615e418 --onto 20c616503abe5ce4253c56dbcd7766a91c675ba0. (2025-01-30 00:33:23)
• ❗ Batteries/Mathlib CI will not be attempted unless your PR branches off the nightly-with-mathlib branch. Try git rebase 104b3519d79f5996dd6d325cba18d94a4615e418 --onto a35bf7ee4c4d900475d88886825a5337f389bd0f. (2025-01-30 00:52:24)
• ❗ Batteries/Mathlib CI will not be attempted unless your PR branches off the nightly-with-mathlib branch. Try git rebase 104b3519d79f5996dd6d325cba18d94a4615e418 --onto e922edfc218090ab2e54092336c67fe3b970dfc2. (2025-01-30 17:26:52)
• ❗ Batteries/Mathlib CI will not be attempted unless your PR branches off the nightly-with-mathlib branch. Try git rebase 104b3519d79f5996dd6d325cba18d94a4615e418 --onto 832d7c500d709deb5e7f0a5a6fd0f01865d1a303. (2025-02-04 04:01:35)
• ❗ Batteries/Mathlib CI will not be attempted unless your PR branches off the nightly-with-mathlib branch. Try git rebase 5eca093a89bc7dcd09e54b0a9c71bb3472d66709 --onto b01ca8ee237a1b3c299384e73ad79d424e216a84. (2025-02-08 00:17:56)

[hargoniX]

I think this is very promising now! There's mostly on memory leaks and stylistic things left but the implementation looks like it should be able to work now.

Beyond these issues it would of course be great if we could also have some tests like for Timer that exercise this API. I would assume you can just connect to localhost and do an echo or something like that? Of course we should have tests for both IPv4 and v6.

After we have those tests I guess it might also be a good idea to write a little benchmark to see how many TCP connections we can handle per second to get an estimate of what kind of load we can expect to handle at best given this implementation.

[TwoFX]

I feel that it's not well explained what exactly this function does.

• What exactly does the size parameter represent? Is the ByteArray we eventually end up with always going to have size size?
• When exactly does the returned task resolve?

I'm currently trying to port the following simple Java echo server:

        try (ServerSocket serverSocket = new ServerSocket(8080, 1, InetAddress.getLoopbackAddress())) {
            System.out.println("Echo server listening on localhost:8080");
            
            while (true) {
                System.out.println("Going to connect");
                try (Socket clientSocket = serverSocket.accept();
                     BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
                     PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true)) {
                    System.out.println("Connected.");
                    String inputLine;
                    while ((inputLine = in.readLine()) != null) {
                        System.out.println("Received: " + inputLine);
                        out.println(inputLine);
                        System.out.println("Reading another...");
                    }
                    System.out.println("Loop exited...");
                } catch (IOException e) {
                    System.err.println("Error handling client: " + e.getMessage());
                }
            }
        } catch (IOException e) {
            System.err.println("Could not listen on port 8080: " + e.getMessage());
        }

But I'm not sure how to detect with the Lean API that the client has disconnected. I have the following Lean skeleton, and I don't know how to fill in the inner while condition.

def server : IO Unit := do
  let sock ← Socket.mk
  sock.bind (.v4 <| .mk (.ofParts 127 0 0 1) 8080)
  sock.listen 1
  while true do
    let connToClient ← (← sock.accept).block
    while ???????? do
      let receive ← connToClient.recv 10000
      let data ← receive.block
      let str := String.fromUTF8! data
      println! "Received: {str}"
      let send ← connToClient.send data
      send.block

[algebraic-dev]

The recv function will throw the error resource vanished (error code: 4294967242, connection reset by peer). You just need to catch the error and assume that it's not connected anymore.

The size parameter defines the maximum amount of data that can be received in a single call. This means the function will retrieve up to this limit, and any remaining data will be delivered in the next calls.

The code now is:

def server : IO Unit := do
  let sock ← Socket.Server.mk

  try
    sock.bind (.v4 <| .mk (.ofParts 127 0 0 1) 8080)
  catch err =>
    IO.eprintln s!"ould not listen on port 8080: {err}"
    return

  sock.listen 1
  IO.println "Echo server listening on localhost:8080"

  while true do
    IO.println "Going to connect"
    let connToClient ← (← sock.accept).block

    while true do
      try
        let receive ← connToClient.recv 10000
        let data ← receive.block
        println! "Received: {data.size}"
      catch err =>
        match err with
        | .resourceVanished _ _ => do IO.println "Disconnected"; break
        | err => IO.eprintln s!"Error handling client: {err}"
    IO.println "Loop exited.."

[TwoFX]

I see, thanks!
Do you think it would be feasible to add an overview to all of the docstrings about which IO errors callers may want to handle? At the moment it seems to me that it's quite difficult to write robust code without a lot of knowledge about the low-level details.

[TwoFX]

Also, perhaps it would be possible to add functions that allow inspecting the state of the socket without trying something and looking at the errors? Like Socket.Client.isBound, Socket.Client.isConnected and so on?