Help understanding async iterator behaviour when returning inside for loop for net socket connection

[ryankauk]

Hey there, I came across some behaviour with net server/client with async iterators I would like to understand and am hoping a node genius could explain to me.

If I use a socket connection in net server as an async iterator and return early it immediately causes the client to close. I was using this to read one message at a time (which I'll be switching to iterator.next() now), but am wondering if someone could explain why this behaviour happens.

happens with both node 16 and 18

Server

const {createServer} = require('net')
async function bootstrap() {
  const server = createServer(async (socket) => {
    console.log('socket')

    for await (const chunk of socket) {
        return;
    }
  });

  await new Promise((resolve) => {
    server.listen(process.env.PORT, () => {
      console.log(`listening on http://localhost:${process.env.PORT}`);
      resolve();
    });
  });
}

bootstrap();

Client

const { connect } = require('net');

async function bootstrap() {
  const socket = await new Promise((resolve) => {
    const socket = connect({ host: 'localhost', port: 3003 }, () => {
      resolve(socket);
    });
  });

  await new Promise((resolve) => {
    socket.write('hello');
    socket.once('close', () => {
      console.log('closes');
      resolve();
    });
  });
}

bootstrap();

[arpit9616]

The behavior you're observing is due to how the for await ... of loop works with async iterators and how you're handling the loop in your server code.

In your server code, you have the following loop:

for await (const chunk of socket) {
    return;
}

When the for await ... of loop encounters a return statement, it immediately terminates the loop and the async iterator. In your case, as soon as you receive the first chunk of data from the socket and encounter the return statement, the loop and the iterator are terminated, causing the server to effectively stop listening to the client and close the socket.

Here's the sequence of events in your server code:

1. The client connects to the server.
2. The server's socket iterator receives the first chunk of data.
3. The for await ... of loop in the server processes the first chunk, encounters the return statement, and terminates the loop.
4. Since the loop is terminated, the server's iterator is closed, which causes the socket to close.

This is why you observe the behavior where the client's socket is closed as soon as it sends the data.

If you want to read one message at a time using async iterators, you can modify your code to continue the loop without the return statement and manually close the iterator when needed. Here's an example of how you could do this:

Server:

const { createServer } = require('net');

async function bootstrap() {
  const server = createServer(async (socket) => {
    console.log('socket');

    const socketIterator = socket[Symbol.asyncIterator]();

    while (true) {
      const { done, value } = await socketIterator.next();
      if (done) break;

      console.log('Received:', value.toString());
    }
  });

  await new Promise((resolve) => {
    server.listen(process.env.PORT, () => {
      console.log(`listening on http://localhost:${process.env.PORT}`);
      resolve();
    });
  });
}

bootstrap();

Client:

const { connect } = require('net');

async function bootstrap() {
  const socket = await new Promise((resolve) => {
    const socket = connect({ host: 'localhost', port: 3003 }, () => {
      resolve(socket);
    });
  });

  socket.write('hello');
  socket.end();
}

bootstrap();

In this modified code, the server keeps listening for incoming data until the socket iterator is explicitly closed, which allows you to handle each chunk of data individually. The client's socket is ended after sending the data to signal the end of communication.