Serveur minecraft

Socket.IO – API de serveur | Socket.IO – Monter un serveur MineCraft

Le 14 juin 2019 - 19 minutes de lecture

Exposé par require ('socket.io').

nouveau serveur (httpServer[, options])

  • httpServer (http.Server) le serveur à lier.
  • options (Objet)

Fonctionne avec et sans Nouveau:

const io = exiger('socket.io') ();

const Serveur = exiger('socket.io')
const io = Nouveau Serveur();

Options disponibles:

Option Valeur par défaut La description
chemin /socket.io nom du chemin à capturer
servirClient vrai si servir les fichiers du client
adaptateur l'adaptateur à utiliser. Par défaut, une instance de Adaptateur qui est livré avec socket.io qui est basé sur la mémoire. Voir socket.io-adaptateur
origines * les origines autorisées
analyseur l'analyseur à utiliser. Par défaut, une instance de Analyseur qui est livré avec socket.io. Voir socket.io-analyseur.

Options disponibles pour le serveur Engine.IO sous-jacent:

Option Valeur par défaut La description
pingTimeout 5000 combien de ms sans paquet pong considérer la connexion fermée
pingInterval 25000 combien de ms avant d'envoyer un nouveau paquet ping
upgradeTimeout 10000 combien de ms avant l'annulation d'une mise à niveau de transport incomplète
maxHttpBufferSize 10e7 nombre d'octets ou de caractères qu'un message peut contenir avant la fermeture de la session (pour éviter les dénis de service).
allowRequest Une fonction qui reçoit une demande de négociation ou de mise à niveau donnée en tant que premier paramètre et peut décider de continuer ou non. Le deuxième argument est une fonction qui doit être appelée avec les informations décidées: fn (err, succès), où Succès est une valeur booléenne où false signifie que la demande est rejetée et err est un code d'erreur.
les transports ['polling', 'websocket'] transports pour permettre les connexions à
allowUpgrades vrai autoriser les mises à niveau de transport
parMessageDeflate vrai paramètres de l'extension WebSocket permessage-deflate (voir ws module aps docs). Mis à faux pour désactiver.
httpCompression vrai paramètres de la compression http pour les transports d'interrogation (voir zlib api docs). Mis à faux pour désactiver.
biscuit io nom du cookie HTTP qui contient le client à envoyer dans le cadre des en-têtes de réponse de négociation. Mis à faux ne pas en envoyer.
cookiePath / chemin de la ci-dessus biscuit option. Si false, aucun chemin ne sera envoyé, ce qui signifie que les navigateurs n'enverront que le cookie sur le chemin attaché engine.io (/engine.io). Définissez false pour ne pas enregistrer le cookie io sur toutes les demandes.
cookieHttpOnly vrai si vrai Les cookies HttpOnly io ne sont pas accessibles par les API côté client, telles que JavaScript. Cette option n'a aucun effet si biscuit ou cookiePath est réglé sur faux.
wsEngine ws quelle implémentation de serveur WebSocket utiliser. Le module spécifié doit être conforme à la ws interface (voir ws module api docs). La valeur par défaut est ws. Un autre addon c ++ est également disponible en installant uws module.

Parmi ces options:

  • le pingTimeout et pingInterval les paramètres auront un impact sur le délai avant qu'un client sache que le serveur n'est plus disponible. Par exemple, si la connexion TCP sous-jacente n’est pas correctement fermée en raison d’un problème de réseau, un client doit attendre jusqu’à pingTimeout + pingInterval ms avant d'obtenir un déconnecter un événement.

  • L'ordre du les transports le tableau est important. Par défaut, une connexion d'interrogation longue est d'abord établie, puis mise à niveau vers WebSocket si possible. En utilisant ['websocket'] signifie qu'il n'y aura pas de solution de rechange si une connexion WebSocket ne peut pas être ouverte.

const serveur = exiger('http') .createServer ();

const io = exiger('socket.io') (serveur,
chemin: '/tester',
serveClient: faux,

pingInterval: 10000,
pingTimeout: 5000,
biscuit: faux
);

server.listen (3000)

nouveau serveur (port[, options])

  • Port (Nombre) un port à écouter (un nouveau http.Server sera créé)
  • options (Objet)

Voir ci-dessus pour la liste des disponibles options.

