ละครสัตว์ - ออนไลน์ในคลาวด์

โครงการ:

ชื่อ

ละครสัตว์ - เอกสารเกี่ยวกับคณะละครสัตว์ [ภาพ]

Circus เป็นโปรแกรม Python ที่สามารถใช้ตรวจสอบและควบคุมกระบวนการและซ็อกเก็ตได้

สามารถขับเคลื่อน Circus ผ่านอินเทอร์เฟซบรรทัดคำสั่ง เว็บอินเทอร์เฟซ หรือโดยทางโปรแกรม
ผ่าน python API

หากต้องการติดตั้งและลองใช้คุณลักษณะ โปรดดูตัวอย่างหรืออ่านส่วนที่เหลือของหน้านี้
สำหรับการแนะนำอย่างรวดเร็ว

วิ่ง A ละคร เดมอน

Circus จัดให้มีการเรียกสคริปต์บรรทัดคำสั่ง ละครสัตว์ ที่สามารถใช้จัดการกระบวนการต่างๆ ได้
จัดอยู่ในผู้ดูตั้งแต่หนึ่งคนขึ้นไป

เครื่องมือบรรทัดคำสั่งของ Circus สามารถกำหนดค่าได้โดยใช้ไฟล์การกำหนดค่าแบบ ini

นี่เป็นตัวอย่างที่น้อยมาก:

[ผู้ดู:โปรแกรม]
cmd = หลาม myprogram.py
จำนวนกระบวนการ = 5

[ผู้ดู:โปรแกรมอื่น]
cmd = another_program
จำนวนกระบวนการ = 2

ไฟล์จะถูกส่งต่อไปยัง ละครสัตว์:

$ ละครสัตว์ example.ini

นอกจากกระบวนการแล้ว Circus ยังสามารถผูกซ็อกเก็ตได้ เนื่องจากทุกกระบวนการที่จัดการโดย Circus คือ
ลูกของภูตละครสัตว์หลักนั่นหมายถึงโปรแกรมใด ๆ ที่ควบคุมโดย Circus can
ใช้ซ็อกเก็ตเหล่านั้น

การรันซ็อกเก็ตทำได้ง่ายเพียงแค่เพิ่ม a เบ้า ส่วนในไฟล์ปรับแต่ง:

[ซ็อกเก็ต: mysocket]
โฮสต์ = localhost
พอร์ต = 8080

หากต้องการเรียนรู้เพิ่มเติมเกี่ยวกับซ็อกเก็ต โปรดดูที่ซ็อกเก็ต

เพื่อให้เข้าใจว่าเหตุใดจึงเป็นคุณลักษณะนักฆ่า ให้อ่านว่าทำไมcircussockets

การควบคุม ละคร

Circus มีเครื่องมือบรรทัดคำสั่งสองแบบเพื่อจัดการ daemon ที่ทำงานอยู่ของคุณ:

· วงเวียน, คอนโซลการจัดการที่คุณสามารถใช้เพื่อดำเนินการต่างๆ เช่น เพิ่มหรือ
ถอดคนงาน

· ละครสัตว์ด้านบน, คอนโซลด้านบนที่คุณสามารถใช้เพื่อแสดงหน่วยความจำและการใช้งาน cpu ของ your
วิ่งละครสัตว์

หากต้องการเรียนรู้เพิ่มเติมเกี่ยวกับสิ่งเหล่านี้ โปรดดูที่ cli

Circus ยังมีเว็บแดชบอร์ดที่สามารถเชื่อมต่อกับ Circus daemon ที่กำลังทำงานอยู่และให้คุณ
ตรวจสอบและโต้ตอบกับมัน

หากต้องการเรียนรู้เพิ่มเติมเกี่ยวกับคุณลักษณะนี้ โปรดดูที่ circushttpd

อะไร ตอนนี้ ?
หากคุณเป็นนักพัฒนาและต้องการใช้ประโยชน์จาก Circus ในโครงการของคุณเอง ให้เขียนปลั๊กอินหรือ
ขอไป fordevs

หากคุณเป็นผู้ปฏิบัติการและต้องการจัดการกระบวนการของคุณโดยใช้ Circus ให้ไปที่ forops

มีส่วนร่วม และ ข้อเสนอแนะ
เพิ่มเติมเกี่ยวกับการบริจาค: ผลงาน

ลิงก์ที่เป็นประโยชน์:

· มีรายชื่อส่งจดหมายสำหรับข้อเสนอแนะหรือคำถาม:
http://tech.groups.yahoo.com/group/circus-dev/

· ที่เก็บและตัวติดตามปัญหาอยู่บน GitHub : https://github.com/circus-tent/circus

· เข้าร่วมกับเราใน IRC : Freenode, channel #เต็นท์ละครสัตว์

เอกสาร ดัชนี
การติดตั้ง วงเวียน
Circus เป็นแพ็คเกจ Python ซึ่งเผยแพร่บน PyPI - ดัชนีแพ็คเกจ Python

วิธีที่ง่ายที่สุดในการติดตั้งคือการใช้ pip ซึ่งเป็นเครื่องมือสำหรับติดตั้งและจัดการ Python
แพคเกจ:

$ pip ติดตั้งละครสัตว์

หรือดาวน์โหลด เก็บ on PyPIแยกและติดตั้งด้วยตนเองด้วย:

$ python setup.py ติดตั้ง

หากคุณต้องการลองใช้ Circus ดูตัวอย่าง

หากคุณกำลังใช้การแจกแจงแบบเดเบียนหรือการแจกแจงแบบเดเบียน คุณสามารถใช้ ppa to
ติดตั้งละครสัตว์ได้ที่ https://launchpad.net/~roman-imankulov/+archive/circus

zc.buildout
เราให้บริการ zc.buildout การกำหนดค่าคุณสามารถใช้งานได้โดยเพียงแค่เรียกใช้ bootstrap
สคริปต์แล้วเรียก buildout:

$ หลาม bootstrap.py
$ ถังขยะ / buildout

เพิ่มเติม on ข้อกำหนด
คณะละครสัตว์ทำงานร่วมกับ:

· หลาม 2.6, 2.7, 3.2 หรือ 3.3

·

ศูนย์mq >= 2.1.10

· เวอร์ชันของ zeromq ที่รองรับจะขึ้นอยู่กับเวอร์ชันของ
พีซเอ็มคิว ถูกติดตั้งโดย pip ระหว่างการติดตั้งละครสัตว์

· รุ่นปัจจุบันรองรับเวอร์ชัน 2.x (จำกัด), 3.x และ 4.x ZeroMQ

· หมายเหตุ: หากคุณใช้ PyPy แทน CPython อย่าลืมอ่าน
เอกสารการติดตั้งเนื่องจากการสนับสนุนเวอร์ชัน ZeroMQ นั้นไม่เหมือนกันใน PyPy

เมื่อคุณติดตั้ง circus เวอร์ชันล่าสุดของการขึ้นต่อกันของ Python จะถูกดึงออกมา
สำหรับคุณ

คุณยังสามารถติดตั้งได้ด้วยตนเองโดยใช้ไฟล์ pip-requirements.txt ที่เรามีให้:

$ pip ติดตั้ง -r pip-requirements.txt

หากคุณต้องการเรียกใช้เว็บคอนโซล คุณจะต้องติดตั้ง ละครสัตว์เว็บ:

$ pip ติดตั้ง circus-web

การกวดวิชา
เป็นขั้นเป็นตอน เกี่ยวกับการสอน
การขอ ตัวอย่าง ไดเรกทอรี ในคลังเก็บละครสัตว์มีตัวอย่างมากมายเพื่อให้คุณได้
เริ่มต้นแล้ว แต่นี่คือบทช่วยสอนฉบับสมบูรณ์ที่ให้ภาพรวมของคุณลักษณะต่างๆ แก่คุณ

เราจะดูแลแอปพลิเคชัน WSGI

การติดตั้ง
Circus ได้รับการทดสอบบน Mac OS X และ Linux ด้วย Python 2.6, 2.7, 3.2 และ 3.3 ล่าสุด ถึง
ดำเนินการละครสัตว์เต็มรูปแบบคุณจะต้อง libzmq, เสรีภาพ & Virtualenv.

บนระบบที่ใช้เดเบียน:

$ sudo apt-get ติดตั้ง libzmq-dev libevent-dev python-dev python-virtualenv

สร้าง virtualenv และติดตั้ง ละครสัตว์, ละครสัตว์เว็บ และ ถุงเท้า ในนั้น

$virtualenv /tmp/ละครสัตว์
$ cd /tmp/ละครสัตว์
$ bin/pip ติดตั้งละครสัตว์
$ bin/pip ติดตั้ง circus-web
$ bin/pip ติดตั้ง chaussette

เมื่อเสร็จแล้ว คุณจะพบคำสั่งมากมายใน local bin dir

การใช้
ถุงเท้า มาพร้อมกับแอพ Hello world เริ่มต้น ลองเรียกใช้:

$ bin / chaussette

คุณควรจะสามารถเยี่ยมชม http://localhost: 8080 และดู สวัสดี โลก.

หยุด Chaussette และเพิ่มไฟล์ circus.ini ในไดเร็กทอรีที่มี:

[ละครสัตว์]
สถิติ = 1
httpd = 1

[ผู้ดู:webapp]
cmd = bin/chaussette --fd $(circus.sockets.web)
จำนวนกระบวนการ = 3
use_sockets = จริง

[ซ็อกเก็ต:เว็บ]
โฮสต์ = 127.0.0.1
พอร์ต = 9999

ไฟล์กำหนดค่านี้บอกให้ Circus ผูกซ็อกเก็ตบนพอร์ต 9999 และเรียกใช้คนงาน chaussette 3 คน
ต่อต้านมัน นอกจากนี้ยังเปิดใช้งานแดชบอร์ดเว็บ Circus และโมดูลสถิติ

บันทึกและเรียกใช้โดยใช้ ละครสัตว์:

$ bin/circusd --daemon circus.ini

ตอนนี้ไปที่ http://127.0.0.1: 9999คุณควรเห็นแอปสวัสดีชาวโลก ความแตกต่างตอนนี้คือ
ที่ซ็อกเก็ตถูกจัดการโดย Circus และมีพนักงานเว็บหลายคนที่ยอมรับ
การเชื่อมต่อกับมัน

หมายเหตุ:
การทำโหลดบาลานซ์ดำเนินการโดยระบบปฏิบัติการ ดังนั้นคุณจะได้ความเร็วเท่ากัน
เช่นเดียวกับเว็บเซิร์ฟเวอร์ pre-fork อื่น ๆ เช่น Apache หรือ NGinx คณะละครสัตว์ไม่รบกวน
ข้อมูลที่ผ่าน

นอกจากนี้คุณยังสามารถเยี่ยมชม http://localhost: 8080 / และเพลิดเพลินไปกับแดชบอร์ดเว็บของ Circus

ปฏิสัมพันธ์
ลองใช้เปลือก circusctl ในขณะที่ระบบกำลังทำงาน:

$ bin/circusctl
circusctl0.7.1
circusd-stats: ใช้งานอยู่
circushttpd: ใช้งานอยู่
เว็บแอพ: active
(วงเวียน)

คุณเข้าสู่เชลล์แบบโต้ตอบ พิมพ์ ช่วย เพื่อรับคำสั่งทั้งหมด:

(circusctl) ช่วย

เอกสารคำสั่ง (พิมพ์ help ):
========================================
เพิ่มรายการรับ numprocesses ออกจาก rm เริ่มหยุด
Decr globaloptions ฟัง numwatchers โหลดชุดสถิติใหม่
dstats incr ตัวเลือก listockets รีสตาร์ทสถานะสัญญาณ

คำสั่งที่ไม่มีเอกสาร:
======================
EOF ช่วย

มาลองทำสิ่งพื้นฐานกัน มาแสดงรายการกระบวนการทำงานบนเว็บและเพิ่มกระบวนการใหม่:

(circusctl) รายการ webapp
13712,13713,13714
(circusctl) รวมเว็บแอป
4
(circusctl) รายการ webapp
13712,13713,13714,13973

ยินดีด้วย คุณได้โต้ตอบกับคณะละครสัตว์ของคุณแล้ว! ออกจากเชลล์ด้วย Ctrl+D แล้วรัน
วงเวียนด้านบน:

$ ถังขยะ / คณะละครสัตว์

นี่เป็นคำสั่งยอดนิยมในการดูหน่วยความจำและการใช้งาน CPU ของกระบวนการทั้งหมดของคุณแบบเรียลไทม์

กด Ctrl+C แล้วออกจาก Circus อย่างสมบูรณ์ผ่าน circus-ctl:

$ bin/circusctl ออก
ok

ถัดไป ทำตามขั้นตอน
คุณสามารถเสียบแอปพลิเคชัน WSGI ของคุณเองแทน Hello world ของ Chaussette ได้ง่ายๆ โดย
ชี้โปรแกรม callable.

Chaussette ยังมาพร้อมกับแบ็กเอนด์มากมาย เช่น Gevent หรือ Meinheld

อ่าน https://chaussette.readthedocs.org/ สำหรับตัวเลือกทั้งหมด

ทำไม น่า I ใช้ วงเวียน แทน of X ?
1. วงเวียน ช่วยลดความยุ่งยาก ธุรกิจ เว็บ กอง กระบวนการ การจัดการ

คณะละครสัตว์รู้วิธีจัดการกระบวนการต่างๆ และ ซ็อกเก็ต ดังนั้นคุณไม่จำเป็นต้องมอบหมาย web
การจัดการคนงานไปยังเซิร์ฟเวอร์ WGSI

ดูว่าทำไมcircussockets

2. วงเวียน ให้ ผับ/ย่อย และ มา การแจ้งเตือน ผ่านทาง ZeroMQ
Circus มีช่องผับ/ช่องย่อยที่คุณสามารถสมัครรับข้อมูลได้ ช่องนี้รับทุกงาน
ที่เกิดขึ้นในละครสัตว์ ตัวอย่างเช่น คุณสามารถรับการแจ้งเตือนเมื่อกระบวนการกระพือหรือ
สร้างไคลเอนต์ที่ทริกเกอร์คำเตือนเมื่อบางกระบวนการกิน CPU ทั้งหมดหรือ
แกะ.

เหตุการณ์เหล่านี้ถูกส่งผ่านช่อง ZeroMQ ซึ่งทำให้แตกต่างจาก stdin
สตรีมที่หัวหน้าใช้:

· Circus ส่งงานกิจกรรมแบบไฟไหม้และลืม ดังนั้นจึงไม่จำเป็นต้องวนซ้ำด้วยตนเอง
ตลอด ทั้งหมด ผู้ฟังและรักษาสถานะของพวกเขา

· สมาชิกสามารถระบุตำแหน่งบนโฮสต์ระยะไกลได้

Circus ยังมีวิธีรับการอัปเดตสถานะผ่านโพลแบบครั้งเดียวใน req/rep
ช่อง. ซึ่งหมายความว่าคุณสามารถรับข้อมูลของคุณได้โดยไม่ต้องสมัครสมาชิก a
ลำธาร. คำสั่ง cli ที่จัดทำโดย Circus ใช้ช่องสัญญาณนี้

ดูตัวอย่าง

3. วงเวียน is (หลาม) ผู้พัฒนา เป็นมิตร
ในขณะที่ Circus สามารถขับเคลื่อนด้วยไฟล์ปรับแต่งและ วงเวียน / ละครสัตว์
คำสั่ง มันง่ายที่จะนำมาใช้ใหม่ทั้งหมดหรือบางส่วนของระบบเพื่อสร้างกำหนดเองของคุณเอง
ตัวตรวจสอบกระบวนการใน Python

ทุกชั้นของระบบถูกแยกออก คุณจึงนำกลับมาใช้ใหม่ได้โดยอิสระ:

· ตัวห่อหุ้มกระบวนการ (กระบวนการ)

· ตัวจัดการกระบวนการ (กะลาสี)

· ผู้จัดการระดับโลกที่ดูแลผู้จัดการกระบวนการหลายคน (ผู้ตัดสิน)

· และอื่นๆ…

4. วงเวียน ตาชั่ง
กรณีการใช้งานหนึ่งของ Circus คือการจัดการกระบวนการนับพันโดยไม่ต้องเพิ่ม
ค่าใช้จ่าย -- เราทุ่มเทเพื่อเน้นเรื่องนี้

มา จาก ผู้ดูแล
Supervisor เป็นวิธีแก้ปัญหาที่ได้รับความนิยมมากในโลกของ Python และเรามักถูกถามถึงวิธีการ Circus
เปรียบเทียบกับมัน

ถ้าคุณมาจาก ผู้ดูแลหน้านี้พยายามให้ภาพรวมว่าเครื่องมือต่างๆ เป็นอย่างไร
แตกต่าง

ความแตกต่าง ภาพรวม
หัวหน้างานและคณะละครสัตว์มีเป้าหมายเดียวกัน - พวกเขาทั้งสองจัดการกระบวนการและจัดหา a
สคริปต์บรรทัดคำสั่ง — ตามลำดับ supervisord และ ละครสัตว์ — ที่อ่านการกำหนดค่า
แยกไฟล์ แยกกระบวนการใหม่ และรักษาไว้

Circus มีคุณสมบัติพิเศษ: ความสามารถในการผูกซ็อกเก็ตและปล่อยให้กระบวนการจัดการ
ใช้มัน. โมเดล "pre-fork" นี้ถูกใช้โดยเว็บเซิร์ฟเวอร์จำนวนมากเช่น อาปาเช่ or
ตัวยูนิคอน. การมีตัวเลือกนี้ใน Circus จะทำให้สแต็กเว็บแอปง่ายขึ้น: กระบวนการทั้งหมดและ
ซ็อกเก็ตถูกจัดการด้วยเครื่องมือเดียว

ทั้งสองโปรเจ็กต์มีวิธีควบคุม daemon ที่ทำงานอยู่ผ่านสคริปต์อื่น ตามลำดับ
Supervisorctl และ วงเวียน. พวกเขาทั้งสองมีกิจกรรมและวิธีการสมัครรับข้อมูล
ความแตกต่างที่สำคัญคือเทคโนโลยีพื้นฐาน: หัวหน้างานใช้ XML-RPC สำหรับการโต้ตอบ
กับภูตในขณะที่ Circus ใช้ ZeroMQ

Circus & Supervisor ต่างก็มีเว็บอินเตอร์เฟสเพื่อแสดงสิ่งที่เกิดขึ้น ละครสัตว์มีมากกว่า
ขั้นสูงเพราะคุณสามารถติดตามสิ่งที่เกิดขึ้นแบบเรียลไทม์และโต้ตอบกับภูต
มันใช้เว็บซ็อกเก็ตและได้รับการพัฒนาในโครงการแยกต่างหาก (ละครสัตว์เว็บ.)

มีความแตกต่างที่ลึกซึ้งอื่น ๆ อีกมากมายในการออกแบบหลัก เราอาจแสดงรายการที่นี่ในวันหนึ่ง... ใน
ในระหว่างนี้ คุณสามารถเรียนรู้เพิ่มเติมเกี่ยวกับการออกแบบภายในคณะละครสัตว์ได้

องค์ประกอบ
ทั้งสองระบบใช้ไฟล์คล้าย ini เป็นการกำหนดค่า

· ผู้ดูแล เอกสาร

· วงเวียน เอกสาร

ต่อไปนี้คือตัวอย่างเล็กๆ ของการเรียกใช้แอปพลิเคชันกับ Supervisor ในกรณีนี้
แอปพลิเคชันจะเริ่มต้นและเริ่มต้นใหม่ในกรณีที่เกิดปัญหา

[โปรแกรม:ตัวอย่าง]
คำสั่ง = npm เริ่มต้น
ไดเรกทอรี=/home/www/my-server/
ผู้ใช้=www-data
autostart = true
รีสตาร์ทอัตโนมัติ=จริง
redirect_stderr=จริง

ใน Circus การกำหนดค่าเดียวกันทำได้โดย:

[ผู้ดู:ตัวอย่าง]
cmd=npm เริ่ม
working_dir=/home/www/เซิร์ฟเวอร์ของฉัน/
ผู้ใช้=www-data
stderr_stream.class=StdoutStream

โปรดสังเกตว่าการเปลี่ยนเส้นทาง stderr นั้นแตกต่างกันเล็กน้อยใน Circus ไม่มีเครื่องมือ
a หาง คุณสมบัติเหมือนในหัวหน้างาน แต่จะช่วยให้คุณขอรหัสใด ๆ เพื่อจัดการกับ
กระแสที่เข้ามา คุณสามารถสร้าง stream hook ของคุณเอง (เป็นคลาส) และทำทุกอย่างที่คุณ
ต้องการกับกระแสที่เข้ามา Circus มีคลาสสตรีมในตัวเช่น
StdoutStream, ไฟล์สตรีม, ดู FileStreamหรือ หมดเวลา RotatingFileStream.

วงเวียน สำหรับ Ops
คำเตือน:
ตามค่าเริ่มต้น Circus จะไม่รักษาความปลอดภัยของข้อความเมื่อส่งข้อมูลผ่าน ZeroMQ
ก่อนใช้งาน Circus ในสภาพแวดล้อมที่ใช้งานจริง อย่าลืมอ่านหน้าความปลอดภัย

ขั้นตอนแรกในการจัดการ Circus daemon คือการเขียนไฟล์การกำหนดค่า ดู
การกำหนดค่า หากคุณกำลังปรับใช้เว็บสแต็ก ให้ดูที่ซ็อกเก็ต

Circus สามารถปรับใช้ได้โดยใช้ Python 2.6, 2.7, 3.2 หรือ 3.3 - การปรับใช้ส่วนใหญ่มีอยู่
ทำใน 2.7 หากต้องการเรียนรู้วิธีปรับใช้ Circus โปรดดูการปรับใช้

ในการจัดการ Circus daemon คุณควรทำความคุ้นเคยกับรายการคำสั่งที่คุณสามารถใช้ได้
in วงเวียน. สังเกตว่าคุณสามารถได้รับความช่วยเหลือออนไลน์เช่นเดียวกันเมื่อคุณวิ่ง วงเวียน เป็น
เปลือก.

นอกจากนี้เรายังมีบริการ ละครสัตว์ด้านบนดู cli และแดชบอร์ดเว็บที่ดี ดูละครสัตว์httpd.

สุดท้ายนี้ เพื่อให้ได้ประโยชน์สูงสุดจาก Circus อย่าลืมดูวิธีใช้ปลั๊กอินและตะขอ
ดูปลั๊กอินและตะขอ

Ops เอกสาร ดัชนี
องค์ประกอบ
ละครสัตว์สามารถกำหนดค่าได้โดยใช้ไฟล์การกำหนดค่าแบบ ini

ตัวอย่าง:

[ละครสัตว์]
ตรวจสอบ_ล่าช้า = 5
จุดปลาย = tcp://127.0.0.1:5555
pubsub_endpoint = tcp://127.0.0.1:5556
รวม = \*.more.config.ini
อูมาสก์ = 002

[ผู้ดู:myprogram]
cmd = หลาม
args = -u myprogram.py $(circus.wid) $(CIRCUS.ENV.VAR)
วอร์มอัพ_ดีเลย์ = 0
จำนวนกระบวนการ = 5

#ตะขอ
hooks.before_start = my.hooks.control_redis

# จะผลักดันใน test.log สตรีมทุก ๆ 300 ms
stdout_stream.class = FileStream
stdout_stream.filename = test.log

# เลือกหมุนไฟล์บันทึกเมื่อถึง 1 gb
# และบันทึก 5 สำเนาของไฟล์ที่หมุน
stdout_stream.max_bytes = 1073741824
stdout_stream.backup_count = 5

[env:โปรแกรมของฉัน]
เส้นทาง = $เส้นทาง:/ bin
เค้ก = โกหก

[ปลั๊กอิน:statsd]
ใช้ = circus.plugins.statsd.StatsdEmitter
โฮสต์ = localhost
พอร์ต = 8125
อัตราการสุ่มตัวอย่าง = 1.0
application_name = ตัวอย่าง

[ซ็อกเก็ต:เว็บ]
โฮสต์ = localhost
พอร์ต = 8080

