ModuleClient class

function close(): Promise<Disconnected>

Retourne

Ferme la connexion de transport et détruit les ressources clientes.

Remarque : après avoir appelé cette méthode, l’objet ModuleClient ne peut pas être réutilisé.

function close(closeCallback?: Callback<Disconnected>)

Paramètres

Crée un client de module IoT Hub à partir de la méthode d’authentification donnée et à l’aide du type de transport donné.

static function fromAuthenticationProvider(authenticationProvider: AuthenticationProvider, transportCtor: any): ModuleClient

Paramètres

Retourne

Crée un client d’appareil IoT Hub à partir de la chaîne de connexion donnée à l’aide du type de transport donné.

static function fromConnectionString(connStr: string, transportCtor: any): ModuleClient

Paramètres

Retourne

static function fromEnvironment(transportCtor: any): Promise<ModuleClient>

Paramètres

Retourne

Crée un client de module IoT Hub à l’aide d’informations de configuration de l’environnement.

Si une variable d’environnement appelée EdgeHubConnectionString ou IotHubConnectionString existe, cette valeur est utilisée et le comportement est identique à l’appel fromConnectionString transmettre cette valeur. Si ces variables d’environnement n’existent pas, les variables suivantes DOIVENT être définies :

- IOTEDGE_WORKLOADURI          URI for iotedged's workload API
- IOTEDGE_DEVICEID             Device identifier
- IOTEDGE_MODULEID             Module identifier
- IOTEDGE_MODULEGENERATIONID   Module generation identifier
- IOTEDGE_IOTHUBHOSTNAME       IoT Hub host name
- IOTEDGE_AUTHSCHEME           Authentication scheme to use; must be "sasToken"

static function fromEnvironment(transportCtor: any, callback?: Callback<ModuleClient>)

Paramètres

Crée un client de module IoT Hub à partir de la signature d’accès partagé donnée à l’aide du type de transport donné.

static function fromSharedAccessSignature(sharedAccessSignature: string, transportCtor: any): ModuleClient

Paramètres

Retourne

function invokeMethod(deviceId: string, methodParams: MethodParams): Promise<MethodResult>

Paramètres

Retourne

Appelle une méthode sur un appareil en aval ou sur un autre module sur le même appareil IoTEdge. Notez que cette fonctionnalité fonctionne uniquement lorsque le module est exécuté dans le cadre d’un appareil IoTEdge.

function invokeMethod(deviceId: string, methodParams: MethodParams, callback?: Callback<MethodResult>)

Paramètres

function invokeMethod(deviceId: string, moduleId: string, methodParams: MethodParams): Promise<MethodResult>

Paramètres

Retourne

function invokeMethod(deviceId: string, moduleId: string, methodParams: MethodParams, callback: Callback<MethodResult>)

Paramètres

Inscrit un rappel pour une méthode nommée methodName.

function onMethod(methodName: string, callback: DoubleValueCallback<DeviceMethodRequest, DeviceMethodResponse>)

Paramètres

function sendOutputEvent(outputName: string, message: Message): Promise<MessageEnqueued>

Paramètres

Retourne

Envoie un événement à la sortie du module donné

function sendOutputEvent(outputName: string, message: Message, callback?: Callback<MessageEnqueued>)

Paramètres

function sendOutputEventBatch(outputName: string, messages: Message[]): Promise<MessageEnqueued>

Paramètres

Retourne

Envoie un tableau d’événements à la sortie du module donné

function sendOutputEventBatch(outputName: string, messages: Message[], callback?: Callback<MessageEnqueued>)

Paramètres

function setOptions(options: DeviceClientOptions): Promise<TransportConfigured>

Paramètres

Retourne

Transmet les options à l’objet ModuleClient qui peut être utilisé pour configurer le transport.

function setOptions(options: DeviceClientOptions, done?: Callback<TransportConfigured>)

Paramètres

function abandon(message: Message): Promise<MessageAbandoned>

Paramètres

Retourne

héritée de InternalClient.abandon

function abandon(message: Message, abandonCallback: Callback<MessageAbandoned>)

Paramètres

héritée de InternalClient.abandon

Alias pour emitter.on(eventName, listener).

function addListener<E>(eventName: string | symbol, listener: (args: any[]) => void): ModuleClient

Paramètres

Retourne

héritée de InternalClient.addListener

function complete(message: Message): Promise<MessageCompleted>

Paramètres

Retourne

héritée de InternalClient.complete

function complete(message: Message, completeCallback: Callback<MessageCompleted>)

Paramètres

héritée de InternalClient.complete

