circus - ອອນໄລນ໌ໃນຟັງໄດ້

ໂຄງການ:

NAME

circus - ເອກະສານ Circus [ຮູບພາບ]

Circus ແມ່ນໂຄງການ Python ທີ່ສາມາດຖືກນໍາໃຊ້ເພື່ອຕິດຕາມກວດກາແລະຄວບຄຸມຂະບວນການແລະເຕົ້າຮັບ.

Circus ສາມາດຖືກຂັບເຄື່ອນໂດຍຜ່ານການໂຕ້ຕອບເສັ້ນຄໍາສັ່ງ, ການໂຕ້ຕອບເວັບໄຊຕ໌ຫຼືໂຄງການ
ຜ່ານ API python ຂອງມັນ.

ການ​ຕິດ​ຕັ້ງ​ມັນ​ແລະ​ທົດ​ລອງ​ຄຸນ​ສົມ​ບັດ​ຂອງ​ຕົນ​ກວດ​ສອບ​ການ​ອອກ​ຕົວ​ຢ່າງ​, ຫຼື​ອ່ານ​ສ່ວນ​ທີ່​ເຫຼືອ​ຂອງ​ຫນ້າ​ນີ້​
ສໍາລັບການແນະນໍາໄວ.

ແລ່ນ A CIRCUS ເດມອນ

Circus ສະຫນອງການໂທຫາ script ເສັ້ນຄໍາສັ່ງ ວົງວຽນ ທີ່ສາມາດຖືກນໍາໃຊ້ເພື່ອຈັດການຂະບວນການ
ຈັດຢູ່ໃນຫນຶ່ງຫຼືຫຼາຍກວ່າ watchers.

ເຄື່ອງມືແຖວຄໍາສັ່ງຂອງ Circus ແມ່ນສາມາດຕັ້ງຄ່າໄດ້ໂດຍໃຊ້ໄຟລ໌ການຕັ້ງຄ່າແບບ ini.

ນີ້ແມ່ນຕົວຢ່າງໜ້ອຍທີ່ສຸດ:

[ຜູ້​ເບິ່ງ​: ໂຄງ​ການ​]
cmd = python myprogram.py
ຈໍານວນຂະບວນການ = 5

[ຜູ້ເບິ່ງ: ໂຄງການອື່ນ]
cmd = ໂປຣແກມອື່ນ
ຈໍານວນຂະບວນການ = 2

ຫຼັງຈາກນັ້ນ, ໄຟລ໌ຈະຖືກສົ່ງກັບ ວົງວຽນ:

$ circusd example.ini

ນອກຈາກຂະບວນການ, Circus ຍັງສາມາດຜູກມັດເຕົ້າຮັບ. ນັບຕັ້ງແຕ່ທຸກຂະບວນການຄຸ້ມຄອງໂດຍ Circus ແມ່ນ
ເດັກນ້ອຍຂອງ Circus daemon ຕົ້ນຕໍ, ນັ້ນຫມາຍຄວາມວ່າໂຄງການທີ່ຄວບຄຸມໂດຍ Circus ສາມາດເຮັດໄດ້
ໃຊ້ຊັອກເກັດເຫຼົ່ານັ້ນ.

ແລ່ນຊັອກເກັດແມ່ນງ່າຍດາຍຄືກັບການເພີ່ມ a socket ພາກສ່ວນໃນໄຟລ໌ config:

[ເຕົ້າຮັບ: mysocket]
host = localhost
ພອດ = 8080

ເພື່ອສຶກສາເພີ່ມເຕີມກ່ຽວກັບຊັອກເກັດ, ເບິ່ງຊັອກເກັດ.

ເພື່ອເຂົ້າໃຈວ່າເປັນຫຍັງມັນເປັນລັກສະນະ killer, ອ່ານ whycircussockets.

ການຄວບຄຸມ CIRCUS

Circus ໃຫ້ສອງເຄື່ອງມືເສັ້ນຄໍາສັ່ງເພື່ອຈັດການ daemon ແລ່ນຂອງທ່ານ:

· circusctl, console ການຈັດການທີ່ທ່ານສາມາດນໍາໃຊ້ເພື່ອປະຕິບັດການດໍາເນີນການເຊັ່ນການເພີ່ມຫຼື
ປົດ​ແຮງ​ງານ

· circus-top, ເປັນ console ເທິງສຸດທີ່ທ່ານສາມາດນໍາໃຊ້ເພື່ອສະແດງຫນ່ວຍຄວາມຈໍາແລະການນໍາໃຊ້ CPU ຂອງທ່ານ
ແລ່ນ Circus.

ເພື່ອຮຽນຮູ້ເພີ່ມເຕີມກ່ຽວກັບສິ່ງເຫຼົ່ານີ້, ເບິ່ງ cli

Circus ຍັງສະຫນອງ dashboard ເວັບໄຊຕ໌ທີ່ສາມາດເຊື່ອມຕໍ່ກັບ daemon Circus ແລ່ນແລະໃຫ້ທ່ານ
ຕິດຕາມກວດກາແລະພົວພັນກັບມັນ.

ເພື່ອຮຽນຮູ້ເພີ່ມເຕີມກ່ຽວກັບຄຸນສົມບັດນີ້, ເບິ່ງ circushttpd

ແມ່ນ​ຫຍັງ ໃນປັດຈຸບັນ ?
ຖ້າທ່ານເປັນນັກພັດທະນາແລະຕ້ອງການ leverage Circus ໃນໂຄງການຂອງທ່ານເອງ, ຂຽນ plugins ຫຼື
hooks, ໄປ fordevs.

ຖ້າທ່ານເປັນ ops ແລະຕ້ອງການຈັດການຂະບວນການຂອງທ່ານໂດຍໃຊ້ Circus, ໃຫ້ໄປທີ່ forops.

ການປະກອບສ່ວນ ແລະ ຂໍ້​ສະ​ເຫນີ​ແນະ
ເພີ່ມເຕີມກ່ຽວກັບການປະກອບສ່ວນ: ການປະກອບສ່ວນ.

ການເຊື່ອມຕໍ່ທີ່ເປັນປະໂຫຍດ:

· ມີບັນຊີລາຍຊື່ທາງໄປສະນີສໍາລັບຄໍາຄຶດຄໍາເຫັນຫຼືຄໍາຖາມ:
http://tech.groups.yahoo.com/group/circus-dev/

· ຄັງ​ເກັບ​ຮັກ​ສາ​ແລະ​ການ​ຕິດ​ຕາມ​ບັນ​ຫາ​ແມ່ນ​ຢູ່​ໃນ GitHub​: https://github.com/circus-tent/circus

·ເຂົ້າຮ່ວມກັບພວກເຮົາໃນ IRC: Freenode, ຊ່ອງທາງ #ເຕັ້ນເຕັ້ນ

ເອ​ກະ​ສານ ດັດຊະນີ
ການຕິດຕັ້ງ Circus
Circus ແມ່ນຊຸດ Python ທີ່ຖືກຈັດພີມມາຢູ່ໃນ PyPI - Python Package Index.

ວິທີທີ່ງ່າຍທີ່ສຸດໃນການຕິດຕັ້ງມັນແມ່ນການໃຊ້ pip, ເຄື່ອງມືສໍາລັບການຕິດຕັ້ງແລະຈັດການ Python
ການຫຸ້ມຫໍ່:

$ pip ຕິດຕັ້ງ circus

ຫຼື​ດາວ​ນ​໌​ໂຫລດ​ ເກັບ on P&IP, ສະກັດແລະຕິດຕັ້ງມັນດ້ວຍຕົນເອງກັບ:

$ python setup.py ຕິດຕັ້ງ

ຖ້າທ່ານຕ້ອງການລອງ Circus, ເບິ່ງຕົວຢ່າງ.

ຖ້າທ່ານກໍາລັງໃຊ້ debian ຫຼືການແຈກຢາຍໂດຍອີງໃສ່ debian, ທ່ານຍັງສາມາດໃຊ້ ppa ເພື່ອ
ຕິດຕັ້ງ circus, ມັນຢູ່ທີ່ https://launchpad.net/~roman-imankulov/+archive/circus

zc.buildout
ພວກເຮົາສະ ໜອງ ກ zc.buildout ການຕັ້ງຄ່າ, ທ່ານສາມາດນໍາໃຊ້ມັນໂດຍພຽງແຕ່ແລ່ນ bootstrap
script, ຫຼັງຈາກນັ້ນໂທຫາ buildout:

$ python bootstrap.py
$ bin/Buildout

ເພີ່ມເຕີມ on ຄວາມຕ້ອງການ
Circus ເຮັດ​ວຽກ​ຮ່ວມ​ກັບ​:

· Python 2.6, 2.7, 3.2 ຫຼື 3.3

·

ສູນ >= 2.1.10

· ສະ​ບັບ​ຂອງ zeromq ສະ​ຫນັບ​ສະ​ຫນູນ​ແມ່ນ​ກໍາ​ນົດ​ໃນ​ທີ່​ສຸດ​ໂດຍ​ສະ​ບັບ​ໃດ​ຂອງ​
pyzmq ຖືກຕິດຕັ້ງໂດຍ pip ໃນລະຫວ່າງການຕິດຕັ້ງ circus.

· ລຸ້ນປັດຈຸບັນຂອງພວກມັນຮອງຮັບ 2.x (ຈຳກັດ), 3.x, ແລະ 4.x ZeroMQ ເວີຊັ່ນ.

· ຫມາຍ​ເຫດ​: ຖ້າທ່ານກໍາລັງໃຊ້ PyPy ແທນ CPython, ໃຫ້ແນ່ໃຈວ່າອ່ານຂອງພວກເຂົາ
ການຕິດຕັ້ງ docs ເປັນ ZeroMQ ລຸ້ນສະຫນັບສະຫນູນແມ່ນບໍ່ຄືກັນໃນ PyPy.

ເມື່ອທ່ານຕິດຕັ້ງ circus, Python dependencies ຮຸ່ນຫຼ້າສຸດຈະຖືກດຶງອອກ
ສໍາລັບທ່ານ.

ນອກນັ້ນທ່ານຍັງສາມາດຕິດຕັ້ງພວກມັນດ້ວຍຕົນເອງໂດຍໃຊ້ໄຟລ໌ pip-requirements.txt ທີ່ພວກເຮົາໃຫ້:

$ pip ຕິດຕັ້ງ -r pip-requirements.txt

ຖ້າທ່ານຕ້ອງການດໍາເນີນການ Web console ທ່ານຈະຕ້ອງຕິດຕັ້ງ circus-web:

$ pip ຕິດຕັ້ງ circus-web

Tutorial
ບາດກ້າວ tutorial
ໄດ້ ຕົວຢ່າງ ລະບົບ ຢູ່ໃນບ່ອນເກັບມ້ຽນ Circus ມີຕົວຢ່າງຫຼາຍຢ່າງເພື່ອໃຫ້ເຈົ້າໄດ້
ເລີ່ມ​ຕົ້ນ​ແລ້ວ, ແຕ່​ນີ້​ແມ່ນ​ການ​ສອນ​ຢ່າງ​ເຕັມ​ທີ່​ທີ່​ເຮັດ​ໃຫ້​ທ່ານ​ສະ​ພາບ​ລວມ​ຂອງ​ຄຸນ​ສົມ​ບັດ​ໄດ້​.

ພວກເຮົາກໍາລັງຈະເບິ່ງແຍງຄໍາຮ້ອງສະຫມັກ WSGI.

ການຕິດຕັ້ງ
Circus ຖືກທົດສອບໃນ Mac OS X ແລະ Linux ດ້ວຍ Python 2.6, 2.7, 3.2 ແລະ 3.3 ຫຼ້າສຸດ. ເຖິງ
ດໍາ​ເນີນ​ການ Circus ຢ່າງ​ເຕັມ​ທີ່​, ທ່ານ​ຍັງ​ຈະ​ຕ້ອງ​ການ​ libzmq, ເສລີພາບ & virtualenv.

ໃນລະບົບທີ່ອີງໃສ່ Debian:

$ sudo apt-get ຕິດຕັ້ງ libzmq-dev libevent-dev python-dev python-virtualenv

ສ້າງ virtualenv ແລະຕິດຕັ້ງ circus, circus-web ແລະ ຖົງຕີນ ໃນ​ມັນ

$ virtualenv /tmp/circus
$ cd /tmp/circus
$ bin/pip ຕິດຕັ້ງ circus
$ bin/pip ຕິດຕັ້ງ circus-web
$ bin/pip ຕິດຕັ້ງ chaussette

ເມື່ອອັນນີ້ສຳເລັດແລ້ວ, ເຈົ້າຈະພົບເຫັນຄຳສັ່ງຫຼາຍອັນຢູ່ໃນ 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

ໄຟລ໌ config ນີ້ບອກ Circus ໃຫ້ຜູກມັດຊັອກເກັດຢູ່ໃນພອດ 9999 ແລະແລ່ນຄົນງານ chaussettes 3 ຄົນ
ຕ້ານມັນ. ມັນຍັງເປີດໃຊ້ dashboard ເວັບ Circus ແລະໂມດູນສະຖິຕິ.

ບັນທຶກມັນແລະດໍາເນີນການມັນໂດຍໃຊ້ ວົງວຽນ:

$ bin/circusd --daemon circus.ini

ດຽວນີ້ໄປຢາມ http://127.0.0.1: 9999, ທ່ານຄວນເບິ່ງ app hello world. ຄວາມແຕກຕ່າງໃນປັດຈຸບັນແມ່ນ
ວ່າເຕົ້າຮັບໄດ້ຖືກຄຸ້ມຄອງໂດຍ Circus ແລະມີພະນັກງານເວັບຈໍານວນຫນຶ່ງທີ່ຍອມຮັບ
ການ​ເຊື່ອມ​ຕໍ່​ກັບ​ມັນ​.

ຫມາຍ​ເຫດ​:
ການດຸ່ນດ່ຽງການໂຫຼດແມ່ນດໍາເນີນການໂດຍລະບົບປະຕິບັດການເພື່ອໃຫ້ທ່ານໄດ້ຮັບຄວາມໄວດຽວກັນ
ເປັນເຄື່ອງແມ່ຂ່າຍເວັບໄຊຕ໌ pre-fork ອື່ນໆເຊັ່ນ Apache ຫຼື NGinx. Circus ບໍ່ແຊກແຊງ
ຂໍ້ມູນທີ່ຜ່ານ.

ທ່ານຍັງສາມາດໄປຢ້ຽມຢາມໄດ້ http://localhost: 8080 / ແລະເພີດເພີນກັບ dashboard ເວັບ Circus.

ການພົວພັນຮ່ວມກັນ
ໃຫ້ໃຊ້ circusctl shell ໃນຂະນະທີ່ລະບົບກໍາລັງເຮັດວຽກ:

$ bin/circusctl
circusctl 0.7.1
circusd-stats: ເຄື່ອນໄຫວ
circushttpd: ການເຄື່ອນໄຫວ
webapp: ເຄື່ອນໄຫວ
(circusctl)

ທ່ານໄດ້ຮັບເຂົ້າໄປໃນແກະແບບໂຕ້ຕອບ. ປະເພດ ຊ່ວຍເຫຼືອ ເພື່ອໃຫ້ໄດ້ຮັບຄໍາສັ່ງທັງຫມົດ:

(circusctl) ຊ່ວຍ

ຄໍາສັ່ງເອກະສານ (ປະເພດການຊ່ວຍເຫຼືອ ):
======================================== ========================================
add get list processes ອອກຈາກ rm ເລີ່ມຢຸດ
decr globaloptions ຟັງ numwatchers ໂຫຼດສະຖິຕິທີ່ກໍານົດໄວ້ໃຫມ່
dstats incr listsockets ທາງເລືອກ restart ສະຖານະສັນຍານ

ຄຳສັ່ງທີ່ບໍ່ມີເອກະສານ:
======================
ຊ່ວຍເຫຼືອ EOF

ລອງໃຊ້ສິ່ງພື້ນຖານ. ຂໍໃຫ້ຈັດລາຍການຂະບວນການພະນັກງານເວັບ ແລະເພີ່ມອັນໃໝ່:

(circusctl) ບັນຊີລາຍຊື່ webapp
13712,13713,13714
(circusctl) incr webapp
4
(circusctl) ບັນຊີລາຍຊື່ webapp
13712,13713,13714,13973

ຂໍສະແດງຄວາມຍິນດີ, ທ່ານໄດ້ພົວພັນກັບ Circus ຂອງທ່ານແລ້ວ! ອອກຈາກແກະດ້ວຍ Ctrl+D ແລະດຽວນີ້ແລ່ນ
circus-top:

$ bin/circus-top

ນີ້ແມ່ນຄໍາສັ່ງທີ່ຄ້າຍຄືເທິງເພື່ອເບິ່ງຫນ່ວຍຄວາມຈໍາຂອງຂະບວນການທັງຫມົດຂອງທ່ານແລະການນໍາໃຊ້ CPU ໃນເວລາຈິງ.

ກົດ Ctrl + C ແລະຕອນນີ້ໃຫ້ອອກຈາກ Circus ຢ່າງສົມບູນຜ່ານ circus-ctl:

$ bin/circusctl ເຊົາ
ok

ຖັດໄປ ຂັ້ນຕອນ
ທ່ານສາມາດສຽບຄໍາຮ້ອງສະຫມັກ WSGI ຂອງທ່ານເອງແທນທີ່ຈະເປັນໂລກສະບາຍດີຂອງ Chaussette ໄດ້ໂດຍງ່າຍດາຍ
ຊີ້ຄໍາຮ້ອງສະຫມັກທີ່ສາມາດໂທຫາໄດ້.

Chaussette ຍັງມາພ້ອມກັບ backend ຫຼາຍເຊັ່ນ: Gevent ຫຼື Meinheld.

ອ່ານ https://chaussette.readthedocs.org/ ສໍາລັບທາງເລືອກທັງຫມົດ.

ເປັນຫຍັງ ຄວນ I ການນໍາໃຊ້ Circus ແທນທີ່ຈະເປັນ of X ?
1. Circus ງ່າຍດາຍ ຂອງ​ທ່ານ ເວັບໄຊຕ໌ stack ຂະບວນການ ການຈັດການ

Circus ຮູ້ວິທີການຈັດການຂະບວນການ ແລະ sockets, ດັ່ງນັ້ນທ່ານບໍ່ຈໍາເປັນຕ້ອງມອບຫມາຍເວັບໄຊຕ໌
ການຈັດການຄົນງານກັບເຊີບເວີ WGSI.

ເບິ່ງວ່າເປັນຫຍັງວົງຈອນປິດ

2. Circus ສະຫນອງໃຫ້ pub/ຍ່ອຍ ແລະ poll ແຈ້ງການ ຜ່ານ ZeroMQ
Circus ມີຊ່ອງ pub/sub ທີ່ທ່ານສາມາດຈອງໄດ້. ຊ່ອງນີ້ຮັບທຸກເຫດການ
ເກີດຂຶ້ນໃນ Circus. ຕົວຢ່າງ, ທ່ານສາມາດໄດ້ຮັບການແຈ້ງເຕືອນເມື່ອຂະບວນການກໍາລັງ flapping, ຫຼື
ສ້າງລູກຄ້າທີ່ກະຕຸ້ນເຕືອນເມື່ອບາງຂະບວນການກໍາລັງກິນ CPU ທັງຫມົດຫຼື
ຂອບ.

ເຫດການເຫຼົ່ານີ້ຖືກສົ່ງຜ່ານຊ່ອງທາງ ZeroMQ, ເຊິ່ງເຮັດໃຫ້ມັນແຕກຕ່າງຈາກ stdin
stream Supervisord ໃຊ້:

· Circus ສົ່ງເຫດການໃນຮູບແບບໄຟແລະລືມ, ສະນັ້ນບໍ່ຈໍາເປັນຕ້ອງ loop ດ້ວຍຕົນເອງ
ໂດຍຜ່ານການ ທັງຫມົດ ຜູ້ຟັງແລະຮັກສາລັດຂອງພວກເຂົາ.

·ຜູ້ຈອງສາມາດຕັ້ງຢູ່ໃນໂຮດຫ່າງໄກສອກຫຼີກ.

Circus ຍັງສະຫນອງວິທີການໄດ້ຮັບການປັບປຸງສະຖານະພາບໂດຍຜ່ານການສໍາຫຼວດຄັ້ງດຽວໃນ req / rep
ຊ່ອງ. ນີ້ຫມາຍຄວາມວ່າທ່ານສາມາດໄດ້ຮັບຂໍ້ມູນຂອງທ່ານໂດຍບໍ່ຈໍາເປັນຕ້ອງລົງທະບຽນ a
ກະແສ. ຄໍາສັ່ງ cli ສະຫນອງໃຫ້ໂດຍ Circus ໃຊ້ຊ່ອງທາງນີ້.

ເບິ່ງຕົວຢ່າງ.

3. Circus is ( python ) ການພັດທະນາ ມິດ
ໃນຂະນະທີ່ Circus ສາມາດຖືກຂັບເຄື່ອນທັງຫມົດໂດຍໄຟລ໌ config ແລະ circusctl / ວົງວຽນ
ຄໍາສັ່ງ, ມັນງ່າຍທີ່ຈະໃຊ້ຄືນໃຫມ່ທັງຫມົດຫຼືບາງສ່ວນຂອງລະບົບເພື່ອສ້າງ custom ຂອງທ່ານເອງ
process watcher ໃນ Python.

ແຕ່ລະຊັ້ນຂອງລະບົບແມ່ນຢູ່ໂດດດ່ຽວ, ດັ່ງນັ້ນທ່ານສາມາດນໍາໃຊ້ຄືນໃຫມ່ໄດ້ຢ່າງເປັນເອກະລາດ:

· wrapper ຂະ​ບວນ​ການ (ຂະບວນການ)

· ຜູ້​ຈັດ​ການ​ຂະ​ບວນ​ການ (ຜູ້ເບິ່ງ)

· ຜູ້​ຈັດ​ການ​ທົ່ວ​ໂລກ​ທີ່​ດໍາ​ເນີນ​ການ​ຜູ້​ຈັດ​ການ​ຂະ​ບວນ​ການ​ຫຼາຍ (ຜູ້ຕັດສິນ)

· ແລະອື່ນໆ...

4. Circus scales
ຫນຶ່ງໃນກໍລະນີການນໍາໃຊ້ຂອງ Circus ແມ່ນການຄຸ້ມຄອງຫຼາຍພັນຂະບວນການໂດຍບໍ່ມີການເພີ່ມ
overhead -- ພວກເຮົາອຸທິດຕົນເພື່ອສຸມໃສ່ການນີ້.

ມາ ຈາກ Supervisor
Supervisor ເປັນການແກ້ໄຂທີ່ນິຍົມຫຼາຍໃນໂລກ Python ແລະພວກເຮົາມັກຈະຖືກຖາມວ່າ Circus ແນວໃດ
ປຽບທຽບກັບມັນ.

ຖ້າທ່ານ ກຳ ລັງມາຈາກ Supervisor, ຫນ້ານີ້ພະຍາຍາມໃຫ້ພາບລວມຂອງວິທີການເຄື່ອງມື
ແຕກຕ່າງກັນ.

ຄວາມແຕກຕ່າງ ພາບລວມ
Supervisor & Circus ມີເປົ້າຫມາຍດຽວກັນ - ພວກເຂົາທັງສອງຈັດການຂະບວນການແລະສະຫນອງ a
script ແຖວຄໍາສັ່ງ - ຕາມລໍາດັບ ຜູ້ຄຸມງານ ແລະ ວົງວຽນ — ທີ່​ອ່ານ​ການ​ຕັ້ງ​ຄ່າ​
ໄຟລ໌, fork ຂະບວນການໃຫມ່ແລະເຮັດໃຫ້ພວກເຂົາມີຊີວິດຢູ່.

Circus ມີຄຸນສົມບັດພິເສດ: ຄວາມສາມາດໃນການຜູກມັດເຕົ້າຮັບແລະປ່ອຍໃຫ້ຂະບວນການທີ່ມັນຄຸ້ມຄອງ
ໃຊ້ພວກມັນ. ຮູບແບບ "ທາງສ່ວນຫນ້າຂອງສ້ອມ" ນີ້ຖືກນໍາໃຊ້ໂດຍເຄື່ອງແມ່ຂ່າຍເວັບໄຊຕ໌ຈໍານວນຫຼາຍອອກມີ, ເຊັ່ນ: Apache or
Unicorn. ມີທາງເລືອກນີ້ຢູ່ໃນ Circus ສາມາດເຮັດໃຫ້ເວັບ app stack: ຂະບວນການທັງຫມົດແລະ
ເຕົ້າຮັບຖືກຄຸ້ມຄອງໂດຍເຄື່ອງມືດຽວ.

ໂຄງການທັງສອງໃຫ້ວິທີການຄວບຄຸມ daemon ແລ່ນຜ່ານ script ອື່ນ. ຕາມລໍາດັບ
supervisorctl ແລະ circusctl. ພວກເຂົາທັງສອງຍັງມີເຫດການແລະວິທີການສະຫມັກໃຫ້ພວກເຂົາ.
ຄວາມແຕກຕ່າງຕົ້ນຕໍແມ່ນເຕັກໂນໂລຢີທີ່ຕິດພັນ: ຜູ້ຄຸມງານໃຊ້ XML-RPC ສໍາລັບການໂຕ້ຕອບ
ກັບ daemon, ໃນຂະນະທີ່ Circus ໃຊ້ ZeroMQ.

Circus & Supervisor ທັງສອງມີການໂຕ້ຕອບເວັບເພື່ອສະແດງສິ່ງທີ່ເກີດຂຶ້ນ. Circus' ແມ່ນຫຼາຍ
ກ້າວຫນ້າເພາະວ່າທ່ານສາມາດປະຕິບັດຕາມໃນເວລາທີ່ແທ້ຈິງສິ່ງທີ່ເກີດຂຶ້ນແລະພົວພັນກັບ daemon ໄດ້.
ມັນໃຊ້ຊັອກເກັດເວັບແລະຖືກພັດທະນາໃນໂຄງການແຍກຕ່າງຫາກ (circus-web.)

ມີຫຼາຍຄວາມແຕກຕ່າງທີ່ລະອຽດອ່ອນໃນການອອກແບບຫຼັກ, ພວກເຮົາອາດຈະບອກຢູ່ທີ່ນີ້ໃນມື້ຫນຶ່ງ… ໃນ
ໃນເວລານີ້, ທ່ານສາມາດຮຽນຮູ້ເພີ່ມເຕີມກ່ຽວກັບ circus ພາຍໃນໃນການອອກແບບ.

ການຕັ້ງຄ່າ
ທັງສອງລະບົບໃຊ້ໄຟລ໌ຄ້າຍຄື ini ເປັນການຕັ້ງຄ່າ.

· Supervisor ເອກະສານ

· Circus ເອກະສານ

ນີ້ແມ່ນຕົວຢ່າງນ້ອຍໆຂອງການແລ່ນແອັບພລິເຄຊັນກັບ Supervisor. ໃນກໍລະນີດັ່ງກ່າວນີ້, ໄດ້
ແອັບພລິເຄຊັ່ນຈະຖືກເລີ່ມຕົ້ນ ແລະເປີດຄືນໃໝ່ໃນກໍລະນີທີ່ມັນຂັດຂ້ອງ

[ໂຄງການ: ຕົວຢ່າງ]
command=npm ເລີ່ມ
directory=/home/www/my-server/
user=www-data
autostart = ຄວາມຈິງ
autorestart=true
redirect_stderr=ຖືກຕ້ອງ

ໃນ Circus, ການຕັ້ງຄ່າດຽວກັນແມ່ນເຮັດໂດຍ:

[ຜູ້ເບິ່ງ: ຕົວຢ່າງ]
cmd=npm ເລີ່ມ
working_dir=/home/www/my-server/
user=www-data
stderr_stream.class=StdoutStream

ສັງເກດເຫັນວ່າການປ່ຽນເສັ້ນທາງ stderr ແມ່ນແຕກຕ່າງກັນເລັກນ້ອຍໃນ Circus. ເຄື່ອງມືບໍ່ມີ
a ຫາງ ລັກສະນະເຊັ່ນໃນ Supervisor, ແຕ່ຈະໃຫ້ທ່ານຕິດລະຫັດໃດໆເພື່ອຈັດການກັບ
ກະແສທີ່ເຂົ້າມາ. ທ່ານສາມາດສ້າງ hook stream ຂອງທ່ານເອງ (ເປັນ Class) ແລະເຮັດອັນໃດກໍໄດ້
ຕ້ອງການກັບກະແສທີ່ເຂົ້າມາ. Circus ສະຫນອງບາງຊັ້ນຮຽນນ້ໍາໃນຕົວເຊັ່ນ:
StdoutStream, FileStream, ເບິ່ງFileStream, ຫຼື TimedRotatingFileStream.

Circus ສໍາລັບການ ໂອ
ຄໍາເຕືອນ:
ໂດຍຄ່າເລີ່ມຕົ້ນ, Circus ບໍ່ຮັບປະກັນຂໍ້ຄວາມຂອງມັນເມື່ອສົ່ງຂໍ້ມູນຜ່ານ ZeroMQ.
ກ່ອນທີ່ຈະແລ່ນ Circus ໃນສະພາບແວດລ້ອມການຜະລິດ, ໃຫ້ແນ່ໃຈວ່າອ່ານຫນ້າຄວາມປອດໄພ.

ຂັ້ນຕອນທໍາອິດໃນການຈັດການ Circus daemon ແມ່ນການຂຽນໄຟລ໌ການຕັ້ງຄ່າຂອງມັນ. ເບິ່ງ
ການຕັ້ງຄ່າ. ຖ້າທ່ານກໍາລັງໃຊ້ເວັບ stack, ໃຫ້ເບິ່ງທີ່ຊັອກເກັດ.

Circus ສາມາດ deployed ໂດຍໃຊ້ Python 2.6, 2.7, 3.2 ຫຼື 3.3 - ສ່ວນຫຼາຍແມ່ນ deployment.
ເຮັດໃນ 2.7. ເພື່ອຮຽນຮູ້ວິທີການປັບໃຊ້ Circus, ໃຫ້ກວດເບິ່ງການໃຊ້ງານ.

ເພື່ອຈັດການ Circus daemon, ທ່ານຄວນຄຸ້ນເຄີຍກັບບັນຊີລາຍຊື່ຂອງຄໍາສັ່ງທີ່ທ່ານສາມາດນໍາໃຊ້
in circusctl. ສັງເກດເຫັນວ່າທ່ານສາມາດມີການຊ່ວຍເຫຼືອດຽວກັນອອນໄລນ໌ໃນເວລາທີ່ທ່ານດໍາເນີນການ circusctl ເປັນຫນຶ່ງ
ຫອຍ.

ພວກເຮົາສະ ໜອງ ໃຫ້ເຊັ່ນກັນ circus-top, ເບິ່ງ cli ແລະ dashboard ເວັບງາມ. ເບິ່ງ circushttpd.

ສຸດທ້າຍ, ເພື່ອໃຫ້ໄດ້ປະໂຫຍດສູງສຸດຈາກ Circus, ໃຫ້ແນ່ໃຈວ່າຈະກວດເບິ່ງວິທີການໃຊ້ plugins ແລະ hooks.
ເບິ່ງ plugins ແລະ hooks.

ໂອ ເອກະສານ ດັດຊະນີ
ການຕັ້ງຄ່າ
Circus ສາມາດຖືກຕັ້ງຄ່າໂດຍໃຊ້ໄຟລ໌ການຕັ້ງຄ່າແບບ ini.

ຕົວຢ່າງ:

[ວົງດົນຕີ]
check_delay = 5
ຈຸດຈົບ = tcp://127.0.0.1:5555
pubsub_endpoint = tcp://127.0.0.1:5556
ລວມ = \*.more.config.ini
umask = 002

[ເບິ່ງ: myprogram]
cmd = python
args = -u myprogram.py $(circus.wid) $(CIRCUS.ENV.VAR)
warmup_delay = 0
ຈໍານວນຂະບວນການ = 5

# hook
hooks.before_start = my.hooks.control_redis

# ຈະກົດໃນ test.log ກະແສທຸກໆ 300 ms
stdout_stream.class = FileStream
stdout_stream.filename = test.log

# ທາງເລືອກໃນການຫມຸນໄຟລ໌ບັນທຶກເມື່ອມັນຮອດ 1 GB
# ແລະບັນທຶກ 5 ສໍາເນົາຂອງໄຟລ໌ rotated
stdout_stream.max_bytes = 1073741824
stdout_stream.backup_count = 5

[env: myprogram]
PATH = $PATH:/ ຖັງ
CAKE = ນອນ

[ປລັກອິນ:statsd]
use = circus.plugins.statsd.StatsdEmitter
host = localhost
ພອດ = 8125
sample_rate = 1.0
application_name = ຕົວຢ່າງ

[ເຕົ້າຮັບ:ເວັບ]
host = localhost
ພອດ = 8080

circus - ດຽວ ສ່ວນ
endpoint
ເຕົ້າຮັບ ZMQ ໃຊ້ເພື່ອຈັດການ Circus ຜ່ານ circusctl. (ຄ່າເລີ່ມຕົ້ນ:
tcp://127.0.0.1:5555)

endpoint_owner
ຖ້າຕັ້ງເປັນຊື່ຜູ້ໃຊ້ລະບົບແລະຈຸດສິ້ນສຸດແມ່ນຊັອກເກັດ iPC ເຊັ່ນ
ipc://var/run/circusd.sock, ຫຼັງຈາກນັ້ນ, ຄວາມເປັນເຈົ້າຂອງຂອງໄຟລ໌ socket ຈະຖືກປ່ຽນເປັນ
ຜູ້ໃຊ້ນັ້ນໃນຕອນເລີ່ມຕົ້ນ. ສໍາລັບລາຍລະອຽດເພີ່ມເຕີມ, ເບິ່ງຄວາມປອດໄພ. (ຄ່າເລີ່ມຕົ້ນ: ບໍ່ມີ)

pubsub_endpoint
ZMQ PUB/SUB socket ຮັບການພິມເຜີຍແຜ່ເຫດການ. (ຄ່າເລີ່ມຕົ້ນ:
tcp://127.0.0.1:5556)

papa_endpoint
ຖ້າໃຊ້ papa, ທ່ານສາມາດກໍານົດຈຸດສິ້ນສຸດ, ເຊັ່ນ: ipc://var/run/circusd.sock.
(ຄ່າເລີ່ມຕົ້ນ: tcp://127.0.0.1:20202)

ສະຖິຕິ ຖ້າຕັ້ງເປັນ True, Circus ແລ່ນ daemon circusd-stats. (ຄ່າເລີ່ມຕົ້ນ: ບໍ່ຖືກຕ້ອງ)

stats_endpoint
ZMQ PUB/SUB socket ຮັບການພິມເຜີຍແຜ່ສະຖິຕິ. (ຄ່າເລີ່ມຕົ້ນ:
tcp://127.0.0.1:5557)

statsd_close_outputs
ຖ້າ True ສົ່ງ circusd-stats stdout/stderr ໄປ /dev/null. (ຄ່າເລີ່ມຕົ້ນ: ບໍ່ຖືກຕ້ອງ)

check_delay
ໄລຍະການລົງຄະແນນສຽງເປັນວິນາທີສຳລັບເຕົ້າຮັບ ZMQ. (ຄ່າເລີ່ມຕົ້ນ: 5)

ປະກອບດ້ວຍ
ບັນຊີລາຍຊື່ຂອງໄຟລ໌ config ທີ່ຈະປະກອບມີ. ທ່ານສາມາດໃຊ້ຕົວແທນ (*) ໂດຍ​ສະ​ເພາະ​ແມ່ນ​
ແຜນ​ການ​ສໍາ​ລັບ​ໄຟລ​໌​ຂອງ​ທ່ານ​. ເສັ້ນທາງແມ່ນສົມບູນຫຼືກ່ຽວຂ້ອງກັບໄຟລ໌ config.
(ຄ່າເລີ່ມຕົ້ນ: ບໍ່ມີ)

include_dir
ບັນຊີລາຍຊື່ຂອງໄດເລກະທໍລີ config. ໄຟລ໌ທັງຫມົດກົງກັນ *.ini ພາຍໃຕ້ແຕ່ລະໄດເລກະທໍລີຈະ
ລວມ. ເສັ້ນທາງແມ່ນສົມບູນຫຼືກ່ຽວຂ້ອງກັບໄຟລ໌ config. (ຄ່າເລີ່ມຕົ້ນ:
ບໍ່ມີ)

stream_backend
ກໍານົດປະເພດຂອງ backend ທີ່ຈະໃຊ້ສໍາລັບການຖ່າຍທອດ. ຄ່າທີ່ເປັນໄປໄດ້ແມ່ນ ກະ​ທູ້
or ເຈນ. (ຄ່າເລີ່ມຕົ້ນ: thread)

warmup_delay
ໄລຍະຫ່າງໃນວິນາທີລະຫວ່າງຜູ້ເບິ່ງສອງຄົນເລີ່ມຕົ້ນ. ຕ້ອງເປັນ int. (ຄ່າເລີ່ມຕົ້ນ: 0)

httpd ຖ້າຕັ້ງເປັນ True, Circus ແລ່ນ circushttpd daemon. (ຄ່າເລີ່ມຕົ້ນ: ບໍ່ຖືກຕ້ອງ)

httpd_host
ເຈົ້າພາບແລ່ນໂດຍ circushttpd daemon. (ຄ່າເລີ່ມຕົ້ນ: localhost)

httpd_port
ທ່າເຮືອແລ່ນໂດຍ circushttpd daemon. (ຄ່າເລີ່ມຕົ້ນ: 8080)

httpd_close_outputs
ຖ້າຖືກຕ້ອງ, ສົ່ງ circushttpd stdout/stderr ໄປ /dev/null. (ຄ່າເລີ່ມຕົ້ນ: ບໍ່ຖືກຕ້ອງ)

debug ຖ້າຕັ້ງເປັນ True, ທັງໝົດ Circus stout/stderr daemons ຈະຖືກໂອນໄປຫາ circusd
stdout/stderr (ຄ່າເລີ່ມຕົ້ນ: ບໍ່ຖືກຕ້ອງ)

debug_gc
ຖ້າຕັ້ງເປັນຖືກຕ້ອງ, circusd ຈະສົ່ງຂໍ້ມູນບັນທຶກເພີ່ມເຕີມຈາກຕົວເກັບຂີ້ເຫຍື້ອ.
ນີ້ສາມາດເປັນປະໂຫຍດໃນການຕິດຕາມການຮົ່ວໄຫລຂອງຫນ່ວຍຄວາມຈໍາ. (ຄ່າເລີ່ມຕົ້ນ: ບໍ່ຖືກຕ້ອງ)

pidfile
ໄຟລ໌ທີ່ຕ້ອງໃຊ້ເພື່ອຮັກສາ daemon pid.

ໜ້າ ກາກ ມູນຄ່າສໍາລັບ umask. ຖ້າບໍ່ໄດ້ຕັ້ງ, circusd ຈະບໍ່ພະຍາຍາມແກ້ໄຂ umask.

loglevel
ລະດັບບັນທຶກທີ່ພວກເຮົາຕ້ອງການເບິ່ງ (ຄ່າເລີ່ມຕົ້ນ: INFO)

ອອກຈາກລະບົບ
ໄຟລ໌ logoutput ບ່ອນທີ່ພວກເຮົາຕ້ອງການບັນທຶກ (ຄ່າເລີ່ມຕົ້ນ: - ເພື່ອເຂົ້າສູ່ລະບົບ stdout). ເຈົ້າ​ສາ​ມາດ
ບັນທຶກໄປຫາ syslog ຫ່າງໄກສອກຫຼີກໂດຍໃຊ້ syntax ຕໍ່ໄປນີ້:
syslog://host:port?facility ບ່ອນທີ່ໂຮດແມ່ນເຄື່ອງແມ່ຂ່າຍ syslog ຂອງທ່ານ, ພອດແມ່ນທາງເລືອກ
ແລະສິ່ງອໍານວຍຄວາມສະດວກແມ່ນສະຖານທີ່ syslog ທີ່ຈະໃຊ້. ຖ້າທ່ານຕ້ອງການເຂົ້າສູ່ລະບົບ syslog ທ້ອງຖິ່ນ
ທ່ານສາມາດໃຊ້ syslog:///path/to/syslog/socket?facility ແທນທີ່ຈະເປັນ.

loggerconfig
ເສັ້ນທາງໄປຫາໄຟລ໌ INI, JSON ຫຼື YAML ເພື່ອຕັ້ງຄ່າການບັນທຶກ Python ມາດຕະຖານສໍາລັບ
ຜູ້ຕັດສິນ. ມູນຄ່າພິເສດ "ຄ່າເລີ່ມຕົ້ນ" ໃຊ້ການຕັ້ງຄ່າການບັນທຶກໃນຕົວ
ອີງ​ຕາມ​ລະ​ດັບ​ການ​ເປັນ​ທາງ​ເລືອກ​ແລະ​ທາງ​ເລືອກ​ການ​ອອກ​ຈາກ​ລະ​ບົບ​.

ຍົກຕົວຢ່າງ YAML ການຕັ້ງຄ່າ ເອກະສານ

ຮຸ່ນ: 1
disable_existing_loggers: false
ຜູ້ຈັດຮູບແບບ:
ງ່າຍດາຍ:
ຮູບແບບ: '%(asctime)s - %(name)s - [%(levelname)s] %(message)s'
ຕົວຈັດການ:
logfile:
ຫ້ອງຮຽນ: logging.FileHandler
ຊື່ໄຟລ໌: logoutput.txt
ລະດັບ: DEBUG
ຮູບແບບ: ງ່າຍດາຍ
ຄົນຕັດໄມ້:
ວົງດົນຕີ:
ລະດັບ: DEBUG
ຕົວຈັດການ: [logfile]
ຂະຫຍາຍພັນ: ບໍ່ມີ
ຮາກ:
ລະດັບ: DEBUG
ຕົວຈັດການ: [logfile]

ຜູ້ເບິ່ງ:NAME - as ຈໍານວນຫຼາຍ ພາກສ່ວນ as ທ່ານ ຕ້ອງການ
NAME ຊື່ຂອງ watcher ໄດ້. ຊື່ນີ້ຖືກນໍາໃຊ້ໃນ circusctl

cmd ໂຄງ​ການ​ປະ​ຕິ​ບັດ​ທີ່​ຈະ​ດໍາ​ເນີນ​ການ​.

ໂຕ້ຖຽງ arguments ແຖວຄໍາສັ່ງທີ່ຈະສົ່ງກັບໂຄງການ. ທ່ານສາມາດນໍາໃຊ້ຮູບແບບ python
syntax ຢູ່ທີ່ນີ້ເພື່ອສ້າງຕົວກໍານົດການ. ຕົວແປສະພາບແວດລ້ອມແມ່ນມີຢູ່, ເປັນ
ເຊັ່ນດຽວກັນກັບ ID ພະນັກງານແລະຕົວແປສະພາບແວດລ້ອມທີ່ທ່ານຜ່ານ, ຖ້າມີ,
ກັບພາລາມິເຕີ "env". ເບິ່ງ ການສ້າງຮູບແບບ ໄດ້ ຄໍາສັ່ງ ແລະ ກະທູ້ທີ່ ກັບ ການເຄື່ອນໄຫວ
ຕົວແປ ສໍາລັບຂໍ້ມູນເພີ່ມເຕີມກ່ຽວກັບເລື່ອງນີ້.

ຫອຍ ຖ້າເປັນຖືກ, ຂະບວນການຕ່າງໆຈະດໍາເນີນການຢູ່ໃນ shell (ຄ່າເລີ່ມຕົ້ນ: False)

shell_args
arguments ແຖວຄໍາສັ່ງທີ່ຈະສົ່ງກັບຄໍາສັ່ງ shell ໃນເວລາທີ່ ຫອຍ ເປັນຄວາມຈິງ. ເຮັດວຽກ
ພຽງແຕ່ສໍາລັບ * nix ລະບົບ (ຄ່າເລີ່ມຕົ້ນ: ບໍ່ມີ)

work_dir
Dir ເຮັດວຽກສໍາລັບຂະບວນການ (ຄ່າເລີ່ມຕົ້ນ: ບໍ່ມີ)

uid id ຜູ້ໃຊ້ຫຼືຊື່ຄໍາສັ່ງຄວນຈະດໍາເນີນການກັບ. (Uid ໃນ​ປັດ​ຈຸ​ບັນ​ແມ່ນ​
ໃນຕອນຕົ້ນ).

gid ກຸ່ມ id ຫຼືຊື່ຄໍາສັ່ງຄວນຈະດໍາເນີນການກັບ. (Gid ໃນ​ປັດ​ຈຸ​ບັນ​ແມ່ນ​
ໃນຕອນຕົ້ນ).

copy_env
ຖ້າຕັ້ງເປັນຖືກ, ຕົວແປສະພາບແວດລ້ອມທ້ອງຖິ່ນຈະຖືກຄັດລອກແລະສົ່ງໄປທີ່
ຄົນງານໃນເວລາລ້ຽງພວກມັນ. (ຄ່າເລີ່ມຕົ້ນ: ບໍ່ຖືກຕ້ອງ)

copy_path
ຖ້າຕັ້ງເປັນຄວາມຈິງ, sys.path ຖືກສົ່ງຜ່ານໃນສະພາບແວດລ້ອມຂະບວນການຍ່ອຍໂດຍໃຊ້ ໄພທອນພົດ.
copy_env ຈະຕ້ອງເປັນຄວາມຈິງ. (ຄ່າເລີ່ມຕົ້ນ: ບໍ່ຖືກຕ້ອງ)

warmup_delay
ຄວາມລ່າຊ້າ (ເປັນວິນາທີ) ລະຫວ່າງຂະບວນການແລ່ນ.

ອໍໂຕ້
ຖ້າຕັ້ງເປັນ false, watcher ຈະບໍ່ຖືກເລີ່ມຕົ້ນອັດຕະໂນມັດເມື່ອ arbiter
ເລີ່ມ. ຜູ້ເບິ່ງສາມາດເລີ່ມຕົ້ນໄດ້ຢ່າງຊັດເຈນ (ຕົວຢ່າງ: circusctrl ການເລີ່ມຕົ້ນ
ໂຄງການຂອງຂ້ອຍ). (ຄ່າເລີ່ມຕົ້ນ: ຖືກ)

ຂະ​ບວນ​ການ​ຈໍາ​ນວນ​
ຈໍານວນຂະບວນການທີ່ຈະດໍາເນີນການສໍາລັບ watcher ນີ້.

rlimit_LIMIT
ກໍານົດຂອບເຂດຈໍາກັດຊັບພະຍາກອນສໍາລັບຂະບວນການທີ່ເບິ່ງ. ຊື່ config ຄວນກົງກັນ
ຄ່າຄົງທີ່ RLIMIT_* (ບໍ່ແມ່ນຕົວພິມນ້ອຍໃຫຍ່) ທີ່ລະບຸໄວ້ໃນ Python ຊັບພະຍາກອນ ໂມດູນ
ອ້າງອິງ. ຕົວຢ່າງ, ເສັ້ນ config 'rlimit_nofile = 500' ກໍານົດສູງສຸດ
ຈໍາ​ນວນ​ຂອງ​ໄຟລ​໌​ທີ່​ເປີດ​ເປັນ 500​. ເພື່ອ​ກໍາ​ນົດ​ຄ່າ​ຈໍາ​ກັດ​ເປັນ RLIM_INFINITY​, ບໍ່​ໄດ້​ກໍາ​ນົດ​ເປັນ
ຄ່າ, ເຊັ່ນເສັ້ນ config ນີ້: 'rlimit_nofile = '.

stderr_stream.class
ຊື່ຫ້ອງຮຽນ Python ທີ່ມີຄຸນວຸດທິຢ່າງເຕັມທີ່ທີ່ຈະ instanciated, ແລະຈະໄດ້ຮັບ
ໄດ້ stderr ກະແສຂອງຂະບວນການທັງຫມົດໃນຂອງມັນ __ໂທ__() ວິທີການ.

Circus ໃຫ້ບາງຊັ້ນຮຽນສະຕຣີມທີ່ທ່ານສາມາດນໍາໃຊ້ໄດ້ໂດຍບໍ່ມີຄໍານໍາຫນ້າ:

· FileStream: ຂຽນໃນໄຟລ໌ແລະສາມາດເຮັດການຫມຸນບັນທຶກອັດຕະໂນມັດ

· ເບິ່ງFileStream: ຂຽນໃນໄຟລ໌ ແລະອາໄສການຫມຸນບັນທຶກພາຍນອກ

· TimedRotatingFileStream: ຂຽນໃນໄຟລ໌ແລະສາມາດ rotate ໃນເວລາທີ່ແນ່ນອນ
ໄລຍະຫ່າງ.

· QueueStream: ຂຽນໃນຄິວຄວາມຊົງຈໍາ

· StdoutStream: ຂຽນໃນ stdout

· FancyStdoutStream: ຂຽນຜົນອອກສີດ້ວຍຄຳນຳໜ້າເວລາໃນ stdout

stderr_stream.*
ທາງເລືອກທັງຫມົດເລີ່ມຕົ້ນດ້ວຍ stderr_stream. ອື່ນກ່ວາ ລະດັບ ຈະ​ໄດ້​ຮັບ​ການ​ຜ່ານ​ການ​
constructor ເມື່ອສ້າງ instance ຂອງ class ທີ່ກໍານົດໄວ້ໃນ
stderr_stream.class.

stdout_stream.class
ຊື່ຫ້ອງຮຽນ Python ທີ່ມີຄຸນວຸດທິຢ່າງເຕັມທີ່ທີ່ຈະ instanciated, ແລະຈະໄດ້ຮັບ
ໄດ້ stdout ກະແສຂອງຂະບວນການທັງຫມົດໃນຂອງມັນ __ໂທ__() ວິທີການ.

Circus ໃຫ້ບາງຊັ້ນຮຽນສະຕຣີມທີ່ທ່ານສາມາດນໍາໃຊ້ໄດ້ໂດຍບໍ່ມີຄໍານໍາຫນ້າ:

· FileStream: ຂຽນໃນໄຟລ໌ແລະສາມາດເຮັດການຫມຸນບັນທຶກອັດຕະໂນມັດ

· ເບິ່ງFileStream: ຂຽນໃນໄຟລ໌ ແລະອາໄສການຫມຸນບັນທຶກພາຍນອກ

· TimedRotatingFileStream: ຂຽນໃນໄຟລ໌ແລະສາມາດ rotate ໃນເວລາທີ່ແນ່ນອນ
ໄລຍະຫ່າງ.

· QueueStream: ຂຽນໃນຄິວຄວາມຊົງຈໍາ

· StdoutStream: ຂຽນໃນ stdout

· FancyStdoutStream: ຂຽນຜົນອອກສີດ້ວຍຄຳນຳໜ້າເວລາໃນ stdout

stdout_stream.*
ທາງເລືອກທັງຫມົດເລີ່ມຕົ້ນດ້ວຍ stdout_stream. ອື່ນກ່ວາ ລະດັບ ຈະ​ໄດ້​ຮັບ​ການ​ຜ່ານ​ການ​
constructor ເມື່ອສ້າງ instance ຂອງ class ທີ່ກໍານົດໄວ້ໃນ
stdout_stream.class.

close_child_stdout
ຖ້າຕັ້ງເປັນ True, stdout stream ຂອງແຕ່ລະຂະບວນການຈະຖືກສົ່ງໄປຫາ /dev/null
ຫຼັງຈາກສ້ອມ. ຄ່າເລີ່ມຕົ້ນເປັນຜິດ.

close_child_stderr
ຖ້າຕັ້ງເປັນ True, stderr stream ຂອງແຕ່ລະຂະບວນການຈະຖືກສົ່ງໄປຫາ /dev/null
ຫຼັງຈາກສ້ອມ. ຄ່າເລີ່ມຕົ້ນເປັນຜິດ.

send_hup
ຖ້າຖືກຕ້ອງ, ຂະບວນການໂຫຼດຄືນໃໝ່ຈະເຮັດໄດ້ໂດຍການສົ່ງສັນຍານ SIGHUP. ຄ່າເລີ່ມຕົ້ນ
ຜິດ.

stop_signal
ສັນຍານທີ່ຈະສົ່ງໃນເວລາທີ່ຢຸດຂະບວນການ. ສາມາດລະບຸເປັນຕົວເລກ ຫຼື a
ຊື່ສັນຍານ. ຊື່ສັນຍານແມ່ນຕົວພິມນ້ອຍ ແລະສາມາດລວມເອົາ 'SIG' ຫຼືບໍ່. ດັ່ງນັ້ນ
ຕົວຢ່າງທີ່ຖືກຕ້ອງລວມມີ ເຊົາ, INT, ໄລຍະເປົ້າໝາຍ ແລະ 3. ຄ່າເລີ່ມຕົ້ນເປັນ SIGTERM.

stop_children
ເມື່ອສົ່ງ stop_signal, ສົ່ງໃຫ້ເດັກນ້ອຍເຊັ່ນດຽວກັນ. ຄ່າເລີ່ມຕົ້ນເປັນ
ບໍ່ຖືກຕ້ອງ.

max_retry
ຈໍານວນຄັ້ງທີ່ພວກເຮົາພະຍາຍາມເລີ່ມຕົ້ນຂະບວນການ, ກ່ອນທີ່ພວກເຮົາຈະປະຖິ້ມແລະຢຸດເຊົາ
watcher ທັງ​ຫມົດ​. ຄ່າເລີ່ມຕົ້ນເປັນ 5. ຕັ້ງເປັນ -1 ເພື່ອປິດການໃຊ້ງານ max_retry ແລະລອງໃໝ່ອີກ
indefinitely

graceful_timeout
ຈໍານວນວິນາທີທີ່ຈະລໍຖ້າຂະບວນການທີ່ຈະສິ້ນສຸດຢ່າງສະຫງ່າງາມກ່ອນ
ຂ້າມັນ.

ເມື່ອຢຸດຂະບວນການ, ພວກເຮົາທໍາອິດສົ່ງມັນ a stop_signal. ພະນັກງານອາດຈະຈັບໄດ້
ສັນຍານເພື່ອດໍາເນີນການທໍາຄວາມສະອາດກ່ອນທີ່ຈະອອກ. ຖ້າຄົນງານຍັງຢູ່
ການເຄື່ອນໄຫວຫຼັງຈາກ graceful_timeout ວິນາທີ, ພວກເຮົາສົ່ງສັນຍານ SIGKILL. ມັນ​ບໍ່​ແມ່ນ
ເປັນໄປໄດ້ເພື່ອຈັບສັນຍານ SIGKILL ດັ່ງນັ້ນຄົນງານຈະຢຸດ.

ຄ່າເລີ່ມຕົ້ນເປັນ 30s.

ບູລິມະສິດ
ຈຳນວນເຕັມທີ່ກຳນົດບຸລິມະສິດສຳລັບຜູ້ເບິ່ງ. ໃນເວລາທີ່ Arbiter ເຮັດບາງ
ການດໍາເນີນງານຢູ່ໃນ watchers ທັງຫມົດ, ມັນຈະຈັດຮຽງໃຫ້ເຂົາເຈົ້າກັບພາກສະຫນາມນີ້, ຈາກຂະຫນາດໃຫຍ່
ຈໍານວນນ້ອຍທີ່ສຸດ. ຄ່າເລີ່ມຕົ້ນເປັນ 0.

singleton
ຖ້າຕັ້ງເປັນຖືກຕ້ອງ, ຕົວເບິ່ງນີ້ຈະມີຂະບວນການດຽວທີ່ສຸດ. ຄ່າເລີ່ມຕົ້ນເປັນ
ບໍ່ຖືກຕ້ອງ.

use_sockets
ຖ້າຕັ້ງເປັນຖືກຕ້ອງ, ຕົວເຝົ້າຍາມນີ້ຈະສາມາດເຂົ້າເຖິງຊັອກເກັດທີ່ກຳນົດໄວ້ໂດຍຜ່ານພວກມັນ
ຕົວອະທິບາຍໄຟລ໌. ຖ້າເປັນຜິດ, fds ທັງໝົດຂອງພໍ່ແມ່ຈະຖືກປິດເມື່ອຂະບວນການຂອງເດັກແມ່ນ
ສ້ອມ. ຄ່າເລີ່ມຕົ້ນເປັນຜິດ.

ສູງສຸດ_ອາຍຸ
ຖ້າຕັ້ງແລ້ວຂະບວນການຈະຖືກເລີ່ມຕົ້ນໃຫມ່ບາງຄັ້ງຫຼັງຈາກ max_age ວິນາທີ. ນີ້
ເປັນປະໂຫຍດໃນເວລາທີ່ຂະບວນການຈັດການກັບກຸ່ມຂອງຕົວເຊື່ອມຕໍ່: ຂະບວນການເລີ່ມຕົ້ນໃຫມ່
ປັບປຸງການດຸ່ນດ່ຽງການໂຫຼດ. ຄ່າເລີ່ມຕົ້ນທີ່ຈະຖືກປິດການໃຊ້ງານ.

max_age_variance
ຖ້າ max_age ຖືກຕັ້ງແລ້ວຂະບວນການຈະມີຊີວິດຢູ່ລະຫວ່າງ max_age ແລະ max_age +
Random(0, max_age_variance) ວິນາທີ. ນີ້ຫຼີກເວັ້ນການ restarting ຂະບວນການທັງຫມົດສໍາລັບ a
watcher ໃນ​ເວ​ລາ​ດຽວ​. ຄ່າເລີ່ມຕົ້ນເປັນ 30 ວິນາທີ.

on_demand
ຖ້າຕັ້ງເປັນຖືກຕ້ອງ, ຂະບວນການຕ່າງໆຈະຖືກເລີ່ມຕົ້ນພຽງແຕ່ຫຼັງຈາກການເຊື່ອມຕໍ່ຄັ້ງທໍາອິດກັບ
ຫນຶ່ງໃນເຕົ້າສຽບທີ່ຖືກຕັ້ງຄ່າ (ເບິ່ງຂ້າງລຸ່ມນີ້). ຖ້າຕ້ອງການ restart, ມັນຈະເປັນ
ກະຕຸ້ນພຽງແຕ່ຢູ່ໃນເຫດການ socket ຕໍ່ໄປ.

hooks.*
hooks ທີ່​ມີ​ຢູ່​: ກ່ອນ_ເລີ່ມ, after_start, before_spawn, after_spawn,
ກ່ອນ_ຢຸດ, after_stop, ກ່ອນ_ສັນຍານ, after_signal, ສະຖິຕິຂະຫຍາຍ

ກຳນົດຟັງຊັນໂທກັບທີ່ຕິດພັນກັບຂະບວນການເລີ່ມຕົ້ນ/ປິດເຄື່ອງຂອງ watcher.

ຖ້າ hook ກັບຄືນມາ ທີ່ບໍ່ຖືກຕ້ອງ ແລະຖ້າຫາກວ່າ hook ແມ່ນຫນຶ່ງໃນ ກ່ອນ_ເລີ່ມ, before_spawn,
after_start or after_spawn, ການເລີ່ມຕົ້ນຈະຖືກຍົກເລີກ.

ຖ້າຫາກວ່າ hook ແມ່ນ ກ່ອນ_ສັນຍານ ແລະກັບຄືນ ທີ່ບໍ່ຖືກຕ້ອງ, ຫຼັງຈາກນັ້ນສັນຍານທີ່ສອດຄ້ອງກັນ
ຈະບໍ່ຖືກສົ່ງ (ຍົກເວັ້ນ SIGKILL ທີ່ຖືກສົ່ງໄປສະເຫມີ)

ສັງເກດເຫັນວ່າ hook ທີ່ລົ້ມເຫລວໃນລະຫວ່າງຂະບວນການຢຸດຈະບໍ່ເອົາລູກອອກ.

ຄໍານິຍາມການໂທກັບສາມາດປະຕິບັດຕາມໂດຍທຸງ boolean ແຍກດ້ວຍເຄື່ອງໝາຍຈຸດ.
ເມື່ອທຸງຖືກຕັ້ງເປັນ ທີ່ແທ້ຈິງ, ຂໍ້ຜິດພາດທີ່ເກີດຂຶ້ນໃນ hook ຈະຖືກລະເລີຍ. ຖ້າ
ຕັ້ງ​ຄ່າ ທີ່ບໍ່ຖືກຕ້ອງ (ຄ່າເລີ່ມຕົ້ນ), hook ຈະກັບຄືນມາ ທີ່ບໍ່ຖືກຕ້ອງ.

ເພີ່ມເຕີມກ່ຽວກັບ hooks.

virtualenv
ເມື່ອສະຫນອງໃຫ້, ຊີ້ໃຫ້ເຫັນເຖິງຮາກຂອງໄດເລກະທໍລີ Virtualenv. watcher ຈະ
ສະແກນທ້ອງຖິ່ນ ແພັກເກດເວັບໄຊ ແລະໂຫຼດເນື້ອໃນຂອງມັນເຂົ້າໃນການປະຕິບັດ
ສະພາບແວດລ້ອມ. ຕ້ອງໃຊ້ກັບ copy_env ຕັ້ງເປັນ True. ຄ່າເລີ່ມຕົ້ນເປັນບໍ່ມີ.

virtualenv_py_ver
ລະບຸເວີຊັນ python ຂອງ virtualenv (ຕົວຢ່າງ "3.3"). ມັນເປັນປະໂຫຍດຖ້າ
circus ແລ່ນກັບສະບັບ python ອື່ນ (ເຊັ່ນ: "2.7") watcher ຈະສະແກນໄດ້
ທ້ອງຖິ່ນ ແພັກເກດເວັບໄຊ ຂອງສະບັບ python ທີ່ກໍານົດໄວ້ແລະໂຫລດເນື້ອໃນຂອງມັນເຂົ້າໄປໃນ
ສະພາບແວດລ້ອມການປະຕິບັດ. ຕ້ອງໃຊ້ກັບ virtualenv. ຄ່າເລີ່ມຕົ້ນເປັນບໍ່ມີ.

ຟື້ນຄືນ
ຖ້າຕັ້ງເປັນຜິດ, ຂະບວນການທີ່ຈັດການໂດຍຜູ້ເຝົ້າລະວັງຈະບໍ່ຖືກສ້າງຄືນໃໝ່
ອັດຕະໂນມັດ. ຂະ​ບວນ​ການ​ສາ​ມາດ​ໄດ້​ຮັບ​ການ respawned ຄູ່​ມື​ການ​ ການເລີ່ມຕົ້ນ ຄໍາສັ່ງ.
(ຄ່າເລີ່ມຕົ້ນ: ຖືກ)

ໃຊ້_papa
ຕັ້ງເປັນ true ເພື່ອໃຊ້ papa.

ເຕົ້າຮັບ:NAME - as ຈໍານວນຫຼາຍ ພາກສ່ວນ as ທ່ານ ຕ້ອງການ
ເຈົ້າພາບ ເຈົ້າພາບຂອງເຕົ້າຮັບ. ຄ່າເລີ່ມຕົ້ນເປັນ 'localhost'

port ທ່າເຮືອ. ຄ່າເລີ່ມຕົ້ນເປັນ 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.

ເສັ້ນທາງ ເມື່ອໃຫ້ເສັ້ນທາງໄປຫາໄຟລ໌ທີ່ຈະໃຊ້ເປັນໄຟລ໌ຊັອກເກັດ unix. ຖ້າ ກ
ເສັ້ນທາງແມ່ນສະຫນອງໃຫ້, ຄອບຄົວ ຖືກບັງຄັບໃຫ້ AF_UNIX ແລະ ເຈົ້າພາບ ແລະ port ຖືກລະເລີຍ.

ໜ້າ ກາກ ເມື່ອສະໜອງໃຫ້, ຕັ້ງຄ່າ umask ທີ່ຈະໃຊ້ເພື່ອສ້າງ AF_UNIX socket. ສໍາລັບ
ຍົກຕົວຢ່າງ, umask=000 ຈະຜະລິດຊັອກເກັດທີ່ມີການອະນຸຍາດ 777.

ທົດແທນ
ເມື່ອສ້າງຊັອກເກັດ Unix ('AF_UNIX'), ໄຟລ໌ທີ່ມີຢູ່ແລ້ວອາດຈະຊີ້ໃຫ້ເຫັນເຖິງບັນຫາ
ດັ່ງນັ້ນຄ່າເລີ່ມຕົ້ນແມ່ນເພື່ອລົ້ມເຫລວ. ລະບຸ ທີ່ແທ້ຈິງ ພຽງແຕ່ເອົາໄຟລ໌ເກົ່າອອກຖ້າທ່ານຢູ່
ໃຫ້ແນ່ໃຈວ່າເຕົ້າຮັບໄດ້ຖືກຄຸ້ມຄອງໂດຍ Circus ເທົ່ານັ້ນ.

so_reuseport
ຖ້າຕັ້ງເປັນ True ແລະ SO_REUSEPORT ແມ່ນມີຢູ່ໃນເວທີເປົ້າຫມາຍ, circus ຈະ
ສ້າງແລະຜູກມັດ SO_REUSEPORT socket(s) ໃຫມ່ສໍາລັບພະນັກງານທຸກຄົນທີ່ມັນເລີ່ມຕົ້ນຊຶ່ງເປັນ
ຜູ້ໃຊ້ຂອງເຕົ້າຮັບນີ້.

ໃຊ້_papa
ຕັ້ງເປັນ true ເພື່ອໃຊ້ papa.

ເມື່ອເຕົ້າສຽບຖືກສ້າງຂື້ນ, ໄດ້ ${circus.sockets.NAME} string ສາມາດຖືກນໍາໃຊ້ໃນຄໍາສັ່ງ
(cmd or ໂຕ້ຖຽງ) ຂອງ​ຜູ້​ເບິ່ງ​. Circus ຈະທົດແທນມັນໂດຍມູນຄ່າ FD. ຜູ້ເບິ່ງຍັງຕ້ອງ
ມີ use_sockets ຕັ້ງ​ຄ່າ ທີ່ແທ້ຈິງ ຖ້າບໍ່ດັ່ງນັ້ນເຕົ້າຮັບຈະຖືກປິດແລະທ່ານຈະໄດ້ຮັບ
ຄວາມຜິດພາດໃນເວລາທີ່ watcher ພະຍາຍາມໃຊ້ມັນ.

ຕົວຢ່າງ:

[ຜູ້ເບິ່ງ: webworker]
cmd = chaussette --fd $(circus.sockets.webapp) chaussette.util.bench_app
use_sockets = ຖືກ

[ເຕົ້າຮັບ: webapp]
ເຈົ້າພາບ = 127.0.0.1
ພອດ = 8888

ປລັກອິນ:NAME - as ຈໍານວນຫຼາຍ ພາກສ່ວນ as ທ່ານ ຕ້ອງການ
ການນໍາໃຊ້ ຊື່ທີ່ມີຄຸນສົມບັດຄົບຖ້ວນທີ່ຊີ້ໃຫ້ເຫັນເຖິງຊັ້ນ plugin.

ຫຍັງ ອື່ນ
ທຸກໆກະແຈອື່ນໆທີ່ພົບເຫັນຢູ່ໃນພາກແມ່ນຖືກສົ່ງໄປຫາຕົວສ້າງ plugin ໃນ
config ແຜນທີ່.

ທ່ານ​ສາ​ມາດ​ນໍາ​ໃຊ້​ທາງ​ເລືອກ watcher ທັງ​ຫມົດ​, ນັບ​ຕັ້ງ​ແຕ່ plugin ໄດ້​ເລີ່ມ​ຕົ້ນ​ຄ້າຍ​ຄື watcher ໄດ້​.

Circus ມາພ້ອມກັບ plugins ທາງສ່ວນຫນ້າຂອງການຂົນສົ່ງຈໍານວນຫນ້ອຍແຕ່ທ່ານຍັງສາມາດຂະຫຍາຍໃຫ້ເຂົາເຈົ້າໄດ້ຢ່າງງ່າຍດາຍໂດຍ
ການ​ພັດ​ທະ​ນາ​ຂອງ​ທ່ານ​ເອງ​.

ປະມານ or env[:WATCHERS] - as ຈໍານວນຫຼາຍ ພາກສ່ວນ as ທ່ານ ຕ້ອງການ
ຫຍັງ
ຊື່ຂອງຕົວແປສະພາບແວດລ້ອມເພື່ອກຳນົດຄ່າໃຫ້. ສະພາບແວດລ້ອມແບບ bash
ການທົດແທນແມ່ນສະຫນັບສະຫນູນ. ສໍາລັບຕົວຢ່າງ, ຕື່ມຂໍ້ມູນໃສ່ / ຖັງ to PATH 'ເສັ້ນທາງ =
$PATH:/ ຖັງ'

ພາກສ່ວນທີ່ຮັບຜິດຊອບໃນການຈັດສົ່ງຕົວແປສະພາບແວດລ້ອມເພື່ອດໍາເນີນການຂະບວນການ.

ຕົວຢ່າງ:

[ຜູ້ເບິ່ງ: ຄົນງານ 1]
cmd = ping 127.0.0.1

[ຜູ້ເບິ່ງ: ຄົນງານ 2]
cmd = ping 127.0.0.1

[env]
CAKE = ນອນ

ຕົວແປ CAKE ຈະຂະຫຍາຍພັນໄປຫາຜູ້ເບິ່ງທັງໝົດທີ່ກຳນົດໄວ້ໃນໄຟລ໌ config.

WATCHERS ສາມາດເປັນລາຍການທີ່ແຍກດ້ວຍເຄື່ອງໝາຍຈຸດຂອງພາກສ່ວນ watcher ເພື່ອນຳໃຊ້ສະພາບແວດລ້ອມນີ້.
ຖ້າຫຼາຍພາກສ່ວນ env ກົງກັບຜູ້ເບິ່ງ, ພວກມັນຈະຖືກລວມເຂົ້າກັນໃນລໍາດັບທີ່ພວກເຂົາປາກົດ
ໄຟລ​໌​ການ​ຕັ້ງ​ຄ່າ​. ການປ້ອນຂໍ້ມູນຕໍ່ມາຈະມີຄວາມສຳຄັນກວ່າ.

ຕົວຢ່າງ:

[ຜູ້ເບິ່ງ: ຄົນງານ 1]
cmd = ping 127.0.0.1

[ຜູ້ເບິ່ງ: ຄົນງານ 2]
cmd = ping 127.0.0.1

[env:worker1,worker2]
ເສັ້ນທາງ = / ຖັງ

[env​: ຄົນ​ງານ 1​]
PATH = $PATH

[env​: ຄົນ​ງານ 2​]
CAKE = ນອນ

ຄົນງານ1 ຈະຖືກແລ່ນດ້ວຍ PATH = $PATH (ຂະຫຍາຍຈາກສະພາບແວດລ້ອມ circusd ຖືກແລ່ນໃນ)
ຄົນງານ2 ຈະດໍາເນີນການກັບ PATH = / ຖັງ ແລະ CAKE = ນອນ

ມັນເປັນໄປໄດ້ທີ່ຈະໃຊ້ wildcards ເຊັ່ນກັນ.

ຕົວຢ່າງ:

[ຜູ້ເບິ່ງ: ຄົນງານ 1]
cmd = ping 127.0.0.1

[ຜູ້ເບິ່ງ: ຄົນງານ 2]
cmd = ping 127.0.0.1

[env: ພະນັກງານ*]
ເສັ້ນທາງ = / ຖັງ

ທັງສອງ ຄົນງານ1 ແລະ ຄົນງານ2 ຈະດໍາເນີນການກັບ PATH = / ຖັງ

ການນໍາໃຊ້ ສະພາບແວດລ້ອມ ຕົວແປ
ເມື່ອຂຽນໄຟລ໌ການຕັ້ງຄ່າຂອງທ່ານ, ທ່ານສາມາດນໍາໃຊ້ຕົວແປສະພາບແວດລ້ອມທີ່ກໍານົດໄວ້ໃນ ປະມານ
ພາກ ຫຼື ໃນ os.environ ຕົວເອງ

ທ່ານພຽງແຕ່ຕ້ອງໃຊ້ circus.env. ຄຳ ນຳ ໜ້າ.

ຕົວຢ່າງ:

[ຜູ້ເບິ່ງ: ຄົນງານ 1]
cmd = $(circus.env.shell)

[ຜູ້ເບິ່ງ: ຄົນງານ 2]
baz = $(circus.env.user)
ບາ = $(circus.env.yeah)
sup = $(circus.env.oh)

[ເຕົ້າຮັບ:socket1]
ພອດ = $(circus.env.port)

[ປລັກອິນ:plugin1]
use = some.path
parameter1 = $(circus.env.plugin_param)

[env]
ແມ່ນແລ້ວ = ໂບ

[env​: ຄົນ​ງານ 2​]
ໂອ້ຍ = ໂອເຄ

ຖ້າຕົວແປຖືກກຳນົດໄວ້ໃນຫຼາຍບ່ອນ, ຄ່າພິເສດທີ່ສຸດແມ່ນເປັນອັນດັບໜຶ່ງ: a
ຕົວແປທີ່ກໍານົດໃນ env:XXX ຈະ override ຕົວແປທີ່ກໍານົດໃນ ປະມານ, ເຊິ່ງຈະ override a
ຕົວແປທີ່ກໍານົດໃນ os.environ.

ການທົດແທນສະພາບແວດລ້ອມສາມາດຖືກນໍາໃຊ້ໃນພາກສ່ວນຂອງການຕັ້ງຄ່າໃນພາກໃດ
ຕົວແປ.

ການສ້າງຮູບແບບ ໄດ້ ຄໍາສັ່ງ ແລະ ກະທູ້ທີ່ ກັບ ການເຄື່ອນໄຫວ ຕົວແປ
ດັ່ງທີ່ທ່ານອາດຈະໄດ້ເຫັນ, ມັນເປັນໄປໄດ້ທີ່ຈະຜ່ານຂໍ້ມູນບາງຢ່າງທີ່ຖືກຄິດໄລ່
ໄດນາມິກໃນເວລາທີ່ແລ່ນຂະບວນການ. ໃນບັນດາສິ່ງອື່ນໆ, ທ່ານສາມາດໄດ້ຮັບ ID ພະນັກງານ
(WID) ແລະທາງເລືອກທັງຫມົດທີ່ຖືກສົ່ງກັບ ຂະບວນການ. ນອກຈາກນັ້ນ, ມັນເປັນໄປໄດ້ທີ່ຈະ
ເຂົ້າເຖິງທາງເລືອກທີ່ຜ່ານໄປ ຜູ້ເບິ່ງ ເຊິ່ງເຮັດໃຫ້ຂະບວນການດັ່ງກ່າວໄດ້ກະຕຸ້ນ.

ຫມາຍ​ເຫດ​:
ID ພະນັກງານແມ່ນແຕກຕ່າງຈາກ id ຂະບວນການ. ມັນເປັນມູນຄ່າທີ່ເປັນເອກະລັກ, ເລີ່ມຕົ້ນທີ່ 1,
ເຊິ່ງເປັນເອກະລັກສະເພາະສຳລັບຜູ້ເບິ່ງເທົ່ານັ້ນ.

ຕົວຢ່າງ, ຖ້າທ່ານຕ້ອງການເຂົ້າເຖິງຕົວແປບາງຢ່າງທີ່ມີຢູ່ໃນສະພາບແວດລ້ອມ,
ທ່ານ ຈຳ ເປັນຕ້ອງເຮັດມັນດ້ວຍການຕັ້ງຄ່ານີ້:

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

ນີ້ເຮັດວຽກກັບທັງສອງ cmd ແລະ ໂຕ້ຖຽງ.

ທີ່ສໍາຄັນ:

· ຕົວແປທັງໝົດຖືກນຳໜ້າດ້ວຍ ວົງດົນຕີ.

· ການທົດແທນແມ່ນບໍ່ມີຕົວພິມນ້ອຍໃຫຍ່.

ນ້ໍາ configuration
ຫ້ອງຮຽນສະຕີມງ່າຍດາຍເຊັ່ນ QueueStream ແລະ StdoutStream ບໍ່ມີຄຸນລັກສະນະສະເພາະແຕ່
ບາງຊັ້ນ stream ອື່ນໆອາດຈະມີບາງ:

FileStream
ຊື່​ເອ​ກະ​ສານ
ເສັ້ນທາງໄຟລ໌ທີ່ບັນທຶກຈະຖືກຂຽນ.

time_format
ຮູບແບບ strftime ທີ່ຈະໃຊ້ເພື່ອນຳໜ້າແຕ່ລະຄັ້ງດ້ວຍການສະແຕມເວລາ. ໂດຍ
ຄ່າເລີ່ມຕົ້ນພວກມັນຈະບໍ່ຖືກນຳໜ້າ.

ເຊັ່ນ: %Y-%m-%d %H:%M:%S

max_bytes
ຂະໜາດສູງສຸດຂອງໄຟລ໌ບັນທຶກກ່ອນທີ່ຈະເລີ່ມໄຟລ໌ໃໝ່. ຖ້າຫາກວ່າບໍ່ໄດ້ສະຫນອງໃຫ້, ໄດ້
ໄຟລ໌ບໍ່ໄດ້ຖືກມ້ວນ.

backup_count
ຈໍາ​ນວນ​ຂອງ​ໄຟລ​໌​ບັນ​ທຶກ​ທີ່​ຈະ​ໄດ້​ຮັບ​ການ​ເກັບ​ຮັກ​ສາ​ໄວ້​ໂດຍ​ເລີ່ມ​ຕົ້ນ backup_count ເປັນ null​.

ຫມາຍ​ເຫດ​:
Rollover ເກີດຂຶ້ນທຸກຄັ້ງທີ່ໄຟລ໌ບັນທຶກປັດຈຸບັນມີຄວາມຍາວເກືອບ max_bytes. ຖ້າ
backup_count ແມ່ນ >= 1, ລະບົບຈະສ້າງໄຟລ໌ໃໝ່ຢ່າງຕໍ່ເນື່ອງ
ຊື່ເສັ້ນທາງເປັນໄຟລ໌ພື້ນຖານ, ແຕ່ມີສ່ວນຂະຫຍາຍ ".1", ".2" ແລະອື່ນໆ. ສໍາລັບ
ຕົວຢ່າງ, ດ້ວຍ backup_count ຂອງ 5 ແລະຊື່ໄຟລ໌ພື້ນຖານຂອງ "app.log", ທ່ານຈະໄດ້ຮັບ
"app.log", "app.log.1", "app.log.2", ... ຈົນເຖິງ "app.log.5". ໄຟລ໌ທີ່ກໍາລັງຂຽນ
to ສະເຫມີ "app.log" - ເມື່ອມັນເຕັມໄປ, ມັນຖືກປິດແລະປ່ຽນຊື່ເປັນ
"app.log.1", ແລະຖ້າໄຟລ໌ "app.log.1", "app.log.2" ແລະອື່ນໆມີຢູ່, ຫຼັງຈາກນັ້ນພວກມັນຈະຖືກປ່ຽນຊື່.
ກັບ "app.log.2", "app.log.3" ແລະອື່ນໆຕາມລໍາດັບ.

ຕົວຢ່າງ:

[ເບິ່ງ: myprogram]
cmd = python -m myapp.server

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

ເບິ່ງFileStream
ຊື່​ເອ​ກະ​ສານ
ເສັ້ນທາງໄຟລ໌ທີ່ບັນທຶກຈະຖືກຂຽນ.

time_format
ຮູບແບບ strftime ທີ່ຈະໃຊ້ເພື່ອນຳໜ້າແຕ່ລະຄັ້ງດ້ວຍການສະແຕມເວລາ. ໂດຍ
ຄ່າເລີ່ມຕົ້ນພວກມັນຈະບໍ່ຖືກນຳໜ້າ.

ເຊັ່ນ: %Y-%m-%d %H:%M:%S

ຫມາຍ​ເຫດ​:
WatchedFileStream ອາໄສເຄື່ອງມືການຫມຸນບັນທຶກພາຍນອກເພື່ອຮັບປະກັນວ່າໄຟລ໌ບັນທຶກ
ຢ່າກາຍເປັນໃຫຍ່ເກີນໄປ. ໄຟລ​໌​ຜົນ​ຜະ​ລິດ​ຈະ​ໄດ້​ຮັບ​ການ​ຕິດ​ຕາມ​ກວດ​ກາ​ແລະ​ຖ້າ​ຫາກ​ວ່າ​ມັນ​ເຄີຍ​ຖືກ​ລົບ​ຫຼື​
ຍ້າຍ​ໂດຍ​ເຄື່ອງ​ມື​ການ​ຫມູນ​ວຽນ​ບັນ​ທຶກ​ພາຍ​ນອກ​, ຫຼັງ​ຈາກ​ນັ້ນ​ການ​ຈັບ​ໄຟລ​໌​ຜົນ​ຜະ​ລິດ​ຈະ​ເປັນ​
ໂຫຼດຄືນໃໝ່ໂດຍອັດຕະໂນມັດ.

ຕົວຢ່າງ:

[ເບິ່ງ: myprogram]
cmd = python -m myapp.server

stdout_stream.class = ເບິ່ງແລ້ວFileStream
stdout_stream.filename = test.log
stdout_stream.time_format = %Y-%m-%d %H:%M:%S

TimedRotatingFileStream
ຊື່​ເອ​ກະ​ສານ
ເສັ້ນທາງໄຟລ໌ທີ່ບັນທຶກຈະຖືກຂຽນ.

backup_count
ຈໍາ​ນວນ​ຂອງ​ໄຟລ​໌​ບັນ​ທຶກ​ທີ່​ຈະ​ໄດ້​ຮັບ​ການ​ເກັບ​ຮັກ​ສາ​ໄວ້​ໂດຍ​ເລີ່ມ​ຕົ້ນ backup_count ເປັນ null​.

time_format
ຮູບແບບ strftime ທີ່ຈະໃຊ້ເພື່ອນຳໜ້າແຕ່ລະຄັ້ງດ້ວຍການສະແຕມເວລາ. ໂດຍ
ຄ່າເລີ່ມຕົ້ນພວກມັນຈະບໍ່ຖືກນຳໜ້າ.

ເຊັ່ນ: %Y-%m-%d %H:%M:%S

rotate_when
ປະເພດຂອງໄລຍະຫ່າງ. ບັນຊີລາຍຊື່ຂອງຄ່າທີ່ເປັນໄປໄດ້ແມ່ນຂ້າງລຸ່ມນີ້. ໃຫ້ສັງເກດວ່າພວກເຂົາແມ່ນ
ບໍ່ແມ່ນຕົວພິມນ້ອຍໃຫຍ່.

┌───────────────┬──────────────────────
│ຄ່າ │ ປະເພດຂອງໄລຍະຫ່າງ │
├──────────────────────────────────────────┤
│'S' │ ວິນາທີ │
├──────────────────────────────────────────┤
│'M' │ ນາທີ │
├──────────────────────────────────────────┤
│'H' │ ຊົ່ວໂມງ │
├──────────────────────────────────────────┤
│'D' │ ມື້ │
├──────────────────────────────────────────┤
│'W0'-'W6' │ ອາທິດ (0=ວັນຈັນ) │
├──────────────────────────────────────────┤
│'ທ່ຽງຄືນ' │ ມ້ວນທ້າຍເວລາທ່ຽງຄືນ │
└──────────────────────────────────────────┘

rotate_interval
ໄລຍະຫ່າງຂອງມ້ວນ.

ຫມາຍ​ເຫດ​:
TimedRotatingFileStream ໝຸນ logfiles ໃນຊ່ວງເວລາທີ່ແນ່ນອນ. ໄລຍະຫ່າງມ້ວນ
ຖືກກໍານົດໂດຍການປະສົມປະສານຂອງ rotate_when ແລະ rotate_interval.

ຕົວຢ່າງ:

[ເບິ່ງ: myprogram]
cmd = python -m myapp.server

stdout_stream.class =TimedRotatingFileStream
stdout_stream.filename = test.log
stdout_stream.time_format = %Y-%m-%d %H:%M:%S
stdout_stream.utc = ຖືກຕ້ອງ
stdout_stream.rotate_when = H
stdout_stream.rotate_interval = 1

FancyStdoutStream
ສີ

ໄດ້ ຊື່ of an ASCII ສີ:

· ສີແດງ

·ສີຂຽວ

· ສີ​ເຫຼືອງ​

·ສີຟ້າ

· ສີມ່ວງແດງ

· ຟ້າ

· ສີຂາວ

time_format
ຮູບແບບ strftime ທີ່ແຕ່ລະແຖວຈະຖືກນຳໜ້າດ້ວຍ.

ຄ່າເລີ່ມຕົ້ນເປັນ: %Y-%m-%d %H:%M:%S

ຕົວຢ່າງ:

[ເບິ່ງ: myprogram]
cmd = python -m myapp.server
stdout_stream.class = FancyStdoutStream
stdout_stream.color = ສີຂຽວ
stdout_stream.time_format = %Y/%m/%d | %H:%M:%S

ຄໍາສັ່ງ
ຢູ່ໃນຈຸດສູນກາງຂອງ circus, ລະບົບຄໍາສັ່ງດໍາລົງຊີວິດ. circusctl ແມ່ນພຽງແຕ່ລູກຄ້າ zeromq,
ແລະຖ້າຈໍາເປັນ, ທ່ານສາມາດຂັບ programmaticaly ລະບົບ Circus ໂດຍການຂຽນ zmq ຂອງທ່ານເອງ
ລູກຄ້າ.

ຂໍ້ຄວາມທັງໝົດແມ່ນແຜນທີ່ JSON.

ສໍາລັບແຕ່ລະຄໍາສັ່ງຂ້າງລຸ່ມນີ້, ພວກເຮົາສະຫນອງຕົວຢ່າງການນໍາໃຊ້ທີ່ມີ circusctl ແຕ່ຍັງ input /
ສົ່ງອອກຂໍ້ຄວາມ zmq.

circus-ctl ຄໍາສັ່ງ
· ເພີ່ມ: ຄໍາສັ່ງ / ເພີ່ມ

· Decr: ຄໍາສັ່ງ/decr

· dstats: ຄໍາສັ່ງ / dstats

· ໄດ້ຮັບ: ຄໍາສັ່ງ / ໄດ້ຮັບ

· globaloptions: ຄໍາສັ່ງ/globaloptions

· incr: ຄໍາສັ່ງ / incr

· python: ຄໍາສັ່ງ/ipython

· ບັນຊີລາຍຊື່: ຄໍາສັ່ງ / ລາຍການ

· ຟັງ: ຄໍາສັ່ງ / ຟັງ

· ບັນຊີລາຍການ: ຄໍາສັ່ງ / listsockets

· ຂະ​ບວນ​ການ​ຈໍາ​ນວນ​: ຄໍາສັ່ງ / ຂະບວນການ

· ຕົວເລກ: ຄໍາສັ່ງ / ຕົວເລກ

· ທາງເລືອກໃນການ: ຄໍາສັ່ງ / ທາງເລືອກ

· ເຊົາ: ຄໍາສັ່ງ / ອອກ

· ໂຫຼດ ໃໝ່: ຄຳສັ່ງ/ໂຫຼດໃໝ່

· reloadconfig: commands/reloadconfig

· ເລີ່ມ​ຕົ້ນ​ໃຫມ່: ຄໍາສັ່ງ / restart

· rm: ຄໍາສັ່ງ / rm

· ທີ່ກໍານົດໄວ້: ຄໍາສັ່ງ / ຊຸດ

· signal: ຄໍາສັ່ງ / ສັນຍານ

· ການເລີ່ມຕົ້ນ: ຄໍາສັ່ງ / ເລີ່ມຕົ້ນ

· ສະຖິຕິ: ຄໍາສັ່ງ / ສະຖິຕິ

· ສະຖານະພາບ: ຄໍາສັ່ງ / ສະຖານະພາບ

· ຢຸດ: ຄໍາສັ່ງ / ຢຸດ

ຕື່ມ a watcher
ຄໍາສັ່ງນີ້ເພີ່ມຜູ້ເບິ່ງແບບເຄື່ອນໄຫວໃຫ້ກັບຜູ້ຕັດສິນ.

ZMQ ຂໍ້ຄວາມ
{
"ຄໍາສັ່ງ": "ຕື່ມ",
"ຄຸນສົມບັດ": {
"cmd": "/path/to/commandline --option"
"name": "ຊື່ຂອງໂມງ"
"args": [],
"ທາງເລືອກ": {},
"ເລີ່ມຕົ້ນ": ບໍ່ຖືກຕ້ອງ
}
}

ຂໍ້ຄວາມມີ 2 ຄຸນສົມບັດ:

· cmd: ເສັ້ນຄໍາສັ່ງເຕັມທີ່ຈະດໍາເນີນການໃນຂະບວນການ

· args: array, arguments ຜ່ານຄໍາສັ່ງ (ທາງເລືອກ)

· ຊື່: ຊື່ຂອງ watcher

·ທາງເລືອກ: ທາງເລືອກຂອງ watcher

· start: ເລີ່ມ watcher ຫຼັງຈາກການສ້າງ

ການ​ຕອບ​ສະ​ຫນອງ​ກັບ​ຄືນ​ສະ​ຖາ​ນະ "ok​"​.

ຄໍາສັ່ງ ອອນໄລນ໌
$ circusctl ເພີ່ມ [--start]

ທາງເລືອກໃນການ
· : ຊື່ຂອງ watcher ທີ່ຈະສ້າງ

· : ເສັ້ນຄໍາສັ່ງເຕັມທີ່ຈະດໍາເນີນການໃນຂະບວນການ

· --start: ເລີ່ມ watcher ທັນທີ

ຫຼຸດລົງ ໄດ້ ຈໍານວນ of ຂະບວນການ in a watcher
ຄໍາເຫັນນີ້ຫຼຸດລົງຈໍານວນຂອງຂະບວນການໃນ watcher ໂດຍ , 1 ເປັນ
Default

ZMQ ຂໍ້ຄວາມ
{
"ຄໍາສັ່ງ": "decr",
"ຄຸນສົມບັດ": {
"ຊື່": " "
"nb":
"ລໍຖ້າ": ບໍ່ຖືກຕ້ອງ
}
}

ຄໍາຕອບຕອບຈໍານວນຂະບວນການໃນຄຸນສົມບັດ 'numprocesses':

{ "ສະຖານະ": "ok", "numprocesses": , "ເວລາ", "ເວລາ" }

ຄໍາສັ່ງ ອອນໄລນ໌
$ circusctl decr [ ] [--ລໍຖ້າ]

ທາງເລືອກໃນການ
· : ຊື່ຂອງ watcher ໄດ້

· : ຈໍານວນຂະບວນການທີ່ຈະເອົາອອກ.

ໄດ້ຮັບ ວົງວຽນ ສະຖິຕິ
ທ່ານສາມາດໄດ້ຮັບສະຖິຕິກ່ຽວກັບ circusd ໄດ້ທຸກເວລາດ້ວຍຄໍາສັ່ງ dstat.

ZMQ ຂໍ້ຄວາມ
ເພື່ອໃຫ້ໄດ້ຮັບສະຖິຕິ circusd, ພຽງແຕ່ດໍາເນີນການ:

{
"ຄໍາສັ່ງ": "dstats"
}

ຄໍາຕອບຈະສົ່ງຄືນແຜນທີ່ຂອງຄຸນສົມບັດ "ຂໍ້ມູນ" ທີ່ມີຂໍ້ມູນຂະບວນການບາງຢ່າງ:

{
"ຂໍ້ມູນ": {
"ເດັກນ້ອຍ": [],
"cmdline": "python",
"cpu": 0.1,
"ctime": "0:00.41",
"mem": 0.1,
"mem_info1": "3M",
"mem_info2": "2G",
"ງາມ": 0,
"pid": 47864, ສ.
"ຊື່ຜູ້ໃຊ້": "ຮາກ"
},
"ສະຖານະ": "ຕົກລົງ",
"ເວລາ": 1332265655.897085
}

ຄໍາສັ່ງ ອອນໄລນ໌
$ circusctl dstats

ໄດ້ຮັບ ໄດ້ ມູນຄ່າ of ສະເພາະ watcher ທາງເລືອກໃນການ
ຄໍາສັ່ງນີ້ສາມາດຖືກນໍາໃຊ້ເພື່ອສອບຖາມມູນຄ່າປະຈຸບັນຂອງຫນຶ່ງຫຼືຫຼາຍທາງເລືອກ watcher.

ZMQ ຂໍ້ຄວາມ
{
"command": "ຮັບ",
"ຄຸນສົມບັດ": {
"keys": ["key1, "key2"]
"name": "ຊື່ຂອງໂມງ"
}
}

ຂໍ້ຄວາມຮ້ອງຂໍມີສອງຄຸນສົມບັດ:

·ຄີ: ບັນຊີລາຍຊື່, ປຸ່ມທາງເລືອກທີ່ທ່ານຕ້ອງການທີ່ຈະໄດ້ຮັບຄ່າ

· ຊື່: ຊື່ຂອງ watcher

ວັດຖຸຕອບສະໜອງມີຄຸນສົມບັດ ທາງເລືອກໃນການ ເຊິ່ງເປັນວັດຈະນານຸກົມຂອງຊື່ທາງເລືອກ ແລະ
ຄ່າ.

ຕົວຢ່າງ:

{
"ສະຖານະ": "ຕົກລົງ",
"ທາງເລືອກ": {
"graceful_timeout": 300,
"send_hup": ຖືກ,
},
ເວລາ': 1332202594.754644
}

ຄໍາສັ່ງ ອອນໄລນ໌
$ circusctl ໄດ້ຮັບ

ໄດ້ຮັບ ໄດ້ arbiter ທາງເລືອກໃນການ
ຄໍາສັ່ງນີ້ສົ່ງຄືນທາງເລືອກ arbiter

ZMQ ຂໍ້ຄວາມ
{
"command": "globaloptions",
"ຄຸນສົມບັດ": {
"key1": "val1",
..
}
}

ຂໍ້ຄວາມມີ 2 ຄຸນສົມບັດ:

·ຄີ: ບັນຊີລາຍຊື່, ປຸ່ມທາງເລືອກທີ່ທ່ານຕ້ອງການທີ່ຈະໄດ້ຮັບຄ່າ

ຄໍາຕອບສົ່ງຄືນວັດຖຸທີ່ມີຄຸນສົມບັດ "ທາງເລືອກ" ທີ່ມີບັນຊີລາຍຊື່ຂອງລະຫັດ / ຄ່າ
ກັບຄືນໂດຍ circus.

ຕົວຢ່າງ:

{
"ສະຖານະ": "ຕົກລົງ",
"ທາງເລືອກ": {
"check_delay": 1,
...
},
ເວລາ': 1332202594.754644
}

ຄໍາສັ່ງ ອອນໄລນ໌
$ circusctl globaloptions

ທາງເລືອກໃນການ
ປຸ່ມທາງເລືອກແມ່ນ:

· endpoint: ການຄວບຄຸມ ZMQ endpoint

· pubsub_endpoint: ຈຸດສິ້ນສຸດ pubsub

· check_delay: ຄວາມລ່າຊ້າລະຫວ່າງສອງຈຸດຄວບຄຸມ

· multicast_endpoint: ຈຸດສິ້ນສຸດ multicast ສໍາລັບການຄົ້ນພົບອັດຕະໂນມັດກຸ່ມ circusd

ເພີ່ມຂຶ້ນ ໄດ້ ຈໍານວນ of ຂະບວນການ in a watcher
ຄໍາເຫັນນີ້ເພີ່ມຈໍານວນຂະບວນການໃນ watcher ໂດຍ , 1 ເປັນ
Default

ZMQ ຂໍ້ຄວາມ
{
"ຄໍາສັ່ງ": "incr",
"ຄຸນສົມບັດ": {
"ຊື່": " ",
"nb": ,
"ລໍຖ້າ": ບໍ່ຖືກຕ້ອງ
}
}

ຄໍາຕອບຕອບຈໍານວນຂະບວນການໃນຄຸນສົມບັດ 'numprocesses':

{ "ສະຖານະ": "ok", "numprocesses": , "ເວລາ", "ເວລາ" }

ຄໍາສັ່ງ ອອນໄລນ໌
$ circusctl incr [ ] [--ລໍຖ້າ]

ທາງເລືອກໃນການ
· : ຊື່ຂອງ watcher ໄດ້.

· : ຈໍານວນຂະບວນການທີ່ຈະເພີ່ມ.

ສ້າງ ຫອຍ ເຂົ້າໄປໃນ ວົງວຽນ ຂະບວນການ
ຄໍາສັ່ງນີ້ມີປະໂຫຍດພຽງແຕ່ຖ້າທ່ານມີຊຸດ ipython ຕິດຕັ້ງ.

ຄໍາສັ່ງ ອອນໄລນ໌
$ circusctl ipython

ໄດ້ຮັບ ບັນຊີລາຍຊື່ of watchers or ຂະບວນການ in a watcher
ZMQ ຂໍ້ຄວາມ
ເພື່ອໃຫ້ໄດ້ຮັບບັນຊີລາຍຊື່ຂອງຜູ້ເບິ່ງທັງຫມົດ:

{
"ຄໍາສັ່ງ": "ບັນຊີລາຍຊື່",
}

ເພື່ອໃຫ້ໄດ້ຮັບບັນຊີລາຍຊື່ຂອງຂະບວນການທີ່ມີການເຄື່ອນໄຫວຢູ່ໃນ watcher:

{
"ຄໍາສັ່ງ": "ບັນຊີລາຍຊື່",
"ຄຸນສົມບັດ": {
"name": "nameofwatcher",
}
}

ຄໍາຕອບຕອບຄືນບັນຊີລາຍຊື່ຖາມ. ແຜນທີ່ກັບຄືນມາສາມາດເປັນ 'ຜູ້ເບິ່ງ' ຫຼື
'pids' ອີງຕາມການຮ້ອງຂໍ.

ຄໍາສັ່ງ ອອນໄລນ໌
$ circusctl ບັນຊີລາຍຊື່ [ ]

ຈອງ to a watcher ກໍລະນີ
ZMQ
ໃນທຸກເວລາທ່ານສາມາດຈອງກິດຈະກໍາ circus ໄດ້. Circus ໃຫ້ຟີດ PUB/SUB ທີ່
ລູກຄ້າໃດສາມາດສະໝັກໄດ້. URI ຈຸດສິ້ນສຸດຂອງຜູ້ຈອງແມ່ນຖືກກໍານົດໄວ້ໃນ circus.ini
ແຟ້ມການຕັ້ງຄ່າ.

ເຫດການແມ່ນຫົວຂໍ້ pubsub:

· ຜູ້ເບິ່ງ. .ເກັບກ່ຽວ: ເມື່ອຂະບວນການຖືກເກັບກ່ຽວ

· ຜູ້ເບິ່ງ. .ໄຂ່: ໃນເວລາທີ່ຂະບວນການແມ່ນ spawned

· ຜູ້ເບິ່ງ. .ຂ້າ: ເມື່ອຂະບວນການຖືກຂ້າ

· ຜູ້ເບິ່ງ. .ອັບເດດ: ເມື່ອ​ການ​ຕັ້ງ​ຄ່າ watcher ຖືກ​ປັບ​ປຸງ​

· ຜູ້ເບິ່ງ. .ຢຸດ: ເມື່ອຜູ້ເຝົ້າລະວັງຖືກຢຸດ

· ຜູ້ເບິ່ງ. .ເລີ່ມ: ເມື່ອຜູ້ສັງເກດການເລີ່ມຕົ້ນ

ຂໍ້ຄວາມເຫດການທັງໝົດຢູ່ໃນໂຄງສ້າງ json.

ຄໍາສັ່ງ ອອນໄລນ໌
ລູກຄ້າໄດ້ຖືກປັບປຸງເພື່ອໃຫ້ວິທີການຟັງງ່າຍໆກ່ຽວກັບເຫດການ:

circusctl ຟັງ [ , ...]

ຍົກຕົວຢ່າງ of ຜົນໄດ້ຮັບ:
$ circusctl ຟັງ tcp://127.0.0.1:5556
watcher.refuge.spawn: {u'process_id': 6, u'process_pid': 72976,
u'time': 1331681080.985104}
watcher.refuge.spawn: {u'process_id': 7, u'process_pid': 72995,
u'time': 1331681086.208542}
watcher.refuge.spawn: {u'process_id': 8, u'process_pid': 73014,
u'time': 1331681091.427005}

ໄດ້ຮັບ ໄດ້ ບັນຊີລາຍຊື່ of ເຕົ້າຮັບ
ZMQ ຂໍ້ຄວາມ
ເພື່ອໃຫ້ໄດ້ຮັບບັນຊີລາຍຊື່ຂອງເຕົ້າຮັບ:

{
"command": "listsockets",
}

ຄໍາຕອບສົ່ງຄືນບັນຊີລາຍຊື່ຂອງແຜນທີ່ json ທີ່ມີກະແຈສໍາລັບ fd, ຊື່, ເຈົ້າພາບແລະພອດ.

ຄໍາສັ່ງ ອອນໄລນ໌
$ circusctl listsockets

ໄດ້ຮັບ ໄດ້ ຈໍານວນ of ຂະບວນການ
ໄດ້ຮັບຈໍານວນຂະບວນການໃນ watcher ຫຼືໃນ arbiter

ZMQ ຂໍ້ຄວາມ
{
"ຄໍາສັ່ງ": "ຂະບວນການ",
"ຄຸນສົມບັດ": {
"ຊື່": " "
}

}

ຄໍາຕອບຕອບຈໍານວນຂະບວນການໃນຄຸນສົມບັດ 'numprocesses':

{ "ສະຖານະ": "ok", "numprocesses": , "ເວລາ", "ເວລາ" }

ຖ້າຊື່ຊັບສິນບໍ່ໄດ້ຖືກລະບຸ, ຜົນລວມຂອງຂະບວນການທັງຫມົດທີ່ຈັດການຈະຖືກສົ່ງຄືນ.

ຄໍາສັ່ງ ອອນໄລນ໌
$ circusctl numprocesses [ ]

ທາງເລືອກໃນການ
· : ຊື່ຂອງ watcher ໄດ້

ໄດ້ຮັບ ໄດ້ ຈໍານວນ of watchers
ໄດ້ຮັບຈໍານວນຂອງ watchers ໃນ arbiter ເປັນ

ZMQ ຂໍ້ຄວາມ
{
"command": "ຜູ້ຕິດຕາມຕົວເລກ",
}

ການຕອບໂຕ້ຄືນຈໍານວນຜູ້ເບິ່ງຢູ່ໃນຄຸນສົມບັດ 'numwatchers':

{ "ສະຖານະ": "ok", "ຜູ້ຕິດຕາມຕົວເລກ": , "ເວລາ", "ເວລາ" }

ຄໍາສັ່ງ ອອນໄລນ໌
$ circusctl numwatchers

ໄດ້ຮັບ ໄດ້ ມູນຄ່າ of ທັງຫມົດ ທາງເລືອກໃນການ ສໍາລັບການ a watcher
ຄໍາສັ່ງນີ້ສົ່ງຄືນຄ່າທາງເລືອກທັງຫມົດສໍາລັບ watcher ທີ່ກໍານົດ.

ZMQ ຂໍ້ຄວາມ
{
"ຄໍາສັ່ງ": "ທາງເລືອກ",
"ຄຸນສົມບັດ": {
"name": "nameofwatcher",
}
}

ຂໍ້ຄວາມມີ 1 ຄຸນສົມບັດ:

· ຊື່: ຊື່ຂອງ watcher

ວັດຖຸຕອບສະໜອງມີຄຸນສົມບັດ ທາງເລືອກໃນການ ເຊິ່ງເປັນວັດຈະນານຸກົມຂອງຊື່ທາງເລືອກ ແລະ
ຄ່າ.

ຕົວຢ່າງ:

{
"ສະຖານະ": "ຕົກລົງ",
"ທາງເລືອກ": {
"graceful_timeout": 300,
"send_hup": ຖືກ,
...
},
ເວລາ': 1332202594.754644
}

ຄໍາສັ່ງ ອອນໄລນ໌
$ circusctl ທາງເລືອກ

ທາງເລືອກໃນການ
· : ຊື່ຂອງ watcher ໄດ້

ປຸ່ມທາງເລືອກແມ່ນ:

· numprocesses: ຈຳນວນ, ຈຳນວນຂະບວນການ

· warmup_delay: ຈໍານວນເຕັມຫຼືຈໍານວນ, ການຊັກຊ້າທີ່ຈະລໍຖ້າລະຫວ່າງຂະບວນການ spawning ໃນວິນາທີ

· working_dir: string, directory ບ່ອນທີ່ຂະບວນການຈະຖືກປະຕິບັດ

· uid: string ຫຼື integer, ID ຜູ້ໃຊ້ທີ່ໃຊ້ເພື່ອເປີດຂະບວນການ

· gid: string ຫຼື integer, ກຸ່ມ ID ໃຊ້ເພື່ອເປີດຂະບວນການ

· send_hup: boolean, ຖ້າ TRU ສັນຍານ HUP ຈະຖືກນໍາໃຊ້ໃນການໂຫຼດໃຫມ່

· shell: boolean, ຈະດໍາເນີນການຄໍາສັ່ງໃນສະພາບແວດລ້ອມ shell ຖ້າເປັນຈິງ

· cmd: string, ເສັ້ນຄໍາສັ່ງທີ່ໃຊ້ເພື່ອເປີດຂະບວນການ

· env: ວັດຖຸ, ກໍານົດສະພາບແວດລ້ອມທີ່ຂະບວນການຈະຖືກເປີດຕົວ

· retry_in: integer ຫຼືຈໍານວນ, ເວລາເປັນວິນາທີທີ່ພວກເຮົາລໍຖ້າກ່ອນທີ່ພວກເຮົາຈະພະຍາຍາມເປີດໃຫມ່
ຂະບວນການຖ້າຫາກວ່າຈໍານວນສູງສຸດຂອງຄວາມພະຍາຍາມບັນລຸໄດ້.

· max_retry: integer, ສູງສຸດຂອງ retry loops

· graceful_timeout: ຈໍານວນເຕັມຫຼືຈໍານວນ, ເວລາທີ່ພວກເຮົາລໍຖ້າກ່ອນທີ່ພວກເຮົາຈະຂ້າຂະບວນການແນ່ນອນ.

· ບູລິມະສິດ: ໃຊ້ເພື່ອຈັດຮຽງນັກສັງເກດການໃນ arbiter

· singleton: ຖ້າເປັນຈິງ, a singleton watcher.

· max_age: ເວລາທີ່ຂະບວນການສາມາດມີຊີວິດຢູ່ກ່ອນທີ່ຈະເລີ່ມຕົ້ນໃຫມ່

· max_age_variance: ການ​ໃຊ້​ເວ​ລາ​ເພີ່ມ​ເຕີມ​ທີ່​ປ່ຽນ​ແປງ​ທີ່​ຈະ​ດໍາ​ລົງ​ຊີ​ວິດ​, ຫຼີກ​ເວັ້ນ​ການ​ຝູງ​ສັດ​ສະ​ແຕມ​.

ເຊົາ ໄດ້ arbiter ທັນທີ
ເມື່ອ arbiter ໄດ້ຮັບຄໍາສັ່ງນີ້, arbiter ອອກຈາກ.

ZMQ ຂໍ້ຄວາມ
{
"command": "ອອກ",
"ລໍຖ້າ": ບໍ່ຖືກຕ້ອງ
}

ການ​ຕອບ​ສະ​ຫນອງ​ກັບ​ຄືນ​ສະ​ຖາ​ນະ "ok​"​.

If ລໍຖ້າ ແມ່ນຜິດ (ຄ່າເລີ່ມຕົ້ນ), ການໂທຈະກັບຄືນມາທັນທີຫຼັງຈາກການໂທ stop_signal
ໃນແຕ່ລະຂະບວນການ.

If ລໍຖ້າ ແມ່ນແທ້, ການໂທຈະກັບຄືນມາພຽງແຕ່ເມື່ອຂະບວນການຢຸດແມ່ນສິ້ນສຸດລົງຢ່າງສົມບູນ.
ເນື່ອງຈາກຕົວເລືອກ graceful_timeout, ມັນສາມາດໃຊ້ເວລາບາງເວລາ.

ຄໍາສັ່ງ ອອນໄລນ໌
$ circusctl ເຊົາ [--ລໍຖ້າ]

ໂຫລດ ໄດ້ arbiter or a watcher
ຄຳສັ່ງນີ້ໂຫຼດຂະບວນການທັງໝົດໃນຕົວເບິ່ງ ຫຼືຕົວເບິ່ງທັງໝົດ. ນີ້ຈະເກີດຂຶ້ນໃນຫນຶ່ງ
ຂອງ 3 ວິ​ທີ​ການ​:

· ຖ້າ graceful ແມ່ນບໍ່ຖືກຕ້ອງ, restart ງ່າຍດາຍເກີດຂຶ້ນ.

· ຖ້າ send_hup ເປັນຄວາມຈິງສໍາລັບຜູ້ເບິ່ງ, ສັນຍານ HUP ຖືກສົ່ງໄປຫາແຕ່ລະຂະບວນການ.

·

ຖ້າບໍ່ດັ່ງນັ້ນ:

· ຖ້າລໍາດັບແມ່ນບໍ່ຖືກຕ້ອງ, ຜູ້ຕັດສິນຈະພະຍາຍາມວາງໄຂ່ ຂະ​ບວນ​ການ​ຈໍາ​ນວນ​ ໃຫມ່
ຂະບວນການ. ຖ້າຫາກວ່າຂະບວນການໃຫມ່ໄດ້ຖືກ spawned ສົບຜົນສໍາເລັດ, ຜົນໄດ້ຮັບແມ່ນ
ຂະບວນການເກົ່າທັງໝົດຖືກຢຸດ, ເພາະວ່າໂດຍຄ່າເລີ່ມຕົ້ນຂະບວນການເກົ່າແກ່ທີ່ສຸດແມ່ນ
ຢຸດເຊົາເມື່ອຈໍານວນຂະບວນການທີ່ແທ້ຈິງສໍາລັບຜູ້ເບິ່ງແມ່ນຫຼາຍກ່ວາ
ຂະ​ບວນ​ການ​ຈໍາ​ນວນ​.

· ຖ້າລໍາດັບແມ່ນຄວາມຈິງ, ຜູ້ຕັດສິນຈະເລີ່ມແຕ່ລະຂະບວນການຄືນໃໝ່ຕາມລໍາດັບ
ທາງ (ມີ ກ warmup_delay ຢຸດ​ຊົ່ວ​ຄາວ​ລະ​ຫວ່າງ​ແຕ່​ລະ​ຂັ້ນ​ຕອນ​)

ZMQ ຂໍ້ຄວາມ
{
"command": "ໂຫຼດໃໝ່",
"ຄຸນສົມບັດ": {
"ຊື່": ' ",
"ງາມ": ຈິງ,
"sequential": ຜິດ,
"ລໍຖ້າ": ບໍ່ຖືກຕ້ອງ
}
}

ການ​ຕອບ​ສະ​ຫນອງ​ກັບ​ຄືນ​ສະ​ຖາ​ນະ "ok​"​. ຖ້າຄຸນສົມບັດທີ່ສະຫງ່າງາມຖືກຕັ້ງໃຫ້ເປັນຈິງຂະບວນການ
ຈະ​ໄດ້​ຮັບ​ການ​ອອກ​ຢ່າງ​ສະ​ຫງ່າ​ງາມ​.

ຖ້າມີຊື່ຊັບສິນ, ຫຼັງຈາກນັ້ນການໂຫຼດຄືນຈະຖືກນໍາໃຊ້ກັບຜູ້ເບິ່ງ.

ຄໍາສັ່ງ ອອນໄລນ໌
$ circusctl reload [ ] [--terminate] [--ລໍຖ້າ]
[-- ລໍາດັບ]

ທາງເລືອກໃນການ
· : ຊື່ຂອງ watcher ໄດ້

· -- ຢຸດຕິ; ອອກຈາກ node ທັນທີ

ໂຫລດ ໄດ້ configuration ເອກະສານ
ຄໍາສັ່ງນີ້ໂຫຼດໄຟລ໌ການຕັ້ງຄ່າຄືນໃໝ່, ດັ່ງນັ້ນການປ່ຽນແປງໃນໄຟລ໌ການຕັ້ງຄ່າຈະເປັນ
ສະທ້ອນໃຫ້ເຫັນໃນການຕັ້ງຄ່າຂອງ circus ໄດ້.

ZMQ ຂໍ້ຄວາມ
{
"command": "reloadconfig",
"ລໍຖ້າ": ບໍ່ຖືກຕ້ອງ
}

ການ​ຕອບ​ສະ​ຫນອງ​ກັບ​ຄືນ​ສະ​ຖາ​ນະ "ok​"​. ຖ້າຄຸນສົມບັດທີ່ສະຫງ່າງາມຖືກຕັ້ງໃຫ້ເປັນຈິງຂະບວນການ
ຈະ​ໄດ້​ຮັບ​ການ​ອອກ​ຢ່າງ​ສະ​ຫງ່າ​ງາມ​.

ຄໍາສັ່ງ ອອນໄລນ໌
$ circusctl reloadconfig [--waiting]

ເລີ່ມ​ຕົ້ນ​ໃຫມ່ ໄດ້ arbiter or a watcher
ຄໍາສັ່ງນີ້ restart ຂະບວນການທັງຫມົດໃນ watcher ຫຼື watchers ທັງຫມົດ. Function ນີ້ງ່າຍດາຍ
ຢຸດຜູ້ເບິ່ງແລ້ວຣີສະຕາດມັນ.

ZMQ ຂໍ້ຄວາມ
{
"command": "restart",
"ຄຸນສົມບັດ": {
"ຊື່": " ",
"ລໍຖ້າ": ຜິດ,
"match": "[ງ່າຍດາຍ|glob|regex]"
}
}

ການ​ຕອບ​ສະ​ຫນອງ​ກັບ​ຄືນ​ສະ​ຖາ​ນະ "ok​"​.

ຖ້າມີຊື່ຊັບສິນ, ຫຼັງຈາກນັ້ນການໂຫຼດຄືນຈະຖືກນໍາໃຊ້ກັບຜູ້ເບິ່ງ.

If ລໍຖ້າ ແມ່ນຜິດ (ຄ່າເລີ່ມຕົ້ນ), ການໂທຈະກັບຄືນມາທັນທີຫຼັງຈາກການໂທ stop_signal
ໃນແຕ່ລະຂະບວນການ.

If ລໍຖ້າ ແມ່ນແທ້, ການໂທຈະກັບຄືນມາພຽງແຕ່ເມື່ອຂະບວນການ restart ຢ່າງສົມບູນ
ສິ້ນສຸດລົງ. ເນື່ອງຈາກຕົວເລືອກ graceful_timeout, ມັນສາມາດໃຊ້ເວລາບາງເວລາ.

ໄດ້ ການແຂ່ງຂັນ ພາລາມິເຕີສາມາດມີມູນຄ່າ ງ່າຍດາຍ ສໍາ​ລັບ​ການ​ປຽບ​ທຽບ​ສາຍ​, ໂລກ ສໍາ​ລັບ​ຕົວ​ແທນ​
ການຈັບຄູ່ (ຄ່າເລີ່ມຕົ້ນ) ຫຼື regex ສໍາລັບການຈັບຄູ່ regex.

ຄໍາສັ່ງ ອອນໄລນ໌
$ circusctl restart [name] [--waiting] [--match=simple|glob|regex]

ທາງເລືອກໃນການ
· : ຊື່ ຫຼືຮູບແບບຂອງຜູ້ເບິ່ງ

· : watcher match method

ເອົາ a watcher
ຄໍາສັ່ງນີ້ເອົາຜູ້ເບິ່ງແບບເຄື່ອນໄຫວຈາກຜູ້ຕັດສິນ. ຜູ້ເຝົ້າຍາມຢ່າງສະຫງ່າງາມ
ຢຸດໂດຍຄ່າເລີ່ມຕົ້ນ.

ZMQ ຂໍ້ຄວາມ
{
"ຄໍາສັ່ງ": "rm",
"ຄຸນສົມບັດ": {
"ຊື່": " ",
"nostop": ຜິດ,
"ລໍຖ້າ": ບໍ່ຖືກຕ້ອງ
}
}

ການ​ຕອບ​ສະ​ຫນອງ​ກັບ​ຄືນ​ສະ​ຖາ​ນະ "ok​"​.

If nostop ເປັນຄວາມຈິງ (ຄ່າເລີ່ມຕົ້ນ: False), ຂະບວນການສໍາລັບ watcher ຈະບໍ່ຖືກຢຸດ -
ແທນທີ່ຈະ watcher ພຽງແຕ່ຈະຖືກລືມໂດຍ circus ແລະຂະບວນການ watcher ຈະເປັນ
ຮັບຜິດຊອບສໍາລັບການຢຸດຕົນເອງ. ຖ້າ nostop ບໍ່ໄດ້ລະບຸ ຫຼືເປັນຜິດ, ຈາກນັ້ນ
ຂະບວນການ watcher ຈະຖືກຢຸດເຊົາຢ່າງສະຫງ່າງາມ.

If ລໍຖ້າ ແມ່ນບໍ່ຖືກຕ້ອງ (ຄ່າເລີ່ມຕົ້ນ), ການໂທຈະກັບຄືນມາທັນທີຫຼັງຈາກທີ່ເລີ່ມເອົາອອກ
ແລະຢຸດຜູ້ເບິ່ງທີ່ສອດຄ້ອງກັນ.

If ລໍຖ້າ ແມ່ນແທ້, ການໂທຈະກັບຄືນມາພຽງແຕ່ເມື່ອຂະບວນການໂຍກຍ້າຍແລະຢຸດ
ສິ້ນສຸດລົງຢ່າງສົມບູນ. ເນື່ອງຈາກຕົວເລືອກ graceful_timeout, ມັນສາມາດໃຊ້ເວລາບາງເວລາ.

ຄໍາສັ່ງ ອອນໄລນ໌
$ circusctl rm [--ລໍຖ້າ] [-- notop]

ທາງເລືອກໃນການ
· : ຊື່ຂອງ watcher ທີ່ຈະເອົາອອກ

· nostop: ບໍ່ຢຸດຂະບວນການ watcher, ພຽງແຕ່ເອົາ watcher ໄດ້

ທີ່ກໍານົດໄວ້ a watcher ທາງເລືອກ
ZMQ ຂໍ້ຄວາມ
{
"ຄໍາສັ່ງ": "ຕັ້ງ",
"ຄຸນສົມບັດ": {
"name": "nameofwatcher",
"ທາງເລືອກ": {
"key1": "val1",
..
}
"ລໍຖ້າ": ບໍ່ຖືກຕ້ອງ
}
}

ການ​ຕອບ​ສະ​ຫນອງ​ກັບ​ຄືນ​ສະ​ຖາ​ນະ "ok​"​. ເບິ່ງຕົວເລືອກຄໍາສັ່ງສໍາລັບບັນຊີລາຍຊື່ຂອງຄີທີ່ຈະຕັ້ງ.

ຄໍາສັ່ງ ອອນໄລນ໌
$ circusctl ຕັ້ງ --ລໍຖ້າ

ສົ່ງ a signal
ຄໍາສັ່ງນີ້ຊ່ວຍໃຫ້ທ່ານສາມາດສົ່ງສັນຍານໄປຫາຂະບວນການທັງຫມົດໃນ watcher, ຂະບວນການສະເພາະ
ໃນ watcher ຫຼືເດັກນ້ອຍຂອງມັນ.

ZMQ ຂໍ້ຄວາມ
ເພື່ອສົ່ງສັນຍານໄປຫາຂະບວນການທັງຫມົດສໍາລັບຜູ້ເບິ່ງ:

{
"ຄໍາສັ່ງ": "ສັນຍານ",
"ຄຸນ​ສົມ​ບັດ": {
"ຊື່": ,
"ເຊັນ":
}

ເພື່ອສົ່ງສັນຍານໄປຫາຂະບວນການ:

{
"ຄໍາສັ່ງ": "ສັນຍານ",
"ຄຸນ​ສົມ​ບັດ": {
"ຊື່": ,
"pid": ,
"ເຊັນ":
}

ຄຸນສົມບັດທາງເລືອກ "ເດັກນ້ອຍ" ສາມາດຖືກນໍາໃຊ້ເພື່ອສົ່ງສັນຍານໃຫ້ເດັກນ້ອຍທັງຫມົດແທນທີ່ຈະ
ກ​່​ວາ​ຂະ​ບວນ​ການ​ຂອງ​ຕົນ​ເອງ​:

{
"ຄໍາສັ່ງ": "ສັນຍານ",
"ຄຸນ​ສົມ​ບັດ": {
"ຊື່": ,
"pid": ,
"ເຊັນ": ,
"ເດັກນ້ອຍ": ຄວາມຈິງ
}

ເພື່ອສົ່ງສັນຍານໄປຫາລູກຂະບວນການ:

{
"ຄໍາສັ່ງ": "ສັນຍານ",
"ຄຸນ​ສົມ​ບັດ": {
"ຊື່": ,
"pid": ,
"ເຊັນ": ,
"child_pid": ,
}

ມັນຍັງສາມາດສົ່ງສັນຍານໄປຫາເດັກນ້ອຍທັງຫມົດຂອງ watcher ໄດ້:

{
"ຄໍາສັ່ງ": "ສັນຍານ",
"ຄຸນ​ສົມ​ບັດ": {
"ຊື່": ,
"ເຊັນ": ,
"ເດັກນ້ອຍ": ຄວາມຈິງ
}

ສຸດທ້າຍ, ທ່ານສາມາດສົ່ງສັນຍານໄປຫາຂະບວນການ ແລະ ເດັກນ້ອຍຂອງຕົນ, ກັບ ຮຽກຮ້ອງ ຕົວເລືອກ:

{
"ຄໍາສັ່ງ": "ສັນຍານ",
"ຄຸນ​ສົມ​ບັດ": {
"ຊື່": ,
"ເຊັນ": ,
"recursive": ຖືກ
}

ຄໍາສັ່ງ ອອນໄລນ໌
$ circusctl ສັນຍານ [ ] [-- ເດັກ​ນ້ອຍ​]
[-- ຊໍ້າຄືນ]

ຕົວເລືອກ:
· : ຊື່ຂອງ watcher ໄດ້

· : integer, the process id.

· : ໝາຍເລກສັນຍານ (ຫຼືຊື່) ທີ່ຈະສົ່ງ.

· : pid ຂອງເດັກນ້ອຍ, ຖ້າມີ

· : boolean, ສົ່ງສັນຍານໃຫ້ເດັກນ້ອຍທັງຫມົດ

· : boolean, ສົ່ງສັນຍານກັບຂະບວນການແລະລູກຂອງມັນ

ເລີ່ມຕົ້ນ ໄດ້ arbiter or a watcher
ຄໍາສັ່ງນີ້ເລີ່ມຕົ້ນຂະບວນການທັງຫມົດໃນ watcher ຫຼື watchers ທັງຫມົດ.

ZMQ ຂໍ້ຄວາມ
{
"ຄໍາສັ່ງ": "ເລີ່ມຕົ້ນ",
"ຄຸນສົມບັດ": {
"ຊື່": ' ",
"ລໍຖ້າ": ຜິດ,
"match": "[ງ່າຍດາຍ|glob|regex]"
}
}

ການ​ຕອບ​ສະ​ຫນອງ​ກັບ​ຄືນ​ສະ​ຖາ​ນະ "ok​"​.

ຖ້າມີຊື່ຊັບສິນ, ຜູ້ເບິ່ງຈະຖືກເລີ່ມຕົ້ນ.

If ລໍຖ້າ ແມ່ນຜິດ (ຄ່າເລີ່ມຕົ້ນ), ການໂທຈະກັບຄືນມາທັນທີຫຼັງຈາກການໂທ ການເລີ່ມຕົ້ນ on
ແຕ່ລະຂະບວນການ.

If ລໍຖ້າ ແມ່ນແທ້, ການໂທຈະກັບຄືນມາພຽງແຕ່ເມື່ອຂະບວນການເລີ່ມຕົ້ນສິ້ນສຸດລົງຢ່າງສົມບູນ.
ເນື່ອງຈາກຕົວເລືອກ graceful_timeout, ມັນສາມາດໃຊ້ເວລາບາງເວລາ.

ໄດ້ ການແຂ່ງຂັນ ພາລາມິເຕີສາມາດມີມູນຄ່າ ງ່າຍດາຍ ສໍາ​ລັບ​ການ​ປຽບ​ທຽບ​ສາຍ​, ໂລກ ສໍາ​ລັບ​ຕົວ​ແທນ​
ການຈັບຄູ່ (ຄ່າເລີ່ມຕົ້ນ) ຫຼື regex ສໍາລັບການຈັບຄູ່ regex.

ຄໍາສັ່ງ ອອນໄລນ໌
$ circusctl restart [name] [--waiting] [--match=simple|glob|regex]

ທາງເລືອກໃນການ
· : ຊື່ ຫຼືຮູບແບບຂອງຜູ້ເບິ່ງ

· : watcher match method

ໄດ້ຮັບ ຂະບວນການ ຂໍ້ມູນຂ່າວສານ
ທ່ານສາມາດໄດ້ຮັບສະຖິຕິກ່ຽວກັບຂະບວນການຂອງທ່ານໄດ້ທຸກເວລາດ້ວຍຄໍາສັ່ງສະຖິຕິ.

ZMQ ຂໍ້ຄວາມ
ເພື່ອຮັບເອົາສະຖິຕິສຳລັບຜູ້ເບິ່ງທັງໝົດ:

{
"ຄໍາສັ່ງ": "ສະຖິຕິ"
}

ເພື່ອໃຫ້ໄດ້ຮັບສະຖິຕິສໍາລັບຜູ້ເບິ່ງ:

{
"ຄໍາສັ່ງ": "ສະຖິຕິ",
"ຄຸນສົມບັດ": {
"ຊື່":
}
}

ເພື່ອໃຫ້ໄດ້ຮັບສະຖິຕິສໍາລັບຂະບວນການ:

{
"ຄໍາສັ່ງ": "ສະຖິຕິ",
"ຄຸນສົມບັດ": {
"ຊື່": ,
"ຂະບວນການ":
}
}

ສະຖິຕິສາມາດຂະຫຍາຍໄດ້ດ້ວຍຕົວຍຶດຂອງ extended_stats ແຕ່ສະຖິຕິການຂະຫຍາຍຈະຕ້ອງເປັນ
ຮ້ອງຂໍ:

{
"ຄໍາສັ່ງ": "ສະຖິຕິ",
"ຄຸນສົມບັດ": {
"ຊື່": ,
"ຂະບວນການ": ,
"ຂະຫຍາຍ": ຖືກ
}
}

ການຕອບໂຕ້ຄືນວັດຖຸຕໍ່ຂະບວນການດ້ວຍຄຸນສົມບັດ "ຂໍ້ມູນ" ທີ່ມີບາງຂະບວນການ
ຂໍ້ມູນ:

{
"ຂໍ້ມູນ": {
"ເດັກນ້ອຍ": [],
"cmdline": "python",
"cpu": 0.1,
"ctime": "0:00.41",
"mem": 0.1,
"mem_info1": "3M",
"mem_info2": "2G",
"ງາມ": 0,
"pid": 47864, ສ.
"ຊື່ຜູ້ໃຊ້": "ຮາກ"
},
"ຂະບວນການ": 5,
"ສະຖານະ": "ຕົກລົງ",
"ເວລາ": 1332265655.897085
}

ຄໍາສັ່ງ ອອນໄລນ໌
$ circusctl ສະຖິຕິ [--extended] [ ] [ ]

ໄດ້ຮັບ ໄດ້ ສະຖານະພາບ of a watcher or ທັງຫມົດ watchers
ຄໍາສັ່ງນີ້ເລີ່ມຕົ້ນໄດ້ຮັບສະຖານະພາບຂອງ watcher ຫຼື watchers ທັງຫມົດ.

ZMQ ຂໍ້ຄວາມ
{
"ຄໍາສັ່ງ": "ສະຖານະ",
"ຄຸນສົມບັດ": {
"ຊື່": ' ",
}
}

ການຕອບສະຫນອງກັບຄືນສະຖານະ "ການເຄື່ອນໄຫວ" ຫຼື "ຢຸດ" ຫຼືສະຖານະພາບ / ຜູ້ເບິ່ງ.

ຄໍາສັ່ງ ອອນໄລນ໌
ສະຖານະ $ circusctl [ ]

ທາງເລືອກໃນການ
· : ຊື່ຂອງ watcher ໄດ້

ຍົກຕົວຢ່າງ
$ circusctl ສະຖານະພາບ dummy
ການເຄື່ອນໄຫວ
$ circusctl ສະຖານະພາບ
dummy: ຫ້າວຫັນ
dummy2: ມີການເຄື່ອນໄຫວ
ອົບພະຍົກ: ການເຄື່ອນໄຫວ

ຢຸດ watchers
ຄຳສັ່ງນີ້ຢຸດຜູ້ເບິ່ງທີ່ໃຫ້ ຫຼືຜູ້ເບິ່ງທັງໝົດ.

ZMQ ຂໍ້ຄວາມ
{
"ຄໍາສັ່ງ": "ຢຸດ",
"ຄຸນສົມບັດ": {
"ຊື່": " ",
"ລໍຖ້າ": ຜິດ,
"match": "[ງ່າຍດາຍ|glob|regex]"
}
}

ການ​ຕອບ​ສະ​ຫນອງ​ກັບ​ຄືນ​ສະ​ຖາ​ນະ "ok​"​.

ຖ້າ ຊື່ ຊັບສິນແມ່ນມີຢູ່, ຫຼັງຈາກນັ້ນການຢຸດຈະຖືກນໍາໃຊ້ກັບຜູ້ເບິ່ງ
ທີ່​ສອດ​ຄ້ອງ​ກັນ​ກັບ​ຊື່​ນັ້ນ​. ຖ້າບໍ່ດັ່ງນັ້ນ, ຜູ້ເບິ່ງທັງໝົດຈະຖືກຢຸດ.

If ລໍຖ້າ ແມ່ນຜິດ (ຄ່າເລີ່ມຕົ້ນ), ການໂທຈະກັບຄືນມາທັນທີຫຼັງຈາກການໂທ stop_signal
ໃນແຕ່ລະຂະບວນການ.

If ລໍຖ້າ ແມ່ນແທ້, ການໂທຈະກັບຄືນມາພຽງແຕ່ເມື່ອຂະບວນການຢຸດໄດ້ສິ້ນສຸດລົງຢ່າງສົມບູນ.
ເນື່ອງຈາກຕົວເລືອກ graceful_timeout, ມັນສາມາດໃຊ້ເວລາບາງເວລາ.

ໄດ້ ການແຂ່ງຂັນ ພາລາມິເຕີສາມາດມີມູນຄ່າ ງ່າຍດາຍ ສໍາ​ລັບ​ການ​ປຽບ​ທຽບ​ສາຍ​, ໂລກ ສໍາ​ລັບ​ຕົວ​ແທນ​
ການຈັບຄູ່ (ຄ່າເລີ່ມຕົ້ນ) ຫຼື regex ສໍາລັບການຈັບຄູ່ regex.

ຄໍາສັ່ງ ອອນໄລນ໌
$ circusctl stop [name] [--waiting] [--match=simple|glob|regex]

ທາງເລືອກໃນການ
· : ຊື່ ຫຼືຮູບແບບຂອງຜູ້ເບິ່ງ

· : watcher match method

CLI ເຄື່ອງ​ມື
circus-top
circus-top ເປັນ console ຄ້າຍຄືເທິງທີ່ທ່ານສາມາດແລ່ນເພື່ອເບິ່ງການດໍາລົງຊີວິດລະບົບ Circus ຂອງທ່ານ. ມັນ
ຈະສະແດງ CPU, ການນໍາໃຊ້ຫນ່ວຍຄວາມຈໍາແລະ socket hits ຖ້າທ່ານມີບາງ.

ຕົວຢ່າງຂອງຜົນຜະລິດ:

-------------------------------------------------- ---------------------
circusd-ສະຖິຕິ
CPU PID (%) ຄວາມຈຳ (%)
+14252 0.8 0.4
0.8 (ສະເລ່ຍ) 0.4 (ລວມ)

dummy
CPU 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 (ລວມ)

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

circus-top ເປັນ console ອ່ານເທົ່ານັ້ນ. ຖ້າທ່ານຕ້ອງການພົວພັນກັບລະບົບ, ໃຊ້ circusctl.

circusctl
circusctl ສາມາດຖືກນໍາໃຊ້ເພື່ອດໍາເນີນການຄໍາສັ່ງໃດໆທີ່ຢູ່ໃນຄໍາສັ່ງ . ຕົວຢ່າງ, ທ່ານສາມາດໄດ້ຮັບ a
ບັນຊີລາຍຊື່ຂອງ watchers ທັງຫມົດ, ທ່ານສາມາດເຮັດໄດ້

$ circusctl ບັນຊີລາຍຊື່

ນອກ​ຈາກ​ການ​ສະ​ຫນັບ​ສະ​ຫນູນ​ມື​ຂອງ​ທາງ​ເລືອກ​ທີ່​ທ່ານ​ຍັງ​ສາ​ມາດ​ລະ​ບຸ​ຈຸດ​ສຸດ​ທ້າຍ​ໄດ້​ circusctl ຄວນ
ໃຊ້​ການ​ນໍາ​ໃຊ້​ CIRCUSCTL_ENDPOINT environment variable

ໄດ້ ເວັບໄຊຕ໌ console
Circus ມາພ້ອມກັບ Web Console ທີ່ສາມາດຖືກນໍາໃຊ້ເພື່ອຈັດການລະບົບ.

Web Console ໃຫ້ທ່ານ:

· ເຊື່ອມ​ຕໍ່​ກັບ​ລະ​ບົບ Circus ໃດ​

·ສັງເກດເບິ່ງຂະບວນການ CPU ແລະການນໍາໃຊ້ຫນ່ວຍຄວາມຈໍາໃນເວລາຈິງ

·ເພີ່ມຫຼືຂ້າຂະບວນການ

·ເພີ່ມຜູ້ເບິ່ງໃຫມ່

ຫມາຍ​ເຫດ​:
ຄຸນສົມບັດການນຳໃຊ້ CPU ແລະໜ່ວຍຄວາມຈຳແບບສົດໆໃຊ້ຊັອກເກັດສະຖິຕິ. ຖ້າທ່ານຕ້ອງການ
ເປີດໃຊ້ມັນ, ໃຫ້ແນ່ໃຈວ່າລະບົບ Circus ທີ່ທ່ານຈະເຊື່ອມຕໍ່ມີສະຖິຕິ
ເປີດໃຊ້ໃນການຕັ້ງຄ່າຂອງມັນ:

[ວົງດົນຕີ]
statsd = ຄວາມຈິງ

ໂດຍຄ່າເລີ່ມຕົ້ນ, ຕົວເລືອກນີ້ບໍ່ໄດ້ຖືກເປີດໃຊ້.

web console ແມ່ນຊຸດຂອງຕົນເອງ, ທ່ານຈໍາເປັນຕ້ອງຕິດຕັ້ງ:

$ pip ຕິດຕັ້ງ circus-web

ເພື່ອເປີດໃຊ້ console, ໃຫ້ເພີ່ມບາງທາງເລືອກໃນໄຟລ໌ Circus ini:

[ວົງດົນຕີ]
httpd = ຄວາມຈິງ
httpd_host = localhost
httpd_port = 8080

httpd_host ແລະ httpd_port ເປັນທາງເລືອກ, ແລະຄ່າເລີ່ມຕົ້ນທີ່ຈະ localhost ແລະ 8080.

ຖ້າທ່ານຕ້ອງການທີ່ຈະດໍາເນີນການ app ເວັບຂອງຕົນເອງ, ພຽງແຕ່ດໍາເນີນການ circushttpd ອັກສອນ:

$ circushttpd
ເຊີບເວີຂວດເລີ່ມຕົ້ນ...
ກຳລັງຟັງຢູ່ http://localhost: 8080 /
ກົດ Ctrl-C ເພື່ອອອກ.

ໂດຍຄ່າເລີ່ມຕົ້ນ script ຈະແລ່ນ Web Console ໃນພອດ 8080, ແຕ່ທາງເລືອກ --port ສາມາດເປັນ.
ເຄີຍປ່ຽນມັນ.

ການນໍາໃຊ້ ໄດ້ console
ເມື່ອສະຄຣິບຖືກແລ່ນ, ທ່ານສາມາດເປີດຕົວທ່ອງເວັບແລະໄປຢ້ຽມຢາມ http://localhost: 8080ທີ່ຢູ່ ທ່ານ
ຄວນໄດ້ຮັບຫນ້າຈໍນີ້: [ຮູບ]

Web Console ແມ່ນພ້ອມທີ່ຈະເຊື່ອມຕໍ່ກັບລະບົບ Circus, ໂດຍໃຫ້ມັນ endpoint. ໂດຍ
ຄ່າເລີ່ມຕົ້ນຈຸດສິ້ນສຸດແມ່ນ tcp://127.0.0.1:5555.

ເມື່ອທ່ານຕີ ເຊື່ອມຕໍ່, ຄໍາຮ້ອງສະຫມັກເວັບໄຊຕ໌ຈະເຊື່ອມຕໍ່ກັບລະບົບ Circus.

ດ້ວຍ Web Console ເຂົ້າສູ່ລະບົບ, ທ່ານຄວນໄດ້ຮັບລາຍຊື່ຜູ້ເບິ່ງ, ແລະສະຖານະໃນເວລາຈິງ
ຂອງສອງຂະບວນການ Circus (circusd ແລະ circusd-stats).

ທ່ານສາມາດຄລິກໃສ່ສະຖານະຂອງແຕ່ລະ watcher ເພື່ອສະຫຼັບມັນຈາກ ການເຄື່ອນໄຫວ (ສີຂຽວ) ກັບ Inactive
(ສີແດງ). ການ​ປ່ຽນ​ແປງ​ນີ້​ມີ​ປະ​ສິດ​ທິ​ຜົນ​ໃນ​ທັນ​ທີ​ແລະ​ໃຫ້​ທ່ານ​ເລີ່ມ​ຕົ້ນ & ຢຸດ​ເຊົາ​ການ​ເບິ່ງ​.

ຖ້າທ່ານຄລິກໃສ່ຊື່ watcher, ທ່ານຈະໄດ້ຮັບຫນ້າເວັບສໍາລັບ watcher ໂດຍສະເພາະ,
ກັບ​ຂະ​ບວນ​ການ​ຂອງ​ຕົນ​:

ໃນຫນ້າຈໍນີ້, ທ່ານສາມາດເພີ່ມຫຼືເອົາຂະບວນການ, ແລະຂ້າອັນທີ່ມີຢູ່ແລ້ວ.

ສຸດ​ທ້າຍ​ແຕ່​ບໍ່​ໄດ້​ຢ່າງ​ຫນ້ອຍ​, ທ່ານ​ສາ​ມາດ​ເພີ່ມ​ຍີ່​ຫໍ້ watcher ໃຫມ່​ໂດຍ​ການ​ຄລິກ​ໃສ່​ ຕື່ມ ຜູ້ເບິ່ງ ເຊື່ອມຕໍ່ໃນ
ເມນູດ້ານຊ້າຍ: .SS ແລ່ນຢູ່ຫລັງ Nginx

Nginx ສາມາດເຮັດຫນ້າທີ່ເປັນຕົວແທນແລະຊັ້ນຄວາມປອດໄພຢູ່ທາງຫນ້າຂອງ circus-web.

ຫມາຍ​ເຫດ​:
ເພື່ອໃຫ້ໄດ້ຮັບການອັບເດດສະຖານະພາບເວລາຈິງແລະກາຟໃນ circus-web, ທ່ານຕ້ອງໃຫ້ Nginx
ການແກ້ໄຂຕົວແທນທີ່ມີການສະຫນັບສະຫນູນ websocket

Nginx >= 1.3.13
ໃນຖານະເປັນຂອງ Nginx>=1.3.13 websocket ສະຫນັບສະຫນູນແມ່ນສ້າງໃນ, ດັ່ງນັ້ນບໍ່ຈໍາເປັນຕ້ອງສົມທົບ Nginx.
ດ້ວຍ Varnish ຫຼື HAProxy. ຕົວຢ່າງ Nginx config ທີ່ມີການສະຫນັບສະຫນູນ websocket:

ເທິງນ້ໍາ circusweb_server {
ເຊີບເວີ 127.0.0.1:8080;
}

ເຊີບເວີ {
ຟັງ 80;
server_name _;

ສະຖານທີ່ / {
proxy_pass http://circusweb_server;
proxy_http_version 1.1;
proxy_set_header ອັບເກຣດ $http_upgrade;
ການເຊື່ອມຕໍ່ proxy_set_header "ຍົກລະດັບ";
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto http;
proxy_redirect off;
}

ສະຖານທີ່ ~/media/\*.png|.jpg|.css|.js|.ico)$ {
alias /path_to_site-packages/circusweb/media/;
}
}

Nginx < 1.3.13
ລຸ້ນ Nginx < 1.3.13 ບໍ່ມີການຮອງຮັບ websocket ໃນຕົວ.

ເພື່ອສະຫນອງການສະຫນັບສະຫນູນ websocket ສໍາລັບ circus-web ໃນເວລາທີ່ການນໍາໃຊ້ Nginx < 1.3.13, ທ່ານສາມາດສົມທົບ.
Nginx ກັບ varnish ຫຼື HAProxy. ນັ້ນແມ່ນ, Nginx ຢູ່ທາງຫນ້າຂອງ circus-web, ດ້ວຍ Varnish ຫຼື
HAProxy ຢູ່ທາງຫນ້າຂອງ Nginx.

ຕົວຢ່າງຂ້າງລຸ່ມນີ້ສະແດງໃຫ້ເຫັນການຕັ້ງຄ່າ Nginix ແລະ Varnish ປະສົມປະສານທີ່ຕ້ອງການເພື່ອຕົວແທນ
circus-web ແລະສະຫນອງການສະຫນັບສະຫນູນ websocket.

Nginx ການຕັ້ງຄ່າ:

ເທິງນ້ໍາ circusweb_server {
ເຊີບເວີ 127.0.0.1:8080;
}

ເຊີບເວີ {
ຟັງ 8001;
server_name _;

ສະຖານທີ່ / {
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header Host $http_host;
proxy_redirect off;
proxy_pass http://circusweb_server;
}

ສະຖານທີ່ ~/media/\*.png|.jpg|.css|.js|.ico)$ {
alias /path_to_site-packages/circusweb/media/;
}
}

ຖ້າທ່ານຕ້ອງການຕົວເລືອກການຕັ້ງຄ່າ Nginx ເພີ່ມເຕີມ, ເບິ່ງ http://wiki.nginx.org/HttpProxyModule.

Varnish ການຕັ້ງຄ່າ:

backend ຄ່າເລີ່ມຕົ້ນ {
.host = "127.0.0.1" ;
.port = "8001" ;
}

ຊັອກເກັດ backend {
.host = "127.0.0.1" ;
.port = "8080" ;
.connect_timeout = 1s;
.first_byte_timeout = 2s;
.between_bytes_timeout = 60s;
}

ຍ່ອຍ vcl_pipe {
ຖ້າ (req.http.upgrade) {
set bereq.http.upgrade = req.http.upgrade;
}
}

ຍ່ອຍ vcl_recv {
ຖ້າ (req.http.Upgrade ~ "(?i)websocket") {
set req.backend = ເຕົ້າຮັບ;
ກັບຄືນ (ທໍ່);
}
}

ໃນຕົວຢ່າງການຕັ້ງຄ່າ Varnish ຂ້າງເທິງສອງ backends ຖືກກໍານົດ. ຫນຶ່ງໃຫ້ບໍລິການເວັບໄຊຕ໌
console ແລະຫນຶ່ງໃຫ້ບໍລິການການເຊື່ອມຕໍ່ socket. ການຮ້ອງຂໍ web console ແມ່ນຜູກມັດກັບພອດ
8001. ຄໍາສັ່ງ 'ເຊີບເວີ' ​​ຂອງ Nginx ຄວນຖືກຕັ້ງຄ່າເພື່ອຟັງຢູ່ໃນພອດ 8001.

ການ​ເຊື່ອມ​ຕໍ່ Websocket ຖືກ​ປັບ​ປຸງ​ແລະ​ທໍ່​ໂດຍ​ກົງ​ກັບ​ການ​ຟັງ​ຂະ​ບວນ​ການ circushttpd​
ໃນພອດ 8080 ໂດຍ Varnish. ເຊັ່ນ: ການຂ້າມພຣັອກຊີ Nginx.

Ubuntu
ຕັ້ງ​ແຕ່​ສະ​ບັບ 13.10 (ຊອດຊີ), Ubuntu ປະກອບມີ Nginx ທີ່ມີການສະຫນັບສະຫນູນ websocket ໃນຕົວຂອງມັນເອງ
ບ່ອນເກັບມ້ຽນ. ສໍາລັບລຸ້ນເກົ່າ, ທ່ານສາມາດຕິດຕັ້ງ Nginx>=1.3.13 ຈາກ Nginx ຢ່າງເປັນທາງການ
PPA ຄົງທີ່, ດັ່ງນັ້ນ:

sudo apt-get ຕິດຕັ້ງ python-software-properties
sudo add-apt-repository ppa:nginx/stable
sudo apt-get update
sudo apt-get ຕິດຕັ້ງ nginx
nginx-v

ປ້ອງກັນລະຫັດຜ່ານ circushttpd
ດັ່ງທີ່ໄດ້ອະທິບາຍໄວ້ໃນຫນ້າຄວາມປອດໄພ, ແລ່ນ circushttpd ແມ່ນບໍ່ປອດໄພຫຼາຍ. ພວກເຮົາບໍ່ໃຫ້
ຄວາມປອດໄພໃດໆໃນ Circus ຕົວຂອງມັນເອງ, ແຕ່ທ່ານສາມາດປົກປ້ອງ console ຂອງທ່ານໃນລະດັບ NGinx, ໂດຍ
ການນໍາໃຊ້ http://wiki.nginx.org/HttpAuthBasicModule

ຕົວຢ່າງ:

ສະຖານທີ່ / {
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header Host $http_host;
proxy_set_header X-Forwarded-Host: $http_host;
proxy_set_header X-Forwarded-Proto: $scheme;
proxy_redirect off;
proxy_pass http://127.0.0.1: 8080;
auth_basic "ຖືກຈຳກັດ";
auth_basic_user_file /path/to/htpasswd;
}

ໄດ້ htpasswd ໄຟລ໌ມີຜູ້ໃຊ້ ແລະລະຫັດຜ່ານຂອງເຂົາເຈົ້າ, ແລະການເຕືອນລະຫັດຜ່ານຈະປາກົດຂຶ້ນເມື່ອໃດ
ທ່ານເຂົ້າເຖິງ console ໄດ້.

ທ່ານສາມາດນໍາໃຊ້ສະຄິບ htpasswd ຂອງ Apache ເພື່ອແກ້ໄຂມັນ, ຫຼືສະຄິບ Python ທີ່ພວກເຂົາໃຫ້ຢູ່ທີ່:
http://trac.edgewall.org/browser/trunk/contrib/htpasswd.py

ຢ່າງໃດກໍ່ຕາມ, ບໍ່ມີການສະຫນັບສະຫນູນພື້ນເມືອງສໍາລັບການນໍາໃຊ້ປະສົມປະສານຂອງ HTTP Authentication ແລະ
WebSockets (ເຄື່ອງແມ່ຂ່າຍຈະຖິ້ມລະຫັດຂໍ້ຜິດພາດ HTTP 401). ການແກ້ໄຂບັນຫາແມ່ນການປິດການໃຊ້ງານດັ່ງກ່າວ
ການກວດສອບຄວາມຖືກຕ້ອງສໍາລັບເຄື່ອງແມ່ຂ່າຍ socket.io.

ຕົວຢ່າງ (ຕ້ອງການເພີ່ມກ່ອນກົດລະບຽບທີ່ຜ່ານມາ):

ສະຖານທີ່ /socket.io {
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header Host $http_host;
proxy_set_header X-Forwarded-Host: $http_host;
proxy_set_header X-Forwarded-Proto: $scheme;
proxy_redirect off;
proxy_pass http://127.0.0.1: 8080;
}

ແນ່ນອນວ່າມັນເປັນພຽງວິທີດຽວເພື່ອປົກປ້ອງ web console ຂອງທ່ານ, ທ່ານສາມາດນໍາໃຊ້ຫຼາຍອັນ
ເຕັກນິກ.

ການຂະຫຍາຍ ໄດ້ ເວັບໄຊຕ໌ console
ພວກເຮົາເລືອກ ແກ້ວ ເພື່ອສ້າງ webconsole, ສ່ວນໃຫຍ່ແມ່ນຍ້ອນວ່າມັນເປັນກອບຂະຫນາດນ້ອຍແທ້ໆ
ບໍ່ໄດ້ເຮັດຫຍັງຫຼາຍ. ໂດຍການເບິ່ງລະຫັດຂອງ web console, ໃນທີ່ສຸດເຈົ້າຈະພົບເຫັນ
ອອກວ່າມັນງ່າຍແທ້ໆທີ່ຈະເຂົ້າໃຈ.

ນີ້ແມ່ນວິທີການແບ່ງອອກ:

·ທ circushttpd.py ໄຟລ໌ປະກອບມີຄໍານິຍາມ "ເບິ່ງ" ແລະບາງລະຫັດເພື່ອຈັດການ
ການເຊື່ອມຕໍ່ socket (ຜ່ານ socketio).

· ໄດ້ controller.py ປະກອບມີຫ້ອງຮຽນດຽວທີ່ຮັບຜິດຊອບໃນການສື່ສານ
ກັບຜູ້ຄວບຄຸມ circus. ມັນອະນຸຍາດໃຫ້ມີ API ລະດັບສູງທີ່ງາມກວ່າເມື່ອກໍານົດ
ເຊີບເວີເວັບ.

ຖ້າທ່ານຕ້ອງການເພີ່ມຄຸນສົມບັດໃນ web console ທ່ານສາມາດໃຊ້ລະຫັດທີ່ມີຢູ່ກ່ອນແລ້ວ. ກ
ເຄື່ອງ​ມື​ຈໍາ​ນວນ​ຫນຶ່ງ​ແມ່ນ​ຢູ່​ໃນ​ການ​ກໍາ​ຈັດ​ຂອງ​ທ່ານ​ເພື່ອ​ຜ່ອນ​ຄາຍ​ຂະ​ບວນ​ການ​:

· ມີ render_template function, ເຊິ່ງໃຊ້ເວລາການໂຕ້ຖຽງທີ່ມີຊື່ທີ່ທ່ານຜ່ານໄປຫາມັນແລະ
ສົ່ງພວກມັນໄປຫາຕົວສະແດງແມ່ແບບແລະສົ່ງຄືນ HTML ຜົນໄດ້ຮັບ. ມັນຍັງຜ່ານບາງ
ຕົວແປເພີ່ມເຕີມ, ເຊັ່ນ session, ສະບັບ circus ແລະລູກຄ້າຖ້າຫາກວ່າກໍານົດ.

· ຖ້າ​ຫາກ​ວ່າ​ທ່ານ​ຕ້ອງ​ການ​ທີ່​ຈະ​ດໍາ​ເນີນ​ການ​ຄໍາ​ສັ່ງ​ແລະ doa redirection ໂດຍ​ອີງ​ຕາມ​ຜົນ​ຂອງ​ມັນ​, ທ່ານ​ສາ​ມາດ​ນໍາ​ໃຊ້​
ໄດ້ run_command function, ເຊິ່ງໃຊ້ເວລາ callable ເປັນ argument ທໍາອິດ, ຂໍ້ຄວາມໃນກໍລະນີ
ຂອງຄວາມສໍາເລັດແລະ url ການປ່ຽນເສັ້ນທາງ.

ໄດ້ StatsNamespace ຫ້ອງຮຽນມີຄວາມຮັບຜິດຊອບໃນການຄຸ້ມຄອງການສື່ສານ websocket ກ່ຽວກັບ
ດ້ານເຊີບເວີ. ເອກະສານຂອງມັນຄວນຈະຊ່ວຍໃຫ້ທ່ານເຂົ້າໃຈສິ່ງທີ່ມັນເຮັດ.

ການເຮັດວຽກ ກັບ ເຕົ້າຮັບ
Circus ສາ​ມາດ​ຜູກ​ມັດ​ເຕົ້າ​ຮັບ​ເຄືອ​ຂ່າຍ​ແລະ​ການ​ຄຸ້ມ​ຄອງ​ພວກ​ເຂົາ​ເປັນ​ມັນ​ເຮັດ​ສໍາ​ລັບ​ຂະ​ບວນ​ການ​.

ແນວຄວາມຄິດຕົ້ນຕໍແມ່ນວ່າຂະບວນການເດັກນ້ອຍທີ່ສ້າງຂຶ້ນໂດຍ Circus ເພື່ອດໍາເນີນການຫນຶ່ງຂອງ watcher ໄດ້
ຄໍາສັ່ງສາມາດສືບທອດມາຈາກຕົວອະທິບາຍໄຟລ໌ທີ່ເປີດທັງຫມົດ.

ນັ້ນແມ່ນວິທີທີ່ Apache ຫຼື Unicorn ເຮັດວຽກ, ແລະເຄື່ອງມືອື່ນໆຈໍານວນຫຼາຍຢູ່ທີ່ນັ້ນ.

ເປົ້າຫມາຍຂອງ
ເປົ້າຫມາຍຂອງການມີເຕົ້າຮັບທີ່ຄຸ້ມຄອງໂດຍ Circus ແມ່ນເພື່ອສາມາດຈັດການຄໍາຮ້ອງສະຫມັກເຄືອຂ່າຍ
ໃນ Circus ຄືກັນກັບຄໍາຮ້ອງສະຫມັກອື່ນໆ.

ຕົວຢ່າງ, ຖ້າທ່ານໃຊ້ Circus ກັບ ຖົງຕີນ -- ເຊີບເວີ WGSI, ທ່ານສາມາດໄດ້ຮັບຄວາມໄວຫຼາຍ
ເຊີບເວີເວັບແລ່ນ ແລະຈັດການ "ເວັບ ຄົນງານ" ໃນ Circus ດັ່ງທີ່ເຈົ້າຈະເຮັດສໍາລັບການອື່ນໆ
ຂະບວນການ.

Spliting socket ການຄຸ້ມຄອງຈາກຄໍາຮ້ອງສະຫມັກເຄືອຂ່າຍຕົວມັນເອງສະເຫນີຫຼາຍ
ໂອກາດທີ່ຈະຂະຫຍາຍແລະຈັດການ stack ຂອງທ່ານ.

ການອອກແບບ
gist ຂອງຄຸນນະສົມບັດແມ່ນເຮັດໄດ້ໂດຍການຜູກມັດເຕົ້າຮັບແລະເລີ່ມຕົ້ນຟັງມັນໃນ
ວົງວຽນ:

ເຕົ້າຮັບການ ນຳ ເຂົ້າ

sock = socket.socket(ຄອບຄົວ, ປະເພດ)
sock.bind((HOST, PORT))
sock.listen(BACKLOG)
fd = sock.fileno()

ຫຼັງຈາກນັ້ນ, Circus ຕິດຕາມ fds ທີ່ເປີດທັງຫມົດ, ແລະປ່ອຍໃຫ້ຂະບວນການທີ່ມັນດໍາເນີນການເປັນເດັກນ້ອຍ
ມີການເຂົ້າເຖິງພວກເຂົາຖ້າພວກເຂົາຕ້ອງການ.

ຖ້າທ່ານສ້າງສະຄິບເຄືອຂ່າຍ Python ຂະຫນາດນ້ອຍທີ່ເຈົ້າຕັ້ງໃຈຈະດໍາເນີນການໃນ Circus, ມັນສາມາດເຮັດໄດ້
ເບິ່ງແບບນີ້:

ເຕົ້າຮັບການ ນຳ ເຂົ້າ
sys ນຳ ເຂົ້າ

fd = int(sys.argv[1]) # ໄດ້ຮັບ FD ຈາກ circus
sock = socket.fromfd(fd, ຄອບຄົວ, ປະເພດ)

# ຈັດການກັບການຮ້ອງຂໍຫນຶ່ງຄັ້ງ
ໃນຂະນະທີ່ຖືກຕ້ອງ:
conn, addr = sock.accept()
ຮ້ອງຂໍ = conn.recv(1024​)
..ເຮັດຫຍັງ..
conn.sendall(ຕອບ)
conn.close()

ຫຼັງຈາກນັ້ນ Circus ສາມາດແລ່ນແບບນີ້:

[ວົງດົນຕີ]
check_delay = 5
ຈຸດຈົບ = tcp://127.0.0.1:5555
pubsub_endpoint = tcp://127.0.0.1:5556
stats_endpoint = tcp://127.0.0.1:5557

[ເບິ່ງ: dummy]
cmd = mycoolscript $(circus.sockets.foo)
use_sockets = ຖືກ
warmup_delay = 0
ຈໍານວນຂະບວນການ = 5

[ເຕົ້າຮັບ:foo]
ເຈົ້າພາບ = 127.0.0.1
ພອດ = 8888

$(circus.sockets.foo) ຈະຖືກແທນທີ່ດ້ວຍຄ່າ FD ເມື່ອຊັອກເກັດຖືກສ້າງຂື້ນແລະ
ຜູກມັດໃນ 8888 port.

ຫມາຍ​ເຫດ​:
ເລີ່ມຕົ້ນທີ່ Circus 0.8 ມີ syntax ທາງເລືອກເພື່ອຫຼີກເວັ້ນການຂັດແຍ້ງກັບບາງຄົນ.
config parser. ທ່ານສາມາດຂຽນ:

((circus.sockets.foo))

ໂລກ​ທີ່​ແທ້​ຈິງ ຍົກຕົວຢ່າງ
ຖົງຕີນ ເປັນຄູ່ Circus ທີ່ສົມບູນແບບຖ້າຫາກວ່າທ່ານຕ້ອງການທີ່ຈະດໍາເນີນການຄໍາຮ້ອງສະຫມັກ WSGI ຂອງທ່ານ.

ເມື່ອມັນຕິດຕັ້ງແລ້ວ, ແລ່ນ 5 meinheld ພະນັກງານສາມາດເຮັດໄດ້ໂດຍການສ້າງເຕົ້າຮັບແລະ
ໂທຫາ ຖົງຕີນ ຄໍາສັ່ງໃນພະນັກງານ, ເຊັ່ນນີ້:

[ວົງດົນຕີ]
ຈຸດຈົບ = 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) --backend meinheld mycool.app
use_sockets = ຖືກ
ຈໍານວນຂະບວນການ = 5

[ເຕົ້າຮັບ:ເວັບ]
ເຈົ້າພາບ = 0.0.0.0
ພອດ = 8000

ພວກເຮົາບໍ່ໄດ້ເຜີຍແຜ່ດັດຊະນີເທື່ອ, ແຕ່ກຸ່ມເວັບທີ່ຄຸ້ມຄອງໂດຍ Circus ກັບ Gevent ຫຼື
Backend Meinheld ແມ່ນໄວເທົ່າກັບເຄື່ອງແມ່ຂ່າຍຂອງ WSGI ລ່ວງໜ້າໃດໆກໍຕາມ.

ການນໍາໃຊ້ ສ້າງຂຶ້ນໃນ plugins
Circus ມາພ້ອມກັບ plugins ທີ່ສ້າງຂຶ້ນໃນຈໍານວນຫນ້ອຍ. ພາກນີ້ນໍາສະເຫນີ plugins ເຫຼົ່ານີ້ແລະຂອງເຂົາເຈົ້າ
ຕົວເລືອກການຕັ້ງຄ່າ.

ສະຖິຕິ
ການນໍາໃຊ້ ຕັ້ງເປັນ 'circus.plugins.statsd.StatsdEmitter'

application_name
ຊື່ທີ່ໃຊ້ເພື່ອກໍານົດຄໍານໍາຫນ້າ bucket ເພື່ອ emit ສະຖິຕິ (ມັນຈະເປັນ
ນຳໜ້າດ້ວຍ ວົງດົນຕີ. ແລະຕໍ່ທ້າຍດ້ວຍ .ເບິ່ງ)

ເຈົ້າພາບ ເຈົ້າພາບທີ່ຈະປະກາດຂໍ້ມູນສະຖິຕິ

port ພອດທີ່ statsd daemon ຟັງຢູ່

ອັດຕາຕົວຢ່າງ
ຖ້າທ່ານຕ້ອງການອັດຕາຕົວຢ່າງທີ່ແຕກຕ່າງກັນຫຼາຍກ່ວາ 1, ທ່ານສາມາດຕັ້ງມັນຢູ່ທີ່ນີ້

ສະຖິຕິເຕັມ
ສ່ວນຂະຫຍາຍຢູ່ໃນປລັກອິນ Statsd ທີ່ຍັງເຜີຍແຜ່ສະຖິຕິຂະບວນການ. ດັ່ງ​ນັ້ນ
ມີຕົວເລືອກການຕັ້ງຄ່າດຽວກັນກັບ Statsd ແລະຕໍ່ໄປນີ້.

ການນໍາໃຊ້ ຕັ້ງ​ຄ່າ circus.plugins.statsd.FullStats

loop_rate
ຄວາມຖີ່ຂອງ plugin ຄວນຮ້ອງຂໍໃຫ້ມີສະຖິຕິໃນວິນາທີ. ຄ່າເລີ່ມຕົ້ນ: 60.

RedisObserver
ການບໍລິການນີ້ສັງເກດເຫັນຂະບວນການ redis ສໍາລັບທ່ານ, ເຜີຍແຜ່ຂໍ້ມູນໄປຍັງ statsd
ແລະສະເໜີໃຫ້ປິດເປີດຕົວເບິ່ງຄືນໃໝ່ເມື່ອມັນບໍ່ຕອບສະໜອງໃນເວລາໝົດເວລາ. plugin ນີ້
ຕ້ອງການ redis-py ແລ່ນ.

ມັນມີການຕັ້ງຄ່າດຽວກັນກັບ statsd ແລະເພີ່ມສິ່ງຕໍ່ໄປນີ້:

ການນໍາໃຊ້ ຕັ້ງ​ຄ່າ circus.plugins.redis_observer.RedisObserver

loop_rate
ຄວາມຖີ່ຂອງ plugin ຄວນຮ້ອງຂໍໃຫ້ມີສະຖິຕິໃນວິນາທີ. ຄ່າເລີ່ມຕົ້ນ: 60.

redis_url
ຖານຂໍ້ມູນທີ່ຈະກວດສອບເປັນ url redis. ຄ່າເລີ່ມຕົ້ນ: "redis://localhost:6379/0"

ຫມົດ​ເວ​ລາ
ໝົດເວລາໃນວິນາທີທີ່ຄຳຮ້ອງຂໍສາມາດໃຊ້ເວລາກ່ອນທີ່ມັນຈະຖືກພິຈາລະນາລົງ.
ຄ່າເລີ່ມຕົ້ນເປັນ 5.

restart_on_timeout
ຊື່ຂອງຂະບວນການທີ່ຈະ restart ເມື່ອຄໍາຮ້ອງຂໍຫມົດເວລາ. ບໍ່ມີການປິດເປີດໃໝ່
ກະຕຸ້ນໃນເວລາທີ່ບໍ່ໄດ້ໃຫ້. ຄ່າເລີ່ມຕົ້ນ: ບໍ່ມີ.

HttpObserver
ການບໍລິການນີ້ສັງເກດເຫັນຂະບວນການ http ສໍາລັບທ່ານໂດຍການ pinging ເວັບໄຊທ໌ສະເພາະໃດຫນຶ່ງເປັນປົກກະຕິ.
ຄ້າຍຄືກັນກັບ redis observer ມັນສະເຫນີໃຫ້ restart the watcher ໃນຄວາມຜິດພາດ. ມັນຮຽກຮ້ອງໃຫ້ມີ
tornado ແລ່ນ.

ມັນມີການຕັ້ງຄ່າດຽວກັນກັບ statsd ແລະເພີ່ມສິ່ງຕໍ່ໄປນີ້:

ການນໍາໃຊ້ ຕັ້ງ​ຄ່າ circus.plugins.http_observer.HttpObserver

loop_rate
ຄວາມຖີ່ຂອງ plugin ຄວນຮ້ອງຂໍໃຫ້ມີສະຖິຕິໃນວິນາທີ. ຄ່າເລີ່ມຕົ້ນ: 60.

check_url
url ທີ່ຈະກວດສອບ. ຄ່າເລີ່ມຕົ້ນ: http://localhost/

ຫມົດ​ເວ​ລາ
ໝົດເວລາໃນວິນາທີທີ່ຄຳຮ້ອງຂໍສາມາດໃຊ້ເວລາກ່ອນທີ່ມັນຈະຖືກພິຈາລະນາລົງ.
ຄ່າເລີ່ມຕົ້ນເປັນ 10.

restart_on_error
ຊື່ຂອງຂະບວນການທີ່ຈະ restart ເມື່ອຄໍາຮ້ອງຂໍຫມົດເວລາຫຼືສົ່ງຄືນໃດໆ
ຄວາມ​ຜິດ​ພາດ​ປະ​ເພດ​ອື່ນໆ​. ບໍ່ມີການເປີດປິດເປີດຄືນໃໝ່ເມື່ອບໍ່ໄດ້ໃຫ້. ຄ່າເລີ່ມຕົ້ນ: ບໍ່ມີ.

ResourceWatcher
ການບໍລິການນີ້ສັງເກດເບິ່ງຊັບພະຍາກອນຂອງຂະບວນການທີ່ໃຫ້ໄວ້ແລະກະຕຸ້ນໃຫ້ restart ເມື່ອໃດ
ພວກມັນເກີນຂໍ້ຈໍາກັດບາງຢ່າງເລື້ອຍໆຕິດຕໍ່ກັນ.

ມັນມີການຕັ້ງຄ່າດຽວກັນກັບ statsd ແລະເພີ່ມສິ່ງຕໍ່ໄປນີ້:

ການນໍາໃຊ້ ຕັ້ງ​ຄ່າ circus.plugins.resource_watcher.ResourceWatcher

loop_rate
ຄວາມຖີ່ຂອງ plugin ຄວນຮ້ອງຂໍໃຫ້ມີສະຖິຕິໃນວິນາທີ. ຄ່າເລີ່ມຕົ້ນ: 60.

watcher
watcher watcher ຊັບພະຍາກອນນີ້ຄວນຈະໄດ້ຮັບການເບິ່ງແຍງ. (ເມື່ອກ່ອນເອີ້ນວ່າ
ການບໍລິການ ແຕ່ ການບໍລິການ ດຽວນີ້ຖືກປະຕິເສດ)

max_cpu
cpu ສູງສຸດຫນຶ່ງຂະບວນການແມ່ນອະນຸຍາດໃຫ້ບໍລິໂພກ (ໃນ %). ຄ່າເລີ່ມຕົ້ນ: 90

min_cpu
CPU ຂັ້ນຕ່ຳສຸດໜຶ່ງຂະບວນການຄວນບໍລິໂພກ (ໃນ %). ຄ່າເລີ່ມຕົ້ນ: ບໍ່ມີ (ບໍ່ມີຂັ້ນຕໍ່າ)
ທ່ານສາມາດຕັ້ງ min_cpu ເປັນ 0 (ສູນ), ໃນກໍລະນີນີ້ຖ້າຫາກວ່າຂະບວນການຫນຶ່ງບໍລິໂພກແນ່ນອນ
0% cpu, ມັນຈະກະຕຸ້ນໃຫ້ເກີນຂອບເຂດຈໍາກັດ.

max_mem
ຈໍານວນຫນ່ວຍຄວາມຈໍາຂະບວນການຫນຶ່ງຂອງ watcher ນີ້ໄດ້ຖືກອະນຸຍາດໃຫ້ບໍລິໂພກ. ຄ່າເລີ່ມຕົ້ນ:
90. ຖ້າບໍ່ມີຫົວໜ່ວຍໃດຖືກລະບຸ, ຄ່າແມ່ນເປັນ %. ຕົວຢ່າງ: 50 ຖ້າຫົວໜ່ວຍເປັນ
ລະບຸໄວ້, ຄ່າແມ່ນຢູ່ໃນ bytes. ຫນ່ວຍງານທີ່ສະຫນັບສະຫນູນແມ່ນ B, K, M, G, T, P, E, Z, Y.
ຕົວຢ່າງ: 250M

min_mem
ຫນ່ວຍຄວາມຈໍາຂັ້ນຕ່ໍາຫນຶ່ງຂະບວນການຂອງ watcher ນີ້ຄວນຈະບໍລິໂພກ. ຄ່າເລີ່ມຕົ້ນ: ບໍ່ມີ (ບໍ່
ຕໍາ່ສຸດທີ່). ຖ້າບໍ່ມີຫົວໜ່ວຍໃດຖືກລະບຸ, ຄ່າແມ່ນຢູ່ໃນ %. ຕົວຢ່າງ: 50 ຖ້າຫົວໜ່ວຍເປັນ
ລະບຸໄວ້, ຄ່າແມ່ນຢູ່ໃນ bytes. ຫນ່ວຍງານທີ່ສະຫນັບສະຫນູນແມ່ນ B, K, M, G, T, P, E, Z, Y.
ຕົວຢ່າງ: 250M

health_threshold
ສຸຂະພາບແມ່ນສະເລ່ຍຂອງ CPU ແລະຫນ່ວຍຄວາມຈໍາ (ໃນ %) ຂະບວນການ watchers ແມ່ນ
ອະນຸຍາດໃຫ້ບໍລິໂພກ (ໃນ %). ຄ່າເລີ່ມຕົ້ນ: 75

max_count
ຂອບເຂດຈໍາກັດເຫຼົ່ານີ້ເລື້ອຍໆເທົ່າໃດ (ແຕ່ລະອັນຖືກນັບແຍກກັນ) ຖືກອະນຸຍາດໃຫ້ເປັນ
ເກີນກ່ອນທີ່ຈະປິດເປີດຄືນໃໝ່ຈະຖືກກະຕຸ້ນ. ຄ່າເລີ່ມຕົ້ນ: 3

ຕົວຢ່າງ:

[ວົງດົນຕີ]
; ...

[ຜູ້​ເບິ່ງ​: ໂຄງ​ການ​]
cmd = ນອນ 120

[ປລັກອິນ:myplugin]
use = circus.plugins.resource_watcher.ResourceWatcher
watcher = ໂຄງການ
min_cpu = 10
max_cpu = 70
min_mem = 0
max_mem = 20

Watchdog
ປລັກອິນທີ່ຜູກມັດຊ່ອງສຽບ udp ແລະລໍຖ້າຂໍ້ຄວາມເຝົ້າລະວັງ. ສໍາລັບ "ເຝົ້າລະວັງ"
ຂະບວນການ, watchdog ຈະຂ້າພວກເຂົາຖ້າພວກເຂົາບໍ່ສົ່ງຫົວໃຈເຕັ້ນໄປຫາສະເພາະໃດຫນຶ່ງ
ໄລ​ຍະ​ເວ​ລາ​ທີ່​ເປັນ​ເອ​ກະ​ສານ​ໂດຍ loop_rate * max_count​. (circus ຈະ​ອັດ​ຕະ​ໂນ​ມັດ​
restart ຂະ​ບວນ​ການ​ທີ່​ຂາດ​ຫາຍ​ໄປ​ໃນ watcher ໄດ້​)

ແຕ່ລະຂະບວນການທີ່ຖືກກວດສອບຄວນສົ່ງຂໍ້ຄວາມ udp ຢ່າງຫນ້ອຍຢູ່ທີ່ loop_rate. udp
ຮູບແບບຂໍ້ຄວາມແມ່ນເສັ້ນຂອງຂໍ້ຄວາມ, ຖອດລະຫັດໂດຍໃຊ້ msg_regex ພາລາມິເຕີ. ຫົວໃຈເຕັ້ນ
ຂໍ້ຄວາມຢ່າງຫນ້ອຍຕ້ອງມີ pid ຂອງຂະບວນການສົ່ງຂໍ້ຄວາມ.

ບັນຊີລາຍຊື່ຂອງຜູ້ເຝົ້າຕິດຕາມແມ່ນຖືກກໍານົດໂດຍພາລາມິເຕີ watchers_regex ໃນ
ການຕັ້ງຄ່າ

ຕົວກໍານົດການກໍານົດ:

ການນໍາໃຊ້ ຕັ້ງ​ຄ່າ circus.plugins.watchdog.WatchDog

loop_rate
watchdog ອັດຕາການ loop ໃນວິນາທີ. ໃນແຕ່ລະ loop, WatchDog ຈະຊອກຫາ "ຕາຍ"
ຂະບວນການ.

watchers_regex
regex ສໍາລັບການຈັບຄູ່ຊື່ watcher ທີ່ຄວນຈະຖືກຕິດຕາມໂດຍ watchdog
(ຄ່າເລີ່ມຕົ້ນ: .* ຜູ້​ເບິ່ງ​ທັງ​ຫມົດ​ແມ່ນ​ຕິດ​ຕາມ​)

msg_regex
regex ສໍາລັບການຖອດລະຫັດຂໍ້ຄວາມເຕັ້ນຫົວໃຈທີ່ໄດ້ຮັບໃນ udp (ຄ່າເລີ່ມຕົ້ນ:
^(?ປ .*);(?ປ .*)$) ຮູບແບບເລີ່ມຕົ້ນແມ່ນຂໍ້ຄວາມທີ່ງ່າຍດາຍ:
pid;ສະແຕມເວລາ

max_count
ຈຳນວນສູງສຸດຂອງວົງຮອບທີ່ຜ່ານໂດຍບໍ່ໄດ້ຮັບການເຕັ້ນຂອງຫົວໃຈກ່ອນທີ່ຈະປິດເປີດໃໝ່
ຂະບວນການ (ຄ່າເລີ່ມຕົ້ນ: 3)

ip ip watchdog ຈະຜູກມັດ (ຄ່າເລີ່ມຕົ້ນ: 127.0.0.1)

port ພອດ watchdog ຈະຜູກມັດ (ຄ່າເລີ່ມຕົ້ນ: 1664)

ກະພິບ
ໃນເວລາທີ່ພະນັກງານ restarts ເລື້ອຍໆເກີນໄປ, ພວກເຮົາເວົ້າວ່າມັນແມ່ນ ກະພິບ. plugin ນີ້ຕິດຕາມ
ຂອງພະນັກງານ restarts ແລະຢຸດ watcher ທີ່ສອດຄ້ອງກັນໃນກໍລະນີທີ່ມັນ flapping. ນີ້
plugin ອາດຈະຖືກນໍາໃຊ້ເພື່ອອັດຕະໂນມັດຢຸດພະນັກງານທີ່ໄດ້ຮັບການ restarted ຢ່າງຕໍ່ເນື່ອງເນື່ອງຈາກວ່າ
ເຂົາເຈົ້າເຮັດວຽກບໍ່ຖືກຕ້ອງ.

ການນໍາໃຊ້ ຕັ້ງ​ຄ່າ circus.plugins.flapping.Flapping

ຄວາມພະຍາຍາມ
ຈໍານວນເວລາທີ່ຂະບວນການສາມາດເລີ່ມຕົ້ນໃຫມ່, ພາຍໃນ ປ່ອງຢ້ຽມ ວິນາທີ, ກ່ອນພວກເຮົາ
ພິຈາລະນາມັນ flapping (ຄ່າເລີ່ມຕົ້ນ: 2)

ປ່ອງຢ້ຽມ ປ່ອງຢ້ຽມເວລາເປັນວິນາທີເພື່ອທົດສອບການ flapping. ຖ້າຂະບວນການ restarts ຫຼາຍ
ກ່ວາ ຄວາມພະຍາຍາມ ເວລາພາຍໃນປ່ອງຢ້ຽມເວລານີ້, ພວກເຮົາພິຈາລະນາມັນເປັນຂະບວນການ flapping.
(ຄ່າເລີ່ມຕົ້ນ: 1)

retry_in
ໃຊ້ເວລາເປັນວິນາທີທີ່ຈະລໍຖ້າຈົນກ່ວາພວກເຮົາພະຍາຍາມທີ່ຈະເລີ່ມຕົ້ນອີກເທື່ອຫນຶ່ງຂະບວນການທີ່ໄດ້
ກະພິບ. (ຄ່າເລີ່ມຕົ້ນ: 7)

max_retry
ຈໍານວນຄັ້ງທີ່ພວກເຮົາພະຍາຍາມເລີ່ມຕົ້ນຂະບວນການທີ່ໄດ້ຮັບການ flapping, ກ່ອນ
ພວກເຮົາປະຖິ້ມແລະຢຸດເຊົາການເບິ່ງທັງຫມົດ. (ຄ່າເລີ່ມຕົ້ນ: 5) ຕັ້ງເປັນ -1 ເພື່ອປິດການໃຊ້ງານ
max_retry ແລະລອງໃໝ່ອີກຢ່າງບໍ່ມີກຳນົດ.

ການເຄື່ອນໄຫວ ກໍານົດວ່າ plugin ເຮັດວຽກຫຼືບໍ່ (ຄ່າເລີ່ມຕົ້ນ: ຖືກ). ຖ້າທຸງໂລກແມ່ນ
ຕັ້ງເປັນຜິດ, ປັ໊ກອິນບໍ່ໄດ້ຖືກເລີ່ມຕົ້ນ.

ທາງເລືອກສາມາດຖືກ overriden ໃນພາກສ່ວນ watcher ໂດຍໃຊ້ a ກະພິບ. ຄຳນຳໜ້າ. ຕົວ​ຢ່າງ,
ນີ້ແມ່ນວິທີທີ່ທ່ານຈະ configure ສະເພາະ max_retry ຄ່າ​ສໍາ​ລັບ nginx​:

[ຜູ້ເບິ່ງ: nginx]
cmd = /path/to/nginx
flapping.max_retry = 2

[ຜູ້ເບິ່ງ: myscript]
cmd = ./my_script.py

; ... watchers ອື່ນໆ

[ປລັກອິນ:flapping]
use = circus.plugins.flapping.Flapping
max_retry = 5

CommandReloader
ປັ໊ກອິນນີ້ຈະປິດເປີດຕົວເບິ່ງຄືນໃໝ່ເມື່ອໄຟລ໌ຄຳສັ່ງຂອງເຂົາເຈົ້າຖືກແກ້ໄຂ. ມັນເຮັດວຽກໂດຍ
ການ​ກວດ​ສອບ​ທີ່​ໃຊ້​ເວ​ລາ​ການ​ດັດ​ແກ້​ແລະ​ເສັ້ນ​ທາງ​ຂອງ​ໄຟລ​໌​ທີ່​ຊີ້​ໃຫ້​ເຫັນ​ໂດຍ​ cmd ທາງ​ເລືອກ​ທຸກ​
loop_rate ວິນາທີ. ນີ້ອາດຈະເປັນປະໂຫຍດໃນຂະນະທີ່ການພັດທະນາຂະບວນການຂອງພະນັກງານຫຼືແມ້ກະທັ້ງສໍາລັບຮ້ອນ
ການຍົກລະດັບລະຫັດໃນການຜະລິດ.

ການນໍາໃຊ້ ຕັ້ງ​ຄ່າ circus.plugins.command_reloader.CommandReloader

loop_rate
ຄວາມຖີ່ຂອງ plugin ຄວນກວດສອບການດັດແກ້ໃນວິນາທີ. ຄ່າເລີ່ມຕົ້ນ: 1.

ການປະຕິບັດ
ເຖິງແມ່ນວ່າ Circus daemon ສາມາດຖືກຈັດການດ້ວຍຄໍາສັ່ງ circusd, ມັນງ່າຍກວ່າທີ່ຈະມີມັນ
ເລີ່ມໃສ່ເກີບ. ຖ້າລະບົບຂອງທ່ານສະຫນັບສະຫນູນ Upstart, ທ່ານສາມາດສ້າງ script Upstart ນີ້ໃນ
/etc/init/circus.conf.

ເລີ່ມຕົ້ນໃນລະບົບໄຟລ໌ ແລະ net-device-up IFACE=lo
ຢຸດຢູ່ໃນລະດັບແລ່ນ [016]

ຟື້ນຄືນ
exec /usr/local/bin/circusd /etc/circus/circusd.ini

ນີ້ສົມມຸດວ່າ circusd.ini ຕັ້ງຢູ່ /etc/circus/circusd.ini. ຫຼັງຈາກ rebooting, ທ່ານ
ສາມາດຄວບຄຸມ circusd ດ້ວຍຄໍາສັ່ງການບໍລິການ:

# ວົງວຽນບໍລິການເລີ່ມຕົ້ນ / ຢຸດ / ເລີ່ມຕົ້ນໃຫມ່

ຖ້າລະບົບຂອງທ່ານສະຫນັບສະຫນູນ systemd, ທ່ານສາມາດສ້າງໄຟລ໌ຫນ່ວຍງານລະບົບນີ້ພາຍໃຕ້
/etc/systemd/system/circus.service.

[ຫນ່ວຍງານ]
Description=ຜູ້​ຈັດ​ການ​ຂະ​ບວນ​ການ Circus
After=syslog.target network.target nss-lookup.target

[ບໍລິການ]
ປະເພດ = ງ່າຍດາຍ
ExecReload=/usr/bin/circusctl ໂຫຼດຄືນໃໝ່
ExecStart=/usr/bin/circusd /etc/circus/circus.ini
Restart = ສະ ເໝີ
RestartSec = 5

[ຕິດຕັ້ງ]
WantedBy=default.target

ການປິດເປີດເຄື່ອງໃໝ່ແມ່ນບໍ່ຈໍາເປັນຖ້າທ່ານແລ່ນຄໍາສັ່ງ daemon-reload ຂ້າງລຸ່ມນີ້:

# systemctl --system daemon-reload

ຫຼັງຈາກນັ້ນ, circus ສາມາດໄດ້ຮັບການຄຸ້ມຄອງໂດຍຜ່ານ:

# systemctl start/stop/status/reload circus

ສູດ
ພາກສ່ວນນີ້ຈະມີສູດອາຫານເພື່ອນຳໃຊ້ Circus. ຈົນກ່ວານັ້ນທ່ານສາມາດເບິ່ງ Pete's
ພ້າ ສູດ ຫຼືຢູ່ Remy ຫົວ ສູດ

Papa ຂະບວນການ ແກ່ນ
ບັນຫາຫນຶ່ງທີ່ພົບເລື້ອຍກັບຜູ້ຈັດການຂະບວນການແມ່ນທ່ານບໍ່ສາມາດເລີ່ມຕົ້ນຜູ້ຈັດການຂະບວນການໃຫມ່ໄດ້
ໂດຍ​ບໍ່​ມີ​ການ restart ທຸກໆ​ຂະ​ບວນ​ການ​ທີ່​ມັນ​ຄຸ້ມ​ຄອງ​. ນີ້ເຮັດໃຫ້ມັນຍາກທີ່ຈະປະຕິບັດ a
ສະບັບໃຫມ່ຂອງ Circus ຫຼືສະບັບໃຫມ່ຂອງຫ້ອງສະຫມຸດໃດໆທີ່ມັນຂຶ້ນກັບ.

ຖ້າທ່ານຢູ່ໃນລະບົບ Unix-type, Circus ສາມາດໃຊ້ kernel ຂະບວນການ Papa. ເມື່ອໃຊ້, Papa
ຈະສ້າງ daemon ທີ່ມີຊີວິດຍາວທີ່ຈະເຮັດຫນ້າທີ່ເປັນເຈົ້າພາບສໍາລັບຂະບວນການແລະເຕົ້າຮັບໃດໆ
ທ່ານສ້າງກັບມັນ. ຖ້າ circus ຖືກປິດ, Papa ຈະຮັກສາທຸກສິ່ງທຸກຢ່າງທີ່ມັນເປັນເຈົ້າພາບ.

ຕັ້ງ​ຄ່າ
ເລີ່ມ​ຕົ້ນ​ໂດຍ​ການ​ຕິດ​ຕັ້ງ​ papa ແລະ setproctitle ໂມດູນ:

pip ຕິດຕັ້ງ papa
pip ຕິດຕັ້ງ setproctitle

ໄດ້ setproctitle ໂມດູນແມ່ນທາງເລືອກ. ມັນຈະຖືກນໍາໃຊ້ຖ້າມີເພື່ອປ່ຽນຊື່ Papa daemon
ສໍາລັບການ top ແລະ ps ກັບບາງສິ່ງບາງຢ່າງເຊັ່ນ: "papa daemon ຈາກ circusd". ຖ້າ​ຫາກ​ວ່າ​ທ່ານ​ບໍ່​ໄດ້​ຕິດ​ຕັ້ງ​
setproctitle ໂມດູນ, ຫົວຂໍ້ນັ້ນຈະເປັນເສັ້ນຄໍາສັ່ງຂອງຂະບວນການທີ່ເປີດຕົວມັນ.
ສັບສົນຫຼາຍ.

ເມື່ອ Papa ຖືກຕິດຕັ້ງ, ເພີ່ມ use_papa=ຈິງ ກັບຂະບວນການທີ່ສໍາຄັນແລະເຕົ້າຮັບຂອງທ່ານ.
ໂດຍທົ່ວໄປແລ້ວທ່ານຕ້ອງການເຮືອນທັງຫມົດຂອງຂະບວນການ stack ຂອງທ່ານໃນ Papa, ແລະບໍ່ມີຂອງ
Circus ຂະບວນການສະຫນັບສະຫນູນເຊັ່ນ: flapping ແລະ stats plugins.

[ວົງດົນຕີ]
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
warmup_delay = 3
graceful_timeout = 10
max_retry = 5
singleton = ຈິງ
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 = FileStream
stderr_stream.filename = /var/logs/web-server-error.log
stderr_stream.max_bytes = 1000000
stderr_stream.backup_count = 10
active = ຈິງ
use_papa = ຈິງ

[ຜູ້ເບິ່ງ: logger]
cmd = /my_service/env/bin/python logger.py ແລ່ນ
work_dir = /my_service
graceful_timeout = 10
singleton = ຈິງ
stop_signal = INT
stdout_stream.class = FileStream
stdout_stream.filename = /var/logs/logger.log
stdout_stream.max_bytes = 10000000
stdout_stream.backup_count = 10
stderr_stream.class = FileStream
stderr_stream.filename = /var/logs/logger.log
stderr_stream.max_bytes = 1000000
stderr_stream.backup_count = 10
ບູລິມະສິດ = 50
use_papa = ຈິງ

[ຜູ້ເບິ່ງ: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)
work_dir = /my_service/web_app
graceful_timeout=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 = FileStream
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 = ຈິງ

[ປລັກອິນ:flapping]
use = circus.plugins.flapping.Flapping
ປ່ອງຢ້ຽມ = 10
ບູລິມະສິດ = 1000

ຫມາຍ​ເຫດ​:
ຖ້າຂະບວນການ Papa ໃຊ້ເຕົ້າສຽບໃດໆ, ເຕົ້າຮັບເຫຼົ່ານັ້ນຕ້ອງໃຊ້ papa.

ການອອກແບບ ເປົ້າຫມາຍຂອງ
Papa ຖືກອອກແບບມາເພື່ອໃຫ້ມີຄຸນສົມບັດແລະຄວາມຕ້ອງການຫນ້ອຍທີ່ສຸດ. ມັນ​ເຮັດ:

·ເລີ່ມແລະຢຸດເຕົ້າຮັບ

· ສະໜອງກະແຈ/ຮ້ານມູນຄ່າ

·ເລີ່ມຕົ້ນຂະບວນການແລະກັບຄືນ stdout, stderr ແລະລະຫັດອອກ

ມັນບໍ່ໄດ້:

· ເລີ່ມຂະບວນການຄືນໃໝ່

·ໃຫ້ວິທີການຢຸດຂະບວນການ

· ໃຫ້ຂໍ້ມູນໃດໆກ່ຽວກັບຂະບວນການນອກເໜືອໄປຈາກວ່າພວກມັນຍັງດຳເນີນຢູ່ຫຼືບໍ່

Papa ຕ້ອງການບໍ່ມີຫ້ອງສະຫມຸດພາກສ່ວນທີສາມດັ່ງນັ້ນມັນສາມາດດໍາເນີນການໄດ້ພຽງແຕ່ຫ້ອງສະຫມຸດ Python ມາດຕະຖານ.
ມັນສາມາດເຮັດໃຫ້ການນໍາໃຊ້ຂອງ setproctitle package ແຕ່ວ່າພຽງແຕ່ຖືກນໍາໃຊ້ສໍາລັບການເຮັດໃຫ້ຫົວຂໍ້
ງາມກວ່າສໍາລັບ ps ແລະ top ແລະບໍ່ຈໍາເປັນ.

ການທໍາງານໄດ້ຖືກເກັບຮັກສາໄວ້ເປັນຕໍາ່ສຸດທີ່ດັ່ງນັ້ນທ່ານບໍ່ຄວນຈໍາເປັນຕ້ອງໄດ້ restart
Papa daemon. ຫຼາຍຂອງການທໍາງານໄດ້ຖືກ pushed ກັບຫ້ອງສະຫມຸດລູກຄ້າເປັນ
ເປັນໄປໄດ້. ດ້ວຍວິທີນັ້ນ, ທ່ານຄວນສາມາດໃຊ້ສໍາເນົາໃຫມ່ຂອງ Papa ສໍາລັບຄຸນສົມບັດລູກຄ້າໃຫມ່
ໂດຍບໍ່ຈໍາເປັນຕ້ອງ restart Papa daemon. Papa ແມ່ນ​ຫມາຍ​ຄວາມ​ວ່າ​ຈະ​ເປັນ​ເສົາ​ຄ້ຳ​ຂອງ​ສະ​ຖຽນ​ລະ​ພາບ​ໃນ
ທະເລທີ່ມີການປ່ຽນແປງຂອງຫ້ອງສະຫມຸດພາກສ່ວນທີສາມ.

ການດໍາເນີນງານ
ສິ່ງສ່ວນໃຫຍ່ຍັງຄົງບໍ່ປ່ຽນແປງບໍ່ວ່າທ່ານຈະໃຊ້ Papa ຫຼືບໍ່. ເຈົ້າຍັງສາມາດເລີ່ມຕົ້ນ ແລະຢຸດໄດ້
ຂະບວນການ. ທ່ານຍັງສາມາດໄດ້ຮັບສະຖານະພາບແລະສະຖິຕິສໍາລັບຂະບວນການ. ສິ່ງທີ່ສໍາຄັນທີ່ມີການປ່ຽນແປງ
ແມ່ນເວລາທີ່ທ່ານເຮັດ circusctl ເຊົາ, ຂະບວນການ Papa ທັງຫມົດແມ່ນຍັງແລ່ນຢູ່. ເມື່ອ​ເຈົ້າ
ການເລີ່ມຕົ້ນ ວົງວຽນ ສໍາຮອງຂໍ້ມູນ, ຂະບວນການເຫຼົ່ານັ້ນແມ່ນຟື້ນຕົວ.

ຫມາຍ​ເຫດ​:
ເມື່ອ​ຂະ​ບວນ​ການ​ໄດ້​ຮັບ​ການ​ຟື້ນ​ຟູ​, ກ່ອນ_ເລີ່ມ ແລະ before_spawn hooks ຖືກຂ້າມ.

ການຕັດໄມ້ທ່ອນ
ໃນຂະນະທີ່ Circus ປິດລົງ, Papa ຈະເກັບຮັກສາຜົນຜະລິດໄດ້ເຖິງ 2M ຕໍ່ຂະບວນການ. ຫຼັງຈາກນັ້ນມັນຈະ
ເລີ່ມການຖິ້ມຂໍ້ມູນເກົ່າແກ່ທີ່ສຸດ. ເມື່ອ​ທ່ານ restart Circus, ຜົນ​ຜະ​ລິດ​ຈາກ​ຖານ​ຄວາມ​ຈໍາ​ນີ້​ຈະ​ເປັນ​ຢ່າງ​ວ່ອງ​ໄວ​
ໄດ້​ຮັບ​ແລະ​ສົ່ງ​ອອກ​ໄປ​ສະ​ຕ​ຣີມ​ຜົນ​ຜະ​ລິດ​ໄດ້​. Papa ຮຽກຮ້ອງໃຫ້ມີການໄດ້ຮັບຜົນຜະລິດ
ໄດ້ຮັບການຍອມຮັບ, ດັ່ງນັ້ນທ່ານບໍ່ຄວນສູນເສຍຜົນຜະລິດໃດໆໃນລະຫວ່າງການປິດເຄື່ອງ.

ບໍ່ພຽງແຕ່ເທົ່ານັ້ນ, ແຕ່ Papa ຊ່ວຍປະຢັດເວລາຂອງຜົນຜະລິດ. Circus ໄດ້​ຮັບ​ການ​ປັບ​ປຸງ​
ໃຊ້ປະໂຫຍດຈາກຂໍ້ມູນເວລາຖ້າມີ. ດັ່ງນັ້ນຖ້າຫາກວ່າທ່ານກໍາລັງຂຽນຜົນຜະລິດເພື່ອບັນທຶກໄຟລ໌
ຫຼືບາງບ່ອນ, ເວລາຂອງທ່ານທັງໝົດຄວນຈະຖືກຕ້ອງ.

ບັນຫາ
ຖ້າທ່ານໃຊ້ incr or Decr ຄໍາ​ສັ່ງ​ທີ່​ຈະ​ປ່ຽນ​ການ​ນັບ​ຂະ​ບວນ​ການ​ສໍາ​ລັບ​ການ watcher ເປັນ​, ນີ້​ຈະ​
ຈະຖືກປັບເປັນລະດັບທີ່ລະບຸໄວ້ໃນໄຟລ໌ INI ເມື່ອ ວົງວຽນ ແມ່ນເລີ່ມຕົ້ນ ໃໝ່ ແລ້ວ.

ນອກຈາກນີ້, ຂ້າພະເຈົ້າໄດ້ປະສົບບັນຫາກັບການປະສົມປະສານຂອງ copy_env ແລະ virtualenv. ທ່ານອາດຈະ
ໃຫ້ສັງເກດວ່າຕົວຢ່າງ INI ຂ້າງເທິງນີ້ຫລີກລ້ຽງບັນຫານີ້ດ້ວຍເສັ້ນທາງທີ່ຊັດເຈນ.

Telnet ການໂຕ້ຕອບ
Papa ມີ​ການ​ໂຕ້​ຕອບ​ເສັ້ນ​ຄໍາ​ສັ່ງ​ພື້ນ​ຖານ​ທີ່​ທ່ານ​ສາ​ມາດ​ເຂົ້າ​ເຖິງ​ໂດຍ​ຜ່ານ telnet​:

Telnet Localhost 20202
ຊ່ວຍເຫຼືອ

Circus ສໍາລັບການ ການພັດທະນາ
ການນໍາໃຊ້ Circus as a ຫ້ອງສະຫມຸດ
Circus ໃຫ້ຫ້ອງຮຽນລະດັບສູງແລະຫນ້າທີ່ຈະຊ່ວຍໃຫ້ທ່ານສາມາດຈັດການຂະບວນການຕ່າງໆ
ຄໍາຮ້ອງສະຫມັກຂອງທ່ານເອງ.

ສໍາລັບຕົວຢ່າງ, ຖ້າທ່ານຕ້ອງການດໍາເນີນການສີ່ຂະບວນການຕະຫຼອດໄປ, ທ່ານສາມາດຂຽນ:

ຈາກການນໍາເຂົ້າ circus get_arbiter

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

arbiter = get_arbiter([ໂປຣແກມຂອງຂ້ອຍ])
ລອງ:
arbiter.start()
ສຸດທ້າຍ:
arbiter.stop()

snippet ນີ້ຈະດໍາເນີນການສີ່ຕົວຢ່າງຂອງ ໂຄງການຂອງຂ້ອຍ ແລະເບິ່ງພວກມັນສໍາລັບທ່ານ, ເລີ່ມຕົ້ນພວກມັນໃຫມ່
ຖ້າພວກເຂົາຕາຍໂດຍບໍ່ຄາດຄິດ.

ເພື່ອສຶກສາເພີ່ມເຕີມກ່ຽວກັບເລື່ອງນີ້, ເບິ່ງຫ້ອງສະໝຸດ

ການຂະຫຍາຍ Circus
ມັນງ່າຍທີ່ຈະຂະຫຍາຍ Circus ເພື່ອສ້າງລະບົບທີ່ສັບສົນຫຼາຍ, ໂດຍການຟັງທັງຫມົດ
ວົງວຽນ ເຫດການຜ່ານຊ່ອງທາງ pub / ຍ່ອຍຂອງມັນ, ແລະຂັບລົດມັນຜ່ານຄໍາສັ່ງ.

ນັ້ນແມ່ນວິທີທີ່ຄຸນນະສົມບັດ flapping ເຮັດວຽກເຊັ່ນ: ມັນຟັງຂະບວນການທັງຫມົດທີ່ເສຍຊີວິດ,
ວັດແທກວ່າມັນເກີດຂຶ້ນເລື້ອຍໆສໍ່າໃດ, ແລະຢຸດຜູ້ເຝົ້າລະວັງທີ່ຖືກຄຸກຄາມຫຼັງຈາກປິດເປີດໃໝ່ຫຼາຍເກີນໄປ
ຄວາມພະຍາຍາມ.

Circus ມາພ້ອມກັບລະບົບ plugin ເພື່ອຊ່ວຍໃຫ້ທ່ານຂຽນການຂະຫຍາຍດັ່ງກ່າວ, ແລະການກໍ່ສ້າງໃນຈໍານວນຫນ້ອຍ
ປັ໊ກອິນທີ່ເຈົ້າສາມາດໃຊ້ຄືນໄດ້. ເບິ່ງ plugins.

ນອກນັ້ນທ່ານຍັງສາມາດມີພຶດຕິກໍາການເລີ່ມຕົ້ນແລະການປິດ subtile ຫຼາຍໂດຍການໃຊ້ hooks ລະບົບ
ທີ່​ຈະ​ໃຫ້​ທ່ານ​ດໍາ​ເນີນ​ການ​ລະ​ຫັດ​ຕົນ​ເອງ​ກ່ອນ​ແລະ​ຫຼັງ​ຈາກ​ຂະ​ບວນ​ການ​ບາງ​ຢ່າງ​ແມ່ນ​ໄດ້​ເລີ່ມ​ຕົ້ນ​ຫຼື​
ຢຸດ. ເບິ່ງ hooks.

ສຸດທ້າຍແຕ່ບໍ່ໄດ້ຢ່າງຫນ້ອຍ, ທ່ານຍັງສາມາດເພີ່ມຄໍາສັ່ງໃຫມ່. ເບິ່ງການເພີ່ມ cmds.

ການພັດທະນາ ເອ​ກະ​ສານ ດັດຊະນີ
Circus ຫ້ອງສະຫມຸດ
ຊຸດ Circus ແມ່ນປະກອບດ້ວຍລະດັບສູງ get_arbiter() ຫນ້າ​ທີ່​ແລະ​ຫຼາຍ​ຫ້ອງ​ຮຽນ​. ໃນ
ກໍລະນີຫຼາຍທີ່ສຸດ, ການນໍາໃຊ້ຫນ້າທີ່ລະດັບສູງຄວນຈະພຽງພໍ, ຍ້ອນວ່າມັນສ້າງທຸກສິ່ງທຸກຢ່າງທີ່
ແມ່ນຈໍາເປັນສໍາລັບ Circus ເພື່ອດໍາເນີນການ.

ທ່ານສາມາດ subclass Circus 'ຫ້ອງຮຽນຖ້າຫາກວ່າທ່ານຕ້ອງການ granularity ຫຼາຍກ່ວາສິ່ງທີ່ສະຫນອງໃຫ້ໂດຍ
ການຕັ້ງຄ່າ

ໄດ້ get_arbiter ຫນ້າທີ່
get_arbiter() ແມ່ນພຽງແຕ່ຄວາມສະດວກສະບາຍຢູ່ເທິງຂອງຫ້ອງຮຽນ circus ຕ່າງໆ. ມັນສ້າງເປັນ
arbiter (ຊັ້ນ ຜູ້ຕັດສິນ) ຕົວ​ຢ່າງ​ທີ່​ມີ​ທາງ​ເລືອກ​ທີ່​ສະ​ຫນອງ​ໃຫ້​, ຊຶ່ງ​ໃນ​ການ​ເຮັດ​ໃຫ້​ການ​ດໍາ​ເນີນ​ການ​ດຽວ​
ຜູ້ເບິ່ງ ກັບດຽວ ຂະບວນການ.

circus.get_arbiter()

ຕົວຢ່າງ:

ຈາກການນໍາເຂົ້າ circus get_arbiter

arbiter = get_arbiter([{"cmd": "myprogram", "numprocesses": 3}])
ລອງ:
arbiter.start()
ສຸດທ້າຍ:
arbiter.stop()

ຫ້ອງຮຽນ
Circus ໃຫ້ຊຸດຂອງຫ້ອງຮຽນທີ່ທ່ານສາມາດນໍາໃຊ້ເພື່ອປະຕິບັດຜູ້ຈັດການຂະບວນການຂອງທ່ານເອງ:

· ຂະບວນການ: ຫໍ່ຂະບວນການແລ່ນ ແລະໃຫ້ຜູ້ຊ່ວຍບໍ່ຫຼາຍປານໃດຢູ່ເທິງສຸດຂອງມັນ.

· ຜູ້ເບິ່ງ: ດໍາເນີນການຫຼາຍຕົວຢ່າງຂອງ ຂະບວນການ ຕໍ່ກັບຄໍາສັ່ງດຽວກັນ. ການ​ຄຸ້ມ​ຄອງ​ການ​ເສຍ​ຊີ​ວິດ​ແລະ​
ຊີ​ວິດ​ຂອງ​ຂະ​ບວນ​ການ​.

· ຜູ້ຕັດສິນ: ຄຸ້ມຄອງຫຼາຍ ຜູ້ເບິ່ງ.

ລະດັບ circus.process.Process(ຊື່, ກວ້າງ, cmd, args=ບໍ່ມີ, work_dir=ບໍ່ມີ, shell=ຜິດ,
uid=ບໍ່ມີ, gid=ບໍ່ມີ, env=ບໍ່ມີ, rlimits=ບໍ່ມີ, executable=ບໍ່ມີ, use_fds=ຜິດ, watcher=ບໍ່ມີ,
spawn=ຄວາມຈິງ, pipe_stdout=ຄວາມຈິງ, pipe_stderr=ຖືກຕ້ອງ, close_child_stdout=ຜິດ,
close_child_stderr=ຜິດ)
ຫໍ່ຂະບວນການ.

ຕົວເລືອກ:

· ກວ້າງ: ຕົວລະບຸເອກະລັກຂອງຂະບວນການ. ຄ່ານີ້ຈະຖືກໃຊ້ເພື່ອແທນທີ່ $WID
string ໃນແຖວຄໍາສັ່ງຖ້າມີ.

· cmd: ຄໍາສັ່ງທີ່ຈະດໍາເນີນການ. ອາດມີຕົວແປໃດນຶ່ງທີ່ມີຢູ່
ຖືກ​ຜ່ານ​ໄປ​ໃນ​ຫ້ອງ​ຮຽນ​ນີ້​. ພວກມັນຈະຖືກແທນທີ່ໂດຍໃຊ້ syntax ຮູບແບບ python.

· ໂຕ້ຖຽງ: arguments ສໍາລັບຄໍາສັ່ງທີ່ຈະດໍາເນີນການ. ສາມາດເປັນລາຍການຫຼືສາຍ. ຖ້າ ໂຕ້ຖຽງ is
ຊ່ອຍແນ່, ມັນແບ່ງອອກໂດຍໃຊ້ shlex.split(). ຄ່າເລີ່ມຕົ້ນເປັນບໍ່ມີ.

· ປະຕິບັດໄດ້: ເມື່ອປະຕິບັດໄດ້ແມ່ນໃຫ້, ລາຍການທໍາອິດໃນລໍາດັບ args
ໄດ້​ມາ​ຈາກ cmd ຍັງຖືກປະຕິບັດໂດຍໂຄງການສ່ວນໃຫຍ່ເປັນຊື່ຄໍາສັ່ງ, ເຊິ່ງ
ຫຼັງຈາກນັ້ນສາມາດແຕກຕ່າງຈາກຊື່ປະຕິບັດຕົວຈິງ. ມັນກາຍເປັນຈໍສະແດງຜົນ
ຊື່ສໍາລັບໂຄງການປະຕິບັດໃນຜົນປະໂຫຍດເຊັ່ນ: ps.

· work_dir: ໄດເລກະທໍລີທີ່ເຮັດວຽກເພື່ອດໍາເນີນການຄໍາສັ່ງໃນ. ຖ້າບໍ່ໄດ້ສະຫນອງໃຫ້, ຈະ
ເລີ່ມຕົ້ນເປັນໄດເລກະທໍລີທີ່ເຮັດວຽກໃນປະຈຸບັນ.

· ຫອຍ: ຖ້າ ທີ່ແທ້ຈິງ, ຈະດໍາເນີນການຄໍາສັ່ງໃນສະພາບແວດລ້ອມ shell. ທີ່ບໍ່ຖືກຕ້ອງ ໂດຍຄ່າເລີ່ມຕົ້ນ
ຄຳ ເຕືອນ: ນີ້ is a ຄວາມປອດໄພ ອັນຕະລາຍ.

· uid: ຖ້າໃຫ້, ແມ່ນ id ຜູ້ໃຊ້ຫຼືຊື່ຄໍາສັ່ງຄວນຈະດໍາເນີນການກັບ. ປະຈຸບັນ
uid ແມ່ນຄ່າເລີ່ມຕົ້ນ.

· gid: ຖ້າໃຫ້, ແມ່ນກຸ່ມ id ຫຼືຊື່ຄໍາສັ່ງຄວນຈະດໍາເນີນການກັບ. ປະຈຸບັນ
gid ແມ່ນຄ່າເລີ່ມຕົ້ນ.

· ປະມານ: ແຜນທີ່ທີ່ບັນຈຸຕົວແປສະພາບແວດລ້ອມທີ່ຄໍາສັ່ງຈະດໍາເນີນການກັບ.
ທາງເລືອກ.

· ຂີດຈຳກັດ: ແຜນທີ່ທີ່ມີຊື່ rlimit ແລະຄ່າທີ່ຈະຖືກກໍານົດກ່ອນ
ຄຳສັ່ງແລ່ນ.

· use_fds: ຖ້າຖືກຕ້ອງ, ຈະບໍ່ປິດ fds ໃນຂະບວນການຍ່ອຍ. ຕ້ອງຖືກຕັ້ງເປັນ
ຖືກຕ້ອງໃນ Windows ຖ້າ stdout ຫຼື stderr ຖືກໂອນ. ຄ່າເລີ່ມຕົ້ນ: ບໍ່ຖືກຕ້ອງ.

· pipe_stdout: ຖ້າຖືກຕ້ອງ, ຈະເປີດ PIPE ໃນ stdout. ຄ່າເລີ່ມຕົ້ນ: ຖືກ.

· pipe_stderr: ຖ້າຖືກຕ້ອງ, ຈະເປີດ PIPE ໃນ stderr. ຄ່າເລີ່ມຕົ້ນ: ຖືກ.

· close_child_stdout: ຖ້າຖືກຕ້ອງ, redirects the child process' stdout to /dev/null
ຫຼັງຈາກສ້ອມ. ຄ່າເລີ່ມຕົ້ນ: ບໍ່ຖືກຕ້ອງ.

· close_child_stderr: ຖ້າຖືກຕ້ອງ, redirects the child process' stdout to /dev/null
ຫຼັງຈາກສ້ອມ. ຄ່າເລີ່ມຕົ້ນ: ບໍ່ຖືກຕ້ອງ.

ອາຍຸ() ກັບຄືນອາຍຸຂອງຂະບວນການໃນວິນາທີ.

ເດັກນ້ອຍ
ກັບຄືນບັນຊີລາຍຊື່ຂອງເດັກນ້ອຍ pid.

ຂໍ້ມູນ () ກັບຄືນຂໍ້ມູນຂະບວນການ.

ຂໍ້​ມູນ​ທີ່​ໄດ້​ຮັບ​ແມ່ນ​ການ​ສ້າງ​ແຜນ​ທີ່​ທີ່​ມີ​ກະ​ແຈ​ເຫຼົ່າ​ນີ້​:

· mem_info1: Resident Set Size Memory in bytes (RSS)

· mem_info2: ຂະໜາດຄວາມຈຳສະເໝືອນເປັນໄບຕ໌ (VMS).

· cpu: % ຂອງການໃຊ້ CPU.

· mem: % ຂອງການໃຊ້ຄວາມຈຳ.

· ເວລາ: ປະມວນຜົນ CPU (ຜູ້ໃຊ້ + ລະບົບ) ເວລາເປັນວິນາທີ.

· pid: ID ຂະບວນການ.

· ຊື່ຜູ້ໃຊ້: ຊື່ຜູ້ໃຊ້ທີ່ເປັນເຈົ້າຂອງຂະບວນການ.

· ງາມ: ຄວາມສວຍງາມຂອງຂະບວນການ (ລະຫວ່າງ -20 ແລະ 20)

· cmdline: ເສັ້ນຄໍາສັ່ງທີ່ຂະບວນການໄດ້ຖືກດໍາເນີນການດ້ວຍ.

is_child(pid)
Return True ແມ່ນໃຫ້ pid ແມ່ນລູກຂອງຂະບວນການນັ້ນ.

pid ກັບໄປ pid

send_signal(*args, **kw)
ສົ່ງສັນຍານ sig ກັບຂະບວນການ.

send_signal_child(*args, **kw)
ສົ່ງສັນຍານ ສັນຍາລັກ ກັບເດັກນ້ອຍ pid.

send_signal_children(*args, **kw)
ສົ່ງສັນຍານ ສັນຍາລັກ ແກ່ເດັກນ້ອຍທຸກຄົນ.

ສະຖານະພາບ ສົ່ງຄືນສະຖານະຂະບວນການເປັນຄ່າຄົງທີ່

· ແລ່ນ

· DEAD_OR_ZOMBIE

· ບໍ່ມີຢູ່

· ອື່ນໆ

stderr ກັບໄປ stdout ນ້ໍາ

stdout ກັບໄປ stdout ນ້ໍາ

ຢຸດ(*args, **kw)
ຢຸດຂະບວນການແລະປິດ stdout/stderr

ຖ້າຂະບວນການທີ່ສອດຄ້ອງກັນຍັງຢູ່ທີ່ນີ້ (ປົກກະຕິມັນຖືກຂ້າແລ້ວໂດຍ
the watcher), SIGTERM ຖືກສົ່ງ, ຫຼັງຈາກນັ້ນ SIGKILL ຫຼັງຈາກ 1 ວິນາທີ.

ຂະບວນການປິດ (SIGTERM ຫຼັງຈາກນັ້ນ SIGKILL) ແມ່ນປະຕິບັດໂດຍປົກກະຕິ
ຜູ້ເບິ່ງ. ດັ່ງນັ້ນຖ້າຫາກວ່າຂະບວນການຍັງມີຢູ່ທີ່ນີ້, ມັນເປັນປະເພດຂອງພຶດຕິກໍາທີ່ບໍ່ດີ
ເພາະວ່າການໝົດເວລາອັນສະຫງ່າງາມຈະບໍ່ຖືກເຄົາລົບຢູ່ທີ່ນີ້.

ຕົວຢ່າງ:

>>> ຈາກຂະບວນການນໍາເຂົ້າ circus.process
>>> ຂະບວນການ = ຂະບວນການ('ເທິງ', 'ເທິງ', shell=True)
>>> process.age()
3.0107998847961426
>>> process.info()
'Top: 6812 N/A tarek Zombie N/AN/AN/AN/AN/A'
>>> process.status
1
>>> process.stop()
>>> process.status
2
>>> process.info()
'ບໍ່ມີຂະບວນການດັ່ງກ່າວ (ຢຸດ?)'

ລະດັບ circus.watcher.Watcher(ຊື່, cmd, args=ບໍ່ມີ, numprocesses=1, warmup_delay=0.0,
work_dir=ບໍ່ມີ, shell=ຜິດ, shell_args=ບໍ່ມີ, uid=ບໍ່ມີ, max_retry=5, gid=ບໍ່ມີ,
send_hup=ຜິດ, stop_signal=15, stop_children=ຜິດ, env=ບໍ່ມີ, graceful_timeout=30.0,
prereload_fn=ບໍ່ມີ, rlimits=ບໍ່ມີ, executable=ບໍ່ມີ, stdout_stream=ບໍ່ມີ, stderr_stream=ບໍ່ມີ,
ບູລິມະສິດ=0, loop=ບໍ່ມີ, singleton=ຜິດ, use_sockets=ຜິດ, copy_env=ຜິດ,
copy_path=ຜິດ, max_age=0, max_age_variance=30, hooks=ບໍ່ມີ, respawn=ຈິງ, autostart=ແທ້,
on_demand=ຜິດ, virtualenv=ບໍ່ມີ, close_child_stdout=ຜິດ, close_child_stderr=ຜິດ,
virtualenv_py_ver=ບໍ່ມີ, use_papa=ຜິດ, ** ທາງ​ເລືອກ​)
ຫ້ອງຮຽນຈັດການບັນຊີລາຍຊື່ຂອງຂະບວນການສໍາລັບຄໍາສັ່ງທີ່ໃຫ້.

ຕົວເລືອກ:

· ຊື່: ຊື່ໃຫ້ຜູ້ເບິ່ງ. ໃຊ້ເພື່ອລະບຸມັນຢ່າງເປັນເອກະລັກ.

· cmd: ຄໍາສັ່ງທີ່ຈະດໍາເນີນການ. ອາດມີ $WID, ເຊິ່ງຈະຖືກແທນທີ່ດ້ວຍ ກວ້າງ.

· ໂຕ້ຖຽງ: arguments ສໍາລັບຄໍາສັ່ງທີ່ຈະດໍາເນີນການ. ສາມາດເປັນລາຍການຫຼືສາຍ. ຖ້າ ໂຕ້ຖຽງ is
ຊ່ອຍແນ່, ມັນແບ່ງອອກໂດຍໃຊ້ shlex.split(). ຄ່າເລີ່ມຕົ້ນເປັນບໍ່ມີ.

· ຂະ​ບວນ​ການ​ຈໍາ​ນວນ​: ຈໍານວນຂະບວນການທີ່ຈະດໍາເນີນການ.

· work_dir: ໄດເລກະທໍລີທີ່ເຮັດວຽກເພື່ອດໍາເນີນການຄໍາສັ່ງໃນ. ຖ້າບໍ່ໄດ້ສະຫນອງໃຫ້, ຈະ
ເລີ່ມຕົ້ນເປັນໄດເລກະທໍລີທີ່ເຮັດວຽກໃນປະຈຸບັນ.

· ຫອຍ: ຖ້າ ທີ່ແທ້ຈິງ, ຈະດໍາເນີນການຄໍາສັ່ງໃນສະພາບແວດລ້ອມ shell. ທີ່ບໍ່ຖືກຕ້ອງ ໂດຍຄ່າເລີ່ມຕົ້ນ
ຄຳ ເຕືອນ: ນີ້ is a ຄວາມປອດໄພ ອັນຕະລາຍ.

· uid: ຖ້າໃຫ້, ແມ່ນ id ຜູ້ໃຊ້ຫຼືຊື່ຄໍາສັ່ງຄວນຈະດໍາເນີນການກັບ. ປະຈຸບັນ
uid ແມ່ນຄ່າເລີ່ມຕົ້ນ.

· gid: ຖ້າໃຫ້, ແມ່ນກຸ່ມ id ຫຼືຊື່ຄໍາສັ່ງຄວນຈະດໍາເນີນການກັບ. ປະຈຸບັນ
gid ແມ່ນຄ່າເລີ່ມຕົ້ນ.

· send_hup: ຖ້າຖືກຕ້ອງ, ຂະບວນການໂຫຼດຄືນໃໝ່ຈະເຮັດໄດ້ໂດຍການສົ່ງສັນຍານ SIGHUP.
ຄ່າເລີ່ມຕົ້ນເປັນຜິດ.

· stop_signal: ສັນຍານທີ່ຈະສົ່ງເມື່ອຢຸດຂະບວນການ. ຄ່າເລີ່ມຕົ້ນເປັນ SIGTERM.

· stop_children: ສົ່ງ stop_signal ແກ່ເດັກນ້ອຍຄືກັນ. ຄ່າເລີ່ມຕົ້ນເປັນຜິດ.

· ປະມານ: ແຜນທີ່ທີ່ບັນຈຸຕົວແປສະພາບແວດລ້ອມທີ່ຄໍາສັ່ງຈະດໍາເນີນການກັບ.
ທາງເລືອກ.

· ຂີດຈຳກັດ: ແຜນທີ່ທີ່ມີຊື່ rlimit ແລະຄ່າທີ່ຈະຖືກກໍານົດກ່ອນ
ຄຳສັ່ງແລ່ນ.

· stdout_stream: ແຜນທີ່ກໍານົດການຖ່າຍທອດສໍາລັບຂະບວນການ stdout. ຄ່າເລີ່ມຕົ້ນ
ກັບບໍ່ມີ.

ທາງເລືອກ. ເມື່ອສະຫນອງໃຫ້, stdout_stream ແມ່ນການສ້າງແຜນທີ່ທີ່ມີເຖິງສາມກະແຈ:

· ລະດັບ: ຫ້ອງຮຽນ stream. ຄ່າເລີ່ມຕົ້ນເປັນ circus.stream.FileStream

· ຊື່​ເອ​ກະ​ສານ: ຊື່ໄຟລ໌, ຖ້າໃຊ້ FileStream

· max_bytes: ຂະຫນາດໄຟລ໌ສູງສຸດ, ຫຼັງຈາກນັ້ນໄຟລ໌ຜົນຜະລິດໃຫມ່ຖືກເປີດ. ຄ່າເລີ່ມຕົ້ນ
ເຖິງ 0 ຊຶ່ງຫມາຍຄວາມວ່າບໍ່ມີຂະຫນາດສູງສຸດ (ໃຊ້ໄດ້ກັບ FileStream ເທົ່ານັ້ນ).

· backup_count: ຈໍາ​ນວນ​ຫຼາຍ​ສໍາ​ຮອງ​ຂໍ້​ມູນ​ທີ່​ຈະ​ຮັກ​ສາ​ໃນ​ເວ​ລາ​ທີ່ rotating ໄຟລ​໌​ອີງ​ຕາມ​ການ​
ພາຣາມິເຕີ max_bytes. ຄ່າເລີ່ມຕົ້ນເປັນ 0 ຊຶ່ງຫມາຍຄວາມວ່າບໍ່ມີການສໍາຮອງໃດໆ (ພຽງແຕ່
ໃຊ້ໄດ້ກັບ FileStream)

ການສ້າງແຜນທີ່ນີ້ຈະຖືກໃຊ້ເພື່ອສ້າງສາຍກະແສທີ່ສາມາດໂທໄດ້ໃນຊັ້ນທີ່ລະບຸ.
ແຕ່ລະລາຍການທີ່ໄດ້ຮັບໂດຍ callable ແມ່ນແຜນທີ່ປະກອບດ້ວຍ:

· pid - ຂະບວນການ pid

· ຊື່ - ຊື່​ສາຍ (stderr or stdout)

· ຂໍ້ມູນ - ຂໍ້​ມູນ​

ອັນນີ້ບໍ່ຮອງຮັບໃນ Windows.

· stderr_stream: ແຜນທີ່ກໍານົດການຖ່າຍທອດສໍາລັບ stderr ຂະບວນການ. ຄ່າເລີ່ມຕົ້ນ
ກັບບໍ່ມີ.

ທາງເລືອກ. ເມື່ອສະຫນອງໃຫ້, stderr_stream ແມ່ນການສ້າງແຜນທີ່ທີ່ມີເຖິງສາມກະແຈ:
- ລະດັບ: ຫ້ອງຮຽນ stream. ຄ່າເລີ່ມຕົ້ນເປັນ circus.stream.FileStream - ຊື່​ເອ​ກະ​ສານ: the
ຊື່ໄຟລ໌, ຖ້າໃຊ້ FileStream - max_bytes: ຂະຫນາດໄຟລ໌ສູງສຸດ, ຫຼັງຈາກນັ້ນມີໃຫມ່
ໄຟລ໌ຜົນຜະລິດແມ່ນ
ເປີດ. defaults ເປັນ 0 ຊຶ່ງຫມາຍຄວາມວ່າບໍ່ມີຂະຫນາດສູງສຸດ (ໃຊ້ໄດ້ກັບ
FileStream)

· backup_count: ຈໍາ​ນວນ​ຫຼາຍ​ສໍາ​ຮອງ​ຂໍ້​ມູນ​ທີ່​ຈະ​ຮັກ​ສາ​ໃນ​ເວ​ລາ​ທີ່ rotating ໄຟລ​໌​ອີງ​ຕາມ​ການ​
ພາຣາມິເຕີ max_bytes. ຄ່າເລີ່ມຕົ້ນເປັນ 0 ຊຶ່ງຫມາຍຄວາມວ່າບໍ່ມີການສໍາຮອງໃດໆ (ພຽງແຕ່
ໃຊ້ໄດ້ກັບ FileStream).

ການສ້າງແຜນທີ່ນີ້ຈະຖືກໃຊ້ເພື່ອສ້າງສາຍກະແສທີ່ສາມາດໂທໄດ້ໃນຊັ້ນທີ່ລະບຸ.

ແຕ່ລະລາຍການທີ່ໄດ້ຮັບໂດຍ callable ແມ່ນແຜນທີ່ປະກອບດ້ວຍ:

· pid - ຂະບວນການ pid

· ຊື່ - ຊື່​ສາຍ (stderr or stdout)

· ຂໍ້ມູນ - ຂໍ້​ມູນ​

ອັນນີ້ບໍ່ຮອງຮັບໃນ Windows.

· ບູລິມະສິດ -- ຈຳນວນເຕັມທີ່ກຳນົດຄວາມສຳຄັນສຳລັບຜູ້ເບິ່ງ. ໃນເວລາທີ່ Arbiter ເຮັດ
ການ​ດໍາ​ເນີນ​ງານ​ບາງ​ຢ່າງ​ກ່ຽວ​ກັບ​ການ watchers ທັງ​ຫມົດ​, ມັນ​ຈະ​ຈັດ​ລຽງ​ລໍາ​ດັບ​ໃຫ້​ເຂົາ​ເຈົ້າ​ກັບ​ພາກ​ສະ​ຫນາມ​ນີ້​, ຈາກ​
ຈໍານວນໃຫຍ່ໄປຫານ້ອຍທີ່ສຸດ. (ຄ່າເລີ່ມຕົ້ນ: 0)

· singleton -- ຖ້າເປັນຄວາມຈິງ, ຜູ້ເບິ່ງນີ້ມີຂະບວນການດຽວ. (ຄ່າເລີ່ມຕົ້ນ: ບໍ່ຖືກຕ້ອງ)

· use_sockets -- ຖ້າຖືກຕ້ອງ, ຂະບວນການຕ່າງໆຈະສືບທອດຕົວອະທິບາຍໄຟລ໌, ດັ່ງນັ້ນຈຶ່ງສາມາດເຮັດໄດ້
ໃຊ້ຊັອກເກັດທີ່ເປີດໂດຍ circusd ຄືນໃໝ່. (ຄ່າເລີ່ມຕົ້ນ: ບໍ່ຖືກຕ້ອງ)

· on_demand -- ຖ້າຖືກຕ້ອງ, ຂະບວນການຕ່າງໆຈະຖືກເລີ່ມຕົ້ນພຽງແຕ່ໃນການເຊື່ອມຕໍ່ຄັ້ງທໍາອິດ
ໄປຫາເຕົ້າຮັບ (ຄ່າເລີ່ມຕົ້ນ: ຜິດ)

· copy_env -- ຖ້າເປັນຈິງ, ສະພາບແວດລ້ອມທີ່ circus ແລ່ນແລ່ນຈະເປັນ
ແຜ່ພັນສໍາລັບຄົນງານ. ນີ້ເປັນຄ່າເລີ່ມຕົ້ນເປັນ True ໃນ Windows ຍ້ອນວ່າທ່ານບໍ່ສາມາດດໍາເນີນການໄດ້
ປະຕິບັດໄດ້ໂດຍບໍ່ມີການ ລະບົບ ຕົວແປ. (ຄ່າເລີ່ມຕົ້ນ: ບໍ່ຖືກຕ້ອງ)

· copy_path -- ຖ້າເປັນຄວາມຈິງ, circusd sys.path ຖືກສົ່ງໄປຫາຂະບວນການໂດຍຜ່ານ ໄພທອນພົດ.
ທ່ານຕ້ອງເປີດໃຊ້ງານ copy_env ສໍາລັບການ copy_path ເຮັດ​ວຽກ. (ຄ່າເລີ່ມຕົ້ນ: ບໍ່ຖືກຕ້ອງ)

· ສູງສຸດ_ອາຍຸ: ຖ້າຕັ້ງຫຼັງຈາກປະມານ max_age ວິນາທີ, ຂະບວນການຈະຖືກແທນທີ່ດ້ວຍອັນໃໝ່
ຫນຶ່ງ. (ຄ່າເລີ່ມຕົ້ນ: 0, Disabled)

· max_age_variance: ຈຳນວນສູງສຸດຂອງວິນາທີທີ່ສາມາດເພີ່ມໃສ່ max_age.
ມູນຄ່າເພີ່ມເຕີມນີ້ແມ່ນເພື່ອຫຼີກເວັ້ນການ restart ຂະບວນການທັງຫມົດໃນເວລາດຽວກັນ. ກ
ຂະບວນການຈະມີຊີວິດຢູ່ລະຫວ່າງ max_age ແລະ max_age + max_age_variance ວິນາທີ.

· hooks: ຟັງຊັນໂທກັບເພື່ອເຊື່ອມຕໍ່ການເລີ່ມຕົ້ນ ແລະປິດເຄື່ອງຂອງ watcher
ຂະບວນການ. hooks ແມ່ນຄຳສັ່ງທີ່ແຕ່ລະຄີແມ່ນຊື່ hook ແລະແຕ່ລະຄ່າແມ່ນ a
2-tuple ທີ່ມີຊື່ຂອງ callable ຫຼື callabled ຕົວຂອງມັນເອງແລະທຸງ boolean
ການຊີ້ບອກວ່າການຍົກເວັ້ນທີ່ເກີດຂື້ນໃນ hook ບໍ່ຄວນຖືກລະເລີຍ. ເປັນໄປໄດ້
ຄ່າສໍາລັບຊື່ hook: ກ່ອນ_ເລີ່ມ, after_start, before_spawn, after_spawn,
ກ່ອນ_ຢຸດ, after_stop., ກ່ອນ_ສັນຍານ, after_signal or ສະຖິຕິຂະຫຍາຍ.

· ທາງເລືອກໃນການ -- ທາງ​ເລືອກ​ພິ​ເສດ​ສໍາ​ລັບ​ພະ​ນັກ​ງານ​. ທາງເລືອກທັງຫມົດທີ່ພົບເຫັນຢູ່ໃນການຕັ້ງຄ່າ
ຕົວຢ່າງ, ໄຟລ໌ຖືກສົ່ງຜ່ານໃນແຜນທີ່ນີ້ - ນີ້ສາມາດຖືກນໍາໃຊ້ໂດຍ plugins ສໍາລັບ
ຕົວເລືອກສະເພາະຂອງຜູ້ຊົມ.

· ຟື້ນຄືນ -- ຖ້າຕັ້ງເປັນ False, ຂະບວນການທີ່ຈັດການໂດຍ watcher ຈະບໍ່ເປັນ
respawned ອັດ​ຕະ​ໂນ​ມັດ​. (ຄ່າເລີ່ມຕົ້ນ: ຖືກ)

· virtualenv -- ໄດເລກະທໍລີຮາກຂອງ virtualenv. ຖ້າສະຫນອງໃຫ້, watcher ຈະ
ໂຫຼດສະພາບແວດລ້ອມສໍາລັບການປະຕິບັດຂອງມັນ. (ຄ່າເລີ່ມຕົ້ນ: ບໍ່ມີ)

· close_child_stdout: ຖ້າຖືກຕ້ອງ, ປິດ stdout ຫຼັງຈາກສ້ອມ. ຄ່າເລີ່ມຕົ້ນ: ບໍ່ຖືກຕ້ອງ.

· close_child_stderr: ຖ້າຖືກຕ້ອງ, ປິດ stderr ຫຼັງຈາກສ້ອມ. ຄ່າເລີ່ມຕົ້ນ: ບໍ່ຖືກຕ້ອງ.

· ໃຊ້_papa: ຖ້າຖືກຕ້ອງ, ໃຊ້ kernel ຂະບວນການ papa ສໍາລັບຂະບວນການນີ້. ຄ່າເລີ່ມຕົ້ນ: ບໍ່ຖືກຕ້ອງ.

kill_process(*args, ** kwargs)
ຂະບວນການຂ້າ (stop_signal, graceful_timeout ຈາກນັ້ນ SIGKILL)

kill_processes(*args, ** kwargs)
ຂ້າຂະບວນການທັງໝົດ (stop_signal, graceful_timeout ຈາກນັ້ນ SIGKILL)

manage_processes(*args, ** kwargs)
ຈັດການຂະບວນການ.

notify_event(ຫົວຂໍ້, ຂໍ້ຄວາມ)
ເຜີຍແຜ່ຂໍ້ຄວາມໃນຊ່ອງຜູ້ເຜີຍແຜ່ເຫດການ

reap_and_manage_processes(*args, ** kwargs)
ເກັບກ່ຽວ ແລະຈັດການຂະບວນການ.

reap_processes(*args, **kw)
Reap ຂະບວນການທັງຫມົດສໍາລັບ watcher ນີ້.

send_signal_child(*args, **kw)
ສົ່ງສັນຍານໃຫ້ເດັກນ້ອຍ.

spawn_process(recovery_wid=ບໍ່ມີ)
ຂະບວນການວາງໄຂ່.

ກັບຄືນ True ຖ້າຕົກລົງ, False ຖ້າຜູ້ເບິ່ງຕ້ອງຖືກຢຸດ

spawn_processes(*args, ** kwargs)
ຂະບວນການວາງໄຂ່.

ລະດັບ circus.arbiter.Arbiter(ຜູ້ເບິ່ງ, ຈຸດ​ສຸດ​ທ້າຍ​, pubsub_endpoint, check_delay=1.0,
prereload_fn=ບໍ່ມີ, context=ບໍ່ມີ, loop=ບໍ່ມີ, statsd=ຜິດ, stats_endpoint=ບໍ່ມີ,
statsd_close_outputs=ຜິດ, multicast_endpoint=ບໍ່ມີ, plugins=ບໍ່ມີ, sockets=ບໍ່ມີ,
warmup_delay=0, httpd=ຜິດ, httpd_host='localhost', httpd_port=8080,
httpd_close_outputs=ຜິດ, debug=ຜິດ, debug_gc=ຜິດ, ssh_server=ບໍ່ມີ,
proc_name='circusd', pidfile=ບໍ່ມີ, loglevel=ບໍ່ມີ, logoutput=ບໍ່ມີ, loggerconfig=ບໍ່ມີ,
fqdn_prefix=ບໍ່ມີ, umask=ບໍ່ມີ, endpoint_owner=ບໍ່ມີ, papa_endpoint=ບໍ່ມີ)
ຫ້ອງຮຽນໃຊ້ເພື່ອຄວບຄຸມລາຍຊື່ຜູ້ເບິ່ງ.

ຕົວເລືອກ:

· watchers -- ບັນຊີລາຍຊື່ຂອງວັດຖຸ Watcher

· endpoint -- ຈຸດສິ້ນສຸດຂອງຕົວຄວບຄຸມ ZMQ

· pubsub_endpoint -- ຈຸດສິ້ນສຸດ pubsub

· ສະຖິຕິ -- ຖ້າຖືກຕ້ອງ, ຂະບວນການ circusd-stats ຖືກແລ່ນ (ຄ່າເລີ່ມຕົ້ນ: False)

· stats_endpoint -- ຈຸດສຸດທ້າຍຂອງສະຖິຕິ.

· statsd_close_outputs -- ຖ້າ True ສົ່ງ circusd-stats stdout/stderr ໄປຫາ
/dev/null (ຄ່າເລີ່ມຕົ້ນ: False)

· multicast_endpoint -- ຈຸດສິ້ນສຸດ multicast ສໍາລັບການຄົ້ນພົບອັດຕະໂນມັດຂອງກຸ່ມ circusd
(ຄ່າເລີ່ມຕົ້ນ: udp://237.219.251.97:12027) Multicast addr ຄວນຢູ່ລະຫວ່າງ 224.0.0.0
ເປັນ 239.255.255.255 ແລະດຽວກັນກັບກຸ່ມທັງໝົດ.

· check_delay -- ຄວາມລ່າຊ້າລະຫວ່າງສອງຈຸດຄວບຄຸມ (ຄ່າເລີ່ມຕົ້ນ: 1 ວິນາທີ)

· prereload_fn -- callable ທີ່​ຈະ​ໄດ້​ຮັບ​ການ​ປະ​ຕິ​ບັດ​ໃນ​ແຕ່​ລະ reload (ຄ່າ​ເລີ່ມ​ຕົ້ນ​: ບໍ່​ມີ​)

· context -- ຖ້າສະຫນອງໃຫ້, zmq context ທີ່ຈະໃຊ້ຄືນ. (ຄ່າເລີ່ມຕົ້ນ: ບໍ່ມີ)

·

ວົງ: if ສະຫນອງໃຫ້, a zmq.eventloop.ioloop.IOLoop ຕົວຢ່າງ
ໃຊ້ຄືນ. (ຄ່າເລີ່ມຕົ້ນ: ບໍ່ມີ)

· plugins -- ບັນຊີລາຍຊື່ຂອງ plugins. ແຕ່ລະລາຍການແມ່ນແຜນທີ່ທີ່ມີ:

· ການນໍາໃຊ້ -- ຊື່ທີ່ມີຄຸນສົມບັດຄົບຖ້ວນທີ່ຊີ້ໃຫ້ເຫັນເຖິງຊັ້ນ plugin

· ທຸກໆຄ່າອື່ນໆຖືກສົ່ງກັບ plugin ໃນ config ທາງເລືອກ

· ເຕົ້າຮັບ -- ການສ້າງແຜນທີ່ຂອງເຕົ້າຮັບ. ແຕ່ລະຄີແມ່ນຊື່ socket, ແລະແຕ່ລະຄ່າ a
CircusSocket ຫ້ອງຮຽນ. (ຄ່າເລີ່ມຕົ້ນ: ບໍ່ມີ)

· warmup_delay -- ຄວາມລ່າຊ້າໃນວິນາທີລະຫວ່າງສອງຜູ້ເບິ່ງການເລີ່ມຕົ້ນ. (ຄ່າເລີ່ມຕົ້ນ: 0)

· httpd -- ຖ້າຖືກຕ້ອງ, ຂະບວນການ circushttpd ຖືກແລ່ນ (ຄ່າເລີ່ມຕົ້ນ: False)

· httpd_host -- ເຈົ້າພາບ circushttpd (ຄ່າເລີ່ມຕົ້ນ: localhost)

· httpd_port -- ພອດ circushttpd (ຄ່າເລີ່ມຕົ້ນ: 8080)

· httpd_close_outputs -- ຖ້າຖືກຕ້ອງ, ສົ່ງ circushttpd stdout/stderr ໄປ /dev/null.
(ຄ່າເລີ່ມຕົ້ນ: ບໍ່ຖືກຕ້ອງ)

· debug -- ຖ້າຖືກ, ເພີ່ມຂໍ້ມູນດີບັກຫຼາຍໃນ stdout (ຄ່າເລີ່ມຕົ້ນ: False)

· debug_gc -- ຖ້າເປັນແມ່ນ, gc.set_debug(gc.DEBUG_LEAK) (ຄ່າເລີ່ມຕົ້ນ: False) ໄປ circusd
ວິເຄາະບັນຫາ (ຄ່າເລີ່ມຕົ້ນ: ບໍ່ຖືກຕ້ອງ)

· proc_name -- ຊື່ຂະບວນການ arbiter

·

fqdn_prefix -- a ຄຳ ນຳ ໜ້າ ສໍາລັບການ ໄດ້ ເປັນເອກະລັກ ຕົວລະບຸ of ໄດ້ circus
ຕົວຢ່າງໃນກຸ່ມ.

· endpoint_owner -- ຜູ້ໃຊ້ unix ເພື່ອ chown ຈຸດສິ້ນສຸດໄປຖ້າໃຊ້ ipc.

· papa_endpoint -- ຈຸດສິ້ນສຸດ kernel ຂະບວນການ papa

add_watcher(*args, ** kwargs)
ເພີ່ມຜູ້ເບິ່ງ.

ຕົວເລືອກ:

· ຊື່: ຊື່ຂອງ watcher ທີ່ຈະເພີ່ມ

· cmd: ຄໍາສັ່ງທີ່ຈະດໍາເນີນການ.

· ທາງເລືອກອື່ນທັງໝົດທີ່ກຳນົດໄວ້ໃນຕົວສ້າງ Watcher.

get_watcher(ຊື່)
ສົ່ງຄືນຜູ້ເບິ່ງ ຊື່.

ຂະບວນການຈໍານວນ ()
ສົ່ງຄືນຈຳນວນຂະບວນການທີ່ແລ່ນຜ່ານຜູ້ເບິ່ງທັງໝົດ.

ຕົວເລກ ()
ກັບຄືນຈໍານວນຜູ້ເບິ່ງ.

reload(*args, ** kwargs)
ໂຫຼດທຸກຢ່າງຄືນໃໝ່.

ດໍາເນີນການ prereload_fn() ສາມາດໂທໄດ້ຖ້າມີ, ຈາກນັ້ນໂຫຼດຜູ້ເບິ່ງທັງໝົດຄືນໃໝ່ຢ່າງສະຫງ່າງາມ.

ເລີ່ມ(*args, ** kwargs)
ເລີ່ມຕົ້ນ watchers ທັງຫມົດ.

ຖ້າ ioloop ໄດ້ຖືກສະຫນອງໃຫ້ໃນລະຫວ່າງການໂທ __init__(), ເລີ່ມຕົ້ນຜູ້ເບິ່ງທັງຫມົດ
ເປັນ coroutine ມາດຕະຖານ

ຖ້າ ioloop ຍັງບໍ່ໄດ້ສະຫນອງໃຫ້ໃນລະຫວ່າງການ __init__() call (ຄ່າເລີ່ມຕົ້ນ), ເລີ່ມຕົ້ນ
watchers ທັງຫມົດແລະ eventloop (ແລະຕັນທີ່ນີ້). ໃນ​ຮູບ​ແບບ​ນີ້​ວິ​ທີ​ການ​
ບໍ່ຕ້ອງໃຫ້ຜົນຕອບແທນອັນໃດ ເພາະມັນເອີ້ນວ່າເປັນວິທີມາດຕະຖານ.

ຕົວກໍານົດການ
cb -- Callback ໂທຫາຫຼັງຈາກ watchers ທັງຫມົດໄດ້ຖືກເລີ່ມຕົ້ນ, ໃນເວລາທີ່
loop ບໍ່ໄດ້ສະຫນອງໃຫ້.

ລາຍລັກອັກສອນ plugins
Circus ມາພ້ອມກັບລະບົບ plugin ທີ່ຊ່ວຍໃຫ້ທ່ານສາມາດພົວພັນກັບ ວົງວຽນ.

ຫມາຍ​ເຫດ​:
ພວກເຮົາອາດຈະເພີ່ມການສະຫນັບສະຫນູນ circusd-stats ກັບ plugins ຕໍ່ມາ.

Plugin ປະກອບດ້ວຍສອງສ່ວນ:

·ເປັນ ZMQ ຈອງກັບເຫດການທັງຫມົດທີ່ຈັດພີມມາໂດຍ ວົງວຽນ

·ລູກຄ້າ ZMQ ເພື່ອສົ່ງຄໍາສັ່ງໄປຫາ ວົງວຽນ

ແຕ່ລະ plugin ແມ່ນດໍາເນີນການເປັນຂະບວນການແຍກຕ່າງຫາກພາຍໃຕ້ watcher ກໍານົດເອງ.

ບາງຕົວຢ່າງຂອງບາງ plugins ທີ່ທ່ານສາມາດສ້າງດ້ວຍລະບົບນີ້:

· ລະບົບການແຈ້ງເຕືອນທີ່ສົ່ງການແຈ້ງເຕືອນທາງອີເມລເມື່ອຜູ້ເຝົ້າລະວັງກຳລັງກະພິບ

· ຄົນຕັດໄມ້

· ເຄື່ອງມືທີ່ເພີ່ມ ຫຼືກຳຈັດຂະບວນການ ຂຶ້ນກັບການໂຫຼດ

· ອື່ນໆ.

Circus ຕົວຂອງມັນເອງມາພ້ອມກັບ plugins ກໍ່ສ້າງໃນຈໍານວນຫນ້ອຍ.

ໄດ້ CircusPlugin ລະດັບ
Circus ໃຫ້ຫ້ອງຮຽນພື້ນຖານເພື່ອຊ່ວຍໃຫ້ທ່ານປະຕິບັດ plugins: circus.plugins.CircusPlugin

ລະດັບ circus.plugins.CircusPlugin(ຈຸດຈົບ, pubsub_endpoint, check_delay, ssh_server=ບໍ່ມີ,
** ການ​ຕັ້ງ​ຄ່າ​)
ຫ້ອງຮຽນພື້ນຖານເພື່ອຂຽນ plugins.

ຕົວເລືອກ:

· context -- ບໍລິບົດ ZMQ ທີ່ຈະໃຊ້

· endpoint -- ຈຸດສິ້ນສຸດຂອງ circusd ZMQ

· pubsub_endpoint -- ຈຸດສິ້ນສຸດ ZMQ pub/sub circusd

· check_delay -- ການ​ຊັກ​ຊ້າ​ການ​ກວດ​ສອບ​ການ​ຕັ້ງ​ຄ່າ​

· config -- ການສ້າງແຜນທີ່ຟຣີ

ໂທ (ຄໍາສັ່ງ, ** ອຸ​ປະ​ກອນ​)
ສົ່ງຄໍາສັ່ງໄປ ວົງວຽນ

ຕົວເລືອກ:

· ຄໍາສັ່ງ -- ຄໍາສັ່ງທີ່ຈະໂທຫາ

· props -- ຄໍາໂຕ້ຖຽງຄໍາສໍາຄັນທີ່ຈະເພີ່ມໃສ່ການໂທ

ສົ່ງຄືນແຜນທີ່ JSON ທີ່ສົ່ງຄືນໂດຍ ວົງວຽນ

cast (ຄໍາສັ່ງ, ** ອຸ​ປະ​ກອນ​)
ໄຟແລະລືມຄໍາສັ່ງທີ່ຈະ ວົງວຽນ

ຕົວເລືອກ:

· ຄໍາສັ່ງ -- ຄໍາສັ່ງທີ່ຈະໂທຫາ

· props -- ຄໍາໂຕ້ຖຽງຄໍາສໍາຄັນທີ່ຈະເພີ່ມໃສ່ການໂທ

handle_init()
ໂທຫາທັນທີກ່ອນທີ່ຈະເລີ່ມ plugin - ໃນຫົວຂໍ້ຫົວຂໍ້.

handle_recv(ຂໍ້ມູນ)
ຮັບທຸກເຫດການທີ່ພິມເຜີຍແຜ່ໂດຍ ວົງວຽນ

ຕົວເລືອກ:

· ຂໍ້ມູນ -- tuple ທີ່ປະກອບດ້ວຍຫົວຂໍ້ແລະຂໍ້ຄວາມ.

handle_stop()
ໂທຫາທັນທີກ່ອນທີ່ plugin ຈະຖືກຢຸດໂດຍ Circus.

ໃນເວລາທີ່ເລີ່ມຕົ້ນໂດຍ Circus, ຫ້ອງຮຽນນີ້ສ້າງ loop ເຫດການຂອງຕົນເອງທີ່ໄດ້ຮັບທັງຫມົດ
ວົງວຽນ ເຫດການແລະໃຫ້ພວກເຂົາຜ່ານໄປ handle_recv(). ຂໍ້ມູນທີ່ໄດ້ຮັບແມ່ນ tuple ທີ່ປະກອບດ້ວຍ
ຫົວຂໍ້ແລະຂໍ້ມູນຂອງມັນເອງ.

handle_recv() ຕ້ອງ ຖືກປະຕິບັດໂດຍ plugin.

ໄດ້ ໂທ() ແລະ cast() ວິທີການສາມາດຖືກນໍາໃຊ້ເພື່ອພົວພັນກັບ ວົງວຽນ ຖ້າທ່ານກໍາລັງສ້າງ a
ປລັກອິນທີ່ມີປະຕິກິລິຍາຢ່າງຈິງຈັງກັບ daemon.

handle_init() ແລະ handle_stop() ແມ່ນພຽງແຕ່ວິທີການສະດວກທີ່ທ່ານສາມາດນໍາໃຊ້ເພື່ອເລີ່ມຕົ້ນແລະ
ເຮັດຄວາມສະອາດລະຫັດຂອງທ່ານ. handle_init() ເອີ້ນວ່າພາຍໃນກະທູ້ທີ່ຫາກໍ່ເລີ່ມຕົ້ນ.
handle_stop() ຖືກເອີ້ນວ່າຢູ່ໃນກະທູ້ຕົ້ນຕໍກ່ອນທີ່ກະທູ້ຈະຖືກຢຸດແລະເຂົ້າຮ່ວມ.

ລາຍລັກອັກສອນ a plugin
ໃຫ້ຂຽນ plugin ທີ່ບັນທຶກໃນໄຟລ໌ທຸກໆເຫດການທີ່ເກີດຂຶ້ນໃນ ວົງວຽນ. ມັນໃຊ້ເວລາຫນຶ່ງ
argument ຊຶ່ງເປັນຊື່ໄຟລ໌.

plugin ອາດຈະເບິ່ງຄືວ່ານີ້:

ຈາກ circus.plugins ນໍາເຂົ້າ CircusPlugin

class Logger(CircusPlugin):

ຊື່ = 'ຜູ້ຕັດໄມ້'

def __init__(ຕົນເອງ, *args, **config):
super(logger, ຕົນເອງ).__init__(*args, **config)
self.filename = config.get('filename')
self.file = ບໍ່ມີ

def handle_init(ຕົວ​ເອງ):
self.file = open(self.filename, 'a+', buffering=1)

def handle_stop(ຕົວ​ເອງ):
self.file.close()

def handle_recv(ຕົນເອງ, ຂໍ້ມູນ):
watcher_name, action, msg = self.split_data(ຂໍ້ມູນ)
msg_dict = self.load_message(ຂໍ້ຄວາມ)
self.file.write('%s %s::%r\n' % (action, watcher_name, msg_dict))

ນັ້ນ​ແມ່ນ​ມັນ ! ຫ້ອງຮຽນນີ້ສາມາດຖືກບັນທຶກໄວ້ໃນຊຸດ / ໂມດູນໃດກໍ່ຕາມ, ຕາບໃດທີ່ມັນສາມາດເຫັນໄດ້ໂດຍ
ງູ.

ຍົກ​ຕົວ​ຢ່າງ, ຊ່າງຕັດໄມ້ ອາດຈະພົບເຫັນຢູ່ໃນ a plugins ໂມດູນພາຍໃນ a ໂຄງການຂອງຂ້ອຍ package

ບໍ່ກົງກັນ ການຮ້ອງຂໍ
ໃນ​ກໍ​ລະ​ນີ​ທີ່​ທ່ານ​ຕ້ອງ​ການ​ທີ່​ຈະ​ເຮັດ​ໃຫ້​ການ​ດໍາ​ເນີນ​ງານ asynchronous ໃດ​ຫນຶ່ງ (ເຊັ່ນ​: ໂທ​ນາ​ໂດ​ຫຼື​ການ​ນໍາ​ໃຊ້​
periodicCall) ໃຫ້ແນ່ໃຈວ່າທ່ານກໍາລັງໃຊ້ loop ທີ່ຖືກຕ້ອງ. loop ທີ່ເຈົ້າຕ້ອງການໃຊ້ຢູ່ສະເໝີ
ແມ່ນ self.loop ຍ້ອນວ່າມັນຖືກຕັ້ງຄ່າໂດຍຫ້ອງຮຽນພື້ນຖານ. loop ເລີ່ມຕົ້ນມັກຈະບໍ່ຄືກັນ
ແລະດັ່ງນັ້ນລະຫັດອາດຈະບໍ່ໄດ້ຮັບການປະຕິບັດຕາມທີ່ຄາດໄວ້.

ພະຍາຍາມ a plugin
ທ່ານ​ສາ​ມາດ​ດໍາ​ເນີນ​ການ plugin ໄດ້​ໂດຍ​ຜ່ານ​ບັນ​ຊີ​ຄໍາ​ສັ່ງ​ທີ່​ມີ​ circus-plugin ຄໍາສັ່ງ, ໂດຍ
ການ​ລະ​ບຸ​ຊື່ plugin ທີ່​ມີ​ຄຸນ​ສົມ​ບັດ​ຢ່າງ​ເຕັມ​ທີ່​:

$ circus-plugin --endpoint tcp://127.0.0.1:5555 --pubsub tcp://127.0.0.1:5556 --config filename:circus-events.log myproject.plugins.Logger
[INFO] ກຳລັງໂຫຼດປລັກອິນ...
[INFO] ຈຸດຈົບ: 'tcp://127.0.0.1:5555'
[INFO] Pub/sub: 'tcp://127.0.0.1:5556'
[INFO] ເລີ່ມ

ອີກວິທີຫນຶ່ງທີ່ຈະດໍາເນີນການ plugin ແມ່ນເພື່ອໃຫ້ Circus ຈັດການການເລີ່ມຕົ້ນຂອງມັນ. ນີ້ແມ່ນເຮັດໄດ້ໂດຍ
ເພີ່ມ a [ປລັກອິນ:NAME] ພາກສ່ວນໃນໄຟລ໌ການຕັ້ງຄ່າ, ບ່ອນທີ່ NAME ເປັນຊື່ທີ່ເປັນເອກະລັກສໍາລັບ
ປລັກອິນຂອງເຈົ້າ:

[ປລັກອິນ:logger]
use = myproject.plugins.Logger
filename = /var/myproject/circus.log

ການນໍາໃຊ້ ແມ່ນບັງຄັບແລະຊີ້ໃຫ້ເຫັນເຖິງຊື່ທີ່ມີຄຸນສົມບັດຢ່າງເຕັມທີ່ຂອງ plugin.

ໃນເວລາທີ່ Circus ເລີ່ມຕົ້ນ, ມັນສ້າງ watcher ທີ່ມີຂະບວນການຫນຶ່ງທີ່ດໍາເນີນການຫ້ອງຮຽນຈຸດ, ແລະ
ຜ່ານຕົວແປອື່ນໆທີ່ມີຢູ່ໃນພາກໄປຫາຕົວສ້າງ plugin ຜ່ານທາງ config
ແຜນທີ່.

ທ່ານຍັງສາມາດເພີ່ມ plugins ໃນການຂຽນໂປຼແກຼມເມື່ອທ່ານສ້າງ a circus.arbiter.Arbiter ລະດັບ
ຫຼືການນໍາໃຊ້ circus.get_arbiter(), ເບິ່ງຫ້ອງສະຫມຸດ.

Performances
ເນື່ອງຈາກທຸກໆ plugin ໄດ້ຖືກໂຫລດໃນຂະບວນການຂອງຕົນເອງ, ມັນບໍ່ຄວນສົ່ງຜົນກະທົບຕໍ່ໂດຍລວມ
ການປະຕິບັດຂອງລະບົບຕາບໃດທີ່ການເຮັດວຽກຂອງ plugin ບໍ່ໄດ້ເຮັດຫຼາຍເກີນໄປ
ໂທຫາໄດ້ ວົງວຽນ ຂະບວນການ.

Hooks
Circus ໃຫ້ hooks ທີ່ສາມາດຖືກນໍາໃຊ້ເພື່ອກະຕຸ້ນການປະຕິບັດຕາມເຫດການ watcher. ມີໃຫ້
hooks ແມ່ນ:

· ກ່ອນ_ເລີ່ມ: ເອີ້ນວ່າກ່ອນທີ່ຈະ watcher ໄດ້ເລີ່ມຕົ້ນ. ຖ້າ hook ກັບຄືນມາ ທີ່ບໍ່ຖືກຕ້ອງ ໄດ້
ການເລີ່ມຕົ້ນຖືກຍົກເລີກ.

· after_start: ເອີ້ນວ່າຫຼັງຈາກ watcher ໄດ້ເລີ່ມຕົ້ນ. ຖ້າ hook ກັບຄືນມາ ທີ່ບໍ່ຖືກຕ້ອງ ເບິ່ງ
ຖືກຢຸດທັນທີແລະການເລີ່ມຕົ້ນແມ່ນຍົກເລີກ.

· before_spawn: ເອີ້ນວ່າກ່ອນທີ່ຈະ watcher spawns ຂະບວນການໃຫມ່. ຖ້າ hook ກັບຄືນມາ ທີ່ບໍ່ຖືກຕ້ອງ
watcher ໄດ້ຖືກຢຸດເຊົາໃນທັນທີແລະການເລີ່ມຕົ້ນໄດ້ຖືກຍົກເລີກ.

· after_spawn: ເອີ້ນວ່າຫຼັງຈາກ watcher spawns ຂະບວນການໃຫມ່. ຖ້າ hook ກັບຄືນມາ ທີ່ບໍ່ຖືກຕ້ອງ
watcher ໄດ້ຖືກຢຸດເຊົາໃນທັນທີແລະການເລີ່ມຕົ້ນໄດ້ຖືກຍົກເລີກ.

· ກ່ອນ_ຢຸດ: ເອີ້ນວ່າກ່ອນທີ່ຈະ watcher ໄດ້ຖືກຢຸດເຊົາ. ຜົນລັບຂອງ hook ແມ່ນຖືກລະເລີຍ.

· after_stop: ເອີ້ນວ່າຫຼັງຈາກ watcher ໄດ້ຢຸດເຊົາ. ຜົນລັບຂອງ hook ແມ່ນຖືກລະເລີຍ.

· ກ່ອນ_ສັນຍານ: ເອີ້ນວ່າກ່ອນທີ່ສັນຍານຈະຖືກສົ່ງໄປຫາຂະບວນການຂອງ watcher. ຖ້າຫາກວ່າ hook ໄດ້
ກັບຄືນມາ ທີ່ບໍ່ຖືກຕ້ອງ ສັນ​ຍານ​ບໍ່​ໄດ້​ຖືກ​ສົ່ງ (ຍົກ​ເວັ້ນ SIGKILL ທີ່​ຖືກ​ສົ່ງ​ສະ​ເຫມີ​ໄປ​)

· after_signal: ເອີ້ນວ່າຫຼັງຈາກສັນຍານຖືກສົ່ງໄປຫາຂະບວນການຂອງ watcher.

· ສະຖິຕິຂະຫຍາຍ: ເອີ້ນວ່າເມື່ອສະຖິຕິຖືກຮ້ອງຂໍດ້ວຍ extended=True. ໃຊ້ສໍາລັບການເພີ່ມ
ສະຖິຕິຂະບວນການສະເພາະຕໍ່ກັບຜົນຜະລິດສະຖິຕິປົກກະຕິ.

ຍົກຕົວຢ່າງ
ກໍລະນີການນໍາໃຊ້ປົກກະຕິແມ່ນເພື່ອຄວບຄຸມວ່າເງື່ອນໄຂທັງຫມົດແມ່ນບັນລຸໄດ້ສໍາລັບຂະບວນການທີ່ຈະເລີ່ມຕົ້ນ.
ໃຫ້ເວົ້າວ່າທ່ານມີ watcher ທີ່ແລ່ນ Redis ແລະຜູ້ເບິ່ງທີ່ແລ່ນສະຄິບ Python ນັ້ນ
ເຮັດວຽກຮ່ວມກັບ Redis. ດ້ວຍ Circus ທ່ານສາມາດສັ່ງການເລີ່ມຕົ້ນໂດຍການໃຊ້ ບູລິມະສິດ ຕົວເລືອກ:

[ຜູ້ເບິ່ງ: ພະນັກງານຄິວ]
cmd = python -u worker.py
ບູລິມະສິດ = 1

[ເບິ່ງ:redis]
cmd = redis-server
ບູລິມະສິດ = 2

ດ້ວຍການຕັ້ງຄ່ານີ້, Circus ຈະເລີ່ມຕົ້ນ Redis ທໍາອິດແລະຫຼັງຈາກນັ້ນມັນຈະເລີ່ມພະນັກງານແຖວ.
ແຕ່ Circus ບໍ່ໄດ້ຄວບຄຸມສິ່ງນັ້ນແທ້ໆ Redis ແມ່ນຂຶ້ນແລະແລ່ນ. ມັນພຽງແຕ່ເລີ່ມຕົ້ນ
ຂະບວນການມັນຖືກຮ້ອງຂໍໃຫ້ເລີ່ມຕົ້ນ. ສິ່ງທີ່ພວກເຮົາພາດຢູ່ທີ່ນີ້ແມ່ນວິທີທີ່ຈະຄວບຄຸມສິ່ງນັ້ນ Redis is
ເລີ່ມ​ຕົ້ນ​ແລະ​ເປັນ​ປະ​ໂຫຍດ​ຢ່າງ​ເຕັມ​ທີ່​. ຟັງຊັນທີ່ຄວບຄຸມສິ່ງນີ້ອາດຈະເປັນ:

ນຳເຂົ້າ redis
ເວລາ ນຳ ເຂົ້າ

def check_redis(*args, **kw):
time.sleep.5) # ໃຫ້ໂອກາດມັນເລີ່ມຕົ້ນ
r = redis.StrictRedis(host='localhost', port=6379, db=0)
r.set('foo', 'bar')
ກັບຄືນ r.get('foo') == 'ແຖບ'

ຟັງຊັນນີ້ສາມາດສຽບເຂົ້າໄປໃນ Circus ເປັນ ກ່ອນ_ເລີ່ມ hook:

[ຜູ້ເບິ່ງ: ພະນັກງານຄິວ]
cmd = python -u worker.py
hooks.before_start = mycoolapp.myplugins.check_redis
ບູລິມະສິດ = 1

[ເບິ່ງ:redis]
cmd = redis-server
ບູລິມະສິດ = 2

ເມື່ອ Circus ໄດ້ເລີ່ມຕົ້ນ redis watcher, ມັນຈະເລີ່ມຕົ້ນການ ພະນັກງານແຖວ watcher, ນັບຕັ້ງແຕ່
ມັນປະຕິບັດຕາມ ບູລິມະສິດ ການສັ່ງຊື້. ພຽງແຕ່ກ່ອນທີ່ຈະເລີ່ມຕົ້ນ watcher ທີສອງ, ມັນຈະດໍາເນີນການ
ໄດ້ check_redis function, ແລະໃນກໍລະນີທີ່ມັນກັບຄືນມາ ທີ່ບໍ່ຖືກຕ້ອງ ຈະເອົາລູກອອກ watcher ເລີ່ມ
ຂະບວນການ.

Hook ລາຍເຊັນ
Hook ຕ້ອງປະຕິບັດຕາມລາຍເຊັນນີ້:

def hook(watcher, arbiter, hook_name, **kwargs):
...
# ຖ້າເຈົ້າບໍ່ກັບຄືນ True, hook ມີການປ່ຽນແປງ
# ພຶດຕິກໍາຂອງ circus (ຂຶ້ນກັບ hook ໄດ້)
ກັບຄືນຄວາມຈິງ

ບ່ອນທີ່ watcher ເປັນ ຜູ້ເບິ່ງ ຕົວຢ່າງຫ້ອງຮຽນ, arbiter ໄດ້ ຜູ້ຕັດສິນ ຫນຶ່ງ, hook_name hook ໄດ້
ຊື່ແລະ kwargs ບາງຕົວກໍານົດການທາງເລືອກເພີ່ມເຕີມ (ຂຶ້ນກັບປະເພດ hook).

ໄດ້ after_spawn hook ເພີ່ມພາລາມິເຕີ pid:

def after_spawn(watcher, arbiter, hook_name, pid, **kwargs):
...
# ຖ້າທ່ານບໍ່ກັບຄືນ True, circus ຈະຂ້າຂະບວນການ
ກັບຄືນຄວາມຈິງ

ບ່ອນທີ່ pid ແມ່ນ PID ຂອງຂະບວນການທີ່ສອດຄ້ອງກັນ.

ເຊັ່ນດຽວກັນ, ກ່ອນ_ສັນຍານ ແລະ after_signal hooks ເພີ່ມ pid ແລະ signum:

def before_signal_hook(watcher, arbiter, hook_name, pid, signum, **kwargs):
...
# ຖ້າເຈົ້າບໍ່ກັບຄືນ True, circus ຈະບໍ່ສົ່ງສັນຍານ signum
# (SIGKILL ຖືກສົ່ງໄປສະເຫມີ)
ກັບຄືນຄວາມຈິງ

ບ່ອນທີ່ pid ແມ່ນ PID ຂອງຂະບວນການທີ່ສອດຄ້ອງກັນແລະ ສັນຍາລັກ ແມ່ນສັນຍານທີ່ສອດຄ້ອງກັນ.

ທ່ານ​ສາ​ມາດ​ບໍ່​ສົນ​ໃຈ​ເຫຼົ່າ​ນັ້ນ​ແຕ່​ສາ​ມາດ​ນໍາ​ໃຊ້ watcher ແລະ / ຫຼື​ຂໍ້​ມູນ arbiter ແລະ​ວິ​ທີ​ການ​ສາ​ມາດ​ເຮັດ​ໄດ້
ເປັນປະໂຫຍດໃນບາງ hooks.

ໃຫ້ສັງເກດວ່າ hooks ຖືກເອີ້ນດ້ວຍການໂຕ້ຖຽງທີ່ມີຊື່. ດັ່ງນັ້ນການນໍາໃຊ້ລາຍເຊັນ hook ໂດຍບໍ່ມີການ
ການປ່ຽນແປງຊື່ argument.

ໄດ້ ສະຖິຕິຂະຫຍາຍ hook ມີຕົວກໍານົດການເພີ່ມເຕີມຂອງຕົນເອງໃນ kwargs:

def extended_stats_hook(watcher, arbiter, hook_name, pid, stats, **kwargs):
...

ບ່ອນທີ່ pid ແມ່ນ PID ຂອງຂະບວນການທີ່ສອດຄ້ອງກັນແລະ ສະຖິຕິ ສະຖິຕິປົກກະຕິທີ່ຈະເປັນ
ກັບຄືນ. ເພີ່ມສະຖິຕິຂອງທ່ານເອງ ສະຖິຕິ. ຕົວຢ່າງແມ່ນຢູ່ໃນ
ຕົວຢ່າງ/uwsgi_lossless_reload.py.

ເປັນຕົວຢ່າງສຸດທ້າຍ, ນີ້ແມ່ນ hook super ທີ່ສາມາດຈັດການກັບທຸກປະເພດຂອງສັນຍານ:

def super_hook(watcher, arbiter, hook_name, **kwargs):
pid = ບໍ່ມີ
signum = ບໍ່ມີ
ຖ້າຊື່ hook_name ໃນ ('before_signal', 'after_signal'):
pid = kwargs['pid']
signum = kwargs['signum']
...
ກັບຄືນຄວາມຈິງ

Hook ກິດຈະກໍາ
ທຸກໆຄັ້ງທີ່ hook ຖືກແລ່ນ, ຜົນໄດ້ຮັບຂອງມັນຈະຖືກແຈ້ງໃຫ້ຮູ້ເປັນເຫດການໃນ Circus.

ມີສອງເຫດການທີ່ກ່ຽວຂ້ອງກັບ hooks:

· hook_success: hook ໄດ້ຖືກເອີ້ນວ່າສົບຜົນສໍາເລັດ. ກະແຈເຫດການແມ່ນ ຊື່ ຊື່ຖ້າຫາກວ່າ
ເຫດການ, ແລະ ທີ່ໃຊ້ເວລາ: ວັນທີຂອງເຫດການ.

· hook_failure: hook ລົ້ມເຫລວ. ກະແຈເຫດການແມ່ນ ຊື່ ຊື່​ຖ້າ​ຫາກ​ວ່າ​ເຫດ​ການ​, ທີ່ໃຊ້ເວລາ:
ວັນທີຂອງເຫດການແລະ ຄວາມຜິດພາດ: ຂໍ້ຍົກເວັ້ນທີ່ເກີດຂຶ້ນໃນກໍລະນີ, ຖ້າມີ.

ເພີ່ມຕື່ມ ໃຫມ່ ຄໍາສັ່ງ
ພວກເຮົາພະຍາຍາມເຮັດໃຫ້ການເພີ່ມຄໍາສັ່ງໃຫມ່ງ່າຍດາຍເທົ່າທີ່ເປັນໄປໄດ້.

ທ່ານຈໍາເປັນຕ້ອງເຮັດສາມຢ່າງ:

1. ສ້າງ ກ your_command.py ຍື່ນພາຍໃຕ້ circus/ຄໍາສັ່ງ/.

2. ປະຕິບັດຫ້ອງຮຽນດຽວຢູ່ໃນນັ້ນ, ດ້ວຍວິທີການທີ່ກໍານົດໄວ້ກ່ອນ

3. ເພີ່ມຄໍາສັ່ງໃຫມ່ໃນ circus/commands/__init__.py.

ສົມມຸດວ່າພວກເຮົາຕ້ອງການເພີ່ມຄໍາສັ່ງທີ່ຈະສົ່ງຄືນຈໍານວນຜູ້ເບິ່ງທີ່ຖືກນໍາໃຊ້ໃນປັດຈຸບັນ,
ພວກ​ເຮົາ​ຈະ​ເຮັດ​ບາງ​ສິ່ງ​ບາງ​ຢ່າງ​ເຊັ່ນ​ນີ້ (ຄໍາ​ຄິດ​ເຫັນ​ຢ່າງ​ກວ້າງ​ຂວາງ​ເພື່ອ​ໃຫ້​ທ່ານ​ຕິດ​ຕາມ​ຫຼາຍ​
ໄດ້​ຢ່າງ​ງ່າຍ​ດາຍ​)​:

ຈາກ circus.commands.base ຄໍາສັ່ງນໍາເຂົ້າ
ຈາກການນໍາເຂົ້າ circus.exc ArgumentError, MessageError
class NumWatchers(Command):
"""ມັນເປັນການປະຕິບັດທີ່ດີທີ່ຈະອະທິບາຍສິ່ງທີ່ຫ້ອງຮຽນເຮັດຢູ່ທີ່ນີ້.

ໃຫ້ເບິ່ງຄໍາສັ່ງອື່ນໆເພື່ອເບິ່ງວ່າພວກເຮົາຖືກນໍາໃຊ້ເພື່ອຈັດຮູບແບບແນວໃດ
ຂໍ້ຄວາມນີ້. ມັນຈະຖືກລວມເຂົ້າໂດຍອັດຕະໂນມັດໃນເອກະສານ,
ສະນັ້ນບໍ່ຕ້ອງຢ້ານທີ່ຈະຫມົດ, ນັ້ນແມ່ນສິ່ງທີ່ມັນເຮັດ
ສໍາລັບ.
"" "" ""
# ຄຳສັ່ງທັງໝົດສືບທອດມາຈາກ `circus.commands.base.Command`

# ທ່ານຕ້ອງລະບຸຊື່ເພື່ອໃຫ້ພວກເຮົາຊອກຫາຄໍາສັ່ງຄືນ
ຊື່ = "ຜູ້ຕິດຕາມຕົວເລກ"

# ຕັ້ງລໍຖ້າເປັນ True ຫຼື False ເພື່ອກໍານົດພຶດຕິກໍາເລີ່ມຕົ້ນຂອງທ່ານ
# - ຖ້າລໍຖ້າແມ່ນຖືກຕ້ອງ, ຄໍາສັ່ງຖືກດໍາເນີນການ synchronously, ແລະລູກຄ້າອາດຈະໄດ້ຮັບ
# ຜົນຕອບແທນ.
# - ຖ້າລໍຖ້າເປັນ False, ຄໍາສັ່ງຈະຖືກດໍາເນີນການ asynchronously ໃນເຄື່ອງແມ່ຂ່າຍແລະລູກຄ້າທັນທີ
# ໄດ້ຮັບການຕອບຮັບ 'ຕົກລົງ' ກັບຄືນມາ
#
# ໂດຍຄ່າເລີ່ມຕົ້ນ, ຄໍາສັ່ງຖືກຕັ້ງເປັນ wait = False
wait = ຈິງ

# ຕົວເລືອກ
options = [('', 'optname', default_value, 'description')]

ຄຸນສົມບັດ = ['foo', 'bar']
# ຄຸນສົມບັດລາຍຊື່ອາກິວເມັນຄຳສັ່ງທີ່ຈຳເປັນ. ຖ້າພວກເຂົາແມ່ນ
# ບໍ່ໄດ້ໃຫ້, ຫຼັງຈາກນັ້ນຄວາມຜິດພາດຈະຖືກຖິ້ມ

def execute (ຕົວ​ເອງ, arbiter, props):
# ວິທີການປະຕິບັດແມ່ນຫຼັກຂອງຄໍາສັ່ງ: ເອົາທັງຫມົດທີ່ນີ້
# ເຫດຜົນຂອງຄໍາສັ່ງແລະສົ່ງຄືນຄໍາສັ່ງທີ່ມີຄ່າທີ່ທ່ານ
#ຢາກກັບຄືນມາ ຖ້າມີ
ກັບຄືນ {"numwatchers": arbiter.numwatchers()}

def console_msg(ຕົນເອງ, msg):
# msg ແມ່ນສິ່ງທີ່ຖືກສົ່ງຄືນໂດຍວິທີການປະຕິບັດ.
# ວິທີການນີ້ຖືກນໍາໃຊ້ເພື່ອຈັດຮູບແບບການຕອບສະຫນອງສໍາລັບ console (ມັນແມ່ນ
# ໃຊ້ຕົວຢ່າງໂດຍ circusctl ເພື່ອພິມຂໍ້ຄວາມຂອງມັນ)
ກັບຄືນ "ສະຕຣິງທີ່ຈະສະແດງ"

def ຂໍ້​ຄວາມ(ຕົວ​ເອງ, *args, **opts):
# ຂໍ້ຄວາມຈັດການການປ້ອນເຂົ້າ console.
# ວິທີການນີ້ຖືກນໍາໃຊ້ເພື່ອແຜນທີ່ console arguments ກັບຄໍາສັ່ງ
# ຕົວເລືອກ. (ມັນຖືກນໍາໃຊ້ສໍາລັບຕົວຢ່າງໃນເວລາທີ່ໂທຫາຄໍາສັ່ງຜ່ານ
# circusctl)
# NotImplementedError ຈະຖືກຖິ້ມຖ້າຟັງຊັນຂາດຫາຍໄປ
numArgs = 1
ຖ້າບໍ່ແມ່ນ len(args) == numArgs:
ຍົກ ArgumentError('ຈຳນວນຜິດຂອງອາກິວເມັນ.')
ອື່ນ:
opts['optname'] = args[0]
ກັບຄືນ self.make_message(**opts)

def validate (ຕົນເອງ, props):
# ວິທີການນີ້ຖືກນໍາໃຊ້ເພື່ອກວດສອບການໂຕ້ຖຽງທີ່ຜ່ານໄປ
# ຄຳສັ່ງຖືກຕ້ອງ. ArgumentError ຄວນຖືກຖິ້ມໃນກໍລະນີ
# ມີຂໍ້ຜິດພາດໃນການໂຕ້ຖຽງທີ່ຜ່ານ (ຕົວຢ່າງຖ້າພວກເຂົາ
#ບໍ່ກົງກັນ.
# ໃນກໍລະນີທີ່ມີບັນຫາ wrt ເນື້ອຫາຂອງພວກເຂົາ, MessageError
# ຄວນຖິ້ມ. ວິທີການນີ້ສາມາດດັດແປງເນື້ອໃນຂອງ props ໄດ້
# dict, ມັນຈະຖືກຖ່າຍທອດໃຫ້ປະຕິບັດຫຼັງຈາກນັ້ນ.

ການນໍາໃຊ້ ກໍລະນີ ຕົວຢ່າງ
ບົດນີ້ສະເຫນີກໍລະນີການນໍາໃຊ້ຈໍານວນຫນ້ອຍ, ເພື່ອໃຫ້ທ່ານມີຄວາມຄິດກ່ຽວກັບວິທີການນໍາໃຊ້ Circus ໃນຂອງທ່ານ
ສິ່ງແວດລ້ອມ.

ເຮັດວຽກ a WSGI ຄໍາຮ້ອງສະຫມັກ
ແລ່ນແອັບພລິເຄຊັນ WSGI ກັບ Circus ແມ່ນຂ້ອນຂ້າງຫນ້າສົນໃຈເພາະວ່າທ່ານສາມາດເບິ່ງແລະຈັດການ
ຂອງ​ທ່ານ ເວັບໄຊຕ໌ ພະນັກງານ ການນໍາໃຊ້ circus-top, circusctl ຫຼືສ່ວນຕິດຕໍ່ເວັບ.

ນີ້ແມ່ນເປັນໄປໄດ້ໂດຍການໃຊ້ຊັອກເກັດ Circus. ເບິ່ງວ່າເປັນຫຍັງວົງຈອນປິດ.

ໃຫ້ເອົາຕົວຢ່າງທີ່ມີຫນ້ອຍທີ່ສຸດ Pyramid ຄໍາຮ້ອງສະຫມັກ:

ຈາກ pyramid.config import Configurator
ຈາກ pyramid.response ນໍາເຂົ້າການຕອບສະຫນອງ

def hello_world(ຄໍາ​ຮ້ອງ​ສະ​ຫມັກ​)​:
return Response('ສະບາຍດີ %(name)s!' % request.matchdict)

config = ຜູ້ກຳນົດຄ່າ()
config.add_route('ສະບາຍດີ', '/hello/{name}')
config.add_view(hello_world, route_name='ສະບາຍດີ')
application = config.make_wsgi_app()

ບັນທຶກສະຄຣິບນີ້ໃສ່ເປັນ app.py ໄຟລ໌, ຫຼັງຈາກນັ້ນຕິດຕັ້ງໂຄງການເຫຼົ່ານັ້ນ:

$ pip ຕິດຕັ້ງ Pyramid
$ pip ຕິດຕັ້ງ chaussette

ຕໍ່ໄປ, ໃຫ້ແນ່ໃຈວ່າທ່ານສາມາດດໍາເນີນການຄໍາຮ້ອງສະຫມັກ Pyramid ຂອງທ່ານໂດຍໃຊ້ ຖົງຕີນ console script:

$ chaussette app.application
ຄໍາຮ້ອງສະຫມັກແມ່ນ
ໃຫ້ບໍລິການໃນ localhost:8080
ການນໍາໃຊ້ ເປັນ backend

ແລະກວດເບິ່ງວ່າທ່ານສາມາດບັນລຸໄດ້ໂດຍການໄປຢ້ຽມຢາມ http://localhost:8080/ສະບາຍດີ/tarek

ຕອນນີ້ແອັບພລິເຄຊັນຂອງທ່ານເລີ່ມເຮັດວຽກແລ້ວ, ໃຫ້ສ້າງໄຟລ໌ການຕັ້ງຄ່າ Circus:

[ວົງດົນຕີ]
check_delay = 5
ຈຸດຈົບ = tcp://127.0.0.1:5555
pubsub_endpoint = tcp://127.0.0.1:5556
stats_endpoint = tcp://127.0.0.1:5557

[ຜູ້ເບິ່ງ: webworker]
cmd = chaussette --fd $(circus.sockets.webapp) app.application
use_sockets = ຖືກ
ຈໍານວນຂະບວນການ = 3

[ເຕົ້າຮັບ: webapp]
ເຈົ້າພາບ = 127.0.0.1
ພອດ = 8080

ໄຟລ໌ນີ້ບອກ Circus ໃຫ້ຜູກມັດຊັອກເກັດຢູ່ໃນພອດ 8080 ແລະແລ່ນ ຖົງຕີນ ຄົນງານກ່ຽວກັບເລື່ອງນັ້ນ
ເຕົ້າຮັບ - ໂດຍການຖ່າຍທອດ fd ຂອງມັນ.

ບັນທຶກມັນໃສ່ server.ini ແລະພະຍາຍາມດໍາເນີນການມັນໂດຍໃຊ້ ວົງວຽນ

$ circusd server.ini
[INFO] ເລີ່ມຕົ້ນຕົ້ນສະບັບໃນ pid 8971
[INFO] ເຕົ້າຮັບເລີ່ມຕົ້ນ
[INFO] ສະຖິຕິ circusd ເລີ່ມ
[INFO] webapp ເລີ່ມ
[ຂໍ້ມູນ] Arbiter ໃນປັດຈຸບັນລໍຖ້າຄໍາສັ່ງ

ໃຫ້ແນ່ໃຈວ່າທ່ານຍັງເປີດແອັບຯຢູ່ http://localhost:8080/ສະບາຍດີ/tarek.

ຊົມເຊີຍ! ທ່ານມີແອັບພລິເຄຊັນ WSGI ເຮັດວຽກ 3 ຄົນ.

ທ່ານສາມາດດໍາເນີນການ circushttpd ຫຼື cli, ແລະມີຄວາມສຸກການຄຸ້ມຄອງ Circus.

ເຮັດວຽກ a Django ຄໍາຮ້ອງສະຫມັກ
ແລ່ນແອັບພລິເຄຊັນ Django ແມ່ນເຮັດຄືກັບການແລ່ນແອັບພລິເຄຊັນ WSGI. ໃຊ້
ໄພທອນພົດ ເພື່ອນໍາເຂົ້າໄດເລກະທໍລີທີ່ໂຄງການຢູ່ໃນ, ໄດເລກະທໍລີທີ່ປະກອບດ້ວຍ
ໄດເລກະທໍລີທີ່ມີ settings.py ໃນມັນ (ກັບ Django 1.4+ ໄດເລກະທໍລີນີ້ມີການຈັດການ.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 ສໍາລັບຕົວຢ່າງ, ສໍາລັບພະນັກງານ backend, ທ່ານສາມາດເຮັດໄດ້
ຜ່ານນັ້ນເຖິງແມ່ນວ່າ ປະມານ ທາງ​ເລືອກ​ການ​ຕັ້ງ​ຄ່າ​:

[ຜູ້ເບິ່ງ: dbackend]
cmd = /path/to/script.py
numprocesses=3

[env:dbackend]
PYTHONPATH = /path/to/parent-of-dproject
DJANGO_SETTINGS_MODULE=dproject.settings

ເບິ່ງ http://chaussette.readthedocs.org ສໍາລັບເພີ່ມເຕີມກ່ຽວກັບ chaussette.

ການອອກແບບ ການຕັດສິນໃຈ
ໂດຍລວມ ຖາປັດຕະຍະ
[ຮູບພາບ]

Circus ແມ່ນປະກອບດ້ວຍຂະບວນການຕົ້ນຕໍທີ່ເອີ້ນວ່າ ວົງວຽນ ເຊິ່ງໃຊ້ເວລາດູແລຂອງແລ່ນທັງຫມົດ
ຂະບວນການ. ແຕ່​ລະ​ຂະ​ບວນ​ການ​ຄຸ້ມ​ຄອງ​ໂດຍ Circus ເປັນ​ຂະ​ບວນ​ການ​ຂອງ​ເດັກ​ນ້ອຍ​ ວົງວຽນ.

ຂະບວນການຖືກຈັດຢູ່ໃນກຸ່ມທີ່ເອີ້ນວ່າ watchers. A watcher ໂດຍພື້ນຖານແລ້ວແມ່ນຄໍາສັ່ງ
ວົງວຽນ ເຮັດວຽກຢູ່ໃນລະບົບຂອງທ່ານ, ແລະສໍາລັບແຕ່ລະຄໍາສັ່ງທ່ານສາມາດກໍານົດວິທີການຈໍານວນຫຼາຍຂະບວນການທີ່ທ່ານ
ຕ້ອງການແລ່ນ.

ແນວຄວາມຄິດຂອງ watcher ເປັນປະໂຫຍດໃນເວລາທີ່ທ່ານຕ້ອງການຄຸ້ມຄອງຂະບວນການທັງຫມົດແລ່ນ
ຄໍາສັ່ງດຽວກັນ - ເຊັ່ນ restart ພວກມັນ, ແລະອື່ນໆ.

ວົງວຽນ ຜູກມັດສອງຊັອກເກັດ ZeroMQ:

· REQ/REP -- ເຕົ້າຮັບທີ່ໃຊ້ເພື່ອຄວບຄຸມ ວົງວຽນ ໃຊ້ json-based ຄໍາສັ່ງ.

· PUB/SUB -- ເຕົ້າຮັບທີ່ ວົງວຽນ ເຜີຍແຜ່ເຫດການ, ເຊັ່ນວ່າຂະບວນການເລີ່ມຕົ້ນ ຫຼື
ຢຸດ.

ຫມາຍ​ເຫດ​:
ເຖິງວ່າຈະມີຊື່ຂອງມັນ, ZeroMQ ບໍ່ແມ່ນລະບົບການຈັດການແຖວ. ຄິດວ່າມັນເປັນ
ຫ້ອງສະໝຸດການສື່ສານລະຫວ່າງຂະບວນການ (IPC).

ຂະບວນການອື່ນເອີ້ນວ່າ circusd-ສະຖິຕິ ແມ່ນດໍາເນີນການໂດຍ ວົງວຽນ ເມື່ອຕົວເລືອກຖືກເປີດໃຊ້.
circusd-ສະຖິຕິວຽກເຮັດງານທໍາຂອງແມ່ນເພື່ອເຜີຍແຜ່ສະຖິຕິການນໍາໃຊ້ CPU / ຫນ່ວຍຄວາມຈໍາໃນອຸທິດຕົນ PUB/SUB
ຊ່ອງ.

ຊ່ອງທາງພິເສດນີ້ຖືກນໍາໃຊ້ໂດຍ circus-top ແລະ circus-httpd ເພື່ອສະແດງການຖ່າຍທອດສົດ
ຂອງ​ກິດ​ຈະ​ກໍາ​.

circus-top ເປັນ console script ທີ່ mimics top ເພື່ອສະແດງການໃຊ້ CPU ແລະ Memory ທັງໝົດ
ຂະບວນການທີ່ຄຸ້ມຄອງໂດຍ Circus.

circus-httpd ແມ່ນການໂຕ້ຕອບການຄຸ້ມຄອງເວັບໄຊຕ໌ທີ່ຈະຊ່ວຍໃຫ້ທ່ານສາມາດພົວພັນກັບ Circus. ມັນ
ສະແດງການຖ່າຍທອດສົດໂດຍໃຊ້ຊັອກເກັດເວັບ ແລະ circusd-ສະຖິຕິ ຊ່ອງທາງ, ແຕ່ຍັງໃຫ້ທ່ານ
ພົວພັນກັບ ວົງວຽນ ຜ່ານຂອງມັນ REQ/REP ຊ່ອງ.

ສຸດ​ທ້າຍ​ແຕ່​ບໍ່​ທ້າຍ​ສຸດ, circusctl ແມ່ນເຄື່ອງມືບັນທັດຄໍາສັ່ງທີ່ຊ່ວຍໃຫ້ທ່ານຂັບລົດ ວົງວຽນ ຜ່ານຂອງມັນ
REQ/REP ຊ່ອງ.

ນອກນັ້ນທ່ານຍັງສາມາດມີ plugins ທີ່ສະຫມັກ ວົງວຽນ's PUB/SUB ຊ່ອງ​ທາງ​ແລະ​ໃຫ້​ທ່ານ​ສົ່ງ​
ຄໍາສັ່ງກັບ REQ/REP ຊ່ອງທາງເຊັ່ນ circusctl ຈະ.

ຄວາມ​ປອດ​ໄພ
Circus ຖືກສ້າງຂຶ້ນຢູ່ເທິງສຸດຂອງຫ້ອງສະຫມຸດ ZeroMQ ແລະມາພ້ອມກັບຄວາມປອດໄພທີ່ບໍ່ມີຢູ່ໃນທັງຫມົດ
ພິທີການ. ຢ່າງໃດກໍຕາມ, ທ່ານສາມາດດໍາເນີນການລະບົບ Circus ໃນເຄື່ອງແມ່ຂ່າຍແລະຕັ້ງຄ່າ tunnel SSH ກັບ
ເຂົ້າເຖິງມັນຈາກເຄື່ອງອື່ນ.

ພາກນີ້ອະທິບາຍສິ່ງທີ່ Circus ເຮັດຢູ່ໃນລະບົບຂອງເຈົ້າເມື່ອທ່ານແລ່ນມັນ, ແລະສິ້ນສຸດ
ອະທິບາຍວິທີການໃຊ້ອຸໂມງ SSH.

ທ່ານຍັງສາມາດອ່ານໄດ້ http://www.zeromq.org/area:faq#toc5

TCP ທ່າ​ເຮືອ
ໂດຍຄ່າເລີ່ມຕົ້ນ, Circus ເປີດພອດ TCP ຕໍ່ໄປນີ້ຢູ່ໃນໂຮດທ້ອງຖິ່ນ:

· 5555 -- ພອດທີ່ໃຊ້ໃນການຄວບຄຸມ circus ຜ່ານ circusctl

· 5556 -- ພອດທີ່ໃຊ້ສໍາລັບຊ່ອງຜູ້ເຜີຍແຜ່/ຜູ້ສະໝັກໃຊ້.

· 5557 -- ພອດທີ່ໃຊ້ສໍາລັບຊ່ອງສະຖິຕິ -- ຖ້າເປີດໃຊ້.

· 8080 -- ພອດທີ່ໃຊ້ໂດຍ Web UI -- ຖ້າເປີດໃຊ້.

ພອດເຫຼົ່ານີ້ອະນຸຍາດໃຫ້ແອັບຯລູກຄ້າສາມາດພົວພັນກັບລະບົບ Circus ຂອງທ່ານ, ແລະຂຶ້ນກັບວິທີການ
ໂຄງສ້າງພື້ນຖານຂອງທ່ານຖືກຈັດຕັ້ງ, ທ່ານອາດຈະຕ້ອງການປົກປ້ອງພອດເຫຼົ່ານີ້ຜ່ານໄຟວໍ or
ຕັ້ງຄ່າ Circus ເພື່ອດໍາເນີນການໂດຍໃຊ້ IPC ທ່າເຮືອ.

ນີ້ແມ່ນຕົວຢ່າງຂອງການແລ່ນ Circus ໂດຍໃຊ້ພຽງແຕ່ຈຸດເຂົ້າ IPC:

[ວົງດົນຕີ]
check_delay = 5
endpoint = ipc:///var/circus/endpoint
pubsub_endpoint = ipc:///var/circus/pubsub
stats_endpoint = ipc:///var/circus/stats

ເມື່ອ Configured ໃຊ້ IPC, ຄໍາສັ່ງຕ້ອງຖືກດໍາເນີນການຈາກກ່ອງດຽວກັນ, ແຕ່ບໍ່ມີໃຜສາມາດເຮັດໄດ້
ເຂົ້າເຖິງພວກມັນຈາກພາຍນອກ, ບໍ່ຄືກັບການໃຊ້ TCP. ຄໍາສັ່ງຍັງຕ້ອງໄດ້ດໍາເນີນການເປັນຜູ້ໃຊ້ທີ່
ມີການຂຽນເຂົ້າເຖິງເສັ້ນທາງຊັອກເກັດ iPC. ທ່ານສາມາດປັບປຸງແກ້ໄຂເຈົ້າຂອງ endpoint ການນໍາໃຊ້
ໄດ້ endpoint_owner ຕົວເລືອກການຕັ້ງຄ່າ. ນີ້ອະນຸຍາດໃຫ້ທ່ານດໍາເນີນການ circusd ເປັນຜູ້ໃຊ້ຮາກ, ແຕ່
ອະນຸຍາດໃຫ້ຂະບວນການທີ່ບໍ່ແມ່ນຮາກເພື່ອສົ່ງຄໍາສັ່ງໄປຫາ ວົງວຽນ. ໃຫ້ສັງເກດວ່າໃນເວລາທີ່ການນໍາໃຊ້ endpoint_owner,
ເພື່ອປ້ອງກັນບໍ່ໃຫ້ຂະບວນການທີ່ບໍ່ແມ່ນຮາກສາມາດເລີ່ມຕົ້ນຂະບວນການທີ່ຕົນເອງມັກ
ແລ່ນດ້ວຍສິດທິພິເສດທີ່ໃຫຍ່ກວ່າ, ຄໍາສັ່ງເພີ່ມຈະບັງຄັບໃຫ້ Watchers ໃຫມ່ຕ້ອງດໍາເນີນການເປັນ
ໄດ້ endpoint_owner ຜູ້ໃຊ້. ຄໍານິຍາມຂອງ Watcher ໃນໄຟລ໌ config ທ້ອງຖິ່ນຈະບໍ່ເປັນ
ຖືກຈຳກັດດ້ວຍວິທີນີ້.

ແນ່ນອນ, ຖ້າທ່ານເປີດໃຊ້ Web UI, the 8080 ພອດຈະຍັງເປີດຢູ່.

circushttpd
ເມື່ອທ່ານແລ່ນ circushttpd ດ້ວຍຕົນເອງ, ຫຼືເມື່ອທ່ານໃຊ້ httpd ທາງເລືອກໃນໄຟລ໌ ini ເຊັ່ນ
ນີ້:

[ວົງດົນຕີ]
check_delay = 5
endpoint = ipc:///var/circus/endpoint
pubsub_endpoint = ipc:///var/circus/pubsub
stats_endpoint = ipc:///var/circus/stats
httpd = 1

ຄໍາຮ້ອງສະຫມັກເວັບໄຊຕ໌ຈະດໍາເນີນການຢູ່ໃນພອດ 8080 ແລະ​ຈະ​ໃຫ້​ທຸກ​ຄົນ​ເຂົ້າ​ເຖິງ​ຫນ້າ​ເວັບ​ໄດ້​
ຄຸ້ມຄອງ ວົງວຽນ ເດມອນ

ນັ້ນລວມເຖິງການສ້າງ watchers ໃຫມ່ທີ່ສາມາດດໍາເນີນການຄໍາສັ່ງໃດໆໃນລະບົບຂອງທ່ານ !

Do ບໍ່ ເຮັດໃຫ້ it ສາທາລະນະ ມີ

ຖ້າທ່ານຕ້ອງການປົກປ້ອງການເຂົ້າເຖິງກະດານເວັບໄຊຕ໌, ທ່ານສາມາດຮັບໃຊ້ມັນຢູ່ຫລັງ Nginx ຫຼື
Apache ຫຼືເຊີບເວີເວັບທີ່ມີຄວາມສາມາດພຣັອກຊີ, ທີ່ສາມາດເບິ່ງແຍງຄວາມປອດໄພໄດ້.

ຜູ້​ໃຊ້ ແລະ ກຸ່ມ Permissions
ໂດຍຄ່າເລີ່ມຕົ້ນ, ຂະບວນການທັງໝົດທີ່ເລີ່ມຕົ້ນດ້ວຍ Circus ຈະເຮັດວຽກກັບຜູ້ໃຊ້ ແລະກຸ່ມດຽວກັນ
as ວົງວຽນ. ອີງຕາມສິດທິພິເສດທີ່ຜູ້ໃຊ້ມີຢູ່ໃນລະບົບ, ທ່ານອາດຈະບໍ່ມີ
ເຂົ້າເຖິງຄຸນສົມບັດທັງໝົດທີ່ Circus ສະໜອງໃຫ້.

ຕົວຢ່າງ, ບາງຄຸນສົມບັດສະຖິຕິໃນຂະບວນການແລ່ນຕ້ອງການສິດທິພິເສດ.
ໂດຍປົກກະຕິ, ຖ້າຕົວເລກການນໍາໃຊ້ CPU ທີ່ທ່ານໄດ້ຮັບການນໍາໃຊ້ ສະຖິຕິ ຄໍາສັ່ງແມ່ນ N / A, ມັນຫມາຍຄວາມວ່າທ່ານ
ຜູ້ໃຊ້ບໍ່ສາມາດເຂົ້າເຖິງໄຟລ໌ proc ໄດ້. ນີ້ຈະເປັນກໍລະນີໂດຍຄ່າເລີ່ມຕົ້ນພາຍໃຕ້ Mac OS X.

ເຈົ້າອາດຈະແລ່ນ ວົງວຽນ ເປັນຮາກເພື່ອແກ້ໄຂນີ້, ແລະກໍານົດ uid ແລະ gid ຄ່າສໍາລັບແຕ່ລະ watcher
ເພື່ອໃຫ້ໄດ້ຮັບຄຸນສົມບັດທັງຫມົດ.

ແຕ່ລະວັງວ່າແລ່ນ ວົງວຽນ ເປັນຮາກ exposes ໃຫ້ທ່ານ escalation ສິດທິພິເສດທີ່ເປັນໄປໄດ້
ແມງໄມ້. ໃນ​ຂະ​ນະ​ທີ່​ພວກ​ເຮົາ​ກໍາ​ລັງ​ເຮັດ​ດີ​ທີ່​ສຸດ​ຂອງ​ພວກ​ເຮົາ​ເພື່ອ​ຫຼີກ​ເວັ້ນ​ການ​ແມງ​ໄມ້​ໃດ​ຫນຶ່ງ, ແລ່ນ​ເປັນ​ຮາກ​ແລະ​ປະ​ເຊີນ​ກັບ bug ທີ່
ປະຕິບັດການກະທໍາທີ່ບໍ່ຕ້ອງການຢູ່ໃນລະບົບຂອງທ່ານອາດຈະເປັນອັນຕະລາຍ.

ວິທີທີ່ດີທີ່ສຸດເພື່ອປ້ອງກັນນີ້ແມ່ນເພື່ອໃຫ້ແນ່ໃຈວ່າລະບົບແລ່ນ Circus ແມ່ນສົມບູນ
ໂດດດ່ຽວ (ຄືກັບ VM) or ເພື່ອດໍາເນີນການລະບົບທັງຫມົດພາຍໃຕ້ຜູ້ໃຊ້ຄວບຄຸມ.

SSH ການເຈາະອຸໂມງ
ລູກຄ້າສາມາດເຊື່ອມຕໍ່ກັບ a ວົງວຽນ ຕົວຢ່າງໂດຍການສ້າງອຸໂມງ SSH. ເພື່ອເຮັດສິ່ງນີ້, ໃຫ້ຜ່ານ
ທາງເລືອກແຖວຄໍາສັ່ງ --ssh ປະຕິບັດຕາມໂດຍ user@ທີ່ຢູ່, ບ່ອນທີ່ ຜູ້ໃຊ້ ແມ່ນຜູ້ໃຊ້ໃນຣີໂໝດ
ເຊີບເວີ ແລະ ທີ່ຢູ່ ແມ່ນທີ່ຢູ່ຂອງເຊີບເວີຕາມທີ່ລູກຄ້າເຫັນ. ອະນຸສັນຍາ SSH ຈະ
ຕ້ອງການຂໍ້ມູນປະຈໍາຕົວເພື່ອເຮັດສໍາເລັດການເຂົ້າສູ່ລະບົບ.

If ວົງວຽນ ດັ່ງທີ່ເຫັນໂດຍເຊີບເວີ SSH ບໍ່ໄດ້ຢູ່ໃນທີ່ຢູ່ປາຍທາງເລີ່ມຕົ້ນ localhost: 5555
ຫຼັງຈາກນັ້ນ, ລະບຸ ວົງວຽນ ທີ່ຢູ່ໂດຍໃຊ້ທາງເລືອກ --ຈຸດຈົບ

ປອດໄພ ຕັ້ງ​ຄ່າ ຍົກຕົວຢ່າງ
ການຕັ້ງຄ່າເຊີບເວີ Circus ທີ່ປອດໄພສາມາດເຮັດໄດ້ໂດຍ:

· ແລ່ນເຊີບເວີ SSH

· ແລ່ນ Apache ຫຼື Nginx ໃນ 80 port, ແລະເຮັດ reverse-proxy ຢູ່ໃນ 8080 ທ່າເຮືອ.

· ການຂັດຂວາງ 8080 ພອດຈາກການເຂົ້າເຖິງພາຍນອກ.

· ແລ່ນພອດ ZMQ Circusd ທັງໝົດໂດຍໃຊ້ໄຟລ໌ IPC ແທນທີ່ Port TCP, ແລະການສ້າງອຸໂມງທັງໝົດ
ໂທຜ່ານ SSH.
[ຮູບພາບ]

ການປະກອບສ່ວນ to Circus
Circus ໄດ້ເລີ່ມຕົ້ນຢູ່ທີ່ Mozilla ແຕ່ເປົ້າຫມາຍຂອງມັນບໍ່ແມ່ນພຽງແຕ່ຢູ່ທີ່ນັ້ນ. ພວກເຮົາກໍາລັງພະຍາຍາມ
ເພື່ອສ້າງເຄື່ອງມືທີ່ເປັນປະໂຫຍດສໍາລັບຜູ້ອື່ນ, ແລະຂະຫຍາຍໄດ້ງ່າຍ.

ພວກເຮົາກໍ່ເປີດໃຫ້ມີການປະກອບສ່ວນໃດໆ, ໃນຮູບແບບຂອງລະຫັດ, ເອກະສານ, ການສົນທະນາ,
ການ​ສະ​ເຫນີ​ຄຸນ​ນະ​ສົມ​ບັດ​ແລະ​ອື່ນໆ

ທ່ານສາມາດເລີ່ມຕົ້ນຫົວຂໍ້ໃນບັນຊີລາຍຊື່ທາງໄປສະນີຂອງພວກເຮົາ: http://tech.groups.yahoo.com/group/circus-dev/

ຫຼືເພີ່ມບັນຫາໃນຂອງພວກເຮົາ bug ບົບຕິດຕາມລຸດ

ການແກ້ໄຂ ພິມຜິດ ແລະ ການປັບປຸງ ໄດ້ ເອກະສານ
ມັນເປັນໄປໄດ້ທັງ ໝົດ ທີ່ຕາຂອງເຈົ້າມີເລືອດອອກໃນຂະນະທີ່ອ່ານພາສາອັງກິດເຄິ່ງ ໜຶ່ງ ນີ້
ເອກະສານເຄິ່ງພາສາຝຣັ່ງ, ຢ່າລັງເລທີ່ຈະປະກອບສ່ວນ rephrasing / ການປັບປຸງໃດໆກ່ຽວກັບ
ແບບຟອມໃນເອກະສານ. ທ່ານອາດຈະບໍ່ຈໍາເປັນຕ້ອງເຂົ້າໃຈວ່າ Circus ເຮັດວຽກແນວໃດ
ພາຍໃຕ້ hood ເພື່ອເຮັດແນວນັ້ນ.

ເພີ່ມຕື່ມ ໃຫມ່ ຄຸນ​ລັກ​ສະ​ນະ
ຄຸນນະສົມບັດໃຫມ່ແນ່ນອນໄດ້ຮັບການຍົກຍ້ອງຫຼາຍ. ຖ້າທ່ານມີຄວາມຕ້ອງການແລະເວລາທີ່ຈະ
ເຮັດວຽກກ່ຽວກັບລັກສະນະໃຫມ່, ການເພີ່ມພວກມັນໃສ່ Circus ບໍ່ຄວນສັບສົນຫຼາຍ. ພວກເຮົາພະຍາຍາມຫຼາຍ
ຍາກທີ່ຈະມີ API ທີ່ສະອາດແລະເຂົ້າໃຈໄດ້, ຫວັງວ່າມັນຮັບໃຊ້ຈຸດປະສົງ.

ທ່ານຈະຕ້ອງເພີ່ມເອກະສານ ແລະການທົດສອບພ້ອມກັບລະຫັດຂອງຄຸນສົມບັດໃໝ່.
ຖ້າ​ບໍ່​ດັ່ງ​ນັ້ນ​ພວກ​ເຮົາ​ຈະ​ບໍ່​ສາ​ມາດ​ຍອມ​ຮັບ​ການ​ແກ້​ໄຂ​ໄດ້​.

ວິທີການ to ສົ່ງ ຂອງ​ທ່ານ ການປ່ຽນແປງ
ພວກເຮົາກຳລັງໃຊ້ git ເປັນ DVCS. ວິທີທີ່ດີທີ່ສຸດທີ່ຈະສະເຫນີການປ່ຽນແປງແມ່ນການສ້າງສາຂາຢູ່ໃນຂອງທ່ານ
ຂ້າງ (ຜ່ານ ໄປ ກວດ​ເບິ່ງ -b ຊື່ສາຂາ) ແລະສັນຍາການປ່ຽນແປງຂອງທ່ານຢູ່ທີ່ນັ້ນ. ເມື່ອທ່ານມີ
ບາງ​ສິ່ງ​ບາງ​ຢ່າງ​ທີ່​ກຽມ​ພ້ອມ​ສໍາ​ລັບ​ການ​ສໍາ​ລັບ​ການ​ສໍາ​ລັບ​ການ​ສໍາ​ຄັນ​, ອອກ​ຄໍາ​ຮ້ອງ​ສະ​ຫມັກ​ດຶງ​ຕໍ່​ກັບ​ສາ​ຂາ​ນີ້​.

ພວກເຮົາປະຕິບັດຕາມຮູບແບບນີ້ເພື່ອອະນຸຍາດໃຫ້ມີການເຊື່ອມຕ່ໍາລະຫວ່າງລັກສະນະທີ່ທ່ານເປັນ
ສະເໜີ. ຕົວຢ່າງ, ພວກເຮົາສາມາດຍອມຮັບການຮ້ອງຂໍດຶງຫນຶ່ງໃນຂະນະທີ່ຍັງຢູ່ໃນການສົນທະນາ
ສໍາລັບຄົນອື່ນ.

ກ່ອນທີ່ຈະສະເຫນີການປ່ຽນແປງຂອງທ່ານ, ກວດເບິ່ງຄືນວ່າພວກເຂົາບໍ່ໄດ້ທໍາລາຍຫຍັງ! ເຈົ້າ​ສາ​ມາດ
ການນໍາໃຊ້ ສານພິດ ຄໍາສັ່ງເພື່ອຮັບປະກັນນີ້, ມັນຈະດໍາເນີນການ testsuite ພາຍໃຕ້ທີ່ແຕກຕ່າງກັນ
ສະ​ຫນັບ​ສະ​ຫນູນ​ສະ​ບັບ python​.

ກະລຸນາໃຊ້: http://issue2pr.herokuapp.com/ ເພື່ອອ້າງອີງຄໍາຫມັ້ນສັນຍາກັບ circus ທີ່ມີຢູ່ແລ້ວ
ບັນຫາ, ຖ້າມີ.

ຫຼີກເວັ້ນການ ລວມ ສັນຍາ
ການຫຼີກລ່ຽງການລວມຕົວເຮັດໃຫ້ມີປະຫວັດທີ່ສະອາດ ແລະສາມາດອ່ານໄດ້. ເພື່ອເຮັດສິ່ງນີ້, ແທນທີ່ຈະ
ເຮັດ "git pull" ແລະປ່ອຍໃຫ້ git ຈັດການການລວມຕົວສໍາລັບທ່ານ, ໂດຍໃຊ້ git pull --rebase ຈະ.
ວາງການປ່ຽນແປງຂອງເຈົ້າຫຼັງຈາກການປ່ຽນແປງທີ່ມຸ່ງຫມັ້ນຢູ່ໃນສາຂາ, ຫຼືໃນເວລາທີ່ເຮັດວຽກ
ຕົ້ນສະບັບ

ນັ້ນແມ່ນ, ສໍາລັບພວກເຮົານັກພັດທະນາຫຼັກ, ມັນເປັນໄປບໍ່ໄດ້ທີ່ຈະໃຊ້ github ສີຂຽວທີ່ມີປະໂຫຍດອີກຕໍ່ໄປ
ປຸ່ມກ່ຽວກັບການຮ້ອງຂໍການດຶງຖ້າຫາກວ່ານັກພັດທະນາບໍ່ໄດ້ອີງໃສ່ການເຮັດວຽກຂອງເຂົາເຈົ້າເອງຫຼືຖ້າພວກເຮົາລໍຖ້າ
ເວລາຫຼາຍເກີນໄປລະຫວ່າງການຮ້ອງຂໍແລະການລວມຕົວຕົວຈິງ. ແທນທີ່ຈະ, ການໄຫຼເຂົ້າເບິ່ງຄືດັ່ງນີ້:

git remote ເພີ່ມຊື່ repo-url
git fetch ຊື່
git checkout feature-ສາຂາ
git rebase master

# ກວດເບິ່ງວ່າທຸກຢ່າງເຮັດວຽກຢ່າງຖືກຕ້ອງແລະຫຼັງຈາກນັ້ນປະສົມປະສານກັບແມ່ບົດ
git checkout ຕົ້ນສະບັບ
git merge ສາຂາຄຸນສົມບັດ

ສົນທະນາ
ຖ້າທ່ານພົບວ່າຕົວທ່ານເອງຕ້ອງການການຊ່ວຍເຫຼືອໃດໆໃນຂະນະທີ່ເບິ່ງລະຫັດຂອງ Circus, ທ່ານສາມາດໄປໄດ້
ແລະຊອກຫາພວກເຮົາໃນ irc ຢູ່ #ເຕັ້ນເຕັ້ນ on irc.freenode.org (ຫຼືຖ້າທ່ານບໍ່ມີ IRC
ລູກຄ້າ, ໃຊ້ ໄດ້ ສົນທະນາເວັບ)

ນອກນັ້ນທ່ານຍັງສາມາດເລີ່ມຕົ້ນຫົວຂໍ້ໃນບັນຊີລາຍຊື່ທາງໄປສະນີຂອງພວກເຮົາ -
http://tech.groups.yahoo.com/group/circus-dev

ເລື້ອຍໆ ຖືກຖາມ ຄໍາຖາມ
ນີ້ແມ່ນບັນຊີລາຍຊື່ຂອງຄໍາຖາມທີ່ພົບເລື້ອຍກ່ຽວກັບ Circus:

ວິທີການ ບໍ່ Circus stack ປຽບທຽບ to a ຄລາສສິກ stack?
ໃນ stack WSGI ຄລາສສິກ, ທ່ານມີເຄື່ອງແມ່ຂ່າຍເຊັ່ນ Gunicorn ທີ່ໃຫ້ບໍລິການໃນພອດຫຼືເປັນ
unix socket ແລະມັກຈະຖືກນໍາໄປໃຊ້ຢູ່ຫລັງເຄື່ອງແມ່ຂ່າຍເວັບເຊັ່ນ Nginx: [ຮູບພາບ]

ລູກຄ້າໂທຫາ Nginx, ເຊິ່ງ reverse proxies ການໂທທັງຫມົດໄປຫາ Gunicorn.

ຖ້າທ່ານຕ້ອງການໃຫ້ແນ່ໃຈວ່າຂະບວນການ Gunicorn ຄົງຢູ່ແລະແລ່ນ, ທ່ານຕ້ອງໃຊ້ a
ໂຄງການເຊັ່ນ Supervisord ຫຼື upstart.

Gunicorn ແລະເຮັດໃຫ້ການສັງເກດເບິ່ງສໍາລັບຂະບວນການຂອງຕົນ ("ພະນັກງານ").

ໃນຄໍາສັບຕ່າງໆອື່ນໆ, ທ່ານກໍາລັງໃຊ້ສອງລະດັບຂອງການຄຸ້ມຄອງຂະບວນການ. ຫນຶ່ງທີ່ທ່ານຄຸ້ມຄອງແລະ
ການຄວບຄຸມ (ຜູ້ຄຸມງານ), ແລະອັນທີສອງທີ່ທ່ານຕ້ອງຈັດການໃນ UI ທີ່ແຕກຕ່າງກັນ, ມີ a
ປັດຊະຍາທີ່ແຕກຕ່າງກັນແລະການຄວບຄຸມຫນ້ອຍກວ່າສິ່ງທີ່ເກີດຂຶ້ນ (ຫນຶ່ງຂອງເຄື່ອງແມ່ຂ່າຍ wsgi)

ນີ້ແມ່ນຄວາມຈິງສໍາລັບ Gunicorn ແລະເຄື່ອງແມ່ຂ່າຍ WSGI ຫຼາຍຂະບວນການທີ່ສຸດທີ່ຂ້ອຍຮູ້ກ່ຽວກັບ.
uWsgi ແມ່ນແຕກຕ່າງກັນເລັກນ້ອຍຍ້ອນວ່າມັນສະຫນອງທາງເລືອກຫຼາຍຢ່າງ.

ແຕ່ຖ້າທ່ານຕ້ອງການເພີ່ມເຄື່ອງແມ່ຂ່າຍ Redis ໃນ stack ຂອງທ່ານ, ທ່ານ ຈະ ສິ້ນສຸດດ້ວຍການຄຸ້ມຄອງຂອງທ່ານ
ຂະບວນການ stack ໃນສອງສະຖານທີ່ທີ່ແຕກຕ່າງກັນ.

ວິທີການຂອງ Circus ກ່ຽວກັບນີ້ແມ່ນການຄຸ້ມຄອງຂະບວນການ ແລະ ເຕົ້າຮັບ.

ແຜ່ນ Circus ສາ​ມາດ​ເບິ່ງ​ຄື​ນີ້​: [ຮູບ​ພາບ​]

ດັ່ງນັ້ນ, ເຊັ່ນດຽວກັບ Gunicorn, Circus ສາມາດຜູກມັດເຕົ້າສຽບທີ່ຈະຖືກ proxied ໂດຍ Nginx. Circus
ບໍ່ຈັດການກັບການຮ້ອງຂໍແຕ່ພຽງແຕ່ຜູກມັດເຕົ້າຮັບ. ມັນຂຶ້ນກັບຜູ້ເຮັດວຽກເວັບ
ຂະບວນການຍອມຮັບການເຊື່ອມຕໍ່ຢູ່ໃນເຕົ້າຮັບແລະເຮັດວຽກ.

ມັນສະຫນອງຄຸນສົມບັດທຽບເທົ່າ Supervisord ແຕ່ຍັງໃຫ້ທ່ານຈັດການທັງຫມົດ
ຂະບວນການຢູ່ໃນລະດັບດຽວກັນ, ບໍ່ວ່າຈະເປັນພະນັກງານເວັບຫຼື Redis ຫຼືໃດກໍ່ຕາມ. ການເພີ່ມ ກ
ພະນັກງານເວັບໃໝ່ແມ່ນເຮັດຄືກັບການເພີ່ມຂະບວນການ Redis ໃໝ່.

ຕັ່ງ
ພວກເຮົາໄດ້ນັ່ງນັ່ງບໍ່ພໍເທົ່າໃດເພື່ອປຽບທຽບ Circus & Chaussette ກັບ Gunicorn. ເພື່ອສະຫຼຸບ, Circus ແມ່ນ
ບໍ່ໄດ້ເພີ່ມຄ່າໃຊ້ຈ່າຍໃດໆແລະທ່ານສາມາດເລືອກເອົາ backends ທີ່ແຕກຕ່າງກັນຫຼາຍສໍາລັບພະນັກງານເວັບຂອງທ່ານ.

ເບິ່ງ:

· http://blog.ziade.org/2012/06/28/wgsi-web-servers-bench

· http://blog.ziade.org/2012/07/03/wsgi-web-servers-bench-part-2

ວິທີການ to troubleshoot Circus?
ໂດຍຕົວຢ່າງ, ວົງວຽນ ຮັກສາການບັນທຶກຂອງຕົນໄປ stdout ຂ້ອນຂ້າງກະແຈກກະຈາຍ. ການຂາດຜົນຜະລິດນີ້ສາມາດ
ເຮັດໃຫ້ສິ່ງທີ່ຍາກທີ່ຈະແກ້ໄຂບັນຫາໃນເວລາທີ່ຂະບວນການເບິ່ງຄືວ່າມີບັນຫາໃນການເລີ່ມຕົ້ນ.

ເພື່ອເພີ່ມການຕັດໄມ້ ວົງວຽນ ໃຫ້, ພະຍາຍາມເພີ່ມລະດັບບັນທຶກ. ເພື່ອເຂົ້າໄປເບິ່ງ
ລະດັບບັນທຶກທີ່ມີຢູ່ພຽງແຕ່ໃຊ້ - ຊ່ວຍ ທຸງ.

$ circus --log-level debug test.ini

ຄໍາເຕືອນຫນຶ່ງ. ຖ້າຂະບວນການໃດນຶ່ງກະພິບ ແລະລະດັບບັນທຶກການດີບັກຖືກເປີດໃຊ້, ເຈົ້າ
ຈະເຫັນຂໍ້ຄວາມສໍາລັບແຕ່ລະຄວາມພະຍາຍາມເລີ່ມຕົ້ນ. ມັນອາດຈະເປັນປະໂຫຍດທີ່ຈະ configure app ທີ່ເປັນ
flapping ການນໍາໃຊ້ a warmup_delay ເພື່ອເຮັດໃຫ້ຂໍ້ຄວາມຊ້າລົງໄປສູ່ຈັງຫວະທີ່ສາມາດຈັດການໄດ້.

[ຜູ້ເບິ່ງ: webapp]
cmd = python -m myapp.wsgi
warmup_delay = 5

ໂດຍຕົວຢ່າງ, stdout ແລະ stderr ຖືກຈັບໂດຍ ວົງວຽນ ຂະ​ບວນ​ການ. ຖ້າທ່ານກໍາລັງທົດສອບຂອງທ່ານ
config ແລະຕ້ອງການເບິ່ງຜົນໄດ້ຮັບທີ່ສອດຄ່ອງກັບຜົນຜະລິດ circusd, ທ່ານສາມາດ configure ຂອງທ່ານ
watcher ການ​ນໍາ​ໃຊ້​ StdoutStream ຊັ້ນຮຽນ.

[ຜູ້ເບິ່ງ: webapp]
cmd = python -m myapp.wsgi
stdout_stream.class = StdoutStream
stderr_stream.class = StdoutStream

ຖ້າຄໍາຮ້ອງສະຫມັກຂອງທ່ານກໍາລັງຜະລິດ traceback ຫຼືຄວາມຜິດພາດໃນເວລາທີ່ມັນພະຍາຍາມເລີ່ມຕົ້ນທ່ານ
ຄວນຈະສາມາດເຫັນມັນຢູ່ໃນຜົນຜະລິດ.

ການປ່ຽນແປງ ປະຫວັດສາດ
0.12.1 - 2015-08-05
· ແກ້​ໄຂ​ຄວາມ​ຜິດ​ພາດ​ໃນ​ເວ​ລາ​ທີ່ restart watcher ກັບ​ສະ​ຕ​ຣີມ​ຜົນ​ຜະ​ລິດ - #913​

· ປັບປ່ຽນເອກະສານເລັກນ້ອຍ

0.12 - 2015-06-02
ການປ່ອຍນີ້ເອົາ Python 3.4, Tornado 4 ແລະການສະຫນັບສະຫນູນ Windows, ໃນບັນດາສິ່ງທີ່ຫນ້າຕື່ນເຕັ້ນຫຼາຍ
ຄຸນ​ນະ​ສົມ​ບັດ​ແລະ​ການ​ແກ້​ໄຂ​.

ການສະຫນັບສະຫນູນ Windows ແມ່ນຍັງທົດລອງ, ແລະບໍ່ໄດ້ຈັດການການຖ່າຍທອດ.

ການປ່ຽນແປງທີ່ ສຳ ຄັນ:

· ຄວາມເຂົ້າກັນໄດ້ກັບ Python 3.4 - #768

· ທົດລອງຮອງຮັບ Windows - #788

·ເຂົ້າກັນໄດ້ກັບ Tornado 4 - #872

· ການປັບປຸງການຫຸ້ມຫໍ່ Debian - #896 - #903

· ຕື່ມການຮອງຮັບສໍາລັບແກ່ນຂະບວນການ Papa - #850

·ເພີ່ມການຈັບຄູ່ globing ແລະ regex ສໍາລັບການເລີ່ມຕົ້ນ, ຢຸດແລະ restart watchers - #829 -
#902

ການປ່ຽນແປງເພີ່ມເຕີມ:

· ການເພີ່ມປະສິດທິພາບຂອງການປິດ - #784 - #842

·ເພີ່ມຄວາມເປັນໄປໄດ້ໃນການລະບຸສະບັບ virtualenv ສໍາລັບ watchers - #805

· ຕື່ມທາງເລືອກ --nostop ໃສ່ຄໍາສັ່ງ rmwatcher - #777

· ເພີ່ມການໂທກັບ Arbiter.start - #840

· ແກ້ໄຂການໂຫຼດຜູ້ເບິ່ງໃໝ່ດ້ວຍຕົວພິມໃຫຍ່ - #823

· ເອົາ socket ຮົ່ວໃນ stats daemon - #843

· ແກ້ໄຂ multicast ໃນ SunOS - #876

· ປິດສະຕຣີມຜົນຜະລິດເມື່ອຢຸດຜູ້ເບິ່ງ - #885

· ແກ້ໄຂສັນຍານການສົ່ງຫາຫລານດ້ວຍ --recursive - #888

0.11.1 - 2014-05-22
· ແກ້ໄຂການຖົດຖອຍທີ່ທໍາລາຍ Circus ໃນ 2.6 - #782

0.11 - 2014-05-21
ການປ່ອຍນີ້ບໍ່ໄດ້ນໍາສະເຫນີລັກສະນະຫຼາຍ, ແລະສຸມໃສ່ການເຮັດໃຫ້ Circus ຫຼາຍ
ແຂງແຮງ & ໝັ້ນຄົງ.

ການ​ປ່ຽນ​ແປງ / ການ​ແກ້​ໄຂ​ທີ່​ສໍາ​ຄັນ​:

· ໃຫ້ແນ່ໃຈວ່າພວກເຮົາບໍ່ສາມາດປະຕິບັດສອງຄໍາສັ່ງຂັດກັນໃນ arbiter ພ້ອມກັນ.

· ພວກ​ເຮົາ​ມີ 2 ຫ້ອງ​ສະ​ຕ​ຣີມ​ໃຫມ່​: TimedRotatingFileStream​, WatchedFileStream

· ພວກ​ເຮົາ​ມີ hook ໃຫມ່​: after_spawn hook​

· CircusPlugin ແມ່ນງ່າຍຕໍ່ການໃຊ້

· ແກ້ໄຂ autostart=ຕົວເບິ່ງທີ່ບໍ່ຖືກຕ້ອງໃນລະຫວ່າງການເລີ່ມຕົ້ນ (ການຖົດຖອຍ)

ການປ່ຽນແປງເພີ່ມເຕີມ:

· ຂໍ້ຄວາມ circus ສາມາດຖືກສົ່ງໄປຫາ syslog ໃນປັດຈຸບັນ - #748

· ທາງເລືອກ endpoint_owner ເພີ່ມເພື່ອໃຫ້ພວກເຮົາສາມາດກໍານົດວ່າຜູ້ໃຊ້ໃດເປັນເຈົ້າຂອງໄຟລ໌ ipc socket ສ້າງໂດຍ
ວົງດົນຕີ.

· ເລີ່ມ​ຕົ້ນ​ການ​ສະ​ຫນັບ​ສະ​ຫນູນ Windows (ພຽງ​ແຕ່ circusctl ສໍາ​ລັບ​ປັດ​ຈຸ​ບັນ​)

·ແກ້ໄຂການຮົ່ວໄຫຼຫຼາຍໃນການທົດສອບ

· ອະນຸຍາດຕົວແປສະພາບແວດລ້ອມທີ່ລະອຽດອ່ອນ

· ປັ໊ກອິນຊັບພະຍາກອນຕອນນີ້ຍອມຮັບຄ່າຄວາມຈຳຢ່າງແທ້ຈິງ - #609

· ຕື່ມ​ການ​ສະ​ຫນັບ​ສະ​ຫນູນ​ຄໍາ​ສັ່ງ​ເພີ່ມ​ສໍາ​ລັບ​ທາງ​ເລືອກ 'singleton​' - #767​

· ອະ​ນຸ​ຍາດ​ໃຫ້​ສົ່ງ​ສັນ​ຍານ​ໂດຍ​ຕົນ​ເອງ​ກັບ procs ເດັກ​ນ້ອຍ​ໂດຍ​ຜ່ານ​ການ watcher ຊັບ​ພະ​ຍາ​ກອນ - #756​

· ອະນຸຍາດການຕັ້ງຄ່າ INI/JSON/YAML ສໍາລັບການບັນທຶກ

· ໃຫ້ແນ່ໃຈວ່າພວກເຮົາເຂົ້າກັນໄດ້ກັບ psutil 2.x ແລະ 3.x

· ເພີ່ມການວັດແທກເພີ່ມເຕີມໃຫ້ກັບຜູ້ໃຫ້ບໍລິການ statsd - #698

· ການຄົ້ນພົບ multicast ຄົງທີ່ - #731

· ເລີ່ມ​ຕົ້ນ​, restart ແລະ reload ເປັນ​ເອ​ກະ​ພາບ​ຫຼາຍ - #673​

· ເລີ່ມຕົ້ນກຸ່ມນຳໃຊ້ທັງໝົດຢ່າງຖືກຕ້ອງ - #635

·ປັບປຸງຄວາມຫມັ້ນຄົງຂອງການທົດສອບ

· ຫຼາຍ, ຫຼາຍສິ່ງຫຼາຍຢ່າງ ....

0.10 - 2013-11-04
ການປ່ຽນແປງທີ່ ສຳ ຄັນ:

· ດຽວນີ້ Python 3.2 & 3.3 ເຂົ້າກັນໄດ້ - #586

· ຍ້າຍຫຼັກໄປຫາຮູບແບບ async ເຕັມຮູບແບບ - #569

· ປັບປຸງເອກະສານ - #622

ການປ່ຽນແປງເພີ່ມເຕີມ:

· ເພີ່ມ stop_signal & stop_children - #594

· ໃຫ້ແນ່ໃຈວ່າ plugin watchdog ປິດເຕົ້າຮັບ - #588

·ປ່ຽນເປັນ ZMQ JSON parser

· ບໍ່ຮອງຮັບໃນທຸກເວທີ - #573

· ອະ​ນຸ​ຍາດ​ໃຫ້​ການ​ທົດ​ແທນ​ສະ​ພາບ​ແວດ​ລ້ອມ​ທົ່ວ​ໂລກ​ໃນ​ພາກ​ສ່ວນ​ການ​ຕັ້ງ​ຄ່າ​ໃດ​ຫນຶ່ງ - #560​

·ອະນຸຍາດໃຫ້ dashes ໃນຊື່ພາກສ່ວນ - #546

· ຕອນນີ້ຕົວແປຖືກຂະຫຍາຍຢູ່ທົ່ວທຸກແຫ່ງໃນການຕັ້ງຄ່າ - #554

· ເພີ່ມ plugin CommandReloader

· ເພີ່ມ before_signal & after_signal hooks

· ອະນຸຍາດໃຫ້ປລັກອິນ flapping ລອງໃຫມ່ຢ່າງບໍ່ມີກຳນົດ

· ຢ່າສ້າງ procs ຄືນໃໝ່ເມື່ອຜູ້ເບິ່ງຢຸດ - #529 - #536

·ເພີ່ມ id ເປັນເອກະລັກສໍາລັບແຕ່ລະຂໍ້ຄວາມລູກຄ້າ - #517

· ID ພະນັກງານໃນປັດຈຸບັນແມ່ນ "ຊ່ອງ" -

· ແກ້​ໄຂ​ພຶດ​ຕິ​ກໍາ​ການ​ປິດ​ທີ່​ສະ​ຫງ່າ​ງາມ - #515​

· ໃຫ້ແນ່ໃຈວ່າພວກເຮົາສາມາດເພີ່ມ watchers ເຖິງແມ່ນວ່າຜູ້ຕັດສິນບໍ່ໄດ້ເລີ່ມຕົ້ນ - #503

· ໃຫ້ແນ່ໃຈວ່າພວກເຮົາປິດຂະບວນການຫມົດອາຍຸ - #510

·ໃຫ້ແນ່ໃຈວ່າຄໍາສັ່ງທີ່ກໍານົດໄວ້ສາມາດກໍານົດ hook ຫຼາຍ

· ຮອງຮັບຊັອກເກັດ ipv6 ຢ່າງຖືກຕ້ອງ - #507

· ອະນຸຍາດທາງເລືອກທີ່ກຳນົດເອງສຳລັບ stdout_stream ແລະ stderr_stream - #495

· ເພີ່ມ time_format ສໍາລັບ FileStream - #493

·ເພີ່ມຕົວເລືອກການຕັ້ງຄ່າເຕົ້າຮັບໃໝ່ເພື່ອຜູກມັດກັບສ່ວນຕິດຕໍ່ສະເພາະໂດຍຊື່

0.9.3 - 2013-09-04
· ໃຫ້ແນ່ໃຈວ່າພວກເຮົາສາມາດເພີ່ມ watchers ເຖິງແມ່ນວ່າຜູ້ຕັດສິນບໍ່ໄດ້ເລີ່ມຕົ້ນ

· ໃຫ້ແນ່ໃຈວ່າພວກເຮົາປາກົດຂະບວນການຫມົດອາຍຸ

·ໃຫ້ແນ່ໃຈວ່າຄໍາສັ່ງທີ່ກໍານົດໄວ້ສາມາດກໍານົດຫນຶ່ງຫຼືຫຼາຍ hook

· ຮອງຮັບ ipv6 sockets ແລະການປັບປຸງ CircusSockets ຢ່າງຖືກຕ້ອງ

·ໃຫ້ຄ່າເລີ່ມຕົ້ນຂອງເສັ້ນທາງເພື່ອປ້ອງກັນ UnboundLocalError

· ເພີ່ມການທົດສອບການມີຢູ່ຂອງ multicast_endpoint ໃນການເລີ່ມຕົ້ນຂອງ Controller

· ບໍ່​ໄດ້​ປ່ຽນ​ທຸກ​ຕົວ​ເລກ​ເປັນ ints ອີກ​ຕໍ່​ໄປ

·​ເພີ່ມ​ການ​ທົດ​ສອບ​

· ບໍ່ຈໍາເປັນຕ້ອງມີກໍລະນີພິເສດເມື່ອປ່ຽນຕົວເລືອກ stdout_stream

·ຍັງຍອມຮັບ umask ເປັນການໂຕ້ຖຽງສໍາລັບຄວາມສອດຄ່ອງ

· ອະນຸຍາດທາງເລືອກທີ່ກຳນົດເອງສຳລັບ stdout_stream ແລະ stderr_stream.

·ເພີ່ມທາງເລືອກການຕັ້ງຄ່າເຕົ້າສຽບໃຫມ່ເພື່ອຜູກມັດກັບການໂຕ້ຕອບສະເພາະໂດຍຊື່

· ເພີ່ມ time_format ສໍາລັບ FileStream + ການທົດສອບ

·ອັບເດດ circus.upstart

0.9.2 - 2013-07-17
· ເມື່ອ PYTHONPATH ຖືກກໍານົດໄວ້ໃນໄຟລ໌ config, ມັນຖືກໂຫລດຢູ່ໃນ sys.path ດັ່ງນັ້ນ hooks ສາມາດເປັນ.
ຢູ່ທີ່ນັ້ນ - #477, #481

·ໃຊ້ການໂຕ້ຖຽງດຽວສໍາລັບ add_callback ດັ່ງນັ້ນມັນເຮັດວຽກກັບ PyZMQ < 13.1.x - ເບິ່ງ #478

0.9 - 2013-07-16
· ເພີ່ມ [env] ພາກ ສ່ວນ ຕົວ ແທນ

· ເພີ່ມພາກ [env] ທົ່ວໂລກ

· ການ​ແກ້​ໄຂ​ຂໍ້​ຍົກ​ເວັ້ນ​ທີ່​ເຊື່ອງ​ໄວ້​ໃນ​ເວ​ລາ​ທີ່ circus-web ບໍ່​ໄດ້​ຕິດ​ຕັ້ງ - #424​

·ໃຫ້ແນ່ໃຈວ່າ incr/decr ຄໍາສັ່ງຂອງພວກເຮົາຢ່າງແທ້ຈິງທາງເລືອກ nb - #421

· ແກ້ໄຂແພັກເກັດເວັບໄຊທ໌ virtualenv ຂອງ watcher ທີ່ບໍ່ຢູ່ໃນ PYTHONPATH

·ໃຫ້ແນ່ໃຈວ່າພວກເຮົາບໍ່ພະຍາຍາມເອົາຂະບວນການຫຼາຍກ່ວາ 0 - #429

· ອັບເດດ bootstrap.py - #436

·ຕົວແຍກ multiplatform ຄົງທີ່ໃນ pythonpath virtualenv watcher

· ຟັງຊັນປິດ socket refactored

· ໃຫ້ແນ່ໃຈວ່າພາກສ່ວນ env ຖືກນໍາໃຊ້ກັບຜູ້ເບິ່ງທັງຫມົດ - #437

·ເພີ່ມຄໍາສັ່ງ reloadconfig

· ເພີ່ມ circus.green ແລະເອົາອອກ gevent ຈາກຫຼັກ - #441, #452

· silenced stdout spurious & ການເຕືອນໄພໃນການທົດສອບ - #438

· $(circus.env.*) ສາມາດໃຊ້ສໍາລັບຕົວເລືອກທັງໝົດໃນການຕັ້ງຄ່າດຽວນີ້

· ໄດ້ເພີ່ມ hook before_spawn

·ແກ້ໄຂເສັ້ນທາງຂອງ circusd ໃນໄຟລ໌ການບໍລິການ systemd - #450

·ໃຫ້ແນ່ໃຈວ່າພວກເຮົາສາມາດປ່ຽນ hook ແລະກໍານົດສາຍນ້ໍາຜ່ານ CLI - #455

· ປັບປຸງເອກະສານ

·ເພີ່ມສະຖິຕິ spawn_count ໃນ watcher

·ເພີ່ມພາລາມິເຕີ min_cpu ແລະ min_mem ໃນ plugin ResourceWatcher

·ເພີ່ມຂໍ້ມູນ FQDN ໃຫ້ກັບຜູ້ຕັດສິນ.

0.8.1 - 2013-05-28
· circusd-stats ໄດ້ choking ສຸດ sockets unix - #415

· circusd-stats & circushttpd ຂະບວນການເດັກ stdout/stderr ປະຈຸບັນຖືກປະໄວ້ໂດຍຄ່າເລີ່ມຕົ້ນ.
Python <= 2.7.5 ຈະ choke ໃນໂມດູນບັນທຶກໃນກໍລະນີທີ່ 2/3 fds ຖືກປິດ - #415

· ຕອນນີ້ປ່ຽນເສັ້ນທາງໄປຫາ /dev/null ໃນຂະບວນການເດັກແທນທີ່ຈະປິດ. #417

0.8 - 2013-05-24
·ຕົວຈັດການບັນທຶກປະສົມປະສານເຂົ້າໄປໃນ zmq io loop.

·ເຮັດໃຫ້ redirector restartable ແລະຕໍ່ມາທີ່ເຂັ້ມແຂງຫຼາຍ.

· ໃຊ້ zmq.green.eventloop ເມື່ອ gevent ຖືກກວດພົບ

· ເພີ່ມ​ການ​ສະ​ຫນັບ​ສະ​ຫນູນ​ສໍາ​ລັບ​ການ CIRCUSCTL_ENDPOINT ສະ​ພາບ​ແວດ​ລ້ອມ​ຕົວ​ປ່ຽນ​ໄດ້​ເປັນ circusctl - #396

· util: ແກ້ໄຂຂໍ້ຜິດພາດໃນຟັງຊັນ to_uid - #397

· ເອົາ handler ໃນຄວາມຜິດພາດ ioloop - #398.

· ການປັບປຸງການຄຸ້ມຄອງການທົດສອບ

· ເຊົາເລືອກ 'ບໍລິການ' ສໍາລັບ plugin ResourceWatcher - #404

· ການ​ນໍາ​ໃຊ້ psutil.error ອອກ​

· ເພີ່ມການຄົ້ນພົບ UDP ໃນ circusd - #407

· ຕອນນີ້ອະນຸຍາດໃຫ້ globs ຢູ່ໃນລະດັບໄດເລກະທໍລີທີ່ມັກ - #388

· ເພີ່ມຕົວເລືອກການຕັ້ງຄ່າ 'statd' - #408

· ເພີ່ມ pidfile, logoutput ແລະທາງເລືອກ loglevel ກັບໄຟລ໌ການຕັ້ງຄ່າ circus - #379

· ເພີ່ມການສອນໃນເອກະສານ.

·ໃຫ້ແນ່ໃຈວ່າພວກເຮົາກໍາລັງລວມທຸກພາກສ່ວນໃນເວລາທີ່ການນໍາໃຊ້ປະກອບມີ - #414

·ເພີ່ມ pipe_stdout, pipe_stderr, close_child_stderr & close_child_stdout ທາງເລືອກໃນການ
ຫ້ອງຮຽນຂະບວນການ

· ເພີ່ມຕົວເລືອກ close_child_stderr & close_child_stdout ໃຫ້ກັບຜູ້ເບິ່ງ

0.7.1 - 2013-05-02
·ແກ້ໄຂທາງເລືອກ respawn - #382

· ໃຫ້ແນ່ໃຈວ່າພວກເຮົາໃຊ້ int ສໍາລັບເວລາຫມົດເວລາ - #380

·ສະແດງເຕົ້າຮັບ unix ເຊັ່ນດຽວກັນ - #381

·ໃຫ້ແນ່ໃຈວ່າມັນເຮັດວຽກກັບ pyzmq ຫລ້າສຸດ

· ນຳສະເໜີ syntax ທີສອງສໍາລັບ notation fd

0.7 - 2013-04-08
·ແກ້ໄຂຕົວຢ່າງ get_arbiter ເພື່ອໃຊ້ຄໍາສັ່ງສໍາລັບການໂຕ້ຖຽງຂອງ watchers. #304

· ເພີ່ມບາງເອກະສານແກ້ໄຂບັນຫາ #323

· ເພີ່ມການຮອງຮັບ python buildout

· ເອົາ gevent ແລະຕົວຊີ້ທິດທາງກະທູ້ອອກ. ຕອນນີ້ໃຊ້ ioloop - ແກ້ໄຂ #346.
ກ່ຽວຂ້ອງ #340

· circus.web ໃນປັດຈຸບັນແມ່ນໂຄງການຂອງຕົນເອງ

· ລົບ​ການ​ແກ້​ໄຂ pyzmq​

· ອະ​ນຸ​ຍາດ​ໃຫ້ watcher ໄດ້​ຮັບ​ການ​ຕັ້ງ​ຄ່າ​ແຕ່​ບໍ່​ໄດ້​ເລີ່ມ​ຕົ້ນ #283​

·ເພີ່ມທາງເລືອກໃນການໂຫຼດເວັບໄຊທ໌ virtualenv dir

· ເພີ່ມຜູ້ເບິ່ງຕາມຄວາມຕ້ອງການ

· ເພີ່ມເອກະສານກ່ຽວກັບ nginx+websockets #371

· ຕອນນີ້ກຳລັງວິເຄາະລາຍຊື່ຕົວເລືອກຂອງແຕ່ລະຄຳສັ່ງ #369 ຢ່າງຖືກຕ້ອງ

· ການ​ຈັດ​ການ​ເຫດ​ການ​ສະ​ຖິ​ຕິ circusd ຄົງ​ທີ່ #372​

· ແກ້​ໄຂ​ບັນ​ຫາ overflow ໃນ circus-top #378

·​ຫຼາຍ​ຢ່າງ​ຫຼາຍ​ຢ່າງ ...

0.6 - 2012-12-18
· Patching protocols name for sockets - #248

· ຫ້າມ​ຂະ​ບວນ​ການ​ອັດ​ຕະ​ໂນ​ມັດ. #240

· circusctl: ຕື່ມການຊ່ວຍຄໍາສັ່ງ, ຈາກ docstrings #217

· ເພີ່ມ hooks ພະ ນັກ ງານ

· ເພີ່ມຊຸດ Debian - #227

· ເພີ່ມ Redis, HTTP Observer, ສະຖິຕິເຕັມ & plugins ຊັບພະຍາກອນ

·ໃນປັດຈຸບັນຂະບວນການສາມາດມີຫົວຂໍ້

· ເພີ່ມການຕື່ມຂໍ້ມູນອັດຕະໂນມັດ

· ເພີ່ມຂະບວນການ/ອາຍຸຜູ້ເບິ່ງໃນ webui

·ເພີ່ມການສະຫນັບສະຫນູນອຸໂມງ SSH

·ຕອນນີ້ໃຊ້ pyzmq.green

· ເພີ່ມ script upstart & Varnish doc

·ເພີ່ມຕົວແປສະພາບແວດລ້ອມແລະພາກສ່ວນ

·ເພີ່ມການສະຫນັບສະຫນູນເຕົ້າສຽບ unix

· ເພີ່ມ ຟື້ນຄືນ ທາງເລືອກທີ່ຈະມີ watchers ແລ່ນດຽວ

·ໃນປັດຈຸບັນການນໍາໃຊ້ tox ໃນການທົດສອບ

·ອະນຸຍາດໃຫ້ປ່ຽນຊັອກເກັດໃນ args

· ຫົວຂໍ້ເອກະສານໃໝ່

· ຕົວເລືອກການຫມຸນໃໝ່ສຳລັບກະແສ: max_bytes/backup_count

0.5.2 - 2012-07-26
· ຕອນນີ້ໄດ້ແກ້ໄຂໂມດູນກະທູ້ຈາກ stdlib ເພື່ອຫຼີກເວັ້ນບາງແມງໄມ້ Python - #203

· ຫນ້າຈໍການຊ່ວຍເຫຼືອ circusctl ດີກວ່າ

· ໃຊ້ pustil get_nice() ເມື່ອມີໃຫ້ (ດີຖືກຍົກເລີກ) - #208

· ເພີ່ມການສະຫນັບສະຫນູນ max_age - #221

·ພຽງແຕ່ໂທຫາຟັງ() ໃນ SOCK_STREAM ຫຼື SOCK_SEQPACKET sockets

· ໃຫ້ແນ່ໃຈວ່າຕົວຄວບຄຸມຫວ່າງເປົ່າລາຍການ plugins ໃນ update_watchers() - #220

· ເພີ່ມ --log-level ແລະ --log-output ໃສ່ circushttpd

·ແກ້ໄຂຂະບວນການຂ້າຜ່ານ web 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
·​ເພີ່ມ​ສະ​ຫນັບ​ສະ​ຫນູນ socket​

·ເພີ່ມຄໍາສັ່ງ listsocket

· sockets ມີ​ສະ​ຖິ​ຕິ​ເຊັ່ນ​ດຽວ​ກັນ​!

·ແກ້ໄຂຂໍ້ບົກຜ່ອງຂະຫນາດນ້ອຍຫຼາຍ

· ເອົາ wid ອອກ - ຕອນນີ້ໃຊ້ pid ຢູ່ທົ່ວທຸກແຫ່ງ

· ການ​ທົດ​ສອບ​ໄວ​ຂຶ້ນ​

·ມີການປ່ຽນແປງ syntax ຂອງຕົວແປ

· ໃຊ້ ioloop ຂອງ pyzmq ໃນສະຖານທີ່ຫຼາຍ

·ຕອນນີ້ໃຊ້ iowait ສໍາລັບການໂທຫາທັງຫມົດ select()

· ຄໍາສັ່ງ incr/decr ໃນປັດຈຸບັນມີພາລາມິເຕີ nbprocess

· ເພີ່ມຕົວເລືອກ reproduce_env ໃຫ້ກັບຜູ້ເບິ່ງ

· ເພີ່ມສະຖານະໃໝ່ທີ່ບໍ່ມີຢູ່ແລ້ວໃຫ້ກັບຂະບວນການຕ່າງໆ

·ເພີ່ມທົ່ວໂລກ httpd ທາງເລືອກທີ່ຈະດໍາເນີນການ circushttpd ເປັນ watcher

0.4 - 2012-06-12
· ເພີ່ມລະບົບປລັກອິນ

·ເພີ່ມທາງເລືອກ "singleton" ສໍາລັບ watchers

· ສ້ອມແຊມການກະພິບຂອງຈໍສະແດງຜົນເທິງ

· ຖອດກະທູ້ອອກຈາກ circus.stats ໃນເງື່ອນໄຂຂອງ zmq callbacks ແຕ່ລະໄລຍະ

· ປັບປຸງເອກະສານ

· Circus client ໃນປັດຈຸບັນມີ send_message api

·ຄຸນນະສົມບັດ flapping ໃນປັດຈຸບັນເປັນ plugin

·ທຸກເຄື່ອງມືບັນທັດຄໍາສັ່ງມີທາງເລືອກ --version

· ເພີ່ມ plugin statsd (ສົ່ງເຫດການຈາກ circus ກັບ statsd)

· UI ເວັບໃນປັດຈຸບັນໃຊ້ websockets (ຜ່ານ socketio) ເພື່ອເອົາສະຖິຕິ

· UI ເວັບໃນປັດຈຸບັນໃຊ້ sessions ສໍາລັບ "ຂໍ້ຄວາມ flash" ໃນ web ui

0.3.4 - 2012-05-30
·ແກ້ໄຂສະພາບການແຂ່ງຂັນທີ່ປ້ອງກັນບໍ່ໃຫ້ຜູ້ຄວບຄຸມສາມາດເກັບກ່ຽວຂະບວນການສໍາເລັດຮູບຢ່າງສະອາດ.

·ຕອນນີ້ check_flapping ສາມາດຄວບຄຸມໄດ້ໃນການຕັ້ງຄ່າ. ແລະ activated / deactivated
ຕໍ່ຜູ້ເບິ່ງ.

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
· ແກ້ໄຂ: ໃຫ້ແນ່ໃຈວ່າຄ່າເລີ່ມຕົ້ນຂອງ watcher ບໍ່ໄດ້ຖືກ overrided

· ເພີ່ມຫ້ອງຮຽນ StdoutStream.

0.3 - 2012-04-18
·ເພີ່ມຄຸນສົມບັດ streaming

· ຕອນນີ້ກຳລັງສະແດງການຄຸ້ມຄອງຢູ່ໃນ Sphinx doc

·​ແກ້​ໄຂ​ວິ​ທີ​ການ​ຂະ​ບວນ​ການ​ໄດ້​ຖືກ​ຂ້າ​ຕາຍ (ບໍ່ SIGQUIT ຫຼາຍ​)

· ການ​ຕັ້ງ​ຄ່າ​ໄດ້​ຮັບ​ການ​ປັດ​ໄຈ​ອອກ​

·ສະຫນັບສະຫນູນ setproctitle

0.2 - 2012-04-04
· ເອົາອອກ ສະແດງໃຫ້ເຫັນ ຊື່. ທົດແທນໂດຍ watcher.

·ເພີ່ມການສະຫນັບສະຫນູນສໍາລັບຂະບວນການກໍານົດ ຈຳກັດ.

·ເພີ່ມການສະຫນັບສະຫນູນສໍາລັບການລວມ dirs ໃນໄຟລ໌ config.

· ແກ້ໄຂບາງຕົວອະທິບາຍໄຟລ໌ທີ່ຮົ່ວ.

· ແກ້​ໄຂ​ຂີ້​ຝຸ່ນ​ຫຼັກ​ໃນ flapping ໄດ້​

· ການປັບປຸງເອກະສານ

· ໃຫ້ແນ່ໃຈວ່າ circusd ຜິດພາດຢ່າງຖືກຕ້ອງເມື່ອ circusd ອື່ນແລ່ນຢູ່ໃນເຕົ້າສຽບດຽວກັນ.

· get_arbiter ດຽວນີ້ຍອມຮັບຜູ້ເບິ່ງຫຼາຍໆຄົນ.

·ແກ້ໄຂ cmd vs args vs executable ໃນຂະບວນການ init.

· ຄົງ --start on circusctl add

0.1 - 2012-03-20
· ການ​ປ່ອຍ​ຕົວ​ເບື້ອງ​ຕົ້ນ​

ຜູ້ຊາຍ ຫນ້າ
ວົງວຽນ ຜູ້ຊາຍ Page
Synopsis
circusd [ຕົວເລືອກ] [config]

ລາຍລະອຽດ
circusd ແມ່ນຂະບວນການຕົ້ນຕໍຂອງສະຖາປັດຕະ Circus. ມັນໃຊ້ເວລາດູແລຂອງແລ່ນທັງຫມົດ
ຂະບວນການ. ແຕ່​ລະ​ຂະ​ບວນ​ການ​ຄຸ້ມ​ຄອງ​ໂດຍ Circus ເປັນ​ຂະ​ບວນ​ການ​ຂອງ​ເດັກ​ນ້ອຍ​ ວົງວຽນ.

Arguments
config ແຟ້ມການຕັ້ງຄ່າ

ທາງເລືອກໃນການ
-ຊ, - ຊ່ວຍ
ສະແດງຂໍ້ຄວາມຊ່ວຍເຫຼືອ ແລະອອກ

--log-level LEVEL
ລະບຸລະດັບບັນທຶກ. LEVEL ສາມາດ ຂໍ້ມູນ, debug, ສໍາຄັນ, ການເຕືອນໄພ or ຄວາມຜິດພາດ.

--log-output ອອກຈາກລະບົບ
ສະຖານທີ່ບ່ອນທີ່ບັນທຶກຈະຖືກຂຽນ. ພຶດຕິກໍາເລີ່ມຕົ້ນແມ່ນການຂຽນໃສ່
stdout (ທ່ານສາມາດບັງຄັບມັນໄດ້ໂດຍການສົ່ງ '-' ໄປຫາທາງເລືອກນີ້). ເອົາຊື່ໄຟລ໌
ຖ້າບໍ່ດັ່ງນັ້ນ.

--logger-config LOGGERCONFIG
ສະຖານທີ່ບ່ອນທີ່ການຕັ້ງຄ່າມາດຕະຖານຕົວບັນທຶກໄຟລ໌ Python INI, JSON ຫຼື YAML
ສາມາດພົບໄດ້. ນີ້ສາມາດຖືກນໍາໃຊ້ເພື່ອ override ການຕັ້ງຄ່າການບັນທຶກໃນຕອນຕົ້ນສໍາລັບ
ຜູ້ຕັດສິນ.

--daemon
ເລີ່ມ circusd ໃນພື້ນຫລັງ.

--pidfile PIDFILE
ທີ່ຕັ້ງຂອງໄຟລ໌ PID.

- ການປ່ຽນແປງ
ສະ​ແດງ​ສະ​ບັບ Circus ແລະ​ອອກ​.

ເບິ່ງ ຍັງ
circus (1) circusctl (1) circusd-ສະຖິຕິ (1) circus-plugin (1) circus-top (1).

ເອກະສານສະບັບເຕັມແມ່ນມີຢູ່ http://circus.readthedocs.org

circusctl ຜູ້ຊາຍ Page
Synopsis
circusctl [ຕົວເລືອກ] ຄໍາສັ່ງ [args]

ລາຍລະອຽດ
circusctl ແມ່ນດ້ານຫນ້າເພື່ອຄວບຄຸມ Circus daemon. ມັນ​ໄດ້​ຖືກ​ອອກ​ແບບ​ເພື່ອ​ຊ່ວຍ​ໃຫ້​
ຜູ້ບໍລິຫານຄວບຄຸມການເຮັດວຽກຂອງ Circud ວົງວຽນ ເດມອນ

ຄໍາສັ່ງ
ເພີ່ມ ເພີ່ມຜູ້ເບິ່ງ

Decr ຫຼຸດຈຳນວນຂະບວນການໃນຕົວເຝົ້າລະວັງ

dstats ໄດ້ຮັບສະຖິຕິ circusd

ໄດ້ຮັບ ໄດ້​ຮັບ​ຄຸນ​ຄ່າ​ຂອງ​ຕົວ​ເລືອກ watcher ສະ​ເພາະ​

globaloptions
ໄດ້ຮັບທາງເລືອກ arbiter

incr ເພີ່ມຈໍານວນຂອງຂະບວນການໃນ watcher

python
ສ້າງແກະເຂົ້າໄປໃນຂະບວນການ circusd

ບັນຊີລາຍຊື່ ເອົາລາຍຊື່ຜູ້ເບິ່ງ ຫຼືຂະບວນການໃນຕົວເບິ່ງ

ຟັງ ຕິດຕາມເຫດການຂອງຜູ້ເບິ່ງ

ບັນຊີລາຍການ
ເອົາບັນຊີລາຍຊື່ຂອງເຕົ້າຮັບ

ຂະ​ບວນ​ການ​ຈໍາ​ນວນ​
ໄດ້ຮັບຈໍານວນຂອງຂະບວນການ

ຕົວເລກ
ເອົາຈໍານວນຜູ້ເບິ່ງ

ທາງເລືອກໃນການ
ເອົາມູນຄ່າຂອງທາງເລືອກທັງຫມົດສໍາລັບຜູ້ເບິ່ງ

ເຊົາ ອອກຈາກຜູ້ຕັດສິນທັນທີ

ໂຫຼດ ໃໝ່ ໂຫຼດ arbiter ຫຼື watcher ເປັນ

reloadconfig
ໂຫຼດໄຟລ໌ການຕັ້ງຄ່າຄືນໃໝ່

ເລີ່ມ​ຕົ້ນ​ໃຫມ່
ຣີສະຕາດ arbiter ຫຼື watcher

rm ເອົາຜູ້ເບິ່ງອອກ

ທີ່ກໍານົດໄວ້ ກໍານົດທາງເລືອກ watcher

signal ສົ່ງສັນຍານ

ການເລີ່ມຕົ້ນ ເລີ່ມຕົ້ນຜູ້ຕັດສິນຫຼືຜູ້ເບິ່ງ

ສະຖິຕິ ໄດ້​ຮັບ​ຂໍ້​ມູນ​ຂະ​ບວນ​ການ​

ສະຖານະພາບ ໄດ້ຮັບສະຖານະພາບຂອງຜູ້ເບິ່ງຫຼືຜູ້ເບິ່ງທັງຫມົດ

ຢຸດ ຢຸດຜູ້ເບິ່ງ

ທາງເລືອກໃນການ
--ຈຸດຈົບ ສິ້ນສຸດ
ຈຸດເຊື່ອມຕໍ່

-ຊ, - ຊ່ວຍ
ສະແດງຂໍ້ຄວາມຊ່ວຍເຫຼືອ ແລະອອກ

--json ສົ່ງອອກໄປຍັງ JSON

--ເຮັດງາມ
prettify ຜົນ​ຜະ​ລິດ​

--ssh SSH
SSH Server ໃນຮູບແບບ user@host:ພອດ

--ssh_keyfile SSH_KEYFILE
ເສັ້ນທາງໄປຫາ keyfile ເພື່ອອະນຸຍາດໃຫ້ຜູ້ໃຊ້

--ຫມົດ​ເວ​ລາ ຫມົດ​ເວ​ລາ
ໝົດເວລາການເຊື່ອມຕໍ່

- ການປ່ຽນແປງ
ສະ​ແດງ​ສະ​ບັບ Circus ແລະ​ອອກ​.

ເບິ່ງ ນອກຈາກນີ້ຍັງ
circus (1) ວົງວຽນ (1) circusd-ສະຖິຕິ (1) circus-plugin (1) circus-top (1).

ເອກະສານສະບັບເຕັມແມ່ນມີຢູ່ http://circus.readthedocs.org

circus-plugin ຜູ້ຊາຍ Page
Synopsis
circus-plugin [ຕົວເລືອກ] [plugin]

ລາຍລະອຽດ
circus-plugin ອະນຸຍາດໃຫ້ເປີດ plugin ຈາກ Circus daemon ແລ່ນ.

Arguments
plugin ຊື່ທີ່ມີຄຸນວຸດທິຄົບຖ້ວນຂອງຫ້ອງຮຽນ plugin.

ທາງເລືອກໃນການ
--ຈຸດຈົບ ສິ້ນສຸດ
ຈຸດເຊື່ອມຕໍ່.

--pubsub PUBSUB
ເຕົ້າຮັບ pub/sub circusd ZeroMQ ເພື່ອເຊື່ອມຕໍ່ກັບ.

--config ກອງປະຊຸມ
ໄຟລ໌ການຕັ້ງຄ່າ plugin.

--ກວດ​ສອບ​ການ​ຊັກ​ຊ້າ​ CHECK_DELAY
ກວດສອບການຊັກຊ້າ.

--log-level LEVEL
ລະບຸລະດັບບັນທຶກ. LEVEL ສາມາດ ຂໍ້ມູນ, debug, ສໍາຄັນ, ການເຕືອນໄພ or ຄວາມຜິດພາດ.

--log-output ອອກຈາກລະບົບ
ສະຖານທີ່ບ່ອນທີ່ບັນທຶກຈະຖືກຂຽນ. ພຶດຕິກໍາເລີ່ມຕົ້ນແມ່ນການຂຽນໃສ່
stdout (ທ່ານສາມາດບັງຄັບມັນໄດ້ໂດຍການສົ່ງ '-' ໄປຫາທາງເລືອກນີ້). ເອົາຊື່ໄຟລ໌
ຖ້າບໍ່ດັ່ງນັ້ນ.

--ssh SSH
SSH Server ໃນຮູບແບບ user@host:ພອດ.

-ຊ, - ຊ່ວຍ
ສະແດງຂໍ້ຄວາມຊ່ວຍເຫຼືອ ແລະອອກ.

- ການປ່ຽນແປງ
ສະ​ແດງ​ສະ​ບັບ Circus ແລະ​ອອກ​.

ເບິ່ງ ຍັງ
circus (1) ວົງວຽນ (1) circusctl (1) circusd-ສະຖິຕິ (1) circus-top (1).

ເອກະສານສະບັບເຕັມແມ່ນມີຢູ່ http://circus.readthedocs.org

circus-top ຜູ້ຊາຍ Page
Synopsis
circus-top [ຕົວເລືອກ]

ລາຍລະອຽດ
circus-top ເປັນ top-like ຄໍາສັ່ງທີ່ຈະສະແດງ Circus daemon ແລະຂະບວນການທີ່ຄຸ້ມຄອງໂດຍ
ວົງດົນຕີ.

ທາງເລືອກໃນການ
--ຈຸດຈົບ ສິ້ນສຸດ
ຈຸດເຊື່ອມຕໍ່.

--ssh SSH
SSH Server ໃນຮູບແບບ user@host:ພອດ.

--ໝົດເວລາຂະບວນການ PROCESS_TIMEOUT
ຫຼັງຈາກການຊັກຊ້າຂອງການບໍ່ມີການເຄື່ອນໄຫວນີ້, ຂະບວນການຈະຖືກລຶບອອກ.

-ຊ, - ຊ່ວຍ
ສະແດງຂໍ້ຄວາມຊ່ວຍເຫຼືອ ແລະອອກ.

- ການປ່ຽນແປງ
ສະ​ແດງ​ສະ​ບັບ Circus ແລະ​ອອກ​.

ເບິ່ງ ຍັງ
circus (1) circusctl (1) ວົງວຽນ (1) circusd-ສະຖິຕິ (1) circus-plugin (1).

ເອກະສານສະບັບເຕັມແມ່ນມີຢູ່ http://circus.readthedocs.org

circusd-ສະຖິຕິ ຜູ້ຊາຍ Page
Synopsis
circusd-stats [ຕົວເລືອກ]

ລາຍລະອຽດ
circusd-stats ແລ່ນສະຖິຕິການລວບລວມສໍາລັບ Circus.

ທາງເລືອກໃນການ
--ຈຸດຈົບ ສິ້ນສຸດ
ຈຸດເຊື່ອມຕໍ່.

--pubsub PUBSUB
ເຕົ້າຮັບ pub/sub circusd ZeroMQ ເພື່ອເຊື່ອມຕໍ່ກັບ.

--ຈຸດສະຖິຕິ STATSPOINT
ZeroMQ pub/socket ເພື່ອສົ່ງຂໍ້ມູນໄປຫາ.

--log-level LEVEL
ລະບຸລະດັບບັນທຶກ. LEVEL ສາມາດ ຂໍ້ມູນ, debug, ສໍາຄັນ, ການເຕືອນໄພ or ຄວາມຜິດພາດ.

--log-output ອອກຈາກລະບົບ
ສະຖານທີ່ບ່ອນທີ່ບັນທຶກຈະຖືກຂຽນ. ພຶດຕິກໍາເລີ່ມຕົ້ນແມ່ນການຂຽນໃສ່
stdout (ທ່ານສາມາດບັງຄັບມັນໄດ້ໂດຍການສົ່ງ '-' ໄປຫາທາງເລືອກນີ້). ເອົາຊື່ໄຟລ໌
ຖ້າບໍ່ດັ່ງນັ້ນ.

--ssh SSH
SSH Server ໃນຮູບແບບ user@host:ພອດ.

-ຊ, - ຊ່ວຍ
ສະແດງຂໍ້ຄວາມຊ່ວຍເຫຼືອ ແລະອອກ.

- ການປ່ຽນແປງ
ສະ​ແດງ​ສະ​ບັບ Circus ແລະ​ອອກ​.

ເບິ່ງ ຍັງ
circus (1) ວົງວຽນ (1) circusctl (1) circus-plugin (1) circus-top (1).

ເອກະສານສະບັບເຕັມແມ່ນມີຢູ່ http://circus.readthedocs.org

Glossary: Circus ສະເພາະ ຂໍ້ກໍານົດ
arbiter
ໄດ້ arbiter ມີຄວາມຮັບຜິດຊອບໃນການຄຸ້ມຄອງຜູ້ເບິ່ງທັງຫມົດພາຍໃນ circus, ຮັບປະກັນ
ຂະບວນການທັງຫມົດດໍາເນີນການຢ່າງຖືກຕ້ອງ.

ຄວບຄຸມ
A ຄວບຄຸມ ປະ​ກອບ​ດ້ວຍ​ຊຸດ​ຂອງ​ການ​ປະ​ຕິ​ບັດ​ທີ່​ສາ​ມາດ​ໄດ້​ຮັບ​ການ​ປະ​ຕິ​ບັດ​ກ່ຽວ​ກັບ arbiter ໄດ້​.

ກະພິບ
ໄດ້ ກະພິບ ການກວດພົບ ສະໝັກໃຊ້ເຫດການ ແລະກວດພົບວ່າມີບາງຂະບວນການ
restarting ຢ່າງຕໍ່ເນື່ອງ.

pub/ຍ່ອຍ
Circus ມີ pubsub ທີ່​ໄດ້​ຮັບ​ກິດ​ຈະ​ກໍາ​ຈາກ watchers ແລະ​ສົ່ງ​ໃຫ້​ເຂົາ​ເຈົ້າ​
ສະມາຊິກທັງຫມົດ.

ໄລຍະໄກ ຄວບຄຸມ
ໄດ້ ໄລຍະໄກ ຄວບຄຸມ ອະ​ນຸ​ຍາດ​ໃຫ້​ທ່ານ​ເພື່ອ​ຕິດ​ຕໍ່​ພົວ​ພັນ​ກັບ​ການ​ຄວບ​ຄຸມ​ໂດຍ​ຜ່ານ ZMQ ກັບ​
ຄວບ​ຄຸມ Circus​.

ຜູ້ເບິ່ງ, watchers
A watcher ແມ່ນໂຄງການທີ່ທ່ານບອກ Circus ໃຫ້ດໍາເນີນການ. ຕົວຢ່າງ Circus ດຽວສາມາດແລ່ນໄດ້
ຫນຶ່ງ ຫຼື ຫຼາຍ watchers.

ພະນັກງານ, ກຳ ມະກອນ, ຂະບວນການ, ຂະບວນການ
A ຂະບວນການ ເປັນຕົວຢ່າງຂະບວນການ OS ທີ່ເປັນເອກະລາດຂອງໂຄງການຂອງທ່ານ. ຜູ້ເບິ່ງຄົນດຽວ
ສາມາດດໍາເນີນການຫນຶ່ງຫຼືຫຼາຍຂະບວນການ. ພວກເຮົາຍັງເອີ້ນພວກເຂົາວ່າຄົນງານ.

ລິຂະສິດ
Circus ໄດ້ລິເລີ່ມໂດຍ Tarek Ziade ແລະໄດ້ຮັບອະນຸຍາດພາຍໃຕ້ APLv2

Benoit Chesneau ເປັນຜູ້ປະກອບສ່ວນຕົ້ນໆ ແລະເຮັດຫຼາຍສິ່ງຫຼາຍຢ່າງເຊັ່ນ: ສ່ວນໃຫຍ່
circus.commands ເຮັດວຽກ.

ໃບອະນຸຍາດ
ສະຫງວນລິຂະສິດ 2012 - ມູນນິທິ Mozilla
ສະຫງວນລິຂະສິດ 2012 - Benoit Chesneau

ໄດ້ຮັບອະນຸຍາດພາຍໃຕ້ໃບອະນຸຍາດ Apache, ເວີຊັນ 2.0 (the "License");
ທ່ານອາດຈະບໍ່ໃຊ້ເອກະສານນີ້ຍົກເວັ້ນໃນການປະຕິບັດຕາມໃບອະນຸຍາດ.
ທ່ານອາດຈະໄດ້ຮັບ ສຳ ເນົາໃບອະນຸຍາດທີ່

http://www.apache.org/licenses/LICENSE-2.0

ເວັ້ນເສຍແຕ່ວ່າກົດ ໝາຍ ທີ່ຕ້ອງການຫຼືໄດ້ຕົກລົງເປັນລາຍລັກອັກສອນ, ຊອບແວ
ແຈກຢາຍພາຍໃຕ້ໃບອະນຸຍາດແມ່ນແຈກຢາຍຢູ່ໃນພື້ນຖານ "ຄື IS",
ໂດຍບໍ່ມີການຄ້ ຳ ປະກັນຫຼືຂໍ້ ກຳ ນົດໃດໆກໍ່ຕາມ, ບໍ່ວ່າຈະເປັນການສະແດງອອກ.
ເບິ່ງໃບອະນຸຍາດ ສຳ ລັບການອະນຸຍາດພາສາສະເພາະແລະ
ຂໍ້ ຈຳ ກັດພາຍໃຕ້ໃບອະນຸຍາດ.

ການປະກອບສ່ວນ
ເບິ່ງບັນຊີລາຍຊື່ເຕັມທີ່ https://github.com/circus-tent/circus/blob/master/CONTRIBUTORS.txt

ໃຊ້ circus ອອນໄລນ໌ໂດຍໃຊ້ບໍລິການ onworks.net