सर्कस - क्लाउड में ऑनलाइन

कार्यक्रम:

नाम

सर्कस - सर्कस दस्तावेज़ीकरण [छवि]

सर्कस एक पायथन प्रोग्राम है जिसका उपयोग प्रक्रियाओं और सॉकेट की निगरानी और नियंत्रण के लिए किया जा सकता है।

सर्कस को कमांड-लाइन इंटरफ़ेस, वेब इंटरफ़ेस या प्रोग्रामेटिक रूप से संचालित किया जा सकता है
इसके पायथन एपीआई के माध्यम से।

इसे स्थापित करने और इसकी विशेषताओं को आज़माने के लिए उदाहरण देखें, या इस पृष्ठ का शेष भाग पढ़ें
त्वरित परिचय के लिए.

चल रहा है A सर्कस डेमोन

सर्कस एक कमांड-लाइन स्क्रिप्ट कॉल प्रदान करता है सर्कसडी जिसका उपयोग प्रक्रियाओं को प्रबंधित करने के लिए किया जा सकता है
एक या अधिक दर्शकों में व्यवस्थित।

सर्कस का कमांड-लाइन टूल एक आईएनआई-स्टाइल कॉन्फ़िगरेशन फ़ाइल का उपयोग करके कॉन्फ़िगर करने योग्य है।

यहाँ एक बहुत ही न्यूनतम उदाहरण है:

[द्रष्टा:कार्यक्रम]
सीएमडी = पायथन myprogram.py
संख्याप्रक्रम = 5

[द्रष्टा: एक अन्य कार्यक्रम]
सीएमडी = अन्य_प्रोग्राम
संख्याप्रक्रम = 2

फिर फ़ाइल को पास कर दिया जाता है सर्कसडी:

$ सर्कस example.ini

प्रक्रियाओं के अलावा, सर्कस सॉकेट्स को भी बांध सकता है। चूँकि प्रत्येक प्रक्रिया सर्कस द्वारा प्रबंधित होती है
मुख्य सर्कस डेमॉन का एक बच्चा, इसका मतलब है कि सर्कस द्वारा नियंत्रित कोई भी कार्यक्रम हो सकता है
उन सॉकेट का उपयोग करें.

सॉकेट चलाना उतना ही सरल है जितना कि जोड़ना सॉकेट कॉन्फ़िग फ़ाइल में अनुभाग:

[सॉकेट: मायसॉकेट]
होस्ट = लोकलहोस्ट
पोर्ट = 8080

सॉकेट के बारे में अधिक जानने के लिए सॉकेट देखें।

यह समझने के लिए कि यह एक शानदार विशेषता क्यों है, व्हाईसर्कससॉकेट पढ़ें।

नियंत्रित सर्कस

सर्कस आपके चल रहे डेमॉन को प्रबंधित करने के लिए दो कमांड-लाइन टूल प्रदान करता है:

· circusctl, एक प्रबंधन कंसोल जिसका उपयोग आप जोड़ने या जोड़ने जैसे कार्य करने के लिए कर सकते हैं
श्रमिकों को हटाना

· सर्कस-टॉप, एक शीर्ष जैसा कंसोल जिसका उपयोग आप अपनी मेमोरी और सीपीयू उपयोग को प्रदर्शित करने के लिए कर सकते हैं
सर्कस चल रहा है.

इनके बारे में अधिक जानने के लिए सीएलआई देखें

सर्कस एक वेब डैशबोर्ड भी प्रदान करता है जो चल रहे सर्कस डेमॉन से कनेक्ट हो सकता है और आपको बता सकता है
इसकी निगरानी करें और इसके साथ बातचीत करें।

इस सुविधा के बारे में अधिक जानने के लिए, सर्कसhttpd देखें

क्या अभी ?
यदि आप एक डेवलपर हैं और अपने स्वयं के प्रोजेक्ट में सर्कस का लाभ उठाना चाहते हैं, तो प्लगइन्स लिखें या
हुक, फ़ोरदेव्स पर जाएँ।

यदि आप एक ऑप्स हैं और सर्कस का उपयोग करके अपनी प्रक्रियाओं को प्रबंधित करना चाहते हैं, तो फ़ोरॉप्स पर जाएँ।

योगदान और प्रतिपुष्टि
योगदान पर अधिक जानकारी: योगदान।

उपयोगी कड़ियाँ:

· किसी भी प्रतिक्रिया या प्रश्न के लिए एक मेल-सूची है:
http://tech.groups.yahoo.com/group/circus-dev/

· रिपॉजिटरी और इश्यू ट्रैकर GitHub पर हैं: https://github.com/circus-tent/circus

· आईआरसी पर हमसे जुड़ें: फ़्रीनोड, चैनल #सरकस का तंबू

दस्तावेज़ीकरण अनुक्रमणिका
का अधिष्ठापन सर्कस
सर्कस एक पायथन पैकेज है जो PyPI - पायथन पैकेज इंडेक्स पर प्रकाशित होता है।

इसे स्थापित करने का सबसे सरल तरीका पिप का उपयोग करना है, जो पायथन को स्थापित करने और प्रबंधित करने के लिए एक उपकरण है
संकुल:

$ पिप इंस्टॉल सर्कस

या डाउनलोड करें संग्रह on PyPI, इसे मैन्युअल रूप से निकालें और इंस्टॉल करें:

$ पायथन setup.py इंस्टॉल करें

यदि आप सर्कस आज़माना चाहते हैं, तो उदाहरण देखें।

यदि आप डेबियन या किसी डेबियन आधारित वितरण का उपयोग कर रहे हैं, तो आप पीपीए का भी उपयोग कर सकते हैं
सर्कस स्थापित करें, यह चालू है https://launchpad.net/~roman-imankulov/+archive/circus

zc.बिल्डआउट
हम एक प्रदान करते हैं zc.बिल्डआउट कॉन्फ़िगरेशन, आप इसे केवल बूटस्ट्रैप चलाकर उपयोग कर सकते हैं
स्क्रिप्ट, फिर बिल्डआउट को कॉल करना:

$ पायथन बूटस्ट्रैप.पी
$ बिन/बिल्डआउट

अधिक on आवश्यकताएँ
सर्कस इसके साथ काम करता है:

· पायथन 2.6, 2.7, 3.2 या 3.3

·

ज़ीरोमक >= 2.1.10

· ज़ीरोमक का समर्थित संस्करण अंततः किस संस्करण द्वारा निर्धारित किया जाता है
pyzmq सर्कस इंस्टालेशन के दौरान पाइप द्वारा स्थापित किया जाता है।

· उनकी वर्तमान रिलीज़ 2.x (सीमित), 3.x और 4.x ZeroMQ संस्करणों का समर्थन करती है।

· नोट: यदि आप CPython के बजाय PyPy का उपयोग कर रहे हैं, तो उन्हें पढ़ना सुनिश्चित करें
ZeroMQ संस्करण समर्थन के रूप में इंस्टॉलेशन डॉक्स PyPy पर समान नहीं है।

जब आप सर्कस स्थापित करते हैं, तो पायथन निर्भरता के नवीनतम संस्करण निकाले जाएंगे
तुम्हारे लिए।

आप हमारे द्वारा प्रदान की गई pip-requirements.txt फ़ाइल का उपयोग करके उन्हें मैन्युअल रूप से भी इंस्टॉल कर सकते हैं:

$ पिप इंस्टाल -आर पिप-requirements.txt

यदि आप वेब कंसोल चलाना चाहते हैं तो आपको इंस्टॉल करना होगा सर्कस-वेब:

$ पिप इंस्टॉल सर्कस-वेब

ट्यूटोरियल
क्रमशः ट्यूटोरियल
RSI उदाहरण डायरेक्टरी सर्कस भंडार में आपके लिए कई उदाहरण मौजूद हैं
प्रारंभ हो गया है, लेकिन यहां एक संपूर्ण ट्यूटोरियल है जो आपको सुविधाओं का एक सिंहावलोकन देता है।

हम डब्लूएसजीआई एप्लिकेशन की निगरानी करने जा रहे हैं।

स्थापना
सर्कस का परीक्षण मैक ओएस एक्स और लिनक्स पर नवीनतम पायथन 2.6, 2.7, 3.2 और 3.3 के साथ किया गया है। को
एक पूरा सर्कस चलाएं, आपको इसकी भी आवश्यकता होगी libzmq, लिबवेंट & Virtualenv.

डेबियन-आधारित सिस्टम पर:

$ sudo apt-get install libzmq-dev libevent-dev Python-dev Python-virtualenv

एक वर्चुअलएन्व बनाएं और इंस्टॉल करें सर्कस, सर्कस-वेब और मौज़ा इस में

$ वर्चुअलएन्व /टीएमपी/सर्कस
$ सीडी /टीएमपी/सर्कस
$ बिन/पिप इंस्टॉल सर्कस
$ बिन/पिप सर्कस-वेब स्थापित करें
$ बिन/पिप इंस्टाल चौसेट

एक बार यह पूरा हो जाने पर, आपको स्थानीय बिन डीआईआर में ढेर सारे कमांड मिलेंगे।

प्रयोग
मौज़ा एक डिफ़ॉल्ट हैलो वर्ल्ड ऐप के साथ आता है, इसे चलाने का प्रयास करें:

$ बिन/चौसेट

आपको यात्रा करने में सक्षम होना चाहिए http://localhost: 8080 और देखो नमस्ते विश्व.

चौसेट को रोकें और निर्देशिका में एक circus.ini फ़ाइल जोड़ें जिसमें:

[सर्कस]
आँकड़े = 1
httpd = 1

[दर्शक:वेबएप]
सीएमडी = बिन/चौसेट --एफडी $(सर्कस.सॉकेट.वेब)
संख्याप्रक्रम = 3
use_sockets = सच

[सॉकेट:वेब]
होस्ट = 127.0.0.1
पोर्ट = 9999

यह कॉन्फ़िगरेशन फ़ाइल सर्कस को पोर्ट पर सॉकेट बाइंड करने के लिए कहती है 9999 और 3 चौसेट्स श्रमिकों को चलाएं
उसके खिलाफ। यह सर्कस वेब डैशबोर्ड और सांख्यिकी मॉड्यूल को भी सक्रिय करता है।

इसे सहेजें और इसका उपयोग करके चलाएं सर्कसडी:

$ बिन/सर्कसड--डेमन सर्कस.आईएनआई

अब विजिट करें http://127.0.0.1: 9999, आपको हेलो वर्ल्ड ऐप देखना चाहिए। फर्क अब है
सॉकेट का प्रबंधन सर्कस द्वारा किया जाता है और कई वेब कर्मचारी इसे स्वीकार कर रहे हैं
इसके विरुद्ध कनेक्शन.

नोट:
लोड संतुलन ऑपरेटिंग सिस्टम द्वारा संचालित होता है इसलिए आपको समान गति मिल रही है
Apache या NGinx जैसे किसी भी अन्य प्री-फोर्क वेब सर्वर की तरह। सर्कस हस्तक्षेप नहीं करता
जो डेटा गुजरता है.

आप यह भी देख सकते हैं http://localhost: 8080 / और सर्कस वेब डैशबोर्ड का आनंद लें।

इंटरेक्शन
जब सिस्टम चल रहा हो तो आइए circusctl शेल का उपयोग करें:

$ बिन/सर्कसक्टल
सर्कसक्टल 0.7.1
सर्कस-आँकड़े: सक्रिय
सर्कसhttpd: सक्रिय
वेबएप: सक्रिय
(सर्कसक्टल)

आप एक इंटरैक्टिव शेल में आ जाते हैं। प्रकार मदद सभी आदेश प्राप्त करने के लिए:

(circusctl) मदद

प्रलेखित आदेश (help टाइप करें) ):
========================================
सूची प्राप्त करें संख्या प्रक्रियाएँ जोड़ें, आरएम प्रारंभ बंद करें छोड़ें
Decr ग्लोबलऑप्शंस सुनो संख्या देखने वालों को सेट आँकड़े पुनः लोड करें
dstats incr listsockets विकल्प सिग्नल स्थिति को पुनरारंभ करें

अनिर्दिष्ट आदेश:
======================
ईओएफ सहायता

आइए बुनियादी चीज़ें आज़माएँ। आइए वेब वर्कर प्रक्रियाओं को सूचीबद्ध करें और एक नई प्रक्रिया जोड़ें:

(circusctl) सूची वेबएप
13712,13713,13714
(circusctl) incr वेबएप
4
(circusctl) सूची वेबएप
13712,13713,13714,13973

बधाई हो, आपने अपने सर्कस के साथ बातचीत की है! Ctrl+D के साथ शेल से बाहर निकलें और अब चलाएँ
सर्कस-टॉप:

$ बिन/सर्कस-टॉप

यह वास्तविक समय में आपकी सभी प्रक्रियाओं की मेमोरी और सीपीयू उपयोग को देखने के लिए एक शीर्ष जैसा कमांड है।

Ctrl+C दबाएं और अब सर्कस-सीटीएल के माध्यम से सर्कस को पूरी तरह से छोड़ दें:

$ बिन/सर्कसक्टल छोड़ें
ok

अगला कदम
आप बस चौसेट के हैलो वर्ल्ड के बजाय अपना खुद का डब्लूएसजीआई एप्लिकेशन प्लग कर सकते हैं
कॉल करने योग्य एप्लिकेशन को इंगित करना।

चौसेट भी गेवेंट या मीनहेल्ड जैसे कई बैकएंड के साथ आता है।

पढ़ना https://chaussette.readthedocs.org/ सभी विकल्पों के लिए.

क्यों चाहिए I उपयोग सर्कस बजाय of X ?
1. सर्कस सरल तुंहारे वेब धुआँरा प्रक्रिया प्रबंध

सर्कस प्रक्रियाओं को प्रबंधित करना जानता है और सॉकेट, इसलिए आपको वेब को प्रतिनिधि नहीं बनाना पड़ेगा
WGSI सर्वर पर श्रमिक प्रबंधन।

देखें सर्कस सॉकेट क्यों

2. सर्कस प्रदान करता है पब/उप और अंदर सूचनाएं के माध्यम से ज़ीरोएमक्यू
सर्कस का एक पब/उप चैनल है जिसकी आप सदस्यता ले सकते हैं। यह चैनल सभी ईवेंट प्राप्त करता है
सर्कस में हो रहा है. उदाहरण के लिए, जब कोई प्रक्रिया फ़्लैप हो रही हो तो आपको सूचित किया जा सकता है, या
एक क्लाइंट बनाएं जो एक चेतावनी ट्रिगर करता है जब कुछ प्रक्रियाएं सभी सीपीयू को खा रही होती हैं
फ्रेम।

ये इवेंट ZeroMQ चैनल के माध्यम से भेजे जाते हैं, जो इसे stdin से अलग बनाता है
स्ट्रीम पर्यवेक्षक का उपयोग करता है:

· सर्कस घटनाओं को आग लगाओ और भूल जाओ की शैली में भेजता है, इसलिए मैन्युअल रूप से लूप करने की कोई आवश्यकता नहीं है
पूज्य गुरुदेव के मार्गदर्शन से संपन्न कर सकते हैं - सब श्रोता और अपनी स्थिति बनाए रखें।

· सब्सक्राइबर्स को रिमोट होस्ट पर स्थित किया जा सकता है।

सर्कस अनुरोध/प्रतिनिधि पर एक बार के मतदान के माध्यम से स्थिति अपडेट प्राप्त करने के तरीके भी प्रदान करता है
चैनल। इसका मतलब है कि आप किसी की सदस्यता लिए बिना अपनी जानकारी प्राप्त कर सकते हैं
धारा। सर्कस द्वारा प्रदान किया गया सीएलआई कमांड इस चैनल का उपयोग करता है।

उदाहरण देखें।

3. सर्कस is (पायथन) विकासक अनुकूल
जबकि सर्कस को पूरी तरह से एक कॉन्फ़िगरेशन फ़ाइल द्वारा संचालित किया जा सकता है और circusctl / सर्कसडी
कमांड, अपना स्वयं का कस्टम बनाने के लिए सिस्टम के सभी या कुछ हिस्सों का पुन: उपयोग करना आसान है
पायथन में प्रक्रिया द्रष्टा।

सिस्टम की प्रत्येक परत पृथक है, ताकि आप स्वतंत्र रूप से पुन: उपयोग कर सकें:

· प्रक्रिया आवरण (प्रक्रिया)

· प्रक्रिया प्रबंधक (चौकीदार)

· वैश्विक प्रबंधक जो कई प्रक्रिया प्रबंधक चलाता है (मध्यस्थ)

· और इसी तरह…

4. सर्कस तराजू
सर्कस के उपयोग के मामलों में से एक हजारों प्रक्रियाओं को बिना जोड़े प्रबंधित करना है
ओवरहेड - हम इस पर ध्यान केंद्रित करने के लिए समर्पित हैं।

आगामी से पर्यवेक्षक
पायथन दुनिया में सुपरवाइज़र एक बहुत लोकप्रिय समाधान है और हमसे अक्सर पूछा जाता है कि सर्कस कैसा है
उससे तुलना करता है.

यदि आप कहां से आ रहे हैं पर्यवेक्षक, यह पृष्ठ उपकरण कैसे हैं इसका एक सिंहावलोकन देने का प्रयास करता है
भिन्न होते हैं।

मतभेद सिंहावलोकन
पर्यवेक्षक और सर्कस के लक्ष्य समान हैं - वे दोनों प्रक्रियाओं का प्रबंधन करते हैं और प्रदान करते हैं
कमांड-लाइन स्क्रिप्ट - क्रमशः supervisord और सर्कसडी - जो एक कॉन्फ़िगरेशन पढ़ता है
फ़ाइल, नई प्रक्रियाओं को फोर्क करता है और उन्हें जीवित रखता है।

सर्कस में एक अतिरिक्त सुविधा है: सॉकेट को बांधने और प्रक्रियाओं को प्रबंधित करने की क्षमता
उनका उपयोग करें। इस "प्री-फोर्क" मॉडल का उपयोग कई वेब सर्वरों द्वारा किया जाता है, जैसे अपाचे or
एक तंगावाला. सर्कस में यह विकल्प होने से वेब ऐप स्टैक सरल हो सकता है: सभी प्रक्रियाएं और
सॉकेट को एक ही टूल द्वारा प्रबंधित किया जाता है।

दोनों परियोजनाएं किसी अन्य स्क्रिप्ट के माध्यम से चल रहे डेमॉन को नियंत्रित करने का एक तरीका प्रदान करती हैं। क्रमश:
पर्यवेक्षक और circusctl. उन दोनों के पास इवेंट और उनकी सदस्यता लेने का एक तरीका भी है।
मुख्य अंतर अंतर्निहित तकनीक है: पर्यवेक्षक बातचीत के लिए XML-RPC का उपयोग करता है
डेमॉन के साथ, जबकि सर्कस ZeroMQ का उपयोग करता है।

सर्कस और पर्यवेक्षक दोनों के पास यह प्रदर्शित करने के लिए एक वेब इंटरफ़ेस है कि क्या हो रहा है। 'सर्कस' ज्यादा है
उन्नत क्योंकि आप वास्तविक समय में क्या चल रहा है उसका अनुसरण कर सकते हैं और डेमॉन के साथ बातचीत कर सकते हैं।
यह वेब सॉकेट का उपयोग करता है और इसे एक अलग प्रोजेक्ट में विकसित किया गया है (सर्कस-वेब.)

मूल डिज़ाइन में कई अन्य सूक्ष्म अंतर हैं, जिन्हें हम एक दिन यहां सूचीबद्ध कर सकते हैं... में
इस बीच, आप डिज़ाइन में सर्कस आंतरिक के बारे में अधिक जान सकते हैं।

विन्यास
दोनों प्रणालियाँ कॉन्फ़िगरेशन के रूप में एक ini-जैसी फ़ाइल का उपयोग करती हैं।

· पर्यवेक्षक दस्तावेज़ीकरण

· सर्कस दस्तावेज़ीकरण

यहां पर्यवेक्षक के साथ एप्लिकेशन चलाने का एक छोटा सा उदाहरण दिया गया है। इस मामले में,
क्रैश होने की स्थिति में एप्लिकेशन प्रारंभ और पुनः प्रारंभ किया जाएगा

[कार्यक्रम: उदाहरण]
कमांड=एनपीएम प्रारंभ
निर्देशिका=/होम/www/my-सर्वर/
उपयोगकर्ता=www-डेटा
ऑटोस्टार्ट = सत्य
स्वतः पुनः आरंभ = सत्य
रीडायरेक्ट_स्टडर = सत्य

सर्कस में, समान विन्यास इसके द्वारा किया जाता है:

[द्रष्टा: उदाहरण]
सीएमडी=एनपीएम प्रारंभ
वर्किंग_डीआईआर=/होम/www/माय-सर्वर/
उपयोगकर्ता=www-डेटा
stderr_stream.class=StdoutStream

ध्यान दें कि सर्कस में stderr पुनर्निर्देशन थोड़ा अलग है। उपकरण नहीं है
a पूंछ सुपरवाइज़र जैसी सुविधा, लेकिन इससे निपटने के लिए आपको कोड के किसी भी हिस्से को हुक करने की सुविधा मिलेगी
आने वाली धारा. आप अपना स्वयं का स्ट्रीम हुक (एक क्लास के रूप में) बना सकते हैं और जो चाहें कर सकते हैं
आने वाली धारा के साथ चाहते हैं. सर्कस कुछ अंतर्निहित स्ट्रीम कक्षाएं प्रदान करता है जैसे
स्टडआउटस्ट्रीम, फ़ाइल स्ट्रीम, देखी गईफ़ाइलस्ट्रीमया, टाइम्डरोटेटिंगफ़ाइलस्ट्रीम.

सर्कस एसटी ऑप्स
चेतावनी:
डिफ़ॉल्ट रूप से, ZeroMQ के माध्यम से जानकारी भेजते समय सर्कस अपने संदेशों को सुरक्षित नहीं करता है।
उत्पादन परिवेश में सर्कस चलाने से पहले, सुरक्षा पृष्ठ को पढ़ना सुनिश्चित करें।

सर्कस डेमॉन को प्रबंधित करने के लिए पहला कदम इसकी कॉन्फ़िगरेशन फ़ाइल लिखना है। देखना
विन्यास। यदि आप वेब स्टैक तैनात कर रहे हैं, तो सॉकेट पर एक नज़र डालें।

सर्कस को Python 2.6, 2.7, 3.2 या 3.3 का उपयोग करके तैनात किया जा सकता है - अधिकांश तैनाती हैं
2.7 में किया गया। सर्कस को तैनात करने का तरीका जानने के लिए, तैनाती देखें।

सर्कस डेमॉन को प्रबंधित करने के लिए, आपको उन आदेशों की सूची से परिचित होना चाहिए जिनका आप उपयोग कर सकते हैं
in circusctl. ध्यान दें कि जब आप दौड़ते हैं तो आपको वही मदद ऑनलाइन मिल सकती है circusctl एक के रूप में
खोल।

हम भी प्रदान करते हैं सर्कस-टॉप, सीएलआई और एक अच्छा वेब डैशबोर्ड देखें। सर्कसhttpd देखें।

अंत में, सर्कस का अधिकतम लाभ उठाने के लिए, प्लगइन और हुक का उपयोग कैसे करें इसकी जांच करना सुनिश्चित करें।
प्लगइन्स और हुक देखें.

ऑप्स दस्तावेज़ीकरण अनुक्रमणिका
विन्यास
सर्कस को आईएनआई-स्टाइल कॉन्फ़िगरेशन फ़ाइल का उपयोग करके कॉन्फ़िगर किया जा सकता है।

उदाहरण:

[सर्कस]
चेक_विलंब = 5
समापन बिंदु = टीसीपी://127.0.0.1:5555
pubsub_endpoint = टीसीपी://127.0.0.1:5556
शामिल करें = \*.more.config.ini
उमास्क = 002

[द्रष्टा: मेरा कार्यक्रम]
सीएमडी = पायथन
args = -u myprogram.py $(circus.wid) $(CIRCUS.ENV.VAR)
वार्मअप_देरी = 0
संख्याप्रक्रम = 5

# अंकुश
हुक.पहले_स्टार्ट = my.hooks.control_redis

# हर 300 एमएस में टेस्ट.लॉग स्ट्रीम को पुश करेगा
stdout_stream.class = फ़ाइलस्ट्रीम
stdout_stream.filename = test.log

# वैकल्पिक रूप से लॉग फ़ाइल को 1 जीबी तक पहुंचने पर घुमाएं
# और घुमाई गई फ़ाइलों की 5 प्रतिलिपियाँ सहेजें
stdout_stream.max_bytes = 1073741824
stdout_stream.backup_count = 5

[env:मायप्रोग्राम]
पथ = $ पथ:/ bin
केक = झूठ

[प्लगइन: आँकड़े]
उपयोग करें = circus.plugins.statsd.StatsdEmitter
होस्ट = लोकलहोस्ट
पोर्ट = 8125
नमूना_दर = 1.0
एप्लिकेशन_नाम = उदाहरण

[सॉकेट:वेब]
होस्ट = लोकलहोस्ट
पोर्ट = 8080