Appelle de manière synchrone chacun des écouteurs inscrits pour l’événement nommé eventName, dans l’ordre dans lequel ils ont été inscrits, en passant les arguments fournis à chacun d’eux.

Retourne true si l’événement avait des écouteurs, false sinon.

import { EventEmitter } from 'node:events';
const myEmitter = new EventEmitter();

// First listener
myEmitter.on('event', function firstListener() {
  console.log('Helloooo! first listener');
});
// Second listener
myEmitter.on('event', function secondListener(arg1, arg2) {
  console.log(`event with parameters ${arg1}, ${arg2} in second listener`);
});
// Third listener
myEmitter.on('event', function thirdListener(...args) {
  const parameters = args.join(', ');
  console.log(`event with parameters ${parameters} in third listener`);
});

console.log(myEmitter.listeners('event'));

myEmitter.emit('event', 1, 2, 3, 4, 5);

// Prints:
// [
//   [Function: firstListener],
//   [Function: secondListener],
//   [Function: thirdListener]
// ]
// Helloooo! first listener
// event with parameters 1, 2 in second listener
// event with parameters 1, 2, 3, 4, 5 in third listener

function emit<E>(eventName: string | symbol, args: any[]): boolean

Paramètres

Retourne

héritée de InternalClient.emit

Retourne un tableau répertoriant les événements pour lesquels l’émetteur a enregistré des écouteurs.

import { EventEmitter } from 'node:events';

const myEE = new EventEmitter();
myEE.on('foo', () => {});
myEE.on('bar', () => {});

const sym = Symbol('symbol');
myEE.on(sym, () => {});

console.log(myEE.eventNames());
// Prints: [ 'foo', 'bar', Symbol(symbol) ]

function eventNames(): (string | symbol)[]

Retourne

héritée de InternalClient.eventNames

Retourne la valeur maximale actuelle de l’écouteur pour l'EventEmitter qui est définie par emitter.setMaxListeners(n) ou par défaut sur events.defaultMaxListeners.

function getMaxListeners(): number

Retourne

héritée de InternalClient.getMaxListeners

function getTwin(): Promise<Twin>

Retourne

héritée de InternalClient.getTwin

function getTwin(done: Callback<Twin>)

Paramètres

héritée de InternalClient.getTwin

Retourne le nombre d’écouteurs à l’écoute de l’événement nommé eventName. Si listener est fourni, il retourne le nombre de fois où l’écouteur est trouvé dans la liste des écouteurs de l’événement.

function listenerCount<E>(eventName: string | symbol, listener?: (args: any[]) => void): number

Paramètres

Retourne

héritée de InternalClient.listenerCount

Retourne une copie du tableau d’écouteurs pour l’événement nommé eventName.

server.on('connection', (stream) => {
  console.log('someone connected!');
});
console.log(util.inspect(server.listeners('connection')));
// Prints: [ [Function] ]

function listeners<E>(eventName: string | symbol): (args: any[]) => void[]

Paramètres

Retourne

héritée de InternalClient.listeners

Alias pour emitter.removeListener().

function off<E>(eventName: string | symbol, listener: (args: any[]) => void): ModuleClient

Paramètres

Retourne

héritée de InternalClient.off

Ajoute la fonction listener à la fin du tableau d’écouteurs pour l’événement nommé eventName. Aucune vérification n’est effectuée pour voir si le listener a déjà été ajouté. Plusieurs appels passant la même combinaison de eventName et de listener entraînent l’ajout de la listener et l’appel, plusieurs fois.

server.on('connection', (stream) => {
  console.log('someone connected!');
});

Retourne une référence au EventEmitter, afin que les appels puissent être chaînés.

Par défaut, les écouteurs d’événements sont appelés dans l’ordre dans lequel ils sont ajoutés. La méthode emitter.prependListener() peut être utilisée comme alternative pour ajouter l’écouteur d’événements au début du tableau d’écouteurs.

import { EventEmitter } from 'node:events';
const myEE = new EventEmitter();
myEE.on('foo', () => console.log('a'));
myEE.prependListener('foo', () => console.log('b'));
myEE.emit('foo');
// Prints:
//   b
//   a

function on<E>(eventName: string | symbol, listener: (args: any[]) => void): ModuleClient

Paramètres

Retourne

héritée de InternalClient.on

Ajoute une fonction listener unique pour l’événement nommé eventName. La prochaine fois que eventName est déclenchée, cet écouteur est supprimé, puis appelé.

server.once('connection', (stream) => {
  console.log('Ah, we have our first user!');
});

Retourne une référence au EventEmitter, afin que les appels puissent être chaînés.