const io = exiger('socket.io') (3000
chemin: '/tester',
serveClient: faux,

pingInterval: 10000,
pingTimeout: 5000,
biscuit: faux
);

nouveau serveur (options)

Voir ci-dessus pour la liste des disponibles options.

const io = exiger('socket.io') (
chemin: '/tester',
serveClient: faux,
);


const serveur = exiger('http') .createServer ();

io.attach (serveur,
pingInterval: 10000,
pingTimeout: 5000,
biscuit: faux
);

server.listen (3000)


io.attach (3000
pingInterval: 10000,
pingTimeout: 5000,
biscuit: faux
);

serveur.sockets

Un alias pour la valeur par défaut (/) espace de noms.

io.sockets.emit ('salut', 'toutes les personnes')

io.of ('/').émettre('salut', 'toutes les personnes')

server.serveClient ([value])

  • valeur (Booléen)
  • Résultats Serveur | Booléen

Si valeur est vrai le serveur connecté (voir Serveur # attaché) servira les fichiers du client. Par défaut à vrai. Cette méthode n'a aucun effet après attacher est appelé. Si aucun argument n'est fourni, cette méthode retourne la valeur actuelle.


const io = exiger('socket.io') (http, servirClient: faux );


const io = exiger('socket.io') ();
io.serveClient (faux)
io.attach (http);

server.path ([value])

  • valeur (Chaîne)
  • Résultats Serveur | Chaîne

Définit le chemin valeur sous lequel moteur.io et les fichiers statiques seront servis. Par défaut à /socket.io. Si aucun argument n'est fourni, cette méthode retourne la valeur actuelle.

const io = exiger('socket.io') ();
io.path ('/ myownpath')


const socket = io (
chemin: '/ myownpath'
);

server.adapter ([value])

  • valeur (Adaptateur)
  • Résultats Serveur | Adaptateur

Définit l'adaptateur valeur. Par défaut, une instance de Adaptateur qui est livré avec socket.io qui est basé sur la mémoire. Voir socket.io-adaptateur. Si aucun argument n'est fourni, cette méthode retourne la valeur actuelle.

const io = exiger('socket.io') (3000)
const redis = exiger('socket.io-redis')
io.adapter (redis ( hôte: 'localhost', Port: 6379 ));

server.origins ([value])

  • valeur (String | String[])
  • Résultats Serveur | Chaîne

Définit les origines autorisées valeur. Par défaut, toutes les origines sont autorisées. Si aucun argument n'est fourni, cette méthode retourne la valeur actuelle.

io.origines ([[[["https://foo.example.com:443"])

server.origins (fn)

  • fn (Une fonction)
  • Résultats Serveur

Fournit une fonction prenant deux arguments origine: String et rappel (erreur, succès), où Succès est une valeur booléenne indiquant si l'origine est autorisée ou non. Si Succès est réglé sur faux, Erreur doit être fourni sous forme de valeur de chaîne qui sera ajoutée à la réponse du serveur, par ex. “Origine non autorisée”.

Inconvénients potentiels:

  • dans certaines situations, lorsqu'il est impossible de déterminer origine il peut avoir valeur de *
  • Comme cette fonction sera exécutée pour chaque requête, il est conseillé de la faire fonctionner le plus rapidement possible.
  • Si socket.io est utilisé avec Express, les en-têtes CORS ne seront affectés que pour socket.io demandes. Pour Express, vous pouvez utiliser cors.
io.origines ((origine, rappel) => 
si (origine! == 'https://foo.example.com')
revenir rappeler('origine non autorisée', faux)

rappeler(nul, vrai)
);

server.attach (httpServer[, options])

  • httpServer (http.Server) le serveur auquel s'attacher
  • options (Objet)

Attache le Serveur à une instance de engine.io sur httpServer avec le fourni options (éventuellement).

server.attach (port[, options])

  • Port (Nombre) le port pour écouter
  • options (Objet)

Attache le Serveur à une instance de engine.io sur un nouveau http.Server avec le options (éventuellement).

server.listen (httpServer[, options])

Synonyme de server.attach (httpServer[, options]).

server.listen (port[, options])

Synonyme de server.attach (port[, options]).

server.bind (moteur)

  • moteur (engine.Server)
  • Résultats Serveur

Utilisation avancée uniquement. Lie le serveur à un moteur spécifique.io Serveur (ou API compatible) instance.

server.onconnection (socket)

  • prise (engine.Socket)
  • Résultats Serveur

Utilisation avancée uniquement. Crée un nouveau socket.io client depuis le engine.io entrant (ou une API compatible) Prise.

serveur.of (nsp)

  • nsp (String | RegExp | Fonction)
  • Résultats Espace de noms

Initialise et récupère le donné Espace de noms par son identifiant de chemin nsp. Si l'espace de nom a déjà été initialisé, il le renvoie immédiatement.

const adminNamespace = io.of ('/ admin')

Une expression régulière ou une fonction peut également être fournie, afin de créer un espace de nom de manière dynamique:

const dynamicNsp = io.of (/ ^  / dynamic-  d + $ /).sur('relier', (socket) => 
const newNamespace = socket.nsp;


newNamespace.emit ('Bonjour')
);


const socket = io ('/ dynamic-101')


dynamicNsp.emit ('Bonjour')


dynamicNsp.use ((prise, prochaine) => );

Avec une fonction:

io.of ((nom, requête, suivant) => 
suivant(nul, checkToken (query.token));
).sur('relier', (socket) => );

server.close ([callback])

Ferme le serveur socket.io. le rappeler l'argument est facultatif et sera appelé lorsque toutes les connexions seront fermées.

const Serveur = exiger('socket.io')
const PORT = 3030;
const serveur = exiger('http').Serveur();

const io = serveur (PORT);

io.close ();

server.listen (PORT);

io = serveur (serveur);

server.engine.generateId

Ecrase la méthode par défaut pour générer votre identifiant de socket personnalisé.

La fonction est appelée avec un objet de requête de noeud (http.IncomingMessage) comme premier paramètre.

io.engine.generateId = (req) => 
revenir "custom: id:" + custom_id ++;

Représente un pool de sockets connectés sous une étendue donnée identifiée par un chemin (par exemple: /bavarder).

Un client se connecte toujours à / (l’espace de noms principal), puis connectez-vous potentiellement à d’autres espaces de noms (tout en utilisant la même connexion sous-jacente).

Pour savoir comment et pourquoi, consultez: Pièces et espaces de noms.

namespace.name

La propriété d'identifiant d'espace de nom.

namespace.connected

Le hash de Prise objets connectés à cet espace de noms, indexés par identifiant.

namespace.adapter

le Adaptateur utilisé pour l'espace de noms. Utile lorsque vous utilisez le Adaptateur basé sur Redis, car il expose des méthodes pour gérer les sockets et les salles de votre cluster.

Remarque: l'adaptateur de l'espace de noms principal est accessible avec io.of ('/'). adaptateur.

namespace.to (room)

  • pièce (Chaîne)
  • Résultats Espace de noms pour chaîner

Définit un modificateur pour une émission d'événement ultérieure que l'événement sera uniquement diffusé aux clients qui ont rejoint le donné pièce.

Pour émettre dans plusieurs pièces, vous pouvez appeler à plusieurs fois.

const io = exiger('socket.io') ();
const adminNamespace = io.of ('/ admin')

adminNamespace.to ('niveau 1').émettre('un évènement' certains: 'Les données' );

namespace.in (room)

Synonyme de namespace.to (salle).

namespace.emit (eventName[, …args])

Émet un événement à tous les clients connectés. Les deux suivants sont équivalents:

const io = exiger('socket.io') ();
io.emit ('un événement envoyé à tous les clients connectés')

const chat = io.of ('/bavarder')
chat.emit ('un événement envoyé à tous les clients connectés dans l'espace de noms de discussion')

Remarque: les accusés de réception ne sont pas pris en charge lors de l'émission à partir d'un espace de noms.

namespace.clients (rappel)

Obtient une liste d'ID de clients connectés à cet espace de noms (sur tous les nœuds, le cas échéant).

const io = exiger('socket.io') ();
io.of ('/bavarder') .clients ((erreur, clients) =>
si (Erreur) jeter Erreur;
console.log (clients);
);

Un exemple pour obtenir tous les clients dans la chambre de l’espace de noms:

io.of ('/bavarder').dans('général') .clients ((erreur, clients) => 
si (Erreur) jeter Erreur;
console.log (clients);
);

Comme pour la diffusion, tous les clients de l’espace de nom par défaut sont tous les clients:

io.clients ((erreur, clients) => 
si (Erreur) jeter Erreur;
console.log (clients);
);

namespace.use (fn)

Enregistre un middleware, une fonction qui est exécutée pour chaque entrée Prise, et reçoit comme paramètres le socket et une fonction permettant de différer éventuellement l’exécution au prochain middleware enregistré.

Les erreurs transmises aux rappels de middleware sont envoyées comme spéciales Erreur paquets aux clients.

io.use ((prise, prochaine) => 
si (socket.request.headers.cookie) revenir suivant();
suivant(Nouveau Erreur('Erreur d'authentification'));
);

Evénement: 'connect'

  • prise (Prise) connexion socket avec le client

Tiré sur une connexion du client.

io.on ('relier', (socket) => 

);

io.of ('/ admin').sur('relier', (socket) =>

);

Evénement: ‘connexion’

Synonyme d’événement: «connect».

Drapeau: «volatile»

Définit un modificateur pour une émission d'événement ultérieure selon laquelle les données d'événement peuvent être perdues si les clients ne sont pas prêts à recevoir des messages (en raison de la lenteur du réseau ou d'autres problèmes, ou du fait qu'ils sont connectés au cours d'une longue interrogation et qu'ils se trouvent au milieu d'une requête. cycle de réponse).

io.volatile.emit ('un évènement' certains: 'Les données' ); 

Drapeau: «binaire»

Spécifie s'il existe des données binaires dans les données émises. Augmente les performances lorsque spécifié. Peut être vrai ou faux.

io.binary (faux).émettre('un évènement' certains: 'Les données' );

Drapeau: «local»

Définit un modificateur pour une émission d'événement ultérieure selon laquelle les données d'événement seront uniquement diffuser au nœud actuel (lorsque l’adaptateur Redis est utilisé).

io.local.emit ('un évènement' certains: 'Les données' );

UNE Prise est la classe fondamentale pour interagir avec les clients du navigateur. UNE Prise appartient à un certain Espace de noms (par défaut /) et utilise un sous-jacent Client communiquer.

Il convient de noter le Prise ne se rapporte pas directement au TCP / IP sous-jacent réel prise et ce n'est que le nom de la classe.

Dans chaque Espace de noms, vous pouvez également définir des canaux arbitraires (appelés pièce) que le Prise peut rejoindre et partir. Cela fournit un moyen pratique de diffuser à un groupe de Prises (voir Socket # to au dessous de).

le Prise La classe hérite de EventEmitter. le Prise la classe annule la émettre méthode, et ne modifie aucune autre EventEmitter méthode. Toutes les méthodes documentées ici qui apparaissent également comme EventEmitter méthodes (en dehors de émettre) sont mis en œuvre par EventEmitteret documentation pour EventEmitter s'applique.

socket.id

Un identifiant unique pour la session, qui provient du sous-jacent Client.

socket.rooms

Un hachage de chaînes identifiant les salles dans lesquelles se trouve ce client, indexé par nom de salle.

io.on ('lien', (socket) => 
socket.join ('chambre 237', () =>
laisser chambres = Objet.keys (socket.rooms);
console.log (chambres);
);
);

socket.client

Une référence au sous-jacent Client objet.

socket.conn

Une référence au sous-jacent Client connexion de transport (engine.io Prise objet). Cela permet d'accéder à la couche de transport d'E / S, qui reste (principalement) abstraite du socket TCP / IP réel.

socket.request

Un proxy getter qui renvoie la référence à la demande qui est à l'origine du moteur.io sous-jacent Client. Utile pour accéder aux en-têtes de requête tels que Biscuit ou Agent utilisateur.

prise de main

Les détails de la poignée de main:


en-têtes:
temps: ,
adresse: ,
xdomain:,
sécurisé:
Publié: ,
URL:,
question:

Usage:

io.use ((prise, prochaine) => 
laisser poignée de main = socket.handshake;

);

io.on ('lien', (socket) =>
laisser poignée de main = socket.handshake;

);

socket.use (fn)

Enregistre un middleware, une fonction qui est exécutée pour chaque entrée Paquet et reçoit en paramètre le paquet et une fonction permettant de différer éventuellement l'exécution au middleware enregistré suivant.

Les erreurs passées aux rappels de middleware sont envoyées comme spéciales Erreur paquets aux clients.

io.on ('lien', (socket) => 
socket.use ((paquet, ensuite) =>
si (packet.doge === vrai) revenir suivant();
suivant(Nouveau Erreur('Pas une erreur de chien'));
);
);

socket.send ([…args][, ack])

  • args
  • ack (Une fonction)
  • Résultats Prise

Envoie un message un événement. Voir socket.emit (eventName[, …args][, ack]).

socket.emit (eventName[, …args][, ack])

(annule EventEmitter.emit)

  • Nom de l'événement (Chaîne)
  • args
  • ack (Une fonction)
  • Résultats Prise

Emet un événement sur le socket identifié par le nom de la chaîne. Tout autre paramètre peut être inclus. Toutes les infrastructures de données sérialisables sont prises en charge, y compris Tampon.

socket.emit ('Bonjour', 'monde')
socket.emit ('avec-binaire', 1, '2' 3: '4', 5: Nouveau Tampon(6));

le ack L’argument est facultatif et sera appelé avec la réponse du client.

io.on ('lien', (socket) => 
socket.emit ('un évènement' certains: 'Les données' );

socket.emit ('furet', 'tobi', (data) =>
console.log (données);
);






);

socket.on (eventName, rappel)

(hérité de EventEmitter)

  • Nom de l'événement (Chaîne)
  • rappeler (Une fonction)
  • Résultats Prise

Enregistrez un nouveau gestionnaire pour l'événement donné.

socket.on ('nouvelles', (data) => 
console.log (données);
);

socket.on ('nouvelles', (arg1, arg2, arg3) =>

);

socket.on ('nouvelles', (data, callback) =>
rappeler(0)
);

socket.once (eventName, listener)

socket.removeListener (eventName, listener)

socket.removeAllListeners ([eventName])

socket.eventNames ()

Hérité de EventEmitter (avec d'autres méthodes non mentionnées ici). Voir la documentation de Node.js pour la événements module.

socket.join (room[, callback])

  • pièce (Chaîne)
  • rappeler (Une fonction)
  • Résultats Prise pour chaîner

Ajoute le client au pièceet déclenche éventuellement un rappel avec se tromper signature (le cas échéant).

io.on ('lien', (socket) => 
socket.join ('chambre 237', () =>
laisser chambres = Objet.keys (socket.rooms);
console.log (chambres);
io.to ('chambre 237').émettre("un nouvel utilisateur a rejoint la salle")
);
);

Les mécanismes de jonction des salles sont gérés par le Adaptateur qui a été configuré (voir Adaptateur # serveur ci-dessus), par défaut sur socket.io-adaptateur.

Pour votre commodité, chaque socket rejoint automatiquement une pièce identifiée par son identifiant (voir Socket # id). Cela facilite la diffusion de messages vers d'autres sockets:

io.on ('lien', (socket) => 
socket.on ('dire à quelqu'un', (id, msg) =>

socket.to (id) .emit ('mon message', msg);
);
);

socket.join (chambres[, callback])

  • pièces (Tableau)
  • rappeler (Une fonction)
  • Résultats Prise pour chaîner

Ajoute le client à la liste des salles et déclenche éventuellement un rappel avec se tromper signature (le cas échéant).

socket.leave (room[, callback])

  • pièce (Chaîne)
  • rappeler (Une fonction)
  • Résultats Prise pour chaîner

Supprime le client de pièceet déclenche éventuellement un rappel avec se tromper signature (le cas échéant).

Les chambres sont laissées automatiquement lors de la déconnexion.

socket.to (salle)

  • pièce (Chaîne)
  • Résultats Prise pour chaîner

Définit un modificateur pour une émission d'événement ultérieure que l'événement sera uniquement diffusé aux clients qui ont rejoint le donné pièce (la prise elle-même étant exclue).

Pour émettre dans plusieurs pièces, vous pouvez appeler à plusieurs fois.

io.on ('lien', (socket) => 


socket.to ('autres').émettre('un évènement' certains: 'Les données' );


socket.to ('room1').à('room2').émettre('Bonjour')


socket.to (). emit ('Hey')



);

Remarque: les accusés de réception ne sont pas pris en charge lors de la diffusion.

socket.in (salle)

Synonyme de socket.to (salle).

socket.compress (valeur)

  • valeur (Booléen) si le paquet suivant sera compressé
  • Résultats Prise pour chaîner

Définit un modificateur pour une émission d'événement ultérieure selon laquelle les données d'événement seront uniquement comprimé si la valeur est vrai. Par défaut à vrai lorsque vous n'appelez pas la méthode.

io.on ('lien', (socket) => 
socket.compress (faux).émettre('non compressé', "c'est rugueux")
);

socket.disconnect (close)

  • Fermer (Booléen) s'il faut fermer la connexion sous-jacente
  • Résultats Prise

Déconnecte ce client. Si la valeur de fermeture est vrai, ferme la connexion sous-jacente. Sinon, il ne fait que déconnecter l'espace de noms.

io.on ('lien', (socket) => 
setTimeout (() => socket.disconnect (vrai), 5000)
);

Drapeau: ‘broadcast’

Définit un modificateur pour une émission d'événement ultérieure selon laquelle les données d'événement seront uniquement diffuser à tous les sockets, mais l'expéditeur.

io.on ('lien', (socket) => 
socket.broadcast.emit ('un évènement' certains: 'Les données' );
);

Drapeau: «volatile»

Définit un modificateur pour une émission d'événement ultérieure selon laquelle les données d'événement peuvent être perdues si le client n'est pas prêt à recevoir des messages (en raison de la lenteur du réseau ou d'autres problèmes, ou parce qu'ils sont connectés au cours d'une longue interrogation et qu'ils sont au milieu d'une demande. cycle de réponse).

io.on ('lien', (socket) => 
socket.volatile.emit ('un évènement' certains: 'Les données' );
);

Drapeau: «binaire»

Spécifie s'il existe des données binaires dans les données émises. Augmente les performances lorsque spécifié. Peut être vrai ou faux.

var io = exiger('socket.io') ();
io.on ('lien', une fonction(prise)
socket.binary (faux).émettre('un évènement' certains: 'Les données' );
);

Evénement: "déconnecter"

  • raison (Chaîne) la raison de la déconnexion (côté client ou côté serveur)

Tiré lors de la déconnexion.

io.on ('lien', (socket) => 
socket.on ('déconnecter', (raison) =>

);
);

Raisons possibles:

Raison Côté La description
erreur de transport Du côté serveur Erreur de transport
Déconnexion de l'espace de noms du serveur Du côté serveur Le serveur effectue un socket.disconnect ()
déconnexion de l'espace de noms du client Côté client Vous avez déconnecté le paquet du client
ping timeout Côté client Le client a cessé de répondre aux pings dans le délai imparti (selon le pingTimeout réglage de configuration)
transport à proximité Côté client Le client a cessé d'envoyer des données

Evénement: ‘erreur’

  • Erreur (Objet) objet d'erreur

Déclenché lorsqu'une erreur survient.

io.on ('lien', (socket) => 
socket.on ('Erreur', (erreur) =>

);
);

Evénement: "déconnexion"

  • raison (Chaîne) la raison de la déconnexion (côté client ou côté serveur)

Se déclenche lorsque le client va être déconnecté (mais n’a pas quitté son pièces encore).

io.on ('lien', (socket) => 
socket.on ('déconnecter', (raison) =>
laisser chambres = Objet.keys (socket.rooms);

);
);

Ce sont des événements réservés (avec relier, nouveauListener et removeListener) qui ne peuvent pas être utilisés comme noms d’événements.

le Client La classe représente une connexion de transport entrant (engine.io). UNE Client peut être associé à de nombreux multiplexés Prises qui appartiennent à différents Espace de nomss.

client.conn

Une référence au sous-jacent moteur.io Prise lien.

client.request

Un proxy getter qui renvoie la référence à la demande qui est à l'origine de la connexion engine.io. Utile pour accéder aux en-têtes de requête tels que Biscuit ou Agent utilisateur.

Pris une erreur? Éditez cette page sur GitHub

Commentaires

Laisser un commentaire

Votre commentaire sera révisé par les administrateurs si besoin.