Net

IoT.js provides asynchronous networking through Net module. You can use this module with require('net') and create both servers and clients.

net.connect(options[, connectListener])

  • options {Object} An object which specifies the connection options.
  • connectListener {Function} Listener for the 'connect' event.
  • Returns {net.Socket}.

Creates a new net.Socket and automatically connects with the supplied options. The options object specifies the following information:

  • port {number} Port connect to (required).
  • host {string} Host connect to (optional, Default: localhost).
  • family {number} Version of IP stack.

The options are passed to both the net.Socket constructor and the socket.connect method. The connectListener is automatically registered as a 'connect' event listener.

Example

  2. var net = require('net');
  4. var port = 22702;
  6. var echo_msg = '';
  8. var socket = net.connect({port: port, family: 4}, function() {
  9.   socket.end('Hello IoT.js');
  10. });
  12. socket.on('data', function(data) {
  13.   echo_msg += data;
  14. });
  16. socket.on('end', function() {
  17.   console.log(echo_msg);
  18. });

net.connect(port[, host][, connectListener])

  • port {number} Port the client should connect to.
  • host {string} Host the client should connect to. Default: localhost.
  • connectListener {Function} Listener for the 'connect' event.
  • Returns {net.Socket}.

Creates a new net.Socket and automatically connects to the supplied port and host. If host is omitted, localhost will be assumed. The connectListener is automatically registered as a 'connect' event listener.

Example

  2. var net = require('net');
  4. var port = 22702;
  5. var host = '127.0.0.1';
  6. var echo_msg = '';
  8. var socket = net.connect(port, host, function() {
  9.   socket.end('Hello IoT.js');
  10. });
  12. socket.on('data', function(data) {
  13.   echo_msg += data;
  14. });
  16. socket.on('end', function() {
  17.   console.log(echo_msg);
  18. });

net.createConnection(options[, connectListener])

  • options {Object} An object which specifies the connection options.
  • connectListener {Function} Listener for the 'connect' event.
  • Returns {net.Socket}.

Creates a new net.Socket and automatically connects with the supplied options. The options are passed to both the net.Socket constructor and the socket.connect method. The options object specifies the following information:

  • port {number} Port connect to (required).
  • host {string} Host connect to (optional, Default: localhost).
  • family {number} Version of IP stack.

The connectionListener is automatically registered as a 'connect' event listener.

Example

  2. var net = require('net');
  4. var port = 80;
  6. var echo_msg = '';
  8. var socket = net.createConnection({port: port, family: 4}, function() {
  9.   socket.end('Hello IoT.js');
  10. });
  12. socket.on('data', function(data) {
  13.   echo_msg += data;
  14. });
  16. socket.on('end', function() {
  17.   console.log(echo_msg);
  18. });

net.createConnection(port[, host][, connectListener])

  • port {number} Port the client should connect to.
  • host {string} Host the client should connect to. Default: localhost.
  • connectListener {Function} Listener for the 'connect' event.
  • Returns {net.Socket}.

Creates a new net.Socket and automatically connects to the supplied port and host. It is equivalent to new net.Socket() followed by socket.connect(). If host is omitted, localhost will be assumed. The connectionListener is automatically registered as a 'connect' event listener.

Example

  2. var net = require('net');
  4. var port = 22702;
  5. var host = '127.0.0.1';
  6. var echo_msg = '';
  8. var socket = net.createConnection(port, host, function() {
  9.   socket.end('Hello IoT.js');
  10. });
  12. socket.on('data', function(data) {
  13.   echo_msg += data;
  14. });
  16. socket.on('end', function() {
  17.   console.log(echo_msg);
  18. });

net.createServer([options][, connectionListener])

  • options {Object} An object which specifies the connection options Default: { allowHalfOpen: false }.
  • connectListener {Function} Listener for the 'connection' event.
  • Returns {net.Server}.

Creates a TCP server according to options. The connectionListener is automatically registered as a 'connection' event listener. If allowHalfOpen is true, then the socket becomes non-readable, but still writable. You should call the socket.end() method explicitly.