Par défaut, les écouteurs d’événements sont appelés dans l’ordre dans lequel ils sont ajoutés. La méthode emitter.prependOnceListener() peut être utilisée comme alternative pour ajouter l’écouteur d’événements au début du tableau d’écouteurs.

import { EventEmitter } from 'node:events';
const myEE = new EventEmitter();
myEE.once('foo', () => console.log('a'));
myEE.prependOnceListener('foo', () => console.log('b'));
myEE.emit('foo');
// Prints:
//   b
//   a

function once<E>(eventName: string | symbol, listener: (args: any[]) => void): ModuleClient

Paramètres

Retourne

héritée de InternalClient.once

function open(): Promise<Connected>

Retourne

héritée de InternalClient.open

function open(openCallback: Callback<Connected>)

Paramètres

héritée de InternalClient.open

Ajoute la fonction listener au début du tableau d’écouteurs pour l’événement nommé eventName. Aucune vérification n’est effectuée pour voir si le listener a déjà été ajouté. Plusieurs appels passant la même combinaison de eventName et de listener entraînent l’ajout de la listener et l’appel, plusieurs fois.

server.prependListener('connection', (stream) => {
  console.log('someone connected!');
});

Retourne une référence au EventEmitter, afin que les appels puissent être chaînés.

function prependListener<E>(eventName: string | symbol, listener: (args: any[]) => void): ModuleClient

Paramètres

Retourne

héritée de InternalClient.prependListener

Ajoute une fonction listener unique pour l’événement nommé eventName au début du tableau d’écouteurs. La prochaine fois que eventName est déclenchée, cet écouteur est supprimé, puis appelé.

server.prependOnceListener('connection', (stream) => {
  console.log('Ah, we have our first user!');
});

Retourne une référence au EventEmitter, afin que les appels puissent être chaînés.

function prependOnceListener<E>(eventName: string | symbol, listener: (args: any[]) => void): ModuleClient

Paramètres

Retourne

héritée de InternalClient.prependOnceListener

Retourne une copie du tableau d’écouteurs pour l’événement nommé eventName, y compris les wrappers (tels que ceux créés par .once()).

import { EventEmitter } from 'node:events';
const emitter = new EventEmitter();
emitter.once('log', () => console.log('log once'));

// Returns a new Array with a function `onceWrapper` which has a property
// `listener` which contains the original listener bound above
const listeners = emitter.rawListeners('log');
const logFnWrapper = listeners[0];

// Logs "log once" to the console and does not unbind the `once` event
logFnWrapper.listener();

// Logs "log once" to the console and removes the listener
logFnWrapper();

emitter.on('log', () => console.log('log persistently'));
// Will return a new Array with a single function bound by `.on()` above
const newListeners = emitter.rawListeners('log');

// Logs "log persistently" twice
newListeners[0]();
emitter.emit('log');

function rawListeners<E>(eventName: string | symbol): (args: any[]) => void[]

Paramètres

Retourne

héritée de InternalClient.rawListeners

function reject(message: Message): Promise<MessageRejected>

Paramètres

Retourne

héritée de InternalClient.reject

function reject(message: Message, rejectCallback: Callback<MessageRejected>)

Paramètres

héritée de InternalClient.reject

Supprime tous les écouteurs, ou ceux de la eventNamespécifiée.

Il est déconseillé de supprimer les écouteurs ajoutés ailleurs dans le code, en particulier lorsque l’instance de EventEmitter a été créée par un autre composant ou module (par exemple, des sockets ou des flux de fichiers).

Retourne une référence au EventEmitter, afin que les appels puissent être chaînés.

function removeAllListeners<E>(eventName?: string | symbol): ModuleClient

Paramètres

Retourne

héritée de InternalClient.removeAllListeners

Supprime le listener spécifié du tableau d’écouteurs pour l’événement nommé eventName.

const callback = (stream) => {
  console.log('someone connected!');
};
server.on('connection', callback);
// ...
server.removeListener('connection', callback);

removeListener() supprimera, au plus, une instance d’un écouteur du tableau d’écouteurs. Si un écouteur unique a été ajouté plusieurs fois au tableau d’écouteurs pour le eventNamespécifié, removeListener() doit être appelé plusieurs fois pour supprimer chaque instance.

Une fois qu’un événement est émis, tous les écouteurs attachés à celui-ci au moment de l’émission sont appelés dans l’ordre. Cela implique que tout removeListener() appel removeAllListeners()après émission et avant la fin de l’exécution du dernier auditeur ne les emit() supprimera pas de la procédure en cours. Les événements suivants se comportent comme prévu.

