זהו קרקס הפקודות שניתן להפעיל בספק האירוח החינמי של OnWorks באמצעות אחת מתחנות העבודה המקוונות החינמיות שלנו, כגון Ubuntu Online, Fedora Online, אמולטור מקוון של Windows או אמולטור מקוון של MAC OS.
תָכְנִית:
שֵׁם
קרקס - תיעוד קרקס [תמונה]
Circus היא תוכנת Python בה ניתן להשתמש כדי לנטר ולשלוט בתהליכים ו-Sockets.
ניתן להפעיל את Circus דרך ממשק שורת פקודה, ממשק אינטרנט או באופן תכנותי.
דרך ה-API של פייתון שלה.
כדי להתקין אותו ולנסות את התכונות שלו, עיינו בדוגמאות, או קראו את שאר הדף הזה.
להיכרות מהירה.
רץ A קרקס דיימון
Circus מספק קריאה לסקריפט שורת פקודה קרקסד שניתן להשתמש בהם לניהול תהליכים
מאורגן בצופה אחד או יותר.
כלי שורת הפקודה של Circus ניתן להגדרה באמצעות קובץ תצורה בסגנון ini.
הנה דוגמה מינימלית מאוד:
[צופה:תוכנית]
cmd = python myprogram.py
מספר תהליכים = 5
[צופה:תוכנית אחרת]
cmd = תוכנית_נוספת
מספר תהליכים = 2
לאחר מכן הקובץ מועבר אל קרקסד:
$ circusd example.ini
מלבד תהליכים, Circus יכול גם לאגד שקעים. מכיוון שכל תהליך המנוהל על ידי Circus הוא
צאצא של הדמון הראשי של סירקוס, כלומר כל תוכנית שנשלטת על ידי סירקוס יכולה
להשתמש בשקעים האלה.
הפעלת שקע היא פשוטה כמו הוספת שקע סעיף בקובץ ההגדרות:
[שקע:השקע שלי]
מארח = מארח מקומי
יציאה = 8080
למידע נוסף על שקעים, ראו שקעים.
כדי להבין מדוע זוהי תכונה מעולה, קראו את whycircussockets.
שליטה קרקס
Circus מספק שני כלי שורת פקודה לניהול הדמון הפועל שלך:
· סירקוסקטל, קונסולת ניהול שבה ניתן להשתמש כדי לבצע פעולות כגון הוספה או
הסרת עובדים
· קרקס-טופ, קונסולה דמוית עליון שבה ניתן להשתמש כדי להציג את ניצול הזיכרון והמעבד של המחשב שלך
ריצה בקרקס.
למידע נוסף על אלה, ראה cli
סירקוס מציע גם לוח מחוונים אינטרנטי שיכול להתחבר לדמון סירקוס פעיל ולאפשר לך
לנטר ולקיים אינטראקציה איתו.
למידע נוסף על תכונה זו, ראו 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
$ פיפ להתקין קרקס
או הורד את ה ארכיון on PyPI, לחלץ ולהתקין אותו ידנית באמצעות:
$ python setup.py install
אם אתם רוצים לנסות את סירקוס, ראו את הדוגמאות.
אם אתם משתמשים בדביאן או בכל הפצה אחרת המבוססת על דביאן, תוכלו גם להשתמש ב-ppa כדי...
התקינו את קרקס, זה ב https://launchpad.net/~roman-imankulov/+archive/circus
zc.buildout
אנו מספקים zc.buildout תצורה, אתה יכול להשתמש בה פשוט על ידי הפעלת bootstrap
סקריפט, לאחר מכן קריאה ל-buildout:
$ python bootstrap.py
$ bin/buildout
עוד on דרישות
קרקס עובד עם:
· פייתון 2.6, 2.7, 3.2 או 3.3
·
אפס >= 2.1.10
· גרסת zeromq הנתמכת נקבעת בסופו של דבר על ידי הגרסה של
פיזמק מותקן על ידי פיפ במהלך התקנת סירקוס.
· הגרסה הנוכחית שלהם תומכת בגרסאות ZeroMQ 2.x (מוגבלות), 3.x ו-4.x.
· הערותאם אתם משתמשים ב-PyPy במקום ב-CPython, הקפידו לקרוא את ההוראות שלהם.
מסמכי ההתקנה מכיוון שתמיכה בגרסת ZeroMQ אינה זהה ב-PyPy.
בעת התקנת Circus, הגרסאות העדכניות ביותר של תלויות Python יישלפו
בשבילך.
ניתן גם להתקין אותם ידנית באמצעות קובץ pip-requirements.txt שאנו מספקים:
$ pip install -r pip-requirements.txt
אם ברצונך להפעיל את קונסולת האינטרנט, תצטרך להתקין קרקס-אינטרנט:
$ pip install circus-web
הדרכה
צעד אחר צעד הדרכה
השמיים דוגמאות בספרייה במאגר Circus יש דוגמאות רבות שיעזרו לכם
התחיל, אבל הנה מדריך מלא שנותן לך סקירה כללית של התכונות.
אנחנו הולכים לפקח על יישום WSGI.
הַתקָנָה
Circus נבדק על Mac OS X ו-Linux עם הגרסאות העדכניות ביותר של Python 2.6, 2.7, 3.2 ו-3.3.
להפעיל קרקס מלא, תצטרכו גם ליבזמק, חביב & וירטואלי.
במערכות מבוססות דביאן:
$ sudo apt-get install libzmq-dev libevent-dev python-dev python-virtualenv
צור וירטואל-סביבה והתקן קרקס, קרקס-אינטרנט ו גֶרֶב בּוֹ
$ virtualenv /tmp/circus
$ cd /tmp/circus
התקנת $ bin/pip בקרקס
התקנת bin/pip של circus-web
התקנת סוללת $ bin/pip
לאחר שתסיים את זה, תמצא שפע של פקודות בקובץ bin המקומי.
נוֹהָג
גֶרֶב מגיע עם אפליקציית Hello world המוגדרת כברירת מחדל, נסה להפעיל אותה:
$ bin/chaussette
אתה אמור להיות מסוגל לבקר http://localhost: 8080 ולראות שלום עוֹלָם.
עצור את Chaussette והוסף קובץ circus.ini לתיקייה המכילה:
[קרקס]
סטטיסטיקה = 1
httpd = 1
[צופה:אפליקציית אינטרנט]
cmd = bin/chaussette --fd $(circus.sockets.web)
מספר תהליכים = 3
use_sockets = נכון
[socket:web]
מארח = 127.0.0.1
יציאה = 9999
קובץ התצורה הזה אומר ל-Circus לקשור שקע בפורט 9999 ולהפעיל 3 עובדי שאסטות
נגדו. זה גם מפעיל את לוח המחוונים של האינטרנט של Circus ואת מודול הסטטיסטיקה.
שמור אותו והפעל אותו באמצעות קרקסד:
$ bin/circusd --daemon circus.ini
עכשיו בקר http://127.0.0.1: 9999, אתה אמור לראות את אפליקציית שלום עולם. ההבדל עכשיו הוא
שהשקע מנוהל על ידי Circus וישנם מספר עובדי אינטרנט שמקבלים
קשרים נגד זה.
הערה:
איזון העומסים מופעל על ידי מערכת ההפעלה כך שאתה מקבל את אותה מהירות
כמו כל שרת אינטרנט אחר מסוג pre-fork כמו Apache או NGinx. Circus לא מפריע
הנתונים שעוברים דרכם.
אתה יכול גם לבקר http://localhost: 8080 / ותיהנו מלוח המחוונים של האינטרנט של סירקוס.
פעולת גומלין
בואו נשתמש במעטפת circusctl בזמן שהמערכת פועלת:
$ bin/circusctl
circusctl 0.7.1
סטטיסטיקות circusd: פעיל
circushttpd: פעיל
אפליקציית אינטרנט: פעילה
(circusctl)
אתה נכנס למעטפת אינטראקטיבית. הקלד לעזור כדי לקבל את כל הפקודות:
עזרה (circusctl)
פקודות מתועדות (הקלד עזרה ):
========================================
הוסף קבל רשימה numprocesses quit rm start stop
decr globaloptions להאזין numwatchers לטעון מחדש סטטיסטיקות
סטטוס אות הפעלה מחדש של אפשרויות dstats incr listsockets
פקודות לא מתועדות:
======================
עזרה ב-EOF
בואו ננסה דברים בסיסיים. בואו נפרט את תהליכי עובדי האינטרנט ונוסיף אחד חדש:
אפליקציית רשימה (circusctl)
13712,13713,13714
אפליקציית אינטרנט incr (circusctl)
4
אפליקציית רשימה (circusctl)
13712,13713,13714,13973
מזל טוב, ביצעת אינטראקציה עם הקרקס שלך! צאו מהקליפה בעזרת Ctrl+D ועכשיו רוץ.
קרקס-טופ:
$ bin/קרקס-top
זוהי פקודה דמוית-על לצפייה בכל ניצול הזיכרון והמעבד של התהליכים שלך בזמן אמת.
לחצו Ctrl+C ועכשיו בואו נצא לחלוטין מ-Circus דרך circus-ctl:
$ bin/circusctl quit
ok
הַבָּא צעדים
אתה יכול לחבר את אפליקציית WSGI שלך במקום את "שלום עולם" של Chaussette פשוט על ידי...
מצביע על כך שהאפליקציה ניתנת לקריאה.
Chaussette מגיע גם עם הרבה מערכות הפעלה אחוריות כמו Gevent או Meinheld.
חומר עיוני https://chaussette.readthedocs.org/ עבור כל האפשרויות.
למה צריך I להשתמש קרקס במקום of X ?
1. קרקס מפשט שֶׁלְךָ אינטרנט לערום תהליך ניהול
קרקס יודע איך לנהל תהליכים ו שקעים, כך שלא תצטרכו להאציל סמכויות אינטרנט
ניהול עובדים לשרת WGSI.
ראה למה מעגלי המעגלים
2. קרקס מספק פאב/סאב ו בו הודעות באמצעות ZeroMQ
לקרקס יש ערוץ פאב/סאב שניתן להירשם אליו. ערוץ זה מקבל את כל האירועים.
קורה ב-Circus. לדוגמה, ניתן לקבל הודעה כאשר תהליך מתנדנד, או
בניית לקוח שמפעיל אזהרה כאשר תהליכים מסוימים אוכלים את כל המעבד או
זיכרון RAM
אירועים אלה נשלחים דרך ערוץ ZeroMQ, מה שמבדיל אותו מה-stdin
משתמש ב-Stream Supervisord:
· סירקוס שולח אירועים בצורה של "אש ושכח", כך שאין צורך לבצע לולאה ידנית
דרך את כל מאזינים ולשמור על מצבם.
· ניתן לאתר מנויים בשרת מרוחק.
סירקוס מספק גם דרכים לקבל עדכוני סטטוס באמצעות סקרים חד פעמיים על בקשת/נציג.
ערוץ. משמעות הדבר היא שתוכלו לקבל את המידע שלכם מבלי להירשם לערוץ
stream. פקודת cli שמספק Circus משתמשת בערוץ זה.
ראה דוגמאות.
3. קרקס is (פִּיתוֹן) מפתחים ידידותי
בעוד ש-Circus יכול להיות מופעל כולו על ידי קובץ תצורה ו- סירקוסקטל / קרקסד
פקודות, קל לעשות שימוש חוזר בכל המערכת או בחלקה כדי לבנות פקודות מותאמות אישית משלך
צופה תהליכים בפייתון.
כל שכבה במערכת מבודדת, כך שניתן לעשות שימוש חוזר באופן עצמאי:
· עטיפת התהליך (התַהֲלִיך)
· מנהל התהליכים (צופה)
· המנהל הגלובלי שמנהל מספר מנהלי תהליכים (שוטר)
· וכן הלאה…
4. קרקס מאזניים
אחד ממקרי השימוש של Circus הוא ניהול אלפי תהליכים מבלי להוסיף
הוצאות תקורה -- אנחנו מחויבים להתמקד בזה.
ביאה החל מ- מפקח
Supervisor הוא פתרון פופולרי מאוד בעולם הפייתון ולעתים קרובות שואלים אותנו איך Circus...
משווה לזה.
אם אתם מגיעים מ מפקח, דף זה מנסה לתת סקירה כללית של אופן פעולת הכלים
שונות.
הבדלים סקירה
למפקח ולקרקס יש את אותן מטרות - שניהם מנהלים תהליכים ומספקים
סקריפט שורת פקודה - בהתאמה מְפַקֵחַ ו קרקסד — שקורא תצורה
קובץ, מפרק תהליכים חדשים ומשאיר אותם בחיים.
ל-Circus יש תכונה נוספת: היכולת לקשור שקעים ולתת לתהליכים שהוא מנהל
השתמשו בהם. מודל "קדם-מזלג" זה משמש שרתי אינטרנט רבים בשוק, כמו אַפָּשׁ or
חד-קרןאפשרות זו ב-Circus יכולה לפשט את מערך אפליקציות האינטרנט: כל התהליכים ו
שקעים מנוהלים על ידי כלי יחיד.
שני הפרויקטים מספקים דרך לשלוט בדמון פעיל באמצעות סקריפט אחר, בהתאמה.
מפקח ו סירקוסקטללשניהם יש גם אירועים ודרך להירשם אליהם.
ההבדל העיקרי הוא הטכנולוגיה הבסיסית: המפקח משתמש ב-XML-RPC לצורך אינטראקציה
עם הדמון, בעוד ש-Circus משתמש ב-ZeroMQ.
ל-Circus ול-Supervisor יש ממשק אינטרנט המציג את מה שקורה. Circus הוא יותר
מתקדם כי אתה יכול לעקוב בזמן אמת אחר מה שקורה ולקיים אינטראקציה עם הדמון.
הוא משתמש ב-web sockets ומפותח בפרויקט נפרד (קרקס-אינטרנט.)
ישנם הבדלים עדינים רבים אחרים בעיצוב הליבה, שאולי נפרט כאן יום אחד... ב
בינתיים, תוכלו ללמוד עוד על עיצוב פנים של סירקוס.
תְצוּרָה
שתי המערכות משתמשות בקובץ דמוי ini כקובץ תצורה.
· מפקח תיעוד
· קרקס תיעוד
הנה דוגמה קטנה להפעלת אפליקציה עם Supervisor. במקרה זה, ה-
היישום יופעל ויופעל מחדש במקרה של קריסה
[תוכנית:דוגמה]
פקודה = npm התחל
ספרייה=/בית/www/השרת-שלי/
משתמש=www-data
התחלה אוטומטית = נכון
הפעלה מחדש אוטומטית = נכון
redirect_stderr=אמת
ב-Circus, אותה תצורה מתבצעת על ידי:
[צופה:דוגמה]
cmd=npm התחל
working_dir=/home/www/my-server/
משתמש=www-data
stderr_stream.class=StdoutStream
שימו לב שהניתוב מחדש של stderr שונה במקצת ב-Circus. לכלי אין
a זנב תכונה כמו ב-Supervisor, אבל תאפשר לך לחבר כל פיסת קוד להתמודד איתה
הזרם הנכנס. אתה יכול ליצור וו זרם משלך (כמחלקה) ולעשות כל מה שאתה רוצה
רוצה עם הזרם הנכנס. Circus מספק כמה מחלקות זרם מובנות כמו
StdoutStream, זרם קובץ, זרם קבצים שנצפה, או זרם קבצים מסתובב בזמן.
קרקס ל Ops
אזהרה:
כברירת מחדל, Circus אינו מאבטח את ההודעות שלו בעת שליחת מידע דרך ZeroMQ.
לפני הפעלת Circus בסביבת ייצור, הקפידו לקרוא את דף האבטחה.
הצעד הראשון בניהול דאמון Circus הוא כתיבת קובץ התצורה שלו.
תצורה. אם אתם פורסים מחסנית רשת, בדקו את ה-sockets.
ניתן לפרוס את Circus באמצעות Python 2.6, 2.7, 3.2 או 3.3 - רוב הפריסות הקיימות הן...
בוצע בגרסה 2.7. כדי ללמוד כיצד לפרוס את Circus, עיינו בפריסה.
כדי לנהל דמון של Circus, עליך להכיר את רשימת הפקודות בהן ניתן להשתמש.
in סירקוסקטלשימו לב שתוכלו לקבל את אותה עזרה באינטרנט גם כשאתם רצים סירקוסקטל בתור
צדף.
אנו מספקים גם קרקס-טופ, ראה cli ולוח מחוונים אינטרנטי נחמד. ראה circushttpd.
לבסוף, כדי להפיק את המרב מ-Circus, הקפידו לבדוק כיצד להשתמש בתוספים וב-hooks.
ראה תוספים וויקים.
Ops תיעוד מדד
תְצוּרָה
ניתן להגדיר את Circus באמצעות קובץ תצורה בסגנון ini.
דוגמא:
[קרקס]
עיכוב_בדיקה = 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)
עיכוב_חימום = 0
מספר תהליכים = 5
# וו
hooks.before_start = my.hooks.control_redis
# ידחוף test.log את הזרם כל 300 אלפיות השנייה
stdout_stream.class = זרם קבצים
stdout_stream.filename = test.log
# אופציונלי לסובב את קובץ היומן כשהוא מגיע ל-1 ג'יגה-בייט
# ושמור 5 קבצים שהועתקו
stdout_stream.max_bytes = 1073741824
stdout_stream.backup_count = 5
[סביבה:התוכנית שלי]
נתיב = $נתיב:/ סל
עוגה = שקר
[תוסף:statsd]
use = circus.plugins.statsd.StatsdEmitter
מארח = מארח מקומי
יציאה = 8125
קצב_דגימה = 1.0
שם_אפליקציה = דוגמה
[socket:web]
מארח = מארח מקומי
יציאה = 8080
קרקס - יחיד סעיף
נקודת סיום
שקע ZMQ המשמש לניהול Circus דרך סירקוסקטל. (בְּרִירַת מֶחדָל:
tcp://127.0.0.1:5555)
בעל/ת קצה
אם מוגדר לשם משתמש של מערכת ונקודת הקצה היא שקע ipc כמו
ipc://var/run/circusd.sock, אז הבעלות על קובץ ה-socket תשתנה ל-
משתמש זה בעת ההפעלה. לפרטים נוספים, ראה אבטחה. (ברירת מחדל: ללא)
נקודת_קצה_פאבסוב
שקע ZMQ PUB/SUB המקבל פרסומים של אירועים. (ברירת מחדל:
tcp://127.0.0.1:5556)
נקודת קצה של פאפא
אם משתמשים ב-papa, ניתן לציין את נקודת הקצה, כגון ipc://var/run/circusd.sock.
(בְּרִירַת מֶחדָל: tcp://127.0.0.1:20202)
סטטיסטיקות אם מוגדר כ-True, Circus מפעיל את הדמון circusd-stats. (ברירת מחדל: False)
נקודת_קצה_סטטיסטיקות
שקע ZMQ PUB/SUB המקבל פרסומים של סטטיסטיקות. (ברירת מחדל:
tcp://127.0.0.1:5557)
יציאות_סגירה_סטטיסטיקות
אם True, הפונקציה circusd-stats שולחת את הפונקציה stdout/stderr אל /dev/null. (ברירת מחדל: False)
עיכוב_בדיקה
מרווח הזמן בין פעולות סקר בשניות עבור שקע ZMQ. (ברירת מחדל: 5)
לכלול
רשימת קבצי תצורה שיש לכלול. ניתן להשתמש בתווים כלליים (*) לכלול פרטים ספציפיים
סכמות עבור הקבצים שלך. הנתיבים הם מוחלטים או יחסיים לקובץ התצורה.
(ברירת מחדל: אין)
include_dir
רשימת ספריות הגדרות. כל הקבצים תואמים *.ini תחת כל ספרייה תהיה
ייכלל. הנתיבים מוחלטים או יחסיים לקובץ התצורה. (ברירת מחדל:
אף אחד)
stream_backend
מגדיר את סוג ה-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. (ברירת מחדל: שקר)
באגים אם מוגדר כ-True, כל הדמונים של Circus stout/stderr מנותבים ל-circusd
stdout/stderr (ברירת מחדל: False)
debug_gc
אם מוגדר כ-True, circusd מפיק מידע נוסף ביומן מאוסף הזבל.
זה יכול להיות שימושי במעקב אחר דליפות זיכרון. (ברירת מחדל: False)
pidfile
הקובץ שיש להשתמש בו כדי לשמור את ה-pid של הדמון.
אומסק ערך עבור umask. אם לא מוגדר, circusd לא ינסה לשנות את umask.
רמת יומן
רמת הלוג שאנו רוצים לראות (ברירת מחדל: INFO)
יציאה
קובץ הפלט של הלוג (logoutput) שבו נרצה לבצע רישום (ברירת מחדל: - כדי להתחבר ב-stdout). אתה יכול
יומן רישום למערכת רישום מרוחקת באמצעות התחביר הבא:
syslog://host:port?facility כאשר host הוא שרת ה-syslog שלך, port הוא אופציונלי.
ו-facility הוא פקטור ה-syslog לשימוש. אם ברצונך להתחבר ל-syslog מקומי
אתה יכול להשתמש syslog:///path/to/syslog/socket?facility במקום.
תצורת לוגר
נתיב לקובץ INI, JSON או YAML כדי להגדיר רישום סטנדרטי של Python עבור ה-
בורר. הערך המיוחד "ברירת מחדל" משתמש בתצורת הרישום המובנית.
בהתבסס על האפשרויות האופציונליות loglevel ו-logoutput.
דוגמה ימל תְצוּרָה שלח
גרסה: 1
השבתת לוגרים_קיימים: שקר
מעצבים:
הפש you
פורמט: '%(asctime)s - %(name)s - [%(levelname)s] %(message)s'
מטפלים:
קובץ יומן:
מחלקה: logging.FileHandler
שם הקובץ: logoutput.txt
רמה: ניפוי באגים
מעצב: פשוט
חוטבי עצים:
קִרקָס:
רמה: ניפוי באגים
מטפלים: [קובץ יומן]
התפשטות: לא
שורש:
רמה: ניפוי באגים
מטפלים: [קובץ יומן]
צופה: שם - as רב סעיפים as אתה רוצה
שֵׁם שם הצופה. שם זה משמש ב סירקוסקטל
cmd התוכנית הניתנת להפעלה.
טוען ארגומנטים משורת הפקודה שיש להעביר לתוכנית. ניתן להשתמש בפורמט פייתון.
תחביר כאן כדי לבנות את הפרמטרים. משתני סביבה זמינים, כ
כמו גם מזהה העובד ומשתני הסביבה שהעברת, אם יש כאלה,
עם הפרמטר "env". ראה עיצוב מה היא פקודות ו טיעונים עם דינמי
משתנים למידע נוסף על זה.
פָּגָז אם אמת, התהליכים רצים במעטפת (ברירת מחדל: שקר)
shell_args
ארגומנטים משורת הפקודה שיש להעביר לפקודת המעטפת כאשר פָּגָז זה נכון. עובד
רק עבור מערכת *nix (ברירת מחדל: ללא)
תיקיית_עבודה
תיקיית העבודה של התהליכים (ברירת מחדל: ללא)
uid שם המשתמש או מזהה המשתמש שאיתו הפקודה צריכה לפעול. (ה-uid הנוכחי הוא ה-
בְּרִירַת מֶחדָל).
gid מזהה הקבוצה או השם שאיתו הפקודה צריכה לפעול. (ה-gid הנוכחי הוא ה-
בְּרִירַת מֶחדָל).
copy_env
אם מוגדר כ-true, משתני הסביבה המקומיים יועתקו ויועברו אל
פועלים בעת השרייתם. (ברירת מחדל: שקר)
נתיב_העתקה
אם מוגדר כאמת, sys.path מועבר בסביבת תת-התהליך באמצעות PYTHONPATH.
copy_env חייב להיות אמיתי. (ברירת מחדל: שקר)
עיכוב_חימום
העיכוב (בשניות) בין תהליכים רצים.
התחלה אוטומטית
אם מוגדר כ-false, הצופה לא יופעל אוטומטית כאשר הבורר
מתחיל. ניתן להפעיל את הצופה במפורש (לדוגמה: סירקוסקטרל התחלה
התוכנית שלי). (ברירת מחדל: אמת)
תהליכים מספריים
מספר התהליכים שיש להריץ עבור צופה זה.
rlimit_LIMIT
הגדר מגבלת משאבים LIMIT עבור התהליכים הנמצאים תחת מעקב. שם התצורה צריך להתאים
קבועי RLIMIT_* (לא תלויי רישיות) המפורטים ב- פיתון משאב מודול
הפניהלדוגמה, שורת התצורה 'rlimit_nofile = 500' קובעת את המקסימום
מספר הקבצים הפתוחים ל-500. כדי להגדיר ערך מגבלה ל-RLIM_INFINITY, אל תגדיר
ערך, כמו שורת ההגדרות הזו: 'rlimit_nofile = '.
stderr_stream.class
שם מחלקה מלא של Python שיופעל ויקבל
מה היא סטדרר זרם של כל התהליכים בו __שִׂיחָה__() שִׁיטָה.
סירקוס מספק כמה שיעורי זרם בהם ניתן להשתמש ללא קידומת:
· זרם קובץכותב בקובץ ויכול לבצע סיבוב יומן אוטומטי
· זרם קבצים שנצפהכותב בקובץ ומסתמך על סיבוב יומנים חיצוני
· זרם קבצים מסתובב בזמןכותב בקובץ ויכול להסתובב בזמן מסוים
מרווחים.
· זרם תורים: כתוב בתור זיכרון
· StdoutStreamכותב ב-stdout
· FancyStdoutStreamכותב פלט צבעוני עם קידומות זמן ב-stdout
stderr_stream.*
כל האפשרויות החל מ stderr_stream. אחר מאשר בכיתה יועבר ה-
בנאי בעת יצירת מופע של המחלקה המוגדרת ב
stderr_stream.class.
stdout_stream.class
שם מחלקה מלא של Python שיופעל ויקבל
מה היא stdout זרם של כל התהליכים בו __שִׂיחָה__() שִׁיטָה.
סירקוס מספק כמה שיעורי זרם בהם ניתן להשתמש ללא קידומת:
· זרם קובץכותב בקובץ ויכול לבצע סיבוב יומן אוטומטי
· זרם קבצים שנצפהכותב בקובץ ומסתמך על סיבוב יומנים חיצוני
· זרם קבצים מסתובב בזמןכותב בקובץ ויכול להסתובב בזמן מסוים
מרווחים.
· זרם תורים: כתוב בתור זיכרון
· StdoutStreamכותב ב-stdout
· FancyStdoutStreamכותב פלט צבעוני עם קידומות זמן ב-stdout
stdout_stream.*
כל האפשרויות החל מ stdout_stream. אחר מאשר בכיתה יועבר ה-
בנאי בעת יצירת מופע של המחלקה המוגדרת ב
stdout_stream.class.
סגור_ילד_סטדאו
אם מוגדר כ- True, זרם ה- stdout של כל תהליך יישלח אל /dev/null
אחרי המזלג. ברירת המחדל היא False.
סגירת_ילד_סטדרר
אם מוגדר כ- True, זרם ה- stderr של כל תהליך יישלח אל /dev/null
אחרי המזלג. ברירת המחדל היא False.
שלח_הופ
אם הערך הוא True, טעינת התהליך תתבצע על ידי שליחת אות SIGHUP.
לשקר.
אות עצירה
האות שיש לשלוח בעת עצירת התהליך. ניתן לציין אותו כמספר או כ
שם אות. שמות אותות אינם תלויי רישיות ויכולים לכלול 'SIG' או לא. לכן
דוגמאות תקפות כוללות להפסיק, INT, טווח יעד ו 3ברירת המחדל היא SIGTERM.
עצירת_ילדים
בעת שליחת ה- אות עצירה, שלח אותו גם לילדים. ברירת המחדל היא
שקר.
max_retry
מספר הפעמים שאנו מנסים להתחיל תהליך, לפני שאנו נוטשים ועוצרים
כל הצופה. ברירת המחדל היא 5. הגדר ל-1- כדי להשבית את max_retry ואת retry
ללא הגבלת זמן.
פסק זמן חינני
מספר השניות שיש להמתין לסיום חלק של תהליך לפני
הורג את זה.
כשאנחנו עוצרים תהליך, אנחנו קודם כל שולחים לו אות עצירהעובד עלול להידבק בזה
אות לבצע פעולות ניקיון לפני היציאה. אם העובד עדיין
פעיל לאחר graceful_timeout שניות, אנו שולחים לו אות SIGKILL. זה לא
אפשרי לתפוס אותות SIGKILL כך שהעובד יעצור.
ברירת המחדל היא 30 שניות.
עדיפות
מספר שלם שמגדיר עדיפות עבור הצופה. כאשר הבורר מבצע פעולות מסוימות
פעולות על כל הצופים, זה ימיין אותם עם שדה זה, מהגדולים יותר
המספר נקבע לקטן ביותר. ברירת המחדל היא 0.
קְלָף בּוֹדֵד
אם מוגדר כ-True, לצופה זה יהיה לכל היותר תהליך אחד. ברירת המחדל היא
שקר.
use_sockets
אם מוגדר כ-True, צופה זה יוכל לגשת לשקעים מוגדרים דרך שלהם
תיאורי קבצים. אם False, כל קובצי ה-fd של האב נסגרים כאשר תהליך הצאצא נסגר.
מפוצל. ברירת המחדל היא False.
max_age
אם מוגדר, התהליך יופעל מחדש מתישהו לאחר max_age שניות.
שימושי כאשר תהליכים עוסקים במאגר של מחברים: הפעלה מחדש של תהליכים
משפר את איזון העומסים. ברירת המחדל היא מושבתת.
שונות_הגיל_המקסימלית
אם max_age מוגדר, התהליך יחיה בין max_age ל-max_age +
random(0, max_age_variance) שניות. זה מונע הפעלה מחדש של כל התהליכים למשך
הצופה בבת אחת. ברירת המחדל היא 30 שניות.
לפי דרישה
אם מוגדר כ- True, התהליכים יופעלו רק לאחר החיבור הראשון אל
אחד מהשקעים שתצורתם נקבעה (ראה להלן). אם נדרש הפעלה מחדש, זה יהיה
מופעל רק באירוע ה-socket הבא.
ווים.*
ווים זמינים: לפני_התחלה, אחרי_התחלה, לפני_השרצה, after_spawn,
לפני_עצירה, אחרי_עצירה, לפני_אות, אות_אחרי, סטטיסטיקות_מורחבות
הגדר פונקציות callback אשר מתחברות לתהליך ההפעלה/כיבוי של הצופה.
אם הקרס חוזר לא נכון ואם הקרס הוא אחד מ לפני_התחלה, לפני_השרצה,
אחרי_התחלה or after_spawn, ההפעלה תבוטל.
אם הקרס הוא לפני_אות וחוזר לא נכון, ואז האות המתאים
לא יישלח (למעט SIGKILL שתמיד נשלח)
שימו לב ש-hook שנכשל במהלך תהליך העצירה לא יבטל אותו.
הגדרת הקריאה החוזרת יכולה לכלול דגל בוליאני מופרד באמצעות פסיק.
כאשר הדגל מוגדר ל נָכוֹן, כל שגיאה שתתרחש ב-hook תתעלם. אם
מכוון ל שקר (ברירת המחדל), הוו יחזיר לא נכון.
עוד על ווים.
וירטואלי
כאשר מסופק, מצביע על שורש של ספריית Virtualenv. הצופה יעשה זאת.
סרוק את המקומי חבילות אתר וטוען את תוכנו לתוך הביצוע
סביבה. יש להשתמש עם copy_env מוגדר כ- True. ברירת המחדל היא ללא.
virtualenv_py_ver
מציין את גרסת הפייתון של ה-virtualenv (לדוגמה "3.3"). זה שימושי אם
מופעלת על ידי קרקס עם גרסת פייתון אחרת (למשל "2.7") הצופה יסרוק את
מקומי חבילות אתר של גרסת הפייתון שצוינה וטען את תוכנה לתוך
סביבת הביצוע. יש להשתמש בה עם וירטואליברירת המחדל היא ללא.
respawn
אם מוגדר כ-False, התהליכים המטופלים על ידי צופה לא יופעלו מחדש
באופן אוטומטי. ניתן להפעיל מחדש את התהליכים באופן ידני באמצעות התחלה פקודה.
(ברירת מחדל: אמת)
השתמש באבא
הגדר לערך אמת כדי להשתמש בפאפא.
שקע: שם - as רב סעיפים as אתה רוצה
המארח המארח של השקע. ברירת המחדל היא 'localhost'
נמל הפורט. ברירת המחדל היא 8080.
משפחה משפחת השקעים. יכולה להיות 'AF_UNIX', 'AF_INET' או 'AF_INET6'. ברירת המחדל היא
'AF_INET'.
סוג סוג השקע. יכול להיות 'SOCK_STREAM', 'SOCK_DGRAM', 'SOCK_RAW', 'SOCK_RDM' או
'SOCK_SEQPACKET'. ברירת המחדל היא 'SOCK_STREAM'.
ממשק
כאשר ניתן שם ממשק רשת כמו 'eth0', ה-socket נקשר אליו.
מכשיר מסוים כך שרק חבילות שהתקבלו מאותו ממשק מסוים
מעובדים על ידי השקע. ניתן להשתמש בכך, לדוגמה, כדי להגביל את המכשיר
להיקשר בעת קשירה ל-IN_ADDR_ANY (0.0.0.0) או IN_ADDR_BROADCAST
(255.255.255.255). שימו לב שזה עובד רק עבור סוגים מסוימים של שקעים, במיוחד
שקעי AF_INET.
נתיב כאשר מסופק נתיב לקובץ שישמש כקובץ שקע יוניקס. אם
נתיב מסופק, משפחה נאלץ ל-AF_UNIX ו המארח ו נמל מתעלמים.
אומסק כאשר מסופק, מגדיר את ה-umask שישמש ליצירת socket AF_UNIX.
דוגמא, umask=000 ייצר שקע עם הרשאה 777.
להחליף
בעת יצירת sockets של יוניקס ('AF_UNIX'), קובץ קיים עשוי להצביע על בעיה
אז ברירת המחדל היא להיכשל. ציין נָכוֹן פשוט להסיר את הקובץ הישן אם אתה
ודא שהשקע מנוהל רק על ידי Circus.
so_reuseport
אם מוגדר כ-True ו-SO_REUSEPORT זמין בפלטפורמת היעד, סירקוס יעשה זאת
צור וקשור שקע(ים) SO_REUSEPORT חדשים עבור כל עובד שהוא מפעיל, וזהו
משתמש של שקע/ים זה/ים.
השתמש באבא
הגדר לערך אמת כדי להשתמש בפאפא.
לאחר יצירת שקע, ה- ${circus.sockets.NAME} ניתן להשתמש במחרוזת בפקודה
(cmd or טוען) של צופה. סירקוס יחליף אותו בערך ה-FD. הצופה חייב גם
יש use_sockets מכוון ל נָכוֹן אחרת השקע יהיה סגור ותקבלו
שגיאות כאשר הצופה מנסה להשתמש בו.
דוגמא:
[צופה: עובד רשת]
cmd = chaussette --fd $(circus.sockets.webapp) chaussette.util.bench_app
use_sockets = נכון
[socket:webapp]
מארח = 127.0.0.1
יציאה = 8888
תוסף: שם - as רב סעיפים as אתה רוצה
להשתמש השם המלא שמצביע על מחלקת התוסף.
דבר אחר
כל מפתח אחר שנמצא במקטע מועבר לבנאי התוסף ב-
config מיפוי.
ניתן להשתמש בכל אפשרויות הצופה, מכיוון שתוסף מופעל כמו צופה.
Circus מגיע עם כמה תוספים מוכנים מראש, אך ניתן גם להרחיב אותם בקלות על ידי...
לפתח משלך.
env or env[:צופים] - as רב סעיפים as אתה רוצה
דבר
שם משתנה סביבה שאליו יש להקצות ערך. סביבה בסגנון bash
תמיכה בהחלפות. לדוגמה, הוספה / סל ל נתיב נתיב =
נתיב$:/ סל'
מדור האחראי על אספקת משתנה סביבה להרצת תהליכים.
דוגמא:
[צופה: עובד1]
cmd = פינג 127.0.0.1
[צופה: עובד2]
cmd = פינג 127.0.0.1
[מעטפה]
עוגה = שקר
המשתנה עוגה יופץ לכל הצופים שהוגדרו בקובץ ההגדרות.
WATCHERS יכול להיות רשימה מופרדת בפסיקים של מקטעי צופים שעליהם ניתן להחיל סביבה זו.
אם מספר מקטעי סביבה תואמים לצופה, הם ישולבו לפי הסדר שבו הם מופיעים.
קובץ התצורה. ערכים מאוחרים יותר יקבלו עדיפות.
דוגמא:
[צופה: עובד1]
cmd = פינג 127.0.0.1
[צופה: עובד2]
cmd = פינג 127.0.0.1
[סביבה: עובד1, עובד2]
נתיב = / סל
[סביבה:עובד1]
נתיב = $נתיב
[סביבה:עובד2]
עוגה = שקר
עובד1 יבוצע עם PATH = $PATH (מורחב מהסביבה בה circusd הופעל)
עובד2 יבוצע עם PATH = / סל ועוגה = שקר
אפשר להשתמש גם בתווים כלליים (wildcards).
דוגמא:
[צופה: עובד1]
cmd = פינג 127.0.0.1
[צופה: עובד2]
cmd = פינג 127.0.0.1
[סביבה:עובד*]
נתיב = / סל
שניהם עובד1 ו עובד2 יבוצע עם PATH = / סל
שימוש סביבה משתנים
בעת כתיבת קובץ התצורה, ניתן להשתמש במשתני סביבה המוגדרים ב- env
סעיף או בתוך os.environ עצמו.
אתה רק צריך להשתמש ב- קרקס.מעטפה. קידומת.
דוגמא:
[צופה: עובד1]
cmd = $(circus.env.shell)
[צופה: עובד2]
baz = $(circus.env.user)
בר = $(circus.env.yeah)
sup = $(circus.env.oh)
[שקע:שקע1]
יציאה = $(circus.env.port)
[תוסף:תוסף1]
use = some.path
פרמטר1 = $(circus.env.plugin_param)
[מעטפה]
כן = בו
[סביבה:עובד2]
אה = בסדר
אם משתנה מוגדר בכמה מקומות, לערך המיוחד ביותר יש עדיפות: a
משתנה המוגדר ב מעטפה:XXX יעקוף משתנה שהוגדר ב env, אשר יעקוף את
משתנה המוגדר ב os.environ.
ניתן להשתמש בתחליפים סביבתיים בכל מקטע של התצורה בכל מקטע
משתנה
עיצוב מה היא פקודות ו טיעונים עם דינמי משתנים
כפי שראיתם, ניתן להעביר מידע מסוים המחושב
באופן דינמי בעת הפעלת התהליכים. בין היתר, ניתן לקבל את מזהה העובד
(WID) וכל האפשרויות המועברות אל התַהֲלִיךבנוסף, ניתן
גישה לאפשרויות שהועברו אל צופה אשר התניע את התהליך.
הערה:
מזהה העובד שונה מזהה התהליך. זהו ערך ייחודי, שמתחיל ב-1,
שהוא ייחודי רק לצופה.
לדוגמה, אם ברצונך לגשת למשתנים מסוימים הכלולים בסביבה,
תצטרך לעשות את זה עם הגדרה כזו:
cmd = "תכינו לי קפה --sugar $(CIRCUS.ENV.SUGAR_AMOUNT)"
זה עובד עם שניהם cmd ו טוען.
חָשׁוּב:
· כל המשתנים מקודמים עם קרקס.
· ההחלפה אינה תלוית רישיות/קטנות.
זרם תצורה
מחלקת זרם פשוטה כמו זרם תורים ו StdoutStream אין להם תכונות ספציפיות אבל
ייתכן שחלק משיעורי הזרם האחרים יכיל כמה:
זרם קובץ
שם הקובץ
נתיב הקובץ שבו ייכתב הלוג.
פורמט זמן
פורמט ה-strftime שישמש להוספת חותמת זמן לפני כל זמן.
ברירת מחדל, הם לא יקודמו.
כלומר: %Y-%m-%d %H:%M:%S
max_bytes
הגודל המרבי של קובץ היומן לפני הפעלת קובץ חדש. אם לא סופק, ה-
הקובץ לא מגולגל.
גיבוי_ספירה
מספר קבצי היומן שיישמרו. כברירת מחדל, backup_count הוא null.
הערה:
Rollover מתרחש בכל פעם שקובץ היומן הנוכחי הוא כמעט באורך 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 = זרם קבצים
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
זרם קבצים שנצפה
שם הקובץ
נתיב הקובץ שבו ייכתב הלוג.
פורמט זמן
פורמט ה-strftime שישמש להוספת חותמת זמן לפני כל זמן.
ברירת מחדל, הם לא יקודמו.
כלומר: %Y-%m-%d %H:%M:%S
הערה:
WatchedFileStream מסתמך על כלי חיצוני לסבב יומני רישום כדי להבטיח שקבצי רישום
אל תהפוך לגדול מדי. קובץ הפלט ינוטר ואם הוא יימחק אי פעם או
הועבר על ידי כלי סיבוב יומן חיצוני, אזי זיהוי קובץ הפלט יהיה
נטען מחדש באופן אוטומטי.
דוגמא:
[צופה:התוכנית שלי]
cmd = python -m myapp.server
stdout_stream.class = זרם קובץ שנצפה
stdout_stream.filename = test.log
stdout_stream.time_format = %Y-%m-%d %H:%M:%S
זרם קבצים מסתובב בזמן
שם הקובץ
נתיב הקובץ שבו ייכתב הלוג.
גיבוי_ספירה
מספר קבצי היומן שיישמרו. כברירת מחדל, backup_count הוא null.
פורמט זמן
פורמט ה-strftime שישמש להוספת חותמת זמן לפני כל זמן.
ברירת מחדל, הם לא יקודמו.
כלומר: %Y-%m-%d %H:%M:%S
סיבוב_כאשר
סוג המרווח. רשימת הערכים האפשריים מופיעה למטה. שימו לב שהם
לא תלוי אותיות גדולות/קטנות.
┌─────────────┬────────────────────────────┐
│ערך │סוג מרווח │
├────────────┼─────────────────────────────┤
│'S' │ שניות │
├────────────┼─────────────────────────────┤
│'M' │ דקות │
├────────────┼─────────────────────────────┤
│'H' │ שעות │
├────────────┼─────────────────────────────┤
ימים
├────────────┼─────────────────────────────┤
│'W0'-'W6' │ יום חול (0=יום שני) │
├────────────┼─────────────────────────────┤
│'חצות' │ התהפכות בחצות │
└────────────┴─────────────────────────────┘
סיבוב_מרווח
מרווח הגלגולים.
הערה:
TimedRotatingFileStream מסובב קבצי יומן במרווחי זמן מסוימים. מרווח גלילה
נקבע על ידי שילוב של rotate_when ו- rotate_interval.
דוגמא:
[צופה:התוכנית שלי]
cmd = python -m myapp.server
stdout_stream.class = זרם קבצים מסתובב בזמן
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
פקודות
במוקד הקרקס שוכנות מערכות הפיקוד. סירקוסקטל הוא רק לקוח zeromq,
ובמידת הצורך תוכלו להניע את מערכת Circus באופן תכנותי על ידי כתיבת zmq משלכם
לקוחות.
כל ההודעות הן מיפויי JSON.
עבור כל פקודה להלן, אנו מספקים דוגמה לשימוש עם circusctl אך גם את הקלט /
פלט הודעות zmq.
קרקס-CTL פקודות
· להוסיף: פקודות/הוספה
· פסק דין: פקודות/decr
· dstats: פקודות/dstats
· לקבל: פקודות/קבל
· גלובלאופציות: פקודות/אפשרויות גלובליות
· תוספת: פקודות/הגדלה
· פִּיתוֹן: פקודות/ipython
· רשימה: פקודות/רשימה
· להקשיב: פקודות/האזנה
· רשימות שקעים: פקודות/רשימות שקעים
· תהליכים מספריים: פקודות/מספר תהליכים
· צופי מספרים: פקודות/משגיחי מספרים
· אפשרויות: פקודות/אפשרויות
· להפסיק: פקודות/יציאה
· לטעון מחדש: פקודות/טעינה מחדש
· טען מחדש את התצורה: פקודות/טעינה מחדש של הגדרות
· הפעלה מחדש: פקודות/הפעלה מחדש
· rm: פקודות/rm
· סט: פקודות/סט
· אוֹת: פקודות/אות
· התחלה: פקודות/התחלה
· סטטיסטיקות: פקודות/סטטיסטיקות
· מצב: פקודות/סטטוס
· להפסיק: פקודות/עצירה
להוסיף a צוֹפֶה
פקודה זו מוסיפה צופה באופן דינמי לבורר.
ZMQ הערות נוספות
{
"פקודה": "הוסף",
"מאפיינים": {
"cmd": "/path/to/commandline --option"
"שם": "שם הצופה"
"ארגומנטים": [],
אפשרויות: {},
"התחלה": שקר
}
}
הודעה מכילה 2 מאפיינים:
· cmd: שורת פקודה מלאה לביצוע בתהליך
· args: מערך, ארגומנטים המועברים לפקודה (אופציונלי)
· שם: שם הצופה
· אפשרויות: אפשרויות של צופה
· התחלה: הפעלת הצופה לאחר היצירה
התגובה מחזירה סטטוס "אישור".
פיקוד קו
$ circusctl הוסף [--start]
אפשרויות
· שם הצופה שייווצר
· שורת פקודה מלאה לביצוע בתהליך
· --start: הפעל את הצופה באופן מיידי
הצהרה מה היא מספר of תהליכים in a צוֹפֶה
הערה זו מקטינה את מספר התהליכים בצופה ב- , 1 הוא ה-
ברירת המחדל.
ZMQ הערות נוספות
{
"פקודה": "הצהרה",
"מאפיינים": {
שם "
"nb":
"מחכה": לא נכון
}
}
התגובה מחזירה את מספר התהליכים במאפיין 'numprocesses`:
{ "סטטוס": "אישור", "מספר תהליכים": , "זמן", "חותמת זמן" }
פיקוד קו
$ circusctl decr [ ] [--מחכה]
אפשרויות
· שם הצופה
· מספר התהליכים להסרה.
לקבל קרקסד סטטיסטיקות
ניתן לקבל בכל עת סטטיסטיקות אודות circusd בעזרת הפקודה dstat.
ZMQ הערות נוספות
כדי לקבל את הסטטיסטיקות של circusd, פשוט הפעילו:
{
פקודה: "dstats"
}
התגובה מחזירה מיפוי של המאפיין "infos" המכיל מידע על התהליך:
{
מידע
"ילדים": [],
"cmdline": "פיתון",
מעבד: 0.1
"ctime": "0:00.41",
"זיכרון": 0.1,
"mem_info1": "3M",
"mem_info2": "2G",
"נחמד": 0,
"pid": 47864,
"שם משתמש": "שורש"
},
"status": "בסדר",
"זמן": 1332265655.897085
}
פיקוד קו
$ circusctl dstats
לקבל מה היא ערך of ספציפי צוֹפֶה אפשרויות
ניתן להשתמש בפקודה זו כדי לבצע שאילתה לגבי הערך הנוכחי של אפשרות אחת או יותר של צופה.
ZMQ הערות נוספות
{
"פקודה": "לקבל",
"מאפיינים": {
"מפתחות": ["מפתח1, "מפתח2"]
"שם": "שם הצופה"
}
}
הודעת בקשה מכילה שני מאפיינים:
· keys: list, מקשי האפשרויות שעבורם ברצונך לקבל את הערכים
· שם: שם הצופה
לאובייקט התגובה יש מאפיין אפשרויות שהוא מילון של שמות אפשרויות ו
ערכים.
לדוגמה:
{
"status": "בסדר",
אפשרויות
"פסק זמן חינני": 300,
"send_hup": נכון,
},
זמן': 1332202594.754644
}
פיקוד קו
$ circusctl לקבל
לקבל מה היא פוסק אפשרויות
פקודה זו מחזירה את אפשרויות הבורר
ZMQ הערות נוספות
{
"פקודה": "אפשרויות גלובליות",
"מאפיינים": {
"מפתח1": "ערך1",
..
}
}
הודעה מכילה 2 מאפיינים:
· keys: list, מקשי האפשרויות שעבורם ברצונך לקבל את הערכים
התגובה מחזירה אובייקט עם המאפיין "options" המכיל את רשימת המפתח/ערך
חזר על ידי קרקס.
לדוגמה:
{
"status": "בסדר",
אפשרויות
"עיכוב_בדיקה": 1,
...
},
זמן': 1332202594.754644
}
פיקוד קו
$ circusctl גלובלאופציות
אפשרויות
מקשי האפשרויות הם:
· נקודת קצה: נקודת הקצה של הבקר ZMQ
· pubsub_endpoint: נקודת הקצה של pubsub
· check_delay: העיכוב בין שתי נקודות בקרה
· multicast_endpoint: נקודת הקצה של שידור מרובה עבור גילוי אוטומטי של אשכול circusd
תוֹסֶפֶת מה היא מספר of תהליכים in a צוֹפֶה
הערה זו מגדילה את מספר התהליכים בצופה ב- , 1 הוא ה-
ברירת מחדל
ZMQ הערות נוספות
{
"פקודה": "הגדלה",
"מאפיינים": {
שם ",
"nb": ,
"מחכה": לא נכון
}
}
התגובה מחזירה את מספר התהליכים במאפיין 'numprocesses`:
{ "סטטוס": "אישור", "מספר תהליכים": , "זמן", "חותמת זמן" }
פיקוד קו
$ circusctl incr [ ] [--מחכה]
אפשרויות
· שם הצופה.
· מספר התהליכים שיש להוסיף.
צור פָּגָז אל תוך קרקסד תהליך
פקודה זו שימושית רק אם חבילת ipython מותקנת אצלך.
פיקוד קו
$ circusctl ipython
לקבל רשימה of צופים or תהליכים in a צוֹפֶה
ZMQ הערות נוספות
כדי לקבל את רשימת כל הצופים:
{
"פקודה": "רשימה",
}
כדי לקבל את רשימת התהליכים הפעילים בצופה:
{
"פקודה": "רשימה",
"מאפיינים": {
"שם": "שם הצופה",
}
}
התגובה מחזירה את הרשימה שנשאלה. המיפוי המוחזר יכול להיות 'צופים' או
'pids' בהתאם לבקשה.
פיקוד קו
רשימת circusctl $ [ ]
הירשם ל a צוֹפֶה אירוע
ZMQ
בכל רגע ניתן להירשם לאירוע של קרקס. קרקס מספק פיד PUB/SUB עליו
כל לקוח יכול להירשם. ה-URI של נקודת הקצה של המנוי מוגדר בקובץ circus.ini.
קובץ תצורה.
אירועים הם נושאי פאבסאב:
· צוֹפֶה. .לִקצוֹרכאשר תהליך נקצר
· צוֹפֶה. .לְהַשְׁרִיץ: כאשר תהליך נוצר
· צוֹפֶה. .לַהֲרוֹגכאשר תהליך נהרס
· צוֹפֶה. .מְעוּדכָּןכאשר תצורת הצופה מתעדכנת
· צוֹפֶה. .לְהַפְסִיקכאשר צופה נעצר
· צוֹפֶה. .הַתחָלָה: כאשר צופה מתחיל
כל הודעות האירועים נמצאות במבנה json.
פיקוד קו
הלקוח עודכן כדי לספק דרך פשוטה להאזין לאירועים:
circusctl להקשיב [ , ...]
דוגמה of התוצאה
$ circusctl האזן tcp://127.0.0.1:5556
watcher.refuge.spawn: {u'process_id': 6, u'process_pid': 72976,
זמן u: 1331681080.985104}
watcher.refuge.spawn: {u'process_id': 7, u'process_pid': 72995,
זמן u: 1331681086.208542}
watcher.refuge.spawn: {u'process_id': 8, u'process_pid': 73014,
זמן u: 1331681091.427005}
לקבל מה היא רשימה of ארובות
ZMQ הערות נוספות
כדי לקבל את רשימת השקעים:
{
"פקודה": "רשימת שקעים",
}
התגובה מחזירה רשימה של מיפויי json עם מפתחות עבור fd, name, host ו-port.
פיקוד קו
$ circusctl listsockets
לקבל מה היא מספר of תהליכים
קבל את מספר התהליכים בצופה או בבורר
ZMQ הערות נוספות
{
"פקודה": "מספר תהליכים",
"מאפיינים": {
שם "
}
}
התגובה מחזירה את מספר התהליכים במאפיין 'numprocesses`:
{ "סטטוס": "אישור", "מספר תהליכים": , "זמן", "חותמת זמן" }
אם שם המאפיין לא צוין, מוחזר סכום כל התהליכים המנוהלים.
פיקוד קו
$ circusctl numprocesses [ ]
אפשרויות
· שם הצופה
לקבל מה היא מספר of צופים
קבל את מספר הצופים בבורר
ZMQ הערות נוספות
{
"פקודה": "מספר צופים",
}
התגובה מחזירה את מספר הצופים במאפיין 'numwatchers`:
{ "סטטוס": "אישור", "מספר צופים": , "זמן", "חותמת זמן" }
פיקוד קו
$ circusctl numwatchers
לקבל מה היא ערך of את כל אפשרויות ל a צוֹפֶה
פקודה זו מחזירה את כל ערכי האפשרויות עבור צופה נתון.
ZMQ הערות נוספות
{
"פקודה": "אפשרויות",
"מאפיינים": {
"שם": "שם הצופה",
}
}
הודעה מכילה מאפיין אחד:
· שם: שם הצופה
לאובייקט התגובה יש מאפיין אפשרויות שהוא מילון של שמות אפשרויות ו
ערכים.
לדוגמה:
{
"status": "בסדר",
אפשרויות
"פסק זמן חינני": 300,
"send_hup": נכון,
...
},
זמן': 1332202594.754644
}
פיקוד קו
אפשרויות $ circusctl
אפשרויות
· שם הצופה
מקשי האפשרויות הם:
· numprocesses: מספר שלם, מספר תהליכים
· warmup_delay: מספר שלם או מספר, השהיית המתנה בין הפעלת תהליכים בשניות
· working_dir: מחרוזת, ספרייה שבה התהליך יבוצע
· uid: מחרוזת או מספר שלם, מזהה המשתמש המשמש להפעלת התהליך
· gid: מחרוזת או מספר שלם, מזהה קבוצה המשמש להפעלת התהליך
· send_hup: בוליאני, אם TRU האות HUP ישמש בעת טעינה מחדש
· shell: בוליאני, יריץ את הפקודה בסביבת ה-shell אם הוא נכון
· cmd: מחרוזת, שורת הפקודה המשמשת להפעלת התהליך
· env: אובייקט, מגדיר את הסביבה בה התהליך יופעל
· retry_in: מספר שלם או מספר, זמן ההמתנה בשניות לפני שננסה שוב להפעיל את
תהליך אם מספר הניסיונות המרבי הושג.
· max_retry: מספר שלם, מקסימום לולאות של ניסיונות חוזרים
· graceful_timeout: מספר שלם או מספר, זמן ההמתנה לפני שאנחנו מפסיקים תהליך באופן מוחלט.
· עדיפות: משמש למיון צופים בבורר
· סינגלטון: אם זה נכון, צופה סינגלטון.
· max_age: משך זמן בו תהליך יכול לחיות לפני שהוא מופעל מחדש
· max_age_variance: זמן חיים נוסף משתנה, מונע עדר חונק.
להפסיק מה היא פוסק מיד
כאשר הבורר מקבל פקודה זו, הבורר עוזב.
ZMQ הערות נוספות
{
"פקודה": "יציאה",
"מחכה": לא נכון
}
התגובה מחזירה את הסטטוס "אישור".
If המתנה הוא False (ברירת מחדל), השיחה תחזור מיד לאחר השיחה אות עצירה
על כל תהליך.
If המתנה אם הפעולה היא True, הקריאה תחזור רק כאשר תהליך העצירה יסתיים לחלוטין.
בגלל האפשרות graceful_timeout, זה יכול לקחת קצת זמן.
פיקוד קו
$ circusctl יציאה [--מחכה]
לִטעוֹן מִחָדָשׁ מה היא פוסק or a צוֹפֶה
פקודה זו טוענת מחדש את כל התהליך בצופה או בכל הצופים. זה יקרה באחד
מתוך 3 דרכים:
· אם graceful הוא false, מתרחשת הפעלה מחדש פשוטה.
· אם שלח_הופ נכון עבור הצופה, אות HUP נשלח לכל תהליך.
·
אחרת:
· אם ה-sequential הוא שקר, השופט ינסה להוביל ליצירת התוצאה תהליכים מספריים חדש
תהליכים. אם התהליכים החדשים נוצרים בהצלחה, התוצאה היא ש
כל התהליכים הישנים נעצרים, מכיוון שכברירת מחדל התהליכים הישנים ביותר נעצרים
נעצר כאשר מספר התהליכים בפועל עבור צופה גדול מ-
תהליכים מספריים.
· אם sequential הוא true, הבורר יפעיל מחדש כל תהליך בסדרה סדרתית
דרך (עם עיכוב_חימום הפסקה בין כל שלב)
ZMQ הערות נוספות
{
"פקודה": "טעינה מחדש",
"מאפיינים": {
שם ",
"חינני": נכון,
"רציף": לא נכון,
"מחכה": לא נכון
}
}
התגובה מחזירה את הסטטוס "אישור". אם המאפיין "פריציונלי" מוגדר כ-"אמת" התהליכים
ייצא באלגנטיות.
אם שם המאפיין קיים, הטעינה מחדש תתבצע על הצופה.
פיקוד קו
טען מחדש $ circusctl [ ] [--סיום] [--מחכה]
[--סִדרָתִי]
אפשרויות
· שם הצופה
· --terminate; צא מהצומת באופן מיידי
לִטעוֹן מִחָדָשׁ מה היא תצורה פילה
פקודה זו טוענת מחדש את קובץ התצורה, כך ששינויים בקובץ התצורה יישמרו.
משתקף בתצורה של קרקס.
ZMQ הערות נוספות
{
"פקודה": "טעינת הגדרות מחדש",
"מחכה": לא נכון
}
התגובה מחזירה את הסטטוס "אישור". אם המאפיין "פריציונלי" מוגדר כ-"אמת" התהליכים
ייצא באלגנטיות.
פיקוד קו
$ circusctl reloadconfig [--מחכה]
הפעל מחדש מה היא פוסק or a צוֹפֶה
פקודה זו מפעילה מחדש את כל התהליך בצופה או בכל הצופים. פונקציה זו פשוטה
לעצור צופה ואז להפעיל אותו מחדש.
ZMQ הערות נוספות
{
"פקודה": "הפעלה מחדש",
"מאפיינים": {
שם ",
"מחכה": לא נכון,
"התאמה": "[פשוט|גלוב|ביטוי רגולרי]"
}
}
התגובה מחזירה את הסטטוס "אישור".
אם שם המאפיין קיים, הטעינה מחדש תתבצע על הצופה.
If המתנה הוא False (ברירת מחדל), השיחה תחזור מיד לאחר השיחה אות עצירה
על כל תהליך.
If המתנה אם מדובר ב-True, הקריאה תחזור רק כאשר תהליך ההפעלה מחדש יושלם לחלוטין
הסתיים. בגלל האפשרות graceful_timeout, זה יכול לקחת קצת זמן.
השמיים להתאים הפרמטר יכול לקבל את הערך פשוט עבור השוואת מחרוזות, גוש עבור תווים כלליים
התאמה (ברירת מחדל) או regex עבור התאמת ביטויים רגולריים.
פיקוד קו
הפעלה מחדש של circusctl [שם] [--מחכה] [--התאמה=simple|glob|ביטוי רגולרי]
אפשרויות
· שם או דפוס של הצופה/ים
· שיטת התאמה של צופה
להסיר a צוֹפֶה
פקודה זו מסירה צופה באופן דינמי מהבורר. הצופים מוצגים בצורה חיננית
נעצר כברירת מחדל.
ZMQ הערות נוספות
{
"פקודה": "rm",
"מאפיינים": {
שם ",
"לא עצור": לא נכון,
"מחכה": לא נכון
}
}
התגובה מחזירה סטטוס "אישור".
If אין עצירה הוא True (ברירת מחדל: False), התהליכים עבור הצופה לא ייעצרו -
במקום זאת, הצופה פשוט יישכח על ידי הקרקס ותהליכי הצופה יהיו
אחראים לעצירת עצמם. אם אין עצירה לא צוין או שקר, אז ה-
תהליכי הצופה ייעצרו בצורה חלקה.
If המתנה הוא False (ברירת מחדל), הקריאה תחזור מיד לאחר תחילת ההסרה
ולעצור את הצופה המתאים.
If המתנה אם הערך True הוא נכון, הקריאה תחזור רק כאשר תהליך ההסרה והעצירה יבוצע
הסתיים לחלוטין. בגלל האפשרות graceful_timeout, זה יכול לקחת קצת זמן.
פיקוד קו
$ circusctl rm [--מחכה] [--אין עצירה]
אפשרויות
· שם הצופה להסרה
· nostop: אל תעצור את תהליכי הצופה, פשוט הסר את הצופה
לקבוע a צוֹפֶה אוֹפְּצִיָה
ZMQ הערות נוספות
{
"פקודה": "הגדר",
"מאפיינים": {
"שם": "שם הצופה",
אפשרויות
"מפתח1": "ערך1",
..
}
"מחכה": לא נכון
}
}
התגובה מחזירה את הסטטוס "אישור". עיין בפקודה "אפשרויות" לקבלת רשימה של מפתחות להגדרה.
פיקוד קו
סט $ circusctl --הַמתָנָה
שילחו a אוֹת
פקודה זו מאפשרת לך לשלוח אות לכל התהליכים בצופה, תהליך ספציפי
בצופה או בילדיו.
ZMQ הערות נוספות
כדי לשלוח אות לכל התהליכים עבור צופה:
{
"פקודה": "אות",
"נכס": {
"שֵׁם": ,
"סימן":
}
כדי לשלוח אות לתהליך:
{
"פקודה": "אות",
"נכס": {
"שֵׁם": ,
"pid": ,
"סימן":
}
ניתן להשתמש במאפיין אופציונלי "ילדים" כדי לשלוח את האות לכל הילדים במקום
מאשר התהליך עצמו:
{
"פקודה": "אות",
"נכס": {
"שֵׁם": ,
"pid": ,
"סימן": ,
"ילדים": נכון
}
כדי לשלוח אות לתהליך בן:
{
"פקודה": "אות",
"נכס": {
"שֵׁם": ,
"pid": ,
"סימן": ,
"pid_ילד": ,
}
ניתן גם לשלוח אות לכל ילדי הצופה:
{
"פקודה": "אות",
"נכס": {
"שֵׁם": ,
"סימן": ,
"ילדים": נכון
}
לבסוף, ניתן לשלוח אות לתהליך ו ילדיה, עם ה- רקורסיבית אפשרות:
{
"פקודה": "אות",
"נכס": {
"שֵׁם": ,
"סימן": ,
"רקורסיבי": נכון
}
פיקוד קו
אות $ circusctl [ ] [--ילדים]
[--רקורסיבי]
אפשרויות:
· שם הצופה
· : מספר שלם, מזהה התהליך.
· מספר האות (או השם) שיש לשלוח.
· : ילד, אם בכלל
· בוליאני, שלח את האות לכל הילדים
· : בוליאני, שולח את האות לתהליך ולצאצאיו
הַתחָלָה מה היא פוסק or a צוֹפֶה
פקודה זו מפעילה את כל התהליכים בצופה או בכל הצופים.
ZMQ הערות נוספות
{
"פקודה": "התחל",
"מאפיינים": {
שם ",
"מחכה": לא נכון,
"התאמה": "[פשוט|גלוב|ביטוי רגולרי]"
}
}
התגובה מחזירה את הסטטוס "אישור".
אם שם המאפיין קיים, הצופה יופעל.
If המתנה הוא False (ברירת מחדל), השיחה תחזור מיד לאחר השיחה התחלה on
כל תהליך.
If המתנה אם הפעולה היא True, הקריאה תחזור רק כאשר תהליך ההתחלה יסתיים לחלוטין.
בגלל האפשרות graceful_timeout, זה יכול לקחת קצת זמן.
השמיים להתאים הפרמטר יכול לקבל את הערך פשוט עבור השוואת מחרוזות, גוש עבור תווים כלליים
התאמה (ברירת מחדל) או regex עבור התאמת ביטויים רגולריים.
פיקוד קו
הפעלה מחדש של circusctl [שם] [--מחכה] [--התאמה=simple|glob|ביטוי רגולרי]
אפשרויות
· שם או דפוס של הצופה/ים
· שיטת התאמה של צופה
לקבל תהליך infos
ניתן לקבל בכל עת נתונים סטטיסטיים על התהליכים שלך בעזרת הפקודה stat.
ZMQ הערות נוספות
כדי לקבל סטטיסטיקות עבור כל הצופים:
{
"פקודה": "סטטיסטיקות"
}
כדי לקבל סטטיסטיקות עבור צופה:
{
"פקודה": "סטטיסטיקות",
"מאפיינים": {
"שֵׁם":
}
}
כדי לקבל סטטיסטיקות עבור תהליך:
{
"פקודה": "סטטיסטיקות",
"מאפיינים": {
"שֵׁם": ,
"תַהֲלִיך":
}
}
ניתן להרחיב סטטיסטיקות בעזרת הוו extended_stats, אך יש צורך להרחיב סטטיסטיקות מורחבות.
מבוקש:
{
"פקודה": "סטטיסטיקות",
"מאפיינים": {
"שֵׁם": ,
"תַהֲלִיך": ,
"מורחב": נכון
}
}
התגובה מחזירה אובייקט לכל תהליך כאשר המאפיין "info" מכיל תהליך כלשהו
מידע:
{
מידע
"ילדים": [],
"cmdline": "פיתון",
מעבד: 0.1
"ctime": "0:00.41",
"זיכרון": 0.1,
"mem_info1": "3M",
"mem_info2": "2G",
"נחמד": 0,
"pid": 47864,
"שם משתמש": "שורש"
},
"תהליך": 5,
"status": "בסדר",
"זמן": 1332265655.897085
}
פיקוד קו
סטטיסטיקות $ circusctl [--extended] [ ] [ ]
לקבל מה היא מצב of a צוֹפֶה or את כל צופים
פקודה זו מתחילה לקבל את הסטטוס של צופה או של כל הצופים.
ZMQ הערות נוספות
{
"פקודה": "מצב",
"מאפיינים": {
שם ",
}
}
התגובה מחזירה את הסטטוס "פעיל" או "נעצר" או את הסטטוס / watchers.
פיקוד קו
סטטוס $ circusctl [ ]
אפשרויות
· שם הצופה
דוגמה
דמה סטטוס של $ circusctl
פעיל
סטטוס $ circusctl
דמה: פעיל
dummy2: פעיל
מקלט: פעיל
עצור צופים
פקודה זו עוצרת צופה נתון או את כל הצופים.
ZMQ הערות נוספות
{
"פקודה": "עצור",
"מאפיינים": {
שם ",
"מחכה": לא נכון,
"התאמה": "[פשוט|גלוב|ביטוי רגולרי]"
}
}
התגובה מחזירה את הסטטוס "אישור".
אם שם אם הנכס קיים, אזי העצירה תחול על הצופה
התואם לשם זה. אחרת, כל הצופים ייעצרו.
If המתנה הוא False (ברירת מחדל), השיחה תחזור מיד לאחר השיחה אות עצירה
על כל תהליך.
If המתנה אם זה נכון, הקריאה תחזור רק כאשר תהליך העצירה יסתיים לחלוטין.
בגלל האפשרות graceful_timeout, זה יכול לקחת קצת זמן.
השמיים להתאים הפרמטר יכול לקבל את הערך פשוט עבור השוואת מחרוזות, גוש עבור תווים כלליים
התאמה (ברירת מחדל) או regex עבור התאמת ביטויים רגולריים.
פיקוד קו
$ circusctl stop [שם] [--מחכה] [--התאמה=simple|glob|ביטוי רגולרי]
אפשרויות
· שם או דפוס של הצופה/ים
· שיטת התאמה של צופה
CLI כלים
קרקס-טופ
קרקס-טופ זוהי קונסולה דמוית-על שתוכלו להפעיל כדי לצפות בשידור חי במערכת Circus שלכם.
יציג את המעבד, ניצול הזיכרון ותפקודי ה-socket אם יש לך כאלה.
דוגמה לפלט:
-------------------------------------------------- ---------------------
סטטיסטיקות circusd
מעבד PID (%) זיכרון (%)
14252
0.8 (ממוצע) 0.4 (סכום)
דמה
מעבד PID (%) זיכרון (%)
14257
14256
14258
14260
14259
74.32 (ממוצע) 0.5 (סכום)
-------------------------------------------------- --------------------
קרקס-טופ הוא קונסולה לקריאה בלבד. אם ברצונך לקיים אינטראקציה עם המערכת, השתמש ב- סירקוסקטל.
סירקוסקטל
סירקוסקטל ניתן להשתמש בו כדי להפעיל כל פקודה המופיעה בפקודות. לדוגמה, ניתן לקבל
רשימה של כל הצופים, אתה יכול לעשות
רשימת $ circusctl
מלבד תמיכה במספר אפשרויות, ניתן גם לציין את נקודת הקצה סירקוסקטל צריך
להשתמש באמצעות ה- CIRCUSCTL_ENDPOINT משתנה הסביבה.
השמיים אינטרנט קונסול
סירקוס מגיע עם קונסולת אינטרנט שניתן להשתמש בה לניהול המערכת.
קונסולת האינטרנט מאפשרת לך:
· התחבר לכל מערכת Circus פעילה
· צפה בזמן אמת בשימוש במעבד ובזיכרון של התהליכים
· הוספה או הסרה של תהליכים
· הוספת צופים חדשים
הערה:
תכונת השימוש במעבד ובזיכרון בזמן אמת משתמשת בשקע הסטטיסטיקות. אם ברצונך
הפעל אותו, ודא שמערכת הקרקס שאליה תתחבר כוללת את נקודות הסטטיסטיקה.
מופעל בתצורה שלו:
[קרקס]
סטטיסטיקה = אמת
כברירת מחדל, אפשרות זו אינה מופעלת.
קונסולת האינטרנט היא חבילה בפני עצמה, עליך להתקין:
$ pip install circus-web
כדי להפעיל את הקונסולה, הוסף מספר אפשרויות בקובץ ה-ini של Circus:
[קרקס]
httpd = אמת
httpd_host = localhost
httpd_port = 8080
httpd_host ו httpd_port הם אופציונליים, וברירת המחדל היא localhost ו 8080.
אם אתם רוצים להפעיל את אפליקציית האינטרנט בפני עצמה, פשוט הפעילו את קרקסhttpd תַסרִיט:
$ circushttpd
שרת הבקבוקים מתחיל לפעול...
האזנה ממשיכה http://localhost: 8080 /
לחץ על Ctrl-C כדי לצאת.
כברירת מחדל, הסקריפט יפעיל את קונסולת האינטרנט בפורט 8080, אך האפשרות --port יכולה להיות
נהג לשנות את זה.
שימוש מה היא לנחם
לאחר שהסקריפט פועל, ניתן לפתוח דפדפן ולבקר באתר http://localhost: 8080. אתה
אמור לקבל את המסך הזה: [תמונה]
קונסולת האינטרנט מוכנה לחיבור למערכת Circus, בהתחשב בכך נקודת סיום. על ידי
ברירת המחדל של נקודת הקצה היא tcp://127.0.0.1:5555.
ברגע שאתה מכה לְחַבֵּר, אפליקציית האינטרנט תתחבר למערכת Circus.
לאחר כניסה למסוף האינטרנט, עליך לקבל רשימה של צופים וסטטוס בזמן אמת.
של שני תהליכי Circus (circusd ו-circusd-stats).
ניתן ללחוץ על הסטטוס של כל צופה כדי להחליף אותו בין Active (ירוק) אל לא פעיל
(אדום). שינוי זה נכנס לתוקף באופן מיידי ומאפשר לך להפעיל ולהפסיק את הצפייה.
אם תלחצו על שם הצופה, תקבלו דף אינטרנט עבור אותו צופה ספציפי,
עם התהליכים שלו:
במסך זה, ניתן להוסיף או להסיר תהליכים, ולסגור תהליכים קיימים.
אחרון חביב, ניתן להוסיף צופה חדש על ידי לחיצה על להוסיף צופה קישור פנימה
התפריט השמאלי: .SS פועל מאחורי Nginx
Nginx יכול לשמש כפרוקסי וכשכבת אבטחה מול circus-web.
הערה:
כדי לקבל עדכוני סטטוס וגרפים בזמן אמת ב-circus-web, עליך לספק Nginx
פתרון פרוקסי עם תמיכה ב-WebSocket
nginx >= 1.3.13
החל מ-Nginx>=1.3.13 תמיכה ב-websocket מובנית, כך שאין צורך לשלב את Nginx
עם Varnish או HAProxy. דוגמה לקונפיגורציית Nginx עם תמיכה ב-websocket:
שרת_web_circus_upstream {
שרת 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;
}
מיקום ~/מדיה/\*(.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 עם Varnish או HAProxy. כלומר, Nginx מול circus-web, עם Varnish או
HAProxy מול Nginx.
הדוגמה שלהלן מציגה את תצורת Nginix ו-Varnish המשולבת הנדרשת לשרת proxy
circus-web ומספקים תמיכה ב-websocket.
nginx Definitive
שרת_web_circus_upstream {
שרת 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;
}
מיקום ~/מדיה/\*(.png|.jpg|.css|.js|.ico)$ {
כינוי /path_to_site-packages/circusweb/media/;
}
}
אם ברצונך לקבל אפשרויות תצורה נוספות של Nginx, ראה http://wiki.nginx.org/HttpProxyModule.
ורנית Definitive
ברירת מחדל של backend {
.host = "127.0.0.1";
.port = "8001";
}
שקע אחורי {
.host = "127.0.0.1";
.port = "8080";
.connect_timeout = 1 שניות;
.first_byte_timeout = 2 שניות;
.between_bytes_timeout = 60 שניות;
}
תת vcl_pipe {
אם (req.http.upgrade) {
הגדר bereq.http.upgrade = req.http.upgrade;
}
}
תת vcl_recv {
אם (req.http.Upgrade ~ "(?i)websocket") {
הגדר req.backend = socket;
חזרה (צינור);
}
}
בדוגמת תצורת Varnish לעיל מוגדרים שני שרתים אחוריים. אחד משרת את האינטרנט
קונסולה אחת המשרתת את חיבורי השקע. בקשות קונסולת אינטרנט קשורות לפורט
8001. יש להגדיר את הוראת ה-'server' של Nginx להאזין בפורט 8001.
חיבורי Websocket משודרגים ומועברים ישירות לתהליך circushttpd שמאזין
בפורט 8080 על ידי Varnish. כלומר עוקף את ה-proxy של 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
הגנה באמצעות סיסמה קרקסhttpd
כפי שהוסבר בדף האבטחה, הפעלה קרקסhttpd די לא בטוח. אנחנו לא מספקים
כל אבטחה ב-Circus עצמו, אבל אתה יכול להגן על הקונסולה שלך ברמת 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: $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 של אפאצ'י כדי לערוך אותו, או בסקריפט הפייתון שהם מספקים בכתובת:
http://trac.edgewall.org/browser/trunk/contrib/htpasswd.py
עם זאת, אין תמיכה מקורית לשימוש משולב של אימות HTTP ו-
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: $http_host;
proxy_set_header X-Forwarded-Proto: $scheme;
proxy_redirect off;
proxy_pass http://127.0.0.1:8080;
}
כמובן שזו רק דרך אחת להגן על קונסולת האינטרנט שלך, אתה יכול להשתמש בהרבה דרכים אחרות
טכניקות.
מאריך מה היא אינטרנט לנחם
בחרנו בקבוק לבנות את קונסולת האינטרנט, בעיקר משום שזוהי מסגרת ממש זעירה ש
לא עושה הרבה. על ידי התבוננות בקוד של קונסולת האינטרנט, תגלו בסופו של דבר
שזה ממש פשוט להבנה.
כך זה מחולק:
· circushttpd.py הקובץ מכיל את הגדרות ה"views" וקוד מסוים לטיפול ב-
חיבור שקע (דרך socketio).
· ה controller.py מכיל מחלקה אחת שאחראית על ביצוע התקשורת
עם בקר ה-Circus. זה מאפשר API ברמה גבוהה יותר בעת הגדרת ה-
שרת אינטרנט.
אם ברצונך להוסיף תכונה בקונסולת האינטרנט, תוכל לעשות שימוש חוזר בקוד הקיים.
מספר כלים עומדים לרשותכם כדי להקל על התהליך:
· יש לדקלם פונקציה, אשר מקבלת את הארגומנטים בעלי השם שאתה מעביר אליה ו
להעביר אותם למעבד התבנית ולהחזיר את ה-HTML שנוצר. זה גם מעביר כמה
משתנים נוספים, כגון הסשן, גרסת הקרקס והלקוח אם מוגדר.
· אם ברצונך להריץ פקודות ולבצע ניתוב מחדש בהתאם לתוצאה שלהן, תוכל להשתמש
מה היא run_command פונקציה, אשר מקבלת ארגומנט ראשון שניתן לקריאה, הודעה במקרה
של הצלחה וכתובת URL להפניה מחדש.
השמיים מרחב שמות סטטיסטי המחלקה אחראית על ניהול תקשורת ה-websocket ב-
צד השרת. התיעוד שלו אמור לעזור לך להבין מה הוא עושה.
עבודה עם ארובות
Circus יכול לקשור שקעי רשת ולנהל אותם כפי שהוא עושה עבור תהליכים.
הרעיון המרכזי הוא תהליך בן שנוצר על ידי Circus כדי להפעיל את אחד מתהליך הצופה.
הפקודה יכולה לרשת את כל תיאורי הקבצים הפתוחים.
כך עובדים אפאצ'י או יוניקורן, ועוד הרבה כלים אחרים שקיימים.
מטרה
המטרה של ניהול שקעים על ידי Circus היא להיות מסוגל לנהל יישומי רשת
ב-Circus בדיוק כמו אפליקציות אחרות.
לדוגמה, אם אתם משתמשים ב-Circus עם גֶרֶב -- שרת WGSI, אתה יכול לקבל מהיר מאוד
הפעלה וניהול של שרת אינטרנט "אינטרנט עובדים בקרקס כמו שהיית עושה לכל מקום אחר
התהליך.
פיצול ניהול השקעים מיישום הרשת עצמו מציע הרבה יתרונות
הזדמנויות להרחבה ולניהול המחסנית שלך.
עיצוב
תמצית התכונה נעשית על ידי קשירת השקע והתחלת האזנה אליו ב
קרקסד:
שקע יבוא
גרב = socket.socket(משפחה, סוג)
גרב.bind((מארח, פורט))
sock.listen(BACKLOG)
fd = sock.filenummer()
לאחר מכן, Circus עוקב אחר כל ה-fds שנפתחו, ומאפשר לתהליכים שהוא פועל כצאצאים.
שיהיה להם גישה אליהם אם הם רוצים.
אם תיצרו סקריפט רשת קטן של פייתון שאתם מתכוונים להריץ ב-Circus, הוא יוכל...
נראה כמו זה:
שקע יבוא
ייבוא
fd = int(sys.argv[1]) # קבלת ה-FD מ-circus
גרב = socket.fromfd(fd, משפחה, סוג)
# טיפול בבקשה אחת בכל פעם
בעוד נכון:
חיבור, כתובת = גרב.accept()
בקשה = חיבור קבלה(1024)
.. תעשה משהו ..
conn.sendall (תגובה)
conn.close()
אז סירקוס יכול לרוץ ככה:
[קרקס]
עיכוב_בדיקה = 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 = נכון
עיכוב_חימום = 0
מספר תהליכים = 5
[שקע:foo]
מארח = 127.0.0.1
יציאה = 8888
$(circus.sockets.foo) יוחלף בערך ה-FD לאחר יצירת ה-socket ו-
קשור על 8888 נמל.
הערה:
החל מ-Circus 0.8 יש תחביר חלופי כדי למנוע התנגשויות עם חלק מה...
מנתחי הגדרות. ניתן לכתוב:
((circus.sockets.foo))
עולם אמיתי דוגמה
גֶרֶב הוא בן הלוויה המושלם של Circus אם ברצונך להריץ את יישום 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 או
ה-backend של Meinheld מהיר כמו כל שרת WSGI pre-fork שקיים.
שימוש מובנה תוספים
סירקוס מגיע עם כמה תוספים מובנים. סעיף זה מציג את התוספים הללו ואת תכונותיהם.
אפשרויות תצורה.
סטטיסטיקה
להשתמש מוגדר ל'circus.plugins.statsd.StatsdEmitter'
שם אפליקציה
השם המשמש לזיהוי קידומת הדלי שאליה יש לשלוח את הנתונים הסטטיסטיים (זה יהיה
עם קידומת קרקס. ומסופקת עם .צוֹפֶה)
המארח המארח שאליו יפורסמו נתוני הסטטיסטיקות
נמל הפורט שדמון ה-statsd מאזין לו
קצב דגימה
אם אתה מעדיף קצב דגימה שונה מ-1, תוכל להגדיר אותו כאן.
סטטיסטיקות מלאות
הרחבה בתוסף Statsd שגם מפרסמת את סטטיסטיקות התהליך. ככזו היא
יש את אותן אפשרויות תצורה כמו Statsd והבאים.
להשתמש מכוון ל circus.plugins.statsd.FullStats
קצב_לולאה
התדירות שבה התוסף צריך לבקש את הסטטיסטיקות בשניות. ברירת מחדל: 60.
RedisObserver
שירות זה של משקיפים מבצע תהליך הערכה מחדש עבורך, מפרסם את המידע ל-statsd
ומציע להפעיל מחדש את הצופה כאשר הוא לא מגיב במסגרת זמן קצוב נתון. תוסף זה
דורש redis-py לרוץ.
יש לו את אותה תצורה כמו statsd והוא מוסיף את הדברים הבאים:
להשתמש מכוון ל circus.plugins.redis_observer.RedisObserver
קצב_לולאה
התדירות שבה התוסף צריך לבקש את הסטטיסטיקות בשניות. ברירת מחדל: 60.
redis_url
מסד הנתונים שיש לבדוק ככתובת URL של redis. ברירת מחדל: "redis://localhost:6379/0"
פסק זמן
הזמן הקצוב בשניות שהבקשה יכולה לקחת לפני שהיא נחשבת מושבתת.
ברירת המחדל היא 5.
הפעלה_בזמן_קצוב
שם התהליך שיש להפעיל מחדש כאשר תם הזמן הקצוב לבקשה. אין צורך בהפעלה מחדש.
מופעל כאשר לא ניתן. ברירת מחדל: ללא.
HttpObserver
שירות זה מבצע עבורך תהליך http על ידי פינג (pinging) לאתר אינטרנט מסוים באופן קבוע.
בדומה ל-redis observer, הוא מציע להפעיל מחדש את ה-watcher במקרה של שגיאה. זה דורש
טורנדו לרוץ.
יש לו את אותה תצורה כמו statsd והוא מוסיף את הדברים הבאים:
להשתמש מכוון ל circus.plugins.http_observer.HttpObserver
קצב_לולאה
התדירות שבה התוסף צריך לבקש את הסטטיסטיקות בשניות. ברירת מחדל: 60.
check_url
כתובת האתר לבדיקה. ברירת מחדל: http://localhost/
פסק זמן
הזמן הקצוב בשניות שהבקשה יכולה לקחת לפני שהיא נחשבת מושבתת.
ברירת המחדל היא 10.
הפעלה_ב_שגיאה
שם התהליך שיש להפעיל מחדש כאשר הבקשה תם בזמן הקצוב או החזירה כלשהו
שגיאה מסוג אחר. לא מופעל הפעלה מחדש כאשר לא ניתן. ברירת מחדל: ללא.
משאב צופה
שירות זה עוקב אחר משאבי התהליך הנתון ומפעיל הפעלה מחדש כאשר
הם חורגים ממגבלות מסוימות לעתים קרובות מדי ברציפות.
יש לו את אותה תצורה כמו statsd והוא מוסיף את הדברים הבאים:
להשתמש מכוון ל circus.plugins.resource_watcher.ResourceWatcher
קצב_לולאה
התדירות שבה התוסף צריך לבקש את הסטטיסטיקות בשניות. ברירת מחדל: 60.
צוֹפֶה
הצופה שצופה המשאבים הזה צריך להשגיח עליו. (נקרא בעבר
שרות אבל שרות הוצא משימוש כעת)
מעבד מקסימלי
המעבד המרבי שתהליך אחד מותר לצרוך (באחוזים). ברירת מחדל: 90
מעבד_מינימלי
המעבד המינימלי שתהליך אחד צריך לצרוך (באחוזים). ברירת מחדל: ללא (אין מינימום)
ניתן להגדיר את ה-min_cpu ל-0 (אפס), במקרה זה אם תהליך אחד צורך בדיוק
0% מעבד, זה יגרום לחריגה ממגבלה.
max_mem
כמות הזיכרון שתהליך אחד של צופה זה רשאי לצרוך. ברירת מחדל:
90. אם לא צוינה יחידה, הערך הוא ב-%. דוגמה: 50 אם יחידה מסוימת
אם צוין, הערך הוא בבתים. היחידות הנתמכות הן B, K, M, G, T, P, E, Z, Y.
דוגמה: 250 מיליון
דקות_זיכרון
הזיכרון המינימלי שתהליך אחד של צופה זה צריך לצרוך. ברירת מחדל: ללא (לא
מינימום). אם לא צוינה יחידה, הערך הוא ב-%. דוגמה: 50 אם יחידה היא
אם צוין, הערך הוא בבתים. היחידות הנתמכות הן B, K, M, G, T, P, E, Z, Y.
דוגמה: 250 מיליון
סף_בריאות
הבריאות היא ממוצע המעבד והזיכרון (באחוזים) של תהליכי המעקב.
מותר לצרוך (באחוזים). ברירת מחדל: 75
max_count
באיזו תדירות מותר להשתמש במגבלות אלו (כל אחת מהן נספרת בנפרד)
חריגה ממה שנדרש לפני שיופעל הפעלה מחדש. ברירת מחדל: 3
דוגמא:
[קרקס]
; ...
[צופה:תוכנית]
cmd = שינה 120
[plugin:myplugin]
שימוש = circus.plugins.resource_watcher.ResourceWatcher
צופה = תוכנית
מעבד_מינימלי = 10
מעבד מקסימלי = 70
מינימום_זיכרון = 0
max_mem = 20
כלב שמירה
תוסף שקושר שקע UDP וממתין להודעות Watchdog. עבור "watchdoged"
תהליכים, כלב השמירה יהרוג אותם אם הם לא ישלחו פעימת לב בנקודה מסוימת
פרק זמן שהתממש על ידי loop_rate * max_count. (הקרקס יפעל אוטומטית
הפעל מחדש את התהליכים החסרים ב-watcher)
כל תהליך מנוטר צריך לשלוח הודעת udp לפחות בקצב הלולאה. ה-udp
פורמט הודעה הוא שורת טקסט, המפוענחת באמצעות msg_regex פרמטר. פעימת הלב
ההודעה חייבת להכיל לפחות את ה-pid של התהליך ששולח את ההודעה.
רשימת הצופים המנוטרים נקבעת על ידי הפרמטר צופים_רגקס ב
תצורה.
פרמטרי תצורה:
להשתמש מכוון ל circus.plugins.watchdog.WatchDog
קצב_לולאה
קצב לולאת watchdog בשניות. בכל לולאה, WatchDog יחפש אחר "מתים".
תהליכים.
צופים_רגקס
ביטוי רגולרי (regex) להתאמה של שמות צופים שאמורים להיות מנוטרים על ידי כלב השמירה
(בְּרִירַת מֶחדָל: .* כל הצופים נמצאים תחת פיקוח)
msg_regex
ביטוי רגולרי לפענוח הודעת פעימות הלב שהתקבלה ב-udp (ברירת מחדל:
^(?P .*);(?P .*)$) פורמט ברירת המחדל הוא הודעת טקסט פשוטה:
pid; חותמת זמן
max_count
מספר מקסימלי של לולאות שעברו ללא קבלת פעימת לב לפני הפעלה מחדש
תהליך (ברירת מחדל: 3)
ip ה-IP שאליו יקשר כלב השמירה (ברירת מחדל: 127.0.0.1)
נמל הפורט שאליו יקשר כלב השמירה (ברירת מחדל: 1664)
מתנפנף
כאשר עובד מופעל מחדש לעתים קרובות מדי, אנו אומרים שזה מתנפנפיםתוסף זה עוקב אחר
של העובד מפעיל מחדש ועוצר את הצופה המתאים במקרה שהוא מתנפנף. זה
ניתן להשתמש בתוסף כדי לעצור אוטומטית עובדים המופעלים מחדש כל הזמן מכיוון
הם לא עובדים כמו שצריך.
להשתמש מכוון ל circus.plugins.flapping.Flapping
ניסיונות
מספר הפעמים שתהליך יכול להפעיל מחדש, בתוך חלון שניות, לפני שאנחנו
חשבו על זה כמתנפנפת (ברירת מחדל: 2)
חלון חלון הזמן בשניות לבדיקת רפרוף. אם התהליך יופעל מחדש יותר
מֵאֲשֶׁר ניסיונות פעמים בתוך חלון זמן זה, אנו רואים זאת כתהליך מתנפנפים.
(ברירת מחדל: 1)
נסה_שוב_ב
זמן ההמתנה בשניות עד שננסה להתחיל שוב תהליך שכבר היה
מתנפנפים. (ברירת מחדל: 7)
max_retry
מספר הפעמים שאנו מנסים להתחיל תהליך שמתנדנד, לפני
אנו נוטשים ועוצרים את כל הצופה. (ברירת מחדל: 5) הגדר ל-1- כדי להשבית
max_retry ונסה שוב ללא הגבלת זמן.
פעיל הגדר אם התוסף פעיל או לא (ברירת מחדל: אמת). אם הדגל הגלובלי הוא
מוגדר כ-False, התוסף לא הופעל.
ניתן לעקוף אפשרויות במקטע הצופה באמצעות מתנופפת. קידומת. לדוגמה,
כך תגדיר פונקציה ספציפית max_retry ערך עבור nginx:
[צופה:nginx]
cmd = /נתיב/אל/nginx
flapping.max_retry = 2
[צופה:myscript]
cmd = ./my_script.py
...צופים אחרים
[תוסף:flapping]
שימוש = circus.plugins.flapping.Flapping
max_retry = 5
טוען מחדש של פקודות
תוסף זה יפעיל מחדש את הצופים כאשר קובץ הפקודות שלהם ישונה. הוא פועל על ידי
בדיקת זמן השינוי ונתיב הקובץ עליו מצביע ה- cmd אפשרות כל
קצב_לולאה שניות. זה עשוי להיות שימושי בעת פיתוח תהליכי עבודה או אפילו עבור תהליכים חמים
שדרוג קוד בסביבת הייצור.
להשתמש מכוון ל circus.plugins.command_reloader.CommandReloader
קצב_לולאה
התדירות שעל התוסף לבדוק שינויים בשניות. ברירת מחדל: 1.
פְּרִיסָה
למרות שניתן לנהל את הדמון של Circus באמצעות הפקודה 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 reload
ExecStart=/usr/bin/circusd /etc/circus/circus.ini
הפעל מחדש = תמיד
הפעלה מחדש שניה=5
[להתקין]
WantedBy=default.target
אתחול מחדש אינו נדרש אם תפעילו את הפקודה daemon-reload שלהלן:
# systemctl --טעינת-העלאה של daemon-המערכת
לאחר מכן ניתן לנהל את הקרקס באמצעות:
# systemctl start/stop/status/reload circus
מתכונים
מדור זה יכיל מתכונים לפריסת קרקס. עד אז תוכלו להסתכל על פיט'ס
בּוּבָּה מתכון או אצל רמי שֶׁף מתכון
אפיפיור התַהֲלִיך גַרעִין
בעיה נפוצה אחת בקרב מנהלי תהליכים היא שלא ניתן להפעיל מחדש את מנהל התהליכים
מבלי להפעיל מחדש את כל התהליכים שהוא מנהל. זה מקשה על פריסת
גרסה חדשה של Circus או גרסאות חדשות של כל אחת מהספריות עליהן הוא תלוי.
אם אתם משתמשים במערכת מסוג יוניקס, Circus יכול להשתמש בליבת התהליך Papa. כאשר הוא משמש, Papa
ייצור דמון ארוך חיים שישמש כמארח עבור כל התהליכים והשקעים
אתה יוצר איתו. אם הקרקס ייסגר, אבא יתחזק את כל מה שהוא מארח.
התקנה
התחל בהתקנת ה אבא ו הגדר כותרת של פרוקט מודולים:
פיפ מתקין פאפא
התקנת pip setproctitle
השמיים הגדר כותרת של פרוקט מודול הוא אופציונלי. הוא ישמש אם קיים כדי לשנות את שם הדמון של פאפא
ל חלק עליון ו ps למשהו כמו "פאפא דמון מ-circusd". אם לא תתקין את
הגדר כותרת של פרוקט מודול, כותרת זו תהיה שורת הפקודה של התהליך שהפעיל אותו.
מאוד מבלבל.
לאחר התקנת פאפא, הוסף use_papa=true לתהליכים ולשקעים הקריטיים שלך.
באופן כללי אתה רוצה לאחסן את כל התהליכים של המחסנית שלך בפאפא, ואף אחד מהם לא
תהליכי תמיכה של Circus כגון תוספי flapping וסטטיסטיקות.
[קרקס]
loglevel = מידע
[צופה:nginx]
cmd = /usr/local/nginx/sbin/nginx -p /Users/scottmax/Source/service-framework/Common/conf/nginx -c /Users/scottmax/Source/service-framework/Common/conf/nginx/nginx.conf
עיכוב_חימום = 3
פסק זמן גרצי = 10
max_retry = 5
סינגלטון = נכון
send_hup = true
אות_עצירה = יציאה
stdout_stream.class = זרם קבצים
stdout_stream.filename = /var/logs/web-server.log
stdout_stream.max_bytes = 10000000
stdout_stream.backup_count = 10
stderr_stream.class = זרם קבצים
שם הקובץ stderr_stream. = /var/logs/web-server-error.log
stderr_stream.max_bytes = 1000000
stderr_stream.backup_count = 10
פעיל = נכון
use_papa = true
[צופה:לוגר]
cmd = /my_service/env/bin/python logger.py הפעלה
working_dir = /my_service
פסק זמן גרצי = 10
סינגלטון = נכון
אות_עצירה = INT
stdout_stream.class = זרם קבצים
שם קובץ stdout_stream.filename = /var/logs/logger.log
stdout_stream.max_bytes = 10000000
stdout_stream.backup_count = 10
stderr_stream.class = זרם קבצים
שם קובץ stderr_stream.filename = /var/logs/logger.log
stderr_stream.max_bytes = 1000000
stderr_stream.backup_count = 10
עדיפות = 50
use_papa = true
[צופה:אפליקציית_אינטרנט]
cmd = /my_service/env/bin/uwsgi --ini uwsgi-live.ini --socket fd://$(circus.sockets.web) --stats 127.0.0.1:809$(circus.wid)
תיקיית_עבודה = /השירות_שלי/אפליקציית_אינטרנט
פסק זמן graceful_timeout=10
אות_עצירה = יציאה
use_sockets = נכון
stdout_stream.class = זרם קבצים
שם קובץ stdout_stream.filename = /var/logs/web_app.log
stdout_stream.max_bytes = 10000000
stdout_stream.backup_count = 10
stderr_stream.class = זרם קבצים
שם הקובץ stderr_stream. = /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 = true
[socket:web]
נתיב = /my_service/sock/uwsgi
use_papa = true
[תוסף:flapping]
שימוש = circus.plugins.flapping.Flapping
חלון = 10
עדיפות = 1000
הערה:
אם תהליכי Papa משתמשים ב-sockets כלשהם, גם sockets אלה חייבים להשתמש ב-papa.
עיצוב מטרה
פאפא תוכנן להיות מינימליסטי מאוד מבחינת תכונות ודרישות. הוא עושה:
· שקעי הפעלה ועצירה
· לספק מאגר מפתחות/ערכים
· הפעלת תהליכים והחזרת stdout, stderr וקוד היציאה
זה לא:
· הפעלה מחדש של תהליכים
· לספק דרך לעצור תהליכים
· ספקו כל מידע על תהליכים מלבד האם הם עדיין פועלים או לא
פאפא אינו דורש ספריות של צד שלישי ולכן הוא יכול לפעול רק על ספריית פייתון הסטנדרטית.
זה יכול לעשות שימוש ב- הגדר כותרת של פרוקט חבילה אבל זו משמשת רק ליצירת הכותרת
יפה יותר עבור ps ו חלק עליון ואינו חיוני.
הפונקציונליות נשמרה למינימום כך שלעולם לא תצטרכו להפעיל מחדש את
פאפא דמון. כמה שיותר מהפונקציונליות נדחפה לספריית הלקוח כמו
אפשרי. כך תוכל לפרוס עותק חדש של Papa עבור תכונות לקוח חדשות.
בלי צורך להפעיל מחדש את הדמון של פאפא. פאפא נועד להיות עמוד תווך של יציבות ב
ים משתנה של ספריות של צד שלישי.
פעולה
רוב הדברים נשארים ללא שינוי בין אם אתם משתמשים בפאפא ובין אם לאו. אתם עדיין יכולים להתחיל ולהפסיק.
תהליכים. עדיין ניתן לקבל סטטוס וסטטיסטיקות עבור תהליכים. הדבר העיקרי שמשתנה
האם זה כאשר אתה עושה סירקוסקטל להפסיק, כל תהליכי הפאפא נשארים פועלים. כאשר אתה
התחלה קרקסד גיבוי, תהליכים אלה משוחזרים.
הערה:
כאשר תהליכים מתאוששים, לפני_התחלה ו לפני_השרצה דילגו על ווים.
רישום
בזמן ש-Circus מושבת, Papa יאחסן עד 2 מיליון פלט לכל תהליך. לאחר מכן הוא...
התחל להשליך את הנתונים הישנים ביותר. כאשר תפעיל מחדש את Circus, הפלט המאוחסן במטמון יבוצע במהירות
אוחזר ונשלח לזרמי הפלט. פאפא דורש שקבלת הפלט תהיה
אושר, כך שלא אמורה להיות לך שום פלט במהלך כיבוי.
לא רק זה, אלא שפאפא שומר את חותמת הזמן של הפלט. סירקוס שופר ל...
נצל נתוני חותמות זמן אם קיימים. לכן, אם אתה כותב את הפלט לקבצי יומן
או איפשהו, כל חותמות הזמן שלך אמורות להיות נכונות.
בעיות
אם אתה משתמש תוספת or פסק דין פקודה לשינוי ספירת התהליכים עבור צופה, פעולה זו תעשה זאת
יאופס לרמה שצוינה בקובץ ה-INI כאשר קרקסד מופעל מחדש.
בנוסף, נתקלתי בבעיות בשילוב של copy_env ו וירטואלי. ייתכן
שים לב שדוגמת ה-INI לעיל עוקפת בעיה זו באמצעות נתיבים מפורשים.
Telnet מִמְשָׁק
לפאפא יש ממשק שורת פקודה בסיסי שניתן לגשת אליו דרך טלנט:
20202
לעזור
קרקס ל מפתחים
שימוש קרקס as a ספריה
Circus מספקת מחלקות ופונקציות ברמה גבוהה שיאפשרו לך לנהל תהליכים ב...
היישומים שלכם.
לדוגמה, אם ברצונך להריץ ארבעה תהליכים לנצח, תוכל לכתוב:
מ-circus import get_arbiter
myprogram = {"cmd": "python myprogram.py", "מספר תהליכים": 4}
בורר = get_arbiter([התוכנית שלי])
נסה:
arbiter.start()
סוף סוף:
arbiter.stop()
קטע זה יריץ ארבעה מופעים של התוכנית שלי ולצפות בהם בשבילך, להפעיל אותם מחדש
אם הם ימותו באופן בלתי צפוי.
למידע נוסף על כך, עיינו בספרייה
מאריך קרקס
קל להרחיב את Circus כדי ליצור מערכת מורכבת יותר, על ידי הקשבה לכל ה...
קרקסד אירועים דרך ערוץ pub/sub שלו, והנעתו באמצעות פקודות.
כך פועלת תכונת הפלאפינג, למשל: היא מקשיבה לכל התהליכים הגוססים,
מודד את תדירות זה קורה, ועוצר את הצופים המופללים לאחר יותר מדי הפעלות מחדש
ניסיונות.
סירקוס מגיע עם מערכת תוספים שתעזור לך לכתוב הרחבות כאלה, וכמה תוספים מובנים
תוספים שניתן להשתמש בהם שוב. ראה תוספים.
ניתן גם לקבל התנהגות הפעלה וכיבוי עדינה יותר באמצעות ווים מערכת
שיאפשר לך להריץ קוד שרירותי לפני ואחרי הפעלת תהליכים מסוימים, או
עצר. ראה ווים.
אחרון חביב, ניתן גם להוסיף פקודות חדשות. ראה הוספת cmds.
מפתחים תיעוד מדד
קרקס סִפְרִיָה
חבילת הקרקס מורכבת מרמה גבוהה get_arbiter() פונקציה ומחלקות רבות. ב
ברוב המקרים, שימוש בפונקציה ברמה גבוהה אמור להספיק, מכיוון שהיא יוצרת את כל מה ש
נחוץ כדי שקרקס יפעל.
ניתן להוסיף תת-מחלקות למחלקות של Circus אם אתם זקוקים לפירוט רב יותר ממה שמציע ה-
תצורה.
השמיים get_arbiter פונקציה
get_arbiter() זוהי רק נוחות בנוסף לשיעורי הקרקס השונים. זה יוצר
בורר (מחלקה שוטר) מופע עם האפשרויות שסופקו, אשר בתורו מפעיל יחיד
צופה עם סינגל התַהֲלִיך.
circus.get_arbiter()
דוגמא:
מ-circus import get_arbiter
בורר = get_arbiter([{"cmd": "התוכנית שלי", "מספר תהליכים": 3}])
נסה:
arbiter.start()
סוף סוף:
arbiter.stop()
חוגים
סירקוס מספקת סדרת שיעורים בהם תוכלו להשתמש כדי ליישם מנהל תהליכים משלכם:
· התַהֲלִיך: עוטף תהליך פעיל ומספק כמה עוזרים מעליו.
· צופה: להריץ מספר מופעים של התַהֲלִיך נגד אותה פקודה. לנהל את המוות ו
חיים של תהליכים.
· שוטרמנהלת מספר צופה.
בכיתה circus.process.Process(שם, רחב, cmd, ארגומנטים=אין, working_dir=אין, מעטפת=שקר,
uid=אין, gid=אין, env=אין, rlimits=אין, קובץ הרצה = אין, use_fds=לא נכון, צופה=אין,
spawn=אמת, pipe_stdout=נכון, pipe_stderr=נכון, close_child_stdout=לא נכון,
(close_child_stderr=לא נכון)
עוטף תהליך.
אפשרויות:
· wid: מזהה ייחודי של התהליך. ערך זה ישמש להחלפת ה- רוחב דולר
מחרוזת בשורת הפקודה אם קיימת.
· cmd: הפקודה להפעלה. עשוי להכיל כל אחד מהמשתנים הזמינים שהם
מועברים למחלקה זו. הם יוחלפו באמצעות תחביר פורמט פייתון.
· טוען: הארגומנטים להפעלת הפקודה. יכול להיות רשימה או מחרוזת. אם טוען is
מחרוזת, היא מפוצלת באמצעות shlex.split()ברירת המחדל היא ללא.
· הפעלהכאשר ניתנת קובץ הרצה, הפריט הראשון ברצף הארגומנטים
הושג מ cmd עדיין מטופל על ידי רוב התוכניות כשם הפקודה, אשר
יכול להיות שונה משם הקובץ הניתן להרצה בפועל. הוא הופך לשם התצוגה
שם התוכנית המבצעת בכלי עזר כגון ps.
· תיקיית_עבודה: ספריית העבודה שבה תפעיל את הפקודה. אם לא תסופק,
ברירת מחדל לספריית העבודה הנוכחית.
· פָּגָזאם נָכוֹן, יריץ את הפקודה בסביבת המעטפת. לא נכון כברירת מחדל.
אַזהָרָה: זֶה is a אבטחה סכנה.
· uidאם ניתן, זהו מזהה המשתמש או השם שאיתו הפקודה צריכה לפעול. הנוכחי
uid הוא ברירת המחדל.
· gidאם ניתן, זהו מזהה הקבוצה או השם שאיתו הפקודה צריכה לפעול. הנוכחי
gid הוא ברירת המחדל.
· envמיפוי המכיל את משתני הסביבה שאיתם הפקודה תפעל.
אופציונלי
· rlimitsמיפוי המכיל שמות וערכים של rlimit שיוגדרו לפני ה-
הפקודה פועלת.
· use_fdsאם הערך True, לא ייסגר ה-fds בתהליך המשנה. יש להגדיר אותו ל-
אמת ב-Windows אם stdout או stderr מופנים מחדש. ברירת מחדל: שקר.
· pipe_stdoutאם הערך נכון, ייפתח קובץ PIPE ביציאה stdout. ברירת מחדל: נכון.
· צינור_סטדרר: אם אמת, ייפתח PIPE ב-stderr. ברירת מחדל: אמת.
· סגור_ילד_סטדאואם ערך זה נכון, מפנה מחדש את stdout של תהליך הילד אל /dev/null
אחרי המזלג. ברירת מחדל: שקר.
· סגירת_ילד_סטדרראם ערך זה נכון, מפנה מחדש את stdout של תהליך הילד אל /dev/null
אחרי המזלג. ברירת מחדל: שקר.
גִיל() החזר את גיל התהליך בשניות.
יְלָדִים()
החזרת רשימה של PIDs לילדים.
מידע () מידע על תהליך ההחזרה.
המידע המוחזר הוא מיפוי עם המפתחות הבאים:
· mem_info1גודל זיכרון של סט תושב בבתים (RSS)
· mem_info2גודל זיכרון וירטואלי בבתים (VMS).
· מעבד: אחוז משימוש במעבד.
· מ: אחוז משימוש בזיכרון.
· זמןזמן תהליך המעבד (משתמש + מערכת) בשניות.
· PIDמזהה תהליך.
· שם משתמששם המשתמש שבבעלותו התהליך.
· נחמד: איכות התהליך (בין -20 ל-20)
· קו ס"משורת הפקודה איתה התהליך בוצע.
is_child(pid)
החזרת True היא הנתון PID הוא ילד של תהליך זה.
PID להחזיר את PID
send_signal(*args, **ק"ו)
שולח אות sig לתהליך.
send_signal_child(*args, **ק"ו)
שלח אות חתימה לילד PID.
send_signal_children(*args, **ק"ו)
שלח אות חתימה לכל הילדים.
מצב החזר את סטטוס התהליך כקבוע
· ריצה
· מתים או זומבי
· לא קיים
· אחר
סטדרר להחזיר את stdout זרם
stdout להחזיר את stdout זרם
עצור(*ארגומנטים, **ק"ו)
עצור את התהליך וסגור את stdout/stderr
אם התהליך המתאים עדיין כאן (בדרך כלל הוא כבר נהרג על ידי
הצופה), נשלח SIGTERM, ואז SIGKILL לאחר שנייה אחת.
תהליך הכיבוי (SIGTERM ואז SIGKILL) מבוצע בדרך כלל על ידי
צופה. אז אם התהליך עדיין קיים כאן, זו סוג של התנהגות רעה
כי פסק הזמן החינני לא יכובד כאן.
דוגמא:
>>> מ-circus.process ייבוא תהליך
>>> תהליך = תהליך('למעלה', 'למעלה', מעטפת=נכון)
>>> process.age()
3.0107998847961426
>>> process.info()
למעלה: 6812 לא רלוונטי טארק זומבי לא רלוונטי/לא רלוונטי/לא רלוונטי/לא רלוונטי'
>>> process.status
1
>>> process.stop()
>>> process.status
2
>>> process.info()
'תהליך כזה לא הופסק?'
בכיתה צופה בקרקס. cmd, ארגומנטים=אין, מספר תהליכים=1, עיכוב_חימום=0.0,
working_dir=אין, מעטפת=שקר, shell_args=אין, uid=אין, max_retry=5, gid=אין,
send_hup=לא נכון, אות עצירה=15, stop_children=לא נכון, env=אין, פסק זמן graceful_timeout=30.0,
prereload_fn=אין, rlimits=אין, קובץ הרצה = אין, stdout_stream=אין, stderr_stream=אין,
עדיפות=0, לולאה=אין, סינגלטון=לא נכון, use_sockets=לא נכון, copy_env=שקר,
נתיב_העתקה=שקר, גיל_מקסימלי=0, שונות_גיל_מקסימלית=30, ווים=אין, respawn=אמת, הפעלה אוטומטית=אמת,
לפי דרישה=לא נכון, וירטואל-סביבה=אין, close_child_stdout=לא נכון, close_child_stderr=לא נכון,
virtualenv_py_ver=אין, use_papa=לא נכון, **אפשרויות)
מחלקה המנהלת רשימה של תהליכים עבור פקודה נתונה.
אפשרויות:
· שםשם שניתן לצופה. משמש לזיהוי ייחודי שלו.
· cmd: הפקודה להפעלה. עשוי להכיל רוחב דולר, אשר יוחלף על ידי wid.
· טוען: הארגומנטים להפעלת הפקודה. יכול להיות רשימה או מחרוזת. אם טוען is
מחרוזת, היא מפוצלת באמצעות shlex.split()ברירת המחדל היא ללא.
· תהליכים מספרייםמספר התהליכים להפעלה.
· תיקיית_עבודה: ספריית העבודה שבה תפעיל את הפקודה. אם לא תסופק,
ברירת מחדל לספריית העבודה הנוכחית.
· פָּגָזאם נָכוֹן, יריץ את הפקודה בסביבת המעטפת. לא נכון כברירת מחדל.
אַזהָרָה: זֶה is a אבטחה סכנה.
· uidאם ניתן, זהו מזהה המשתמש או השם שאיתו הפקודה צריכה לפעול. הנוכחי
uid הוא ברירת המחדל.
· gidאם ניתן, זהו מזהה הקבוצה או השם שאיתו הפקודה צריכה לפעול. הנוכחי
gid הוא ברירת המחדל.
· שלח_הופאם הערך True, טעינת התהליך תתבצע על ידי שליחת אות SIGHUP.
ברירת המחדל היא False.
· אות עצירה: האות שיש לשלוח בעת עצירת התהליך. ברירת המחדל היא SIGTERM.
· עצירת_ילדים: לשלוח את אות עצירה גם לילדים. ברירת המחדל היא False.
· envמיפוי המכיל את משתני הסביבה שאיתם הפקודה תפעל.
אופציונלי
· rlimitsמיפוי המכיל שמות וערכים של rlimit שיוגדרו לפני ה-
הפקודה פועלת.
· stdout_streamמיפוי המגדיר את הזרם עבור התהליך stdout. ברירות מחדל
לאף אחד.
אופציונלי. כאשר מסופק, stdout_stream הוא מיפוי המכיל עד שלושה מפתחות:
· בכיתה: מחלקת הזרם. ברירת המחדל היא circus.stream.FileStream
· שם הקובץשם הקובץ, אם משתמשים ב-FileStream
· max_bytesגודל קובץ מקסימלי, ולאחר מכן נפתח קובץ פלט חדש.
ל-0, מה שאומר שאין גודל מקסימלי (רלוונטי רק עם FileStream).
· גיבוי_ספירהכמה גיבויים לשמור בעת סיבוב קבצים בהתאם ל-
הפרמטר max_bytes. ברירת המחדל היא 0, מה שאומר שלא מתבצעים גיבויים (רק
ישים עם FileStream)
מיפוי זה ישמש ליצירת זרם הניתן לקריאה של המחלקה שצוינה.
כל ערך שמתקבל על ידי הניתן לקריאה הוא מיפוי המכיל:
· PID - pid התהליך
· שם - שם הזרם (סטדרר or stdout)
· נתונים - הנתונים
זה לא נתמך ב-Windows.
· stderr_streamמיפוי המגדיר את הזרם עבור התהליך stderr. ברירות מחדל
לאף אחד.
אופציונלי. כאשר מסופק, stderr_stream הוא מיפוי המכיל עד שלושה מפתחות:
- בכיתה: מחלקת הזרם. ברירת המחדל היא circus.stream.FileStream - שם הקובץ: ה
שם קובץ, אם משתמשים ב-FileStream - max_bytesגודל קובץ מקסימלי, ולאחר מכן חדש
קובץ הפלט הוא
פתוח. ברירת המחדל היא 0, מה שאומר שאין גודל מקסימלי (חל רק עם
זרם קבצים)
· גיבוי_ספירהכמה גיבויים לשמור בעת סיבוב קבצים בהתאם ל-
הפרמטר max_bytes. ברירת המחדל היא 0, מה שאומר שלא מתבצעים גיבויים (רק
ישים עם FileStream).
מיפוי זה ישמש ליצירת זרם הניתן לקריאה של המחלקה שצוינה.
כל ערך שמתקבל על ידי הניתן לקריאה הוא מיפוי המכיל:
· PID - pid התהליך
· שם - שם הזרם (סטדרר or stdout)
· נתונים - הנתונים
זה לא נתמך ב-Windows.
· עדיפות -- מספר שלם המגדיר עדיפות עבור הצופה. כאשר הבורר עושה
פעולות מסוימות על כל הצופים, זה ימיין אותן עם שדה זה, החל מ-
מספר גדול יותר לקטן יותר. (ברירת מחדל: 0)
· קְלָף בּוֹדֵד -- אם אמת, לצופה זה יש תהליך יחיד. (ברירת מחדל: שקר)
· use_sockets -- אם זה נכון, התהליכים יירשו את תיאורי הקבצים, וכך יוכלו
השתמש מחדש בסוקטים שנפתחו על ידי circusd. (ברירת מחדל: False)
· לפי דרישה -- אם הערך נכון, התהליכים יופעלו רק בחיבור הראשון
לשקע (ברירת מחדל: False)
· copy_env -- אם זה נכון, הסביבה שבה הקרקס פועל תהיה
משוכפל עבור העובדים. ברירת המחדל היא True ב-Windows מכיוון שלא ניתן להפעיל
כל קובץ הפעלה ללא מערכת רוט משתנה. (ברירת מחדל: שקר)
· נתיב_העתקה -- אם נכון, סירקסד sys.path נשלח לתהליך דרך PYTHONPATH.
עליך להפעיל copy_env ל נתיב_העתקה לעבודה. (ברירת מחדל: שקר)
· max_ageאם מוגדר לאחר כ-max_age שניות, התהליך מוחלף בתהליך חדש
אחד. (ברירת מחדל: 0, מושבת)
· שונות_הגיל_המקסימלית: מספר השניות המקסימלי שניתן להוסיף ל- max_age.
ערך נוסף זה נועד למנוע הפעלה מחדש של כל התהליכים בו זמנית.
התהליך יחיה בין max_age ל- max_age + max_age_variance שניות.
· וויםפונקציות קריאה חוזרת (callback) לחיבור להפעלה וכיבוי של הצופה
התהליך. ווים הוא דיקטטור שבו כל מקש הוא שם הוו וכל ערך הוא
2-tuple עם שם הניתן לקריאה או הניתן לקריאה עצמו ודגל בוליאני
מציין אם אין להתעלם מחריגה המתרחשת ב-hook. אפשרי
ערכים עבור שם הוו: לפני_התחלה, אחרי_התחלה, לפני_השרצה, after_spawn,
לפני_עצירה, אחרי_עצירה., לפני_אות, אות_אחרי or סטטיסטיקות_מורחבות.
· אפשרויות -- אפשרויות נוספות עבור העובד. כל האפשרויות נמצאות בתצורה
קובץ לדוגמה, מועברים במיפוי הזה -- תוספים יכולים להשתמש בזה עבור
אפשרויות ספציפיות לצופה.
· respawn -- אם מוגדר כ-False, התהליכים המטופלים על ידי צופה לא יטופלו
הופיע מחדש באופן אוטומטי. (ברירת מחדל: אמת)
· וירטואלי -- ספריית השורש של סביבה וירטואלית. אם תסופק, הצופה יעשה זאת.
טען את הסביבה לצורך ביצועה. (ברירת מחדל: ללא)
· סגור_ילד_סטדאואם True, סוגר את ה-stdout לאחר ה-fork. ברירת מחדל: False.
· סגירת_ילד_סטדרראם אמת, סוגר את ה-stderr לאחר ה-fork. ברירת מחדל: שקר.
· השתמש באבאאם אמת, השתמש בליבת התהליך papa עבור תהליך זה. ברירת מחדל: שקר.
kill_process(*args, **קווארגס)
תהליך הריגת קוד (stop_signal, graceful_timeout ואז SIGKILL)
kill_processes(*args, **קווארגס)
להרוג את כל התהליכים (stop_signal, graceful_timeout ואז SIGKILL)
ניהול_תהליכים (*ארגומנטים, **קווארגס)
ניהול תהליכים.
הודעה_על_אירוע(נושא, הודעה)
פרסום הודעה בערוץ מפרסם האירוע
reap_and_manage_processes(*args, **קווארגס)
לקצור ולנהל תהליכים.
reap_processes(*args, **ק"ו)
לקצור את כל התהליכים עבור הצופה הזה.
send_signal_child(*args, **ק"ו)
לשלוח אות לילד.
spawn_process(recovery_wid=אין)
תהליך ההשרצה.
החזר True אם תקין, False אם יש לעצור את הצופה
spawn_processes(*args, **קווארגס)
תהליכי יצירת צמחים.
בכיתה קרקס.בורר.בורר (צופים, נקודת קצה, נקודת קצה של פאבסאב, עיכוב_בדיקה=1.0,
prereload_fn=אין, הקשר=אין, לולאה=אין, סטטיסטיקה=שקר, נקודת_סוף_סטטיסטיקות=אין,
statsd_close_outputs=לא נכון, נקודת_קצה_מולטי-שידור=אין, תוספים=אין, שקעים=אין,
עיכוב_חימום=0, httpd=לא נכון, httpd_host='host מקומי', httpd_port=8080,
httpd_close_outputs=לא נכון, ניפוי שגיאות = שקר, debug_gc=לא נכון, ssh_server=אין,
proc_name='circusd', pidfile=אין, רמת יומן=אין, יציאה_מהיד = אין, תצורת לוגר=אין,
fqdn_prefix=אין, umask=אין, endpoint_owner=אין, papa_endpoint=אין)
מחלקה המשמשת לשליטה ברשימת צופים.
אפשרויות:
· צופים -- רשימה של אובייקטי צופה
· נקודת סיום -- נקודת הקצה של הבקר ZMQ
· נקודת_קצה_פאבסוב -- נקודת הקצה של pubsub
· סטטיסטיקות -- אם True, תהליך circusd-stats מופעל (ברירת מחדל: False)
· נקודת_קצה_סטטיסטיקות -- נקודת הקצה הסטטיסטית.
· יציאות_סגירה_סטטיסטיקות -- אם True שולח את circusd-stats stdout/stderr אל
/dev/null (ברירת מחדל: False)
· נקודת קצה של שידור מרובה -- נקודת הקצה של שידור מרובה (multicast) עבור גילוי אוטומטי של אשכולות circusd
(ברירת מחדל: udp://237.219.251.97:12027) כתובת שידור מרובה צריכה להיות בין 224.0.0.0
ל- 239.255.255.255 ואותו הדבר עבור כל האשכול.
· עיכוב_בדיקה -- העיכוב בין שתי נקודות בקר (ברירת מחדל: שנייה אחת)
· טעינה_מוקדמת_fn -- ניתן לקריאה שיבוצע בכל טעינה מחדש (ברירת מחדל: ללא)
· הקשר -- אם סופק, ההקשר של zmq לשימוש חוזר. (ברירת מחדל: ללא)
·
לוּלָאָה: if בתנאי, a zmq.eventloop.ioloop.IOLoop למשל
לשימוש חוזר. (ברירת מחדל: ללא)
· תוספים -- רשימת תוספים. כל פריט הוא מיפוי עם:
· להשתמש -- שם מלא שמצביע על מחלקת התוסף
כל ערך אחר מועבר לתוסף ב- config אוֹפְּצִיָה
· ארובות -- מיפוי של שקעים. כל מפתח הוא שם השקע, וכל ערך הוא
סירקוס שקע מחלקה. (ברירת מחדל: ללא)
· עיכוב_חימום -- עיכוב בשניות בין הפעלת שני צופים. (ברירת מחדל: 0)
· httpd -- אם True (אמת), תהליך circushttpd מופעל (ברירת מחדל: False)
· httpd_host -- מארח circushttpd (ברירת מחדל: localhost)
· httpd_port -- פורט circushttpd (ברירת מחדל: 8080)
· httpd_close_outputs -- אם אמת, שולח את circushttpd stdout/stderr אל /dev/null.
(ברירת מחדל: False)
· באגים -- אם True, מוסיף הרבה מידע על ניפוי שגיאות ב-stdout (ברירת מחדל: False)
· debug_gc -- אם אמת, האם gc.set_debug(gc.DEBUG_LEAK) (ברירת מחדל: שקר) יעביר את הפונקציה circusd
לנתח בעיות (ברירת מחדל: False)
· שם_המערכת -- שם הליך הבוררות
·
קידומת_fqdn -- a קידומת ל מה היא ייחודי מזהה of מה היא קרקס
מופע על האשכול.
· בעל/ת קצה -- משתמש יוניקס שאליו יצטרכו לנתב את נקודת הקצה אם משתמשים ב-ipc.
· נקודת קצה של פאפא -- נקודת הקצה של ליבת תהליך papa
add_watcher(*args, **קווארגס)
מוסיף צופה.
אפשרויות:
· שםשם הצופה להוספה
· cmd: פקודה להפעלה.
· כל שאר האפשרויות המוגדרות בבנאי ה-Watcher.
get_watcher(שם)
החזירו את הצופה שם.
numprocesses()
החזר את מספר התהליכים הפועלים בכל הצופים.
מספר צופי ()
החזר את מספר הצופים.
טעינה מחדש (*ארגומנטים, **קווארגס)
טוען הכל מחדש.
הפעל את טעינה_מוקדמת_fn() ניתן לקריאה אם בכלל, ואז טען מחדש בצורה חיננית את כל הצופים.
התחל(*ארגומנטים, **קווארגס)
מתחיל את כל הצופים.
אם ה-ioloop סופק במהלך קריאת __init__(), מפעיל את כל הצופים
כקורוטין סטנדרטי
אם ה-ioloop לא סופק במהלך קריאת __init__() (ברירת מחדל), הפעולה מתחילה
כל הצופים ולולאת האירועים (והבלוקים כאן). במצב זה השיטה
אסור להניב כלום מכיוון שזה נקרא כשיטה סטנדרטית.
פרמטרים
cb -- קריאה חוזרת נקראת לאחר שכל הצופים התחילו, כאשר
הלולאה לא סופקה.
כתיבה תוספים
סירקוס מגיע עם מערכת תוספים המאפשרת לך אינטראקציה עם קרקסד.
הערה:
ייתכן שנוסיף תמיכה ב-circusd-stats לתוספים בהמשך.
תוסף מורכב משני חלקים:
· מנוי ZMQ לכל האירועים שפורסמו על ידי קרקסד
· לקוח ZMQ לשליחת פקודות קרקסד
כל תוסף מופעל כתהליך נפרד תחת צופה מותאם אישית.
כמה דוגמאות לתוספים שתוכלו ליצור עם מערכת זו:
· מערכת התראות ששולחת התראות בדוא"ל כאשר צופה מנפנף בכנפיים
· חוטב עצים
כלי שמוסיף או מסיר תהליכים בהתאם לעומס
· וכו.
סירקוס עצמו מגיע עם כמה תוספים מובנים.
השמיים תוסף סירקוס בכיתה
Circus מספק מחלקה בסיסית שתעזור לך ליישם תוספים: circus.plugins.CircusPlugin
בכיתה circus.plugins.CircusPlugin(נקודת קצה, נקודת קצה של פאבסאב, עיכוב_בדיקה, ssh_server=אין,
**הגדרות)
מחלקת בסיס לכתיבת תוספים.
אפשרויות:
· הקשר -- ההקשר של ZMQ לשימוש
· נקודת סיום -- נקודת הקצה של ZMQ במעגל
· נקודת_קצה_פאבסוב -- נקודת הקצה של circusd ZMQ פאב/סאב
· עיכוב_בדיקה -- עיכוב הבדיקה שהוגדר
· config -- מיפוי תצורה חופשי
קריאה (פקודה, **אביזרים)
שולח את הפקודה אל קרקסד
אפשרויות:
· הפקודה -- הפקודה להתקשר
· אבזרים -- ארגומנטים של מילות מפתח להוספה לקריאה
מחזירה את מיפוי ה-JSON שנשלח בחזרה על ידי קרקסד
יצוק (פקודה, **אביזרים)
פקודה "שיגור ושכח" ל קרקסד
אפשרויות:
· הפקודה -- הפקודה להתקשר
· אבזרים -- ארגומנטים של מילות מפתח להוספה לקריאה
handle_init()
נקרא ממש לפני הפעלת תוסף - בהקשר של השרשור.
handle_recv(נתונים)
מקבל כל אירוע שפורסם על ידי קרקסד
אפשרויות:
· נתונים -- קבוצה המכילה את הנושא והמסר.
handle_stop()
נקרא ממש לפני שהתוסף נעצר על ידי Circus.
כאשר מחלקה זו מאותחלת על ידי Circus, היא יוצרת לולאת אירועים משלה שמקבלת את כל
קרקסד אירועים ולהעביר אותם אליהם handle_recv()הנתונים שהתקבלו הם צמד המכיל את
הנושא והנתונים עצמם.
handle_recv() צריך להיות מיושם על ידי התוסף.
השמיים שִׂיחָה() ו יָצוּק() ניתן להשתמש בשיטות כדי לתקשר עם קרקסד אם אתה בונה
תוסף שמקיים אינטראקציה פעילה עם הדמון.
handle_init() ו handle_stop() הן רק שיטות נוחות בהן ניתן להשתמש כדי לאתחל ו
לנקות את הקוד שלך. handle_init() נקרא בתוך השרשור שזה עתה התחיל.
handle_stop() נקרא בשרשור הראשי רגע לפני שהשרשור נעצר ומצטרף.
כתיבה a חיבור
בואו נכתוב תוסף שרושם בקובץ כל אירוע שקורה ב... קרקסד. זה לוקח אחד
ארגומנט שהוא שם הקובץ.
התוסף עשוי להיראות כך:
ייבוא CircusPlugin מ-circus.plugins
לוגר מחלקה (CircusPlugin):
שם = 'לוגר'
def __init__(self, *args, **config):
סופר(לוגר, עצמי).__init__(*ארגומנטים, **קונפיגורציה)
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):
שם_הצופה, פעולה, הודעה = self.split_data(נתונים)
msg_dict = self.load_message(הודעה)
self.file.write('%s %s::%r\n' % (פעולה, שם_הצופה, msg_dict))
זהו! ניתן לשמור את המחלקה הזו בכל חבילה/מודול, כל עוד היא ניתנת לצפייה על ידי
פייתון
לדוגמה, לוגר ניתן למצוא ב- תוספים מודול בתוך הפרויקט שלי חֲבִילָה.
אסינק בקשות
במקרה שתרצו לבצע פעולות אסינכרוניות (כמו קריאה לטורנדו או שימוש
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
[מידע] טוען את התוסף...
נקודת קצה: 'tcp://127.0.0.1:5555'
[מידע] פרסום/משנה: 'tcp://127.0.0.1:5556'
[מידע] מתחיל
דרך נוספת להפעיל תוסף היא לאפשר ל-Circus לטפל באתחול שלו. זה נעשה על ידי
הוספת א [תוסף:שם] סעיף בקובץ התצורה, שבו שֵׁם הוא שם ייחודי עבור
התוסף שלך:
[תוסף: לוגר]
שימוש = myproject.plugins.Logger
שם קובץ = /var/myproject/circus.log
להשתמש חובה ומצביע על השם המלא של התוסף.
כאשר Circus מתחיל, הוא יוצר צופה עם תהליך אחד שמפעיל את המחלקה המוכוונת, ו
להעביר כל משתנה אחר הכלול בסעיף לבנאי התוסף דרך ה- config
מיפוי.
ניתן גם להוסיף תוספים באופן תכנותי בעת יצירת קרקס.בורר.בורר בכיתה
או שימוש circus.get_arbiter(), ראה ספרייה.
הופעות
מכיוון שכל תוסף נטען בתהליך משלו, זה לא אמור להשפיע על התוצאה הכוללת
ביצועי המערכת כל עוד העבודה שנעשית על ידי התוסף אינה עושה יותר מדי
שיחות אל ה- קרקסד התהליך.
הוקס
סירקוס מספק ווים (hooks) בהם ניתן להשתמש כדי להפעיל פעולות באירועי צופה. זמין
ווים הם:
· לפני_התחלה: נקרא לפני שהצופה מתחיל. אם הוו חוזר לא נכון מה היא
ההפעלה בוטלה.
· אחרי_התחלה: נקרא לאחר שהצופה הופעל. אם הוו חוזר לא נכון הצופה
נעצר באופן מיידי והאתחול נפסק.
· לפני_השרצה: נקרא לפני שהצופה מפעיל תהליך חדש. אם ה-hook חוזר לא נכון
הצופה נעצר מיד והאתחול נפסק.
· after_spawn: נקרא לאחר שהצופה מפעיל תהליך חדש. אם ה-hook חוזר לא נכון
הצופה נעצר מיד והאתחול נפסק.
· לפני_עצירה: נקרא לפני שהצופה נעצר. תוצאת ה-hook מתעלמת.
· אחרי_עצירה: נקרא לאחר שהצופה נעצר. תוצאת ה-hook מתעלמת.
· לפני_אות: נקרא לפני שנשלח אות לתהליך של צופה. אם הוו
החזרות לא נכון האות לא נשלח (למעט SIGKILL שתמיד נשלח)
· אות_אחרי: נקרא לאחר שנשלח אות לתהליך של צופה.
· סטטיסטיקות_מורחבות: נקרא כאשר מתבקשים סטטיסטיקות עם extended=True. משמש להוספה
סטטיסטיקות ספציפיות לתהליך לפלט הסטטיסטיקות הרגיל.
דוגמה
מקרה שימוש טיפוסי הוא לשלוט בכך שכל התנאים להתחלת תהליך מתקיימים.
נניח שיש לך צופה שפועל Redis וצופה שמריץ סקריפט פייתון ש
עובד עם Redisעם סירקוס ניתן להזמין את הסטארט-אפ באמצעות עדיפות אפשרות:
[צופה: עובד-תור]
cmd = python -u worker.py
עדיפות = 1
[צופה:רדיס]
cmd = redis-server
עדיפות = 2
עם הגדרה זו, סירקוס יתחיל Redis תחילה ולאחר מכן זה יפעיל את עובד התור.
אבל סירקוס לא באמת שולט בזה Redis פעיל ופועל. זה פשוט מתחיל את
תהליך שנתבקש להתחיל. מה שחסר לנו כאן הוא דרך לשלוט בזה Redis is
התחיל ופועל במלואו. פונקציה ששולטת בכך יכולה להיות:
ייבוא רדיס
זמן יבוא
def check_redis(*args, **kw):
time.sleep(.5) # תן לזה הזדמנות להתחיל
r = redis.StrictRedis(host='localhost', port=6379, db=0)
r.set('פו', 'בר')
החזר r.get('foo') == 'bar'
ניתן לחבר פונקציה זו ל-Circus כ- לפני_התחלה וו:
[צופה: עובד-תור]
cmd = python -u worker.py
hooks.before_start = mycoolapp.myplugins.check_redis
עדיפות = 1
[צופה:רדיס]
cmd = redis-server
עדיפות = 2
ברגע שקרקס התחיל את חוזר צופה, זה יתחיל את עובד תור צופה, מאז
זה עוקב אחר ה עדיפות הזמנה. רגע לפני הפעלת הצופה השני, הוא יפעל
מה היא check_redis פונקציה, ובמקרה שהיא מחזירה לא נכון יבטל את הצופה החל מ-
התהליך.
וו חֲתִימָה
חייב להיות וו אחרי החתימה הזו:
def hook(צופה, שופט, שם_הוק, **kwargs):
...
# אם לא תחזירו True, ה-hook יכול להשתנות
# התנהגות הקרקס (בהתאם לז'אנר)
להחזיר נכון
איפה צוֹפֶה האם ה צופה מופע מחלקה, פוסק מה היא שוטר אחד, Hook_name הקרס
שם ו קווארגים כמה פרמטרים אופציונליים נוספים (בהתאם לסוג הקרס).
השמיים after_spawn hook מוסיף את פרמטרי ה-pid:
def after_spawn(צופה, שופט, שם_הוק, pid, **kwargs):
...
# אם לא תחזיר את הערך True, סירקוס יהרוג את התהליך
להחזיר נכון
איפה PID הוא ה-PID של התהליך המתאים.
כמו כן, לפני_אות ו אות_אחרי ווים מוסיפים pid ו-signum:
def before_signal_hook(צופה, בורר, שם_הוק, pid, חתימה, **kwargs):
...
# אם לא תחזיר True, circus לא ישלח את אות ה-signum
# (SIGKILL תמיד נשלח)
להחזיר נכון
איפה PID הוא ה-PID של התהליך המתאים ו- חתימה הוא האות המתאים.
אפשר להתעלם מאלה, אבל היכולת להשתמש בנתונים ובשיטות של הצופה ו/או הבורר יכולה...
להיות שימושי בכמה ווים.
שימו לב ש-hooks נקראים עם ארגומנטים בעלי שם. לכן השתמשו בחתימת ה-hook ללא
שינוי שמות ארגומנטים.
השמיים סטטיסטיקות_מורחבות ל-hook יש פרמטרים נוספים משלו ב- קווארגים:
def extended_stats_hook(צופה, שופט, שם_הוק, pid, נתונים סטטיסטיים, **kwargs):
...
איפה PID הוא ה-PID של התהליך המתאים ו- סטטיסטיקות הסטטיסטיקות הרגילות שיהיו
הוחזר. הוסף את הסטטיסטיקות שלך לתוך סטטיסטיקותדוגמה לכך נמצאת ב
דוגמאות/uwsgi_lossless_reload.py.
כדוגמה אחרונה, הנה סופר וו שיכול להתמודד עם כל מיני אותות:
def super_hook(צופה, שופט, שם_הוק, **kwargs):
pid = אין
חתימה = אין
אם שם_הוק ב-('לפני_אות', 'אחרי_אות'):
pid = קווארגס['pid']
חתימה = קווארגס['חתימה']
...
להחזיר נכון
וו אירועים
בכל פעם שמפעילים hook, התוצאה שלו מתעדכנת כאירוע ב-Circus.
ישנם שני אירועים הקשורים ל-hooks:
· הצלחה_הוק: קריאה ל-hook בוצעה בהצלחה. מפתחות האירוע הם שם השם אם ה
אירוע, ו זמן: תאריך האירועים.
· כשל_הוק: נכשלה פעולת הוק. מפתחות האירועים הם שם שם האירוע, זמן:
תאריך האירועים ו שגיאההחריג שאירע באירוע, אם בכלל.
מוסיף חדש פקודות
ניסינו להפוך את הוספת פקודות חדשות לפשוטה ככל האפשר.
אתה צריך לעשות שלושה דברים:
1. ליצור הפקודה שלך.py קובץ תחת קרקס/פקודות/.
2. הטמע שם מחלקה אחת, עם מתודות מוגדרות מראש
3. הוסף את הפקודה החדשה ב circus/commands/__init__.py.
נניח שאנחנו רוצים להוסיף פקודה שמחזירה את מספר הצופים הנמצאים כעת בשימוש,
היינו עושים משהו כזה (עם הערות נרחבות כדי לאפשר לכם לעקוב אחר עוד
בְּקַלוּת):
מתוך פקודת הייבוא של circus.commands.base
מ-circus.exc import ArgumentError, MessageError
מחלקה NumWatchers (פקודה):
"""זהו תרגול טוב לתאר כאן מה הכיתה עושה.
עיין בפקודות אחרות כדי לראות כיצד אנו רגילים לעצב
טקסט זה. הוא ייכלל אוטומטית בתיעוד,
אז אל תפחדו להיות ממצה, בשביל זה זה נעשה
ל.
"" "
# כל הפקודות יורשות מ-`circus.commands.base.Command`
# אתה צריך לציין שם כדי שנוכל למצוא את הפקודה איכשהו
שם = "מספר צופים"
# הגדר את ההמתנה ל-True או False כדי להגדיר את התנהגות ברירת המחדל שלך
# - אם ההמתנה היא True, הפקודה מופעלת באופן סינכרוני, והלקוח עשוי לקבל
# תוצאות חזרה.
# - אם האפשרות "המתנה" היא "שקר", הפקודה מופעלת באופן אסינכרוני בשרת ובלקוח באופן מיידי.
# מקבל תשובה 'אוקיי'
#
# כברירת מחדל, פקודות מוגדרות כ- waiting = False
מחכה = נכון
# אפשרויות
אפשרויות = [('', 'שם אופציה', ערך_ברירת_מחדל, 'תיאור')]
מאפיינים = ['פו', 'בר']
# מאפיינים מפרטים את ארגומנטי הפקודה שהם חובה. אם הם
# לא סופק, אז תיוורק שגיאה
def execute(self, arbiter, props):
# שיטת ה-execute היא ליבת הפקודה: שים כאן את כל ה-
# היגיון הפקודה והחזרת פקודה המכילה את הערכים שאתה
# רוצים לחזור, אם בכלל
החזר {"numwatchers": arbiter.numwatchers()}
def console_msg(self, msg):
# msg הוא מה שמוחזר על ידי מתודת execute.
# שיטה זו משמשת לעיצוב התגובה עבור קונסולה (היא
# משמש למשל את circusctl להדפסת הודעותיו)
להחזיר "מחרוזת שתוצג"
def message(self, *args, **opts):
# הודעה מטפלת בקלט של הקונסולה.
# שיטה זו משמשת למיפוי ארגומנטים של קונסולה לפקודה
# אפשרויות. (הוא משמש למשל בעת קריאה לפקודה דרך
# circusctl)
# NotImplementedError יזרוק אם הפונקציה חסרה
מספר ארגומנטים = 1
אם לא len(args) == numArgs:
raise ArgumentError('מספר לא חוקי של ארגומנטים.')
else
opts['optname'] = args[0]
החזר self.make_message(**opts)
def אימות (עצמי, אביזרים):
# שיטה זו משמשת לאימות הארגומנטים שהועברו אל
# פקודות נכונות. יש להזריק שגיאת ArgumentError במקרה
# יש שגיאה בארגומנטים שהועברו (לדוגמה, אם הם
# לא מתאימים יחד.
# במקרה שיש בעיה עם התוכן שלהם, שגיאת MessageError
יש לזרוק את ה-#. שיטה זו יכולה לשנות את תוכן האביזרים.
# dict, הוא יועבר לביצוע לאחר מכן.
השתמש מקרים דוגמאות
פרק זה מציג מספר מקרי שימוש, כדי לתת לכם מושג כיצד להשתמש ב-Circus בכם
סביבה.
ריצה a WSGI יישום
הפעלת אפליקציית WSGI עם Circus היא די מעניינת מכיוון שניתן לצפות ולנהל אותה
שֶׁלְךָ אינטרנט עובדים באמצעות קרקס-טופ, סירקוסקטל או ממשק האינטרנט.
זה מתאפשר באמצעות שקעי Circus. ראה מדוע שקעי Circus.
בואו ניקח דוגמה עם מינימום פירמידה יישום:
מ-pyramid.config import Configurator
מ-pyramid.response ייבוא תגובה
def hello_world(בקשה):
החזרת תגובה ('שלום %(שם)s!' % request.matchdict)
config = קונפיגורטור()
config.add_route('שלום', '/שלום/{שם}')
config.add_view(hello_world, route_name='hello')
יישום = config.make_wsgi_app()
שמור את הסקריפט הזה לתוך app.py קובץ, ולאחר מכן התקן את הפרויקטים האלה:
$ פיפ התקנת פירמידה
$ pip להתקין שאסט
לאחר מכן, ודא שאתה יכול להפעיל את אפליקציית הפירמידה שלך באמצעות גֶרֶב סקריפט קונסולה:
$ chaussette app.application
היישום הוא
הגשה ב-localhost:8080
שימוש כ-backend
ותבדוק שאתה יכול להגיע אליו על ידי ביקור http://localhost:8080/שלום/טארק
כעת, לאחר שהאפליקציה שלך פועלת, בואו ניצור קובץ תצורה של Circus:
[קרקס]
עיכוב_בדיקה = 5
נקודת קצה = tcp://127.0.0.1:5555
pubsub_endpoint = tcp://127.0.0.1:5556
stats_endpoint = tcp://127.0.0.1:5557
[צופה: עובד רשת]
cmd = chaussette --fd $(circus.sockets.webapp) app.application
use_sockets = נכון
מספר תהליכים = 3
[socket:webapp]
מארח = 127.0.0.1
יציאה = 8080
קובץ זה מורה ל-Circus לאגד שקע בפורט 8080 ורוץ גֶרֶב עובדים על זה
שקע -- על ידי העברת ה-fd שלו.
שמור את זה ב server.ini ולנסות להפעיל אותו באמצעות קרקסד
$ circusd server.ini
[מידע] הפעלת מאסטר ב-pid 8971
שקעים [INFO] התחילו
[INFO] סטטיסטיקות circusd התחילו
אפליקציית [INFO] הופעלה
[מידע] הבורר ממתין כעת לפקודות
ודא שהאפליקציה עדיין פועלת http://localhost:8080/שלום/טארק.
מזל טוב! יש לך אפליקציית WSGI שמריצה 3 עובדים.
אתה יכול להריץ את circushttpd או את ה-cli, וליהנות מניהול Circus.
ריצה a ג'נגו יישום
הרצת אפליקציית Django מתבצעת בדיוק כמו הרצת אפליקציית WSGI. השתמש ב-
PYTHONPATH כדי לייבא את הספרייה שבה נמצא הפרויקט, הספרייה שמכילה את
ספרייה שמכילה settings.py (עם Django 1.4+ ספרייה זו מכילה manage.py)
:
[socket:dwebapp]
מארח = 127.0.0.1
יציאה = 8080
[צופה:dwebworker]
cmd = chaussette --fd $(circus.sockets.dwebapp) dproject.wsgi.application
use_sockets = נכון
מספר תהליכים = 2
[סביבה:dwebworker]
PYTHONPATH = /נתיב/אל/הורה-של-פרויקט-d
אם אתה צריך לעבור את DJANGO_SETTINGS_MODULE עבור עובד backend לדוגמה, אתה יכול
תעבירו את זה גם למרות ש- env אפשרות תצורה:
[צופה:dbackend]
cmd = /path/to/script.py
מספר תהליכים=3
[סביבה:dbackend]
PYTHONPATH = /נתיב/אל/הורה-של-פרויקט-d
DJANGO_SETTINGS_MODULE=dproject.settings
לִרְאוֹת http://chaussette.readthedocs.org למידע נוסף על שוסט.
עיצוב החלטות
באופן כללי ארכיטקטורה
[תמונה]
קרקס מורכב מתהליך עיקרי הנקרא קרקסד אשר דואג להפעלת כל
תהליכים. כל תהליך המנוהל על ידי Circus הוא תהליך בן של קרקסד.
תהליכים מאורגנים בקבוצות הנקראות צופים. צוֹפֶה היא בעצם פקודה
קרקסד פועל על המערכת שלך, ועבור כל פקודה תוכל להגדיר כמה תהליכים אתה
רוצה לרוץ.
הרעיון של צוֹפֶה שימושי כשרוצים לנהל את כל התהליכים שמפעילים את
אותה פקודה -- כמו להפעיל אותם מחדש וכו'
קרקסד קושר שני שקעי ZeroMQ:
· בקשה/נציגות -- שקע המשמש לשליטה קרקסד שימוש ב-json מבוסס פקודות.
· פאב/סאב -- שקע שבו קרקסד מפרסם אירועים, כמו מתי תהליך מתחיל או
עצר.
הערה:
למרות שמה, ZeroMQ אינה מערכת לניהול תורים. חשבו עליה כ...
ספריית תקשורת בין-תהליכית (IPC).
תהליך נוסף שנקרא סטטיסטיקות circusd מנוהל על ידי קרקסד כאשר האפשרות מופעלת.
סטטיסטיקות circusdתפקידו לפרסם סטטיסטיקות של שימוש במעבד/זיכרון בקובץ ייעודי פאב/סאב
ערוץ.
ערוץ מיוחד זה משמש את קרקס-טופ ו קרקס-httpd כדי להציג שידור חי
של הפעילות.
קרקס-טופ הוא סקריפט קונסולה שמחקה חלק עליון כדי להציג את כל ניצול המעבד והזיכרון של
התהליכים המנוהלים על ידי סירקוס.
קרקס-httpd הוא ממשק ניהול האינטרנט שיאפשר לך לתקשר עם Circus. זה
מציג שידור חי באמצעות שקעי אינטרנט ו- סטטיסטיקות circusd ערוץ, אלא גם מאפשר לך
להתערבב עם קרקסד דרך שלה בקשה/נציגות ערוץ.
האחרון חביב, סירקוסקטל הוא כלי שורת פקודה המאפשר לך לנהוג קרקסד דרך שלה
בקשה/נציגות ערוץ.
ניתן גם להוסיף תוספים שנרשמים ל קרקסד's פאב/סאב ערוץ ולתת לך לשלוח
פקודות ל- בקשה/נציגות כמו ערוץ סירקוסקטל היה.
אבטחה
Circus בנוי על גבי ספריית ZeroMQ ואינו מגיע עם אבטחה כלל.
פרוטוקולים. עם זאת, ניתן להריץ מערכת Circus על שרת ולהגדיר מנהרת SSH כדי
לגשת אליו ממכונה אחרת.
סעיף זה מסביר מה Circus עושה במערכת שלך כשאתה מפעיל אותו, ומסתיים
תיאור כיצד להשתמש במנהרת SSH.
אתה יכול גם לקרוא http://www.zeromq.org/area:שאלות נפוצות#toc5
TCP יציאות
כברירת מחדל, Circus פותח את פורטי ה-TCP הבאים במארח המקומי:
· 5555 -- הנמל ששימש לשליטה בקרקס דרך סירקוסקטל
· 5556 -- הפורט המשמש עבור ערוץ המפרסם/מנוי.
· 5557 -- הפורט המשמש לערוץ הסטטיסטיקה -- אם מופעל.
· 8080 -- הפורט בו משתמש ממשק המשתמש של האינטרנט -- אם מופעל.
פורטים אלה מאפשרים לאפליקציות לקוח לקיים אינטראקציה עם מערכת Circus שלך, ובהתאם לאופן שבו
אם התשתית שלך מאורגנת, ייתכן שתרצה להגן על פורטים אלה באמצעות חומות אש or
הגדר את Circus לרוץ באמצעות IPC יציאות.
הנה דוגמה להפעלת Circus באמצעות נקודות כניסה של IPC בלבד:
[קרקס]
עיכוב_בדיקה = 5
נקודת קצה = ipc:///var/circus/endpoint
נקודת_קצה_פאבסאב = ipc:///var/circus/פאבסאב
נקודת_קצה_סטטיסטיקות = ipc:///var/circus/stats
כאשר מוגדרים באמצעות IPC, יש להריץ את הפקודות מאותה תיבה, אך איש אינו יכול
לגשת אליהן מבחוץ, בניגוד לשימוש ב-TCP. יש להריץ את הפקודות גם כמשתמש ש
יש גישת כתיבה לנתיבי socket ה-ipc. באפשרותך לשנות את הבעלים של נקודת סיום באמצעות
מה היא בעל/ת קצה אפשרות הגדרות. זה מאפשר לך להריץ את circusd כמשתמש root, אבל
לאפשר לתהליכים שאינם root לשלוח פקודות אל קרקסדשים לב שכאשר משתמשים ב- בעל/ת קצה,
על מנת למנוע מתהליכים שאינם root להפעיל תהליכים שרירותיים אשר
לרוץ עם הרשאות גדולות יותר, הפקודה add תאכוף שצופים חדשים חייבים לרוץ כ-
מה היא בעל/ת קצה משתמש. הגדרות הצופה בקבצי התצורה המקומיים לא יהיו
מוגבל בדרך זו.
כמובן, אם תפעילו את ממשק המשתמש של האינטרנט, ה- 8080 הנמל עדיין יהיה פתוח.
קרקסhttpd
כאשר אתה מפעיל קרקסhttpd באופן ידני, או כאשר אתה משתמש ב- httpd אפשרות בקובץ ini כמו
זֶה:
[קרקס]
עיכוב_בדיקה = 5
נקודת קצה = ipc:///var/circus/endpoint
נקודת_קצה_פאבסאב = ipc:///var/circus/פאבסאב
נקודת_קצה_סטטיסטיקות = ipc:///var/circus/stats
httpd = 1
יישום האינטרנט יפעל על פורט 8080 ויאפשר לכל אחד לגשת לדף האינטרנט
לנהל את קרקסד דמון.
זה כולל יצירת צופים חדשים שיכולים להריץ כל פקודה במערכת שלך!
Do לֹא לעשות it בפומבי זמין
אם ברצונך להגן על הגישה לפאנל האינטרנט, תוכל להגיש אותו מאחורי Nginx או
אפאצ'י או כל שרת אינטרנט אחר התומך בפרוקסי, שיכול לדאוג לאבטחה.
משתמש ו קְבוּצָה הרשאות
כברירת מחדל, כל התהליכים שיופעלו עם Circus יפעלו עם אותו משתמש וקבוצה
as קרקסדבהתאם להרשאות שיש למשתמש במערכת, ייתכן שלא יהיו לך
גישה לכל התכונות ש-Circus מספקת.
לדוגמה, חלק מתכונות הסטטיסטיקה בתהליכים הפועלים דורשות הרשאות מורחבות.
בדרך כלל, אם נתוני השימוש במעבד שמקבלים באמצעות סטטיסטיקות הפקודה היא N / A, זה אומר שלך
המשתמש לא יכול לגשת לקבצי proc. זה יהיה המצב כברירת מחדל ב-Mac OS X.
אתה יכול לרוץ קרקסד כשורש כדי לתקן זאת, ולהגדיר את uid ו gid ערכים עבור כל צופה
כדי לקבל את כל התכונות.
אבל היזהרו מריצה קרקסד כאשר root חושף אותך להסלמה אפשרית של הרשאות
באגים. בעוד שאנו עושים כמיטב יכולתנו להימנע מכל באגים, הפעלה כ-root מתמודדת עם באג ש...
מבצע פעולות לא רצויות במערכת שלך עלול להיות מסוכן.
הדרך הטובה ביותר למנוע זאת היא לוודא שהמערכת שמפעילה את Circus תקינה לחלוטין.
מבודד (כמו מכונה וירטואלית) or להפעיל את כל המערכת תחת משתמש מבוקר.
SSH מנהור
לקוחות יכולים להתחבר ל- קרקסד לדוגמה על ידי יצירת מנהרת SSH. לשם כך, העבר את
אפשרות שורת פקודה --שש אחריו משתמש@כתובת, שם המשתמש האם המשתמש בשלט רחוק
שרת ו כתובת היא כתובת השרת כפי שהיא נראית על ידי הלקוח. פרוטוקול ה-SSH יעשה זאת.
דורשים אישורים להשלמת ההתחברות.
If קרקסד כפי שרואים על ידי שרת ה-SSH, אינו נמצא בכתובת נקודת הקצה המוגדרת כברירת מחדל 5555
לאחר מכן ציין את קרקסד כתובת באמצעות האפשרות --נקודת קצה
מְאוּבטָח התקנה דוגמה
ניתן להגדיר שרת מאובטח של Circus על ידי:
· הפעלת שרת SSH
· הפעלת Apache או Nginx על 80 פורט, וביצוע פרוקסי הפוך על ה- 8080 נָמָל.
· חסימת ה 8080 יציאה מגישה חיצונית.
· הפעלת כל פורטי ZMQ Circusd באמצעות קבצי IPC במקום פורטי TCP, ומנהור של כולם
שיחות דרך SSH.
[תמונה]
תרומה ל קרקס
סירקוס הוקם במוזילה, אך מטרתו אינה להישאר רק שם. אנחנו מנסים
לבנות כלי שיהיה שימושי לאחרים, וניתן להרחבה בקלות.
אנחנו באמת פתוחים לכל תרומה, בצורה של קוד, תיעוד, דיונים,
הצעת תכונה וכו'.
ניתן לפתוח נושא ברשימת התפוצה שלנו: http://tech.groups.yahoo.com/group/circus-dev/
או להוסיף נושא בדף שלנו באג גשש
קביעה שגיאות הקלדה ו שיפור מה היא תיעוד
בהחלט ייתכן שהעיניים שלך מדממות בזמן קריאת הקטע החצי-אנגלי הזה.
תיעוד חצי-צרפתי, אל תהססו לתרום כל ניסוח מחדש / שיפור בנושא
הטופס בתיעוד. כנראה שאתם אפילו לא צריכים להבין איך Circus עובד
מתחת למכסה המנוע כדי לעשות את זה.
מוסיף חדש מאפיינים
תכונות חדשות כמובן יתקבלו בברכה רבה. אם יש לכם את הצורך והזמן לעשות זאת
לעבוד על תכונות חדשות, הוספתן ל-Circus לא אמורה להיות כל כך מסובכת. ניסינו מאוד
קשה שיהיה ממשק API נקי ומובן, מקווה שזה ישרת את המטרה.
תצטרכו להוסיף תיעוד ובדיקות יחד עם הקוד של התכונה החדשה.
אחרת לא נוכל לקבל את התיקון.
איך ל להגיש שֶׁלְךָ שינויים
אנחנו משתמשים ב-git כ-DVCS. הדרך הטובה ביותר להציע שינויים היא ליצור ענף על ה-...
צד (דרך סילון לתשלום -b שם הסניף) ותבצע שם את השינויים שלך. לאחר שתסיים
משהו מוכן לשעות הפריים טיים, להוציא בקשת משיכה כנגד ענף זה.
אנו עוקבים אחר מודל זה כדי לאפשר צימוד נמוך בין התכונות שאתה
הצעה. לדוגמה, אנו יכולים לקבל בקשת משיכה אחת בזמן שאנחנו עדיין נמצאים בדיון
לעוד אחד.
לפני שאתם מציעים את השינויים שלכם, ודאו שוב שהם לא מפרים שום דבר! אתם יכולים
להשתמש רעב פקודה כדי להבטיח זאת, היא תפעיל את חבילת הבדיקות תחת הגדרות שונות
גרסאות פייתון נתמכות.
אנא השתמשו ב: http://issue2pr.herokuapp.com/ להפנות ל-commit לקרקס קיים
בעיה, אם בכלל.
הימנעות למזג מתחייב
הימנעות מפעולות מיזוג מאפשרת היסטוריה נקייה וקלה לקריאה. לשם כך, במקום
ביצוע "git pull" ותן ל-git לטפל במיזוגים עבורך, באמצעות git pull --rebase
הציבו את השינויים שלכם אחרי השינויים שבוצעו בענף, או כשאתם עובדים על
אדון.
כלומר, עבורנו, מפתחי הליבה, לא ניתן יותר להשתמש ב-GitHub Green הנוח.
כפתור בבקשות משיכה אם המפתחים לא ביצעו ביסוס מחדש של עבודתם בעצמם או אם נמתין
יותר מדי זמן בין הבקשה למיזוג בפועל. במקום זאת, הזרימה נראית כך:
הוסף שם של git מרחוק
שם של git fetch
ענף תכונות של קופה בגיט
מאסטר ריבייס של גיט
# בדוק שהכל עובד כמו שצריך ואז מזג במאסטר
מאסטר לקופות
גיט מיזוג תכונה-ענף
בדיון
אם אתם מוצאים את עצמכם זקוקים לעזרה כלשהי בזמן שאתם מסתכלים על הקוד של סירקוס, אתם יכולים ללכת
ומצאו אותנו ב-IRC ב #אוהל-קרקס on irc.freenode.org (או אם אין לך IRC)
לקוח, שימוש מה היא אינטרנט צ'אט)
ניתן גם לפתוח שרשור ברשימת התפוצה שלנו -
http://tech.groups.yahoo.com/group/circus-dev
לעתים קרובות שאל שאלות
הנה רשימה של שאלות נפוצות על סירקוס:
איך עושה קרקס לערום לְהַשְׁווֹת ל a קלאסי לַעֲרוֹם?
במחסנית WSGI קלאסית, יש לך שרת כמו Gunicorn שמשרת על פורט או
שקע יוניקס ובדרך כלל פרוס מאחורי שרת אינטרנט כמו Nginx: [תמונה]
לקוחות קוראים ל-Nginx, אשר מעביר פרוקסי הפוך לכל הקריאות ל-Gunicorn.
אם אתם רוצים לוודא שתהליך Gunicorn ימשיך לפעול, עליכם להשתמש ב-
תוכנה כמו Supervisord או Upstart.
גוניקורן בתורו עוקב אחר התהליכים שלו ("עובדים").
במילים אחרות, אתם משתמשים בשתי רמות של ניהול תהליכים. אחת שאתם מנהלים ואחת שאתם...
בקרה (מפקח), ובקרה שנייה שעליך לנהל בממשק משתמש אחר, עם
פילוסופיה שונה ופחות שליטה על מה שקורה (זו של שרת wsgi)
זה נכון לגבי Gunicorn ורוב שרתי WSGI מרובי התהליכים שאני מכיר.
uWsgi קצת שונה מכיוון שהוא מציע שפע של אפשרויות.
אבל אם אתה רוצה להוסיף שרת Redis לערימה שלך, אתה יצטרך בסופו של דבר עם ניהול שלך
לערום תהליכים בשני מקומות שונים.
הגישה של סירקוס בנושא זה היא לנהל תהליכים ו שקעים.
ערימת סירקוס יכולה להיראות כך: [תמונה]
אז, כמו Gunicorn, Circus מסוגל לאגד שקע שיופעל באמצעות פרוקסי על ידי Nginx.
לא מטפלים בבקשות אלא פשוט קושרים את השקע. לאחר מכן זה תלוי בעובד רשת.
תהליך לקבלת חיבורים על השקע וביצוע העבודה.
הוא מספק תכונות שוות ערך לאלו של Supervisord אך גם יאפשר לך לנהל את הכל
תהליכים באותה רמה, בין אם הם עובדי אינטרנט או Redis או כל דבר אחר. הוספת
הוספת תהליך Web Worker חדש מתבצעת בדיוק כמו הוספת תהליך Redis חדש.
ספסלים
עשינו כמה ספסלים כדי להשוות את Circus & Chaussette עם Gunicorn. לסיכום, Circus הוא
מבלי להוסיף תקורה ותוכלו לבחור מגוון רחב של מערכות צד-ארכיון עבור עובדי האינטרנט שלכם.
ראה:
· 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
מילת אזהרה אחת. אם תהליך מתנדנד ורמת יומן ניפוי השגיאות מופעלת, אתה
יראה הודעות עבור כל ניסיון הפעלה. ייתכן שיהיה מועיל להגדיר את האפליקציה ש
מתנפנפים כדי להשתמש ב- עיכוב_חימום כדי להאט את ההודעות לקצב שניתן לנהל.
[צופה:אפליקציית אינטרנט]
cmd = python -m myapp.wsgi
עיכוב_חימום = 5
כברירת מחדל, stdout ו סטדרר נלכדים על ידי ה קרקסד תהליך. אם אתם בודקים את
config ורוצים לראות את הפלט בהתאם לפלט של circusd, אתם יכולים להגדיר את שלכם
הצופה להשתמש ב- StdoutStream מעמד.
[צופה:אפליקציית אינטרנט]
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
מהדורה זו מביאה תמיכה בפייתון 3.4, טורנדו 4 ו-Windows, בין כמה אפשרויות מרגשות.
תכונות ותיקונים.
התמיכה ב-Windows עדיין ניסיונית, ואינה מטפלת בזרמים.
שינויים עיקריים:
· תאימות עם Python 3.4 - #768
· תמיכה ניסיונית ב-Windows - #788
· תאימות עם טורנדו 4 - #872
· אריזה משופצת של דביאן - #896 - #903
· הוספת תמיכה בליבת תהליך Papa - #850
· הוספת התאמת globing ו-regex להפעלה, עצירה והפעלה מחדש של צופים - #829 -
#902
שינויים נוספים:
· אופטימיזציה של הכיבוי - #784 - #842
· הוספת אפשרות לציין גרסת virtualenv עבור הצופים - #805
· הוסף את האפשרות --nostop לפקודת rmwatcher - #777
· הוסף קריאה חוזרת ל-Arbiter.start - #840
· תיקון טעינת צופי זיכרון עם אותיות גדולות - #823
· הסרת שקע דולף בדמון הסטטיסטיקות - #843
· תיקון שידור מרובה ב-SunOS - #876
סגירת זרמי פלט בעת עצירת צופה - #885
· תיקון של שליחת אותות לנכדים באמצעות --recursive - #888
0.11.1 - 2014-05-22
· תוקנה רגרסיה ששברה את Circus בגרסה 2.6 - #782
0.11 - 2014-05-21
מהדורה זו לא מציגה הרבה תכונות, ומתמקדת בהפיכת Circus ל...
חזק ויציב.
שינויים/תיקונים עיקריים:
· ודא שלא נוכל לבצע שתי פקודות סותרות בו זמנית על הבורר.
· יש לנו 2 מחלקות זרמים חדשות: TimedRotatingFileStream, WatchedFileStream
· יש לנו וו חדש אחד: וו after_spawn
· קל יותר להשתמש בתוסף Circus
· תיקון autostart=משגיחים שגויים במהלך ההפעלה (רגרסיה)
שינויים נוספים:
· ניתן כעת לנתב הודעות Circus ל-syslog - #748
· האפשרות endpoint_owner נוספה כדי שנוכל להגדיר איזה משתמש מחזיק בבעלותו קבצי socket ipc שנוצרו על ידי
קרקס.
· התחלתי את התמיכה ב-Windows (רק circusctl לעת עתה)
· תיקנו הרבה דליפות בבדיקות
· אפשר משתני סביבה תלויי רישיות
· תוסף המשאבים מקבל כעת ערכי זיכרון מוחלטים - #609
· הוספת תמיכה לפקודת add עבור האפשרות 'singleton' - #767
· לאפשר שליחת אותות שרירותיים לפרוקסי צאצאים דרך צופה המשאבים - #756
· אפשר הגדרות INI/JSON/YAML לצורך רישום
· ודאו שאנחנו תואמים ל-psutil 2.x ו 3.x
· נוספו מדדים נוספים לספק ה-statsd - #698
· תוקן גילוי שידורים מרובים - #731
· להפוך את ההפעלה, ההפעלה מחדש והטעינה לאחידים יותר - #673
· אתחול נכון של כל קבוצות השימוש - #635
· יציבות משופרת של בדיקות
· עוד הרבה, הרבה דברים....
0.10 - 2013-11-04
שינויים עיקריים:
· כעת תואם לפייתון 3.2 ו-3.3 - #586
· העברת הליבה למודל אסינכרוני לחלוטין - #569
· תיעוד משופר - #622
שינויים נוספים:
· נוסף stop_signal ו-stop_children - #594
· ודא שתוסף ה-watchdog סוגר את ה-sockets - #588
· עברתי למנתח JSON של ZMQ
· IN אינו נתמך בכל הפלטפורמות - #573
· אפשר החלפות סביבה גלובליות בכל מקטע תצורה - #560
· אפשר מקפים בשמות מקטעים - #546
· כעת משתנים מורחבים בכל מקום בתצורה - #554
· נוסף התוסף CommandReloader
· נוספו ווים של before_signal ו- after_signal
· אפשר לתוסף flapping לנסות שוב ללא הגבלת זמן
· אל תפעילו מחדש פרוקס כאשר הצופה עוצר - #529 - #536
· נוסף מזהה ייחודי לכל הודעת לקוח - #517
· מזהי עובדים הם כעת "משבצות" -
· תוקנה התנהגות הכיבוי החיננית - #515
· לוודא שנוכל להוסיף צופים גם אם השופט לא התחיל - #503
· ודאו שאנחנו מציגים תהליך שפג תוקפו - #510
· ודא שהפקודה set יכולה להגדיר מספר ווים
· תמיכה נכונה ב-ipv6 sockets - #507
· אפשר אפשרויות מותאמות אישית עבור stdout_stream ו- stderr_stream - #495
· נוסף time_format עבור FileStream - #493
· נוספה אפשרות תצורת socket חדשה כדי להיקשר לממשק ספציפי לפי שם
0.9.3 - 2013-09-04
· לוודא שנוכל להוסיף צופים גם אם הבורר עדיין לא התחיל
· ודאו שאנו מציגים תהליך שפג תוקפו
· ודא שפקודת set יכולה להגדיר וו אחד או יותר
· תמיכה נכונה ב-ipv6 sockets ושיפורים של CircusSockets
· תן ערך ברירת מחדל של הנתיב כדי למנוע UnboundLocalError
· נוסף בדיקה לקיומה של multicast_endpoint באתחול הבקר
· לא ממיר יותר כל מחרוזת ספרות למספרים אינטליים
· הוספת מבחנים
אין צורך במקרים מיוחדים בעת המרת אפשרויות stdout_stream
· קבלו גם את umask כטיעון לעקביות
· אפשר אפשרויות מותאמות אישית עבור stdout_stream ו- stderr_stream.
· הוספת אפשרות תצורת שקע חדשה כדי להיקשר לממשק ספציפי לפי שם
· הוסף time_format עבור בדיקות FileStream +
· עדכון circus.upstart
0.9.2 - 2013-07-17
כאשר PYTHONPATH מוגדר בקובץ הגדרות, הוא נטען בקובץ sys.path כך שניתן יהיה ליצור hooks.
ממוקם שם - #477, #481
· השתמשו בארגומנט יחיד עבור add_callback כך שזה יעבוד עם PyZMQ < 13.1.x - ראו #478
0.9 - 2013-07-16
· נוספו תווים כלליים של מקטעים [env]
· נוסף מקטע [env] גלובלי
· תוקן חריג נסתר כאשר circus-web אינו מותקן - #424
· ודא שפקודות incr/decr באמת משתמשות באפשרות nb - #421
· תיקון חבילות אתר של watcher virtualenv שלא נמצאות ב-PYTHONPATH
· לוודא שאנחנו לא מנסים להסיר יותר תהליכים מ-0 - #429
· עדכון bootstrap.py - #436
· תוקן מפריד רב-פלטפורמות בצופה הווירטואל-ענב של pythonpath
· פונקציית סגירת שקעים שעברה שיפוץ
· יש לוודא שקטעי סביבה מוחלים על כל הצופים - #437
· הוסיפה את הפקודה reloadconfig
· הוסיף את circus.green והסיר את givent מהליבה - #441, #452
· השתקת stdout מזויף ואזהרות בבדיקות - #438
ניתן להשתמש כעת ב-$(circus.env.*) עבור כל האפשרויות בהגדרות.
· הוסיף וו של before_spawn
· תקן את הנתיב של circusd בקובץ השירות של systemd - #450
· לוודא שאנחנו יכולים לשנות ווים ולהגדיר סטרימינג דרך ממשק שורת פקודה (CRI) - #455
· מסמך משופר
· הוסיף סטטיסטיקה של spawn_count ב-watcher
· נוספו פרמטרים של min_cpu ו- min_mem בתוסף ResourceWatcher
· הוסיף את פרטי ה-FQDN לבורר.
0.8.1 - 2013-05-28
· circusd-stats נחנק מ-sockets יוניקס - #415
· תהליכי ה-circusd-stats וה-circushttpd chapter 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.
· כיסוי משופר של הבדיקות
· אפשרות ה-'service' עבור תוסף ResourceWatcher הוצאה משימוש - #404
· הוסר את השימוש ב- psutil.error
· נוספה גילוי UDP ב-circusd - #407
· כעת מאפשרים שימוש ב-globs ברמות ספרייה שרירותיות - #388
· נוספה אפשרות התצורה 'statd' - #408
· הוספת אפשרות pidfile, logoutput ו-loglevel לקובץ התצורה של circus - #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
· תוקנה אפשרות ההשרצה מחדש - #382
· ודאו שאנו משתמשים ב- int עבור פסק הזמן - #380
· להציג גם את sockets יוניקס - #381
· ודא שזה עובד עם הגרסה העדכנית ביותר של pyzmq
הציג תחביר שני לסימון fd
0.7 - 2013-04-08
· תיקון דוגמת get_arbiter לשימוש ב-dict עבור הארגומנט watchers. #304
· הוסף תיעוד לפתרון בעיות #323
· הוספת תמיכה בבניית פייתון
· הוסרו את ה-gevent ואת מעבירי השרשור. כעת משתמשים ב-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, סטטיסטיקות מלאות ומשאבים
· כעת לתהליכים יכולות להיות כותרות
· נוספה השלמה אוטומטית
· גיל תהליך/צופה נוסף בממשק המשתמש של האינטרנט
· נוספה תמיכה במנהרת SSH
· כעת משתמש ב-pyzmq.green
· נוסף סקריפט upstart ומסמך Varnish
· נוספו משתני סביבה וקטעים
· נוספה תמיכה ב-Unix sockets
· הוסיף את respawn אפשרות לצופים בריצה בודדת
· כעת משתמשים בטוקס בבדיקות
· אפשר החלפת שקעים ב-args
· ערכת נושא חדשה למסמך
· אפשרויות סיבוב חדשות לסטרימינג: max_bytes/backup_count
0.5.2 - 2012-07-26
· כעת מעדכן את מודול ה-thread מ-stdlib כדי להימנע מכמה באגים בפייתון - #203
מסך עזרה של circusctl שנראה טוב יותר
משתמש בפונקציה pustil get_nice() כאשר היא זמינה (nice הוצא משימוש) - #208
· נוספה תמיכה בגיל מקסימלי - #221
· קריאה לפונקציה listen() רק בסוקט 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 כראוי
· נוסף קוד שגיאה מסוג errno בהודעות - תיקונים ל-#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 (שולח את האירועים מ-circus ל-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.
· נוספה תמיכה עבור הכללת תיקיות בקובץ ההגדרות.
· תוקנו כמה תיאורי קבצים דולפים.
· תוקנה תקלה ביצירת ליבה (core dump) בתנועות הפלאפינג
· שיפורי מסמך
· ודא שגיאות circusd תקינות כאשר circusd אחר פועל על אותו socket.
· get_arbiter מקבל כעת מספר צופים.
· תוקן הבעיה עם cmd לעומת args לעומת קובץ executable בתהליך init.
· תוקן --start בהוספה של circusctl
0.1 - 2012-03-20
· גרסה ראשונית
איש דפים
קרקסד איש עמוד
תַקצִיר
circusd [אפשרויות] [הגדרות]
תיאור
circusd הוא התהליך העיקרי בארכיטקטורת Circus. הוא דואג להפעלת כל ה-
תהליכים. כל תהליך המנוהל על ידי Circus הוא תהליך בן של קרקסד.
טיעונים
config קובץ תצורה
אפשרויות
-ח, - עזרה
הצג את הודעת העזרה וצא
--רמת יומן רמה
ציין את רמת היומן. רמה יכול להיות מידע, באגים, קריטי, אזהרה or שגיאה.
--פלט-לוג יציאה
המיקום שבו ייכתבו יומני הרישום. אופן הפעולה המוגדר כברירת מחדל הוא לכתוב אל
stdout (ניתן לאלץ זאת על ידי העברת '-' לאפשרות זו). מקבל שם קובץ
אחרת.
--logger-config קונפיגורציית לוגר
המיקום שבו נמצא קובץ INI, JSON או YAML של תצורת לוגר פייתון סטנדרטית
ניתן למצוא. ניתן להשתמש בזה כדי לעקוף את תצורת הרישום המוגדרת כברירת מחדל עבור
הבורר.
--דימון
התחל להשמיע סירקוס ברקע.
--pidfile PIDFILE
מיקום קובץ ה-PID.
--גִרְסָה
מציג את גרסת הקרקס ויוצא.
לִרְאוֹת גם
קרקס (1), סירקוסקטל (1), סטטיסטיקות circusd (1), תוסף קרקס (1), קרקס-טופ (1).
תיעוד מלא זמין ב http://circus.readthedocs.org
סירקוסקטל איש עמוד
תַקצִיר
circusctl [אפשרויות] פקודה [ארגומנטים]
תיאור
circusctl הוא ממשק משתמש לשליטה בדמון Circus. הוא נועד לעזור ל-
מנהל שולט בתפקוד המעגל קרקסד דמון.
פקודות
להוסיף הוסף צופה
פסק דין הפחתת מספר התהליכים בצופה
dstats קבל סטטיסטיקות של סירקוס
לקבל קבל את הערך של אפשרויות צופה ספציפיות
גלובלאופציות
קבלו את אפשרויות הבורר
תוספת הגדלת מספר התהליכים בצופה
פִּיתוֹן
יצירת מעטפת בתהליך circusd
רשימה קבל רשימה של צופים או תהליכים בצופה
להקשיב הירשמו לאירוע צופה
רשימות שקעים
קבל את רשימת השקעים
תהליכים מספריים
קבל את מספר התהליכים
צופי מספרים
קבל את מספר הצופים
אפשרויות
קבל את הערך של כל האפשרויות עבור צופה
להפסיק לעזוב את הבורר מיד
לטעון מחדש טען מחדש את הבורר או את הצופה
טען מחדש את התצורה
טען מחדש את קובץ התצורה
הפעלה מחדש
הפעל מחדש את הבורר או את הצופה
rm הסר צופה
סט הגדר אפשרות צופה
אוֹת שלח אות
התחלה התחל את הבורר או הצופה
סטטיסטיקות קבל מידע על התהליך
מצב קבל את הסטטוס של צופה או של כל הצופים
להפסיק עצור צופים
אפשרויות
--נקודת קצה נקודת קצה
נקודת קצה של החיבור
-ח, - עזרה
הצג את הודעת העזרה וצא
--json פלט ל-JSON
--לְיַפּוֹת
לייפות את הפלט
--שש SSH
שרת SSH בפורמט משתמש@מארח:יציאה
--ssh_keyfile SSH_KEYFILE
נתיב לקובץ המפתחות כדי לאשר את המשתמש
--פסק זמן פסק זמן
זמן תפוגה של החיבור
--גִרְסָה
מציג את גרסת הקרקס ויוצא.
לִרְאוֹת גם
קרקס (1), קרקסד (1), סטטיסטיקות circusd (1), תוסף קרקס (1), קרקס-טופ (1).
תיעוד מלא זמין ב http://circus.readthedocs.org
תוסף קרקס איש עמוד
תַקצִיר
תוסף-circus [אפשרויות] [תוסף]
תיאור
התוסף circus מאפשר להפעיל תוסף מדמון Circus שפועל.
טיעונים
חיבור שם מלא של מחלקת התוסף.
אפשרויות
--נקודת קצה נקודת קצה
נקודת קצה של החיבור.
--פאבסאב פאבסאב
שקע הפאב/סאב של circusd ZeroMQ להתחברות.
--config התצורה
קובץ התצורה של התוסף.
--עיכוב-בדיקה עיכוב_המחאה
בדיקת עיכוב.
--רמת יומן רמה
ציין את רמת היומן. רמה יכול להיות מידע, באגים, קריטי, אזהרה or שגיאה.
--פלט-לוג יציאה
המיקום שבו ייכתבו יומני הרישום. אופן הפעולה המוגדר כברירת מחדל הוא לכתוב אל
stdout (ניתן לאלץ זאת על ידי העברת '-' לאפשרות זו). מקבל שם קובץ
אחרת.
--שש SSH
שרת SSH בפורמט משתמש@מארח:יציאה.
-ח, - עזרה
הצג את הודעת העזרה וצא.
--גִרְסָה
מציג את גרסת הקרקס ויוצא.
לִרְאוֹת גם
קרקס (1), קרקסד (1), סירקוסקטל (1), סטטיסטיקות circusd (1), קרקס-טופ (1).
תיעוד מלא זמין ב http://circus.readthedocs.org
קרקס-טופ איש עמוד
תַקצִיר
טופ-קרקס [אפשרויות]
תיאור
קרקס-טופ הוא חלק עליוןפקודה דמוית-כדי להציג את הדמון של סירקוס ותהליכים המנוהלים על ידי
קרקס.
אפשרויות
--נקודת קצה נקודת קצה
נקודת קצה של החיבור.
--שש SSH
שרת SSH בפורמט משתמש@מארח:יציאה.
--זמן-קצוב-לתהליך זמן_קצת_לעיבוד
לאחר עיכוב זה של חוסר פעילות, תהליך יוסר.
-ח, - עזרה
הצג את הודעת העזרה וצא.
--גִרְסָה
מציג את גרסת הקרקס ויוצא.
לִרְאוֹת גם
קרקס (1), סירקוסקטל (1), קרקסד (1), סטטיסטיקות circusd (1), תוסף קרקס (1).
תיעוד מלא זמין ב http://circus.readthedocs.org
סטטיסטיקות circusd איש עמוד
תַקצִיר
circusd-stats [אפשרויות]
תיאור
circusd-stats מפעיל את צובר הסטטיסטיקות עבור Circus.
אפשרויות
--נקודת קצה נקודת קצה
נקודת קצה של החיבור.
--פאבסאב פאבסאב
שקע הפאב/סאב של circusd ZeroMQ להתחברות.
--נקודת סטטיסטיקה סטטספוינט
שקע הפאב/סאב של ZeroMQ שאליו יש לשלוח נתונים.
--רמת יומן רמה
ציין את רמת היומן. רמה יכול להיות מידע, באגים, קריטי, אזהרה or שגיאה.
--פלט-לוג יציאה
המיקום שבו ייכתבו יומני הרישום. אופן הפעולה המוגדר כברירת מחדל הוא לכתוב אל
stdout (ניתן לאלץ זאת על ידי העברת '-' לאפשרות זו). מקבל שם קובץ
אחרת.
--שש SSH
שרת SSH בפורמט משתמש@מארח:יציאה.
-ח, - עזרה
הצג את הודעת העזרה וצא.
--גִרְסָה
מציג את גרסת הקרקס ויוצא.
לִרְאוֹת גם
קרקס (1), קרקסד (1), סירקוסקטל (1), תוסף קרקס (1), קרקס-טופ (1).
תיעוד מלא זמין ב http://circus.readthedocs.org
מילון מונחים: ספציפי לקרקס מונחים
פוסק
השמיים פוסק אחראי על ניהול כל הצופים בקרקס, תוך הבטחה
כל התהליכים פועלים כראוי.
בקר
A בקר מכיל את קבוצת הפעולות שניתן לבצע על הבורר.
מתנפנפים
השמיים מתנפנפים זיהוי נרשם לאירועים ומזהה מתי תהליכים מסוימים פועלים
הפעלה מחדש ללא הרף.
פאב/סאב
יש לקרקס פאבסאב שמקבל אירועים מהצופים ושולח אותם אליהם
כל המנויים.
מרחוק בקר
השמיים מרחוק בקר מאפשר לך לתקשר עם הבקר דרך ZMQ כדי
שליטה בקרקס.
צוֹפֶה, צופים
A צוֹפֶה היא התוכנית שאתה מורה ל-Circus להפעיל. מופע יחיד של Circus יכול לפעול
צופה אחד או יותר.
עוֹבֵד, עובדים, תַהֲלִיך, תהליכים
A תהליך הוא מופע תהליך מערכת הפעלה עצמאי של התוכנית שלך. צופה יחיד
יכולים להריץ תהליך אחד או יותר. אנו קוראים להם גם עובדים.
זכויות יוצרים
סירקוס יוזם על ידי טארק זיאדה והוא מורשה תחת 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
השתמש ב-Circus Online באמצעות שירותי onworks.net
