Lier un socket UDP (Bun.udpSocket())

Pour créer un nouveau socket UDP (lié) :

const socket = await Bun.udpSocket({});
console.log(socket.port); // assigné par le système d'exploitation

Spécifier un port :

const socket = await Bun.udpSocket({
  port: 41234, 
});

console.log(socket.port); // 41234

Envoyer un datagramme

Spécifiez les données à envoyer, ainsi que le port et l'adresse de destination.

socket.send("Hello, world!", 41234, "127.0.0.1");

Notez que l'adresse doit être une adresse IP valide - send n'effectue pas de résolution DNS, car il est destiné aux opérations à faible latence.

Recevoir des datagrammes

Lors de la création de votre socket, ajoutez un callback pour spécifier ce qui doit être fait lorsque des paquets sont reçus :

const server = await Bun.udpSocket({
  socket: {
    data(socket, buf, port, addr) {
      console.log(`message de ${addr}:${port}:`);
      console.log(buf.toString());
    },
  },
});

const client = await Bun.udpSocket({});
client.send("Hello!", server.port, "127.0.0.1");

Connexions

Bien que UDP n'ait pas de concept de connexion, de nombreuses communications UDP (surtout en tant que client) n'impliquent qu'un seul pair. Dans de tels cas, il peut être avantageux de connecter le socket à ce pair, ce qui spécifie à quelle adresse tous les paquets sont envoyés et restreint les paquets entrants à ce pair uniquement.

const server = await Bun.udpSocket({
  socket: {
    data(socket, buf, port, addr) {
      console.log(`message de ${addr}:${port}:`);
      console.log(buf.toString());
    },
  },
});

const client = await Bun.udpSocket({
  connect: {
    port: server.port,
    hostname: "127.0.0.1",
  },
});

client.send("Hello");

Parce que les connexions sont implémentées au niveau du système d'exploitation, vous pouvez potentiellement observer des avantages de performance également.

Envoyer plusieurs paquets à la fois avec sendMany()

Si vous voulez envoyer un grand volume de paquets à la fois, il peut être judicieux de les regrouper tous ensemble pour éviter la surcharge de faire un appel système pour chacun. Cela est rendu possible par l'API sendMany() :

Pour un socket non connecté, sendMany prend un tableau comme seul argument. Chaque ensemble de trois éléments du tableau décrit un paquet : Le premier élément est les données à envoyer, le deuxième est le port cible, et le dernier est l'adresse cible.

const socket = await Bun.udpSocket({});

// envoie 'Hello' à 127.0.0.1:41234, et 'foo' à 1.1.1.1:53 en une seule opération
socket.sendMany(["Hello", 41234, "127.0.0.1", "foo", 53, "1.1.1.1"]);

Avec un socket connecté, sendMany prend simplement un tableau, où chaque élément représente les données à envoyer au pair.

const socket = await Bun.udpSocket({
  connect: {
    port: 41234,
    hostname: "localhost",
  },
});

socket.sendMany(["foo", "bar", "baz"]);

sendMany retourne le nombre de paquets qui ont été envoyés avec succès. Comme avec send, sendMany ne prend que des adresses IP valides comme destinations, car il n'effectue pas de résolution DNS.

Gérer la contre-pression

Il peut arriver qu'un paquet que vous envoyez ne tienne pas dans le tampon de paquets du système d'exploitation. Vous pouvez détecter que cela s'est produit lorsque :

• send retourne false
• sendMany retourne un nombre inférieur au nombre de paquets que vous avez spécifiés. Dans ce cas, le gestionnaire de socket drain sera appelé une fois que le socket redevient accessible en écriture :

const socket = await Bun.udpSocket({
  socket: {
    drain(socket) {
      // continuer à envoyer des données
    },
  },
});