import { EventEmitter } from 'node:events';
class MyEmitter extends EventEmitter {}
const myEmitter = new MyEmitter();

const callbackA = () => {
  console.log('A');
  myEmitter.removeListener('event', callbackB);
};

const callbackB = () => {
  console.log('B');
};

myEmitter.on('event', callbackA);

myEmitter.on('event', callbackB);

// callbackA removes listener callbackB but it will still be called.
// Internal listener array at time of emit [callbackA, callbackB]
myEmitter.emit('event');
// Prints:
//   A
//   B

// callbackB is now removed.
// Internal listener array [callbackA]
myEmitter.emit('event');
// Prints:
//   A

Comme les auditeurs sont gérés via un tableau interne, appeler cela modifie les indices de position de tout auditeur enregistré après la suppression de cet auditeur. Cela n’aura pas d’impact sur l’ordre dans lequel les écouteurs sont appelés, mais cela signifie que toutes les copies du tableau d’écouteurs retournées par la méthode emitter.listeners() devront être recréées.

Lorsqu’une fonction unique a été ajoutée en tant que gestionnaire plusieurs fois pour un événement unique (comme dans l’exemple ci-dessous), removeListener() supprime l’instance la plus récemment ajoutée. Dans l’exemple, l’écouteur once('ping') est supprimé :

import { EventEmitter } from 'node:events';
const ee = new EventEmitter();

function pong() {
  console.log('pong');
}

ee.on('ping', pong);
ee.once('ping', pong);
ee.removeListener('ping', pong);

ee.emit('ping');
ee.emit('ping');

Retourne une référence au EventEmitter, afin que les appels puissent être chaînés.

function removeListener<E>(eventName: string | symbol, listener: (args: any[]) => void): ModuleClient

Paramètres

Retourne

héritée de InternalClient.removeListener

function sendEvent(message: Message): Promise<MessageEnqueued>

Paramètres

Retourne

héritée de InternalClient.sendEvent

function sendEvent(message: Message, sendEventCallback: Callback<MessageEnqueued>)

Paramètres

héritée de InternalClient.sendEvent

function sendEventBatch(messages: Message[]): Promise<MessageEnqueued>

Paramètres

Retourne

héritée de InternalClient.sendEventBatch

function sendEventBatch(messages: Message[], sendEventBatchCallback: Callback<MessageEnqueued>)

Paramètres

héritée de InternalClient.sendEventBatch

Par défaut, EventEmitters affiche un avertissement si plus de 10 écouteurs sont ajoutés pour un événement particulier. Il s’agit d’une valeur par défaut utile qui permet de trouver des fuites de mémoire. La méthode emitter.setMaxListeners() permet de modifier la limite pour cette instance de EventEmitter spécifique. La valeur peut être définie sur Infinity (ou 0) pour indiquer un nombre illimité d’écouteurs.

Retourne une référence au EventEmitter, afin que les appels puissent être chaînés.

function setMaxListeners(n: number): ModuleClient

Paramètres

Retourne

héritée de InternalClient.setMaxListeners

Définit la stratégie de nouvelle tentative utilisée par le client sur toutes les opérations. La valeur par défaut est ExponentialBackoffWithJitter.

function setRetryPolicy(policy: RetryPolicy)

Paramètres

héritée de InternalClient.setRetryPolicy

function setTransportOptions(options: any): Promise<TransportConfigured>

Paramètres

Retourne

héritée de InternalClient.setTransportOptions

function setTransportOptions(options: any, done: Callback<TransportConfigured>)

Paramètres

héritée de InternalClient.setTransportOptions

function updateSharedAccessSignature(sharedAccessSignature: string, updateSasCallback?: Callback<SharedAccessSignatureUpdated>)

Paramètres

héritée de InternalClient.updateSharedAccessSignature

La Symbol.for('nodejs.rejection') méthode est appelée au cas où un rejet de promesse survient lors de l’émission d’un événement et captureRejections est activée sur l’émetteur. Il est possible d’utiliser events.captureRejectionSymbol à la place de Symbol.for('nodejs.rejection').

import { EventEmitter, captureRejectionSymbol } from 'node:events';

class MyClass extends EventEmitter {
  constructor() {
    super({ captureRejections: true });
  }

  [captureRejectionSymbol](err, event, ...args) {
    console.log('rejection happened for', event, 'with', err, ...args);
    this.destroy(err);
  }

  destroy(err) {
    // Tear the resource down here.
  }
}

function [captureRejectionSymbol](error: Error, event: string | symbol, args: any[])

Paramètres

Hérité de InternalClient.__@captureRejectionSymbol@129