## 사용법

### 설치```
npm install toxy

## Benchmark

자세한 내용은 [toxy/benchmark](https://github.com/h2non/toxy/tree/master/benchmark)를 참조하세요.

## 포이즌

포이즌은 프록시 서버에서 HTTP 트랜잭션을 가로채고 변경, 래핑, 수정 및/또는 취소하는 특정 로직을 호스팅합니다.
포이즌은 들어오는 트래픽, 나가는 트래픽 또는 둘 모두에 적용될 수 있습니다([포이즈닝 단계](#poisoning-phases) 참조).

포이즌은 다양한 HTTP 시나리오에 대해 구성 및 재사용이 가능합니다.
FIFO 순서로 비동기적으로 실행됩니다.

### 포이즈닝 범위

`toxy`는 `global`과 `route`라는 두 가지 범위를 기반으로 하는 계층적 설계를 가지고 있습니다.

**Global** 범위는 HTTP 메서드나 경로와 관계없이 프록시 서버가 수신하는 모든 들어오는 HTTP 트래픽을 대상으로 합니다.

**Route** 범위는 특정 HTTP 동사와 URI 경로와 일치하는 모든 들어오는 트래픽을 대상으로 합니다.

포이즌은 두 범위 모두에 연결할 수 있으며, 이를 통해 더 정확하게 운영하고 포이즈닝 범위를 제한할 수 있습니다.
예를 들어, `/download` 또는 `/images`와 같은 특정 경로에만 대역폭 제한 포이즈닝을 적용하고 싶을 수 있습니다.

전체 예제는 [routes.js](https://github.com/h2non/toxy/blob/master/examples/routes.js)를 참조하세요.

### 포이즈닝 단계

포이즌은 들어오는 트래픽 흐름, 나가는 트래픽 흐름 또는 둘 모두에 연결될 수 있습니다.

**들어오는** 포이즈닝은 프록시가 트래픽을 수신했지만 아직 대상 서버로 전달되지 않은 경우에 적용됩니다.

**나가는** 포이즈닝은 트래픽이 대상 서버로 전달되고 프록시가 해당 서버의 응답을 수신했지만, 그 응답이 아직 클라이언트로 전송되지 않은 경우를 말합니다.

이는 기본적으로 요청이 대상 HTTP 서버로 전달되거나 클라이언트로 전송되기 전후에 HTTP 트래픽을 감염시키도록 포이즌을 연결할 수 있음을 의미합니다.

이를 통해 요청이나 서버 응답에 기반하여 더 나은 정확도로 포이즈닝을 적용할 수 있습니다.
예를 들어, `inject error`와 같은 일부 포이즌의 특성상 대상 서버 응답(예: 특정 헤더의 존재 여부)에 따라 활성화할 수 있습니다.

전체 예제는 [poison-phases.js](https://github.com/h2non/toxy/blob/master/examples/poison-phases.js)를 참조하세요.

### 내장 포이즌

#### Latency

<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>Reaches the server</b></td><td>true</td>
</tr>
</table>

응답에 지연 시간 지터를 주입하여 HTTP 흐름을 감염시킵니다.

**인수**:

- **options** `object`
  - **jitter** `number` - 밀리초 단위의 지터 값
  - **max** `number` - 무작위 지터 최대값
  - **min** `number` - 무작위 지터 최소값```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>이름</b></td><td>bandwidth</td>
</tr>
<tr>
<td><b>중독 단계</b></td><td>수신 / 송신</td>
</tr>
<tr>
<td><b>서버에 도달</b></td><td>true</td>
</tr>
</table>

특정 시간 동안 발신 HTTP 트래픽에서 네트워크를 통해 전송되는 바이트 수를 제한합니다.

이 중독은 기본적으로 [throttle](#throttle)의 별칭입니다.

**인수**:

- **options** `object`
  - **bytes** `number` - 전송할 바이트 청크의 양. 기본값 `1024`
  - **threshold** `number` - 패킷 시간 프레임(밀리초). 기본값 `1000````js
toxy.poison(toxy.poisons.bandwidth({ bytes: 512 }))

#### Slow read

<table>
<tr>
<td><b>이름</b></td><td>slowRead</td>
</tr>
<tr>
<td><b>중독 단계</b></td><td>incoming</td>
</tr>
<tr>
<td><b>서버 도달 여부</b></td><td>true</td>
</tr>
</table>

들어오는 페이로드 데이터 패킷을 느리게 읽습니다. GET이 아닌 요청에만 유효합니다.

**인수**:

- **options** `object`
  - **chunk** `number` - 패킷 청크 크기(바이트). 기본값 `1024`
  - **threshold** `number` - 제한 임계값 시간(밀리초). 기본값 `1000````js
toxy.poison(toxy.poisons.slowRead({ chunk: 2048, threshold: 1000 }))

#### 느린 종료

<table>
<tr>
<td><b>이름</b></td><td>slowClose</td>
</tr>
<tr>
<td><b>포이즈닝 단계</b></td><td>수신 / 송신</td>
</tr>
<tr>
<td><b>서버에 도달</b></td><td>true</td>
</tr>
</table>

HTTP 연결 종료 신호(EOF)를 지연시킵니다.

**인수**:

- **options** `object`
  - **delay** `number` - 밀리초 단위의 지연 시간. 기본값은 `1000`입니다.```js
toxy.poison(toxy.poisons.slowClose({ delay: 2000 }))

#### 연결 중단

<table>
<tr>
<td><b>이름</b></td><td>abort</td>
</tr>
<tr>
<td><b>포이즈닝 단계</b></td><td>수신 / 송신</td>
</tr>
<tr>
<td><b>서버에 도달</b></td><td>false (수신 포이즌으로만 작동)</td>
</tr>
</table>

TCP 연결을 중단합니다. 저수준 관점에서, 이는 서버의 소켓을 파괴하며, HTTP 애플리케이션 레벨 데이터를 전송하지 않고 TCP 레벨에서만 작동합니다.

**인수**:

- **options** `object`
  - **delay** `number` - 지정된 밀리초만큼 대기한 후 TCP 연결을 중단합니다. 기본값은 `0`입니다.
  - **next** `boolean` - `true`로 설정하면 대상 서버가 `delay` 매개변수 시간보다 더 오래 응답할 경우 연결이 중단됩니다. 기본값은 `false`입니다.
  - **error** `Error` - 소켓을 파괴할 때 사용할 사용자 정의 Node.js 내부 오류입니다. 기본값은 `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 }))

### 포이즌 작성 방법

포이즌은 connect/express 미들웨어와 동일한 인터페이스를 가진 표준 미들웨어 함수로 구현됩니다.

일부 포이즌은 구현이 간단하지 않으므로 node.js [http](https://nodejs.org/api/http.html) 모듈과 해당 API에 익숙해야 합니다.

다음은 서버 지연 포이즌의 간단한 예입니다:```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))

실제 예시를 보려면 [내장된 포이즌](https://github.com/h2non/toxy/tree/master/lib/poisons) 구현을 확인하세요.

## 규칙

규칙은 간단한 검증 필터로, 수신 또는 송신 HTTP 트래픽을 검사하여 주어진 규칙(예: 메소드, 헤더, 쿼리 매개변수, 본문 등과 일치)에 기반해 규칙의 평가값에 따라 현재 HTTP 트랜잭션을 포이즈닝해야 할지 결정합니다.

규칙은 다양한 포이즈닝 시나리오 간에 로직을 구성, 분리 및 재사용하는 데 유용합니다.
규칙은 전역, 라우트 또는 포이즌 범위에 적용할 수 있으며, [포이즈닝 단계](#poisoning-phases) 모두에 적용됩니다.

규칙은 FIFO 순서로 실행됩니다. 평가 로직은 JavaScript의 `Array#every()`와 동일합니다: 모든 규칙이 통과해야 포이즈닝이 진행됩니다.

### 내장 규칙

#### 확률

<table>
<tr>
<td><b>이름</b></td><td>probability</td>
</tr>
<tr>
<td><b>포이즌 단계</b></td><td>인입 / 송신</td>
</tr>
</table>

무작위 확률로 규칙을 활성화합니다. 무작위 포이즈닝에 유용합니다.

**인수**:

- **percentage** `number` - 필터링 백분율. 기본값 `50````js
var rule = toxy.rules.probability(85)
toxy.rule(rule)

#### 메서드

<table>
<tr>
<td><b>이름</b></td><td>method</td>
</tr>
<tr>
<td><b>포이즌 단계</b></td><td>수신 / 송신</td>
</tr>
</table>

HTTP 메서드별로 필터링합니다.

**인수**:

- **method** `string|array` - 필터링할 메서드 또는 메서드들.```js
var method = toxy.rules.method(['GET', 'POST'])
toxy.rule(method)

#### 헤더

<table>
<tr>
<td><b>이름</b></td><td>헤더</td>
</tr>
<tr>
<td><b>포이즌 단계</b></td><td>수신 / 발신</td>
</tr>
</table>

요청 헤더로 필터링합니다.

**인수**:

- **headers** `object` - 키-값 쌍으로 일치시킬 헤더. `value`는 문자열, 정규식, `boolean` 또는 `function(headerValue, headerName) => boolean`일 수 있습니다.```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)

#### 본문

<table>
<tr>
<td><b>이름</b></td><td>body</td>
</tr>
<tr>
<td><b>중독 단계</b></td><td>incoming / outgoing</td>
</tr>
</table>

주어진 `string`, `regexp` 또는 사용자 정의 필터 `function`을 사용하여 들어오는 본문 페이로드를 매칭합니다.

이 규칙은 상당히 단순하므로, 복잡한 본문 매칭(예: JSON 스키마 검증)의 경우 자체 규칙을 작성하는 것이 좋습니다.

**인수**:

- **match** `string|regexp|function` - 매칭할 본문 내용
- **limit** `string` - 선택 사항. 사람이 읽기 쉬운 단위의 본문 크기 제한. 예: `5mb`
- **encoding** `string` - 본문 인코딩. 기본값은 `utf8`
- **length** `number` - 본문 길이. 기본값은 `Content-Length` 헤더에서 가져옴```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)

#### 응답 상태

<table>
<tr>
<td><b>이름</b></td><td>responseStatus</td>
</tr>
<tr>
<td><b>중독 단계</b></td><td>outgoing</td>
</tr>
</table>

대상 서버의 응답 상태를 평가합니다. 발신 중독에만 적용 가능합니다.

**인수**:

- **range** `array` - 일치시킬 상태 코드 범위의 쌍. 기본값 `[200, 300]`.
- **lower** `number` - 상태 비교를 `lower than` 연산으로 수행. 기본값 `null`.
- **higher** `number` - 상태 비교를 `higher than` 연산으로 수행. 기본값 `null`.
- **value** `number` - 엄격한 동등 비교를 통해 일치시킬 상태 코드. 기본값 `null`.
- **include** `array` - 일치시킬 상태 코드의 순서 없는 목록. 사용자 정의 상태를 지정하는 데 유용. 기본값 `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] }))

내장된 규칙을 자신의 규칙으로 선택적으로 확장할 수 있습니다:```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... ])
반환: `ToxyRoute`

`GET` 메소드에 대한 새 경로를 등록합니다.

#### toxy#post(path, [ middleware... ])
반환: `ToxyRoute`

`POST` 메소드에 대한 새 경로를 등록합니다.

#### toxy#put(path, [ middleware... ])
반환: `ToxyRoute`

`PUT` 메소드에 대한 새 경로를 등록합니다.

#### toxy#patch(path, [ middleware... ])
반환: `ToxyRoute`

#### toxy#delete(path, [ middleware... ])
반환: `ToxyRoute`

`DELETE` 메소드에 대한 새 경로를 등록합니다.

#### toxy#head(path, [ middleware... ])
반환: `ToxyRoute`

`HEAD` 메소드에 대한 새 경로를 등록합니다.

#### toxy#all(path, [ middleware... ])
반환: `ToxyRoute`

모든 메소드에 대한 새 경로를 등록합니다.

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

내장된 독소(poisons)의 맵을 노출합니다. 프로토타입 별칭: `toxy.poisons`

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

내장된 독소의 맵을 노출합니다. 프로토타입 별칭: `toxy.rules`

#### toxy#forward(url)

프록시가 수신하는 트래픽을 전달할 URL을 정의합니다.

#### toxy#balance(urls)

여러 서버로 전달하여 로드 밸런싱을 수행합니다.

자세한 내용은 [rocky 문서](https://github.com/h2non/rocky#programmatic-api)를 참조하세요.

#### toxy#replay(url)

새 재생 서버(replay server)를 정의합니다.
여러 재생 서버를 정의하려면 이 메소드를 여러 번 호출할 수 있습니다.

자세한 내용은 [rocky 문서](https://github.com/h2non/rocky#programmatic-api)를 참조하세요.

#### toxy#use(middleware)

사용자 정의 미들웨어를 플러그인합니다.

자세한 내용은 [rocky 문서](https://github.com/h2non/rocky#middleware-layer)를 참조하세요.

#### toxy#useResponse(middleware)

응답 트래픽(outgoing) 미들웨어를 플러그인합니다.

자세한 내용은 [rocky 문서](https://github.com/h2non/rocky#middleware-layer)를 참조하세요.

#### toxy#useReplay(middleware)

재생 트래픽 미들웨어를 플러그인합니다.

자세한 내용은 [rocky 문서](https://github.com/h2non/rocky#middleware-layer)를 참조하세요.

#### toxy#requestBody(middleware)

수신 요청 본문(body)을 가로챕니다. 실시간으로 수정하는 데 유용합니다.

자세한 내용은 [rocky 문서](https://github.com/h2non/rocky#programmatic-api)를 참조하세요.

#### toxy#responseBody(middleware)

응답 본문(outgoing response body)을 가로챕니다. 실시간으로 수정하는 데 유용합니다.

자세한 내용은 [rocky 문서](https://github.com/h2non/rocky#programmatic-api)를 참조하세요.

#### toxy#middleware()

connect/express와 함께 사용할 표준 미들웨어를 반환합니다.

#### toxy#host(host)

`Host` 헤더를 사용자 정의 값으로 덮어씁니다. `forwardHost` 옵션과 유사합니다.

#### toxy#redirect(url)

트래픽을 주어진 URL로 리디렉션합니다.

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

ID 또는 경로와 메소드로 경로를 찾습니다.

#### toxy#listen(port)

내장 HTTP 서버를 시작하여 특정 TCP 포트에서 수신 대기합니다.

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

HTTP 서버를 닫습니다.

#### toxy#poison(poison)
별칭: `usePoison`, `useIncomingPoison`

[수신(incoming)](#poisoning-phases) 트래픽을 감염시키기 위한 새 독소(poison)를 등록합니다.

#### toxy#outgoingPoison(poison)
별칭: `useOutgoingPoison`, `responsePoison`

[송신(outgoing)](#poisoning-phases) 트래픽을 감염시키기 위한 새 독소를 등록합니다.

#### toxy#rule(rule)
별칭: `useRule`

새 규칙을 등록합니다.

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

가장 최근에 등록된 독소에 대해 새 규칙을 적용합니다.

#### toxy#enable(poison)

이름 식별자로 독소를 활성화합니다.

#### toxy#disable(poison)

이름 식별자로 독소를 비활성화합니다.

#### toxy#remove(poison)
반환: `boolean`

이름 식별자 또는 객체 참조로 수신 트래픽 독소를 제거합니다.

#### toxy#removeOutgoing(poison)
반환: `boolean`

이름 식별자 또는 객체 참조로 송신 트래픽 독소를 제거합니다.

#### toxy#isEnabled(poison)
반환: `boolean`

이름 식별자로 독소가 활성화되어 있는지 확인합니다.

#### toxy#disableAll()
별칭: `disablePoisons`

등록된 모든 독소를 비활성화합니다.

#### toxy#getPoison(name)
반환: `Directive|null`

스택에서 이름 식별자로 등록된 독소를 검색하여 반환합니다.

#### toxy#getIncomingPoison(name)
반환: `Directive|null`

스택에서 이름 식별자로 등록된 `incoming` 독소를 검색하여 반환합니다.

#### toxy#getOutgoingPoison(name)
반환: `Directive|null`

스택에서 이름 식별자로 등록된 `outgoing` 독소를 검색하여 반환합니다.

#### toxy#getPoisons()
반환: `array<Directive>`

등록된 독소의 배열을 반환합니다.

#### toxy#getIncomingPoisons()
반환: `array<Directive>`

등록된 `incoming` 독소의 배열을 반환합니다.

#### toxy#getOutgoingPoisons()
반환: `array<Directive>`

등록된 `outgoing` 독소의 배열을 반환합니다.

#### toxy#flush()
별칭: `flushPoisons`

수신 및 송신 트래픽 흐름 모두에 대해 등록된 모든 독소를 제거합니다.

#### toxy#enableRule(rule)

이름 식별자로 규칙을 활성화합니다.

#### toxy#disableRule(rule)

이름 식별자로 규칙을 비활성화합니다.

#### toxy#removeRule(rule)
반환: `boolean`

이름 식별자로 규칙을 제거합니다.

#### toxy#disableRules()

등록된 모든 규칙을 비활성화합니다.

#### toxy#isRuleEnabled(rule)
반환: `boolean`

주어진 규칙이 이름 식별자로 활성화되어 있는지 확인합니다.

#### toxy#getRule(rule)
반환: `Directive|null`

스택에서 이름 식별자로 등록된 규칙을 검색하여 반환합니다.

#### toxy#getRules()
반환: `array<Directive>`

`Directive`로 감싸진 등록된 규칙의 배열을 반환합니다.

#### toxy#flushRules()

모든 규칙을 제거합니다.

### toxy.addPoison(name, fn)

내장 독소를 확장합니다.

### toxy.addRule(name, fn)

내장 규칙을 확장합니다.

### toxy.poisons `=>` Object

내장된 독소의 맵을 노출합니다.

### toxy.rules `=>` Object

내장된 규칙의 맵을 노출합니다.

### toxy.VERSION `=>` String

현재 toxy의 시맨틱 버전(semantic version)입니다.

### ToxyRoute

`ToxyRoute`는 `Toxy` 전역 인터페이스와 동일한 인터페이스를 노출하며, 몇 가지 경로 수준의 [추가 메소드](https://github.com/h2non/rocky#routepath)를 제공합니다.

`ToxyRoute` API에 대해 수행하는 추가 작업은 경로 수준(중첩)에만 적용됩니다. 즉, API를 이미 알고 있다는 의미입니다.

다음 예제가 의문점을 해소해 줄 것입니다:```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'))

### 인증

관리자 프로그래밍 API에 대한 자세한 내용은 [아래](#programmatic-api-1)를 참조하세요.

HTTP API는 권한 없는 클라이언트로부터 보호될 수 있습니다. 인증된 클라이언트는 `API-Key` 또는 `Authorization` HTTP 헤더를 통해 API 키 토큰을 정의해야 합니다.

이를 활성화하려면 `toxy` 관리 서버에 다음 옵션을 전달하면 됩니다:```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

### 포이즌

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

#### POST /servers/:id/poisons
수락 형식: `application/json`

예제 페이로드:```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

### 경로

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

#### POST /servers/:id/routes
수락: `application/json`

예제 페이로드:```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
Accepts: `application/json`

예제 페이로드:```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

### 프로그래밍 API

내장 HTTP 관리 서버는 확장 및 해킹 목적에 개방된 간단한 인터페이스를 제공합니다.
예를 들어, 관리 서버에 추가 미들웨어를 연결하거나 새로운 라우트를 등록할 수 있습니다.

#### toxy.admin([ opts ])
반환값: `Admin`

**지원 옵션**:

- **apiKey** `string` - 서버를 보호하기 위한 선택적 API 키
- **port** `number` - 선택적. 수신할 TCP 포트
- **cors** `boolean` - 웹 브라우저 접근을 위한 CORS 활성화
- **middleware** `array<function>` - 추가 미들웨어 연결
- **ssl** `object` - Node.js HTTPS 서버 [TLS 옵션](https://nodejs.org/api/tls.html#tls_tls_createserver_options_secureconnectionlistener).

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

네트워크에서 수신을 시작합니다.

##### Admin#manage(toxy)

`toxy` 서버 인스턴스를 관리합니다.

##### Admin#find(toxy)

toxy 인스턴스를 찾습니다. toxy 서버 ID 또는 toxy 인스턴스를 허용합니다.

##### Admin#remove(toxy)

toxy 인스턴스 관리를 중지합니다.

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

미들웨어를 등록합니다.

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

파라미터 미들웨어를 등록합니다.

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

GET 라우트를 등록합니다.

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

POST 라우트를 등록합니다.

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

PUT 라우트를 등록합니다.

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

DELETE 라우트를 등록합니다.

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

PATCH 라우트를 등록합니다.

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

모든 HTTP 메서드를 허용하는 라우트를 등록합니다.

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

connect/express와 함께 연결할 미들웨어.

##### Admin#close(cb)

서버를 중지합니다.

## 라이선스

MIT - Tomas Aparicio

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