सर्कस - एक अनुभाग
समापन बिंदु
ZMQ सॉकेट का उपयोग सर्कस को प्रबंधित करने के लिए किया जाता है circusctl. (गलती करना:
टीसीपी://127.0.0.1:5555)

समापन बिंदु_स्वामी
यदि सिस्टम उपयोगकर्ता नाम पर सेट किया गया है और समापन बिंदु एक आईपीसी सॉकेट जैसा है
आईपीसी://var/run/circusd.sock, तो सॉकेट फ़ाइल का स्वामित्व बदल दिया जाएगा
स्टार्टअप पर वह उपयोगकर्ता। अधिक विवरण के लिए, सुरक्षा देखें. (डिफ़ॉल्ट: कोई नहीं)

pubsub_endpoint
ZMQ PUB/SUB सॉकेट घटनाओं के प्रकाशन प्राप्त कर रहा है। (गलती करना:
टीसीपी://127.0.0.1:5556)

पापा_एंडपॉइंट
यदि पापा का उपयोग कर रहे हैं, तो आप समापन बिंदु निर्दिष्ट कर सकते हैं, जैसे आईपीसी://var/run/circusd.sock.
(चूक जाना: टीसीपी://127.0.0.1:20202)

आँकड़े यदि सही पर सेट किया जाता है, तो सर्कस सर्कस-स्टैट्स डेमॉन चलाता है। (डिफ़ॉल्ट: ग़लत)

आँकड़े_अंतबिंदु
ZMQ PUB/SUB सॉकेट आंकड़ों का प्रकाशन प्राप्त कर रहा है। (गलती करना:
टीसीपी://127.0.0.1:5557)

आँकड़े_बंद_आउटपुट
यदि ट्रू सर्कस-स्टैट्स stdout/stderr को /dev/null पर भेजता है। (डिफ़ॉल्ट: ग़लत)

check_delay
ZMQ सॉकेट के लिए सेकंड में मतदान अंतराल। (डिफ़ॉल्ट: 5)

शामिल
शामिल करने योग्य कॉन्फ़िगरेशन फ़ाइलों की सूची. आप वाइल्डकार्ड का उपयोग कर सकते हैं (*) विशेष को शामिल करने के लिए
आपकी फ़ाइलों के लिए योजनाएँ। पथ कॉन्फ़िग फ़ाइल से निरपेक्ष या सापेक्ष हैं।
(डिफ़ॉल्ट: कोई नहीं)

शामिल_दिर
कॉन्फ़िगरेशन निर्देशिकाओं की सूची. सभी फ़ाइलें मेल खा रही हैं *.इनी प्रत्येक निर्देशिका के अंतर्गत होगा
शामिल हो। पथ कॉन्फ़िग फ़ाइल से निरपेक्ष या सापेक्ष हैं। (गलती करना:
कोई नहीं)

स्ट्रीम_बैकएंड
स्ट्रीमिंग के लिए उपयोग किए जाने वाले बैकएंड के प्रकार को परिभाषित करता है। संभावित मान हैं धागा
or गीवेंट. (डिफ़ॉल्ट: थ्रेड)

वार्मअप_देरी
दो दर्शकों के बीच सेकंड का अंतराल शुरू हो जाता है. एक इंट होना चाहिए. (डिफ़ॉल्ट: 0)

httpd यदि सही पर सेट किया जाता है, तो सर्कस सर्कसhttpd डेमॉन चलाता है। (डिफ़ॉल्ट: ग़लत)

httpd_host
मेज़बान सर्कसटेड डेमॉन द्वारा भागा। (डिफ़ॉल्ट: लोकलहोस्ट)

httpd_port
पोर्ट सर्कसटैप्ड डेमॉन द्वारा चलाया गया। (डिफ़ॉल्ट: 8080)

httpd_close_outputs
यदि सत्य है, तो सर्कसhttpd stdout/stderr को /dev/null पर भेजता है। (डिफ़ॉल्ट: ग़लत)

डिबग यदि सही पर सेट किया जाता है, तो सभी सर्कस स्टाउट/स्टडर डेमॉन सर्कसडी पर पुनर्निर्देशित हो जाते हैं
stdout/stderr (डिफ़ॉल्ट: गलत)

डिबग_जीसी
यदि सही पर सेट किया जाता है, तो सर्कस कचरा संग्रहकर्ता से अतिरिक्त लॉग जानकारी आउटपुट करता है।
यह मेमोरी लीक को ट्रैक करने में उपयोगी हो सकता है। (डिफ़ॉल्ट: ग़लत)

पिडफाइल
वह फ़ाइल जिसका उपयोग डेमॉन पिड को रखने के लिए किया जाना चाहिए।

umask उमास्क के लिए मूल्य. यदि सेट नहीं किया गया है, तो सर्कस umask को संशोधित करने का प्रयास नहीं करेगा।

लॉग स्तर
वह लॉगलेवल जिसे हम देखना चाहते हैं (डिफ़ॉल्ट: जानकारी)

लॉगआउटपुट
लॉगआउटपुट फ़ाइल जहां हम लॉग करना चाहते हैं (डिफ़ॉल्ट: - stdout पर लॉग इन करने के लिए)। तुम कर सकते हो
निम्नलिखित सिंटैक्स का उपयोग करके दूरस्थ syslog में लॉग इन करें:
syslog://host:port?सुविधा जहां होस्ट आपका syslog सर्वर है, पोर्ट वैकल्पिक है
और सुविधा उपयोग करने के लिए syslog सुविधा है। यदि आप स्थानीय syslog पर लॉग इन करना चाहते हैं
आप उपयोग कर सकते हैं syslog:///path/to/syslog/socket?facility बजाय.

loggerconfig
मानक पायथन लॉगिंग को कॉन्फ़िगर करने के लिए INI, JSON या YAML फ़ाइल का पथ
मध्यस्थ. विशेष मान "डिफ़ॉल्ट" अंतर्निहित लॉगिंग कॉन्फ़िगरेशन का उपयोग करता है
वैकल्पिक लॉगलेवल और लॉगआउटपुट विकल्पों के आधार पर।

उदाहरण यमल विन्यास पट्टिका

संस्करण: 1
अक्षम_मौजूदा_लॉगर्स: गलत
फ़ॉर्मेटर:
सरल:
प्रारूप: '%(asctime)s - %(name)s - [%(levelname)s] %(message)s'
संचालक:
बोटा दस्तावेज:
वर्ग: लॉगिंग.फ़ाइलहैंडलर
फ़ाइल नाम: logoutput.txt
स्तर: डीबग
फ़ॉर्मेटर: सरल
लकड़हारा:
सर्कस:
स्तर: डीबग
हैंडलर: [लॉगफ़ाइल]
प्रचारित करें: नहीं
जड़:
स्तर: डीबग
हैंडलर: [लॉगफ़ाइल]

देखने वाला:नाम - as बहुत वर्गों as इसलिए आप करना चाहते हैं
नाम देखने वाले का नाम. इस नाम का प्रयोग किया जाता है circusctl

सीएमडी चलाने योग्य निष्पादन योग्य प्रोग्राम.

आर्ग प्रोग्राम को पास करने के लिए कमांड-लाइन तर्क। आप पाइथॉन प्रारूप का उपयोग कर सकते हैं
पैरामीटर बनाने के लिए यहां सिंटैक्स। पर्यावरण चर उपलब्ध हैं, जैसे
साथ ही कार्यकर्ता आईडी और आपके द्वारा पारित पर्यावरण चर, यदि कोई हो,
"env" पैरामीटर के साथ। देखना फॉर्मेटिंग la आज्ञाओं और तर्क साथ में गतिशील
चर इस पर अधिक जानकारी के लिए।

खोल यदि सत्य है, तो प्रक्रियाएँ शेल में चलती हैं (डिफ़ॉल्ट: ग़लत)

शेल_आर्ग्स
शेल कमांड को पास करने के लिए कमांड-लाइन तर्क जब खोल क्या सच है। काम करता है
केवल *निक्स सिस्टम के लिए (डिफ़ॉल्ट: कोई नहीं)

वर्किंग_डीआईआर
प्रक्रियाओं के लिए कार्यशील डीआईआर (डिफ़ॉल्ट: कोई नहीं)

यूआईडी कमांड को उपयोगकर्ता आईडी या नाम के साथ चलाना चाहिए। (वर्तमान यूआईडी है
चूक)।

gid कमांड को समूह आईडी या नाम के साथ चलना चाहिए। (वर्तमान gid है
चूक)।

Copy_env
यदि सही पर सेट किया जाता है, तो स्थानीय पर्यावरण चर की प्रतिलिपि बनाई जाएगी और उसे पास कर दिया जाएगा
श्रमिक जब उन्हें पैदा करते हैं। (डिफ़ॉल्ट: ग़लत)

प्रतिलिपि_पथ
यदि सत्य पर सेट किया जाए, sys.पथ का उपयोग करके उपप्रक्रिया वातावरण में पारित किया जाता है अजगरपथ.
Copy_env सच होना चाहिए. (डिफ़ॉल्ट: ग़लत)

वार्मअप_देरी
चल रही प्रक्रियाओं के बीच विलंब (सेकंड में)।

ऑटो स्टार्ट
यदि गलत पर सेट किया जाता है, तो मध्यस्थ होने पर वॉचर स्वचालित रूप से प्रारंभ नहीं होगा
शुरू होता है. द्रष्टा को स्पष्ट रूप से प्रारंभ किया जा सकता है (उदाहरण: circusctrl प्रारंभ
मेरा कार्यक्रम). (डिफ़ॉल्ट: सत्य)

numprocesses
इस वॉचर के लिए चलने वाली प्रक्रियाओं की संख्या.

rlimit_LIMIT
देखी गई प्रक्रियाओं के लिए संसाधन सीमा LIMIT निर्धारित करें। कॉन्फ़िगरेशन नाम मेल खाना चाहिए
में सूचीबद्ध RLIMIT_* स्थिरांक (केस संवेदनशील नहीं)। अजगर संसाधन मॉड्यूल
संदर्भ. उदाहरण के लिए, कॉन्फिग लाइन 'rlimit_nofile = 500' अधिकतम सेट करती है
खुली फ़ाइलों की संख्या 500 तक। सीमा मान को RLIM_INFINITY पर सेट करने के लिए, सेट न करें
मान, इस कॉन्फ़िगरेशन लाइन की तरह: 'rlimit_nofile ='।

stderr_stream.class
एक पूरी तरह से योग्य पायथन वर्ग का नाम जिसे स्थापित किया जाएगा, और प्राप्त किया जाएगा
la stderr इसमें सभी प्रक्रियाओं की धारा __पुकारना__() विधि.

सर्कस कुछ स्ट्रीम कक्षाएं प्रदान करता है जिनका उपयोग आप बिना उपसर्ग के कर सकते हैं:

· फ़ाइल स्ट्रीम: एक फ़ाइल में लिखता है और स्वचालित लॉग रोटेशन कर सकता है

· देखी गईफ़ाइलस्ट्रीम: एक फ़ाइल में लिखता है और बाहरी लॉग रोटेशन पर निर्भर करता है

· टाइम्डरोटेटिंगफ़ाइलस्ट्रीम: किसी फ़ाइल में लिखता है और निश्चित समय पर रोटेट कर सकता है
अंतराल।

· क्यूस्ट्रीम: स्मृति कतार में लिखें

· स्टडआउटस्ट्रीम: स्टडआउट में लिखता है

· फैंसीस्टडआउटस्ट्रीम: स्टडआउट में समय उपसर्गों के साथ रंगीन आउटपुट लिखता है

stderr_stream.*
से प्रारंभ होने वाले सभी विकल्प stderr_stream. अन्य की तुलना में कक्षा पारित कर दिया जाएगा
परिभाषित वर्ग का एक उदाहरण बनाते समय कंस्ट्रक्टर
stderr_stream.class.

stdout_stream.class
एक पूरी तरह से योग्य पायथन वर्ग का नाम जिसे स्थापित किया जाएगा, और प्राप्त किया जाएगा
la stdout इसमें सभी प्रक्रियाओं की धारा __पुकारना__() विधि.

सर्कस कुछ स्ट्रीम कक्षाएं प्रदान करता है जिनका उपयोग आप बिना उपसर्ग के कर सकते हैं:

· फ़ाइल स्ट्रीम: एक फ़ाइल में लिखता है और स्वचालित लॉग रोटेशन कर सकता है

· देखी गईफ़ाइलस्ट्रीम: एक फ़ाइल में लिखता है और बाहरी लॉग रोटेशन पर निर्भर करता है

· टाइम्डरोटेटिंगफ़ाइलस्ट्रीम: किसी फ़ाइल में लिखता है और निश्चित समय पर रोटेट कर सकता है
अंतराल।

· क्यूस्ट्रीम: स्मृति कतार में लिखें

· स्टडआउटस्ट्रीम: स्टडआउट में लिखता है

· फैंसीस्टडआउटस्ट्रीम: स्टडआउट में समय उपसर्गों के साथ रंगीन आउटपुट लिखता है

stdout_stream.*
से प्रारंभ होने वाले सभी विकल्प stdout_stream. अन्य की तुलना में कक्षा पारित कर दिया जाएगा
परिभाषित वर्ग का एक उदाहरण बनाते समय कंस्ट्रक्टर
stdout_stream.class.

क्लोज़_चाइल्ड_स्टडआउट
यदि सही पर सेट किया जाता है, तो प्रत्येक प्रक्रिया की स्टडआउट स्ट्रीम /dev/null पर भेजी जाएगी
कांटे के बाद. डिफ़ॉल्ट ग़लत है।

क्लोज़_चाइल्ड_स्टडर
यदि सही पर सेट किया जाता है, तो प्रत्येक प्रक्रिया की stderr स्ट्रीम /dev/null पर भेजी जाएगी
कांटे के बाद. डिफ़ॉल्ट ग़लत है।

भेजें_हप
यदि सत्य है, तो SIGHUP सिग्नल भेजकर एक प्रक्रिया पुनः लोड की जाएगी। चूक
ग़लत करने के लिए.

stop_signal
प्रक्रिया को रोकते समय भेजने का संकेत। एक संख्या या एक के रूप में निर्दिष्ट किया जा सकता है
संकेत नाम. सिग्नल नाम केस-असंवेदनशील होते हैं और इनमें 'SIG' शामिल हो सकता है या नहीं। इसलिए
वैध उदाहरणों में शामिल हैं छोड़ना, INT, सिगटरम और 3. SIGTERM पर डिफ़ॉल्ट।

रुको_बच्चों
भेजते समय stop_signal, इसे बच्चों को भी भेजें। के लिए डिफ़ॉल्ट
असत्य।

max_retry
हम किसी प्रक्रिया को शुरू करने का प्रयास करते हैं, इससे पहले कि हम उसे छोड़ दें और रोक दें
संपूर्ण द्रष्टा. डिफ़ॉल्ट 5 है। max_retry को अक्षम करने और पुनः प्रयास करने के लिए -1 पर सेट करें
अनिश्चित काल के लिए।

ग्रेसफुल_टाइमआउट
किसी प्रक्रिया के सुचारु रूप से पहले समाप्त होने के लिए प्रतीक्षा करने वाले सेकंड की संख्या
मार रहे हैं।

किसी प्रक्रिया को रोकते समय, हम पहले उसे भेजते हैं stop_signal. कोई कार्यकर्ता इसे पकड़ सकता है
बाहर निकलने से पहले सफ़ाई कार्य करने का संकेत। यदि कार्यकर्ता अभी भी है
ग्रेसफुल_टाइमआउट सेकंड के बाद सक्रिय, हम इसे एक सिगकिल सिग्नल भेजते हैं। यह नहीं है
सिगकिल संकेतों को पकड़ना संभव है ताकि कार्यकर्ता रुक जाए।

डिफ़ॉल्ट 30s पर.

प्राथमिकता
पूर्णांक जो देखने वाले के लिए प्राथमिकता को परिभाषित करता है। जब मध्यस्थ कुछ करेगा
सभी पर्यवेक्षकों पर परिचालन, यह उन्हें बड़े से इस क्षेत्र के साथ क्रमबद्ध करेगा
सबसे छोटी संख्या. डिफ़ॉल्ट 0 है.

एकाकी वस्तु
यदि सही पर सेट किया जाता है, तो इस वॉचर के पास अधिकतम एक प्रक्रिया होगी। के लिए डिफ़ॉल्ट
असत्य।

उपयोग_सॉकेट
यदि सही पर सेट किया जाता है, तो यह वॉचर उनके माध्यम से परिभाषित सॉकेट तक पहुंचने में सक्षम होगा
फ़ाइल डिस्क्रिप्टर. यदि गलत है, तो चाइल्ड प्रोसेस होने पर सभी मूल एफडीएस बंद हो जाते हैं
द्विभाजित। डिफ़ॉल्ट ग़लत है।

अधिकतम_आयु
यदि सेट किया गया है तो प्रक्रिया max_age सेकंड के कुछ समय बाद फिर से शुरू हो जाएगी। यह
यह तब उपयोगी होता है जब प्रक्रियाएँ कनेक्टर्स के पूल से निपटती हैं: प्रक्रियाओं को पुनः आरंभ करना
भार संतुलन में सुधार करता है। डिफ़ॉल्ट रूप से अक्षम किया जा रहा है.

अधिकतम_आयु_विचरण
यदि max_age सेट है तो प्रक्रिया max_age और max_age + के बीच रहेगी
यादृच्छिक(0, max_age_variance) सेकंड। यह a के लिए सभी प्रक्रियाओं को पुनः आरंभ करने से बचाता है
एक बार में देखने वाला. डिफ़ॉल्ट 30 सेकंड.

मांग पर
यदि इसे सही पर सेट किया जाता है, तो प्रक्रियाएं पहले कनेक्शन के बाद ही शुरू की जाएंगी
कॉन्फ़िगर किए गए सॉकेट में से एक (नीचे देखें)। यदि पुनरारंभ की आवश्यकता है, तो यह होगा
केवल अगले सॉकेट इवेंट में ट्रिगर किया गया।

हुक.*
उपलब्ध हुक: पहले_शुरू, After_start, पहले_स्पॉन, After_spawn,
पहले_रुको, उपरांत_रुकें, before_signal, After_signal, विस्तारित_आँकड़े

कॉलबैक फ़ंक्शंस को परिभाषित करें जो वॉचर स्टार्टअप/शटडाउन प्रक्रिया से जुड़ते हैं।

यदि हुक वापस आता है झूठा और यदि हुक इनमें से एक है पहले_शुरू, पहले_स्पॉन,
After_start or After_spawn, स्टार्टअप निरस्त कर दिया जाएगा।

अगर हुक है before_signal और लौटता है झूठा, फिर संबंधित संकेत
नहीं भेजा जाएगा (सिग्किल को छोड़कर जो हमेशा भेजा जाता है)

ध्यान दें कि एक हुक जो रोकने की प्रक्रिया के दौरान विफल हो जाता है, उसे निरस्त नहीं किया जाएगा।

कॉलबैक परिभाषा को अल्पविराम द्वारा अलग किए गए बूलियन ध्वज द्वारा अनुसरण किया जा सकता है।
जब ध्वज को सेट किया जाता है <strong>उद्देश्य</strong>, हुक में होने वाली किसी भी त्रुटि को नजरअंदाज कर दिया जाएगा। अगर
करने के लिए सेट असत्य (डिफ़ॉल्ट), हुक वापस आ जाएगा झूठा.

हुक पर अधिक.

Virtualenv
प्रदान किए जाने पर, वर्चुअलएन्व निर्देशिका की जड़ को इंगित करता है। देखने वाला होगा
स्थानीय स्कैन करें साइट-संकुल और इसकी सामग्री को निष्पादन में लोड करता है
पर्यावरण। के साथ प्रयोग करना चाहिए Copy_env सत्य पर सेट करें. कोई नहीं पर डिफ़ॉल्ट।

वर्चुअलenv_py_ver
वर्चुअलएन्व के पायथन संस्करण को निर्दिष्ट करता है (उदाहरण के लिए "3.3")। यदि यह उपयोगी है
सर्कस दूसरे पायथन संस्करण (उदाहरण के लिए "2.7") के साथ चलता है, दर्शक इसे स्कैन करेगा
स्थानीय साइट-संकुल निर्दिष्ट पायथन संस्करण का और इसकी सामग्री को इसमें लोड करें
निष्पादन वातावरण. के साथ प्रयोग करना चाहिए Virtualenv. कोई नहीं पर डिफ़ॉल्ट।

respawn
यदि गलत पर सेट किया जाता है, तो एक द्रष्टा द्वारा संभाली गई प्रक्रियाएँ पुनः उत्पन्न नहीं होंगी
खुद ब खुद। प्रक्रियाओं को मैन्युअल रूप से पुनः उत्पन्न किया जा सकता है प्रारंभ आदेश।
(डिफ़ॉल्ट: सत्य)

उपयोग_पापा
पापा का उपयोग करने के लिए सत्य पर सेट करें।

सॉकेट:नाम - as बहुत वर्गों as इसलिए आप करना चाहते हैं
मेजबान सॉकेट का होस्ट. 'लोकलहोस्ट' पर डिफ़ॉल्ट

बंदरगाह बंदरगाह। 8080 पर डिफ़ॉल्ट।

परिवार सॉकेट परिवार. 'AF_UNIX', 'AF_INET' या 'AF_INET6' हो सकता है। के लिए डिफ़ॉल्ट
'AF_INET'.

टाइप सॉकेट प्रकार. 'SOCK_STREAM', 'SOCK_DGRAM', 'SOCK_RAW', 'SOCK_RDM' या हो सकता है
'SOCK_SEQPACKET'. डिफ़ॉल्ट रूप से 'SOCK_STREAM'.

इंटरफेस
जब 'eth0' जैसा नेटवर्क इंटरफ़ेस नाम प्रदान किया जाता है, तो सॉकेट को उससे बांध दिया जाता है
विशेष उपकरण ताकि केवल पैकेट ही उस विशेष इंटरफ़ेस से प्राप्त हों
सॉकेट द्वारा संसाधित किया जाता है। इसका उपयोग उदाहरण के लिए किस डिवाइस को सीमित करने के लिए किया जा सकता है
IN_ADDR_ANY (0.0.0.0) या IN_ADDR_BROADCAST पर बाइंड करते समय बाइंड करना
(255.255.255.255)। ध्यान दें कि यह विशेष रूप से केवल कुछ सॉकेट प्रकारों के लिए काम करता है
AF_INET सॉकेट.

पथ जब किसी फ़ाइल के लिए एक पथ प्रदान किया जाता है जिसका उपयोग यूनिक्स सॉकेट फ़ाइल के रूप में किया जाएगा। यदि एक
पथ प्रदान किया गया है, परिवार AF_UNIX और के लिए बाध्य है मेजबान और बंदरगाह नजरअंदाज कर दिया जाता है।

umask प्रदान किए जाने पर, umask सेट करता है जिसका उपयोग AF_UNIX सॉकेट बनाने के लिए किया जाएगा। के लिए
उदाहरण, उमास्क=000 अनुमति के साथ एक सॉकेट का उत्पादन करेगा 777.

की जगह
यूनिक्स सॉकेट ('AF_UNIX') बनाते समय, मौजूदा फ़ाइल किसी समस्या का संकेत दे सकती है
इसलिए डिफ़ॉल्ट विफल होना है। उल्लिखित करना यह सच है यदि आप हैं तो बस पुरानी फ़ाइल को हटा दें
सुनिश्चित करें कि सॉकेट का प्रबंधन केवल सर्कस द्वारा किया जाता है।

so_reuseport
यदि ट्रू पर सेट किया गया है और SO_REUSEPORT लक्ष्य प्लेटफ़ॉर्म पर उपलब्ध है, तो सर्कस होगा
प्रत्येक कर्मचारी के लिए नया SO_REUSEPORT सॉकेट बनाएं और बाइंड करें जो कि एक है
इस सॉकेट का उपयोगकर्ता.

उपयोग_पापा
पापा का उपयोग करने के लिए सत्य पर सेट करें।

एक बार सॉकेट बन जाने के बाद, ${circus.sockets.NAME} स्ट्रिंग का उपयोग कमांड में किया जा सकता है
(सीएमडी or आर्ग) एक द्रष्टा का। सर्कस इसे एफडी मूल्य से बदल देगा। देखने वाले को भी चाहिए
है उपयोग_सॉकेट करने के लिए सेट यह सच है अन्यथा सॉकेट बंद हो चुका होगा और आपको मिल जाएगा
जब देखने वाला इसका उपयोग करने का प्रयास करता है तो त्रुटियाँ होती हैं।

उदाहरण:

[देखने वाला: वेबवर्कर]
सीएमडी = चौसेट --fd $(circus.sockets.webapp) चौसेट.util.bench_app
use_sockets = सच

[सॉकेट:वेबएप]
होस्ट = 127.0.0.1
पोर्ट = 8888

प्लगइन:नाम - as बहुत वर्गों as इसलिए आप करना चाहते हैं
उपयोग पूर्णतः योग्य नाम जो प्लगइन वर्ग की ओर इंगित करता है।

कुछ भी अन्य
अनुभाग में पाई गई प्रत्येक अन्य कुंजी प्लगइन कंस्ट्रक्टर को भेज दी जाती है
विन्यास मानचित्रण।

आप सभी वॉचर विकल्पों का उपयोग कर सकते हैं, क्योंकि एक प्लगइन एक वॉचर की तरह शुरू होता है।

सर्कस कुछ प्री-शिप्ड प्लगइन्स के साथ आता है लेकिन आप उन्हें आसानी से बढ़ा भी सकते हैं
अपना खुद का विकास करना।

env or env[:वॉचर्स] - as बहुत वर्गों as इसलिए आप करना चाहते हैं
कुछ भी
मान निर्दिष्ट करने के लिए पर्यावरण चर का नाम। बैश शैली का वातावरण
प्रतिस्थापन समर्थित हैं. उदाहरण के लिए, जोड़ें / bin सेवा मेरे पथ 'पथ =
$ पथ:/ bin'

प्रक्रियाओं को चलाने के लिए पर्यावरण चर प्रदान करने के लिए जिम्मेदार अनुभाग।

उदाहरण:

[देखने वाला:कार्यकर्ता1]
सीएमडी = पिंग 127.0.0.1

[देखने वाला:कार्यकर्ता2]
सीएमडी = पिंग 127.0.0.1

[पर्यावरण]
केक = झूठ

चर केक कॉन्फ़िगरेशन फ़ाइल में परिभाषित सभी दर्शकों के लिए प्रचारित किया जाएगा।

इस परिवेश को लागू करने के लिए वॉचर्स, वॉचर्स अनुभागों की अल्पविराम से अलग की गई सूची हो सकती है।
यदि कई एनवी अनुभाग एक दर्शक से मेल खाते हैं, तो उन्हें उसी क्रम में संयोजित किया जाएगा जिसमें वे दिखाई देते हैं
कॉन्फ़िगरेशन फ़ाइल. बाद की प्रविष्टियों को प्राथमिकता दी जाएगी।

उदाहरण:

[देखने वाला:कार्यकर्ता1]
सीएमडी = पिंग 127.0.0.1

[देखने वाला:कार्यकर्ता2]
सीएमडी = पिंग 127.0.0.1

[पर्यावरण: कार्यकर्ता 1, कार्यकर्ता 2]
पथ = / bin

[पर्यावरण:कार्यकर्ता1]
पथ = $पथ

[पर्यावरण:कार्यकर्ता2]
केक = झूठ

कार्यकर्ता 1 PATH = $PATH के साथ चलाया जाएगा (उस वातावरण से विस्तारित जिसमें सर्कस चलाया गया था)
कार्यकर्ता 2 PATH = के साथ चलाया जाएगा / bin और केक = झूठ

वाइल्डकार्ड का उपयोग भी संभव है.

उदाहरण:

[देखने वाला:कार्यकर्ता1]
सीएमडी = पिंग 127.0.0.1

[देखने वाला:कार्यकर्ता2]
सीएमडी = पिंग 127.0.0.1

[पर्यावरण:कार्यकर्ता*]
पथ = / bin

दोनों कार्यकर्ता 1 और कार्यकर्ता 2 PATH = के साथ चलाया जाएगा / bin

का प्रयोग वातावरण चर
अपनी कॉन्फ़िगरेशन फ़ाइल लिखते समय, आप इसमें परिभाषित पर्यावरण चर का उपयोग कर सकते हैं env
अनुभाग या में ओएस.पर्यावरण ही.

आपको बस इसका उपयोग करना है सर्कस.env. उपसर्ग।

उदाहरण:

[देखने वाला:कार्यकर्ता1]
सीएमडी = $(circus.env.shell)

[देखने वाला:कार्यकर्ता2]
बाज़ = $(circus.env.user)
बार = $(circus.env.yeah)
सुपर = $(circus.env.oh)

[सॉकेट:सॉकेट1]
पोर्ट = $(circus.env.port)

[प्लगइन:प्लगइन1]
उपयोग = कुछ.पथ
पैरामीटर1 = $(circus.env.plugin_param)

[पर्यावरण]
हाँ = बू

[पर्यावरण:कार्यकर्ता2]
ओह = ठीक है

यदि एक चर को कई स्थानों पर परिभाषित किया गया है, तो सबसे विशिष्ट मूल्य को प्राथमिकता दी जाती है: ए
वैरिएबल को परिभाषित किया गया है env:XXX में परिभाषित एक वेरिएबल को ओवरराइड कर देगा env, जो a को ओवरराइड करेगा
वैरिएबल को परिभाषित किया गया है ओएस.पर्यावरण.

पर्यावरण प्रतिस्थापन का उपयोग कॉन्फ़िगरेशन के किसी भी अनुभाग में किसी भी अनुभाग में किया जा सकता है
चर।

फॉर्मेटिंग la आज्ञाओं और तर्क साथ में गतिशील चर
जैसा कि आपने देखा होगा, गणना की गई कुछ सूचनाओं को पारित करना संभव है
प्रक्रियाओं को चलाते समय गतिशील रूप से। अन्य बातों के अलावा, आप वर्कर आईडी प्राप्त कर सकते हैं
(WID) और सभी विकल्प जो पास किए गए हैं प्रक्रिया. इसके अतिरिक्त, यह संभव है
को दिए गए विकल्पों तक पहुंचें चौकीदार जिसने इस प्रक्रिया को आरंभ किया।

नोट:
वर्कर आईडी प्रक्रिया आईडी से भिन्न है। यह एक अद्वितीय मान है, 1 से शुरू होकर,
जो केवल देखने वाले के लिए अद्वितीय है।

उदाहरण के लिए, यदि आप पर्यावरण में मौजूद कुछ चरों तक पहुँचना चाहते हैं,
आपको इसे इस तरह की सेटिंग के साथ करना होगा:

cmd = "मेरे लिए कॉफ़ी बनाओ--चीनी $(CIRCUS.ENV.SUGAR_AMOUNT)"

यह दोनों के साथ काम करता है सीएमडी और आर्ग.

महत्त्वपूर्ण:

· सभी वेरिएबल्स के साथ उपसर्ग जुड़े हुए हैं सर्कस

· प्रतिस्थापन केस असंवेदनशील है.

धारा विन्यास
सरल धारा वर्ग की तरह क्यूस्ट्रीम और स्टडआउटस्ट्रीम लेकिन विशिष्ट गुण नहीं हैं
किसी अन्य स्ट्रीम क्लास में कुछ हो सकता है:

फ़ाइल स्ट्रीम
फ़ाइल का नाम
फ़ाइल पथ जहां लॉग लिखा जाएगा.

समय स्वरूप
स्ट्रेफ़टाइम प्रारूप जिसका उपयोग हर बार टाइमस्टैम्प के साथ उपसर्ग करने के लिए किया जाएगा। द्वारा
डिफ़ॉल्ट वे उपसर्ग नहीं होंगे।

यानी: %Y-%m-%d %H:%M:%S

अधिकतम_बाइट्स
नई फ़ाइल प्रारंभ होने से पहले लॉग फ़ाइल का अधिकतम आकार। यदि उपलब्ध नहीं कराया गया तो
फ़ाइल को रोलओवर नहीं किया गया है.

बैकअप_गिनती
डिफ़ॉल्ट बैकअप_काउंट द्वारा रखी जाने वाली लॉग फ़ाइलों की संख्या शून्य है।

नोट:
रोलओवर तब होता है जब वर्तमान लॉग फ़ाइल की लंबाई लगभग अधिकतम_बाइट्स होती है। अगर
बैकअप_काउंट>=1 है, सिस्टम क्रमिक रूप से उसी के साथ नई फ़ाइलें बनाएगा
पथनाम को आधार फ़ाइल के रूप में, लेकिन इसमें ".1", ".2" आदि एक्सटेंशन जोड़े गए हैं। के लिए
उदाहरण के लिए, 5 के बैकअप_काउंट और "app.log" के बेस फ़ाइल नाम के साथ, आपको मिलेगा
"app.log", "app.log.1", "app.log.2", ... से "app.log.5" तक। फ़ाइल लिखी जा रही है
to हमेशा "app.log" होता है - जब यह भर जाता है, तो इसे बंद कर दिया जाता है और इसका नाम बदल दिया जाता है
"app.log.1", और यदि फ़ाइलें "app.log.1", "app.log.2" आदि मौजूद हैं, तो उनका नाम बदल दिया जाता है
से क्रमशः "app.log.2", "app.log.3" आदि।

उदाहरण:

[द्रष्टा: मेरा कार्यक्रम]
सीएमडी = पायथन -एम myapp.server

stdout_stream.class = फ़ाइलस्ट्रीम
stdout_stream.filename = test.log
stdout_stream.time_format = %Y-%m-%d %H:%M:%S
stdout_stream.max_bytes = 1073741824
stdout_stream.backup_count = 5

देखी गईफ़ाइलस्ट्रीम
फ़ाइल का नाम
फ़ाइल पथ जहां लॉग लिखा जाएगा.

समय स्वरूप
स्ट्रेफ़टाइम प्रारूप जिसका उपयोग हर बार टाइमस्टैम्प के साथ उपसर्ग करने के लिए किया जाएगा। द्वारा
डिफ़ॉल्ट वे उपसर्ग नहीं होंगे।

यानी: %Y-%m-%d %H:%M:%S

नोट:
WatchedFileStream लॉग फ़ाइलों को सुनिश्चित करने के लिए बाहरी लॉग रोटेशन टूल पर निर्भर करता है
बहुत बड़े मत बनो. आउटपुट फ़ाइल की निगरानी की जाएगी और यदि इसे कभी हटाया गया है या नहीं
बाहरी लॉग रोटेशन टूल द्वारा ले जाया गया, तो आउटपुट फ़ाइल हैंडल होगा
स्वचालित रूप से पुनः लोड किया गया।

उदाहरण:

[द्रष्टा: मेरा कार्यक्रम]
सीएमडी = पायथन -एम myapp.server

stdout_stream.class = WatchedFileStream
stdout_stream.filename = test.log
stdout_stream.time_format = %Y-%m-%d %H:%M:%S

टाइम्डरोटेटिंगफ़ाइलस्ट्रीम
फ़ाइल का नाम
फ़ाइल पथ जहां लॉग लिखा जाएगा.

बैकअप_गिनती
डिफ़ॉल्ट बैकअप_काउंट द्वारा रखी जाने वाली लॉग फ़ाइलों की संख्या शून्य है।

समय स्वरूप
स्ट्रेफ़टाइम प्रारूप जिसका उपयोग हर बार टाइमस्टैम्प के साथ उपसर्ग करने के लिए किया जाएगा। द्वारा
डिफ़ॉल्ट वे उपसर्ग नहीं होंगे।

यानी: %Y-%m-%d %H:%M:%S

घुमाएँ_कब
अंतराल का प्रकार. संभावित मानों की सूची नीचे है. ध्यान दें कि वे हैं
केस - संवे्दनशील नहीं।

┌───────────┬────────────────────┐
│मान │ अंतराल का प्रकार │
├───────────┼────────────────────┤
│'S' │ सेकंड │
├───────────┼────────────────────┤
│'एम' │ मिनट │
├───────────┼────────────────────┤
│'H' │ घंटे │
├───────────┼────────────────────┤
│'D' │ दिन │
├───────────┼────────────────────┤
│'W0'-'W6' │ कार्यदिवस (0=सोमवार) │
├───────────┼────────────────────┤
│'आधी रात' │ आधी रात को पलटना │
└───────────┴────────────────────┘

घुमाएँ_अंतराल
रोलओवर अंतराल.

नोट:
TimedRotatingFileStream निश्चित समय अंतराल पर लॉगफ़ाइलों को घुमाता है। रोलओवर अंतराल
रोटेट_व्हेन और रोटेट_इंटरवल के संयोजन द्वारा निर्धारित किया जाता है।

उदाहरण:

[द्रष्टा: मेरा कार्यक्रम]
सीएमडी = पायथन -एम myapp.server

stdout_stream.class = TimedRotatingFileStream
stdout_stream.filename = test.log
stdout_stream.time_format = %Y-%m-%d %H:%M:%S
stdout_stream.utc = सत्य
stdout_stream.rotate_when = एच
stdout_stream.rotate_interval = 1

फैंसीस्टडआउटस्ट्रीम
रंग

RSI नाम of an ASCII रंग:

· लाल

· हरा

· पीला

· नीला

· मजेंटा

· सियान

· सफ़ेद

समय स्वरूप
स्ट्रेफ़टाइम प्रारूप जिसके साथ प्रत्येक पंक्ति उपसर्ग की जाएगी।

डिफ़ॉल्ट: %Y-%m-%d %H:%M:%S

उदाहरण:

[द्रष्टा: मेरा कार्यक्रम]
सीएमडी = पायथन -एम myapp.server
stdout_stream.class = FancyStdoutStream
stdout_stream.color = हरा
stdout_stream.time_format = %Y/%m/%d | %H:%M:%S

कमानों
सर्कस के केंद्र में कमांड सिस्टम रहते हैं। circusctl यह सिर्फ एक जीरोएमक्यू क्लाइंट है,
और यदि आवश्यक हो तो आप अपना स्वयं का zmq लिखकर सर्कस सिस्टम को प्रोग्रामेटिक रूप से चला सकते हैं
ग्राहक।

सभी संदेश JSON मैपिंग हैं.

नीचे दिए गए प्रत्येक कमांड के लिए, हम circusctl के साथ एक उपयोग उदाहरण प्रदान करते हैं, साथ ही इनपुट / भी प्रदान करते हैं
आउटपुट zmq संदेश।

सर्कस-सीटीएल आज्ञाओं
· जोड़ना: आदेश/जोड़ें

· दिसंबर: आदेश/decr

· dstats: आदेश/dstats

· मिल: आदेश/प्राप्त करें

· वैश्विक विकल्प: आदेश/वैश्विक विकल्प

· इन्क्र: आदेश/वृद्धि

· आईपीथॉन: आदेश/आईपीथॉन

· सूची: आदेश/सूची

· बात सुनो: आदेश/सुनें

· listsockets: आदेश/सूची सॉकेट

· numprocesses: आदेश/संख्या प्रक्रियाएँ

· संख्या देखने वाले: आदेश/संख्या देखने वाले

· विकल्पों: आदेश/विकल्प

· छोड़ना: आदेश/छोड़ें

· सीमा से अधिक लादना: आदेश/पुनः लोड करें

· पुनः लोड करेंकॉन्फिग: कमांड/रीलोडकॉन्फिग

· पुनः प्रारंभ: आदेश/पुनरारंभ करें

· rm: आदेश/आरएम

· सेट: आदेश/सेट

· संकेत: आदेश/संकेत

· प्रारंभ: आदेश/प्रारंभ

· आँकड़े: आदेश/आँकड़े

· हैसियत: आदेश/स्थिति

· रुकें: आदेश/रोकें

जोड़ना a चौकीदार
यह आदेश एक पर्यवेक्षक को गतिशील रूप से एक मध्यस्थ में जोड़ता है।

ZMQ मैसेज
{
"कमांड": "जोड़ें",
"गुण": {
"cmd": "/पथ/से/कमांडलाइन--विकल्प"
"नाम": "नॉमऑफ़वॉचर"
"तर्क": [],
"विकल्प": {},
"प्रारंभ": गलत
}
}

एक संदेश में 2 गुण होते हैं:

· सीएमडी: एक प्रक्रिया में निष्पादित करने के लिए पूर्ण कमांड लाइन

· तर्क: सरणी, कमांड को दिए गए तर्क (वैकल्पिक)

· नाम: देखने वाले का नाम

· विकल्प: एक देखने वाले के विकल्प

· प्रारंभ: निर्माण के बाद द्रष्टा प्रारंभ करें

प्रतिक्रिया "ठीक" स्थिति लौटाती है।

आदेश line
$ सर्कसक्टल जोड़ें [--प्रारंभ]

ऑप्शंस
· : बनाने वाले पर्यवेक्षक का नाम

· : एक प्रक्रिया में निष्पादित करने के लिए पूर्ण कमांड लाइन

· --प्रारंभ: तुरंत निगरानी शुरू करें

घटती la संख्या of प्रक्रियाओं in a चौकीदार
यह टिप्पणी एक द्रष्टा में प्रक्रियाओं की संख्या को कम कर देती है , 1 जा रहा है
चूक।

ZMQ मैसेज
{
"कमांड": "decr",
"गुण": {
"नाम": " "
"नायब":
"प्रतीक्षा": गलत
}
}

प्रतिक्रिया 'numprocesses' संपत्ति में प्रक्रियाओं की संख्या लौटाती है:

{ "स्थिति": "ठीक", "संख्या प्रक्रियाएँ": , "समय", "टाइमस्टैम्प" }

आदेश line
$ सर्कसक्टल दिसंबर [ ] [--इंतज़ार में]

ऑप्शंस
· : देखने वाले का नाम

· : हटाने के लिए प्रक्रियाओं की संख्या.

सर्कसडी आँकड़े
आप किसी भी समय dstat कमांड से सर्कस के बारे में कुछ आँकड़े प्राप्त कर सकते हैं।

ZMQ मैसेज
सर्कस आँकड़े प्राप्त करने के लिए, बस चलाएँ:

{
"कमांड": "डीस्टैट्स"
}

प्रतिक्रिया संपत्ति "इन्फोस" की मैपिंग लौटाती है जिसमें कुछ प्रक्रिया जानकारी होती है:

{
"जानकारी": {
"बच्चे": [],
"cmdline": "पायथन",
"सीपीयू": 0.1,
"समय": "0:00.41",
"मेम": 0.1,
"mem_info1": "3एम",
"mem_info2": "2G",
"अच्छा": 0,
"पिड": 47864,
"उपयोगकर्ता नाम": "रूट"
},
"स्थिति": "ठीक है",
"समय": 1332265655.897085
}

आदेश लाइन
$ सर्कसक्टल डीस्टैट्स

la मूल्य of विशिष्ट चौकीदार विकल्पों
इस कमांड का उपयोग एक या अधिक वॉचर विकल्पों के वर्तमान मूल्य को क्वेरी करने के लिए किया जा सकता है।

ZMQ मैसेज
{
"कमांड": "प्राप्त करें",
"गुण": {
"कुंजियाँ": ["कुंजी1, "कुंजी2"]
"नाम": "नॉमऑफ़वॉचर"
}
}

एक अनुरोध संदेश में दो गुण होते हैं:

· कुंजियाँ: सूची, विकल्प कुंजियाँ जिनके लिए आप मान प्राप्त करना चाहते हैं

· नाम: देखने वाले का नाम

प्रतिक्रिया वस्तु में एक संपत्ति है विकल्पों जो विकल्प नामों का एक शब्दकोश है और
मूल्यों.

उदाहरण के लिए:

{
"स्थिति": "ठीक है",
"विकल्प": {
"ग्रेसफुल_टाइमआउट": 300,
"send_hup": सच है,
},
समय': 1332202594.754644
}

आदेश line
$सर्कसक्टल प्राप्त करें

la मध्यस्थ विकल्पों
यह आदेश मध्यस्थ विकल्प लौटाता है

ZMQ मैसेज
{
"कमांड": "ग्लोबलऑप्शंस",
"गुण": {
"key1": "val1",
..
}
}

एक संदेश में 2 गुण होते हैं:

· कुंजियाँ: सूची, विकल्प कुंजियाँ जिनके लिए आप मान प्राप्त करना चाहते हैं

प्रतिक्रिया एक ऑब्जेक्ट को कुंजी/मूल्य की सूची वाली संपत्ति "विकल्प" के साथ लौटाती है
सर्कस से लौटा.

उदाहरण के लिए:

{
"स्थिति": "ठीक है",
"विकल्प": {
"चेक_देरी": 1,
...
},
समय': 1332202594.754644
}

आदेश line
$ सर्कस ग्लोबल विकल्प

ऑप्शंस
विकल्प कुंजियाँ हैं:

· समापन बिंदु: नियंत्रक ZMQ समापन बिंदु

· पबसब_एंडपॉइंट: पबसब एंडपॉइंट

· check_delay: दो नियंत्रक बिंदुओं के बीच विलंब

· मल्टीकास्ट_एंडपॉइंट: सर्कस क्लस्टर ऑटो-डिस्कवरी के लिए मल्टीकास्ट एंडपॉइंट

वेतन वृद्धि la संख्या of प्रक्रियाओं in a चौकीदार
यह टिप्पणी एक द्रष्टा में प्रक्रियाओं की संख्या में वृद्धि करती है , 1 जा रहा है
चूक

ZMQ मैसेज
{
"कमांड": "incr",
"गुण": {
"नाम": " ",
"नायब": ,
"प्रतीक्षा": गलत
}
}

प्रतिक्रिया 'numprocesses' संपत्ति में प्रक्रियाओं की संख्या लौटाती है:

{ "स्थिति": "ठीक", "संख्या प्रक्रियाएँ": , "समय", "टाइमस्टैम्प" }

आदेश line
$ सर्कस्टल इंक [ ] [--इंतज़ार में]

ऑप्शंस
· : देखने वाले का नाम.

· : जोड़ने के लिए प्रक्रियाओं की संख्या.

बनाएं खोल में सर्कसडी प्रक्रिया
यह कमांड केवल तभी उपयोगी है जब आपके पास ipython पैकेज स्थापित हो।

आदेश लाइन
$ सर्कसक्टल आईपीथॉन

सूची of पर नजर रखने वालों or प्रक्रियाओं in a चौकीदार
ZMQ मैसेज
सभी दर्शकों की सूची प्राप्त करने के लिए:

{
"कमांड": "सूची",
}

किसी वॉचर में सक्रिय प्रक्रियाओं की सूची प्राप्त करने के लिए:

{
"कमांड": "सूची",
"गुण": {
"नाम": "नामऑफ़वॉचर",
}
}

जवाब में मांगी गई सूची लौटा दी गई। लौटाई गई मैपिंग या तो 'दर्शक' हो सकती है या
अनुरोध के आधार पर 'पिड्स'।

आदेश line
$ सर्कस सूची [ ]

सदस्यता लें सेवा मेरे a चौकीदार घटना
ZMQ
आप किसी भी समय सर्कस कार्यक्रम की सदस्यता ले सकते हैं। जिस पर सर्कस एक PUB/SUB फ़ीड प्रदान करता है
कोई भी ग्राहक सदस्यता ले सकता है. सब्सक्राइबर एंडपॉइंट यूआरआई सर्कस.आईएनआई में सेट है
विन्यास फाइल।

इवेंट पबसब विषय हैं:

· देखने वाला. .काटना: जब किसी प्रक्रिया का लाभ मिलता है

· देखने वाला. .स्पॉन: जब कोई प्रक्रिया उत्पन्न होती है

· देखने वाला. ।मारना: जब कोई प्रक्रिया समाप्त हो जाती है

· देखने वाला. .अद्यतन: जब वॉचर कॉन्फ़िगरेशन अपडेट किया जाता है

· देखने वाला. ।रुकना: जब एक देखने वाले को रोका जाता है

· देखने वाला. ।शुरू: जब एक द्रष्टा शुरू किया जाता है

सभी ईवेंट संदेश एक json संरचना में हैं।

आदेश line
क्लाइंट को घटनाओं को सुनने का एक सरल तरीका प्रदान करने के लिए अद्यतन किया गया है:

सर्कसक्टल सुनो [ , ...]

उदाहरण of परिणाम:
$ सर्कसक्टल सुनें टीसीपी://127.0.0.1:5556
watcher.refuge.spawn: {u'process_id': 6, u'process_pid': 72976,
यू'टाइम': 1331681080.985104}
watcher.refuge.spawn: {u'process_id': 7, u'process_pid': 72995,
यू'टाइम': 1331681086.208542}
watcher.refuge.spawn: {u'process_id': 8, u'process_pid': 73014,
यू'टाइम': 1331681091.427005}

la सूची of कुर्सियां
ZMQ मैसेज
सॉकेट की सूची प्राप्त करने के लिए:

{
"कमांड": "लिस्टसॉकेट",
}

प्रतिक्रिया एफडी, नाम, होस्ट और पोर्ट के लिए कुंजी के साथ जेसन मैपिंग की एक सूची लौटाती है।

आदेश line
$ सर्कसक्टल लिस्टसॉकेट

la संख्या of प्रक्रियाओं
एक द्रष्टा या एक मध्यस्थ में प्रक्रियाओं की संख्या प्राप्त करें

ZMQ मैसेज
{
"कमांड": "संख्या प्रक्रियाएँ",
"गुण": {
"नाम": " "
}

}

प्रतिक्रिया 'numprocesses' संपत्ति में प्रक्रियाओं की संख्या लौटाती है:

{ "स्थिति": "ठीक", "संख्या प्रक्रियाएँ": , "समय", "टाइमस्टैम्प" }

यदि संपत्ति का नाम निर्दिष्ट नहीं है, तो प्रबंधित सभी प्रक्रियाओं का योग वापस कर दिया जाता है।

आदेश line
$ सर्कससीटीएल संख्याप्रक्रियाएं [ ]

ऑप्शंस
· : देखने वाले का नाम

la संख्या of पर नजर रखने वालों
एक मध्यस्थ में देखने वालों की संख्या प्राप्त करें

ZMQ मैसेज
{
"कमांड": "न्यूमवॉचर्स",
}

प्रतिक्रिया 'numwatchers' संपत्ति में दर्शकों की संख्या लौटाती है:

{ "स्थिति": "ठीक है", "संख्या देखने वाले": , "समय", "टाइमस्टैम्प" }

आदेश line
$ सर्कस संख्या देखने वाले

la मूल्य of सब विकल्पों एसटी a चौकीदार
यह आदेश किसी दिए गए पर्यवेक्षक के लिए सभी विकल्प मान लौटाता है।

ZMQ मैसेज
{
"कमांड": "विकल्प",
"गुण": {
"नाम": "नामऑफ़वॉचर",
}
}

एक संदेश में 1 गुण होता है:

· नाम: देखने वाले का नाम

प्रतिक्रिया वस्तु में एक संपत्ति है विकल्पों जो विकल्प नामों का एक शब्दकोश है और
मूल्यों.

उदाहरण के लिए:

{
"स्थिति": "ठीक है",
"विकल्प": {
"ग्रेसफुल_टाइमआउट": 300,
"send_hup": सच है,
...
},
समय': 1332202594.754644
}

आदेश line
$ सर्कसक्टल विकल्प

ऑप्शंस
· : देखने वाले का नाम

विकल्प कुंजियाँ हैं:

· संख्याप्रक्रियाएँ: पूर्णांक, प्रक्रियाओं की संख्या

· वार्मअप_देरी: पूर्णांक या संख्या, सेकंड में प्रक्रिया स्पॉनिंग के बीच प्रतीक्षा करने में देरी

·working_dir: स्ट्रिंग, निर्देशिका जहां प्रक्रिया निष्पादित की जाएगी

· यूआईडी: स्ट्रिंग या पूर्णांक, प्रक्रिया शुरू करने के लिए उपयोग की जाने वाली उपयोगकर्ता आईडी

· gid: स्ट्रिंग या पूर्णांक, समूह आईडी प्रक्रिया को लॉन्च करने के लिए उपयोग की जाती है

· सेंड_हप: बूलियन, यदि टीआरयू सिग्नल एचयूपी का उपयोग पुनः लोड करने पर किया जाएगा

· शेल: बूलियन, यदि सत्य है तो शेल वातावरण में कमांड चलाएगा

· सीएमडी: स्ट्रिंग, प्रक्रिया शुरू करने के लिए उपयोग की जाने वाली कमांड लाइन

· env: ऑब्जेक्ट, उस वातावरण को परिभाषित करें जिसमें प्रक्रिया लॉन्च की जाएगी

· पुनः प्रयास करें: पूर्णांक या संख्या, सेकंड में समय हम लॉन्च करने के लिए पुनः प्रयास करने से पहले प्रतीक्षा करते हैं
यदि प्रयासों की अधिकतम संख्या पहुंच गई है तो प्रक्रिया करें।

· max_retry: पूर्णांक, पुनर्प्रयास लूप की अधिकतम संख्या

· ग्रेसफुल_टाइमआउट: पूर्णांक या संख्या, वह समय जब हम निश्चित रूप से किसी प्रक्रिया को ख़त्म करने से पहले प्रतीक्षा करते हैं।

· प्राथमिकता: मध्यस्थ में दर्शकों को क्रमबद्ध करने के लिए उपयोग किया जाता है

· सिंगलटन: यदि सच है, तो सिंगलटन पर नजर रखने वाला।

· अधिकतम आयु: वह समय जब कोई प्रक्रिया पुनरारंभ होने से पहले रह सकती है

· max_age_variance: रहने के लिए परिवर्तनीय अतिरिक्त समय, भीड़भाड़ वाले झुंड से बचा जाता है।

छोड़ना la मध्यस्थ तुरंत
जब मध्यस्थ को यह आदेश प्राप्त होता है, तो मध्यस्थ बाहर निकल जाता है।

ZMQ मैसेज
{
"आदेश": "छोड़ें",
"प्रतीक्षा": गलत
}

प्रतिक्रिया स्थिति "ठीक" लौटाती है।

If प्रतीक्षा गलत है (डिफ़ॉल्ट), कॉल करने के तुरंत बाद कॉल वापस आ जाएगी stop_signal
प्रत्येक प्रक्रिया पर.

If प्रतीक्षा सत्य है, कॉल तभी वापस आएगी जब स्टॉप प्रक्रिया पूरी तरह समाप्त हो जाएगी।
ग्रेसफुल_टाइमआउट विकल्प के कारण, इसमें कुछ समय लग सकता है।

आदेश line
$ सर्कस छोड़ो [--प्रतीक्षा]

सीमा से अधिक लादना la मध्यस्थ or a चौकीदार
यह कमांड एक वॉचर या सभी वॉचर्स में सभी प्रक्रियाओं को पुनः लोड करता है। ये एक में होगा
3 तरीकों में से:

· यदि ग्रेसफुल गलत है, तो एक सरल पुनरारंभ होता है।

· अगर भेजें_हप देखने वाले के लिए सच है, प्रत्येक प्रक्रिया के लिए एक HUP सिग्नल भेजा जाता है।

·

अन्यथा:

· यदि अनुक्रमिक गलत है, तो मध्यस्थ उत्पन्न करने का प्रयास करेगा numprocesses नई
प्रक्रियाएँ। यदि नई प्रक्रियाएँ सफलतापूर्वक उत्पन्न होती हैं, तो परिणाम वही होता है
सभी पुरानी प्रक्रियाएँ रोक दी गई हैं, क्योंकि डिफ़ॉल्ट रूप से सबसे पुरानी प्रक्रियाएँ बंद हैं
तब रुक जाता है जब एक दर्शक के लिए प्रक्रियाओं की वास्तविक संख्या इससे अधिक हो जाती है
numprocesses.

· यदि अनुक्रमिक सत्य है, तो मध्यस्थ प्रत्येक प्रक्रिया को अनुक्रमिक रूप से पुनः आरंभ करेगा
रास्ता (ए के साथ) वार्मअप_देरी प्रत्येक चरण के बीच रुकें)

ZMQ मैसेज
{
"कमांड": "पुनः लोड करें",
"गुण": {
"नाम": ' ",
"सुंदर": सच,
"अनुक्रमिक": गलत,
"प्रतीक्षा": गलत
}
}

प्रतिक्रिया स्थिति "ठीक" लौटाती है। यदि प्रॉपर्टी ग्रेसफुल को प्रक्रियाओं को सत्य पर सेट किया गया है
शालीनता से बाहर निकल जाएंगे.

यदि संपत्ति का नाम मौजूद है, तो पुनः लोड देखने वाले पर लागू किया जाएगा।

आदेश line
$ सर्कसक्टल पुनः लोड करें [ ] [--समाप्त] [--प्रतीक्षा]
[--अनुक्रमिक]

ऑप्शंस
· : देखने वाले का नाम

· --समाप्त करें; नोड को तुरंत छोड़ें

सीमा से अधिक लादना la विन्यास पट्टिका
यह कमांड कॉन्फ़िगरेशन फ़ाइल को पुनः लोड करता है, इसलिए कॉन्फ़िगरेशन फ़ाइल में परिवर्तन होंगे
सर्कस के विन्यास में परिलक्षित होता है।

ZMQ मैसेज
{
"कमांड": "रीलोडकॉन्फिग",
"प्रतीक्षा": गलत
}

प्रतिक्रिया स्थिति "ठीक" लौटाती है। यदि प्रॉपर्टी ग्रेसफुल को प्रक्रियाओं को सत्य पर सेट किया गया है
शालीनता से बाहर निकल जाएंगे.

आदेश line
$ सर्कसक्टल रीलोडकॉन्फिग [--प्रतीक्षा]

पुनः प्रारंभ la मध्यस्थ or a चौकीदार
यह आदेश एक द्रष्टा या सभी द्रष्टाओं में सभी प्रक्रियाओं को पुनः आरंभ करता है। यह कार्य सरलता से होता है
किसी दर्शक को रोकें और फिर उसे पुनः आरंभ करें।

ZMQ मैसेज
{
"कमांड": "पुनः आरंभ करें",
"गुण": {
"नाम": " ",
"प्रतीक्षा": गलत,
"मिलान": "[सरल|ग्लोब|रेगेक्स]"
}
}

प्रतिक्रिया स्थिति "ठीक" लौटाती है।

यदि संपत्ति का नाम मौजूद है, तो पुनः लोड देखने वाले पर लागू किया जाएगा।

If प्रतीक्षा गलत है (डिफ़ॉल्ट), कॉल करने के तुरंत बाद कॉल वापस आ जाएगी stop_signal
प्रत्येक प्रक्रिया पर.

If प्रतीक्षा सत्य है, कॉल तभी वापस आएगी जब पुनरारंभ प्रक्रिया पूरी तरह से पूरी हो जाएगी
समाप्त. ग्रेसफुल_टाइमआउट विकल्प के कारण, इसमें कुछ समय लग सकता है।

RSI मैच पैरामीटर का मान हो सकता है सरल स्ट्रिंग तुलना के लिए, ग्लोब वाइल्डकार्ड के लिए
मिलान (डिफ़ॉल्ट) या regex रेगेक्स मिलान के लिए।

आदेश line
$ सर्कससीटीएल पुनरारंभ [नाम] [--प्रतीक्षा] [--मैच=सरल|ग्लोब|रेगेक्स]

ऑप्शंस
· : देखने वाले का नाम या पैटर्न

· : द्रष्टा मिलान विधि

हटाना a चौकीदार
यह आदेश एक द्रष्टा को मध्यस्थ से गतिशील रूप से हटा देता है। देखने वाले शालीन हैं
डिफ़ॉल्ट रूप से बंद कर दिया गया.

ZMQ मैसेज
{
"कमांड": "आरएम",
"गुण": {
"नाम": " ",
"नोस्टॉप": गलत,
"प्रतीक्षा": गलत
}
}

प्रतिक्रिया "ठीक" स्थिति लौटाती है।

If कोई रोक नहिं सत्य है (डिफ़ॉल्ट: ग़लत), देखने वाले के लिए प्रक्रियाएं बंद नहीं की जाएंगी -
इसके बजाय सर्कस द्वारा दर्शक को भुला दिया जाएगा और देखने वाली प्रक्रियाएँ समाप्त हो जाएँगी
खुद को रोकने के लिए जिम्मेदार. अगर कोई रोक नहिं निर्दिष्ट नहीं है या ग़लत है, तो
वॉचर प्रक्रियाओं को इनायत से रोक दिया जाएगा।

If प्रतीक्षा गलत है (डिफ़ॉल्ट), कॉल हटाना शुरू करने के तुरंत बाद वापस आ जाएगी
और संबंधित द्रष्टा को रोकें।

If प्रतीक्षा सत्य है, कॉल केवल तभी वापस आएगी जब हटाने और रोकने की प्रक्रिया होगी
पूर्णतः समाप्त। ग्रेसफुल_टाइमआउट विकल्प के कारण, इसमें कुछ समय लग सकता है।

आदेश line
$ सर्कसक्टल आरएम [--प्रतीक्षा] [-नोस्टॉप]

ऑप्शंस
· : हटाने के लिए देखने वाले का नाम

· नोस्टॉप: द्रष्टा प्रक्रियाओं को रोकें नहीं, बस द्रष्टा को हटा दें

सेट a चौकीदार विकल्प
ZMQ मैसेज
{
"कमांड": "सेट",
"गुण": {
"नाम": "नामऑफ़वॉचर",
"विकल्प": {
"key1": "val1",
..
}
"प्रतीक्षा": गलत
}
}

प्रतिक्रिया स्थिति "ठीक" लौटाती है। सेट की जाने वाली कुंजी की सूची के लिए कमांड विकल्प देखें।

आदेश line
$ सर्कससीटीएल सेट --इंतज़ार में

भेजें a संकेत
यह कमांड आपको एक वॉचर, एक विशिष्ट प्रक्रिया में सभी प्रक्रियाओं के लिए सिग्नल भेजने की अनुमति देता है
एक द्रष्टा या उसके बच्चों में.

ZMQ मैसेज
एक दर्शक के लिए सभी प्रक्रियाओं को संकेत भेजने के लिए:

{
"कमांड": "सिग्नल",
"संपत्ति": {
"नाम": ,
"हस्ताक्षर":
}

किसी प्रक्रिया को सिग्नल भेजने के लिए:

{
"कमांड": "सिग्नल",
"संपत्ति": {
"नाम": ,
"पिड": ,
"हस्ताक्षर":
}

सभी बच्चों को सिग्नल भेजने के लिए एक वैकल्पिक संपत्ति "चिल्ड्रेन" का उपयोग किया जा सकता है
प्रक्रिया से ही:

{
"कमांड": "सिग्नल",
"संपत्ति": {
"नाम": ,
"पिड": ,
"हस्ताक्षर": ,
"बच्चे": सच है
}

किसी प्रोसेस चाइल्ड को सिग्नल भेजने के लिए:

{
"कमांड": "सिग्नल",
"संपत्ति": {
"नाम": ,
"पिड": ,
"हस्ताक्षर": ,
"child_pid": ,
}

द्रष्टा के सभी बच्चों को संकेत भेजना भी संभव है:

{
"कमांड": "सिग्नल",
"संपत्ति": {
"नाम": ,
"हस्ताक्षर": ,
"बच्चे": सच है
}

अंत में, आप प्रक्रिया को एक संकेत भेज सकते हैं और इसके बच्चे, के साथ पुनरावर्ती विकल्प:

{
"कमांड": "सिग्नल",
"संपत्ति": {
"नाम": ,
"हस्ताक्षर": ,
"पुनरावर्ती": सत्य
}

आदेश line
$ सर्कसक्टल सिग्नल [ ] [--बच्चे]
[--पुनरावर्ती]

विकल्प:
· : देखने वाले का नाम

· : पूर्णांक, प्रक्रिया आईडी।

· : भेजने के लिए सिग्नल नंबर (या नाम)।

· : किसी बच्चे का नाम, यदि कोई हो

· : बूलियन, सभी बच्चों को संकेत भेजें

· : बूलियन, प्रक्रिया और उसके बच्चों को संकेत भेजें

प्रारंभ la मध्यस्थ or a चौकीदार
यह आदेश एक द्रष्टा या सभी द्रष्टाओं में सभी प्रक्रियाओं को प्रारंभ करता है।

ZMQ मैसेज
{
"कमांड": "प्रारंभ",
"गुण": {
"नाम": ' ",
"प्रतीक्षा": गलत,
"मिलान": "[सरल|ग्लोब|रेगेक्स]"
}
}

प्रतिक्रिया स्थिति "ठीक" लौटाती है।

यदि संपत्ति का नाम मौजूद है, तो निगरानी शुरू कर दी जाएगी।

If प्रतीक्षा गलत है (डिफ़ॉल्ट), कॉल करने के तुरंत बाद कॉल वापस आ जाएगी प्रारंभ on
प्रत्येक प्रक्रिया.

If प्रतीक्षा सत्य है, कॉल तभी वापस आएगी जब प्रारंभ प्रक्रिया पूरी तरह समाप्त हो जाएगी।
ग्रेसफुल_टाइमआउट विकल्प के कारण, इसमें कुछ समय लग सकता है।

RSI मैच पैरामीटर का मान हो सकता है सरल स्ट्रिंग तुलना के लिए, ग्लोब वाइल्डकार्ड के लिए
मिलान (डिफ़ॉल्ट) या regex रेगेक्स मिलान के लिए।

आदेश line
$ सर्कससीटीएल पुनरारंभ [नाम] [--प्रतीक्षा] [--मैच=सरल|ग्लोब|रेगेक्स]

ऑप्शंस
· : देखने वाले का नाम या पैटर्न

· : द्रष्टा मिलान विधि

प्रक्रिया सूचना
आप किसी भी समय स्टेट कमांड से अपनी प्रक्रियाओं के बारे में कुछ आँकड़े प्राप्त कर सकते हैं।

ZMQ मैसेज
सभी दर्शकों के आँकड़े प्राप्त करने के लिए:

{
"कमांड": "आँकड़े"
}

किसी दर्शक के लिए आँकड़े प्राप्त करने के लिए:

{
"कमांड": "आँकड़े",
"गुण": {
"नाम":
}
}

किसी प्रक्रिया के आँकड़े प्राप्त करने के लिए:

{
"कमांड": "आँकड़े",
"गुण": {
"नाम": ,
"प्रक्रिया":
}
}

आँकड़ों को एक्सटेंडेड_स्टैट्स हुक के साथ बढ़ाया जा सकता है लेकिन विस्तारित आँकड़ों की आवश्यकता है
का अनुरोध किया:

{
"कमांड": "आँकड़े",
"गुण": {
"नाम": ,
"प्रक्रिया": ,
"विस्तारित": सत्य
}
}

प्रतिक्रिया किसी वस्तु को प्रति प्रक्रिया संपत्ति "जानकारी" के साथ पुनः ट्यून करती है जिसमें कुछ प्रक्रिया होती है
जानकारी:

{
"जानकारी": {
"बच्चे": [],
"cmdline": "पायथन",
"सीपीयू": 0.1,
"समय": "0:00.41",
"मेम": 0.1,
"mem_info1": "3एम",
"mem_info2": "2G",
"अच्छा": 0,
"पिड": 47864,
"उपयोगकर्ता नाम": "रूट"
},
"प्रक्रिया": 5,
"स्थिति": "ठीक है",
"समय": 1332265655.897085
}

आदेश लाइन
$ सर्कस आँकड़े [--विस्तारित] [ ] [ ]

la हैसियत of a चौकीदार or सब पर नजर रखने वालों
इस आदेश से एक द्रष्टा या सभी द्रष्टा का दर्जा मिलना शुरू हो जाता है।

ZMQ मैसेज
{
"कमांड": "स्थिति",
"गुण": {
"नाम": ' ",
}
}

प्रतिक्रिया स्थिति "सक्रिय" या "बंद" या स्थिति/निगरानीकर्ता लौटाती है।

आदेश line
$ सर्कस स्थिति [ ]

ऑप्शंस
· : देखने वाले का नाम

उदाहरण
$ सर्कस स्टेटस डमी
सक्रिय
$ सर्कस स्थिति
डमी: सक्रिय
डमी2: सक्रिय
शरण: सक्रिय

रुकें पर नजर रखने वालों
यह आदेश किसी दिए गए पर्यवेक्षक या सभी दर्शकों को रोक देता है।

ZMQ मैसेज
{
"आदेश": "रुकें",
"गुण": {
"नाम": " ",
"प्रतीक्षा": गलत,
"मिलान": "[सरल|ग्लोब|रेगेक्स]"
}
}

प्रतिक्रिया स्थिति "ठीक" लौटाती है।

अगर नाम संपत्ति मौजूद है तो देखने वाले पर रोक लगा दी जाएगी
उस नाम के अनुरूप. नहीं तो सभी देखने वाले बंद हो जायेंगे.

If प्रतीक्षा गलत है (डिफ़ॉल्ट), कॉल करने के तुरंत बाद कॉल वापस आ जाएगी stop_signal
प्रत्येक प्रक्रिया पर.

If प्रतीक्षा सत्य है, कॉल तभी वापस आएगी जब स्टॉप प्रक्रिया पूरी तरह समाप्त हो जाएगी।
ग्रेसफुल_टाइमआउट विकल्प के कारण, इसमें कुछ समय लग सकता है।

RSI मैच पैरामीटर का मान हो सकता है सरल स्ट्रिंग तुलना के लिए, ग्लोब वाइल्डकार्ड के लिए
मिलान (डिफ़ॉल्ट) या regex रेगेक्स मिलान के लिए।

आदेश line
$ सर्कससीटीएल स्टॉप [नाम] [--प्रतीक्षा] [--मैच=सरल|ग्लोब|रेगेक्स]

ऑप्शंस
· : देखने वाले का नाम या पैटर्न

· : द्रष्टा मिलान विधि

सीएलआई उपकरण
सर्कस-टॉप
सर्कस-टॉप यह एक शीर्ष जैसा कंसोल है जिसे आप अपने चल रहे सर्कस सिस्टम को लाइव देखने के लिए चला सकते हैं। यह
यदि आपके पास कुछ है तो सीपीयू, मेमोरी उपयोग और सॉकेट हिट प्रदर्शित करेगा।

आउटपुट का उदाहरण:

-------------------------------------------------- ---------------------
सर्कस-आँकड़े
पीआईडी ​​सीपीयू (%) मेमोरी (%)
14252 0.8 0.4
0.8 (औसत) 0.4 (योग)

नकली
पीआईडी ​​सीपीयू (%) मेमोरी (%)
14257 78.6 0.1
14256 76.6 0.1
14258 74.3 0.1
14260 71.4 0.1
14259 70.7 0.1
74.32 (औसत) 0.5 (योग)

-------------------------------------------------- --------------------

सर्कस-टॉप केवल पढ़ने योग्य कंसोल है। यदि आप सिस्टम के साथ इंटरैक्ट करना चाहते हैं, तो उपयोग करें circusctl.

circusctl
circusctl कमांड में सूचीबद्ध किसी भी कमांड को चलाने के लिए उपयोग किया जा सकता है। उदाहरण के लिए, आप एक प्राप्त कर सकते हैं
सभी दर्शकों की सूची, आप कर सकते हैं

$ सर्कस सूची

मुट्ठी भर विकल्पों का समर्थन करने के अलावा आप समापन बिंदु भी निर्दिष्ट कर सकते हैं circusctl चाहिए
का उपयोग करके उपयोग करें CIRCUSCTL_ENDPOINT वातावरण विविधता।

RSI वेब कंसोल
सर्कस एक वेब कंसोल के साथ आता है जिसका उपयोग सिस्टम को प्रबंधित करने के लिए किया जा सकता है।

वेब कंसोल आपको इसकी सुविधा देता है:

· किसी भी चल रहे सर्कस सिस्टम से कनेक्ट करें

· वास्तविक समय में सीपीयू और मेमोरी उपयोग की प्रक्रियाओं को देखें

· प्रक्रियाओं को जोड़ें या समाप्त करें

· नए दर्शक जोड़ें

नोट:
वास्तविक समय सीपीयू और मेमोरी उपयोग सुविधा सांख्यिकी सॉकेट का उपयोग करती है। यदि आप चाहते हैं
इसे सक्रिय करें, सुनिश्चित करें कि आप जिस सर्कस सिस्टम से कनेक्ट होंगे उसमें आँकड़े निर्दिष्ट हैं
इसके कॉन्फ़िगरेशन में सक्षम:

[सर्कस]
आँकड़े = सत्य

डिफ़ॉल्ट रूप से, यह विकल्प सक्रिय नहीं है.

वेब कंसोल का अपना पैकेज है, आपको इंस्टॉल करना होगा:

$ पिप इंस्टॉल सर्कस-वेब

कंसोल को सक्षम करने के लिए, सर्कस आईएनआई फ़ाइल में कुछ विकल्प जोड़ें:

[सर्कस]
httpd = सत्य
httpd_host = लोकलहोस्ट
httpd_port = 8080

httpd_host और httpd_port वैकल्पिक हैं, और डिफ़ॉल्ट हैं स्थानीय होस्ट और 8080.

यदि आप वेब ऐप को स्वयं चलाना चाहते हैं, तो बस चलाएँ सर्कसhttpd स्क्रिप्ट:

$ सर्कसhttpd
बोतल सर्वर प्रारंभ हो रहा है...
सुन रहा हूँ http://localhost: 8080 /
छोड़ने के लिए Ctrl-C दबाएँ।

डिफ़ॉल्ट रूप से स्क्रिप्ट वेब कंसोल को पोर्ट 8080 पर चलाएगी, लेकिन --पोर्ट विकल्प चल सकता है
इसे बदल देते थे.

का प्रयोग la एक ढ़ांचा जिस में आंगन की स्वरकुंजियां आदि लगि है
एक बार स्क्रिप्ट चलने के बाद, आप ब्राउज़र खोल सकते हैं और विज़िट कर सकते हैं http://localhost: 8080. आप
यह स्क्रीन मिलनी चाहिए: [छवि]

वेब कंसोल, सर्कस सिस्टम से कनेक्ट होने के लिए तैयार है समापन बिंदु। द्वारा
डिफ़ॉल्ट समापनबिंदु है टीसीपी://127.0.0.1:5555.

एक बार जब आप हिट जुड़ें, वेब एप्लिकेशन सर्कस सिस्टम से कनेक्ट हो जाएगा।

वेब कंसोल में लॉग इन करने पर, आपको दर्शकों की एक सूची और वास्तविक समय की स्थिति मिलनी चाहिए
दो सर्कस प्रक्रियाओं (सर्कसड और सर्कसड-आँकड़े) में से।

आप इसे टॉगल करने के लिए प्रत्येक दर्शक की स्थिति पर क्लिक कर सकते हैं सक्रिय (हरा) को निष्क्रिय
(लाल)। यह परिवर्तन तुरंत प्रभावी है और आपको दर्शकों को शुरू करने और रोकने की सुविधा देता है।

यदि आप देखने वाले के नाम पर क्लिक करते हैं, तो आपको उस विशेष दर्शक के लिए एक वेब पेज मिलेगा,
इसकी प्रक्रियाओं के साथ:

इस स्क्रीन पर, आप प्रक्रियाओं को जोड़ या हटा सकते हैं, और मौजूदा प्रक्रियाओं को समाप्त कर सकते हैं।

अंतिम लेकिन महत्वपूर्ण बात, आप पर क्लिक करके एक बिल्कुल नया वॉचर जोड़ सकते हैं जोड़ना चौकीदार लिंक करें
बायां मेनू: .SS Nginx के पीछे चल रहा है

Nginx सर्कस-वेब के सामने प्रॉक्सी और सुरक्षा परत के रूप में कार्य कर सकता है।

नोट:
सर्कस-वेब में वास्तविक समय स्थिति अपडेट और ग्राफ़ प्राप्त करने के लिए, आपको एक Nginx प्रदान करना होगा
प्रॉक्सी समाधान जिसमें वेबसोकेट समर्थन है

nginx >= 1.3.13
चूंकि Nginx>=1.3.13 वेबसॉकेट समर्थन अंतर्निहित है, इसलिए Nginx को संयोजित करने की कोई आवश्यकता नहीं है
वार्निश या HAProxy के साथ। वेबसॉकेट समर्थन के साथ Nginx कॉन्फ़िगरेशन का एक उदाहरण:

अपस्ट्रीम सर्कसवेब_सर्वर {
सर्वर 127.0.0.1:8080;
}

सर्वर {
80 सुनें;
सर्वर का नाम _;

स्थान / {
प्रॉक्सी_पास http://circusweb_server;
प्रॉक्सी_http_संस्करण 1.1;
प्रॉक्सी_सेट_हेडर अपग्रेड $http_upgrade;
प्रॉक्सी_सेट_हेडर कनेक्शन "अपग्रेड";
प्रॉक्सी_सेट_हेडर होस्ट $ होस्ट;
प्रॉक्सी_सेट_हेडर एक्स-रियल-आईपी $remote_addr;
proxy_set_header
प्रॉक्सी_सेट_हेडर एक्स-फॉरवर्डेड-प्रोटो http;
प्रॉक्सी_रीडायरेक्ट बंद;
}

स्थान ~/मीडिया/\*(.png|.jpg|.css|.js|.ico)$ {
उपनाम /path_to_site-packages/circusweb/media/;
}
}

nginx < 1.3.13
Nginx संस्करण <1.3.13 में वेबसॉकेट समर्थन अंतर्निहित नहीं है।

Nginx <1.3.13 का उपयोग करते समय सर्कस-वेब के लिए वेबसोकेट समर्थन प्रदान करने के लिए, आप संयोजन कर सकते हैं
वार्निश या HAProxy के साथ Nginx। यानी, सर्कस-वेब के सामने नेग्नेक्स, वार्निश के साथ या
Nginx के सामने HAProxy।

नीचे दिया गया उदाहरण प्रॉक्सी के लिए आवश्यक संयुक्त Nginix और वार्निश कॉन्फ़िगरेशन दिखाता है
सर्कस-वेब और वेबसॉकेट समर्थन प्रदान करें।

nginx विन्यास:

अपस्ट्रीम सर्कसवेब_सर्वर {
सर्वर 127.0.0.1:8080;
}

सर्वर {
8001 सुनें;
सर्वर का नाम _;

स्थान / {
proxy_set_header
प्रॉक्सी_सेट_हेडर होस्ट $http_host;
प्रॉक्सी_रीडायरेक्ट बंद;
प्रॉक्सी_पास http://circusweb_server;
}

स्थान ~/मीडिया/\*(.png|.jpg|.css|.js|.ico)$ {
उपनाम /path_to_site-packages/circusweb/media/;
}
}

यदि आप अधिक Nginx कॉन्फ़िगरेशन विकल्प चाहते हैं, तो देखें http://wiki.nginx.org/HttpProxyModule.

वार्निश विन्यास:

बैकएंड डिफ़ॉल्ट {
.होस्ट = "127.0.0.1";
.पोर्ट = "8001";
}

बैकएंड सॉकेट {
.होस्ट = "127.0.0.1";
.पोर्ट = "8080";
.connect_timeout = 1s;
.first_byte_timeout = 2s;
.between_bytes_timeout = 60s;
}

उप वीसीएल_पाइप {
यदि (req.http.upgrade) {
सेट bereq.http.upgrade = req.http.upgrade;
}
}

उप vcl_recv {
यदि (req.http.Upgrade ~ "(?i)वेबसॉकेट") {
सेट req.backend = सॉकेट;
वापसी (पाइप);
}
}

उपरोक्त वार्निश कॉन्फ़िगरेशन उदाहरण में दो बैकएंड परिभाषित हैं। एक वेब परोस रहा है
कंसोल और सॉकेट कनेक्शन परोसने वाला एक। वेब कंसोल अनुरोध पोर्ट के लिए बाध्य हैं
8001. Nginx 'सर्वर' निर्देश को पोर्ट 8001 पर सुनने के लिए कॉन्फ़िगर किया जाना चाहिए।

वेबसॉकेट कनेक्शन को अपग्रेड किया जाता है और सीधे सर्कसएचटीपीडी प्रक्रिया सुनने के लिए पाइप किया जाता है
वार्निश द्वारा पोर्ट 8080 पर। यानी Nginx प्रॉक्सी को बायपास करना।

Ubuntu
संस्करण 13.10 के बाद से (सजीव), उबंटू में वेबसॉकेट समर्थन के साथ Nginx शामिल है
भंडार। पुराने संस्करणों के लिए, आप आधिकारिक Nginx से Nginx>=1.3.13 इंस्टॉल कर सकते हैं
स्थिर पीपीए, इस प्रकार:

sudo apt-get install पायथन-सॉफ़्टवेयर-प्रॉपर्टीज़
sudo add-apt-repository ppa:nginx/stable
उपयुक्त sudo- मिल अद्यतन
sudo apt-get nginx स्थापित करें
nginx -v

पासवर्ड-सुरक्षित सर्कसhttpd
जैसा कि सुरक्षा पृष्ठ में बताया गया है, चल रहा है सर्कसhttpd काफी असुरक्षित है. हम उपलब्ध नहीं कराते
सर्कस में ही कोई भी सुरक्षा, लेकिन आप अपने कंसोल को NGinx स्तर पर सुरक्षित कर सकते हैं
का उपयोग http://wiki.nginx.org/HttpAuthBasicModule

उदाहरण:

स्थान / {
proxy_set_header
प्रॉक्सी_सेट_हेडर होस्ट $http_host;
प्रॉक्सी_सेट_हेडर एक्स-फॉरवर्डेड-होस्ट: $http_host;
प्रॉक्सी_सेट_हेडर एक्स-फॉरवर्डेड-प्रोटो: $स्कीम;
प्रॉक्सी_रीडायरेक्ट बंद;
प्रॉक्सी_पास http://127.0.0.1:8080 XNUMX;
auth_basic "प्रतिबंधित";
auth_basic_user_file /path/to/htpasswd;
}

RSI htpasswd फ़ाइल में उपयोगकर्ता और उनके पासवर्ड शामिल हैं, और एक पासवर्ड प्रॉम्प्ट तब पॉप होगा
आप कंसोल तक पहुंचें.

आप इसे संपादित करने के लिए अपाचे की htpasswd स्क्रिप्ट, या उनके द्वारा प्रदान की गई पायथन स्क्रिप्ट का उपयोग कर सकते हैं:
http://trac.edgewall.org/browser/trunk/contrib/htpasswd.py

हालाँकि, HTTP प्रमाणीकरण के संयुक्त उपयोग के लिए कोई मूल समर्थन नहीं है
WebSockets (सर्वर HTTP 401 त्रुटि कोड फेंक देगा)। इसका समाधान यह है कि इसे अक्षम कर दिया जाए
सॉकेट.आईओ सर्वर के लिए प्रमाणीकरण।

उदाहरण (पिछले नियम से पहले जोड़ने की आवश्यकता है):

स्थान /सॉकेट.आईओ {
proxy_set_header
प्रॉक्सी_सेट_हेडर होस्ट $http_host;
प्रॉक्सी_सेट_हेडर एक्स-फॉरवर्डेड-होस्ट: $http_host;
प्रॉक्सी_सेट_हेडर एक्स-फॉरवर्डेड-प्रोटो: $स्कीम;
प्रॉक्सी_रीडायरेक्ट बंद;
प्रॉक्सी_पास http://127.0.0.1:8080 XNUMX;
}

बेशक यह आपके वेब कंसोल को सुरक्षित रखने का सिर्फ एक तरीका है, आप कई अन्य तरीकों का भी उपयोग कर सकते हैं
तकनीक।

विस्तार la वेब एक ढ़ांचा जिस में आंगन की स्वरकुंजियां आदि लगि है
हमने चुना बोतल वेबकंसोल बनाने के लिए, मुख्यतः क्योंकि यह वास्तव में एक छोटा ढांचा है
बहुत कुछ नहीं करता. वेब कंसोल के कोड पर एक नज़र डालने पर, आपको अंततः पता चल जाएगा
इसे समझना वास्तव में सरल है।

यहां बताया गया है कि यह कैसे विभाजित है:

· circushttpd.py फ़ाइल में "दृश्य" परिभाषाएँ और इसे संभालने के लिए कुछ कोड शामिल हैं
सॉकेट कनेक्शन (सॉकेटियो के माध्यम से)।

· NS कंट्रोलर.py इसमें एक एकल वर्ग शामिल है जो संचार करने का प्रभारी है
सर्कस नियंत्रक के साथ. परिभाषित करते समय यह एक बेहतर उच्च स्तरीय एपीआई की अनुमति देता है
वेब सर्वर।

यदि आप वेब कंसोल में कोई सुविधा जोड़ना चाहते हैं तो आप मौजूदा कोड का पुन: उपयोग कर सकते हैं। ए
प्रक्रिया को आसान बनाने के लिए कुछ उपकरण आपके पास उपलब्ध हैं:

· वहां एक है रेंडर_टैम्पलेट फ़ंक्शन, जो आपके द्वारा पास किए गए नामित तर्कों को लेता है और
उन्हें टेम्प्लेट रेंडरर के पास भेजें और परिणामी HTML लौटाएँ। कुछ गुजर भी जाता है
अतिरिक्त चर, जैसे सत्र, सर्कस संस्करण और क्लाइंट यदि परिभाषित हो।

· यदि आप कमांड चलाना चाहते हैं और इसके परिणाम के आधार पर पुनर्निर्देशन करना चाहते हैं, तो आप इसका उपयोग कर सकते हैं
la चलाने के आदेश फ़ंक्शन, जो कॉल करने योग्य को पहले तर्क के रूप में लेता है, मामले में एक संदेश
सफलता की और एक पुनर्निर्देशन यूआरएल।

RSI आँकड़ेनामस्थान क्लास वेबसोकेट संचार के प्रबंधन के लिए जिम्मेदार है
सर्वर साइड। इसके दस्तावेज़ीकरण से आपको यह समझने में मदद मिलेगी कि यह क्या करता है।

काम कर रहे साथ में कुर्सियां
सर्कस नेटवर्क सॉकेट को बांध सकता है और उन्हें प्रबंधित कर सकता है जैसा कि वह प्रक्रियाओं के लिए करता है।

मुख्य विचार यह है कि एक चाइल्ड प्रक्रिया जो सर्कस द्वारा दर्शकों में से एक को चलाने के लिए बनाई गई है
कमांड सभी खोले गए फ़ाइल डिस्क्रिप्टर से प्राप्त हो सकता है।

अपाचे या यूनिकॉर्न इसी तरह काम करते हैं, और कई अन्य उपकरण भी मौजूद हैं।

लक्ष्य
सर्कस द्वारा प्रबंधित सॉकेट का लक्ष्य नेटवर्क अनुप्रयोगों को प्रबंधित करने में सक्षम होना है
सर्कस में बिल्कुल अन्य अनुप्रयोगों की तरह।

उदाहरण के लिए, यदि आप सर्कस का उपयोग करते हैं मौज़ा -- एक WGSI सर्वर, आप बहुत तेज़ गति से प्राप्त कर सकते हैं
वेब सर्वर चलाना और प्रबंधित करना "वेब कर्मी" सर्कस में जैसा कि आप किसी अन्य के लिए करेंगे
प्रक्रिया.

नेटवर्क एप्लिकेशन से सॉकेट प्रबंधन को विभाजित करना स्वयं बहुत कुछ प्रदान करता है
अपने स्टैक को स्केल करने और प्रबंधित करने के अवसर।

डिज़ाइन
फीचर का सार सॉकेट को बाइंड करके और उसमें सुनना शुरू करके किया जाता है
सर्कसडी:

आयात सॉकेट

सॉक = सॉकेट.सॉकेट (परिवार, प्रकार)
सॉक.बाइंड((होस्ट, पोर्ट))
सॉक.सुनें(बैकलॉग)
एफडी = sock.fileno()

सर्कस फिर सभी खोले गए एफडीएस पर नज़र रखता है, और प्रक्रियाओं को बच्चों की तरह चलने देता है
यदि वे चाहें तो उन तक पहुंच है।

यदि आप एक छोटी पायथन नेटवर्क स्क्रिप्ट बनाते हैं जिसे आप सर्कस में चलाने का इरादा रखते हैं, तो यह हो सकता है
ऐसे दिखते हैं:

आयात सॉकेट
आयात sys

fd = int(sys.argv[1]) # सर्कस से FD प्राप्त करना
सॉक = सॉकेट.फ्रॉमएफडी(एफडी, परिवार, प्रकार)

# एक समय में एक अनुरोध से निपटना
जबकि सच:
कॉन, पता = sock.accept()
अनुरोध = conn.recv(1024)
.. कुछ करो ..
conn.sendall(प्रतिक्रिया)
conn.बंद करें()

तब सर्कस इस तरह चल सकता था:

[सर्कस]
चेक_विलंब = 5
समापन बिंदु = टीसीपी://127.0.0.1:5555
pubsub_endpoint = टीसीपी://127.0.0.1:5556
आँकड़े_एंडपॉइंट = टीसीपी: //127.0.0.1:5557

[देखने वाला:डमी]
सीएमडी = मायकूलस्क्रिप्ट $(circus.sockets.foo)
use_sockets = सच
वार्मअप_देरी = 0
संख्याप्रक्रम = 5

[सॉकेट: फू]
होस्ट = 127.0.0.1
पोर्ट = 8888

$(सर्कस.सॉकेट.फू) सॉकेट बनने के बाद एफडी मूल्य को बदल दिया जाएगा
8888 पर बाध्य बंदरगाह.

नोट:
सर्कस 0.8 से शुरू करके कुछ के साथ टकराव से बचने के लिए एक वैकल्पिक वाक्यविन्यास है
कॉन्फिग पार्सर्स। आप लिख सकते हो:

((सर्कस.सॉकेट.फू))

असली दुनिया उदाहरण
मौज़ा यदि आप अपना डब्लूएसजीआई एप्लिकेशन चलाना चाहते हैं तो यह एक आदर्श सर्कस साथी है।

एक बार यह इंस्टॉल हो जाए, 5 चल रहा है मुझे बताया गया श्रमिकों को एक सॉकेट बनाकर किया जा सकता है और
बुला रहा है मौज़ा किसी कार्यकर्ता में आदेश, इस प्रकार:

[सर्कस]
समापन बिंदु = टीसीपी://127.0.0.1:5555
pubsub_endpoint = टीसीपी://127.0.0.1:5556
आँकड़े_एंडपॉइंट = टीसीपी: //127.0.0.1:5557

[द्रष्टा:वेब]
सीएमडी = चौसेट --एफडी $(circus.sockets.web) --बैकएंड में हेल्ड mycool.app
use_sockets = सच
संख्याप्रक्रम = 5

[सॉकेट:वेब]
होस्ट = 0.0.0.0
पोर्ट = 8000

हमने अभी तक बेंचमार्क प्रकाशित नहीं किए हैं, लेकिन सर्कस द्वारा गेवेंट या के साथ प्रबंधित एक वेब क्लस्टर
मीनहेल्ड बैकएंड किसी भी प्री-फोर्क डब्लूएसजीआई सर्वर जितना तेज़ है।

का प्रयोग में निर्मित plugins
सर्कस कुछ अंतर्निर्मित प्लगइन्स के साथ आता है। यह अनुभाग इन प्लगइन्स और उनके प्रस्तुत करता है
कॉन्फ़िगरेशन विकल्प।

कहा गया है
उपयोग 'circus.plugins.statsd.StatsdEmitter' पर सेट करें

आवेदन का नाम
आँकड़ों को उत्सर्जित करने के लिए बकेट उपसर्ग की पहचान करने के लिए उपयोग किया जाने वाला नाम (यह होगा)।
के साथ उपसर्ग सर्कस और इसके साथ जुड़ा हुआ है .देखनेवाला)

मेजबान स्टेट्स डेटा को पोस्ट करने के लिए होस्ट

बंदरगाह वह पोर्ट जिस पर स्टैटिस्टिक्स डेमॉन सुनता है

नमूना दर
यदि आप 1 से भिन्न नमूना दर पसंद करते हैं, तो आप इसे यहां सेट कर सकते हैं

पूर्ण आँकड़े
Statsd प्लगइन पर एक एक्सटेंशन जो प्रक्रिया आँकड़े भी प्रकाशित कर रहा है। ऐसे तो यह
इसमें Statsd और निम्नलिखित के समान कॉन्फ़िगरेशन विकल्प हैं।

उपयोग करने के लिए सेट सर्कस.प्लगइन्स.स्टैट्सडी.फुलस्टैट्स

लूप_रेट
प्लगइन को सेकंड में आँकड़े माँगने की आवृत्ति। डिफ़ॉल्ट: 60.

रेडिसऑब्जर्वर
यह सेवा आपके लिए रेडिस प्रक्रिया का अवलोकन करती है, सूचना को स्टेट्सडी पर प्रकाशित करती है
और जब वॉचर किसी निश्चित टाइमआउट में प्रतिक्रिया नहीं करता है तो उसे पुनः आरंभ करने की पेशकश करता है। यह प्लगइन
की आवश्यकता होती है रेडिस-पीई चलाने के लिए।

इसमें statsd जैसा ही कॉन्फ़िगरेशन है और निम्नलिखित जोड़ता है:

उपयोग करने के लिए सेट सर्कस.प्लगइन्स.रेडिस_ऑब्जर्वर.रेडिसऑब्जर्वर

लूप_रेट
प्लगइन को सेकंड में आँकड़े माँगने की आवृत्ति। डिफ़ॉल्ट: 60.

redis_url
रेडिस यूआरएल के रूप में जांचने के लिए डेटाबेस। डिफ़ॉल्ट: "रेडिस://लोकलहोस्ट:6379/0"

मध्यांतर
अनुरोध पर विचार किए जाने से पहले सेकंड में टाइमआउट हो सकता है।
5 के लिए डिफ़ॉल्ट।

पुनः आरंभ_पर_समयबाह्य
अनुरोध का समय समाप्त होने पर पुनः आरंभ करने की प्रक्रिया का नाम। कोई पुनरारंभ नहीं
नहीं दिए जाने पर चालू हो गया। डिफ़ॉल्ट: कोई नहीं.

Httpऑब्जर्वर
यह सेवा नियमित रूप से एक निश्चित वेबसाइट को पिंग करके आपके लिए http प्रक्रिया का अवलोकन करती है।
रेडिस ऑब्जर्वर के समान यह किसी त्रुटि पर वॉचर को पुनः आरंभ करने की पेशकश करता है। उसकी आवश्यकता हैं
बवंडर चलाने के लिए।

इसमें statsd जैसा ही कॉन्फ़िगरेशन है और निम्नलिखित जोड़ता है:

उपयोग करने के लिए सेट circus.plugins.http_observer.HttpObserver

लूप_रेट
प्लगइन को सेकंड में आँकड़े माँगने की आवृत्ति। डिफ़ॉल्ट: 60.

check_url
जांचने के लिए यूआरएल. गलती करना: http://localhost/

मध्यांतर
अनुरोध पर विचार किए जाने से पहले सेकंड में टाइमआउट हो सकता है।
10 के लिए डिफ़ॉल्ट।

पुनरारंभ_पर_त्रुटि
अनुरोध का समय समाप्त होने या वापस आने पर पुनः आरंभ करने की प्रक्रिया का नाम
अन्य प्रकार की त्रुटि. नहीं दिए जाने पर कोई पुनरारंभ ट्रिगर नहीं हुआ। डिफ़ॉल्ट: कोई नहीं.

संसाधन द्रष्टा
यह सेवाएँ दी गई प्रक्रिया के संसाधनों पर नज़र रखती है और जब पुनरारंभ होती है तो ट्रिगर करती है
वे लगातार कुछ सीमाओं को पार कर जाते हैं।

इसमें statsd जैसा ही कॉन्फ़िगरेशन है और निम्नलिखित जोड़ता है:

उपयोग करने के लिए सेट सर्कस.प्लगइन्स.resource_watcher.ResourceWatcher

लूप_रेट
प्लगइन को सेकंड में आँकड़े माँगने की आवृत्ति। डिफ़ॉल्ट: 60.

चौकीदार
इस संसाधन पर नजर रखने वाले की देखभाल निगरानीकर्ता को करनी चाहिए। (पहले बुलाया गया था
सेवा लेकिन सेवा अब बहिष्कृत कर दिया गया है)

max_cpu
अधिकतम सीपीयू एक प्रक्रिया को उपभोग करने की अनुमति है (% में)। डिफ़ॉल्ट: 90

min_cpu
न्यूनतम सीपीयू एक प्रक्रिया का उपभोग करना चाहिए (% में)। डिफ़ॉल्ट: कोई नहीं (न्यूनतम नहीं)
आप min_cpu को 0 (शून्य) पर सेट कर सकते हैं, इस मामले में यदि एक प्रक्रिया बिल्कुल उपभोग करती है
0% सीपीयू, यह एक सीमा से अधिक को ट्रिगर करेगा।

max_mem
इस वॉचर की एक प्रक्रिया द्वारा उपभोग की जाने वाली मेमोरी की मात्रा। गलती करना:
90. यदि कोई इकाई निर्दिष्ट नहीं है, तो मान % में है। उदाहरण: 50 यदि एक इकाई है
निर्दिष्ट, मान बाइट्स में है। समर्थित इकाइयाँ B, K, M, G, T, P, E, Z, Y हैं।
उदाहरण: 250एम

min_mem
इस वॉचर की एक प्रक्रिया को न्यूनतम मेमोरी का उपभोग करना चाहिए। डिफ़ॉल्ट: कोई नहीं (नहीं)
न्यूनतम)। यदि कोई इकाई निर्दिष्ट नहीं है, तो मान % में है। उदाहरण: 50 यदि एक इकाई है
निर्दिष्ट, मान बाइट्स में है। समर्थित इकाइयाँ B, K, M, G, T, P, E, Z, Y हैं।
उदाहरण: 250एम

स्वास्थ्य_सीमा
स्वास्थ्य सीपीयू और मेमोरी (% में) का औसत है, जो देखने वाली प्रक्रियाएँ हैं
उपभोग करने की अनुमति (% में)। डिफ़ॉल्ट: 75

अधिकतम_गिनती
कितनी बार इन सीमाओं (प्रत्येक को अलग से गिना जाता है) की अनुमति दी जाती है
पुनरारंभ शुरू होने से पहले पार हो जाएगा। डिफ़ॉल्ट: 3

उदाहरण:

[सर्कस]
; ...

[द्रष्टा:कार्यक्रम]
सीएमडी = नींद 120

[प्लगइन:मायप्लगिन]
उपयोग करें = सर्कस.प्लगइन्स.resource_watcher.ResourceWatcher
द्रष्टा = कार्यक्रम
न्यूनतम_सीपीयू = 10
अधिकतम_सीपीयू = 70
न्यूनतम_मेम = 0
अधिकतम_मेम = 20

प्रहरी
प्लगइन जो यूडीपी सॉकेट को बांधता है और वॉचडॉग संदेशों की प्रतीक्षा करता है। "निगरानी" के लिए
प्रक्रियाएं, यदि वे एक निश्चित में दिल की धड़कन नहीं भेजते हैं तो निगरानीकर्ता उन्हें मार डालेगा
लूप_रेट * मैक्स_काउंट द्वारा समय की अवधि को पूरा किया गया। (सर्कस स्वचालित रूप से होगा
वॉचर में गुम प्रक्रियाओं को पुनः आरंभ करें)

प्रत्येक मॉनिटर की गई प्रक्रिया को कम से कम लूप_रेट पर यूडीपी संदेश भेजना चाहिए। यूडीपी
संदेश प्रारूप पाठ की एक पंक्ति है, जिसे उपयोग करके डिकोड किया जाता है msg_regex पैरामीटर. दिल की धड़कन
संदेश में कम से कम संदेश भेजने की प्रक्रिया का पीआईडी ​​अवश्य होना चाहिए।

मॉनिटर किए गए दर्शकों की सूची पैरामीटर द्वारा निर्धारित की जाती है watchers_regex में
विन्यास।

कॉन्फ़िगरेशन पैरामीटर:

उपयोग करने के लिए सेट सर्कस.प्लगइन्स.वॉचडॉग.वॉचडॉग

लूप_रेट
वॉचडॉग लूप दर सेकंड में। प्रत्येक लूप पर, वॉचडॉग "मृत" की तलाश करेगा
प्रक्रियाओं.

watchers_regex
देखने वालों के नामों के मिलान के लिए रेगेक्स, जिसकी निगरानी निगरानी संस्था द्वारा की जानी चाहिए
(चूक जाना: .* सभी दर्शकों पर नजर रखी जाती है)

msg_regex
यूडीपी में प्राप्त दिल की धड़कन संदेश को डिकोड करने के लिए रेगेक्स (डिफ़ॉल्ट:
^(?P.*);(?P.*)$) डिफ़ॉल्ट प्रारूप एक साधारण पाठ संदेश है:
पीआईडी;टाइमस्टैम्प

अधिकतम_गिनती
पुनरारंभ करने से पहले दिल की धड़कन प्राप्त किए बिना पारित लूप की अधिकतम संख्या
प्रक्रिया (डिफ़ॉल्ट: 3)

ip वॉचडॉग आईपी पर आबद्ध होगा (डिफ़ॉल्ट: 127.0.0.1)

बंदरगाह पोर्ट पर वॉचडॉग आबद्ध होगा (डिफ़ॉल्ट: 1664)

फड़फड़ाने
जब कोई कर्मचारी बार-बार पुनरारंभ करता है, तो हम कहते हैं कि यह है फड़फड़ाने. यह प्लगइन ट्रैक रखता है
यदि फड़फड़ा रहा हो तो कार्यकर्ता पुनः प्रारंभ होता है और संबंधित वॉचर को रोक देता है। यह
प्लगइन का उपयोग उन श्रमिकों को स्वचालित रूप से रोकने के लिए किया जा सकता है जो लगातार पुनरारंभ होते हैं क्योंकि
वे ठीक से काम नहीं कर रहे हैं.

उपयोग करने के लिए सेट सर्कस.प्लगइन्स.फ़्लैपिंग.फ़्लैपिंग

प्रयास
किसी प्रक्रिया को कितनी बार पुनः आरंभ किया जा सकता है खिड़की सेकंड, हमसे पहले
इसे फड़फड़ाने पर विचार करें (डिफ़ॉल्ट: 2)

खिड़की फ़्लैपिंग का परीक्षण करने के लिए सेकंड में समय विंडो। यदि प्रक्रिया अधिक पुनः आरंभ होती है
से प्रयास इस समय विंडो के भीतर, हम इसे फ़्लैपिंग प्रक्रिया मानते हैं।
(डिफ़ॉल्ट: 1)

इसमें पुन: प्रयास करें
जब तक हम उस प्रक्रिया को फिर से शुरू करने का प्रयास नहीं करते, तब तक प्रतीक्षा करने का समय सेकंड में है
फड़फड़ाना (डिफ़ॉल्ट: 7)

max_retry
जितनी बार हम किसी ऐसी प्रक्रिया को शुरू करने का प्रयास करते हैं जो पहले फ़्लैप होती रही है
हम पूरे देखने वाले को छोड़ देते हैं और रोक देते हैं। (डिफ़ॉल्ट: 5) अक्षम करने के लिए -1 पर सेट करें
max_retry और अनिश्चित काल तक पुनः प्रयास करें।

सक्रिय परिभाषित करें कि प्लगइन सक्रिय है या नहीं (डिफ़ॉल्ट: सत्य)। यदि वैश्विक ध्वज है
गलत पर सेट है, प्लगइन प्रारंभ नहीं हुआ है।

का उपयोग करके वॉचर अनुभाग में विकल्पों को ओवरराइड किया जा सकता है फड़फड़ाना उपसर्ग. उदाहरण के लिए,
यहां बताया गया है कि आप किसी विशिष्ट को कैसे कॉन्फ़िगर करेंगे max_retry nginx के लिए मूल्य:

[द्रष्टा:nginx]
सीएमडी = /पथ/से/nginx
फ़्लैपिंग.मैक्स_रेट्री = 2

[द्रष्टा: मेरीस्क्रिप्ट]
सीएमडी = ./my_script.py

; ...अन्य दर्शक

[प्लगइन: फ़्लैपिंग]
उपयोग = सर्कस.प्लगइन्स.फ़्लैपिंग.फ़्लैपिंग
अधिकतम_पुनर्प्रयास = 5

CommandReloader
जब उनकी कमांड फ़ाइल संशोधित हो जाएगी तो यह प्लगइन दर्शकों को पुनः आरंभ करेगा। यह द्वारा काम करता है
द्वारा बताए गए संशोधन समय और फ़ाइल के पथ की जाँच करना सीएमडी विकल्प हर
लूप_रेट सेकंड. यह श्रमिक प्रक्रियाओं को विकसित करते समय या गर्म के लिए भी उपयोगी हो सकता है
उत्पादन में कोड उन्नयन.

उपयोग करने के लिए सेट सर्कस.प्लगइन्स.कमांड_रीलोडर.कमांड रीलोडर

लूप_रेट
प्लगइन को सेकंडों में संशोधन के लिए आवृत्ति की जांच करनी चाहिए। डिफ़ॉल्ट: 1.

तैनाती
हालाँकि सर्कस डेमॉन को सर्कस कमांड से प्रबंधित किया जा सकता है, लेकिन इसे प्राप्त करना आसान है
बूट पर शुरूआत। यदि आपका सिस्टम अपस्टार्ट का समर्थन करता है, तो आप इस अपस्टार्ट स्क्रिप्ट को बना सकते हैं
/etc/init/circus.conf.

फ़ाइल सिस्टम और नेट-डिवाइस-अप IFACE=lo पर प्रारंभ करें
रनलेवल पर रुकें [016]

respawn
कार्यकारी /usr/local/bin/circusd /etc/circus/circusd.ini

यह मानता है कि circusd.ini /etc/circus/circusd.ini पर स्थित है। रिबूट करने के बाद, आप
सर्विस कमांड से सर्कस को नियंत्रित कर सकते हैं:

# सर्विस सर्कस स्टार्ट/स्टॉप/रीस्टार्ट

यदि आपका सिस्टम systemd को सपोर्ट करता है, तो आप इस systemd यूनिट फ़ाइल को नीचे बना सकते हैं
/etc/systemd/system/circus.service.

[यूनिट]
विवरण=सर्कस प्रक्रिया प्रबंधक
After=syslog.target नेटवर्क.लक्ष्य nss-lookup.target

[सर्विस]
प्रकार = सरल
ExecReload=/usr/bin/circusctl पुनः लोड करें
ExecStart=/usr/bin/circusd /etc/circus/circus.ini
पुनः प्रारंभ हमेशा =
RestartSec = 5

[इंस्टॉल करें]
वांटेडबाय=डिफ़ॉल्ट.लक्ष्य

यदि आप नीचे डेमॉन-रीलोड कमांड चलाते हैं तो रीबूट की आवश्यकता नहीं है:

# systemctl --सिस्टम डेमॉन-रीलोड

फिर सर्कस का प्रबंधन इसके माध्यम से किया जा सकता है:

# systemctl स्टार्ट/स्टॉप/स्टेटस/रीलोड सर्कस

व्यंजन विधि
इस अनुभाग में सर्कस तैनात करने की विधियाँ शामिल होंगी। तब तक आप पीट को देख सकते हैं
कठपुतली नुस्खा या रेमी में महाराज नुस्खा

पोप प्रक्रिया गुठली
प्रक्रिया प्रबंधकों के लिए एक आम समस्या यह है कि आप प्रक्रिया प्रबंधक को पुनरारंभ नहीं कर सकते
इसके द्वारा प्रबंधित सभी प्रक्रियाओं को पुनः आरंभ किए बिना। इससे इसे तैनात करना मुश्किल हो जाता है
सर्कस का नया संस्करण या किसी भी पुस्तकालय का नया संस्करण जिस पर यह निर्भर करता है।

यदि आप यूनिक्स-प्रकार की प्रणाली पर हैं, तो सर्कस पापा प्रक्रिया कर्नेल का उपयोग कर सकता है। जब इस्तेमाल किया, पापा
एक लंबे समय तक जीवित रहने वाला डेमॉन बनाएगा जो किसी भी प्रक्रिया और सॉकेट के लिए होस्ट के रूप में काम करेगा
आप इसके साथ सृजन करते हैं। यदि सर्कस बंद हो जाता है, तो पापा उसकी मेजबानी की हर चीज़ का रखरखाव करेंगे।

व्यवस्था
स्थापित करके प्रारंभ करें पिता और setproctitle मॉड्यूल:

पिप इंस्टाल पापा
पिप इंस्टाल सेटप्रोक्टाइटल

RSI setproctitle मॉड्यूल वैकल्पिक है. यदि मौजूद है तो इसका उपयोग पापा डेमॉन का नाम बदलने के लिए किया जाएगा
एसटी ऊपर का और ps कुछ इस तरह कि "सर्कसड से पापा डेमन"। यदि आप इंस्टॉल नहीं करते हैं
setproctitle मॉड्यूल, वह शीर्षक उस प्रक्रिया की कमांड लाइन होगी जिसने इसे लॉन्च किया था।
बहुत कन्फ्यूज़िंग है।

एक बार पापा स्थापित हो जाए तो जोड़ें उपयोग_पापा = सत्य आपकी महत्वपूर्ण प्रक्रियाओं और सॉकेट्स के लिए।
आम तौर पर आप अपने स्टैक की सभी प्रक्रियाओं को पापा में रखना चाहते हैं, और किसी को भी नहीं
सर्कस फ़्लैपिंग और सांख्यिकी प्लगइन्स जैसी प्रक्रियाओं का समर्थन करता है।

[सर्कस]
लॉगलेवल = जानकारी

[द्रष्टा:nginx]
cmd = /usr/local/nginx/sbin/nginx -p /Users/scottmax/Source/service-framework/Common/conf/nginx -c /Users/scottmax/Source/service-framework/Common/conf/nginx/nginx .conf
वार्मअप_देरी = 3
ग्रेसफुल_टाइमआउट = 10
अधिकतम_पुनर्प्रयास = 5
सिंगलटन = सत्य
भेजें_हप = सत्य
स्टॉप_सिग्नल = छोड़ें
stdout_stream.class = फ़ाइलस्ट्रीम
stdout_stream.filename = /var/logs/web-server.log
stdout_stream.max_bytes = 10000000
stdout_stream.backup_count = 10
stderr_stream.class = फ़ाइलस्ट्रीम
stderr_stream.filename = /var/logs/web-server-error.log
stderr_stream.max_bytes = 1000000
stderr_stream.backup_count = 10
सक्रिय = सत्य
उपयोग_पापा = सत्य

[देखने वाला: लकड़हारा]
cmd = /my_service/env/bin/python logger.py चलाएँ
वर्किंग_डीआईआर = /my_service
ग्रेसफुल_टाइमआउट = 10
सिंगलटन = सत्य
स्टॉप_सिग्नल = आईएनटी
stdout_stream.class = फ़ाइलस्ट्रीम
stdout_stream.filename = /var/logs/logger.log
stdout_stream.max_bytes = 10000000
stdout_stream.backup_count = 10
stderr_stream.class = फ़ाइलस्ट्रीम
stderr_stream.filename = /var/logs/logger.log
stderr_stream.max_bytes = 1000000
stderr_stream.backup_count = 10
प्राथमिकता = 50
उपयोग_पापा = सत्य

[दर्शक:वेब_ऐप]
cmd = /my_service/env/bin/uwsgi --ini uwsgi-live.ini --socket fd://$(circus.sockets.web) --stats 127.0.0.1:809$(circus.wid)
वर्किंग_डीआईआर = /my_service/web_app
ग्रेसफुल_टाइमआउट=10
स्टॉप_सिग्नल = छोड़ें
use_sockets = सच
stdout_stream.class = फ़ाइलस्ट्रीम
stdout_stream.filename = /var/logs/web_app.log
stdout_stream.max_bytes = 10000000
stdout_stream.backup_count = 10
stderr_stream.class = फ़ाइलस्ट्रीम
stderr_stream.filename = /var/logs/web_app.log
stderr_stream.max_bytes = 1000000
stderr_stream.backup_count = 10
हुक्स.आफ्टर_स्पॉन = उदाहरण.यूडब्ल्यूएसजीआई_लॉसलेस_रीलोड.चिल्ड्रन_स्टार्टेड
हुक.बिफोर_सिग्नल = उदाहरण.uwsgi_losless_reload.clean_stop
हुक्स.एक्सटेंडेड_स्टैट्स = उदाहरण.यूडब्ल्यूएसजीआई_लॉसलेस_रीलोड.एक्सटेंडेड_स्टैट्स
प्राथमिकता = 40
उपयोग_पापा = सत्य

[सॉकेट:वेब]
पथ = /my_service/sock/uwsgi
उपयोग_पापा = सत्य

[प्लगइन: फ़्लैपिंग]
उपयोग = सर्कस.प्लगइन्स.फ़्लैपिंग.फ़्लैपिंग
विंडो = 10
प्राथमिकता = 1000

नोट:
यदि पापा प्रक्रियाएँ किसी सॉकेट का उपयोग करती हैं, तो उन सॉकेटों को भी पापा का उपयोग करना चाहिए।

डिज़ाइन लक्ष्य
पापा को सुविधाओं और आवश्यकताओं में बहुत न्यूनतम बनाया गया है। ऐसा होता है:

· सॉकेट प्रारंभ और बंद करें

· एक कुंजी/मूल्य भंडार प्रदान करें

· प्रक्रियाएं प्रारंभ करें और stdout, stderr और निकास कोड लौटाएं

यदि ऐसा नहीं होता:

· प्रक्रियाओं को पुनः प्रारंभ करें

· प्रक्रियाओं को रोकने का एक तरीका प्रदान करें

· प्रक्रियाएं अभी भी चल रही हैं या नहीं इसके अलावा उनके बारे में कोई भी जानकारी प्रदान करें

पापा को किसी तृतीय-पक्ष लाइब्रेरी की आवश्यकता नहीं है, इसलिए यह केवल मानक पायथन लाइब्रेरी पर चल सकता है।
इसका उपयोग कर सकते हैं setproctitle पैकेज लेकिन उसका उपयोग केवल शीर्षक बनाने के लिए किया जाता है
के लिए सुंदर ps और ऊपर का और यह आवश्यक नहीं है.

कार्यक्षमता को न्यूनतम रखा गया है ताकि आपको इसे पुनः आरंभ करने की आवश्यकता न पड़े
पापा डेमन. अधिकांश कार्यक्षमता को क्लाइंट लाइब्रेरी में धकेल दिया गया है
संभव। इस तरह आप नई ग्राहक सुविधाओं के लिए पापा की एक नई प्रति तैनात करने में सक्षम होंगे
पापा डेमॉन को पुनः आरंभ करने की आवश्यकता के बिना। पापा को स्थिरता का स्तंभ माना जाता है
तृतीय पक्ष पुस्तकालयों का बदलता सागर।

आपरेशन
चाहे आप पापा का उपयोग करें या नहीं, अधिकांश चीजें अपरिवर्तित रहती हैं। आप अभी भी शुरू और बंद कर सकते हैं
प्रक्रियाएँ। आप अभी भी प्रक्रियाओं की स्थिति और आँकड़े प्राप्त कर सकते हैं। मुख्य चीज़ जो बदलती है
क्या वह तब है जब आप ऐसा करते हैं circusctl छोड़ना, पापा की सभी प्रक्रियाएँ चलती रहती हैं। जब आप
प्रारंभ सर्कसडी बैक अप लेने पर, वे प्रक्रियाएँ पुनर्प्राप्त हो जाती हैं।

नोट:
जब प्रक्रियाएँ पुनर्प्राप्त हो जाती हैं, पहले_शुरू और पहले_स्पॉन हुक छूट गए हैं.

लॉगिंग
जबकि सर्कस बंद है, पापा प्रति प्रक्रिया 2M तक आउटपुट संग्रहीत करेंगे। तो यह होगा
सबसे पुराना डेटा डंप करना प्रारंभ करें। जब आप सर्कस को पुनः आरंभ करेंगे, तो यह कैश्ड आउटपुट शीघ्रता से होगा
पुनर्प्राप्त किया गया और आउटपुट स्ट्रीम पर भेजा गया। पापा चाहते हैं कि आउटपुट की प्राप्ति हो
स्वीकार किया गया है, इसलिए शटडाउन के दौरान आपको कोई आउटपुट नहीं खोना चाहिए।

इतना ही नहीं, पापा आउटपुट का टाइमस्टैम्प भी सेव कर लेते हैं। सर्कस को बढ़ाया गया है
यदि मौजूद हो तो टाइमस्टैम्प डेटा का लाभ उठाएं। इसलिए यदि आप लॉग फ़ाइलों में आउटपुट लिख रहे हैं
या कहीं, आपके सभी टाइमस्टैम्प सही होने चाहिए।

समस्याएँ
यदि आप उपयोग करते हैं इन्क्र or दिसंबर एक द्रष्टा के लिए प्रक्रिया गणना को बदलने का आदेश, यह होगा
जब INI फ़ाइल में निर्दिष्ट स्तर पर रीसेट किया जाए सर्कसडी पुनः आरंभ किया जाता है।

इसके अलावा, मुझे इनके संयोजन में भी समस्याओं का अनुभव हुआ है Copy_env और Virtualenv। आप कर सकते हैं
ध्यान दें कि उपरोक्त INI नमूना स्पष्ट पथों के साथ इस समस्या को हल करता है।

टेलनेट इंटरफेस
पापा के पास एक बुनियादी कमांड-लाइन इंटरफ़ेस है जिसे आप टेलनेट के माध्यम से एक्सेस कर सकते हैं:

टेलनेट लोकलहोस्ट 20202
मदद

सर्कस एसटी डेवलपर्स
का प्रयोग सर्कस as a पुस्तकालय
सर्कस उच्च-स्तरीय कक्षाएं और फ़ंक्शन प्रदान करता है जो आपको प्रक्रियाओं को प्रबंधित करने देगा
आपके अपने अनुप्रयोग.

उदाहरण के लिए, यदि आप चार प्रक्रियाओं को हमेशा के लिए चलाना चाहते हैं, तो आप लिख सकते हैं:

सर्कस आयात से get_arbiter

मायप्रोग्राम = {"cmd": "पायथन myprogram.py", "numprocesses": 4}

मध्यस्थ = get_arbiter([myprogram])
प्रयास करें:
मध्यस्थ.प्रारंभ()
आखिरकार:
मध्यस्थ.रोको()

यह स्निपेट चार उदाहरण चलाएगा मेरा कार्यक्रम और उन्हें पुनः आरंभ करके अपने लिए देखें
यदि वे अप्रत्याशित रूप से मर जाते हैं.

इसके बारे में अधिक जानने के लिए लाइब्रेरी देखें

विस्तार सर्कस
सभी को सुनकर, अधिक जटिल प्रणाली बनाने के लिए सर्कस का विस्तार करना आसान है
सर्कसडी इसके पब/उप चैनल के माध्यम से ईवेंट, और इसे कमांड के माध्यम से चलाना।

उदाहरण के लिए, फ़्लैपिंग सुविधा इस प्रकार काम करती है: यह ख़त्म होने वाली सभी प्रक्रियाओं को सुनती है,
यह मापता है कि ऐसा कितनी बार होता है, और बहुत बार पुनरारंभ होने के बाद दोषी दर्शकों को रोक देता है
प्रयास किए गए।

सर्कस आपको ऐसे एक्सटेंशन लिखने में मदद करने के लिए एक प्लगइन सिस्टम और कुछ बिल्ट-इन के साथ आता है
प्लगइन्स आप पुन: उपयोग कर सकते हैं। प्लगइन्स देखें.

आप इसका उपयोग करके अधिक सूक्ष्म स्टार्टअप और शटडाउन व्यवहार भी प्राप्त कर सकते हैं हुक प्रणाली
यह आपको कुछ प्रक्रियाएं शुरू होने से पहले और बाद में मनमाना कोड चलाने देगा
रोका हुआ। हुक देखें.

अंतिम लेकिन महत्वपूर्ण बात, आप नए कमांड भी जोड़ सकते हैं। सीएमडी जोड़ना देखें।

डेवलपर्स दस्तावेज़ीकरण सूची
सर्कस पुस्तकालय
सर्कस पैकेज उच्च स्तरीय से बना है get_arbiter() फ़ंक्शन और कई कक्षाएं। में
अधिकांश मामलों में, उच्च-स्तरीय फ़ंक्शन का उपयोग करना पर्याप्त होना चाहिए, क्योंकि यह वह सब कुछ बनाता है
सर्कस चलाने के लिए आवश्यक है.

यदि आपको सर्कस की कक्षाओं की पेशकश की तुलना में अधिक विस्तृतता की आवश्यकता है, तो आप सर्कस की कक्षाओं को उपवर्गित कर सकते हैं
विन्यास।

RSI get_arbiter समारोह
get_arbiter() यह विभिन्न सर्कस कक्षाओं के शीर्ष पर सिर्फ एक सुविधा है। यह एक बनाता है
मध्यस्थ (वर्ग) मध्यस्थ) दिए गए विकल्पों के साथ उदाहरण, जो बदले में एकल चलाता है
चौकीदार एक के साथ प्रक्रिया.

सर्कस.get_arbiter()

उदाहरण:

सर्कस आयात से get_arbiter

आर्बिटर = get_arbiter([{"cmd": "myprogram", "numprocesses": 3}])
प्रयास करें:
मध्यस्थ.प्रारंभ()
आखिरकार:
मध्यस्थ.रोको()

क्लासेज
सर्कस कक्षाओं की एक श्रृंखला प्रदान करता है जिसका उपयोग आप अपने स्वयं के प्रक्रिया प्रबंधक को लागू करने के लिए कर सकते हैं:

· प्रक्रिया: एक चालू प्रक्रिया को लपेटता है और उसके ऊपर कुछ सहायक प्रदान करता है।

· चौकीदार: के कई उदाहरण चलाएँ प्रक्रिया उसी आदेश के विरुद्ध. मौत का प्रबंधन करें और
प्रक्रियाओं का जीवन.

· मध्यस्थ: कई का प्रबंधन करता है चौकीदार.

कक्षा सर्कस.प्रक्रिया.प्रक्रिया(नाम, चौड़ा, cmd, तर्क=कोई नहीं, वर्किंग_डीआईआर=कोई नहीं, खोल=झूठा,
यूआईडी=कोई नहीं, gid=कोई नहीं, env=कोई नहीं, rlimits=कोई नहीं, निष्पादन योग्य=कोई नहीं, उपयोग_एफडीएस=गलत, देखने वाला=कोई नहीं,
स्पॉन = सत्य, पाइप_स्टडआउट = सत्य, Pipe_stderr=सत्य, क्लोज़_चाइल्ड_स्टडआउट=गलत,
क्लोज़_चाइल्ड_स्टडर=गलत)
एक प्रक्रिया लपेटता है.

विकल्प:

· चौड़ी: प्रक्रिया अद्वितीय पहचानकर्ता. इस मान का उपयोग प्रतिस्थापित करने के लिए किया जाएगा $WID
यदि मौजूद हो तो कमांड लाइन में स्ट्रिंग।

· सीएमडी: चलाने का आदेश. इसमें उपलब्ध कोई भी वेरिएबल शामिल हो सकता है
इस कक्षा में उत्तीर्ण किया जा रहा है। उन्हें पायथन प्रारूप सिंटैक्स का उपयोग करके प्रतिस्थापित किया जाएगा।

· आर्ग: कमांड चलाने के लिए तर्क। एक सूची या एक स्ट्रिंग हो सकती है. अगर आर्ग is
एक स्ट्रिंग, इसका उपयोग करके विभाजित किया गया है shlex.स्प्लिट(). कोई नहीं पर डिफ़ॉल्ट।

· निष्पादन: जब निष्पादन योग्य दिया जाता है, तो आर्ग अनुक्रम में पहला आइटम
प्राप्त हुआ सीएमडी अधिकांश प्रोग्रामों द्वारा इसे अभी भी कमांड नाम के रूप में माना जाता है, जो
फिर वास्तविक निष्पादन योग्य नाम से भिन्न हो सकता है। यह डिस्प्ले बन जाता है
उपयोगिताओं में निष्पादित प्रोग्राम का नाम जैसे ps.

· वर्किंग_डीआईआर: कमांड चलाने के लिए कार्यशील निर्देशिका। यदि प्रदान नहीं किया गया है, तो किया जाएगा
वर्तमान कार्यशील निर्देशिका के लिए डिफ़ॉल्ट।

· खोल: अगर यह सच है, शेल वातावरण में कमांड चलाएगा। झूठा डिफ़ॉल्ट रूप से
चेतावनी: इसका is a सुरक्षा खतरा.

· यूआईडी: यदि दिया गया है, तो वह उपयोगकर्ता आईडी या नाम है जिसके साथ कमांड को चलना चाहिए। द करेंट
यूआईडी डिफ़ॉल्ट है.

· gid: यदि दिया गया है, तो वह समूह आईडी या नाम है जिसके साथ कमांड को चलना चाहिए। द करेंट
gid डिफ़ॉल्ट है.

· env: एक मैपिंग जिसमें पर्यावरण चर होंगे जिनके साथ कमांड चलेगा।
वैकल्पिक।

· सीमा: एक मैपिंग जिसमें rlimit नाम और मान शामिल हैं जिन्हें पहले सेट किया जाएगा
आदेश चलता है.

· उपयोग_एफडीएस: यदि सत्य है, तो उपप्रक्रिया में एफडीएस बंद नहीं होगा। पर सेट होना चाहिए
यदि stdout या stderr को पुनर्निर्देशित किया जाता है तो विंडोज़ पर यह सत्य है। डिफ़ॉल्ट: गलत.

· पाइप_स्टडआउट: यदि सत्य है, तो stdout पर एक PIPE खुलेगा। डिफ़ॉल्ट: सत्य.

· Pipe_stderr: यदि सत्य है, तो stderr पर एक PIPE खुलेगा। डिफ़ॉल्ट: सत्य.

· क्लोज़_चाइल्ड_स्टडआउट: यदि सत्य है, तो चाइल्ड प्रोसेस के stdout को /dev/null पर रीडायरेक्ट करता है
कांटे के बाद. डिफ़ॉल्ट: गलत.

· क्लोज़_चाइल्ड_स्टडर: यदि सत्य है, तो चाइल्ड प्रोसेस के stdout को /dev/null पर रीडायरेक्ट करता है
कांटे के बाद. डिफ़ॉल्ट: गलत.

आयु() प्रक्रिया की आयु सेकंड में लौटाएँ।

बाल बच्चे()
बच्चों की सूची वापस करें।

जानकारी () प्रक्रिया की जानकारी लौटाएँ.

लौटाई गई जानकारी इन कुंजियों के साथ एक मैपिंग है:

· mem_info1: निवासी सेट आकार मेमोरी बाइट्स में (आरएसएस)

· mem_info2: बाइट्स में वर्चुअल मेमोरी साइज (वीएमएस)।

· सीपीयू: सीपीयू उपयोग का %.

· मेम: मेमोरी उपयोग का %.

· समय: प्रक्रिया सीपीयू (उपयोगकर्ता + सिस्टम) समय सेकंड में।

· पीआईडी: प्रक्रिया आईडी.

· उपयोगकर्ता नाम: उपयोगकर्ता नाम जो प्रक्रिया का स्वामी है।

· अच्छा: प्रक्रिया की सुंदरता (-20 और 20 के बीच)

· सीएमडीलाइन: वह कमांड लाइन जिसके साथ प्रक्रिया चलाई गई थी।

is_child(pid)
रिटर्न ट्रू दिया गया है पीआईडी उस प्रक्रिया का एक बच्चा है.

पीआईडी ये वापिस पीआईडी

सेंड_सिग्नल(*आर्ग्स, **किलोवाट)
एक संकेत भेजता है हस्ताक्षर प्रक्रिया के लिए.

सेंड_सिग्नल_चाइल्ड(*आर्ग्स, **किलोवाट)
संकेत भेजें Signum बच्चे को पीआईडी.

सेंड_सिग्नल_चिल्ड्रन(*आर्ग, **किलोवाट)
संकेत भेजें Signum सभी बच्चों को.

हैसियत प्रक्रिया स्थिति को स्थिरांक के रूप में लौटाएँ

· दौड़ना

· मृत_या_ज़ॉम्बी

· अस्तित्वहीन

· अन्य

stderr ये वापिस stdout धारा

stdout ये वापिस stdout धारा

रोकें(*तर्क, **किलोवाट)
प्रक्रिया रोकें और stdout/stderr बंद करें

यदि संबंधित प्रक्रिया अभी भी यहां है (आम तौर पर यह पहले ही समाप्त हो चुकी है
द्रष्टा), एक SIGTERM भेजा जाता है, फिर 1 सेकंड के बाद एक SIGKILL।

शटडाउन प्रक्रिया (SIGTERM फिर SIGKILL) सामान्यतः द्वारा ली जाती है
देखने वाला. इसलिए यदि प्रक्रिया अभी भी यहां है, तो यह एक प्रकार का बुरा व्यवहार है
क्योंकि यहां सुशोभित टाइमआउट का सम्मान नहीं किया जाएगा।

उदाहरण:

>>> सर्कस.प्रोसेस आयात प्रक्रिया से
>>> प्रक्रिया = प्रक्रिया ('शीर्ष', 'शीर्ष', शेल = सत्य)
>>> प्रक्रिया.आयु()
3.0107998847961426
>>> प्रक्रिया.जानकारी()
'शीर्ष: 6812 एन/ए तारेक ज़ोंबी एन/ए एन/ए एन/ए एन/ए एन/ए'
>>> प्रक्रिया.स्थिति
1
>>> प्रोसेस.स्टॉप()
>>> प्रक्रिया.स्थिति
2
>>> प्रक्रिया.जानकारी()
'ऐसी कोई प्रक्रिया नहीं (रोकी गई?)'

कक्षा सर्कस.देखनेवाला.देखनेवाला(नाम, cmd, तर्क=कोई नहीं, संख्याप्रक्रियाएँ=1, वार्मअप_देरी=0.0,
वर्किंग_डीआईआर=कोई नहीं, खोल=झूठा, शेल_आर्ग्स=कोई नहीं, यूआईडी=कोई नहीं, अधिकतम_पुनर्प्रयास=5, gid=कोई नहीं,
भेजें_हप=गलत, स्टॉप_सिग्नल=15, stop_children=झूठा, env=कोई नहीं, ग्रेसफुल_टाइमआउट=30.0,
prereload_fn=कोई नहीं, rlimits=कोई नहीं, निष्पादन योग्य=कोई नहीं, stdout_stream=कोई नहीं, stderr_stream=कोई नहीं,
प्राथमिकता=0, लूप=कोई नहीं, सिंगलटन=झूठा, उपयोग_सॉकेट=गलत, Copy_env=गलत,
प्रतिलिपि_पथ=गलत, अधिकतम आयु=0, अधिकतम_आयु_विचरण=30, हुक=कोई नहीं, पुनरुत्पादन = सत्य, ऑटोस्टार्ट = सत्य,
on_demand=गलत, वर्चुअलएन्व=कोई नहीं, क्लोज़_चाइल्ड_स्टडआउट=गलत, क्लोज़_चाइल्ड_स्टडर=गलत,
वर्चुअलenv_py_ver=कोई नहीं, उपयोग_पापा=गलत, **विकल्प)
किसी दिए गए आदेश के लिए प्रक्रियाओं की सूची का प्रबंधन करने वाला वर्ग।

विकल्प:

· नाम: देखने वाले को दिया गया नाम. इसकी विशिष्ट पहचान के लिए उपयोग किया जाता है।

· सीएमडी: चलाने का आदेश. में हो सकता है $WID, जिसे प्रतिस्थापित किया जाएगा चौड़ी.

· आर्ग: कमांड चलाने के लिए तर्क। एक सूची या एक स्ट्रिंग हो सकती है. अगर आर्ग is
एक स्ट्रिंग, इसका उपयोग करके विभाजित किया गया है shlex.स्प्लिट(). कोई नहीं पर डिफ़ॉल्ट।

· numprocesses: चलने वाली प्रक्रियाओं की संख्या.

· वर्किंग_डीआईआर: कमांड चलाने के लिए कार्यशील निर्देशिका। यदि प्रदान नहीं किया गया है, तो किया जाएगा
वर्तमान कार्यशील निर्देशिका के लिए डिफ़ॉल्ट।

· खोल: अगर यह सच है, शेल वातावरण में कमांड चलाएगा। झूठा डिफ़ॉल्ट रूप से
चेतावनी: इसका is a सुरक्षा खतरा.

· यूआईडी: यदि दिया गया है, तो वह उपयोगकर्ता आईडी या नाम है जिसके साथ कमांड को चलना चाहिए। द करेंट
यूआईडी डिफ़ॉल्ट है.

· gid: यदि दिया गया है, तो वह समूह आईडी या नाम है जिसके साथ कमांड को चलना चाहिए। द करेंट
gid डिफ़ॉल्ट है.

· भेजें_हप: यदि सत्य है, तो SIGHUP सिग्नल भेजकर एक प्रक्रिया पुनः लोड की जाएगी।
डिफ़ॉल्ट ग़लत है।

· stop_signal: प्रक्रिया को रोकते समय भेजने के लिए संकेत। SIGTERM पर डिफ़ॉल्ट।

· रुको_बच्चों: भेजें stop_signal बच्चों को भी. डिफ़ॉल्ट ग़लत है।

· env: एक मैपिंग जिसमें पर्यावरण चर होंगे जिनके साथ कमांड चलेगा।
वैकल्पिक।

· सीमा: एक मैपिंग जिसमें rlimit नाम और मान शामिल हैं जिन्हें पहले सेट किया जाएगा
आदेश चलता है.

· stdout_stream: एक मैपिंग जो प्रक्रिया स्टडआउट के लिए स्ट्रीम को परिभाषित करती है। चूक
किसी को नहीं.

वैकल्पिक। जब प्रदान किया गया, stdout_stream एक मैपिंग है जिसमें अधिकतम तीन कुंजियाँ होती हैं:

· कक्षा: धारा वर्ग. के लिए डिफ़ॉल्ट सर्कस.स्ट्रीम.फ़ाइलस्ट्रीम

· फ़ाइल का नाम: फ़ाइल नाम, यदि फ़ाइलस्ट्रीम का उपयोग कर रहे हैं

· अधिकतम_बाइट्स: अधिकतम फ़ाइल आकार, जिसके बाद एक नई आउटपुट फ़ाइल खोली जाती है। चूक
से 0 जिसका अर्थ है कोई अधिकतम आकार नहीं (केवल फाइलस्ट्रीम के साथ लागू)।

· बैकअप_गिनती: के अनुसार फ़ाइलों को घुमाते समय कितने बैकअप बनाए रखने हैं
max_bytes पैरामीटर। डिफ़ॉल्ट 0 है जिसका मतलब है कि कोई बैकअप नहीं बनाया गया है (केवल
फ़ाइलस्ट्रीम के साथ लागू)

इस मैपिंग का उपयोग निर्दिष्ट वर्ग की कॉल करने योग्य स्ट्रीम बनाने के लिए किया जाएगा।
कॉल करने योग्य द्वारा प्राप्त प्रत्येक प्रविष्टि एक मैपिंग है जिसमें शामिल है:

· पीआईडी - प्रक्रिया पीआईडी

· नाम - स्ट्रीम का नाम (stderr or stdout)

· तिथि - आंकड़ा

यह विंडोज़ पर समर्थित नहीं है.

· stderr_stream: एक मैपिंग जो प्रक्रिया stderr के लिए स्ट्रीम को परिभाषित करती है। चूक
किसी को नहीं.

वैकल्पिक। जब प्रदान किया गया, stderr_stream एक मैपिंग है जिसमें अधिकतम तीन कुंजियाँ होती हैं:
- कक्षा: धारा वर्ग. के लिए डिफ़ॉल्ट सर्कस.स्ट्रीम.फ़ाइलस्ट्रीम - फ़ाइल का नाम:
फ़ाइल नाम, यदि फ़ाइलस्ट्रीम का उपयोग कर रहे हैं - अधिकतम_बाइट्स: अधिकतम फ़ाइल आकार, जिसके बाद एक नया
आउटपुट फ़ाइल है
खुल गया। डिफ़ॉल्ट 0 है जिसका अर्थ है कोई अधिकतम आकार नहीं (केवल इसके साथ लागू)।
फ़ाइल धारा)

· बैकअप_गिनती: के अनुसार फ़ाइलों को घुमाते समय कितने बैकअप बनाए रखने हैं
max_bytes पैरामीटर। डिफ़ॉल्ट 0 है जिसका मतलब है कि कोई बैकअप नहीं बनाया गया है (केवल
फ़ाइलस्ट्रीम के साथ लागू)।

इस मैपिंग का उपयोग निर्दिष्ट वर्ग की कॉल करने योग्य स्ट्रीम बनाने के लिए किया जाएगा।

कॉल करने योग्य द्वारा प्राप्त प्रत्येक प्रविष्टि एक मैपिंग है जिसमें शामिल है:

· पीआईडी - प्रक्रिया पीआईडी

· नाम - स्ट्रीम का नाम (stderr or stdout)

· तिथि - आंकड़ा

यह विंडोज़ पर समर्थित नहीं है.

· प्राथमिकता -- पूर्णांक जो देखने वाले के लिए प्राथमिकता को परिभाषित करता है। जब मध्यस्थ ऐसा करते हैं
सभी दर्शकों पर कुछ ऑपरेशन, यह उन्हें इस फ़ील्ड के साथ क्रमबद्ध करेगा
सबसे छोटी से बड़ी संख्या. (डिफ़ॉल्ट: 0)

· एकाकी वस्तु -- यदि सत्य है, तो इस द्रष्टा के पास एक ही प्रक्रिया है। (डिफ़ॉल्ट: ग़लत)

· उपयोग_सॉकेट - यदि सत्य है, तो प्रक्रियाएँ फ़ाइल डिस्क्रिप्टर को इनहेरिट करेंगी, इस प्रकार ऐसा हो सकता है
सर्कस द्वारा खोले गए सॉकेट का पुन: उपयोग करें। (डिफ़ॉल्ट: ग़लत)

· मांग पर - यदि सत्य है, तो प्रक्रियाएं केवल पहले कनेक्शन पर ही शुरू की जाएंगी
सॉकेट के लिए (डिफ़ॉल्ट: गलत)

· Copy_env -- यदि सत्य है, तो जिस वातावरण में सर्कस चल रहा है, वह भाग होगा
श्रमिकों के लिए पुनः प्रस्तुत किया गया। विंडोज़ पर यह डिफ़ॉल्ट रूप से सत्य है क्योंकि आप इसे चला नहीं सकते
के बिना कोई भी निष्पादन योग्य सिस्टमरूट चर। (डिफ़ॉल्ट: ग़लत)

· प्रतिलिपि_पथ -- यदि सत्य है, सर्कस sys.पथ के माध्यम से प्रक्रिया में भेजा जाता है अजगरपथ.
आपको सक्रिय करना होगा Copy_env एसटी प्रतिलिपि_पथ काम करने के लिए। (डिफ़ॉल्ट: ग़लत)

· अधिकतम_आयु: यदि लगभग अधिकतम आयु सेकंड के बाद सेट किया जाता है, तो प्रक्रिया को एक नई प्रक्रिया से बदल दिया जाता है
एक। (डिफ़ॉल्ट: 0, अक्षम)

· अधिकतम_आयु_विचरण: सेकंड की अधिकतम संख्या जिसे max_age में जोड़ा जा सकता है।
यह अतिरिक्त मान एक ही समय में सभी प्रक्रियाओं को पुनरारंभ करने से बचने के लिए है। ए
प्रक्रिया max_age और max_age + max_age_variance सेकंड के बीच रहेगी।

· हुक: वॉचर स्टार्टअप और शटडाउन से जुड़ने के लिए कॉलबैक फ़ंक्शन
प्रक्रिया. हुक एक निर्देश है जहां प्रत्येक कुंजी हुक नाम है और प्रत्येक मान एक है
2-कॉल करने योग्य या स्वयं कॉल करने योग्य के नाम और एक बूलियन ध्वज के साथ टुपल
यह दर्शाता है कि क्या हुक में होने वाले अपवाद को नजरअंदाज नहीं किया जाना चाहिए। संभव
हुक नाम के लिए मान: पहले_शुरू, After_start, पहले_स्पॉन, After_spawn,
पहले_रुको, उपरांत_रुकें., before_signal, After_signal or विस्तारित_आँकड़े.

· विकल्पों --कर्मचारी के लिए अतिरिक्त विकल्प। कॉन्फ़िगरेशन में सभी विकल्प मिले
उदाहरण के लिए, फ़ाइल को इस मैपिंग में पास किया जाता है - इसका उपयोग प्लगइन्स द्वारा किया जा सकता है
द्रष्टा-विशिष्ट विकल्प।

· respawn - यदि गलत पर सेट किया जाता है, तो पर्यवेक्षक द्वारा संभाली जाने वाली प्रक्रियाएँ गलत नहीं होंगी
स्वतः ही पुनः उत्पन्न हो गया। (डिफ़ॉल्ट: सत्य)

· Virtualenv -- वर्चुअलएन्व की मूल निर्देशिका। यदि प्रदान किया गया, तो द्रष्टा करेगा
इसके निष्पादन के लिए पर्यावरण को लोड करें। (डिफ़ॉल्ट: कोई नहीं)

· क्लोज़_चाइल्ड_स्टडआउट: यदि सत्य है, तो कांटे के बाद स्टडआउट बंद कर देता है। डिफ़ॉल्ट: गलत.

· क्लोज़_चाइल्ड_स्टडर: यदि सत्य है, तो कांटे के बाद स्टडर को बंद कर देता है। डिफ़ॉल्ट: गलत.

· उपयोग_पापा: यदि सत्य है, तो इस प्रक्रिया के लिए पापा प्रोसेस कर्नेल का उपयोग करें। डिफ़ॉल्ट: गलत.

किल_प्रोसेस(*आर्ग्स, **क्वार्ग्स)
किल प्रक्रिया (स्टॉप_सिग्नल, ग्रेसफुल_टाइमआउट फिर सिगकिल)

किल_प्रोसेसेस(*आर्ग्स, **क्वार्ग्स)
सभी प्रक्रियाओं को समाप्त करें (स्टॉप_सिग्नल, ग्रेसफुल_टाइमआउट फिर सिगकिल)

मैनेज_प्रोसेसेस(*आर्ग्स, **क्वार्ग्स)
प्रक्रियाओं को प्रबंधित करें.

सूचित_घटना(विषय, संदेश)
इवेंट प्रकाशक चैनल पर एक संदेश प्रकाशित करें

Reap_and_manage_processes(*args, **क्वार्ग्स)
प्रक्रियाओं को काटें और प्रबंधित करें।

reap_processes(*args, **किलोवाट)
इस पर्यवेक्षक के लिए सभी प्रक्रियाओं का लाभ उठाएं।

सेंड_सिग्नल_चाइल्ड(*आर्ग्स, **किलोवाट)
किसी बच्चे को सिग्नल भेजें.

स्पॉन_प्रोसेस(रिकवरी_विड=कोई नहीं)
स्पॉन प्रक्रिया.

यदि ठीक है तो सत्य लौटें, यदि देखने वाले को रोकना पड़े तो असत्य लौटें

spawn_processes(*args, **क्वार्ग्स)
स्पॉन प्रक्रियाएं.

कक्षा सर्कस.मध्यस्थ.मध्यस्थ(देखने वाले, समापन बिंदु, पबसब_एंडपॉइंट, चेक_विलंब=1.0,
prereload_fn=कोई नहीं, प्रसंग=कोई नहीं, लूप=कोई नहीं, आँकड़े = गलत, आँकड़े_अंतबिंदु=कोई नहीं,
आँकड़ेd_close_outputs=गलत, मल्टीकास्ट_एंडपॉइंट=कोई नहीं, प्लगइन्स=कोई नहीं, सॉकेट=कोई नहीं,
वार्मअप_देरी=0, httpd=गलत, httpd_host='लोकलहोस्ट', httpd_port=8080,
httpd_close_outputs=गलत, डीबग=गलत, डिबग_जीसी=गलत, ssh_server=कोई नहीं,
proc_name='circusd', पिडफ़ाइल=कोई नहीं, लॉगलेवल=कोई नहीं, लॉगआउटपुट=कोई नहीं, लकड़हारा=कोई नहीं,
fqdn_prefix=कोई नहीं, उमास्क=कोई नहीं, समापन बिंदु_स्वामी=कोई नहीं, पापा_एंडपॉइंट=कोई नहीं)
कक्षा का उपयोग दर्शकों की सूची को नियंत्रित करने के लिए किया जाता है।

विकल्प:

· पर नजर रखने वालों - वॉचर ऑब्जेक्ट की एक सूची

· समापन बिंदु - नियंत्रक ZMQ समापन बिंदु

· pubsub_endpoint - पबसब समापन बिंदु

· आँकड़े - यदि सत्य है, तो एक सर्कस-आँकड़े प्रक्रिया चलाई जाती है (डिफ़ॉल्ट: गलत)

· आँकड़े_अंतबिंदु - आँकड़े समापन बिंदु।

· आँकड़े_बंद_आउटपुट - यदि ट्रू सर्कस-स्टैट्स stdout/stderr को भेजता है
/dev/null (डिफ़ॉल्ट: गलत)

· मल्टीकास्ट_एंडपॉइंट - सर्कस क्लस्टर ऑटो-डिस्कवरी के लिए मल्टीकास्ट एंडपॉइंट
(डिफ़ॉल्ट: udp://237.219.251.97:12027) मल्टीकास्ट एड्रेस 224.0.0.0 के बीच होना चाहिए
से 239.255.255.255 और सभी क्लस्टर के लिए समान।

· check_delay - दो नियंत्रक बिंदुओं के बीच विलंब (डिफ़ॉल्ट: 1 सेकंड)

· प्रीरीलोड_एफएन - कॉल करने योग्य जिसे प्रत्येक पुनः लोड पर निष्पादित किया जाएगा (डिफ़ॉल्ट: कोई नहीं)

· प्रसंग - यदि प्रदान किया गया है, तो zmq संदर्भ का पुन: उपयोग करें। (डिफ़ॉल्ट: कोई नहीं)

·

पाश: if प्रदान किया गया, a zmq.eventloop.ioloop.IOLoop उदाहरण
पुनर्प्रयोग करना। (डिफ़ॉल्ट: कोई नहीं)

· plugins -- प्लगइन्स की एक सूची. प्रत्येक आइटम एक मैपिंग है:

· उपयोग - पूरी तरह से योग्य नाम जो प्लगइन क्लास की ओर इशारा करता है

· प्रत्येक अन्य मान को प्लगइन में भेज दिया जाता है विन्यास विकल्प

· कुर्सियां - सॉकेट की मैपिंग। प्रत्येक कुंजी सॉकेट नाम है, और प्रत्येक मान एक है
सर्कस सॉकेट कक्षा। (डिफ़ॉल्ट: कोई नहीं)

· वार्मअप_देरी - दो दर्शकों के स्टार्टअप के बीच सेकंड में देरी। (डिफ़ॉल्ट: 0)

· httpd - यदि सत्य है, तो एक सर्कसएचटीपीडी प्रक्रिया चलाई जाती है (डिफ़ॉल्ट: गलत)

· httpd_host -- सर्कसhttpd होस्ट (डिफ़ॉल्ट: लोकलहोस्ट)

· httpd_port -- सर्कसhttpd पोर्ट (डिफ़ॉल्ट: 8080)

· httpd_close_outputs -- यदि सत्य है, तो circushttpd stdout/stderr को /dev/null पर भेजता है।
(डिफ़ॉल्ट: ग़लत)

· डिबग - यदि सही है, तो स्टडआउट में बहुत सारी डीबग जानकारी जोड़ता है (डिफ़ॉल्ट: ग़लत)

· डिबग_जीसी - यदि सही है, तो gc.set_debug(gc.DEBUG_LEAK) (डिफ़ॉल्ट: ग़लत) सर्कसड में करता है
समस्याओं का विश्लेषण करने के लिए (डिफ़ॉल्ट: ग़लत)

· proc_name - मध्यस्थ प्रक्रिया का नाम

·

fqdn_prefix -- a उपसर्ग एसटी la अद्वितीय पहचानकर्ता of la सर्कस
क्लस्टर पर उदाहरण.

· समापन बिंदु_स्वामी - यदि आईपीसी का उपयोग कर रहे हैं तो यूनिक्स उपयोगकर्ता को समापन बिंदु को चाउ करना होगा।

· पापा_एंडपॉइंट - पापा प्रक्रिया कर्नेल समापन बिंदु

add_watcher(*args, **क्वार्ग्स)
एक द्रष्टा जोड़ता है.

विकल्प:

· नाम: जोड़ने हेतु देखने वाले का नाम

· सीएमडी: चलाने का आदेश.

· वॉचर कंस्ट्रक्टर में परिभाषित अन्य सभी विकल्प।

get_watcher(नाम)
देखने वाले को लौटा दो नाम.

संख्याप्रक्रियाएं()
सभी दर्शकों के बीच चल रही प्रक्रियाओं की संख्या लौटाएँ।

अंक देखने वाले()
देखने वालों की संख्या लौटाएँ.

पुनः लोड करें(*आर्ग, **क्वार्ग्स)
सब कुछ पुनः लोड करता है.

चलाएं प्रीरीलोड_एफएन() यदि कोई कॉल करने योग्य है, तो सभी दर्शकों को शालीनता से पुनः लोड करें।

प्रारंभ(*तर्क, **क्वार्ग्स)
सभी दर्शकों को प्रारंभ करता है.

यदि __init__() कॉल के दौरान ioloop प्रदान किया गया है, तो सभी वॉचर्स प्रारंभ हो जाते हैं
एक मानक कोरआउटिन के रूप में

यदि __init__() कॉल (डिफ़ॉल्ट) के दौरान ioloop प्रदान नहीं किया गया है, तो प्रारंभ होता है
सभी दर्शक और इवेंटलूप (और यहां ब्लॉक)। इस विधा में विधि
इससे कुछ भी प्राप्त नहीं होना चाहिए क्योंकि इसे मानक विधि कहा जाता है।

पैरामीटर्स
cb - सभी वॉचर्स शुरू होने के बाद कॉलबैक किया गया, कब
लूप उपलब्ध नहीं कराया गया है.

लेखन plugins
सर्कस एक प्लगइन सिस्टम के साथ आता है जो आपको बातचीत करने की सुविधा देता है सर्कसडी.

नोट:
हम बाद में प्लगइन्स में सर्कस-स्टेट्स समर्थन जोड़ सकते हैं।

एक प्लगइन दो भागों से बना होता है:

· द्वारा प्रकाशित सभी घटनाओं के लिए एक ZMQ ग्राहक सर्कसडी

· कमांड भेजने के लिए एक ZMQ क्लाइंट सर्कसडी

प्रत्येक प्लगइन को एक कस्टम वॉचर के तहत एक अलग प्रक्रिया के रूप में चलाया जाता है।

कुछ प्लगइन्स के कुछ उदाहरण जिन्हें आप इस सिस्टम से बना सकते हैं:

· एक अधिसूचना प्रणाली जो देखने वाले के फड़फड़ाने पर ई-मेल अलर्ट भेजती है

· एक लकड़हारा

· एक उपकरण जो लोड के आधार पर प्रक्रियाओं को जोड़ता या हटाता है

· वगैरह।

सर्कस स्वयं कुछ अंतर्निर्मित प्लगइन्स के साथ आता है।

RSI सर्कसप्लगइन कक्षा
प्लगइन्स लागू करने में आपकी सहायता के लिए सर्कस एक बेस क्लास प्रदान करता है: सर्कस.प्लगइन्स.सर्कसप्लगइन

कक्षा सर्कस.प्लगइन्स.सर्कसप्लगइन(एंडपॉइंट, पबसब_एंडपॉइंट, जाँच_विलंब, ssh_server=कोई नहीं,
**विन्यास)
प्लगइन्स लिखने के लिए बेस क्लास।

विकल्प:

· प्रसंग - उपयोग करने के लिए ZMQ संदर्भ

· समापन बिंदु - सर्कस ZMQ समापन बिंदु

· pubsub_endpoint -- सर्कस ZMQ पब/उप समापन बिंदु

· check_delay - कॉन्फ़िगर किया गया चेक विलंब

· विन्यास - निःशुल्क कॉन्फिग मैपिंग

कॉल(कमांड, **प्रॉप्स)
को आदेश भेजता है सर्कसडी

विकल्प:

· आदेश -- कॉल करने का आदेश

· रंगमंच की सामग्री - कॉल में जोड़ने के लिए कीवर्ड तर्क

द्वारा वापस भेजी गई JSON मैपिंग लौटाता है सर्कसडी

कास्ट(कमांड, **प्रॉप्स)
आग लगाओ और भूल जाओ का आदेश सर्कसडी

विकल्प:

· आदेश -- कॉल करने का आदेश

· रंगमंच की सामग्री - कॉल में जोड़ने के लिए कीवर्ड तर्क

हैंडल_इनिट()
प्लगइन शुरू होने से ठीक पहले कॉल किया जाता है - थ्रेड संदर्भ में।

हैंडल_रेकव(डेटा)
द्वारा प्रकाशित प्रत्येक घटना को प्राप्त करता है सर्कसडी

विकल्प:

· तिथि -- एक टुपल जिसमें विषय और संदेश शामिल है।

हैंडल_स्टॉप()
सर्कस द्वारा प्लगइन बंद करने से ठीक पहले कॉल किया गया।

जब सर्कस द्वारा आरंभ किया जाता है, तो यह वर्ग अपना स्वयं का ईवेंट लूप बनाता है जो सभी को प्राप्त करता है
सर्कसडी घटनाएँ और उन्हें पास करें हैंडल_रेकव(). प्राप्त डेटा एक टपल है जिसमें शामिल है
विषय और डेटा स्वयं।

हैंडल_रेकव() चाहिए प्लगइन द्वारा कार्यान्वित किया जाएगा।

RSI कॉल () और ढालना() तरीकों का उपयोग बातचीत करने के लिए किया जा सकता है सर्कसडी यदि आप निर्माण कर रहे हैं
प्लगइन जो सक्रिय रूप से डेमॉन के साथ इंटरैक्ट करता है।

हैंडल_इनिट() और हैंडल_स्टॉप() ये केवल सुविधाजनक तरीके हैं जिनका उपयोग आप आरंभ करने के लिए कर सकते हैं
अपना कोड साफ़ करें. हैंडल_इनिट() उस थ्रेड के भीतर कहा जाता है जो अभी शुरू हुआ है।
हैंडल_स्टॉप() थ्रेड को रोकने और जोड़ने से ठीक पहले मुख्य थ्रेड में कॉल किया जाता है।

लेखन a लगाना
आइए एक प्लगइन लिखें जो होने वाली प्रत्येक घटना को एक फ़ाइल में लॉग इन करता है सर्कसडी. यह एक लेता है
तर्क जो फ़ाइल नाम है।

प्लगइन इस तरह दिख सकता है:

सर्कस.प्लगइन्स से सर्कसप्लगइन आयात करें

क्लास लॉगर (सर्कसप्लगइन):

नाम = 'लकड़हारा'

def __init__(स्वयं, *args, **config):
सुपर(लॉगर, सेल्फ).__init__(*args, **config)
self.filename = config.get('फ़ाइल नाम')
स्व.फ़ाइल = कोई नहीं

डीईएफ़ हैंडल_इनिट(स्वयं):
self.file = open(self.filename, 'a+', बफ़रिंग=1)

डीईएफ़ हैंडल_स्टॉप(स्वयं):
स्व.फ़ाइल.बंद करें()

डीईएफ़ हैंडल_रेकव(स्वयं, डेटा):
द्रष्टा_नाम, क्रिया, संदेश = self.split_data(डेटा)
msg_dict = self.load_message(संदेश)
self.file.write('%s %s::%r\n' % (कार्रवाई, watcher_name, msg_dict))

इतना ही ! इस क्लास को किसी भी पैकेज/मॉड्यूल में तब तक सेव किया जा सकता है, जब तक इसे देखा जा सके
अजगर।

उदाहरण के लिए, लकड़हारा ए में पाया जा सकता है plugins एक के भीतर मॉड्यूल मेरी परियोजना पैकेज.

async अनुरोधों
यदि आप कोई एसिंक्रोनस ऑपरेशन (जैसे टॉरनेडो कॉल या उपयोग करना) करना चाहते हैं
periodicCall) सुनिश्चित करें कि आप सही लूप का उपयोग कर रहे हैं। वह लूप जिसे आप हमेशा उपयोग करना चाहते हैं
सेल्फ.लूप है क्योंकि यह बेस क्लास द्वारा सेट किया जाता है। डिफ़ॉल्ट लूप अक्सर समान नहीं होता है
और इसलिए कोड अपेक्षित रूप से निष्पादित नहीं हो सकता है।

कोशिश कर रहे हैं a लगाना
आप कमांड लाइन के माध्यम से एक प्लगइन चला सकते हैं सर्कस-प्लगइन आदेश, द्वारा
प्लगइन का पूर्णतः योग्य नाम निर्दिष्ट करना:

$ सर्कस-प्लगइन --एंडपॉइंट tcp://127.0.0.1:5555 --pubsub tcp://127.0.0.1:5556 --config फ़ाइल नाम:circus-events.log myproject.plugins.Logger
[जानकारी] प्लगइन लोड हो रहा है...
[जानकारी] समापन बिंदु: 'tcp://127.0.0.1:5555'
[जानकारी] पब/उप: 'tcp://127.0.0.1:5556'
[जानकारी] शुरू हो रहा है

प्लगइन चलाने का दूसरा तरीका सर्कस को इसके आरंभीकरण को संभालने देना है। यह द्वारा किया जाता है
जोड़ना [प्लगइन:नाम] कॉन्फ़िगरेशन फ़ाइल में अनुभाग, जहां नाम के लिए एक अनोखा नाम है
आपका प्लगइन:

[प्लगइन:लॉगर]
उपयोग = myproject.plugins.Logger
फ़ाइल नाम = /var/myproject/circus.log

उपयोग अनिवार्य है और प्लगइन के पूर्णतः योग्य नाम की ओर इशारा करता है।

जब सर्कस शुरू होता है, तो यह एक प्रक्रिया के साथ एक दर्शक बनाता है जो नुकीले वर्ग को चलाता है, और
अनुभाग में मौजूद किसी भी अन्य वेरिएबल को प्लगइन कंस्ट्रक्टर के माध्यम से पास करें विन्यास
मानचित्रण।

जब आप बनाते हैं तो आप प्रोग्रामेटिक रूप से प्लगइन भी जोड़ सकते हैं सर्कस.मध्यस्थ.मध्यस्थ कक्षा
या उपयोग करें सर्कस.get_arbiter(), लाइब्रेरी देखें।

प्रदर्शन
चूँकि प्रत्येक प्लगइन अपनी प्रक्रिया में लोड होता है, इसलिए इसका समग्र प्रभाव नहीं पड़ना चाहिए
जब तक प्लगइन द्वारा किया गया कार्य बहुत अधिक न हो तब तक सिस्टम का प्रदर्शन
को कॉल करता है सर्कसडी प्रक्रिया.

कांटों
सर्कस हुक प्रदान करता है जिसका उपयोग दर्शकों की घटनाओं पर कार्रवाई शुरू करने के लिए किया जा सकता है। उपलब्ध
हुक हैं:

· पहले_शुरू: वॉचर शुरू होने से पहले कॉल किया जाता है। यदि हुक वापस आता है झूठा la
स्टार्टअप निरस्त कर दिया गया है.

· After_start: वॉचर शुरू होने के बाद कॉल किया जाता है। यदि हुक वापस आता है झूठा देखने वाला
तुरंत रोक दिया जाता है और स्टार्टअप निरस्त कर दिया जाता है।

· पहले_स्पॉन: द्रष्टा द्वारा एक नई प्रक्रिया उत्पन्न करने से पहले बुलाया जाता है। यदि हुक वापस आता है झूठा
देखने वाले को तुरंत रोक दिया जाता है और स्टार्टअप को रोक दिया जाता है।

· After_spawn: द्रष्टा द्वारा एक नई प्रक्रिया उत्पन्न करने के बाद बुलाया जाता है। यदि हुक वापस आता है झूठा
देखने वाले को तुरंत रोक दिया जाता है और स्टार्टअप को रोक दिया जाता है।

· पहले_रुको: देखने वाले के रुकने से पहले कॉल किया जाता है। हुक परिणाम को नजरअंदाज कर दिया जाता है।

· उपरांत_रुकें: वॉचर के रुकने के बाद कॉल किया गया। हुक परिणाम को नजरअंदाज कर दिया जाता है।

· before_signal: वॉचर की प्रक्रिया में सिग्नल भेजने से पहले कॉल किया जाता है। यदि हुक
रिटर्न झूठा सिग्नल नहीं भेजा गया है (सिग्किल को छोड़कर जो हमेशा भेजा जाता है)

· After_signal: वॉचर की प्रक्रिया में सिग्नल भेजे जाने के बाद कॉल किया जाता है।

· विस्तारित_आँकड़े: जब आँकड़ों का अनुरोध विस्तारित = सत्य के साथ किया जाता है तो कॉल किया जाता है। जोड़ने के लिए उपयोग किया जाता है
नियमित सांख्यिकी आउटपुट के लिए प्रक्रिया-विशिष्ट आँकड़े।

उदाहरण
एक सामान्य उपयोग का मामला यह नियंत्रित करना है कि किसी प्रक्रिया को शुरू करने के लिए सभी शर्तें पूरी की जाती हैं।
मान लीजिए कि आपके पास एक चलने वाला वॉचर है Redis और एक द्रष्टा जो पायथन लिपि चलाता है
के साथ काम करता है Redis. सर्कस के साथ आप इसका उपयोग करके स्टार्टअप को ऑर्डर कर सकते हैं प्राथमिकता विकल्प:

[द्रष्टा: कतार-कार्यकर्ता]
सीएमडी = पायथन -यू वर्कर.पी.ई
प्राथमिकता = 1

[द्रष्टा:रेडिस]
सीएमडी = रेडिस-सर्वर
प्राथमिकता = 2

इस सेटअप के साथ सर्कस शुरू हो जाएगा Redis पहले और फिर यह कतार कार्यकर्ता शुरू करेगा।
लेकिन सर्कस वास्तव में उस पर नियंत्रण नहीं रखता है Redis चालू है और चल रहा है. यह तो बस शुरू होता है
इसकी प्रक्रिया शुरू करने को कहा गया। यहां हम जो भूल रहे हैं वह उसे नियंत्रित करने का एक तरीका है Redis is
प्रारंभ हो चुका है और पूर्णतः कार्यात्मक है। एक फ़ंक्शन जो इसे नियंत्रित करता है वह हो सकता है:

रेडिस आयात करें
आयात समय

def check_redis(*args, **kw):
time.sleep(.5) # इसे शुरू करने का मौका दें
आर = रेडिस.स्ट्रिक्टरेडिस(होस्ट='लोकलहोस्ट', पोर्ट=6379, डीबी=0)
r.set('फू', 'बार')
वापसी r.get('foo') == 'बार'

इस फ़ंक्शन को सर्कस में प्लग किया जा सकता है पहले_शुरू हुक:

[द्रष्टा: कतार-कार्यकर्ता]
सीएमडी = पायथन -यू वर्कर.पी.ई
हुक.बिफोर_स्टार्ट = mycoolapp.myplugins.check_redis
प्राथमिकता = 1

[द्रष्टा:रेडिस]
सीएमडी = रेडिस-सर्वर
प्राथमिकता = 2

एक बार सर्कस शुरू हो गया redis द्रष्टा, यह शुरू हो जाएगा पंक्तिबद्ध कार्यकर्ता द्रष्टा, तब से
यह अनुसरण करता है प्राथमिकता आदेश देना दूसरा वॉचर शुरू करने से ठीक पहले यह चलेगा
la check_redis फ़ंक्शन, और यदि यह वापस आता है झूठा वॉचर स्टार्टिंग को निरस्त कर देगा
प्रक्रिया.

अंकुड़ा हस्ताक्षर
एक हुक को इस हस्ताक्षर का पालन करना होगा:

डीईएफ़ हुक (देखने वाला, मध्यस्थ, हुक_नाम, **क्वार्ग्स):
...
# यदि आप True नहीं लौटाते हैं, तो हुक बदल सकता है
# सर्कस का व्यवहार (हुक के आधार पर)
सच लौटाओ

कहा पे चौकीदार विश्व का सबसे लोकप्रिय एंव चौकीदार वर्ग उदाहरण, मध्यस्थ la मध्यस्थ एक, हुक_नाम काँटा
नाम और क्वार्ग्स कुछ अतिरिक्त वैकल्पिक पैरामीटर (हुक प्रकार के आधार पर)।

RSI After_spawn हुक पिड पैरामीटर जोड़ता है:

def After_spawn(द्रष्टा, मध्यस्थ, हुक_नाम, पीआईडी, **क्वार्ग्स):
...
# यदि आप सच नहीं लौटाते हैं, तो सर्कस प्रक्रिया को ख़त्म कर देगा
सच लौटाओ

कहा पे पीआईडी संबंधित प्रक्रिया की पीआईडी ​​है।

इसी तरह, before_signal और After_signal हुक पिड और साइनम जोड़ते हैं:

def before_signal_hook(द्रष्टा, मध्यस्थ, हुक_नाम, पीआईडी, साइनम, **क्वार्ग्स):
...
# यदि आप ट्रू नहीं लौटाते हैं, तो सर्कस साइनम सिग्नल नहीं भेजेगा
# (सिगकिल हमेशा भेजा जाता है)
सच लौटाओ

कहा पे पीआईडी संबंधित प्रक्रिया की पीआईडी ​​है और Signum संगत संकेत है.

आप उन्हें अनदेखा कर सकते हैं लेकिन द्रष्टा और/या मध्यस्थ डेटा और विधियों का उपयोग करने में सक्षम होने से आप ऐसा कर सकते हैं
कुछ हुक में उपयोगी हो.

ध्यान दें कि हुक को नामित तर्कों के साथ बुलाया जाता है। तो बिना हुक सिग्नेचर का उपयोग करें
तर्क नाम बदलना.

RSI विस्तारित_आँकड़े हुक के अपने अतिरिक्त पैरामीटर हैं क्वार्ग्स:

डीईएफ़ एक्सटेंडेड_स्टैट्स_हुक(द्रष्टा, मध्यस्थ, हुक_नाम, पीआईडी, आँकड़े, **क्वार्ग्स):
...

कहा पे पीआईडी संबंधित प्रक्रिया की पीआईडी ​​है और आँकड़े होने वाले नियमित आँकड़े
लौटा हुआ। इसमें अपने आँकड़े जोड़ें आँकड़े. एक उदाहरण में है
उदाहरण/uwsgi_losless_reload.py.

अंतिम उदाहरण के रूप में, यहां एक सुपर हुक है जो सभी प्रकार के संकेतों से निपट सकता है:

डीईएफ़ सुपर_हुक(द्रष्टा, मध्यस्थ, हुक_नाम, **क्वार्ग्स):
पीआईडी ​​= कोई नहीं
साइनम = कोई नहीं
यदि हुक_नाम ('बिफोर_सिग्नल', 'आफ्टर_सिग्नल'):
पिड = क्वार्ग्स['पिड']
साइनम = क्वार्ग्स['साइनम']
...
सच लौटाओ

अंकुड़ा घटनाओं
जब भी कोई हुक चलाया जाता है, तो उसका परिणाम सर्कस में एक घटना के रूप में अधिसूचित किया जाता है।

हुक्स से संबंधित दो घटनाएँ हैं:

· हुक_सफलता: एक हुक सफलतापूर्वक बुलाया गया था। इवेंट कुंजियाँ हैं नाम नाम यदि
घटना, और पहर: घटनाओं की तारीख.

· हुक_विफलता: एक हुक विफल हो गया है. इवेंट कुंजियाँ हैं नाम यदि घटना है तो नाम, पहर:
घटनाओं की तारीख और त्रुटि: घटना में घटित अपवाद, यदि कोई हो।

जोड़ना नई आज्ञाओं
हमने नए कमांड जोड़ने को यथासंभव सरल बनाने का प्रयास किया।

आपको तीन काम करने होंगे:

1. एक बनाएँ your_command.py के तहत दर्ज करें सर्कस/आदेश/.

2. पूर्वनिर्धारित विधियों के साथ, वहां एक एकल वर्ग लागू करें

3. इसमें नया कमांड जोड़ें सर्कस/कमांड/__init__.py.

मान लीजिए कि हम एक कमांड जोड़ना चाहते हैं जो वर्तमान में उपयोग में आने वाले दर्शकों की संख्या लौटाता है,
हम ऐसा कुछ करेंगे (आपको और अधिक अनुसरण करने की अनुमति देने के लिए व्यापक रूप से टिप्पणी की गई है
आसानी से):

सर्कस.कमांड.बेस से कमांड आयात करें
circus.exc से ArgumentError, MessageError आयात करें
क्लास न्यूमवॉचर्स (कमांड):
"""यहां यह वर्णन करना एक अच्छा अभ्यास है कि कक्षा क्या करती है।

यह देखने के लिए कि हम प्रारूपित करने के लिए कैसे उपयोग किए जाते हैं, अन्य आदेशों पर एक नज़र डालें
यह पाठ। इसे दस्तावेज़ीकरण में स्वचालित रूप से शामिल किया जाएगा,
इसलिए संपूर्ण होने से डरो मत, इसे इसी तरह बनाया गया है
के.
"" "
# सभी कमांड `circus.commands.base.Command` से प्राप्त होते हैं

# आपको एक नाम निर्दिष्ट करने की आवश्यकता है ताकि हम किसी तरह कमांड वापस पा सकें
नाम = "संख्या देखने वाले"

# अपने डिफ़ॉल्ट व्यवहार को परिभाषित करने के लिए प्रतीक्षा को सही या गलत पर सेट करें
# - यदि प्रतीक्षा सही है, तो कमांड समकालिक रूप से चलाया जाता है, और क्लाइंट को मिल सकता है
#वापस परिणाम.
# - यदि प्रतीक्षा गलत है, तो कमांड तुरंत सर्वर और क्लाइंट पर एसिंक्रोनस रूप से चलाया जाता है
# को 'ठीक' प्रतिक्रिया मिलती है
#
# डिफ़ॉल्ट रूप से, कमांड प्रतीक्षा = गलत पर सेट होते हैं
प्रतीक्षा = सत्य

#विकल्प
विकल्प = [('', 'ऑप्टनाम', डिफॉल्ट_वैल्यू, 'विवरण')]

गुण = ['फू', 'बार']
# गुण उन कमांड तर्कों को सूचीबद्ध करते हैं जो अनिवार्य हैं। अगर वे हैं
# प्रदान नहीं किया गया, तो एक त्रुटि फेंक दी जाएगी

def निष्पादन (स्वयं, मध्यस्थ, सहारा):
# निष्पादन विधि कमांड का मूल है: सभी को यहां रखें
# कमांड का तर्क और आपके मूल्यों से युक्त एक निर्देश वापस करें
#वापसी करना चाहते हैं, यदि कोई हो
वापसी {"numwatchers": arbiter.numwatchers()}

def कंसोल_msg(स्वयं, संदेश):
# संदेश वह है जो निष्पादन विधि द्वारा लौटाया जाता है।
# इस पद्धति का उपयोग कंसोल के लिए प्रतिक्रिया को प्रारूपित करने के लिए किया जाता है (यह है)।
उदाहरण के लिए #circusctl द्वारा अपने संदेशों को मुद्रित करने के लिए उपयोग किया जाता है)
वापसी "एक स्ट्रिंग जो प्रदर्शित की जाएगी"

डीईएफ़ संदेश (स्वयं, *आर्ग, **ऑप्ट्स):
# संदेश कंसोल इनपुट को संभालता है।
# इस विधि का उपयोग कंसोल तर्कों को कमांड में मैप करने के लिए किया जाता है
#विकल्प. (उदाहरण के लिए इसका उपयोग कमांड को कॉल करते समय किया जाता है
#सर्कसक्टल)
यदि फ़ंक्शन गुम है तो # NotImplementedError फेंक दिया जाएगा
संख्याआर्ग = 1
यदि नहीं len(args) == numArgs:
ArgumentError बढ़ाएँ ('तर्कों की अमान्य संख्या।')
अन्य:
opts['optname'] = args[0]
self.make_message(**opts) वापस करें

def मान्य(स्वयं, सहारा):
# इस पद्धति का उपयोग यह सत्यापित करने के लिए किया जाता है कि तर्क पारित हो गए हैं
# आदेश सही है. मामले में एक ArgumentError फेंक दिया जाना चाहिए
# पारित तर्कों में कोई त्रुटि है (उदाहरण के लिए यदि वे
# एक साथ मेल नहीं खाते.
# यदि उनकी सामग्री के संबंध में कोई समस्या है, तो एक MessageError
#फेंक देना चाहिए. यह विधि प्रॉप्स की सामग्री को संशोधित कर सकती है
# dict, इसे बाद में निष्पादित करने के लिए पारित किया जाएगा।

उपयोग मामलों उदाहरण
यह अध्याय कुछ उपयोग के मामले प्रस्तुत करता है, जिससे आपको यह पता चल जाएगा कि सर्कस का उपयोग कैसे करें
पर्यावरण.

रनिंग a डब्लूएसजीआई आवेदन
सर्कस के साथ डब्लूएसजीआई एप्लिकेशन चलाना काफी दिलचस्प है क्योंकि आप देख और प्रबंधित कर सकते हैं
तुंहारे वेब श्रमिकों का उपयोग सर्कस-टॉप, circusctl या वेब इंटरफ़ेस.

यह सर्कस सॉकेट का उपयोग करके संभव बनाया गया है। देखें सर्कस सॉकेट क्यों।

आइए न्यूनतम के साथ एक उदाहरण लें पिरामिड आवेदन:

पिरामिड.कॉन्फिग से कॉन्फिगरेटर आयात करें
पिरामिड.रेस्पॉन्स से प्रतिक्रिया आयात करें

def hello_world(अनुरोध):
वापसी प्रतिक्रिया('हैलो %(नाम)s!' % request.matchdict)

कॉन्फिग = विन्यासकर्ता()
config.add_route('हैलो', '/हैलो/{नाम}')
config.add_view(हैलो_वर्ल्ड, रूट_नाम='हैलो')
एप्लिकेशन = config.make_wsgi_app()

इस स्क्रिप्ट को एक में सहेजें ऐप.पी.ई फ़ाइल, फिर उन परियोजनाओं को स्थापित करें:

$ पिप पिरामिड स्थापित करें
$ पिप इंस्टॉल चौसेट

इसके बाद, सुनिश्चित करें कि आप इसका उपयोग करके अपना पिरामिड एप्लिकेशन चला सकते हैं मौज़ा कंसोल स्क्रिप्ट:

$ चौसेट ऐप.एप्लिकेशन
आवेदन है
लोकलहोस्ट पर सेवा:8080
का उपयोग करते हुए बैकएंड के रूप में

और जांच कर लें कि आप वहां जाकर पहुंच सकते हैं या नहीं http://localhost:8080/हैलो/तारेक

अब जबकि आपका एप्लिकेशन चालू है और चल रहा है, आइए एक सर्कस कॉन्फ़िगरेशन फ़ाइल बनाएं:

[सर्कस]
चेक_विलंब = 5
समापन बिंदु = टीसीपी://127.0.0.1:5555
pubsub_endpoint = टीसीपी://127.0.0.1:5556
आँकड़े_एंडपॉइंट = टीसीपी: //127.0.0.1:5557

[देखने वाला: वेबवर्कर]
सीएमडी = चौसेट --एफडी $(सर्कस.सॉकेट.वेबएप) ऐप.एप्लिकेशन
use_sockets = सच
संख्याप्रक्रम = 3

[सॉकेट:वेबएप]
होस्ट = 127.0.0.1
पोर्ट = 8080

यह फ़ाइल सर्कस को पोर्ट पर सॉकेट बाइंड करने के लिए कहती है 8080 और भाग खड़ा हुआ मौज़ा उस पर कार्यकर्ता
सॉकेट - इसकी एफडी पास करके।

इसे सेव करें सर्वर.आईएनआई और इसका उपयोग करके चलाने का प्रयास करें सर्कसडी

$ सर्कस सर्वर.आईएनआई
[जानकारी] पीआईडी ​​8971 पर मास्टर शुरू करना
[जानकारी] सॉकेट शुरू हो गए
[जानकारी] सर्कस-आँकड़े शुरू हुए
[जानकारी] वेबएप शुरू हुआ
[सूचना] मध्यस्थ अब आदेशों की प्रतीक्षा कर रहा है

सुनिश्चित करें कि आपको ऐप अभी भी चालू है http://localhost:8080/हैलो/तारेक.

बधाई ! आपके पास एक डब्लूएसजीआई एप्लिकेशन है जो 3 कर्मचारियों को चला रहा है।

आप सर्कस httpd या cli चला सकते हैं, और सर्कस प्रबंधन का आनंद ले सकते हैं।

रनिंग a Django आवेदन
Django एप्लिकेशन को चलाना बिल्कुल WSGI एप्लिकेशन को चलाने की तरह ही किया जाता है। उपयोग
अजगरपथ उस निर्देशिका को आयात करने के लिए जिसमें प्रोजेक्ट है, वह निर्देशिका जिसमें शामिल है
वह निर्देशिका जिसमें सेटिंग्स.py है (Django 1.4+ के साथ इस निर्देशिका में मैनेज.py है)
:

[सॉकेट:ड्वेबएप]
होस्ट = 127.0.0.1
पोर्ट = 8080

[देखने वाला:डवेबवर्कर]
cmd = चौसेट --fd $(circus.sockets.dwebapp) dproject.wsgi.application
use_sockets = सच
संख्याप्रक्रम = 2

[env:dwebworker]
PythonPATH = /path/to/parent-of-dproject

यदि आपको उत्तीर्ण होना है DJANGO_SETTINGS_MODULE उदाहरण के लिए, बैकएंड कार्यकर्ता के लिए, आप ऐसा कर सकते हैं
यद्यपि वह भी उत्तीर्ण करें env कॉन्फ़िगरेशन विकल्प:

[द्रष्टा:डीबैकेंड]
cmd = /path/to/script.py
संख्याप्रक्रियाएँ=3

[env:dbackend]
PythonPATH = /path/to/parent-of-dproject
DJANGO_SETTINGS_MODULE=dproject.settings

देख http://chaussette.readthedocs.org चौसेट के बारे में अधिक जानकारी के लिए।

डिज़ाइन निर्णय
कुल स्थापत्य
[चित्र]

सर्कस एक मुख्य प्रक्रिया से बना है जिसे कहा जाता है सर्कसडी जो सभी को चलाने का ख्याल रखता है
प्रक्रियाएं। सर्कस द्वारा प्रबंधित प्रत्येक प्रक्रिया एक चाइल्ड प्रोसेस है सर्कसडी.

प्रक्रियाओं को समूहों में व्यवस्थित किया जाता है जिन्हें कहा जाता है पर नजर रखने वालों. एक चौकीदार मूलतः एक आदेश है
सर्कसडी आपके सिस्टम पर चलता है, और प्रत्येक कमांड के लिए आप कॉन्फ़िगर कर सकते हैं कि आप कितनी प्रक्रियाएँ करते हैं
दौड़ना चाहते हैं।

इसकी अवधारणा चौकीदार यह तब उपयोगी होता है जब आप चल रही सभी प्रक्रियाओं को प्रबंधित करना चाहते हैं
वही आदेश - जैसे उन्हें पुनः आरंभ करें, आदि।

सर्कसडी दो ZeroMQ सॉकेट को बांधता है:

· अनुरोध/प्रतिनिधि - नियंत्रित करने के लिए उपयोग किया जाने वाला सॉकेट सर्कसडी json-आधारित का उपयोग करना आज्ञाओं.

· पब/उप -- एक सॉकेट जहां सर्कसडी घटनाओं को प्रकाशित करता है, जैसे जब कोई प्रक्रिया शुरू की जाती है या
रोका हुआ।

नोट:
अपने नाम के बावजूद, ZeroMQ एक कतार प्रबंधन प्रणाली नहीं है। इसे एक ऐसे समझें
अंतर-प्रक्रिया संचार (आईपीसी) लाइब्रेरी।

एक और प्रक्रिया बुलाई गई सर्कस-आँकड़े द्वारा चलाया जाता है सर्कसडी जब विकल्प सक्रिय हो जाता है.
सर्कस-आँकड़ेका काम एक समर्पित में सीपीयू/मेमोरी उपयोग के आँकड़े प्रकाशित करना है पब/उप
चैनल.

इस विशेष चैनल का उपयोग किया जाता है सर्कस-टॉप और सर्कस-httpd लाइव स्ट्रीम प्रदर्शित करने के लिए
गतिविधि का।

सर्कस-टॉप एक कंसोल स्क्रिप्ट है जो नकल करती है ऊपर का के सभी सीपीयू और मेमोरी उपयोग को प्रदर्शित करने के लिए
सर्कस द्वारा प्रबंधित प्रक्रियाएँ।

सर्कस-httpd वेब प्रबंधन इंटरफ़ेस है जो आपको सर्कस के साथ बातचीत करने देगा। यह
वेब सॉकेट और का उपयोग करके एक लाइव स्ट्रीम प्रदर्शित करता है सर्कस-आँकड़े चैनल, लेकिन आपको भी दें
बात करना सर्कसडी इसके माध्यम से अनुरोध/प्रतिनिधि चैनल.

अंतिम पर कम नहीं, circusctl एक कमांड-लाइन टूल है जो आपको गाड़ी चलाने देता है सर्कसडी इसके माध्यम से
अनुरोध/प्रतिनिधि चैनल.

आपके पास सदस्यता लेने वाले प्लगइन भी हो सकते हैं सर्कसडी's पब/उप चैनल और आपको भेजने दें
को आदेश देता है अनुरोध/प्रतिनिधि चैनल पसंद है circusctl होगा।

सुरक्षा
सर्कस ज़ीरोएमक्यू लाइब्रेरी के शीर्ष पर बनाया गया है और इसमें कोई सुरक्षा नहीं है
प्रोटोकॉल. हालाँकि, आप एक सर्वर पर सर्कस सिस्टम चला सकते हैं और एक एसएसएच सुरंग स्थापित कर सकते हैं
इसे किसी अन्य मशीन से एक्सेस करें।

यह अनुभाग बताता है कि जब आप सर्कस चलाते हैं तो वह आपके सिस्टम पर क्या करता है और समाप्त हो जाता है
एसएसएच सुरंग का उपयोग करने का तरीका बताते हुए।

आप भी पढ़ सकते हैं http://www.zeromq.org/area:faq#toc5

टीसीपी बंदरगाहों
डिफ़ॉल्ट रूप से, सर्कस स्थानीय होस्ट पर निम्नलिखित टीसीपी पोर्ट खोलता है:

· 5555 - सर्कस को नियंत्रित करने के लिए उपयोग किया जाने वाला बंदरगाह circusctl

· 5556 - प्रकाशक/सब्सक्राइबर चैनल के लिए उपयोग किया जाने वाला पोर्ट।

· 5557 - सांख्यिकी चैनल के लिए उपयोग किया जाने वाला पोर्ट - यदि सक्रिय हो।

· 8080 - वेब यूआई द्वारा उपयोग किया जाने वाला पोर्ट - यदि सक्रिय है।

ये पोर्ट क्लाइंट ऐप्स को आपके सर्कस सिस्टम के साथ इंटरैक्ट करने की अनुमति देते हैं, और यह इस पर निर्भर करता है कि कैसे
आपका बुनियादी ढांचा व्यवस्थित है, आप फ़ायरवॉल के माध्यम से इन बंदरगाहों की सुरक्षा करना चाह सकते हैं or
सर्कस को उपयोग करके चलाने के लिए कॉन्फ़िगर करें आईपीसी बंदरगाहों।

यहां केवल आईपीसी प्रवेश बिंदुओं का उपयोग करके सर्कस चलाने का एक उदाहरण दिया गया है:

[सर्कस]
चेक_विलंब = 5
समापन बिंदु = आईपीसी:///var/circus/समापन बिंदु
पबसब_एंडपॉइंट = आईपीसी:///var/circus/pubsub
आँकड़े_अंत बिंदु = आईपीसी:///var/circus/आँकड़े

जब IPC का उपयोग करके कॉन्फ़िगर किया जाता है, तो कमांड को उसी बॉक्स से चलाया जाना चाहिए, लेकिन कोई नहीं चला सकता
टीसीपी का उपयोग करने के विपरीत, उन्हें बाहर से एक्सेस करें। कमांड को एक उपयोगकर्ता के रूप में भी चलाया जाना चाहिए
आईपीसी सॉकेट पथों तक लिखने की पहुंच है। आप इसके स्वामी को संशोधित कर सकते हैं समापन बिंदु का उपयोग
la समापन बिंदु_स्वामी कॉन्फ़िगरेशन विकल्प. यह आपको सर्कसड को रूट उपयोगकर्ता के रूप में चलाने की अनुमति देता है, लेकिन
गैर-रूट प्रक्रियाओं को आदेश भेजने की अनुमति दें सर्कसडी. उपयोग करते समय ध्यान दें समापन बिंदु_स्वामी,
गैर-रूट प्रक्रियाओं को मनमानी प्रक्रियाएं शुरू करने से रोकने के लिए
अधिक विशेषाधिकारों के साथ चलाएँ, ऐड कमांड यह लागू करेगा कि नए वॉचर्स को इसी रूप में चलाना होगा
la समापन बिंदु_स्वामी उपयोगकर्ता. स्थानीय कॉन्फ़िगरेशन फ़ाइलों में वॉचर परिभाषाएँ नहीं होंगी
इस तरह से प्रतिबंधित.

बेशक, यदि आप वेब यूआई सक्रिय करते हैं, तो 8080 पोर्ट अभी भी खुला रहेगा.

सर्कसhttpd
जब आप दौड़ते हैं सर्कसhttpd मैन्युअल रूप से, या जब आप इसका उपयोग करते हैं httpd ini फ़ाइल में विकल्प जैसे
इस:

[सर्कस]
चेक_विलंब = 5
समापन बिंदु = आईपीसी:///var/circus/समापन बिंदु
पबसब_एंडपॉइंट = आईपीसी:///var/circus/pubsub
आँकड़े_अंत बिंदु = आईपीसी:///var/circus/आँकड़े
httpd = 1

वेब एप्लिकेशन पोर्ट पर चलेगा 8080 और किसी को भी वेब पेज तक पहुंचने देगा
प्रबंधन करें सर्कसडी डेमॉन।

इसमें नए वॉचर्स बनाना शामिल है जो आपके सिस्टम पर कोई भी कमांड चला सकते हैं!

Do नहीं बनाना it सार्वजनिक रूप से उपलब्ध

यदि आप वेब पैनल तक पहुंच की सुरक्षा करना चाहते हैं, तो आप इसे Nginx या के पीछे सेवा दे सकते हैं
अपाचे या कोई प्रॉक्सी-सक्षम वेब सर्वर, जो सुरक्षा का ख्याल रख सकता है।

उपयोगकर्ता और समूह अनुमतियाँ
डिफ़ॉल्ट रूप से, सर्कस के साथ शुरू हुई सभी प्रक्रियाएँ एक ही उपयोगकर्ता और समूह के साथ चलेंगी
as सर्कसडी. सिस्टम पर उपयोगकर्ता के विशेषाधिकारों के आधार पर, हो सकता है कि आपके पास न हों
सर्कस द्वारा प्रदान की जाने वाली सभी सुविधाओं तक पहुंच।

उदाहरण के लिए, चल रही प्रक्रियाओं पर कुछ सांख्यिकी सुविधाओं के लिए विस्तारित विशेषाधिकारों की आवश्यकता होती है।
आमतौर पर, यदि आपको सीपीयू उपयोग संख्या का उपयोग मिलता है आँकड़े आदेश हैं एन / ए, इसका मतलब है आपका
उपयोगकर्ता proc फ़ाइलों तक नहीं पहुंच सकता. मैक ओएस एक्स के तहत डिफ़ॉल्ट रूप से यही स्थिति होगी।

आप चला सकते हैं सर्कसडी इसे ठीक करने के लिए रूट के रूप में, और सेट करें यूआईडी और gid प्रत्येक दर्शक के लिए मूल्य
सभी सुविधाएं पाने के लिए.

लेकिन उस दौड़ से सावधान रहें सर्कसडी जैसा कि रूट आपको संभावित विशेषाधिकार वृद्धि के लिए उजागर करता है
कीड़े. हालाँकि हम किसी भी बग से बचने की पूरी कोशिश कर रहे हैं, रूट के रूप में चल रहे हैं और बग का सामना कर रहे हैं
आपके सिस्टम पर अवांछित कार्य करना खतरनाक हो सकता है।

इसे रोकने का सबसे अच्छा तरीका यह सुनिश्चित करना है कि सिस्टम पूरी तरह से सर्कस चला रहा है
पृथक (वीएम की तरह) or पूरे सिस्टम को एक नियंत्रित उपयोगकर्ता के तहत चलाने के लिए।

एसएसएच सुरंग
ग्राहक a से जुड़ सकते हैं सर्कसडी उदाहरण के लिए SSH सुरंग बनाकर। ऐसा करने के लिए, पास करें
कमांड लाइन विकल्प --ssh द्वारा पीछा उपयोगकर्ता@पता, जहां उपयोगकर्ता रिमोट पर उपयोगकर्ता है
सर्वर और पता क्लाइंट द्वारा देखा गया सर्वर का पता है। SSH प्रोटोकॉल होगा
लॉगिन पूरा करने के लिए क्रेडेंशियल की आवश्यकता है।

If सर्कसडी जैसा कि SSH सर्वर द्वारा देखा गया है, डिफ़ॉल्ट समापन बिंदु पते पर नहीं है स्थानीय होस्ट: 5555
फिर निर्दिष्ट करें सर्कसडी विकल्प का उपयोग कर पता --अंत बिंदु

सिक्योर्ड व्यवस्था उदाहरण
एक सुरक्षित सर्कस सर्वर की स्थापना निम्न द्वारा की जा सकती है:

· SSH सर्वर चलाना

· Apache या Nginx को चालू करना 80 पोर्ट, और पर रिवर्स-प्रॉक्सी कर रहा है 8080 बंदरगाह।

· अवरुद्ध करना 8080 बाहरी पहुंच से बंदरगाह।

· टीसीपी पोर्ट के बजाय आईपीसी फाइलों का उपयोग करके सभी ZMQ सर्कस पोर्ट चलाना, और सभी को टनल करना
SSH के माध्यम से कॉल करता है.
[चित्र]

योगदान सेवा मेरे सर्कस
सर्कस की शुरुआत मोज़िला में हो चुकी है लेकिन इसका लक्ष्य सिर्फ वहीं तक सीमित रहना नहीं है. कोशिश कर रहे थे
एक ऐसा उपकरण बनाना जो दूसरों के लिए उपयोगी हो और आसानी से विस्तार योग्य हो।

हम वास्तव में कोड, दस्तावेज़ीकरण, चर्चा आदि के रूप में किसी भी योगदान के लिए तैयार हैं।
फीचर प्रस्ताव आदि

आप हमारी मेलिंग सूची में एक विषय शुरू कर सकते हैं: http://tech.groups.yahoo.com/group/circus-dev/

या हमारे में एक मुद्दा जोड़ें बग ट्रैकर

फिक्सिंग लेखन और बढ़ाने la दस्तावेज़ीकरण
यह पूरी तरह संभव है कि इस आधी अंग्रेजी को पढ़ते समय आपकी आंखों से खून बह रहा हो
अर्ध-फ़्रेंच दस्तावेज़ीकरण, किसी भी पुनर्लेखन/संवर्द्धन में योगदान करने में संकोच न करें
दस्तावेज़ में प्रपत्र. आपको शायद यह समझने की ज़रूरत भी नहीं है कि सर्कस कैसे काम करता है
ऐसा करने के लिए हुड के नीचे।

जोड़ना नई विशेषताएं
नई सुविधाएँ निश्चित रूप से बहुत सराहनीय हैं। यदि आपके पास आवश्यकता और समय है
नई सुविधाओं पर काम करें, उन्हें सर्कस में जोड़ना इतना जटिल नहीं होना चाहिए। हमने बहुत कोशिश की
एक साफ़ और समझने योग्य एपीआई प्राप्त करना कठिन है, आशा है कि यह उद्देश्य पूरा करेगा।

आपको नई सुविधा के कोड के साथ दस्तावेज़ीकरण और परीक्षण जोड़ने की आवश्यकता होगी।
अन्यथा हम पैच स्वीकार नहीं कर पाएंगे.

कैसे सेवा मेरे प्रस्तुत तुंहारे परिवर्तन
हम git का उपयोग DVCS के रूप में कर रहे हैं। परिवर्तनों का प्रस्ताव करने का सबसे अच्छा तरीका अपनी एक शाखा बनाना है
पक्ष (के माध्यम से) Git जांच -b शाखा का नाम) और वहां अपने परिवर्तन करें। एक बार आपके पास है
प्राइम-टाइम के लिए कुछ तैयार है, इस शाखा के विरुद्ध पुल अनुरोध जारी करें।

हम आपकी सुविधाओं के बीच कम युग्मन की अनुमति देने के लिए इस मॉडल का अनुसरण कर रहे हैं
प्रस्ताव उदाहरण के लिए, हम चर्चा में रहते हुए भी एक पुल अनुरोध स्वीकार कर सकते हैं
दूसरे के लिए.

अपने परिवर्तनों का प्रस्ताव देने से पहले, दोबारा जांच लें कि वे कुछ भी तोड़ नहीं रहे हैं! तुम कर सकते हो
उपयोग tox यह सुनिश्चित करने के लिए कमांड, यह अलग-अलग के तहत टेस्टसूट चलाएगा
समर्थित पायथन संस्करण।

इस्तेमाल करें : http://issue2pr.herokuapp.com/ किसी मौजूदा सर्कस के प्रति प्रतिबद्धता का संदर्भ देने के लिए
मुद्दा, यदि कोई हो.

बचना मर्ज करता है
मर्ज कमिट से बचने से स्वच्छ और पठनीय इतिहास प्राप्त करने की अनुमति मिलती है। इसके बजाय, ऐसा करने के लिए
"गिट पुल" करना और गिट पुल --रीबेस का उपयोग करके गिट को आपके लिए मर्ज को संभालने देना होगा
शाखा में किए गए परिवर्तनों के बाद, या काम करते समय अपने परिवर्तन डालें
गुरुजी।

यानी, हम कोर डेवलपर्स के लिए, सुविधाजनक जीथब ग्रीन का उपयोग करना अब संभव नहीं है
यदि डेवलपर्स ने स्वयं अपना काम दोबारा आधारित नहीं किया है या हम प्रतीक्षा करते हैं तो पुल अनुरोधों पर बटन
अनुरोध और वास्तविक मर्ज के बीच बहुत अधिक समय। इसके बजाय, प्रवाह इस तरह दिखता है:

गिट रिमोट नाम रेपो-यूआरएल जोड़ें
गिट फ़ेच नाम
गिट चेकआउट सुविधा-शाखा
गिट रिबेस मास्टर

# जांचें कि सब कुछ ठीक से काम कर रहा है और फिर मास्टर पर मर्ज करें
गिट चेकआउट मास्टर
गिट मर्ज फीचर-शाखा

पर चर्चा
यदि आपको सर्कस का कोड देखते समय किसी सहायता की आवश्यकता महसूस हो तो आप जा सकते हैं
और हमें irc पर खोजें #सरकस का तंबू on irc.freenode.org (या यदि आपके पास कोई आईआरसी नहीं है
ग्राहक, उपयोग करें la वैब वार्तालाप)

आप हमारी मेलिंग सूची में भी एक थ्रेड शुरू कर सकते हैं -
http://tech.groups.yahoo.com/group/circus-dev

अक्सर यह पूछने पर प्रशन
यहां सर्कस के बारे में अक्सर पूछे जाने वाले प्रश्नों की सूची दी गई है:

कैसे कर देता है सर्कस धुआँरा तुलना सेवा मेरे a क्लासिक ढेर?
क्लासिकल डब्लूएसजीआई स्टैक में, आपके पास गुनिकॉर्न जैसा एक सर्वर होता है जो पोर्ट या एएन पर कार्य करता है
यूनिक्स सॉकेट और आमतौर पर इसे Nginx जैसे वेब सर्वर के पीछे तैनात किया जाता है: [छवि]

ग्राहक Nginx को कॉल करते हैं, जो सभी कॉलों को Gunicorn पर रिवर्स प्रॉक्सी करता है।

यदि आप यह सुनिश्चित करना चाहते हैं कि गुनिकॉर्न प्रक्रिया चालू रहे, तो आपको इसका उपयोग करना होगा
सुपरवाइज़र्ड या अपस्टार्ट जैसे प्रोग्राम।

गुनिकॉर्न बदले में अपनी प्रक्रियाओं ("श्रमिकों") पर नज़र रखता है।

दूसरे शब्दों में आप प्रक्रिया प्रबंधन के दो स्तरों का उपयोग कर रहे हैं। एक जिसे आप प्रबंधित करते हैं और
नियंत्रण (पर्यवेक्षक), और दूसरा जिसे आपको एक अलग यूआई में प्रबंधित करना होगा, एक के साथ
भिन्न दर्शन और जो हो रहा है उस पर कम नियंत्रण (डब्ल्यूएसजीआई सर्वर का एक)

यह गुनिकॉर्न और अधिकांश मल्टी-प्रोसेस डब्लूएसजीआई सर्वरों के लिए सच है जिनके बारे में मैं जानता हूं।
uWsgi थोड़ा अलग है क्योंकि यह ढेर सारे विकल्प प्रदान करता है।

लेकिन यदि आप अपने स्टैक में रेडिस सर्वर जोड़ना चाहते हैं, तो आप मर्जी अपने प्रबंधन के साथ समाप्त करें
दो अलग-अलग स्थानों में स्टैक प्रक्रियाएँ।

इस पर सर्कस का दृष्टिकोण प्रक्रियाओं का प्रबंधन करना है और सॉकेट।

एक सर्कस स्टैक इस तरह दिख सकता है: [छवि]

तो, गुनिकॉर्न की तरह, सर्कस एक सॉकेट को बांधने में सक्षम है जिसे Nginx द्वारा प्रॉक्सी किया जाएगा। सर्कस
अनुरोधों से निपटें नहीं बल्कि केवल सॉकेट को बांधें। फिर यह एक वेब वर्कर पर निर्भर है
सॉकेट पर कनेक्शन स्वीकार करने और कार्य करने की प्रक्रिया।

यह सुपरवाइज़र की तुलना में समतुल्य सुविधाएँ प्रदान करता है लेकिन आपको सभी को प्रबंधित करने की सुविधा भी देगा
प्रक्रियाएं समान स्तर पर हों, चाहे वे वेब वर्कर हों या रेडिस या कुछ और। एक जोड़ना
नया वेब वर्कर ठीक उसी तरह किया जाता है जैसे एक नई रेडिस प्रक्रिया को जोड़ना।

न्यायपीठों
हमने सर्कस और चौसेट की गुनिकॉर्न से तुलना करने के लिए कुछ बेंचें बनाईं। संक्षेप में कहें तो सर्कस है
कोई ओवरहेड नहीं जोड़ रहा है और आप अपने वेब कर्मचारियों के लिए कई अलग-अलग बैकएंड चुन सकते हैं।

देखें:

· http://blog.ziade.org/2012/06/28/wgsi-web-servers-bench

· http://blog.ziade.org/2012/07/03/wsgi-web-servers-bench-part-2

कैसे सेवा मेरे समस्याओं का निवारण सर्कस?
डिफ़ॉल्ट रूप से, सर्कसडी इसकी लॉगिंग को रखता है stdout बल्कि विरल. आउटपुट की यह कमी हो सकती है
जब प्रक्रियाओं को शुरू करने में समस्या आ रही हो तो समस्या का निवारण करना कठिन बना दें।

लॉगिंग बढ़ाने के लिए सर्कसडी प्रदान करता है, लॉग स्तर बढ़ाने का प्रयास करें। देखने के लिए
उपलब्ध लॉग स्तर का उपयोग करें --मदद झंडा।

$ सर्कस--लॉग-स्तरीय डिबग test.ini

चेतावनी का एक शब्द. यदि कोई प्रक्रिया फ़्लैप हो रही है और डिबग लॉग स्तर चालू है, तो आप
प्रत्येक प्रारंभ प्रयास के लिए संदेश देखेंगे. यह उस ऐप को कॉन्फ़िगर करने में मददगार हो सकता है
उपयोग करने के लिए फड़फड़ाना वार्मअप_देरी संदेशों को प्रबंधनीय गति से धीमा करने के लिए।

[दर्शक:वेबएप]
सीएमडी = पायथन -एम myapp.wsgi
वार्मअप_देरी = 5

डिफ़ॉल्ट रूप से, stdout और stderr द्वारा कब्जा कर लिया गया है सर्कसडी प्रक्रिया। यदि आप अपना परीक्षण कर रहे हैं
config और सर्कस आउटपुट के अनुरूप आउटपुट देखना चाहते हैं, तो आप अपना कॉन्फ़िगर कर सकते हैं
उपयोग करने के लिए द्रष्टा स्टडआउटस्ट्रीम वर्ग.

[दर्शक:वेबएप]
सीएमडी = पायथन -एम myapp.wsgi
stdout_stream.class = StdoutStream
stderr_stream.class = StdoutStream

यदि आपका एप्लिकेशन आपको प्रारंभ करने का प्रयास करते समय ट्रेसबैक या त्रुटि उत्पन्न कर रहा है
इसे आउटपुट में देखने में सक्षम होना चाहिए।

चैंज इतिहास
0.12.1 - 2015-08-05
· आउटपुट स्ट्रीम के साथ वॉचर को पुनः प्रारंभ करते समय त्रुटि ठीक करें - #913

· दस्तावेज़ में मामूली बदलाव

0.12 - 2015-06-02
यह रिलीज़ कई रोमांचक चीज़ों के अलावा Python 3.4, Tornado 4 और Windows सपोर्ट लेकर आती है
सुविधाएँ और सुधार.

विंडोज़ समर्थन अभी भी प्रयोगात्मक है, और स्ट्रीम को संभाल नहीं पाता है।

बड़े बदलाव:

· पायथन 3.4 के साथ संगतता - #768

· प्रायोगिक विंडोज़ समर्थन - #788

· टॉरनेडो 4 के साथ संगतता - #872

· पुनर्निर्मित डेबियन पैकेजिंग - #896 - #903

· पापा प्रक्रिया कर्नेल के लिए समर्थन जोड़ें - #850

· देखने वालों को शुरू करने, रोकने और पुनः आरंभ करने के लिए ग्लोबिंग और रेगेक्स मिलान जोड़ें - #829 -
#902

अधिक परिवर्तन:

· शटडाउन का अनुकूलन - #784 - #842

· दर्शकों के लिए वर्चुअलएन्व संस्करण निर्दिष्ट करने की संभावना जोड़ें - #805

· rmwatcher कमांड में --nostop विकल्प जोड़ें - #777

· Arbiter.start - #840 पर कॉलबैक जोड़ें

· बड़े अक्षरों से पुनः लोड करने वाले वॉचर्स को ठीक करें - #823

· स्टैटिस्टिक्स डेमॉन में लीक हो रहे सॉकेट को हटाएं - #843

· SunOS पर मल्टीकास्ट ठीक करें - #876

· किसी दर्शक को रोकते समय आउटपुट स्ट्रीम बंद करें - #885

· --पुनरावर्ती - #888 के साथ पोते-पोतियों को सिग्नल भेजना ठीक करें

0.11.1 - 2014-05-22
· 2.6 - #782 पर सर्कस को तोड़ने वाले प्रतिगमन को ठीक किया गया

0.11 - 2014-05-21
यह रिलीज़ बहुत सारी सुविधाएँ पेश नहीं कर रही है, और सर्कस को और अधिक बनाने पर केंद्रित है
मजबूत एवं स्थिर.

प्रमुख परिवर्तन/सुधार:

· सुनिश्चित करें कि हम मध्यस्थ पर दो परस्पर विरोधी आदेशों को एक साथ निष्पादित नहीं कर सकते।

· हमारे पास 2 नई स्ट्रीम क्लास हैं: TimedRotatingFileStream, WatchedFileStream

· हमारे पास एक नया हुक है: आफ्टर_स्पॉन हुक

· सर्कसप्लगइन का उपयोग करना आसान है

· ऑटोस्टार्ट को ठीक करें=शुरुआत के दौरान गलत दर्शक (प्रतिगमन)

अधिक परिवर्तन:

· सर्कस संदेशों को अब syslog पर भेजा जा सकता है - #748

· एंडपॉइंट_ओनर विकल्प जोड़ा गया ताकि हम यह परिभाषित कर सकें कि किस उपयोगकर्ता द्वारा बनाई गई आईपीसी सॉकेट फ़ाइलों का स्वामित्व है
सर्कस

· विंडोज़ समर्थन प्रारंभ किया गया (अभी के लिए केवल सर्कस)

· परीक्षणों में बहुत सारी लीक ठीक की गईं

· केस संवेदनशील पर्यावरण चर की अनुमति दें

· संसाधन प्लगइन अब पूर्ण मेमोरी मान स्वीकार करता है - #609

· 'सिंगलटन' विकल्प के लिए ऐड कमांड में समर्थन जोड़ें - #767

· संसाधन निगरानीकर्ता के माध्यम से चाइल्ड प्रोसेस को मनमाने सिग्नल भेजने की अनुमति दें - #756

· लॉगिंग के लिए INI/JSON/YAML कॉन्फ़िगरेशन की अनुमति दें

· सुनिश्चित करें कि हम psutil 2.x के साथ संगत हैं और 3.x

· सांख्यिकी प्रदाता में और अधिक मेट्रिक्स जोड़े गए - #698

· फिक्स्ड मल्टीकास्ट डिस्कवरी - #731

· प्रारंभ करें, पुनरारंभ करें और अधिक समान पुनः लोड करें - #673

· सभी उपयोग समूहों को सही ढंग से प्रारंभ करें - #635

· बेहतर परीक्षण स्थिरता

· बहुत सारी, और भी बहुत सी बातें....

0.10 - 2013-11-04
बड़े बदलाव:

· अब पायथन 3.2 और 3.3 संगत - #586

· कोर को पूरी तरह से एसिंक मॉडल में ले जाया गया - #569

· बेहतर दस्तावेज़ीकरण - #622

अधिक परिवर्तन:

· स्टॉप_सिग्नल और स्टॉप_चिल्ड्रन जोड़ा गया - #594

· सुनिश्चित करें कि वॉचडॉग प्लगइन सॉकेट बंद कर देता है - #588

· ZMQ JSON पार्सर पर स्विच किया गया

· IN सभी प्लेटफ़ॉर्म पर समर्थित नहीं है - #573

· किसी भी कॉन्फ़िगरेशन अनुभाग में वैश्विक पर्यावरण प्रतिस्थापन की अनुमति दें - #560

· अनुभाग नामों में डैश की अनुमति दें - #546

· अब कॉन्फ़िगरेशन में हर जगह वेरिएबल का विस्तार किया गया है - #554

· CommandReloader प्लगइन जोड़ा गया

· before_signal औरafter_signal हुक जोड़े गए

· फ़्लैपिंग प्लगइन को अनिश्चित काल तक पुनः प्रयास करने की अनुमति दें

· जब देखने वाला रुक रहा हो तो प्रॉसेस को दोबारा उत्पन्न न करें - #529 - #536

· प्रत्येक ग्राहक संदेश के लिए एक अद्वितीय आईडी जोड़ी गई - #517

· कार्यकर्ता आईडी अब "स्लॉट" हैं -

· सुंदर शटडाउन व्यवहार को ठीक किया गया - #515

· सुनिश्चित करें कि आर्बिटर शुरू न होने पर भी हम पर्यवेक्षकों को जोड़ सकते हैं - #503

· सुनिश्चित करें कि हम समाप्त हो चुकी प्रक्रिया - #510 को पॉप करें

· सुनिश्चित करें कि सेट कमांड कई हुक सेट कर सकता है

· आईपीवी6 सॉकेट को सही ढंग से सपोर्ट करें - #507

· stdout_stream और stderr_stream के लिए कस्टम विकल्पों की अनुमति दें - #495

· फाइलस्ट्रीम के लिए टाइम_फॉर्मेट जोड़ा गया - #493

· नाम से एक विशिष्ट इंटरफ़ेस से जुड़ने के लिए नया सॉकेट कॉन्फ़िगरेशन विकल्प जोड़ा गया

0.9.3 - 2013-09-04
· सुनिश्चित करें कि यदि मध्यस्थ शुरू नहीं हुआ है तो भी हम पर्यवेक्षकों को जोड़ सकते हैं

· सुनिश्चित करें कि हम समाप्त हो चुकी प्रक्रिया को पॉप कर दें

· सुनिश्चित करें कि सेट कमांड एक या कई हुक सेट कर सकता है

· आईपीवी6 सॉकेट और सर्कस सॉकेट के सुधारों का सही ढंग से समर्थन करें

· अनबाउंडलोकल एरर को रोकने के लिए पथ डिफ़ॉल्ट मान दें

· नियंत्रक आरंभीकरण में मल्टीकास्ट_एंडपॉइंट अस्तित्व के लिए एक परीक्षण जोड़ा गया

· अंकों की प्रत्येक स्ट्रिंग को अब इनट्स में परिवर्तित नहीं किया जा रहा है

· परीक्षण जोड़ें

· stdout_stream विकल्पों को परिवर्तित करते समय विशेष मामलों की कोई आवश्यकता नहीं है

· उमास्क को निरंतरता के तर्क के रूप में भी स्वीकार करें

· stdout_stream और stderr_stream के लिए कस्टम विकल्पों की अनुमति दें।

· नाम से किसी विशिष्ट इंटरफ़ेस से जुड़ने के लिए नया सॉकेट कॉन्फ़िगरेशन विकल्प जोड़ें

· FileStream + परीक्षणों के लिए time_format जोड़ें

· सर्कस.अपस्टार्ट को अपडेट करें

0.9.2 - 2013-07-17
· जब एक PYTHONPATH को एक कॉन्फ़िगरेशन फ़ाइल में परिभाषित किया जाता है, तो इसे sys.path में लोड किया जाता है ताकि हुक हो सकें
वहां स्थित है - #477, #481

· add_callback के लिए एकल तर्क का उपयोग करें ताकि यह PyZMQ < 13.1.x के साथ काम करे - #478 देखें

0.9 - 2013-07-16
· [env] अनुभाग वाइल्डकार्ड जोड़े गए

· वैश्विक [env] अनुभाग जोड़ा गया

· सर्कस-वेब स्थापित नहीं होने पर छिपे हुए अपवाद को ठीक किया गया - #424

· सुनिश्चित करें कि incr/decr कमांड वास्तव में हमारे लिए nb विकल्प है - #421

· वॉचर वर्चुअलएन्व साइट-पैकेज को ठीक करें जो PythonPATH में नहीं हैं

· सुनिश्चित करें कि हम 0 - #429 से अधिक प्रक्रियाओं को हटाने का प्रयास न करें

· अद्यतन Bootstrap.py - #436

· पायथॉनपाथ वर्चुअलएनवी वॉचर में फिक्स्ड मल्टीप्लेटफॉर्म सेपरेटर

· रिफैक्टर सॉकेट क्लोज फ़ंक्शन

· सुनिश्चित करें कि पर्यावरण अनुभाग सभी दर्शकों पर लागू हों - #437

· reloadconfig कमांड जोड़ा गया

· सर्कस.ग्रीन जोड़ा गया और कोर से गीवेंट हटा दिया गया - #441, #452

· परीक्षणों में नकली स्टडआउट और चेतावनियों को शांत किया गया - #438

· $(circus.env.*) का उपयोग अब कॉन्फ़िगरेशन में सभी विकल्पों के लिए किया जा सकता है

· एक before_spawn हुक जोड़ा गया

· सिस्टमडी सर्विस फ़ाइल में सर्कसड का पथ ठीक करें - #450

· सुनिश्चित करें कि हम सीएलआई - #455 के माध्यम से हुक बदल सकते हैं और स्ट्रीम सेट कर सकते हैं

· बेहतर दस्तावेज़

· वॉचर में एक स्पॉन_काउंट स्टेट जोड़ा गया

· रिसोर्सवॉचर प्लगइन में min_cpu और min_mem पैरामीटर जोड़े गए

· मध्यस्थ में FQDN जानकारी जोड़ी गई।

0.8.1 - 2013-05-28
· सर्कस-स्टैट्स यूनिक्स सॉकेट्स पर अटक रहा था - #415

· सर्कस-आँकड़े और सर्कसएचटीपीडी चाइल्ड प्रोसेस stdout/stderr अब डिफ़ॉल्ट रूप से खुले छोड़ दिए गए हैं।
2.7.5/2 एफडीएस बंद होने की स्थिति में पायथन <= 3 लॉगिंग मॉड्यूल में बंद हो जाएगा - #415

· अब चाइल्ड प्रोसेस को बंद करने के बजाय /dev/null पर रीडायरेक्ट कर रहा है। #417

0.8 - 2013-05-24
· zmq io लूप में एकीकृत लॉग हैंडलर।

· पुनर्निर्देशक को पुनः आरंभ करने योग्य और बाद में अधिक मजबूत बनाएं।

· जीवेंट का पता चलने पर zmq.green.eventloop का उपयोग करता है

· circusctl - #396 में CIRCUSCTL_ENDPOINT पर्यावरण चर के लिए समर्थन जोड़ा गया

· उपयोग: to_uid फ़ंक्शन में बग ठीक करें - #397

· आईओलूप त्रुटि पर हैंडलर हटाएं - #398।

· बेहतर परीक्षण कवरेज

· रिसोर्सवॉचर प्लगइन के लिए 'सेवा' विकल्प को हटा दिया गया - #404

· psutil.error उपयोग हटा दिया गया

· सर्कस में यूडीपी डिस्कवरी जोड़ी गई - #407

· अब मनमाने निर्देशिका स्तरों पर ग्लब्स की अनुमति - #388

· 'statd' कॉन्फ़िगरेशन विकल्प जोड़ा गया - #408

· सर्कस कॉन्फ़िगरेशन फ़ाइल में पिडफ़ाइल, लॉगआउटपुट और लॉगलेवल विकल्प जोड़ें - #379

· दस्तावेज़ों में एक ट्यूटोरियल जोड़ा गया.

· इन्क्लूड - #414 का उपयोग करते समय सुनिश्चित करें कि हम सभी अनुभागों का विलय कर रहे हैं

· इसमें पाइप_स्टडआउट, पाइप_स्टडर, क्लोज़_चाइल्ड_स्टडर और क्लोज़_चाइल्ड_स्टडआउट विकल्प जोड़े गए
प्रक्रिया वर्ग

· वॉचर में क्लोज़_चाइल्ड_स्टडर और क्लोज़_चाइल्ड_स्टडआउट विकल्प जोड़े गए

0.7.1 - 2013-05-02
· रिस्पॉन विकल्प को ठीक किया गया - #382

· सुनिश्चित करें कि हम टाइमआउट के लिए int का उपयोग करते हैं - #380

· यूनिक्स सॉकेट भी प्रदर्शित करें - #381

· सुनिश्चित करें कि यह नवीनतम pyzmq के साथ काम करता है

· एफडी नोटेशन के लिए दूसरा सिंटैक्स पेश किया गया

0.7 - 2013-04-08
· वॉचर्स तर्क के लिए एक निर्देश का उपयोग करने के लिए get_arbiter उदाहरण को ठीक करें। #304

· कुछ समस्या निवारण दस्तावेज़ #323 जोड़ें

· पायथन बिल्डआउट समर्थन जोड़ें

· गीवेंट और थ्रेड रीडायरेक्टर्स को हटा दिया गया। अब ioloop का उपयोग कर रहा हूँ - #346 को ठीक करता है।
#340 से संबंधित है

· सर्कस.वेब अब अपना स्वयं का प्रोजेक्ट है

· pyzmq पैचिंग हटा दी गई

· वॉचर को कॉन्फ़िगर होने दें लेकिन प्रारंभ न होने दें #283

· वर्चुअलएन्व साइट डीआईआर लोड करने के लिए एक विकल्प जोड़ें

· ऑन_डिमांड दर्शकों को जोड़ा गया

· nginx+websockets #371 के बारे में दस्तावेज़ जोड़ा गया

· अब प्रत्येक कमांड #369 की विकल्प सूची को ठीक से पार्स करना

· #372 को संभालने वाले सर्कस-आँकड़े की घटनाओं को ठीक किया गया

· सर्कस-टॉप #378 में ओवरफ्लो समस्या को ठीक किया गया

· और भी बहुत सी बातें...

0.6 - 2012-12-18
· सॉकेट के लिए पैचिंग प्रोटोकॉल का नाम - #248

· ग्राफ़ को ऑटोस्केल न करें. #240

· सर्कससीटीएल: डॉकस्ट्रिंग्स #217 से प्रति कमांड सहायता जोड़ें

· श्रमिक हुक जोड़े गए

· डेबियन पैकेज जोड़ा गया - #227

· रेडिस, HTTP ऑब्जर्वर, पूर्ण आँकड़े और संसाधन प्लगइन्स जोड़े गए

· अब प्रक्रियाओं के शीर्षक हो सकते हैं

· स्वतः पूर्णता जोड़ा गया

· वेबुई में प्रक्रिया/दर्शक की उम्र जोड़ी गई

· एसएसएच सुरंग समर्थन जोड़ा गया

· अब pyzmq.green का उपयोग कर रहे हैं

· अपस्टार्ट स्क्रिप्ट और वार्निश दस्तावेज़ जोड़ा गया

· पर्यावरण चर और अनुभाग जोड़े गए

· यूनिक्स सॉकेट समर्थन जोड़ा गया

· जोड़ा गया respawn सिंगल-रन वॉचर्स रखने का विकल्प

· अब परीक्षणों में टॉक्स का उपयोग

· आर्ग्स में सॉकेट प्रतिस्थापन की अनुमति दें

· नई डॉक थीम

· स्ट्रीम के लिए नए रोटेशन विकल्प: max_bytes/backup_count

0.5.2 - 2012-07-26
· अब कुछ पायथन बग्स से बचने के लिए stdlib से थ्रेड मॉड्यूल को पैच कर रहा हूँ - #203

· बेहतर दिखने वाली सर्कससीटीएल सहायता स्क्रीन

· उपलब्ध होने पर pustil get_nice() का उपयोग करता है (नाइस को हटा दिया गया था) - #208

· अधिकतम आयु समर्थन जोड़ा गया - #221

· केवल SOCK_STREAM या SOCK_SEQPACKET सॉकेट पर सुनें() को कॉल करें

· सुनिश्चित करें कि नियंत्रक update_watchers() - #220 में प्लगइन्स सूची को खाली कर दे

· सर्कसhttpd में --लॉग-लेवल और --लॉग-आउटपुट जोड़ा गया

· वेब यूआई के माध्यम से प्रक्रिया को खत्म करने को ठीक करें - #219

· अब सर्कस स्क्रिप्ट के लिए zc.buildout संगत है।

· क्लाइंट के डिस्कनेक्ट होने पर वेबसॉकेट को साफ़ करें - #225

· समापन बिंदु के लिए डिफ़ॉल्ट मान तय किया गया - #199

· तार्किक मॉड्यूल में विभाजित सर्कसhttpd

0.5.1 - 2012-07-11
· दस्तावेज़ीकरण में बहुत सारी टाइपो त्रुटियों को ठीक किया गया

· डिबग विकल्प जोड़ा गया

· वेब-requirements.txt को ठीक से पैकेज करें

· संदेशों में एक त्रुटि कोड जोड़ा गया - #111 को ठीक किया गया

0.5 - 2012-07-06
· सॉकेट समर्थन जोड़ा गया

· एक लिस्टसॉकेट कमांड जोड़ा गया

· सॉकेट में आँकड़े भी होते हैं!

· बहुत सी छोटी-मोटी बग ठीक की गईं

· विड हटा दिया गया - अब हर जगह पिड का उपयोग किया जा रहा है

· तेज़ परीक्षण

· वेरिएबल सिंटैक्स को बदल दिया

· अधिक स्थानों पर pyzmq के iooop का उपयोग करें

· अब सभी चुनिंदा() कॉलों के लिए iowait का उपयोग किया जा रहा है

· incr/decr कमांड में अब एक nbprocess पैरामीटर है

· दर्शकों के लिए एक रिप्रोड्यूस_एनवी विकल्प जोड़ें

· प्रक्रियाओं में एक नई UNEXISTING स्थिति जोड़ें

· वैश्विक जोड़ा गया httpd एक दर्शक के रूप में सर्कसhttpd चलाने का विकल्प

0.4 - 2012-06-12
· एक प्लगइन सिस्टम जोड़ा गया

· दर्शकों के लिए एक "सिंगलटन" विकल्प जोड़ा गया

· सर्कस-टॉप स्क्रीन की टिमटिमाहट को ठीक किया गया

· zmq आवधिक कॉलबैक के पक्ष में सर्कस.स्टेट्स से थ्रेड हटा दिए गए

· दस्तावेज़ीकरण को उन्नत किया गया

· सर्कस क्लाइंट के पास अब एक सेंड_मैसेज एपीआई है

· फ़्लैपिंग सुविधा अब एक प्लगइन है

· प्रत्येक कमांड लाइन टूल में --संस्करण विकल्प होता है

· एक स्टैटिस्टिक्स प्लगइन जोड़ा गया (सर्कस से स्टैटिस्टिक्स पर इवेंट भेजता है)

· वेब यूआई अब आँकड़े प्राप्त करने के लिए वेबसॉकेट (सॉकेटियो के माध्यम से) का उपयोग करता है

· वेब यूआई अब वेब यूआई में "फ्लैश संदेश" के लिए सत्र का उपयोग करता है

0.3.4 - 2012-05-30
· एक दौड़ की स्थिति को ठीक किया गया जो नियंत्रक को तैयार प्रक्रियाओं को साफ-सुथरा करने से रोकती थी।

· अब कॉन्फ़िगरेशन में check_flapping को नियंत्रित किया जा सकता है। और सक्रिय/निष्क्रिय
प्रति द्रष्टा.

0.3.3 - 2012-05-29
· यूआईडी हैंडलिंग पर प्रतिगमन को ठीक किया गया

0.3.2 - 2012-05-24
· add_watcher कमांड के लिए वैकल्पिक args प्रॉपर्टी की अनुमति देता है।

· सर्कसhttpd, सर्कस-टॉप और सर्कस-स्टेट्स जोड़े गए

· Arbiter.add_watcher() को सभी वॉचर विकल्प सेट करने की अनुमति देना

· सुनिश्चित करें कि पुनरारंभ पर पुनर्निर्देशक पुनः बनाए गए हैं

0.3.1 - 2012-04-18
· ठीक करें: सुनिश्चित करें कि देखने वाले के डिफ़ॉल्ट को ओवरराइड न किया जाए

· एक StdoutStream क्लास जोड़ा गया।

0.3 - 2012-04-18
· स्ट्रीमिंग सुविधा जोड़ी गई

· अब स्फिंक्स दस्तावेज़ में कवरेज प्रदर्शित हो रहा है

· प्रक्रियाओं को ख़त्म करने का तरीका तय किया गया (अब कोई SIGQUIT नहीं)

· कॉन्फ़िगरेशन को ध्यान में रखा गया है

· सेटप्रोक्टाइटल समर्थन

0.2 - 2012-04-04
· निकाला गया दिखाना नाम। द्वारा प्रतिस्थापित चौकीदार.

· सेटिंग प्रक्रिया के लिए समर्थन जोड़ा गया rlimit.

· कॉन्फ़िगरेशन फ़ाइल में डीआईआर शामिल करने के लिए समर्थन जोड़ा गया।

· लीक हो रहे कुछ फ़ाइल डिस्क्रिप्टरों को ठीक किया गया।

· फ़्लैपिंग में एक कोर डंप को ठीक किया गया

· दस्तावेज़ सुधार

· सुनिश्चित करें कि जब कोई अन्य सर्कस उसी सॉकेट पर चल रहा हो तो सर्कस की त्रुटियां ठीक से हों।

· get_arbiter अब कई दर्शकों को स्वीकार करता है।

· प्रक्रिया init में cmd ​​बनाम args बनाम निष्पादन योग्य को ठीक किया गया।

· सर्कससीटीएल ऐड पर फिक्स--स्टार्ट

0.1 - 2012-03-20
· प्रारंभिक रिहाई

आदमी पृष्ठों
सर्कसडी आदमी पृष्ठ
सार
सर्कसड [विकल्प] [कॉन्फ़िगरेशन]

विवरण
सर्कसड सर्कस वास्तुकला की मुख्य प्रक्रिया है। यह सभी को चलाने का ख्याल रखता है
प्रक्रियाएं। सर्कस द्वारा प्रबंधित प्रत्येक प्रक्रिया एक चाइल्ड प्रोसेस है सर्कसडी.

तर्क
विन्यास विन्यास फाइल

ऑप्शंस
-एच, --मदद
सहायता संदेश दिखाएं और बाहर निकलें

--छांटने का स्तर LEVEL
लॉग स्तर निर्दिष्ट करें। LEVEL हो सकता है पता, डिबग, महत्वपूर्ण, चेतावनी or त्रुटि.

--लॉग-आउटपुट लॉगआउटपुट
वह स्थान जहां लॉग लिखे जाएंगे। डिफ़ॉल्ट व्यवहार को लिखना है
stdout (आप इस विकल्प में '-' पास करके इसे बाध्य कर सकते हैं)। एक फ़ाइल नाम लेता है
अन्यथा।

--लॉगर-कॉन्फ़िगरेशन लॉगरकॉन्फिग
वह स्थान जहां एक मानक पायथन लॉगर कॉन्फ़िगरेशन आईएनआई, जेएसओएन या वाईएएमएल फ़ाइल
पाया जा सकता है। इसका उपयोग डिफ़ॉल्ट लॉगिंग कॉन्फ़िगरेशन को ओवरराइड करने के लिए किया जा सकता है
मध्यस्थ।

--डेमन
बैकग्राउंड में सर्कसड शुरू करें।

--पिडफाइल पिडफाइल
पीआईडी ​​फाइल का स्थान।

--संस्करण
सर्कस संस्करण प्रदर्शित करता है और बाहर निकलता है।

देख भी
सर्कस (1) circusctl (1) सर्कस-आँकड़े (1) सर्कस-प्लगइन (1) सर्कस-टॉप (1).

पूर्ण दस्तावेज़ीकरण यहां उपलब्ध है http://circus.readthedocs.org

circusctl आदमी पृष्ठ
सार
सर्कसक्टल [विकल्प] कमांड [आर्ग]

विवरण
सर्कस डेमॉन को नियंत्रित करने के लिए सर्कससीटीएल फ्रंट एंड है। यह मदद करने के लिए डिज़ाइन किया गया है
प्रशासक सर्कड के कामकाज को नियंत्रित करता है सर्कसडी डेमॉन।

कमानों
जोड़ना एक पर्यवेक्षक जोड़ें

दिसंबर एक द्रष्टा में प्रक्रियाओं की संख्या घटाएँ

dstats सर्कस आँकड़े प्राप्त करें

मिल विशिष्ट द्रष्टा विकल्पों का मूल्य प्राप्त करें

वैश्विक विकल्प
मध्यस्थ विकल्प प्राप्त करें

इन्क्र एक वॉचर में प्रक्रियाओं की संख्या बढ़ाएँ

आईपीथॉन
सर्कस प्रक्रिया में शेल बनाएं

सूची किसी वॉचर में देखने वालों या प्रक्रियाओं की सूची प्राप्त करें

बात सुनो एक दर्शक कार्यक्रम की सदस्यता लें

listsockets
सॉकेट की सूची प्राप्त करें

numprocesses
प्रक्रियाओं की संख्या प्राप्त करें

संख्या देखने वाले
देखने वालों की संख्या प्राप्त करें

विकल्पों
एक दर्शक के लिए सभी विकल्पों का मूल्य प्राप्त करें

छोड़ना मध्यस्थ तुरंत छोड़ें

सीमा से अधिक लादना मध्यस्थ या द्रष्टा को पुनः लोड करें

पुनः लोड करेंकॉन्फिग
कॉन्फ़िगरेशन फ़ाइल पुनः लोड करें

पुनः प्रारंभ
मध्यस्थ या द्रष्टा को पुनः प्रारंभ करें

rm एक निगरानीकर्ता को हटा दें

सेट एक द्रष्टा विकल्प सेट करें

संकेत एक संकेत भेजें

प्रारंभ मध्यस्थ या द्रष्टा प्रारंभ करें

आँकड़े प्रक्रिया की जानकारी प्राप्त करें

हैसियत एक द्रष्टा या सभी द्रष्टा का दर्जा प्राप्त करें

रुकें देखने वालों को रोकें

ऑप्शंस
--अंत बिंदु endpoint
कनेक्शन समापन बिंदु

-एच, --मदद
सहायता संदेश दिखाएं और बाहर निकलें

--json JSON पर आउटपुट

--सुंदरीकरण
सुंदर आउटपुट

--ssh एसएसएच
प्रारूप में SSH सर्वर उपयोगकर्ता @ होस्ट: पोर्ट

--ssh_keyfile SSH_KEYफ़ाइल
उपयोगकर्ता को अधिकृत करने के लिए कीफ़ाइल का पथ

--समय समाप्त TIMEOUT
रिश्तों का समय बाहर

--संस्करण
सर्कस संस्करण प्रदर्शित करता है और बाहर निकलता है।

देख भी
सर्कस (1) सर्कसडी (1) सर्कस-आँकड़े (1) सर्कस-प्लगइन (1) सर्कस-टॉप (1).

पूर्ण दस्तावेज़ीकरण यहां उपलब्ध है http://circus.readthedocs.org

सर्कस-प्लगइन आदमी पृष्ठ
सार
सर्कस-प्लगइन [विकल्प] [प्लगइन]

विवरण
सर्कस-प्लगइन एक चालू सर्कस डेमॉन से एक प्लगइन लॉन्च करने की अनुमति देता है।

तर्क
लगाना प्लगइन क्लास का पूर्णतः योग्य नाम.

ऑप्शंस
--अंत बिंदु endpoint
कनेक्शन समापन बिंदु।

--पबसब पबसब
कनेक्ट करने के लिए सर्कस जीरोएमक्यू पब/सब सॉकेट।

--कॉन्फ़िगरेशन कॉन्फ़िग
प्लगइन कॉन्फ़िगरेशन फ़ाइल.

--चेक-विलंब CHECK_DELAY
विलंब की जाँच करें.

--छांटने का स्तर LEVEL
लॉग स्तर निर्दिष्ट करें। LEVEL हो सकता है पता, डिबग, महत्वपूर्ण, चेतावनी or त्रुटि.

--लॉग-आउटपुट लॉगआउटपुट
वह स्थान जहां लॉग लिखे जाएंगे। डिफ़ॉल्ट व्यवहार को लिखना है
stdout (आप इस विकल्प में '-' पास करके इसे बाध्य कर सकते हैं)। एक फ़ाइल नाम लेता है
अन्यथा।

--ssh एसएसएच
प्रारूप में SSH सर्वर उपयोगकर्ता @ होस्ट: पोर्ट.

-एच, --मदद
सहायता संदेश दिखाएं और बाहर निकलें।

--संस्करण
सर्कस संस्करण प्रदर्शित करता है और बाहर निकलता है।

देख भी
सर्कस (1) सर्कसडी (1) circusctl (1) सर्कस-आँकड़े (1) सर्कस-टॉप (1).

पूर्ण दस्तावेज़ीकरण यहां उपलब्ध है http://circus.readthedocs.org

सर्कस-टॉप आदमी पृष्ठ
सार
सर्कस-टॉप [विकल्प]

विवरण
सर्कस-टॉप a . है ऊपर कासर्कस डेमॉन और प्रक्रियाओं को प्रदर्शित करने के लिए समान कमांड
सर्कस

ऑप्शंस
--अंत बिंदु endpoint
कनेक्शन समापन बिंदु।

--ssh एसएसएच
प्रारूप में SSH सर्वर उपयोगकर्ता @ होस्ट: पोर्ट.

--प्रक्रिया-समयबाह्य PROCESS_TIMEOUT
निष्क्रियता की इस देरी के बाद, एक प्रक्रिया को हटा दिया जाएगा।

-एच, --मदद
सहायता संदेश दिखाएं और बाहर निकलें।

--संस्करण
सर्कस संस्करण प्रदर्शित करता है और बाहर निकलता है।

देख भी
सर्कस (1) circusctl (1) सर्कसडी (1) सर्कस-आँकड़े (1) सर्कस-प्लगइन (1).

पूर्ण दस्तावेज़ीकरण यहां उपलब्ध है http://circus.readthedocs.org

सर्कस-आँकड़े आदमी पृष्ठ
सार
सर्कस-आँकड़े [विकल्प]

विवरण
सर्कसडी-स्टैट्स सर्कस के लिए सांख्यिकी एग्रीगेटर चलाता है।

ऑप्शंस
--अंत बिंदु endpoint
कनेक्शन समापन बिंदु।

--पबसब पबसब
कनेक्ट करने के लिए सर्कस जीरोएमक्यू पब/सब सॉकेट।

--स्टैट्सप्वाइंट स्टेटसप्वाइंट
डेटा भेजने के लिए ZeroMQ पब/उप सॉकेट।

--छांटने का स्तर LEVEL
लॉग स्तर निर्दिष्ट करें। LEVEL हो सकता है पता, डिबग, महत्वपूर्ण, चेतावनी or त्रुटि.

--लॉग-आउटपुट लॉगआउटपुट
वह स्थान जहां लॉग लिखे जाएंगे। डिफ़ॉल्ट व्यवहार को लिखना है
stdout (आप इस विकल्प में '-' पास करके इसे बाध्य कर सकते हैं)। एक फ़ाइल नाम लेता है
अन्यथा।

--ssh एसएसएच
प्रारूप में SSH सर्वर उपयोगकर्ता @ होस्ट: पोर्ट.

-एच, --मदद
सहायता संदेश दिखाएं और बाहर निकलें।

--संस्करण
सर्कस संस्करण प्रदर्शित करता है और बाहर निकलता है।

देख भी
सर्कस (1) सर्कसडी (1) circusctl (1) सर्कस-प्लगइन (1) सर्कस-टॉप (1).

पूर्ण दस्तावेज़ीकरण यहां उपलब्ध है http://circus.readthedocs.org

शब्दावली: सर्कस-विशिष्ट शर्तों
मध्यस्थ
RSI मध्यस्थ सर्कस के भीतर सभी दर्शकों का प्रबंधन सुनिश्चित करने के लिए जिम्मेदार है
सभी प्रक्रियाएँ सही ढंग से चलती हैं।

नियंत्रक
A नियंत्रक इसमें क्रियाओं का वह सेट शामिल है जो मध्यस्थ पर किया जा सकता है।

फड़फड़ाने
RSI फड़फड़ाने खोज घटनाओं की सदस्यता लेता है और पता लगाता है कि कुछ प्रक्रियाएँ कब चल रही हैं
लगातार पुनः आरंभ करना.

पब/उप
सर्कस में एक है पबसब जो दर्शकों से घटनाएँ प्राप्त करता है और उन्हें भेजता है
सभी ग्राहक.

दूरस्थ नियंत्रक
RSI दूरस्थ नियंत्रक आपको ZMQ के माध्यम से नियंत्रक के साथ संचार करने की अनुमति देता है
नियंत्रण सर्कस.

देखने वाला, पर नजर रखने वालों
A चौकीदार यह वह प्रोग्राम है जिसे आप सर्कस को चलाने के लिए कहते हैं। एक एकल सर्कस उदाहरण चल सकता है
एक या अधिक दर्शक.

कार्यकर्ता, कर्मी, प्रक्रिया, प्रक्रियाओं
A प्रक्रिया आपके प्रोग्राम का एक स्वतंत्र OS प्रक्रिया उदाहरण है। एक अकेला द्रष्टा
एक या अधिक प्रक्रियाएँ चला सकते हैं। इन्हें हम श्रमिक भी कहते हैं.

कॉपीराइट
सर्कस की शुरुआत तारेक ज़ियादे ने की थी और इसे APLv2 के तहत लाइसेंस प्राप्त है

बेनोइट चेसन्यू एक प्रारंभिक योगदानकर्ता थे और उन्होंने अधिकांश कार्यों की तरह कई कार्य किए
सर्कस.कमांड काम करते हैं।

लाइसेंस
कॉपीराइट 2012 - मोज़िला फाउंडेशन
कॉपीराइट 2012 - बेनोइट चेसन्यू

अपाचे लाइसेंस, संस्करण 2.0 ("लाइसेंस") के तहत लाइसेंस प्राप्त;
आप लाइसेंस के अनुपालन के अलावा इस फ़ाइल का उपयोग नहीं कर सकते।
आप लाइसेंस की एक प्रति प्राप्त कर सकते हैं

http://www.apache.org/licenses/LICENSE-2.0

जब तक लागू कानून की आवश्यकता न हो या लेखन, सॉफ्टवेयर में सहमति न हो
लाइसेंस के तहत वितरित "जैसा है" आधार पर वितरित किया जाता है,
किसी भी प्रकार की वारंटी या शर्तों के बिना, या तो व्यक्त या निहित है।
विशिष्ट भाषा शासी अनुमतियों के लिए लाइसेंस देखें और
लाइसेंस के तहत सीमाएँ।

योगदानकर्ता
पूरी सूची यहां देखें https://github.com/circus-tent/circus/blob/master/CONTRIBUTORS.txt

onworks.net सेवाओं का उपयोग करके ऑनलाइन सर्कस का उपयोग करें