Introduction to net module

The Net module in Node.js provides the ability to create network servers and clients, facilitating communication between computers or devices over the Internet. Whether you want to build a chat application, transfer data between systems, or create a networked game, the Net module is a fundamental building block. In this topic, we will explore the basics of the Net module and learn how to create TCP servers and clients.

Working with the net module

When working with the Net module, the first step is to include it in your Node.js application using the require statement:

const net = require('node:net');

Once included, the net object becomes available, providing functions and methods to handle network-related tasks. With the Net module, you can create a TCP server that listens for incoming connections. You can also handle data received from clients, and manage client disconnections. Similarly, you can create a TCP client that establishes a connection with a server, sends data, and handles data received from the server.

Creating a TCP server

Once you have the net module imported, you can create a TCP server using the net.createServer() method. This method takes a callback function as a parameter, which will be called whenever a new client connection is established. Inside this callback function, you can define how your server should handle client requests.

Here's a basic example of creating a TCP server that echoes back any data received from the client:

Setting up a TCP server in server.js:

const net = require('node:net');

const server = net.createServer((client) => {
  console.log('Client connected');

  // When data is received from the client
  client.on('data', (data) => {
    console.log(`Received data from client: ${data}`);

    // Echo the received data back to the client
    client.write(data);
  });

  // When the client disconnects
  client.on('end', () => {
    console.log('Client disconnected');
  });
});

In the code above, we're creating a server and listening for the 'data' event on the client socket. Whenever data is received from the client, we log the received data and write it back to the client using the client.write() method. When the client disconnects, we handle the 'end' event and log a message indicating the disconnection.

Once you have defined your server, you need to tell it to start listening for incoming client connections. You can do this by calling the server.listen() method and specifying the port number you want your server to listen on. Here's an example:

Making the server listen for connections in server.js:

// Specify the port
const port = 3000;

// Make the server listen for connections
server.listen(port, () => {
  console.log(`Server is listening on port ${server.address().port}`);
});

In the above code, the listen function in the net module is used to start a server and make it listen on a specific port. The first parameter of the listen function specifies the port number on which the server will listen for incoming connections. The second parameter is a callback function that gets executed once the server has started listening.

Now, if you run your Node.js application, your TCP server will start and listen for client connections on the specified port. Clients can establish a connection to your server using the server's IP address and port number.

Creating a TCP client

In Node.js, you can use the net module to create a TCP client. This client enables server communication via the Transmission Control Protocol (TCP). Let's explore how to create a TCP client in Node.js.

Once you have the net module available, you can create a TCP client by calling the net.createConnection() method. This method takes the port number and server address as parameters and returns a socket object representing the client side of the connection.

Here's an example of creating a TCP client and connecting it to a server:

const client = net.createConnection({ port: 3000, host: 'localhost' }, () => {
  console.log('Connected to server');
  
  // Send data to the server
  client.write('Hello, server!');
});

In the above code, we create a TCP client and connect it to a server running on localhost (your own computer) at port 3000. Once the connection is established, the callback function is executed, and we log a message to indicate that the client is connected. We also send a message to the server using the client.write() method.

To receive data from the server, you can listen for the 'data' event on the client socket:

client.on('data', (data) => {
  console.log(`Received data from server: ${data}`);
  
  // Close the connection after receiving data
  client.end();
});

In the code above, we listen for the 'data' event and log the received data from the server. We also close the connection using the client.end() method after receiving the data.

It's important to handle errors and gracefully close the connection when necessary. You can listen for the 'error' and 'end' events on the client socket to handle errors and disconnections, respectively.

When the client disconnects, the server detects this event and logs a message indicating that the client has disconnected.

By handling these events, you ensure that the server behaves predictably in different scenarios, which is a key aspect of building robust network applications.

Handling errors in net modules

When working with the net module in Node.js to create TCP servers and clients, it's important to handle errors that may occur during the network communication process. Two common errors you may encounter are ERR_SERVER_ALREADY_LISTEN and EADDRINUSE. Let's understand how to handle these errors effectively.

ERR_SERVER_ALREADY_LISTEN: This error occurs when you attempt to start a TCP server on a port that is already in use by another process. To handle this error, you can use a try...catch block to catch the error and provide appropriate error-handling logic. Here's an example:

try {
  server.listen(port, () => {
    console.log(`Server is listening on port ${port}`);
  });
} catch (error) {
  if (error.code === 'ERR_SERVER_ALREADY_LISTEN') {
    console.error('Server is already listening on the specified port');
  } else {
    console.error('An error occurred while starting the server:', error);
  }
}

In the above code, we try to start the server using server.listen() and catch any errors that occur. If the error code matches ERR_SERVER_ALREADY_LISTEN, we log a specific error message indicating that the server is already listening on the specified port. Otherwise, we provide a generic error message for any other errors that may occur.

EADDRINUSE: This error occurs when you attempt to create a TCP client and connect to a server on a port that is already being used by another process. To handle this error, you can listen for the 'error' event on the client socket and check if the error code is 'EADDRINUSE'. Here's an example:

server.on('error', (error) => {
  if (error.code === 'EADDRINUSE') {
    console.log('Address in use, retrying...');
    setTimeout(() => {
      server.close();
      server.listen(port, () => {
        console.log(`Server is listening on port ${port}`);
      });
    }, 1000);
  } else {
    console.error('An error occurred while starting the server:', error);
  }
});

In this code, the server listens for the error event. When the event occurs, the callback function checks if the error code is EADDRINUSE. If it matches, it logs the message Address in use, retrying....

To resolve the conflict, the code includes a setTimeout function with a delay of 1 second (1000 milliseconds). After the delay, it attempts to close the previous server instance using server.close() and then restart the server on the same port by calling server.listen() again.

This approach provides a retry mechanism, allowing the server to automatically retry after a brief delay if the specified port is already in use.

By handling these errors gracefully, you can improve the robustness of your network applications and provide meaningful feedback to users. Remember to consider the specific requirements of your application and implement appropriate error-handling strategies accordingly.

Conclusion

The net module in Node.js enables you to create TCP servers and clients for network communication. By utilizing this module, you can establish connections, exchange data, and build robust networked applications. With effective error handling, you can ensure the reliability and resilience of your applications. Embrace the possibilities of Node.js networking and unleash your creativity in building innovative solutions.