קרקס - מקוון בענן

תָכְנִית:

שֵׁם

קרקס - תיעוד קרקס [תמונה]

Circus היא תוכנת Python אשר יכולה לשמש לניטור ובקרה של תהליכים ושקעים.

ניתן להניע את הקרקס באמצעות ממשק שורת פקודה, ממשק אינטרנט או באופן תכנותי
דרך ה-API של python.

כדי להתקין אותו ולנסות את התכונות שלו, עיין בדוגמאות, או קרא את שאר העמוד הזה
להיכרות מהירה.

רץ A קרקס דיימון

קרקס מספק שיחת סקריפט בשורת הפקודה קרקס שניתן להשתמש בהם לניהול תהליכים
מאורגן בצופה אחד או יותר.

כלי שורת הפקודה של Circus ניתן להגדרה באמצעות קובץ תצורה בסגנון ini.

הנה דוגמה מאוד מינימלית:

[צופה:תוכנית]
cmd = python myprogram.py
מספר תהליכים = 5

[צופה: תוכנית אחרת]
cmd = תוכנית אחרת
מספר תהליכים = 2

לאחר מכן הקובץ מועבר אל קרקס:

$ circusd example.ini

מלבד תהליכים, קרקס יכול גם לקשור שקעים. מאז כל תהליך המנוהל על ידי קרקס הוא
בן של דמון הקרקס הראשי, כלומר כל תוכנית שנשלטת על ידי קרקס יכולה
להשתמש בשקעים האלה.

הפעלת שקע היא פשוטה כמו הוספת א שקע סעיף בקובץ התצורה:

[socket:mysocket]
מארח = מארח מקומי
יציאה = 8080

למידע נוסף על שקעים, ראה שקעים.

כדי להבין למה זה תכונה קטלנית, קרא למה שקעים.

שליטה קרקס

Circus מספק שני כלים בשורת פקודה לניהול הדמון הרץ שלך:

· circusctl, קונסולת ניהול שבה תוכל להשתמש כדי לבצע פעולות כגון הוספה או
פינוי עובדים

· טופ קרקס, קונסולה דמוית עליון שבה תוכל להשתמש כדי להציג את השימוש בזיכרון ובמעבד שלך
הפעלת קרקס.

למידע נוסף על אלה, ראה cli

Circus מציעה גם לוח מחוונים אינטרנטי שיכול להתחבר לדמון Circus פועל ולאפשר לך
לפקח וליצור איתו אינטראקציה.

למידע נוסף על תכונה זו, ראה circushttpd

מה עַכשָׁיו ?
אם אתה מפתח ורוצה למנף את Circus בפרויקט משלך, כתוב תוספים או
הוקס, עבור אל fordevs.

אם אתה אופר ורוצה לנהל את התהליכים שלך באמצעות Circus, עבור ל-forops.

תרומות ו מָשׁוֹב
עוד על תרומה: תרומות.

קישורים שימושיים:

· יש רשימת דיוור לכל משוב או שאלה:
http://tech.groups.yahoo.com/group/circus-dev/

· המאגר ומעקב הבעיות נמצאים ב-GitHub: https://github.com/circus-tent/circus

· הצטרפו אלינו ל-IRC : Freenode, ערוץ #אוהל קרקס

תיעוד מדד
התקנה קרקס
Circus היא חבילת Python המתפרסמת ב- PyPI - אינדקס החבילות של Python.

הדרך הפשוטה ביותר להתקין אותו היא להשתמש ב-pip, כלי להתקנה וניהול של Python
מאר you

$ pip להתקין קרקס

או הורד את ה ארכיון on PyPI, חלץ והתקן אותו באופן ידני עם:

$ python setup.py להתקין

אם אתה רוצה לנסות את קרקס, ראה את הדוגמאות.

אם אתה משתמש ב-debian או בכל הפצה מבוססת debian, אתה גם יכול להשתמש ב-ppa to
להתקין קרקס, זה ב https://launchpad.net/~roman-imankulov/+archive/circus

בניית zc.
אנו מספקים בניית zc. תצורה, אתה יכול להשתמש בה פשוט על ידי הפעלת ה-bootstrap
סקריפט, ואז קורא buildout:

$ python bootstrap.py
$ bin/buildout

עוד on דרישות
קרקס עובד עם:

· Python 2.6, 2.7, 3.2 או 3.3

·

zeromq >= 2.1.10

· הגרסה של zeromq הנתמכת נקבעת בסופו של דבר לפי איזו גרסה של
pyzmq מותקן על ידי pip במהלך התקנת קרקס.

· המהדורה הנוכחית שלהם תומכת בגרסאות 2.x (מוגבל), 3.x ו-4.x ZeroMQ.

· הערות: אם אתה משתמש ב-PyPy במקום ב-CPython, הקפד לקרוא אותם
מסמכי התקנה כמו תמיכה בגרסת ZeroMQ אינה זהה ב- PyPy.

כאשר אתה מתקין קרקס, הגרסאות העדכניות ביותר של התלות של Python יישלפו
בשבילך.

אתה יכול גם להתקין אותם באופן ידני באמצעות קובץ pip-requirements.txt שאנו מספקים:

$ pip התקנת -r pip-requirements.txt

אם אתה רוצה להפעיל את קונסולת האינטרנט תצטרך להתקין רשת קרקס:

$ pip להתקין circus-web

הדרכה
צעד אחר צעד הדרכה
השמיים דוגמאות בספרייה במאגר הקרקס מכיל דוגמאות רבות כדי להשיג אותך
התחיל, אבל הנה מדריך מלא שנותן לך סקירה כללית של התכונות.

אנחנו הולכים לפקח על יישום WSGI.

הַתקָנָה
Circus נבדק על Mac OS X ו-Linux עם ה-Python 2.6, 2.7, 3.2 ו-3.3 העדכניים ביותר. ל
להפעיל קרקס מלא, תצטרך גם libzmq, חביב & וירטואלי.

במערכות מבוססות דביאן:

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

צור Virtualenv והתקן קרקס, רשת קרקס ו גֶרֶב בּוֹ

$ virtualenv /tmp/circus
$ cd /tmp/circus
$ bin/pip להתקין קרקס
$ bin/pip התקנת circus-web
$ bin/pip להתקין chausset

ברגע שזה נעשה, תמצא שפע של פקודות ב-bin dir המקומי.

נוֹהָג
גֶרֶב מגיע עם אפליקציית Hello world, נסה להפעיל אותה:

פח/צ'וסטה $

אתה אמור להיות מסוגל לבקר http://localhost: 8080 ולראות שלום עוֹלָם.

עצור את Chaussette והוסף קובץ circus.ini בספרייה המכילה:

[קרקס]
סטטיסטיקה = 1
httpd = 1

[watcher:webapp]
cmd = bin/chaussette --fd $(circus.sockets.web)
מספר תהליכים = 3
use_sockets = נכון

[socket:web]
מארח = 127.0.0.1
יציאה = 9999

קובץ התצורה הזה אומר לסירקוס לאגד שקע ביציאה 9999 ולהפעיל 3 עובדי צ'וסטס
נגד זה. זה גם מפעיל את לוח המחוונים האינטרנט של Circus ואת מודול הסטטיסטיקה.

שמור אותו והפעל אותו באמצעות קרקס:

$ bin/circusd --daemon circus.ini

עכשיו בקר http://127.0.0.1: 9999, אתה אמור לראות את אפליקציית hello world. ההבדל כעת הוא
שהשקע מנוהל על ידי Circus ויש כמה עובדי אינטרנט שמקבלים
קשרים נגדו.

הערה:
איזון העומס מופעל על ידי מערכת ההפעלה כך שאתה מקבל את אותה מהירות
כמו כל שרת אינטרנט אחר מראש כמו Apache או NGinx. קרקס לא מפריע
הנתונים שעוברים.

אתה יכול גם לבקר http://localhost: 8080 / ותיהנו מלוח המחוונים האינטרנטי של Circus.

פעולת גומלין
בואו נשתמש במעטפת circusctl בזמן שהמערכת פועלת:

$ bin/circusctl
circusctl 0.7.1
circusd-stats: פעיל
circushttpd: פעיל
webapp: פעיל
(circusctl)

אתה נכנס למעטפת אינטראקטיבית. סוּג לעזור כדי לקבל את כל הפקודות:

(circusctl) עזרה

פקודות מתועדות (הקלד עזרה ):
========================================
הוסף קבל רשימה numprocesses quit rm start stop
decr globaloptions האזינו numwatchers טען מחדש סט סטטיסטיקות
dstats incr listsockets אפשרויות סטטוס אות הפעלה מחדש

פקודות לא מתועדות:
======================
עזרה של EOF

בואו ננסה דברים בסיסיים. בואו נרשום את התהליכים של Web Workers ונוסיף אחד חדש:

(circusctl) רשימת webapp
13712,13713,13714
(circusctl) incr webapp
4
(circusctl) רשימת webapp
13712,13713,13714,13973

מזל טוב, יצרת אינטראקציה עם הקרקס שלך! רדו מהקליפה עם Ctrl+D ועכשיו הפעל
טופ קרקס:

$ פח/עליון קרקס

זוהי פקודה דמוית-על כדי לצפות בכל הזיכרון והשימוש ב-CPU של כל התהליכים שלך בזמן אמת.

לחץ על Ctrl+C ועכשיו בוא נצא מסירקוס לחלוטין באמצעות circus-ctl:

$ bin/circusctl עזוב
ok

הַבָּא צעדים
אתה יכול לחבר את אפליקציית WSGI משלך במקום את שלום העולם של Chaussette פשוט על ידי
מפנה את היישום שניתן לקרוא.

Chaussette מגיעה גם עם חלקים אחוריים רבים כמו Gevent או Meinheld.

חומר עיוני https://chaussette.readthedocs.org/ לכל האפשרויות.

למה צריך I להשתמש קרקס במקום of X ?
1. קרקס מפשט שֶׁלְךָ אינטרנט לערום תהליך ניהול

קרקס יודע לנהל תהליכים ו שקעים, כך שלא תצטרך להאציל אינטרנט
ניהול עובדים לשרת WGSI.

ראה למה שקעים

2. קרקס מספק פאב/תת ו בו הודעות באמצעות ZeroMQ
לקרקס יש פאב/ערוץ משנה שאתה יכול להירשם אליו. ערוץ זה מקבל את כל האירועים
קורה בקרקס. לדוגמה, אתה יכול לקבל הודעה כאשר תהליך מתנופף, או
לבנות לקוח שמפעיל אזהרה כאשר תהליכים מסוימים אוכלים את כל המעבד או
זיכרון RAM

אירועים אלו נשלחים דרך ערוץ ZeroMQ, מה שעושה אותו שונה מה-stdin
מפקח הזרם משתמש ב:

· קרקס שולח אירועים בצורה של אש ושכח, כך שאין צורך לבצע לולאה ידנית
דרך את כל מאזינים ולשמור על מדינותיהם.

· ניתן לאתר מנויים על מארח מרוחק.

Circus מספקת גם דרכים לקבל עדכוני סטטוס באמצעות סקרים חד-פעמיים על דרישה/נציג
עָרוּץ. זה אומר שאתה יכול לקבל את המידע שלך מבלי שתצטרך להירשם ל-a
זרם. הפקודה cli שמספקת Circus משתמשת בערוץ הזה.

ראה דוגמאות.

3. קרקס is (פִּיתוֹן) מפתחים ידידותי
בעוד ש-Circus יכול להיות מונע כולו על ידי קובץ תצורה וה- circusctl / קרקס
פקודות, קל לעשות שימוש חוזר בכל המערכת או בחלקה כדי לבנות התאמה אישית משלך
צופה תהליך ב- Python.

כל שכבה של המערכת מבודדת, כך שתוכל לעשות שימוש חוזר באופן עצמאי:

· מעטפת התהליך (התַהֲלִיך)

· מנהל התהליכים (צופה)

· המנהל הגלובלי שמנהל מספר מנהלי תהליכים (שוטר)

· וכולי…

4. קרקס מאזניים
אחד ממקרי השימוש של Circus הוא לנהל אלפי תהליכים ללא הוספה
תקורה -- אנו מחויבים להתמקד בזה.

ביאה החל מ- מפקח
Supervisor הוא פתרון פופולרי מאוד בעולם Python ואנחנו נשאלים לעתים קרובות איך Circus
משווה איתו.

אם אתה בא מ מפקח, דף זה מנסה לתת סקירה כללית של אופן השימוש בכלים
שונות.

הבדלים סקירה
למפקח ולקרקס יש אותן מטרות - הן מנהלות תהליכים ומספקות א
סקריפט שורת הפקודה - בהתאמה מְפַקֵחַ ו קרקס - שקורא תצורה
קובץ, מזלג תהליכים חדשים ושומר אותם בחיים.

לקרקס יש תכונה נוספת: היכולת לאגד שקעים ולתת לתהליכים שהוא מנהל
להשתמש בהם. מודל "קדם-מזלג" זה משמש שרתי אינטרנט רבים בחוץ, כמו אַפָּשׁ or
חד-קרן. אפשרות זו ב-Circus יכולה לפשט ערימת אפליקציות אינטרנט: כל התהליכים ו
שקעים מנוהלים על ידי כלי אחד.

שני הפרויקטים מספקים דרך לשלוט בדמון פועל באמצעות סקריפט אחר. בהתאמה
מפקח ו circusctl. לשניהם יש גם אירועים ודרך להירשם אליהם.
ההבדל העיקרי הוא הטכנולוגיה הבסיסית: Supervisor משתמש ב-XML-RPC לאינטראקציה
עם הדמון, בעוד שסירקוס משתמש ב-ZeroMQ.

ל-Circus ול-Supervisor יש ממשק אינטרנטי כדי להציג את המתרחש. קרקס זה יותר
מתקדם כי אתה יכול לעקוב בזמן אמת אחר המתרחש ולקיים אינטראקציה עם הדמון.
הוא משתמש בשקעי אינטרנט ומפותח בפרויקט נפרד (רשת קרקס.)

ישנם הבדלים עדינים רבים אחרים בעיצוב הליבה, אולי נפרט כאן יום אחד... ב
בינתיים, אתה יכול ללמוד עוד על פנימיות קרקס בעיצוב.

תְצוּרָה
שתי המערכות משתמשות בקובץ דמוי ini כתצורה.

· מפקח תיעוד

· קרקס תיעוד

הנה דוגמה קטנה להפעלת אפליקציה עם Supervisor. במקרה זה, ה
היישום יופעל ויופעל מחדש במקרה שהוא קורס

[תוכנית:דוגמה]
command=npm start
directory=/home/www/my-server/
user=www-data
התחלה אוטומטית = נכון
autorestart=true
redirect_stderr=נכון

בקרקס, אותה תצורה נעשית על ידי:

[צופה:דוגמה]
cmd=npm התחלה
working_dir=/home/www/my-server/
user=www-data
stderr_stream.class=StdoutStream

שימו לב שהניתוב מחדש של stderr שונה במקצת ב-Circus. לכלי אין
a זנב תכונה כמו ב-Supervisor, אבל תאפשר לך לחבר כל פיסת קוד להתמודד איתה
הזרם הנכנס. אתה יכול ליצור הוק זרימה משלך (ככיתה) ולעשות מה שאתה
רוצה עם הזרם הנכנס. Circus מספק כמה שיעורי זרם מובנים כמו
StdoutStream, זרם קובץ, WatchedFileStream, או TimedRotatingFileStream.

קרקס ל Ops
אזהרה:
כברירת מחדל, Circus אינו מאבטח את ההודעות שלו בעת שליחת מידע דרך ZeroMQ.
לפני הפעלת Circus בסביבת הפקה, הקפד לקרוא את דף האבטחה.

הצעד הראשון לניהול דמון סירקוס הוא לכתוב את קובץ התצורה שלו. לִרְאוֹת
תְצוּרָה. אם אתה פורס ערימת אינטרנט, עיין בשקעים.

ניתן לפרוס את Circus באמצעות Python 2.6, 2.7, 3.2 או 3.3 - רוב הפריסות בחוץ
נעשה ב-2.7. כדי ללמוד כיצד לפרוס את Circus, בדוק את הפריסה.

כדי לנהל דמון קרקס, עליך להכיר את רשימת הפקודות שבהן אתה יכול להשתמש
in circusctl. שים לב שאתה יכול לקבל את אותה עזרה באינטרנט כשאתה רץ circusctl בתור
צדף.

אנו מספקים גם טופ קרקס, ראה cli ולוח מחוונים אינטרנטי נחמד. ראה circushttpd.

לבסוף, כדי להפיק את המרב מסירקוס, הקפד לבדוק כיצד להשתמש בתוספים וב-hooks.
ראה תוספים והוקס.

Ops תיעוד מדד
תְצוּרָה
ניתן להגדיר את Circus באמצעות קובץ תצורה בסגנון ini.

דוגמא:

[קרקס]
check_delay = 5
נקודת קצה = tcp://127.0.0.1:5555
pubsub_endpoint = tcp://127.0.0.1:5556
include = \*.more.config.ini
umask = 002

[צופה:התוכנית שלי]
cmd = פיתון
args = -u myprogram.py $(circus.wid) $(CIRCUS.ENV.VAR)
delay_warmup = 0
מספר תהליכים = 5

# וו
hooks.before_start = my.hooks.control_redis

# ידחוף ב-test.log את הזרם כל 300 אלפיות השנייה
stdout_stream.class = FileStream
stdout_stream.filename = test.log

# אופציונלי לסובב את קובץ היומן כאשר הוא מגיע ל-1 GB
# ושמור 5 עותקים של קבצים מסובבים
stdout_stream.max_bytes = 1073741824
stdout_stream.backup_count = 5

[env:myprogram]
PATH = $PATH:/ סל
עוגה = שקר

[plugin:statsd]
use = circus.plugins.statsd.StatsdEmitter
מארח = מארח מקומי
יציאה = 8125
sample_rate = 1.0
application_name = דוגמה

[socket:web]
מארח = מארח מקומי
יציאה = 8080

