ModuleClient class

function close(): Promise<Disconnected>

Retornos

Fecha a conexão de transporte e destrói os recursos do cliente.

Observação: depois de chamar esse método, o objeto ModuleClient não pode ser reutilizado.

function close(closeCallback?: Callback<Disconnected>)

Parâmetros

Cria um cliente de módulo do Hub IoT com base no método de autenticação fornecido e usando o tipo de transporte fornecido.

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

Parâmetros

Retornos

Cria um cliente de dispositivo do Hub IoT da cadeia de conexão fornecida usando o tipo de transporte fornecido.

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

Parâmetros

Retornos

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

Parâmetros

Retornos

Cria um cliente de módulo do Hub IoT usando informações de configuração do ambiente.

Se houver uma variável de ambiente chamada EdgeHubConnectionString ou IotHubConnectionString, esse valor será usado e o comportamento será idêntico à chamada fromConnectionString passando isso. Se essas variáveis de ambiente não existirem, as seguintes variáveis deverão ser definidas:

- 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>)

Parâmetros

Cria um cliente de módulo do Hub IoT com base na assinatura de acesso compartilhado fornecida usando o tipo de transporte fornecido.

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

Parâmetros

Retornos

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

Parâmetros

Retornos

Invoca um método em um dispositivo downstream ou em outro módulo no mesmo dispositivo IoTEdge. Observe que esse recurso só funciona quando o módulo está sendo executado como parte de um dispositivo IoTEdge.

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

Parâmetros

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

Parâmetros

Retornos

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

Parâmetros

Registra um retorno de chamada para um método chamado methodName.

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

Parâmetros

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

Parâmetros

Retornos

Envia um evento para a saída de módulo fornecida

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

Parâmetros

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

Parâmetros

Retornos

Envia uma matriz de eventos para a saída do módulo fornecida

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

Parâmetros

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

Parâmetros

Retornos

Passa opções para o objeto ModuleClient que pode ser usado para configurar o transporte.

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

Parâmetros

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

Parâmetros

Retornos

herdado de InternalClient.abandon

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

Parâmetros

herdado de InternalClient.abandon

Alias para emitter.on(eventName, listener).

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

Parâmetros

Retornos

Herdado de InternalClient.addListener

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

Parâmetros

Retornos

Herdado de InternalClient.complete

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

Parâmetros

Herdado de InternalClient.complete

Chama de forma síncrona cada um dos ouvintes registrados para o evento chamado eventName, na ordem em que foram registrados, passando os argumentos fornecidos para cada um.

Retorna true se o evento tiver ouvintes, false caso contrário.

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

Parâmetros

Retornos

Herdado de InternalClient.emit

Retorna uma matriz listando os eventos para os quais o emissor registrou ouvintes.

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)[]

Retornos

Herdado de InternalClient.eventNames

Retorna o valor máximo atual do ouvinte para o EventEmitter que é definido por emitter.setMaxListeners(n) ou usa como padrão events.defaultMaxListeners.

function getMaxListeners(): number

Retornos

herdado de InternalClient.getMaxListeners

function getTwin(): Promise<Twin>

Retornos

herdado de InternalClient.getTwin

function getTwin(done: Callback<Twin>)

Parâmetros

herdado de InternalClient.getTwin

Retorna o número de ouvintes que escutam o evento chamado eventName. Se listener for fornecido, ele retornará quantas vezes o ouvinte é encontrado na lista de ouvintes do evento.

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

Parâmetros

Retornos

Herdado de InternalClient.listenerCount

Retorna uma cópia da matriz de ouvintes para o evento chamado 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[]

Parâmetros

Retornos

Herdado de InternalClient.listeners

Alias para emitter.removeListener().

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

Parâmetros

Retornos

Herdado de InternalClient.off

Adiciona a função listener ao final da matriz de ouvintes para o evento chamado eventName. Nenhuma verificação é feita para ver se o listener já foi adicionado. Várias chamadas passando a mesma combinação de eventName e listener resultarão na adição da listener e chamada várias vezes.

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

Retorna uma referência ao EventEmitter, para que as chamadas possam ser encadeadas.

Por padrão, os ouvintes de eventos são invocados na ordem em que são adicionados. O método emitter.prependListener() pode ser usado como uma alternativa para adicionar o ouvinte de eventos ao início da matriz de ouvintes.

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

Parâmetros

Retornos

Herdado de InternalClient.on

Adiciona uma função de única para o evento chamado . Na próxima vez que eventName for disparado, esse ouvinte será removido e invocado.

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

Retorna uma referência ao EventEmitter, para que as chamadas possam ser encadeadas.

Por padrão, os ouvintes de eventos são invocados na ordem em que são adicionados. O método emitter.prependOnceListener() pode ser usado como uma alternativa para adicionar o ouvinte de eventos ao início da matriz de ouvintes.

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