Example

  2. var net = require('net');
  4. var port = 22702;
  6. var server = net.createServer(
  7.   {
  8.     allowHalfOpen: true
  9.   },
  10.   function(socket) {
  11.     server.close();
  12.   }
  13. );
  15. server.listen(port);
  17. server.on('connection', function(socket) {
  18.   var msg = '';
  19.   socket.on('data', function(data) {
  20.     msg += data;
  21.   });
  22.   socket.on('end', function() {
  23.     socket.end(msg);
  24.   });
  25. });

Class: net.Server

This class is used to create a TCP or local server. You can create net.Server instance with net.createServer().

server.close([closeListener])

  • closeListener {Function} Listener for the 'close' event.

Stops listening new arriving connection. Server socket will be finally closed when all existing connections are closed, then emits 'close' event. The closeListener is registered as a 'close' event listener.

Example

  2. var net = require('net');
  4. var server = net.createServer();
  5. var port = 22704;
  6. var timeout = 1000;
  8. server.listen(port);
  10. /* ... */
  12. server.close();

server.listen(port[, host][, backlog][, listenListener])

  • port {number} Port the client should connect to.
  • host {string} Host the client should connect to.
  • backlog {number} The maximum length of the queue of pending connections. Default: 511.
  • listenListener {Function} Listener for the 'listening' event.
  • Returns: {Object} The self instance of net.Server.

Begin accepting connections on the specified port and hostname. If the hostname is omitted, the server will accept connections on any IPv4 address (0.0.0.0).

Example

  2. var net = require('net');
  4. var server = net.createServer();
  5. var port = 22709;
  7. server.listen(port);

server.listen(options[, listenListener])

  • options {Object} An object which specifies the connection options.
  • listenListener {Function} Listener for the 'listening' event.

It behaves as the server.listen(port[, host][, backlog][, listenListener]) function above.

The option object supports the following properties:

  • port {number} Port the client should connect to.
  • host {string} Host the client should connect to.
  • backlog {number} The maximum length of the queue of pending connections. Default: 511.

Example

  2. var net = require('net');
  4. var server = net.createServer();
  6. server.listen({port: 80, host: 'localhost'});

Event: ‘close’

  • callback {Function}

Emitted when server has closed the connection.

Note that this event will be emitted after all existing connections are closed.

Example

  2. var net = require('net');
  4. var serverCloseEvent = 0;
  5. var server = net.createServer();
  6. var port = 80;
  8. server.listen(port);
  10. server.on('connection', function(socket) {
  11.   server.on('close', function() {
  12.     serverCloseEvent++;
  13.   });
  14. });

Event: ‘connection(socket)’

  • callback {Function}
    • socket {Net.Socket}

Emitted when new connection is established.

Example

  2. var net = require('net');
  4. var server = net.createServer();
  5. var port = 80;
  7. server.listen(port);
  9. server.on('connection', function(socket) {
  10.   var msg = '';
  11.   socket.on('data', function(data) {
  12.     msg += data;
  13.   });
  15. });

Event: ‘error’

  • callback {Function}

Emitted when an error occurs.

Example

  2. var assert = require('assert');
  3. var net = require('net');
  5. var port = 80;
  6. var msg = 'Hello IoT.js';
  7. var server = net.createServer();
  9. /* ... */
  11. server.on('error', function() {
  12.   assert.fail();
  13.   server.close();
  14. });

Event: ‘listening’

  • callback {Function}

Emitted when server has been started listening.

Example

  2. var net = require('net');
  4. var port = 80;
  6. var server = net.createServer(
  7.   {
  8.     allowHalfOpen: true
  9.   },
  10.   function(socket) {
  11.     server.close();
  12.   }
  13. );
  15. server.listen(port);
  17. server.on('listening', function() {
  18.     console.log('started listening');
  19. });

Class: net.Socket

This object is an abstraction of a TCP or a local socket. net.Socket inherits from Stream.Duplex. They can be created by the user (used as a client with connect()) or by the IoT.js engine (passed to the user through the ‘connection’ event of a server).

