IotEdgeAuthenticationProvider class

Wartość: boolean

Zmień domyślną captureRejections opcję na wszystkich nowych EventEmitter obiektach.

static captureRejections: boolean

Wartość właściwości

Dziedziczone zSharedAccessKeyAuthenticationProvider.captureOdrzucenia

Wartość: Symbol.for('nodejs.rejection')

Zobacz, jak napisać niestandardową rejection handlerwersję .

static captureRejectionSymbol: typeof captureRejectionSymbol

Wartość właściwości

Dziedziczone zSharedAccessKeyAuthenticationProvider.captureRejectionSymbol

Domyślnie maksymalna liczba 10 słuchaczy może być zarejestrowana na dowolne wydarzenie. Limit ten można zmieniać dla poszczególnych EventEmitter instancji za pomocą tej metody emitter.setMaxListeners(n) . Aby zmienić domyślne ustawienia dla wszystkichEventEmitter instancji, events.defaultMaxListeners można użyć tej właściwości. Jeśli ta wartość nie jest dodatnią, rzuca się a RangeError .

Zachowaj ostrożność przy ustawianiu, events.defaultMaxListeners ponieważ zmiana dotyczy wszystkichEventEmitter instancji, w tym tych utworzonych przed jej wprowadzeniem. Jednak wywoływanie emitter.setMaxListeners(n) nadal ma pierwszeństwo nad events.defaultMaxListeners.

To nie jest twardy limit. Instancja EventEmitter pozwala na dodanie większej liczby słuchaczy, ale wygeneruje ostrzeżenie o śladzie do stderr, sygnalizujące wykrycie "możliwego wycieku pamięci EventEmitter". Dla dowolnego pojedynczego EventEmitter, emitter.getMaxListeners() metody i emitter.setMaxListeners() mogą być użyte do tymczasowego uniknięcia tego ostrzeżenia:

import { EventEmitter } from 'node:events';
const emitter = new EventEmitter();
emitter.setMaxListeners(emitter.getMaxListeners() + 1);
emitter.once('event', () => {
  // do stuff
  emitter.setMaxListeners(Math.max(emitter.getMaxListeners() - 1, 0));
});

Flaga --trace-warnings wiersza poleceń może być użyta do wyświetlania śladu stosu dla takich ostrzeżeń.

Emitowane ostrzeżenie można sprawdzić za pomocą process.on('warning') i będzie zawierać emitterdodatkowe , type, oraz count właściwości, odnoszące się odpowiednio do instancji emitora zdarzenia, nazwy zdarzenia oraz liczby podłączonych słuchaczy. Jego name własność jest ustawiona na .'MaxListenersExceededWarning'

static defaultMaxListeners: number

Wartość właściwości

Dziedziczone zSharedAccessKeyAuthenticationProvider.defaultMaxListeners

Ten symbol powinien być używany do instalacji nasłuchiwacza, który służy wyłącznie do monitorowania 'error' zdarzeń. Słuchacze zainstalowani za pomocą tego symbolu są wywoływani przed regularnymi 'error' słuchaczami.

Zainstalowanie słuchacza za pomocą tego symbolu nie zmienia zachowania po 'error' wygenerowaniu zdarzenia. Dlatego proces nadal się zawiesił, jeśli nie 'error' zainstalowano regularnego nasłuchiwacza.

static errorMonitor: typeof errorMonitor

Wartość właściwości

Dziedziczone zSharedAccessKeyAuthenticationProvider.errorMonitor

type: AuthenticationType

Wartość właściwości

dziedziczone zSharedAccessKeyAuthenticationProvider.type

function getTrustBundle(callback: (err?: Error, ca?: string) => void)

Parametry

Słucha raz wydarzenia abort na poleconym signalkoncie.

