We Keep Coding

Send Video between servers using Node

i am working in a project using node. My goal is to get a video from one server to the other. I am using udp protocol, so, i just want to know, how i must work with the video and how to do that. I mean, must i convert the video to a string and sent it by the socket udp? I know how to send strings, but i don't know how to apply this using video. Cpuld you help me please?
This is the code i use for the listening server:
var PORT = 33333;
var HOST = '127.0.0.1';
var dgram = require('dgram');
var server = dgram.createSocket('udp4');
server.on('listening', function () {
var address = server.address();
console.log('UDP Server Running on ' + address.address + ":" + address.port);
});
server.on('message', function (message, remote) {
console.log(remote.address + ':' + remote.port +' - ' + message);
});
server.bind(PORT, HOST);
Regards

Node.js UDP Multicast over Network

I'm having an issue with a repeated EADDRNOTAVAIL issue on a UDP multicast proof of concept. I have a Linux server sending multicast messages to a Windows client (have tried reversing this to no avail..). The server works correctly when running both the client and the server on the same machine, but not over the same network.
Below is the code I've tried to get this to work with, the IPs I'm using, and the errors I've received.
I'm not sure what I'm doing incorrectly!
Environment
Windows Local IP: 192.168.1.10
Linux Local IP: 192.168.1.11
Server: server.js
const SRC_PORT = 6025;
const PORT = 6024;
const MULTICAST_ADDR = '239.255.255.250';
const LOCAL_IP = '192.168.1.11';
const dgram = require('dgram');
const server = dgram.createSocket("udp4");
server.bind(SRC_PORT, LOCAL_IP, function () {
setInterval(function () {
let message = new Buffer(new Date().toLocaleTimeString());
server.send(message, 0, message.length, PORT, MULTICAST_ADDR, function () {
console.log("Sent '" + message + "'");
});
}, 4000);
});
Client: client.js
const PORT = 6024;
const MULTICAST_ADDR = '239.255.255.250';
const LOCAL_IP = '192.168.1.10';
const HOST_IP = '192.168.1.11';
const dgram = require('dgram');
const client = dgram.createSocket('udp4');
client.on('listening', function () {
let address = client.address();
console.log('UDP Client listening on ' + address.address + ":" + address.port);
});
client.on('message', function (message, rinfo) {
console.log('Message from: ' + rinfo.address + ':' + rinfo.port + ' - ' + message);
});
//*** Also tried with client.bind(PORT, LOCAL_IP, ... and failed
client.bind(PORT, function () {
client.addMembership(MULTICAST_ADDR, HOST_IP);
});
Error
dgram.js:508
throw errnoException(err, 'addMembership');
^
Error: addMembership EADDRNOTAVAIL
at exports._errnoException (util.js:1026:11)
at Socket.addMembership (dgram.js:508:11)
at Socket.<anonymous> (~/dev/node-multicast/client.js:16:10)
at Socket.g (events.js:286:16)
at emitNone (events.js:91:20)
at Socket.emit (events.js:185:7)
at startListening (dgram.js:121:10)
at dgram.js:228:7
at _combinedTickCallback (internal/process/next_tick.js:77:11)

I'm sure you joined wrong multicastInterface from this error:
addMembership EADDRNOTAVAIL
It should be your address of local interface:
client.addMembership(MULTICAST_ADDR, LOCAL_IP);
As the doc says:
socket.addMembership(multicastAddress[, multicastInterface])
Tells the kernel to join a multicast group at the given
multicastAddress and multicastInterface using the IP_ADD_MEMBERSHIP
socket option. If the multicastInterface argument is not specified,
the operating system will choose one interface and will add membership
to it. To add membership to every available interface, call
addMembership multiple times, once per interface.

Multiple Clients connected to the same Server using UDP in NodeJS

