cyrk - Online w chmurze

PROGRAM:

IMIĘ

cyrk - Dokumentacja cyrkowa [image]

Circus to program w języku Python, którego można używać do monitorowania i kontrolowania procesów i gniazd.

Circus można obsługiwać za pomocą interfejsu wiersza poleceń, interfejsu internetowego lub programowo
poprzez API Pythona.

Aby go zainstalować i wypróbować jego funkcje, zapoznaj się z przykładami lub przeczytaj resztę tej strony
na szybkie wprowadzenie.

BIEGANIE A CYRK DEMON

Circus udostępnia wywołanie skryptu wiersza poleceń cyrk które można wykorzystać do zarządzania procesami
zorganizowane w jednym lub większej liczbie obserwatorów.

Narzędzie wiersza poleceń Circus można konfigurować za pomocą pliku konfiguracyjnego w stylu ini.

Oto bardzo minimalny przykład:

[obserwator:program]
cmd = python mójprogram.py
liczbaprocesów = 5

[obserwator:inny program]
cmd = inny_program
liczbaprocesów = 2

Następnie plik jest przekazywany do cyrk:

$ circusd przykład.ini

Oprócz procesów Circus może także wiązać gniazda. Ponieważ każdy proces zarządzany przez Circus jest
dziecko głównego demona Circus, co oznacza, że ​​każdy program kontrolowany przez Circus może to zrobić
użyj tych gniazd.

Uruchomienie gniazda jest tak proste, jak dodanie pliku gniazdo sekcja w pliku konfiguracyjnym:

[gniazdo:mojegniazdo]
host = host lokalny
port = 8080

Aby dowiedzieć się więcej o gniazdach, zobacz gniazda.

Aby zrozumieć, dlaczego jest to zabójcza funkcja, przeczytaj dlaczego circussockets.

KONTROLOWANIE CYRK

Circus udostępnia dwa narzędzia wiersza poleceń do zarządzania działającym demonem:

· okrężny, konsola zarządzania, za pomocą której można wykonywać takie czynności, jak dodawanie lub
usuwanie pracowników

· szczyt cyrku, przypominająca konsolę konsolę, za pomocą której możesz wyświetlić wykorzystanie pamięci i procesora
działający cyrk.

Aby dowiedzieć się więcej na ten temat, zobacz cli

Circus oferuje także internetowy panel kontrolny, który umożliwia połączenie się z działającym demonem Circus
monitorować i wchodzić z nim w interakcję.

Aby dowiedzieć się więcej o tej funkcji, zobacz circushttpd

Co już dziś ?
Jeśli jesteś programistą i chcesz wykorzystać Circus w swoim własnym projekcie, napisz wtyczki lub
haki, idź do fordevs.

Jeśli jesteś operatorem i chcesz zarządzać swoimi procesami za pomocą Circus, przejdź do forops.

Wpłaty na siódmą tradycję i Informacje zwrotne
Więcej o wkładzie: wkłady.

Przydatne linki:

· Istnieje lista mailingowa, w której można przesyłać wszelkie uwagi i pytania:
http://tech.groups.yahoo.com/group/circus-dev/

· Repozytorium i narzędzie do śledzenia problemów znajdują się na GitHubie: https://github.com/circus-tent/circus

· Dołącz do nas na IRC: Freenode, kanał #namiot cyrkowy

Dokumenty wskaźnik
Instalacja Cyrk
Circus to pakiet Pythona publikowany w PyPI - indeksie pakietów Pythona.

Najprostszym sposobem instalacji jest użycie pip, narzędzia do instalowania i zarządzania Pythonem
pakiety:

$ pip zainstaluj cyrk

Lub pobierz archiwum on PyPI, wyodrębnij i zainstaluj ręcznie za pomocą:

Instalacja $ Pythona setup.py

Jeśli chcesz wypróbować Circus, zobacz przykłady.

Jeśli używasz Debiana lub jakiejkolwiek dystrybucji opartej na Debianie, możesz także użyć ppa to
zainstaluj cyrk, jest na https://launchpad.net/~roman-imankulov/+archive/circus

zc.budowa
Zapewniamy zc.budowa konfiguracji, możesz z niego skorzystać, po prostu uruchamiając bootstrap
skrypt, a następnie wywołanie kompilacji:

$ Pythona bootstrap.py
$ bin/rozbudowa

Więcej on wymagania
Cyrk współpracuje z:

· Python 2.6, 2.7, 3.2 lub 3.3

·

zeromq >= 2.1.10

· Obsługiwana wersja Zeromq jest ostatecznie określona przez wersję
pyzmq jest instalowany przez pip podczas instalacji cyrkowej.

· Obecna wersja obsługuje wersje 2.x (ograniczone), 3.x i 4.x ZeroMQ.

· Note: Jeśli używasz PyPy zamiast CPython, koniecznie przeczytaj ich
dokumentacja instalacyjna, ponieważ obsługa wersji ZeroMQ nie jest taka sama w PyPy.

Kiedy zainstalujesz Circus, zostaną wyciągnięte najnowsze wersje zależności Pythona
dla Ciebie.

Można je także zainstalować ręcznie, korzystając z udostępnionego przez nas pliku pip-requirements.txt:

$ pip install -r pip-requirements.txt

Jeśli chcesz uruchomić konsolę internetową, musisz ją zainstalować sieć cyrkowa:

$ pip zainstaluj circus-web

Poradnik
Krok po kroku Tutorial
Połączenia przykłady katalog w repozytorium Circus zawiera wiele przykładów, które Cię dostaną
rozpoczęte, ale tutaj jest pełny samouczek, który daje przegląd funkcji.

Będziemy nadzorować aplikację WSGI.

Instalacja
Circus jest testowany na systemach Mac OS X i Linux z najnowszymi wersjami Pythona 2.6, 2.7, 3.2 i 3.3. Do
uruchomić pełny cyrk, będziesz także potrzebować libzmq, życie & virtualenv.

W systemach opartych na Debianie:

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

Utwórz wirtualne środowisko i zainstaluj cyrk, sieć cyrkowa i skarpetka w tym

$ virtualenv /tmp/cyrk
$cd /tmp/cyrk
$ bin/pip zainstaluj cyrk
$ bin/pip zainstaluj circus-web
$ bin/pip zainstaluj chaussette

Gdy już to zrobisz, w lokalnym katalogu bin znajdziesz mnóstwo poleceń.

Stosowanie
Skarpety zawiera domyślną aplikację Hello world, spróbuj ją uruchomić:

$ pojemnik/chaussette

Powinieneś móc odwiedzić http://localhost: 8080 i zobacz cześć świat.

Zatrzymaj Chaussette i dodaj plik circus.ini do katalogu zawierającego:

[cyrk]
statystyki = 1
httpd = 1

[obserwator:aplikacja internetowa]
cmd = bin/chaussette --fd $(circus.sockets.web)
liczbaprocesów = 3
use_sockets = Prawda

[gniazdo:sieć]
host = 127.0.0.1
port = 9999

Ten plik konfiguracyjny mówi Circusowi, aby powiązał gniazdo z portem 9999 i obsługuje 3 pracowników chaussettes
przeciwko temu. Aktywuje także panel internetowy Circus i moduł statystyk.

Zapisz go i uruchom za pomocą cyrk:

$ bin/circusd --daemon circus.ini

Teraz odwiedź http://127.0.0.1: 9999, powinieneś zobaczyć aplikację hello world. Różnica jest teraz
że gniazdem zarządza firma Circus i kilku pracowników sieciowych to akceptuje
powiązania przeciwko niemu.

UWAGA:
Równoważenie obciążenia jest obsługiwane przez system operacyjny, dzięki czemu uzyskujesz tę samą prędkość
jak każdy inny serwer WWW przed forkiem, taki jak Apache lub NGinx. Cyrk nie przeszkadza
dane, które przechodzą.

Możesz też odwiedzić http://localhost: 8080 / i korzystaj z panelu internetowego Circus.

Wzajemne oddziaływanie
Użyjmy powłoki circusctl podczas działania systemu:

$ bin/circusctl
circusctl 0.7.1
circusd-stats: aktywne
circushttpd: aktywny
aplikacja internetowa: aktywna
(około)

Trafisz do interaktywnej powłoki. Typ pomoc aby uzyskać wszystkie polecenia:

(circusctl) pomocy

Udokumentowane polecenia (wpisz help ):
====================================
dodaj pobierz listę liczba procesów zakończ rm start stop
decr globaloptions słuchaj numwatchers przeładuj ustawione statystyki
dstats incr listsockets opcje restartu status sygnału

Nieudokumentowane polecenia:
======================
Pomoc EOF

Spróbujmy podstawowych rzeczy. Wymieńmy procesy pracowników sieciowych i dodajmy nowy:

(circusctl) wyświetla listę aplikacji internetowych
13712,13713,13714
(circusctl) incr aplikacja internetowa
4
(circusctl) wyświetla listę aplikacji internetowych
13712,13713,13714,13973

Gratulacje, nawiązałeś kontakt ze swoim cyrkiem! Wyjdź z powłoki za pomocą Ctrl+D i teraz uruchom
cyrk na szczycie:

$ kosz/cyrk-top

Jest to bardzo podobne polecenie umożliwiające śledzenie w czasie rzeczywistym wykorzystania pamięci i procesora wszystkich procesów.

Naciśnij Ctrl+C, a teraz całkowicie wyjdź z Circus za pomocą circus-ctl:

$ bin/circusctl zakończ
ok

Następna kroki
Możesz po prostu podłączyć własną aplikację WSGI zamiast hello world Chaussette
wskazując aplikację wywoływalną.

Chaussette ma również wiele backendów, takich jak Gevent lub Meinheld.

Czytaj https://chaussette.readthedocs.org/ dla wszystkich opcji.

Czemu powinien I posługiwać się Cyrk zamiast of X ?
1. Cyrk upraszcza Twój sieć stos wygląda tak i konserwacjami

Cyrk wie, jak zarządzać procesami i gniazd, więc nie musisz delegować web
zarządzanie pracownikami na serwerze WGSI.

Zobacz dlaczegocircussockets

2. Cyrk zapewnia pub/sub i w. Powiadomienia przez ZeroMQ
Circus ma kanał pubowy/sub, który możesz subskrybować. Ten kanał odbiera wszystkie zdarzenia
dzieje się w Cyrku. Na przykład możesz zostać powiadomiony, gdy proces się zawiesza lub
zbuduj klienta, który uruchomi ostrzeżenie, gdy niektóre procesy zjadają cały procesor lub
BARAN.

Zdarzenia te są przesyłane poprzez kanał ZeroMQ, co odróżnia go od standardowego wejścia
Nadzorca strumienia używa:

· Circus wysyła zdarzenia w sposób „wystrzel i zapomnij”, więc nie ma potrzeby ręcznego zapętlania
przez cała kolekcja słuchaczy i utrzymać swoje stany.

· Abonentów można zlokalizować na zdalnym hoście.

Circus umożliwia także uzyskanie aktualizacji statusu poprzez jednorazowe ankiety dotyczące żądania/rep
kanał. Oznacza to, że możesz uzyskać informacje bez konieczności subskrypcji
strumień. Polecenie cli dostarczone przez Circus używa tego kanału.

Zobacz przykłady.

3. Cyrk is (Pyton) wywoływacz przyjazny
Chociaż Circus może być całkowicie sterowany przez plik konfiguracyjny i okrężny / cyrk
poleceń, łatwo jest ponownie wykorzystać całość lub część systemu do zbudowania własnego, niestandardowego rozwiązania
obserwator procesu w Pythonie.

Każda warstwa systemu jest izolowana, dzięki czemu można ponownie używać niezależnie:

· opakowanie procesu (Przetwarzanie)

· kierownik procesów (Obserwator)

· menedżer globalny, który zarządza kilkoma menedżerami procesów (Rozstrzygać)

· i tak dalej…

4. Cyrk waga
Jednym z przypadków użycia Circus jest zarządzanie tysiącami procesów bez dodawania
koszty ogólne – skupiamy się na tym.

Przyjście od Kierownik
Supervisor to bardzo popularne rozwiązanie w świecie Pythona i często jesteśmy pytani, jak Circus
porównuje z nim.

Jeśli pochodzisz z Kierownik, ta strona stara się przedstawić przegląd działania narzędzi
różnić się.

Różnice przegląd
Supervisor i Circus mają te same cele – obaj zarządzają procesami i zapewniają
skrypt wiersza poleceń — odpowiednio supervisord i cyrk — to odczytuje konfigurację
plik, rozwidla nowe procesy i utrzymuje je przy życiu.

Circus ma dodatkową funkcję: możliwość wiązania gniazd i zezwalania procesom, którymi zarządza
Użyj ich. Ten model „przed rozwidleniem” jest używany przez wiele serwerów internetowych, np Apache or
Jednorożec. Posiadanie tej opcji w Circus może uprościć stos aplikacji internetowych: wszystkie procesy i
gniazdami zarządza się za pomocą jednego narzędzia.

Obydwa projekty umożliwiają kontrolowanie działającego demona za pomocą innego skryptu. odpowiednio
przełożony i okrężny. Obydwa mają także wydarzenia i możliwość ich subskrybowania.
Główną różnicą jest podstawowa technologia: Supervisor używa XML-RPC do interakcji
z demonem, podczas gdy Circus używa ZeroMQ.

Zarówno Circus, jak i Supervisor mają interfejs sieciowy umożliwiający wyświetlanie tego, co się dzieje. Cyrk to coś więcej
zaawansowane, ponieważ możesz śledzić w czasie rzeczywistym, co się dzieje i wchodzić w interakcję z demonem.
Wykorzystuje gniazda sieciowe i jest rozwijany w oddzielnym projekcie (sieć cyrkowa.)

Istnieje wiele innych subtelnych różnic w projekcie rdzenia, które pewnego dnia możemy tu wymienić…
w międzyczasie możesz dowiedzieć się więcej o wnętrzach cyrku w projektowaniu.

systemu
Obydwa systemy używają pliku ini jako konfiguracji.

· Kierownik dokumentacja

· Cyrk dokumentacja

Oto mały przykład uruchomienia aplikacji za pomocą programu Supervisor. W tym przypadku
aplikacja zostanie uruchomiona i uruchomiona ponownie w przypadku awarii

[program:przykład]
polecenie=npm start
katalog=/home/www/mój-serwer/
użytkownik=dane-www
autostart = true
autorestart=true
redirect_stderr=Prawda

W Circus tę samą konfigurację wykonuje się poprzez:

[obserwator:przykład]
cmd=npm początek
Working_dir=/home/www/my-server/
użytkownik=dane-www
stderr_stream.class=StdoutStream

Zauważ, że przekierowanie stderr jest nieco inne w Circus. Narzędzie nie ma
a ogon funkcja podobna do Supervisora, ale pozwoli ci podłączyć dowolny fragment kodu, z którym będziesz musiał sobie poradzić
nadchodzący strumień. Możesz stworzyć własny hak do transmisji strumieniowej (jako klasa) i robić, co tylko chcesz
chcesz z nadchodzącym strumieniem. Circus udostępnia kilka wbudowanych klas strumieniowych, takich jak
Strumień stdout, Filestream, Obejrzany plikFileStreamlub TimedRotatingFileStream.

Cyrk dla ops
UWAGA:
Domyślnie Circus nie zabezpiecza swoich wiadomości podczas wysyłania informacji za pośrednictwem ZeroMQ.
Zanim uruchomisz Circus w środowisku produkcyjnym, koniecznie przeczytaj stronę Bezpieczeństwo.

Pierwszym krokiem do zarządzania demonem Circus jest napisanie jego pliku konfiguracyjnego. Widzieć
konfiguracja. Jeśli wdrażasz stos sieciowy, spójrz na gniazda.

Circus można wdrożyć przy użyciu języka Python 2.6, 2.7, 3.2 lub 3.3 — większość dostępnych wdrożeń to
zrobione w 2.7. Aby dowiedzieć się, jak wdrożyć Circus, sprawdź wdrażanie.

Aby zarządzać demonem Circus, powinieneś zapoznać się z listą poleceń, których możesz użyć
in okrężny. Zauważ, że podczas biegania możesz uzyskać tę samą pomoc online okrężny jak
muszla.

Zapewniamy również szczyt cyrku, zobacz cli i ładny pulpit nawigacyjny sieciowy. zobacz cyrkhttpd.

Na koniec, aby jak najlepiej wykorzystać możliwości Circus, sprawdź, jak korzystać z wtyczek i haków.
Zobacz wtyczki i hooki.

ops dokumentacja wskaźnik
systemu
Circus można skonfigurować za pomocą pliku konfiguracyjnego w stylu ini.

Przykład:

[cyrk]
check_delay = 5
punkt końcowy = tcp://127.0.0.1:5555
pubsub_endpoint = tcp://127.0.0.1:5556
zawierać = \*.więcej.config.ini
umaska ​​= 002

[obserwator:mójprogram]
cmd = pyton
args = -u mójprogram.py $(cyrk.wid) $(CIRCUS.ENV.VAR)
opóźnienie_rozgrzewki = 0
liczbaprocesów = 5

# hak
hooks.before_start = moje.hooks.control_redis

# wprowadzi test.log do strumienia co 300 ms
stdout_stream.class = Strumień Plików
stdout_stream.filename = test.log

# opcjonalnie obróć plik dziennika, gdy osiągnie 1 GB
# i zapisz 5 kopii obróconych plików
stdout_stream.max_bytes = 1073741824
stdout_stream.backup_count = 5

[env:mójprogram]
ŚCIEŻKA = $ŚCIEŻKA:/kosz
CIASTO = kłamstwo

[wtyczka:statsd]
use = circus.plugins.statsd.StatsdEmitter
host = host lokalny
port = 8125
szybkość_próbki = 1.0
nazwa_aplikacji = przykład

[gniazdo:sieć]
host = host lokalny
port = 8080