Nasłuchiwanie abort zdarzenia na sygnałach przerwania jest niebezpieczne i może prowadzić do wycieków zasobów, ponieważ inna osoba trzecia z sygnałem może zadzwonić e.stopImmediatePropagation(). Niestety Node.js tego nie zmienić, bo naruszałoby to standard internetowy. Dodatkowo oryginalne API ułatwia zapomnienie usunięcia słuchaczy.

To API pozwala bezpiecznie używać AbortSignals w Node.js API, rozwiązując te dwa problemy poprzez nasłuchiwanie zdarzenia w taki sposób, by stopImmediatePropagation nie uniemożliwiać uruchomienia nasłuchowcy.

Zwraca jednorazowy, aby łatwiej się z niego wypisać.

import { addAbortListener } from 'node:events';

function example(signal) {
  let disposable;
  try {
    signal.addEventListener('abort', (e) => e.stopImmediatePropagation());
    disposable = addAbortListener(signal, (e) => {
      // Do something when signal is aborted.
    });
  } finally {
    disposable?.[Symbol.dispose]();
  }
}

static function addAbortListener(signal: AbortSignal, resource: (event: Event) => void): Disposable

Parametry

Zwraca

Jednorazowe, które odbiera abort słuchacza.

Dziedziczone zSharedAccessKeyAuthenticationProvider.addAbortListener

Alias dla emitter.on(eventName, listener).

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

Parametry

Zwraca

dziedziczone zSharedAccessKeyAuthenticationProvider.addListener

Synchronicznie wywołuje każdy odbiornik zarejestrowany dla zdarzenia o nazwie eventName, w kolejności, w której zostały zarejestrowane, przekazując podane argumenty do każdego.

Zwraca true, jeśli zdarzenie miało odbiorniki, false w przeciwnym razie.

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<K>(eventName: string | symbol, args: AnyRest): boolean

Parametry

Zwraca

dziedziczone zSharedAccessKeyAuthenticationProvider.emit

Zwraca tablicę z listą zdarzeń, dla których emiter zarejestrował odbiorniki. Wartości w tablicy to ciągi lub Symbols.

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

Zwraca

dziedziczone zSharedAccessKeyAuthenticationProvider.eventNames

Tworzy nowy SharedAccessKeyAuthenticationProvider na podstawie parametrów połączenia

static function fromConnectionString(connectionString: string, tokenValidTimeInSeconds?: number, tokenRenewalMarginInSeconds?: number): SharedAccessKeyAuthenticationProvider

Parametry

Zwraca

dziedziczone zSharedAccessKeyAuthenticationProvider.fromConnectionString

function getDeviceCredentials(): Promise<TransportConfig>

Zwraca

dziedziczone zSharedAccessKeyAuthenticationProvider.getDeviceCredentials

Ta metoda jest używana przez transporty w celu uzyskania najbardziej aktualnych poświadczeń urządzenia w postaci obiektu TransportConfig.

function getDeviceCredentials(callback?: Callback<TransportConfig>)

Parametry

dziedziczone zSharedAccessKeyAuthenticationProvider.getDeviceCredentials

Zwraca kopię tablicy odbiorników dla zdarzenia o nazwie eventName.

Dla EventEmitters zachowuje się to dokładnie tak samo jak wywołanie .listeners emitera.

Dla EventTargets to jedyny sposób, by zdobyć odbiorców wydarzenia dla docelowego wydarzenia. Jest to przydatne do debugowania i diagnostyki.

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

{
  const ee = new EventEmitter();
  const listener = () => console.log('Events are fun');
  ee.on('foo', listener);
  console.log(getEventListeners(ee, 'foo')); // [ [Function: listener] ]
}
{
  const et = new EventTarget();
  const listener = () => console.log('Events are fun');
  et.addEventListener('foo', listener);
  console.log(getEventListeners(et, 'foo')); // [ [Function: listener] ]
}

static function getEventListeners(emitter: EventEmitter<DefaultEventMap> | EventTarget, name: string | symbol): Function[]

Parametry

Zwraca

Odziedziczone zSharedAccessKeyAuthenticationProvider.getEventListeners