Is it possible to have multiple clients to the same UDP server ?
I'd like to broadcast the same data to all connected clients.
Here would be a starting sample, if it helps somehow ...
// Server
var news = [
"Borussia Dortmund wins German championship",
"Tornado warning for the Bay Area",
"More rain for the weekend"
];
var dgram = require('dgram');
var server = dgram.createSocket("udp4");
server.bind(function() {
server.setBroadcast(true)
server.setMulticastTTL(128);
setInterval(broadcastNew, 3000);
});
function broadcastNew() {
var message = new Buffer(news[Math.floor(Math.random() * news.length)]);
server.send(message, 0, message.length, 5007, "224.1.1.1");
console.log("Sent " + message + " to the wire...");
}
// Client 1
var PORT = 5007;
var dgram = require('dgram');
var client = dgram.createSocket('udp4');
client.on('listening', function() {
var address = client.address();
console.log('UDP Client listening on ' + address.address + ":" + address.port);
client.setBroadcast(true)
client.setMulticastTTL(128);
client.addMembership('224.1.1.1');
});
client.on('message', function(message, remote) {
console.log('A: Epic Command Received. Preparing Relay.');
console.log('B: From: ' + remote.address + ':' + remote.port + ' - ' + message);
});
client.bind(PORT);
// Client 2
// Here would go another client, it is possible ?

