## Verwendung

### Installation```
npm install toxy

## Benchmark

Siehe [toxy/benchmark](https://github.com/h2non/toxy/tree/master/benchmark) für Details.

## Poisons

Poisons hosten spezifische Logik, die eine HTTP-Transaktion im Proxy-Server abfängt, verändert, umschließt, modifiziert und/oder abbricht.
Poisons können auf eingehenden oder ausgehenden oder sogar auf beide Datenverkehrsflüsse angewendet werden (siehe [Poisoning Phasen](#poisoning-phases)).

Poisons können für verschiedene HTTP-Szenarien zusammengesetzt und wiederverwendet werden.
Sie werden asynchron in FIFO-Reihenfolge ausgeführt.

### Poisoning-Bereiche

`toxy` hat ein hierarchisches Design, das auf zwei verschiedenen Bereichen basiert: `global` und `route`.

Der **globale** Bereich bezieht sich auf den gesamten eingehenden HTTP-Datenverkehr, der vom Proxy-Server empfangen wird, unabhängig von HTTP-Methode oder Pfad.

Der **Route**-Bereich bezieht sich auf eingehenden Datenverkehr, der mit einem bestimmten HTTP-Verb und URI-Pfad übereinstimmt.

Poisons können an beide Bereiche angeschlossen werden, was bedeutet, dass Sie mit größerer Genauigkeit arbeiten und den Umfang der Vergiftung einschränken können,
zum Beispiel möchten Sie vielleicht eine Bandbreitenbegrenzungsvergiftung nur auf
bestimmte Routen anwenden, z. B. `/download` oder `/images`.

Siehe [routes.js](https://github.com/h2non/toxy/blob/master/examples/routes.js) für ein detailliertes Beispiel.

### Poisoning-Phasen

Poisons können an eingehende oder ausgehende Datenverkehrsflüsse oder sogar an beide angeschlossen werden.

**Eingehende** Vergiftung wird angewendet, wenn der Datenverkehr vom Proxy empfangen wurde,
aber noch nicht an den Zielserver weitergeleitet wurde.

**Ausgehende** Vergiftung bezieht sich auf den Datenverkehr, der an den Zielserver weitergeleitet wurde und
wenn der Proxy die Antwort von ihm empfängt, diese Antwort jedoch noch nicht an den Client gesendet wurde.

Das bedeutet im Wesentlichen, dass Sie Ihre Poisons einstecken können, um den HTTP-Datenverkehr zu infizieren,
bevor oder nachdem die Anfrage an den Ziel-HTTP-Server weitergeleitet oder an den Client gesendet wurde.

Dadurch können Sie eine bessere und genauere Vergiftung basierend auf der Anfrage oder Serverantwort anwenden.
Zum Beispiel möchten Sie aufgrund der Natur einiger Poisons, wie `inject error`,
diese möglicherweise basierend auf der Antwort des Zielservers aktivieren (z. B. ob ein bestimmter Header vorhanden ist oder nicht).

Siehe [poison-phases.js](https://github.com/h2non/toxy/blob/master/examples/poison-phases.js) für ein detailliertes Beispiel.

### Integrierte Poisons

#### Latenz

<table>
<tr>
<td><b>Name</b></td><td>latency</td>
</tr>
<tr>
<td><b>Poisoning Phase</b></td><td>incoming / outgoing</td>
</tr>
<tr>
<td><b>Erreicht den Server</b></td><td>true</td>
</tr>
</table>

Infiziert den HTTP-Fluss, indem ein Latenzjitter in die Antwort eingefügt wird

**Argumente**:

- **options** `object`
  - **jitter** `number` - Jitter-Wert in Millisekunden
  - **max** `number` - Maximaler Zufallsjitter
  - **min** `number` - Minimaler Zufallsjitter```js
toxy.poison(toxy.poisons.latency({ jitter: 1000 }))
// Or alternatively using a random value
toxy.poison(toxy.poisons.latency({ max: 1000, min: 100 }))

#### Bandwidth

<table>
<tr>
<td><b>Name</b></td><td>bandwidth</td>
</tr>
<tr>
<td><b>Poisoning Phase</b></td><td>incoming / outgoing</td>
</tr>
<tr>
<td><b>Reaches the server</b></td><td>true</td>
</tr>
</table>

Begrenzt die Anzahl der Bytes, die in einem bestimmten Zeitrahmen über das Netzwerk im ausgehenden HTTP-Verkehr gesendet werden.

Dieses Poison ist im Wesentlichen ein Alias für [throttle](#throttle).

**Argumente**:

- **options** `object`
  - **bytes** `number` – Menge der zu sendenden Byte-Blöcke. Standard `1024`
  - **threshold** `number` – Zeitrahmen für Pakete in Millisekunden. Standard `1000````js
toxy.poison(toxy.poisons.bandwidth({ bytes: 512 }))

#### Langsames Lesen

<table>
<tr>
<td><b>Name</b></td><td>slowRead</td>
</tr>
<tr>
<td><b>Vergiftungsphase</b></td><td>incoming</td>
</tr>
<tr>
<td><b>Erreicht den Server</b></td><td>true</td>
</tr>
</table>

Liest eingehende Payload-Datenpakete langsam. Nur gültig für Nicht-GET-Anfragen.

**Argumente**:

- **options** `object`
  - **chunk** `number` - Paket-Chunk-Größe in Bytes. Standardmäßig `1024`
  - **threshold** `number` - Grenzschwellenwert-Zeitrahmen in Millisekunden. Standardmäßig `1000````js
toxy.poison(toxy.poisons.slowRead({ chunk: 2048, threshold: 1000 }))

#### Slow close

<table>
<tr>
<td><b>Name</b></td><td>slowClose</td>
</tr>
<tr>
<td><b>Poisoning Phase</b></td><td>incoming / outgoing</td>
</tr>
<tr>
<td><b>Reaches the server</b></td><td>true</td>
</tr>
</table>

Verzögert das HTTP-Verbindungssignal zum Schließen (EOF).

**Argumente**:

- **options** `object`
  - **delay** `number` - Verzögerungszeit in Millisekunden. Standardwert ist `1000````js
toxy.poison(toxy.poisons.slowClose({ delay: 2000 }))

#### Verbindung abbrechen

<table>
<tr>
<td><b>Name</b></td><td>abort</td>
</tr>
<tr>
<td><b>Vergiftungsphase</b></td><td>eingehend / ausgehend</td>
</tr>
<tr>
<td><b>Erreicht den Server</b></td><td>false (nur als eingehendes Gift)</td>
</tr>
</table>

Bricht die TCP-Verbindung ab. Aus der Low-Level-Perspektive wird dies den Socket auf dem Server zerstören, indem es nur auf TCP-Ebene arbeitet, ohne spezifische HTTP-Anwendungsdaten zu senden.

**Argumente**:

- **options** `object`
  - **delay** `number` - Bricht die TCP-Verbindung nach dem Warten der angegebenen Millisekunden ab. Standard: `0`
  - **next** `boolean` - Wenn `true`, wird die Verbindung abgebrochen, wenn der Zielserver mehr Zeit als den `delay`-Parameter benötigt, um zu antworten. Standard: `false`
  - **error** `Error` - Benutzerdefinierter interner node.js-Fehler, der beim Zerstören des Sockets verwendet wird. Standard: `null````js
// Basic connection abort
toxy.poison(toxy.poisons.abort())
// Abort after a delay
toxy.poison(toxy.poisons.abort(1000))
// In this case, the socket will be closed if
// the target server takes more than
// 2 seconds to respond
toxy.poison(toxy.poisons.abort({ delay: 2000, next: true }))

### Wie man Gifte schreibt

Gifte werden als standardmäßige Middleware-Funktionen mit der gleichen Schnittstelle wie connect/express-Middleware implementiert.

Einige Gifte sind nicht trivial zu implementieren, daher müssen Sie mit dem Node.js [http](https://nodejs.org/api/http.html)-Modul und seiner API vertraut sein.

Hier ist ein einfaches Beispiel für ein Server-Latenz-Gift:```js
var toxy = require('toxy')

function customLatencyPoison (delay) {
  // We name the function since toxy uses it as identifier to get/disable/remove it in the future
  return function customLatency (req, res, next) {
    var timeout = setTimeout(process, delay)
    req.once('close', onClose)

    function onClose () {
      clearTimeout(timeout)
      next('client connection closed')
    }

    function process () {
      req.removeListener('close', onClose)
      next()
    }
  }
}

var proxy = toxy()

// Register and enable the poison
proxy
  .get('/foo')
  .poison(customLatencyPoison(2000))

Ein praktisches Beispiel finden Sie in der Implementierung der [eingebauten Gifte](https://github.com/h2non/toxy/tree/master/lib/poisons).

## Regeln

Regeln sind einfache Validierungsfilter, die eingehenden oder ausgehenden HTTP-Verkehr überprüfen, um anhand bestimmter Regeln (z. B. Übereinstimmung mit Methode, Headern, Query-Parametern, Body...) zu bestimmen, ob die aktuelle HTTP-Transaktion vergiftet werden soll oder nicht, basierend auf dem Erfüllungswert der Regel.

Regeln sind nützlich, um Logik in verschiedenen Vergiftungsszenarien zu kombinieren, zu entkoppeln und wiederzuverwenden.
Regeln können auf globalen, Routen- oder sogar Vergiftungsbereich angewendet werden und gelten auch für beide [Vergiftungsphasen](#poisoning-phases).

Regeln werden in der FIFO-Reihenfolge ausgeführt. Ihre Auswertungslogik entspricht `Array#every()` in JavaScript: Alle Regeln müssen bestanden werden, um mit der Vergiftung fortzufahren.

### Eingebaute Regeln

#### Wahrscheinlichkeit

<table>
<tr>
<td><b>Name</b></td><td>Wahrscheinlichkeit</td>
</tr>
<tr>
<td><b>Vergiftungsphase</b></td><td>eingehend / ausgehend</td>
</tr>
</table>

Aktiviert die Regel mit einer zufälligen Wahrscheinlichkeit. Nützlich für zufällige Vergiftungen.

**Argumente**:

- **percentage** `number` - Prozentsatz der Filterung. Standard `50````js
var rule = toxy.rules.probability(85)
toxy.rule(rule)

#### Methode

<table>
<tr>
<td><b>Name</b></td><td>method</td>
</tr>
<tr>
<td><b>Vergiftungsphase</b></td><td>eingehend / ausgehend</td>
</tr>
</table>

Filtert nach HTTP-Methode.

**Argumente**:

- **method** `string|array` - Methode oder Methoden zum Filtern.```js
var method = toxy.rules.method(['GET', 'POST'])
toxy.rule(method)

#### Headers

<table>
<tr>
<td><b>Name</b></td><td>headers</td>
</tr>
<tr>
<td><b>Vergiftungsphase</b></td><td>eingehend / ausgehend</td>
</tr>
</table>

Nach Anfrage-Headern filtern.

**Argumente**:

- **headers** `object` - Header, die nach Schlüssel-Wert-Paar abgeglichen werden. `value` kann ein string, regexp, `boolean` oder `function(headerValue, headerName) => boolean` sein.```js
var matchHeaders = {
  'content-type': /^application/\json/i,
  'server': true, // meaning it should be present,
  'accept': function (value, key) {
    return value.indexOf('text') !== -1
  }
}

var rule = toxy.rules.headers(matchHeaders)
toxy.rule(rule)

#### Body

<table>
<tr>
<td><b>Name</b></td><td>Body</td>
</tr>
<tr>
<td><b>Vergiftungsphase</b></td><td>eingehend / ausgehend</td>
</tr>
</table>

Stimme die eingehende Body-Nutzlast mit einem angegebenen `string`, `regexp` oder benutzerdefinierten Filter `function` ab.

Diese Regel ist recht einfach, daher solltest du für komplexes Body-Matching (z.B. Validierung gegen ein JSON-Schema) wahrscheinlich deine eigene Regel schreiben.

**Argumente**:

- **match** `string|regexp|function` – Zu vergleichender Body-Inhalt
- **limit** `string` – Optional. Body-Limit in menschenlesbarer Größe. Z.B: `5mb`
- **encoding** `string` – Body-Kodierung. Standardmäßig `utf8`
- **length** `number` – Body-Länge. Standardmäßig aus dem `Content-Length`-Header entnommen```js
var rule = toxy.rules.body('"hello":"world"')
toxy.rule(rule)

// Or using a filter function returning a boolean
var rule = toxy.rules.body(function contains(body) {
  return body.indexOf('hello') !== -1
})
toxy.rule(rule)

#### Antwortstatus

<table>
<tr>
<td><b>Name</b></td><td>responseStatus</td>
</tr>
<tr>
<td><b>Vergiftungsphase</b></td><td>ausgehend</td>
</tr>
</table>

Bewertet den Antwortstatus des Zielservers.
Nur anwendbar auf ausgehende Vergiftungen.

**Argumente**:

- **range** `array` - Paar von Statuscode-Bereichen zum Abgleichen. Standard `[200, 300]`.
- **lower** `number` - Vergleicht Status als `lower than`-Operation. Standardmäßig `null`.
- **higher** `number` - Vergleicht Status als `higher than`-Operation. Standardmäßig `null`.
- **value** `number` - Statuscode zum Abgleichen mittels striktem Gleichheitsvergleich. Standardmäßig `null`.
- **include** `array` - Unsortierte Liste von Statuscodes zum Abgleichen. Nützlich, um benutzerdefinierte Status anzugeben. Standardmäßig `null`.```js
// Strict evaluation of the status code
toxy.rule(toxy.rules.responseBody(200))
// Using a range of valid status
toxy.rule(toxy.rules.responseBody([200, 204]))
// Using relational comparison
toxy.rule(toxy.rules.responseBody({ higher: 199, lower: 400 }))
// Custom unordered status code to match
toxy.rule(toxy.rules.responseBody({ include: [200, 204, 400, 404] }))

Sie können optional die eingebauten Regeln mit Ihren eigenen Regeln erweitern:```js
toxy.addRule(customMethodRule)

// Then you can use it as a built-in poison
proxy
  .get('/foo')
  .rules(toxy.rules.customMethodRule)

#### toxy#get(path, [ middleware... ])
Rückgabe: `ToxyRoute`

Registriert eine neue Route für die `GET`-Methode.

#### toxy#post(path, [ middleware... ])
Rückgabe: `ToxyRoute`

Registriert eine neue Route für die `POST`-Methode.

#### toxy#put(path, [ middleware... ])
Rückgabe: `ToxyRoute`

Registriert eine neue Route für die `PUT`-Methode.

#### toxy#patch(path, [ middleware... ])
Rückgabe: `ToxyRoute`

#### toxy#delete(path, [ middleware... ])
Rückgabe: `ToxyRoute`

Registriert eine neue Route für die `DELETE`-Methode.

#### toxy#head(path, [ middleware... ])
Rückgabe: `ToxyRoute`

Registriert eine neue Route für die `HEAD`-Methode.

#### toxy#all(path, [ middleware... ])
Rückgabe: `ToxyRoute`

Registriert eine neue Route für jede Methode.

#### toxy#poisons `=>` Object

Stellt eine Map mit den integrierten Poisons bereit. Prototyp-Alias zu `toxy.poisons`

#### toxy#rules `=>` Object

Stellt eine Map mit den integrierten Regeln bereit. Prototyp-Alias zu `toxy.rules`

#### toxy#forward(url)

Definiert eine URL, an die der vom Proxy empfangene eingehende Datenverkehr weitergeleitet wird.

#### toxy#balance(urls)

Leitet an mehrere Server weiter und verteilt die Last auf diese.

Weitere Informationen finden Sie in der [rocky-Dokumentation](https://github.com/h2non/rocky#programmatic-api)

#### toxy#replay(url)

Definiert einen neuen Wiedergabeserver.
Sie können diese Methode mehrmals aufrufen, um mehrere Wiedergabeserver zu definieren.

Weitere Informationen finden Sie in der [rocky-Dokumentation](https://github.com/h2non/rocky#programmatic-api)

#### toxy#use(middleware)

Bindet eine benutzerdefinierte Middleware ein.

Weitere Informationen finden Sie in der [rocky-Dokumentation](https://github.com/h2non/rocky#middleware-layer).

#### toxy#useResponse(middleware)

Bindet eine Middleware für ausgehenden Antwortdatenverkehr ein.

Weitere Informationen finden Sie in der [rocky-Dokumentation](https://github.com/h2non/rocky#middleware-layer).

#### toxy#useReplay(middleware)

Bindet eine Middleware für Wiedergabedatenverkehr ein.

Weitere Informationen finden Sie in der [rocky-Dokumentation](https://github.com/h2non/rocky#middleware-layer)

#### toxy#requestBody(middleware)

Fängt den eingehenden Anforderungstext ab. Nützlich, um ihn spontan zu ändern.

Weitere Informationen finden Sie in der [rocky-Dokumentation](https://github.com/h2non/rocky#programmatic-api)

#### toxy#responseBody(middleware)

Fängt den ausgehenden Antworttext ab. Nützlich, um ihn spontan zu ändern.

Weitere Informationen finden Sie in der [rocky-Dokumentation](https://github.com/h2non/rocky#programmatic-api)

#### toxy#middleware()

Gibt eine Standard-Middleware zur Verwendung mit connect/express zurück.

#### toxy#host(host)

Überschreibt den `Host`-Header mit einem benutzerdefinierten Wert. Ähnlich der Option `forwardHost`.

#### toxy#redirect(url)

Leitet den Datenverkehr an die angegebene URL um.

#### toxy#findRoute(routeIdOrPath, [ method ])

Findet eine Route anhand von ID oder Pfad und Methode.

#### toxy#listen(port)

Startet den integrierten HTTP-Server und lauscht auf einem bestimmten TCP-Port.

#### toxy#close([ callback ])

Schließt den HTTP-Server.

#### toxy#poison(poison)
Alias: `usePoison`, `useIncomingPoison`

Registriert ein neues Poison, um [eingehenden](#poisoning-phases) Datenverkehr zu infizieren.

#### toxy#outgoingPoison(poison)
Alias: `useOutgoingPoison`, `responsePoison`

Registriert ein neues Poison, um [ausgehenden](#poisoning-phases) Datenverkehr zu infizieren.

#### toxy#rule(rule)
Alias: `useRule`

Registriert eine neue Regel.

#### toxy#withRule(rule)
Aliase: `ifRule`, `whenRule`, `poisonRule`, `poisonFilter`

Wendet eine neue Regel auf das zuletzt registrierte Poison an.

#### toxy#enable(poison)

Aktiviert ein Poison anhand des Namensidentifikators.

#### toxy#disable(poison)

Deaktiviert ein Poison anhand des Namensidentifikators.

#### toxy#remove(poison)
Rückgabe: `boolean`

Entfernt ein eingehendes Datenverkehr-Poison anhand des Namensidentifikators oder der Objektreferenz.

#### toxy#removeOutgoing(poison)
Rückgabe: `boolean`

Entfernt ein ausgehendes Datenverkehr-Poison anhand des Namensidentifikators oder der Objektreferenz.

#### toxy#isEnabled(poison)
Rückgabe: `boolean`

Prüft, ob ein Poison anhand des Namensidentifikators aktiviert ist.

#### toxy#disableAll()
Alias: `disablePoisons`

Deaktiviert alle registrierten Poisons.

#### toxy#getPoison(name)
Rückgabe: `Directive|null`

Sucht und ruft ein registriertes Poison aus dem Stapel anhand des Namensidentifikators ab.

#### toxy#getIncomingPoison(name)
Rückgabe: `Directive|null`

Sucht und ruft ein registriertes `incoming`-Poison aus dem Stapel anhand des Namensidentifikators ab.

#### toxy#getOutgoingPoison(name)
Rückgabe: `Directive|null`

Sucht und ruft ein registriertes `outgoing`-Poison aus dem Stapel anhand des Namensidentifikators ab.

#### toxy#getPoisons()
Rückgabe: `array<Directive>`

Gibt ein Array der registrierten Poisons zurück.

#### toxy#getIncomingPoisons()
Rückgabe: `array<Directive>`

Gibt ein Array der registrierten `incoming`-Poisons zurück.

#### toxy#getOutgoingPoisons()
Rückgabe: `array<Directive>`

Gibt ein Array der registrierten `outgoing`-Poisons zurück.

#### toxy#flush()
Alias: `flushPoisons`

Entfernt alle registrierten Poisons für sowohl eingehende als auch ausgehende Datenverkehrsflüsse.

#### toxy#enableRule(rule)

Aktiviert eine Regel anhand des Namensidentifikators.

#### toxy#disableRule(rule)

Deaktiviert eine Regel anhand des Namensidentifikators.

#### toxy#removeRule(rule)
Rückgabe: `boolean`

Entfernt eine Regel anhand des Namensidentifikators.

#### toxy#disableRules()

Deaktiviert alle registrierten Regeln.

#### toxy#isRuleEnabled(rule)
Rückgabe: `boolean`

Prüft, ob die angegebene Regel anhand des Namensidentifikators aktiviert ist.

#### toxy#getRule(rule)
Rückgabe: `Directive|null`

Sucht und ruft eine registrierte Regel aus dem Stapel anhand des Namensidentifikators ab.

#### toxy#getRules()
Rückgabe: `array<Directive>`

Gibt ein Array mit den registrierten Regeln zurück, die als `Directive` verpackt sind.

#### toxy#flushRules()

Entfernt alle Regeln.

### toxy.addPoison(name, fn)

Erweitert die integrierten Poisons.

### toxy.addRule(name, fn)

Erweitert die integrierten Regeln.

### toxy.poisons `=>` Object

Stellt eine Map mit den integrierten Poisons bereit.

### toxy.rules `=>` Object

Stellt eine Map mit den integrierten Regeln bereit.

### toxy.VERSION `=>` String

Aktuelle semantische Version von toxy.

### ToxyRoute

`ToxyRoute` stellt die gleiche Schnittstelle bereit wie das globale `Toxy`-Interface, fügt jedoch einige zusätzliche Methoden auf Routenebene hinzu (siehe [rocky-Dokumentation](https://github.com/h2non/rocky#routepath)).

Weitere Aktionen, die Sie über die `ToxyRoute`-API ausführen, gelten nur auf Routenebene (verschachtelt). Mit anderen Worten: Sie kennen die API bereits.

Dieses Beispiel wird mögliche Zweifel wahrscheinlich klären:```js
var toxy = require('toxy')
var proxy = toxy()

// Now using the global API
proxy
  .forward('http://server.net')
  .poison(toxy.poisons.bandwidth({ bps: 1024 }))
  .rule(toxy.rules.method('GET'))

// Now create a route
var route = proxy
  .get('/foo')
  .toPath('/bar') // Route-level API method
  .host('server.net') // Route-level API method
  .forward('http://new.server.net')

// Now using the ToxyRoute interface
route
  .poison(toxy.poisons.bandwidth({ bps: 512 }))
  .rule(toxy.rules.contentType('json'))

Weitere Details zur programmatischen API des Admin finden Sie [unten](#programmatic-api-1).

### Autorisierung

Die HTTP-API kann vor nicht autorisierten Clients geschützt werden.
Autorisierte Clients müssen den API-Key-Token über die HTTP-Header `API-Key` oder `Authorization` definieren.

Um dies zu aktivieren, übergeben Sie einfach die folgenden Optionen an den `toxy`-Admin-Server:```js
const toxy = require('toxy')

const opts = { apiKey: 's3cr3t' }
var admin = toxy.admin(opts)

admin.listen(9000)
console.log('protected toxy admin server listening on port:', 9000)

#### DELETE /servers/:id/rules

#### GET /servers/:id/rules/:id

#### DELETE /servers/:id/rules/:id

### Vergiftungen

#### GET /servers/:id/poison

#### POST /servers/:id/poisons
Akzeptiert: `application/json`

Beispiel-Payload:```js
{
  "name": "latency",
  "phase": "outgoing",
  "options": { "jitter": 1000 }
}

#### DELETE /servers/:id/poisons/:id/rules

#### GET /servers/:id/poisons/:id/rules/:id

#### DELETE /servers/:id/poisons/:id/rules/:id

### Routes

#### GET /servers/:id/routes

#### POST /servers/:id/routes
Akzeptiert: `application/json`

Beispiel-Payload:```js
{
  "path": "/foo", // Required
  "method": "GET", // use ALL for all the methods
  "forward": "http://my.server", // Optional custom forward server URL
}

#### DELETE /servers/:id/routes/:id/rules

#### GET /servers/:id/routes/:id/rules/:id

#### DELETE /servers/:id/routes/:id/rules/:id

### Route poisons

#### GET /servers/:id/routes/:id/poisons

#### POST /servers/:id/routes/:id/poisons
Akzeptiert: `application/json`

Beispiel-Nutzlast:```js
{
  "name": "latency",
  "phase": "outgoing",
  "options": { "jitter": 1000 }
}

#### DELETE /servers/:id/routes/:id/poisons/:id/rules

#### GET /servers/:id/routes/:id/poisons/:id/rules/:id

#### DELETE /servers/:id/routes/:id/poisons/:id/rules/:id

### Programmatische API

Der integrierte HTTP-Administrationsserver bietet zudem eine einfache Schnittstelle, die für Erweiterbarkeit und Hacking-Zwecke offen ist.
Beispielsweise können Sie zusätzliche Middleware in den Admin-Server einbinden oder neue Routen registrieren.

#### toxy.admin([ opts ])
Gibt zurück: `Admin`

**Unterstützte Optionen**:

- **apiKey** `string` - Optionaler API-Schlüssel zum Schutz des Servers
- **port** `number` - Optional. TCP-Port zum Abhören
- **cors** `boolean` - CORS für Webbrowser-Zugriff aktivieren
- **middleware** `array<function>` - Zusätzliche Middleware einbinden
- **ssl** `object` - Node.js HTTPS-Server [TLS-Optionen](https://nodejs.org/api/tls.html#tls_tls_createserver_options_secureconnectionlistener).

##### Admin#listen([ port, host ])

Startet das Lauschen im Netzwerk.

##### Admin#manage(toxy)

Verwaltet eine `toxy`-Serverinstanz.

##### Admin#find(toxy)

Findet eine toxy-Instanz. Akzeptiert eine toxy-Server-ID oder eine toxy-Instanz.

##### Admin#remove(toxy)

Beendet die Verwaltung einer toxy-Instanz.

##### Admin#use(...middleware)

Registriert eine Middleware.

##### Admin#param(...middleware)

Registriert eine Parameter-Middleware.

##### Admin#get(path, [ ...middleware ])

Registriert eine GET-Route.

##### Admin#post(path, [ ...middleware ])

Registriert eine POST-Route.

##### Admin#put(path, [ ...middleware ])

Registriert eine PUT-Route.

##### Admin#delete(path, [ ...middleware ])

Registriert eine DELETE-Route.

##### Admin#patch(path, [ ...middleware ])

Registriert eine PATCH-Route.

##### Admin#all(path, [ ...middleware ])

Registriert eine Route, die jede HTTP-Methode akzeptiert.

##### Admin#middleware(req, res, next)

Middleware zur Einbindung mit connect/express.

##### Admin#close(cb)

Stoppt den Server.

## Lizenz

MIT - Tomas Aparicio

[![views](https://sourcegraph.com/api/repos/github.com/h2non/toxy/.counters/views.svg)](https://sourcegraph.com/github.com/h2non/toxy)