new net.Socket([options])

  • options {Object} An optional object which specifies the socket information.
  • Returns {net.Socket}.

Construct a new socket object. The options object specifies only the following information: allowHalfOpen {boolean}.

Example

  2. var net = require('net');
  4. var socket = new net.Socket();

socket.connect(options[, connectListener])

  • options {Object} An object which specifies the connection information.
  • connectListener {Function} Listener for the 'connect' event.
  • Returns {net.Socket}.

Creates a new socket object and automatically connects with the supplied options.

The options object specifies following information:

  • port {number} Port connect to (required).
  • host {string} Host connect to (optional, Default: localhost).
  • family {number} Version of IP stack.

The connectionListener is automatically registered as a 'connect' event listener which will be emitted when the connection is established.

Example

  2. var net = require('net');
  4. var port = 22702;
  6. var socket = new net.Socket();
  8. socket.connect({port: port, family: 4}, function() {
  9.   socket.end('Hello IoT.js');
  10. });

socket.connect(port[, host][, connectListener])

  • port {number} Port the client should connect to.
  • host {string} Host the client should connect to. Default: localhost.
  • connectListener {Function} Listener for the 'connect' event.
  • Returns {net.Socket}.

Creates a new socket and automatically connects with the supplied port and host.

connectionListener is automatically registered as a 'connect' event listener which will be emitted when the connection is established.

Example

  2. var net = require('net');
  4. var port = 80;
  6. var socket = new net.Socket();
  8. socket.connect(port, '127.0.0.1', function() {
  9.   socket.end('Hello IoT.js');
  10. });

socket.destroy()

Ensures that no more I/O activity happens on the socket and destroys the socket as soon as possible.

Example

  2. var net = require('net');
  4. var port = 80;
  6. var socket = new net.Socket();
  8. socket.connect(port, '127.0.0.1', function() {
  9.   socket.end('Hello IoT.js');
  10. });
  12. /* ... */
  14. socket.destroy();

socket.end([data][, callback])

  • data {Buffer|string}
  • callback {Function}

Half-closes the socket. The socket is no longer writable. If data is given it is equivalent to socket.write(data) followed by socket.end().

Example

  2. var net = require('net');
  4. var server = net.createServer();
  5. var port = 4010;
  7. server.listen(port);
  9. server.on('connection', function(socket) {
  10.   socket.on('data', function(data) {
  11.     socket.end('Hello IoT.js');
  12.   });
  13. });

socket.pause()

Pauses reading data.

Example

  2. var net = require('net');
  4. var server = net.createServer();
  5. var port = 4010;
  7. server.listen(port);
  9. server.on('connection', function(socket) {
  11.   // as soon as connection established, pause the socket
  12.   socket.pause();
  13. });

socket.resume()

Resumes reading data after a call to pause().

Example

  2. var net = require('net');
  3. var timers = require('timers');
  5. var server = net.createServer();
  6. var port = 80;
  8. var socket = new net.Socket();
  9. var msg = "";
  11. /* ... */
  13. server.listen(port);
  15. server.on('connection', function(socket) {
  16.   socket.on('data', function(data) {
  17.     msg += data;
  18.     socket.end();
  19.   });
  20.   socket.on('close', function() {
  21.     server.close();
  22.   });
  24.   // as soon as connection established, pause the socket
  25.   socket.pause();
  27.   // resume after 2 secs
  28.   timers.setTimeout(function() {
  29.     socket.resume();
  30.   }, 2000);
  31. });

