← Alle AufgabenNode.js · Senior

Circuit Breaker

Ist eine Abhängigkeit ausgefallen, wartet jede Anfrage an sie auf ein Timeout und bindet Ressourcen. Schreib createBreaker(fn, { failureThreshold, resetMs, now }) mit call(...args) und state().

- closed: Aufrufe gehen an fn; nach failureThreshold Fehlschlägen in Folge geht der Breaker auf open (ein Erfolg setzt den Zähler zurück). - open: call lehnt sofort mit Circuit open ab, und fn wird nicht aufgerufen. - resetMs nach dem Öffnen ist der Zustand half-open: ein Probeaufruf geht durch (andere gleichzeitige bekommen Circuit open). Erfolg schließt den Breaker, ein Fehlschlag öffnet ihn wieder für resetMs.

function createBreaker(fn, { failureThreshold, resetMs, now = Date.now }) {
  return {
    async call(...args) {
      // ...
      return fn(...args);
    },
    state() {
      return "closed";
    },
  };
}

Strg+Enter führt die Tests aus. Tab rückt ein; um den Editor per Tastatur zu verlassen, drücke Esc und dann Tab. Der Code wird in diesem Browser gespeichert.

Tests (6)

let t = 0;
const b = createBreaker(async (x) => x * 2, { failureThreshold: 3, resetMs: 1000, now: () => t });
expect(await b.call(21)).toBe(42);
expect(b.state()).toBe('closed');

let t = 0;
const f = fn(async () => { throw new Error('timeout'); });
const b = createBreaker(f, { failureThreshold: 3, resetMs: 1000, now: () => t });
for (let i = 0; i < 3; i++) await expect(b.call()).rejects.toThrow('timeout');
expect(b.state()).toBe('open');
await expect(b.call()).rejects.toThrow('Circuit open');
expect(f).toHaveBeenCalledTimes(3);

let t = 0;
let fail = true;
const b = createBreaker(async () => { if (fail) throw new Error('down'); return 'ok'; }, { failureThreshold: 2, resetMs: 1000, now: () => t });
await expect(b.call()).rejects.toThrow('down');
await expect(b.call()).rejects.toThrow('down');
t = 999;
expect(b.state()).toBe('open');
t = 1000;
expect(b.state()).toBe('half-open');
fail = false;
expect(await b.call()).toBe('ok');
expect(b.state()).toBe('closed');

let t = 0;
const b = createBreaker(async () => { throw new Error('down'); }, { failureThreshold: 1, resetMs: 500, now: () => t });
await expect(b.call()).rejects.toThrow('down');
t = 500;
await expect(b.call()).rejects.toThrow('down');
expect(b.state()).toBe('open');
t = 900;
await expect(b.call()).rejects.toThrow('Circuit open');

let t = 0;
let ok = false;
const b = createBreaker(async () => { if (!ok) throw new Error('down'); await wait(30); return 'ok'; }, { failureThreshold: 1, resetMs: 100, now: () => t });
await expect(b.call()).rejects.toThrow('down');
t = 100;
ok = true;
const first = b.call();
await expect(b.call()).rejects.toThrow('Circuit open');
expect(await first).toBe('ok');

let t = 0;
let n = 0;
const b = createBreaker(async () => { n++; if (n % 2) throw new Error('flaky'); return n; }, { failureThreshold: 2, resetMs: 1000, now: () => t });
await expect(b.call()).rejects.toThrow('flaky');
expect(await b.call()).toBe(2);
await expect(b.call()).rejects.toThrow('flaky');
expect(b.state()).toBe('closed');