h2non/toxyहैक करने योग्य HTTP प्रॉक्सी जो रेज़िलिएंसी परीक्षण और सिम्युलेटेड नेटवर्क स्थितियों के लिए है।
सक्रिय रूप से रखरखाव नहीं किया जा रहा है, नवीनतम node.js रनटाइम के साथ काम नहीं कर सकता। यदि आप toxy के रखरखाव में रुचि रखते हैं, तो कृपया एक मुद्दा खोलें।
हैक करने योग्य HTTP प्रॉक्सी जो सर्वर विफलता परिदृश्यों, सिस्टम लचीलापन परीक्षण और अप्रत्याशित नेटवर्क स्थितियों को सिम्युलेट करती है, node.js के लिए निर्मित।
यह मुख्य रूप से विफलता प्रतिरोध परीक्षण के लिए डिज़ाइन किया गया था, जब toxy किसी सिस्टम की दोष सहनशीलता और लचीलापन क्षमताओं को कवर करने के लिए विशेष रूप से उपयोगी हो जाता है, विशेष रूप से disruption-tolerant networks और service-oriented आर्किटेक्चर में, जहाँ toxy सेवाओं के बीच MitM प्रॉक्सी के रूप में कार्य कर सकता है ताकि विफलता इंजेक्ट कर सके।
toxy आपको poisons प्लग इन करने की अनुमति देता है, वैकल्पिक रूप से rules द्वारा फ़िल्टर किए गए, जो मूल रूप से आवश्यकतानुसार HTTP प्रवाह को इंटरसेप्ट और बदल सकते हैं, उस प्रक्रिया के बीच में कई बुरे कार्य करते हुए, जैसे बैंडविड्थ को सीमित करना, नेटवर्क पैकेट में देरी करना, नेटवर्क जिटर लेटेंसी इंजेक्ट करना या कस्टम एरर या स्टेटस कोड के साथ उत्तर देना। यह मुख्य रूप से L7 पर काम करता है, हालाँकि यह L3 नेटवर्क स्थितियों का अनुकरण कर सकता है।
toxy का programmatically या HTTP API के माध्यम से आसानी से उपयोग किया जा सकता है। यह rocky के ऊपर बनाया गया है, एक पूर्ण-सुविधा वाला मिडलवेयर-उन्मुख HTTP प्रॉक्सी, और यह connect/express में मानक मिडलवेयर के रूप में pluggable भी है।
node.js +4 की आवश्यकता है।
बाज़ार में toxy जैसे कुछ अन्य समान समाधान हैं, लेकिन उनमें से अधिकांश उचित प्रोग्रामेटिक नियंत्रण प्रदान नहीं करते हैं और आमतौर पर हैक करने, कॉन्फ़िगर करने में आसान नहीं होते हैं या सीधे विस्तारशीलता के लिए बंद होते हैं। इसके अलावा, उन समाधानों में से अधिकांश केवल TCP L3 स्तर के स्टैक पर काम करते हैं, बजाय HTTP L7 प्रोटोकॉल के विशिष्ट डोमेन और प्रकृति में सामान्य आवश्यकताओं को कवर करने के लिए उच्च-स्तरीय एब्स्ट्रैक्शन प्रदान करने के, जैसा toxy प्रदान करने का प्रयास करता है। toxy एक शक्तिशाली हैक करने योग्य और विस्तारणीय समाधान लाता है जिसमें एक सुविधाजनक एब्स्ट्रैक्शन है, लेकिन HTTP प्रोटोकॉल प्रिमिटिव से आसानी से निपटने के लिए उचित निम्न-स्तरीय इंटरफ़ेस क्षमताओं को खोए बिना। toxy को composition, सरलता और extensibility के नियमों पर आधारित डिज़ाइन किया गया है। अपने अंतर्निहित पदानुक्रमित डोमेन-विशिष्ट मिडलवेयर परत के माध्यम से आप अपनी आवश्यकताओं के अनुसार toxy सुविधाओं को आसानी से बढ़ा सकते हैं।
toxy दो निर्देश प्रस्तुत करता है: पॉइज़न और नियम।
पॉइज़न वह विशिष्ट तर्क है जो इनकमिंग या आउटगोइंग HTTP लेनदेन को संक्रमित करता है (उदा: लेटेंसी इंजेक्ट करना, एरर के साथ उत्तर देना)। एक HTTP लेनदेन एक या कई पॉइज़न द्वारा संक्रमित किया जा सकता है, और उन पॉइज़न को वैश्विक या रूट स्तर के ट्रैफ़िक दोनों को संक्रमित करने के लिए भी कॉन्फ़िगर किया जा सकता है।
नियम एक प्रकार के मिलान सत्यापन फ़िल्टर हैं जो यह निर्धारित करने के लिए HTTP अनुरोध/प्रतिक्रिया का निरीक्षण करते हैं कि दिए गए कुछ नियमों के अनुसार, HTTP लेनदेन को पॉइज़न किया जाना चाहिए या नहीं (उदा: हेडर मेल खाते हैं, क्वेरी पैरामीटर, विधि, बॉडी...)। नियमों का पुन: उपयोग किया जा सकता है और इनकमिंग और आउटगोइंग दोनों ट्रैफ़िक प्रवाहों पर लागू किया जा सकता है, जिसमें विभिन्न स्कोप शामिल हैं: वैश्विक, रूट या पॉइज़न स्तर।
↓ ( Incoming request ) ↓ ↓ ||| ↓ ↓ +-------------+ ↓ ↓ | Toxy Router | ↓ -> Match the incoming request ↓ +-------------+ ↓ ↓ ||| ↓ ↓ +--------------------+ ↓ ↓ | Incoming phase | ↓ -> The proxy receives the request from the client ↓ |~~~~~~~~~~~~~~~~~~~~| ↓ ↓ | ---------------- | ↓ ↓ | | Exec Rules | | ↓ -> Apply configured rules for the incoming request ↓ | ---------------- | ↓ ↓ | ||| | ↓ ↓ | ---------------- | ↓ ↓ | | Exec Poisons | | ↓ -> If all rules passed, then poison the HTTP flow ↓ | ---------------- | ↓ ↓ +~~~~~~~~~~~~~~~~~~~~+ ↓ ↓ / \ ↓ ↓ \ / ↓ ↓ +--------------------+ ↓ ↓ | HTTP dispatcher | ↓ -> Forward the HTTP traffic to the target server, either poisoned or not ↓ +--------------------+ ↓ ↓ / \ ↓ ↓ \ / ↓ ↓ +--------------------+ ↓ ↓ | Outgoing phase | ↓ -> Receives response from target server ↓ |~~~~~~~~~~~~~~~~~~~~| ↓ ↓ | ---------------- | ↓ ↓ | | Exec Rules | | ↓ -> Apply configured rules for the outgoing request ↓ | ---------------- | ↓ ↓ | ||| | ↓ ↓ | ---------------- | ↓ ↓ | | Exec Poisons | | ↓ -> If all rules passed, then poison the HTTP flow before send it to the client ↓ | ---------------- | ↓ ↓ +~~~~~~~~~~~~~~~~~~~~+ ↓ ↓ ||| ↓ ↓ ( Send to the client ) ↓ -> Finally, send the request to the client, either poisoned or not
## उपयोग
### स्थापना```
npm install toxy
अधिक उपयोग के मामलों के लिए उदाहरण निर्देशिका देखें।```js var toxy = require('toxy') var poisons = toxy.poisons var rules = toxy.rules
// Create a new toxy proxy var proxy = toxy()
// Default server to forward incoming traffic proxy .forward('http://httpbin.org')
// Register global poisons and rules proxy .poison(poisons.latency({ jitter: 500 })) .rule(rules.probability(25))
// Register multiple routes proxy .get('/download/') .forward('http://files.myserver.net') .poison(poisons.bandwidth({ bps: 1024 })) .withRule(rules.headers({'Authorization': /^Bearer (.)$/i }))
// Infect outgoing traffic only (after the server replied properly) proxy .get('/image/*') .outgoingPoison(poisons.bandwidth({ bps: 512 })) .withRule(rules.method('GET')) .withRule(rules.timeThreshold({ duration: 1000, threshold: 1000 * 10 })) .withRule(rules.responseStatus({ range: [ 200, 400 ] }))
proxy .all('/api/*') .poison(poisons.rateLimit({ limit: 10, threshold: 1000 })) .withRule(rules.method(['POST', 'PUT', 'DELETE'])) // And use a different more permissive poison for GET requests .poison(poisons.rateLimit({ limit: 50, threshold: 1000 })) .withRule(rules.method('GET'))
// Handle the rest of the traffic proxy .all('/*') .poison(poisons.slowClose({ delay: 1000 })) .poison(poisons.slowRead({ bps: 128 })) .withRule(rules.probability(50))
proxy.listen(3000) console.log('Server listening on port:', 3000) console.log('Test it:', 'http://localhost:3000/image/jpeg')
## बेंचमार्क
विवरण के लिए [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) देखें।
### जहर लगाने के चरण
जहर को इनकमिंग या आउटगोइंग ट्रैफ़िक प्रवाहों, या दोनों में भी प्लग किया जा सकता है।
**Incoming** जहर तब लागू किया जाता है जब ट्रैफ़िक प्रॉक्सी द्वारा प्राप्त किया गया है लेकिन अभी तक लक्ष्य सर्वर को अग्रेषित नहीं किया गया है।
**Outgoing** जहर उस ट्रैफ़िक को संदर्भित करता है जो लक्ष्य सर्वर को अग्रेषित किया गया है और
जब प्रॉक्सी उससे प्रतिक्रिया प्राप्त करता है, लेकिन वह प्रतिक्रिया अभी तक क्लाइंट को नहीं भेजी गई है।
इसका मूल रूप से अर्थ है कि आप अपने जहर को HTTP ट्रैफ़िक को संक्रमित करने के लिए प्लग कर सकते हैं
अनुरोध को लक्ष्य HTTP सर्वर को अग्रेषित करने या क्लाइंट को भेजने से पहले या बाद में।
यह आपको अनुरोध या सर्वर प्रतिक्रिया के आधार पर बेहतर और अधिक सटीक जहर लागू करने की अनुमति देता है।
उदाहरण के लिए, कुछ जहरों की प्रकृति को देखते हुए, जैसे `inject error`,
आप इसे लक्ष्य सर्वर प्रतिक्रिया के अनुसार सक्षम करना चाह सकते हैं (जैसे: कोई हेडर मौजूद है या नहीं)।
एक प्रदर्शित उदाहरण के लिए [poison-phases.js](https://github.com/h2non/toxy/blob/master/examples/poison-phases.js) देखें।
### अंतर्निहित जहर
#### विलंबता
<table>
<tr>
<td><b>नाम</b></td><td>latency</td>
</tr>
<tr>
<td><b>जहर चरण</b></td><td>इनकमिंग / आउटगोइंग</td>
</tr>
<tr>
<td><b>सर्वर तक पहुंचता है</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 }))
| नाम | inject |
| विषाक्तता चरण | आने वाला / जाने वाला |
| सर्वर तक पहुंचता है | false (केवल आने वाले विषाक्त के रूप में) |
अनुरोध को लक्ष्य सर्वर पर भेजने से पहले उसे रोककर एक कस्टम प्रतिक्रिया इंजेक्ट करता है। सर्वर में उत्पन्न त्रुटियों को इंजेक्ट करने के लिए उपयोगी।
तर्क:
object
number - प्रतिक्रिया HTTP स्थिति कोड। डिफ़ॉल्ट 500object - भेजने के लिए वैकल्पिक हेडर्सmixed - भेजने के लिए वैकल्पिक बॉडी डेटा। यह buffer या string हो सकता हैstring - बॉडी एन्कोडिंग। डिफ़ॉल्ट `utf8````js
toxy.poison(toxy.poisons.inject({
code: 503,
body: '{"error": "toxy injected error"}',
headers: {'Content-Type': 'application/json'}
}))#### बैंडविड्थ
<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 }))
| नाम | rateLimit |
| विषाक्तता चरण | incoming / outgoing |
| सर्वर तक पहुँचता है | true |
प्रॉक्सी द्वारा एक निश्चित थ्रेशोल्ड समय अवधि में प्राप्त अनुरोधों की मात्रा को सीमित करता है। API सीमाओं का परीक्षण करने के लिए डिज़ाइन किया गया है। सामान्य X-RateLimit-* हेडर को उजागर करता है।
ध्यान दें कि यह बहुत ही सरल दर सीमा कार्यान्वयन है; वास्तव में सीमाएँ मेमोरी में संग्रहीत होती हैं, इसलिए पूरी तरह से अस्थायी हैं। कई सुविधाओं और सुसंगत दर सीमित करने वाले कार्यान्वयन npm में उपलब्ध हैं जिन्हें आप विष के रूप में प्लग इन कर सकते हैं। आपको टोकन बकेट एल्गोरिदम में भी रुचि हो सकती है।
तर्क:
object
number - कुल अनुरोधों की संख्या। डिफ़ॉल्ट 10number - सीमा समय अवधि मिलीसेकंड में। डिफ़ॉल्ट 1000string - सीमा पहुँचने पर वैकल्पिक त्रुटि संदेश।number - सीमा पहुँचने पर HTTP स्थिति कोड। डिफ़ॉल्ट 429।```js
toxy.poison(toxy.poisons.rateLimit({ limit: 5, threshold: 10 * 1000 }))#### धीमी पढ़ाई
<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 }))
Name: slowOpen
| Name | slowOpen |
| Poisoning Phase | incoming |
| Reaches the server | true |
HTTP कनेक्शन की तैयार स्थिति में देरी करता है।
Arguments:
object
number - कनेक्शन में मिलीसेकंड में देरी। डिफ़ॉल्ट 1000 है```js
toxy.poison(toxy.poisons.slowOpen({ delay: 2000 }))#### धीमा बंद
<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 }))
| नाम | थ्रॉटल |
| विषाक्तता चरण | आने वाला / बाहर जाने वाला |
| सर्वर तक पहुँचता है | true |
एक विशिष्ट थ्रेशोल्ड समय सीमा में नेटवर्क पर भेजे जाने वाले पैकेटों की मात्रा को प्रतिबंधित करता है।
तर्क:
object
number - बाइट्स में पैकेट चंक आकार। डिफ़ॉल्ट 1024 है।object - मिलीसेकंड में डेटा चंक विलंब समय सीमा। डिफ़ॉल्ट 100 है।```js
toxy.poison(toxy.poisons.throttle({ chunk: 2048, threshold: 1000 }))#### कनेक्शन समाप्त करें
<table>
<tr>
<td><b>नाम</b></td><td>abort</td>
</tr>
<tr>
<td><b>विषाक्ति चरण</b></td><td>इनकमिंग / आउटगोइंग</td>
</tr>
<tr>
<td><b>सर्वर तक पहुँचता है</b></td><td>गलत (केवल इनकमिंग पॉइजन के रूप में)</td>
</tr>
</table>
TCP कनेक्शन को समाप्त करता है। निचले स्तर के दृष्टिकोण से, यह सर्वर पर सॉकेट को नष्ट कर देगा, केवल TCP स्तर पर काम करता है और कोई विशिष्ट HTTP एप्लिकेशन स्तर डेटा नहीं भेजता है।
**तर्क**:
- **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 }))
| नाम | timeout |
| विषाक्ति चरण | incoming / outgoing |
| सर्वर तक पहुँचता है | true |
प्रतिक्रिया समय-सीमा को परिभाषित करता है। धीमे सर्वरों पर अग्रेषित करते समय उपयोगी।
तर्क:
number - मिलीसेकंड में टाइमआउट सीमा```js
toxy.poison(toxy.poisons.timeout(5000))### पॉइज़न कैसे लिखें
पॉइज़न को मानक मिडलवेयर फंक्शन के रूप में लागू किया जाता है, जिसका इंटरफ़ेस 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))
आप वैकल्पिक रूप से बिल्ट-इन पॉइज़न को अपने स्वयं के पॉइज़न के साथ बढ़ा सकते हैं:```js toxy.addPoison(customLatency)
// Then you can use it as a built-in poison proxy .get('/foo') .poison(toxy.poisons.customLatency)
एक विशिष्ट वास्तविक उदाहरण के लिए, [built-in poisons](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>incoming / outgoing</td>
</tr>
</table>
यादृच्छिक संभाव्यता द्वारा नियम को सक्षम करता है। यादृच्छिक विषाक्तता के लिए उपयोगी।
**तर्क**:
- **percentage** `number` - फ़िल्टरिंग का प्रतिशत। डिफ़ॉल्ट `50````js
var rule = toxy.rules.probability(85)
toxy.rule(rule)
| नाम | timeThreshold |
| ज़हर चरण | incoming / outgoing |
एक विशिष्ट समय सीमा और अवधि के आधार पर ज़हर को सक्षम करने का सरल नियम। उदाहरण के लिए, आप एक समय सीमा (जैसे: 1 मिनट) के भीतर एक विशिष्ट समय (जैसे: 1 सेकंड) के लिए कुछ ज़हर सक्षम कर सकते हैं।
तर्क:
object
number - समय अंतराल मिलीसेकंड में सक्षम करें। डिफ़ॉल्ट 1000number - ज़हर को पुनः सक्षम करने से पहले प्रतीक्षा करने के लिए मिलीसेकंड में समय सीमा। डिफ़ॉल्ट `10000````js
// Enable the poisoning only 100 milliseconds per each 10 seconds
proxy.rule(toxy.rules.timeThreshold(100))
// Enable poisoning during 1 second every minute
proxy.rule(toxy.rules.timeThreshold({ duration: 1000, period: 1000 * 60 }))#### विधि
<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)
हेडर के अनुसार सामग्री प्रकार को फ़िल्टर करता है। यह मौजूद होना चाहिए।
Arguments:
string|regexp - मिलान करने के लिए हेडर मान।```js
var rule = toxy.rules.contentType('application/json')
toxy.rule(rule)#### Headers
<table>
<tr>
<td><b>Name</b></td><td>headers</td>
</tr>
<tr>
<td><b>Poison Phase</b></td><td>incoming / outgoing</td>
</tr>
</table>
अनुरोध हेडर्स द्वारा फ़िल्टर करें।
**Arguments**:
- **headers** `object` - कुंजी-मान जोड़ी द्वारा मिलान करने के लिए हेडर्स। `value` एक string, regexp, `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)
| नाम | responseHeaders |
| विष चरण | outgoing |
लक्ष्य सर्वर से प्रतिक्रिया हेडर द्वारा फ़िल्टर करें। headers नियम के समान, लेकिन आउटगोइंग अनुरोध का मूल्यांकन करते हुए।
तर्क:
object - कुंजी-मान जोड़ी द्वारा मिलान करने के लिए हेडर। value एक string, regexp, 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.responseHeaders(matchHeaders) toxy.rule(rule)
#### बॉडी
<table>
<tr>
<td><b>नाम</b></td><td>body</td>
</tr>
<tr>
<td><b>विष चरण</b></td><td>आने वाला / बाहर जाने वाला</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)
| नाम | responseBody |
| विष चरण | outgoing |
दिए गए string, regexp या कस्टम फ़िल्टर function द्वारा आउटगोइंग बॉडी पेलोड का मिलान करें।
तर्क:
string|regexp|function - मिलान करने के लिए बॉडी सामग्रीstring - बॉडी एन्कोडिंग। डिफ़ॉल्ट utf8number - बॉडी लंबाई। डिफ़ॉल्ट Content-Length हेडर से लिया गया```js
var rule = toxy.rules.responseBody('"hello":"world"')
toxy.rule(rule)// Or using a filter function returning a boolean var rule = toxy.rules.responseBody(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>
लक्ष्य सर्वर से प्रतिक्रिया स्थिति का मूल्यांकन करता है।
केवल outgoing ज़हर पर लागू होता है।
**तर्क**:
- **range** `array` - मिलान करने के लिए स्थिति कोड की जोड़ी। डिफ़ॉल्ट `[200, 300]`.
- **lower** `number` - स्थिति की तुलना `से कम` संचालन के रूप में करें। डिफ़ॉल्ट `null`.
- **higher** `number` - स्थिति की तुलना `से अधिक` संचालन के रूप में करें। डिफ़ॉल्ट `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] }))
समुदाय द्वारा प्रदान किए गए उपलब्ध तृतीय-पक्ष नियमों की सूची। PR का स्वागत है।
नियम सरल मिडलवेयर फ़ंक्शन होते हैं जो एक boolean मान के साथ अतुल्यकालिक रूप से हल होते हैं, यह निर्धारित करने के लिए कि किसी दिए गए HTTP लेन-देन को जहर देते समय अनदेखा किया जाना चाहिए या नहीं।
आपके नियम को मिडलवेयर में next(err, shouldIgnore) फ़ंक्शन को कॉल करके boolean पैरामीटर के साथ हल करना होगा, यदि नियम से मेल नहीं खाता है और जहर लागू नहीं होना चाहिए तो true मान पास करता है, और इस प्रकार अगले मिडलवेयर स्टैक के साथ जारी रखता है।
यहाँ एक सरल नियम का उदाहरण है जो HTTP विधि से मेल खाता है यह निर्धारित करने के लिए कि:```js var toxy = require('toxy')
function customMethodRule(matchMethod) { /**
var proxy = toxy()
// Register and enable the rule proxy .get('/foo') .rule(customMethodRule('GET')) .poison(/* ... */)
आप वैकल्पिक रूप से अंतर्निहित नियमों को अपने स्वयं के नियमों के साथ विस्तारित कर सकते हैं:```js
toxy.addRule(customMethodRule)
// Then you can use it as a built-in poison
proxy
.get('/foo')
.rules(toxy.rules.customMethodRule)
For featured real examples, take a look to the built-in rules implementation
toxy API पूरी तरह से rocky API पर आधारित है। दूसरे शब्दों में, आप rocky द्वारा मूल रूप से प्रदान किए गए किसी भी तरीके, सुविधाओं और मिडलवेयर लेयर का उपयोग कर सकते हैं।
एक नया toxy प्रॉक्सी बनाएँ।
समर्थित options के लिए, कृपया rocky documentation देखें।```js
var toxy = require('toxy')
toxy({ forward: 'http://server.net', timeout: 30000 })
toxy .get('/foo') .poison(toxy.poisons.latency(1000)) .withRule(toxy.rules.contentType('json')) .forward('http://foo.server')
toxy .post('/bar') .poison(toxy.poisons.bandwidth({ bps: 1024 })) .withRule(toxy.rules.probability(50)) .forward('http://bar.server')
toxy .post('/boo') .outgoingPoison(toxy.poisons.bandwidth({ bps: 1024 })) .withRule(toxy.rules.method('GET')) .forward('http://boo.server')
toxy.all('/*')
toxy.listen(3000)
#### toxy#get(path, [ middleware... ])
Return: `ToxyRoute`
`GET` विधि के लिए एक नया रूट पंजीकृत करें।
#### toxy#post(path, [ middleware... ])
Return: `ToxyRoute`
`POST` विधि के लिए एक नया रूट पंजीकृत करें।
#### toxy#put(path, [ middleware... ])
Return: `ToxyRoute`
`PUT` विधि के लिए एक नया रूट पंजीकृत करें।
#### toxy#patch(path, [ middleware... ])
Return: `ToxyRoute`
#### toxy#delete(path, [ middleware... ])
Return: `ToxyRoute`
`DELETE` विधि के लिए एक नया रूट पंजीकृत करें।
#### toxy#head(path, [ middleware... ])
Return: `ToxyRoute`
`HEAD` विधि के लिए एक नया रूट पंजीकृत करें।
#### toxy#all(path, [ middleware... ])
Return: `ToxyRoute`
किसी भी विधि के लिए एक नया रूट पंजीकृत करें।
#### toxy#poisons `=>` Object
बिल्ट-इन पॉइज़न के साथ एक मैप प्रकट करता है। प्रोटोटाइप उपनाम `toxy.poisons`
#### toxy#rules `=>` Object
बिल्ट-इन पॉइज़न के साथ एक मैप प्रकट करता है। प्रोटोटाइप उपनाम `toxy.rules`
#### toxy#forward(url)
प्रॉक्सी द्वारा प्राप्त आने वाले ट्रैफ़िक को अग्रेषित करने के लिए एक URL परिभाषित करें।
#### toxy#balance(urls)
एकाधिक सर्वरों पर अग्रेषित करें, उनके बीच संतुलन बनाए रखें।
अधिक जानकारी के लिए, [rocky docs](https://github.com/h2non/rocky#programmatic-api) देखें।
#### toxy#replay(url)
एक नया रीप्ले सर्वर परिभाषित करें।
एकाधिक रीप्ले सर्वर परिभाषित करने के लिए आप इस विधि को कई बार कॉल कर सकते हैं।
अधिक जानकारी के लिए, [rocky docs](https://github.com/h2non/rocky#programmatic-api) देखें।
#### toxy#use(middleware)
एक कस्टम मिडलवेयर प्लग इन करें।
अधिक जानकारी के लिए, [rocky docs](https://github.com/h2non/rocky#middleware-layer) देखें।
#### toxy#useResponse(middleware)
एक रिस्पॉन्स आउटगोइंग ट्रैफ़िक मिडलवेयर प्लग इन करें।
अधिक जानकारी के लिए, [rocky docs](https://github.com/h2non/rocky#middleware-layer) देखें।
#### toxy#useReplay(middleware)
एक रीप्ले ट्रैफ़िक मिडलवेयर प्लग इन करें।
अधिक जानकारी के लिए, [rocky docs](https://github.com/h2non/rocky#middleware-layer) देखें।
#### toxy#requestBody(middleware)
आने वाले अनुरोध निकाय (request body) को इंटरसेप्ट करें। इसे चलते-फिरते संशोधित करने के लिए उपयोगी।
अधिक जानकारी के लिए, [rocky docs](https://github.com/h2non/rocky#programmatic-api) देखें।
#### toxy#responseBody(middleware)
बाहर जाने वाले प्रतिक्रिया निकाय (response body) को इंटरसेप्ट करें। इसे चलते-फिरते संशोधित करने के लिए उपयोगी।
अधिक जानकारी के लिए, [rocky docs](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)
Alias: `usePoison`, `useIncomingPoison`
[आने वाले](#poisoning-phases) ट्रैफ़िक को संक्रमित करने के लिए एक नया पॉइज़न पंजीकृत करें।
#### toxy#outgoingPoison(poison)
Alias: `useOutgoingPoison`, `responsePoison`
[बाहर जाने वाले](#poisoning-phases) ट्रैफ़िक को संक्रमित करने के लिए एक नया पॉइज़न पंजीकृत करें।
#### toxy#rule(rule)
Alias: `useRule`
एक नया नियम पंजीकृत करें।
#### toxy#withRule(rule)
Aliases: `ifRule`, `whenRule`, `poisonRule`, `poisonFilter`
नवीनतम पंजीकृत पॉइज़न के लिए एक नया नियम लागू करें।
#### toxy#enable(poison)
नाम पहचानकर्ता द्वारा एक पॉइज़न सक्षम करें।
#### toxy#disable(poison)
नाम पहचानकर्ता द्वारा एक पॉइज़न अक्षम करें।
#### toxy#remove(poison)
Return: `boolean`
नाम पहचानकर्ता या वस्तु संदर्भ द्वारा एक आने वाले ट्रैफ़िक पॉइज़न को हटाएं।
#### toxy#removeOutgoing(poison)
Return: `boolean`
नाम पहचानकर्ता या वस्तु संदर्भ द्वारा एक बाहर जाने वाले ट्रैफ़िक पॉइज़न को हटाएं।
#### toxy#isEnabled(poison)
Return: `boolean`
जांचता है कि नाम पहचानकर्ता द्वारा एक पॉइज़न सक्षम है या नहीं।
#### toxy#disableAll()
Alias: `disablePoisons`
सभी पंजीकृत पॉइज़न को अक्षम करें।
#### toxy#getPoison(name)
Return: `Directive|null`
नाम पहचानकर्ता द्वारा स्टैक में पंजीकृत पॉइज़न खोजता और प्राप्त करता है।
#### toxy#getIncomingPoison(name)
Return: `Directive|null`
नाम पहचानकर्ता द्वारा स्टैक में पंजीकृत `incoming` पॉइज़न खोजता और प्राप्त करता है।
#### toxy#getOutgoingPoison(name)
Return: `Directive|null`
नाम पहचानकर्ता द्वारा स्टैक में पंजीकृत `outgoing` पॉइज़न खोजता और प्राप्त करता है।
#### toxy#getPoisons()
Return: `array<Directive>`
पंजीकृत पॉइज़न की एक सरणी लौटाता है।
#### toxy#getIncomingPoisons()
Return: `array<Directive>`
पंजीकृत `incoming` पॉइज़न की एक सरणी लौटाता है।
#### toxy#getOutgoingPoisons()
Return: `array<Directive>`
पंजीकृत `outgoing` पॉइज़न की एक सरणी लौटाता है।
#### toxy#flush()
Alias: `flushPoisons`
आने वाले और बाहर जाने वाले दोनों ट्रैफ़िक प्रवाहों के लिए सभी पंजीकृत पॉइज़न हटाएं।
#### toxy#enableRule(rule)
नाम पहचानकर्ता द्वारा एक नियम सक्षम करें।
#### toxy#disableRule(rule)
नाम पहचानकर्ता द्वारा एक नियम अक्षम करें।
#### toxy#removeRule(rule)
Return: `boolean`
नाम पहचानकर्ता द्वारा एक नियम हटाएं।
#### toxy#disableRules()
सभी पंजीकृत नियमों को अक्षम करें।
#### toxy#isRuleEnabled(rule)
Return: `boolean`
जांचता है कि दिया गया नियम नाम पहचानकर्ता द्वारा सक्षम है या नहीं।
#### toxy#getRule(rule)
Return: `Directive|null`
नाम पहचानकर्ता द्वारा स्टैक में पंजीकृत नियम खोजता और प्राप्त करता है।
#### toxy#getRules()
Return: `array<Directive>`
`Directive` के रूप में लिपटे पंजीकृत नियमों के साथ एक सरणी लौटाता है।
#### toxy#flushRules()
सभी नियम हटाएं।
### toxy.addPoison(name, fn)
बिल्ट-इन पॉइज़न का विस्तार करें।
### toxy.addRule(name, fn)
बिल्ट-इन नियमों का विस्तार करें।
### toxy.poisons `=>` Object
बिल्ट-इन पॉइज़न के साथ एक मैप प्रकट करता है।
### toxy.rules `=>` Object
बिल्ट-इन नियमों के साथ एक मैप प्रकट करता है।
### toxy.VERSION `=>` String
वर्तमान toxy सिमैंटिक वर्शन।
### 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'))
पॉइज़न और नियमों के लिए आंतरिक रूप से उपयोग किया जाने वाला एक सुविधाजनक रैपर।
आमतौर पर आपको इस इंटरफ़ेस को जानने की आवश्यकता नहीं है, लेकिन हैकिंग उद्देश्यों या अधिक निम्न-स्तरीय क्रियाओं के लिए उपयोगी हो सकता है।
वापसी: boolean
वापसी: boolean
वापसी: boolean
उपनाम: filter
वापसी: function(req, res, next)
toxy HTTP API JSON API सम्मेलनों का पालन करता है, जिसमें संसाधन-आधारित हाइपरमीडिया लिंकिंग शामिल है।
एक विशिष्ट उपयोग के मामले के लिए, admin server उदाहरण देखें।```js const toxy = require('toxy')
// Create the toxy admin server var admin = toxy.admin({ cors: true }) admin.listen(9000)
// Create the toxy proxy var proxy = toxy() proxy.listen(3000)
// Add the toxy instance to be managed by the admin server admin.manage(proxy)
// Then configure the proxy proxy .forward('http://my.target.net')
proxy .get('/slow') .poison(toxy.poisons.bandwidth({ bps: 1024 }))
// Handle the rest of the traffic proxy .all('/*') .poison(toxy.poisons.bandwidth({ bps: 1024 * 5 }))
console.log('toxy proxy listening on port:', 3000) console.log('toxy admin server listening on port:', 9000)
For more details about the admin programmatic API, see [below](#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)
पदानुक्रम:
toxy इंस्टेंसेस
स्वीकार करता है: application/json
उदाहरण पेलोड:```js { "name": "method", "options": "GET" }
#### 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 }
}
स्वीकार करता है: application/json
उदाहरण पेलोड:```js { "name": "method", "options": "GET" }
#### 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
स्वीकार करता है: `application/json`
उदाहरण पेलोड:```js
{
"path": "/foo", // Required
"method": "GET", // use ALL for all the methods
"forward": "http://my.server", // Optional custom forward server URL
}
स्वीकार करता है: application/json
उदाहरण payload:```js { "name": "method", "options": "GET" }
#### DELETE /servers/:id/routes/:id/rules
#### GET /servers/:id/routes/:id/rules/:id
#### DELETE /servers/:id/routes/:id/rules/:id
### रूट पॉइज़न
#### GET /servers/:id/routes/:id/poisons
#### POST /servers/:id/routes/:id/poisons
स्वीकार करता है: `application/json`
उदाहरण पेलोड:```js
{
"name": "latency",
"phase": "outgoing",
"options": { "jitter": 1000 }
}
स्वीकार करता है: application/json
उदाहरण पेलोड:```js { "name": "method", "options": "GET" }
#### 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 - टॉमस अपरिसियो
[](https://sourcegraph.com/github.com/h2non/toxy)