socket.setKeepAlive([enable][, initialDelay])

  • enable {boolean} Default: false.
  • initialDelay {number} **Default:** 0`.

Enables or disables keep-alive functionality.

Example

  2. var net = require('net');
  4. var keepalive_sock = new net.Socket();
  6. keepalive_sock.setKeepAlive(true, 1000);

socket.setTimeout(timeout[, callback])

  • timeout {number} Timeout number.
  • callback {Function} Registered as a 'timeout' event listener.

Sets timeout for the socket.

If the socket is inactive for timeout milliseconds, 'timeout' event will emit.

Example

  2. var net = require('net');
  4. var server = net.createServer();
  5. var port = 40;
  6. var timeout = 2000;
  7. var msg = '';
  9. server.listen(port);
  11. server.on('connection', function(socket) {
  12.   socket.setTimeout(timeout, function() {
  13.     socket.end();
  14.   });
  15. });

socket.write(data[, callback])

  • data {Buffer|string} Data to write.
  • callback {Function} Executed function (when the data is finally written out).

Sends data on the socket.

The optional callback function will be called after the given data is flushed through the connection.

Example

  2. var net = require('net');
  3. var timers = require('timers');
  5. var writeat = 1000;
  7. var socket = new net.Socket();
  9. /* ... */
  11. socket.on('connect', function() {
  12.   timers.setTimeout(function() {
  13.     socket.write('Hello IoT.js');
  14.   }, writeat);
  15. });

Event: ‘connect’

  • callback {Function}

Emitted after connection is established.

Example

  2. var net = require('net');
  4. var port = 80;
  6. var count = 40;
  8. /* ... */
  10. for (var i = 0; i < count; ++i) {
  11.   (function(i) {
  12.     var socket = new net.Socket();
  14.     socket.connect(port, "localhost");
  15.     socket.on('connect', function() {
  16.       socket.end(i.toString());
  17.     });
  19.     /* ... */
  21.   })(i);
  22. }

Event: ‘close’

  • callback {Function}

Emitted when the socket has been closed.

Example

  2. var net = require('net');
  4. var server = net.createServer();
  5. var port = 80;
  7. server.listen(port);
  9. server.on('connection', function(socket) {
  11.   /* ... */
  13.   socket.on('close', function() {
  14.     server.close();
  15.   });
  16. });

Event: ‘data’

  • callback {Function}

The data is given an argument (data: Buffer|string).

Emitted when data is received from the connection.

Example

  2. var net = require('net');
  4. var msg = "";
  6. var socket = new net.Socket();
  8. /* ... */
  10. socket.on('data', function(data) {
  11.   msg += data;
  12. });

Event: ‘drain’

  • callback {Function}

Emitted when the write buffer becomes empty.

Example

  2. var net = require('net');
  4. var port = 22703;
  5. var limit = 200;
  6. var server = net.createServer();
  8. server.listen({ port: port });
  10. /* ... */
  12. server.on('connection', function(socket) {
  13.   var i = 0;
  14.   var writing = function() {
  15.     var ok;
  16.     do {
  17.       ok = socket.write("" + (i % 10));
  18.       if (++i == limit) {
  19.         socket.end();
  20.         ok = false;
  21.       }
  22.     } while (ok);
  23.   };
  24.   socket.on('drain', writing);
  25.   writing();
  26. });

Event: ‘end’

  • callback {Function}

Emitted when FIN packet received.

Example

  2. var net = require('net');
  4. var socket = new net.Socket();
  6. /* ... */
  8. socket.on('end', function() {
  9.   socket.end();
  10. });

Event: ‘error’

  • callback {Function}
    • err {Error}

Emitted when an error occurs.

Example

  2. var assert = require('assert');
  3. var net = require('net');
  5. var bad_sock = new net.Socket();
  6. bad_sock.on('error', function(err){
  7.   assert.equal(err instanceof Error, true);
  8. });

Event: ‘lookup’

  • callback {Function}
    • err {Error}
    • address {string}
    • family {string|null}

Emitted after resolving hostname.

Example

  2. var socket = new net.Socket();
  3. var msg = "";
  4. var lookupHandled = false;
  6. socket.on('lookup', function(err, ip, family) {
  7.   lookupHandled = true;
  8. });

Event: ‘timeout’

  • callback {Function}`

Emitted when the connection remains idle for the specified timeout.

Example

  2. var net = require('net');
  4. var timedout = false;
  6. // Try connect to host that is not exist (Reserved address)
  7. var socket = net.createConnection(11111, '192.0.2.1');
  9. socket.setTimeout(1000);
  11. socket.on('timeout', function() {
  12.   timedout = true;
  13.   socket.destroy();
  14. });