Zwraca bieżącą wartość maksymalnego odbiornika dla EventEmitter, która jest ustawiona przez emitter.setMaxListeners(n) lub domyślnie ma wartość <xref:EventEmitter.defaultMaxListeners>.

function getMaxListeners(): number

Zwraca

dziedziczone zSharedAccessKeyAuthenticationProvider.getMaxListeners

Zwraca aktualnie ustaloną maksymalną liczbę słuchaczy.

Dla EventEmitters zachowuje się to dokładnie tak samo jak wywołanie .getMaxListeners emitera.

Dla EventTargets to jedyny sposób, aby uzyskać maksymalną liczbę słuchaczy zdarzeń dla docelowego wydarzenia. Jeśli liczba obsługiwaczy zdarzeń na jednym EventTarget przekroczy maksymalny zestaw, EventTarget wydrukuje ostrzeżenie.

import { getMaxListeners, setMaxListeners, EventEmitter } from 'node:events';

{
  const ee = new EventEmitter();
  console.log(getMaxListeners(ee)); // 10
  setMaxListeners(11, ee);
  console.log(getMaxListeners(ee)); // 11
}
{
  const et = new EventTarget();
  console.log(getMaxListeners(et)); // 10
  setMaxListeners(11, et);
  console.log(getMaxListeners(et)); // 11
}

static function getMaxListeners(emitter: EventEmitter<DefaultEventMap> | EventTarget): number

Parametry

Zwraca

dziedziczone zSharedAccessKeyAuthenticationProvider.getMaxListeners

Metoda klasowa zwracająca liczbę słuchaczy dla danego eventName rejestru na danym emitter.

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

const myEmitter = new EventEmitter();
myEmitter.on('event', () => {});
myEmitter.on('event', () => {});
console.log(listenerCount(myEmitter, 'event'));
// Prints: 2

static function listenerCount(emitter: EventEmitter<DefaultEventMap>, eventName: string | symbol): number

Parametry

Zwraca

dziedziczone zSharedAccessKeyAuthenticationProvider.listenerCount

Zwraca liczbę odbiorników nasłuchujących zdarzenia o nazwie eventName. W przypadku podania listener zostanie zwrócona liczba znalezionych odbiorników na liście odbiorników zdarzenia.

function listenerCount<K>(eventName: string | symbol, listener?: Function): number

Parametry

Zwraca

dziedziczone zSharedAccessKeyAuthenticationProvider.listenerCount

Zwraca kopię tablicy odbiorników dla zdarzenia o nazwie eventName.

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

function listeners<K>(eventName: string | symbol): Function[]

Parametry

Zwraca

dziedziczone zSharedAccessKeyAuthenticationProvider.listeners

Alias dla emitter.removeListener().

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

Parametry

Zwraca

dziedziczone zSharedAccessKeyAuthenticationProvider.off

import { on, EventEmitter } from 'node:events';
import process from 'node:process';

const ee = new EventEmitter();

// Emit later on
process.nextTick(() => {
  ee.emit('foo', 'bar');
  ee.emit('foo', 42);
});

for await (const event of on(ee, 'foo')) {
  // The execution of this inner block is synchronous and it
  // processes one event at a time (even with await). Do not use
  // if concurrent execution is required.
  console.log(event); // prints ['bar'] [42]
}
// Unreachable here

Zwraca i AsyncIterator iteruje eventName zdarzenia. Będzie rzucać, jeśli wyemituje EventEmitter'error'. Usuwa wszystkich słuchaczy po wyjściu z pętli. Zwrócony value przez każdą iterację to tablica złożona z argumentów wyemitowanych zdarzeń.

An może być użyte do anulowania oczekiwania AbortSignal na wydarzenia:

import { on, EventEmitter } from 'node:events';
import process from 'node:process';

const ac = new AbortController();