Parâmetros

Retornos

herdado de InternalClient.once

function open(): Promise<Connected>

Retornos

herdado de InternalClient.open

function open(openCallback: Callback<Connected>)

Parâmetros

herdado de InternalClient.open

Adiciona a função listener à inicial da matriz de ouvintes para o evento chamado eventName. Nenhuma verificação é feita para ver se o listener já foi adicionado. Várias chamadas passando a mesma combinação de eventName e listener resultarão na adição da listener e chamada várias vezes.

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

Retorna uma referência ao EventEmitter, para que as chamadas possam ser encadeadas.

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

Parâmetros

Retornos

Herdado de InternalClient.prependListener

Adiciona uma função de única para o evento chamado à inicial da matriz de ouvintes. Na próxima vez que eventName for disparado, esse ouvinte será removido e invocado.

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

Retorna uma referência ao EventEmitter, para que as chamadas possam ser encadeadas.

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

Parâmetros

Retornos

Herdado de InternalClient.prependOnceListener

Retorna uma cópia da matriz de ouvintes para o evento chamado eventName, incluindo quaisquer wrappers (como aqueles criados por .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[]

Parâmetros

Retornos

herdado de InternalClient.rawListeners

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

Parâmetros

Retornos

herdado de InternalClient.reject

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

Parâmetros

herdado de InternalClient.reject

Remove todos os ouvintes ou os do eventNameespecificado.

É uma má prática remover ouvintes adicionados em outro lugar no código, especialmente quando a instância de EventEmitter foi criada por algum outro componente ou módulo (por exemplo, soquetes ou fluxos de arquivo).

Retorna uma referência ao EventEmitter, para que as chamadas possam ser encadeadas.

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

Parâmetros

Retornos

herdado de InternalClient.removeAllListeners

Remove o listener especificado da matriz de ouvintes para o evento chamado eventName.

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

removeListener() removerá, no máximo, uma instância de um ouvinte da matriz do ouvinte. Se qualquer ouvinte tiver sido adicionado várias vezes à matriz de ouvintes para o eventNameespecificado, removeListener() deverá ser chamado várias vezes para remover cada instância.

Depois que um evento é emitido, todos os ouvintes anexados a ele no momento da emissão são chamados em ordem. Isso implica que qualquer removeListener() chamada removeAllListeners() após a emissão e antes da execução do último ouvinte não as remove do emit() processo em andamento. Os eventos subsequentes se comportam conforme o esperado.

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

Como os ouvintes são gerenciados usando um array interno, chamar isso altera os índices de posição de qualquer ouvinte registrado após a remoção do ouvinte. Isso não afetará a ordem na qual os ouvintes são chamados, mas significa que todas as cópias da matriz do ouvinte, conforme retornado pelo método emitter.listeners(), precisarão ser recriadas.

Quando uma única função tiver sido adicionada como um manipulador várias vezes para um único evento (como no exemplo abaixo), removeListener() removerá a instância adicionada mais recentemente. No exemplo, o ouvinte once('ping') é removido:

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');

Retorna uma referência ao EventEmitter, para que as chamadas possam ser encadeadas.

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

Parâmetros

Retornos

herdado de InternalClient.removeListener

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

Parâmetros

Retornos

herdado de InternalClient.sendEvent

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

Parâmetros

herdado de InternalClient.sendEvent

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

Parâmetros

Retornos

herdado de InternalClient.sendEventBatch

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

Parâmetros

herdado de InternalClient.sendEventBatch

Por padrão, EventEmitterimprimirão um aviso se mais de 10 ouvintes forem adicionados para um evento específico. Esse é um padrão útil que ajuda a localizar vazamentos de memória. O método emitter.setMaxListeners() permite que o limite seja modificado para esta instância de EventEmitter específica. O valor pode ser definido como Infinity (ou 0) para indicar um número ilimitado de ouvintes.

Retorna uma referência ao EventEmitter, para que as chamadas possam ser encadeadas.

function setMaxListeners(n: number): ModuleClient

Parâmetros

Retornos

herdado de InternalClient.setMaxListeners

Define a política de repetição usada pelo cliente em todas as operações. O padrão é ExponentialBackoffWithJitter.

function setRetryPolicy(policy: RetryPolicy)

Parâmetros

herdado de InternalClient.setRetryPolicy

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

Parâmetros

Retornos

Herdado de InternalClient.setTransportOptions

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

Parâmetros

Herdado de InternalClient.setTransportOptions

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

Parâmetros

herdado de InternalClient.updateSharedAccessSignature

O Symbol.for('nodejs.rejection') método é chamado caso ocorra uma rejeição de promessa ao emitir um evento e captureRejections é ativado no emissor. É possível usar events.captureRejectionSymbol no lugar 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[])

Parâmetros

Herdado de InternalClient.__@captureRejectionSymbol@129