ละครสัตว์ - เดียว ส่วน
ปลายทาง
ซ็อกเก็ต ZMQ ใช้เพื่อจัดการ Circus ผ่าน วงเวียน. (ค่าเริ่มต้น:
TCP://127.0.0.1:5555)

endpoint_owner
หากตั้งค่าเป็นชื่อผู้ใช้ระบบและปลายทางเป็นซ็อกเก็ต ipc เช่น
ipc://var/run/circusd.sockจากนั้นความเป็นเจ้าของไฟล์ซ็อกเก็ตจะเปลี่ยนเป็น
ผู้ใช้รายนั้นเมื่อเริ่มต้น สำหรับรายละเอียดเพิ่มเติม โปรดดูความปลอดภัย (ค่าเริ่มต้น: ไม่มี)

pubsub_endpoint
ซ็อกเก็ต ZMQ PUB/SUB ได้รับการเผยแพร่เหตุการณ์ (ค่าเริ่มต้น:
TCP://127.0.0.1:5556)

papa_endpoint
หากใช้ papa คุณสามารถระบุจุดสิ้นสุดได้ เช่น ipc://var/run/circusd.sock.
(ค่าเริ่มต้น: TCP://127.0.0.1:20202)

สถิติ หากตั้งค่าเป็น True Circus จะเรียกใช้ circusd-stats daemon (ค่าเริ่มต้น: เท็จ)

stats_endpoint
ซ็อกเก็ต ZMQ PUB/SUB ได้รับการเผยแพร่สถิติ (ค่าเริ่มต้น:
TCP://127.0.0.1:5557)

statsd_close_outputs
หาก True ส่ง circusd-stats stdout/stderr ไปที่ /dev/null (ค่าเริ่มต้น: เท็จ)

ตรวจสอบ_ล่าช้า
ช่วงเวลาการหยั่งเสียงเป็นวินาทีสำหรับซ็อกเก็ต ZMQ (ค่าเริ่มต้น: 5)

ประกอบด้วย
รายการไฟล์ปรับแต่งที่จะรวม คุณสามารถใช้ไวด์การ์ด (*) เพื่อรวมโดยเฉพาะ
แบบแผนสำหรับไฟล์ของคุณ เส้นทางเป็นแบบสัมบูรณ์หรือสัมพันธ์กับไฟล์ปรับแต่ง
(ค่าเริ่มต้น: ไม่มี)

รวม_dir
รายการไดเร็กทอรี config ไฟล์ทั้งหมดที่ตรงกัน *.นี่ ภายใต้แต่ละไดเร็กทอรี will
รวมอยู่ด้วย เส้นทางเป็นแบบสัมบูรณ์หรือสัมพันธ์กับไฟล์ปรับแต่ง (ค่าเริ่มต้น:
ไม่มี)

stream_backend
กำหนดประเภทของแบ็กเอนด์ที่จะใช้สำหรับการสตรีม ค่าที่เป็นไปได้คือ ด้าย
or เกเวนต์. (ค่าเริ่มต้น: เธรด)

วอร์มอัพ_ดีเลย์
ช่วงเวลาเป็นวินาทีระหว่างผู้ดูสองคนเริ่มต้นขึ้น ต้องเป็น int. (ค่าเริ่มต้น: 0)

httpd หากตั้งค่าเป็น True Circus จะเรียกใช้ circushttpd daemon (ค่าเริ่มต้น: เท็จ)

httpd_host
โฮสต์ดำเนินการโดย circushttpd daemon (ค่าเริ่มต้น: localhost)

httpd_port
พอร์ตที่ดำเนินการโดย circushttpd daemon (ค่าเริ่มต้น: 8080)

httpd_close_outputs
หากเป็น True ส่ง circushttpd stdout/stderr ไปที่ /dev/null (ค่าเริ่มต้น: เท็จ)

การแก้ปัญหา หากตั้งค่าเป็น True Circus stout/stderr daemons ทั้งหมดจะถูกเปลี่ยนเส้นทางไปที่ circusd
stdout/stderr (ค่าเริ่มต้น: เท็จ)

debug_gc
หากตั้งค่าเป็น True circusd จะแสดงข้อมูลบันทึกเพิ่มเติมจากตัวรวบรวมขยะ
สิ่งนี้มีประโยชน์ในการติดตามการรั่วไหลของหน่วยความจำ (ค่าเริ่มต้น: เท็จ)

ไฟล์ pid
ไฟล์ที่ต้องใช้เพื่อเก็บ daemon pid

อูมาสก์ คุ้มค่าสำหรับ umask หากไม่ได้ตั้งค่า circusd จะไม่พยายามแก้ไข umask

ระดับการบันทึก
ระดับบันทึกที่เราต้องการดู (ค่าเริ่มต้น: INFO)

ออกจากระบบ
ไฟล์ logoutput ที่เราต้องการบันทึก (ค่าเริ่มต้น: - เพื่อเข้าสู่ระบบ stdout) คุณสามารถ
เข้าสู่ระบบ syslog ระยะไกลโดยใช้ไวยากรณ์ต่อไปนี้:
syslog://host:port?สิ่งอำนวยความสะดวก โดยที่โฮสต์คือเซิร์ฟเวอร์ syslog ของคุณ พอร์ตเป็นทางเลือก
และสิ่งอำนวยความสะดวกคือสิ่งอำนวยความสะดวก syslog ที่จะใช้ หากคุณต้องการเข้าสู่ระบบ syslog . ในเครื่อง
คุณสามารถใช้ได้ syslog:///path/to/syslog/socket?facility แทน.

ล็อกเกอร์คอนฟิกูเรชัน
เส้นทางไปยังไฟล์ INI, JSON หรือ YAML เพื่อกำหนดค่าการบันทึก Python มาตรฐานสำหรับ
อนุญาโตตุลาการ ค่าพิเศษ "ค่าเริ่มต้น" ใช้การกำหนดค่าการบันทึกในตัว
ขึ้นอยู่กับตัวเลือกระดับบันทึกและล็อกเอาต์ที่เลือกได้

ตัวอย่าง ย.ม องค์ประกอบ เนื้อไม่มีมัน

รุ่น: 1
ปิดการใช้งาน_existing_loggers: เท็จ
ตัวจัดรูปแบบ:
ง่าย:
รูปแบบ: '%(asctime)s - %(name)s - [%(levelname)s] %(message)s'
ตัวจัดการ:
ไฟล์บันทึก:
คลาส: logging.FileHandler
ชื่อไฟล์: logoutput.txt
ระดับ: DEBUG
รูปแบบ: ง่าย
คนตัดไม้:
คณะละครสัตว์:
ระดับ: DEBUG
ตัวจัดการ: [logfile]
เผยแพร่: ไม่
ราก:
ระดับ: DEBUG
ตัวจัดการ: [logfile]

ผู้เฝ้ามอง:NAME - as หลาย ส่วน as เธอ ต้องการ
ชื่อ ชื่อผู้เฝ้า. ชื่อนี้ใช้ใน วงเวียน

cmd โปรแกรมปฏิบัติการที่จะรัน

args อาร์กิวเมนต์บรรทัดคำสั่งเพื่อส่งผ่านไปยังโปรแกรม คุณสามารถใช้รูปแบบหลาม
ไวยากรณ์ที่นี่เพื่อสร้างพารามิเตอร์ มีตัวแปรสภาพแวดล้อมเช่น
รวมถึงรหัสผู้ปฏิบัติงานและตัวแปรสภาพแวดล้อมที่คุณส่งผ่าน หากมี
ด้วยพารามิเตอร์ "env" ดู การจัดรูปแบบ คำสั่ง และ ข้อโต้แย้ง สีสดสวย พลวัต
ตัวแปร สำหรับข้อมูลเพิ่มเติมเกี่ยวกับเรื่องนี้

เปลือกหอย หากเป็น True กระบวนการจะทำงานในเชลล์ (ค่าเริ่มต้น: False)

เชลล์_args
อาร์กิวเมนต์บรรทัดคำสั่งที่จะส่งผ่านไปยังคำสั่งเชลล์เมื่อ เปลือกหอย เป็นความจริง. ผลงาน
สำหรับระบบ *nix เท่านั้น (ค่าเริ่มต้น: ไม่มี)

Working_dir
dir ทำงานสำหรับกระบวนการ (ค่าเริ่มต้น: ไม่มี)

UID ID ผู้ใช้หรือชื่อที่คำสั่งควรรันด้วย (uid ปัจจุบันคือ
ค่าเริ่มต้น).

กิด รหัสกลุ่มหรือชื่อที่คำสั่งควรรันด้วย (กิดปัจจุบันคือ
ค่าเริ่มต้น).

copy_env
หากตั้งค่าเป็น true ตัวแปรสภาพแวดล้อมโลคัลจะถูกคัดลอกและส่งผ่านไปยัง
คนงานเมื่อวางไข่พวกเขา (ค่าเริ่มต้น: เท็จ)

copy_path
หากตั้งค่าเป็นจริง sys.path ถูกส่งผ่านในสภาพแวดล้อมกระบวนการย่อยโดยใช้ ไพธอนพาธ.
copy_env จะต้องเป็นจริง (ค่าเริ่มต้น: เท็จ)

วอร์มอัพ_ดีเลย์
ความล่าช้า (เป็นวินาที) ระหว่างกระบวนการที่ทำงานอยู่

ออโต้
หากตั้งค่าเป็นเท็จ ผู้เฝ้าจะไม่เริ่มทำงานโดยอัตโนมัติเมื่อผู้ชี้ขาด
เริ่ม ผู้สังเกตการณ์สามารถเริ่มต้นได้อย่างชัดเจน (ตัวอย่าง: วงกลม เริ่มต้น
โปรแกรมของฉัน). (ค่าเริ่มต้น: จริง)

จำนวนกระบวนการ
จำนวนกระบวนการที่จะรันสำหรับผู้สังเกตการณ์รายนี้

rlimit_LIMIT
ตั้งค่าขีดจำกัดทรัพยากร LIMIT สำหรับกระบวนการที่เฝ้าดู ชื่อการกำหนดค่าควรตรงกัน
ค่าคงที่ RLIMIT_* (ไม่คำนึงถึงตัวพิมพ์เล็กและตัวพิมพ์ใหญ่) ที่ระบุไว้ใน หลาม ทรัพยากร โมดูล
การอ้างอิง. ตัวอย่างเช่น บรรทัดกำหนดค่า 'rlimit_nofile = 500' ตั้งค่าสูงสุด
จำนวนไฟล์ที่เปิดอยู่ที่ 500 หากต้องการตั้งค่าขีดจำกัดเป็น RLIM_INFINITY อย่าตั้งค่า a
ค่า เช่น config บรรทัดนี้: 'rlimit_nofile = '

stderr_stream.class
ชื่อคลาส Python ที่ผ่านการรับรองโดยสมบูรณ์ซึ่งจะถูกสร้างอินสแตนซ์และจะได้รับ
สตเดอร์ กระแสของกระบวนการทั้งหมดในนั้น __เรียก__() วิธี

Circus มีคลาสสตรีมบางคลาสที่คุณสามารถใช้ได้โดยไม่มีคำนำหน้า:

· ไฟล์สตรีม: เขียนในไฟล์และสามารถหมุนบันทึกอัตโนมัติได้

· ดู FileStream: เขียนในไฟล์และอาศัยการหมุนบันทึกภายนอก

· หมดเวลา RotatingFileStream: เขียนในไฟล์และสามารถหมุนได้ตามเวลาที่กำหนด
ช่วงเวลา

· คิวสตรีม: เขียนในคิวความทรงจำ

· StdoutStream: เขียนใน stdout

· แฟนซีสเตดเอาท์สตรีม: เขียนเอาต์พุตสีพร้อมคำนำหน้าเวลาใน stdout

stderr_stream.*
ตัวเลือกทั้งหมดที่ขึ้นต้นด้วย stderr_stream. นอกเหนือจาก ชั้น จะผ่าน
ตัวสร้างเมื่อสร้างอินสแตนซ์ของคลาสที่กำหนดไว้ใน
stderr_stream.class.

stdout_stream.class
ชื่อคลาส Python ที่ผ่านการรับรองโดยสมบูรณ์ซึ่งจะถูกสร้างอินสแตนซ์และจะได้รับ
แย่ กระแสของกระบวนการทั้งหมดในนั้น __เรียก__() วิธี

Circus มีคลาสสตรีมบางคลาสที่คุณสามารถใช้ได้โดยไม่มีคำนำหน้า:

· ไฟล์สตรีม: เขียนในไฟล์และสามารถหมุนบันทึกอัตโนมัติได้

· ดู FileStream: เขียนในไฟล์และอาศัยการหมุนบันทึกภายนอก

· หมดเวลา RotatingFileStream: เขียนในไฟล์และสามารถหมุนได้ตามเวลาที่กำหนด
ช่วงเวลา

· คิวสตรีม: เขียนในคิวความทรงจำ

· StdoutStream: เขียนใน stdout

· แฟนซีสเตดเอาท์สตรีม: เขียนเอาต์พุตสีพร้อมคำนำหน้าเวลาใน stdout

stdout_stream.*
ตัวเลือกทั้งหมดที่ขึ้นต้นด้วย stdout_stream. นอกเหนือจาก ชั้น จะผ่าน
ตัวสร้างเมื่อสร้างอินสแตนซ์ของคลาสที่กำหนดไว้ใน
stdout_stream.class.

close_child_stdout
หากตั้งค่าเป็น True สตรีม stdout ของแต่ละกระบวนการจะถูกส่งไปยัง /dev/null
หลังส้อม ค่าเริ่มต้นเป็นเท็จ

close_child_stderr
หากตั้งค่าเป็น True สตรีม stderr ของแต่ละกระบวนการจะถูกส่งไปยัง /dev/null
หลังส้อม ค่าเริ่มต้นเป็นเท็จ

send_hup
หากเป็น True จะทำการโหลดกระบวนการใหม่โดยการส่งสัญญาณ SIGHUP ค่าเริ่มต้น
เป็นเท็จ

หยุด_สัญญาณ
สัญญาณที่จะส่งเมื่อหยุดกระบวนการ สามารถระบุเป็นตัวเลขหรือ a
ชื่อสัญญาณ ชื่อสัญญาณไม่คำนึงถึงขนาดตัวพิมพ์และสามารถรวม 'SIG' ได้หรือไม่ ดังนั้น
ตัวอย่างที่ถูกต้องได้แก่ เลิก, INT, ซิกเทอร์ม และ 3. ค่าดีฟอลต์เป็น SIGTERM

stop_children
เมื่อส่ง หยุด_สัญญาณ,ส่งให้เด็กๆด้วยนะครับ. ค่าเริ่มต้นเป็น
เท็จ

max_retry
จำนวนครั้งที่เราพยายามเริ่มกระบวนการ ก่อนที่เราจะละทิ้งและหยุด
ผู้เฝ้าดูทั้งหมด ค่าเริ่มต้นเป็น 5. ตั้งค่าเป็น -1 เพื่อปิดใช้งาน max_retry และลองใหม่อีกครั้ง
อย่างไม่มีกำหนด

สง่างาม_timeout
จำนวนวินาทีที่รอให้กระบวนการสิ้นสุดอย่างงดงามก่อน
ฆ่ามัน.

เมื่อหยุดกระบวนการ ขั้นแรก เราจะส่ง หยุด_สัญญาณ. คนงานอาจจับสิ่งนี้
สัญญาณให้ดำเนินการล้างข้อมูลก่อนออก ถ้าคนงานยังอยู่
ทำงานหลังจากเวลาผ่านไปที่ graceful_timeout วินาที เราจะส่งสัญญาณ SIGKILL ไปให้ มันไม่ใช่
สามารถจับสัญญาณ SIGKILL เพื่อให้คนงานหยุด

ค่าเริ่มต้นเป็น 30 วินาที

ลำดับความสำคัญ
จำนวนเต็มที่กำหนดลำดับความสำคัญสำหรับผู้เฝ้าดู เมื่ออนุญาโตตุลาการทำบางอย่าง
การดำเนินการกับผู้ดูทั้งหมดจะเรียงลำดับตามฟิลด์นี้จากที่ใหญ่กว่า
จำนวนที่น้อยที่สุด ค่าเริ่มต้นเป็น 0

เดี่ยว
หากตั้งค่าเป็น True ผู้เฝ้าดูรายนี้จะมีกระบวนการมากที่สุด XNUMX ขั้นตอน ค่าเริ่มต้นเป็น
เท็จ

use_sockets
หากตั้งค่าเป็น True ผู้เฝ้าดูนี้จะสามารถเข้าถึงซ็อกเก็ตที่กำหนดผ่าน
คำอธิบายไฟล์ หากเป็นเท็จ fds พาเรนต์ทั้งหมดจะถูกปิดเมื่อโปรเซสลูกเป็น
ง่าม ค่าเริ่มต้นเป็นเท็จ

สูงสุด_อายุ
หากตั้งค่าไว้ กระบวนการจะเริ่มต้นใหม่หลังจาก max_age วินาที นี้
มีประโยชน์เมื่อกระบวนการจัดการกับกลุ่มของตัวเชื่อมต่อ: การรีสตาร์ทกระบวนการ
ปรับปรุงการปรับสมดุลโหลด ค่าเริ่มต้นที่จะปิดการใช้งาน

max_age_variance
หากตั้งค่า max_age ไว้ กระบวนการจะทำงานระหว่าง max_age และ max_age +
สุ่ม(0, max_age_variance) วินาที สิ่งนี้จะหลีกเลี่ยงการรีสตาร์ทกระบวนการทั้งหมดสำหรับ a
ผู้เฝ้าดูในครั้งเดียว ค่าเริ่มต้นคือ 30 วินาที

ตามความต้องการ
หากตั้งค่าเป็น True กระบวนการจะเริ่มขึ้นหลังจากการเชื่อมต่อกับ .ครั้งแรกเท่านั้น
หนึ่งในซ็อกเก็ตที่กำหนดค่าไว้ (ดูด้านล่าง) หากจำเป็นต้องรีสตาร์ท มันจะเป็น
ทริกเกอร์ในเหตุการณ์ซ็อกเก็ตถัดไปเท่านั้น

ตะขอ*
ตะขอที่มีจำหน่าย: before_start, after_start, before_spawn, after_spawn,
ก่อน_หยุด, อาฟเตอร์_สต็อป, ก่อน_สัญญาณ, after_signal, Extended_stats

กำหนดฟังก์ชันการโทรกลับที่เชื่อมโยงกับกระบวนการเริ่มต้น/ปิดตัวตรวจสอบ

ถ้าเบ็ดกลับมา เท็จ และถ้าเบ็ดเป็นหนึ่งใน before_start, before_spawn,
after_start or after_spawnการเริ่มต้นจะถูกยกเลิก

ถ้าเบ็ดคือ ก่อน_สัญญาณ และผลตอบแทน เท็จแล้วสัญญาณที่สอดคล้องกัน
จะไม่ถูกส่ง (ยกเว้น SIGKILL ที่ส่งเสมอ)

ขอให้สังเกตว่า hook ที่ล้มเหลวระหว่างกระบวนการหยุดจะไม่ยกเลิก

คำจำกัดความการโทรกลับสามารถตามด้วยแฟล็กบูลีนที่คั่นด้วยเครื่องหมายจุลภาค
เมื่อตั้งค่าสถานะเป็น จริงข้อผิดพลาดใด ๆ ที่เกิดขึ้นในเบ็ดจะถูกละเว้น ถ้า
ตั้งค่าให้ เท็จ (ค่าเริ่มต้น) เบ็ดจะกลับมา เท็จ.

เพิ่มเติมเกี่ยวกับตะขอ

Virtualenv
เมื่อระบุ ให้ชี้ไปที่รูทของไดเร็กทอรี Virtualenv ผู้เฝ้าดูจะ
สแกนท้องถิ่น ไซต์แพ็คเกจ และโหลดเนื้อหาลงในการดำเนินการ
สิ่งแวดล้อม. ต้องใช้กับ copy_env ตั้งค่าเป็น True ค่าเริ่มต้นเป็นไม่มี

virtualenv_py_ver
ระบุเวอร์ชันหลามของ virtualenv (เช่น "3.3") มันมีประโยชน์ถ้า
circus รันด้วย python เวอร์ชันอื่น (เช่น "2.7") ผู้เฝ้าดูจะสแกน
ในประเทศ ไซต์แพ็คเกจ ของเวอร์ชันหลามที่ระบุและโหลดเนื้อหาลงใน
สภาพแวดล้อมการดำเนินการ ต้องใช้กับ Virtualenv. ค่าเริ่มต้นเป็นไม่มี

respawn
หากตั้งค่าเป็น "เท็จ" กระบวนการที่จัดการโดยผู้สังเกตการณ์จะไม่เกิดใหม่
โดยอัตโนมัติ กระบวนการสามารถเกิดใหม่ได้ด้วยตนเองด้วย เริ่มต้น คำสั่ง
(ค่าเริ่มต้น: จริง)

use_papa
ตั้งค่าเป็นจริงเพื่อใช้พ่อ

ซ็อกเก็ต:NAME - 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' ให้ผูกซ็อกเก็ตกับสิ่งนั้น
อุปกรณ์เฉพาะเพื่อให้เฉพาะแพ็กเก็ตที่ได้รับจากอินเทอร์เฟซเฉพาะนั้น
ถูกประมวลผลโดยซ็อกเก็ต สามารถใช้ตัวอย่างเช่นเพื่อ จำกัด อุปกรณ์
เพื่อผูกเมื่อผูกกับ IN_ADDR_ANY (0.0.0.0) หรือ IN_ADDR_BROADCAST
(255.255.255.255). โปรดทราบว่าวิธีนี้ใช้ได้กับซ็อกเก็ตบางประเภทเท่านั้น โดยเฉพาะ
ซ็อกเก็ต AF_INET

เส้นทาง เมื่อระบุพาธไปยังไฟล์ที่จะใช้เป็นไฟล์ซ็อกเก็ตยูนิกซ์ ถ้า
มีเส้นทางให้ ครอบครัว ถูกบังคับให้ AF_UNIX และ เจ้าภาพ และ พอร์ต จะถูกละเว้น

อูมาสก์ เมื่อมีให้ ตั้งค่า umask ที่จะใช้เพื่อสร้างซ็อกเก็ต AF_UNIX สำหรับ
ตัวอย่าง, อูมาสก์=000 จะสร้างซ็อกเก็ตโดยได้รับอนุญาต 777.

แทนที่
เมื่อสร้างซ็อกเก็ต Unix ('AF_UNIX') ไฟล์ที่มีอยู่อาจบ่งบอกถึงปัญหา
ดังนั้นค่าเริ่มต้นคือล้มเหลว ระบุ จริง เพียงแค่ลบไฟล์เก่าถ้าคุณเป็น
ตรวจสอบให้แน่ใจว่าซ็อกเก็ตได้รับการจัดการโดย Circus เท่านั้น

so_reuseport
หากตั้งค่าเป็น True และ SO_REUSEPORT พร้อมใช้งานบนแพลตฟอร์มเป้าหมาย คณะละครสัตว์ will
สร้างและผูกซ็อกเก็ต SO_REUSEPORT ใหม่สำหรับผู้ปฏิบัติงานทุกคนที่เริ่มต้นซึ่งก็คือa
ผู้ใช้ซ็อกเก็ตนี้

use_papa
ตั้งค่าเป็นจริงเพื่อใช้พ่อ

เมื่อสร้างซ็อกเก็ตแล้ว ${circus.sockets.NAME} สามารถใช้สตริงในคำสั่ง
(cmd or args) ของผู้เฝ้า Circus จะแทนที่ด้วยค่า FD ผู้เฝ้าก็ต้องเช่นกัน
มี use_sockets ตั้งค่าให้ จริง มิฉะนั้นซ็อกเก็ตจะถูกปิดและคุณจะได้รับ
ข้อผิดพลาดเมื่อผู้เฝ้าดูพยายามใช้

ตัวอย่าง:

[ผู้ดู:เว็บเวิร์คเกอร์]
cmd = chaussette --fd $ (circus.sockets.webapp) chaussette.util.bench_app
use_sockets = จริง

[ซ็อกเก็ต: เว็บแอพ]
โฮสต์ = 127.0.0.1
พอร์ต = 8888

ปลั๊กอิน:NAME - as หลาย ส่วน as เธอ ต้องการ
ใช้ ชื่อแบบเต็มซึ่งชี้ไปที่คลาสปลั๊กอิน

สิ่งใด อื่น
ทุกคีย์อื่น ๆ ที่พบในส่วนนี้จะถูกส่งไปยังตัวสร้างปลั๊กอินใน
การตั้งค่า การทำแผนที่

คุณสามารถใช้ตัวเลือกผู้ดูทั้งหมดได้ เนื่องจากปลั๊กอินเริ่มทำงานเหมือนผู้ดู

Circus มาพร้อมกับปลั๊กอินที่จัดส่งไว้ล่วงหน้าสองสามตัว แต่คุณยังสามารถขยายได้อย่างง่ายดายโดย
พัฒนาตัวเอง.

env or env[:ผู้ดู] - as หลาย ส่วน as เธอ ต้องการ
สิ่งใด
ชื่อของตัวแปรสภาพแวดล้อมที่จะกำหนดค่าให้ สภาพแวดล้อมสไตล์ทุบตี
รองรับการทดแทน ตัวอย่างเช่น ผนวก / bin ไปยัง เส้นทาง 'เส้นทาง =
$เส้นทาง:/ bin'

ส่วนที่รับผิดชอบในการส่งตัวแปรสภาพแวดล้อมเพื่อรันกระบวนการ

ตัวอย่าง:

[ผู้เฝ้าดู:คนงาน1]
cmd = ปิง 127.0.0.1

[ผู้เฝ้าดู:คนงาน2]
cmd = ปิง 127.0.0.1

[สิ่งแวดล้อม]
เค้ก = โกหก

ตัวแปร เค้ก จะเผยแพร่ไปยังผู้ดูทั้งหมดที่กำหนดไว้ในไฟล์ปรับแต่ง

WATCHERS สามารถเป็นรายการส่วนผู้สังเกตการณ์ที่คั่นด้วยเครื่องหมายจุลภาคเพื่อใช้สภาพแวดล้อมนี้
หากส่วน env หลายส่วนตรงกับผู้ดู พวกเขาจะถูกรวมตามลำดับที่ปรากฏใน
ไฟล์การกำหนดค่า รายการในภายหลังจะมีความสำคัญ

ตัวอย่าง:

[ผู้เฝ้าดู:คนงาน1]
cmd = ปิง 127.0.0.1

[ผู้เฝ้าดู:คนงาน2]
cmd = ปิง 127.0.0.1

[env:คนงาน1,คนงาน2]
เส้นทาง = / bin

[env:คนงาน1]
เส้นทาง = $เส้นทาง

[env:คนงาน2]
เค้ก = โกหก

คนงาน1 จะถูกเรียกใช้ด้วย PATH = $PATH (ขยายจากสภาพแวดล้อมที่เรียกใช้ circusd)
คนงาน2 จะถูกรันด้วย PATH = / bin และเค้ก = โกหก

คุณสามารถใช้ไวด์การ์ดได้เช่นกัน

ตัวอย่าง:

[ผู้เฝ้าดู:คนงาน1]
cmd = ปิง 127.0.0.1

[ผู้เฝ้าดู:คนงาน2]
cmd = ปิง 127.0.0.1

[env:คนงาน*]
เส้นทาง = / bin

ทั้งสอง คนงาน1 และ คนงาน2 จะถูกรันด้วย PATH = / bin

การใช้ สิ่งแวดล้อม ตัวแปร
เมื่อเขียนไฟล์การกำหนดค่า คุณสามารถใช้ตัวแปรสภาพแวดล้อมที่กำหนดไว้ใน env
ส่วนหรือใน ระบบปฏิบัติการ.สภาพแวดล้อม ตัวเอง

คุณเพียงแค่ต้องใช้ คณะละครสัตว์.env. คำนำหน้า

ตัวอย่าง:

[ผู้เฝ้าดู:คนงาน1]
cmd = $ (circus.env.shell)

[ผู้เฝ้าดู:คนงาน2]
baz = $(circus.env.user)
บาร์ = $(circus.env.yeah)
ซุป = $(circus.env.oh)

[ซ็อกเก็ต:ซ็อกเก็ต1]
พอร์ต = $(circus.env.port)

[ปลั๊กอิน:ปลั๊กอิน1]
ใช้ = some.path
พารามิเตอร์1 = $(circus.env.plugin_param)

[สิ่งแวดล้อม]
ใช่ = บู

[env:คนงาน2]
โอ้ = โอเค

หากมีการกำหนดตัวแปรในหลายตำแหน่ง ค่าเฉพาะมากที่สุดจะมีลำดับความสำคัญเหนือกว่า: a
ตัวแปรที่กำหนดไว้ใน สิ่งแวดล้อม:XXX จะแทนที่ตัวแปรที่กำหนดไว้ใน envซึ่งจะแทนที่ a
ตัวแปรที่กำหนดไว้ใน ระบบปฏิบัติการ.สภาพแวดล้อม.

สามารถใช้การทดแทนสภาพแวดล้อมในส่วนใดก็ได้ของการกำหนดค่าในส่วนใดก็ได้
ตัวแปร

การจัดรูปแบบ คำสั่ง และ ข้อโต้แย้ง สีสดสวย พลวัต ตัวแปร
อย่างที่คุณอาจเห็นแล้ว เป็นไปได้ที่จะส่งข้อมูลบางอย่างที่คำนวณมา
แบบไดนามิกเมื่อรันกระบวนการ เหนือสิ่งอื่นใด คุณสามารถรับ ID ผู้ปฏิบัติงานได้
(WID) และตัวเลือกทั้งหมดที่ส่งผ่านไปยัง กระบวนการ. นอกจากนี้ยังสามารถ
เข้าถึงตัวเลือกที่ส่งผ่านไปยัง กะลาสี ซึ่งเป็นตัวกำหนดกระบวนการ

หมายเหตุ:
รหัสผู้ปฏิบัติงานแตกต่างจากรหัสกระบวนการ เป็นค่าเฉพาะ เริ่มที่ 1
ซึ่งเป็นเอกลักษณ์เฉพาะสำหรับผู้ดูเท่านั้น

ตัวอย่างเช่น หากคุณต้องการเข้าถึงตัวแปรบางตัวที่อยู่ในสภาพแวดล้อม
คุณจะต้องตั้งค่าดังนี้:

cmd = "make-me-a-coffee --sugar $ (CIRCUS.ENV.SUGAR_AMOUNT)"

ใช้ได้กับทั้ง cmd และ args.

สำคัญ:

· ตัวแปรทั้งหมดนำหน้าด้วย คณะละครสัตว์

· การแทนที่ไม่คำนึงถึงตัวพิมพ์เล็กและตัวพิมพ์ใหญ่

กระแส องค์ประกอบ
คลาสสตรีมง่าย ๆ เช่น คิวสตรีม และ StdoutStream ไม่มีคุณลักษณะเฉพาะแต่
คลาสสตรีมอื่น ๆ อาจมีบางส่วน:

ไฟล์สตรีม
ชื่อไฟล์
เส้นทางของไฟล์ที่จะเขียนบันทึก

เวลา_รูปแบบ
รูปแบบ strftime ที่จะใช้นำหน้าแต่ละครั้งด้วยการประทับเวลา โดย
ค่าเริ่มต้นจะไม่นำหน้า

เช่น: %Y-%m-%d %H:%M:%S

สูงสุด_ไบต์
ขนาดสูงสุดของล็อกไฟล์ก่อนเริ่มไฟล์ใหม่ หากไม่ระบุ
ไฟล์จะไม่ถูกพลิกกลับ

สำรองข้อมูล
จำนวนไฟล์บันทึกที่จะถูกเก็บไว้ โดยค่าเริ่มต้น backup_count เป็นโมฆะ

หมายเหตุ:
โรลโอเวอร์จะเกิดขึ้นทุกครั้งที่ล็อกไฟล์ปัจจุบันมีความยาวเกือบ 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" เป็นต้น ตามลำดับ

ตัวอย่าง:

[ผู้ดู:myprogram]
cmd = หลาม -m myapp.server

stdout_stream.class = FileStream
stdout_stream.filename = test.log
stdout_stream.time_format = %Y-%m-%d %H:%M:%S
stdout_stream.max_bytes = 1073741824
stdout_stream.backup_count = 5

ดู FileStream
ชื่อไฟล์
เส้นทางของไฟล์ที่จะเขียนบันทึก

เวลา_รูปแบบ
รูปแบบ strftime ที่จะใช้นำหน้าแต่ละครั้งด้วยการประทับเวลา โดย
ค่าเริ่มต้นจะไม่นำหน้า

เช่น: %Y-%m-%d %H:%M:%S

หมายเหตุ:
WatchedFileStream อาศัยเครื่องมือหมุนบันทึกภายนอกเพื่อให้แน่ใจว่าไฟล์บันทึก
อย่าใหญ่เกินไป ไฟล์เอาต์พุตจะถูกตรวจสอบและหากไฟล์นั้นถูกลบหรือ
ย้ายโดยเครื่องมือหมุนบันทึกภายนอก จากนั้นตัวจัดการไฟล์เอาต์พุตจะเป็น
โหลดซ้ำโดยอัตโนมัติ

ตัวอย่าง:

[ผู้ดู:myprogram]
cmd = หลาม -m myapp.server

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

หมดเวลา RotatingFileStream
ชื่อไฟล์
เส้นทางของไฟล์ที่จะเขียนบันทึก

สำรองข้อมูล
จำนวนไฟล์บันทึกที่จะถูกเก็บไว้ โดยค่าเริ่มต้น backup_count เป็นโมฆะ

เวลา_รูปแบบ
รูปแบบ strftime ที่จะใช้นำหน้าแต่ละครั้งด้วยการประทับเวลา โดย
ค่าเริ่มต้นจะไม่นำหน้า

เช่น: %Y-%m-%d %H:%M:%S

หมุน_เมื่อ
ประเภทของช่วงเวลา รายการค่าที่เป็นไปได้อยู่ด้านล่าง โปรดทราบว่าพวกเขากำลัง
ไม่คำนึงถึงขนาดตัวพิมพ์

┌────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────...
│ค่า │ ประเภทของช่วงเวลา │
├────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────...
│'S' │ วินาที │
├────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────...
│'M' │ นาที │
├────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────...
│'H' │ ชั่วโมง │
├────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────...
│'D' │ วัน │
├────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────...
│'W0'-'W6' │ วันธรรมดา (0=วันจันทร์) │
├────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────...
│'เที่ยงคืน' │ ทบเวลาเที่ยงคืน │
└────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────...

rotator_interval
ช่วงโรลโอเวอร์

หมายเหตุ:
TimedRotatingFileStream หมุนล็อกไฟล์ตามช่วงเวลาที่กำหนด ช่วงเวลาโรลโอเวอร์
ถูกกำหนดโดยผลรวมของrotation_whenและrotation_interval

ตัวอย่าง:

[ผู้ดู:myprogram]
cmd = หลาม -m myapp.server

stdout_stream.class = TimedRotatingFileStream
stdout_stream.filename = test.log
stdout_stream.time_format = %Y-%m-%d %H:%M:%S
stdout_stream.utc = จริง
stdout_stream.rotate_when = H
stdout_stream.rotate_interval = 1

แฟนซีสเตดเอาท์สตรีม
สี

การขอ พร้อมชื่อ of an ASCII สี:

· สีแดง

· เขียว

· สีเหลือง

· สีฟ้า

· สีม่วงแดง

· สีฟ้า

· สีขาว

เวลา_รูปแบบ
รูปแบบ strftime ที่แต่ละบรรทัดจะขึ้นต้นด้วย

ค่าเริ่มต้นเป็น: %Y-%m-%d %H:%M:%S

ตัวอย่าง:

[ผู้ดู:myprogram]
cmd = หลาม -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: คำสั่ง/decr

· ดีสแตท: คำสั่ง/dstats

· ได้รับ: คำสั่ง/get

· ตัวเลือกระดับโลก: คำสั่ง/globaloptions

· รวม: คำสั่ง/incr

· หลาม: คำสั่ง/ipython

· รายการ: คำสั่ง/รายการ

· ฟัง: คำสั่ง/ฟัง

· listockets: คำสั่ง/listsockets

· จำนวนกระบวนการ: คำสั่ง/numprocesses

· นักดูตัวเลข: คำสั่ง/numwatchers

· ตัวเลือก: คำสั่ง/ตัวเลือก

· เลิก: คำสั่ง/ออก

· โหลด: คำสั่ง/โหลดซ้ำ

· โหลดการกำหนดค่าใหม่: คำสั่ง/reloadconfig

· การเริ่มต้นใหม่: คำสั่ง/รีสตาร์ท

· rm: คำสั่ง/rm

· เซ็ต: คำสั่ง/set

· สัญญาณ: คำสั่ง/สัญญาณ

· เริ่มต้น: คำสั่ง/เริ่ม

· สถิติ: คำสั่ง/สถิติ

· สถานะ: คำสั่ง/สถานะ

· หยุด: คำสั่ง/หยุด

เพิ่ม a กะลาสี
คำสั่งนี้เพิ่มผู้ดูแบบไดนามิกให้กับผู้ตัดสิน

ซีเอ็มคิว ระบุความประสงค์หรือข้อมูลเพิ่มเติม
{
"คำสั่ง": "เพิ่ม",
"คุณสมบัติ": {
"cmd": "/path/to/commandline --option"
"name": "nameofwatcher"
"args": [],
"ตัวเลือก": {},
"เริ่มต้น": เท็จ
}
}

ข้อความประกอบด้วย 2 คุณสมบัติ:

· cmd: บรรทัดคำสั่งแบบเต็มเพื่อดำเนินการในกระบวนการ

· args: อาร์เรย์ อาร์กิวเมนต์ที่ส่งผ่านไปยังคำสั่ง (ทางเลือก)

· ชื่อ: ชื่อผู้ดู

·ตัวเลือก: ตัวเลือกของผู้ดู

· เริ่มต้น: เริ่มการเฝ้าติดตามหลังจากการสร้าง

การตอบสนองส่งคืนสถานะ "ตกลง"

คำสั่ง เส้น
$ circusctl เพิ่ม [--เริ่ม]

Options
· : ชื่อผู้ดูที่จะสร้าง

· : บรรทัดคำสั่งแบบเต็มเพื่อดำเนินการในกระบวนการ

· --start: เริ่มการดูทันที

การลดลง จำนวน of กระบวนการ in a กะลาสี
ความคิดเห็นนี้ลดจำนวนกระบวนการในตัวดูโดย , 1 เป็น
ค่าเริ่มต้น.

ซีเอ็มคิว ระบุความประสงค์หรือข้อมูลเพิ่มเติม
{
"command": "decr",
"คุณสมบัติ": {
"ชื่อ": " "
"นบี":
"กำลังรอ": เท็จ
}
}

การตอบสนองส่งคืนจำนวนกระบวนการในคุณสมบัติ 'numprocesses':

{ "สถานะ": "ตกลง", "ประมวลผลจำนวน": , "เวลา", "ประทับเวลา" }

คำสั่ง เส้น
$ circusctl Decr [ ] [--ที่รอ]

Options
· : ชื่อผู้เฝ้า

· : จำนวนกระบวนการที่จะลบ

เข้ามา ละครสัตว์ สถิติ
คุณสามารถรับสถิติเกี่ยวกับ circusd ได้ตลอดเวลาด้วยคำสั่ง dstat

ซีเอ็มคิว ระบุความประสงค์หรือข้อมูลเพิ่มเติม
ในการรับสถิติ circusd ให้เรียกใช้:

{
"command": "dstats"
}

การตอบสนองส่งคืนการแมปคุณสมบัติ "infos" ที่มีข้อมูลกระบวนการบางอย่าง:

{
"ข้อมูล": {
"เด็ก": [],
"cmdline": "หลาม",
"ซีพียู": 0.1,
"ctime": "0:00.41",
"เมม": 0.1,
"mem_info1": "3M",
"mem_info2": "2G",
"สวย": 0,
"ปี๊ด": 47864,
"ชื่อผู้ใช้": "รูท"
},
"สถานะ": "ตกลง",
"เวลา": 1332265655.897085
}

คำสั่ง Line
$circuitl dstats

เข้ามา ความคุ้มค่า of โดยเฉพาะ กะลาสี ตัวเลือก
คำสั่งนี้สามารถใช้เพื่อสอบถามค่าปัจจุบันของตัวเลือกตัวตรวจสอบตั้งแต่หนึ่งตัวขึ้นไป

ซีเอ็มคิว ระบุความประสงค์หรือข้อมูลเพิ่มเติม
{
"คำสั่ง": "รับ",
"คุณสมบัติ": {
"คีย์": ["key1, "key2"]
"name": "nameofwatcher"
}
}

ข้อความขอมีคุณสมบัติสองประการ:

· คีย์: รายการ ปุ่มตัวเลือกที่คุณต้องการรับค่า

· ชื่อ: ชื่อผู้ดู

วัตถุตอบสนองมีคุณสมบัติ ตัวเลือก ซึ่งเป็นพจนานุกรมของชื่อตัวเลือกและ
ค่า

เช่น:

{
"สถานะ": "ตกลง",
"ตัวเลือก": {
"graceful_timeout": 300,
"send_hup": จริง
},
เวลา': 1332202594.754644
}

คำสั่ง เส้น
$ circusctl รับ

เข้ามา ผู้ตัดสิน ตัวเลือก
คำสั่งนี้ส่งคืนตัวเลือกผู้ตัดสิน

ซีเอ็มคิว ระบุความประสงค์หรือข้อมูลเพิ่มเติม
{
"command": "globaloptions",
"คุณสมบัติ": {
"key1": "val1",
..
}
}

ข้อความประกอบด้วย 2 คุณสมบัติ:

· คีย์: รายการ ปุ่มตัวเลือกที่คุณต้องการรับค่า

การตอบสนองส่งคืนอ็อบเจ็กต์ที่มีคุณสมบัติ "ตัวเลือก" ที่มีรายการคีย์/ค่า
กลับมาโดยคณะละครสัตว์

เช่น:

{
"สถานะ": "ตกลง",
"ตัวเลือก": {
"check_delay": 1,
...
},
เวลา': 1332202594.754644
}

คำสั่ง เส้น
$circultl globaloption

Options
ปุ่มตัวเลือกคือ:

· จุดสิ้นสุด: จุดปลาย ZMQ ของตัวควบคุม

· pubsub_endpoint: จุดสิ้นสุด pubsub

· check_delay: ความล่าช้าระหว่างจุดควบคุมสองจุด

· multicast_endpoint: จุดปลายแบบหลายผู้รับสำหรับการค้นพบอัตโนมัติของคลัสเตอร์ circusd

การเพิ่มขึ้น จำนวน of กระบวนการ in a กะลาสี
ความคิดเห็นนี้เพิ่มจำนวนกระบวนการในตัวดูโดย , 1 เป็น
ผิดนัด

ซีเอ็มคิว ระบุความประสงค์หรือข้อมูลเพิ่มเติม
{
"คำสั่ง": "incr",
"คุณสมบัติ": {
"ชื่อ": " ",
"นบี": ,
"กำลังรอ": เท็จ
}
}

การตอบสนองส่งคืนจำนวนกระบวนการในคุณสมบัติ 'numprocesses':

{ "สถานะ": "ตกลง", "ประมวลผลจำนวน": , "เวลา", "ประทับเวลา" }

คำสั่ง เส้น
$ circusctl incr [ ] [--ที่รอ]

Options
· : ชื่อผู้เฝ้า

· : จำนวนกระบวนการที่จะเพิ่ม

สร้างบัญชีตัวแทน เปลือกหอย เข้าไป ละครสัตว์ กระบวนการ
คำสั่งนี้มีประโยชน์ก็ต่อเมื่อคุณได้ติดตั้งแพ็คเกจ ipython ไว้

คำสั่ง Line
$circusctl ipython

เข้ามา รายการ of นักดู or กระบวนการ in a กะลาสี
ซีเอ็มคิว ระบุความประสงค์หรือข้อมูลเพิ่มเติม
เพื่อรับรายชื่อผู้ดูทั้งหมด:

{
"คำสั่ง": "รายการ",
}

ในการรับรายการกระบวนการที่ใช้งานอยู่ในตัวตรวจสอบ:

{
"คำสั่ง": "รายการ",
"คุณสมบัติ": {
"name": "nameofwatcher",
}
}

คำตอบกลับรายการที่ถาม การทำแผนที่ที่ส่งคืนอาจเป็น 'ผู้เฝ้าดู' หรือ
'pids' ขึ้นอยู่กับคำขอ

คำสั่ง เส้น
$ circusctl รายการ [ ]

Subscribe ไปยัง a กะลาสี เหตุการณ์
ซีเอ็มคิว
คุณสามารถสมัครเข้าร่วมกิจกรรมละครสัตว์ได้ทุกเมื่อ Circus ให้ฟีด PUB/SUB ซึ่ง
ลูกค้าท่านใดสมัครได้. URI ปลายทางของสมาชิกถูกตั้งค่าใน circus.ini
ไฟล์การกำหนดค่า

กิจกรรมเป็นหัวข้อผับ:

· ผู้เฝ้ามอง .เก็บเกี่ยว: เมื่อกระบวนการถูกเก็บเกี่ยว

· ผู้เฝ้ามอง .วางไข่: เมื่อเกิดกระบวนการขึ้น

· ผู้เฝ้ามอง .ฆ่า: เมื่อกระบวนการถูกฆ่า

· ผู้เฝ้ามอง .update: เมื่อมีการอัปเดตการกำหนดค่าผู้ดู

· ผู้เฝ้ามอง .หยุด: เมื่อผู้เฝ้าหยุดนิ่ง

· ผู้เฝ้ามอง .เริ่ม: เมื่อผู้เฝ้าเริ่มต้นขึ้น

ข้อความเหตุการณ์ทั้งหมดอยู่ในโครงสร้าง json

คำสั่ง เส้น
ไคลเอนต์ได้รับการอัปเดตเพื่อให้เป็นวิธีการง่ายๆ ในการฟังเหตุการณ์:

circusctl ฟัง [ , ...]

ตัวอย่าง of ผลลัพธ์:
$ circusctl ฟัง tcp://127.0.0.1:5556
watcher.refuge.spawn: {u'process_id': 6, u'process_pid': 72976,
เวลาของคุณ: 1331681080.985104}
watcher.refuge.spawn: {u'process_id': 7, u'process_pid': 72995,
เวลาของคุณ: 1331681086.208542}
watcher.refuge.spawn: {u'process_id': 8, u'process_pid': 73014,
เวลาของคุณ: 1331681091.427005}

เข้ามา รายการ of ซ็อกเก็ต
ซีเอ็มคิว ระบุความประสงค์หรือข้อมูลเพิ่มเติม
ในการรับรายการซ็อกเก็ต:

{
"command": "listsockets",
}

การตอบสนองจะส่งคืนรายการการแมป json พร้อมคีย์สำหรับ fd ชื่อ โฮสต์ และพอร์ต

คำสั่ง เส้น
$ circusctl listockets

เข้ามา จำนวน of กระบวนการ
รับจำนวนกระบวนการในผู้เฝ้าหรือผู้ตัดสิน

ซีเอ็มคิว ระบุความประสงค์หรือข้อมูลเพิ่มเติม
{
"command": "numprocesses",
"คุณสมบัติ": {
"ชื่อ": " "
}

}

การตอบสนองส่งคืนจำนวนกระบวนการในคุณสมบัติ 'numprocesses':

{ "สถานะ": "ตกลง", "ประมวลผลจำนวน": , "เวลา", "ประทับเวลา" }

ถ้าไม่ได้ระบุชื่อคุณสมบัติ ผลรวมของกระบวนการทั้งหมดที่จัดการจะถูกส่งคืน

คำสั่ง เส้น
$ circusctl numprocesses [ ]

Options
· : ชื่อผู้เฝ้า

เข้ามา จำนวน of นักดู
รับจำนวนผู้ดูในอนุญาโตตุลาการ

ซีเอ็มคิว ระบุความประสงค์หรือข้อมูลเพิ่มเติม
{
"command": "นาฬิกานับเลข",
}

การตอบสนองส่งคืนจำนวนผู้ดูในคุณสมบัติ 'numwatchers':

{ "สถานะ": "ตกลง", "นาฬิกาตัวเลข": , "เวลา", "ประทับเวลา" }

คำสั่ง เส้น
$ circusctl numwatchers

เข้ามา ความคุ้มค่า of ทั้งหมด ตัวเลือก สำหรับ a กะลาสี
คำสั่งนี้คืนค่าตัวเลือกทั้งหมดสำหรับผู้สังเกตการณ์ที่กำหนด

ซีเอ็มคิว ระบุความประสงค์หรือข้อมูลเพิ่มเติม
{
"คำสั่ง": "ตัวเลือก",
"คุณสมบัติ": {
"name": "nameofwatcher",
}
}

ข้อความมี 1 คุณสมบัติ:

· ชื่อ: ชื่อผู้ดู

วัตถุตอบสนองมีคุณสมบัติ ตัวเลือก ซึ่งเป็นพจนานุกรมของชื่อตัวเลือกและ
ค่า

เช่น:

{
"สถานะ": "ตกลง",
"ตัวเลือก": {
"graceful_timeout": 300,
"send_hup": จริง
...
},
เวลา': 1332202594.754644
}

คำสั่ง เส้น
$ circusctl ตัวเลือก

Options
· : ชื่อผู้เฝ้า

ปุ่มตัวเลือกคือ:

· numprocesses: จำนวนเต็ม, จำนวนกระบวนการ

· warmup_delay: จำนวนเต็มหรือตัวเลข หน่วงเวลารอระหว่างกระบวนการวางไข่ในไม่กี่วินาที

· working_dir: string, ไดเร็กทอรีที่กระบวนการจะถูกดำเนินการ

· uid: สตริงหรือจำนวนเต็ม ID ผู้ใช้ที่ใช้เพื่อเริ่มกระบวนการ

· gid: สตริงหรือจำนวนเต็ม ID กลุ่มที่ใช้เพื่อเริ่มกระบวนการ

· send_hup: บูลีน ถ้า TRU สัญญาณ HUP จะถูกใช้ในการโหลดซ้ำ

· เชลล์: บูลีน จะรันคำสั่งในสภาพแวดล้อมของเชลล์หากเป็น true

· cmd: string บรรทัดคำสั่งที่ใช้เปิดกระบวนการ

· env: วัตถุกำหนดสภาพแวดล้อมที่กระบวนการจะเปิดตัว

· retry_in: จำนวนเต็มหรือตัวเลข เวลาเป็นวินาทีที่เรารอ ก่อนที่เราจะลองเปิด .อีกครั้ง
ดำเนินการหากถึงจำนวนครั้งสูงสุดแล้ว

· max_retry: จำนวนเต็ม จำนวนสูงสุดของการลองซ้ำลูป

· graceful_timeout: จำนวนเต็มหรือตัวเลข เวลาที่เรารอก่อนที่เราจะฆ่ากระบวนการอย่างแน่นอน

· ลำดับความสำคัญ: ใช้ในการจัดเรียงผู้ดูในอนุญาโตตุลาการ

· singleton: ถ้าจริง ผู้เฝ้าเดี่ยว

· max_age: เวลาที่กระบวนการสามารถใช้งานได้ก่อนที่จะเริ่มใหม่

· max_age_variance: เปลี่ยนแปลงเวลาเพิ่มเติมในการมีชีวิตอยู่ หลีกเลี่ยงการตีฝูง

เลิก ผู้ตัดสิน ทันที
เมื่ออนุญาโตตุลาการได้รับคำสั่งนี้ อนุญาโตตุลาการจะออก

ซีเอ็มคิว ระบุความประสงค์หรือข้อมูลเพิ่มเติม
{
"คำสั่ง": "เลิก",
"กำลังรอ": เท็จ
}

การตอบสนองส่งคืนสถานะ "ตกลง"

If ที่รอ เป็นเท็จ (ค่าเริ่มต้น) การโทรจะกลับมาทันทีหลังจากโทร หยุด_สัญญาณ
ในแต่ละกระบวนการ

If ที่รอ เป็นจริง การโทรจะกลับมาเมื่อสิ้นสุดกระบวนการหยุดเท่านั้น
เนื่องจากตัวเลือก graceful_timeout อาจใช้เวลาสักครู่

คำสั่ง เส้น
$ circusctl เลิก [--กำลังรอ]

โหลด ผู้ตัดสิน or a กะลาสี
คำสั่งนี้จะโหลดกระบวนการทั้งหมดใน watcher หรือ watcher ทั้งหมด สิ่งนี้จะเกิดขึ้นในที่เดียว
จาก 3 วิธี:

· หากเป็นความสง่างามเป็นเท็จ การรีสตาร์ทอย่างง่ายจะเกิดขึ้น

· ถ้า send_hup เป็นจริงสำหรับผู้เฝ้าดู สัญญาณ HUP จะถูกส่งไปยังแต่ละกระบวนการ

·

มิฉะนั้น:

· หากลำดับเป็นเท็จ อนุญาโตตุลาการจะพยายามวางไข่ จำนวนกระบวนการ ใหม่
กระบวนการ หากเกิดกระบวนการใหม่สำเร็จ ผลลัพธ์ก็คือ
กระบวนการเก่าทั้งหมดจะหยุดลง เนื่องจากโดยค่าเริ่มต้น กระบวนการที่เก่าที่สุดจะเป็น
หยุดเมื่อจำนวนกระบวนการจริงสำหรับผู้เฝ้าติดตามมากกว่า
จำนวนกระบวนการ.

· หากซีเควนเชียลเป็นจริง อนุญาโตตุลาการจะรีสตาร์ทแต่ละกระบวนการตามลำดับ
ทาง (ด้วย a วอร์มอัพ_ดีเลย์ หยุดระหว่างแต่ละขั้นตอน)

ซีเอ็มคิว ระบุความประสงค์หรือข้อมูลเพิ่มเติม
{
"command": "โหลดซ้ำ",
"คุณสมบัติ": {
"ชื่อ": ' ",
"สง่างาม": จริง
"ลำดับ": เท็จ,
"กำลังรอ": เท็จ
}
}

การตอบสนองส่งคืนสถานะ "ตกลง" หากคุณสมบัติที่สง่างามถูกตั้งค่าเป็นจริงกระบวนการ
จะจากไปอย่างสง่างาม

หากมีชื่อคุณสมบัติ การโหลดซ้ำจะถูกนำไปใช้กับผู้เฝ้าดู

คำสั่ง เส้น
$ circusctl รีโหลด [ ] [--สิ้นสุด] [--รอ]
[--ตามลำดับ]

Options
· : ชื่อผู้เฝ้า

· --terminate; ออกจากโหนดทันที

โหลด องค์ประกอบ ไฟล์
คำสั่งนี้จะรีโหลดไฟล์คอนฟิกูเรชัน ดังนั้นการเปลี่ยนแปลงในไฟล์คอนฟิกูเรชันจะเป็น
สะท้อนให้เห็นในโครงร่างของคณะละครสัตว์

ซีเอ็มคิว ระบุความประสงค์หรือข้อมูลเพิ่มเติม
{
"command": "reloadconfig",
"กำลังรอ": เท็จ
}

การตอบสนองส่งคืนสถานะ "ตกลง" หากคุณสมบัติที่สง่างามถูกตั้งค่าเป็นจริงกระบวนการ
จะจากไปอย่างสง่างาม

คำสั่ง เส้น
$ circusctl reloadconfig [--กำลังรอ]

เริ่มต้นใหม่ ผู้ตัดสิน or a กะลาสี
คำสั่งนี้รีสตาร์ทกระบวนการทั้งหมดในตัวตรวจสอบหรือผู้ดูทั้งหมด ฟังชั่นนี้ง่ายๆ
หยุดผู้เฝ้าดูแล้วเริ่มใหม่

ซีเอ็มคิว ระบุความประสงค์หรือข้อมูลเพิ่มเติม
{
"command": "รีสตาร์ท",
"คุณสมบัติ": {
"ชื่อ": " ",
"รอ": เท็จ
"match": "[simple|glob|regex]"
}
}

การตอบสนองส่งคืนสถานะ "ตกลง"

หากมีชื่อคุณสมบัติ การโหลดซ้ำจะถูกนำไปใช้กับผู้เฝ้าดู

If ที่รอ เป็นเท็จ (ค่าเริ่มต้น) การโทรจะกลับมาทันทีหลังจากโทร หยุด_สัญญาณ
ในแต่ละกระบวนการ

If ที่รอ เป็น True จะโทรกลับเมื่อกระบวนการรีสตาร์ทเสร็จสมบูรณ์เท่านั้น
สิ้นสุด เนื่องจากตัวเลือก graceful_timeout อาจใช้เวลาสักครู่

การขอ การจับคู่ พารามิเตอร์สามารถมีค่าได้ ง่าย สำหรับการเปรียบเทียบสตริง glob สำหรับไวด์การ์ด
การจับคู่ (ค่าเริ่มต้น) หรือ นิพจน์ทั่วไป สำหรับการจับคู่ regex

คำสั่ง เส้น
$ circusctl รีสตาร์ท [ชื่อ] [--กำลังรอ] [--match=simple|glob|regex]

Options
· : ชื่อหรือลายของผู้เฝ้า

· : วิธีการจับคู่ผู้ดู

ลบรายการออกจากรถเข็น a กะลาสี
คำสั่งนี้จะลบผู้สังเกตการณ์ออกจากผู้ตัดสินแบบไดนามิก คนเฝ้ามองอย่างสง่างาม
หยุดโดยค่าเริ่มต้น

ซีเอ็มคิว ระบุความประสงค์หรือข้อมูลเพิ่มเติม
{
"คำสั่ง": "rm",
"คุณสมบัติ": {
"ชื่อ": " ",
"nostop": เท็จ
"กำลังรอ": เท็จ
}
}

การตอบสนองส่งคืนสถานะ "ตกลง"

If ไม่หยุด เป็นจริง (ค่าเริ่มต้น: เท็จ) กระบวนการสำหรับผู้เฝ้าดูจะไม่หยุด -
แทนผู้เฝ้าจะถูกลืมโดยคณะละครสัตว์และกระบวนการเฝ้าสังเกตจะเป็น
รับผิดชอบในการหยุดตัวเอง ถ้า ไม่หยุด ไม่ได้ระบุไว้หรือเป็นเท็จ ดังนั้น
กระบวนการเฝ้าระวังจะหยุดอย่างงดงาม

If ที่รอ เป็นเท็จ (ค่าเริ่มต้น) การโทรจะกลับมาทันทีหลังจากเริ่มลบ
และหยุดผู้เฝ้าดูที่เกี่ยวข้อง

If ที่รอ เป็นจริงการโทรจะกลับมาก็ต่อเมื่อกระบวนการลบและหยุดเป็น
สิ้นสุดลงอย่างสมบูรณ์ เนื่องจากตัวเลือก graceful_timeout อาจใช้เวลาสักครู่

คำสั่ง เส้น
$ circusctl rm [--รอ] [--nostop]

Options
· : ชื่อผู้เฝ้าที่จะลบ

· nostop: อย่าหยุดกระบวนการของผู้เฝ้าดูเพียงแค่ลบผู้เฝ้าดูออก

ชุด a กะลาสี ตัวเลือก
ซีเอ็มคิว ระบุความประสงค์หรือข้อมูลเพิ่มเติม
{
"คำสั่ง": "ตั้งค่า",
"คุณสมบัติ": {
"name": "nameofwatcher",
"ตัวเลือก": {
"key1": "val1",
..
}
"กำลังรอ": เท็จ
}
}

การตอบสนองส่งคืนสถานะ "ตกลง" ดูคำสั่ง ตัวเลือก สำหรับรายการคีย์ที่จะตั้งค่า

คำสั่ง เส้น
$ circusctl ชุด --ที่รอ

ส่ง a สัญญาณ
คำสั่งนี้อนุญาตให้คุณส่งสัญญาณไปยังกระบวนการทั้งหมดใน watcher ซึ่งเป็นกระบวนการเฉพาะ
ในผู้เฝ้าหรือลูกของมัน

ซีเอ็มคิว ระบุความประสงค์หรือข้อมูลเพิ่มเติม
ในการส่งสัญญาณไปยังกระบวนการทั้งหมดสำหรับผู้เฝ้าดู:

{
"คำสั่ง": "สัญญาณ",
"คุณสมบัติ": {
"ชื่อ": ,
"ซิกเนม":
}

ในการส่งสัญญาณไปยังกระบวนการ:

{
"คำสั่ง": "สัญญาณ",
"คุณสมบัติ": {
"ชื่อ": ,
"ปี๊ด": ,
"ซิกเนม":
}

สามารถใช้คุณสมบัติเสริม "ลูก" เพื่อส่งสัญญาณไปยังเด็กทุกคนได้
กว่ากระบวนการเอง:

{
"คำสั่ง": "สัญญาณ",
"คุณสมบัติ": {
"ชื่อ": ,
"ปี๊ด": ,
"ซิกเนม": ,
"เด็ก": จริง
}

ในการส่งสัญญาณไปยังโปรเซสชายด์:

{
"คำสั่ง": "สัญญาณ",
"คุณสมบัติ": {
"ชื่อ": ,
"ปี๊ด": ,
"ซิกเนม": ,
"child_pid": ,
}

นอกจากนี้ยังสามารถส่งสัญญาณไปยังลูก ๆ ของผู้เฝ้าดู:

{
"คำสั่ง": "สัญญาณ",
"คุณสมบัติ": {
"ชื่อ": ,
"ซิกเนม": ,
"เด็ก": จริง
}

สุดท้ายคุณสามารถส่งสัญญาณไปยังกระบวนการ และ ลูกของมันด้วย ซ้ำ ตัวเลือก:

{
"คำสั่ง": "สัญญาณ",
"คุณสมบัติ": {
"ชื่อ": ,
"ซิกเนม": ,
"เรียกซ้ำ": จริง
}

คำสั่ง เส้น
$ circusctl สัญญาณ [ ] [--เด็ก]
[--เรียกซ้ำ]

ตัวเลือก:
· : ชื่อผู้เฝ้า

· : จำนวนเต็ม รหัสกระบวนการ

· : หมายเลขสัญญาณ (หรือชื่อ) ที่จะส่ง

· : pid ของเด็กถ้ามี

· : บูลีน ส่งสัญญาณให้เด็กๆ ทุกคน

· : บูลีน ส่งสัญญาณไปยังกระบวนการและลูกของมัน

เริ่มต้น ผู้ตัดสิน or a กะลาสี
คำสั่งนี้เริ่มต้นกระบวนการทั้งหมดในผู้เฝ้าหรือผู้เฝ้าดูทั้งหมด

ซีเอ็มคิว ระบุความประสงค์หรือข้อมูลเพิ่มเติม
{
"คำสั่ง": "เริ่มต้น",
"คุณสมบัติ": {
"ชื่อ": ' ",
"รอ": เท็จ
"match": "[simple|glob|regex]"
}
}

การตอบสนองส่งคืนสถานะ "ตกลง"

หากมีชื่อพร็อพเพอร์ตี้ ผู้สังเกตการณ์จะเริ่มทำงาน

If ที่รอ เป็นเท็จ (ค่าเริ่มต้น) การโทรจะกลับมาทันทีหลังจากโทร เริ่มต้น on
แต่ละกระบวนการ

If ที่รอ เป็นจริง การโทรจะกลับมาเมื่อกระบวนการเริ่มต้นสิ้นสุดเท่านั้น
เนื่องจากตัวเลือก graceful_timeout อาจใช้เวลาสักครู่

การขอ การจับคู่ พารามิเตอร์สามารถมีค่าได้ ง่าย สำหรับการเปรียบเทียบสตริง glob สำหรับไวด์การ์ด
การจับคู่ (ค่าเริ่มต้น) หรือ นิพจน์ทั่วไป สำหรับการจับคู่ regex

คำสั่ง เส้น
$ circusctl รีสตาร์ท [ชื่อ] [--กำลังรอ] [--match=simple|glob|regex]

Options
· : ชื่อหรือลายของผู้เฝ้า

· : วิธีการจับคู่ผู้ดู

เข้ามา กระบวนการ ข้อมูล
คุณสามารถรับสถิติเกี่ยวกับกระบวนการของคุณได้ตลอดเวลาด้วยคำสั่ง stat

ซีเอ็มคิว ระบุความประสงค์หรือข้อมูลเพิ่มเติม
เพื่อรับสถิติสำหรับผู้ดูทั้งหมด:

{
"command": "สถิติ"
}

เพื่อรับสถิติสำหรับผู้เฝ้าดู:

{
"command": "สถิติ",
"คุณสมบัติ": {
"ชื่อ":
}
}

ในการรับสถิติสำหรับกระบวนการ:

{
"command": "สถิติ",
"คุณสมบัติ": {
"ชื่อ": ,
"กระบวนการ":
}
}

สถิติสามารถขยายได้โดยใช้ Extended_stats hook แต่ต้องมีการขยายสถิติ
ร้องขอ:

{
"command": "สถิติ",
"คุณสมบัติ": {
"ชื่อ": ,
"กระบวนการ": ,
"ขยาย": จริง
}
}

การตอบสนอง retun วัตถุต่อกระบวนการด้วยคุณสมบัติ "ข้อมูล" ที่มีบางกระบวนการ
รายละเอียด:

{
"ข้อมูล": {
"เด็ก": [],
"cmdline": "หลาม",
"ซีพียู": 0.1,
"ctime": "0:00.41",
"เมม": 0.1,
"mem_info1": "3M",
"mem_info2": "2G",
"สวย": 0,
"ปี๊ด": 47864,
"ชื่อผู้ใช้": "รูท"
},
"กระบวนการ": 5,
"สถานะ": "ตกลง",
"เวลา": 1332265655.897085
}

คำสั่ง Line
$ สถิติ circusctl [--ขยาย] [ ] [ ]

เข้ามา สถานะ of a กะลาสี or ทั้งหมด นักดู
คำสั่งนี้เริ่มรับสถานะของผู้เฝ้าหรือผู้เฝ้าดูทั้งหมด

ซีเอ็มคิว ระบุความประสงค์หรือข้อมูลเพิ่มเติม
{
"คำสั่ง": "สถานะ",
"คุณสมบัติ": {
"ชื่อ": ' ",
}
}

การตอบสนองส่งคืนสถานะ "ใช้งานอยู่" หรือ "หยุด" หรือสถานะ / ผู้เฝ้าดู

คำสั่ง เส้น
$ สถานะ circusctl [ ]

Options
· : ชื่อผู้เฝ้า

ตัวอย่าง
$ หุ่นจำลองสถานะ circusctl
คล่องแคล่ว
$ สถานะ circusctl
หุ่นจำลอง: ใช้งานอยู่
dummy2: ใช้งานอยู่
ที่หลบภัย: ใช้งานอยู่

หยุด นักดู
คำสั่งนี้หยุดผู้เฝ้าดูที่กำหนดหรือผู้เฝ้าดูทั้งหมด

ซีเอ็มคิว ระบุความประสงค์หรือข้อมูลเพิ่มเติม
{
"คำสั่ง": "หยุด",
"คุณสมบัติ": {
"ชื่อ": " ",
"รอ": เท็จ
"match": "[simple|glob|regex]"
}
}

การตอบสนองส่งคืนสถานะ "ตกลง"

ถ้า พร้อมชื่อ ทรัพย์สินที่มีอยู่แล้วหยุดจะถูกนำไปใช้กับผู้ดู
ตรงกับชื่อนั้น มิฉะนั้น ผู้เฝ้าดูทั้งหมดจะถูกหยุด

If ที่รอ เป็นเท็จ (ค่าเริ่มต้น) การโทรจะกลับมาทันทีหลังจากโทร หยุด_สัญญาณ
ในแต่ละกระบวนการ

If ที่รอ เป็น True การโทรจะกลับมาเมื่อสิ้นสุดกระบวนการหยุดโดยสมบูรณ์เท่านั้น
เนื่องจากตัวเลือก graceful_timeout อาจใช้เวลาสักครู่

การขอ การจับคู่ พารามิเตอร์สามารถมีค่าได้ ง่าย สำหรับการเปรียบเทียบสตริง glob สำหรับไวด์การ์ด
การจับคู่ (ค่าเริ่มต้น) หรือ นิพจน์ทั่วไป สำหรับการจับคู่ regex

คำสั่ง เส้น
$ circusctl หยุด [ชื่อ] [--กำลังรอ] [--match=simple|glob|regex]

Options
· : ชื่อหรือลายของผู้เฝ้า

· : วิธีการจับคู่ผู้ดู

CLI เครื่องมือ
ละครสัตว์ด้านบน
ละครสัตว์ด้านบน เป็นคอนโซลยอดนิยมที่คุณสามารถเรียกใช้เพื่อดูระบบ Circus ที่กำลังทำงานอยู่ มัน
จะแสดง CPU การใช้หน่วยความจำและซ็อกเก็ตฮิตถ้าคุณมี

ตัวอย่างเอาต์พุต:

-------------------------------------------------- ---------------------
สถิติวงเวียน
ซีพียู PID (%) หน่วยความจำ (%)
14252 0.8 0.4
0.8 (เฉลี่ย) 0.4 (ผลรวม)

ตัวแทนเชิด
ซีพียู PID (%) หน่วยความจำ (%)
14257 78.6 0.1
14256 76.6 0.1
14258 74.3 0.1
14260 71.4 0.1
14259 70.7 0.1
74.32 (เฉลี่ย) 0.5 (ผลรวม)

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

ละครสัตว์ด้านบน เป็นคอนโซลแบบอ่านอย่างเดียว หากคุณต้องการโต้ตอบกับระบบ ให้ใช้ วงเวียน.

วงเวียน
วงเวียน สามารถใช้เพื่อเรียกใช้คำสั่งใด ๆ ที่ระบุไว้ในคำสั่ง ตัวอย่างเช่น คุณจะได้รับ
รายชื่อผู้เฝ้าทุกท่าน ทำได้

$ circusctl รายการ

นอกจากการรองรับตัวเลือกจำนวนหนึ่งแล้ว คุณยังสามารถระบุจุดสิ้นสุดได้อีกด้วย วงเวียน น่า
ใช้โดยใช้ CIRCUCCTL_ENDPOINT ตัวแปรสภาพแวดล้อม

การขอ เว็บ ปลอบใจ
Circus มาพร้อมกับ Web Console ที่สามารถใช้จัดการระบบได้

เว็บคอนโซลช่วยให้คุณ:

·เชื่อมต่อกับระบบ Circus ที่กำลังทำงานอยู่

·ดูกระบวนการ CPU และการใช้หน่วยความจำแบบเรียลไทม์

· เพิ่มหรือฆ่ากระบวนการ

·เพิ่มผู้ดูใหม่

หมายเหตุ:
คุณสมบัติการใช้งาน CPU และหน่วยความจำแบบเรียลไทม์ใช้ซ็อกเก็ตสถิติ ถ้าคุณต้องการ
เปิดใช้งาน ตรวจสอบให้แน่ใจว่าระบบ Circus ที่คุณจะเชื่อมต่อมีข้อมูลสถิติ
เปิดใช้งานในการกำหนดค่า:

[ละครสัตว์]
statsd = จริง

โดยค่าเริ่มต้น ตัวเลือกนี้จะไม่เปิดใช้งาน

เว็บคอนโซลเป็นแพ็คเกจของตัวเอง คุณต้องติดตั้ง:

$ pip ติดตั้ง circus-web

ในการเปิดใช้งานคอนโซล ให้เพิ่มตัวเลือกสองสามตัวในไฟล์ Circus ini:

[ละครสัตว์]
httpd = จริง
httpd_host = โลคัลโฮสต์
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

เมื่อเข้าสู่ระบบคอนโซลเว็บแล้ว คุณจะได้รับรายชื่อผู้เฝ้าดูและสถานะแบบเรียลไทม์
ของกระบวนการละครทั้งสอง (circusd และ circusd-stats)

คุณสามารถคลิกที่สถานะของผู้ดูแต่ละคนเพื่อสลับจาก ใช้งาน (สีเขียว) ถึง เฉื่อยชา
(สีแดง). การเปลี่ยนแปลงนี้มีผลทันที และให้คุณเริ่มและหยุดผู้ดูได้

หากคุณคลิกที่ชื่อผู้ดู คุณจะได้รับหน้าเว็บสำหรับผู้ดูรายนั้น
ด้วยกระบวนการ:

ในหน้าจอนี้ คุณสามารถเพิ่มหรือลบกระบวนการ และกำจัดกระบวนการที่มีอยู่

สุดท้ายแต่ไม่ท้ายสุด คุณสามารถเพิ่มผู้ดูใหม่เอี่ยมโดยคลิกที่ เพิ่ม กะลาสี ลิงก์ใน
เมนูด้านซ้าย: .SS วิ่งตาม Nginx

Nginx สามารถทำหน้าที่เป็นชั้นพร็อกซีและความปลอดภัยต่อหน้าเว็บละครสัตว์

หมายเหตุ:
ในการรับการอัปเดตสถานะและกราฟแบบเรียลไทม์ในเว็บละครสัตว์ คุณต้องระบุ Nginx
โซลูชันพร็อกซี่ที่รองรับ websocket

Nginx >= 1.3.13
เนื่องจาก Nginx>=1.3.13 รองรับ websocket ในตัว จึงไม่จำเป็นต้องรวม Nginx
ด้วยวานิชหรือ HAProxy ตัวอย่างการกำหนดค่า Nginx พร้อมรองรับ websocket:

ต้นน้ำ circusweb_server {
เซิร์ฟเวอร์ 127.0.0.1:8080;
}

เซิร์ฟเวอร์ {
ฟัง 80;
ชื่อเซิร์ฟเวอร์ _;

สถานที่ /
proxy_pass http://circusweb_server;
พร็อกซี_http_เวอร์ชัน 1.1;
proxy_set_header อัพเกรด $http_upgrade;
proxy_set_header การเชื่อมต่อ "อัพเกรด";
proxy_set_header โฮสต์ $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded- สำหรับ $proxy_add_x_forwarded_for;
proxy_set_header X-ส่งต่อโปรโต http;
proxy_redirect ปิด;
}

ที่ตั้ง ~/สื่อ/\*(.png|.jpg|.css|.js|.ico)$ {
นามแฝง /path_to_site-packages/circusweb/media/;
}
}

Nginx < 1.3.13
เวอร์ชัน Nginx < 1.3.13 ไม่มีการสนับสนุน websocket ในตัว

เพื่อให้การสนับสนุน websocket สำหรับเว็บละครสัตว์เมื่อใช้ Nginx < 1.3.13 คุณสามารถรวม
Nginx กับวานิชหรือ HAProxy นั่นคือ Nginx หน้าเว็บละครสัตว์ด้วย Varnish หรือ
HAProxy หน้า Nginx

ตัวอย่างด้านล่างแสดงการกำหนดค่า Nginix และ Varnish ที่จำเป็นสำหรับ proxy
circus-web และให้การสนับสนุน websocket

Nginx การกำหนดค่า:

ต้นน้ำ circusweb_server {
เซิร์ฟเวอร์ 127.0.0.1:8080;
}

เซิร์ฟเวอร์ {
ฟัง 8001;
ชื่อเซิร์ฟเวอร์ _;

สถานที่ /
proxy_set_header X-Forwarded- สำหรับ $proxy_add_x_forwarded_for;
proxy_set_header โฮสต์ $http_host;
proxy_redirect ปิด;
proxy_pass http://circusweb_server;
}

ที่ตั้ง ~/สื่อ/\*(.png|.jpg|.css|.js|.ico)$ {
นามแฝง /path_to_site-packages/circusweb/media/;
}
}

หากคุณต้องการตัวเลือกการกำหนดค่า Nginx เพิ่มเติม โปรดดูที่ http://wiki.nginx.org/HttpProxyModule.

เคลือบเงา การกำหนดค่า:

ค่าเริ่มต้นของแบ็กเอนด์ {
.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 {
if (req.http.Upgrade ~ "(?i)websocket") {
ตั้งค่า req.backend = ซ็อกเก็ต;
ส่งคืน (ท่อ);
}
}

ในตัวอย่างการกำหนดค่าวานิชด้านบนมีการกำหนดแบ็กเอนด์สองรายการ หนึ่งที่ให้บริการเว็บ
คอนโซลและอีกอันที่ให้บริการการเชื่อมต่อซ็อกเก็ต คำขอเว็บคอนโซลถูกผูกไว้กับพอร์ต
8001. ควรกำหนดค่าคำสั่ง 'เซิร์ฟเวอร์' ของ Nginx ให้รับฟังบนพอร์ต 8001

การเชื่อมต่อ Websocket ได้รับการอัพเกรดและส่งไปยังกระบวนการ circushttpd โดยตรง
บนพอร์ต 8080 โดยวานิช เช่นข้ามพร็อกซี Nginx

อูบุนตู
ตั้งแต่รุ่น 13.10 (ทะลึ่ง) Ubuntu รวม Nginx พร้อมรองรับ websocket ในตัว
ที่เก็บ สำหรับเวอร์ชันเก่า คุณสามารถติดตั้ง Nginx>=1.3.13 จาก Nginx . อย่างเป็นทางการ
PPA ที่เสถียรดังนี้:

sudo apt-get ติดตั้ง python-software-properties
sudo add-apt-repository ppa:nginx/stable.php
sudo ปรับปรุง apt-get
sudo apt-get ติดตั้ง nginx
nginx -v

ป้องกันด้วยรหัสผ่าน ละครสัตว์httpd
ตามที่อธิบายไว้ในหน้าความปลอดภัย การทำงาน ละครสัตว์httpd ค่อนข้างไม่ปลอดภัย เราไม่ได้ให้
ความปลอดภัยใด ๆ ใน Circus เอง แต่คุณสามารถปกป้องคอนโซลของคุณที่ระดับ NGinx โดย
ด้วย http://wiki.nginx.org/HttpAuthBasicModule

ตัวอย่าง:

สถานที่ /
proxy_set_header X-Forwarded- สำหรับ $proxy_add_x_forwarded_for;
proxy_set_header โฮสต์ $http_host;
proxy_set_header X-ส่งต่อ-โฮสต์: $http_host;
proxy_set_header X-ส่งต่อ-Proto: $scheme;
proxy_redirect ปิด;
proxy_pass http://127.0.0.1: 8080;
auth_basic "ถูกจำกัด";
auth_basic_user_file /path/to/htpasswd;
}

การขอ htpasswd ไฟล์มีผู้ใช้และรหัสผ่านของพวกเขา และรหัสผ่านจะปรากฏขึ้นเมื่อ
คุณเข้าถึงคอนโซล

คุณสามารถใช้สคริปต์ htpasswd ของ Apache เพื่อแก้ไข หรือสคริปต์ Python ที่มีให้ที่:
http://trac.edgewall.org/browser/trunk/contrib/htpasswd.py

อย่างไรก็ตาม ไม่รองรับการใช้งาน HTTP Authentication และ . ร่วมกัน
WebSockets (เซิร์ฟเวอร์จะส่งรหัสข้อผิดพลาด HTTP 401) วิธีแก้ปัญหาคือปิดการใช้งานเช่น
การพิสูจน์ตัวตนสำหรับเซิร์ฟเวอร์ socket.io

ตัวอย่าง (ต้องเพิ่มก่อนกฎก่อนหน้า):

ตำแหน่ง /socket.io {
proxy_set_header X-Forwarded- สำหรับ $proxy_add_x_forwarded_for;
proxy_set_header โฮสต์ $http_host;
proxy_set_header X-ส่งต่อ-โฮสต์: $http_host;
proxy_set_header X-ส่งต่อ-Proto: $scheme;
proxy_redirect ปิด;
proxy_pass http://127.0.0.1: 8080;
}

แน่นอน นั่นเป็นเพียงวิธีหนึ่งในการปกป้องเว็บคอนโซลของคุณ คุณสามารถใช้วิธีอื่นๆ ได้มากมาย
เทคนิค

ขยาย เว็บ ปลอบใจ
เราเลือก ขวด เพื่อสร้างเว็บคอนโซล ส่วนใหญ่เพราะมันเป็นเฟรมเวิร์กเล็กๆ ที่
ไม่ได้ทำอะไรมาก เมื่อดูโค้ดของเว็บคอนโซลแล้วคุณจะพบ
ว่ามันง่ายที่จะเข้าใจ

นี่คือวิธีการแยก:

· วงเวียนhttpd.py ไฟล์มีคำจำกัดความ "มุมมอง" และรหัสบางส่วนเพื่อจัดการกับ
การเชื่อมต่อซ็อกเก็ต (ผ่าน socketio)

· NS คอนโทรลเลอร์.py มีชั้นเดียวที่รับผิดชอบในการทำการสื่อสาร
ด้วยตัวควบคุมคณะละครสัตว์ อนุญาตให้มี API ระดับสูงที่ดีกว่าเมื่อกำหนด
เว็บเซิร์ฟเวอร์.

หากคุณต้องการเพิ่มคุณลักษณะในเว็บคอนโซล คุณสามารถใช้รหัสที่มีอยู่ซ้ำได้ อา
มีเครื่องมือสองสามอย่างให้คุณใช้เพื่อทำให้กระบวนการง่ายขึ้น:

· มี เรนเดอร์_เทมเพลต ฟังก์ชัน ซึ่งใช้อาร์กิวเมนต์ที่มีชื่อที่คุณส่งผ่านไปยังและ
ส่งต่อไปยังตัวสร้างเทมเพลตและส่งคืน HTML ที่เป็นผลลัพธ์ ก็ยังผ่านบ้าง
ตัวแปรเพิ่มเติม เช่น เซสชัน เวอร์ชันละครสัตว์ และไคลเอ็นต์ หากกำหนดไว้

· หากคุณต้องการเรียกใช้คำสั่งและเปลี่ยนเส้นทาง doa ขึ้นอยู่กับผลลัพธ์ คุณสามารถใช้
run_command ฟังก์ชัน ซึ่งรับ callable เป็นอาร์กิวเมนต์แรก ข้อความในกรณี
ของความสำเร็จและ URL การเปลี่ยนเส้นทาง

การขอ สถิติเนมสเปซ class มีหน้าที่จัดการการสื่อสาร websocket บน
ฝั่งเซิร์ฟเวอร์. เอกสารประกอบควรช่วยให้คุณเข้าใจสิ่งที่ทำ

การทำงาน สีสดสวย ซ็อกเก็ต
Circus สามารถผูกซ็อกเก็ตเครือข่ายและจัดการได้เหมือนกับที่ทำกับกระบวนการ

แนวคิดหลักคือกระบวนการย่อยที่สร้างขึ้นโดย Circus เพื่อเรียกใช้หนึ่งใน watcher's
คำสั่งสามารถสืบทอดจากตัวอธิบายไฟล์ที่เปิดอยู่ทั้งหมด

นั่นเป็นวิธีที่ Apache หรือ Unicorn ทำงาน และเครื่องมืออื่นๆ มากมาย

เป้าหมาย
เป้าหมายของการมีซ็อกเก็ตที่จัดการโดย Circus คือการสามารถจัดการแอปพลิเคชันเครือข่ายได้
ใน Circus เหมือนกับแอปพลิเคชันอื่นๆ

ตัวอย่างเช่น หากคุณใช้ Circus กับ ถุงเท้า -- เซิร์ฟเวอร์ WGSI คุณสามารถรับได้เร็วมาก
เว็บเซิร์ฟเวอร์ที่ทำงานและจัดการ "เว็บ คนงาน" ในละครสัตว์เหมือนที่คุณทำเพื่อคนอื่น
กระบวนการ

การแยกการจัดการซ็อกเก็ตออกจากแอปพลิเคชันเครือข่ายนั้นมีประโยชน์มากมาย
โอกาสในการปรับขนาดและจัดการสแตกของคุณ

ออกแบบ
สาระสำคัญของคุณลักษณะนี้ทำได้โดยการผูกซ็อกเก็ตและเริ่มฟังใน
ละครสัตว์:

นำเข้าซ็อกเก็ต

ถุงเท้า = socket.socket (ครอบครัว, ประเภท)
sock.bind ((โฮสต์, พอร์ต))
sock.listen (แบ็คล็อก)
fd = ถุงเท้า.fileno()

จากนั้น Circus จะติดตาม fds ที่เปิดอยู่ทั้งหมด และปล่อยให้กระบวนการทำงานเหมือนเด็ก
เข้าถึงได้หากต้องการ

หากคุณสร้างสคริปต์เครือข่าย Python ขนาดเล็กที่คุณตั้งใจจะเรียกใช้ใน Circus ก็สามารถทำได้
มีลักษณะดังนี้:

นำเข้าซ็อกเก็ต
sys นำเข้า

fd = int(sys.argv[1]) # รับ FD จากละครสัตว์
ถุงเท้า = socket.fromfd(fd, FAMILY, TYPE)

#จัดการกับคำขอทีละครั้ง
ในขณะที่ True:
เชื่อมต่อ addr = sock.accept()
ขอ = conn.recv(1024)
.. ทำอะไรสักอย่าง ..
conn.sendall(ตอบกลับ)
con.ปิด()

จากนั้น 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 = mycoolscript $(circus.sockets.foo)
use_sockets = จริง
วอร์มอัพ_ดีเลย์ = 0
จำนวนกระบวนการ = 5

[ซ็อกเก็ต:ฟู]
โฮสต์ = 127.0.0.1
พอร์ต = 8888

$(circus.sockets.foo) จะถูกแทนที่ด้วยค่า FD เมื่อสร้างซ็อกเก็ตและ
ผูกพันกับ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

[ผู้ดู:เว็บ]
cmd = chaussette --fd $(circus.sockets.web) --แบ็กเอนด์ meinheld mycool.app
use_sockets = จริง
จำนวนกระบวนการ = 5

[ซ็อกเก็ต:เว็บ]
โฮสต์ = 0.0.0.0
พอร์ต = 8000

เรายังไม่ได้เผยแพร่การวัดประสิทธิภาพ แต่เป็นคลัสเตอร์เว็บที่จัดการโดย Circus กับ Gevent หรือ
แบ็กเอนด์ Meinheld นั้นเร็วพอๆ กับเซิร์ฟเวอร์ WSGI ก่อนแยกย่อย

การใช้ built-in ปลั๊กอิน
Circus มาพร้อมกับปลั๊กอินในตัวบางตัว ส่วนนี้นำเสนอปลั๊กอินเหล่านี้และ
ตัวเลือกการกำหนดค่า

สถิติ
ใช้ ตั้งค่าเป็น 'circus.plugins.statsd.StatsdEmitter'

application_name
ชื่อที่ใช้ระบุคำนำหน้าถังเพื่อส่งสถิติไปที่ (จะเป็น
นำหน้าด้วย คณะละครสัตว์ และลงท้ายด้วย .วอชเชอร์)

เจ้าภาพ โฮสต์ที่จะโพสต์ข้อมูล statds ไปที่

พอร์ต พอร์ตที่ statsd daemon รับฟัง

อัตราการสุ่มตัวอย่าง
หากคุณต้องการอัตราตัวอย่างที่แตกต่างจาก 1 คุณสามารถตั้งค่าได้ที่นี่

สถิติเต็ม
ส่วนขยายบนปลั๊กอิน Statsd ที่เผยแพร่สถิติกระบวนการด้วย เป็นเช่นนั้น
มีตัวเลือกการกำหนดค่าเช่นเดียวกับ Statsd และรายการต่อไปนี้

ใช้ ตั้งค่าให้ circus.plugins.statsd.FullStats

วนซ้ำ
ความถี่ที่ปลั๊กอินควรถามถึงสถิติในหน่วยวินาที ค่าเริ่มต้น: 60

RedisObserver
บริการนี้ผู้สังเกตการณ์กระบวนการ redis สำหรับคุณ เผยแพร่ข้อมูลไปยัง statsd
และเสนอให้รีสตาร์ทผู้ดูเมื่อไม่ตอบสนองในช่วงเวลาที่กำหนด ปลั๊กอินนี้
ต้อง redis-py วิ่ง.

มีการกำหนดค่าเช่นเดียวกับ statsd และเพิ่มสิ่งต่อไปนี้:

ใช้ ตั้งค่าให้ circus.plugins.redis_observer.RedisObserver

วนซ้ำ
ความถี่ที่ปลั๊กอินควรถามถึงสถิติในหน่วยวินาที ค่าเริ่มต้น: 60

redis_url
ฐานข้อมูลที่จะตรวจสอบเป็น redis url ค่าเริ่มต้น: "redis://localhost:6379/0"

การหยุดพักชั่วคราว
การหมดเวลาเป็นวินาทีที่คำขอสามารถทำได้ก่อนที่จะถูกพิจารณาว่าไม่ทำงาน
ค่าเริ่มต้นเป็น 5

รีสตาร์ท_on_timeout
ชื่อของกระบวนการที่จะเริ่มต้นใหม่เมื่อคำขอหมดเวลา ไม่มีการรีสตาร์ท
กระตุ้นเมื่อไม่ได้รับ ค่าเริ่มต้น: ไม่มี

HttpObserver
บริการนี้จะตรวจสอบกระบวนการ http ให้กับคุณโดยส่ง Ping ไปยังเว็บไซต์บางแห่งเป็นประจำ
คล้ายกับผู้สังเกตการณ์ redis เสนอให้รีสตาร์ทผู้ดูเมื่อมีข้อผิดพลาด มันต้องการ
พายุทอร์นาโด วิ่ง.

มีการกำหนดค่าเช่นเดียวกับ statsd และเพิ่มสิ่งต่อไปนี้:

ใช้ ตั้งค่าให้ circus.plugins.http_observer.HttpObserver

วนซ้ำ
ความถี่ที่ปลั๊กอินควรถามถึงสถิติในหน่วยวินาที ค่าเริ่มต้น: 60

ตรวจสอบ_url
url ที่จะตรวจสอบ ค่าเริ่มต้น: http://localhost/

การหยุดพักชั่วคราว
การหมดเวลาเป็นวินาทีที่คำขอสามารถทำได้ก่อนที่จะถูกพิจารณาว่าไม่ทำงาน
ค่าเริ่มต้นเป็น 10

รีสตาร์ท_on_error
ชื่อของกระบวนการที่จะเริ่มต้นใหม่เมื่อคำขอหมดเวลาหรือส่งคืนใด ๆ
ข้อผิดพลาดประเภทอื่น ไม่มีการรีสตาร์ทเมื่อไม่ได้รับ ค่าเริ่มต้น: ไม่มี

ResourceWatcher
บริการนี้เฝ้าดูทรัพยากรของกระบวนการที่กำหนดและทริกเกอร์การรีสตาร์ทเมื่อ
พวกเขาเกินข้อจำกัดบางอย่างบ่อยเกินไปติดต่อกัน

มีการกำหนดค่าเช่นเดียวกับ statsd และเพิ่มสิ่งต่อไปนี้:

ใช้ ตั้งค่าให้ circus.plugins.resource_watcher.ResourceWatcher

วนซ้ำ
ความถี่ที่ปลั๊กอินควรถามถึงสถิติในหน่วยวินาที ค่าเริ่มต้น: 60

กะลาสี
ผู้เฝ้ามองที่ผู้เฝ้าดูทรัพยากรนี้ควรดูแล (แต่ก่อนเรียกว่า
บริการ แต่ บริการ ตอนนี้เลิกใช้แล้ว)

max_cpu
อนุญาตให้ใช้ซีพียูสูงสุดหนึ่งกระบวนการ (เป็น%) ค่าเริ่มต้น: 90

min_cpu
ซีพียูขั้นต่ำหนึ่งกระบวนการควรใช้ (เป็น%) ค่าเริ่มต้น: ไม่มี (ไม่มีขั้นต่ำ)
คุณสามารถตั้งค่า min_cpu เป็น 0 (ศูนย์) ได้ ในกรณีนี้หากกระบวนการใดกระบวนการหนึ่งใช้หมดทุกประการ
0% cpu มันจะทริกเกอร์เกินขีดจำกัด

max_mem
จำนวนหน่วยความจำหนึ่งกระบวนการของผู้สังเกตการณ์นี้ได้รับอนุญาตให้ใช้ ค่าเริ่มต้น:
90. หากไม่มีการระบุหน่วย ค่าจะเป็น % ตัวอย่าง: 50 ถ้าหน่วยเป็น
ระบุ ค่าเป็นไบต์ หน่วยที่รองรับคือ B, K, M, G, T, P, E, Z, Y
ตัวอย่าง: 250M

min_mem
หน่วยความจำขั้นต่ำหนึ่งกระบวนการของผู้สังเกตการณ์นี้ควรใช้ ค่าเริ่มต้น: ไม่มี (no
ขั้นต่ำ) หากไม่มีการระบุหน่วย ค่าจะเป็น % ตัวอย่าง: 50 ถ้าหน่วยเป็น
ระบุ ค่าเป็นไบต์ หน่วยที่รองรับคือ B, K, M, G, T, P, E, Z, Y
ตัวอย่าง: 250M

สุขภาพ_เกณฑ์
ความสมบูรณ์คือค่าเฉลี่ยของซีพียูและหน่วยความจำ (เป็น%) ที่ผู้ดูประมวลผล
อนุญาตให้บริโภค (เป็น%) ค่าเริ่มต้น: 75

สูงสุด_นับ
ความถี่ที่อนุญาต (แต่ละอันถูกนับแยกกัน) ได้รับอนุญาตให้เป็น
เกินก่อนที่จะเริ่มการทำงานใหม่ ค่าเริ่มต้น: 3

ตัวอย่าง:

[ละครสัตว์]
- -

[ผู้ดู:โปรแกรม]
cmd = นอน 120

[ปลั๊กอิน: myplugin]
ใช้ = circus.plugins.resource_watcher.ResourceWatcher
ผู้เฝ้าดู = โปรแกรม
min_cpu = 10
max_cpu = 70
ขั้นต่ำ_mem = 0
สูงสุด_mem = 20

สุนัขเฝ้าบ้าน
ปลั๊กอินที่ผูกซ็อกเก็ต udp และรอข้อความจ้องจับผิด สำหรับ "เฝ้าระวัง"
กระบวนการ สุนัขเฝ้าบ้านจะฆ่าพวกเขาหากพวกเขาไม่ส่งการเต้นของหัวใจในบางช่วงเวลา
ระยะเวลาที่เกิดขึ้นโดย loop_rate * max_count (ละครสัตว์จะทำโดยอัตโนมัติ
รีสตาร์ทกระบวนการที่ขาดหายไปในตัวตรวจสอบ)

แต่ละกระบวนการที่ถูกมอนิเตอร์ควรส่งข้อความ udp อย่างน้อยที่ loop_rate udp
รูปแบบข้อความเป็นบรรทัดข้อความ ถอดรหัสโดยใช้ msg_regex พารามิเตอร์. การเต้นของหัวใจ
ข้อความอย่างน้อยต้องมี pid ของกระบวนการส่งข้อความ

รายชื่อผู้เฝ้าติดตามจะถูกกำหนดโดยพารามิเตอร์ watchers_regex ที่
องค์ประกอบ

พารามิเตอร์การกำหนดค่า:

ใช้ ตั้งค่าให้ circus.plugins.watchdog.WatchDog

วนซ้ำ
อัตราการวนซ้ำของสุนัขเฝ้าบ้านในไม่กี่วินาที ในแต่ละวง WatchDog จะค้นหา "ตาย"
กระบวนการ

watchers_regex
regex สำหรับชื่อผู้เฝ้าดูที่ตรงกันซึ่งควรตรวจสอบโดยสุนัขเฝ้าบ้าน
(ค่าเริ่มต้น: .* ผู้เฝ้าติดตามทุกคน)

msg_regex
regex สำหรับการถอดรหัสข้อความ heartbeat ที่ได้รับใน udp (ค่าเริ่มต้น:
^(?ป .*);(?ป .*)$) รูปแบบเริ่มต้นคือข้อความธรรมดา:
pid;ประทับเวลา

สูงสุด_นับ
จำนวนสูงสุดของลูปที่ผ่านไปโดยไม่ได้รับ heartbeat ใด ๆ ก่อนรีสตาร์ท
กระบวนการ (ค่าเริ่มต้น: 3)

ip ip ที่สุนัขเฝ้าบ้านจะผูกไว้ (ค่าเริ่มต้น: 127.0.0.1)

พอร์ต พอร์ตที่สุนัขเฝ้าบ้านจะผูกไว้ (ค่าเริ่มต้น: 1664)

เครื่องกระพือ
เมื่อผู้ปฏิบัติงานรีสตาร์ทบ่อยเกินไป เราว่ามันคือ เครื่องกระพือ. ปลั๊กอินนี้ติดตาม
ของผู้ปฏิบัติงานรีสตาร์ทและหยุดผู้เฝ้าระวังที่เกี่ยวข้องในกรณีที่กระพือปีก นี้
ปลั๊กอินอาจถูกใช้เพื่อหยุดผู้ปฏิบัติงานที่เริ่มต้นใหม่อย่างต่อเนื่องโดยอัตโนมัติเพราะ
พวกมันทำงานไม่ถูกต้อง

ใช้ ตั้งค่าให้ circus.plugins.flapping.กระพือ

ความพยายามในการ
จำนวนครั้งที่กระบวนการสามารถเริ่มต้นใหม่ได้ภายใน หน้าต่าง วินาทีก่อนที่เราจะ
คิดว่ามันกระพือปีก (ค่าเริ่มต้น: 2)

หน้าต่าง กรอบเวลาเป็นวินาทีเพื่อทดสอบการกระพือปีก หากกระบวนการเริ่มต้นใหม่มากขึ้น
กว่า ความพยายามในการ ครั้งภายในกรอบเวลานี้ เราถือว่าเป็นกระบวนการกระพือปีก
(ค่าเริ่มต้น: 1)

ลองใหม่อีกครั้ง
เวลาเป็นวินาทีเพื่อรอจนกว่าเราจะพยายามเริ่มต้นใหม่อีกครั้งซึ่งเป็นกระบวนการที่ได้รับ
กระพือปีก (ค่าเริ่มต้น: 7)

max_retry
จำนวนครั้งที่เราพยายามเริ่มกระบวนการที่มีการกระพือปีกมาก่อน
เราละทิ้งและหยุดผู้เฝ้าดูทั้งหมด (ค่าเริ่มต้น: 5) ตั้งค่าเป็น -1 เพื่อปิดการใช้งาน
max_retry แล้วลองใหม่ไม่มีกำหนด

คล่องแคล่ว กำหนดว่าปลั๊กอินทำงานอยู่หรือไม่ (ค่าเริ่มต้น: จริง) ถ้าธงโลกคือ
ตั้งค่าเป็น False ปลั๊กอินจะไม่เริ่มทำงาน

ตัวเลือกสามารถแทนที่ได้ในส่วนผู้เฝ้าดูโดยใช้a กระพือปีก คำนำหน้า ตัวอย่างเช่น
นี่คือวิธีที่คุณจะกำหนดค่าเฉพาะ max_retry ค่าสำหรับ nginx:

[ผู้ดู:nginx]
cmd = /path/to/nginx.com
กระพือ.max_retry = 2

[ผู้ดู:myscript]
cmd = ./my_script.py

; ...ผู้ดูอื่นๆ

[ปลั๊กอิน:กระพือ]
ใช้ = circus.plugins.flapping.Flapping
สูงสุด_ลองใหม่ = 5

CommandReloader
ปลั๊กอินนี้จะรีสตาร์ทผู้ดูเมื่อมีการแก้ไขไฟล์คำสั่ง มันทำงานโดย
ตรวจสอบเวลาแก้ไขและเส้นทางของไฟล์ที่ชี้โดย cmd ตัวเลือกทุก
วนซ้ำ วินาที นี้อาจเป็นประโยชน์ในขณะที่พัฒนากระบวนการของผู้ปฏิบัติงานหรือแม้กระทั่งสำหรับร้อน
การอัพเกรดรหัสในการผลิต

ใช้ ตั้งค่าให้ circus.plugins.command_reloader.CommandReloader

วนซ้ำ
ความถี่ที่ปลั๊กอินควรตรวจสอบการแก้ไขในไม่กี่วินาที ค่าเริ่มต้น: 1.

การใช้งาน
แม้ว่า Circus daemon สามารถจัดการได้ด้วยคำสั่ง circusd แต่ก็ง่ายกว่าที่จะมี
เริ่มต้นในการบูต หากระบบของคุณรองรับ Upstart คุณสามารถสร้างสคริปต์ Upstart นี้ได้ใน
/etc/init/circus.conf

เริ่มที่ระบบไฟล์และ net-device-up IFACE=lo
หยุดที่ระดับการวิ่ง [016]

respawn
ผู้บริหาร /usr/local/bin/circusd /etc/circus/circusd.ini

นี่ถือว่า circusd.ini อยู่ที่ /etc/circus/circusd.ini หลังจากรีบูต คุณ
สามารถควบคุม circusd ด้วยคำสั่ง service:

# บริการละครเริ่ม / หยุด / เริ่มใหม่

หากระบบของคุณรองรับ systemd คุณสามารถสร้างไฟล์หน่วย systemd ภายใต้
/etc/systemd/system/circus.service.

[Unit]
Description=ผู้จัดการกระบวนการคณะละครสัตว์
After=syslog.target network.target nss-lookup.target

[บริการ]
type = ง่าย
ExecReload=/usr/bin/circusctl โหลดซ้ำ
ExecStart=/usr/bin/circusd /etc/circus/circus.ini
เริ่มต้นใหม่ = เสมอ
RestartSec = 5

[ติดตั้ง]
ต้องการโดย=default.target

ไม่จำเป็นต้องรีบูตหากคุณเรียกใช้คำสั่ง daemon-reload ด้านล่าง:

# systemctl --system daemon-reload

จากนั้นสามารถจัดการคณะละครสัตว์ได้ผ่าน:

# systemctl เริ่ม/หยุด/สถานะ/โหลดละครสัตว์

สูตรอาหาร
ส่วนนี้จะมีสูตรในการปรับใช้ Circus จนสามารถมองดู Pete's . ได้
หุ่นเชิด สูตร หรือที่ Remy's พ่อครัว สูตร

สันตะปาปา กระบวนการ เมล็ด
ปัญหาหนึ่งที่มักเกิดขึ้นกับผู้จัดการกระบวนการคือ คุณไม่สามารถเริ่มตัวจัดการกระบวนการใหม่ได้
โดยไม่ต้องรีสตาร์ทกระบวนการทั้งหมดที่จัดการ ซึ่งทำให้ยากต่อการนำ a . ไปใช้งาน
เวอร์ชันใหม่ของ Circus หรือเวอร์ชันใหม่ของไลบรารีใด ๆ ที่ขึ้นอยู่กับ

หากคุณใช้ระบบ Unix-type Circus สามารถใช้เคอร์เนลกระบวนการ Papa ได้ เมื่อใช้ Papa
จะสร้างภูตที่มีอายุยืนยาวซึ่งจะทำหน้าที่เป็นโฮสต์สำหรับกระบวนการและซ็อกเก็ตใด ๆ
คุณสร้างมันขึ้นมา ถ้าคณะละครสัตว์ปิดตัว พ่อจะดูแลทุกอย่างที่มันเป็นเจ้าภาพ

การติดตั้ง
เริ่มต้นด้วยการติดตั้ง พ่อ และ ตั้งค่าโพรคไตเติ้ล โมดูล:

pip ติดตั้ง papa
pip ติดตั้ง setproctitle

การขอ ตั้งค่าโพรคไตเติ้ล โมดูลเป็นทางเลือก จะใช้ถ้ามีเพื่อเปลี่ยนชื่อ Papa daemon
สำหรับ ด้านบน และ ps ถึงบางอย่างเช่น "papa daemon จาก circusd" หากคุณไม่ได้ติดตั้ง
ตั้งค่าโพรคไตเติ้ล โมดูล หัวเรื่องนั้นจะเป็นบรรทัดคำสั่งของกระบวนการที่เปิดใช้งาน
สับสนมาก

เมื่อติดตั้ง Papa แล้ว ให้เพิ่ม use_papa=จริง สู่กระบวนการและซ็อกเก็ตที่สำคัญของคุณ
โดยทั่วไปคุณต้องการเก็บกระบวนการทั้งหมดของสแต็กของคุณใน Papa และไม่มี
กระบวนการสนับสนุนของคณะละครสัตว์ เช่น ปลั๊กอินการกระพือปีกและสถิติ

[ละครสัตว์]
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
Graceful_timeout = 10
สูงสุด_ลองใหม่ = 5
ซิงเกิลตัน = จริง
send_hup = จริง
stop_signal = เลิก
stdout_stream.class = FileStream
stdout_stream.filename = /var/logs/web-server.log
stdout_stream.max_bytes = 10000000
stdout_stream.backup_count = 10
stderr_stream.class=ไฟล์สตรีม
stderr_stream.filename = /var/logs/web-server-error.log
stderr_stream.max_bytes = 1000000
stderr_stream.backup_count = 10
ใช้งาน = จริง
use_papa = จริง

[ผู้ดู:คนตัดไม้]
cmd = /my_service/env/bin/python logger.py เรียกใช้
working_dir = /my_service
Graceful_timeout = 10
ซิงเกิลตัน = จริง
stop_signal = INT
stdout_stream.class = FileStream
stdout_stream.filename = /var/logs/logger.log
stdout_stream.max_bytes = 10000000
stdout_stream.backup_count = 10
stderr_stream.class=ไฟล์สตรีม
stderr_stream.filename = /var/logs/logger.log
stderr_stream.max_bytes = 1000000
stderr_stream.backup_count = 10
ลำดับความสำคัญ = 50
use_papa = จริง

[ผู้ดู:web_app]
cmd = /my_service/env/bin/uwsgi --ini uwsgi-live.ini --socket fd://$(circus.sockets.web) --stats 127.0.0.1:809$(circus.wid)
working_dir = /my_service/web_app
สง่างาม_หมดเวลา=10
stop_signal = เลิก
use_sockets = จริง
stdout_stream.class = FileStream
stdout_stream.filename = /var/logs/web_app.log
stdout_stream.max_bytes = 10000000
stdout_stream.backup_count = 10
stderr_stream.class=ไฟล์สตรีม
stderr_stream.filename = /var/logs/web_app.log
stderr_stream.max_bytes = 1000000
stderr_stream.backup_count = 10
hooks.after_spawn = Example.uwsgi_lossless_reload.children_started
hooks.before_signal = Example.uwsgi_lossless_reload.clean_stop
hooks.extended_stats = Example.uwsgi_lossless_reload.extended_stats
ลำดับความสำคัญ = 40
use_papa = จริง

[ซ็อกเก็ต:เว็บ]
เส้นทาง = /my_service/sock/uwsgi
use_papa = จริง

[ปลั๊กอิน:กระพือ]
ใช้ = circus.plugins.flapping.Flapping
หน้าต่าง = 10
ลำดับความสำคัญ = 1000

หมายเหตุ:
หากกระบวนการ Papa ใช้ซ็อกเก็ตใด ๆ ซ็อกเก็ตเหล่านั้นจะต้องใช้ Papa ด้วย

ออกแบบ เป้าหมาย
Papa ได้รับการออกแบบให้มีลักษณะและข้อกำหนดที่เรียบง่าย มันทำ:

·เริ่มและหยุดซ็อกเก็ต

· จัดให้มีที่เก็บคีย์/ค่า

· เริ่มกระบวนการและส่งคืน stdout, stderr และรหัสทางออก

มันไม่ใช่:

· เริ่มกระบวนการใหม่

· จัดให้มีวิธีการหยุดกระบวนการ

· ให้ข้อมูลใด ๆ เกี่ยวกับกระบวนการอื่น ๆ นอกเหนือจากว่ายังทำงานอยู่หรือไม่

Papa ไม่ต้องการไลบรารี่ของบุคคลที่สาม จึงสามารถทำงานบนไลบรารี Python มาตรฐานได้
สามารถใช้ ตั้งค่าโพรคไตเติ้ล แพ็คเกจแต่ใช้สร้างชื่อเท่านั้น
สวยกว่าสำหรับ ps และ ด้านบน และไม่จำเป็น

ฟังก์ชันการทำงานถูกเก็บไว้ให้น้อยที่สุด เพื่อที่คุณจะได้ไม่ต้องรีสตาร์ท
ป๋าเดมอน. ฟังก์ชันการทำงานส่วนใหญ่ถูกผลักไปที่ไลบรารีไคลเอนต์เช่น
เป็นไปได้. ด้วยวิธีนี้คุณจะสามารถปรับใช้ Papa ใหม่สำหรับคุณสมบัติไคลเอนต์ใหม่
โดยไม่ต้องรีสตาร์ท Papa daemon พ่อมีไว้เพื่อเป็นเสาหลักของความมั่นคงใน
ทะเลที่เปลี่ยนไปของห้องสมุดบุคคลที่สาม

การดำเนินการ
สิ่งต่าง ๆ ส่วนใหญ่ยังคงไม่เปลี่ยนแปลงไม่ว่าคุณจะใช้ Papa หรือไม่ คุณยังสามารถเริ่มและหยุดได้
กระบวนการ คุณยังสามารถรับสถานะและสถิติสำหรับกระบวนการได้ สิ่งสำคัญที่เปลี่ยนแปลง
คือเมื่อคุณทำ วงเวียน เลิกกระบวนการ Papa ทั้งหมดยังคงทำงานอยู่ เมื่อคุณ
เริ่มต้น ละครสัตว์ สำรองข้อมูล กระบวนการเหล่านั้นจะถูกกู้คืน

หมายเหตุ:
เมื่อกระบวนการถูกกู้คืน before_start และ before_spawn ตะขอถูกข้าม

เข้าสู่ระบบ
ในขณะที่ Circus ปิดตัวลง Papa จะจัดเก็บเอาต์พุตได้มากถึง 2M ต่อกระบวนการ แล้วจะ
เริ่มดัมพ์ข้อมูลที่เก่าที่สุด เมื่อคุณรีสตาร์ท Circus เอาต์พุตแคชนี้จะรวดเร็ว
ดึงและส่งไปยังกระแสข้อมูลขาออก พ่อต้องการใบเสร็จที่ออกมาเป็น
รับทราบ ดังนั้นคุณไม่ควรสูญเสียเอาต์พุตใด ๆ ระหว่างการปิดเครื่อง

ไม่เพียงเท่านั้น แต่ Papa ยังบันทึกการประทับเวลาของเอาต์พุต ละครสัตว์ได้รับการปรับปรุงให้
ใช้ประโยชน์จากข้อมูลการประทับเวลา หากมี ดังนั้นหากคุณกำลังเขียนผลลัพธ์ไปยังไฟล์บันทึก
หรือที่ไหนสักแห่ง การประทับเวลาของคุณควรถูกต้องทั้งหมด

ปัญหา
ถ้าคุณใช้ รวม or Decr คำสั่งให้เปลี่ยนกระบวนการนับสำหรับผู้เฝ้าสังเกตนี้จะ
ถูกรีเซ็ตเป็นระดับที่ระบุในไฟล์ INI เมื่อ ละครสัตว์ จะเริ่มต้นใหม่

นอกจากนี้ ฉันยังประสบปัญหากับการรวมกันของ copy_env และ Virtualenv. คุณอาจ
โปรดทราบว่าตัวอย่าง INI ด้านบนจะหลีกเลี่ยงปัญหานี้ด้วยเส้นทางที่ชัดเจน

Telnet อินเตอร์เฟซ
Papa มีอินเทอร์เฟซบรรทัดคำสั่งพื้นฐานที่คุณสามารถเข้าถึงได้ผ่าน telnet:

เทลเน็ตโลคัลโฮสต์ 20202
ช่วย

วงเวียน สำหรับ นักพัฒนา
การใช้ วงเวียน as a ห้องสมุด
Circus มีคลาสและฟังก์ชันระดับสูงที่จะช่วยให้คุณจัดการกระบวนการต่างๆ ใน
แอปพลิเคชันของคุณเอง

ตัวอย่างเช่น หากคุณต้องการเรียกใช้สี่กระบวนการตลอดไป คุณสามารถเขียน:

จากการนำเข้าละครสัตว์ get_arbiter

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

arbiter = get_arbiter([โปรแกรม myprogram])
ลอง:
อนุญาโตตุลาการ.start()
สุดท้าย:
อนุญาโตตุลาการหยุด ()

ตัวอย่างนี้จะเรียกใช้สี่อินสแตนซ์ของ โปรแกรมของฉัน และดูให้คุณเริ่มต้นใหม่
หากพวกเขาตายอย่างกะทันหัน

ดูข้อมูลเพิ่มเติมได้ที่ห้องสมุด

ขยาย วงเวียน
ง่ายต่อการขยาย Circus เพื่อสร้างระบบที่ซับซ้อนมากขึ้น โดยการฟังทั้งหมด
ละครสัตว์ เหตุการณ์ผ่านช่องผับ/ย่อย และขับผ่านคำสั่ง

นั่นคือวิธีการทำงานของคุณสมบัติการกระพือปีก: ฟังกระบวนการทั้งหมดที่กำลังจะตาย
วัดความถี่ที่เกิดขึ้นและหยุดผู้เฝ้าดูที่ถูกกล่าวหาหลังจากรีสตาร์ทหลายครั้งเกินไป
ความพยายามในการ

Circus มาพร้อมกับระบบปลั๊กอินที่จะช่วยคุณเขียนส่วนขยายดังกล่าว และตัวช่วยในตัวอีกสองสามตัว
ปลั๊กอินที่คุณสามารถนำมาใช้ซ้ำได้ ดูปลั๊กอิน

คุณยังสามารถมีพฤติกรรมการเริ่มต้นและการปิดระบบที่ละเอียดยิ่งขึ้นโดยใช้ปุ่ม ตะขอ ระบบ
ที่จะช่วยให้คุณรันโค้ดที่กำหนดเองได้ก่อนและหลังกระบวนการบางอย่างเริ่มต้นหรือ
หยุด ดูตะขอ

สุดท้ายแต่ไม่ท้ายสุด คุณยังสามารถเพิ่มคำสั่งใหม่ได้ ดูการเพิ่มcmds.

นักพัฒนา เอกสาร ดัชนี
วงเวียน ห้องสมุด
แพ็คเกจ Circus ประกอบด้วยระดับสูง get_arbiter() ฟังก์ชั่นและคลาสมากมาย ใน
ส่วนใหญ่แล้ว การใช้ฟังก์ชันระดับสูงน่าจะเพียงพอ เพราะจะสร้างทุกอย่างที่
เป็นสิ่งจำเป็นสำหรับ Circus ในการทำงาน

คุณสามารถคลาสย่อยคลาสของ Circus หากคุณต้องการความละเอียดมากกว่าที่ .เสนอให้
องค์ประกอบ

การขอ get_arbiter ฟังก์ชัน
get_arbiter() เป็นเพียงความสะดวกสบายเหนือชั้นเรียนละครสัตว์ต่างๆ มันสร้าง
อนุญาโตตุลาการ (คลาส ผู้ตัดสิน) อินสแตนซ์ที่มีตัวเลือกที่ให้ไว้ซึ่งจะเรียกใช้ตัวเดียว
กะลาสี ด้วยไฟล์ กระบวนการ.

วงเวียน.get_arbiter()

ตัวอย่าง:

จากการนำเข้าละครสัตว์ get_arbiter

arbiter = get_arbiter([{"cmd": "myprogram", "numprocesses": 3}])
ลอง:
อนุญาโตตุลาการ.start()
สุดท้าย:
อนุญาโตตุลาการหยุด ()

เรียน
Circus มีชุดของคลาสที่คุณสามารถใช้เพื่อปรับใช้ตัวจัดการกระบวนการของคุณเอง:

· กระบวนการ: ล้อมกระบวนการที่ทำงานอยู่และจัดเตรียมผู้ช่วยบางส่วนไว้ด้านบน

· กะลาสี: เรียกใช้หลายอินสแตนซ์ของ กระบวนการ ต่อต้านคำสั่งเดียวกัน จัดการความตายและ
ชีวิตของกระบวนการ

· ผู้ตัดสิน: จัดการหลาย กะลาสี.

ชั้น circus.process.Process(ชื่อ วิด, คำสั่ง args=ไม่มี, working_dir=ไม่มี, เปลือก=เท็จ
uid=ไม่มี, gid=ไม่มี, env=ไม่มี, rlimits=ไม่มี, ปฏิบัติการ=ไม่มี, use_fds=เท็จ ผู้เฝ้า=ไม่มี,
วางไข่=จริง pipe_stdout=จริง pipe_stderr=จริง close_child_stdout=ผิด
close_child_stderr=เท็จ)
ห่อกระบวนการ

ตัวเลือก:

· กว้าง: ตัวระบุเฉพาะกระบวนการ ค่านี้จะถูกใช้เพื่อแทนที่ $WID
สตริงในบรรทัดคำสั่งถ้ามี

· cmd: คำสั่งเรียกใช้ อาจมีตัวแปรใด ๆ ที่มีอยู่ที่เป็น
ถูกส่งผ่านไปยังชั้นนี้ พวกเขาจะถูกแทนที่โดยใช้ไวยากรณ์รูปแบบหลาม

· args: อาร์กิวเมนต์สำหรับคำสั่งที่จะรัน สามารถเป็นรายการหรือสตริง ถ้า args is
สตริง มันแยกโดยใช้ shlex.แยก(). ค่าเริ่มต้นเป็นไม่มี

· ปฏิบัติการ: เมื่อให้โปรแกรมเรียกทำงาน รายการแรกในลำดับ args
ได้รับจาก cmd ยังคงได้รับการปฏิบัติโดยโปรแกรมส่วนใหญ่ในฐานะชื่อคำสั่ง ซึ่ง
จากนั้นจะแตกต่างจากชื่อเรียกใช้งานได้จริง กลายเป็นจอแสดงผล
ชื่อโปรแกรมรันในยูทิลิตี้เช่น ps.

· Working_dir: ไดเร็กทอรีการทำงานที่จะรันคำสั่ง หากไม่ระบุ will
ค่าเริ่มต้นไปยังไดเร็กทอรีการทำงานปัจจุบัน

· เปลือกหอย: ถ้า จริงจะรันคำสั่งในสภาพแวดล้อมของเชลล์ เท็จ โดยค่าเริ่มต้น
คำเตือน: นี้ is a ความปลอดภัย อันตราย.

· UID: หากกำหนดไว้ คือ ID ผู้ใช้หรือชื่อที่คำสั่งควรรันด้วย ปัจจุบัน
uid เป็นค่าเริ่มต้น

· กิด: ถ้ากำหนดไว้ คือ id กลุ่มหรือชื่อที่คำสั่งควรรันด้วย ปัจจุบัน
gid เป็นค่าเริ่มต้น

· env: การแมปที่มีตัวแปรสภาพแวดล้อมที่คำสั่งจะรันด้วย
ไม่จำเป็น.

· ริมิต: การแมปที่มีชื่อและค่าไรลิมิตที่จะถูกตั้งค่าก่อน
คำสั่งทำงาน

· use_fds: หากเป็น True จะไม่ปิด fds ในกระบวนการย่อย ต้องตั้งค่าเป็น
True บน Windows หาก stdout หรือ stderr ถูกเปลี่ยนเส้นทาง ค่าเริ่มต้น: เท็จ

· ท่อ_stdout: ถ้า True จะเปิด PIPE ใน stdout ค่าเริ่มต้น: จริง

· ท่อ_stderr: ถ้า True จะเปิด PIPE บน stderr ค่าเริ่มต้น: จริง

· close_child_stdout: หากเป็น True ให้เปลี่ยนเส้นทาง stdout ของโปรเซสลูกไปที่ /dev/null
หลังส้อม ค่าเริ่มต้น: เท็จ

· close_child_stderr: หากเป็น True ให้เปลี่ยนเส้นทาง stdout ของโปรเซสลูกไปที่ /dev/null
หลังส้อม ค่าเริ่มต้น: เท็จ

อายุ() คืนอายุของกระบวนการเป็นวินาที

เด็ก()
ส่งคืนรายการ pids ย่อย

ข้อมูล() กลับข้อมูลกระบวนการ

ข้อมูลที่ส่งคืนเป็นการแมปด้วยคีย์เหล่านี้:

· mem_info1: Resident Set ขนาดหน่วยความจำเป็นไบต์ (RSS)

· mem_info2: ขนาดหน่วยความจำเสมือนเป็นไบต์ (VMS)

· ซีพียู: % ของการใช้งานซีพียู

· Mem: % ของการใช้หน่วยความจำ

· เวลา: ประมวลผลเวลา CPU (ผู้ใช้ + ระบบ) เป็นวินาที

· pid: รหัสกระบวนการ

· ชื่อผู้ใช้: ชื่อผู้ใช้ที่เป็นเจ้าของกระบวนการ

· ดี: กระบวนการที่ดี (ระหว่าง -20 ถึง 20)

· cmdline: บรรทัดคำสั่งที่เรียกใช้กระบวนการ

is_child(พิด)
คืนค่า จริง คือค่าที่กำหนด pid เป็นลูกของกระบวนการนั้น

pid ส่งคืน pid

send_signal(*หาเรื่อง, **กิโลวัตต์)
ส่งสัญญาณ sig สู่กระบวนการ

send_signal_child(*หาเรื่อง, **กิโลวัตต์)
ส่งสัญญาณ สัญญาณ ถึงลูก pid.

send_signal_children(*หาเรื่อง, **กิโลวัตต์)
ส่งสัญญาณ สัญญาณ ให้กับเด็กทุกคน

สถานะ ส่งกลับสถานะกระบวนการเป็นค่าคงที่

· วิ่ง

· DEAD_OR_ZOMBIE

·ไม่มีอยู่

· อื่น ๆ

สตเดอร์ ส่งคืน แย่ กระแส

แย่ ส่งคืน แย่ กระแส

หยุด(*อาร์กิวเมนต์, **กิโลวัตต์)
หยุดกระบวนการและปิด stdout/stderr

หากกระบวนการที่เกี่ยวข้องยังอยู่ที่นี่ (ปกติจะถูกฆ่าโดย
ผู้เฝ้าสังเกต) SIGTERM จะถูกส่ง จากนั้น SIGKILL หลังจาก 1 วินาที

กระบวนการปิดระบบ (SIGTERM จากนั้น SIGKILL) ปกติดำเนินการโดย
ผู้เฝ้ามอง ดังนั้นหากกระบวนการยังอยู่ที่นี่ ก็เป็นพฤติกรรมที่ไม่ดีชนิดหนึ่ง
เพราะการหมดเวลาอย่างสง่างามจะไม่ได้รับการเคารพที่นี่

ตัวอย่าง:

>>> จากกระบวนการนำเข้า circus.process
>>> กระบวนการ = กระบวนการ ('ด้านบน', 'ด้านบน', เชลล์ = จริง)
>>> process.age()
3.0107998847961426
>>> process.info()
'ด้านบน: 6812 N/A tarek Zombie N/AN/AN/AN/AN/A'
>>> process.status
1
>>> กระบวนการหยุด ()
>>> process.status
2
>>> process.info()
'ไม่มีกระบวนการดังกล่าว (หยุด?)'

ชั้น circus.watcher.Watcher (ชื่อ คำสั่ง args=ไม่มี, จำนวนกระบวนการ = 1, วอร์มอัพ_ดีเลย์=0.0,
working_dir=ไม่มี, เปลือก=เท็จ shell_args=ไม่มี, uid=ไม่มี, สูงสุด_ลองใหม่=5, gid=ไม่มี,
send_hup=เท็จ stop_signal=15, stop_children=เท็จ env=ไม่มี, Graceful_timeout=30.0,
prereload_fn=ไม่มี rlimits=ไม่มี, ปฏิบัติการ=ไม่มี, stdout_stream=ไม่มี stderr_stream=ไม่มี,
ลำดับความสำคัญ=0, ลูป=ไม่มี, ซิงเกิลตัน=เท็จ use_sockets=เท็จ copy_env=เท็จ,
copy_path=เท็จ, สูงสุด_อายุ=0, max_age_variance=30, ตะขอ=ไม่มี, เกิดใหม่=จริง ออโต้สตาร์ท=จริง
on_demand=เท็จ virtualenv=ไม่มี close_child_stdout=ผิด close_child_stderr=เท็จ
virtualenv_py_ver=ไม่มี use_papa=เท็จ **ตัวเลือก)
คลาสที่จัดการรายการโปรเซสสำหรับคำสั่งที่กำหนด

ตัวเลือก:

· พร้อมชื่อ: ชื่อที่กำหนดให้ผู้ดู ใช้เพื่อระบุตัวตนโดยเฉพาะ

· cmd: คำสั่งเรียกใช้ อาจมี $WIDซึ่งจะถูกแทนที่ด้วย กว้าง.

· args: อาร์กิวเมนต์สำหรับคำสั่งที่จะรัน สามารถเป็นรายการหรือสตริง ถ้า args is
สตริง มันแยกโดยใช้ shlex.แยก(). ค่าเริ่มต้นเป็นไม่มี

· จำนวนกระบวนการ: จำนวนโปรเซสที่จะรัน

· Working_dir: ไดเร็กทอรีการทำงานที่จะรันคำสั่ง หากไม่ระบุ will
ค่าเริ่มต้นไปยังไดเร็กทอรีการทำงานปัจจุบัน

· เปลือกหอย: ถ้า จริงจะรันคำสั่งในสภาพแวดล้อมของเชลล์ เท็จ โดยค่าเริ่มต้น
คำเตือน: นี้ is a ความปลอดภัย อันตราย.

· UID: หากกำหนดไว้ คือ ID ผู้ใช้หรือชื่อที่คำสั่งควรรันด้วย ปัจจุบัน
uid เป็นค่าเริ่มต้น

· กิด: ถ้ากำหนดไว้ คือ id กลุ่มหรือชื่อที่คำสั่งควรรันด้วย ปัจจุบัน
gid เป็นค่าเริ่มต้น

· send_hup: หากเป็น True กระบวนการจะทำการรีโหลดโดยการส่งสัญญาณ SIGHUP
ค่าเริ่มต้นเป็นเท็จ

· หยุด_สัญญาณ: สัญญาณที่จะส่งเมื่อหยุดกระบวนการ ค่าดีฟอลต์เป็น SIGTERM

· stop_children: ส่ง หยุด_สัญญาณ ให้กับเด็กๆ ด้วย ค่าเริ่มต้นเป็นเท็จ

· env: การแมปที่มีตัวแปรสภาพแวดล้อมที่คำสั่งจะรันด้วย
ไม่จำเป็น.

· ริมิต: การแมปที่มีชื่อและค่าไรลิมิตที่จะถูกตั้งค่าก่อน
คำสั่งทำงาน

· stdout_stream: การแมปที่กำหนดสตรีมสำหรับกระบวนการ stdout ค่าเริ่มต้น
ถึงไม่มี

ไม่จำเป็น. เมื่อจัดให้ stdout_stream เป็นการแมปที่มีมากถึงสามปุ่ม:

· ชั้น: คลาสสตรีม ค่าเริ่มต้นเป็น circus.stream.FileStream

· ชื่อไฟล์: ชื่อไฟล์ หากใช้ FileStream

· สูงสุด_ไบต์: ขนาดไฟล์สูงสุด หลังจากนั้นไฟล์เอาต์พุตใหม่จะเปิดขึ้น ค่าเริ่มต้น
เป็น 0 ซึ่งหมายความว่าไม่มีขนาดสูงสุด (ใช้ได้กับ FileStream เท่านั้น)

· สำรองข้อมูล: จำนวนข้อมูลสำรองที่จะเก็บไว้เมื่อหมุนไฟล์ตาม
พารามิเตอร์ max_bytes ค่าเริ่มต้นเป็น 0 ซึ่งหมายความว่าไม่มีการสำรองข้อมูล (เฉพาะ
ใช้ได้กับ FileStream)

การแมปนี้จะใช้เพื่อสร้างสตรีมที่เรียกได้ของคลาสที่ระบุ
แต่ละรายการที่ได้รับโดย callable คือการแมปที่ประกอบด้วย:

· pid - กระบวนการ pid

· พร้อมชื่อ - ชื่อสตรีม (สตเดอร์ or แย่)

· ข้อมูล - ข้อมูล

ไม่รองรับบน Windows

· stderr_stream: การแมปที่กำหนดสตรีมสำหรับกระบวนการ stderr ค่าเริ่มต้น
ถึงไม่มี

ไม่จำเป็น. เมื่อจัดให้ stderr_stream เป็นการแมปที่มีมากถึงสามปุ่ม:
- ชั้น: คลาสสตรีม ค่าเริ่มต้นเป็น circus.stream.FileStream - ชื่อไฟล์:
ชื่อไฟล์หากใช้ FileStream - สูงสุด_ไบต์: ขนาดไฟล์สูงสุด หลังจากนั้นให้สร้างใหม่
ไฟล์ที่ส่งออกคือ
เปิด ค่าเริ่มต้นเป็น 0 ซึ่งหมายความว่าไม่มีขนาดสูงสุด (ใช้ได้กับ .เท่านั้น
ไฟล์สตรีม)

· สำรองข้อมูล: จำนวนข้อมูลสำรองที่จะเก็บไว้เมื่อหมุนไฟล์ตาม
พารามิเตอร์ max_bytes ค่าเริ่มต้นเป็น 0 ซึ่งหมายความว่าไม่มีการสำรองข้อมูล (เฉพาะ
ใช้ได้กับ FileStream)

การแมปนี้จะใช้เพื่อสร้างสตรีมที่เรียกได้ของคลาสที่ระบุ

แต่ละรายการที่ได้รับโดย callable คือการแมปที่ประกอบด้วย:

· pid - กระบวนการ pid

· พร้อมชื่อ - ชื่อสตรีม (สตเดอร์ or แย่)

· ข้อมูล - ข้อมูล

ไม่รองรับบน Windows

· ลำดับความสำคัญ -- จำนวนเต็มที่กำหนดลำดับความสำคัญสำหรับผู้เฝ้าดู เมื่ออนุญาโตตุลาการทำ
การดำเนินการบางอย่างกับผู้ดูทั้งหมดจะเรียงลำดับตามฟิลด์นี้จาก
จำนวนที่มากไปหาน้อย (ค่าเริ่มต้น: 0)

· เดี่ยว -- หากเป็น True ผู้เฝ้าดูรายนี้มีขั้นตอนเดียว (ค่าเริ่มต้น: เท็จ)

· use_sockets -- ถ้า True กระบวนการจะสืบทอด file descriptor ดังนั้นจึงสามารถ
นำซ็อกเก็ตที่เปิดโดย circusd มาใช้ซ้ำ (ค่าเริ่มต้น: เท็จ)

· ตามความต้องการ -- หากเป็น True กระบวนการจะเริ่มในการเชื่อมต่อครั้งแรกเท่านั้น
ไปยังซ็อกเก็ต (ค่าเริ่มต้น: เท็จ)

· copy_env -- หากเป็น True สภาพแวดล้อมที่คณะละครสัตว์กำลังทำงานอยู่จะเป็น
ทำซ้ำสำหรับคนงาน ค่าเริ่มต้นนี้เป็น True บน Windows เนื่องจากคุณไม่สามารถเรียกใช้
ปฏิบัติการใด ๆ โดยไม่ต้อง ซิสเต็มรูท ตัวแปร. (ค่าเริ่มต้น: เท็จ)

· copy_path -- ถ้าเป็นจริง circusd sys.path ถูกส่งไปยังกระบวนการผ่าน ไพธอนพาธ.
คุณต้องเปิดใช้งาน copy_env สำหรับ copy_path ไปทำงาน. (ค่าเริ่มต้น: เท็จ)

· สูงสุด_อายุ: หากตั้งค่าหลังจากประมาณ max_age วินาที กระบวนการจะถูกแทนที่ด้วย new
หนึ่ง. (ค่าเริ่มต้น: 0, ปิดการใช้งาน)

· max_age_variance: จำนวนวินาทีสูงสุดที่สามารถเพิ่มใน max_age
ค่าพิเศษนี้คือเพื่อหลีกเลี่ยงการรีสตาร์ทกระบวนการทั้งหมดพร้อมกัน อา
กระบวนการจะมีชีวิตอยู่ระหว่าง max_age และ max_age + max_age_variance วินาที

· ตะขอ: ฟังก์ชันเรียกกลับสำหรับการเชื่อมต่อกับการเริ่มต้นและปิดตัวจับเวลา
กระบวนการ ตะขอ เป็น dict โดยที่แต่ละคีย์คือชื่อ hook และแต่ละค่าคือ a
2-tuple ที่มีชื่อของ callable หรือ callabled เอง และแฟล็กบูลีน
บ่งชี้ว่าไม่ควรละเว้นข้อยกเว้นที่เกิดขึ้นในเบ็ด เป็นไปได้
ค่าสำหรับชื่อเบ็ด: before_start, after_start, before_spawn, after_spawn,
ก่อน_หยุด, อาฟเตอร์_สต็อป., ก่อน_สัญญาณ, after_signal or Extended_stats.

· ตัวเลือก -- ตัวเลือกเสริมสำหรับผู้ปฏิบัติงาน ตัวเลือกทั้งหมดที่พบในการกำหนดค่า
ตัวอย่างเช่น ถูกส่งผ่านในการแมปนี้ -- ปลั๊กอินนี้สามารถใช้ได้สำหรับ
ตัวเลือกเฉพาะผู้ดู

· respawn -- หากตั้งค่าเป็น "เท็จ" กระบวนการที่จัดการโดยผู้สังเกตการณ์จะไม่เป็น
เกิดใหม่โดยอัตโนมัติ (ค่าเริ่มต้น: จริง)

· Virtualenv -- ไดเร็กทอรีรากของ virtualenv. หากมีให้ผู้ดูจะ
โหลดสภาพแวดล้อมสำหรับการดำเนินการ (ค่าเริ่มต้น: ไม่มี)

· close_child_stdout: หากเป็น True ให้ปิด stdout หลังส้อม ค่าเริ่มต้น: เท็จ

· close_child_stderr: ถ้า True ปิด stderr หลังส้อม ค่าเริ่มต้น: เท็จ

· use_papa: หากเป็น True ให้ใช้เคอร์เนล papa process สำหรับกระบวนการนี้ ค่าเริ่มต้น: เท็จ

kill_process(*อาร์กิวเมนต์, **ควาร์ก)
กระบวนการฆ่า (stop_signal, graceful_timeout จากนั้น SIGKILL)

kill_processes(*args, **ควาร์ก)
ฆ่ากระบวนการทั้งหมด (stop_signal, graceful_timeout จากนั้น SIGKILL)

manager_processes(*args, **ควาร์ก)
จัดการกระบวนการ

notify_event(หัวข้อ ผงชูรส)
เผยแพร่ข้อความในช่องผู้เผยแพร่เหตุการณ์

reap_and_manage_processes(*args, **ควาร์ก)
เก็บเกี่ยวและจัดการกระบวนการ

reap_processes(*args, **กิโลวัตต์)
เก็บเกี่ยวกระบวนการทั้งหมดสำหรับผู้เฝ้าดูรายนี้

send_signal_child(*หาเรื่อง, **กิโลวัตต์)
ส่งสัญญาณให้ลูก

spawn_process(recovery_wid=ไม่มี)
กระบวนการวางไข่

คืนค่า จริง ถ้า ok คืนค่า เท็จ หากต้องหยุดผู้ดู

spawn_processes(*หาเรื่อง, **ควาร์ก)
กระบวนการวางไข่

ชั้น circus.arbiter.Arbiter (นักดู จุดสิ้นสุด, pubsub_endpoint, ตรวจสอบ_ล่าช้า=1.0,
prereload_fn=ไม่มี บริบท=ไม่มี ลูป=ไม่มี, statsd=เท็จ, stats_endpoint=ไม่มี,
statsd_close_outputs=เท็จ multicast_endpoint=ไม่มี ปลั๊กอิน=ไม่มี, ซ็อกเก็ต=ไม่มี,
วอร์มอัพ_ดีเลย์=0, httpd=เท็จ httpd_host='localhost', httpd_port=8080,
httpd_close_outputs=เท็จ ดีบัก=เท็จ debug_gc=เท็จ, ssh_server=ไม่มี,
proc_name='circusd', pidfile=ไม่มี, loglevel=ไม่มี, ออกจากระบบ=ไม่มี, loggerconfig=ไม่มี
fqdn_prefix=ไม่มี, umask=ไม่มี, endpoint_owner=ไม่มี papa_endpoint=ไม่มี)
คลาสที่ใช้ควบคุมรายชื่อผู้เฝ้าดู

ตัวเลือก:

· นักดู -- รายการวัตถุผู้สังเกตการณ์

· ปลายทาง -- ปลายทาง ZMQ ตัวควบคุม

· pubsub_endpoint --จุดสิ้นสุดของผับ

· สถิติ -- หากเป็น True จะมีการเรียกใช้กระบวนการ circusd-stats (ค่าเริ่มต้น: False)

· stats_endpoint -- จุดสิ้นสุดสถิติ

· statsd_close_outputs -- ถ้า True ส่ง circusd-stats stdout/stderr ไปที่
/dev/null (ค่าเริ่มต้น: เท็จ)

· multicast_endpoint -- ปลายทางมัลติคาสต์สำหรับการค้นพบอัตโนมัติของคลัสเตอร์ circusd
(ค่าเริ่มต้น: udp://237.219.251.97:12027) Multicast addr ควรอยู่ระหว่าง 224.0.0.0
ถึง 239.255.255.255 และเหมือนกันสำหรับคลัสเตอร์ทั้งหมด

· ตรวจสอบ_ล่าช้า -- การหน่วงเวลาระหว่างจุดควบคุมสองจุด (ค่าเริ่มต้น: 1 วินาที)

· โหลดล่วงหน้า_fn -- callable ที่จะดำเนินการในการโหลดแต่ละครั้ง (ค่าเริ่มต้น: ไม่มี)

· สิ่งแวดล้อม -- หากมีให้ บริบท zmq เพื่อนำกลับมาใช้ใหม่ (ค่าเริ่มต้น: ไม่มี)

·

วน: if ให้, a zmq.eventloop.ioloop.IOloop ตัวอย่าง
เพื่อนำมาใช้ใหม่ (ค่าเริ่มต้น: ไม่มี)

· ปลั๊กอิน -- รายการปลั๊กอิน แต่ละรายการเป็นการแมปด้วย:

· ใช้ -- ชื่อแบบเต็มที่ชี้ไปที่คลาสปลั๊กอิน

· ทุกค่าอื่น ๆ จะถูกส่งไปยังปลั๊กอินใน การตั้งค่า ตัวเลือก

· ซ็อกเก็ต -- แผนที่ของซ็อกเก็ต แต่ละคีย์คือชื่อซ็อกเก็ต และแต่ละค่า a
เซอร์คัสซอคเก็ต ระดับ. (ค่าเริ่มต้น: ไม่มี)

· วอร์มอัพ_ดีเลย์ -- การหน่วงเวลาเป็นวินาทีระหว่างการเริ่มต้นผู้ดูสองคน (ค่าเริ่มต้น: 0)

· httpd -- หากเป็น True จะมีการเรียกใช้กระบวนการ circushttpd (ค่าเริ่มต้น: False)

· httpd_host -- โฮสต์ circushttpd (ค่าเริ่มต้น: localhost)

· httpd_port -- พอร์ต circushttpd (ค่าเริ่มต้น: 8080)

· httpd_close_outputs -- ถ้า True ส่ง circushttpd stdout/stderr ไปที่ /dev/null
(ค่าเริ่มต้น: เท็จ)

· การแก้ปัญหา -- ถ้า True เพิ่มข้อมูลการดีบักจำนวนมากใน stdout (ค่าเริ่มต้น: เท็จ)

· debug_gc -- ถ้าเป็นจริง gc.set_debug(gc.DEBUG_LEAK) (ค่าเริ่มต้น: เท็จ) จะเป็น circusd
เพื่อวิเคราะห์ปัญหา (ค่าเริ่มต้น: เท็จ)

· proc_name --ชื่อกระบวนการอนุญาโตตุลาการ

·

fqdn_prefix -- a อุปสรรค สำหรับ ที่ไม่เหมือนใคร ระบุ of ละครสัตว์
อินสแตนซ์บนคลัสเตอร์

· endpoint_owner -- ผู้ใช้ยูนิกซ์จะเรียกปลายทางว่าถ้าใช้ ipc

· papa_endpoint -- จุดสิ้นสุดเคอร์เนลของกระบวนการ papa

add_watcher(*หาเรื่อง **ควาร์ก)
เพิ่มผู้เฝ้าดู

ตัวเลือก:

· พร้อมชื่อ: ชื่อผู้ดูที่จะเพิ่ม

· cmd: คำสั่งให้เรียกใช้

· ตัวเลือกอื่นๆ ทั้งหมดที่กำหนดไว้ในตัวสร้าง Watcher

get_watcher (ชื่อ)
กลับผู้เฝ้ามอง พร้อมชื่อ.

จำนวนการประมวลผล ()
ส่งกลับจำนวนกระบวนการที่ทำงานอยู่ในผู้เฝ้าดูทั้งหมด

นักดูตัวเลข()
ส่งคืนจำนวนผู้ดู

โหลดซ้ำ (*args, **ควาร์ก)
รีโหลดทุกอย่าง

เรียกใช้ โหลดล่วงหน้า_fn() เรียกได้ถ้ามี จากนั้นโหลดผู้ดูทั้งหมดอย่างสง่างาม

เริ่มต้น(*หาเรื่อง, **ควาร์ก)
เริ่มต้นผู้ดูทั้งหมด

หากมีการจัดเตรียม ioloop ไว้ในระหว่างการโทร __init__() ให้เริ่มผู้ดูทั้งหมด
เป็นคอร์รูทีนมาตรฐาน

หากไม่ได้ระบุ ioloop ระหว่างการโทร __init__() (ค่าเริ่มต้น) ให้เริ่ม
ผู้ดูทั้งหมดและ eventloop (และบล็อกที่นี่) ในโหมดนี้ วิธีการ
จะต้องไม่ให้ผลอะไรเพราะมันเรียกว่าเป็นวิธีมาตรฐาน

พารามิเตอร์
cb -- โทรกลับหลังจากเริ่มดูทั้งหมดแล้ว เมื่อ
ไม่ได้ระบุลูป

การเขียน ปลั๊กอิน
Circus มาพร้อมกับระบบปลั๊กอินที่ให้คุณโต้ตอบกับ ละครสัตว์.

หมายเหตุ:
เราอาจเพิ่มการสนับสนุน circusd-stats ให้กับปลั๊กอินในภายหลัง

ปลั๊กอินประกอบด้วยสองส่วน:

· สมาชิก ZMQ สำหรับกิจกรรมทั้งหมดที่เผยแพร่โดย ละครสัตว์

·ไคลเอนต์ ZMQ เพื่อส่งคำสั่งไปยัง ละครสัตว์

ปลั๊กอินแต่ละตัวทำงานเป็นกระบวนการที่แยกจากกันภายใต้ตัวตรวจสอบที่กำหนดเอง

ตัวอย่างบางส่วนของปลั๊กอินบางตัวที่คุณสามารถสร้างได้ด้วยระบบนี้:

· ระบบแจ้งเตือนที่ส่งอีเมล์แจ้งเตือนเมื่อคนดูกระพือปีก

· คนตัดไม้

· เครื่องมือที่เพิ่มหรือลบกระบวนการขึ้นอยู่กับโหลด

· ฯลฯ

Circus เองมาพร้อมกับปลั๊กอินในตัวไม่กี่ตัว

การขอ Circus Plugin ชั้น
Circus มีคลาสพื้นฐานเพื่อช่วยคุณติดตั้งปลั๊กอิน: circus.plugins.CircusPlugin

ชั้น circus.plugins.CircusPlugin(ปลายทาง pubsub_endpoint, ตรวจสอบ_ล่าช้า, ssh_server=ไม่มี,
**การกำหนดค่า)
คลาสพื้นฐานในการเขียนปลั๊กอิน

ตัวเลือก:

· สิ่งแวดล้อม -- บริบท ZMQ ที่จะใช้

· ปลายทาง -- ปลายทาง ZMQ circusd

· pubsub_endpoint -- จุดสิ้นสุดผับ/ย่อย ZMQ ของวงเวียน

· ตรวจสอบ_ล่าช้า -- การกำหนดค่าล่าช้าในการตรวจสอบที่กำหนดค่า

· การตั้งค่า -- การทำแผนที่การกำหนดค่าฟรี

โทร (คำสั่ง **อุปกรณ์ประกอบฉาก)
ส่งคำสั่งไปที่ ละครสัตว์

ตัวเลือก:

· คำสั่ง --คำสั่งเรียก

· พร็อพ -- อาร์กิวเมนต์คำหลักเพื่อเพิ่มในการเรียก

ส่งคืนการแมป JSON ที่ส่งกลับโดย ละครสัตว์

หล่อ (คำสั่ง **อุปกรณ์ประกอบฉาก)
ไฟและลืมคำสั่งเพื่อ ละครสัตว์

ตัวเลือก:

· คำสั่ง --คำสั่งเรียก

· พร็อพ -- อาร์กิวเมนต์คำหลักเพื่อเพิ่มในการเรียก

handle_init()
ถูกเรียกก่อนที่จะเริ่มปลั๊กอิน - ในบริบทของเธรด

handle_recv (ข้อมูล)
รับทุกงานเผยแพร่โดย ละครสัตว์

ตัวเลือก:

· ข้อมูล -- tuple ที่มีหัวข้อและข้อความ

handle_stop()
ถูกเรียกก่อนที่ปลั๊กอินจะหยุดโดย Circus

เมื่อเริ่มต้นโดย Circus คลาสนี้จะสร้างลูปเหตุการณ์ของตัวเองที่รับทั้งหมด
ละครสัตว์ เหตุการณ์และส่งต่อไปยัง handle_recv(). ข้อมูลที่ได้รับคือทูเพิลที่มี
หัวข้อและข้อมูลเอง

handle_recv() ต้อง ถูกใช้งานโดยปลั๊กอิน

การขอ เรียก() และ หล่อ() สามารถใช้วิธีการโต้ตอบกับ ละครสัตว์ หากคุณกำลังสร้าง
ปลั๊กอินที่โต้ตอบกับ daemon อย่างแข็งขัน

handle_init() และ handle_stop() เป็นเพียงวิธีการอำนวยความสะดวกที่คุณสามารถใช้เพื่อเริ่มต้นและ
ล้างรหัสของคุณ handle_init() ถูกเรียกภายในเธรดที่เพิ่งเริ่มต้น
handle_stop() ถูกเรียกในเธรดหลักก่อนที่เธรดจะหยุดและเข้าร่วม

การเขียน a เสียบเข้าไป
มาเขียนปลั๊กอินที่บันทึกไฟล์ทุกเหตุการณ์ที่เกิดขึ้นใน ละครสัตว์. มันต้องใช้เวลาหนึ่ง
อาร์กิวเมนต์ซึ่งเป็นชื่อไฟล์

ปลั๊กอินอาจมีลักษณะดังนี้:

จาก circus.plugins นำเข้า CircusPlugin

คลาส Logger (CircusPlugin):

ชื่อ = 'คนตัดไม้'

def __init__(ตัวเอง, *args, **config):
super(คนตัดไม้, ตัวเอง).__init__(*args, **config)
self.filename = config.get('ชื่อไฟล์')
self.file = ไม่มี

def handle_init (ตัวเอง):
self.file = เปิด (ชื่อตัวเอง, 'a+', บัฟเฟอร์ = 1)

def handle_stop (ตัวเอง):
self.file.close()

def handle_recv (ตัวเอง, ข้อมูล):
watcher_name, การกระทำ, msg = self.split_data (ข้อมูล)
msg_dict = self.load_message(ผงชูรส)
self.file.write('%s %s::%r\n' % (การกระทำ, watcher_name, msg_dict))

แค่นั้นแหละ ! คลาสนี้สามารถบันทึกในแพ็คเกจ/โมดูลใดก็ได้ ตราบใดที่สามารถเห็นได้
หลาม

ตัวอย่างเช่น คนตัดไม้ สามารถพบได้ใน ปลั๊กอิน โมดูลภายใน a โครงการของฉัน บรรจุภัณฑ์

อะซิงโครนัส การร้องขอ
ในกรณีที่คุณต้องการดำเนินการแบบอะซิงโครนัส (เช่นการโทรทอร์นาโดหรือการใช้
periodicCall) ตรวจสอบให้แน่ใจว่าคุณใช้ลูปที่ถูกต้อง ลูปที่คุณต้องการใช้เสมอ
เป็น self.loop ที่ถูกกำหนดโดยคลาสพื้นฐาน ลูปเริ่มต้นมักไม่เหมือนกัน
ดังนั้นโค้ดอาจไม่ทำงานตามที่คาดไว้

พยายาม a เสียบเข้าไป
คุณสามารถเรียกใช้ปลั๊กอินผ่านบรรทัดคำสั่งด้วยปุ่ม ละครสัตว์ปลั๊กอิน คำสั่งโดย
การระบุชื่อปลั๊กอินแบบเต็ม:

$ circus-plugin --endpoint tcp://127.0.0.1:5555 --pubsub tcp://127.0.0.1:5556 --config ชื่อไฟล์:circus-events.log myproject.plugins.Logger
[INFO] กำลังโหลดปลั๊กอิน...
[INFO] ปลายทาง: 'tcp://127.0.0.1:5555'
[INFO] ผับ/ย่อย: 'tcp://127.0.0.1:5556'
[INFO] เริ่มต้น

อีกวิธีหนึ่งในการเรียกใช้ปลั๊กอินคือให้ Circus จัดการการเริ่มต้น นี้ทำโดย
เพิ่มไฟล์ [ปลั๊กอิน:NAME] ส่วนในไฟล์กำหนดค่าโดยที่ ชื่อ เป็นชื่อเฉพาะสำหรับ
ปลั๊กอินของคุณ:

[ปลั๊กอิน:คนตัดไม้]
ใช้ = myproject.plugins.Logger
ชื่อไฟล์ = /var/myproject/circus.log

ใช้ เป็นข้อบังคับและชี้ไปที่ชื่อเต็มของปลั๊กอิน

เมื่อ Circus เริ่มต้นขึ้น มันจะสร้างผู้เฝ้าดูด้วยกระบวนการเดียวที่เรียกใช้คลาสที่ชี้และ
ส่งผ่านตัวแปรอื่น ๆ ที่มีอยู่ในส่วนไปยังตัวสร้างปลั๊กอินผ่านทาง การตั้งค่า
การทำแผนที่

คุณยังสามารถเพิ่มปลั๊กอินโดยทางโปรแกรมเมื่อคุณสร้าง a circus.arbiter.อนุญาโตตุลาการ ชั้น
หรือใช้ วงเวียน.get_arbiter(), ดูห้องสมุด.

ผลการดำเนินงาน
เนื่องจากทุกปลั๊กอินถูกโหลดด้วยกระบวนการของตัวเอง จึงไม่ควรส่งผลกระทบต่อโดยรวม
ประสิทธิภาพของระบบตราบใดที่งานที่ทำโดยปลั๊กอินไม่ได้ทำมากเกินไป
โทรไปที่ ละครสัตว์ กระบวนการ

ตะขอ
Circus มีตะขอที่สามารถใช้เพื่อกระตุ้นการกระทำตามเหตุการณ์ของผู้เฝ้าดู มีอยู่
ตะขอคือ:

· before_start: เรียกก่อนที่ผู้เฝ้ายามจะเริ่ม ถ้าเบ็ดกลับมา เท็จ
การเริ่มต้นถูกยกเลิก

· after_start: เรียกหลังจากเริ่มผู้เฝ้า ถ้าเบ็ดกลับมา เท็จ ผู้เฝ้าดู
จะหยุดทันทีและการเริ่มต้นจะถูกยกเลิก

· before_spawn: เรียกก่อนที่ผู้เฝ้าดูจะเกิดกระบวนการใหม่ ถ้าเบ็ดกลับมา เท็จ
ผู้เฝ้าดูจะหยุดทันทีและการเริ่มต้นจะถูกยกเลิก

· after_spawn: เรียกหลังจากผู้เฝ้าดูวางไข่กระบวนการใหม่ ถ้าเบ็ดกลับมา เท็จ
ผู้เฝ้าดูจะหยุดทันทีและการเริ่มต้นจะถูกยกเลิก

· ก่อน_หยุด: เรียกก่อนที่ผู้เฝ้าจะหยุด ผลลัพธ์ของเบ็ดจะถูกละเว้น

· อาฟเตอร์_สต็อป: เรียกหลังจากผู้เฝ้าหยุด ผลลัพธ์ของเบ็ดจะถูกละเว้น

· ก่อน_สัญญาณ: เรียกก่อนที่สัญญาณจะถูกส่งไปยังกระบวนการของผู้เฝ้า ถ้าขอเกี่ยว
รับคืน เท็จ ไม่ได้ส่งสัญญาณ (ยกเว้น SIGKILL ที่ส่งเสมอ)

· after_signal: เรียกหลังจากส่งสัญญาณไปยังกระบวนการของผู้เฝ้า

· Extended_stats: เรียกเมื่อมีการขอสถิติด้วย Extended=True ใช้สำหรับเพิ่ม
สถิติเฉพาะกระบวนการไปยังเอาต์พุตสถิติปกติ

ตัวอย่าง
กรณีใช้งานทั่วไปคือการควบคุมให้เป็นไปตามเงื่อนไขทั้งหมดเพื่อให้กระบวนการเริ่มต้น
สมมุติว่าคุณมีผู้เฝ้าคอยวิ่งอยู่ Redis และผู้เฝ้าดูที่รันสคริปต์ Python นั้น
ทำงานร่วมกับ Redis. ด้วย Circus คุณสามารถสั่งซื้อการเริ่มต้นได้โดยใช้ปุ่ม ลำดับความสำคัญ ตัวเลือก:

[ผู้ดู:พนักงานเข้าคิว]
cmd = python -u worker.py
ลำดับความสำคัญ = 1

[ผู้ดู:redis]
cmd = เซิร์ฟเวอร์ redis
ลำดับความสำคัญ = 2

ด้วยการตั้งค่านี้ ละครสัตว์จะเริ่มขึ้น Redis ก่อนแล้วจึงจะเริ่มคิวงาน
แต่คณะละครสัตว์ไม่ได้ควบคุมสิ่งนั้นจริงๆ Redis กำลังดำเนินการอยู่ มันก็แค่เริ่มต้น
กระบวนการถูกขอให้เริ่มต้น สิ่งที่เราคิดถึงนี่คือวิธีควบคุมสิ่งนั้น Redis is
เริ่มใช้งานได้เต็มประสิทธิภาพ ฟังก์ชั่นที่ควบคุมสิ่งนี้อาจเป็น:

นำเข้า redis
เวลานำเข้า

def check_redis(*args, **กิโลวัตต์):
time.sleep(.5) # ให้โอกาสในการเริ่มต้น
r = redis.StrictRedis(host='localhost', port=6379, db=0)
r.set('foo', 'bar')
ส่งคืน r.get('foo') == 'bar'

ฟังก์ชั่นนี้สามารถเสียบเข้ากับ Circus เป็น an before_start ตะขอ:

[ผู้ดู:พนักงานเข้าคิว]
cmd = python -u worker.py
hooks.before_start = mycoolapp.myplugins.check_redis
ลำดับความสำคัญ = 1

[ผู้ดู:redis]
cmd = เซิร์ฟเวอร์ redis
ลำดับความสำคัญ = 2

เมื่อคณะละครสัตว์ได้เริ่มต้น Redis ผู้เฝ้าดูก็จะเริ่มต้น พนักงานรอคิว ผู้เฝ้าดูตั้งแต่
มันเป็นไปตาม ลำดับความสำคัญ การสั่งซื้อ ก่อนเริ่มการดูที่สอง มันจะรัน
check_redis ฟังก์ชั่นและในกรณีที่ส่งคืน เท็จ จะยกเลิกผู้เฝ้าเริ่มต้น
กระบวนการ

ตะขอ ลายเซ็น
เบ็ดต้องปฏิบัติตามลายเซ็นนี้:

def hook(ผู้ดู, ผู้ชี้ขาด, hook_name, **kwargs):
...
#ไม่คืนทรูขอเปลี่ยนได้
#พฤติกรรมของคณะละครสัตว์(แล้วแต่เบ็ด)
ส่งคืน True

ที่ไหน กะลาสี คือ กะลาสี ตัวอย่างคลาส ผู้ตัดสิน ผู้ตัดสิน หนึ่ง, hook_name ตะขอ
ชื่อและ กวาง พารามิเตอร์ทางเลือกเพิ่มเติมบางส่วน (ขึ้นอยู่กับประเภทของเบ็ด)

การขอ after_spawn hook เพิ่มพารามิเตอร์ pid:

def after_spawn(ผู้เฝ้าดู, ผู้ตัดสิน, hook_name, pid, **kwargs):
...
#ถ้าคุณไม่คืน True คณะละครสัตว์จะฆ่ากระบวนการ
ส่งคืน True

ที่ไหน pid คือ PID ของกระบวนการที่เกี่ยวข้อง

ในทำนองเดียวกัน ก่อน_สัญญาณ และ after_signal hooks เพิ่ม pid และ signum:

def before_signal_hook(ผู้สังเกตการณ์, ผู้ตัดสิน, hook_name, pid, signum, **kwargs):
...
#ไม่คืนทรู เซอร์คัสไม่ส่งสัญญาณซิกนัม
# (ส่ง SIGKILL เสมอ)
ส่งคืน True

ที่ไหน pid เป็น PID ของกระบวนการที่เกี่ยวข้องและ สัญญาณ เป็นสัญญาณที่สอดคล้องกัน

คุณสามารถละเว้นสิ่งเหล่านั้นได้ แต่สามารถใช้ข้อมูลและวิธีการของผู้สังเกตการณ์และ / หรืออนุญาโตตุลาการได้
มีประโยชน์ในบางตะขอ

โปรดทราบว่า hooks ถูกเรียกด้วยอาร์กิวเมนต์ที่มีชื่อ ดังนั้นใช้ลายเซ็นเบ็ดโดยไม่ต้อง
การเปลี่ยนชื่ออาร์กิวเมนต์

การขอ Extended_stats hook มีพารามิเตอร์เพิ่มเติมใน กวาง:

def extended_stats_hook(ผู้เฝ้าสังเกตการณ์, ผู้ตัดสิน, hook_name, pid, สถิติ, **kwargs):
...

ที่ไหน pid เป็น PID ของกระบวนการที่เกี่ยวข้องและ สถิติ สถิติปกติที่จะ
กลับมา เพิ่มสถิติของคุณเองลงใน สถิติ. ตัวอย่างอยู่ใน
ตัวอย่าง/uwsgi_lossless_reload.py

เป็นตัวอย่างสุดท้าย นี่คือ super hook ที่สามารถจัดการกับสัญญาณทุกประเภท:

def super_hook(ผู้ดู, ผู้ชี้ขาด, hook_name, **kwargs):
pid = ไม่มี
signum = ไม่มี
ถ้า hook_name ใน ('before_signal', 'after_signal'):
pid = kwargs['pid']
signum = kwargs['signum']
...
ส่งคืน True

ตะขอ เหตุการณ์
ทุกครั้งที่มีการเรียกใช้ hook ผลลัพธ์จะได้รับแจ้งเป็นเหตุการณ์ใน Circus

มีสองเหตุการณ์ที่เกี่ยวข้องกับ hooks:

· hook_success: เรียกเบ็ดสำเร็จ คีย์เหตุการณ์คือ พร้อมชื่อ ชื่อถ้า
เหตุการณ์และ เวลา: วันที่จัดงาน

· hook_failure: เบ็ดล้มเหลว คีย์เหตุการณ์คือ พร้อมชื่อ ชื่อถ้าเหตุการณ์ เวลา:
วันที่จัดงานและ ความผิดพลาด: ข้อยกเว้นที่เกิดขึ้นในเหตุการณ์ หากมี

เพิ่ม ใหม่ คำสั่ง
เราพยายามเพิ่มคำสั่งใหม่ให้ง่ายที่สุด

คุณต้องทำสามสิ่ง:

1. สร้าง your_command.py ไฟล์ภายใต้ คณะละครสัตว์/คำสั่ง/.

2. ใช้คลาสเดียวในนั้นด้วยวิธีการที่กำหนดไว้ล่วงหน้า

3. เพิ่มคำสั่งใหม่ใน วงเวียน/commands/__init__.py.

สมมติว่าเราต้องการเพิ่มคำสั่งซึ่งส่งคืนจำนวนผู้ดูที่ใช้อยู่ในปัจจุบัน
เราก็จะทำประมาณนี้ค่ะ (คอมเมนต์กันเยอะๆนะคะ เผื่อจะได้ติดตามกันมากขึ้น
อย่างง่ายดาย):

จาก circus.commands.base นำเข้าคำสั่ง
จาก circus.exc นำเข้า ArgumentError, MessageError
คลาส NumWatchers (คำสั่ง):
""" เป็นการดีที่จะอธิบายสิ่งที่ชั้นเรียนทำที่นี่

ดูคำสั่งอื่นๆ เพื่อดูว่าเราใช้ฟอร์แมตอย่างไร
ข้อความนี้ มันจะรวมอยู่ในเอกสารโดยอัตโนมัติ
ดังนั้นอย่ากลัวที่จะละเอียดถี่ถ้วนนั่นคือสิ่งที่ทำขึ้น
สำหรับ
"" "
# คำสั่งทั้งหมดสืบทอดมาจาก `circus.commands.base.Command`

# คุณต้องระบุชื่อเพื่อให้เราพบคำสั่งกลับมา
ชื่อ = "นักนับเลข"

# ตั้งค่ารอเป็นจริงหรือเท็จเพื่อกำหนดพฤติกรรมเริ่มต้นของคุณ
# - หากการรอเป็น True คำสั่งจะถูกรันแบบซิงโครนัสและไคลเอนต์อาจได้รับ
#ผลย้อนหลัง.
# - หากการรอเป็นเท็จ คำสั่งจะถูกรันแบบอะซิงโครนัสบนเซิร์ฟเวอร์และไคลเอนต์ทันที
#ได้รับการตอบกลับว่า 'ตกลง'
#
# โดยค่าเริ่มต้น คำสั่งจะถูกตั้งค่าให้รอ = False
รอ = จริง

# ตัวเลือก
ตัวเลือก = [('', 'optname', default_value, 'description')]

คุณสมบัติ = ['foo', 'bar']
# คุณสมบัติแสดงรายการอาร์กิวเมนต์คำสั่งที่จำเป็น ถ้าใช่
#ไม่ได้ระบุแล้วจะโยนข้อผิดพลาด

def ดำเนินการ (ตัวเอง, ผู้ตัดสิน, อุปกรณ์ประกอบฉาก):
# วิธีดำเนินการคือแกนหลักของคำสั่ง: ใส่ทั้งหมด
# ตรรกะของคำสั่งและส่งคืน dict ที่มีค่าคุณ
#อยากคืนถ้ามี
ส่งคืน {"numwatchers": arbiter.numwatchers()}

def console_msg(ตัวเอง, ผงชูรส):
# msg คือสิ่งที่ส่งคืนโดยวิธีการดำเนินการ
# วิธีนี้ใช้เพื่อจัดรูปแบบการตอบสนองสำหรับคอนโซล (คือ
# ใช้สำหรับตัวอย่างเช่นโดย circusctl เพื่อพิมพ์ข้อความ)
ส่งคืน "สตริงที่จะแสดง"

ข้อความ def (ตัวเอง, *args, **opts):
# ข้อความจัดการอินพุตคอนโซล
# วิธีนี้ใช้เพื่อแมปอาร์กิวเมนต์คอนโซลกับคำสั่ง
# ตัวเลือก. (ใช้เช่นเมื่อเรียกใช้คำสั่งผ่าน
#วงเวียน)
# NotImplementedError จะถูกส่งออกไปหากฟังก์ชันหายไป
numArgs = 1
ถ้าไม่ใช่ len(args) == numArgs:
ยก ArgumentError('จำนวนอาร์กิวเมนต์ไม่ถูกต้อง')
อื่น:
opts['optname'] = args[0]
ส่งคืน self.make_message(**ตัวเลือก)

def ตรวจสอบ (ตัวเอง, อุปกรณ์ประกอบฉาก):
# วิธีนี้ใช้เพื่อตรวจสอบว่าอาร์กิวเมนต์ส่งผ่านไปยัง
#คำสั่งถูกต้อง ArgumentError ควรโยนในกรณี
# มีข้อผิดพลาดในการส่งอาร์กิวเมนต์ (เช่นถ้าพวกเขา
#ไม่เข้ากัน.
# ในกรณีที่มีปัญหาในการเขียนเนื้อหา MessageError
#ควรโยนทิ้ง วิธีนี้สามารถปรับเปลี่ยนเนื้อหาของพร็อพได้
# dict มันจะถูกส่งต่อเพื่อดำเนินการในภายหลัง

ใช้ กรณี ตัวอย่าง
บทนี้นำเสนอกรณีการใช้งานบางประการเพื่อให้คุณมีแนวคิดในการใช้ Circus ใน
สิ่งแวดล้อม

เล่น a WSGI ใบสมัคร
การเรียกใช้แอปพลิเคชั่น WSGI กับ Circus นั้นค่อนข้างน่าสนใจเพราะคุณสามารถรับชมและจัดการได้
ธุรกิจ เว็บ แรงงาน ด้วย ละครสัตว์ด้านบน, วงเวียน หรือเว็บอินเตอร์เฟส

สิ่งนี้เกิดขึ้นได้โดยใช้ซ็อกเก็ต Circus ดูว่าทำไมcircussockets

ลองมาดูตัวอย่างที่มีน้อยที่สุด ปิรามิด แอพลิเคชัน

จาก pyramid.config นำเข้า Configurator
จาก pyramid.response นำเข้าการตอบสนอง

def hello_world (คำขอ):
return Response('สวัสดี %(name)s!' % request.matchdict)

config = ตัวกำหนดค่า ()
config.add_route('hello', '/hello/{name}')
config.add_view(hello_world, route_name='hello')
แอปพลิเคชัน = config.make_wsgi_app()

บันทึกสคริปต์นี้ลงใน an app.py ไฟล์ จากนั้นติดตั้งโครงการเหล่านั้น:

$ pip ติดตั้งพีระมิด
$ pip ติดตั้ง chaussette

ถัดไป ตรวจสอบให้แน่ใจว่าคุณสามารถเรียกใช้แอปพลิเคชัน Pyramid ได้โดยใช้ปุ่ม ถุงเท้า สคริปต์คอนโซล:

$ chaussette app.application
ใบสมัครคือ
ให้บริการบน localhost:8080
โดยใช้ เป็นแบ็กเอนด์

และตรวจสอบว่าคุณสามารถเข้าถึงได้โดยไปที่ http://localhost:8080/สวัสดี/tarek

เมื่อแอปพลิเคชันของคุณเริ่มทำงานแล้ว มาสร้างไฟล์การกำหนดค่า 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

[ซ็อกเก็ต: เว็บแอพ]
โฮสต์ = 127.0.0.1
พอร์ต = 8080

ไฟล์นี้บอกให้ Circus ผูกซ็อกเก็ตบนพอร์ต 8080 และวิ่ง ถุงเท้า คนงานบนนั้น
ซ็อกเก็ต -- โดยผ่าน fd ของมัน

บันทึกไว้ใน เซิร์ฟเวอร์.ini แล้วลองรันโดยใช้ ละครสัตว์

$circusd server.ini
[INFO] ต้นแบบเริ่มต้นบน pid 8971
[INFO] ซ็อกเก็ตเริ่มต้น
[INFO] สถิติละครเริ่มแล้ว
[INFO] เริ่มใช้งานเว็บแอป
[INFO] อนุญาโตตุลาการกำลังรอคำสั่งอยู่

ตรวจสอบให้แน่ใจว่าคุณยังคงเปิดแอปอยู่ http://localhost:8080/สวัสดี/tarek.

ยินดีด้วย ! คุณมีแอปพลิเคชัน WSGI ที่ทำงาน 3 คน

คุณสามารถเรียกใช้ circushttpd หรือ cli และเพลิดเพลินกับการจัดการ Circus

เล่น a Django ใบสมัคร
การเรียกใช้แอปพลิเคชัน Django ทำได้เหมือนกับการเรียกใช้แอปพลิเคชัน WSGI ใช้
ไพธอนพาธ เพื่อนำเข้าไดเร็กทอรีที่โปรเจ็กต์อยู่ ไดเร็กทอรีที่มี
ไดเร็กทอรีที่มี settings.py อยู่ในนั้น (ด้วย Django 1.4+ ไดเร็กทอรีนี้มี Manage.py อยู่ในนั้น)
:

[ซ็อกเก็ต:dwebapp]
โฮสต์ = 127.0.0.1
พอร์ต = 8080

[ผู้ดู:dwebworker]
cmd = chaussette --fd $ (circus.sockets.dwebapp) dproject.wsgi.application
use_sockets = จริง
จำนวนกระบวนการ = 2

[env:dwebworker]
PYTHONPATH = /path/to/parent-of-dproject

หากคุณจำเป็นต้องผ่าน DJANGO_SETTINGS_MODULE สำหรับผู้ปฏิบัติงานส่วนหลัง ตัวอย่างเช่น คุณสามารถ
ผ่านที่แม้ว่า env ตัวเลือกการกำหนดค่า:

[ผู้ดู:dbackend]
cmd = /path/to/script.py
จำนวนการประมวลผล = 3

[env:dbackend]
PYTHONPATH = /path/to/parent-of-dproject
DJANGO_SETTINGS_MODULE=dproject.settings

ดู http://chaussette.readthedocs.org สำหรับข้อมูลเพิ่มเติมเกี่ยวกับ chaussette

ออกแบบ การตัดสินใจ
ทั้งหมด สถาปัตยกรรม
[ภาพ]

Circus ประกอบด้วยกระบวนการหลักที่เรียกว่า ละครสัตว์ ที่ดูแลการวิ่งทั้งหมด
กระบวนการ แต่ละกระบวนการที่จัดการโดย Circus เป็นกระบวนการย่อยของ ละครสัตว์.

กระบวนการจัดเป็นกลุ่มที่เรียกว่า นักดู. กะลาสี ก็คือคำสั่ง
ละครสัตว์ ทำงานบนระบบของคุณ และสำหรับแต่ละคำสั่ง คุณสามารถกำหนดจำนวนกระบวนการที่คุณ
ต้องการวิ่ง

แนวคิดของ กะลาสี มีประโยชน์เมื่อคุณต้องการจัดการกระบวนการทั้งหมดที่ทำงานอยู่
คำสั่งเดียวกัน เช่น รีสตาร์ท เป็นต้น

ละครสัตว์ ผูกสองซ็อกเก็ต ZeroMQ:

· คำขอ/ตัวแทน -- ซ็อกเก็ตที่ใช้ในการควบคุม ละครสัตว์ ใช้ json-based คำสั่ง.

· ผับ/ย่อย -- ซ็อกเก็ตที่ ละครสัตว์ เผยแพร่กิจกรรม เช่น เมื่อเริ่มกระบวนการหรือ
หยุด

หมายเหตุ:
แม้จะมีชื่อ ZeroMQ ไม่ใช่ระบบการจัดการคิว คิดว่ามันเป็น
ไลบรารีการสื่อสารระหว่างกระบวนการ (IPC)

กระบวนการอื่นที่เรียกว่า สถิติวงเวียน ดำเนินการโดย ละครสัตว์ เมื่อเปิดใช้งานตัวเลือก
สถิติวงเวียนหน้าที่ของมันคือการเผยแพร่สถิติการใช้งาน CPU/หน่วยความจำในเฉพาะ ผับ/ย่อย
ช่อง

ช่องพิเศษนี้ใช้โดย ละครสัตว์ด้านบน และ ละครสัตว์-httpd เพื่อแสดงสตรีมสด
ของกิจกรรม

ละครสัตว์ด้านบน เป็นสคริปต์คอนโซลที่เลียนแบบ ด้านบน เพื่อแสดงการใช้งาน CPU และหน่วยความจำทั้งหมดของ
กระบวนการที่จัดการโดยคณะละครสัตว์

ละครสัตว์-httpd เป็นอินเทอร์เฟซการจัดการเว็บที่จะช่วยให้คุณโต้ตอบกับ Circus มัน
แสดงสตรีมสดโดยใช้ซ็อกเก็ตเว็บและ สถิติวงเวียน ช่อง แต่ยังให้คุณ
โต้ตอบกับ ละครสัตว์ ผ่านทาง คำขอ/ตัวแทน ช่อง

สุดท้าย แต่ไม่ท้ายสุด, วงเวียน เป็นเครื่องมือบรรทัดคำสั่งที่ให้คุณขับรถได้ ละครสัตว์ ผ่านทาง
คำขอ/ตัวแทน ช่อง

คุณยังสามารถมีปลั๊กอินที่สมัครสมาชิก ละครสัตว์'s ผับ/ย่อย ช่องทางและให้คุณส่ง
คำสั่งให้ คำขอ/ตัวแทน ช่อง like วงเวียน หากว่า

⁠ความปลอดภัย
Circus สร้างขึ้นที่ด้านบนของไลบรารี ZeroMQ และไม่มีการรักษาความปลอดภัยเลยในนั้น
โปรโตคอล อย่างไรก็ตาม คุณสามารถเรียกใช้ระบบ Circus บนเซิร์ฟเวอร์และตั้งค่าช่องสัญญาณ SSH เป็น
เข้าถึงได้จากเครื่องอื่น

ส่วนนี้จะอธิบายว่า Circus ทำอะไรกับระบบของคุณเมื่อคุณเรียกใช้งาน และจบลงที่
อธิบายวิธีการใช้อุโมงค์ SSH

คุณยังสามารถอ่าน http://www.zeromq.org/area:คำถามที่พบบ่อย#toc5

TCP พอร์ต
ตามค่าเริ่มต้น Circus จะเปิดพอร์ต TCP ต่อไปนี้บนโฮสต์ท้องถิ่น:

· 5555 -- ท่าเรือที่ใช้ควบคุมคณะละครสัตว์ ผ่านทาง วงเวียน

· 5556 -- พอร์ตที่ใช้สำหรับช่อง Publisher/Subscriber

· 5557 -- พอร์ตที่ใช้สำหรับช่องสถิติ -- ถ้าเปิดใช้งาน

· 8080 -- พอร์ตที่ใช้โดย Web UI -- หากเปิดใช้งาน

พอร์ตเหล่านี้อนุญาตให้แอปไคลเอ็นต์โต้ตอบกับระบบ Circus ของคุณได้ และขึ้นอยู่กับวิธีการ
โครงสร้างพื้นฐานของคุณได้รับการจัดระเบียบ คุณอาจต้องการปกป้องพอร์ตเหล่านี้ผ่านไฟร์วอลล์ or
กำหนดค่า Circus ให้ทำงานโดยใช้ IPC พอร์ต

ต่อไปนี้คือตัวอย่างการรัน Circus โดยใช้จุดเริ่มต้น IPC เท่านั้น:

[ละครสัตว์]
ตรวจสอบ_ล่าช้า = 5
จุดปลาย = ipc:///var/circus/endpoint
pubsub_endpoint = ipc:///var/circus/pubsub
stats_endpoint = ipc:///var/circus/stats

เมื่อกำหนดค่าโดยใช้ IPC คำสั่งจะต้องเรียกใช้จากกล่องเดียวกัน แต่ไม่มีใครสามารถ
เข้าถึงได้จากภายนอก ไม่เหมือนกับการใช้ TCP คำสั่งยังต้องรันในฐานะผู้ใช้ที่
มีการเข้าถึงการเขียนเส้นทางซ็อกเก็ต ipc คุณสามารถแก้ไขเจ้าของ ปลายทาง ด้วย
endpoint_owner ตัวเลือกการกำหนดค่า สิ่งนี้ทำให้คุณสามารถเรียกใช้ circusd ในฐานะผู้ใช้รูทได้ แต่
อนุญาตให้กระบวนการที่ไม่ใช่รูทส่งคำสั่งไปที่ ละครสัตว์. โปรดทราบว่าเมื่อใช้ endpoint_owner,
เพื่อป้องกันไม่ให้กระบวนการที่ไม่ใช่รูทสามารถเริ่มกระบวนการตามอำเภอใจที่
รันด้วยสิทธิพิเศษที่มากกว่า คำสั่ง add จะบังคับให้ผู้ดูใหม่ต้องทำงานเป็น
endpoint_owner ผู้ใช้ คำจำกัดความของผู้สังเกตการณ์ในไฟล์กำหนดค่าในเครื่องจะไม่เป็น
จำกัดด้วยวิธีนี้

แน่นอน หากคุณเปิดใช้งาน UI ของเว็บ 8080 พอร์ตจะยังคงเปิดอยู่

ละครสัตว์httpd
เมื่อคุณรัน ละครสัตว์httpd ด้วยตนเองหรือเมื่อคุณใช้ httpd ตัวเลือกในไฟล์ ini เช่น
นี้:

[ละครสัตว์]
ตรวจสอบ_ล่าช้า = 5
จุดปลาย = ipc:///var/circus/endpoint
pubsub_endpoint = ipc:///var/circus/pubsub
stats_endpoint = ipc:///var/circus/stats
httpd = 1

เว็บแอปพลิเคชันจะทำงานบนพอร์ต 8080 และจะยอมให้ใครก็ตามเข้าถึงหน้าเว็บ
จัดการไฟล์ ละครสัตว์ ภูต

ซึ่งรวมถึงการสร้างผู้สังเกตการณ์รายใหม่ที่สามารถเรียกใช้คำสั่งใดๆ ในระบบของคุณ!

Do ไม่ ทำ it สาธารณชน ใช้ได้

หากคุณต้องการป้องกันการเข้าถึงแผงเว็บ คุณสามารถให้บริการหลัง Nginx หรือ
Apache หรือเว็บเซิร์ฟเวอร์ที่รองรับพร็อกซี่ที่สามารถดูแลความปลอดภัยได้

ผู้ใช้งาน และ บัญชีกลุ่ม สิทธิ์
โดยค่าเริ่มต้น กระบวนการทั้งหมดที่เริ่มต้นด้วย Circus จะทำงานโดยผู้ใช้และกลุ่มเดียวกัน
as ละครสัตว์. ขึ้นอยู่กับสิทธิ์ที่ผู้ใช้มีในระบบ คุณอาจไม่มี
เข้าถึงคุณลักษณะทั้งหมดที่ Circus มีให้

ตัวอย่างเช่น คุณลักษณะทางสถิติบางอย่างในกระบวนการที่ทำงานอยู่ต้องการสิทธิ์เพิ่มเติม
โดยปกติ หากตัวเลขการใช้งาน CPU ที่คุณได้รับโดยใช้ สถิติ คำสั่งคือ N / A, มันหมายถึง . ของคุณ
ผู้ใช้ไม่สามารถเข้าถึงไฟล์ proc ซึ่งจะเป็นตามค่าเริ่มต้นใน Mac OS X

คุณสามารถเรียกใช้ ละครสัตว์ เป็นรูทเพื่อแก้ไขปัญหานี้และตั้งค่า UID และ กิด คุณค่าสำหรับผู้ดูแต่ละคน
เพื่อรับคุณสมบัติทั้งหมด

แต่ระวังวิ่งนะ ละครสัตว์ เนื่องจากรูททำให้คุณได้รับการยกระดับสิทธิ์ที่อาจเกิดขึ้น
ข้อบกพร่อง ในขณะที่เรากำลังพยายามอย่างเต็มที่ที่จะหลีกเลี่ยงบั๊ก การรันแบบรูทและเผชิญหน้ากับบั๊กนั้น
ดำเนินการที่ไม่ต้องการในระบบของคุณอาจเป็นอันตรายได้

วิธีที่ดีที่สุดที่จะป้องกันสิ่งนี้คือต้องแน่ใจว่าระบบที่รัน Circus นั้นสมบูรณ์
โดดเดี่ยว (เช่น VM) or เพื่อรันทั้งระบบภายใต้การควบคุมของผู้ใช้

SSH การขุดเจาะอุโมงค์
ลูกค้าสามารถเชื่อมต่อกับ a ละครสัตว์ อินสแตนซ์โดยการสร้างช่องสัญญาณ SSH ในการทำเช่นนั้น ให้ผ่าน
ตัวเลือกบรรทัดคำสั่ง --ssh ตามมาด้วย ผู้ใช้@ที่อยู่ที่นี่มี ผู้ใช้งาน คือผู้ใช้บนรีโมท
เซิร์ฟเวอร์และ ที่อยู่ คือที่อยู่ของเซิร์ฟเวอร์ตามที่ลูกค้าเห็น โปรโตคอล SSH จะ
ต้องการข้อมูลประจำตัวเพื่อเข้าสู่ระบบให้เสร็จสมบูรณ์

If ละครสัตว์ ตามที่เห็นโดยเซิร์ฟเวอร์ SSH ไม่ใช่ที่อยู่ปลายทางเริ่มต้น localhost: 5555
แล้วระบุ ละครสัตว์ ที่อยู่โดยใช้ตัวเลือก --จุดปลาย

ปลอดภัย การติดตั้ง ตัวอย่าง
การตั้งค่าเซิร์ฟเวอร์ Circus ที่ปลอดภัยสามารถทำได้โดย:

· การรันเซิร์ฟเวอร์ SSH

·เรียกใช้ Apache หรือ Nginx บน 80 พอร์ต และทำ reverse-proxy บน the 8080 ท่าเรือ.

·การปิดกั้น 8080 พอร์ตจากการเข้าถึงภายนอก

· รันพอร์ต ZMQ Circusd ทั้งหมดโดยใช้ไฟล์ IPC แทนพอร์ต TCP และทำการทันเนลทั้งหมด
โทรผ่าน SSH
[ภาพ]

การบริจาค ไปยัง วงเวียน
คณะละครสัตว์ได้เริ่มต้นที่ Mozilla แล้ว แต่เป้าหมายไม่ใช่แค่การอยู่ที่นั่นเท่านั้น เรากำลังพยายาม
เพื่อสร้างเครื่องมือที่เป็นประโยชน์ต่อผู้อื่นและขยายได้ง่าย

เราเปิดกว้างสำหรับการสนับสนุนใด ๆ ในรูปแบบของรหัส, เอกสาร, การอภิปราย,
ข้อเสนอคุณสมบัติ ฯลฯ

คุณสามารถเริ่มหัวข้อในรายชื่อผู้รับจดหมายของเรา: http://tech.groups.yahoo.com/group/circus-dev/

หรือเพิ่มปัญหาใน .ของเรา ข้อผิดพลาด ติดตาม

เครื่องประกอบ ความผิดพลาด และ การเสริมสร้าง เอกสาร
เป็นไปได้อย่างยิ่งที่ดวงตาของคุณจะมีเลือดออกขณะอ่านครึ่งภาษาอังกฤษ
เอกสารครึ่งฝรั่งเศส อย่าลังเลที่จะใช้ถ้อยคำใหม่/ปรับปรุงบน
แบบฟอร์มในเอกสารประกอบ คุณอาจไม่จำเป็นต้องเข้าใจว่า Circus ทำงานอย่างไร
ภายใต้ประทุนที่จะทำอย่างนั้น

เพิ่ม ใหม่ ที่
แน่นอนว่าคุณสมบัติใหม่นั้นได้รับการชื่นชมอย่างมาก หากคุณมีความต้องการและเวลาในการ
ทำงานกับคุณสมบัติใหม่ การเพิ่มคุณสมบัติเหล่านี้ใน Circus ไม่ควรซับซ้อนขนาดนั้น เราพยายามมาก
ยากที่จะมี API ที่สะอาดและเข้าใจได้ หวังว่ามันจะตอบสนองวัตถุประสงค์

คุณจะต้องเพิ่มเอกสารประกอบและการทดสอบควบคู่ไปกับโค้ดของคุณลักษณะใหม่
มิฉะนั้น เราจะไม่สามารถยอมรับแพตช์นี้ได้

สรุป ความน่าเชื่อถือของ Olymp Trade? ไปยัง ส่ง ธุรกิจ การเปลี่ยนแปลง
เรากำลังใช้ git เป็น DVCS วิธีที่ดีที่สุดในการเสนอการเปลี่ยนแปลงคือการสร้างสาขาใน .ของคุณ
ด้านข้าง (ผ่าน คอมไพล์ เช็คเอาต์ -b ชื่อสาขา) และยืนยันการเปลี่ยนแปลงของคุณที่นั่น เมื่อคุณมี
สิ่งที่พร้อมสำหรับไพรม์ไทม์ ออกคำขอดึงกับสาขานี้

เรากำลังติดตามโมเดลนี้เพื่อให้มีการมีเพศสัมพันธ์ต่ำระหว่างคุณสมบัติที่คุณเป็น
เสนอ ตัวอย่างเช่น เราสามารถยอมรับคำขอดึงหนึ่งรายการในขณะที่ยังอยู่ระหว่างการสนทนา
สำหรับอีกคนหนึ่ง

ก่อนเสนอการเปลี่ยนแปลงของคุณ ให้ตรวจสอบอีกครั้งว่าไม่ได้ทำสิ่งใดเสียหาย! คุณสามารถ
ใช้ Tox คำสั่งเพื่อให้แน่ใจว่ามันจะรัน testsuite ภายใต้ different
รองรับเวอร์ชันหลาม

โปรดใช้ : http://issue2pr.herokuapp.com/ เพื่ออ้างถึงความมุ่งมั่นต่อคณะละครสัตว์ที่มีอยู่
ปัญหาถ้ามี

หลีกเลี่ยง ผสาน มุ่งมั่น
การหลีกเลี่ยงการผสานรวมช่วยให้มีประวัติที่ชัดเจนและอ่านได้ ให้ทำเช่นนั้นแทน
ทำ "git pull" และปล่อยให้ git จัดการการผสานให้คุณโดยใช้ git pull --rebase will
ใส่การเปลี่ยนแปลงของคุณหลังจากการเปลี่ยนแปลงที่เกิดขึ้นในสาขาหรือเมื่อทำงานกับ
เจ้านาย

นั่นคือสำหรับนักพัฒนาหลักอย่างพวกเราแล้ว มันเป็นไปไม่ได้อีกต่อไปที่จะใช้ github green ที่มีประโยชน์
ปุ่มบนคำขอดึงหากนักพัฒนาไม่ได้ปรับงานของพวกเขาเองหรือถ้าเรารอ
เวลามากเกินไประหว่างคำขอและการผสานจริง การไหลจะมีลักษณะดังนี้:

git remote เพิ่มชื่อ repo-url
git เรียกชื่อ
git checkout คุณลักษณะสาขา
คอมไพล์รีเบสมาสเตอร์

# ตรวจสอบว่าทุกอย่างทำงานอย่างถูกต้องแล้วรวมเข้ากับ master
git checkout master
git ผสานคุณสมบัติสาขา

การอภิปราย
หากคุณต้องการความช่วยเหลือขณะดูโค้ดของ Circus คุณสามารถไปที่
และพบกับเราบน irc ได้ที่ #เต็นท์ละครสัตว์ on irc.freenode.org (หรือถ้าคุณไม่มีIRC
ลูกค้าใช้ เว็บแชท)

คุณยังสามารถตั้งกระทู้ในรายชื่อผู้รับจดหมายของเรา -
http://tech.groups.yahoo.com/group/circus-dev

มัก ถาม คำถามที่พบบ่อย
นี่คือรายการคำถามที่พบบ่อยเกี่ยวกับ Circus:

สรุป ความน่าเชื่อถือของ Olymp Trade? ทำ วงเวียน กอง เปรียบเทียบ ไปยัง a คลาสสิก ซ้อนกัน?
ในสแต็ก WSGI แบบคลาสสิก คุณมีเซิร์ฟเวอร์เช่น Gunicorn ที่ให้บริการบนพอร์ตหรือ
ยูนิกซ์ซ็อกเก็ตและมักจะถูกปรับใช้หลังเว็บเซิร์ฟเวอร์เช่น Nginx: [ภาพ]

ลูกค้าโทรหา Nginx ซึ่งจะทำการพร็อกซีย้อนกลับไปยัง Gunicorn ทั้งหมด

หากคุณต้องการให้แน่ใจว่ากระบวนการ Gunicorn ยังคงทำงานอยู่ คุณต้องใช้ a
โปรแกรมเช่น Supervisord หรือพุ่งพรวด

ในทางกลับกัน Gunicorn เฝ้าดูกระบวนการ ("คนงาน")

คุณกำลังใช้การจัดการกระบวนการสองระดับ หนึ่งที่คุณจัดการและ
control (supervisord) และอันที่สองที่คุณต้องจัดการใน UI อื่นด้วย a
ปรัชญาที่แตกต่างและควบคุมสิ่งที่เกิดขึ้นได้น้อยลง (เซิร์ฟเวอร์ wsgi หนึ่งอัน)

นี่เป็นเรื่องจริงสำหรับ Gunicorn และเซิร์ฟเวอร์ WSGI แบบหลายกระบวนการส่วนใหญ่ที่ฉันรู้
uWsgi นั้นแตกต่างออกไปเล็กน้อยเนื่องจากมีตัวเลือกมากมายเหลือเฟือ

แต่ถ้าคุณต้องการเพิ่มเซิร์ฟเวอร์ Redis ในสแต็กของคุณ คุณ จะ ลงเอยด้วยการจัดการของคุณ
กระบวนการสแต็กในสองที่ต่างกัน

แนวทางของคณะละครสัตว์ในเรื่องนี้คือการจัดการกระบวนการ และ ซ็อกเก็ต

กองละครสัตว์สามารถมีลักษณะดังนี้: [ภาพ]

เช่นเดียวกับ Gunicorn ที่ Circus สามารถผูกซ็อกเก็ตที่จะ Proxied โดย Nginx ละครสัตว์
ไม่จัดการกับคำขอแต่เพียงผูกซ็อกเก็ต แล้วแต่คนทำเว็บ
กระบวนการยอมรับการเชื่อมต่อบนซ็อกเก็ตและทำงาน

มันมีคุณสมบัติเทียบเท่ากับ Supervisord แต่ยังช่วยให้คุณจัดการทั้งหมด
กระบวนการในระดับเดียวกัน ไม่ว่าจะเป็นพนักงานเว็บหรือ Redis หรืออะไรก็ตาม การเพิ่ม
เจ้าหน้าที่เว็บใหม่เสร็จสิ้นเหมือนกับการเพิ่มกระบวนการ 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

สรุป ความน่าเชื่อถือของ Olymp Trade? ไปยัง แก้ไขปัญหา ละครสัตว์?
โดยค่าเริ่มต้น ละครสัตว์ ยังคงเข้าสู่ระบบ แย่ ค่อนข้างเบาบาง การขาดผลผลิตนี้สามารถ
ทำให้สิ่งที่ยากต่อการแก้ไขปัญหาเมื่อกระบวนการดูเหมือนจะมีปัญหาในการเริ่มต้น

เพื่อเพิ่มการบันทึก ละครสัตว์ ให้ลองเพิ่มระดับบันทึก เพื่อดู
ระดับบันทึกที่ใช้ได้เพียงแค่ใช้ --ช่วยด้วย ธง.

$ circus --log-level ดีบัก test.ini

หนึ่งคำเตือน หากกระบวนการกระพือและระดับล็อกการดีบักเปิดอยู่ คุณจะ
จะเห็นข้อความสำหรับการพยายามเริ่มต้นแต่ละครั้ง อาจเป็นประโยชน์ในการกำหนดค่าแอพที่เป็น
กระพือปีกเพื่อใช้ a วอร์มอัพ_ดีเลย์ เพื่อทำให้ข้อความช้าลงจนสามารถจัดการได้

[ผู้ดู:webapp]
cmd = หลาม -m myapp.wsgi
วอร์มอัพ_ดีเลย์ = 5

โดยค่าเริ่มต้น แย่ และ สตเดอร์ ถูกจับโดย ละครสัตว์ กระบวนการ. หากคุณกำลังทดสอบ .ของคุณ
config และต้องการดูผลลัพธ์ที่สอดคล้องกับเอาต์พุต circusd คุณสามารถกำหนดค่าของคุณ
ผู้เฝ้าติดตามใช้ StdoutStream ชั้นเรียน

[ผู้ดู:webapp]
cmd = หลาม -m myapp.wsgi
stdout_stream.class = StdoutStream
stderr_stream.class = StdoutStream

หากแอปพลิเคชันของคุณสร้างการสืบค้นกลับหรือข้อผิดพลาดขณะพยายามเริ่มต้นระบบของคุณ
ควรจะสามารถดูได้ในการส่งออก

การเปลี่ยนแปลง ประวัติ
0.12.1 - 2015-08-05
· แก้ไขข้อผิดพลาดเมื่อรีสตาร์ทผู้ดูด้วยสตรีมเอาต์พุต - #913

·ปรับแต่งเอกสารเล็กน้อย

0.12 - 2015-06-02
รุ่นนี้รองรับ Python 3.4, Tornado 4 และ Windows ท่ามกลางความตื่นเต้นมากมาย
คุณสมบัติและการแก้ไข

การสนับสนุน 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

· ลบซ็อกเก็ตที่รั่วใน stats daemon - #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 hook

· CircusPlugin ใช้งานง่ายกว่า

· แก้ไข autostart=False watchers ระหว่างการเริ่มต้น (การถดถอย)

การเปลี่ยนแปลงเพิ่มเติม:

· ข้อความละครสัตว์สามารถกำหนดเส้นทางไปยัง syslog ได้แล้ว - #748

เพิ่มตัวเลือก endpoint_owner เพื่อให้เราสามารถกำหนดได้ว่าผู้ใช้รายใดเป็นเจ้าของไฟล์ซ็อกเก็ต ipc ที่สร้างโดย
คณะละครสัตว์

· เริ่มการรองรับ Windows (ตอนนี้แค่ circusctl)

· แก้ไขการรั่วจำนวนมากในการทดสอบ

· อนุญาตให้ใช้ตัวแปรสภาพแวดล้อมที่มีความสำคัญตัวพิมพ์เล็กและตัวพิมพ์ใหญ่

· ปลั๊กอินทรัพยากรยอมรับค่าหน่วยความจำแบบสัมบูรณ์แล้ว - #609

· เพิ่มการรองรับคำสั่งเพิ่มสำหรับตัวเลือก 'ซิงเกิลตัน' - #767

· อนุญาตให้ส่งสัญญาณตามอำเภอใจไปยัง procs ย่อยผ่านตัวตรวจสอบทรัพยากร - #756

· อนุญาตการกำหนดค่า INI/JSON/YAML สำหรับการบันทึก

· ตรวจสอบให้แน่ใจว่าเราเข้ากันได้กับ psutil 2.x และ 3.x

· เพิ่มตัวชี้วัดเพิ่มเติมให้กับผู้ให้บริการ statsd - #698

· แก้ไขการค้นพบหลายผู้รับ - #731

· เริ่มต้น รีสตาร์ท และโหลดซ้ำอย่างสม่ำเสมอมากขึ้น - #673

· เริ่มต้นกลุ่มการใช้งานทั้งหมดอย่างถูกต้อง - #635

· ปรับปรุงความเสถียรของการทดสอบ

· อื่นๆอีกมากมาย....

0.10 - 2013-11-04
การเปลี่ยนแปลงที่สำคัญ:

· ตอนนี้รองรับ Python 3.2 & 3.3 แล้ว - #586

· ย้ายแกนกลางไปยังโมเดล async อย่างสมบูรณ์ - #569

· เอกสารที่ได้รับการปรับปรุง - #622

การเปลี่ยนแปลงเพิ่มเติม:

· เพิ่ม stop_signal & stop_children - #594

· ตรวจสอบให้แน่ใจว่าปลั๊กอิน watchdog ปิดซ็อกเก็ต - #588

· เปลี่ยนเป็นตัวแยกวิเคราะห์ ZMQ JSON

· IN ไม่รองรับในทุกแพลตฟอร์ม - #573

· อนุญาตให้แทนที่สภาพแวดล้อมส่วนกลางในส่วนการกำหนดค่าใด ๆ - #560

· อนุญาตให้ขีดกลางในชื่อส่วน - #546

· ตอนนี้ตัวแปรถูกขยายทุกที่ในการกำหนดค่า - #554

· เพิ่มปลั๊กอิน CommandReloader

· เพิ่ม before_signal & after_signal hooks

· อนุญาตให้ปลั๊กอินกระพือเพื่อลองใหม่ไม่มีกำหนด

· ไม่เกิด procs เมื่อผู้เฝ้าหยุด - #529 - #536

· เพิ่มรหัสเฉพาะสำหรับแต่ละข้อความของลูกค้า - #517

· ID ผู้ปฏิบัติงานเป็น "ช่อง" -

· แก้ไขพฤติกรรมการปิดระบบอย่างสง่างาม - #515

· ตรวจสอบให้แน่ใจว่าเราสามารถเพิ่มผู้ดูได้แม้ว่าผู้ตัดสินจะไม่เริ่มต้น - #503

· ตรวจสอบให้แน่ใจว่ากระบวนการหมดอายุ - #510

· ตรวจสอบให้แน่ใจว่าคำสั่ง set สามารถตั้งค่า hooks ได้หลายอัน

· รองรับซ็อกเก็ต ipv6 อย่างถูกต้อง - #507

· อนุญาตตัวเลือกที่กำหนดเองสำหรับ stdout_stream และ stderr_stream - #495

· เพิ่ม time_format สำหรับ FileStream - #493

· เพิ่มตัวเลือกการกำหนดค่าซ็อกเก็ตใหม่เพื่อผูกกับอินเทอร์เฟซเฉพาะตามชื่อ

0.9.3 - 2013-09-04
· ตรวจสอบให้แน่ใจว่าเราสามารถเพิ่มผู้ดูได้แม้ว่าผู้ตัดสินจะไม่เริ่มต้นก็ตาม

·ตรวจสอบให้แน่ใจว่าเราป๊อปหมดอายุกระบวนการ

· ตรวจสอบให้แน่ใจว่าคำสั่ง set สามารถตั้งค่า hooks ได้หนึ่งหรือหลายตัว

· รองรับซ็อกเก็ต ipv6 และการปรับปรุงของ CircusSockets อย่างถูกต้อง

· ให้ค่าเริ่มต้นพาธเพื่อป้องกัน UnboundLocalError

· เพิ่มการทดสอบการมีอยู่ของ multicast_endpoint ในการกำหนดค่าเริ่มต้นของคอนโทรลเลอร์

·ไม่แปลงตัวเลขทุกหลักเป็น ints อีกต่อไป

·เพิ่มการทดสอบ

· ไม่จำเป็นต้องมีกรณีพิเศษเมื่อแปลงตัวเลือก 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] ส่วน wildcards

·เพิ่ม global [env] secrtion

· แก้ไขข้อยกเว้นที่ซ่อนอยู่เมื่อไม่ได้ติดตั้งเว็บละครสัตว์ - #424

· ตรวจสอบให้แน่ใจว่าคำสั่ง incr/decr นั้นใช้ตัวเลือก nb กับเราจริง ๆ - #421

· แก้ไขแพ็คเกจไซต์ watcher virtualenv ที่ไม่ได้อยู่ใน PYTHONPATH

· ตรวจสอบให้แน่ใจว่าเราไม่ได้พยายามลบกระบวนการมากกว่า 0 - #429

· อัปเดต bootstrap.py - #436

·แก้ไขตัวคั่นหลายแพลตฟอร์มใน pythonpath virtualenv watcher

· ฟังก์ชั่นปิดซ็อกเก็ตที่ปรับโครงสร้างใหม่

· ตรวจสอบให้แน่ใจว่ามีการใช้ส่วน env กับผู้ดูทั้งหมด - #437

· เพิ่มคำสั่ง reloadconfig

· เพิ่ม circus.green และ gevent ออกจากแกนกลาง - #441, #452

·ปิดเสียง stdout & คำเตือนปลอมในการทดสอบ - #438

· $(circus.env.*) ใช้ได้กับทุกตัวเลือกในการกำหนดค่าทันที

· เพิ่ม before_spawn hook

· แก้ไขเส้นทางของ circusd ในไฟล์บริการ systemd - #450

· ตรวจสอบให้แน่ใจว่าเราสามารถเปลี่ยน hooks และตั้งค่าการสตรีมผ่าน CLI - #455

· ปรับปรุงเอกสาร

· เพิ่ม spawn_count stat ใน watcher

· เพิ่มพารามิเตอร์ min_cpu และ min_mem ในปลั๊กอิน ResourceWatcher

· เพิ่มข้อมูล FQDN ให้กับผู้ตัดสิน

0.8.1 - 2013-05-28
· circusd-stats สำลักบนซ็อกเก็ตยูนิกซ์ - #415

· circusd-stats & circushttpd โปรเซสลูก stdout/stderr ถูกเปิดทิ้งไว้ตามค่าเริ่มต้น
Python <= 2.7.5 จะสำลักในโมดูลการบันทึกในกรณีที่ปิด 2/3 fds - #415

· ตอนนี้เปลี่ยนเส้นทางไปที่ /dev/null ในกระบวนการย่อยแทนที่จะปิด #417

0.8 - 2013-05-24
· ตัวจัดการบันทึกแบบบูรณาการใน zmq io loop

· ทำให้ตัวเปลี่ยนเส้นทางเริ่มต้นใหม่ได้และต่อมามีประสิทธิภาพมากขึ้น

· ใช้ zmq.green.eventloop เมื่อตรวจพบ gevent

· เพิ่มการรองรับตัวแปรสภาพแวดล้อม CIRCUSCTL_ENDPOINT ให้กับ circusctl - #396

· util: แก้ไขข้อผิดพลาดในฟังก์ชัน to_uid - #397

· ลบตัวจัดการบนข้อผิดพลาด ioloop - #398

· ปรับปรุงความครอบคลุมการทดสอบ

· เลิกใช้ตัวเลือก 'บริการ' สำหรับปลั๊กอิน ResourceWatcher - #404

· ลบการใช้งาน psutil.error

· เพิ่มการค้นพบ UDP ใน circusd - #407

· ตอนนี้อนุญาต globs ที่ระดับไดเร็กทอรีที่กำหนดเอง - #388

· เพิ่มตัวเลือกการกำหนดค่า 'statd' - #408

· เพิ่มตัวเลือก pidfile, ล็อกเอาต์และระดับล็อกไปยังไฟล์การกำหนดค่าของคณะละครสัตว์ - #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

· แสดงซ็อกเก็ตยูนิกซ์ด้วย - #381

·ตรวจสอบให้แน่ใจว่าใช้งานได้กับ pyzmq . ล่าสุด

· แนะนำไวยากรณ์ที่สองสำหรับสัญกรณ์ fd

0.7 - 2013-04-08
· แก้ไขตัวอย่าง get_arbiter เพื่อใช้ dict สำหรับอาร์กิวเมนต์ watchers #304

· เพิ่มเอกสารการแก้ไขปัญหา #323

·เพิ่มการสนับสนุนการสร้างหลาม

· ลบ gevent และตัวเปลี่ยนเส้นทางเธรด ตอนนี้ใช้ ioloop - แก้ไข #346
ข่าวที่เกี่ยวข้อง #340

· circus.web เป็นโครงการของตัวเองแล้ว

·ลบ pyzmq patching

· อนุญาตให้กำหนดค่าผู้ดูแต่ไม่เริ่ม #283

· เพิ่มตัวเลือกในการโหลดเว็บไซต์ virtualenv dir

·เพิ่มผู้ดูตามความต้องการ

· เพิ่มเอกสารเกี่ยวกับ nginx+websockets #371

· ตอนนี้แยกวิเคราะห์รายการตัวเลือกของแต่ละคำสั่งอย่างถูกต้อง #369

· แก้ไขเหตุการณ์ circusd-stats ที่จัดการ #372

· แก้ไขปัญหาน้ำล้นในละครสัตว์ด้านบน #378

· อื่นๆอีกมากมาย...

0.6 - 2012-12-18
· แพทช์ชื่อโปรโตคอลสำหรับซ็อกเก็ต - #248

·อย่าปรับกราฟอัตโนมัติ #240

· circusctl: เพิ่มความช่วยเหลือตามคำสั่งจาก docstrings #217

· เพิ่มตะขอคนงาน

· เพิ่มแพ็คเกจ Debian - #227

· เพิ่ม Redis, HTTP Observer, สถิติแบบเต็ม & ปลั๊กอินทรัพยากร

·ตอนนี้กระบวนการสามารถมีชื่อได้

·เพิ่มการเติมข้อความอัตโนมัติ

· เพิ่มกระบวนการ/อายุผู้ดูใน webui

· เพิ่มการรองรับช่องสัญญาณ SSH

· ตอนนี้ใช้ pyzmq.green

· เพิ่มสคริปต์พุ่งพรวด & เอกสารเคลือบเงา

· เพิ่มตัวแปรสภาพแวดล้อมและส่วนต่างๆ

· เพิ่มการสนับสนุนซ็อกเก็ตยูนิกซ์

·เพิ่ม respawn ตัวเลือกในการมีผู้ดูแบบวิ่งครั้งเดียว

· ตอนนี้ใช้สารพิษในการทดสอบ

· อนุญาตให้แทนที่ซ็อกเก็ตใน args

· ธีมเอกสารใหม่

· ตัวเลือกการหมุนใหม่สำหรับสตรีม: max_bytes/backup_count

0.5.2 - 2012-07-26
· ตอนนี้กำลังแก้ไขโมดูลเธรดจาก stdlib เพื่อหลีกเลี่ยงข้อบกพร่องของ Python - #203

·หน้าจอช่วยเหลือ circusctl ที่ดูดีขึ้น

· ใช้ pustil get_nice() เมื่อพร้อมใช้งาน (nice เลิกใช้แล้ว) - #208

· เพิ่มการรองรับ max_age - #221

· เรียกฟังเท่านั้น () บนซ็อกเก็ต SOCK_STREAM หรือ SOCK_SEQPACKET

· ตรวจสอบให้แน่ใจว่าคอนโทรลเลอร์ล้างรายการปลั๊กอินใน update_watchers() - #220

· เพิ่ม --log-level และ --log-output ไปที่ circushttpd

· แก้ไขกระบวนการฆ่าผ่านเว็บ UI - #219

· ตอนนี้ circus เป็น zc.buildout ที่เข้ากันได้กับสคริปต์

· ล้าง websocket เมื่อไคลเอนต์ยกเลิกการเชื่อมต่อ - #225

· แก้ไขค่าเริ่มต้นสำหรับปลายทาง - #199

·แยก circushttpd ในโมดูลตรรกะ

0.5.1 - 2012-07-11
· แก้ไขคำผิดมากมายในเอกสาร

· เพิ่มตัวเลือกการดีบัก

· แพ็คเกจ web-requirements.txt อย่างถูกต้อง

· เพิ่มรหัสข้อผิดพลาด errno ในข้อความ - แก้ไข #111

0.5 - 2012-07-06
· เพิ่มการสนับสนุนซ็อกเก็ต

· เพิ่มคำสั่ง listocket

· ซ็อกเก็ตก็มีสถิติเช่นกัน !

· แก้ไขข้อผิดพลาดเล็กๆ น้อยๆ มากมาย

·ลบ wid - ตอนนี้ใช้ pid ทุกที่

·การทดสอบที่เร็วขึ้น

· เปลี่ยนไวยากรณ์ของตัวแปร

·ใช้ ioloop ของ pyzmq ในที่ต่างๆ มากขึ้น

· ตอนนี้ใช้ iowait สำหรับการโทรแบบเลือก () ทั้งหมด

· คำสั่ง incr/decr ตอนนี้มีพารามิเตอร์ nbprocess

· เพิ่มตัวเลือก reproduce_env ให้กับผู้ดู

· เพิ่มสถานะ UNEXISTING ใหม่ให้กับกระบวนการ

·เพิ่ม global httpd ตัวเลือกในการเรียกใช้ circushttpd เป็นผู้ดูแล

0.4 - 2012-06-12
· เพิ่มระบบปลั๊กอิน

· เพิ่มตัวเลือก "ซิงเกิลตัน" สำหรับผู้ดู

· แก้ไขการกะพริบของหน้าจอละครสัตว์ด้านบน

· ลบเธรดออกจาก circus.stats เพื่อสนับสนุนการเรียกกลับเป็นระยะ zmq

· ปรับปรุงเอกสารประกอบการ

·ไคลเอนต์ Circus มี send_message api

· คุณสมบัติการกระพือตอนนี้เป็นปลั๊กอิน

·เครื่องมือบรรทัดคำสั่งทุกตัวมี --version option

· เพิ่มปลั๊กอิน statsd (ส่งเหตุการณ์จากคณะละครสัตว์ไปยัง statsd)

· เว็บ UI ตอนนี้ใช้ websockets (ผ่าน socketio) เพื่อรับสถิติ

· เว็บ UI ตอนนี้ใช้เซสชันสำหรับ "ข้อความแฟลช" ในเว็บ ui

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
· ลบ โชว์ ชื่อ. แทนที่ด้วย กะลาสี.

· เพิ่มการสนับสนุนสำหรับกระบวนการตั้งค่า ขีด จำกัด.

· เพิ่มการรองรับการรวม dirs ในไฟล์ปรับแต่ง

· แก้ไขตัวอธิบายไฟล์ที่รั่วสองสามตัว

· แก้ไขการถ่ายโอนข้อมูลหลักในการกระพือ

· การปรับปรุงเอกสาร

· ตรวจสอบให้แน่ใจว่าข้อผิดพลาดของ circusd ถูกต้องเมื่อ circusd อื่นทำงานบนซ็อกเก็ตเดียวกัน

· get_arbiter ยอมรับผู้ดูหลายรายแล้ว

· แก้ไข cmd vs args vs executable ในกระบวนการ init

· แก้ไข -- เริ่มบน circusctl add

0.1 - 2012-03-20
· การเปิดตัวครั้งแรก

มนุษย์ หน้า
ละครสัตว์ มนุษย์ หน้า
สรุป
circusd [ตัวเลือก] [config]

รายละเอียด
circusd เป็นกระบวนการหลักของสถาปัตยกรรม Circus ดูแลการวิ่งทั้งหมด
กระบวนการ แต่ละกระบวนการที่จัดการโดย Circus เป็นกระบวนการย่อยของ ละครสัตว์.

ข้อโต้แย้ง
การตั้งค่า ไฟล์การกำหนดค่า

Options
-ชม, --ช่วยด้วย
แสดงข้อความช่วยเหลือและออก

--log-ระดับ ระดับ
ระบุระดับบันทึก ระดับ เป็นไปได้ ข้อมูล, การแก้ปัญหา, วิกฤติ, คำเตือน or ความผิดพลาด.

--log-เอาท์พุท ออกจากระบบ
ตำแหน่งที่จะเขียนบันทึก พฤติกรรมเริ่มต้นคือการเขียนถึง
stdout (คุณสามารถบังคับได้โดยส่ง '-' ไปยังตัวเลือกนี้) ใช้ชื่อไฟล์
มิฉะนั้น.

--logger-config LOGGERCONFIG
ตำแหน่งที่ไฟล์ INI, JSON หรือ YAML การกำหนดค่า Python logger มาตรฐาน
สามารถพบได้ สามารถใช้เพื่อแทนที่การกำหนดค่าการบันทึกเริ่มต้นสำหรับ
ผู้ตัดสิน

--ภูต
เริ่ม circusd ในพื้นหลัง

--pidfile PIDFILE
ตำแหน่งของไฟล์ PID

--รุ่น
แสดงเวอร์ชันและการออกของ Circus

ดู ด้วย
ละครสัตว์ (1) วงเวียน (1) สถิติวงเวียน (1) ละครสัตว์ปลั๊กอิน (1) ละครสัตว์ด้านบน (1)

สามารถดูเอกสารฉบับเต็มได้ที่ http://circus.readthedocs.org

วงเวียน มนุษย์ หน้า
สรุป
circusctl [ตัวเลือก] คำสั่ง [args]

รายละเอียด
circusctl เป็นส่วนหน้าเพื่อควบคุม Circus daemon ได้รับการออกแบบมาเพื่อช่วย
ผู้ดูแลระบบควบคุมการทำงานของ Circud ละครสัตว์ ภูต

คำสั่ง
เพิ่ม เพิ่มผู้เฝ้าดู

Decr ลดจำนวนกระบวนการในตัวเฝ้าระวัง

ดีสแตท รับสถิติวงเวียน

ได้รับ รับค่าของตัวเลือกผู้เฝ้าดูเฉพาะ

ตัวเลือกระดับโลก
รับตัวเลือกผู้ตัดสิน

รวม เพิ่มจำนวนกระบวนการในการเฝ้าระวัง

หลาม
สร้างเปลือกเป็นกระบวนการ circusd

รายการ รับรายชื่อผู้เฝ้าดูหรือกระบวนการในการเฝ้าระวัง

ฟัง สมัครรับข้อมูลจากผู้ดูเหตุการณ์

listockets
รับรายการซ็อกเก็ต

จำนวนกระบวนการ
รับจำนวนกระบวนการ

นักดูตัวเลข
รับจำนวนผู้ดู

ตัวเลือก
รับคุณค่าของตัวเลือกทั้งหมดสำหรับผู้เฝ้าดู

เลิก ออกจากผู้ชี้ขาดทันที

โหลด โหลดผู้ตัดสินหรือผู้ดูใหม่

โหลดการกำหนดค่าใหม่
โหลดไฟล์การกำหนดค่าซ้ำ

การเริ่มต้นใหม่
รีสตาร์ทผู้ชี้ขาดหรือผู้เฝ้าดู

rm ลบผู้เฝ้าดู

เซ็ต ตั้งค่าตัวเลือกผู้ดู

สัญญาณ ส่งสัญญาณ

เริ่มต้น เริ่มต้นผู้ตัดสินหรือผู้ดู

สถิติ รับข้อมูลกระบวนการ

สถานะ รับสถานะผู้ดูหรือผู้ดูทั้งหมด

หยุด หยุดเฝ้าดู

Options
--จุดปลาย ENDPOINT
ปลายทางการเชื่อมต่อ

-ชม, --ช่วยด้วย
แสดงข้อความช่วยเหลือและออก

--json ส่งออกไปยัง JSON

--เสริมสวย
ผลลัพธ์ที่สวยงาม

--ssh SSH
เซิร์ฟเวอร์ SSH ในรูปแบบ ผู้ใช้@โฮสต์:พอร์ต

--ssh_keyfile SSH_KEYFILE
เส้นทางไปยัง keyfile เพื่ออนุญาตผู้ใช้

--หมดเวลา หมดเวลา
หมดเวลาการเชื่อมต่อ

--รุ่น
แสดงเวอร์ชันและการออกของ Circus

ดู Also
ละครสัตว์ (1) ละครสัตว์ (1) สถิติวงเวียน (1) ละครสัตว์ปลั๊กอิน (1) ละครสัตว์ด้านบน (1)

สามารถดูเอกสารฉบับเต็มได้ที่ http://circus.readthedocs.org

ละครสัตว์ปลั๊กอิน มนุษย์ หน้า
สรุป
ละครสัตว์-ปลั๊กอิน [ตัวเลือก] [ปลั๊กอิน]

รายละเอียด
circus-plugin อนุญาตให้เปิดปลั๊กอินจาก Circus daemon ที่รันอยู่

ข้อโต้แย้ง
เสียบเข้าไป ชื่อแบบเต็มของคลาสปลั๊กอิน

Options
--จุดปลาย ENDPOINT
ปลายทางการเชื่อมต่อ

--ผับซับ ผับซับ
ผับ / ซ็อกเก็ตย่อย ZeroMQ circusd เพื่อเชื่อมต่อ

--การกำหนดค่า กำหนดค่า
ไฟล์การกำหนดค่าปลั๊กอิน

--ตรวจสอบล่าช้า ตรวจสอบ_DELAY
ตรวจสอบความล่าช้า

--log-ระดับ ระดับ
ระบุระดับบันทึก ระดับ เป็นไปได้ ข้อมูล, การแก้ปัญหา, วิกฤติ, คำเตือน or ความผิดพลาด.

--log-เอาท์พุท ออกจากระบบ
ตำแหน่งที่จะเขียนบันทึก พฤติกรรมเริ่มต้นคือการเขียนถึง
stdout (คุณสามารถบังคับได้โดยส่ง '-' ไปยังตัวเลือกนี้) ใช้ชื่อไฟล์
มิฉะนั้น.

--ssh SSH
เซิร์ฟเวอร์ SSH ในรูปแบบ ผู้ใช้@โฮสต์:พอร์ต.

-ชม, --ช่วยด้วย
แสดงข้อความช่วยเหลือและออก

--รุ่น
แสดงเวอร์ชันและการออกของ Circus

ดู ด้วย
ละครสัตว์ (1) ละครสัตว์ (1) วงเวียน (1) สถิติวงเวียน (1) ละครสัตว์ด้านบน (1)

สามารถดูเอกสารฉบับเต็มได้ที่ http://circus.readthedocs.org

ละครสัตว์ด้านบน มนุษย์ หน้า
สรุป
วงเวียนด้านบน [ตัวเลือก]

รายละเอียด
circus-top คือ a ด้านบน-like คำสั่งเพื่อแสดง Circus daemon และกระบวนการที่จัดการโดย
คณะละครสัตว์

Options
--จุดปลาย ENDPOINT
ปลายทางการเชื่อมต่อ

--ssh SSH
เซิร์ฟเวอร์ SSH ในรูปแบบ ผู้ใช้@โฮสต์:พอร์ต.

--ประมวลผล-หมดเวลา กระบวนการ_หมดเวลา
หลังจากไม่มีการใช้งานล่าช้า กระบวนการจะถูกลบออก

-ชม, --ช่วยด้วย
แสดงข้อความช่วยเหลือและออก

--รุ่น
แสดงเวอร์ชันและการออกของ Circus

ดู ด้วย
ละครสัตว์ (1) วงเวียน (1) ละครสัตว์ (1) สถิติวงเวียน (1) ละครสัตว์ปลั๊กอิน (1)

สามารถดูเอกสารฉบับเต็มได้ที่ http://circus.readthedocs.org

สถิติวงเวียน มนุษย์ หน้า
สรุป
สถิติคณะละครสัตว์ [ตัวเลือก]

รายละเอียด
circusd-stats เรียกใช้ตัวรวบรวมสถิติสำหรับ Circus

Options
--จุดปลาย ENDPOINT
ปลายทางการเชื่อมต่อ

--ผับซับ ผับซับ
ผับ / ซ็อกเก็ตย่อย ZeroMQ circusd เพื่อเชื่อมต่อ

--statspoint สถิติ
ซ็อกเก็ตผับ/ย่อย ZeroMQ เพื่อส่งข้อมูลไปที่

--log-ระดับ ระดับ
ระบุระดับบันทึก ระดับ เป็นไปได้ ข้อมูล, การแก้ปัญหา, วิกฤติ, คำเตือน or ความผิดพลาด.

--log-เอาท์พุท ออกจากระบบ
ตำแหน่งที่จะเขียนบันทึก พฤติกรรมเริ่มต้นคือการเขียนถึง
stdout (คุณสามารถบังคับได้โดยส่ง '-' ไปยังตัวเลือกนี้) ใช้ชื่อไฟล์
มิฉะนั้น.

--ssh SSH
เซิร์ฟเวอร์ SSH ในรูปแบบ ผู้ใช้@โฮสต์:พอร์ต.

-ชม, --ช่วยด้วย
แสดงข้อความช่วยเหลือและออก

--รุ่น
แสดงเวอร์ชันและการออกของ Circus

ดู ด้วย
ละครสัตว์ (1) ละครสัตว์ (1) วงเวียน (1) ละครสัตว์ปลั๊กอิน (1) ละครสัตว์ด้านบน (1)

สามารถดูเอกสารฉบับเต็มได้ที่ http://circus.readthedocs.org

คำศัพท์: เฉพาะคณะละครสัตว์ เงื่อนไขการใช้บริการ
ผู้ตัดสิน
การขอ ผู้ตัดสิน มีหน้าที่จัดการผู้เฝ้าดูทั้งหมดภายในคณะละครสัตว์ รับรอง
กระบวนการทั้งหมดทำงานอย่างถูกต้อง

ตัวควบคุม
A ตัวควบคุม มีชุดของการกระทำที่สามารถทำได้กับผู้ตัดสิน

เครื่องกระพือ
การขอ เครื่องกระพือ การค้นพบ สมัครรับข้อมูลเหตุการณ์และตรวจพบเมื่อกระบวนการบางอย่างเป็น
เริ่มต้นใหม่อย่างต่อเนื่อง

ผับ/ย่อย
ละครสัตว์มี ผับ ที่รับเหตุการณ์จากผู้ดูและส่งไปยัง
สมาชิกทั้งหมด

รีโมท ตัวควบคุม
การขอ รีโมท ตัวควบคุม ให้คุณสื่อสารกับคอนโทรลเลอร์ผ่าน ZMQ ถึง
ควบคุมละครสัตว์

ผู้เฝ้ามอง นักดู
A กะลาสี เป็นโปรแกรมที่คุณบอกให้ Circus ทำงาน อินสแตนซ์ Circus ตัวเดียวสามารถเรียกใช้ได้
ผู้เฝ้าดูหนึ่งคนขึ้นไป

คนงาน, คนงาน กระบวนการ, กระบวนการ
A กระบวนการ เป็นอินสแตนซ์กระบวนการ OS อิสระของโปรแกรมของคุณ เฝ้าคนเดียว
สามารถเรียกใช้กระบวนการได้ตั้งแต่หนึ่งกระบวนการขึ้นไป เรายังเรียกพวกเขาว่าคนงาน

ลิขสิทธิ์
Circus ริเริ่มโดย Tarek Ziade และได้รับอนุญาตภายใต้ APLv2

เบอนัวต์ เชสโนเป็นผู้ร่วมสร้างผลงานในยุคแรกๆ และได้ทำหลายสิ่งหลายอย่าง เช่น . ส่วนใหญ่
circus.commands ทำงาน

ใบอนุญาต
ลิขสิทธิ์ 2012 - มูลนิธิ Mozilla
ลิขสิทธิ์ 2012 - Benoit Chesneau

ได้รับอนุญาตภายใต้ Apache License เวอร์ชัน 2.0 ("License");
คุณไม่สามารถใช้ไฟล์นี้ยกเว้นว่าเป็นไปตามใบอนุญาต
คุณสามารถขอรับสำเนาใบอนุญาตได้ที่

http://www.apache.org/licenses/LICENSE-2.0

เว้นแต่จะกำหนดไว้โดยกฎหมายที่บังคับใช้หรือตกลงเป็นลายลักษณ์อักษรซอฟต์แวร์
แจกจ่ายภายใต้ใบอนุญาตมีการแจกจ่ายบนพื้นฐาน "ตามสภาพ"
โดยไม่มีการรับประกันหรือเงื่อนไขใด ๆ ไม่ว่าโดยชัดแจ้งหรือโดยนัย
ดูใบอนุญาตสำหรับภาษาเฉพาะที่ควบคุมสิทธิ์และ
ข้อ จำกัด ภายใต้ใบอนุญาต

ร่วมให้ข้อมูล
ดูรายการเต็มได้ที่ https://github.com/circus-tent/circus/blob/master/CONTRIBUTORS.txt

ใช้ละครสัตว์ออนไลน์โดยใช้บริการ onworks.net