(async () => {
  const ee = new EventEmitter();

  // Emit later on
  process.nextTick(() => {
    ee.emit('foo', 'bar');
    ee.emit('foo', 42);
  });

  for await (const event of on(ee, 'foo', { signal: ac.signal })) {
    // The execution of this inner block is synchronous and it
    // processes one event at a time (even with await). Do not use
    // if concurrent execution is required.
    console.log(event); // prints ['bar'] [42]
  }
  // Unreachable here
})();

process.nextTick(() => ac.abort());

Użyj close opcji określenia tablicy nazw zdarzeń, która zakończy iterację:

import { on, EventEmitter } from 'node:events';
import process from 'node:process';

const ee = new EventEmitter();

// Emit later on
process.nextTick(() => {
  ee.emit('foo', 'bar');
  ee.emit('foo', 42);
  ee.emit('close');
});

for await (const event of on(ee, 'foo', { close: ['close'] })) {
  console.log(event); // prints ['bar'] [42]
}
// the loop will exit after 'close' is emitted
console.log('done'); // prints 'done'

static function on(emitter: EventEmitter<DefaultEventMap>, eventName: string | symbol, options?: StaticEventEmitterIteratorOptions): AsyncIterator<any[], any, any>

Parametry

Zwraca

A AsyncIterator , która iteruje eventName zdarzenia emitowane przez emitter

dziedziczone zSharedAccessKeyAuthenticationProvider.on

static function on(emitter: EventTarget, eventName: string, options?: StaticEventEmitterIteratorOptions): AsyncIterator<any[], any, any>

Parametry

Zwraca

dziedziczone zSharedAccessKeyAuthenticationProvider.on

Dodaje funkcję listener na końcu tablicy odbiorników dla zdarzenia o nazwie eventName. Nie są sprawdzane, czy listener został już dodany. Wiele wywołań przekazujących tę samą kombinację eventName i listener spowoduje dodanie listener i wywołanie wielu razy.

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

Zwraca odwołanie do EventEmitter, aby wywołania mogły być łańcuchowe.

Domyślnie odbiorniki zdarzeń są wywoływane w kolejności, w której są dodawane. Metodę emitter.prependListener() można użyć jako alternatywy, aby dodać odbiornik zdarzeń na początku tablicy odbiorników.

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<K>(eventName: string | symbol, listener: (args: any[]) => void): IotEdgeAuthenticationProvider

Parametry

Zwraca

dziedziczone zSharedAccessKeyAuthenticationProvider.on

Tworzy , Promise które jest spełnione, gdy emituje EventEmitter dane zdarzenie, lub które jest odrzucane, jeśli emituje 'error' podczas EventEmitter oczekiwania. Rozstrzygnie się Promise za pomocą tablicy wszystkich argumentów wydanych dla danego zdarzenia.

Ta metoda jest celowo ogólna i działa z interfejsem platformy internetowej EventTarget , która nie posiada semantyki specjalnych'error' zdarzeń i nie słucha 'error' zdarzenia.

import { once, EventEmitter } from 'node:events';
import process from 'node:process';

const ee = new EventEmitter();

process.nextTick(() => {
  ee.emit('myevent', 42);
});

const [value] = await once(ee, 'myevent');
console.log(value);

const err = new Error('kaboom');
process.nextTick(() => {
  ee.emit('error', err);
});

try {
  await once(ee, 'myevent');
} catch (err) {
  console.error('error happened', err);
}

Specjalne zarządzanie wydarzeniem 'error' jest stosowane tylko wtedy, gdy events.once() jest używane do oczekiwania na inne wydarzenie. Jeśli events.once() jest używany do oczekiwania naerror' samo 'zdarzenie', to traktuje się go jak każde inne zdarzenie bez specjalnego traktowania:

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

const ee = new EventEmitter();

once(ee, 'error')
  .then(([err]) => console.log('ok', err.message))
  .catch((err) => console.error('error', err.message));

ee.emit('error', new Error('boom'));

// Prints: ok boom