קרקס - יחיד סעיף
נקודת סיום
שקע ZMQ המשמש לניהול Circus באמצעות circusctl. (בְּרִירַת מֶחדָל:
tcp://127.0.0.1:5555)

endpoint_owner
אם מוגדר בשם משתמש מערכת ונקודת הקצה היא שקע ipc כמו
ipc://var/run/circusd.sock, אז הבעלות על קובץ ה-socket תשתנה ל
אותו משתמש בעת ההפעלה. לפרטים נוספים, ראה אבטחה. (ברירת מחדל: אין)

pubsub_endpoint
שקע PUB/SUB של ZMQ מקבל פרסומים של אירועים. (בְּרִירַת מֶחדָל:
tcp://127.0.0.1:5556)

papa_endpoint
אם אתה משתמש ב-papa, אתה יכול לציין את נקודת הקצה, כגון ipc://var/run/circusd.sock.
(בְּרִירַת מֶחדָל: tcp://127.0.0.1:20202)

סטטיסטיקה אם מוגדר כ-True, Circus מריץ את דמון circusd-stats. (ברירת מחדל: False)

stats_endpoint
שקע PUB/SUB של ZMQ מקבל פרסומים של סטטיסטיקות. (בְּרִירַת מֶחדָל:
tcp://127.0.0.1:5557)

statsd_close_outputs
If True שולח את circusd-stats stdout/stderr אל /dev/null. (ברירת מחדל: False)

check_delay
מרווח הסקר בשניות עבור שקע ZMQ. (ברירת מחדל: 5)

לכלול
רשימה של קבצי תצורה שיש לכלול. אתה יכול להשתמש בתווים כלליים (*) לכלול פרט
סכימות עבור הקבצים שלך. הנתיבים הם מוחלטים או יחסיים לקובץ התצורה.
(ברירת מחדל: אין)

include_dir
רשימת ספריות תצורה. כל הקבצים תואמים *.ini מתחת לכל ספרייה
להיכלל. הנתיבים הם מוחלטים או יחסיים לקובץ התצורה. (בְּרִירַת מֶחדָל:
אף אחד)

stream_backend
מגדיר את סוג הקצה העורפי לשימוש עבור הסטרימינג. ערכים אפשריים הם חוט
or gavt. (ברירת מחדל: שרשור)

עיכוב_חימום
המרווח בשניות בין שני צופים מתחיל. חייב להיות אינט. (ברירת מחדל: 0)

httpd אם מוגדר כ-True, Circus מריץ את דמון circushttpd. (ברירת מחדל: False)

httpd_host
המארח רץ על ידי הדמון circushttpd. (ברירת מחדל: localhost)

httpd_port
הנמל מנוהל על ידי הדמון circushttpd. (ברירת מחדל: 8080)

httpd_close_outputs
אם נכון, שולח את ה-circushttpd stdout/stderr אל /dev/null. (ברירת מחדל: False)

באגים אם מוגדר כ-True, כל הדמונים של Circus stout/stderr מנותבים ל-circusd
stdout/stderr (ברירת מחדל: False)

debug_gc
אם מוגדר כ-True, circusd מוציא מידע יומן נוסף מאוספן האשפה.
זה יכול להיות שימושי במעקב אחר דליפות זיכרון. (ברירת מחדל: False)

pidfile
הקובץ שיש להשתמש בו כדי לשמור על ה-demon pid.

אומסק ערך עבור umask. אם לא מוגדר, circusd לא ינסה לשנות את umask.

רמת יומן
רמת היומן שאנו רוצים לראות (ברירת מחדל: INFO)

פלט לוגו
קובץ הפלט שבו אנו רוצים להיכנס (ברירת מחדל: - כדי להיכנס ל-stdout). אתה יכול
התחבר ל-syslog מרוחק באמצעות התחביר הבא:
syslog://host:port?facility כאשר המארח הוא שרת ה-syslog שלך, היציאה היא אופציונלית
ו-facility הוא מתקן ה-syslog לשימוש. אם ברצונך להיכנס ל-syslog מקומי
אתה יכול להשתמש syslog:///path/to/syslog/socket?facility במקום.

loggerconfig
נתיב לקובץ INI, JSON או YAML כדי להגדיר רישום Python סטנדרטי עבור
פּוֹסֵק. הערך המיוחד "ברירת מחדל" משתמש בתצורת הרישום המובנית
בהתבסס על אפשרויות היומן האופציונליות ואפשרויות פלט לוגו.

דוגמה ימל תְצוּרָה שלח

גרסה: 1
disable_existing_loggers: false
מעצבים:
הפש you
פורמט: '%(asctime)s - %(name)s - [%(levelname)s] %(message)s'
מטפלים:
קובץ לוג:
מחלקה: logging.FileHandler
שם הקובץ: logoutput.txt
רמה: DEBUG
פורמט: פשוט
כורתים:
קרקס:
רמה: DEBUG
מטפלים: [logfile]
להפיץ: לא
שורש:
רמה: DEBUG
מטפלים: [logfile]

צופה:NAME - as רב סעיפים as אתה רוצה
שֵׁם שם הצופה. שם זה משמש ב circusctl

cmd תוכנית ההפעלה להפעלה.

טוען ארגומנטים בשורת הפקודה להעביר לתוכנית. אתה יכול להשתמש בפורמט python
תחביר כאן כדי לבנות את הפרמטרים. משתני סביבה זמינים, כמו
כמו גם מזהה העובד ומשתני הסביבה שהעברת, אם יש,
עם הפרמטר "env". לִרְאוֹת עיצוב מה היא פקודות ו טיעונים עם דינמי
משתנים למידע נוסף על זה.

פָּגָז אם נכון, התהליכים מופעלים במעטפת (ברירת מחדל: False)

shell_args
ארגומנטים בשורת הפקודה להעביר לפקודת המעטפת כאשר פָּגָז נכון. עובד
רק עבור מערכת *nix (ברירת מחדל: אין)

working_dir
מנהל העבודה של התהליכים (ברירת מחדל: אין)

uid מזהה המשתמש או השם שאיתו הפקודה אמורה לפעול. (ה-uid הנוכחי הוא
בְּרִירַת מֶחדָל).

gid מזהה הקבוצה או השם שאיתו הפקודה אמורה לפעול. (ה-Gid הנוכחי הוא ה
בְּרִירַת מֶחדָל).

copy_env
אם מוגדר כ-true, משתני הסביבה המקומית יועתקו ויעברו ל-
עובדים כשהם מטילים אותם. (ברירת מחדל: False)

copy_path
אם מוגדר כ-true, sys.path מועבר בסביבת תת-התהליך באמצעות PYTHONPATH.
copy_env חייב להיות נכון. (ברירת מחדל: False)

עיכוב_חימום
ההשהיה (בשניות) בין תהליכים הפועלים.

התחלה אוטומטית
אם הוגדר כ-false, הצופה לא יופעל אוטומטית כאשר הבורר
מתחיל. ניתן להפעיל את הצופה במפורש (לדוגמה: circusctrl התחלה
התוכנית שלי). (ברירת מחדל: נכון)

מספר תהליכים
מספר התהליכים להפעיל עבור הצופה הזה.

rlimit_LIMIT
הגדר מגבלת משאבים LIMIT עבור התהליכים שנצפו. שם התצורה צריך להתאים
הקבועים RLIMIT_* (לא תלויי רישיות) הרשומים ב- פיתון משאב מודול
הפניה. לדוגמה, שורת התצורה 'rlimit_nofile = 500' מגדירה את המקסימום
מספר הקבצים הפתוחים ל-500. כדי להגדיר ערך מגבלה ל-RLIM_INFINITY, אל תגדיר
ערך, כמו שורת התצורה הזו: 'rlimit_nofile = '.

stderr_stream.class
שם כיתת Python מוסמך במלואו שיוצג ויקבל
מה היא סטדרר זרם של כל התהליכים בה __שִׂיחָה__() שִׁיטָה.

Circus מספק כמה שיעורי זרם שבהם אתה יכול להשתמש ללא קידומת:

· זרם קובץ: כותב בקובץ ויכול לבצע סיבוב יומן אוטומטי

· WatchedFileStream: כותב בקובץ ומסתמך על סיבוב יומן חיצוני

· TimedRotatingFileStream: כותב בקובץ ויכול לסובב בזמן מסוים
מרווחים.

· QueueStream: כתוב בתור זיכרון

· StdoutStream: כותב ב-stdout

· FancyStdoutStream: כותב פלט צבעוני עם קידומות זמן ב-stdout

stderr_stream.*
כל האפשרויות החל מ stderr_stream. אחר מאשר בכיתה יעבור את
בנאי בעת יצירת מופע של המחלקה המוגדרת ב
stderr_stream.class.

stdout_stream.class
שם כיתת Python מוסמך במלואו שיוצג ויקבל
מה היא stdout זרם של כל התהליכים בה __שִׂיחָה__() שִׁיטָה.

Circus מספק כמה שיעורי זרם שבהם אתה יכול להשתמש ללא קידומת:

· זרם קובץ: כותב בקובץ ויכול לבצע סיבוב יומן אוטומטי

· WatchedFileStream: כותב בקובץ ומסתמך על סיבוב יומן חיצוני

· TimedRotatingFileStream: כותב בקובץ ויכול לסובב בזמן מסוים
מרווחים.

· QueueStream: כתוב בתור זיכרון

· StdoutStream: כותב ב-stdout

· FancyStdoutStream: כותב פלט צבעוני עם קידומות זמן ב-stdout

stdout_stream.*
כל האפשרויות החל מ stdout_stream. אחר מאשר בכיתה יעבור את
בנאי בעת יצירת מופע של המחלקה המוגדרת ב
stdout_stream.class.

close_child_stdout
אם מוגדר כ-True, זרם ה-stdout של כל תהליך יישלח אל /dev/null
אחרי המזלג. ברירת המחדל ל-False.

close_child_stderr
אם מוגדר כ-True, זרם stderr של כל תהליך יישלח אל /dev/null
אחרי המזלג. ברירת המחדל ל-False.

שלח_הפ
אם נכון, טעינת תהליך מחדש תתבצע על ידי שליחת האות SIGHUP. ברירות מחדל
לשקר.

אות_עצירה
האות שיש לשלוח בעת עצירת התהליך. ניתן לציין כמספר או א
שם האות. שמות האותות אינם תלויי רישיות ויכולים לכלול 'SIG' או לא. לכן
דוגמאות תקפות כוללות להפסיק, INT, טווח יעד ו 3. ברירת המחדל היא SIGTERM.

עצור_ילדים
בעת שליחת ה אות_עצירה, שלח אותו גם לילדים. ברירת מחדל ל
שקר.

max_retry
מספר הפעמים שאנו מנסים להתחיל תהליך, לפני שאנו נוטשים ומפסיקים
כל הצופה. ברירת המחדל היא 5. הגדר ל-1 כדי להשבית את max_retry ולנסות שוב
ללא הגבלת זמן.

פסק זמן_חינני
מספר השניות שיש להמתין עד שתהליך יסתיים בחן לפני כן
הורג את זה.

כאשר עוצרים תהליך, אנו קודם כל שולחים לו א אות_עצירה. עובד עלול לתפוס את זה
סימן לבצע פעולות ניקוי לפני היציאה. אם העובד דומם
פעיל לאחר שניות Graceful_timeout, אנו שולחים לו אות SIGKILL. זה לא
אפשר לתפוס אותות SIGKILL כך שהעובד יפסיק.

ברירת המחדל היא שנות ה-30.

עדיפות
מספר שלם שמגדיר עדיפות לצופה. כשהבורר יעשה קצת
פעולות על כל הצופים, זה ימיין אותם עם השדה הזה, מהגדול יותר
מספר לקטן ביותר. ברירת המחדל היא 0.

קְלָף בּוֹדֵד
אם מוגדר כ-True, לצופה הזה יהיה תהליך אחד לכל היותר. ברירת מחדל ל
שקר.

use_sockets
אם מוגדר כ-True, הצופה הזה יוכל לגשת לשקעים מוגדרים דרך שלהם
מתארי קבצים. אם False, כל ה-Fds של ההורים סגורים כאשר תהליך הצאצא מתבצע
מְפוּצָל. ברירת המחדל ל-False.

max_age
אם מוגדר, התהליך יופעל מחדש מתישהו לאחר שניות max_age. זֶה
שימושי כאשר תהליכים עוסקים במאגר של מחברים: הפעלה מחדש של תהליכים
משפר את איזון העומס. ברירת המחדל היא להיות מושבת.

max_age_variance
אם max_age מוגדר, התהליך יתקיים בין max_age לבין max_age +
random(0, max_age_variance) שניות. זה ימנע הפעלה מחדש של כל התהליכים עבור א
צופה בבת אחת. ברירת המחדל היא 30 שניות.

לפי דרישה
אם מוגדר כ-True, התהליכים יופעלו רק לאחר החיבור הראשון אל
אחד מהשקעים המוגדרים (ראה להלן). אם יש צורך בהפעלה מחדש, זה יהיה
מופעל רק באירוע השקע הבא.

ווים.*
ווים זמינים: לפני_התחל, after_start, before_spawn, after_spawn,
לפני_עצור, after_stop, לפני_אות, אחרי_אות, סטטיסטיקות_מורחבות

הגדר פונקציות התקשרות חוזרות המתחברות לתהליך ההפעלה/כיבוי של הצופה.

אם הקרס חוזר לא נכון ואם הוו הוא אחד מ לפני_התחל, before_spawn,
after_start or after_spawn, ההפעלה תבוטל.

אם הקרס הוא לפני_אות וחוזר לא נכון, ואז האות המתאים
לא יישלח (למעט SIGKILL שנשלח תמיד)

שימו לב שהוו שנכשל במהלך תהליך העצירה לא יבטל אותו.

ניתן לעקוב אחרי הגדרת ההתקשרות חזרה דגל בוליאני מופרד בפסיק.
כאשר הדגל מוגדר ל נָכוֹן, תתעלם מכל שגיאה שתתרחש ב-hook. אם
מכוון ל שקר (ברירת המחדל), הוו יחזור לא נכון.

עוד על ווים.

וירטואלי
כאשר מסופק, מצביע על השורש של ספריית Virtualenv. הצופה יעשה זאת
לסרוק את המקומי חבילות אתר וטוען את תוכנו לביצוע
סביבה. יש להשתמש עם copy_env מוגדר ל-True. ברירת המחדל היא ללא.

virtualenv_py_ver
מציין את גרסת ה-python של ה-virtualenv (למשל "3.3"). זה שימושי אם
הפעלת קרקס עם גרסת פיתון אחרת (למשל "2.7") הצופה יסרוק את
מקומי חבילות אתר של גרסת הפיתון שצוינה וטען את התוכן שלה לתוך
סביבת הביצוע. יש להשתמש עם וירטואלי. ברירת המחדל היא ללא.

respawn
אם מוגדר כ-false, התהליכים המטופלים על ידי צופה לא יוחזרו
אוטומטית. ניתן להפעיל מחדש את התהליכים באופן ידני עם התחלה פקודה.
(ברירת מחדל: נכון)

use_papa
הגדר ל-true כדי להשתמש באבא.

שקע:NAME - 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 שתשמש ליצירת שקע AF_UNIX. ל
דוגמא, umask=000 ייצר שקע באישור 777.

להחליף
בעת יצירת שקעי יוניקס ('AF_UNIX'), קובץ קיים עשוי להצביע על בעיה
אז ברירת המחדל היא להיכשל. לפרט נָכוֹן פשוט להסיר את הקובץ הישן אם כן
בטוח שהשקע מנוהל רק על ידי קרקס.

so_reuseport
אם מוגדר כ-True ו-SO_REUSEPORT זמין בפלטפורמת היעד, הקרקס יהיה
צור ואגד שקע(ים) SO_REUSEPORT חדשים עבור כל עובד שהוא מפעיל שהוא א
משתמש בשקע(ים) זה.

use_papa
הגדר ל-true כדי להשתמש באבא.

ברגע שנוצר שקע, ה ${circus.sockets.NAME} ניתן להשתמש במחרוזת בפקודה
(cmd or טוען) של צופה. קרקס יחליף אותו בערך FD. גם הצופה חייב
יש use_sockets מכוון ל נָכוֹן אחרת השקע היה סגור ותקבל
שגיאות כאשר הצופה מנסה להשתמש בו.

דוגמא:

[watcher:webworker]
cmd = chaussette --fd $(circus.sockets.webapp) chaussette.util.bench_app
use_sockets = נכון

[socket:webapp]
מארח = 127.0.0.1
יציאה = 8888

תוסף:NAME - as רב סעיפים as אתה רוצה
להשתמש השם המלא המצביע על מעמד הפלאגין.

דבר אחר
כל מפתח אחר שנמצא בקטע מועבר לבונה הפלאגין ב-
config מיפוי.

אתה יכול להשתמש בכל אפשרויות הצופה, מכיוון שתוסף מופעל כמו צופה.

Circus מגיע עם כמה תוספים שנשלחו מראש אבל אתה יכול גם להרחיב אותם בקלות על ידי
לפתח משלך.

env or env[:WATCHERS] - as רב סעיפים as אתה רוצה
דבר
שם משתנה סביבה להקצאת ערך. סביבה בסגנון bash
תחליפים נתמכים. למשל, לצרף / סל ל נתיב 'נתיב =
$PATH:/ סל'

מדור האחראי על אספקת משתני סביבה להפעלת תהליכים.

דוגמא:

[watcher:worker1]
cmd = ping 127.0.0.1

[watcher:worker2]
cmd = ping 127.0.0.1

[env]
עוגה = שקר

המשתנה עוגה יופץ לכל הצופים המוגדרים בקובץ התצורה.

WATCHERS יכולה להיות רשימה מופרדת בפסיקים של קטעי צופה להחיל סביבה זו.
אם קטעי Env מרובים תואמים לצופה, הם ישולבו לפי הסדר שבו הם מופיעים
קובץ התצורה. ערכים מאוחרים יותר יקבלו עדיפות.

דוגמא:

[watcher:worker1]
cmd = ping 127.0.0.1

[watcher:worker2]
cmd = ping 127.0.0.1

[env:worker1,worker2]
נתיב = / סל

[env:worker1]
PATH = $PATH

[env:worker2]
עוגה = שקר

worker1 יופעל עם PATH = $PATH (מורחב מהסביבה circusd הופעל)
worker2 יופעל עם PATH = / סל ועוגה = שקר

אפשר להשתמש גם בתווים כלליים.

דוגמא:

[watcher:worker1]
cmd = ping 127.0.0.1

[watcher:worker2]
cmd = ping 127.0.0.1

[env:worker*]
נתיב = / סל

שניהם worker1 ו worker2 יופעל עם PATH = / סל

שימוש סביבה משתנים
בעת כתיבת קובץ התצורה שלך, אתה יכול להשתמש במשתני סביבה המוגדרים ב- env
מקטע או ב os.environ עצמו.

אתה רק צריך להשתמש ב- circus.env. קידומת.

דוגמא:

[watcher:worker1]
cmd = $(circus.env.shell)

[watcher:worker2]
baz = $(circus.env.user)
bar = $(circus.env.yeah)
sup = $(circus.env.oh)

[socket:socket1]
port = $(circus.env.port)

[plugin:plugin1]
use = some.path
פרמטר1 = $(circus.env.plugin_param)

[env]
כן = בוז

[env:worker2]
אה = בסדר

אם משתנה מוגדר במספר מקומות, לערך המיוחד ביותר יש עדיפות: א
משתנה המוגדר ב env:XXX יעקוף משתנה שהוגדר ב env, אשר יעקוף את א
משתנה המוגדר ב os.environ.

ניתן להשתמש בהחלפות סביבה בכל חלק של התצורה בכל סעיף
משתנה

עיצוב מה היא פקודות ו טיעונים עם דינמי משתנים
כפי שאולי ראית, אפשר להעביר מידע מסוים שמחושב
באופן דינמי בעת הפעלת התהליכים. בין היתר ניתן לקבל את תעודת העובד
(WID) וכל האפשרויות המועברות ל- התַהֲלִיך. בנוסף, אפשר
לגשת לאפשרויות שהועברו ל- צופה מה שהציג את התהליך.

הערה:
מזהה העובד שונה מזהה התהליך. זה ערך ייחודי, החל מ-1,
שהוא ייחודי רק עבור הצופה.

לדוגמה, אם אתה רוצה לגשת למשתנים מסוימים הכלולים בסביבה,
תצטרך לעשות את זה עם הגדרה כזו:

cmd = "תכין לי קפה --sugar $(CIRCUS.ENV.SUGAR_AMOUNT)"

זה עובד עם שניהם cmd ו טוען.

חָשׁוּב:

· כל המשתנים מקבלים קידומת קרקס.

· התחליף אינו תלוי רישיות.

זרם תצורה
כיתת זרם פשוטה כמו QueueStream ו StdoutStream אין תכונות ספציפיות אבל
מחלקת זרם אחרת עשויה לכלול כמה:

זרם קובץ
שם הקובץ
נתיב הקובץ שבו ייכתב יומן.

פורמט זמן
פורמט strftime שישמש לקידומת כל פעם עם חותמת זמן. על ידי
ברירת מחדל הם לא יהיו קידומת.

כלומר: %Y-%m-%d %H:%M:%S

max_bytes
הגודל המרבי של קובץ היומן לפני הפעלת קובץ חדש. אם לא מסופק, ה
הקובץ לא מתהפך.

גיבוי_ספירת
מספר קובצי היומן שיישמרו כברירת מחדל backup_count הוא null.

הערה:
הגלגול מתרחש בכל פעם שקובץ היומן הנוכחי באורך של כמעט max_bytes. אם
backup_count הוא >= 1, המערכת תיצור ברציפות קבצים חדשים עם אותו
שם הנתיב כקובץ הבסיס, אך עם הסיומות ".1", ".2" וכו' מצורפות אליו. ל
לדוגמה, עם backup_count של 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" וכו' בהתאמה.

דוגמא:

[צופה:התוכנית שלי]
cmd = python -m myapp.server

stdout_stream.class = FileStream
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

WatchedFileStream
שם הקובץ
נתיב הקובץ שבו ייכתב יומן.

פורמט זמן
פורמט strftime שישמש לקידומת כל פעם עם חותמת זמן. על ידי
ברירת מחדל הם לא יהיו קידומת.

כלומר: %Y-%m-%d %H:%M:%S

הערה:
WatchedFileStream מסתמך על כלי סיבוב יומן חיצוני כדי להבטיח קובצי יומן
אל תהפוך לגדול מדי. קובץ הפלט יהיה במעקב ואם הוא יימחק אי פעם או
הועבר על ידי כלי סיבוב היומן החיצוני, ואז האחיזה של קובץ הפלט תהיה
נטען מחדש אוטומטית.

דוגמא:

[צופה:התוכנית שלי]
cmd = python -m myapp.server

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

TimedRotatingFileStream
שם הקובץ
נתיב הקובץ שבו ייכתב יומן.

גיבוי_ספירת
מספר קובצי היומן שיישמרו כברירת מחדל backup_count הוא null.

פורמט זמן
פורמט strftime שישמש לקידומת כל פעם עם חותמת זמן. על ידי
ברירת מחדל הם לא יהיו קידומת.

כלומר: %Y-%m-%d %H:%M:%S

סובב_מתי
סוג המרווח. רשימת הערכים האפשריים נמצאת למטה. שימו לב שהם כן
לא רגיש לאותיות גדולות.

┌───────────┬──────────────────────
│ערך │ סוג המרווח │
├───────────┼──────────────────────
│'S' │ שניות │
├───────────┼──────────────────────
│'M' │ דקות │
├───────────┼──────────────────────
│'H' │ שעות │
├───────────┼──────────────────────
│'D' │ ימים │
├───────────┼──────────────────────
│'W0'-'W6' │ יום חול (0=יום שני) │
├───────────┼──────────────────────
│'חצות' │ התהפכו בחצות │
└───────────┴────────────────────────

rotate_interval
מרווח ההתהפכות.

הערה:
TimedRotatingFileStream מסובב קובצי יומן במרווחי זמן מסוימים. מרווח גלגול
נקבע על ידי שילוב של rotate_when ו-rotate_interval.

דוגמא:

[צופה:התוכנית שלי]
cmd = python -m 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 = H
stdout_stream.rotate_interval = 1

FancyStdoutStream
צֶבַע

השמיים שם of an ASCII צֶבַע:

· אדום

· ירוק

· צהוב

· כחול

· מגנטה

· טורקיז

· לבן

פורמט זמן
פורמט strftime שלכל שורה תהיה קידומת.

ברירת המחדל היא: %Y-%m-%d %H:%M:%S

דוגמא:

[צופה:התוכנית שלי]
cmd = python -m myapp.server
stdout_stream.class = FancyStdoutStream
stdout_stream.color = ירוק
stdout_stream.time_format = %Y/%m/%d | %H:%M:%S

פקודות
במוקד הקרקס מתגוררות מערכות הפיקוד. circusctl הוא רק לקוח zeromq,
ואם צריך אתה יכול לנהוג באופן תוכנתי במערכת Circus על ידי כתיבת zmq משלך
לקוחות.

כל ההודעות הן מיפוי JSON.

עבור כל פקודה למטה, אנו מספקים דוגמה לשימוש עם circusctl אך גם את הקלט /
פלט הודעות zmq.

circus-ctl פקודות
· להוסיף: פקודות/הוסף

· decr: פקודות/הסרה

· dstats: פקודות/dstats

· לקבל: פקודות/קבל

· אופציות גלובליות: פקודות/גלובלאופציות

· תוספת: פקודות/incr

· פִּיתוֹן: פקודות/איפיטון

· רשימה: פקודות/רשימה

· להקשיב: פקודות/האזנה

· שקעי רשימות: פקודות/ליסטים

· מספר תהליכים: פקודות/מספר תהליכים

· שומרי מספר: פקודות / numwatchers

· אפשרויות: פקודות/אפשרויות

· להפסיק: פקודות/צא

· לטעון מחדש: פקודות/טעינה מחדש

· טען מחדש את התצורה: commands/reloadconfig

· הפעלה מחדש: פקודות/הפעלה מחדש

· rm: פקודות/rm

· סט: פקודות/סט

· אוֹת: פקודות/אות

· התחלה: פקודות/התחל

· סטטיסטיקות: פקודות/סטטיסטיקות

· מצב: פקודות/סטטוס

· להפסיק: פקודות/עצירה

להוסיף a צוֹפֶה
פקודה זו מוסיפה צופה באופן דינמי לבורר.

ZMQ הערות נוספות
{
"command": "הוסף",
"נכסים": {
"cmd": "/path/to/commandline --option"
"name": "nameofwatcher"
"args": [],
"אפשרויות": {},
"התחל": שקר
}
}

הודעה מכילה 2 מאפיינים:

· cmd: שורת פקודה מלאה לביצוע בתהליך

· args: מערך, ארגומנטים שהועברו לפקודה (אופציונלי)

· שם: שם הצופה

· אפשרויות: אפשרויות של צופה

· התחל: הפעל את הצופה לאחר היצירה

התגובה מחזירה סטטוס "בסדר".

פיקוד קו
$ circusctl הוסף [--התחל]

אפשרויות
· : שם הצופה שיש ליצור

· : שורת פקודה מלאה לביצוע בתהליך

· --התחל: הפעל את הצופה מיד

הצהרה מה היא מספר of תהליכים in a צוֹפֶה
הערה זו מורידה את מספר התהליכים בצופה ב- , 1 הוא ה
ברירת המחדל.

ZMQ הערות נוספות
{
"command": "decr",
"נכסים": {
"שם": " "
"נ"ב:
"מחכה": לא נכון
}
}

התגובה מחזירה את מספר התהליכים במאפיין 'numprocesses':

{ "status": "בסדר", "numprocesses": , "זמן", "חותמת זמן" }

פיקוד קו
$ circusctl decr [ ] [--מחכה]

אפשרויות
· : שם הצופה

· : מספר התהליכים להסרה.

לקבל קרקס סטטיסטיקות
אתה יכול לקבל בכל עת כמה סטטיסטיקות על circusd עם הפקודה dstat.

ZMQ הערות נוספות
כדי לקבל את הנתונים הסטטיסטיים של הקרקס, פשוט הרץ:

{
"command": "dstats"
}

התגובה מחזירה מיפוי של המאפיין "מידע" המכיל כמה מידע על תהליך:

{
"מידע": {
"ילדים": [],
"cmdline": "פיתון",
"מעבד": 0.1,
"ctime": "0:00.41",
"ממ": 0.1,
"mem_info1": "3 מיליון",
"mem_info2": "2G",
"נחמד": 0,
"pid": 47864,
"שם משתמש": "שורש"
},
"status": "בסדר",
"זמן": 1332265655.897085
}

פיקוד קו
$ circusctl dstats

לקבל מה היא ערך of ספציפי צוֹפֶה אפשרויות
ניתן להשתמש בפקודה זו כדי לשאול את הערך הנוכחי של אפשרות צופה אחת או יותר.

ZMQ הערות נוספות
{
"command": "קבל",
"נכסים": {
"keys": ["key1, "key2"]
"name": "nameofwatcher"
}
}

הודעת בקשה מכילה שני מאפיינים:

· מקשים: רשימה, מקשי האפשרות שעבורם ברצונך לקבל את הערכים

· שם: שם הצופה

לאובייקט התגובה יש מאפיין אפשרויות שהוא מילון של שמות אפשרויות ו
ערכים.

לדוגמה:

{
"status": "בסדר",
"אפשרויות": {
"timeout_graceful": 300,
"send_hup": נכון,
},
זמן': 1332202594.754644
}

פיקוד קו
$ circusctl לקבל

לקבל מה היא פוסק אפשרויות
פקודה זו מחזירה את אפשרויות הבורר

ZMQ הערות נוספות
{
"command": "גלובלאופציות",
"נכסים": {
"key1": "val1",
..
}
}

הודעה מכילה 2 מאפיינים:

· מקשים: רשימה, מקשי האפשרות שעבורם ברצונך לקבל את הערכים

התגובה מחזירה אובייקט עם מאפיין "אפשרויות" המכיל את רשימת המפתח/ערך
הוחזר על ידי קרקס.

לדוגמה:

{
"status": "בסדר",
"אפשרויות": {
"check_delay": 1,
...
},
זמן': 1332202594.754644
}

פיקוד קו
$ circusctl אופציות גלובליות

אפשרויות
מקשי האפשרויות הם:

· נקודת קצה: נקודת הקצה של הבקר ZMQ

· pubsub_endpoint: נקודת הקצה של pubsub

· check_delay: ההשהיה בין שתי נקודות בקר

· multicast_endpoint: נקודת הקצה של multicast לגילוי אוטומטי של אשכול circusd

תוֹסֶפֶת מה היא מספר of תהליכים in a צוֹפֶה
הערה זו מגדילה את מספר התהליכים בצופה ב- , 1 הוא ה
ברירת מחדל

ZMQ הערות נוספות
{
"command": "incr",
"נכסים": {
"שם": " ",
"נ"ב: ,
"מחכה": לא נכון
}
}

התגובה מחזירה את מספר התהליכים במאפיין 'numprocesses':

{ "status": "בסדר", "numprocesses": , "זמן", "חותמת זמן" }

פיקוד קו
$ circusctl Incr [ ] [--מחכה]

אפשרויות
· : שם הצופה.

· : מספר התהליכים שיש להוסיף.

צור פָּגָז אל תוך קרקס תהליך
פקודה זו שימושית רק אם מותקנת חבילת ipython.

פיקוד קו
$ circusctl ipython

לקבל רשימה of צופים or תהליכים in a צוֹפֶה
ZMQ הערות נוספות
כדי לקבל את רשימת כל הצופים:

{
"command": "רשימה",
}

כדי לקבל את רשימת התהליכים הפעילים ב-watcher:

{
"command": "רשימה",
"נכסים": {
"name": "nameofwatcher",
}
}

התגובה החזירה את הרשימה ביקשה. המיפוי המוחזר יכול להיות 'צופים' או
'pids' בהתאם לבקשה.

פיקוד קו
$ circusctl רשימה [ ]

הירשם ל a צוֹפֶה אירוע
ZMQ
בכל רגע ניתן להירשם לאירוע קרקס. קרקס מספק עדכון PUB/SUB עליו
כל לקוח יכול להירשם. URI של נקודת הקצה של המנוי נקבע ב-circus.ini
קובץ תצורה.

אירועים הם נושאי פאב:

· צוֹפֶה. .לִקצוֹר: כאשר תהליך קוצר

· צוֹפֶה. .לְהַשְׁרִיץ: כאשר נוצר תהליך

· צוֹפֶה. .לַהֲרוֹג: כאשר תהליך מומת

· צוֹפֶה. .מְעוּדכָּן: כאשר תצורת הצופה מתעדכנת

· צוֹפֶה. .תפסיק: כאשר צופה מופסק

· צוֹפֶה. .הַתחָלָה: כאשר מופעל צופה

כל הודעות האירועים נמצאות במבנה json.

פיקוד קו
הלקוח עודכן כדי לספק דרך פשוטה להאזין לאירועים:

תקשיב במעגל [ ,...]

דוגמה of התוצאה
$ circusctl להאזין tcp://127.0.0.1:5556
watcher.refuge.spawn: {u'process_id': 6, u'process_pid': 72976,
u'time': 1331681080.985104}
watcher.refuge.spawn: {u'process_id': 7, u'process_pid': 72995,
u'time': 1331681086.208542}
watcher.refuge.spawn: {u'process_id': 8, u'process_pid': 73014,
u'time': 1331681091.427005}

לקבל מה היא רשימה of ארובות
ZMQ הערות נוספות
כדי לקבל את רשימת השקעים:

{
"command": "listsockets",
}

התגובה מחזירה רשימה של מיפויי json עם מפתחות עבור fd, name, host ו-port.

פיקוד קו
$ circusctl listsockets

לקבל מה היא מספר of תהליכים
קבל את מספר התהליכים בצופה או בבורר

ZMQ הערות נוספות
{
"command": "numprocesses",
"נכסים": {
"שם": " "
}

}

התגובה מחזירה את מספר התהליכים במאפיין 'numprocesses':

{ "status": "בסדר", "numprocesses": , "זמן", "חותמת זמן" }

אם שם המאפיין לא צוין, סכום כל התהליכים המנוהלים יוחזר.

פיקוד קו
$ circusctl numprocesses [ ]

אפשרויות
· : שם הצופה

לקבל מה היא מספר of צופים
קבל את מספר הצופים בבורר

ZMQ הערות נוספות
{
"command": "numwatchers",
}

התגובה מחזירה את מספר הצופים במאפיין 'numwatchers':

{ "status": "בסדר", "numwatchers": , "זמן", "חותמת זמן" }

פיקוד קו
$ circusctl numwatchers

לקבל מה היא ערך of את כל אפשרויות ל a צוֹפֶה
פקודה זו מחזירה את כל ערכי האפשרויות עבור צופה נתון.

ZMQ הערות נוספות
{
"command": "אפשרויות",
"נכסים": {
"name": "nameofwatcher",
}
}

הודעה מכילה מאפיין אחד:

· שם: שם הצופה

לאובייקט התגובה יש מאפיין אפשרויות שהוא מילון של שמות אפשרויות ו
ערכים.

לדוגמה:

{
"status": "בסדר",
"אפשרויות": {
"timeout_graceful": 300,
"send_hup": נכון,
...
},
זמן': 1332202594.754644
}

פיקוד קו
$ circusctl אפשרויות

אפשרויות
· : שם הצופה

מקשי האפשרויות הם:

· מספר תהליכים: מספר שלם, מספר תהליכים

· warmup_delay: מספר שלם או מספר, עיכוב להמתנה בין השרצת תהליך בשניות

· working_dir: מחרוזת, ספרייה שבה יתבצע התהליך

· uid: מחרוזת או מספר שלם, מזהה משתמש המשמש להפעלת התהליך

· gid: מחרוזת או מספר שלם, מזהה קבוצה המשמש להפעלת התהליך

· send_hup: בוליאני, אם TRU האות HUP ישמש בטעינה מחדש

· shell: boolean, יפעיל את הפקודה בסביבת מעטפת אם היא נכונה

· cmd: string, שורת הפקודה המשמשת להפעלת התהליך

· env: אובייקט, הגדר את הסביבה שבה התהליך יושק

· retry_in: מספר שלם או מספר, זמן בשניות שאנו מחכים לפני שננסה שוב להפעיל את
תהליך אם הושג מספר הניסיונות המרבי.

· max_retry: מספר שלם, המקסימום של לולאות ניסיונות חוזרים

· פסק זמן_graceful: מספר שלם או מספר, זמן שאנו מחכים לפני שבוודאי נהרוג תהליך.

· עדיפות: משמש למיון צופים בבורר

· יחיד: אם נכון, צופה יחיד.

· max_age: זמן שבו תהליך יכול לחיות לפני שהוא מופעל מחדש

· max_age_variance: משתנה זמן נוסף לחיות, נמנע מהכת עדר.

להפסיק מה היא פוסק מיד
כאשר הבורר מקבל פקודה זו, הבורר יוצא.

ZMQ הערות נוספות
{
"command": "צא",
"מחכה": לא נכון
}

התגובה מחזירה את הסטטוס "בסדר".

If המתנה הוא False (ברירת מחדל), השיחה תחזור מיד לאחר השיחה אות_עצירה
על כל תהליך.

If המתנה נכון, השיחה תחזור רק כאשר תהליך העצירה יסתיים לחלוטין.
בגלל האפשרות graceful_timeout, זה יכול לקחת קצת זמן.

פיקוד קו
$ circusctl עזוב [--ממתין]

לִטעוֹן מִחָדָשׁ מה היא פוסק or a צוֹפֶה
פקודה זו טוענת מחדש את כל התהליך בצופה או את כל הצופים. זה יקרה באחד
מתוך 3 דרכים:

· אם חינני הוא שקר, מתרחשת הפעלה מחדש פשוטה.

· אם שלח_הפ נכון עבור הצופה, אות HUP נשלח לכל תהליך.

·

אחרת:

· אם הרצף הוא שקר, הבורר ינסה להשריץ מספר תהליכים חדש
תהליכים. אם התהליכים החדשים נוצרו בהצלחה, התוצאה היא זאת
כל התהליכים הישנים נעצרים, שכן כברירת מחדל התהליכים הישנים ביותר הם
הופסק כאשר מספר התהליכים בפועל עבור צופה גדול מ
מספר תהליכים.

· אם רצף נכון, הבורר יתחיל מחדש כל תהליך ברצף
דרך (עם א עיכוב_חימום הפסקה בין כל שלב)

ZMQ הערות נוספות
{
"command": "טען מחדש",
"נכסים": {
"שם":' ",
"חן": נכון,
"sequential": false,
"מחכה": לא נכון
}
}

התגובה מחזירה את הסטטוס "בסדר". אם הנכס חינני מוגדר כאמת התהליכים
ייצא בחן.

אם שם הנכס קיים, הטעינה מחדש תוחל על הצופה.

פיקוד קו
טען מחדש $ circusctl [ ] [--להפסיק] [--ממתין]
[--סִדרָתִי]

אפשרויות
· : שם הצופה

· --לבטל, לסיים; צא מהצומת מיד

לִטעוֹן מִחָדָשׁ מה היא תצורה פילה
פקודה זו טוענת מחדש את קובץ התצורה, כך ששינויים בקובץ התצורה יהיו
משתקף בתצורת הקרקס.

ZMQ הערות נוספות
{
"command": "reloadconfig",
"מחכה": לא נכון
}

התגובה מחזירה את הסטטוס "בסדר". אם הנכס חינני מוגדר כאמת התהליכים
ייצא בחן.

פיקוד קו
$ circusctl reloadconfig [--ממתין]

הפעל מחדש מה היא פוסק or a צוֹפֶה
פקודה זו הפעל מחדש את כל התהליך בצופה או את כל הצופים. הפונקציה הזו פשוט
עצור צופה ואז הפעל אותו מחדש.

ZMQ הערות נוספות
{
"command": "הפעל מחדש",
"נכסים": {
"שם": " ",
"ממתין": שקר,
"match": "[פשוט|גלוב|רגקס]"
}
}

התגובה מחזירה את הסטטוס "בסדר".

אם שם הנכס קיים, הטעינה מחדש תוחל על הצופה.

If המתנה הוא False (ברירת מחדל), השיחה תחזור מיד לאחר השיחה אות_עצירה
על כל תהליך.

If המתנה נכון, השיחה תחזור רק כאשר תהליך ההפעלה מחדש יהיה מלא
הסתיים. בגלל האפשרות graceful_timeout, זה יכול לקחת קצת זמן.

השמיים להתאים פרמטר יכול לקבל את הערך פשוט להשוואת מחרוזת, גוש עבור תו כללי
התאמה (ברירת מחדל) או regex עבור התאמת ביטויים רגילים.

פיקוד קו
$ circusctl הפעל מחדש [שם] [--waiting] [--match=simple|glob|regex]

אפשרויות
· : שם או תבנית של הצופה/ים

· : שיטת התאמה של צופה

להסיר a צוֹפֶה
פקודה זו מסירה צופה באופן דינמי מהבורר. הצופים הם בחן
הופסק כברירת מחדל.

ZMQ הערות נוספות
{
"command": "rm",
"נכסים": {
"שם": " ",
"nostop": שקר,
"מחכה": לא נכון
}
}

התגובה מחזירה סטטוס "בסדר".

If אין עצירה נכון (ברירת מחדל: False), התהליכים עבור הצופה לא יופסקו -
במקום זאת, הצופה פשוט יישכח על ידי הקרקס ותהליכי הצופה יהיו
אחראים לעצור את עצמם. אם אין עצירה לא צוין או שהוא False, אז ה-
תהליכי הצופה יופסקו בחן.

If המתנה הוא False (ברירת מחדל), השיחה תחזור מיד לאחר תחילת ההסרה
ולעצור את הצופה המקביל.

If המתנה נכון, השיחה תחזור רק לאחר תהליך ההסרה והעצירה
הסתיים לחלוטין. בגלל האפשרות graceful_timeout, זה יכול לקחת קצת זמן.

פיקוד קו
$ circusctl rm [--מחכה] [--nostop]

אפשרויות
· : שם הצופה שיש להסיר

· nostop: אל תפסיק את תהליכי הצופה, פשוט הסר את הצופה

לקבוע a צוֹפֶה אוֹפְּצִיָה
ZMQ הערות נוספות
{
"command": "קבע",
"נכסים": {
"name": "nameofwatcher",
"אפשרויות": {
"key1": "val1",
..
}
"מחכה": לא נכון
}
}

התגובה מחזירה את הסטטוס "בסדר". עיין בפקודה 'אפשרויות' עבור רשימה של מפתחות להגדרה.

פיקוד קו
$ circusctl סט --הַמתָנָה

שילחו a אוֹת
פקודה זו מאפשרת לשלוח אות לכל התהליכים בצופה, תהליך ספציפי
בצופה או בילדיו.

ZMQ הערות נוספות
כדי לשלוח אות לכל התהליכים עבור צופה:

{
"command": "אות",
"תכונה": {
"שֵׁם": ,
"סימן":
}

כדי לשלוח אות לתהליך:

{
"command": "אות",
"תכונה": {
"שֵׁם": ,
"pid": ,
"סימן":
}

ניתן להשתמש בנכס אופציונלי "ילדים" כדי לשלוח את האות לכל הילדים דווקא
מאשר התהליך עצמו:

{
"command": "אות",
"תכונה": {
"שֵׁם": ,
"pid": ,
"סימן": ,
"ילדים": נכון
}

כדי לשלוח אות לילד בתהליך:

{
"command": "אות",
"תכונה": {
"שֵׁם": ,
"pid": ,
"סימן": ,
"child_pid": ,
}

אפשר גם לשלוח אות לכל ילדי הצופה:

{
"command": "אות",
"תכונה": {
"שֵׁם": ,
"סימן": ,
"ילדים": נכון
}

לבסוף, אתה יכול לשלוח אות לתהליך ו ילדיה, עם ה רקורסיבית אפשרות:

{
"command": "אות",
"תכונה": {
"שֵׁם": ,
"סימן": ,
"רקורסיבי": נכון
}

פיקוד קו
אות circusctl $ [ ] [--ילדים]
[--רקורסיבי]

אפשרויות:
· : שם הצופה

· : מספר שלם, מזהה התהליך.

· : מספר האות (או השם) לשליחה.

· : פיד של ילד, אם בכלל

· : בוליאני, שלח את האות לכל הילדים

· : בוליאני, שלח את האות לתהליך ולילדיו

הַתחָלָה מה היא פוסק or a צוֹפֶה
פקודה זו מתחילה את כל התהליכים בצופה או את כל הצופים.

ZMQ הערות נוספות
{
"command": "התחל",
"נכסים": {
"שם":' ",
"ממתין": שקר,
"match": "[פשוט|גלוב|רגקס]"
}
}

התגובה מחזירה את הסטטוס "בסדר".

אם שם הנכס קיים, הצופה יופעל.

If המתנה הוא False (ברירת מחדל), השיחה תחזור מיד לאחר השיחה התחלה on
כל תהליך.

If המתנה נכון, השיחה תחזור רק כאשר תהליך ההתחלה יסתיים לחלוטין.
בגלל האפשרות graceful_timeout, זה יכול לקחת קצת זמן.

השמיים להתאים פרמטר יכול לקבל את הערך פשוט להשוואת מחרוזת, גוש עבור תו כללי
התאמה (ברירת מחדל) או regex עבור התאמת ביטויים רגילים.

פיקוד קו
$ circusctl הפעל מחדש [שם] [--waiting] [--match=simple|glob|regex]

אפשרויות
· : שם או תבנית של הצופה/ים

· : שיטת התאמה של צופה

לקבל תהליך infos
אתה יכול לקבל בכל עת כמה סטטיסטיקות על התהליכים שלך עם הפקודה stat.

ZMQ הערות נוספות
כדי לקבל נתונים סטטיסטיים עבור כל הצופים:

{
"command": "סטטיסטיקות"
}

כדי לקבל נתונים סטטיסטיים עבור צופה:

{
"command": "סטטיסטיקות",
"נכסים": {
"שֵׁם":
}
}

כדי לקבל נתונים סטטיסטיים עבור תהליך:

{
"command": "סטטיסטיקות",
"נכסים": {
"שֵׁם": ,
"תהליך":
}
}

ניתן להרחיב את הנתונים הסטטיסטיים עם ה-extend_stats הוק, אך יש צורך בנתונים סטטיסטיים מורחבים
ביקש:

{
"command": "סטטיסטיקות",
"נכסים": {
"שֵׁם": ,
"תהליך": ,
"מורחב": נכון
}
}

התגובה תכונה מחדש אובייקט לכל תהליך עם המאפיין "מידע" המכיל תהליך כלשהו
מידע:

{
"מידע": {
"ילדים": [],
"cmdline": "פיתון",
"מעבד": 0.1,
"ctime": "0:00.41",
"ממ": 0.1,
"mem_info1": "3 מיליון",
"mem_info2": "2G",
"נחמד": 0,
"pid": 47864,
"שם משתמש": "שורש"
},
"תהליך": 5,
"status": "בסדר",
"זמן": 1332265655.897085
}

פיקוד קו
$ circusctl סטטיסטיקות [--מורחב] [ ] [ ]

לקבל מה היא מצב of a צוֹפֶה or את כל צופים
פקודה זו התחל לקבל את הסטטוס של צופה או כל הצופים.

ZMQ הערות נוספות
{
"command": "סטטוס",
"נכסים": {
"שם":' ",
}
}

התגובה מחזירה את הסטטוס "פעיל" או "נעצר" או את הסטטוס / צופים.

פיקוד קו
$ circusctl status [ ]

אפשרויות
· : שם הצופה

דוגמה
$ circusctl סטטוס דמה
פעיל
$ circusctl סטטוס
דמה: פעיל
dummy2: פעיל
מקלט: פעיל

עצור צופים
פקודה זו עוצרת צופה נתון או את כל הצופים.

ZMQ הערות נוספות
{
"command": "עצור",
"נכסים": {
"שם": " ",
"ממתין": שקר,
"match": "[פשוט|גלוב|רגקס]"
}
}

התגובה מחזירה את הסטטוס "בסדר".

אם שם הנכס קיים, ואז העצירה תחול על הצופה
מתאים לשם זה. אחרת, כל הצופים ייעצרו.

If המתנה הוא False (ברירת מחדל), השיחה תחזור מיד לאחר השיחה אות_עצירה
על כל תהליך.

If המתנה נכון, השיחה תחזור רק כאשר תהליך העצירה יסתיים לחלוטין.
בגלל האפשרות graceful_timeout, זה יכול לקחת קצת זמן.

השמיים להתאים פרמטר יכול לקבל את הערך פשוט להשוואת מחרוזת, גוש עבור תו כללי
התאמה (ברירת מחדל) או regex עבור התאמת ביטויים רגילים.

פיקוד קו
$ circusctl stop [name] [--waiting] [--match=simple|glob|regex]

אפשרויות
· : שם או תבנית של הצופה/ים

· : שיטת התאמה של צופה

CLI כלים
טופ קרקס
טופ קרקס היא קונסולה דמויית מובילה שתוכל להפעיל כדי לצפות בשידור חי במערכת ה-Circus שלך. זה
יציג את ה-CPU, שימוש בזיכרון וכניסות שקע אם יש לך.

דוגמה לפלט:

-------------------------------------------------- ---------------------
סטטיסטיקות קרקס
PID CPU (%) זיכרון (%)
14252 0.8 0.4
0.8 (ממוצע) 0.4 (סכום)

דמה
PID CPU (%) זיכרון (%)
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 צריך
להשתמש באמצעות CIRCUSCTL_ENDPOINT משתנה הסביבה.

השמיים אינטרנט קונסול
Circus מגיע עם קונסולת אינטרנט שניתן להשתמש בה לניהול המערכת.

מסוף האינטרנט מאפשר לך:

· התחבר לכל מערכת Circus פועלת

· צפו בתהליכי שימוש במעבד ובזיכרון בזמן אמת

· הוסף או הרג תהליכים

· הוסף צופים חדשים

הערה:
תכונת השימוש במעבד וזיכרון בזמן אמת משתמשת בשקע הסטטיסטיקה. אם אתה רוצה
הפעל אותו, ודא שמערכת הסירקוס שאליה תתחבר מכילה את הנתונים הסטטיסטיים
מופעל בתצורה שלו:

[קרקס]
statsd = נכון

כברירת מחדל, אפשרות זו אינה מופעלת.

קונסולת האינטרנט היא חבילה משלה, עליך להתקין:

$ pip להתקין circus-web

כדי להפעיל את המסוף, הוסף כמה אפשרויות בקובץ Circus ini:

[קרקס]
httpd = נכון
httpd_host = מארח מקומי
httpd_port = 8080

httpd_host ו httpd_port הם אופציונליים, וברירת המחדל היא localhost ו 8080.

אם אתה רוצה להפעיל את אפליקציית האינטרנט לבד, פשוט הפעל את circushttpd תַסרִיט:

$ circushttpd
שרת בקבוקים מופעל...
מאזין הלאה http://localhost: 8080 /
לחץ על Ctrl-C כדי לצאת.

כברירת מחדל, הסקריפט יריץ את מסוף האינטרנט ביציאה 8080, אבל האפשרות --port יכולה להיות
נהג לשנות את זה.

שימוש מה היא לנחם
לאחר שהסקריפט פועל, אתה יכול לפתוח דפדפן ולבקר http://localhost: 8080. אתה
צריך לקבל את המסך הזה: [תמונה]

קונסולת האינטרנט מוכנה לחיבור למערכת Circus, בהתחשב בה נקודת סיום. על ידי
ברירת המחדל היא נקודת הקצה tcp://127.0.0.1:5555.

ברגע שאתה מכה לְחַבֵּר, אפליקציית האינטרנט תתחבר למערכת הקרקס.

כאשר קונסולת האינטרנט מחוברת, אתה אמור לקבל רשימה של צופים וסטטוס בזמן אמת
של שני תהליכי הקרקס (סירקס ו-circusd-stats).

אתה יכול ללחוץ על הסטטוס של כל צופה כדי לעבור ממנו Active (ירוק) ל לא פעיל
(אָדוֹם). שינוי זה תקף באופן מיידי ומאפשר לך להתחיל ולעצור צופים.

אם תלחץ על שם הצופה, תקבל דף אינטרנט עבור אותו צופה ספציפי,
עם התהליכים שלו:

במסך זה, אתה יכול להוסיף או להסיר תהליכים ולהרוג תהליכים קיימים.

אחרון חביב, אתה יכול להוסיף צופה חדש לגמרי על ידי לחיצה על להוסיף צופה קישור פנימה
התפריט השמאלי: .SS פועל מאחורי Nginx

Nginx יכול לשמש כשכבת פרוקסי ואבטחה מול רשת קרקס.

הערה:
כדי לקבל עדכוני סטטוס וגרפים בזמן אמת ב-circus-web, עליך לספק Nginx
פתרון פרוקסי שיש לו תמיכה ב-websocket

nginx >= 1.3.13
החל מ-Nginx>=1.3.13 תמיכת websocket מובנית, כך שאין צורך לשלב את Nginx
עם לכה או HAProxy. תצורת Nginx לדוגמה עם תמיכה ב-websocket:

במעלה הזרם circusweb_server {
שרת 127.0.0.1:8080;
}

שרת {
להקשיב 80;
שם שרת _;

מקום / {
proxy_pass http://circusweb_server;
proxy_http_version 1.1;
proxy_set_header שדרוג $http_upgrade;
proxy_set_header חיבור "שדרוג";
proxy_set_header מארח $ מארח;
proxy_set_header X-Real-IP $ remote_addr;
proxy_set_header X-Forwarded-For proxy_add_x_forwarded_for $;
proxy_set_header X-Forwarded-Proto http;
proxy_redirect off;
}

מיקום ~/media/\*(.png|.jpg|.css|.js|.ico)$ {
כינוי /path_to_site-packages/circusweb/media/;
}
}

nginx < 1.3.13
גרסאות Nginx < 1.3.13 אינן כוללות תמיכה מובנית ב-websocket.

כדי לספק תמיכה ב-websocket עבור circus-web בעת שימוש ב-Nginx < 1.3.13, אתה יכול לשלב
Nginx עם לכה או HAProxy. כלומר, Nginx מול circus-web, עם Varnish או
HAProxy מול Nginx.

הדוגמה להלן מציגה את תצורת Nginix ו- Varnish המשולבת הנדרשת ל-proxy
circus-web ולספק תמיכה ב-websocket.

nginx Definitive

במעלה הזרם circusweb_server {
שרת 127.0.0.1:8080;
}

שרת {
להקשיב 8001;
שם שרת _;

מקום / {
proxy_set_header X-Forwarded-For proxy_add_x_forwarded_for $;
מארח proxy_set_header $ HTTP_HOST;
proxy_redirect off;
proxy_pass http://circusweb_server;
}

מיקום ~/media/\*(.png|.jpg|.css|.js|.ico)$ {
כינוי /path_to_site-packages/circusweb/media/;
}
}

אם אתה רוצה עוד אפשרויות תצורה של Nginx, ראה http://wiki.nginx.org/HttpProxyModule.

ורנית Definitive

ברירת המחדל האחורית {
.host = "127.0.0.1";
.port = "8001";
}

שקע אחורי {
.host = "127.0.0.1";
.port = "8080";
‎.connect_timeout = 1s;
.first_byte_timeout = 2 שניות;
.between_bytes_timeout = 60 שניות;
}

sub vcl_pipe {
if (req.http.upgrade) {
set bereq.http.upgrade = req.http.upgrade;
}
}

sub vcl_recv {
if (req.http.Upgrade ~ "(?i)websocket") {
set req.backend = socket;
חזרה (צינור);
}
}

בדוגמה של תצורת Varnish לעיל מוגדרים שני קצה אחוריים. אחד המשרת את האינטרנט
קונסולה ואחד המשרת את חיבורי השקע. בקשות קונסולת האינטרנט כבולים ליציאה
8001. יש להגדיר את ההנחיה 'שרת' של Nginx להאזנה ביציאה 8001.

חיבורי Websocket משודרגים ומועברים ישירות לתהליך האזנה של circushttpd
על נמל 8080 על ידי Varnish. כלומר עקיפת פרוקסי Nginx.

אובונטו
מאז הגרסה 13.10 (סאוסי), אובונטו כוללת Nginx עם תמיכה ב-websocket בפני עצמה
מאגרים. עבור גרסאות ישנות יותר, אתה יכול להתקין Nginx>=1.3.13 מה-Nginx הרשמי
PPA יציב, כך:

sudo apt-get install python-software-properties
sudo add-apt-repository ppa:nginx/stable
עדכון sudo apt-get
sudo apt-get להתקין nginx
nginx -v

הגן באמצעות סיסמה circushttpd
כפי שהוסבר בדף האבטחה, פועל circushttpd הוא די לא בטוח. אנחנו לא מספקים
כל אבטחה בסירקוס עצמו, אבל אתה יכול להגן על הקונסולה שלך ברמת NGinx, על ידי
באמצעות http://wiki.nginx.org/HttpAuthBasicModule

דוגמא:

מקום / {
proxy_set_header X-Forwarded-For proxy_add_x_forwarded_for $;
מארח proxy_set_header $ HTTP_HOST;
proxy_set_header X-Forwarded-Host: $http_host;
proxy_set_header X-Forwarded-Proto: $scheme;
proxy_redirect off;
proxy_pass http://127.0.0.1: 8080;
auth_basic "מוגבל";
auth_basic_user_file /path/to/htpasswd;
}

השמיים htpasswd הקובץ מכיל משתמשים ואת הסיסמאות שלהם, ומתי תופיע בקשת סיסמה
אתה ניגש לקונסולה.

אתה יכול להשתמש בסקריפט htpasswd של Apache כדי לערוך אותו, או בסקריפט Python שהם מספקים ב:
http://trac.edgewall.org/browser/trunk/contrib/htpasswd.py

עם זאת, אין תמיכה מקורית לשימוש המשולב ב-HTTP Authentication ו
WebSockets (השרת יזרוק קודי שגיאה של HTTP 401). דרך לעקיפת הבעיה היא להשבית כאלה
אימות עבור שרת socket.io.

דוגמה (יש להוסיף לפני הכלל הקודם):

מיקום /socket.io {
proxy_set_header X-Forwarded-For proxy_add_x_forwarded_for $;
מארח proxy_set_header $ HTTP_HOST;
proxy_set_header X-Forwarded-Host: $http_host;
proxy_set_header X-Forwarded-Proto: $scheme;
proxy_redirect off;
proxy_pass http://127.0.0.1: 8080;
}

כמובן שזו רק דרך אחת להגן על קונסולת האינטרנט שלך, אתה יכול להשתמש רבות אחרות
טכניקות.

מאריך מה היא אינטרנט לנחם
בחרנו בקבוק לבנות את קונסולת האינטרנט, בעיקר בגלל שזו מסגרת ממש זעירה
לא עושה הרבה. עיון בקוד של קונסולת האינטרנט, בסופו של דבר תמצא
החוצה שזה ממש פשוט להבנה.

הנה איך זה מחולק:

· circushttpd.py הקובץ מכיל את הגדרות "תצוגות" וקצת קוד לטיפול ב
חיבור שקע (באמצעות socketio).

· ה controller.py מכיל מחלקה אחת שאחראית על ביצוע התקשורת
עם בקר הקרקס. זה מאפשר לקבל API ברמה גבוהה יותר כשמגדירים את
שרת אינטרנט.

אם ברצונך להוסיף תכונה בקונסולת האינטרנט, תוכל לעשות שימוש חוזר בקוד הקיים. א
כמה כלים עומדים לרשותך כדי להקל על התהליך:

· יש לדקלם פונקציה, שלוקחת את הארגומנטים בעלי השם שאתה מעביר אליה ו
להעביר אותם למעבד התבניות ולהחזיר את ה-HTML שנוצר. זה גם עובר חלק
משתנים נוספים, כגון הפגישה, גרסת הקרקס והלקוח אם הוגדר.

· אם אתה רוצה להריץ פקודות ולעשות ניתוב מחדש בהתאם לתוצאה של זה, אתה יכול להשתמש
מה היא run_command פונקציה, שלוקחת ארגומנט שניתן לקרוא כארגומנט ראשון, הודעה במקרה
של הצלחה וכתובת אתר להפניה מחדש.

השמיים מרחב נתונים סטטיסטיים class אחראית לניהול תקשורת ה-websocket ב-
בצד השרת. התיעוד שלו אמור לעזור לך להבין מה הוא עושה.

עבודה עם ארובות
Circus יכול לאגד שקעי רשת ולנהל אותם כפי שהוא עושה עבור תהליכים.

הרעיון המרכזי הוא שתהליך ילד שנוצר על ידי קרקס כדי להפעיל את אחד הצופים
הפקודה יכולה לרשת מכל מתארי הקובץ שנפתחו.

כך עובד אפאצ'י או חד קרן, וכלים רבים אחרים בחוץ.

מטרה
המטרה של שקעים המנוהלים על ידי Circus היא להיות מסוגלים לנהל אפליקציות רשת
בקרקס בדיוק כמו אפליקציות אחרות.

לדוגמה, אם אתה משתמש בסירקוס עם גֶרֶב -- שרת WGSI, אתה יכול לקבל שרת מהיר מאוד
שרת אינטרנט פועל ומנהל "אינטרנט עובדים" בקרקס כפי שהיית עושה עבור כל אחד אחר
התהליך.

פיצול ניהול השקעים מאפליקציית הרשת עצמה מציע הרבה
הזדמנויות להרחיב ולנהל את הערימה שלך.

עיצוב
עיקר התכונה נעשה על ידי קשירת השקע והתחל להאזין לו פנימה
קרקס:

שקע יבוא

sock = socket.socket(FAMILY, TYPE)
sock.bind((HOST, PORT))
sock.listen(BACKLOG)
fd = sock.fileno()

לאחר מכן קרקס עוקב אחר כל ה-fds שנפתחו, ונותן לתהליכים שהוא מריץ בילדותם
יש להם גישה אליהם אם הם רוצים.

אם תיצור סקריפט רשת קטן של Python שאתה מתכוון להפעיל ב-Circus, זה יכול
נראה כמו זה:

שקע יבוא
ייבוא

fd = int(sys.argv[1]) # מקבל את ה-FD מהקרקס
sock = socket.fromfd(fd, FAMILY, TYPE)

# טיפול בבקשה אחת בכל פעם
בעוד נכון:
conn, addr = sock.accept()
בקשה = conn.recv(1024)
.. תעשה משהו ..
conn.sendall(response)
conn.close()

אז קרקס יכול לרוץ כך:

[קרקס]
check_delay = 5
נקודת קצה = tcp://127.0.0.1:5555
pubsub_endpoint = tcp://127.0.0.1:5556
stats_endpoint = tcp://127.0.0.1:5557

[צופה:דמה]
cmd = mycoolscript $(circus.sockets.foo)
use_sockets = נכון
delay_warmup = 0
מספר תהליכים = 5

[socket:foo]
מארח = 127.0.0.1
יציאה = 8888

$(circus.sockets.foo) יוחלף בערך FD לאחר יצירת השקע ו
קשור ל-8888 נמל.

הערה:
החל מ-Circus 0.8 יש תחביר חלופי כדי למנוע התנגשויות מסוימות עם כמה
מנתחי תצורה. אתה יכול לכתוב:

((circus.sockets.foo))

עולם אמיתי דוגמה
גֶרֶב הוא המלווה המושלם לסירקוס אם אתה רוצה להפעיל את אפליקציית WSGI שלך.

לאחר ההתקנה, הפעלת 5 מייןהלד עובדים ניתן לעשות על ידי יצירת שקע ו
קורא ל גֶרֶב פקודה בעובד, כך:

[קרקס]
נקודת קצה = tcp://127.0.0.1:5555
pubsub_endpoint = tcp://127.0.0.1:5556
stats_endpoint = tcp://127.0.0.1:5557

[watcher:web]
cmd = chaussette --fd $(circus.sockets.web) --backend meinheld mycool.app
use_sockets = נכון
מספר תהליכים = 5

[socket:web]
מארח = 0.0.0.0
יציאה = 8000

עדיין לא פרסמנו מדדים, אלא אשכול אינטרנט בניהולו של Circus עם Gevent או
הקצה האחורי של Meinheld הוא מהיר כמו כל שרת WSGI pre-fork בחוץ.

שימוש מובנה תוספים
Circus מגיע עם כמה תוספים מובנים. סעיף זה מציג את התוספים הללו ושלהם
אפשרויות תצורה.

סטטיסטיקה
להשתמש מוגדר ל'circus.plugins.statsd.StatsdEmitter'

שם אפליקציה
השם המשמש לזיהוי קידומת הדלי שאליה ישלחו את הנתונים הסטטיסטיים (זה יהיה
עם קידומת קרקס. ומוסמך עם .צוֹפֶה)

המארח המארח שאליו יש לפרסם את נתוני ה-statds

נמל היציאה שהדמון ה-statsd מאזין לה

קצב דגימה
אם אתה מעדיף קצב דגימה שונה מ-1, אתה יכול להגדיר אותו כאן

נתונים מלאים
הרחבה בתוסף Statsd שמפרסמת גם את סטטיסטיקת התהליך. ככזה זה
יש את אותן אפשרויות תצורה כמו Statsd והבאים.

להשתמש מכוון ל circus.plugins.statsd.FullStats

loop_rate
התדירות שהתוסף צריך לבקש את הנתונים הסטטיסטיים בשניות. ברירת מחדל: 60.

RedisObserver
שירות זה משקיף עבורך בתהליך ניתוח מחדש, מפרסם את המידע ל-statsd
ומציע להפעיל מחדש את הצופה כאשר הוא לא מגיב בזמן קצוב נתון. התוסף הזה
דורש redis-py לרוץ.

יש לו אותה תצורה כמו statd ומוסיף את הדברים הבאים:

להשתמש מכוון ל circus.plugins.redis_observer.RedisObserver

loop_rate
התדירות שהתוסף צריך לבקש את הנתונים הסטטיסטיים בשניות. ברירת מחדל: 60.

redis_url
מסד הנתונים שיש לבדוק אותו ככתובת אתר redis. ברירת מחדל: "redis://localhost:6379/0"

פסק זמן
הזמן הקצוב בשניות שהבקשה עשויה להימשך לפני שהיא נחשבת מושבתת.
ברירת המחדל היא 5.

restart_on_timeout
שם התהליך להפעלה מחדש כאשר תם הזמן הקצוב של הבקשה. אין הפעלה מחדש
מופעל כאשר לא ניתן. ברירת מחדל: אין.

HttpObserver
שירות זה משקיף עבורך בתהליך http על ידי פינג לאתר מסוים באופן קבוע.
בדומה ל-redis observer הוא מציע להפעיל מחדש את הצופה על שגיאה. זה דורש
טורנדו לרוץ.

יש לו אותה תצורה כמו statd ומוסיף את הדברים הבאים:

להשתמש מכוון ל circus.plugins.http_observer.HttpObserver

loop_rate
התדירות שהתוסף צריך לבקש את הנתונים הסטטיסטיים בשניות. ברירת מחדל: 60.

check_url
כתובת האתר שצריך לבדוק. בְּרִירַת מֶחדָל: http://localhost/

פסק זמן
הזמן הקצוב בשניות שהבקשה עשויה להימשך לפני שהיא נחשבת מושבתת.
ברירת המחדל היא 10.

restart_on_error
שם התהליך להפעלה מחדש כאשר תם הזמן הקצוב לבקשה או שהחזירה בקשה כלשהי
סוג אחר של שגיאה. לא מופעלת מחדש כאשר לא ניתן. ברירת מחדל: אין.

ResourceWatcher
שירות זה צופה במשאבים של התהליך הנתון ומפעיל הפעלה מחדש כאשר
הם חורגים ממגבלות מסוימות לעתים קרובות מדי ברציפות.

יש לו אותה תצורה כמו statd ומוסיף את הדברים הבאים:

להשתמש מכוון ל circus.plugins.resource_watcher.ResourceWatcher

loop_rate
התדירות שהתוסף צריך לבקש את הנתונים הסטטיסטיים בשניות. ברירת מחדל: 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

max_count
באיזו תדירות מותר להגביל את הגבולות האלה (כל אחד מהם נספר בנפרד).
חריגה לפני שתופעל הפעלה מחדש. ברירת מחדל: 3

דוגמא:

[קרקס]
; ...

[צופה:תוכנית]
cmd = שינה 120

[plugin:myplugin]
use = circus.plugins.resource_watcher.ResourceWatcher
צופה = תוכנית
min_cpu = 10
max_cpu = 70
min_mem = 0
max_mem = 20

כלב שמירה
תוסף שמקשר שקע udp ומחכה להודעות Watchdog. עבור "משמר"
תהליכים, כלב השמירה יהרוג אותם אם הם לא ישלחו פעימת לב בזמן מסוים
פרק זמן שהתממש לפי loop_rate * max_count. (קרקס יהיה אוטומטי
הפעל מחדש את התהליכים החסרים בצופה)

כל תהליך מנוטר צריך לשלוח הודעת udp לפחות ב-loop_rate. ה-udp
פורמט ההודעה הוא שורת טקסט, מפוענחת באמצעות msg_regex פָּרָמֶטֶר. פעימות הלב
ההודעה חייבת להכיל לפחות את ה-PID של תהליך שליחת ההודעה.

רשימת הצופים המנוטרים נקבעת לפי הפרמטר watchers_regex ב
תצורה.

פרמטרי תצורה:

להשתמש מכוון ל circus.plugins.watchdog.WatchDog

loop_rate
קצב הלולאה של כלב השמירה בשניות. בכל לולאה, WatchDog יחפש "מתים"
תהליכים.

watchers_regex
regex עבור התאמת שמות צופים שאמורים להיות במעקב על ידי כלב השמירה
(בְּרִירַת מֶחדָל: .* כל הצופים מנוטרים)

msg_regex
regex עבור פענוח הודעת פעימות הלב שהתקבלה ב-udp (ברירת מחדל:
^(?P .*);(?P .*)$) פורמט ברירת המחדל הוא הודעת טקסט פשוטה:
pid;חותמת זמן

max_count
המספר המרבי של הלולאה שעברה ללא קבלת פעימות לב לפני הפעלה מחדש
תהליך (ברירת מחדל: 3)

ip ip כלב השמירה יחייב (ברירת מחדל: 127.0.0.1)

נמל יציאה שכלב השמירה יחייב (ברירת מחדל: 1664)

מתנפנף
כאשר עובד מתחיל לעתים קרובות מדי, אנו אומרים שכן מתנפנף. תוסף זה עוקב אחריו
של העובד מפעיל מחדש ומפסיק את הצופה המקביל למקרה שהוא מתנופף. זֶה
ניתן להשתמש בתוסף כדי לעצור אוטומטית עובדים המופעלים מחדש כל הזמן בגלל
הם לא עובדים כמו שצריך.

להשתמש מכוון ל תוספי קרקס. מתנפנפים. מתנפנפים

ניסיונות
מספר הפעמים שתהליך יכול להתחיל מחדש, בתוך חלון שניות, לפני שאנחנו
תחשוב שזה מתנופף (ברירת מחדל: 2)

חלון חלון הזמן בשניות לבדיקת התנופפות. אם התהליך יתחיל מחדש יותר
מֵאֲשֶׁר ניסיונות פעמים בתוך חלון הזמן הזה, אנו רואים בזה תהליך מתנופף.
(ברירת מחדל: 1)

נסו שוב בעוד
זמן בשניות לחכות עד שננסה להתחיל שוב תהליך שהיה
מתנופפת. (ברירת מחדל: 7)

max_retry
מספר הפעמים שאנו מנסים להתחיל תהליך שהתנופף בעבר
אנחנו נוטשים ועוצרים את כל הצופה. (ברירת מחדל: 5) הגדר ל-1 כדי להשבית
max_retry ונסה שוב ללא הגבלת זמן.

פעיל להגדיר אם הפלאגין פעיל או לא (ברירת מחדל: True). אם הדגל העולמי הוא
מוגדר ל-false, התוסף לא מופעל.

ניתן לעקוף את האפשרויות בקטע הצופה באמצעות א מתנופפת. קידומת. לדוגמה,
הנה איך תגדיר ספציפי max_retry ערך עבור nginx:

[watcher:nginx]
cmd = /path/to/nginx
flapping.max_retry = 2

[watcher:myscript]
cmd = ./my_script.py

; ... צופים אחרים

[plugin:flapping]
use = circus.plugins.flapping.flapping
max_retry = 5

CommandReloader
תוסף זה יפעיל מחדש את הצופים כאשר קובץ הפקודה שלהם ישתנה. זה עובד לפי
בדיקת זמן השינוי והנתיב של הקובץ שמצביע על ידי ה- cmd אפשרות כל
loop_rate שניות. זה עשוי להיות שימושי בעת פיתוח תהליכי עבודה או אפילו עבור חם
שדרוג קוד בייצור.

להשתמש מכוון ל circus.plugins.command_reloader.CommandReloader

loop_rate
התדירות שהתוסף צריך לבדוק אם יש שינויים בשניות. ברירת מחדל: 1.

פְּרִיסָה
למרות שניתן לנהל את דמון הקרקס עם הפקודה circusd, קל יותר לקבל אותו
להתחיל באתחול. אם המערכת שלך תומכת ב-Upstart, תוכל ליצור את הסקריפט של Upstart זה ב
/etc/init/circus.conf.

התחל על מערכת הקבצים ו-net-device-up IFACE=lo
עצור ברמת ריצה [016]

respawn
exec /usr/local/bin/circusd /etc/circus/circusd.ini

זה בהנחה ש-circusd.ini נמצא ב-/etc/circus/circusd.ini. לאחר אתחול מחדש, אתה
יכול לשלוט על circusd עם פקודת השירות:

# התחלה/עצירה/הפעלה מחדש של קרקס שירות

אם המערכת שלך תומכת ב-systemd, תוכל ליצור קובץ יחידת systemd זה תחת
/etc/systemd/system/circus.service.

[יחידה]
תיאור=מנהל תהליכי קרקס
After=syslog.target network.target nss-lookup.target

[שֵׁרוּת]
סוג = פשוט
ExecReload=/usr/bin/circusctl טען מחדש
ExecStart=/usr/bin/circusd /etc/circus/circus.ini
הפעל מחדש = תמיד
RestartSec = 5

[להתקין]
WantedBy=default.target

לא נדרש אתחול אם אתה מפעיל את פקודת daemon-reload למטה:

# systemctl --system daemon-load reload

אז ניתן לנהל את הקרקס באמצעות:

# systemctl start/stop/status/load reload circus

מתכונים
חלק זה יכיל מתכונים לפריסת קרקס. עד אז אתה יכול להסתכל אצל פיט
בּוּבָּה מתכון או אצל רמי שֶׁף מתכון

אפיפיור התַהֲלִיך גַרעִין
בעיה אחת המשותפת למנהלי תהליכים היא שאינך יכול להפעיל מחדש את מנהל התהליכים
מבלי להפעיל מחדש את כל התהליכים שהוא מנהל. זה מקשה על פריסת א
גרסה חדשה של Circus או גרסאות חדשות של כל אחת מהספריות שבהן זה תלוי.

אם אתה על מערכת מסוג Unix, Circus יכול להשתמש בליבת תהליך Papa. כשמשתמשים בו, אבא
תיצור דמון ארוך חיים שישמש כמארח לכל תהליכים ושקעים
אתה יוצר עם זה. אם הקרקס ייסגר, אבא ישמור על כל מה שהוא מארח.

התקנה
התחל בהתקנת ה אבא ו setproctitle מודולים:

pip להתקין אבא
pip התקנת setproctitle

השמיים setproctitle המודול הוא אופציונלי. הוא ישמש אם קיים כדי לשנות את שם דמון הפפא
ל חלק עליון ו ps למשהו כמו "דמון אבא מהקרקס". אם לא תתקין את
setproctitle מודול, כותרת זו תהיה שורת הפקודה של התהליך שהפעיל אותה.
מאוד מבלבל.

לאחר התקנת Papa, הוסף use_papa=true לתהליכים ולשקעים הקריטיים שלך.
בדרך כלל אתה רוצה לאכסן את כל התהליכים של המחסנית שלך ב-Papa, ואף אחד מהם
קרקס תומכים בתהליכים כמו התוספים לפלפול וסטטיסטיקות.

[קרקס]
loglevel = מידע

[watcher: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
delay_warmup = 3
פסק זמן חינני = 10
max_retry = 5
יחיד = נכון
send_hup = נכון
stop_signal = QUIT
stdout_stream.class = FileStream
stdout_stream.filename = /var/logs/web-server.log
stdout_stream.max_bytes = 10000000
stdout_stream.backup_count = 10
stderr_stream.class = FileStream
stderr_stream.filename = /var/logs/web-server-error.log
stderr_stream.max_bytes = 1000000
stderr_stream.backup_count = 10
פעיל = נכון
use_papa = נכון

[watcher:logger]
cmd = /my_service/env/bin/python logger.py הפעלה
working_dir = /my_service
פסק זמן חינני = 10
יחיד = נכון
stop_signal = INT
stdout_stream.class = FileStream
stdout_stream.filename = /var/logs/logger.log
stdout_stream.max_bytes = 10000000
stdout_stream.backup_count = 10
stderr_stream.class = FileStream
stderr_stream.filename = /var/logs/logger.log
stderr_stream.max_bytes = 1000000
stderr_stream.backup_count = 10
עדיפות = 50
use_papa = נכון

[watcher:web_app]
cmd = /my_service/env/bin/uwsgi --ini uwsgi-live.ini --socket fd://$(circus.sockets.web) --stats 127.0.0.1:809$(circus.wid)
working_dir = /my_service/web_app
graceful_timeout=10
stop_signal = QUIT
use_sockets = נכון
stdout_stream.class = FileStream
stdout_stream.filename = /var/logs/web_app.log
stdout_stream.max_bytes = 10000000
stdout_stream.backup_count = 10
stderr_stream.class = FileStream
stderr_stream.filename = /var/logs/web_app.log
stderr_stream.max_bytes = 1000000
stderr_stream.backup_count = 10
hooks.after_spawn = examples.uwsgi_lossless_reload.children_started
hooks.before_signal = examples.uwsgi_lossless_reload.clean_stop
hooks.extended_stats = examples.uwsgi_lossless_reload.extended_stats
עדיפות = 40
use_papa = נכון

[socket:web]
נתיב = /my_service/sock/uwsgi
use_papa = נכון

[plugin:flapping]
use = circus.plugins.flapping.flapping
חלון = 10
עדיפות = 1000

הערה:
אם תהליכי הפאפא משתמשים בשקעים כלשהם, שקעים אלה חייבים להשתמש גם בפאפא.

עיצוב מטרה
Papa תוכנן להיות מאוד מינימליסטי בתכונות ובדרישות. זה עושה:

· שקעי הפעלה ועצירה

· לספק חנות מפתח/ערך

· התחל תהליכים והחזר את stdout, stderr וקוד היציאה

זה לא:

· הפעל מחדש תהליכים

· לספק דרך לעצור תהליכים

· לספק כל מידע על תהליכים מלבד האם הם עדיין פועלים או לא

Papa אינו דורש ספריות של צד שלישי כך שהוא יכול לפעול רק על ספריית Python הסטנדרטית.
זה יכול לעשות שימוש ב setproctitle חבילה אבל זה משמש רק להכנת הכותרת
יפה יותר עבור ps ו חלק עליון ואינו חיוני.

הפונקציונליות נשמרה למינימום כך שלעולם לא תצטרך להפעיל מחדש את
דמון אבא. כמה מהפונקציונליות נדחקה לספריית הלקוח
אפשרי. כך אתה אמור להיות מסוגל לפרוס עותק חדש של Papa עבור תכונות לקוח חדשות
בלי צורך להפעיל מחדש את דמון פאפא. אבא נועד להיות עמוד תווך של יציבות ב
ים משתנה של ספריות צד שלישי.

פעולה
רוב הדברים נשארים ללא שינוי בין אם אתה משתמש ב-Papa ובין אם לא. אתה עדיין יכול להתחיל ולעצור
תהליכים. אתה עדיין יכול לקבל סטטוס וסטטיסטיקה עבור תהליכים. העיקר שמשתנה
זה כאשר אתה עושה circusctl להפסיק, כל תהליכי הפאפא נותרו פועלים. כאשר אתה
התחלה קרקס גיבוי, תהליכים אלה משוחזרים.

הערה:
כאשר תהליכים מתאוששים, לפני_התחל ו before_spawn ווים מדלגים.

רישום
בזמן שסירקוס מושבת, פאפא יאחסן עד 2 מיליון פלט לכל תהליך. ואז זה יהיה
להתחיל לזרוק את הנתונים הישנים ביותר. כאשר אתה מפעיל מחדש את Circus, הפלט המאוחסן במטמון זה יהיה במהירות
אוחזר ונשלח לזרמי הפלט. אבא דורש שקבלת הפלט תהיה
מאושרת, אז אתה לא אמור לאבד שום פלט במהלך כיבוי.

לא רק זה, אבל פאפא שומר את חותמת הזמן של הפלט. קרקס הוגבר ל
נצל את נתוני חותמת הזמן אם קיימים. אז אם אתה כותב את הפלט לקובצי יומן
או איפשהו, חותמות הזמן שלך צריכות להיות נכונות.

בעיות
אם אתה משתמש תוספת or decr פקודה לשנות את ספירת התהליך עבור צופה, זה יעשה
לאפס לרמה המצוינת בקובץ INI כאשר קרקס מופעל מחדש.

כמו כן, חוויתי בעיות עם השילוב של copy_env ו וירטואלי. ייתכן
שים לב שדגימת ה-INI לעיל עוקפת בעיה זו עם נתיבים מפורשים.

Telnet מִמְשָׁק
ל-Papa יש ממשק שורת פקודה בסיסי שאליו אתה יכול לגשת דרך telnet:

20202
לעזור

קרקס ל מפתחים
שימוש קרקס as a ספריה
Circus מספק שיעורים ופונקציות ברמה גבוהה שיאפשרו לך לנהל תהליכים פנימה
היישומים שלך.

לדוגמה, אם אתה רוצה להפעיל ארבעה תהליכים לנצח, תוכל לכתוב:

מ-Circus import get_arbiter

myprogram = {"cmd": "python myprogram.py", "numprocesses": 4}

arbiter = get_arbiter([התוכנית שלי])
נסה:
arbiter.start()
סוף סוף:
arbiter.stop()

קטע זה יפעיל ארבעה מופעים של התוכנית שלי ולצפות בהם בשבילך, להפעיל אותם מחדש
אם הם ימותו במפתיע.

למידע נוסף על כך, ראה ספריה

מאריך קרקס
קל להרחיב את Circus כדי ליצור מערכת מורכבת יותר, על ידי האזנה לכל
קרקס אירועים דרך הפאב/ערוץ המשנה שלו, והנעת אותו באמצעות פקודות.

כך פועלת תכונת ההתנופפות למשל: היא מקשיבה לכל התהליכים גוססים,
מודד באיזו תדירות זה קורה, ועוצר את הצופים המופללים לאחר יותר מדי הפעלה מחדש
ניסיונות.

Circus מגיע עם מערכת תוספים שתעזור לך לכתוב הרחבות כאלה, וכמה מובנות
תוספים שאתה יכול לעשות בהם שימוש חוזר. ראה תוספים.

אתה יכול גם לקבל התנהגות הפעלה וכיבוי עדינה יותר על ידי שימוש ב- ווים מערכת
שיאפשר לך להריץ קוד שרירותי לפני ואחרי כמה תהליכים מופעלים או
עצר. ראה ווים.

אחרון חביב, אתה יכול גם להוסיף פקודות חדשות. ראה הוספת cmds.

מפתחים תיעוד מדד
קרקס סִפְרִיָה
חבילת הקרקס מורכבת מרמה גבוהה get_arbiter() פונקציה ושיעורים רבים. ב
ברוב המקרים, השימוש בפונקציה ברמה גבוהה אמור להספיק, מכיוון שהוא יוצר את כל מה
דרוש לקרקס לרוץ.

אתה יכול לתת כיתה לשיעורים של Circus אם אתה צריך פירוט רב יותר ממה שמציע
תצורה.

השמיים קבל_בורר פונקציה
get_arbiter() הוא רק נוחות על גבי שיעורי הקרקס השונים. זה יוצר א
פוסק (מעמד שוטר) מופע עם האפשרויות שסופקו, אשר בתורו מריץ סינגל
צופה עם סינגל התַהֲלִיך.

circus.get_arbiter()

דוגמא:

מ-Circus import get_arbiter

arbiter = get_arbiter([{"cmd": "myprogram", "numprocesses": 3}])
נסה:
arbiter.start()
סוף סוף:
arbiter.stop()

חוגים
Circus מספקת סדרה של שיעורים שבהם תוכל להשתמש כדי ליישם את מנהל התהליך שלך:

· התַהֲלִיך: עוטף תהליך רץ ומספק כמה עוזרים על גביו.

· צופה: הפעל מספר מופעים של התַהֲלִיך נגד אותה פקודה. נהל את המוות ו
חיים של תהליכים.

· שוטר: מנהל כמה צופה.

בכיתה circus.process.Process(name, wid, cmd, args=אין, working_dir=ללא, מעטפת=שקר,
uid=אין, gid=אין, env=אין, rlimits=אין, הפעלה=אין, use_fds=שקר, צופה=אין,
spawn=נכון, pipe_stdout=נכון, pipe_stderr=נכון, close_child_stdout=שקר,
close_child_stderr=False)
עוטף תהליך.

אפשרויות:

· wid: המזהה הייחודי של התהליך. ערך זה ישמש כדי להחליף את $WID
מחרוזת בשורת הפקודה אם קיימת.

· cmd: הפקודה להפעלה. עשוי להכיל כל אחד מהמשתנים הזמינים שהם
מועבר לכיתה זו. הם יוחלפו באמצעות תחביר פורמט python.

· טוען: הארגומנטים להפעלת הפקודה. יכולה להיות רשימה או מחרוזת. אם טוען is
מחרוזת, היא מפוצלת באמצעות shlex.split (). ברירת המחדל היא ללא.

· הפעלה: כאשר ניתן קובץ הפעלה, הפריט הראשון ברצף args
הושג מ cmd עדיין מתייחסים לרוב התוכניות כשם הפקודה, אשר
לאחר מכן יכול להיות שונה משם ההפעלה בפועל. זה הופך לתצוגה
שם לתוכנית המבצעת בכלי שירות כגון ps.

· working_dir: ספריית העבודה שבה יש להפעיל את הפקודה. אם לא מסופק, יהיה
ברירת המחדל לספריית העבודה הנוכחית.

· פָּגָז: אם נָכוֹן, יריץ את הפקודה בסביבת המעטפת. לא נכון כברירת מחדל.
אַזהָרָה: זֶה is a אבטחה סכנה.

· uid: אם ניתן, האם מזהה המשתמש או השם שאיתו הפקודה צריכה לפעול. הנוכחי
uid הוא ברירת המחדל.

· gid: אם ניתן, האם מזהה הקבוצה או השם שאיתו הפקודה צריכה לפעול. הנוכחי
gid הוא ברירת המחדל.

· env: מיפוי המכיל את משתני הסביבה איתם תפעל הפקודה.
אופציונלי

· rlimits: מיפוי המכיל שמות וערכים של rlimit שיוגדרו לפני ה-
הפקודה פועלת.

· use_fds: אם נכון, לא יסגור את ה-fds בתהליך המשנה. יש להגדיר ל
נכון ב-Windows אם stdout או stderr מנותבים מחדש. ברירת מחדל: False.

· pipe_stdout: אם נכון, יפתח PIPE על stdout. ברירת מחדל: נכון.

· pipe_stderr: אם נכון, יפתח PIPE על stderr. ברירת מחדל: נכון.

· close_child_stdout: אם נכון, מפנה מחדש את ה-stdout של תהליך הילד אל /dev/null
אחרי המזלג. ברירת מחדל: False.

· close_child_stderr: אם נכון, מפנה מחדש את ה-stdout של תהליך הילד אל /dev/null
אחרי המזלג. ברירת מחדל: False.

גיל() החזר את גיל התהליך בשניות.

יְלָדִים()
החזר רשימה של ילדים ילדים.

מידע () החזרת מידע על תהליך.

המידע המוחזר הוא מיפוי עם המפתחות הבאים:

· mem_info1: זיכרון גודל תושב בבתים (RSS)

· mem_info2: גודל זיכרון וירטואלי בבתים (VMS).

· מעבד:% מהשימוש במעבד.

· מ: % משימוש בזיכרון.

· זמן: זמן עיבוד מעבד (משתמש + מערכת) בשניות.

· PID: מזהה תהליך.

· שם משתמש: שם משתמש שהוא הבעלים של התהליך.

· נחמד: נחמדות התהליך (בין -20 ל-20)

· קו ס"מ: שורת הפקודה איתה התנהל התהליך.

is_child(pid)
החזר נכון הוא הנתון PID הוא ילד של התהליך הזה.

PID להחזיר את PID

send_signal(*args, ** קילוואט)
שולח אות sig לתהליך.

send_signal_child(*args, ** קילוואט)
שלח אות חתימה לילד PID.

send_signal_children(*args, ** קילוואט)
שלח אות חתימה לכל הילדים.

מצב החזר את מצב התהליך כקבוע

· רץ

· DEAD_OR_ZOMBIE

· לא קיים

· אחר

סטדרר להחזיר את stdout זרם

stdout להחזיר את stdout זרם

עצור(*ארגס, ** קילוואט)
עצור את התהליך וסגור את stdout/stderr

אם התהליך המתאים עדיין כאן (בדרך כלל הוא כבר נהרג על ידי
הצופה), נשלח SIGTERM, ואז SIGKILL לאחר שנייה אחת.

תהליך הכיבוי (SIGTERM ואז SIGKILL) מתבצע בדרך כלל על ידי
צוֹפֶה. אז אם התהליך עדיין שם, זה סוג של התנהגות רעה
כי פסק הזמן החינני לא יכבד כאן.

דוגמא:

>>> מתוך תהליך ייבוא ​​circus.process
>>> process = Process('Top', 'top', shell=True)
>>> process.age()
3.0107998847961426
>>> process.info()
'למעלה: 6812 N/A tarek Zombie N/AN/AN/AN/AN/A'
>>> process.status
1
>>> process.stop()
>>> process.status
2
>>> process.info()
'אין תהליך כזה (נעצר?)'

בכיתה circus.watcher.Watcher(שם, cmd, args=אין, numprocesses=1, warmup_delay=0.0,
working_dir=ללא, מעטפת=שקר, shell_args=אין, uid=אין, max_retry=5, gid=אין,
send_hup=שקר, stop_signal=15, stop_children=שקר, env=אין, graceful_timeout=30.0,
prereload_fn=אין, rlimits=אין, הפעלה=אין, stdout_stream=אין, stderr_stream=אין,
priority=0, לולאה=אין, singleton=שקר, use_sockets=שקר, copy_env=שקר,
copy_path=שקר, max_age=0, max_age_variance=30, ווים=אין, respawn=נכון, autostart=נכון,
on_demand=שקר, virtualenv=ללא, close_child_stdout=שקר, close_child_stderr=שקר,
virtualenv_py_ver=ללא, use_papa=שקר, **אפשרויות)
כיתה ניהול רשימה של תהליכים עבור פקודה נתונה.

אפשרויות:

· שם: שם שניתן לצופה. משמש לזיהוי ייחודי.

· cmd: הפקודה להפעלה. עשוי להכיל $WID, אשר יוחלף ב wid.

· טוען: הארגומנטים להפעלת הפקודה. יכולה להיות רשימה או מחרוזת. אם טוען is
מחרוזת, היא מפוצלת באמצעות shlex.split (). ברירת המחדל היא ללא.

· מספר תהליכים: מספר התהליכים להפעלה.

· working_dir: ספריית העבודה שבה יש להפעיל את הפקודה. אם לא מסופק, יהיה
ברירת המחדל לספריית העבודה הנוכחית.

· פָּגָז: אם נָכוֹן, יריץ את הפקודה בסביבת המעטפת. לא נכון כברירת מחדל.
אַזהָרָה: זֶה is a אבטחה סכנה.

· uid: אם ניתן, האם מזהה המשתמש או השם שאיתו הפקודה צריכה לפעול. הנוכחי
uid הוא ברירת המחדל.

· gid: אם ניתן, האם מזהה הקבוצה או השם שאיתו הפקודה צריכה לפעול. הנוכחי
gid הוא ברירת המחדל.

· שלח_הפ: אם נכון, טעינת תהליך מחדש תתבצע על ידי שליחת האות SIGHUP.
ברירת המחדל ל-False.

· אות_עצירה: האות שיש לשלוח בעת עצירת התהליך. ברירת המחדל היא SIGTERM.

· עצור_ילדים: שלח את ה אות_עצירה גם לילדים. ברירת המחדל ל-False.

· env: מיפוי המכיל את משתני הסביבה איתם תפעל הפקודה.
אופציונלי

· rlimits: מיפוי המכיל שמות וערכים של rlimit שיוגדרו לפני ה-
הפקודה פועלת.

· stdout_stream: מיפוי שמגדיר את הזרם עבור ה-proces stdout. ברירות מחדל
ל-None.

אופציונאלי. כאשר מסופק, stdout_stream הוא מיפוי המכיל עד שלושה מפתחות:

· בכיתה: כיתת הנחל. ברירת מחדל ל circus.stream.FileStream

· שם הקובץ: שם הקובץ, אם משתמשים ב-FileStream

· max_bytes: גודל קובץ מקסימלי, שלאחריו נפתח קובץ פלט חדש. ברירות מחדל
ל-0 כלומר אין גודל מקסימלי (מתאים רק עם FileStream).

· גיבוי_ספירת: כמה גיבויים לשמור בעת סיבוב קבצים לפי ה
פרמטר max_bytes. ברירת המחדל היא 0 מה שאומר שלא מתבצעים גיבויים (רק
ישים עם FileStream)

מיפוי זה ישמש ליצירת זרם הניתן להתקשרות של המחלקה שצוינה.
כל ערך שמתקבל על ידי הניתן להתקשרות הוא מיפוי המכיל:

· PID - תהליך pid

· שם - שם הזרם (סטדרר or stdout)

· נתונים - הנתונים

זה לא נתמך ב-Windows.

· stderr_stream: מיפוי שמגדיר את הזרם עבור תהליך stderr. ברירות מחדל
ל-None.

אופציונאלי. כאשר מסופק, stderr_stream הוא מיפוי המכיל עד שלושה מפתחות:
- בכיתה: כיתת הנחל. ברירת מחדל ל circus.stream.FileStream - שם הקובץ: ה
שם קובץ, אם משתמשים ב- FileStream - max_bytes: גודל קובץ מקסימלי, ולאחר מכן חדש
קובץ הפלט הוא
נפתח. ברירת המחדל היא 0, כלומר אין גודל מקסימלי (מתאים רק עם
FileStream)

· גיבוי_ספירת: כמה גיבויים לשמור בעת סיבוב קבצים לפי ה
פרמטר max_bytes. ברירת המחדל היא 0 מה שאומר שלא מתבצעים גיבויים (רק
ישים עם FileStream).

מיפוי זה ישמש ליצירת זרם הניתן להתקשרות של המחלקה שצוינה.

כל ערך שמתקבל על ידי הניתן להתקשרות הוא מיפוי המכיל:

· PID - תהליך pid

· שם - שם הזרם (סטדרר or stdout)

· נתונים - הנתונים

זה לא נתמך ב-Windows.

· עדיפות -- מספר שלם המגדיר עדיפות עבור הצופה. כשהבורר יעשה זאת
כמה פעולות על כל הצופים, זה ימיין אותם עם השדה הזה, מה
מספר גדול יותר לקטן ביותר. (ברירת מחדל: 0)

· קְלָף בּוֹדֵד -- אם נכון, לצופה הזה יש תהליך יחיד. (ברירת מחדל: False)

· use_sockets -- אם נכון, התהליכים יירשו את מתארי הקבצים, ובכך יכולים
לעשות שימוש חוזר בשקעים שנפתחו על ידי circusd. (ברירת מחדל: False)

· לפי דרישה -- אם נכון, התהליכים יופעלו רק בחיבור הראשון
לשקע (ברירת מחדל: False)

· copy_env -- אם נכון, הסביבה שבה מתנהל הקרקס תהיה
משוכפל עבור העובדים. ברירת המחדל היא True ב-Windows מכיוון שאינך יכול להפעיל
כל קובץ הפעלה ללא SYSTEMROOT מִשְׁתַנֶה. (ברירת מחדל: False)

· copy_path - אם זה נכון, קרקס sys.path נשלח לתהליך דרך PYTHONPATH.
עליך להפעיל copy_env ל copy_path לעבוד. (ברירת מחדל: False)

· max_age: אם מוגדר לאחר בסביבות max_age seconds, התהליך מוחלף בחדש
אחד. (ברירת מחדל: 0, מושבת)

· max_age_variance: המספר המרבי של שניות שניתן להוסיף ל-max_age.
ערך נוסף זה נועד להימנע מהפעלה מחדש של כל התהליכים בו-זמנית. א
התהליך יתקיים בין max_age לבין max_age + max_age_variance שניות.

· ווים: פונקציות התקשרות חוזרת לחיבור להפעלה וכיבוי של הצופה
התהליך. ווים הוא dict שבו כל מפתח הוא שם הוו וכל ערך הוא a
2-tuple עם השם של הניתן להתקשרות או הנקרא עצמו ודגל בוליאני
המציין אם אין להתעלם מחריג המתרחש ב-hook. אפשרי
ערכים עבור שם הוו: לפני_התחל, after_start, before_spawn, after_spawn,
לפני_עצור, after_stop., לפני_אות, אחרי_אות or סטטיסטיקות_מורחבות.

· אפשרויות -- אפשרויות נוספות עבור העובד. כל האפשרויות נמצאות בתצורה
למשל, מועברים במיפוי זה -- זה יכול לשמש תוספים עבור
אפשרויות ספציפיות לצופה.

· respawn -- אם מוגדר כ-false, התהליכים המטופלים על ידי צופה לא יהיו
הופץ מחדש באופן אוטומטי. (ברירת מחדל: נכון)

· וירטואלי -- ספריית השורש של virtualenv. אם יסופק, הצופה יעשה זאת
להעמיס את הסביבה לביצועה. (ברירת מחדל: אין)

· close_child_stdout: אם נכון, סוגר את ה-stdout אחרי המזלג. ברירת מחדל: False.

· close_child_stderr: אם נכון, סוגר את הסטדרר אחרי המזלג. ברירת מחדל: False.

· use_papa: אם נכון, השתמש בליבת תהליך papa עבור תהליך זה. ברירת מחדל: False.

kill_process(*args, **קווארגס)
תהליך הרג (stop_signal, graceful_timeout ואז SIGKILL)

kill_processes(*args, **קווארגס)
הרוג את כל התהליכים (stop_signal, graceful_timeout ואז SIGKILL)

manage_processes(*args, **קווארגס)
ניהול תהליכים.

notify_event(נושא, msg)
פרסם הודעה בערוץ מפרסם האירוע

reap_and_manage_processes(*args, **קווארגס)
קצור ונהל תהליכים.

reap_processes(*args, ** קילוואט)
קצור את כל התהליכים עבור הצופה הזה.

send_signal_child(*args, ** קילוואט)
שלח אות לילד.

spawn_process(recovery_wid=None)
תהליך השרצים.

החזר True אם בסדר, False אם יש לעצור את הצופה

spawn_processes(*args, **קווארגס)
תהליכי השרצים.

בכיתה circus.arbiter.Arbiter(watchers, נקודת קצה, pubsub_endpoint, check_delay=1.0,
prereload_fn=אין, context=אין, לולאה=אין, statsd=שקר, stats_endpoint=אין,
statsd_close_outputs=שקר, multicast_endpoint=ללא, plugins=אין, שקעים=אין,
warmup_delay=0, httpd=שקר, httpd_host='localhost', httpd_port=8080,
httpd_close_outputs=שקר, debug=שקר, debug_gc=שקר, ssh_server=אין,
proc_name='circusd', pidfile=אין, loglevel=ללא, logoutput=ללא, loggerconfig=ללא,
fqdn_prefix=אין, umask=אין, endpoint_owner=אין, papa_endpoint=ללא)
הכיתה משמשת לשליטה ברשימת צופים.

אפשרויות:

· צופים -- רשימה של אובייקטים של Watcher

· נקודת סיום -- נקודת הקצה של הבקר ZMQ

· pubsub_endpoint -- נקודת הקצה של pubsub

· סטטיסטיקה -- אם נכון, מופעל תהליך circusd-stats (ברירת מחדל: False)

· stats_endpoint -- נקודת הקצה הסטטיסטית.

· statsd_close_outputs -- אם True שולח את circusd-stats stdout/stderr אל
/dev/null (ברירת מחדל: False)

· multicast_endpoint -- נקודת הסיום של ריבוי שידורים לגילוי אוטומטי של אשכול circusd
(ברירת מחדל: udp://237.219.251.97:12027) כתובת ריבוי שידור צריכה להיות בין 224.0.0.0
ל-239.255.255.255 וזהה עבור אשכול הכל.

· check_delay -- ההשהיה בין שתי נקודות בקרה (ברירת מחדל: 1 שניות)

· prereload_fn -- ניתן להתקשרות שיבוצע בכל טעינה מחדש (ברירת מחדל: אין)

· הקשר -- אם מסופק, ההקשר של zmq לשימוש חוזר. (ברירת מחדל: אין)

·

לולאה: if בתנאי, a zmq.eventloop.ioloop.IOLoop למשל
לעשות שימוש מחודש. (ברירת מחדל: אין)

· תוספים -- רשימה של תוספים. כל פריט הוא מיפוי עם:

· להשתמש -- שם מלא המצביע על מחלקת הפלאגין

· כל ערך אחר מועבר לפלאגין ב- config אוֹפְּצִיָה

· ארובות -- מיפוי של שקעים. כל מפתח הוא שם השקע, וכל ערך a
CircusSocket מעמד. (ברירת מחדל: אין)

· עיכוב_חימום - עיכוב בשניות בין הפעלה של שני צופים. (ברירת מחדל: 0)

· httpd -- אם נכון, מופעל תהליך circushttpd (ברירת מחדל: False)

· httpd_host -- המארח circushttpd (ברירת מחדל: localhost)

· httpd_port -- נמל circushttpd (ברירת מחדל: 8080)

· httpd_close_outputs -- אם נכון, שולח את circushttpd stdout/stderr אל /dev/null.
(ברירת מחדל: False)

· באגים -- אם נכון, מוסיף מידע רב על ניפוי באגים ב-stdout (ברירת מחדל: False)

· debug_gc -- אם נכון, האם gc.set_debug(gc.DEBUG_LEAK) (ברירת מחדל: False) ל-circusd
לנתח בעיות (ברירת מחדל: False)

· proc_name -- שם תהליך הבורר

·

fqdn_prefix -- a קידומת ל מה היא ייחודי מזהה of מה היא קרקס
מופע על האשכול.

· endpoint_owner - משתמש יוניקס לבחירת נקודת הקצה אם משתמשים ב-ipc.

· papa_endpoint -- נקודת הסיום של ליבת תהליך Papa

add_watcher(*args, **קווארגס)
מוסיף צופה.

אפשרויות:

· שם: שם הצופה להוספה

· cmd: הפקודה להפעלה.

· כל שאר האפשרויות המוגדרות בבנאי Watcher.

get_watcher(שם)
החזר את הצופה שם.

numprocesses()
החזר את מספר התהליכים הפועלים בכל הצופים.

numwatchers()
החזר את מספר הצופים.

טען מחדש(*args, **קווארגס)
טוען הכל מחדש.

הפעל את prereload_fn() ניתן להתקשר אם יש, אז בחן מחדש את כל הצופים.

start(*args, **קווארגס)
מתחיל את כל הצופים.

אם ה-ioloop סופק במהלך הקריאה __init__(), מפעיל את כל הצופים
כקורוטינה סטנדרטית

אם ה-ioloop לא סופק במהלך הקריאה __init__() (ברירת מחדל), מתחיל
כל הצופים וה-eventloop (וגם חסימות כאן). במצב זה השיטה
אסור להניב שום דבר כי זה נקרא כשיטה סטנדרטית.

פרמטרים
cb -- התקשרות חוזרת התקשרה לאחר שכל הצופים הופעלו, מתי
הלולאה לא סופקה.

כתיבה תוספים
Circus מגיע עם מערכת תוספים המאפשרת לך לתקשר איתה קרקס.

הערה:
אנו עשויים להוסיף תמיכת circusd-stats לתוספים בהמשך.

תוסף מורכב משני חלקים:

· מנוי ZMQ לכל האירועים שפורסמו על ידי קרקס

· לקוח ZMQ לשלוח אליו פקודות קרקס

כל תוסף מופעל כתהליך נפרד תחת צופה מותאם אישית.

כמה דוגמאות לכמה תוספים שתוכל ליצור עם מערכת זו:

· מערכת התראות השולחת התראות בדואר אלקטרוני כאשר צופה מנפנף

· כורת עצים

· כלי המוסיף או מסיר תהליכים בהתאם לעומס

· וכו.

Circus עצמו מגיע עם כמה תוספים מובנים.

השמיים CircusPlugin בכיתה
Circus מספקת שיעור בסיס שיעזור לך ליישם תוספים: circus.plugins.CircusPlugin

בכיתה circus.plugins.CircusPlugin(נקודת קצה, pubsub_endpoint, check_delay, ssh_server=אין,
**תצורה)
מחלקה בסיס לכתיבת תוספים.

אפשרויות:

· הקשר -- ההקשר של ZMQ לשימוש

· נקודת סיום -- נקודת הקצה של circusd ZMQ

· pubsub_endpoint -- נקודת הקצה של פאב/משנה circusd ZMQ

· check_delay -- עיכוב הבדיקה המוגדר

· config -- מיפוי תצורה בחינם

call(command, **אביזרים)
שולח את הפקודה אל קרקס

אפשרויות:

· הפקודה -- הפקודה להתקשר

· אבזרים -- ארגומנטים של מילת מפתח להוספה לשיחה

מחזירה את מיפוי ה-JSON שנשלח בחזרה על ידי קרקס

cast(פקודה, **אביזרים)
אש ושכח פקודה ל קרקס

אפשרויות:

· הפקודה -- הפקודה להתקשר

· אבזרים -- ארגומנטים של מילת מפתח להוספה לשיחה

handle_init()
נקרא ממש לפני הפעלת תוסף - בהקשר השרשור.

handle_recv(data)
מקבל כל אירוע שפורסם על ידי קרקס

אפשרויות:

· נתונים -- טפול המכיל את הנושא והמסר.

handle_stop()
התקשר ממש לפני שהפלאגין נעצר על ידי Circus.

כאשר מאתחל על ידי Circus, מחלקה זו יוצרת לולאת אירועים משלה שמקבלת הכל
קרקס אירועים ולהעביר אותם אליהם handle_recv(). הנתונים שהתקבלו הם טופל המכיל את
הנושא והנתונים עצמם.

handle_recv() צריך להיות מיושם על ידי הפלאגין.

השמיים שִׂיחָה() ו ללהק() ניתן להשתמש בשיטות ליצירת אינטראקציה קרקס אם אתה בונה א
תוסף שמקיים אינטראקציה פעילה עם הדמון.

handle_init() ו handle_stop() הן רק שיטות נוחות שבהן אתה יכול להשתמש כדי לאתחל ו
לנקות את הקוד שלך. handle_init() נקרא בתוך השרשור שזה עתה התחיל.
handle_stop() נקרא בשרשור הראשי ממש לפני הפסקת החוט וחיבורו.

כתיבה a חיבור
בואו נכתוב תוסף שמתחבר לקובץ כל אירוע שקורה בו קרקס. זה לוקח אחד
ארגומנט שהוא שם הקובץ.

התוסף עשוי להיראות כך:

מ-circus.plugins ייבוא ​​CircusPlugin

class Logger(CircusPlugin):

שם = 'לוגר'

def __init__(self, *args, **config):
super(Logger, self).__init__(*args, **config)
self.filename = config.get('filename')
self.file = אין

def handle_init(self):
self.file = open(self.filename, 'a+', buffering=1)

def handle_stop(self):
self.file.close()

def handle_recv(self, data):
watcher_name, action, msg = self.split_data(data)
msg_dict = self.load_message(מסג)
self.file.write('%s %s::%r\n' % (action, watcher_name, msg_dict))

זהו זה ! ניתן לשמור את המחלקה הזו בכל חבילה/מודול, כל עוד ניתן לראות אותה על ידי
פייתון

לדוגמה, לוגר ניתן למצוא ב א תוספים מודול בתוך a הפרויקט שלי חֲבִילָה.

אסינק בקשות
למקרה שתרצה לבצע פעולות אסינכרוניות כלשהן (כמו שיחת טורנדו או שימוש
periodicCall) ודא שאתה משתמש בלולאה הנכונה. הלולאה שבה אתה תמיד רוצה להשתמש
הוא self.loop כפי שהוא מוגדר על ידי מחלקת הבסיס. לרוב לולאת ברירת המחדל אינה זהה
ולכן ייתכן שהקוד לא יבוצע כצפוי.

מנסה a חיבור
אתה יכול להפעיל תוסף דרך שורת הפקודה עם ה קרקס-פלאגין פקודה, על ידי
ציון שם התוסף המלא:

$ circus-plugin --endpoint tcp://127.0.0.1:5555 --pubsub tcp://127.0.0.1:5556 --config filename:circus-events.log myproject.plugins.Logger
[INFO] טוען את הפלאגין...
[INFO] נקודת קצה: 'tcp://127.0.0.1:5555'
[INFO] Pub/sub: 'tcp://127.0.0.1:5556'
[INFO] מתחיל

דרך נוספת להפעיל תוסף היא לתת לסירקוס לטפל באתחול שלו. זה נעשה על ידי
הוספת א [פלאגין:שם] סעיף בקובץ התצורה, איפה שֵׁם הוא שם ייחודי עבור
התוסף שלך:

[plugin:logger]
use = myproject.plugins.Logger
שם הקובץ = /var/myproject/circus.log

להשתמש הוא חובה ומצביע על השם המלא של התוסף.

כאשר קרקס מתחיל, הוא יוצר צופה עם תהליך אחד שמפעיל את השיעור המחודד, ו
להעביר כל משתנה אחר הכלול בקטע לבנאי הפלאגין דרך ה- config
מיפוי.

אתה יכול גם להוסיף פלאגין באופן תכנותי בעת יצירת א קרקס.בורר.בורר בכיתה
או שימוש circus.get_arbiter(), ראה ספריה.

הופעות
מכיוון שכל תוסף נטען בתהליך משלו, זה לא אמור להשפיע על הכלל
ביצועים של המערכת כל עוד העבודה שנעשתה על ידי התוסף לא עושה יותר מדי
שיחות ל קרקס התהליך.

הוקס
קרקס מספק ווים שניתן להשתמש בהם כדי להפעיל פעולות באירועי צופה. זמין
ווים הם:

· לפני_התחל: נקרא לפני הפעלת הצופה. אם הקרס חוזר לא נכון מה היא
ההפעלה הופסקה.

· after_start: נקרא לאחר הפעלת הצופה. אם הקרס חוזר לא נכון הצופה
מופסק מיד וההפעלה מבוטלת.

· before_spawn: נקרא לפני שהצופה מוביל תהליך חדש. אם הקרס חוזר לא נכון
הצופה מופסק מיד וההפעלה מופסקת.

· after_spawn: נקרא לאחר שהצופה הוליד תהליך חדש. אם הקרס חוזר לא נכון
הצופה מופסק מיד וההפעלה מופסקת.

· לפני_עצור: נקרא לפני שהצופה נעצר. מתעלמים מתוצאת ה-hook.

· after_stop: נקרא לאחר הפסקת הצופה. מתעלמים מתוצאת ה-hook.

· לפני_אות: נקרא לפני שליחת אות לתהליך של צופה. אם הקרס
החזרות לא נכון האות לא נשלח (למעט SIGKILL שנשלח תמיד)

· אחרי_אות: נקרא לאחר שליחת אות לתהליך של צופה.

· סטטיסטיקות_מורחבות: נקרא כאשר מתבקשים נתונים סטטיסטיים עם extended=True. משמש להוספה
נתונים סטטיסטיים ספציפיים לתהליך לפלט הסטטיסטיקה הרגילה.

דוגמה
מקרה שימוש טיפוסי הוא לבקר שכל התנאים מתקיימים לתחילת תהליך.
נניח שיש לך צופה שפועל Redis וצופה שמריץ סקריפט של Python ש
עובד עם Redis. עם Circus אתה יכול להזמין את הסטארט-אפ באמצעות עדיפות אפשרות:

[צופה:עובד בתור]
cmd = python -u worker.py
עדיפות = 1

[watcher:redis]
cmd = redis-server
עדיפות = 2

עם ההגדרה הזו, Circus יתחיל Redis תחילה ולאחר מכן הוא יתחיל את עובד התור.
אבל קרקס לא באמת שולט בזה Redis פועל. זה רק מתחיל את
תהליך שהתבקש להתחיל. מה שאנחנו מתגעגעים כאן הוא דרך לשלוט בזה Redis is
התחיל ומתפקד במלואו. פונקציה ששולטת בזה יכולה להיות:

ייבוא ​​redis
זמן יבוא

def check_redis(*args, **kw):
time.sleep(.5) # תן לזה הזדמנות להתחיל
r = redis.StrictRedis(host='localhost', port=6379, db=0)
r.set('foo', 'bar')‎
return r.get('foo') == 'bar'

פונקציה זו יכולה להיות מחוברת לסירקוס בתור לפני_התחל וו:

[צופה:עובד בתור]
cmd = python -u worker.py
hooks.before_start = mycoolapp.myplugins.check_redis
עדיפות = 1

[watcher:redis]
cmd = redis-server
עדיפות = 2

ברגע שקרקס התחיל את חוזר צופה, זה יתחיל את עובד תור צופה, מאז
זה עוקב אחר ה עדיפות הזמנה. רגע לפני הפעלת הצופה השני, הוא יפעל
מה היא check_redis פונקציה, ובמקרה שהיא חוזרת לא נכון יבטל את הפעלת הצופה
התהליך.

וו חֲתִימָה
וו חייב לעקוב אחר החתימה הזו:

def hook(watcher, arbiter, hook_name, **kwargs):
...
# אם לא תחזיר True, הקרס יכול להשתנות
# ההתנהגות של קרקס (תלוי בהוק)
להחזיר נכון

איפה צוֹפֶה האם ה צופה דוגמה בכיתה, פוסק מה היא שוטר אחד, Hook_name הוו
שם ו קווארגס כמה פרמטרים אופציונליים נוספים (בהתאם לסוג הקרס).

השמיים after_spawn hook מוסיף את פרמטרי pid:

def after_spawn(watcher, arbiter, hook_name, pid, **kwargs):
...
# אם לא תחזיר את True, הקרקס יהרוג את התהליך
להחזיר נכון

איפה PID הוא ה-PID של התהליך המתאים.

כמו כן, לפני_אות ו אחרי_אות ווים מוסיפים pid ו-signum:

def before_signal_hook(watcher, arbiter, hook_name, pid, signnum, **kwargs):
...
# אם לא תחזיר True, קרקס לא ישלח את אות הסימן
# (SIGKILL נשלח תמיד)
להחזיר נכון

איפה PID הוא ה-PID של התהליך המתאים ו חתימה הוא האות המתאים.

אתה יכול להתעלם מאלה אבל היכולת להשתמש בנתונים ובשיטות של הצופה ו/או הבורר
להיות שימושי בכמה ווים.

שימו לב ש-hooks נקראים עם ארגומנטים בעלי שם. אז השתמש בחתימת הוו בלי
שינוי שמות ארגומנטים.

השמיים סטטיסטיקות_מורחבות להוק יש פרמטרים נוספים משלו ב קווארגס:

def extended_stats_hook(watcher, arbiter, hook_name, pid, stats, **kwargs):
...

איפה PID הוא ה-PID של התהליך המתאים ו סטטיסטיקות הסטטיסטיקה הרגילה להיות
חזר. הוסף נתונים סטטיסטיים משלך לתוך סטטיסטיקות. דוגמה נמצאת ב
examples/uwsgi_lossless_reload.py.

כדוגמה אחרונה, הנה סופר וו שיכול להתמודד עם כל מיני אותות:

def super_hook(watcher, arbiter, hook_name, **kwargs):
pid = אין
סימן = אין
if hook_name in ('before_signal', 'after_signal'):
pid = kwargs['pid']
signum = kwargs['signum']
...
להחזיר נכון

וו אירועים
בכל פעם שהוק מופעל, התוצאה שלו מקבלת הודעה כאירוע בקרקס.

ישנם שני אירועים הקשורים ל-hooks:

· הוק_הצלחה: הוק נקרא בהצלחה. מפתחות האירוע הם שם השם אם ה
אירוע, וכן זמן: תאריך האירועים.

· hook_failure: הוק נכשל. מפתחות האירוע הם שם השם אם האירוע, זמן:
תאריך האירועים ו שגיאה: החריג שהתרחש באירוע, אם בכלל.

מוסיף חדש פקודות
ניסינו להפוך את הוספת פקודות חדשות לפשוטה ככל האפשר.

אתה צריך לעשות שלושה דברים:

1. ליצור א your_command.py קובץ תחת קרקס/פקודות/.

2. הטמיע שם מחלקה אחת, עם שיטות מוגדרות מראש

3. הוסף את הפקודה החדשה circus/commands/__init__.py.

נניח שאנו רוצים להוסיף פקודה שמחזירה את מספר הצופים שנמצאים כעת בשימוש,
היינו עושים משהו כזה (הגיבו בהרחבה כדי לאפשר לך לעקוב אחר
בְּקַלוּת):

מ-circus.commands.base ייבוא ​​Command
מ-circus.exc ייבוא ​​ArgumentError, MessageError
class NumWatchers (פקודה):
"""זה תרגול טוב לתאר מה הכיתה עושה כאן.

עיין בפקודות אחרות כדי לראות כיצד אנו רגילים לעצב
הטקסט הזה. זה ייכלל אוטומטית בתיעוד,
אז אל תפחד להיות ממצה, זה מה שזה נעשה
ל.
"" "
# כל הפקודות יורשות מ`circus.commands.base.Command`

# אתה צריך לציין שם כדי למצוא את הפקודה איכשהו
שם = "numwatchers"

# הגדר את ההמתנה ל-True או False כדי להגדיר את התנהגות ברירת המחדל שלך
# - אם ההמתנה היא True, הפקודה מופעלת באופן סינכרוני, והלקוח עשוי לקבל
# תוצאות חזרה.
# - אם המתנה היא False, הפקודה מופעלת באופן אסינכרוני בשרת ובלקוח באופן מיידי
# מקבל בחזרה תגובה 'בסדר'
#
# כברירת מחדל, הפקודות מוגדרות ל- waiting = False
מחכה = נכון

# אפשרויות
options = [('', 'optname', default_value, 'description')]

מאפיינים = ['foo', 'בר']
# מאפיינים מציגים את ארגומנטי הפקודה שהם חובה. אם הם
# לא מסופק, אז תיגרם שגיאה

def execute (עצמי, בורר, אביזרים):
# שיטת הביצוע היא הליבה של הפקודה: שים כאן את כל
# לוגיקה של הפקודה והחזרת dict המכיל את הערכים שאתה
# רוצה לחזור, אם יש
החזר {"numwatchers": arbiter.numwatchers()}

def console_msg(self, msg):
# msg הוא מה שמוחזר על ידי שיטת הביצוע.
# שיטה זו משמשת לעיצוב התגובה עבור קונסולה (זה
# משמש למשל על ידי circusctl כדי להדפיס את ההודעות שלו)
החזר "מחרוזת שתוצג"

def message(self, *args, **opts):
# הודעה מטפלת בקלט המסוף.
# שיטה זו משמשת למיפוי ארגומנטים של מסוף לפקודה
# אפשרויות. (הוא משמש למשל כאשר קוראים לפקודה via
# circusctl)
# NotImplementedError תושק אם הפונקציה חסרה
numArgs = 1
אם לא len(args) == numArgs:
raise ArgumentError('מספר לא חוקי של ארגומנטים.')
else
opts['optname'] = args[0]
החזר self.make_message(**opts)

def validate (עצמי, אביזרים):
# שיטה זו משמשת כדי לאמת שהארגומנטים הועברו ל-
פקודה # נכונה. יש לזרוק ArgumentError למקרה
# יש שגיאה בארגומנטים שעברו (למשל אם הם
# לא מתאימים זה לזה.
# במקרה שיש בעיה בתוכן שלהם, הודעת MessageError
יש לזרוק #. שיטה זו יכולה לשנות את התוכן של האביזרים
# dict, הוא יועבר לביצוע לאחר מכן.

השתמש מקרים דוגמאות
פרק זה מציג כמה מקרי שימוש, כדי לתת לך מושג כיצד להשתמש ב-Circus ב-Circus שלך
סביבה.

ריצה a WSGI יישום
הפעלת אפליקציית WSGI עם Circus היא די מעניינת מכיוון שאתה יכול לצפות ולנהל
שֶׁלְךָ אינטרנט עובדים באמצעות טופ קרקס, circusctl או ממשק האינטרנט.

זה מתאפשר באמצעות שקעי קרקס. ראה למה שקעים.

ניקח דוגמה עם מינימום פירמידה יישום:

מ-pyramid.config ייבוא ​​Configurator
מ-pyramid.response import Response

def hello_world (בקשה):
return Response('שלום %(name)s!' % request.matchdict)

config = Configurator()
config.add_route('hello', '/hello/{name}')
config.add_view(hello_world, route_name='hello')
application = config.make_wsgi_app()

שמור את הסקריפט הזה ב-an app.py קובץ, ואז התקן את הפרויקטים האלה:

$ pip להתקין פירמידה
$ pip להתקין chausset

לאחר מכן, ודא שאתה יכול להפעיל את יישום הפירמידה שלך באמצעות ה גֶרֶב סקריפט מסוף:

$ chausset app.application
יישום הוא
הגשה ב-localhost:8080
באמצעות בתור קצה אחורי

ובדקו שאתם יכולים להגיע אליו בביקור http://localhost:8080/hello/tarek

כעת כשהאפליקציה שלך פועלת, בואו ניצור קובץ תצורה של Circus:

[קרקס]
check_delay = 5
נקודת קצה = tcp://127.0.0.1:5555
pubsub_endpoint = tcp://127.0.0.1:5556
stats_endpoint = tcp://127.0.0.1:5557

[watcher:webworker]
cmd = chaussette --fd $(circus.sockets.webapp) app.application
use_sockets = נכון
מספר תהליכים = 3

[socket:webapp]
מארח = 127.0.0.1
יציאה = 8080

הקובץ הזה אומר לסירקוס לאגד שקע ביציאה 8080 ורוץ גֶרֶב עובדים על זה
שקע - על ידי העברת ה-fd שלו.

שמור אותו ל server.ini ונסה להריץ אותו באמצעות קרקס

$ circusd server.ini
[INFO] התחלת מאסטר ב-pid 8971
הופעלו שקעי [INFO]
[INFO] circusd-stats התחילו
[INFO] האפליקציה הופעלה
[INFO] פוסק מחכה כעת לפקודות

ודא שאתה עדיין מפעיל את האפליקציה http://localhost:8080/hello/tarek.

מזל טוב ! יש לך יישום WSGI שמריץ 3 עובדים.

אתה יכול להפעיל את circushttpd או את ה-cli, וליהנות מניהול קרקס.

ריצה a ג'נגו יישום
הפעלת אפליקציית Django נעשית בדיוק כמו הפעלת אפליקציית WSGI. להשתמש ב
PYTHONPATH כדי לייבא את הספרייה בה נמצא הפרוייקט, הספרייה המכילה את
ספרייה שיש בה settings.py (עם Django 1.4+ יש בספרייה הזו manage.py)
:

[socket:dwebapp]
מארח = 127.0.0.1
יציאה = 8080

[watcher:dwebworker]
cmd = chaussette --fd $(circus.sockets.dwebapp) dproject.wsgi.application
use_sockets = נכון
מספר תהליכים = 2

[env:dwebworker]
PYTHONPATH = /path/to/parent-of-dproject

אם אתה צריך לעבור את DJANGO_SETTINGS_MODULE עבור עובד backend למשל, אתה יכול
להעביר את זה גם למרות ה env אפשרות תצורה:

[watcher:dbackend]
cmd = /path/to/script.py
מספר תהליכים=3

[env:dbackend]
PYTHONPATH = /path/to/parent-of-dproject
DJANGO_SETTINGS_MODULE=dproject.settings

לִרְאוֹת http://chaussette.readthedocs.org למידע נוסף על chausset.

עיצוב החלטות
באופן כללי ארכיטקטורה
[תמונה]

קרקס מורכב מתהליך עיקרי הנקרא קרקס שדואגת להפעיל את כל
תהליכים. כל תהליך המנוהל על ידי קרקס הוא תהליך ילד של קרקס.

תהליכים מאורגנים בקבוצות הנקראות צופים. צוֹפֶה זה בעצם פקודה
קרקס פועל על המערכת שלך, ולכל פקודה אתה יכול להגדיר כמה תהליכים אתה
רוצה לרוץ.

הרעיון של צוֹפֶה שימושי כאשר אתה רוצה לנהל את כל התהליכים המריצים את
אותה פקודה -- כמו הפעל אותם מחדש וכו'.

קרקס מחבר שני שקעי ZeroMQ:

· REQ/REP -- שקע המשמש לשליטה קרקס באמצעות מבוסס json פקודות.

· PUB/SUB -- שקע שבו קרקס מפרסם אירועים, כמו מתי מתחיל תהליך או
עצר.

הערה:
למרות שמה, ZeroMQ אינה מערכת לניהול תורים. תחשוב על זה כעל
ספריית תקשורת בין תהליכים (IPC).

תהליך אחר נקרא סטטיסטיקות קרקס מנוהל על ידי קרקס כאשר האפשרות מופעלת.
סטטיסטיקות קרקסתפקידו הוא לפרסם נתונים סטטיסטיים של שימוש במעבד/זיכרון בקובץ ייעודי PUB/SUB
ערוץ.

ערוץ מיוחד זה משמש את טופ קרקס ו קרקס-httpd כדי להציג זרם חי
של הפעילות.

טופ קרקס הוא סקריפט קונסולה המחקה חלק עליון כדי להציג את כל השימוש במעבד ובזיכרון של
התהליכים בניהול קרקס.

קרקס-httpd הוא ממשק ניהול האינטרנט שיאפשר לך ליצור אינטראקציה עם Circus. זה
מציג זרם חי באמצעות שקעי אינטרנט ו- סטטיסטיקות קרקס ערוץ, אבל גם לאפשר לך
להתערבב עם קרקס דרך שלה REQ/REP ערוץ.

האחרון חביב, circusctl הוא כלי שורת פקודה המאפשר לך לנהוג קרקס דרך שלה
REQ/REP ערוץ.

אתה יכול גם לקבל תוספים שנרשמים אליהם קרקס's PUB/SUB ערוץ ולתת לך לשלוח
פקודות ל- REQ/REP כמו ערוץ circusctl היה.

אבטחה
Circus בנוי בחלק העליון של ספריית ZeroMQ ומגיע ללא אבטחה כלל
פרוטוקולים. עם זאת, אתה יכול להפעיל מערכת Circus על שרת ולהגדיר מנהרת SSH כדי
לגשת אליו ממכונה אחרת.

חלק זה מסביר מה Circus עושה במערכת שלך כשאתה מפעיל אותה, ובסופו של דבר
מתאר כיצד להשתמש במנהרת SSH.

אתה יכול גם לקרוא http://www.zeromq.org/area:faq#toc5

TCP יציאות
כברירת מחדל, Circus פותח את יציאות ה-TCP הבאות במארח המקומי:

· 5555 - הנמל המשמש לשליטה בקרקס באמצעות circusctl

· 5556 -- היציאה המשמשת לערוץ המפרסם/מנויים.

· 5557 -- היציאה המשמשת לערוץ הסטטיסטיקה -- אם מופעלת.

· 8080 -- היציאה המשמשת את ממשק המשתמש האינטרנט -- אם מופעלת.

יציאות אלו מאפשרות לאפליקציות לקוח לקיים אינטראקציה עם מערכת Circus שלך, ובהתאם לאופן שבו
התשתית שלך מאורגנת, ייתכן שתרצה להגן על היציאות הללו באמצעות חומות אש or
להגדיר את Circus לרוץ באמצעות IPC יציאות.

הנה דוגמה להפעלת Circus באמצעות נקודות כניסה ל-IPC בלבד:

[קרקס]
check_delay = 5
נקודת קצה = ipc:///var/circus/endpoint
pubsub_endpoint = ipc:///var/circus/pubsub
stats_endpoint = ipc:///var/circus/stats

כאשר מוגדרים באמצעות IPC, יש להפעיל את הפקודות מאותה תיבה, אך אף אחד לא יכול
לגשת אליהם מבחוץ, בניגוד לשימוש ב-TCP. יש להפעיל את הפקודות גם כמשתמש ש
יש גישת כתיבה לנתיבי שקע ה-ipc. אתה יכול לשנות את הבעלים של נקודת סיום באמצעות
מה היא endpoint_owner אפשרות תצורה. זה מאפשר לך להפעיל את circusd כמשתמש השורש, אבל
לאפשר לתהליכים שאינם שורש לשלוח אליהם פקודות קרקס. שימו לב כי בעת השימוש endpoint_owner,
על מנת למנוע מתהליכים שאינם שורש להיות מסוגל להתחיל תהליכים שרירותיים כי
לרוץ עם הרשאות גדולות יותר, פקודת ההוספה תאכוף ש-Watchers חדשים חייבים לפעול בתור
מה היא endpoint_owner מִשׁתַמֵשׁ. הגדרות Watcher בקבצי התצורה המקומיים לא יהיו
מוגבל בדרך זו.

כמובן, אם תפעיל את ממשק המשתמש האינטרנטי, ה 8080 הנמל עדיין יהיה פתוח.

circushttpd
כאשר אתה מפעיל circushttpd באופן ידני, או כאשר אתה משתמש ב- httpd אפשרות בקובץ ini כמו
זֶה:

[קרקס]
check_delay = 5
נקודת קצה = ipc:///var/circus/endpoint
pubsub_endpoint = ipc:///var/circus/pubsub
stats_endpoint = ipc:///var/circus/stats
httpd = 1

אפליקציית האינטרנט תפעל ביציאה 8080 ויאפשר לכל אחד לגשת לדף האינטרנט
לנהל את קרקס דמון.

זה כולל יצירת צופים חדשים שיכולים להריץ כל פקודה במערכת שלך!

Do לֹא לעשות it בפומבי זמין

אם אתה רוצה להגן על הגישה לפאנל האינטרנט, אתה יכול להגיש אותו מאחורי Nginx או
Apache או כל שרת אינטרנט בעל יכולת פרוקסי, שיכול לדאוג לאבטחה.

משתמש ו קְבוּצָה הרשאות
כברירת מחדל, כל התהליכים שהתחילו עם Circus יפעלו עם אותו משתמש וקבוצה
as קרקס. בהתאם להרשאות שיש למשתמש במערכת, ייתכן שלא יהיו לך
גישה לכל התכונות ש-Circus מספק.

לדוגמה, תכונות סטטיסטיקה מסוימות בתהליכים פועלים דורשות הרשאות מורחבות.
בדרך כלל, אם מספרי השימוש במעבד אתה מקבל באמצעות סטטיסטיקות הפקודה הם N / A, זה אומר שלך
המשתמש לא יכול לגשת לקבצי הפרוצדורה. זה יהיה המקרה כברירת מחדל תחת Mac OS X.

אתה יכול לרוץ קרקס בתור root כדי לתקן את זה, ולהגדיר את uid ו gid ערכים עבור כל צופה
כדי לקבל את כל התכונות.

אבל היזהרו בריצה קרקס כמו שורש חושף אותך להסלמה פוטנציאלית של הרשאות
באגים. אמנם אנחנו עושים כמיטב יכולתנו כדי להימנע מכל באג, פועל כשורש ומתמודד עם באג זה
מבצע פעולות לא רצויות במערכת שלך עלול להיות מסוכן.

הדרך הטובה ביותר למנוע זאת היא לוודא שהמערכת שמפעילה את Circus היא מלאה
מבודד (כמו VM) or להפעיל את כל המערכת תחת משתמש מבוקר.

SSH מנהור
לקוחות יכולים להתחבר ל- a קרקס מופע על ידי יצירת מנהרת SSH. כדי לעשות זאת, העבר את
אפשרות שורת פקודה --שש אחריו user@address, שם המשתמש הוא המשתמש בשלט
שרת ו כתובת היא כתובת השרת כפי שנראתה על ידי הלקוח. פרוטוקול SSH יהיה
דורשים אישורים כדי להשלים את הכניסה.

If קרקס כפי שנראה על ידי שרת SSH אינו בכתובת ברירת המחדל של נקודת הקצה 5555
לאחר מכן ציין את קרקס כתובת באמצעות האפשרות --נקודת קצה

מְאוּבטָח התקנה דוגמה
הגדרת שרת Circus מאובטח יכולה להתבצע על ידי:

· הפעלת שרת SSH

· הפעלת Apache או Nginx על 80 יציאה, ועושה פרוקסי הפוך על 8080 נָמָל.

· חסימת ה 8080 נמל מגישה מבחוץ.

· הפעלת כל יציאות ZMQ Circusd באמצעות קבצי IPC במקום יציאות TCP, ומנהור של כל
שיחות דרך SSH.
[תמונה]

תרומה ל קרקס
קרקס הוקם במוזילה אבל המטרה שלו היא לא להישאר רק שם. אנחנו מנסים
לבנות כלי שימושי עבור אחרים וניתן להרחבה בקלות.

אנחנו באמת פתוחים לכל תרומה, בצורה של קוד, תיעוד, דיונים,
הצעת תכונה וכו'.

אתה יכול להתחיל נושא ברשימת התפוצה שלנו: http://tech.groups.yahoo.com/group/circus-dev/

או הוסף בעיה אצלנו באג גשש

קביעה שגיאות הקלדה ו שיפור מה היא תיעוד
זה בהחלט אפשרי שהעיניים שלך מדממות בזמן קריאת החצי האנגלית הזו
תיעוד חצי צרפתי, אל תהסס לתרום כל ניסוח מחדש / שיפור
הטופס בתיעוד. כנראה שאתה אפילו לא צריך להבין איך קרקס עובד
מתחת למכסה המנוע כדי לעשות זאת.

מוסיף חדש מאפיינים
תכונות חדשות מוערכות כמובן מאוד. אם יש לך את הצורך והזמן לכך
לעבוד על תכונות חדשות, הוספתם לסירקוס לא אמורה להיות כל כך מסובכת. ניסינו מאוד
קשה לקבל API נקי ומובן, מקווה שזה משרת את המטרה.

תצטרך להוסיף תיעוד ובדיקות לצד הקוד של התכונה החדשה.
אחרת לא נוכל לקבל את התיקון.

איך ל להגיש שֶׁלְךָ שינויים
אנחנו משתמשים ב-git בתור DVCS. הדרך הטובה ביותר להציע שינויים היא ליצור סניף שלך
צד (דרך סילון לתשלום -b שם הסניף) ובצע את השינויים שלך שם. ברגע שיש לך
משהו מוכן לפריים טיים, תוציא בקשת משיכה נגד הסניף הזה.

אנו עוקבים אחר המודל הזה כדי לאפשר צימוד נמוך בין התכונות שאתה
מציע. לדוגמה, אנו יכולים לקבל בקשת משיכה אחת תוך כדי דיון
לעוד אחד.

לפני שאתה מציע את השינויים שלך, בדוק שוב שהם לא שוברים שום דבר! אתה יכול
להשתמש רעב הפקודה כדי להבטיח זאת, היא תפעיל את testsuite תחת ה- different
גרסאות פיתון נתמכות.

בבקשה תשתמש : http://issue2pr.herokuapp.com/ להתייחס להתחייבות לקרקס קיים
בעיה, אם בכלל.

הימנעות למזג מתחייב
הימנעות מהתחייבויות מיזוג מאפשרת לקבל היסטוריה נקייה וקריאה. כדי לעשות זאת, במקום
עושה "git pull" ונותן ל-git לטפל במיזוגים עבורך, באמצעות git pull --rebase will
לשים את השינויים שלך אחרי השינויים שמתחייבים בסניף, או כאשר עובדים עליהם
אדון.

כלומר, עבורנו מפתחי הליבה, לא ניתן יותר להשתמש ב-github הירוק השימושי
כפתור על בקשות משיכה אם מפתחים לא ביססו מחדש את העבודה שלהם בעצמם או אם נחכה
זמן רב מדי בין הבקשה למיזוג בפועל. במקום זאת, הזרימה נראית כך:

git remote הוסף שם מאגר כתובת אתר
שם אחזור git
git checkout feature-branch
git rebase master

# בדוק שהכל עובד כמו שצריך ואז התמזג במאסטר
מאסטר לקופות
git merge feature-branch

בדיון
אם אתה מוצא את עצמך זקוק לעזרה כלשהי בזמן שאתה מסתכל על הקוד של קרקס, אתה יכול ללכת
ומצא אותנו ב-irc בכתובת #אוהל קרקס on irc.freenode.org (או אם אין לך IRC
לקוח, להשתמש מה היא אינטרנט צ'אט)

אתה יכול גם לפתוח שרשור ברשימת התפוצה שלנו -
http://tech.groups.yahoo.com/group/circus-dev

לעתים קרובות שאל שאלות
להלן רשימה של שאלות נפוצות על קרקס:

איך עושה קרקס לערום לְהַשְׁווֹת ל a קלאסי לַעֲרוֹם?
בערימת WSGI קלאסית, יש לך שרת כמו Gunicorn שמשרת על פורט או an
שקע יוניקס ונפרס בדרך כלל מאחורי שרת אינטרנט כמו Nginx: [תמונה]

לקוחות מתקשרים ל-Nginx, אשר מפנה את כל השיחות ל-Gunicorn.

אם אתה רוצה לוודא שתהליך Gunicorn יישאר פעיל, עליך להשתמש ב-a
תוכנית כמו Supervisord או upstart.

גוניקורן בתורו צופה בתהליכים שלו ("עובדים").

במילים אחרות אתה משתמש בשתי רמות של ניהול תהליכים. כזה שאתה מנהל ו
control (סופרvisord), ואחד שני שאתה צריך לנהל בממשק משתמש אחר, עם א
פילוסופיה שונה ופחות שליטה על מה שקורה (זו של שרת wsgi)

זה נכון עבור Gunicorn ורוב שרתי WSGI מרובי תהליכים בחוץ שאני מכיר.
uWsgi קצת שונה מכיוון שהוא מציע שפע של אפשרויות.

אבל אם אתה רוצה להוסיף שרת Redis לערימה שלך, אתה יצטרך בסופו של דבר בניהול שלך
מחסנית תהליכים בשני מקומות שונים.

הגישה של קרקס בנושא זה היא לנהל תהליכים ו שקעים.

ערימת קרקס יכולה להיראות כך: [תמונה]

אז, כמו גוניקורן, סירקוס מסוגל לאגד שקע שיישלח על ידי Nginx. קרקס
אל תתמודד עם הבקשות אלא פשוט קושר את השקע. אז זה תלוי בעובד אינטרנט
תהליך קבלת חיבורים על השקע ולבצע את העבודה.

הוא מספק תכונות שוות ל-Supervisord, אך גם יאפשר לך לנהל את כולם
תהליכים באותה רמה, בין אם הם עובדי אינטרנט או Redis או כל דבר אחר. הוספת א
עובד אינטרנט חדש נעשה בדיוק כמו הוספת תהליך Redis חדש.

ספסלים
עשינו כמה ספסלים כדי להשוות את Circus & Chaussette עם Gunicorn. לסיכום, קרקס הוא
לא מוסיף תקורה כלשהי ואתה יכול לאסוף הרבה קצה קצה עבור עובדי האינטרנט שלך.

ראה:

· 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 דלילה למדי. חוסר תפוקה זה יכול
להקשות על פתרון בעיות כאשר נראה שתהליכים מתקשים להתחיל.

כדי להגביר את הרישום קרקס מספק, נסה להגדיל את רמת היומן. לראות את ה
רמות יומן זמינות פשוט השתמש ב- - עזרה דגל.

$ circus --log-level debug test.ini

מילת אזהרה אחת. אם תהליך מתנופף ורמת יומן ניפוי הבאגים מופעלת, אתה
יראה הודעות עבור כל ניסיון התחלה. זה עשוי להיות מועיל להגדיר את האפליקציה כלומר
מתנופפת להשתמש א עיכוב_חימום להאט את ההודעות לקצב ניתן לניהול.

[watcher:webapp]
cmd = python -m myapp.wsgi
delay_warmup = 5

כברירת מחדל, stdout ו סטדרר נלכדים על ידי ה קרקס תהליך. אם אתה בודק את שלך
config וברצונך לראות את הפלט בהתאם לפלט circusd, אתה יכול להגדיר את
צופה להשתמש ב StdoutStream מעמד.

[watcher:webapp]
cmd = python -m myapp.wsgi
stdout_stream.class = StdoutStream
stderr_stream.class = StdoutStream

אם היישום שלך מייצר עקבות או שגיאה כאשר הוא מנסה להפעיל אותך
אמור להיות מסוגל לראות את זה בפלט.

changelog היסטוריה
0.12.1 - 2015-08-05
· תקן שגיאה בעת הפעלה מחדש של צופה עם זרם פלט - #913

· שינויים קלים במסמך

0.12 - 2015-06-02
מהדורה זו מביאה את התמיכה של Python 3.4, Tornado 4 ו-Windows, בין כמה מרתקים
תכונות ותיקונים.

התמיכה של Windows עדיין ניסיונית ואינה מטפלת בזרמים.

שינויים עיקריים:

· תאימות עם Python 3.4 - #768

· תמיכה נסיונית ב-Windows - #788

· תאימות עם Tornado 4 - #872

· אריזת דביאן מחודשת - #896 - #903

· הוסף תמיכה בליבת תהליך Papa - #850

· הוסף התאמת גלוב וגרסאות רגילות להפעלה, עצירה והפעלה מחדש של צופים - #829 -
#902

שינויים נוספים:

· אופטימיזציה של הכיבוי - #784 - #842

· הוסף אפשרות לציין גרסת virtualenv עבור הצופים - #805

· הוסף אפשרות --nostop לפקודה rmwatcher - #777

· הוסף התקשרות חוזרת ל-Arbiter.start - #840

· תקן שומרי טעינה מחדש באותיות גדולות - #823

· הסר שקע דולף בדמון סטטיסטיקה - #843

· תקן שידור ריבוי ב-SunOS - #876

· סגור זרמי פלט בעת עצירת צופה - #885

· תקן שליחת אותות לנכדים עם --רקורסיבי - #888

0.11.1 - 2014-05-22
· תוקן רגרסיה ששברה את קרקס ב-2.6 - #782

0.11 - 2014-05-21
מהדורה זו אינה מציגה הרבה תכונות, ומתמקדת בהפיכת Circus ליותר
חזק ויציב.

שינויים/תיקונים עיקריים:

· ודא שאיננו יכולים לבצע שתי פקודות סותרות על הבורר בו זמנית.

· יש לנו 2 מחלקות זרמים חדשות: TimedRotatingFileStream, WatchedFileStream

· יש לנו הוק אחד חדש: after_spawn hook

· CircusPlugin קל יותר לשימוש

· fix autostart=צופים כוזבים במהלך ההתחלה (רגרסיה)

שינויים נוספים:

· ניתן לנתב הודעות קרקס ל-syslog עכשיו - #748

· אפשרות endpoint_owner נוספה כדי שנוכל להגדיר לאיזה משתמש יש קבצי שקע ipc שנוצרו על ידי
קרקס.

· הפעלת תמיכה ב-Windows (רק circusctl לעת עתה)

· תיקן הרבה דליפות בבדיקות

· אפשר משתני סביבה תלויי רישיות

· תוסף המשאבים מקבל כעת ערכי זיכרון מוחלטים - #609

· הוסף תמיכה לפקודה add עבור אפשרות 'סינגלטון' - #767

· לאפשר שליחת אותות שרירותיים לפרוייקטים של ילדים באמצעות שומר משאבים - #756

· אפשר תצורת INI/JSON/YAML לרישום

· ודא שאנו תואמים ל-psutil 2.x ו 3.x

· הוסיפו עוד מדדים לספק סטטיסטיקה - #698

· גילוי ריבוי שידורים קבוע - #731

· הפוך את ההתחלה, הפעל מחדש וטען מחדש לאחידות יותר - #673

· אתחול נכון של כל קבוצות השימוש - #635

· שיפור יציבות הבדיקות

· עוד הרבה הרבה דברים....

0.10 - 2013-11-04
שינויים עיקריים:

· כעת תואם Python 3.2 ו-3.3 - #586

· העביר את הליבה לדגם אסינכרון מלא - #569

· תיעוד משופר - #622

שינויים נוספים:

· נוספו אות עצור וילדי עצירה - #594

· ודא שהתוסף Watchdog סוגר את השקעים - #588

· עבר למנתח JSON ZMQ

· IN לא נתמך בכל הפלטפורמות - #573

· אפשר החלפות סביבה גלובליות בכל סעיף תצורה - #560

· אפשר מקפים בשמות קטעים - #546

· כעת משתנים מורחבים בכל מקום בתצורה - #554

· הוסיף את הפלאגין CommandReloader

· נוספו ווים לפני_אות & לאחר_אות

· אפשר לפלאגין מתנופף לנסות שוב ללא הגבלת זמן

· אל תפעיל מחדש תהליכים כשהצופה עוצר - #529 - #536

· הוסף מזהה ייחודי לכל הודעת לקוח - #517

· מזהי עובדים הם כעת "חריצים" -

· תיקן את התנהגות הכיבוי החיננית - #515

· ודא שנוכל להוסיף צופים גם אם הבורר לא מופעל - #503

· ודא ודא שנופץ תהליך שפג תוקפו - #510

· ודא שהפקודה הגדר יכולה להגדיר מספר ווים

· תמיכה נכונה בשקעי ipv6 - #507

· אפשר אפשרויות מותאמות אישית עבור stdout_stream ו-stderr_stream - #495

· הוספת time_format עבור FileStream - #493

· נוספה אפשרות חדשה לתצורת socket כדי לאגד לממשק ספציפי לפי שם

0.9.3 - 2013-09-04
· ודא שנוכל להוסיף צופים גם אם הבורר לא הופעל

· ודא שאנו מקפיצים תהליך שפג תוקפו

· ודא שהפקודה הגדר יכולה להגדיר ווים אחד או כמה

· תמיכה נכונה בשקעי ipv6 ושיפורים של CircusSockets

· תן ערך ברירת מחדל לנתיב כדי למנוע UnboundLocalError

· נוסף בדיקה לקיום multicast_endpoint באתחול Controller

· לא ממירים יותר כל מחרוזת ספרות ל-ints

· הוסף מבחנים

· אין צורך במקרים מיוחדים בעת המרת אפשרויות stdout_stream

· קבל גם את umask כטיעון לעקביות

· אפשר אפשרויות מותאמות אישית עבור stdout_stream ו-stderr_stream.

· הוסף אפשרות חדשה לתצורת socket כדי לאגד לממשק ספציפי לפי שם

· הוסף time_format עבור FileStream + בדיקות

· עדכון circus.upstart

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]

· תוקן חריג נסתר כאשר סירקוס-web אינו מותקן - #424

· לוודא ש-incr/decr פקודות באמת לנו את האפשרות nb - #421

· תקן חבילות אתר של watcher virtualenv שאינן ב-PYTHONPATH

· ודא שלא ננסה להסיר יותר תהליכים מ-0 - #429

· מעודכן bootstrap.py - #436

· מפריד רב פלטפורמות קבוע ב-pythonpath virtualenv watcher

· פונקציית סגירת שקע מחודשת

· ודא שקטעי Env מיושמים על כל הצופים - #437

· הוסיף את הפקודה reloadconfig

· הוסיפו circus.green והוסרו gevent מהליבה - #441, #452

· השתקת נקודות זיוף ואזהרות במבחנים - #438

· ניתן להשתמש ב$(circus.env.*) עבור כל האפשרויות בתצורה כעת

· הוסיף הוק before_spawn

· תקן את הנתיב של circusd בקובץ שירות systemd - #450

· לוודא שנוכל לשנות ווים ולהגדיר זרמים באמצעות CLI - #455

· מסמך משופר

· הוסיף סטטיסטיקת spawn_count ב-watcher

· הוסיפו פרמטרים min_cpu ו-min_mem בתוסף ResourceWatcher

· הוסיף את פרטי ה-FQDN לבורר.

0.8.1 - 2013-05-28
· circusd-stats נחנק משקעי יוניקס - #415

· circusd-stats & circushttpd תהליכי ילד stdout/stderr נותרים כעת פתוחים כברירת מחדל.
Python <= 2.7.5 יחנק במודול הרישום במקרה ש-2/3 ה-fds ייסגרו - #415

· כעת מפנה אל /dev/null בתהליך הילד במקום סגירה. #417

0.8 - 2013-05-24
· שולבו מטפלי יומנים בלולאת zmq io.

· הפוך את הניתוב מחדש לניתן לאתחל ובעקבות כך חזק יותר.

· משתמש ב-zmq.green.eventloop כאשר gevent מזוהה

· נוספה תמיכה במשתנה הסביבה CIRCUSCTL_ENDPOINT ל-circusctl - #396

· util: תקן באג בפונקציית to_uid - #397

· הסר מטפל בשגיאת ioloop - #398.

· כיסוי מבחן משופר

· הוציא משימוש את אפשרות ה'שירות' עבור הפלאגין ResourceWatcher - #404

· הוסר שימוש psutil.error

· נוסף תגלית UDP בקרקס - #407

· מאפשר כעת גלובס ברמות ספריות שרירותיות - #388

· הוספה את אפשרות התצורה 'statd' - #408

· הוסף אפשרות pidfile, logooutput ו-loglevel לקובץ התצורה של הקרקס - #379

· נוסף מדריך במסמכים.

· ודא שאנו ממזגים את כל הסעיפים בעת השימוש ב- include - #414

· הוסיפו אפשרויות pipe_stdout, pipe_stderr, close_child_stderr ו-close_child_stdout ל-
שיעור תהליכים

· הוסיפו אפשרויות close_child_stderr & close_child_stdout לצופה

0.7.1 - 2013-05-02
· תוקן את אפשרות ה-respawn - #382

· ודא שאנו משתמשים ב-int עבור פסק הזמן - #380

· הצג גם את שקעי יוניקס - #381

· ודא שהוא עובד עם ה-pyzmq העדכני ביותר

· הציג תחביר שני עבור סימון fd

0.7 - 2013-04-08
· תקן דוגמה של get_arbiter כדי להשתמש ב-dict לטיעון הצופים. #304

· הוסף כמה תיעוד לפתרון בעיות #323

· הוסף תמיכה בבניית פיתון

· הסירו את ה-givent ואת מנותבי השרשור. משתמש כעת ב-ioloop - תיקונים מס' 346.
מתייחס #340

· circus.web הוא כעת פרויקט משלו

· הסיר את תיקון pyzmq

· אפשר לצופה להיות מוגדר אך לא מופעל #283

· הוסף אפשרות לטעינת מדריך אתר virtualenv

· הוסיפו צופים לפי דרישה

· הוסיף מסמך על nginx+websockets #371

· מנתח נכון את רשימת האפשרויות של כל פקודה #369

· טיפול באירועי circusd-stats קבוע מס' 372

· תיקן את בעיית ההצפה ב-Circus-top #378

· עוד הרבה דברים...

0.6 - 2012-12-18
· שם פרוטוקולי תיקון עבור שקעים - #248

· אין לבצע קנה מידה אוטומטי של גרפים. #240

· circusctl: הוסף לעזרה לפי פקודה, מ-docstrings #217

· נוספו ווי עובדים

· נוספה חבילת דביאן - #227

· נוסף Redis, HTTP Observer, נתונים סטטיסטיים מלאים ותוספי משאבים

· כעת לתהליכים יכולים להיות כותרות

· השלמה אוטומטית נוספה

· נוסף תהליך/גיל צופה ב-webui

· נוספה תמיכה במנהרת SSH

· כעת באמצעות pyzmq.green

· נוסף סקריפט upstart & לכה doc

· נוספו משתני סביבה וקטעים

· נוספה תמיכה בשקעי יוניקס

· הוסיף את respawn אפשרות להחזיק צופים בריצה אחת

· כעת משתמשים ברעלן בבדיקות

· אפשר החלפת שקעים ב-args

· נושא חדש למסמך

· אפשרויות סיבוב חדשות לזרמים: max_bytes/backup_count

0.5.2 - 2012-07-26
· כעת מתקן את מודול השרשור מה-stdlib כדי למנוע כמה באגים של Python - #203

· מסך עזרה circusctl נראה טוב יותר

· משתמש ב-pustil get_nice() כאשר זמין (נחמד הוצא משימוש) - #208

· הוספת תמיכת max_age - #221

· התקשר רק להאזנה() בשקעי SOCK_STREAM או SOCK_SEQPACKET

· ודא שהבקר מרוקן את רשימת התוספים ב-update_watchers() - #220

· הוסיף --log-level ו --log-output ל-circushttpd

· לתקן את הרג התהליך באמצעות ממשק המשתמש באינטרנט - #219

· כעת circus תואם zc.buildout לתסריטים.

· נקה את ה-websocket כאשר הלקוח מתנתק - #225

· תיקן את ערך ברירת המחדל עבור נקודת הקצה - #199

· מפוצל circushttpd במודולים לוגיים

0.5.1 - 2012-07-11
· תוקן מספר שגיאות הקלדה בתיעוד

· נוספה אפשרות ניפוי באגים

· ארוז את web-requirements.txt כראוי

· הוסף קוד שגיאה בהודעות - תיקונים #111

0.5 - 2012-07-06
· הוספת תמיכת שקעים

· הוסיף פקודת listsocket

· גם לשקעים יש נתונים סטטיסטיים!

· תיקנו הרבה באגים קטנים

· הסיר את ה-wid - כעת משתמש ב-Pid בכל מקום

· בדיקות מהירות יותר

· שינה את תחביר המשתנים

· השתמש ב-ioloop של pyzmq במקומות נוספים

· משתמש כעת ב-iowait עבור כל הקריאות select()

· לפקודות incr/decr יש כעת פרמטר nbprocess

· הוסף אפשרות reproduce_env לצופים

· הוסף סטטוס לא קיים חדש לתהליכים

· הוסיף את הגלובלי httpd אפשרות להפעיל circushttpd כצופה

0.4 - 2012-06-12
· נוספה מערכת פלאגין

· נוספה אפשרות "סינגלטון" לצופים

· הבהוב מסך עליון קרקס קבוע

· הסירו שרשורים מ-circus.stats לטובת התקשרויות תקופתיות של zmq

· שיפר את התיעוד

· ללקוח Circus יש כעת ממשק API של send_message

· התכונה המתנופפת היא כעת תוסף

· לכל כלי שורת פקודה יש ​​אפשרות --version

· נוסף תוסף statsd (שולח את האירועים מקרקס ל-statsd)

· ממשק המשתמש של האינטרנט משתמש כעת ב-websockets (דרך socketio) כדי לקבל את הנתונים הסטטיסטיים

· ממשק המשתמש של האינטרנט משתמש כעת בהפעלות עבור "הודעות הבזק" בממשק האינטרנט

0.3.4 - 2012-05-30
· תוקן מצב מירוץ שמנע מהבקר לקצור בצורה נקייה תהליכים שהסתיימו.

· כעת ניתן לשלוט ב-check_flapping בתצורה. ומופעל/מושבת
לכל צופה.

0.3.3 - 2012-05-29
· תיקן את הרגרסיה בטיפול ב-uid

0.3.2 - 2012-05-24
· מאפשר מאפיין args אופציונלי לפקודה add_watcher.

· הוסיף circushttpd, circus-top ו-circusd-stats

· מאפשר ל-Arbiter.add_watcher() להגדיר את כל האפשרויות Watcher

· לוודא שהמפנים מחדש נוצרו מחדש בהפעלה מחדש

0.3.1 - 2012-04-18
· תיקון: ודא שברירות המחדל של הצופה אינן עוקפות

· הוסיף כיתת StdoutStream.

0.3 - 2012-04-18
· הוסיף את תכונת הסטרימינג

· מציג כעת כיסוי במסמך הספינקס

· תיקן את הדרך שבה התהליכים מומתים (לא עוד SIGQUIT)

· התצורה נלקחה בחשבון

· תמיכה ב-setproctitle

0.2 - 2012-04-04
· הסיר את לְהַצִיג שֵׁם. הוחלף על ידי צוֹפֶה.

· נוספה תמיכה בתהליך ההגדרה rlimit.

· נוספה תמיכה עבור include dirs בקובץ התצורה.

· תוקן כמה מתארי קבצים דולפים.

· תוקן מזבלה של ליבה בנפנוף

· שיפורי מסמך

· ודא שגיאות circusd כראוי כאשר circusd אחר פועל על אותו שקע.

· get_arbiter מקבל כעת מספר צופים.

· תיקן את cmd vs args vs executable בתהליך init.

· קבוע - התחל ב-circusctl להוסיף

0.1 - 2012-03-20
· שיחרור ראשוני

איש דפים
קרקס איש עמוד
תַקצִיר
circusd [אפשרויות] [config]

תיאור
circusd הוא התהליך העיקרי של ארכיטקטורת הקרקס. זה דואג להפעיל את כל
תהליכים. כל תהליך המנוהל על ידי קרקס הוא תהליך ילד של קרקס.

טיעונים
config קובץ תצורה

אפשרויות
-ח, - עזרה
הצג את הודעת העזרה וצא

--רמת יומן רמה
ציין את רמת היומן. רמה יכול להיות מידע, באגים, קריטי, אזהרה or שגיאה.

--פלט יומן LOGOUTPUT
המיקום בו ייכתבו היומנים. התנהגות ברירת המחדל היא לכתוב אל
stdout (תוכל לאלץ אותו על ידי העברת '-' לאפשרות זו). לוקח שם קובץ
אחרת.

--logger-config LOGGERCONFIG
המיקום שבו קובץ Python לוגר תצורת INI, JSON או YAML
יכול להמצא. ניתן להשתמש בזה כדי לעקוף את תצורת רישום ברירת המחדל עבור
הבורר.

--דימון
התחל קרקס ברקע.

--pidfile PIDFILE
המיקום של קובץ ה-PID.

--גִרְסָה
מציג את גרסת הקרקס ויציאות.

לִרְאוֹת גם
קרקס (1), circusctl (1), סטטיסטיקות קרקס (1), קרקס-פלאגין (1), טופ קרקס (1).

התיעוד המלא זמין בכתובת http://circus.readthedocs.org

circusctl איש עמוד
תַקצִיר
הפקודה circusctl [אפשרויות] [args]

תיאור
circusctl הוא הקצה הקדמי לשליטה בדמון הקרקס. זה נועד לעזור ל
המנהל שולט בתפקוד ה-Circud קרקס דמון.

פקודות
להוסיף הוסף צופה

decr הקטנת מספר התהליכים בצופה

dstats קבלו סטטיסטיקות של קרקס

לקבל קבל את הערך של אפשרויות צופה ספציפיות

אופציות גלובליות
קבל את אפשרויות הבורר

תוספת הגדל את מספר התהליכים בצופה

פִּיתוֹן
צור מעטפת לתהליך הקרקס

רשימה קבל רשימה של צופים או תהליכים בצופה

להקשיב הירשם לאירוע צופה

שקעי רשימות
קבלו את רשימת השקעים

מספר תהליכים
קבל את מספר התהליכים

שומרי מספר
קבל את מספר הצופים

אפשרויות
קבל את הערך של כל האפשרויות עבור צופה

להפסיק עזוב את הבורר מיד

לטעון מחדש טען מחדש את הבורר או צופה

טען מחדש את התצורה
טען מחדש את קובץ התצורה

הפעלה מחדש
הפעל מחדש את הבורר או צופה

rm הסר צופה

סט הגדר אפשרות צופה

אוֹת שלח אות

התחלה התחל את הבורר או צופה

סטטיסטיקות קבל מידע על תהליך

מצב קבל סטטוס של צופה או כל הצופים

להפסיק שומרי עצור

אפשרויות
--נקודת קצה סיום
נקודת קצה חיבור

-ח, - עזרה
הצג את הודעת העזרה וצא

--json פלט ל-JSON

--לְיַפּוֹת
לייפות פלט

--שש SSH
שרת SSH בפורמט user@host:port

--ssh_keyfile SSH_KEYFILE
נתיב לקובץ המפתח כדי לאשר את המשתמש

--פסק זמן פסק זמן
פסק זמן לחיבור

--גִרְסָה
מציג את גרסת הקרקס ויציאות.

לִרְאוֹת גם
קרקס (1), קרקס (1), סטטיסטיקות קרקס (1), קרקס-פלאגין (1), טופ קרקס (1).

התיעוד המלא זמין בכתובת http://circus.readthedocs.org

קרקס-פלאגין איש עמוד
תַקצִיר
circus-plugin [אפשרויות] [plugin]

תיאור
circus-plugin מאפשר להפעיל תוסף מדמון Circus פועל.

טיעונים
חיבור שם מלא של מחלקת הפלאגין.

אפשרויות
--נקודת קצה סיום
נקודת קצה חיבור.

--pubsub PUBSUB
שקע הפאב/סאב circusd ZeroMQ להתחבר אליו.

--config התצורה
קובץ התצורה של הפלאגין.

--עיכוב בדיקה CHECK_DELAY
בדוק עיכוב.

--רמת יומן רמה
ציין את רמת היומן. רמה יכול להיות מידע, באגים, קריטי, אזהרה or שגיאה.

--פלט יומן LOGOUTPUT
המיקום בו ייכתבו היומנים. התנהגות ברירת המחדל היא לכתוב אל
stdout (תוכל לאלץ אותו על ידי העברת '-' לאפשרות זו). לוקח שם קובץ
אחרת.

--שש SSH
שרת SSH בפורמט user@host:port.

-ח, - עזרה
הצג את הודעת העזרה וצא.

--גִרְסָה
מציג את גרסת הקרקס ויציאות.

לִרְאוֹת גם
קרקס (1), קרקס (1), circusctl (1), סטטיסטיקות קרקס (1), טופ קרקס (1).

התיעוד המלא זמין בכתובת http://circus.readthedocs.org

טופ קרקס איש עמוד
תַקצִיר
ראש קרקס [אפשרויות]

תיאור
קרקס-טופ הוא א חלק עליוןפקודה -like להצגת דמון הקרקס והתהליכים המנוהלים על ידי
קרקס.

אפשרויות
--נקודת קצה סיום
נקודת קצה חיבור.

--שש SSH
שרת SSH בפורמט user@host:port.

--זמן קצוב לתהליך PROCESS_TIMEOUT
לאחר עיכוב זה של חוסר פעילות, תהליך יוסר.

-ח, - עזרה
הצג את הודעת העזרה וצא.

--גִרְסָה
מציג את גרסת הקרקס ויציאות.

לִרְאוֹת גם
קרקס (1), circusctl (1), קרקס (1), סטטיסטיקות קרקס (1), קרקס-פלאגין (1).

התיעוד המלא זמין בכתובת http://circus.readthedocs.org

סטטיסטיקות קרקס איש עמוד
תַקצִיר
circusd-stats [אפשרויות]

תיאור
circusd-stats מפעיל את אגרגטור הנתונים הסטטיסטיים עבור Circus.

אפשרויות
--נקודת קצה סיום
נקודת קצה חיבור.

--pubsub PUBSUB
שקע הפאב/סאב circusd ZeroMQ להתחבר אליו.

--statspoint STATSPOINT
שקע הפאב/משנה ZeroMQ לשלוח אליו נתונים.

--רמת יומן רמה
ציין את רמת היומן. רמה יכול להיות מידע, באגים, קריטי, אזהרה or שגיאה.

--פלט יומן LOGOUTPUT
המיקום בו ייכתבו היומנים. התנהגות ברירת המחדל היא לכתוב אל
stdout (תוכל לאלץ אותו על ידי העברת '-' לאפשרות זו). לוקח שם קובץ
אחרת.

--שש SSH
שרת SSH בפורמט user@host:port.

-ח, - עזרה
הצג את הודעת העזרה וצא.

--גִרְסָה
מציג את גרסת הקרקס ויציאות.

לִרְאוֹת גם
קרקס (1), קרקס (1), circusctl (1), קרקס-פלאגין (1), טופ קרקס (1).

התיעוד המלא זמין בכתובת http://circus.readthedocs.org

מילון מונחים: ספציפי לקרקס מונחים
פוסק
השמיים פוסק אחראי על ניהול כל הצופים בקרקס, להבטיח
כל התהליכים פועלים כהלכה.

בקר
A בקר מכיל את מכלול הפעולות שניתן לבצע על הבורר.

מתנפנף
השמיים מתנפנף זיהוי נרשם לאירועים ומזהה מתי תהליכים מסוימים
כל הזמן מחדש.

פאב/תת
לקרקס יש א pubsub שמקבל אירועים מהצופים ושולח אותם אליהם
כל המנויים.

מרחוק בקר
השמיים מרחוק בקר מאפשר לך לתקשר עם הבקר באמצעות ZMQ ל
לשלוט בקרקס.

צוֹפֶה, צופים
A צוֹפֶה היא התוכנית שאתה אומר לקרקס להפעיל. מופע יחיד של Circus יכול לפעול
צופה אחד או יותר.

עוֹבֵד, עובדים, תַהֲלִיך, תהליכים
A תהליך הוא מופע עצמאי של תהליך מערכת הפעלה של התוכנית שלך. צופה יחיד
יכול להפעיל תהליך אחד או יותר. אנחנו קוראים להם גם עובדים.

זכויות יוצרים
Circus הוקם על ידי Tarek Ziade והוא מורשה תחת APLv2

בנואה צ'סנו היה תורם מוקדם ועשה דברים רבים, כמו רוב הפעולות
circus.commands עבודה.

רישיון
זכויות יוצרים 2012 - קרן מוזילה
זכויות יוצרים 2012 - בנואה צ'סנו

מורשה ברישיון אפאצ'י, גרסה 2.0 ("הרישיון");
אינך רשאי להשתמש בקובץ זה אלא רק בהתאם לרישיון.
אתה יכול להשיג עותק של הרישיון בכתובת

http://www.apache.org/licenses/LICENSE-2.0

אלא אם כן נדרש על פי החוק החל או מוסכם בכתב, תוכנה
המופץ תחת הרישיון מופץ על בסיס "כפי שהוא",
ללא אחריות או תנאים מכל סוג שהוא, מפורש או משתמע.
עיין ברישיון לקבלת השפה הספציפית המסדירה את ההרשאות
מגבלות תחת הרישיון.

תורם
ראה את הרשימה המלאה ב https://github.com/circus-tent/circus/blob/master/CONTRIBUTORS.txt

השתמש בקרקס באינטרנט באמצעות שירותי onworks.net