cyrk - pojedynczy Sekcja
Punkt końcowy
Gniazdo ZMQ służące do zarządzania Circusem poprzez okrężny. (domyślny:
TCP://127.0.0.1:5555)

właściciel_punktu końcowego
Jeśli jest ustawiona na systemową nazwę użytkownika, a punktem końcowym jest gniazdo IPC
ipc://var/run/circusd.sock, wówczas własność pliku gniazda zostanie zmieniona na
tego użytkownika podczas uruchamiania. Aby uzyskać więcej informacji, zobacz bezpieczeństwo. (domyślnie: Brak)

pubsub_punkt końcowy
Gniazdo ZMQ PUB/SUB odbierające publikacje wydarzeń. (domyślny:
TCP://127.0.0.1:5556)

papa_punkt końcowy
Jeśli używasz papa, możesz określić punkt końcowy, na przykład ipc://var/run/circusd.sock.
(domyślny: TCP://127.0.0.1:20202)

statystyki Jeśli ustawione na True, Circus uruchamia demona circusd-stats. (domyślnie: Fałsz)

stats_punkt końcowy
Gniazdo ZMQ PUB/SUB odbierające publikacje statystyk. (domyślny:
TCP://127.0.0.1:5557)

statsd_close_outputs
Jeśli True wysyła circusd-stats stdout/stderr do /dev/null. (domyślnie: Fałsz)

check_opóźnienie
Interwał odpytywania w sekundach dla gniazda ZMQ. (domyślnie: 5)

zawierać
Lista plików konfiguracyjnych do dołączenia. Możesz używać symboli wieloznacznych (*), aby uwzględnić szczególne
schematy dla Twoich plików. Ścieżki są bezwzględne lub względne w stosunku do pliku konfiguracyjnego.
(domyślnie: brak)

zawiera_katalog
Lista katalogów konfiguracyjnych. Wszystkie pliki pasują *.ini w każdym katalogu będzie
być uwzględnionym. Ścieżki są bezwzględne lub względne w stosunku do pliku konfiguracyjnego. (domyślny:
Nic)

strumień_zaplecza
Definiuje typ zaplecza używanego do przesyłania strumieniowego. Możliwe wartości to wątek
or dziać się. (domyślnie: wątek)

rozgrzewka_opóźnienie
Rozpoczyna się przerwa w sekundach pomiędzy dwoma obserwatorami. Musi to być int. (domyślnie: 0)

httpd Jeśli ustawione na True, Circus uruchamia demona circushttpd. (domyślnie: Fałsz)

httpd_host
Host jest uruchamiany przez demona circushttpd. (domyślnie: localhost)

httpd_port
Port obsługiwany jest przez demona circushttpd. (domyślnie: 8080)

httpd_close_outputs
Jeśli ma wartość True, wysyła circushttpd stdout/stderr do /dev/null. (domyślnie: Fałsz)

debug Jeśli ustawione na True, wszystkie demony Circus stout/stderr będą przekierowywane do circusd
stdout/stderr (domyślnie: fałsz)

debug_gc
Jeśli ustawione na True, circusd wyprowadza dodatkowe informacje z dziennika z modułu zbierającego elementy bezużyteczne.
Może to być przydatne w śledzeniu wycieków pamięci. (domyślnie: Fałsz)

plik pid
Plik, który musi być używany do przechowywania pid demona.

umaska Wartość dla umaska. Jeśli nie jest ustawiony, circusd nie będzie próbował modyfikować umaska.

poziom dziennika
Poziom logowania, który chcemy zobaczyć (domyślnie: INFO)

wyjście wylogowania
Plik wylogowania, w którym chcemy się zalogować (domyślnie: - aby zalogować się na standardowe wyjście). Możesz
zaloguj się do zdalnego sysloga, używając następującej składni:
syslog://host:port?facility gdzie host jest serwerem syslog, port jest opcjonalny
a obiekt to obiekt syslog, z którego można korzystać. Jeśli chcesz zalogować się do lokalnego syslog
możesz użyć syslog:///path/to/syslog/socket?facility zamiast.

konfiguracja loggera
Ścieżka do pliku INI, JSON lub YAML, w którym można skonfigurować standardowe rejestrowanie języka Python dla pliku
Arbiter. Wartość specjalna „default” wykorzystuje wbudowaną konfigurację rejestrowania
w oparciu o opcjonalne opcje poziomu logowania i wylogowania.

Przykład YAM systemu filet

Wersja: 1
dezaktywuj_istniejące_loggery: fałsz
formatyzatory:
prosty:
format: '%(asctime)s - %(nazwa)s - [%(nazwa poziomu)s] %(wiadomość)s"
obsługa:
plik dziennika:
klasa: logowanie.FileHandler
nazwa pliku: logoutput.txt
poziom: DEBUGOWANIE
formater: prosty
rejestratory:
cyrk:
poziom: DEBUGOWANIE
moduły obsługi: [plik dziennika]
propagować: nie
korzeń:
poziom: DEBUGOWANIE
moduły obsługi: [plik dziennika]

obserwator: NAZWA - as wiele działy as ty chcieć
IMIĘ Imię obserwatora. Nazwa ta jest używana w okrężny

cmd Program wykonywalny do uruchomienia.

args Argumenty wiersza poleceń do przekazania do programu. Możesz użyć formatu Pythona
składnia tutaj, aby zbudować parametry. Dostępne są zmienne środowiskowe, np
a także identyfikator pracownika i przekazane zmienne środowiskowe, jeśli takie istnieją,
z parametrem „env”. Widzieć Formatowanie dotychczasowy Polecenia i argumenty w dynamiczny
zmienne aby uzyskać więcej informacji na ten temat.

powłoka Jeśli True, procesy są uruchamiane w powłoce (domyślnie: Fałsz)

powłoka_args
Argumenty wiersza poleceń do przekazania do polecenia powłoki kiedy powłoka jest prawdziwy. Pracuje
tylko dla systemu *nix (domyślnie: Brak)

katalog_roboczy
Katalog roboczy procesów (domyślnie: Brak)

uid Identyfikator użytkownika lub nazwa, z którą polecenie powinno zostać uruchomione. (Obecny identyfikator użytkownika to
domyślna).

kołowacizna Identyfikator lub nazwa grupy, z którą powinno zostać uruchomione polecenie. (Obecny gid to
domyślna).

kopia_środ
Jeśli ustawione na true, lokalne zmienne środowiskowe zostaną skopiowane i przekazane do
robotnicy podczas ich rozmnażania. (Domyślnie: Fałsz)

ścieżka_kopii
Jeśli ustawione na true, sys.ścieżka jest przekazywany w środowisku podprocesu using ŚCIEŻKA PYTONA.
kopia_środ musi być prawdą. (Domyślnie: Fałsz)

rozgrzewka_opóźnienie
Opóźnienie (w sekundach) pomiędzy uruchomionymi procesami.

autostart
Jeśli ustawione na false, obserwator nie zostanie uruchomiony automatycznie, gdy zostanie uruchomiony arbiter
zaczyna. Obserwatora można uruchomić jawnie (przykład: circusctrl początek
mójprogram). (Domyślnie: prawda)

liczba procesów
Liczba procesów do uruchomienia dla tego obserwatora.

rlimit_LIMIT
Ustaw limit zasobów LIMIT dla obserwowanych procesów. Nazwa konfiguracji powinna być zgodna
stałe RLIMIT_* (wielkość liter nie jest uwzględniana) wymienione w pliku Python Zasób moduł
odniesienie. Na przykład linia konfiguracyjna „rlimit_nofile = 500” ustawia maksimum
liczba otwartych plików na 500. Aby ustawić wartość limitu na RLIM_INFINITY, nie ustawiaj
wartość, jak ta linia konfiguracyjna: 'rlimit_nofile = '.

stderr_stream.class
W pełni kwalifikowana nazwa klasy języka Python, która zostanie utworzona i otrzyma
dotychczasowy stderr strumień wszystkich procesów w nim zachodzących __dzwonić__() Metoda.

Circus udostępnia kilka klas strumieni, których można używać bez przedrostka:

· Filestream: zapisuje w pliku i może wykonać automatyczną rotację dziennika

· Obejrzany plikFileStream: zapisuje w pliku i opiera się na zewnętrznej rotacji dziennika

· TimedRotatingFileStream: zapisuje w pliku i może obracać w określonym czasie
Interwały.

· Strumień kolejki: zapisz w kolejce pamięci

· Strumień stdout: zapisuje na standardowe wyjście

· FancyStdoutStream: zapisuje kolorowe wyjście z przedrostkami czasu na standardowe wyjście

stderr_stream.*
Wszystkie opcje zaczynające się od stderr_stream. inne niż klasa zostanie przekazany
konstruktor podczas tworzenia instancji klasy zdefiniowanej w
stderr_stream.class.

stdout_stream.class
W pełni kwalifikowana nazwa klasy języka Python, która zostanie utworzona i otrzyma
dotychczasowy stdout strumień wszystkich procesów w nim zachodzących __dzwonić__() Metoda.

Circus udostępnia kilka klas strumieni, których można używać bez przedrostka:

· Filestream: zapisuje w pliku i może wykonać automatyczną rotację dziennika

· Obejrzany plikFileStream: zapisuje w pliku i opiera się na zewnętrznej rotacji dziennika

· TimedRotatingFileStream: zapisuje w pliku i może obracać w określonym czasie
Interwały.

· Strumień kolejki: zapisz w kolejce pamięci

· Strumień stdout: zapisuje na standardowe wyjście

· FancyStdoutStream: zapisuje kolorowe wyjście z przedrostkami czasu na standardowe wyjście

stdout_stream.*
Wszystkie opcje zaczynające się od stdout_stream. inne niż klasa zostanie przekazany
konstruktor podczas tworzenia instancji klasy zdefiniowanej w
stdout_stream.class.

zamknij_dziecko_stdout
Jeśli ustawione na True, strumień stdout każdego procesu zostanie wysłany do /dev/null
po widelcu. Domyślnie ustawiona jest wartość Fałsz.

zamknij_dziecko_stderr
Jeśli ustawione na True, strumień stderr każdego procesu zostanie wysłany do /dev/null
po widelcu. Domyślnie ustawiona jest wartość Fałsz.

wyślij_hup
Jeśli ma wartość True, przeładowanie procesu zostanie wykonane poprzez wysłanie sygnału SIGHUP. Domyślne
do Fałszywego.

sygnał_stopu
Sygnał do wysłania w przypadku zatrzymania procesu. Można określić jako liczbę lub a
nazwa sygnału. W nazwach sygnałów nie jest rozróżniana wielkość liter i mogą zawierać „SIG” lub nie. Więc
prawidłowe przykłady obejmują porzucić, INT, SIGTERM i 3. Domyślnie SIGTERM.

stop_dzieci
Podczas wysyłania sygnał_stopu, wyślij to również dzieciom. Domyślnie
Fałszywy.

maksymalna_ponowna próba
Liczba prób rozpoczęcia procesu, zanim porzucimy go i zatrzymamy
cały obserwator. Wartość domyślna to 5. Ustaw na -1, aby wyłączyć max_retry i ponawiać próby
w sposób nieokreślony.

pełen wdzięku_limit czasu
Liczba sekund oczekiwania, zanim proces zakończy się pomyślnie
zabicie tego.

Zatrzymując proces, najpierw wysyłamy mu plik a sygnał_stopu. Pracownik może to złapać
sygnał do wykonania czynności porządkowych przed wyjściem. Jeśli pracownik jest nieruchomy
aktywny po sekundach Graceful_timeout, wysyłamy do niego sygnał SIGKILL. Nie jest
możliwe jest przechwycenie sygnałów SIGKILL, aby pracownik się zatrzymał.

Domyślnie 30 s.

priorytet
Liczba całkowita określająca priorytet obserwatora. Kiedy Arbiter coś zrobi
operacje na wszystkich obserwatorach, posortuje je według tego pola, od większego
liczba do najmniejszej. Wartość domyślna to 0.

syngielton
Jeśli ustawione na True, ten obserwator będzie miał co najwyżej jeden proces. Domyślnie
Fałszywy.

użyj_gniazd
Jeśli ustawione na True, ten obserwator będzie mógł uzyskać dostęp do zdefiniowanych gniazd poprzez swoje
deskryptory plików. Jeśli Fałsz, wszystkie nadrzędne fds są zamykane, gdy proces potomny jest zamknięty
rozwidlony. Domyślnie ustawiona jest wartość Fałsz.

max_wiek
Jeśli ustawione, proces zostanie ponownie uruchomiony po upływie max_age sekund. Ten
jest przydatny, gdy procesy zajmują się pulą konektorów: ponowne uruchamianie procesów
poprawia równoważenie obciążenia. Domyślnie jest wyłączony.

maksymalna_zmienność_wieku
Jeśli ustawiono max_age, proces będzie trwał pomiędzy max_age i max_age +
losowe (0, max_age_variance) sekundy. Pozwala to uniknąć ponownego uruchamiania wszystkich procesów przez a
od razu obserwator. Domyślnie 30 sekund.

na żądanie
Jeśli ustawione na True, procesy zostaną uruchomione dopiero po pierwszym połączeniu
jedno ze skonfigurowanych gniazd (patrz poniżej). Jeśli konieczne będzie ponowne uruchomienie, tak się stanie
wyzwalane dopiero przy następnym zdarzeniu w gnieździe.

haczyki.*
Dostępne haczyki: przed startem, po_startu, przed_spawnem, po_spawnie,
przed_zatrzymaniem, po_stopie, przed_sygnałem, po_sygnale, rozszerzone_stats

Zdefiniuj funkcje wywołania zwrotnego, które łączą się z procesem uruchamiania/zamykania obserwatora.

Jeśli hak powróci Fałszywy i jeśli hak jest jednym z przed startem, przed_spawnem,
po_startu or po_spawnie, uruchomienie zostanie przerwane.

Jeśli hak jest przed_sygnałem i wraca Fałszywy, a następnie odpowiedni sygnał
nie zostaną wysłane (z wyjątkiem SIGKILL, który jest zawsze wysyłany)

Zauważ, że hak, który zawiedzie podczas procesu zatrzymywania, nie spowoduje jego przerwania.

Po definicji wywołania zwrotnego może następować flaga logiczna oddzielona przecinkiem.
Gdy flaga jest ustawiona na prawdziwy, każdy błąd występujący w haku zostanie zignorowany. Jeśli
Ustawić fałszywy (domyślnie), hak powróci Fałszywy.

Więcej o hakach.

virtualenv
Jeśli jest podany, wskazuje katalog główny katalogu Virtualenv. Obserwator to zrobi
zeskanuj lokalnie pakiety witryn i ładuje jego zawartość do wykonania
środowisko. Należy używać z kopia_środ ustaw na True. Wartość domyślna to Brak.

virtualenv_py_ver
Określa wersję wirtualnego środowiska Pythona (np. „3.3”). Przydaje się, jeśli
cyrk z inną wersją Pythona (np. „2.7”) Obserwator przeskanuje plik
miejscowy pakiety witryn określonej wersji Pythona i załaduj jej zawartość do
środowisko wykonawcze. Należy używać z virtualenv. Wartość domyślna to Brak.

respawn
Jeśli ustawione na False, procesy obsługiwane przez obserwatora nie zostaną odtworzone
automatycznie. Procesy można ręcznie odrodzić za pomocą polecenia początek dowództwo.
(domyślnie: Prawda)

użyj_taty
Ustaw na true, aby używać papa.

gniazdo:NAZWA - as wiele działy as ty chcieć
gospodarz Gospodarz gniazda. Domyślnie jest to „localhost”

Port Port. Domyślnie jest to 8080.

członków Twojej rodziny Rodzina gniazd. Może mieć wartość „AF_UNIX”, „AF_INET” lub „AF_INET6”. Domyślnie
„AF_INET”.

rodzaj Typ gniazda. Może mieć wartość „SOCK_STREAM”, „SOCK_DGRAM”, „SOCK_RAW”, „SOCK_RDM” lub
„SOCK_SEQPACKET”. Domyślnie jest to „SOCK_STREAM”.

Interfejs
Po podaniu nazwy interfejsu sieciowego, takiej jak „eth0”, wiąże z nią gniazdo
konkretnego urządzenia, tak aby tylko pakiety odebrane z tego konkretnego interfejsu
są przetwarzane przez gniazdo. Można to wykorzystać na przykład do ograniczenia urządzenia
do wiązania podczas wiązania na IN_ADDR_ANY (0.0.0.0) lub IN_ADDR_BROADCAST
(255.255.255.255). Należy pamiętać, że działa to szczególnie w przypadku niektórych typów gniazd
Gniazda AF_INET.

ścieżka Po podaniu ścieżki do pliku, który będzie używany jako plik gniazda unix. Jeśli
podana jest ścieżka, członków Twojej rodziny jest zmuszony do AF_UNIX i gospodarz i Port są ignorowane.

umaska Jeśli jest podany, ustawia maskę umask, która będzie używana do tworzenia gniazda AF_UNIX. Dla
przykład, umaska=000 wyprodukuje gniazdo za pozwoleniem 777.

obsługi produkcji rolnej, która zastąpiła
Podczas tworzenia gniazd Unixowych („AF_UNIX”) istniejący plik może wskazywać na problem
więc domyślnie jest to porażka. Sprecyzować Prawdziwy aby po prostu usunąć stary plik, jeśli tak jest
upewnij się, że gniazdem zarządza wyłącznie firma Circus.

so_reuseport
Jeśli ustawione na True i SO_REUSEPORT jest dostępne na platformie docelowej, cyrk będzie
utwórz i powiąż nowe gniazda SO_REUSEPORT dla każdego uruchamianego procesu roboczego, czyli a
użytkownik tego gniazda(ów).

użyj_taty
Ustaw na true, aby używać papa.

Po utworzeniu gniazda plik ${circus.sockets.NAME} w poleceniu można użyć ciągu znaków
(cmd or args) obserwatora. Circus zastąpi ją wartością FD. Obserwator też musi
mieć użyj_gniazd Ustawić Prawdziwy w przeciwnym razie gniazdo zostanie zamknięte i otrzymasz
błędy, gdy obserwator próbuje go użyć.

Przykład:

[obserwator:webworker]
cmd = chaussette --fd $(circus.sockets.webapp) chaussette.util.bench_app
use_sockets = Prawda

[gniazdo:aplikacja internetowa]
host = 127.0.0.1
port = 8888

wtyczka:NAZWA - as wiele działy as ty chcieć
posługiwać się W pełni kwalifikowana nazwa wskazująca klasę wtyczki.

wszystko więcej
Każdy inny klucz znaleziony w tej sekcji jest przekazywany do konstruktora wtyczki w pliku
config mapowanie.

Możesz używać wszystkich opcji obserwatora, ponieważ wtyczka jest uruchamiana jak obserwator.

Circus zawiera kilka fabrycznie dostarczonych wtyczek, ale można je także łatwo rozszerzyć
rozwijanie własnego.

env or środowisko[:OBSERWATORZY] - as wiele działy as ty chcieć
wszystko
Nazwa zmiennej środowiskowej, do której ma zostać przypisana wartość. środowisko w stylu bash
substytucje są obsługiwane. na przykład dołącz /kosz do PATH 'ŚCIEŻKA =
ŚCIEŻKA $:/kosz'

Sekcja odpowiedzialna za dostarczanie zmiennych środowiskowych do uruchamiania procesów.

Przykład:

[obserwator:pracownik1]
cmd = ping 127.0.0.1

[obserwator:pracownik2]
cmd = ping 127.0.0.1

[środ.]
CIASTO = kłamstwo

Zmienna CAKE zostanie rozesłany do wszystkich obserwatorów zdefiniowanych w pliku konfiguracyjnym.

WATCHERS może być rozdzieloną przecinkami listą sekcji obserwatorów, do których można zastosować to środowisko.
jeśli do obserwatora pasuje wiele sekcji env, zostaną one połączone w kolejności, w jakiej się pojawiają
plik konfiguracyjny. późniejsze wpisy będą miały pierwszeństwo.

Przykład:

[obserwator:pracownik1]
cmd = ping 127.0.0.1

[obserwator:pracownik2]
cmd = ping 127.0.0.1

[środ.:pracownik1,pracownik2]
ŚCIEŻKA = /kosz

[środ.:pracownik1]
ŚCIEŻKA = $ŚCIEŻKA

[środ.:pracownik2]
CIASTO = kłamstwo

pracownik1 zostanie uruchomiony z PATH = $PATH (rozszerzony ze środowiska, w którym został uruchomiony circusd)
pracownik2 zostanie uruchomiony z PATH = /kosz i CIASTO = kłamstwo

Możliwe jest również użycie symboli wieloznacznych.

Przykład:

[obserwator:pracownik1]
cmd = ping 127.0.0.1

[obserwator:pracownik2]
cmd = ping 127.0.0.1

[środ.:pracownik*]
ŚCIEŻKA = /kosz

Obie pracownik1 i pracownik2 zostanie uruchomiony z PATH = /kosz

Korzystanie z środowisko zmienne
Pisząc plik konfiguracyjny, możesz użyć zmiennych środowiskowych zdefiniowanych w pliku env
sekcja lub w os.środowisko sama.

Musisz tylko użyć cyrk.env. prefiks.

Przykład:

[obserwator:pracownik1]
cmd = $(cyrk.env.shell)

[obserwator:pracownik2]
baz = $(cyrk.env.użytkownik)
bar = $(cyrk.env.yeah)
sup = $(cyrk.env.oh)

[gniazdo:gniazdo1]
port = $(cyrk.env.port)

[wtyczka:wtyczka1]
use = jakaś.ścieżka
parametr1 = $(circus.env.plugin_param)

[środ.]
tak = buu

[środ.:pracownik2]
och = ok

Jeżeli zmienna jest zdefiniowana w kilku miejscach, pierwszeństwo ma najbardziej wyspecjalizowana wartość: a
zmienna zdefiniowana w Środowisko:XXX zastąpi zmienną zdefiniowaną w env, co zastąpi a
zmienna zdefiniowana w os.środowisko.

podstawienia środowiska mogą być użyte w dowolnej sekcji konfiguracji w dowolnej sekcji
zmienna.

Formatowanie dotychczasowy Polecenia i argumenty w dynamiczny zmienne
Jak zapewne zauważyłeś, możliwe jest przekazywanie niektórych informacji, które są obliczane
dynamicznie podczas uruchamiania procesów. Między innymi możesz uzyskać identyfikator pracownika
(WID) i wszystkie opcje przekazywane do Przetwarzanie. Dodatkowo jest to możliwe
uzyskaj dostęp do opcji przekazanych do Obserwator który zainicjował ten proces.

UWAGA:
Identyfikator pracownika różni się od identyfikatora procesu. To unikalna wartość, zaczynająca się od 1,
co jest wyjątkowe tylko dla obserwatora.

Na przykład, jeśli chcesz uzyskać dostęp do niektórych zmiennych zawartych w środowisku,
musiałbyś to zrobić przy takim ustawieniu:

cmd = "zaparz mi kawę -- cukier $(CIRCUS.ENV.SUGAR_AMOUNT)"

To działa z obydwoma cmd i args.

Ważny:

· Wszystkie zmienne są poprzedzone prefiksem cyrk.

· Przy zamianie wielkość liter nie jest uwzględniana.

Strumień konfiguracja
Prosta klasa strumieniowa, taka jak Strumień kolejki i Strumień stdout nie mają określonych atrybutów, ale
inna klasa strumieniowa może mieć kilka:

Filestream
filename
Ścieżka pliku, w którym zostanie zapisany dziennik.

format czasu
Format strftime, który będzie używany do każdorazowego poprzedzania znacznikiem czasu. Przez
domyślnie nie będą one poprzedzane.

tj.: %Y-%m-%d %H:%M:%S

max_bajty
Maksymalny rozmiar pliku dziennika przed uruchomieniem nowego pliku. Jeśli nie podano,
plik nie jest przenoszony.

liczba_kopii zapasowych
Liczba plików dziennika, które będą przechowywane. Domyślnie liczba_kopii zapasowych ma wartość null.

UWAGA:
Przejście następuje zawsze, gdy bieżący plik dziennika ma prawie maksymalną długość bajtów. Jeśli
liczba kopii zapasowych wynosi >= 1, system będzie sukcesywnie tworzył nowe pliki z tymi samymi
pathname jako plik podstawowy, ale z dołączonymi do niego rozszerzeniami „.1”, „.2” itp. Dla
na przykład przy liczbie kopii zapasowych równej 5 i podstawowej nazwie pliku „app.log” otrzymasz
„app.log”, „app.log.1”, „app.log.2”, ... aż do „app.log.5”. Zapisywany plik
to zawsze jest „app.log” — po zapełnieniu jest zamykany i zmieniana jest jego nazwa
„app.log.1”, a jeśli istnieją pliki „app.log.1”, „app.log.2” itp., to ich nazwy są zmieniane
odpowiednio do „app.log.2”, „app.log.3” itp.

Przykład:

[obserwator:mójprogram]
cmd = python -m mojaaplikacja.serwer

stdout_stream.class = Strumień Plików
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

Obejrzany plikFileStream
filename
Ścieżka pliku, w którym zostanie zapisany dziennik.

format czasu
Format strftime, który będzie używany do każdorazowego poprzedzania znacznikiem czasu. Przez
domyślnie nie będą one poprzedzane.

tj.: %Y-%m-%d %H:%M:%S

UWAGA:
WatchedFileStream korzysta z zewnętrznego narzędzia do rotacji dzienników, aby zapewnić, że pliki dziennika
nie bądź zbyt duży. Plik wyjściowy będzie monitorowany i jeśli kiedykolwiek zostanie usunięty lub
przesunięty przez zewnętrzne narzędzie do rotacji logów, wówczas uchwyt pliku wyjściowego zostanie przesunięty
automatycznie przeładowany.

Przykład:

[obserwator:mójprogram]
cmd = python -m mojaaplikacja.serwer

stdout_stream.class = Strumień obserwowanego pliku
stdout_stream.filename = test.log
stdout_stream.time_format = %Y-%m-%d %H:%M:%S

TimedRotatingFileStream
filename
Ścieżka pliku, w którym zostanie zapisany dziennik.

liczba_kopii zapasowych
Liczba plików dziennika, które będą przechowywane. Domyślnie liczba_kopii zapasowych ma wartość null.

format czasu
Format strftime, który będzie używany do każdorazowego poprzedzania znacznikiem czasu. Przez
domyślnie nie będą one poprzedzane.

tj.: %Y-%m-%d %H:%M:%S

obróć_kiedy
Rodzaj interwału. Lista możliwych wartości znajduje się poniżej. Zauważ, że są
wielkość liter nie jest uwzględniana.

┌───────────┬───────────────────────┐
│Wartość │ Typ interwału │
├───────────┼───────────────────────┤
│ „S” │ Sekundy │
├───────────┼───────────────────────┤
│'M' │ Minuty │
├───────────┼───────────────────────┤
│'H' │ Godziny │
├───────────┼───────────────────────┤
│'D' │ Dni │
├───────────┼───────────────────────┤
│'W0'-'W6' │ Dzień powszedni (0=poniedziałek) │
├───────────┼───────────────────────┤
│'północ' │ Przejdź o północy │
└───────────┴───────────────────────┘

obrót_interwał
Interwał rolowania.

UWAGA:
TimedRotatingFileStream obraca pliki dziennika w określonych odstępach czasu. Interwał rolowania
jest określana przez kombinację opcji obracaj_kiedy i obracaj_interwał.

Przykład:

[obserwator:mójprogram]
cmd = python -m mojaaplikacja.serwer

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

FancyStdoutStream
kolor

Połączenia Nazwa of an Ascii kolor:

· czerwony

· zielony

· żółty

· niebieski

· purpurowy

· cyjan

· biały

format czasu
Format strftime, w którym będzie poprzedzana każda linia.

Domyślnie: %Y-%m-%d %H:%M:%S

Przykład:

[obserwator:mójprogram]
cmd = python -m mojaaplikacja.serwer
stdout_stream.class = Fantazyjny strumień
stdout_stream.color = zielony
stdout_stream.time_format = %Y/%m/%d | %H:%M:%S

Polecenia
W epicentrum cyrku żyją systemy dowodzenia. okrężny to tylko klient Zeromq,
a jeśli zajdzie taka potrzeba, możesz programowo sterować systemem Circus, pisząc własne zmq
klient.

Wszystkie wiadomości są mapowaniami JSON.

Dla każdego poniższego polecenia podajemy przykład użycia z circusctl, ale także wejściem /
wysyłaj wiadomości zmq.

cyrk-ctl Polecenia
· Dodaj: polecenia/dodaj

· dekret: polecenia/dekr

· statystyki: polecenia/dstats

· otrzymać: polecenia/pobierz

· opcje globalne: polecenia/opcje globalne

· przyrost: polecenia/przyrost

· pyton: polecenia/ipython

· podstęp: polecenia/lista

· słuchać: komendy/słuchaj

· listy gniazd: polecenia/listsockets

· liczba procesów: polecenia/liczbaprocesów

· numwatcherzy: polecenia/numwatchers

· Opcje: polecenia/opcje

· porzucić: polecenia/zakończ

· przeładować: polecenia/przeładuj

· przeładuj konfigurację: polecenia/przeładujkonfigurację

· restart: polecenia/uruchom ponownie

· rm: polecenia/rm

· zestaw: polecenia/zestaw

· sygnał: polecenia/sygnały

· początek: polecenia/start

· statystyki: polecenia/statystyki

· status: polecenia/stan

· Zatrzymaj się: polecenia/zatrzymaj

Dodaj a obserwator
To polecenie dynamicznie dodaje obserwatora do arbitra.

ZMQ Wiadomość
{
"polecenie": "dodaj",
"nieruchomości": {
"cmd": "/ścieżka/do/wiersza poleceń --opcja"
"name": "nazwa obserwatora"
"argumenty": [],
„opcje”: {},
„start”: fałsz
}
}

Wiadomość zawiera 2 właściwości:

· cmd: Pełna linia poleceń do wykonania w procesie

· args: tablica, argumenty przekazywane do polecenia (opcjonalnie)

· imię: imię i nazwisko obserwatora

· opcje: opcje obserwatora

· start: uruchom obserwatora po utworzeniu

Odpowiedź zwraca status „ok”.

Command linia
$ circusctl dodaj [--start]

Opcje
· : nazwa obserwatora, który ma zostać utworzony

· : pełna linia poleceń do wykonania w procesie

· --start: natychmiastowe uruchomienie obserwatora

Zmniejszenie dotychczasowy numer of procesów in a obserwator
Ten komentarz zmniejsza liczbę procesów w obserwatorze o , 1 to
domyślna.

ZMQ Wiadomość
{
"polecenie": "dekr",
„właściwości”: {
"nazwa": " "
„NB”:
„czekanie”: fałsz
}
}

Odpowiedź zwraca liczbę procesów we właściwości „numprocesses”:

{ "status": "ok", "liczbaprocesów": , "czas", "znacznik czasu" }

Command linia
$ circusctl dec [ ] [--Czekanie]

Opcje
· : imię obserwatora

· : liczba procesów do usunięcia.

Get cyrk statystyki
W każdej chwili możesz uzyskać statystyki dotyczące circusd za pomocą polecenia dstat.

ZMQ Wiadomość
Aby uzyskać statystyki cyrkowe, po prostu uruchom:

{
"polecenie": "dstats"
}

Odpowiedź zwraca mapowanie właściwości „infos” zawierające pewne informacje o procesie:

{
"informacje": {
"dzieci": [],
"cmdline": "python",
„procesor”: 0.1,
"ctime": "0:00.41",
„mem”: 0.1,
"mem_info1": "3M",
"mem_info2": "2G",
„fajnie”: 0,
"pid": 47864,
„nazwa użytkownika”: „root”
},
„stan”: „ok”,
„czas”: 1332265655.897085
}

Command Linia
$ circusctl dstats

Get dotychczasowy wartość of specyficzny obserwator Opcje
Tego polecenia można użyć do zapytania o bieżącą wartość jednej lub większej liczby opcji obserwatora.

ZMQ Wiadomość
{
„polecenie”: „pobierz”,
"nieruchomości": {
„klucze”: [„klucz1, „klucz2”]
"name": "nazwa obserwatora"
}
}

Komunikat żądania zawiera dwie właściwości:

· klucze: lista, klawisze opcji, dla których chcesz uzyskać wartości

· imię: imię i nazwisko obserwatora

Obiekt odpowiedzi ma właściwość Opcje który jest słownikiem nazw opcji i
wartości.

na przykład:

{
„stan”: „ok”,
„opcje”: {
„graceful_timeout”: 300,
„send_hup”: Prawda,
},
czas": 1332202594.754644
}

Command linia
$ circusctl get

Get dotychczasowy arbiter Opcje
To polecenie zwraca opcje arbitra

ZMQ Wiadomość
{
"polecenie": "globaopcje",
"nieruchomości": {
„klucz1”: „wartość1”,
..
}
}

Wiadomość zawiera 2 właściwości:

· klucze: lista, klawisze opcji, dla których chcesz uzyskać wartości

Odpowiedź zwraca obiekt z właściwością „opcje” zawierającą listę klucz/wartość
wrócił cyrkiem.

na przykład:

{
„stan”: „ok”,
„opcje”: {
„check_delay”: 1,
...
},
czas": 1332202594.754644
}

Command linia
$ circusctl opcje globalne

Opcje
Klawisze opcji to:

· punkt końcowy: punkt końcowy kontrolera ZMQ

· pubsub_endpoint: punkt końcowy pubsub

· check_delay: opóźnienie pomiędzy dwoma punktami kontrolnymi

· multicast_endpoint: punkt końcowy multicast dla automatycznego wykrywania klastra Circusd

Przyrost dotychczasowy numer of procesów in a obserwator
Ten komentarz zwiększa liczbę procesów w obserwatorze o , 1 to
domyślnym

ZMQ Wiadomość
{
"polecenie": "zwiększ",
"nieruchomości": {
"nazwa": " ",
„NB”: ,
„czekanie”: fałsz
}
}

Odpowiedź zwraca liczbę procesów we właściwości „numprocesses”:

{ "status": "ok", "liczbaprocesów": , "czas", "znacznik czasu" }

Command linia
$ circusctl przyrost [ ] [--Czekanie]

Opcje
· : imię obserwatora.

· : liczba procesów do dodania.

Stwórz powłoka najnowszych cyrk wygląda tak
To polecenie jest przydatne tylko wtedy, gdy masz zainstalowany pakiet ipython.

Command Linia
$ circusctl ipython

Get podstęp of obserwatorzy or procesów in a obserwator
ZMQ Wiadomość
Aby uzyskać listę wszystkich obserwatorów:

{
"polecenie": "lista",
}

Aby uzyskać listę aktywnych procesów w obserwatorze:

{
"polecenie": "lista",
"nieruchomości": {
"name": "nazwisko obserwatora",
}
}

Odpowiedź zwraca żądaną listę. zwrócone mapowanie może być „obserwatorami” lub
„pids” w zależności od żądania.

Command linia
$ circusctl lista [ ]

Zapisz się! do a obserwator wydarzenie
ZMQ
W każdej chwili możesz zapisać się na wydarzenie cyrkowe. Circus zapewnia kanał PUB/SUB, na którym
każdy klient może subskrybować. URI punktu końcowego subskrybenta jest ustawiony w pliku circus.ini
plik konfiguracyjny.

Wydarzenia są tematami pubsub:

· obserwator. .zbierać: kiedy proces jest zbierany

· obserwator. .ikra: kiedy proces jest uruchamiany

· obserwator. .zabić: kiedy proces zostaje zabity

· obserwator. zaktualizowano: po aktualizacji konfiguracji obserwatora

· obserwator. .zatrzymywać się: kiedy obserwator zostaje zatrzymany

· obserwator. .początek: po uruchomieniu obserwatora

Wszystkie komunikaty o zdarzeniach znajdują się w strukturze json.

Command linia
Klient został zaktualizowany, aby zapewnić prosty sposób słuchania wydarzeń:

około słuchaj [ , ...]

Przykład of wynik:
$ circusctl słuchaj tcp://127.0.0.1:5556
watcher.refuge.spawn: {u'process_id': 6, u'process_pid': 72976,
twój czas': 1331681080.985104}
watcher.refuge.spawn: {u'process_id': 7, u'process_pid': 72995,
twój czas': 1331681086.208542}
watcher.refuge.spawn: {u'process_id': 8, u'process_pid': 73014,
twój czas': 1331681091.427005}

Get dotychczasowy podstęp of Gniazda
ZMQ Wiadomość
Aby uzyskać listę gniazd:

{
"polecenie": "listsockets",
}

Odpowiedź zwraca listę mapowań json z kluczami fd, name, host i port.

Command linia
$ circusctl listsockets

Get dotychczasowy numer of procesów
Uzyskaj liczbę procesów w obserwatorze lub w arbitrze

ZMQ Wiadomość
{
"polecenie": "liczbaprocesów",
„właściwości”: {
"nazwa": " "
}

}

Odpowiedź zwraca liczbę procesów we właściwości „numprocesses”:

{ "status": "ok", "liczbaprocesów": , "czas", "znacznik czasu" }

Jeśli nazwa właściwości nie zostanie określona, ​​zwracana jest suma wszystkich zarządzanych procesów.

Command linia
$ circusctl liczba procesów [ ]

Opcje
· : imię obserwatora

Get dotychczasowy numer of obserwatorzy
Uzyskaj liczbę obserwatorów w arbitrze

ZMQ Wiadomość
{
"polecenie": "numwatchers",
}

Odpowiedź zwraca liczbę obserwatorów we właściwości „numwatchers”:

{ "status": "ok", "numwatchers": , "czas", "znacznik czasu" }

Command linia
$ circusctl liczba obserwatorów

Get dotychczasowy wartość of cała kolekcja Opcje dla a obserwator
To polecenie zwraca wszystkie wartości opcji dla danego obserwatora.

ZMQ Wiadomość
{
"polecenie": "opcje",
"nieruchomości": {
"name": "nazwisko obserwatora",
}
}

Wiadomość zawiera 1 właściwość:

· imię: imię i nazwisko obserwatora

Obiekt odpowiedzi ma właściwość Opcje który jest słownikiem nazw opcji i
wartości.

na przykład:

{
„stan”: „ok”,
„opcje”: {
„graceful_timeout”: 300,
„send_hup”: Prawda,
...
},
czas": 1332202594.754644
}

Command linia
$ circusctl opcje

Opcje
· : imię obserwatora

Klawisze opcji to:

· numprocesses: liczba całkowita, liczba procesów

· Warmup_delay: liczba całkowita lub liczba, opóźnienie oczekiwania pomiędzy pojawieniem się procesu w sekundach

· Working_dir: string, katalog, w którym proces będzie wykonywany

· uid: ciąg znaków lub liczba całkowita, identyfikator użytkownika używany do uruchomienia procesu

· gid: ciąg znaków lub liczba całkowita, identyfikator grupy używany do uruchomienia procesu

· send_hup: wartość logiczna, jeśli TRU, przy przeładowaniu zostanie użyty sygnał HUP

· Shell: boolean, uruchomi polecenie w środowisku Shell, jeśli ma wartość true

· cmd: string, Linia poleceń używana do uruchomienia procesu

· env: obiekt, zdefiniuj środowisko, w którym proces zostanie uruchomiony

· retry_in: liczba całkowita lub liczba, czas w sekundach oczekiwania przed ponowną próbą uruchomienia
proces, jeśli osiągnięto maksymalną liczbę prób.

· max_retry: integer, Maksymalna liczba powtórzeń pętli

· Graceful_timeout: liczba całkowita lub liczba, czas oczekiwania zanim definitywnie zabijemy proces.

· priorytet: używany do sortowania obserwatorów w arbitrze

· singleton: jeśli True, obserwator singletonu.

· max_age: czas życia procesu przed ponownym uruchomieniem

· max_age_variance: zmienny dodatkowy czas życia, pozwala uniknąć stada pędzącego.

porzucić dotychczasowy arbiter natychmiast
Kiedy arbiter otrzyma tę komendę, arbiter wychodzi.

ZMQ Wiadomość
{
"polecenie": "wyjdź",
„czekanie”: fałsz
}

Odpowiedź zwraca status „ok”.

If czekanie ma wartość Fałsz (domyślnie), połączenie zostanie wznowione natychmiast po wywołaniu sygnał_stopu
na każdym procesie.

If czekanie ma wartość True, wywołanie powróci dopiero po całkowitym zakończeniu procesu zatrzymywania.
Ze względu na opcję Graceful_timeout może to zająć trochę czasu.

Command linia
$ circusctl zakończ [--czekanie]

Przeładować dotychczasowy arbiter or a obserwator
To polecenie ponownie ładuje cały proces w obserwatorze lub we wszystkich obserwatorach. Stanie się to w jednym
z 3 sposobów:

· Jeśli Graceful ma wartość false, następuje proste ponowne uruchomienie.

· Gdyby wyślij_hup jest prawdziwe dla obserwatora, do każdego procesu wysyłany jest sygnał HUP.

·

Inaczej:

· Jeśli sekwencja jest fałszywa, arbiter spróbuje się odrodzić liczba procesów nowa
procesy. Jeśli nowe procesy zostaną pomyślnie uruchomione, rezultat jest taki
wszystkie stare procesy są zatrzymywane, ponieważ domyślnie są to najstarsze procesy
zatrzymany, gdy rzeczywista liczba procesów obserwatora jest większa niż
liczba procesów.

· Jeśli sekwencja ma wartość true, arbiter ponownie uruchomi każdy proces po kolei
sposób (z rozgrzewka_opóźnienie przerwa pomiędzy każdym krokiem)

ZMQ Wiadomość
{
"polecenie": "przeładuj",
"nieruchomości": {
"nazwa": ' ",
„wdzięczny”: prawda,
„sekwencyjny”: fałszywy,
„czekanie”: fałsz
}
}

Odpowiedź zwraca status „ok”. Jeśli właściwość Graceful jest ustawiona na True, procesy
wyjdzie z wdziękiem.

Jeśli nazwa właściwości jest obecna, przeładowanie zostanie zastosowane do obserwatora.

Command linia
$ circusctl przeładuj [ ] [--zakończ] [--czekam]
[--sekwencyjny]

Opcje
· : imię obserwatora

· --zakończ; natychmiast opuść węzeł

Przeładować dotychczasowy konfiguracja filet
To polecenie ponownie ładuje plik konfiguracyjny, więc zmiany w pliku konfiguracyjnym zostaną dokonane
odzwierciedlenie w konfiguracji cyrku.

ZMQ Wiadomość
{
"polecenie": "przeładujkonfigurację",
„czekanie”: fałsz
}

Odpowiedź zwraca status „ok”. Jeśli właściwość Graceful jest ustawiona na True, procesy
wyjdzie z wdziękiem.

Command linia
$ circusctl reloadconfig [--czekanie]

restart dotychczasowy arbiter or a obserwator
To polecenie zrestartuje cały proces w obserwatorze lub we wszystkich obserwatorach. Ta funkcja jest po prostu
zatrzymaj obserwatora, a następnie uruchom go ponownie.

ZMQ Wiadomość
{
"polecenie": "uruchom ponownie",
"nieruchomości": {
"nazwa": " ",
„czekanie”: fałsz,
"match": "[proste|glob|regex]"
}
}

Odpowiedź zwraca status „ok”.

Jeśli nazwa właściwości jest obecna, przeładowanie zostanie zastosowane do obserwatora.

If czekanie ma wartość Fałsz (domyślnie), połączenie zostanie wznowione natychmiast po wywołaniu sygnał_stopu
na każdym procesie.

If czekanie ma wartość True, wywołanie zostanie powrócone dopiero po zakończeniu procesu ponownego uruchamiania
zakończył się. Ze względu na opcję Graceful_timeout może to zająć trochę czasu.

Połączenia mecz parametr może mieć wartość prosty do porównania ciągów, kula dla symbolu wieloznacznego
dopasowanie (domyślne) lub regex do dopasowania wyrażeń regularnych.

Command linia
$ circusctl restart [nazwa] [--waiting] [--match=simple|glob|regex]

Opcje
· : imię i nazwisko lub wzór obserwatora(ów)

· : metoda dopasowania obserwatora

Usunąć a obserwator
To polecenie usuwa dynamicznie obserwatora z arbitra. Obserwatorzy są z wdziękiem
domyślnie zatrzymany.

ZMQ Wiadomość
{
"polecenie": "rm",
"nieruchomości": {
"nazwa": " ",
„nostop”: fałsz,
„czekanie”: fałsz
}
}

Odpowiedź zwraca status „ok”.

If Bez przerwy ma wartość True (domyślnie: Fałsz), procesy obserwatora nie zostaną zatrzymane -
zamiast tego cyrk zostanie po prostu zapomniany przez obserwatora i procesy obserwatora pozostaną
odpowiedzialni za zatrzymanie się. Jeśli Bez przerwy nie jest określony lub ma wartość Fałsz, wówczas
procesy obserwatora zostaną bezpiecznie zatrzymane.

If czekanie ma wartość Fałsz (domyślnie), połączenie zostanie powrócone natychmiast po rozpoczęciu usuwania
i zatrzymaj odpowiedniego obserwatora.

If czekanie ma wartość True, wywołanie zostanie zwrócone tylko wtedy, gdy proces usuwania i zatrzymywania zostanie zakończony
całkowicie się skończył. Ze względu na opcję Graceful_timeout może to zająć trochę czasu.

Command linia
$ circusctl rm [--czekam] [--nostop]

Opcje
· : nazwa obserwatora do usunięcia

· nostop: nie zatrzymuj procesów obserwatora, po prostu usuń obserwatora

Zestaw a obserwator opcja
ZMQ Wiadomość
{
"polecenie": "ustaw",
"nieruchomości": {
"name": "nazwisko obserwatora",
„opcje”: {
„klucz1”: „wartość1”,
..
}
„czekanie”: fałsz
}
}

Odpowiedź zwraca status „ok”. Zobacz polecenie Opcje, aby uzyskać listę kluczy do ustawienia.

Command linia
$ circusctl zestaw --Czekanie

Wyślij a sygnał
To polecenie pozwala wysłać sygnał do wszystkich procesów w obserwatorze, konkretnego procesu
w obserwatorze lub jego dzieciach.

ZMQ Wiadomość
Aby wysłać sygnał do wszystkich procesów dla obserwatora:

{
"polecenie": "sygnał",
"nieruchomość": {
"nazwa": ,
"sygnał":
}

Aby wysłać sygnał do procesu:

{
"polecenie": "sygnał",
"nieruchomość": {
"nazwa": ,
„pid”: ,
"sygnał":
}

Zamiast tego można użyć opcjonalnej właściwości „dzieci” do wysłania sygnału do wszystkich dzieci
niż sam proces:

{
"polecenie": "sygnał",
"nieruchomość": {
"nazwa": ,
„pid”: ,
"sygnał": ,
„dzieci”: Prawda
}

Aby wysłać sygnał do procesu potomnego:

{
"polecenie": "sygnał",
"nieruchomość": {
"nazwa": ,
„pid”: ,
"sygnał": ,
„pid_dziecka”: ,
}

Możliwe jest również wysłanie sygnału do wszystkich dzieci obserwatora:

{
"polecenie": "sygnał",
"nieruchomość": {
"nazwa": ,
"sygnał": ,
„dzieci”: Prawda
}

Na koniec możesz wysłać sygnał do procesu i jego dzieci, z rekurencyjne opcja:

{
"polecenie": "sygnał",
"nieruchomość": {
"nazwa": ,
"sygnał": ,
„rekursywny”: Prawda
}

Command linia
$ sygnał cyrkulacyjny [ ] [--dzieci]
[--rekursywny]

Opcje:
· : imię obserwatora

· : liczba całkowita, identyfikator procesu.

· : numer sygnału (lub nazwa) do wysłania.

· : pid dziecka, jeśli istnieje

· : boolean, wyślij sygnał do wszystkich dzieci

· : boolean, wyślij sygnał do procesu i jego dzieci

Start dotychczasowy arbiter or a obserwator
To polecenie uruchamia wszystkie procesy w obserwatorze lub we wszystkich obserwatorach.

ZMQ Wiadomość
{
„polecenie”: „rozpocznij”,
"nieruchomości": {
"nazwa": ' ",
„czekanie”: fałsz,
"match": "[proste|glob|regex]"
}
}

Odpowiedź zwraca status „ok”.

Jeśli nazwa właściwości jest obecna, obserwator zostanie uruchomiony.

If czekanie ma wartość Fałsz (domyślnie), połączenie zostanie wznowione natychmiast po wywołaniu początek on
każdy proces.

If czekanie ma wartość True, wywołanie powróci dopiero po całkowitym zakończeniu procesu uruchamiania.
Ze względu na opcję Graceful_timeout może to zająć trochę czasu.

Połączenia mecz parametr może mieć wartość prosty do porównania ciągów, kula dla symbolu wieloznacznego
dopasowanie (domyślne) lub regex do dopasowania wyrażeń regularnych.

Command linia
$ circusctl restart [nazwa] [--waiting] [--match=simple|glob|regex]

Opcje
· : imię i nazwisko lub wzór obserwatora(ów)

· : metoda dopasowania obserwatora

Get wygląda tak Informacje
Za pomocą polecenia stat możesz w dowolnym momencie uzyskać statystyki dotyczące swoich procesów.

ZMQ Wiadomość
Aby uzyskać statystyki dla wszystkich obserwujących:

{
"polecenie": "statystyki"
}

Aby uzyskać statystyki dla obserwatora:

{
"polecenie": "statystyki",
"nieruchomości": {
"nazwa":
}
}

Aby uzyskać statystyki dla procesu:

{
"polecenie": "statystyki",
"nieruchomości": {
"nazwa": ,
"proces":
}
}

Statystyki można rozszerzyć za pomocą haka Extended_stats, ale konieczne jest rozszerzenie statystyk rozszerzonych
wymagany:

{
"polecenie": "statystyki",
"nieruchomości": {
"nazwa": ,
"proces": ,
„rozszerzony”: Prawda
}
}

Odpowiedź zwraca obiekt na proces z właściwością „info” zawierającą jakiś proces
informacje:

{
"informacje": {
"dzieci": [],
"cmdline": "python",
„procesor”: 0.1,
"ctime": "0:00.41",
„mem”: 0.1,
"mem_info1": "3M",
"mem_info2": "2G",
„fajnie”: 0,
"pid": 47864,
„nazwa użytkownika”: „root”
},
„proces”: 5,
„stan”: „ok”,
„czas”: 1332265655.897085
}

Command Linia
$ circusctl statystyki [--rozszerzone] [ ] [ ]

Get dotychczasowy status of a obserwator or cała kolekcja obserwatorzy
Komenda ta uruchamia uzyskanie statusu obserwatora lub wszystkich obserwatorów.

ZMQ Wiadomość
{
"polecenie": "stan",
"nieruchomości": {
"nazwa": ' ",
}
}

W odpowiedzi zwrócony zostanie status „aktywny” lub „zatrzymany” lub status / obserwatorzy.

Command linia
$ status cyrku [ ]

Opcje
· : imię obserwatora

Przykład
Manekin statusu $ circusctl
aktywny
$ circusctl status
manekin: aktywny
manekin2: aktywny
schronienie: aktywne

Stop obserwatorzy
Polecenie to zatrzymuje danego obserwatora lub wszystkich obserwatorów.

ZMQ Wiadomość
{
„polecenie”: „zatrzymaj”,
"nieruchomości": {
"nazwa": " ",
„czekanie”: fałsz,
"match": "[proste|glob|regex]"
}
}

Odpowiedź zwraca status „ok”.

Jeśli Nazwa właściwość jest obecna, wówczas zatrzymanie zostanie zastosowane do obserwatora
odpowiadające tej nazwie. W przeciwnym razie wszyscy obserwatorzy zostaną zatrzymani.

If czekanie ma wartość Fałsz (domyślnie), połączenie zostanie powrócone natychmiast po wywołaniu sygnał_stopu
na każdym procesie.

If czekanie ma wartość True, wywołanie powróci dopiero po całkowitym zakończeniu procesu zatrzymywania.
Ze względu na opcję Graceful_timeout może to zająć trochę czasu.

Połączenia mecz parametr może mieć wartość prosty do porównania ciągów, kula dla symbolu wieloznacznego
dopasowanie (domyślne) lub regex do dopasowania wyrażeń regularnych.

Command linia
$ circusctl stop [nazwa] [--waiting] [--match=simple|glob|regex]

Opcje
· : imię i nazwisko lub wzór obserwatora(ów)

· : metoda dopasowania obserwatora

CLI narzędzia
szczyt cyrku
szczyt cyrku to konsola przypominająca top, na której możesz uruchomić i oglądać na żywo działający system Circus. To
wyświetli procesor, użycie pamięci i trafienia w gniazdach, jeśli je posiadasz.

Przykład wyjścia:

-------------------------------------------------- ---------------------
statystyki cyrkowe
PID procesora (%) PAMIĘĆ (%)
14252 0.8 0.4
0.8 (średnio) 0.4 (suma)

manekin
PID procesora (%) PAMIĘĆ (%)
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 (średnio) 0.5 (suma)

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

szczyt cyrku jest konsolą tylko do odczytu. Jeśli chcesz wejść w interakcję z systemem, użyj okrężny.

okrężny
okrężny można użyć do uruchomienia dowolnego polecenia wymienionego w poleceniach. Możesz otrzymać np
listę wszystkich obserwatorów, co możesz zrobić

$ circusctl lista

Oprócz obsługi kilku opcji możesz także określić punkt końcowy okrężny powinien
użyj za pomocą CIRCUSCTL_ENDPOINT zmienna środowiskowa.

Połączenia Sieć Konsola
Circus jest wyposażony w konsolę internetową, za pomocą której można zarządzać systemem.

Konsola internetowa umożliwia:

· Połącz się z dowolnym działającym systemem Circus

· Oglądaj procesy wykorzystania procesora i pamięci w czasie rzeczywistym

· Dodaj lub zakończ procesy

· Dodaj nowych obserwatorów

UWAGA:
Funkcja wykorzystania procesora i pamięci w czasie rzeczywistym korzysta z gniazda statystyk. Jeśli chcesz
aktywuj go, upewnij się, że system Circus, z którym się łączysz, ma ustawione statystyki
włączone w jego konfiguracji:

[cyrk]
statystyki = Prawda

Domyślnie ta opcja nie jest aktywna.

Konsola internetowa jest osobnym pakietem, należy zainstalować:

$ pip zainstaluj circus-web

Aby włączyć konsolę, dodaj kilka opcji w pliku ini Circus:

[cyrk]
httpd = Prawda
httpd_host = host lokalny
httpd_port = 8080

httpd_host i httpd_port są opcjonalne i domyślne localhost i 8080.

Jeśli chcesz uruchomić aplikację internetową samodzielnie, po prostu uruchom plik cyrkhttpd scenariusz:

$ cyrkhttpd
Uruchamianie serwera butelek...
Słucham dalej http://localhost: 8080 /
Naciśnij Ctrl-C, aby wyjść.

Domyślnie skrypt uruchomi konsolę internetową na porcie 8080, ale opcja --port może być
zwykłem to zmieniać.

Korzystanie z dotychczasowy konsola
Po uruchomieniu skryptu możesz otworzyć przeglądarkę i odwiedzić http://localhost: 8080. Ty
powinien otrzymać ten ekran: [image]

Konsola internetowa jest gotowa do podłączenia do systemu Circus, biorąc pod uwagę jej możliwości Punkt końcowy, Przez
domyślnym punktem końcowym jest TCP://127.0.0.1:5555.

Kiedy już trafisz Skontaktuj się, aplikacja internetowa połączy się z systemem Circus.

Po zalogowaniu się do konsoli internetowej powinieneś otrzymać listę obserwatorów i status w czasie rzeczywistym
z dwóch procesów Circus (circusd i circusd-stats).

Możesz kliknąć status każdego obserwatora, aby go przełączyć Aktywna (zielony) do Nieaktywny
(czerwony). Ta zmiana wchodzi w życie natychmiast i umożliwia uruchamianie i zatrzymywanie obserwatorów.

Jeśli klikniesz na nazwę obserwatora, wyświetli się strona internetowa tego konkretnego obserwatora,
z jego procesami:

Na tym ekranie możesz dodawać lub usuwać procesy oraz zabijać istniejące.

Na koniec możesz dodać zupełnie nowego obserwatora, klikając przycisk Dodaj Obserwator przyłączać się
menu po lewej stronie: .SS Działa za Nginxem

Nginx może działać jako serwer proxy i warstwa bezpieczeństwa przed siecią cyrkową.

UWAGA:
Aby otrzymywać aktualizacje statusu i wykresy w czasie rzeczywistym w circus-web, musisz podać Nginx
rozwiązanie proxy obsługujące protokół websocket

nginx >= 1.3.13
Od Nginx>=1.3.13 obsługa websocket jest wbudowana, więc nie ma potrzeby łączenia Nginx
z lakierem lub HAProxy. Przykładowa konfiguracja Nginx z obsługą websocket:

nadrzędny serwer_cyrkowy {
serwer 127.0.0.1:8080;
}

serwer {
słuchać 80;
Nazwa serwera _;

Lokalizacja / {
hasło_proxy http://circusweb_server;
proxy_http_wersja 1.1;
proxy_set_header Aktualizacja $http_upgrade;
proxy_set_header Połączenie „aktualizacja”;
proxy_set_header Host $ host;
proxy_set_header X-Real-IP $ remote_addr;
proxy_set_header X-Przekazano-For $ proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto http;
proxy_redirect wyłączone;
}

lokalizacja ~/media/\*(.png|.jpg|.css|.js|.ico)$ {
alias /path_to_site-packages/circusweb/media/;
}
}

nginx < 1.3.13
Wersje Nginx < 1.3.13 nie mają wbudowanej obsługi websocket.

Aby zapewnić obsługę protokołu websocket dla circus-web podczas korzystania z Nginx < 1.3.13, możesz połączyć
Nginx z lakierem lub HAProxy. Oznacza to, że Nginx przed siecią cyrkową, z lakierem lub
HAProxy przed Nginxem.

Poniższy przykład pokazuje połączoną konfigurację Nginix i Varnish wymaganą do proxy
circus-web i zapewnia obsługę protokołu websocket.

nginx konfiguracja:

nadrzędny serwer_cyrkowy {
serwer 127.0.0.1:8080;
}

serwer {
słuchać 8001;
Nazwa serwera _;

Lokalizacja / {
proxy_set_header X-Przekazano-For $ proxy_add_x_forwarded_for;
proxy_set_header Host $ HTTP_HOST;
proxy_redirect wyłączone;
hasło_proxy http://circusweb_server;
}

lokalizacja ~/media/\*(.png|.jpg|.css|.js|.ico)$ {
alias /path_to_site-packages/circusweb/media/;
}
}

Jeśli chcesz więcej opcji konfiguracji Nginx, zobacz http://wiki.nginx.org/HttpProxyModule.

Lakier konfiguracja:

domyślny backend {
.host = "127.0.0.1";
.port = "8001";
}

gniazdo backendu {
.host = "127.0.0.1";
.port = "8080";
.connect_timeout = 1s;
.first_byte_timeout = 2s;
.between_bytes_timeout = 60s;
}

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

sub vcl_recv {
if (req.http.Upgrade ~ "(?i)websocket") {
set req.backend = gniazdo;
powrót (rura);
}
}

W powyższym przykładzie konfiguracji Varnish zdefiniowano dwa backendy. Jeden obsługujący sieć
konsolę i jedną obsługującą połączenia gniazdowe. Żądania konsoli internetowej są powiązane z portem
8001. Dyrektywa „serwerowa” Nginx powinna być skonfigurowana do nasłuchiwania na porcie 8001.

Połączenia Websocket są aktualizowane i przesyłane bezpośrednio do procesu nasłuchującego circushttpd
na porcie 8080 przez Varnish. tj. omijanie proxy Nginx.

Ubuntu
Od wersji 13.10 (Pyskaty), Ubuntu zawiera Nginx z własną obsługą websocket
repozytoria. W przypadku starszych wersji możesz zainstalować Nginx>=1.3.13 z oficjalnego Nginx
stabilny PPA, a więc:

sudo apt-get install Python-software-properties
sudo add-apt-repository ppa: nginx/stable
sudo apt-get update
sudo apt-get install nginx
nginx -v

Ochrona hasłem cyrkhttpd
Jak wyjaśniono na stronie Bezpieczeństwo, running cyrkhttpd jest dość niebezpieczne. Nie zapewniamy
dowolne zabezpieczenia w samym Circus, ale możesz chronić swoją konsolę na poziomie NGinx, poprzez
za pomocą http://wiki.nginx.org/HttpAuthBasicModule

Przykład:

Lokalizacja / {
proxy_set_header X-Przekazano-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: $ schemat;
proxy_redirect wyłączone;
hasło_proxy http://127.0.0.1:8080;
auth_basic "Ograniczone";
plik_użytkownika_auth_podstawowego /ścieżka/do/htpasswd;
}

Połączenia htpasswd plik zawiera użytkowników i ich hasła, a kiedy zostanie wyświetlony monit o podanie hasła
uzyskujesz dostęp do konsoli.

Do edycji możesz użyć skryptu htpasswd Apache lub skryptu Pythona, który udostępnia pod adresem:
http://trac.edgewall.org/browser/trunk/contrib/htpasswd.py

Jednakże nie ma natywnej obsługi łącznego użycia uwierzytelniania HTTP i
WebSockets (serwer wyrzuci kody błędów HTTP 401). Rozwiązaniem jest wyłączenie takiego
uwierzytelnianie dla serwera Socket.io.

Przykład (należy dodać przed poprzednią regułą):

lokalizacja /socket.io {
proxy_set_header X-Przekazano-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: $ schemat;
proxy_redirect wyłączone;
hasło_proxy http://127.0.0.1:8080;
}

Oczywiście to tylko jeden ze sposobów ochrony konsoli internetowej. Można zastosować wiele innych
Techniki.

Rozsuwalny dotychczasowy sieć konsola
Wybraliśmy butelka do zbudowania konsoli internetowej, głównie dlatego, że jest to naprawdę mały framework
nie robi wiele. Rzucając okiem na kod konsoli internetowej, w końcu znajdziesz
się, że jest to naprawdę proste do zrozumienia.

Oto jak to jest podzielone:

· cyrkhttpd.py plik zawiera definicje „widoków” i kod do obsługi
połączenie z gniazdem (przez Socketio).

· ten kontroler.py zawiera jedną klasę odpowiedzialną za komunikację
z dyrektorem cyrku. Pozwala mieć ładniejszy interfejs API wysokiego poziomu podczas definiowania
serwer internetowy.

Jeśli chcesz dodać funkcję do konsoli internetowej, możesz ponownie wykorzystać istniejący kod. A
do Twojej dyspozycji jest kilka narzędzi ułatwiających ten proces:

· Tam jest szablon_renderowania funkcję, która pobiera nazwane argumenty, które jej przekazujesz, i
przekaż je do modułu renderującego szablony i zwróć wynikowy kod HTML. To też trochę mija
dodatkowe zmienne, takie jak sesja, wersja cyrkowa i klient, jeśli jest zdefiniowany.

· Jeśli chcesz uruchamiać polecenia i dokonywać przekierowań w zależności od wyniku, możesz użyć
dotychczasowy Uruchom polecenie funkcja, która jako pierwszy argument przyjmuje wywołanie, w razie potrzeby wiadomość
sukcesu i adres URL przekierowania.

Połączenia Przestrzeń nazw statystyk klasa jest odpowiedzialna za zarządzanie komunikacją websocket na platformie
po stronie serwera. Jego dokumentacja powinna pomóc ci zrozumieć, co robi.

Pracujący w Gniazda
Circus może łączyć gniazda sieciowe i zarządzać nimi tak samo, jak procesami.

Główną ideą jest proces potomny utworzony przez Circus w celu uruchomienia jednego z procesów obserwatora
polecenie może dziedziczyć po wszystkich otwartych deskryptorach plików.

Tak działa Apache, Unicorn i wiele innych dostępnych narzędzi.

Cel
Celem posiadania gniazd zarządzanych przez Circus jest możliwość zarządzania aplikacjami sieciowymi
w Circus dokładnie tak, jak inne aplikacje.

Na przykład, jeśli używasz Circus z Skarpety -- serwer WGSI, można uzyskać bardzo szybko
serwer WWW działający i zarządzający "Sieć Pracownicy" w cyrku, tak jak zrobiłbyś to w każdym innym
proces.

Oddzielenie zarządzania gniazdami od samej aplikacji sieciowej oferuje wiele
możliwości skalowania i zarządzania stosem.

Wnętrze
Istota tej funkcji polega na związaniu gniazda i rozpoczęciu słuchania
cyrk:

gniazdo importu

skarpetka = gniazdo.gniazdo(RODZINA, TYP)
skarpetka.bind((HOST, PORT))
skarpetka.słuchaj(BACKLOG)
fd = skarpetka.plik()

Circus następnie śledzi wszystkie otwarte fds i pozwala, aby procesy działały jako dzieci
mieć do nich dostęp, jeśli chcą.

Jeśli utworzysz mały skrypt sieciowy w języku Python, który zamierzasz uruchomić w Circus, może to nastąpić
wygląda jak to:

gniazdo importu
import sys

fd = int(sys.argv[1]) # pobieranie FD z cyrku
skarpetka = gniazdo.fromfd(fd, RODZINA, TYP)

# rozpatrywanie jednego żądania na raz
podczas gdy prawda:
conn, adres = skarpetka.accept()
prośba = połączenie.odbiór(1024)
.. Zrób coś ..
conn.sendall(odpowiedź)
poł.zamknij()

Wtedy Cyrk mógłby działać tak:

[cyrk]
check_delay = 5
punkt końcowy = tcp://127.0.0.1:5555
pubsub_endpoint = tcp://127.0.0.1:5556
stats_endpoint = tcp://127.0.0.1:5557

[obserwator:manekin]
cmd = mycoolscript $(circus.sockets.foo)
use_sockets = Prawda
opóźnienie_rozgrzewki = 0
liczbaprocesów = 5

[gniazdo:foo]
host = 127.0.0.1
port = 8888

$(cyrk.sockets.foo) zostanie zastąpiony wartością FD po utworzeniu gniazda i
związane z 8888 Port.

UWAGA:
Począwszy od wersji Circus 0.8 istnieje alternatywna składnia pozwalająca uniknąć pewnych konfliktów z niektórymi
konfigurować parsery. Możesz pisać:

((cyrk.sockets.foo))

Prawdziwy świat przykład
Skarpety jest idealnym towarzyszem Circus, jeśli chcesz uruchomić aplikację WSGI.

Po zainstalowaniu uruchom wersję 5 meinheld workers można wykonać, tworząc gniazdo i
dzwoniąc na skarpetka polecenie w pracowniku, takie jak to:

[cyrk]
punkt końcowy = tcp://127.0.0.1:5555
pubsub_endpoint = tcp://127.0.0.1:5556
stats_endpoint = tcp://127.0.0.1:5557

[obserwator:sieć]
cmd = chaussette --fd $(circus.sockets.web) --backend meinheld mycool.app
use_sockets = Prawda
liczbaprocesów = 5

[gniazdo:sieć]
host = 0.0.0.0
port = 8000

Nie publikowaliśmy jeszcze testów porównawczych, ale klaster internetowy zarządzany przez Circus z Geventem lub
Backend Meinhelda jest tak szybki, jak każdy dostępny serwer WSGI przed forkiem.

Korzystanie z wbudowany wtyczki
Circus posiada kilka wbudowanych wtyczek. W tej sekcji przedstawiono te wtyczki i ich funkcje
opcje konfiguracji.

Statystyki
posługiwać się ustaw na „circus.plugins.statsd.StatsdEmitter”

Nazwa aplikacji
nazwa używana do identyfikacji przedrostka segmentu, do którego będą wysyłane statystyki (będzie to
z przedrostkiem cyrk. i z przyrostkiem .obserwator)

gospodarz host, do którego mają zostać przesłane dane statystyczne

Port port, na którym nasłuchuje demon statsd

próbna stawka
jeśli wolisz inną częstotliwość próbkowania niż 1, możesz ją ustawić tutaj

Pełne statystyki
Rozszerzenie wtyczki Statsd, które publikuje także statystyki procesów. Jako takie
ma te same opcje konfiguracji co Statsd i poniższe.

posługiwać się Ustawić circus.plugins.statsd.FullStats

szybkość_pętli
częstotliwość, w której wtyczka powinna pytać o statystyki w sekundach. Wartość domyślna: 60.

RedisObserver
Zapewnia to obserwatorom proces redis dla Ciebie, publikuje informacje w statsd
i oferuje ponowne uruchomienie obserwatora, jeśli nie zareaguje w określonym czasie. Ta wtyczka
Wymaga redis-py biegać.

Ma taką samą konfigurację jak statsd i dodaje co następuje:

posługiwać się Ustawić circus.plugins.redis_observer.RedisObserver

szybkość_pętli
częstotliwość, w której wtyczka powinna pytać o statystyki w sekundach. Wartość domyślna: 60.

redis_url
baza danych, którą należy sprawdzić jako adres URL ponownego wysłania. Wartość domyślna: „redis://localhost:6379/0”

Timeout
limit czasu w sekundach, jaki może upłynąć, zanim żądanie zostanie uznane za odrzucone.
Domyślnie 5.

restart_on_timeout
nazwa procesu, który ma zostać uruchomiony ponownie po przekroczeniu limitu czasu żądania. Bez ponownego uruchomienia
wyzwalane, gdy nie zostało podane. Wartość domyślna: Brak.

HttpObserver
Obsługuje to obserwatorów za Ciebie proces http poprzez regularne pingowanie określonej witryny internetowej.
Podobnie jak obserwator redis, oferuje ponowne uruchomienie obserwatora w przypadku błędu. To wymaga
tornado biegać.

Ma taką samą konfigurację jak statsd i dodaje co następuje:

posługiwać się Ustawić circus.plugins.http_observer.HttpObserver

szybkość_pętli
częstotliwość, w której wtyczka powinna pytać o statystyki w sekundach. Wartość domyślna: 60.

sprawdź_url
adres URL, który należy sprawdzić. Domyślny: http://localhost/

Timeout
limit czasu w sekundach, jaki może upłynąć, zanim żądanie zostanie uznane za odrzucone.
Domyślnie 10.

restart_on_error
nazwa procesu, który ma zostać ponownie uruchomiony po przekroczeniu limitu czasu żądania lub zwróceniu żadnego
inny rodzaj błędu. Nie jest uruchamiany żaden restart, jeśli nie został podany. Wartość domyślna: Brak.

Obserwator zasobów
Usługa ta obserwuje zasoby danego procesu i po jego uruchomieniu wyzwala restart
zbyt często z rzędu przekraczają pewne ograniczenia.

Ma taką samą konfigurację jak statsd i dodaje co następuje:

posługiwać się Ustawić circus.plugins.resource_watcher.ResourceWatcher

szybkość_pętli
częstotliwość, w której wtyczka powinna pytać o statystyki w sekundach. Wartość domyślna: 60.

obserwator
obserwator, którym powinien opiekować się ten obserwator zasobów. (wcześniej tzw
usługa ale usługa jest już przestarzały)

maks_procesor
Maksymalny procesor, jaki może wykorzystać jeden proces (w%). Wartość domyślna: 90

min_procesor
Minimalny procesor, jaki powinien zużywać jeden proces (w%). Wartość domyślna: Brak (brak minimum)
Możesz ustawić min_cpu na 0 (zero), w tym przypadku, jeśli jeden proces zużywa dokładnie
0% procesora, spowoduje to przekroczenie limitu.

max_pamięć
Ilość pamięci, jaką może wykorzystać jeden proces tego obserwatora. Domyślny:
90. Jeżeli nie określono żadnej jednostki, wartość jest wyrażona w %. Przykład: 50 Jeśli jednostka jest
określony, wartość jest w bajtach. Obsługiwane jednostki to B, K, M, G, T, P, E, Z, Y.
Przykład: 250M

min_pamięć
Minimalna pamięć, jaką powinien zużywać jeden proces tego obserwatora. Wartość domyślna: Brak (nie
minimum). Jeżeli nie określono żadnej jednostki, wartość jest wyrażona w %. Przykład: 50 Jeśli jednostka jest
określony, wartość jest w bajtach. Obsługiwane jednostki to B, K, M, G, T, P, E, Z, Y.
Przykład: 250M

próg_zdrowia
Kondycja to średnia procesora i pamięci (w%) procesów obserwatorów
dopuszczone do spożycia (w %). Wartość domyślna: 75

maksymalna_liczba
Jak często te limity (każdy liczony osobno) mogą występować
przekroczony, zanim nastąpi ponowne uruchomienie. Wartość domyślna: 3

Przykład:

[cyrk]
; ...

[obserwator:program]
cmd = sen 120

[wtyczka:mojawtyczka]
use = circus.plugins.resource_watcher.ResourceWatcher
obserwator = program
min_procesor = 10
maks_procesor = 70
min_pamięć = 0
max_pamięć = 20

Watchdog
Wtyczka, która wiąże gniazdo udp i czeka na komunikaty watchdoga. Dla „nadzorowanych”
procesów, watchdog je zabije, jeśli w pewnym momencie nie wyślą uderzenia serca
okres czasu zmaterializowany przez pętla_rate * max_count. (cyrk zrobi to automatycznie
zrestartuj brakujące procesy w obserwatorze)

Każdy monitorowany proces powinien wysłać komunikat udp co najmniej z szybkością pętli. udp
format wiadomości to linia tekstu zdekodowana za pomocą msg_regex parametr. Bicie serca
wiadomość MUSI zawierać przynajmniej pid procesu wysyłającego wiadomość.

Listę monitorowanych obserwatorów określa parametr obserwatorzy_regex
konfiguracja.

Parametry konfiguracyjne:

posługiwać się Ustawić cyrk.plugins.watchdog.WatchDog

szybkość_pętli
szybkość pętli watchdog w sekundach. W każdej pętli WatchDog będzie szukał „martwego”
procesów.

obserwatorzy_regex
wyrażenie regularne pasujące do nazw obserwatorów, które powinny być monitorowane przez watchdog
(domyślny: .* wszyscy obserwatorzy są monitorowani)

msg_regex
wyrażenie regularne do dekodowania otrzymanej wiadomości pulsu w udp (domyślnie:
^(?P .*);(?P .*)$) domyślny format to prosta wiadomość tekstowa:
pid;znacznik czasu

maksymalna_liczba
maksymalna liczba przebytych pętli bez otrzymania sygnału pulsu przed ponownym uruchomieniem
proces (domyślnie: 3)

ip ip, na który zostanie powiązany watchdog (domyślnie: 127.0.0.1)

Port port, z którym będzie się łączyć watchdog (domyślnie: 1664)

Trzepotanie
Jeśli pracownik zbyt często uruchamia się ponownie, mówimy, że tak trzepotanie. Ta wtyczka śledzi
pracownika uruchamia się ponownie i zatrzymuje odpowiedniego obserwatora w przypadku trzepotania. Ten
Wtyczka może być używana do automatycznego zatrzymywania pracowników, którzy są ciągle uruchamiani ponownie, ponieważ
nie działają prawidłowo.

posługiwać się Ustawić cyrk.plugins.trzepotanie.Trzepotanie

próby
ile razy proces może zostać ponownie uruchomiony w ciągu okno sekundy, zanim my
uważaj to za trzepotanie (domyślnie: 2)

okno okno czasowe w sekundach, aby sprawdzić trzepotanie. Jeśli proces zostanie ponownie uruchomiony, więcej
niż próby razy w tym oknie czasowym, uważamy to za proces trzepotania.
(domyślnie: 1)

ponowna próba
czas w sekundach oczekiwania, aż spróbujemy ponownie rozpocząć proces, który już się rozpoczął
trzepotanie. (domyślnie: 7)

maksymalna_ponowna próba
ile razy próbowaliśmy rozpocząć proces, który wcześniej trzepotał
porzucamy i zatrzymujemy całego obserwatora. (domyślnie: 5) Ustaw na -1, aby wyłączyć
max_retry i ponawiaj próby w nieskończoność.

aktywny określ, czy wtyczka jest aktywna, czy nie (domyślnie: True). Jeśli flaga globalna to
ustawiona na False, wtyczka nie zostanie uruchomiona.

Opcje można zastąpić w sekcji obserwatora za pomocą a trzepotanie. prefiks. Na przykład,
oto jak skonfigurować konkretny plik maksymalna_ponowna próba wartość dla nginx:

[obserwator:nginx]
cmd = /ścieżka/do/nginx
trzepotanie.max_retry = 2

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

; ...inni obserwatorzy

[wtyczka:trzepotanie]
use = circus.plugins.flapping.Flapping
max_ponowna próba = 5

Program CommandReloader
Ta wtyczka zrestartuje obserwatorów, gdy ich plik poleceń zostanie zmodyfikowany. Działa przez
sprawdzenie czasu modyfikacji i ścieżki pliku wskazanego przez cmd opcja każda
szybkość_pętli sekundy. Może to być przydatne podczas opracowywania procesów roboczych lub nawet na gorąco
aktualizacja kodu w produkcji.

posługiwać się Ustawić circus.plugins.command_reloader.CommandReloader

szybkość_pętli
częstotliwość, w ciągu kilku sekund, którą wtyczka powinna sprawdzać pod kątem modyfikacji. Wartość domyślna: 1.

Rozlokowanie
Chociaż demonem Circus można zarządzać za pomocą polecenia circusd, łatwiej jest go mieć
zacznij od rozruchu. Jeśli Twój system obsługuje Upstart, możesz utworzyć ten skrypt Upstart w
/etc/init/circus.conf.

zacznij od systemu plików i urządzenia sieciowego IFACE=lo
zatrzymaj się na poziomie pracy [016]

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

Zakłada się, że plik circusd.ini znajduje się w /etc/circus/circusd.ini. Po ponownym uruchomieniu ty
można kontrolować circusd za pomocą polecenia service:

# uruchomienie/zatrzymanie/uruchomienie cyrku usługowego

Jeśli Twój system obsługuje systemd, możesz utworzyć ten plik jednostki systemowej w obszarze
/etc/systemd/system/circus.service.

[Jednostka]
Opis=Menedżer procesów cyrkowych
After=syslog.target sieć.target nss-lookup.target

[Usługa]
Typ = prosty
ExecReload=/usr/bin/circusctl przeładuj
ExecStart=/usr/bin/circusd /etc/circus/circus.ini
Uruchom ponownie = zawsze
RestartSec = 5

[Zainstalować]
Poszukiwany przez=domyślny.cel

Ponowne uruchomienie nie jest wymagane, jeśli uruchomisz poniższe polecenie daemon-reload:

# systemctl --system demon-reload

Zatem cyrkiem można zarządzać poprzez:

# systemctl start/stop/status/reload circus

przepisy
Ta sekcja będzie zawierała przepisy na rozmieszczenie Cyrku. Do tego czasu możesz zajrzeć do Pete'a
Marionetka Przepis albo u Remy’ego Szef kuchni Przepis

Papież Przetwarzanie Jądro
Jednym z problemów typowych dla menedżerów procesów jest to, że nie można ponownie uruchomić menedżera procesów
bez ponownego uruchamiania wszystkich procesów, którymi zarządza. Utrudnia to wdrożenie a
nowa wersja Circusa lub nowe wersje którejkolwiek z bibliotek, od których jest zależny.

Jeśli korzystasz z systemu typu Unix, Circus może używać jądra procesu Papa. Kiedy jest używany, tato
utworzy długowiecznego demona, który będzie służył jako host dla wszelkich procesów i gniazd
z nim tworzysz. Jeśli cyrk zostanie zamknięty, tata zajmie się wszystkim, co jest w nim przechowywane.

ustawienie
Zacznij od zainstalowania papa i ustaw tytułproc moduły:

pip zainstaluj tatusiu
pip zainstaluj setproctitle

Połączenia ustaw tytułproc moduł jest opcjonalny. Zostanie użyty, jeśli jest obecny, do zmiany nazwy demona Papa
dla Top i ps do czegoś w rodzaju „demona taty z cyrku”. Jeśli nie zainstalujesz
ustaw tytułproc module, tytuł ten będzie wierszem poleceń procesu, który go uruchomił.
Bardzo mylące.

Po zainstalowaniu Papa dodaj use_papa=true do krytycznych procesów i gniazd.
Ogólnie rzecz biorąc, chcesz umieścić wszystkie procesy swojego stosu w Papa i żaden z nich
Procesy wspierające Circus, takie jak wtyczki do trzepotania i statystyk.

[cyrk]
poziom logowania = informacja

[obserwator: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
opóźnienie_rozgrzewki = 3
wdzięku_timeout = 10
max_ponowna próba = 5
singleton = prawda
send_hup = prawda
stop_signal = WYJDŹ
stdout_stream.class = Strumień Plików
stdout_stream.filename = /var/logs/web-server.log
stdout_stream.max_bytes = 10000000
stdout_stream.backup_count = 10
stderr_stream.class = Strumień plików
stderr_stream.filename = /var/logs/błąd-serwera-web.log
stderr_stream.max_bytes = 1000000
stderr_stream.backup_count = 10
aktywny = prawdziwy
use_papa = prawda

[obserwator:logger]
cmd = /my_service/env/bin/python logger.py uruchom
katalog_roboczy = /moja_usługa
wdzięku_timeout = 10
singleton = prawda
stop_signal = INT
stdout_stream.class = Strumień Plików
stdout_stream.filename = /var/logs/logger.log
stdout_stream.max_bytes = 10000000
stdout_stream.backup_count = 10
stderr_stream.class = Strumień plików
stderr_stream.filename = /var/logs/logger.log
stderr_stream.max_bytes = 1000000
stderr_stream.backup_count = 10
priorytet = 50
use_papa = prawda

[obserwator:aplikacja internetowa]
cmd = /my_service/env/bin/uwsgi --ini uwsgi-live.ini --socket fd://$(circus.sockets.web) --stats 127.0.0.1:809$(circus.wid)
katalog_roboczy = /moja_usługa/aplikacja internetowa
wdzięczny_czas oczekiwania = 10
stop_signal = WYJDŹ
use_sockets = Prawda
stdout_stream.class = Strumień Plików
stdout_stream.filename = /var/logs/web_app.log
stdout_stream.max_bytes = 10000000
stdout_stream.backup_count = 10
stderr_stream.class = Strumień plików
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 = przykłady.uwsgi_lossless_reload.clean_stop
hooks.extended_stats = przykłady.uwsgi_lossless_reload.extended_stats
priorytet = 40
use_papa = prawda

[gniazdo:sieć]
ścieżka = /moja_usługa/sock/uwsgi
use_papa = prawda

[wtyczka:trzepotanie]
use = circus.plugins.flapping.Flapping
okno = 10
priorytet = 1000

UWAGA:
Jeśli procesy Papa korzystają z jakichkolwiek gniazd, te gniazda również muszą używać papa.

Wnętrze Cel
Papa została zaprojektowana tak, aby była bardzo minimalistyczna pod względem funkcji i wymagań. To robi:

· Gniazda uruchamiające i zatrzymujące

· Zapewnij magazyn kluczy/wartości

· Rozpocznij procesy i zwróć stdout, stderr i kod zakończenia

To nie:

· Uruchom ponownie procesy

· Zapewnij sposób na zatrzymanie procesów

· Podaj wszelkie informacje o procesach inne niż to, czy nadal działają

Papa nie wymaga żadnych bibliotek innych firm, więc może działać tylko na standardowej bibliotece Pythona.
Może skorzystać z ustaw tytułproc pakiet, ale jest on używany tylko do tworzenia tytułu
ładniejsza dla ps i Top i nie jest niezbędne.

Funkcjonalność została ograniczona do minimum, dzięki czemu nigdy nie będzie konieczne ponowne uruchamianie
Tata demon. Do biblioteki klienckiej przeniesiono większość funkcjonalności
możliwy. W ten sposób powinieneś móc wdrożyć nową kopię Papy dla nowych funkcji klienta
bez konieczności ponownego uruchamiania demona Papa. Tata ma być filarem stabilności
zmieniające się morze bibliotek zewnętrznych.

Działanie
Większość rzeczy pozostaje niezmieniona, niezależnie od tego, czy używasz Papa, czy nie. Nadal możesz zaczynać i kończyć
procesy. Nadal możesz uzyskać status i statystyki procesów. Najważniejsze, co się zmienia
to wtedy to robisz okrężny porzucić, wszystkie procesy Papa pozostają uruchomione. Kiedy ty
początek cyrk kopię zapasową, procesy te zostaną odzyskane.

UWAGA:
Kiedy procesy zostaną przywrócone, przed startem i przed_spawnem haki są pomijane.

Logowanie
Kiedy Circus jest wyłączony, Papa będzie przechowywać do 2M danych wyjściowych na proces. Wtedy tak się stanie
zacznij zrzucać najstarsze dane. Po ponownym uruchomieniu Circus dane wyjściowe z pamięci podręcznej zostaną szybko zapisane
pobierane i wysyłane do strumieni wyjściowych. Tata wymaga, aby odbiór wyników był
potwierdzony, więc nie powinieneś utracić żadnego wyjścia podczas zamykania.

Co więcej, Papa zapisuje znacznik czasu wyniku. Cyrk został ulepszony
skorzystaj z danych znacznika czasu, jeśli są obecne. Więc jeśli piszesz dane wyjściowe do plików dziennika
lub gdzieś, wszystkie twoje znaczniki czasu powinny być poprawne.

Problemy
Jeśli używasz przyrost or dekret polecenie zmiany liczby procesów dla obserwatora, to zrobi
zostać zresetowany do poziomu określonego w pliku INI, gdy cyrk zostaje uruchomiony ponownie.

Ponadto doświadczyłem problemów z kombinacją kopia_środ i virtualenv. Użytkownik może
zauważ, że powyższy przykład INI omija ten problem za pomocą jawnych ścieżek.

Telnet Interfejs
Papa ma podstawowy interfejs wiersza poleceń, do którego można uzyskać dostęp przez telnet:

lokalny host telnet 20202
pomoc

Cyrk dla deweloperzy
Korzystanie z Cyrk as a biblioteka
Circus udostępnia klasy i funkcje wysokiego poziomu, które pozwolą Ci zarządzać procesami
własne aplikacje.

Na przykład, jeśli chcesz uruchamiać cztery procesy w nieskończoność, możesz napisać:

z cyrku import get_arbiter

mójprogram = {"cmd": "python mójprogram.py", "numprocesses": 4}

arbiter = get_arbiter([mójprogram])
spróbuj:
arbiter.start()
Wreszcie:
arbiter.stop()

Ten fragment kodu uruchomi cztery wystąpienia mójprogram i obserwuj je, uruchamiając je ponownie
jeśli niespodziewanie umrą.

Więcej informacji na ten temat znajdziesz w bibliotece

Rozsuwalny Cyrk
Łatwo jest rozbudować Circus, tworząc bardziej złożony system, słuchając wszystkich plików
cyrk wydarzenia za pośrednictwem kanału pub/sub i sterować nimi za pomocą poleceń.

Tak na przykład działa funkcja trzepotania: nasłuchuje umierania wszystkich procesów,
mierzy, jak często to się zdarza, i zatrzymuje oskarżonych obserwatorów po zbyt wielu ponownych uruchomieniach
próbowanie.

Circus zawiera system wtyczek, które pomogą Ci napisać takie rozszerzenia, a także kilka wbudowanych
wtyczki, których możesz używać ponownie. Zobacz wtyczki.

Możesz także uzyskać bardziej subtelne zachowanie podczas uruchamiania i zamykania, używając opcji haczyki system
który pozwoli ci uruchomić dowolny kod przed i po uruchomieniu niektórych procesów lub
zatrzymany. Zobacz haki.

Na koniec możesz także dodać nowe polecenia. Zobacz dodawaniecmds.

Deweloperzy Dokumenty wskaźnik
Cyrk Biblioteka
Pakiet Cyrk składa się z wysokiego poziomu get_arbiter() funkcja i wiele klas. W
w większości przypadków użycie funkcji wysokiego poziomu powinno wystarczyć, ponieważ tworzy ona wszystko
jest potrzebny do działania cyrku.

Możesz podklasować klasy Circus, jeśli potrzebujesz większej szczegółowości niż to, co oferuje
konfiguracja.

Połączenia get_arbiter funkcjonować
get_arbiter() to tylko udogodnienie, oprócz różnych zajęć cyrkowych. Tworzy
arbiter (klasa Rozstrzygać) instancję z dostarczonymi opcjami, która z kolei uruchamia pojedynczą
Obserwator z jednym Przetwarzanie.

cyrk.get_arbiter()

Przykład:

z cyrku import get_arbiter

arbiter = get_arbiter([{"cmd": "mójprogram", "numprocesses": 3}])
spróbuj:
arbiter.start()
Wreszcie:
arbiter.stop()

Zajęcia
Circus udostępnia szereg klas, których możesz użyć do wdrożenia własnego menedżera procesów:

· Przetwarzanie: otacza działający proces i zapewnia na nim kilka pomocników.

· Obserwator: uruchom kilka instancji Przetwarzanie przeciwko temu samemu poleceniu. Zarządzaj śmiercią i
życie procesów.

· Rozstrzygać: zarządza kilkoma Obserwator.

klasa cyrk.proces.Proces(nazwa, szeroki, cmd, argumenty=Brak, katalog_roboczy=Brak, powłoka = fałsz,
uid=Brak, gid=Brak, env=Brak, rlimity=Brak, plik wykonywalny = brak, use_fds=Fałsz, obserwator=Brak,
spawn=prawda, pipe_stdout=Prawda, pipe_stderr=Prawda, close_child_stdout=Fałsz,
close_child_stderr=Fałsz)
Zamyka proces.

Opcje:

· szeroki: unikalny identyfikator procesu. Ta wartość zostanie użyta do zastąpienia $SZER
ciąg znaków w wierszu poleceń, jeśli jest obecny.

· cmd: polecenie uruchomienia. Może zawierać dowolne z dostępnych zmiennych
przekazywana do tej klasy. Zostaną one zastąpione przy użyciu składni formatu Pythona.

· args: argumenty polecenia do wykonania. Może to być lista lub ciąg znaków. Jeśli args is
ciąg znaków, który jest dzielony za pomocą shlex.split(). Wartość domyślna to Brak.

· plik wykonywalny: Gdy podany jest plik wykonywalny, pierwszy element w sekwencji argumentów
uzyskany z cmd jest nadal traktowana przez większość programów jako nazwa polecenia, która
może wówczas różnić się od rzeczywistej nazwy pliku wykonywalnego. Staje się wyświetlaczem
nazwa programu wykonawczego w narzędziach takich jak ps.

· katalog_roboczy: katalog roboczy, w którym ma zostać uruchomione polecenie. Jeśli nie zostanie podany, zostanie to wykonane
domyślnie do bieżącego katalogu roboczego.

· powłoka: gdyby Prawdziwy, uruchomi polecenie w środowisku powłoki. Fałszywy domyślnie.
ostrzeżenie: to is a bezpieczeństwo hazard.

· uid: jeśli jest podany, jest identyfikatorem lub nazwą użytkownika, pod którą polecenie powinno zostać uruchomione. Obecny
uid jest domyślny.

· kołowacizna: jeśli podano, jest to identyfikator lub nazwa grupy, z którą polecenie powinno zostać uruchomione. Obecny
gid jest domyślny.

· env: mapowanie zawierające zmienne środowiskowe, z którymi będzie uruchamiane polecenie.
Opcjonalny.

· granice: mapowanie zawierające nazwy i wartości granic, które zostaną ustawione przed
działa komenda.

· użyj_fds: jeśli True, nie zamknie fds w podprocesie. Musi być ustawione na
Prawda w systemie Windows, jeśli przekierowane zostanie stdout lub stderr. wartość domyślna: Fałsz.

· pipe_stdout: jeśli True, otworzy PIPE na standardowe wyjście. domyślnie: Prawda.

· rura_stderr: jeśli True, otworzy PIPE na stderr. domyślnie: Prawda.

· zamknij_dziecko_stdout: Jeśli ma wartość True, przekierowuje standardowe wyjście procesu potomnego do /dev/null
po widelcu. wartość domyślna: Fałsz.

· zamknij_dziecko_stderr: Jeśli ma wartość True, przekierowuje standardowe wyjście procesu potomnego do /dev/null
po widelcu. wartość domyślna: Fałsz.

wiek() Zwróć wiek procesu w sekundach.

dzieci()
Zwróć listę pidów dzieci.

info () Informacje o procesie zwrotu.

Zwrócone informacje to mapowanie z następującymi kluczami:

· mem_info1: Rezydentny ustawiony rozmiar pamięci w bajtach (RSS)

· mem_info2: Rozmiar pamięci wirtualnej w bajtach (VMS).

· cpu: % użycia procesora.

· Członek: % wykorzystania pamięci.

· czas: czas procesora procesu (użytkownik + system) w sekundach.

· Pid: identyfikator procesu.

· nazwa użytkownika: nazwa użytkownika będącego właścicielem procesu.

· miło: uprzejmość procesu (od -20 do 20)

· linia poleceń: linia poleceń, za pomocą której uruchomiono proces.

is_child(pid)
Powrót Prawda jest dana Pid jest dzieckiem tego procesu.

Pid Zwróć Pid

wyślij_sygnał(*argumenty, **kw)
Wysyła sygnał porządek do procesu.

send_signal_child(*args, **kw)
Wyślij sygnał znak do dziecka Pid.

send_signal_children(*args, **kw)
Wyślij sygnał znak wszystkim dzieciom.

status Zwróć status procesu jako stałą

· DZIAŁANIE

· DEAD_OR_ZOMBIE

· NIEISTNIEJĄCY

· INNY

stderr Zwróć stdout strumień

stdout Zwróć stdout strumień

stop(*argumenty, **kw)
Zatrzymaj proces i zamknij stdout/stderr

Jeśli odpowiedni proces nadal tu jest (zwykle został już zabity przez
obserwatora), wysyłany jest SIGTERM, a następnie SIGKILL po 1 sekundzie.

Proces zamykania (SIGTERM, a następnie SIGKILL) jest zwykle wykonywany przez
obserwator. Jeśli więc proces ten nadal występuje, jest to pewnego rodzaju złe zachowanie
ponieważ pełen wdzięku limit czasu nie będzie tutaj przestrzegany.

Przykład:

>>> z circus.process proces importu
>>> proces = Proces('Góra', 'góra', powłoka=True)
>>> proces.wiek()
3.0107998847961426
>>> proces.info()
„Na górze: 6812 N/A tarek Zombie N/AN/AN/AN/AN/A”
>>> status.procesu
1
>>> proces.stop()
>>> status.procesu
2
>>> proces.info()
„Nie ma takiego procesu (zatrzymany?)”

klasa cyrk.obserwator.Obserwator(imię, cmd, argumenty=Brak, liczbaprocesów=1, opóźnienie_rozgrzania=0.0,
katalog_roboczy=Brak, powłoka = fałsz, powłoki_args=Brak, uid=Brak, max_ponowna próba=5, gid=Brak,
send_hup=Fałsz, sygnał_stopu=15, stop_children=Fałsz, env=Brak, wdzięczny_czas oczekiwania = 30.0,
prereload_fn=Brak, rlimity=Brak, plik wykonywalny = brak, stdout_stream=Brak, stderr_stream=Brak,
priorytet=0, pętla=Brak, singleton=fałsz, use_sockets=Fałsz, copy_env=Fałsz,
copy_path=Fałsz, maksymalny_wiek=0, maksymalna_zmienność_wieku=30, haki=Brak, respawn=Prawda, autostart=prawda,
on_demand=Fałsz, virtualenv=Brak, close_child_stdout=Fałsz, close_child_stderr=Fałsz,
virtualenv_py_ver=Brak, use_papa=Fałsz, **opcje)
Klasa zarządzająca listą procesów dla danego polecenia.

Opcje:

· Nazwa: imię nadane obserwatorowi. Służy do jednoznacznej identyfikacji.

· cmd: polecenie uruchomienia. Może zawierać $SZER, który zostanie zastąpiony przez szeroki.

· args: argumenty polecenia do wykonania. Może to być lista lub ciąg znaków. Jeśli args is
ciąg znaków, który jest dzielony za pomocą shlex.split(). Wartość domyślna to Brak.

· liczba procesów: Liczba procesów do uruchomienia.

· katalog_roboczy: katalog roboczy, w którym ma zostać uruchomione polecenie. Jeśli nie zostanie podany, zostanie to wykonane
domyślnie do bieżącego katalogu roboczego.

· powłoka: gdyby Prawdziwy, uruchomi polecenie w środowisku powłoki. Fałszywy domyślnie.
ostrzeżenie: to is a bezpieczeństwo hazard.

· uid: jeśli jest podany, jest identyfikatorem lub nazwą użytkownika, pod którą polecenie powinno zostać uruchomione. Obecny
uid jest domyślny.

· kołowacizna: jeśli podano, jest to identyfikator lub nazwa grupy, z którą polecenie powinno zostać uruchomione. Obecny
gid jest domyślny.

· wyślij_hup: jeśli True, przeładowanie procesu zostanie wykonane poprzez wysłanie sygnału SIGHUP.
Domyślnie ustawiona jest wartość Fałsz.

· sygnał_stopu: sygnał do wysłania w przypadku zatrzymania procesu. Domyślnie SIGTERM.

· stop_dzieci: wysłać sygnał_stopu także dzieciom. Domyślnie ustawiona jest wartość Fałsz.

· env: mapowanie zawierające zmienne środowiskowe, z którymi będzie uruchamiane polecenie.
Opcjonalny.

· granice: mapowanie zawierające nazwy i wartości granic, które zostaną ustawione przed
działa komenda.

· stdout_stream: mapowanie definiujące strumień dla standardowego wyjścia procesu. Domyślne
do Żadnego.

Opcjonalny. Gdy jest zapewniony, stdout_stream to mapowanie zawierające maksymalnie trzy klucze:

· klasa: klasa strumienia. Domyślnie circus.stream.FileStream

· filename: nazwa pliku, jeśli używasz FileStream

· max_bajty: maksymalny rozmiar pliku, po przekroczeniu którego otwierany jest nowy plik wyjściowy. wartości domyślne
na 0, co oznacza brak maksymalnego rozmiaru (dotyczy tylko FileStream).

· liczba_kopii zapasowych: ile kopii zapasowych należy zachować podczas obracania plików zgodnie z
parametr max_bytes. domyślnie wynosi 0, co oznacza, że ​​nie są tworzone żadne kopie zapasowe (tylko
dotyczy FileStream)

To mapowanie zostanie użyte do utworzenia strumienia wywoływalnego określonej klasy.
Każdy wpis otrzymany przez obiekt wywoływalny jest mapowaniem zawierającym:

· Pid - identyfikator procesu

· Nazwa - nazwa strumienia (stderr or stdout)

· dane - dane

Nie jest to obsługiwane w systemie Windows.

· stderr_stream: mapowanie definiujące strumień dla procesu stderr. Domyślne
do Żadnego.

Opcjonalny. Gdy jest zapewniony, stderr_stream to mapowanie zawierające maksymalnie trzy klucze:
- klasa: klasa strumienia. Domyślnie circus.stream.FileStream - filename: the
nazwa pliku, jeśli używasz FileStream - max_bajty: maksymalny rozmiar pliku, po czym nowy
plik wyjściowy to
otwierany. domyślnie ustawiona jest wartość 0, co oznacza brak maksymalnego rozmiaru (dotyczy tylko
Strumień pliku)

· liczba_kopii zapasowych: ile kopii zapasowych należy zachować podczas obracania plików zgodnie z
parametr max_bytes. domyślnie wynosi 0, co oznacza, że ​​nie są tworzone żadne kopie zapasowe (tylko
dotyczy FileStream).

To mapowanie zostanie użyte do utworzenia strumienia wywoływalnego określonej klasy.

Każdy wpis otrzymany przez obiekt wywoływalny jest mapowaniem zawierającym:

· Pid - identyfikator procesu

· Nazwa - nazwa strumienia (stderr or stdout)

· dane - dane

Nie jest to obsługiwane w systemie Windows.

· priorytet -- liczba całkowita określająca priorytet obserwatora. Kiedy Arbiter to zrobi
niektóre operacje na wszystkich obserwatorach, posortuje je według tego pola, od
większa liczba do najmniejszej. (domyślnie: 0)

· syngielton -- Jeśli ma wartość True, ten obserwator ma pojedynczy proces. (domyślnie: Fałsz)

· użyj_gniazd -- Jeśli ma wartość True, procesy będą dziedziczyć deskryptory plików, więc mogą
ponownie wykorzystaj gniazda otwarte przez circusd. (domyślnie: Fałsz)

· na żądanie -- Jeśli True, procesy zostaną uruchomione dopiero przy pierwszym połączeniu
do gniazda (domyślnie: Fałsz)

· kopia_środ -- Jeśli ma wartość True, środowisko, w którym działa cyrk, będzie działać
reprodukowane dla pracowników. Domyślnie jest to True w systemie Windows, ponieważ nie można uruchomić
dowolny plik wykonywalny bez SYSTEMROOT zmienny. (domyślnie: Fałsz)

· ścieżka_kopii -- Jeśli to prawda, cyrk sys.ścieżka jest wysyłany do procesu poprzez ŚCIEŻKA PYTONA.
Musisz aktywować kopia_środ dla ścieżka_kopii pracować. (domyślnie: Fałsz)

· max_wiek: Jeśli zostanie ustawiony po około max_age sekundach, proces zostanie zastąpiony nowym
jeden. (domyślnie: 0, wyłączone)

· maksymalna_zmienność_wieku: Maksymalna liczba sekund, które można dodać do max_age.
Ta dodatkowa wartość ma na celu uniknięcie ponownego uruchamiania wszystkich procesów w tym samym czasie. A
proces będzie trwał od max_age do max_age + max_age_variance sekund.

· haczyki: funkcje wywołania zwrotnego umożliwiające podłączenie się do uruchamiania i zamykania obserwatora
proces. haczyki to dyktat, w którym każdy klucz jest nazwą haka, a każda wartość to a
2-krotka z nazwą wywoływanej lub samej wywoływanej i flagą boolowską
wskazując, czy wyjątek występujący w haku nie powinien być ignorowany. Możliwy
wartości nazwy haka: przed startem, po_startu, przed_spawnem, po_spawnie,
przed_zatrzymaniem, po_stopie., przed_sygnałem, po_sygnale or rozszerzone_stats.

· Opcje -- dodatkowe opcje dla pracownika. Wszystkie opcje znalezione w konfiguracji
na przykład plik są przekazywane w tym mapowaniu - może to być używane przez wtyczki do
opcje specyficzne dla obserwatora.

· respawn -- Jeśli ustawione na False, procesy obsługiwane przez obserwatora nie będą
odrodził się automatycznie. (domyślnie: Prawda)

· virtualenv -- Katalog główny wirtualnego środowiska. Jeśli tak, obserwator to zrobi
załaduj środowisko do jego wykonania. (domyślnie: Brak)

· zamknij_dziecko_stdout: Jeśli True, zamyka standardowe wyjście po rozwidleniu. wartość domyślna: Fałsz.

· zamknij_dziecko_stderr: Jeśli True, zamyka stderr po rozwidleniu. wartość domyślna: Fałsz.

· użyj_taty: Jeśli ma wartość True, użyj jądra procesu papa w tym procesie. wartość domyślna: Fałsz.

kill_process(*argumenty, **kwargi)
Zabij proces (stop_signal, Graceful_timeout, a następnie SIGKILL)

kill_processes(*argumenty, **kwargi)
Zabij wszystkie procesy (stop_signal, Graceful_timeout, a następnie SIGKILL)

zarządzaj_procesami(*args, **kwargi)
Zarządzaj procesami.

notify_event(temat, wiadomość)
Opublikuj wiadomość na kanale wydawcy wydarzenia

reap_and_manage_processes(*args, **kwargi)
Zbieraj i zarządzaj procesami.

reap_processes(*args, **kw)
Zbierz wszystkie procesy dla tego obserwatora.

send_signal_child(*args, **kw)
Wyślij sygnał do dziecka.

spawn_process(recovery_wid=Brak)
Proces spawnowania.

Zwróć True, jeśli wszystko jest w porządku, False, jeśli obserwator musi zostać zatrzymany

spawn_processes(*args, **kwargi)
Procesy spawnowania.

klasa circus.arbiter.Arbiter(obserwatorzy, punkt końcowy, pubsub_punkt końcowy, check_delay=1.0,
prereload_fn=Brak, kontekst=Brak, pętla=Brak, statystykid=Fałsz, stats_endpoint=Brak,
statsd_close_outputs=Fałsz, multicast_endpoint=Brak, wtyczki=Brak, gniazda=Brak,
opóźnienie_rozgrzania=0, httpd=fałsz, httpd_host='localhost', httpd_port=8080,
httpd_close_outputs=Fałsz, debugowanie = fałsz, debug_gc=Fałsz, ssh_server=Brak,
proc_name='cyrk', plik pid=Brak, poziom logowania=Brak, wylogowanie=Brak, loggerconfig=Brak,
fqdn_prefix=Brak, umask=Brak, endpoint_owner=Brak, papa_endpoint=Brak)
Klasa używana do kontrolowania listy obserwatorów.

Opcje:

· obserwatorzy -- lista obiektów Obserwatora

· Punkt końcowy -- punkt końcowy ZMQ kontrolera

· pubsub_punkt końcowy -- punkt końcowy pubsub

· statystyki -- Jeśli True, uruchamiany jest proces circusd-stats (domyślnie: False)

· stats_punkt końcowy -- punkt końcowy statystyk.

· statsd_close_outputs -- jeśli True wysyła circusd-stats na stdout/stderr
/dev/null (domyślnie: fałsz)

· multicast_punkt końcowy -- punkt końcowy multiemisji do automatycznego wykrywania klastrów Circusd
(domyślnie: udp://237.219.251.97:12027) Adres multiemisji powinien należeć do zakresu 224.0.0.0
do 239.255.255.255 i to samo dla całego klastra.

· check_opóźnienie -- opóźnienie pomiędzy dwoma punktami kontrolera (domyślnie: 1 s)

· wczytaj ponownie_fn -- wywoływalny, który będzie wykonywany przy każdym przeładowaniu (domyślnie: Brak)

· kontekst -- jeśli podano, kontekst zmq do ponownego użycia. (domyślnie: Brak)

·

pętla: if pod warunkiem, że, a zmq.eventloop.ioloop.IOLoop przykład
do ponownego użycia. (domyślnie: Brak)

· wtyczki -- lista wtyczek. Każdy element jest mapowaniem zawierającym:

· posługiwać się -- W pełni kwalifikowana nazwa wskazująca klasę wtyczki

· każda inna wartość jest przekazywana do wtyczki w pliku config opcja

· Gniazda -- mapowanie gniazd. Każdy klucz to nazwa gniazda, a każda wartość a
CircusSocket klasa. (domyślnie: Brak)

· rozgrzewka_opóźnienie -- opóźnienie w sekundach pomiędzy uruchomieniem dwóch obserwatorów. (domyślnie: 0)

· httpd -- Jeśli ma wartość True, uruchamiany jest proces circushttpd (domyślnie: Fałsz)

· httpd_host -- host circushttpd (domyślnie: localhost)

· httpd_port -- port circushttpd (domyślnie: 8080)

· httpd_close_outputs -- jeśli True, wysyła circushttpd stdout/stderr do /dev/null.
(domyślnie: Fałsz)

· debug -- jeśli True, dodaje wiele informacji debugowania na standardowe wyjście (domyślnie: False)

· debug_gc -- jeśli True, wykonuje gc.set_debug(gc.DEBUG_LEAK) (domyślnie: False) do circusd
do analizy problemów (domyślnie: Fałsz)

· nazwa_procesu -- nazwa procesu arbitra

·

prefiks_fqdn -- a prefiks dla dotychczasowy wyjątkowy identyfikator of dotychczasowy cyrk
instancję w klastrze.

· właściciel_punktu końcowego -- użytkownik unix, do którego chcesz wybrać punkt końcowy, jeśli używasz ipc.

· papa_punkt końcowy -- punkt końcowy jądra procesu papa

add_watcher(*argumenty, **kwargi)
Dodaje obserwatora.

Opcje:

· Nazwa: nazwa obserwatora do dodania

· cmd: polecenie uruchomienia.

· wszystkie inne opcje zdefiniowane w konstruktorze Watcher.

get_watcher(imię)
Zwróć obserwatora Nazwa.

liczbaprocesów()
Zwróć liczbę procesów uruchomionych na wszystkich obserwatorach.

numwatchers()
Zwróć liczbę obserwujących.

załaduj ponownie(*args, **kwargi)
Ładuje wszystko ponownie.

Uruchom wstępne ładowanie_fn() można wywołać, jeśli istnieje, a następnie z wdziękiem przeładuj wszystkich obserwatorów.

początek(*argumenty, **kwargi)
Uruchamia wszystkich obserwatorów.

Jeśli podczas wywołania __init__() podano ioloop, uruchamiane są wszystkie obserwatory
jako standardowa współprogram

Jeśli ioloop nie został podany podczas wywołania __init__() (domyślnie), rozpoczyna się
wszyscy obserwatorzy i pętla zdarzeń (i tutaj bloki). W tym trybie metoda
NIE MOŻE niczego dawać, ponieważ nazywa się to metodą standardową.

parametry
cb -- Oddzwonienie wywoływane po uruchomieniu wszystkich obserwatorów, kiedy
pętla nie została zapewniona.

Pisanie wtyczki
Circus jest wyposażony w system wtyczek, z którym możesz wchodzić w interakcję cyrk.

UWAGA:
Być może później dodamy obsługę circusd-stats do wtyczek.

Wtyczka składa się z dwóch części:

· subskrybent ZMQ wszystkich wydarzeń publikowanych przez cyrk

· Klient ZMQ, do którego można wysyłać polecenia cyrk

Każda wtyczka jest uruchamiana jako oddzielny proces w ramach niestandardowego obserwatora.

Kilka przykładów niektórych wtyczek, które możesz stworzyć w tym systemie:

· system powiadomień wysyłający powiadomienia e-mailem, gdy obserwator macha ręką

· rejestrator

· narzędzie dodające lub usuwające procesy w zależności od obciążenia

· itp.

Sam Circus ma kilka wbudowanych wtyczek.

Połączenia Wtyczka Circus klasa
Circus udostępnia klasę bazową, która pomoże Ci wdrożyć wtyczki: circus.plugins.CircusPlugin

klasa circus.plugins.CircusPlugin(punkt końcowy, pubsub_punkt końcowy, opóźnienie_sprawdzenia, ssh_server=Brak,
**konfiguracja)
Klasa bazowa do pisania wtyczek.

Opcje:

· kontekst -- kontekst ZMQ, którego należy użyć

· Punkt końcowy -- cyrkowy punkt końcowy ZMQ

· pubsub_punkt końcowy -- punkt końcowy pub/sub circusd ZMQ

· check_opóźnienie -- skonfigurowane opóźnienie sprawdzenia

· config -- bezpłatne mapowanie konfiguracji

zadzwoń (polecenie, **rekwizyty)
Wysyła polecenie do cyrk

Opcje:

· komenda - polecenie wywołania

· props -- argumenty słów kluczowych, które należy dodać do wywołania

Zwraca mapowanie JSON odesłane przez cyrk

obsada (polecenie, **rekwizyty)
Uruchom i zapomnij polecenie cyrk

Opcje:

· komenda - polecenie wywołania

· props -- argumenty słów kluczowych, które należy dodać do wywołania

handle_init()
Wywoływany tuż przed uruchomieniem wtyczki - w kontekście wątku.

uchwyt_recv(dane)
Odbiera każde wydarzenie opublikowane przez cyrk

Opcje:

· dane -- krotka zawierająca temat i wiadomość.

uchwyt_stop()
Wywoływany tuż przed zatrzymaniem wtyczki przez Circus.

Po zainicjowaniu przez Circus ta klasa tworzy własną pętlę zdarzeń, która odbiera wszystko
cyrk wydarzenia i przekazać je uchwyt_recv(). Otrzymane dane to krotka zawierająca
tematu i samych danych.

uchwyt_recv() musi zostać zaimplementowane przez wtyczkę.

Połączenia połączenie() i rzucać() metody, z którymi można wchodzić w interakcję cyrk jeśli budujesz
Wtyczka aktywnie współdziałająca z demonem.

handle_init() i uchwyt_stop() to tylko wygodne metody, których można użyć do inicjalizacji i
oczyść swój kod. handle_init() jest wywoływana w wątku, który właśnie się rozpoczął.
uchwyt_stop() jest wywoływana w głównym wątku tuż przed zatrzymaniem i połączeniem wątku.

Pisanie a wtyczka
Napiszmy wtyczkę, która loguje do pliku każde wydarzenie, w którym się dzieje cyrk. Potrzeba jednego
argument będący nazwą pliku.

Wtyczka może wyglądać następująco:

z circus.plugins importuj CircusPlugin

Rejestrator klasy (CircusPlugin):

imię = 'rejestrator'

def __init__(self, *args, **config):
super(Logger, self).__init__(*args, **config)
self.filename = config.get('nazwa pliku')
self.file = Brak

def handle_init(self):
self.file = open(self.filename, 'a+', buforowanie=1)

def handle_stop(self):
plik.samodzielny.close()

def handle_recv(ja, dane):
nazwa_obserwatora, akcja, msg = self.split_data(data)
msg_dict = self.load_message(wiadomość)
self.file.write('%s %s::%r\n' % (akcja, nazwa_obserwatora, msg_dykt))

Otóż ​​to ! Tę klasę można zapisać w dowolnym pakiecie/module, o ile będzie widoczna
Python.

Na przykład, Logger można znaleźć w wtyczki moduł w obrębie a mój projekt pakiet.

Asynchronizacja wywołań
Jeśli chcesz wykonać jakiekolwiek operacje asynchroniczne (takie jak wywołanie Tornado lub użycie
periodicCall) upewnij się, że używasz właściwej pętli. Pętla, z której zawsze chcesz korzystać
to self.loop skonfigurowany przez klasę bazową. Domyślna pętla często nie jest taka sama
i dlatego kod może nie zostać wykonany zgodnie z oczekiwaniami.

Próbować a wtyczka
Możesz uruchomić wtyczkę za pomocą wiersza poleceń za pomocą polecenia wtyczka cyrkowa polecenie, przez
określenie pełnej nazwy wtyczki:

$ circus-plugin --endpoint tcp://127.0.0.1:5555 --pubsub tcp://127.0.0.1:5556 --config nazwa pliku:circus-events.log mójproject.plugins.Logger
[INFO] Ładowanie wtyczki...
[INFO] Punkt końcowy: 'tcp://127.0.0.1:5555'
[INFO] Pub/sub: 'tcp://127.0.0.1:5556'
[INFO] Rozpoczęcie

Innym sposobem uruchomienia wtyczki jest pozwolenie Circusowi na obsługę jej inicjalizacji. Dokonuje się tego poprzez
dodanie [wtyczka:NAZWA] sekcja w pliku konfiguracyjnym, gdzie IMIĘ to unikalna nazwa
twoja wtyczka:

[wtyczka:logger]
use = mój projekt.plugins.Logger
nazwa pliku = /var/myproject/circus.log

posługiwać się jest obowiązkowe i wskazuje pełną nazwę wtyczki.

Kiedy Circus się uruchamia, tworzy obserwatora z jednym procesem, który uruchamia wskazaną klasę, i
przekazać dowolną inną zmienną zawartą w sekcji do konstruktora wtyczki za pośrednictwem metody config
mapowanie.

Możesz także programowo dodawać wtyczki podczas tworzenia pliku cyrk.arbiter.Arbiter klasa
albo użyj cyrk.get_arbiter(), zobacz bibliotekę.

Wydajność
Ponieważ każda wtyczka jest ładowana we własnym procesie, nie powinno to mieć wpływu na całość
wydajności systemu, o ile praca wykonywana przez wtyczkę nie jest zbyt duża
wzywa do cyrk proces.

Haczyki
Circus udostępnia haki, które można wykorzystać do wyzwalania akcji po zdarzeniach obserwatora. Dostępny
haki to:

· przed startem: wywoływane przed uruchomieniem obserwatora. Jeśli hak powróci Fałszywy dotychczasowy
uruchamianie zostaje przerwane.

· po_startu: wywoływane po uruchomieniu obserwatora. Jeśli hak powróci Fałszywy obserwator
zostaje natychmiast zatrzymany, a uruchomienie zostaje przerwane.

· przed_spawnem: wywoływane, zanim obserwator uruchomi nowy proces. Jeśli hak powróci Fałszywy
obserwator zostaje natychmiast zatrzymany, a uruchomienie zostaje przerwane.

· po_spawnie: wywoływane po tym, jak obserwator uruchomi nowy proces. Jeśli hak powróci Fałszywy
obserwator zostaje natychmiast zatrzymany, a uruchomienie zostaje przerwane.

· przed_zatrzymaniem: wywoływane przed zatrzymaniem obserwatora. Wynik haka jest ignorowany.

· po_stopie: wywoływane po zatrzymaniu obserwatora. Wynik haka jest ignorowany.

· przed_sygnałem: wywoływane przed wysłaniem sygnału do procesu obserwatora. Jeśli hak
powraca Fałszywy sygnał nie jest wysyłany (z wyjątkiem SIGKILL, który jest zawsze wysyłany)

· po_sygnale: wywoływany po wysłaniu sygnału do procesu obserwatora.

· rozszerzone_stats: wywoływane, gdy żądane są statystyki z rozszerzonym=True. Służy do dodawania
statystyki specyficzne dla procesu do zwykłych wyników statystycznych.

Przykład
Typowym przypadkiem użycia jest sprawdzenie, czy wszystkie warunki są spełnione, aby proces mógł się rozpocząć.
Załóżmy, że masz obserwatora, który działa Redis i obserwator, który uruchamia skrypt Pythona
Współpracuje z Redis. Dzięki Circus możesz zamówić startup za pomocą priorytet opcja:

[obserwator: pracownik kolejki]
cmd = python -u worker.py
priorytet = 1

[obserwator:redis]
cmd = serwer-redis
priorytet = 2

Przy tej konfiguracji uruchomi się Circus Redis najpierw, a następnie uruchomi proces roboczy kolejki.
Ale Cyrk tak naprawdę nad tym nie panuje Redis jest uruchomiony. Po prostu zaczyna
procesu, o którego uruchomienie poproszono. Brakuje nam tutaj sposobu na kontrolowanie tego Redis is
uruchomiony i w pełni sprawny. Funkcja kontrolująca to może być:

zaimportuj redisa
czas importu

def check_redis(*args, **kw):
time.sleep(.5) # daj mu szansę na uruchomienie
r = redis.StrictRedis(host='localhost', port=6379, db=0)
r.set('foo', 'bar')
return r.get('foo') == 'bar'

Tę funkcję można podłączyć do Circus jako przed startem hak:

[obserwator: pracownik kolejki]
cmd = python -u worker.py
hooks.before_start = mycoolapp.myplugins.check_redis
priorytet = 1

[obserwator:redis]
cmd = serwer-redis
priorytet = 2

Kiedy Cyrk już rozpoczął redis obserwatorze, rozpocznie się pracownik kolejki obserwator, od
wynika z tego priorytet zamawianie. Tuż przed uruchomieniem drugiego obserwatora uruchomi się
dotychczasowy sprawdź_redis funkcję i na wypadek, gdyby powróciła Fałszywy przerwie uruchomienie obserwatora
proces.

Hak podpis
Hak musi podążać za tym podpisem:

def hak(obserwator, arbiter, nazwa_haka, **kwargs):
...
# Jeśli nie zwrócisz True, hak może się zmienić
# zachowanie cyrku (w zależności od haka)
powrót True

Gdzie obserwator jest Obserwator instancja klasy, arbiter dotychczasowy Rozstrzygać jeden, nazwa_haka hak
imię i kwargi dodatkowe parametry opcjonalne (w zależności od rodzaju haka).

Połączenia po_spawnie hak dodaje parametry pid:

def after_spawn(obserwator, arbiter, nazwa_haka, pid, **kwargs):
...
# Jeśli nie zwrócisz True, cyrk zabije proces
powrót True

Gdzie Pid jest PID odpowiedniego procesu.

Podobnie, przed_sygnałem i po_sygnale hooki dodają pid isignum:

def before_signal_hook(watcher, arbiter, hook_name, pid,signum, **kwargs):
...
# Jeśli nie zwrócisz True, cyrk nie wyśle ​​sygnału Signum
# (SIGKILL jest zawsze wysyłany)
powrót True

Gdzie Pid jest PID odpowiedniego procesu i znak jest odpowiednim sygnałem.

Możesz je zignorować, ale możliwość korzystania z danych i metod obserwatora i/lub arbitra może
przydać się w niektórych hakach.

Należy pamiętać, że hooki wywoływane są z nazwanymi argumentami. Więc użyj podpisu haka bez
zmiana nazw argumentów.

Połączenia rozszerzone_stats hook ma swoje własne dodatkowe parametry kwargi:

def Extended_stats_hook(obserwator, arbiter, nazwa_haka, pid, statystyki, **kwargs):
...

Gdzie Pid jest PID odpowiedniego procesu i statystyki zwykłe statystyki
zwrócony. Dodaj własne statystyki do statystyki. Przykład jest w
przykłady/uwsgi_lossless_reload.py.

Jako ostatni przykład, oto super hak, który radzi sobie z wszelkiego rodzaju sygnałami:

def super_hook(obserwator, arbiter, nazwa_haka, **kwargs):
pid = Brak
znak = Brak
if nazwa_haczyka w („przed_sygnałem”, „po_sygnale”):
pid = kwargs ['pid']
znak = kwargs ['signum']
...
powrót True

Hak wydarzenia
Za każdym razem, gdy hak jest uruchamiany, jego wynik jest powiadamiany jako zdarzenie w Circus.

Z hakami powiązane są dwa zdarzenia:

· hak_sukces: hak został pomyślnie wywołany. Klucze zdarzeń są Nazwa imię i nazwisko, jeśli
wydarzenie i czas: data wydarzeń.

· awaria_haka: hak zawiódł. Klucze zdarzeń są Nazwa nazwa, jeśli wydarzenie, czas:
daty wydarzeń i błąd: wyjątek, który wystąpił w zdarzeniu, jeśli taki istnieje.

Dodawanie nowa Polecenia
Staraliśmy się maksymalnie uprościć dodawanie nowych poleceń.

Musisz zrobić trzy rzeczy:

1. stworzyć twoje_polecenie.py plik w ramach cyrk/komendy/.

2. Zaimplementuj tam pojedynczą klasę z predefiniowanymi metodami

3. Dodaj nowe polecenie circus/commands/__init__.py.

Powiedzmy, że chcemy dodać polecenie, które zwróci liczbę aktualnie używanych obserwatorów,
zrobilibyśmy coś takiego (obszernie komentowane, abyś mógł śledzić więcej
łatwo):

z circus.commands.base Polecenie importu
z circus.exc import ArgumentError, MessageError
klasa NumWatchers (polecenie):
"""Dobrą praktyką jest opisanie, co klasa robi w tym miejscu.

Przyjrzyj się innym poleceniom, aby zobaczyć, jak jesteśmy przyzwyczajeni do formatowania
ten tekst. Zostanie on automatycznie uwzględniony w dokumentacji,
więc nie bój się być wyczerpujący, tak to jest
dla.
"" "
# wszystkie polecenia dziedziczą z `circus.commands.base.Command`

# musisz podać nazwę, abyśmy mogli jakoś znaleźć polecenie
imię = "numwatchers"

# Ustaw oczekiwanie na Prawda lub Fałsz, aby zdefiniować domyślne zachowanie
# — Jeśli oczekiwanie ma wartość True, polecenie jest uruchamiane synchronicznie i klient może otrzymać
# wyniki wstecz.
# — Jeśli oczekiwanie ma wartość Fałsz, polecenie jest natychmiast uruchamiane asynchronicznie na serwerze i kliencie
# otrzymuje odpowiedź „OK”.
#
# Domyślnie polecenia są ustawione na oczekiwanie = False
czekanie = Prawda

# opcje
opcje = [('', 'nazwa opcji', wartość_domyślna, 'opis')]

właściwości = ['foo', 'bar']
# właściwości wyświetla listę argumentów poleceń, które są obowiązkowe. Jeśli są
# nie podano, zostanie zgłoszony błąd

def wykonaj(ja, arbiter, rekwizyty):
# metoda wykonania jest rdzeniem polecenia: umieść tutaj wszystkie
# logika polecenia i zwróć dyktando zawierające wartości, które Ty
# chcę wrócić, jeśli taki istnieje
return {"numwatchers": arbiter.numwatchers()}

def console_msg(ja, wiadomość):
# msg to wartość zwracana przez metodę wykonywania.
# ta metoda służy do formatowania odpowiedzi dla konsoli (tj
# używany na przykład przez circusctl do drukowania wiadomości)
zwróć „ciąg znaków, który zostanie wyświetlony”

def wiadomość(self, *args, **opts):
# wiadomość obsługuje dane wejściowe konsoli.
# ta metoda służy do mapowania argumentów konsoli na polecenie
# opcje. (jest używany na przykład podczas wywoływania polecenia poprzez
# cyrktl)
# NotImplementedError zostanie zgłoszony, jeśli brakuje funkcji
liczbaArgs = 1
jeśli nie len(args) == numArgs:
raise ArgumentError('Nieprawidłowa liczba argumentów.')
jeszcze:
opcje['nazwaopcji'] = argumenty[0]
zwróć self.make_message(**opcje)

def validate(self, rekwizyty):
# ta metoda służy do sprawdzenia, czy argumenty przekazane do
# polecenie jest poprawne. Na wszelki wypadek należy zgłosić ArgumentError
# w przekazanych argumentach wystąpił błąd (na przykład, jeśli one
# nie pasują do siebie.
# W przypadku problemu z zawartością zostanie wyświetlony komunikat MessageError
# należy wyrzucić. Ta metoda może modyfikować zawartość rekwizytów
# dyktat, zostanie on później przekazany do wykonania.

Zastosowanie Etui przykłady
W tym rozdziale przedstawiono kilka przypadków użycia, które mają dać ci wyobrażenie o tym, jak używać Circus w swoim
środowisko.

Bieganie a WSGI aplikacja
Uruchamianie aplikacji WSGI w Circus jest dość interesujące, ponieważ możesz oglądać i zarządzać
Twój sieć pracowników za pomocą szczyt cyrku, okrężny lub interfejs sieciowy.

Jest to możliwe dzięki zastosowaniu gniazd Circus. Zobacz dlaczegocircussockets.

Weźmy przykład z minimum Piramida Aplikacja:

z konfiguratora importu piramidy.config
from pyramid.response importuj odpowiedź

def hello_world(żądanie):
return Response('Witajcie %(imię)!' % request.matchdict)

config = Konfigurator()
config.add_route('witaj', '/witaj/{nazwa}')
config.add_view(hello_world, Route_name='hello')
aplikacja = config.make_wsgi_app()

Zapisz ten skrypt w pliku aplikacja.py plik, a następnie zainstaluj te projekty:

$ pip zainstaluj Piramidę
$ pip zainstaluj chaussette

Następnie upewnij się, że możesz uruchomić aplikację Pyramid za pomocą pliku skarpetka skrypt konsoli:

Aplikacja $ chaussette.aplikacja
Zastosowanie jest
Serwowanie na serwerze lokalnym: 8080
Za pomocą jako backend

I sprawdź, czy możesz do niego dotrzeć odwiedzając http://localhost:8080/cześć/tarek

Teraz, gdy aplikacja jest już uruchomiona, utwórzmy plik konfiguracyjny Circus:

[cyrk]
check_delay = 5
punkt końcowy = tcp://127.0.0.1:5555
pubsub_endpoint = tcp://127.0.0.1:5556
stats_endpoint = tcp://127.0.0.1:5557

[obserwator:webworker]
cmd = chaussette --fd $(circus.sockets.webapp) aplikacja.aplikacja
use_sockets = Prawda
liczbaprocesów = 3

[gniazdo:aplikacja internetowa]
host = 127.0.0.1
port = 8080

Ten plik mówi Circusowi, aby powiązał gniazdo z portem 8080 i biegnij skarpetka pracownicy na tym
gniazdo - przekazując jego fd.

Zapisz to w serwer.ini i spróbuj uruchomić go za pomocą cyrk

$ circusd serwer.ini
[INFO] Uruchamianie wzorca na pid 8971
[INFO] uruchomiono gniazda
[INFO] rozpoczęło się circusd-stats
[INFO] aplikacja internetowa została uruchomiona
[INFO] Arbiter oczekuje teraz na komendy

Upewnij się, że nadal masz włączoną aplikację http://localhost:8080/cześć/tarek.

Gratulacje ! masz aplikację WSGI obsługującą 3 procesy robocze.

Możesz uruchomić circushttpd lub cli i cieszyć się zarządzaniem cyrkiem.

Bieganie a Django aplikacja
Uruchamianie aplikacji Django odbywa się dokładnie tak samo, jak uruchamianie aplikacji WSGI. Użyj
ŚCIEŻKA PYTONA aby zaimportować katalog, w którym znajduje się projekt, katalog zawierający plik
katalog, w którym znajduje się plik settings.py (w przypadku Django 1.4+ ten katalog zawiera plik Manage.py)
:

[gniazdo:dwebapp]
host = 127.0.0.1
port = 8080

[obserwator:dwebworker]
cmd = chaussette --fd $(circus.sockets.dwebapp) dproject.wsgi.application
use_sockets = Prawda
liczbaprocesów = 2

[env:dwebworker]
PYTHONPATH = /ścieżka/do/rodzica-projektu

Jeśli musisz przejść DJANGO_SETTINGS_MODULE na przykład dla pracownika zaplecza, możesz
przekaż to także przez env opcja konfiguracji:

[obserwator:dbackend]
cmd = /ścieżka/do/skrypt.py
liczbaprocesów=3

[env:dbackend]
PYTHONPATH = /ścieżka/do/rodzica-projektu
DJANGO_SETTINGS_MODULE=dproject.settings

See http://chaussette.readthedocs.org aby dowiedzieć się więcej o chaussette.

Wnętrze Decyzje
Ogólnie architektura
[Obrazek]

Cyrk składa się z głównego procesu zwanego cyrk który zajmuje się uruchamianiem wszystkich
procesy. Każdy proces zarządzany przez Circus jest procesem potomnym cyrk.

Procesy zorganizowane są w grupy tzw obserwatorzy, ZA obserwator jest w zasadzie poleceniem
cyrk działa w twoim systemie i dla każdego polecenia możesz skonfigurować liczbę procesów
chcę biegać.

Pojęcie obserwator jest przydatny, gdy chcesz zarządzać wszystkimi procesami uruchamiającymi
to samo polecenie - na przykład uruchom je ponownie itp.

cyrk wiąże dwa gniazda ZeroMQ:

· REQ/REP - gniazdo służące do sterowania cyrk przy użyciu technologii JSON Polecenia.

· PUB/POD - gniazdo, w którym cyrk publikuje zdarzenia, na przykład rozpoczęcie procesu lub
zatrzymany.

UWAGA:
Pomimo swojej nazwy ZeroMQ nie jest systemem zarządzania kolejkami. Pomyśl o tym jako o
Biblioteka komunikacji międzyprocesowej (IPC).

Inny proces zwany statystyki cyrkowe jest prowadzony przez cyrk gdy opcja jest aktywna.
statystyki cyrkowezadaniem jest publikowanie statystyk użycia procesora/pamięci w dedykowanym pliku PUB/POD
kanał.

Z tego specjalistycznego kanału korzystają m.in szczyt cyrku i cyrk-httpd aby wyświetlić transmisję na żywo
działalności.

szczyt cyrku to skrypt konsolowy, który naśladuje Top aby wyświetlić całe wykorzystanie procesora i pamięci
procesy zarządzane przez Circus.

cyrk-httpd to internetowy interfejs zarządzania, który pozwala na interakcję z Circus. To
wyświetla transmisję na żywo za pomocą gniazd sieciowych i statystyki cyrkowe kanał, ale także pozwolić
współdziałać z cyrk poprzez jego REQ/REP kanał.

Ostatni, ale nie najmniej, okrężny to narzędzie wiersza poleceń, które pozwala prowadzić cyrk poprzez jego
REQ/REP kanał.

Możesz także mieć wtyczki, które subskrybują cyrk's PUB/POD kanał i pozwolić ci wysłać
polecenia do REQ/REP kanał jak okrężny doskonałe.

Bezpieczeństwo
Circus jest zbudowany na bazie biblioteki ZeroMQ i nie zawiera żadnych zabezpieczeń
protokoły. Można jednak uruchomić system Circus na serwerze i skonfigurować do niego tunel SSH
uzyskaj do niego dostęp z innego komputera.

W tej sekcji wyjaśniono, co Circus robi w twoim systemie po uruchomieniu i co kończy
opisujący sposób korzystania z tunelu SSH.

Możesz także przeczytać http://www.zeromq.org/area:FAQ#toc5

TCP porty
Domyślnie Circus otwiera następujące porty TCP na hoście lokalnym:

· 5555 -- port używany do sterowania cyrkiem okrężny

· 5556 -- port używany dla kanału wydawcy/subskrybenta.

· 5557 -- port używany dla kanału statystycznego -- jeśli jest aktywowany.

· 8080 -- port używany przez interfejs WWW -- jeśli jest aktywowany.

Porty te umożliwiają aplikacjom klienckim interakcję z systemem Circus i w zależności od sposobu
Twoja infrastruktura jest zorganizowana, możesz chcieć chronić te porty za pomocą zapór sieciowych or
skonfiguruj Circus do działania przy użyciu IPC porty.

Oto przykład uruchomienia Cyrku przy użyciu wyłącznie punktów wejścia IPC:

[cyrk]
check_delay = 5
punkt końcowy = ipc:///var/circus/punkt końcowy
pubsub_punkt końcowy = ipc:///var/circus/pubsub
stats_endpoint = ipc:///var/circus/stats

W przypadku konfiguracji przy użyciu IPC polecenia muszą być uruchamiane z tego samego okna, ale nikt nie może tego zrobić
uzyskać do nich dostęp z zewnątrz, w przeciwieństwie do protokołu TCP. Polecenia należy również uruchomić jako użytkownik
ma prawo zapisu do ścieżek gniazd ipc. Możesz modyfikować właściciela pliku Punkt końcowy za pomocą
dotychczasowy właściciel_punktu końcowego opcja konfiguracji. Dzięki temu możesz uruchomić circusd jako użytkownik root, ale
Zezwalaj procesom innym niż root na wysyłanie poleceń cyrk. Pamiętaj, że podczas używania właściciel_punktu końcowego,
aby uniemożliwić procesom innym niż root uruchamianie dowolnych procesów
uruchamiany z większymi uprawnieniami, polecenie add wymusi, aby nowi obserwatorzy musieli działać jako
dotychczasowy właściciel_punktu końcowego użytkownik. Definicje obserwatorów w lokalnych plikach konfiguracyjnych nie będą
ograniczone w ten sposób.

Oczywiście, jeśli aktywujesz interfejs WWW, plik 8080 port będzie nadal otwarty.

cyrkhttpd
Kiedy uciekasz cyrkhttpd ręcznie lub podczas korzystania z httpd opcja w pliku ini, np
to:

[cyrk]
check_delay = 5
punkt końcowy = ipc:///var/circus/punkt końcowy
pubsub_punkt końcowy = ipc:///var/circus/pubsub
stats_endpoint = ipc:///var/circus/stats
httpd = 1

Aplikacja internetowa będzie działać na porcie 8080 i umożliwi każdemu dostęp do strony internetowej
zarządzać cyrk demon.

Obejmuje to tworzenie nowych obserwatorów, którzy mogą uruchamiać dowolne polecenia w twoim systemie!

Do nie robić it publicznie dostępny

Jeśli chcesz zabezpieczyć dostęp do panelu WWW, możesz obsłużyć go za Nginxem lub
Apache lub dowolny serwer WWW obsługujący proxy, który może zadbać o bezpieczeństwo.

Użytkownik i Zarządzanie Uprawnienia
Domyślnie wszystkie procesy rozpoczęte w Circus będą uruchamiane z tym samym użytkownikiem i grupą
as cyrk. W zależności od uprawnień użytkownika w systemie, Ty możesz ich nie mieć
dostęp do wszystkich funkcji oferowanych przez Circus.

Na przykład niektóre funkcje statystyczne dotyczące uruchomionych procesów wymagają rozszerzonych uprawnień.
Zazwyczaj, jeśli numery wykorzystania procesora otrzymujesz za pomocą statystyki polecenie są N / A, to znaczy twój
użytkownik nie może uzyskać dostępu do plików proc. Tak będzie domyślnie w systemie Mac OS X.

Możesz uciekać cyrk jako root, aby to naprawić, i ustaw plik uid i kołowacizna wartości dla każdego obserwatora
aby uzyskać wszystkie funkcje.

Ale uważaj na bieganie cyrk ponieważ root naraża Cię na potencjalną eskalację uprawnień
błędy. Chociaż robimy co w naszej mocy, aby uniknąć jakichkolwiek błędów, działając jako root i napotykając błąd, który
wykonuje niepożądane działania w systemie, może być niebezpieczne.

Najlepszym sposobem, aby temu zapobiec, jest upewnienie się, że system, na którym działa Circus, jest całkowicie uszkodzony
izolowany (jak maszyna wirtualna) or aby uruchomić cały system pod kontrolą użytkownika.

SSH tunelowanie
Klienci mogą łączyć się z cyrk instancję, tworząc tunel SSH. Aby to zrobić, przekaż
opcja wiersza poleceń --ssz następnie użytkownik@adres, Gdzie użytkownik jest użytkownikiem na pilocie
serwer i adres to adres serwera widziany przez klienta. Protokół SSH będzie
wymagają danych uwierzytelniających, aby dokończyć logowanie.

If cyrk jak widzi serwer SSH, nie znajduje się on pod domyślnym adresem punktu końcowego localhost: 5555
następnie określ cyrk adres za pomocą opcji --punkt końcowy

zabezpieczone ustawienie przykład
Konfigurowanie zabezpieczonego serwera Circus można wykonać poprzez:

· Uruchamianie serwera SSH

· Uruchamianie Apache lub Nginx na komputerze 80 portu i wykonać odwrotne proxy na 8080 Port.

· Blokowanie 8080 portu z dostępem z zewnątrz.

· Uruchamianie wszystkich portów ZMQ Circusd przy użyciu plików IPC zamiast portów TCP i tunelowanie wszystkich
połączenia przez SSH.
[Obrazek]

Przyczyniając do Cyrk
Cyrk powstał w Mozilli, ale jego celem nie jest pozostanie tylko w Mozilli. Próbujemy
zbudować narzędzie, które będzie przydatne dla innych i łatwe do rozbudowy.

Jesteśmy naprawdę otwarci na każdy wkład w postaci kodu, dokumentacji, dyskusji,
propozycja funkcji itp.

Możesz rozpocząć temat na naszej liście mailingowej: http://tech.groups.yahoo.com/group/circus-dev/

Lub dodaj problem w naszym pluskwa naganiacz zwierza

Ustalenie literówek i wzmocnienie dotychczasowy dokumentacja
Jest całkowicie możliwe, że podczas czytania tego półangielskiego tekstu krwawią Ci oczy
półfrancuskiej dokumentacji, nie wahaj się wnieść żadnego przeformułowania/ulepszenia
formularz w dokumentacji. Prawdopodobnie nie musisz nawet rozumieć, jak działa Circus
pod maską, aby to zrobić.

Dodawanie nowa cechy
Nowe funkcje są oczywiście bardzo mile widziane. Jeśli masz potrzebę i czas
pracuj nad nowymi funkcjami, dodanie ich do Circus nie powinno być aż tak skomplikowane. Bardzo się staraliśmy
trudno mieć czysty i zrozumiały interfejs API, mam nadzieję, że spełni on swój cel.

Będziesz musiał dodać dokumentację i testy wraz z kodem nowej funkcji.
W przeciwnym razie nie będziemy mogli zaakceptować łatki.

W jaki sposób do Zatwierdź Twój zmiany
Używamy git jako DVCS. Najlepszym sposobem zaproponowania zmian jest utworzenie oddziału na Twoim
strona (przez odrzutowiec checkout -b Nazwa oddziału) i tam zatwierdź zmiany. Kiedy już to zrobisz
coś gotowego do premiery, wyślij żądanie ściągnięcia dla tej gałęzi.

Postępujemy zgodnie z tym modelem, aby zapewnić niskie sprzężenie między cechami, którymi jesteś
proponowanie. Na przykład możemy zaakceptować jedno żądanie ściągnięcia, będąc jeszcze w trakcie dyskusji
dla innego.

Zanim zaproponujesz zmiany, sprawdź dokładnie, czy niczego nie psują! Możesz
użyć tox aby to zapewnić, uruchomi zestaw testów w ramach pliku Different
obsługiwane wersje Pythona.

Proszę użyć : http://issue2pr.herokuapp.com/ aby odwołać się do zatwierdzenia istniejącego cyrku
problem, jeśli taki istnieje.

unikanie łączyć popełnia
Unikanie zatwierdzeń scalających pozwala mieć czystą i czytelną historię. Aby to zrobić, zamiast
wykonując „git pull” i pozwalając gitowi zajmować się scalaniem za ciebie, używając git pull --rebase will
wstaw swoje zmiany po zmianach wprowadzonych w gałęzi lub podczas pracy nad nimi
mistrz.

Oznacza to, że dla nas, głównych programistów, nie jest już możliwe korzystanie z poręcznego githuba green
przycisk na żądaniach ściągnięcia, jeśli programiści sami nie zmienili swojej pracy lub jeśli zaczekamy
zbyt dużo czasu między żądaniem a faktycznym połączeniem. Zamiast tego przepływ wygląda następująco:

git remote dodaj nazwę repo-url
git pobierz nazwę
git Checkout Feature-branch
git, mistrz rebase

# sprawdź, czy wszystko działa poprawnie, a następnie połącz na serwerze głównym
git checkout master
git merge gałąź funkcji

omawiając
Jeśli podczas przeglądania kodu Cyrku okaże się, że potrzebujesz pomocy, możesz iść
i znajdź nas na irc o godz #namiot cyrkowy on irc.freenode.org (lub jeśli nie masz żadnego IRC
klient, użyj dotychczasowy internetowy czat)

Możesz także rozpocząć wątek na naszej liście mailingowej -
http://tech.groups.yahoo.com/group/circus-dev

Często Spytał pytania
Oto lista najczęściej zadawanych pytań na temat cyrku:

W jaki sposób robi Cyrk stos porównać do a klasyczny stos?
W klasycznym stosie WSGI masz serwer taki jak Gunicorn, który obsługuje port lub
unix i zwykle jest wdrażany za serwerem WWW, takim jak Nginx: [image]

Klienci dzwonią do Nginx, który odwraca wszystkie połączenia proxy do Gunicorn.

Jeśli chcesz mieć pewność, że proces Gunicorn będzie działał prawidłowo, musisz użyć pliku
program taki jak Supervisord lub początkujący.

Gunicorn z kolei obserwuje swoje procesy („pracownicy”).

Innymi słowy, używasz dwóch poziomów zarządzania procesami. Taki, którym zarządzasz i
kontrola (nadzorca) i druga, którą musisz zarządzać w innym interfejsie użytkownika, za pomocą a
inna filozofia i mniejsza kontrola nad tym, co się dzieje (serwer wsgi)

Dotyczy to Gunicorn i większości wieloprocesowych serwerów WSGI, o których wiem.
uWsgi jest nieco inny, ponieważ oferuje mnóstwo opcji.

Ale jeśli chcesz dodać serwer Redis do swojego stosu, ty będzie skończ z zarządzaniem swoimi
stosuj procesy w dwóch różnych miejscach.

Podejście cyrku w tym przypadku polega na zarządzaniu procesami i gniazda.

Stos cyrku może wyglądać tak: [image]

Tak więc, podobnie jak Gunicorn, Circus jest w stanie powiązać gniazdo, które będzie proxy przez Nginx. Cyrk
nie zajmuj się żądaniami, ale po prostu wiąże gniazdo. Następnie wszystko zależy od pracownika internetowego
proces akceptowania połączeń w gnieździe i wykonywania pracy.

Zapewnia równoważne funkcje niż Supervisord, ale pozwala także zarządzać wszystkim
procesy na tym samym poziomie, niezależnie od tego, czy są to pracownicy sieciowi, Redis czy cokolwiek innego. Dodanie a
nowy proces sieciowy odbywa się dokładnie tak, jak dodanie nowego procesu Redis.

Ławki
Zrobiliśmy kilka ławek, aby porównać Circus & Chaussette z Gunicorn. Podsumowując, Cyrk jest
nie dodając żadnych kosztów ogólnych i możesz wybrać wiele różnych backendów dla swoich pracowników sieciowych.

Zobacz:

· http://blog.ziade.org/2012/06/28/wgsi-web-servers-bench

· http://blog.ziade.org/2012/07/03/wsgi-web-servers-bench-part-2

W jaki sposób do rozwiązywania Cyrk?
Domyślnie cyrk utrzymuje swoje logowanie stdout raczej rzadkie. Ten brak wydajności może
utrudniają rozwiązywanie problemów, gdy procesy wydają się mieć problemy z uruchomieniem.

Aby zwiększyć rejestrowanie cyrk zapewnia, spróbuj zwiększyć poziom rejestrowania. Aby zobaczyć
dostępne poziomy dziennika po prostu użyj --help flag.

$ circus --log-level debugowania test.ini

Jedno słowo ostrzeżenia. Jeśli proces trzepocze i poziom dziennika debugowania jest włączony, ty
wyświetli komunikaty przy każdej próbie uruchomienia. Pomocne może być skonfigurowanie aplikacji
trzepotanie, aby użyć a rozgrzewka_opóźnienie aby spowolnić wiadomości do rozsądnego tempa.

[obserwator:aplikacja internetowa]
cmd = python -m mojaaplikacja.wsgi
opóźnienie_rozgrzewki = 5

Domyślnie stdout i stderr są schwytane przez cyrk proces. Jeśli testujesz swój
config i chcesz zobaczyć wyjście zgodne z wyjściem circusd, możesz skonfigurować swój
obserwator, aby użyć Strumień stdout class.

[obserwator:aplikacja internetowa]
cmd = python -m mojaaplikacja.wsgi
stdout_stream.class = StdoutStream
stderr_stream.class = StdoutStream

Jeśli aplikacja generuje komunikat zwrotny lub błąd podczas próby uruchomienia
powinien być w stanie zobaczyć to na wyjściu.

Lista zmian historia
0.12.1 - 2015-08-05
· Napraw błąd podczas ponownego uruchamiania obserwatora ze strumieniem wyjściowym - #913

· Drobne poprawki w dokumencie

0.12 - 2015-06-02
To wydanie zawiera między innymi obsługę Pythona 3.4, Tornado 4 i Windows
funkcje i poprawki.

Obsługa systemu Windows jest nadal eksperymentalna i nie obsługuje strumieni.

Główne zmiany:

· Zgodność z Pythonem 3.4 - #768

· Eksperymentalna obsługa systemu Windows - #788

· Kompatybilność z Tornado 4 - #872

· Zmodernizowane opakowanie Debiana - #896 - #903

· Dodano obsługę jądra procesu Papa - #850

· Dodaj dopasowanie globowania i wyrażeń regularnych do uruchamiania, zatrzymywania i ponownego uruchamiania obserwatorów - #829 -
#902

Więcej zmian:

· Optymalizacja wyłączenia - #784 - #842

· Dodano możliwość określenia wersji virtualenv dla obserwatorów - #805

· Dodaj opcję --nostop do polecenia rmwatcher - #777

· Dodaj wywołanie zwrotne do Arbiter.start - #840

· Naprawiono przeładowywanie obserwatorów wielkimi literami - #823

· Usuń nieszczelne gniazdo w demonie statystyk - #843

· Napraw multicast w SunOS - #876

· Zamknij strumienie wyjściowe podczas zatrzymywania obserwatora - #885

· Napraw wysyłanie sygnału do wnuków za pomocą opcji --recursive - #888

0.11.1 - 2014-05-22
· Naprawiono regresję, która zepsuła Circus w wersji 2.6 - #782

0.11 - 2014-05-21
To wydanie nie wprowadza wielu funkcji i koncentruje się na udoskonalaniu Circus
solidny i stabilny.

Główne zmiany/poprawki:

· Upewnij się, że nie możemy wykonać na arbitrze dwóch sprzecznych poleceń jednocześnie.

· mamy 2 nowe klasy streamów: TimedRotatingFileStream, WatchedFileStream

· mamy jeden nowy hak: hak after_spawn

· CircusPlugin jest łatwiejszy w użyciu

· napraw autostart=fałszywi obserwatorzy podczas startu (regresja)

Więcej zmian:

· Wiadomości cyrkowe mogą być teraz kierowane do sysloga - #748

· Dodano opcję endpoint_owner, dzięki której możemy zdefiniować, który użytkownik jest właścicielem plików gniazd ipc utworzonych przez
cyrk.

· Rozpoczęto obsługę systemu Windows (na razie tylko około)

· Naprawiono wiele nieszczelności w testach

· Zezwalaj na rozróżnianie wielkości liter w zmiennych środowiskowych

· Wtyczka zasobów akceptuje teraz bezwzględne wartości pamięci - #609

· Dodano obsługę polecenia dodawania dla opcji „singleton” – #767

· Zezwalaj na wysyłanie dowolnych sygnałów do procesów podrzędnych poprzez obserwatora zasobów - #756

· Zezwól na konfigurację INI/JSON/YAML do logowania

· Upewnij się, że jesteśmy kompatybilni z psutil 2.x i 3.x

· Dodano więcej wskaźników do dostawcy statystyk – #698

· Naprawiono wykrywanie multiemisji – #731

· Spraw, aby uruchamianie, ponowne uruchamianie i ładowanie były bardziej jednolite – #673

· Prawidłowo zainicjuj wszystkie grupy użytkowe - #635

· poprawiona stabilność testów

· wiele, wiele innych rzeczy....

0.10 - 2013-11-04
Główne zmiany:

· Teraz kompatybilny z Pythonem 3.2 i 3.3 - #586

· Przeniesiono rdzeń do modelu w pełni asynchronicznego – #569

· Ulepszona dokumentacja - #622

Więcej zmian:

· Dodano stop_signal i stop_children - #594

· Upewnij się, że wtyczka watchdog zamyka gniazda - #588

· Przełączono na parser ZMQ JSON

· IN nie jest obsługiwany na wszystkich platformach – #573

· Zezwalaj na globalne podstawienia środowiska w dowolnej sekcji konfiguracji - #560

· Zezwalaj na myślniki w nazwach sekcji - #546

· Teraz zmienne są rozwinięte w całej konfiguracji - #554

· Dodano wtyczkę CommandReloader

· Dodano zaczepy before_signal i after_signal

· Zezwalaj na ponawianie wtyczek w nieskończoność

· Nie odradzaj proców, gdy obserwator się zatrzymuje - #529 - #536

· Dodano unikalny identyfikator dla każdej wiadomości klienta - #517

· identyfikatory pracowników są teraz „slotami” -

· Naprawiono płynne zachowanie podczas zamykania - #515

· Upewnij się, że możemy dodawać obserwatorów, nawet jeśli arbiter nie jest uruchomiony - #503

· Upewnij się, że uruchomiliśmy wygasły proces - #510

· Upewnij się, że polecenie set może ustawić kilka zaczepów

· Prawidłowa obsługa gniazd IPv6 - #507

· Zezwalaj na niestandardowe opcje dla stdout_stream i stderr_stream – #495

· Dodano format czasu dla FileStream - #493

· Dodano nową opcję konfiguracji gniazda, umożliwiającą powiązanie z określonym interfejsem według nazwy

0.9.3 - 2013-09-04
· Upewnij się, że możemy dodawać obserwatorów, nawet jeśli arbiter nie jest uruchomiony

· Upewnij się, że uruchomiliśmy wygasły proces

· Upewnij się, że polecenie set umożliwia ustawienie jednego lub kilku zaczepów

· Prawidłowa obsługa gniazd IPv6 i ulepszeń CircusSockets

· Podaj domyślną wartość ścieżki, aby zapobiec błędowi UnboundLocalError

· Dodano test na istnienie punktu końcowego multicast_end podczas inicjalizacji kontrolera

· Nie konwertuje już każdego ciągu cyfr na inty

· Dodaj testy

· Nie ma potrzeby stosowania specjalnych przypadków podczas konwersji opcji stdout_stream

· Zaakceptuj także umask jako argument za spójnością

· Zezwalaj na niestandardowe opcje dla stdout_stream i stderr_stream.

· Dodano nową opcję konfiguracji gniazda, aby powiązać się z określonym interfejsem według nazwy

· Dodaj time_format dla FileStream + testy

· Zaktualizuj circus.upstart

0.9.2 - 2013-07-17
· Gdy w pliku konfiguracyjnym zdefiniowana jest ścieżka PYTHONPATH, jest ona ładowana do sys.path, dzięki czemu można
znajdujące się tam - #477, #481

· Użyj pojedynczego argumentu dla add_callback, aby działało z PyZMQ < 13.1.x - patrz #478

0.9 - 2013-07-16
· dodano [env] sekcje symboli wieloznacznych

· dodano sekcję globalną [env].

· naprawiono ukryty wyjątek, gdy circus-web nie jest zainstalowany - #424

· upewnij się, że polecenia incr/decr rzeczywiście korzystają z opcji nb - #421

· Napraw pakiety witryn virtualenv obserwatora poza PYTHONPATH

· upewnij się, że nie próbujemy usunąć więcej procesów niż 0 - #429

· zaktualizowano plik bootstrap.py - #436

· naprawiono separator wieloplatformowy w pythonpath virtualenv watcher

· przebudowana funkcja zamykania gniazda

· Upewnij się, że sekcje env są stosowane do wszystkich obserwatorów – #437

· dodano polecenie reloadconfig

· dodano circus.green i usunięto event z rdzenia - #441, #452

· wyciszono fałszywe standardowe wyjścia i ostrzeżenia w testach – #438

· $(circus.env.*) może być teraz używany dla wszystkich opcji w konfiguracji

· dodano hak before_spawn

· popraw ścieżkę circusd w pliku usługi systemowej - #450

· upewnij się, że możemy zmieniać zaczepy i ustawiać strumienie poprzez CLI - #455

· poprawiony dok

· dodano statystykę spawn_count w obserwatorze

· dodano parametry min_cpu i min_mem we wtyczce ResourceWatcher

· dodano informację FQDN do arbitra.

0.8.1 - 2013-05-28
· circusd-stats dławił się na gniazdach uniksowych - #415

· Procesy potomne circusd-stats i circushttpd stdout/stderr są teraz domyślnie otwarte.
Python <= 2.7.5 zadławiłby moduł logowania w przypadku zamknięcia 2/3 fds - #415

· Teraz przekierowuje do /dev/null w procesie potomnym zamiast zamykać. #417

0.8 - 2013-05-24
· Zintegrowane procedury obsługi logów w pętli zmq io.

· Spraw, aby readresator działał ponownie, a co za tym idzie, był bardziej niezawodny.

· Używa zmq.green.eventloop w przypadku wykrycia zdarzenia

· Dodano obsługę zmiennej środowiskowej CIRCUSCTL_ENDPOINT do circusctl - #396

· util: napraw błąd w funkcji to_uid - #397

· Usuń moduł obsługi w przypadku błędu ioloop - #398.

· Lepszy zasięg testów

· Wycofano opcję „usługi” dla wtyczki ResourceWatcher – #404

· usunięto użycie psutil.error

· Dodano wykrywanie UDP w cyrku - #407

· Teraz zezwalamy na globy na dowolnych poziomach katalogów – #388

· Dodano opcję konfiguracyjną „statd” – #408

· Dodaj opcję pidfile, logoutput i loglevel do pliku konfiguracyjnego cyrku - #379

· Dodano samouczek w dokumentacji.

· upewnij się, że łączymy wszystkie sekcje, gdy używamy opcji include - #414

· dodano opcje pipe_stdout, pipe_stderr, close_child_stderr i close_child_stdout do
Klasa procesu

· dodano opcje Close_child_stderr i Close_child_stdout do obserwatora

0.7.1 - 2013-05-02
· Naprawiono opcję odradzania się - #382

· Upewnij się, że użyliśmy inta jako limitu czasu - #380

· wyświetl także gniazda unixowe - #381

· Upewnij się, że działa z najnowszą wersją pyzmq

· wprowadzono drugą składnię notacji fd

0.7 - 2013-04-08
· Napraw przykład get_arbiter, aby używać dykta jako argumentu obserwatorów. #304

· Dodaj dokumentację dotyczącą rozwiązywania problemów #323

· Dodano obsługę budowania Pythona

· Usunięto gevent i przekierowania wątków. teraz korzystam z ioloop — poprawka #346.
Dotyczy #340

· circus.web jest teraz własnym projektem

· usunięto łatkę pyzmq

· Zezwól na skonfigurowanie obserwatora, ale nie na jego uruchomienie #283

· Dodaj opcję ładowania katalogu witryny virtualenv

· dodano obserwatorów na żądanie

· dodano dokument o nginx+websockets #371

· Teraz poprawnie analizuję listę opcji każdego polecenia #369

· Naprawiono obsługę zdarzeń circusd-stats #372

· naprawiono problem przepełnienia w cyrku #378

· wiele innych rzeczy...

0.6 - 2012-12-18
· Nazwa protokołów łatania dla gniazd - #248

· Nie autoskaluj wykresów. #240

· circusctl: dodaj pomoc do każdego polecenia, z dokumentacji #217

· Dodano haki pracowników

· Dodano pakiet Debiana - #227

· Dodano Redis, obserwatora HTTP, pełne statystyki i wtyczki zasobów

· Teraz procesy mogą mieć tytuły

· Dodano autouzupełnianie

· Dodano wiek procesu/obserwatora w webui

· Dodano obsługę tunelu SSH

· Teraz używasz pyzmq.green

· Dodano nowy skrypt i dokument Varnish

· Dodano zmienne środowiskowe i sekcje

· Dodano obsługę gniazd unixowych

· Dodano respawn możliwość posiadania pojedynczych obserwatorów

· Teraz używamy toxu w testach

· Zezwalaj na podstawienie gniazd w argumentach

· Nowy motyw dokumentu

· Nowe opcje rotacji strumieni: max_bytes/backup_count

0.5.2 - 2012-07-26
· Teraz łatamy moduł wątków z biblioteki stdlib, aby uniknąć błędów w Pythonie - #203

· Lepiej wyglądający ekran pomocy circusctl

· używa pustil get_nice(), jeśli jest dostępna (nice było przestarzałe) - #208

· dodano obsługę max_age - #221

· Wywołuj funkcję Listen() tylko na gniazdach SOCK_STREAM lub SOCK_SEQPACKET

· upewnij się, że kontroler opróżnia listę wtyczek w update_watchers() - #220

· dodano --log-level i --log-output do circushttpd

· Napraw zabijanie procesu poprzez interfejs WWW - #219

· teraz circus jest kompatybilny ze skryptami zc.buildout.

· wyczyść websocket po rozłączeniu klienta - #225

· naprawiono domyślną wartość punktu końcowego - #199

· podzielony circushttpd na moduły logiczne

0.5.1 - 2012-07-11
· Naprawiono kilka literówek w dokumentacji

· Dodano opcję debugowania

· Prawidłowo spakuj plik web-requirements.txt

· Do wiadomości dodano kod błędu errno – poprawka nr 111

0.5 - 2012-07-06
· dodano obsługę gniazd

· dodano polecenie listsocket

· Gniazda też mają statystyki!

· naprawiono wiele małych błędów

· usunięto wid - teraz wszędzie używa się pid

· szybsze testy

· zmieniono składnię zmiennych

· używaj ioloop pyzmqa w większej liczbie miejsc

· teraz używam iowait dla wszystkich wywołań funkcji Select().

· Polecenia incr/decr mają teraz parametr nbprocess

· Dodaj opcję reprodukcji_env dla obserwatorów

· Dodaj do procesów nowy status NIEISTNIEJĄCY

· Dodano globalny httpd możliwość uruchomienia circushttpd jako obserwator

0.4 - 2012-06-12
· Dodano system wtyczek

· Dodano opcję „singleton” dla obserwatorów

· Naprawiono migotanie ekranu w cyrku

· Usunięto wątki z circus.stats na rzecz okresowych wywołań zwrotnych zmq

· Udoskonalono dokumentację

· Klient Circus ma teraz API send_message

· Funkcja trzepotania jest teraz wtyczką

· Każde narzędzie wiersza poleceń posiada opcję --version

· Dodano wtyczkę statsd (wysyła wydarzenia z cyrku do statsd)

· Interfejs sieciowy korzysta teraz z gniazd sieciowych (poprzez Socketio) w celu uzyskania statystyk

· Interfejs sieciowy wykorzystuje teraz sesje dla „wiadomości flash” w interfejsie sieciowym

0.3.4 - 2012-05-30
· Naprawiono sytuację wyścigu, która uniemożliwiała kontrolerowi czyste zebranie ukończonych procesów.

· Teraz w konfiguracji można kontrolować check_flapping. I aktywowane/dezaktywowane
na obserwatora.

0.3.3 - 2012-05-29
· Naprawiono regresję w obsłudze interfejsu użytkownika

0.3.2 - 2012-05-24
· umożliwia opcjonalną właściwość args poleceniu add_watcher.

· dodano circushttpd, circus-top i circusd-stats

· zezwolenie Arbiter.add_watcher() na ustawienie wszystkich opcji Obserwatora

· Upewnij się, że przekierowania są tworzone ponownie przy ponownym uruchomieniu

0.3.1 - 2012-04-18
· poprawka: upewnij się, że ustawienia domyślne obserwatora nie zostały zastąpione

· dodano klasę StdoutStream.

0.3 - 2012-04-18
· dodano funkcję przesyłania strumieniowego

· teraz wyświetla zasięg w dokumencie Sphinx

· naprawiono sposób zabijania procesów (koniec z SIGQUIT)

· konfiguracja została uwzględniona

· Ustaw wsparcie dla tytułu

0.2 - 2012-04-04
· Usunięto pokazać nazwa. zastąpione przez obserwator.

· Dodano wsparcie dla procesu ustawiania limit.

· Dodano obsługę dołączania katalogów do pliku konfiguracyjnego.

· Naprawiono kilka nieszczelnych deskryptorów plików.

· Naprawiono zrzut rdzenia w trzepotaniu

· Ulepszenia dokumentu

· Upewnij się, że błędy circusd są prawidłowe, gdy inny circusd działa na tym samym gnieździe.

· get_arbiter akceptuje teraz kilku obserwatorów.

· Naprawiono cmd vs args vs plik wykonywalny w init procesu.

· Naprawiono --start na circusctl add

0.1 - 2012-03-20
· Pierwsze wydanie

mężczyzna stron
cyrk mężczyzna strona
streszczenie
circusd [opcje] [konfiguracja]

Opis
circusd jest głównym procesem architektury cyrkowej. Zajmuje się obsługą wszystkich
procesy. Każdy proces zarządzany przez Circus jest procesem potomnym cyrk.

Argumenty
config Plik konfiguracyjny

Opcje
-H, --help
Pokaż komunikat pomocy i wyjdź

--poziom-logarytmowania POZIOM
Określ poziom dziennika. POZIOM może być Informacje, debug, krytyczny, ostrzeżenie or błąd.

--log-wyjście WYLOGOWANIE
Lokalizacja, w której będą zapisywane dzienniki. Domyślnym zachowaniem jest zapis do
stdout (możesz to wymusić, przekazując „-” do tej opcji). Przyjmuje nazwę pliku
Inaczej.

--logger-config KONFIG.LOGGERA
Lokalizacja, w której znajduje się standardowy plik konfiguracyjny rejestratora Pythona INI, JSON lub YAML
może być znaleziony. Można tego użyć do zastąpienia domyślnej konfiguracji rejestrowania dla
arbiter.

--demon
Rozpocznij cyrk w tle.

--pidplik PLIK PID
Lokalizacja pliku PID.

--wersja
Wyświetla wersję Circus i wychodzi.

See również
cyrk (1) okrężny (1) statystyki cyrkowe (1) wtyczka cyrkowa (1) szczyt cyrku (1).

Pełna dokumentacja dostępna jest pod adresem http://circus.readthedocs.org

okrężny mężczyzna strona
streszczenie
circusctl [opcje] polecenie [argumenty]

Opis
circusctl to interfejs do sterowania demonem Circus. Ma na celu pomóc
administrator kontroluje funkcjonowanie Circud cyrk demon.

Polecenia
Dodaj Dodaj obserwatora

dekret Zmniejsz liczbę procesów w obserwatorze

statystyki Uzyskaj statystyki cyrku

otrzymać Uzyskaj wartość określonych opcji obserwatora

opcje globalne
Uzyskaj opcje arbitra

przyrost Zwiększ liczbę procesów w obserwatorze

pyton
Utwórz powłokę w procesie circusd

podstęp Uzyskaj listę obserwatorów lub procesów w obserwatorze

słuchać Zapisz się na wydarzenie obserwatora

listy gniazd
Pobierz listę gniazd

liczba procesów
Uzyskaj liczbę procesów

numwatcherzy
Uzyskaj liczbę obserwatorów

Opcje
Uzyskaj wartość wszystkich opcji dla obserwatora

porzucić Odejdź natychmiast od arbitra

przeładować Przeładuj arbitra lub obserwatora

przeładuj konfigurację
Załaduj ponownie plik konfiguracyjny

restart
Zrestartuj arbitra lub obserwatora

rm Usuń obserwatora

zestaw Ustaw opcję obserwatora

sygnał Wyślij sygnał

początek Uruchom arbitra lub obserwatora

statystyki Uzyskaj informacje o procesie

status Uzyskaj status obserwatora lub wszystkich obserwatorów

Zatrzymaj się Zatrzymaj obserwatorów

Opcje
--punkt końcowy PUNKT KOŃCOWY
punkt końcowy połączenia

-H, --help
Pokaż komunikat pomocy i wyjdź

--json wyjście do JSON

--upiększać
upiększyć wyjście

--ssz SSH
Serwer SSH w formacie użytkownik@host:port

--ssh_plik_klucza PLIK_KLUCZA SSH
ścieżkę do pliku klucza, aby autoryzować użytkownika

--koniec czasu TIMEOUT
czas połączenia minął

--wersja
Wyświetla wersję Circus i wychodzi.

See Również
cyrk (1) cyrk (1) statystyki cyrkowe (1) wtyczka cyrkowa (1) szczyt cyrku (1).

Pełna dokumentacja dostępna jest pod adresem http://circus.readthedocs.org

wtyczka cyrkowa mężczyzna strona
streszczenie
wtyczka-cyrk [opcje] [wtyczka]

Opis
circus-plugin pozwala na uruchomienie wtyczki z działającego demona Circus.

Argumenty
wtyczka Pełna nazwa klasy wtyczki.

Opcje
--punkt końcowy PUNKT KOŃCOWY
Punkt końcowy połączenia.

--pubsub PUBSUB
Gniazdo pub/sub circusd ZeroMQ, z którym należy się połączyć.

--konfig CONFIG
Plik konfiguracyjny wtyczki.

--opóźnienie sprawdzenia SPRAWDŹ_DELAY
Sprawdź opóźnienie.

--poziom-logarytmowania POZIOM
Określ poziom dziennika. POZIOM może być Informacje, debug, krytyczny, ostrzeżenie or błąd.

--log-wyjście WYLOGOWANIE
Lokalizacja, w której będą zapisywane dzienniki. Domyślnym zachowaniem jest zapis do
stdout (możesz to wymusić, przekazując „-” do tej opcji). Przyjmuje nazwę pliku
Inaczej.

--ssz SSH
Serwer SSH w formacie użytkownik@host:port.

-H, --help
Pokaż komunikat pomocy i wyjdź.

--wersja
Wyświetla wersję Circus i wychodzi.

See również
cyrk (1) cyrk (1) okrężny (1) statystyki cyrkowe (1) szczyt cyrku (1).

Pełna dokumentacja dostępna jest pod adresem http://circus.readthedocs.org

szczyt cyrku mężczyzna strona
streszczenie
cyrk-top [opcje]

Opis
cyrk-top to a Top-podobne do polecenia, aby wyświetlić demona Circus i zarządzane przez niego procesy
cyrk.

Opcje
--punkt końcowy PUNKT KOŃCOWY
Punkt końcowy połączenia.

--ssz SSH
Serwer SSH w formacie użytkownik@host:port.

--przekroczenie limitu czasu procesu PROCES_TIMEOUT
Po tym opóźnieniu braku aktywności proces zostanie usunięty.

-H, --help
Pokaż komunikat pomocy i wyjdź.

--wersja
Wyświetla wersję Circus i wychodzi.

See również
cyrk (1) okrężny (1) cyrk (1) statystyki cyrkowe (1) wtyczka cyrkowa (1).

Pełna dokumentacja dostępna jest pod adresem http://circus.readthedocs.org

statystyki cyrkowe mężczyzna strona
streszczenie
circusd-stats [opcje]

Opis
circusd-stats uruchamia agregator statystyk dla Circus.

Opcje
--punkt końcowy PUNKT KOŃCOWY
Punkt końcowy połączenia.

--pubsub PUBSUB
Gniazdo pub/sub circusd ZeroMQ, z którym należy się połączyć.

--punkt statystyczny PUNKT STATYSTYCZNY
Gniazdo pub/sub ZeroMQ do wysyłania danych.

--poziom-logarytmowania POZIOM
Określ poziom dziennika. POZIOM może być Informacje, debug, krytyczny, ostrzeżenie or błąd.

--log-wyjście WYLOGOWANIE
Lokalizacja, w której będą zapisywane dzienniki. Domyślnym zachowaniem jest zapis do
stdout (możesz to wymusić, przekazując „-” do tej opcji). Przyjmuje nazwę pliku
Inaczej.

--ssz SSH
Serwer SSH w formacie użytkownik@host:port.

-H, --help
Pokaż komunikat pomocy i wyjdź.

--wersja
Wyświetla wersję Circus i wychodzi.

See również
cyrk (1) cyrk (1) okrężny (1) wtyczka cyrkowa (1) szczyt cyrku (1).

Pełna dokumentacja dostępna jest pod adresem http://circus.readthedocs.org

Słownik: Specyficzne dla cyrku REGULAMIN
arbiter
Połączenia arbiter jest odpowiedzialny za zarządzanie wszystkimi obserwatorami w cyrku, zapewniając
wszystkie procesy działają poprawnie.

kontroler
A kontroler zawiera zestaw akcji, które można wykonać na arbitrze.

trzepotanie
Połączenia trzepotanie wykrywanie subskrybuje zdarzenia i wykrywa, kiedy niektóre procesy są
ciągłe uruchamianie ponownie.

pub/sub
Cyrk ma pubsub który odbiera zdarzenia od obserwatorów i wysyła je do
wszystkich abonentów.

zdalny kontroler
Połączenia zdalny kontroler umożliwia komunikację ze sterownikiem poprzez ZMQ do
kontrolować cyrk.

obserwator, obserwatorzy
A obserwator to program, który każesz uruchomić Circusowi. Może działać pojedyncza instancja Circus
jednego lub więcej obserwatorów.

pracownik, pracownicy, proces, procesów
A wygląda tak jest niezależną instancją procesu systemu operacyjnego Twojego programu. Jeden obserwator
może uruchomić jeden lub więcej procesów. Nazywamy ich również pracownikami.

prawo autorskie
Circus został zainicjowany przez Tarka Ziade i jest dostępny na licencji APLv2

Benoit Chesneau był jednym z pierwszych autorów i zrobił wiele rzeczy, jak większość
Polecenia circus.command działają.

Licencja
Prawa autorskie 2012 - Fundacja Mozilli
Prawa autorskie 2012 - Benoit Chesneau

Licencjonowane na podstawie licencji Apache w wersji 2.0 („Licencja”);
nie możesz używać tego pliku, chyba że jest to zgodne z licencją.
Możesz uzyskać kopię licencji pod adresem

http://www.apache.org/licenses/LICENSE-2.0

O ile nie jest to wymagane przez obowiązujące prawo lub pisemnie uzgodnione, oprogramowanie
dystrybuowane w ramach Licencji jest rozpowszechniane na PODSTAWIE „TAK JAK JEST”,
BEZ ŻADNYCH GWARANCJI LUB WARUNKÓW, wyraźnych lub dorozumianych.
Zobacz licencję, aby zapoznać się z uprawnieniami dotyczącymi konkretnego języka i
ograniczenia wynikające z licencji.

Dostawcy
Zobacz pełną listę na https://github.com/circus-tent/circus/blob/master/CONTRIBUTORS.txt

Korzystaj z cyrku online, korzystając z usług onworks.net