An może być użyte do odwołania oczekiwania AbortSignal na wydarzenie:

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

const ee = new EventEmitter();
const ac = new AbortController();

async function foo(emitter, event, signal) {
  try {
    await once(emitter, event, { signal });
    console.log('event emitted!');
  } catch (error) {
    if (error.name === 'AbortError') {
      console.error('Waiting for the event was canceled!');
    } else {
      console.error('There was an error', error.message);
    }
  }
}

foo(ee, 'foo', ac.signal);
ac.abort(); // Abort waiting for the event
ee.emit('foo'); // Prints: Waiting for the event was canceled!

static function once(emitter: EventEmitter<DefaultEventMap>, eventName: string | symbol, options?: StaticEventEmitterOptions): Promise<any[]>

Parametry

Zwraca

dziedziczone zSharedAccessKeyAuthenticationProvider.once

static function once(emitter: EventTarget, eventName: string, options?: StaticEventEmitterOptions): Promise<any[]>

Parametry

Zwraca

dziedziczone zSharedAccessKeyAuthenticationProvider.once

Dodaje funkcję jednorazowąlistener dla zdarzenia o nazwie eventName. Przy następnym wyzwoleniu eventName ten odbiornik zostanie usunięty, a następnie wywołany.

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

Zwraca odwołanie do EventEmitter, aby wywołania mogły być łańcuchowe.

Domyślnie odbiorniki zdarzeń są wywoływane w kolejności, w której są dodawane. Metodę emitter.prependOnceListener() można użyć jako alternatywy, aby dodać odbiornik zdarzeń na początku tablicy odbiorników.

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<K>(eventName: string | symbol, listener: (args: any[]) => void): IotEdgeAuthenticationProvider

Parametry

Zwraca

dziedziczone zSharedAccessKeyAuthenticationProvider.once

Dodaje funkcję listener do rozpoczynającej się tablicy odbiorników dla zdarzenia o nazwie eventName. Nie są sprawdzane, czy listener został już dodany. Wiele wywołań przekazujących tę samą kombinację eventName i listener spowoduje dodanie listener i wywołanie wielu razy.

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

Zwraca odwołanie do EventEmitter, aby wywołania mogły być łańcuchowe.

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

Parametry

Zwraca

dziedziczone zSharedAccessKeyAuthenticationProvider.prependListener

Dodaje funkcję jednorazowąlistener dla zdarzenia o nazwie eventName do rozpoczynającej się tablicy odbiorników. Następnym razem, gdy eventName zostanie wyzwolony, ten odbiornik zostanie usunięty, a następnie wywołany.

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

Zwraca odwołanie do EventEmitter, aby wywołania mogły być łańcuchowe.

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

Parametry

Zwraca

dziedziczone zSharedAccessKeyAuthenticationProvider.prependOnceListener

