/** * Send concatenated data to StatsD server via UDP * * @param {Buffer} buf */ send(buf) { //this.logger.info("Buffer\n" + buf.toString()); const sock = dgram.createSocket("udp4"); sock.send(buf, 0, buf.length, this.opts.port, this.opts.host, (err, bytes) => { if (err) { this.logger.warn("Unable to send metrics to StatsD server. Error:" + err.message, err); } else { this.logger.debug("Metrics are uploaded to StatsD. Sent bytes:", bytes); } sock.close(); }); }
describe("Test send method", () => { const broker = new ServiceBroker({ logger: false, metrics: true }); const registry = broker.metrics; const reporter = new StatsDReporter({ maxPayloadSize: 0 }); reporter.init(registry); it("should send data via udp4", () => { dgram.createSocket.mockClear(); sockSend.mockClear(); sockClose.mockClear(); const buf = Buffer.from("Moleculer Metrics Data"); reporter.send(buf); expect(dgram.createSocket).toBeCalledTimes(1); expect(dgram.createSocket).toBeCalledWith("udp4"); expect(sockSend).toBeCalledTimes(1); expect(sockSend).toBeCalledWith(buf, 0, 22, 8125, "localhost", expect.any(Function)); expect(sockClose).toBeCalledTimes(1); }); });
it("should bind UDP with broadcast", () => { udp = new UdpServer(transporter, { udpReuseAddr: true }); udp.getBroadcastAddresses = jest.fn(() => (["192.168.100.255", "192.168.200.255"])); return udp.startServer("127.0.0.1", 4567).catch(protectReject).then(() => { expect(udp.servers.length).toBe(1); const server = udp.servers[0]; expect(dgram.createSocket).toHaveBeenCalledTimes(1); expect(dgram.createSocket).toHaveBeenCalledWith({ "reuseAddr": true, "type": "udp4" }); expect(server.bind).toHaveBeenCalledTimes(1); expect(server.bind).toHaveBeenCalledWith({ "exclusive": true, "host": "127.0.0.1", "port": 4567 }, jasmine.any(Function)); expect(server.on).toHaveBeenCalledTimes(2); expect(server.on).toHaveBeenCalledWith("error", jasmine.any(Function)); expect(server.on).toHaveBeenCalledWith("message", jasmine.any(Function)); expect(server.setBroadcast).toHaveBeenCalledTimes(1); expect(server.setBroadcast).toHaveBeenCalledWith(true); expect(server.destinations).toEqual(["192.168.100.255", "192.168.200.255"]); expect(udp.getBroadcastAddresses).toHaveBeenCalledTimes(1); }); });
it("should bind UDP with multicast", () => { dgram.createSocket.mockClear(); const server = udp.servers[0]; expect(dgram.createSocket).toHaveBeenCalledTimes(1); expect(dgram.createSocket).toHaveBeenCalledWith({ "reuseAddr": true, "type": "udp4" });
return new this.Promise(resolve => { try { const server = dgram.createSocket({ type: "udp4", reuseAddr: this.opts.udpReuseAddr }); server.on("message", this.onMessage.bind(this)); server.on("error", err => { this.logger.warn("UDP server binding error!", err); resolve(); port = port || 4445; server.bind({ port, host, exclusive: true }, () => { try { if (multicastAddress) { this.logger.info(`UDP Multicast Server is listening on ${host}:${port}. Membership: ${multicastAddress}`); server.setMulticastInterface(host); server.addMembership(multicastAddress, host); server.setMulticastTTL(ttl || 1); server.destinations = [multicastAddress]; } else { this.logger.info(`UDP Broadcast Server is listening on ${host}:${port}`); server.setBroadcast(true); server.destinations = this.getBroadcastAddresses(); this.logger.info(" Broadcast addresses:", server.destinations.join(", "));
stop(force: boolean, cb: () => void) { this.socket.close(); process.nextTick(cb); }
sendRaw(msg: any) { this.socket.send(msg, 0, msg.length, this.port, this.host, function (err, bytes) { if (!!err) { logger.error('send msg to remote with err: %j', err.stack); return; } }); }
start(cb: () => void) { let self = this; this.tcpServer = net.createServer(); this.socket = dgram.createSocket(this.type, function (msg, peer) { let key = genKey(peer); if (!self.clients[key]) { this.socket.on('message', function (data: Buffer, peer: dgram.RemoteInfo) { let socket = self.clients[genKey(peer)]; if (!!socket) { this.socket.on('error', function (err: Error) { logger.error('udp socket encounters with error: %j', err.stack); return; }); this.socket.bind(this.port, this.host); this.tcpServer.listen(this.port); process.nextTick(cb);
const listener = dgram.createSocket({type: 'udp4', reuseAddr: true}); listener.bind(6666); const listenerEncrypted = dgram.createSocket({type: 'udp4', reuseAddr: true}); listenerEncrypted.bind(6667); listener.close(); listener.removeAllListeners(); listenerEncrypted.close(); listenerEncrypted.removeAllListeners(); resolve(true); listener.on('message', broadcastHandler(resolve, reject)); listener.on('error', err => { reject(err); }); listenerEncrypted.on('message', broadcastHandler(resolve, reject)); listenerEncrypted.on('error', err => { reject(err); }); }), timeout * 1000, () => { listener.close(); listener.removeAllListeners(); listenerEncrypted.close(); listenerEncrypted.removeAllListeners();
constructor(id: number, socket: dgram.Socket, peer: dgram.RemoteInfo) { super(); this.id = id; this.socket = socket; this.peer = peer; this.host = peer.address; this.port = peer.port; this.remoteAddress = { ip: this.host, port: this.port }; let self = this; this.on('package', function (pkg) { if (!!pkg) { pkg = Package.decode(pkg); handler(self, pkg); } }); this.state = ST_INITED; }
unref() { this.udf.unref(); this.chunkInterval.unref(); return this; }
sendAndClose(callback) { this.callback = callback || this._defaultCallback; this._debug('Sending last messages and closing...'); this._popMsgsAndSend(); clearTimeout(this.timer); if (this.protocol === 'udp') { this.udpClient.close(); } }
this.wifiServerUDP.on('message', (msg) => { if (!bufferEqual(lastMsg, msg)) { this._processBytes(msg); } lastMsg = msg; });
// Start an UDP server to mock calls. const startUdpServer = async function() { const requests = [] const server = createSocket('udp4', buffer => { requests.push(buffer.toString()) }) await promisify(server.bind.bind(server))(0) const { address, port } = server.address() const stopServer = promisify(server.close.bind(server)) return { host: address, port, requests, stopServer } }