Yes, it is possible.
I won't go on a speech about how you should use TCP before UDP and only use UDP when absolutely necessary.
For your problem, the fact is that UDP doesn't have any "connection". You receive messages, you send messages, but there is no "connection".
So what you should do is:
When receiving a message from an incoming client, store the IP/Port used by the client
When wanting to send messages to clients, send to all the IP/Port combinations stored
Periodically remove old clients (for example who didn't send a message in the last 5 minutes)
You can detect when a message is received on a bound socket after the "message" event. Your code would look something like that (helped myself):
// Server
var news = [
"Borussia Dortmund wins German championship",
"Tornado warning for the Bay Area",
"More rain for the weekend"
];
var clients = {};
const dgram = require('dgram');
const server = dgram.createSocket('udp4');
server.on('error', (err) => {
console.log(`server error:\n${err.stack}`);
server.close();
});
server.on('message', (msg, rinfo) => {
console.log(`server got: ${msg} from ${rinfo.address}:${rinfo.port}`);
clients[JSON.stringify([rinfo.address, rinfo.port])] = true;
//use delete clients[client] to remove from the list of clients
});
function broadCastNew() {
var message = new Buffer(news[Math.floor(Math.random() * news.length)]);
for (var client in clients) {
client = JSON.parse(client);
var port = client[1];
var address = client[0];
server.send(message, 0, message.length, port, address);
}
console.log("Sent " + message + " to the wire...");
}
server.on('listening', () => {
var address = server.address();
console.log(`server listening ${address.address}:${address.port}`);
setInterval(broadcastNew, 3000);
});
server.bind(5007);
Now whenever your server gets an UDP message on port 5007, it will add the sender to the list of clients, and every 3 seconds it will send a message to all the clients stored. How to make the sender receive that piece of news is another story, but you can use a tool such as WireShark to confirm yourself that it was correctly sent back.
Here I didn't delete old clients but you probably should include a mechanism to store the last time they contacted you (instead of using = true you can for example store current time, then periodically remove old clients)
Broadcast and Multicast are probably different from what you imagine, broadcast is used for example to send a message to everyone on the local network.

NodeJS simple UDP client server application using broker

I am writing a simple client server NodeJS application using UDP protocol. The main point of this application is that it requires the use of a broker, whose function, in the given case, is to link the sender with the receiver. The requirements tell me that the sender doesn't need to be aware of the receiver's IP address and port number - it only needs to know the broker's corresponding IP and PORT. Afterwards, the broker will send the client's message to the server, based on the server's IP and PORT.
To clarify the previous(?confusing) paragraph, below you will find a illustration of what I've done so far:
sender.js
var PORT1 = XXXXX;
var HOST = '127.0.0.1';
var fs = require('fs');
var dgram = require('dgram');
var client = dgram.createSocket('udp4');
fs.readFile('Path/to/the/file','utf8', function (err, data) {
if (err) throw err;
var message = new Buffer(data);
client.send(data, 0, message.length, PORT1, HOST, function(err, bytes) {
if (err) throw err;
console.log('UDP message sent to ' + HOST +':'+ PORT1);
client.close();
});
});
The code above reads from a file, stores its contents in a buffer and sends it to the broker's port(the broker listens to the same port) and host(which, in my case is the localhost).
broker.js
var PORT1 = XXXXX;
var PORT2 = YYYYY;
var HOST = '127.0.0.1';
var dgram = require('dgram');
var server = dgram.createSocket('udp4');
var client = dgram.createSocket('udp4');
server.on('listening', function () {
var address = server.address();
console.log('UDP broker listening on ' + address.address + ":" + address.port);
});
server.on('message', function (message, remote) {
client.send(message, 0, message.length, PORT2, HOST, function(err, bytes) {
if (err) throw err;
console.log('UDP message sent to ' + HOST +':'+ PORT2);
client.close();
});
console.log(remote.address + ':' + remote.port +' - ' + message);
});
server.bind(PORT1, HOST);
Here, PORT1 is the port that the broker listens to(waiting for incoming messages from sender) and PORT2 is the port which transmits the message to the receiver(and correspondingly, the receiver listens to this port).
receiver.js
var PORT2 = YYYYY;
var HOST = '127.0.0.1';
var fs = require('fs');
var dgram = require('dgram');
var server = dgram.createSocket('udp4');
var parser = require('xml2json');
server.on('listening', function () {
var address = server.address();
console.log('UDP receiver listening on ' + address.address + ":" + address.port);
});
server.on('message', function (message, remote) {
console.log(remote.address + ':' + remote.port +' - ' + message);
var contents = fs.writeFile("/Path/To/Written/File", parser.toJson(message),
function(error){
if (error) {
console.log("error writing");
}
console.log("File was saved");
});
});
server.bind(PORT2, HOST);
The receiver gets the message from the broker and writes it to a file in the JSON format.
Here are the results:
Sender
UserName's-MacBook-Pro:UDP server UserName$ node sender.js
UDP message sent to 127.0.0.1:XXXXX
Broker
UserName's-MacBook-Pro:UDP server UserName$ node broker.js
UDP broker listening on 127.0.0.1:XXXXX
127.0.0.1:60009 - <?xml version="1.0"?>
<Some XML content here>
</XML content ends here>
UDP message sent to 127.0.0.1:YYYYY
Receiver
UserName's-MacBook-Pro:UDP server UserName$ node receiver.js
UDP receiver listening on 127.0.0.1:YYYYY
127.0.0.1:63407 - <?xml version="1.0"?>
<XML contents here>
</XML content ends here>
File was saved
I am sorry for the long post, but I want to specify all the details to eliminate(hopefully) any ambiguities. Now, to the matter,
HERE is my question
What changes should I make for the broker in order to solve the following problem:
In case of multiple senders and receivers, the broker should manage the ports to link the sender to the receiver(with any specified criteria).
Thank you in advance!

Take a look in this book "Node.js Design Patterns,Publisher:Packt Publishing By: Mario Casciaro ISBN: 978-1-78328-731-4 Year: 2014" at page 361. There is the exact thing you want to do with very good explanation.
Hope it will help!

How to bind socket to more than one port, NodeJS

I have set up a node application which receives packets from a Port at an IP address and serves the contents to a web-page. This IP address has traffic going through two ports, 9999 and 10000. My application has the following code:
var PORT_ONE = 9999;
var PORT_TWO = 10000;
var SENSOR = '239.0.0.1';
var client = require('dgram').createSocket('udp4');
var dns = require('dns');
/* Client starts listening on IP */
client.on('listening', function () {
console.log('UDP Client listening on ' + SENSOR + ":" + PORT_TWO);
client.setMulticastTTL(1);
client.addMembership(SENSOR);
});
/* Client receives a message */
client.on('message', function (message, remote) {
var tempMessage = message.toString(); //cast Buffer var to String
var delimiter = "\n";
var tempData = tempMessage.split(delimiter);
console.log('From: ' + remote.address + ':' + remote.port +' - \n' + message);
var data = {
ip: [SENSOR],
info: [tempData]
};
sendMessage(data);
});
client.bind(PORT_ONE);
client.bind(PORT_TWO); //error here
When I run my node application in the terminal, I receive the error
dgram.js:163
throw new Error('Socket is already bound');
Where dgram.js is part of the Nodejs libraries. The error comes when binding to PORT_TWO. Is there a way to bind the socket to more than one port?

I want to add my 2 cents here, what I normally do is create array of ports and Ips and put in for loop binding on them one by one
udpclients = [5550,5551];
udpsockets=[]
var dgram = require('dgram');
udpclients.forEach(function(port){
var udpServer = dgram.createSocket('udp4');
udpServer.bind(port,'127.0.0.1')
udpServer.on('listening', function() {
var address = udpServer.address()
console.log("listening"+address.address+" port::"+address.port)
});
udpServer.on('message', function(msg, rinfo) {
console.log("message received :: "+ msg +" address::"+rinfo.address+ "port = "+ rinfo.port )
});
});

Or you can bind multiple sockets, wrap them into streams and then combine streams to get feeling of one single socket.