Zwraca kopię tablicy odbiorników dla zdarzenia o nazwie eventName, w tym wszelkie otoki (takie jak te utworzone przez .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<K>(eventName: string | symbol): Function[]

Parametry

Zwraca

dziedziczone zSharedAccessKeyAuthenticationProvider.rawListeners

Usuwa wszystkie odbiorniki lub te z określonych eventName.

Źle jest usunąć odbiorniki dodane gdzie indziej w kodzie, szczególnie w przypadku utworzenia wystąpienia EventEmitter przez inny składnik lub moduł (np. gniazda lub strumienie plików).

Zwraca odwołanie do EventEmitter, aby wywołania mogły być łańcuchowe.

function removeAllListeners(eventName?: string | symbol): IotEdgeAuthenticationProvider

Parametry

Zwraca

dziedziczone zSharedAccessKeyAuthenticationProvider.removeAllListeners

Usuwa określone listener z tablicy odbiorników dla zdarzenia o nazwie eventName.

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

removeListener() usunie co najwyżej jedno wystąpienie odbiornika z tablicy odbiornika. Jeśli jakikolwiek pojedynczy odbiornik został dodany wiele razy do tablicy odbiornika dla określonego eventName, removeListener() należy wywołać wiele razy, aby usunąć każde wystąpienie.

Po emitowaniu zdarzenia wszystkie odbiorniki dołączone do niego w momencie emitowania są wywoływane w kolejności. Oznacza to, że wszystkie wywołania removeListener() lub removeAllListeners()po emitowaniu i przed ostatnie wykonanie odbiornika nie spowoduje usunięcia ich zemit() w toku. Kolejne zdarzenia zachowują się zgodnie z oczekiwaniami.

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

Ponieważ odbiorniki są zarządzane przy użyciu tablicy wewnętrznej, wywołanie spowoduje zmianę indeksów pozycji dowolnego odbiornika zarejestrowanego po usunięcia odbiornika. Nie będzie to miało wpływu na kolejność wywoływanych odbiorników, ale oznacza to, że wszystkie kopie tablicy odbiorników zwrócone przez metodę emitter.listeners() będą musiały zostać ponownie odtworzone.

Gdy pojedyncza funkcja została dodana jako procedura obsługi wiele razy dla pojedynczego zdarzenia (jak w poniższym przykładzie), removeListener() usunie ostatnio dodane wystąpienie. W przykładzie odbiornik once('ping') zostanie usunięty:

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

Zwraca odwołanie do EventEmitter, aby wywołania mogły być łańcuchowe.

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

Parametry

Zwraca

dziedziczone zSharedAccessKeyAuthenticationProvider.removeListener

Domyślnie EventEmitters wyświetli ostrzeżenie, jeśli dla określonego zdarzenia zostanie dodane więcej niż 10 odbiorniki. Jest to przydatna wartość domyślna, która ułatwia znajdowanie przecieków pamięci. Metoda emitter.setMaxListeners() umożliwia zmodyfikowanie limitu dla tego konkretnego wystąpienia EventEmitter. Wartość można ustawić na Infinity (lub 0), aby wskazać nieograniczoną liczbę odbiorników.

Zwraca odwołanie do EventEmitter, aby wywołania mogły być łańcuchowe.

function setMaxListeners(n: number): IotEdgeAuthenticationProvider

Parametry

Zwraca

dziedziczone zSharedAccessKeyAuthenticationProvider.setMaxListeners

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

const target = new EventTarget();
const emitter = new EventEmitter();

setMaxListeners(5, target, emitter);

static function setMaxListeners(n?: number, eventTargets: (EventEmitter<DefaultEventMap> | EventTarget)[])

Parametry

dziedziczone zSharedAccessKeyAuthenticationProvider.setMaxListeners

Ta metoda umożliwia obiektowi wywołującym ustawienie nowych wartości na potrzeby odnawiania uwierzytelniania.

Ta funkcja jest wykonywana synchronicznie, ale spowoduje asynchroniczne wykonywanie akcji. Jeśli dostawca wykonuje już odnawianie tokenów, na przykład — jeśli zostało nawiązane połączenie sieciowe, wywołanie tej funkcji spowoduje niemal natychmiastowe wznowienie. W zależności od protokołu może to spowodować rozłączenie i ponowne nawiązanie połączenia. Jeśli jednak odnowienia nie są obecnie wykonywane, po prostu zapiszemy nowe wartości do użycia później.

function setTokenRenewalValues(tokenValidTimeInSeconds: number, tokenRenewalMarginInSeconds: number)

Parametry

dziedziczone zSharedAccessKeyAuthenticationProvider.setTokenRenewalValues

Zatrzymuje czasomierz używany do odnawiania tokenu SAS.

function stop()

dziedziczone zSharedAccessKeyAuthenticationProvider.stop

function [captureRejectionSymbol]<K>(error: Error, event: string | symbol, args: AnyRest)

Parametry

dziedziczone zSharedAccessKeyAuthenticationProvider. [captureRejectionSymbol]