circo - Online na nuvem

PROGRAMA:

NOME

circo - Documentação de circo [imagem]

Circus é um programa Python que pode ser usado para monitorar e controlar processos e sockets.

O Circus pode ser conduzido por meio de uma interface de linha de comando, uma interface da web ou programaticamente
por meio de sua API python.

Para instalá-lo e experimentar seus recursos, verifique os exemplos ou leia o restante desta página
para uma introdução rápida.

CORRENDO A CIRCO DAEMON

Circus fornece uma chamada de script de linha de comando circo que pode ser usado para gerenciar processos
organizado em um ou mais observadores.

A ferramenta de linha de comando Circus é configurável usando um arquivo de configuração no estilo ini.

Aqui está um exemplo mínimo:

[observador: programa]
cmd = python meuprograma.py
numprocessos = 5

[observador: outro programa]
cmd = outro_programa
numprocessos = 2

O arquivo é então passado para circo:

$ circusd exemplo.ini

Além dos processos, o Circus também pode ligar soquetes. Uma vez que todo processo gerenciado pela Circus é
um filho do daemon principal do Circus, o que significa que qualquer programa controlado pelo Circus pode
use esses soquetes.

Executar um soquete é tão simples quanto adicionar um soquete seção no arquivo de configuração:

[socket: mysocket]
host = host local
porta = 8080

Para saber mais sobre sockets, veja sockets.

Para entender por que é um recurso matador, leia por que circussockets.

CONTROLANDO CIRCO

O Circus oferece duas ferramentas de linha de comando para gerenciar o daemon em execução:

· circo, um console de gerenciamento que você pode usar para realizar ações como adicionar ou
removendo trabalhadores

· circo, um console semelhante ao de topo que você pode usar para exibir a memória e o uso da CPU de seu
executando o circo.

Para saber mais sobre isso, consulte cli

O Circus também oferece um painel da web que pode se conectar a um daemon Circus em execução e permitir que você
monitorar e interagir com ele.

Para saber mais sobre esse recurso, consulte circushttpd

O Quê agora ?
Se você é um desenvolvedor e deseja alavancar o Circus em seu próprio projeto, escreva plug-ins ou
ganchos, vá para fordevs.

Se você é um operador e deseja gerenciar seus processos usando o Circus, vá para forops.

Contribuições e Opiniões sobre o curso
Mais sobre como contribuir: contribs.

Links Úteis:

· Existe uma lista de discussão para qualquer feedback ou pergunta:
http://tech.groups.yahoo.com/group/circus-dev/

· O repositório e o rastreador de problemas estão no GitHub: https://github.com/circus-tent/circus

· Junte-se a nós no IRC: Freenode, canal #tenda de circo

Documentação índice
Instalando Circo
Circus é um pacote Python publicado no PyPI - o índice de pacotes Python.

A maneira mais simples de instalá-lo é usar pip, uma ferramenta para instalar e gerenciar Python
pacotes:

$ pip instalar circo

Ou baixe o arquivo on PyPI, extraia e instale-o manualmente com:

$ python setup.py instalação

Se você quiser experimentar o Circus, veja os exemplos.

Se você estiver usando o debian ou qualquer distribuição baseada no debian, você também pode usar o ppa para
instalar circo, é em https://launchpad.net/~roman-imankulov/+archive/circus

zc.buildout
Nós fornecemos um zc.buildout configuração, você pode usá-lo simplesmente executando o bootstrap
script e, em seguida, chamando buildout:

$ python bootstrap.py
$ bin / buildout

Mais on Requisitos
O circo trabalha com:

· Python 2.6, 2.7, 3.2 ou 3.3

·

zeromq >= 2.1.10

· A versão do zeromq suportada é, em última análise, determinada por qual versão do
pyzmq é instalado por pip durante a instalação do circo.

· Sua versão atual oferece suporte às versões 2.x (limitado), 3.x e 4.x ZeroMQ.

· Observação: Se você estiver usando PyPy em vez de CPython, certifique-se de ler seu
A documentação de instalação, pois o suporte à versão ZeroMQ não é o mesmo no PyPy.

Quando você instala o circo, as versões mais recentes das dependências do Python são retiradas
para você.

Você também pode instalá-los manualmente usando o arquivo pip-requirements.txt que fornecemos:

$ pip install -r pip-requirements.txt

Se você deseja executar o console da Web, você precisará instalar circo-teia:

$ pip instalar circus-web

Tutorial
Passo a passo tutorial
O exemplos anuário no repositório Circus contém muitos exemplos para você
iniciado, mas aqui está um tutorial completo que oferece uma visão geral dos recursos.

Vamos supervisionar um aplicativo WSGI.

Instalação
Circus foi testado em Mac OS X e Linux com os Python 2.6, 2.7, 3.2 e 3.3 mais recentes. Para
executar um circo completo, você também precisará libzmq, evento livre & virtualenv.

Em sistemas baseados em Debian:

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

Crie um virtualenv e instale circo, circo-teia e chaussette nisso

$ virtualenv / tmp / circus
$ cd / tmp / circus
$ bin / pip install circus
$ bin / pip instalar circus-web
$ bin / pip install chaussette

Depois de fazer isso, você encontrará uma infinidade de comandos no bin dir local.

Uso
Meia vem com um aplicativo Hello world padrão, tente executá-lo:

$ bin / chaussette

Você deve ser capaz de visitar http://localhost: 8080 e ver Olá mundo.

Pare Chaussette e adicione um arquivo circus.ini no diretório que contém:

[circo]
estatísticasd = 1
httpd = 1

[observador: webapp]
cmd = bin / chaussette --fd $ (circus.sockets.web)
numprocessos = 3
use_sockets = Verdadeiro

[socket: web]
hospedeiro = 127.0.0.1
porta = 9999

Este arquivo de configuração diz ao Circus para ligar um soquete na porta 9999 e executar 3 trabalhadores chaussettes
contra isso. Ele também ativa o painel da web do Circus e o módulo de estatísticas.

Salve-o e execute-o usando circo:

$ bin / circusd --daemon circus.ini

Agora visite http://127.0.0.1: 9999, você deverá ver o aplicativo hello world. A diferença agora é
que o soquete é gerenciado pelo Circus e há vários web workers que estão aceitando
conexões contra ele.

OBSERVAÇÃO:
O balanceamento de carga é operado pelo sistema operacional para que você obtenha a mesma velocidade
como qualquer outro servidor da web pré-bifurcação, como Apache ou NGinx. O circo não interfere com
os dados que passam.

Você também pode visitar http://localhost: 8080 / e aproveite o painel da web do Circus.

Interação
Vamos usar o shell circusctl enquanto o sistema está em execução:

$ bin / circusctl
circusctl 0.7.1
circusd-stats: ativo
circushttpd: ativo
webapp: ativo
(circunstância)

Você entra em um shell interativo. Modelo ajudar para obter todos os comandos:

(circusctl) ajuda

Comandos documentados (digite ajuda ):
========================================
add obter lista numprocessos quit rm start stop
decr globaloptions escutar numwatchers recarregar definir estatísticas
dstats incr listsockets opções reiniciar sinal status

Comandos não documentados:
======================
Ajuda EOF

Vamos tentar coisas básicas. Vamos listar os processos de web workers e adicionar um novo:

(circusctl) listar webapp
13712,13713,13714
(circusctl) incr webapp
4
(circusctl) listar webapp
13712,13713,13714,13973

Parabéns, você interagiu com o seu Circo! Saia do shell com Ctrl + D e agora execute
topo de circo:

$ bin / circus-top

Este é um comando semelhante ao top para observar a memória de todos os seus processos e o uso da CPU em tempo real.

Pressione Ctrl + C e agora vamos sair do Circus completamente via circus-ctl:

$ bin / circusctl quit
ok

Next passos
Você pode conectar seu próprio aplicativo WSGI em vez do hello world de Chaussette simplesmente por
apontando o aplicativo que pode ser chamado.

Chaussette também vem com muitos back-ends, como Gevent ou Meinheld.

Ler https://chaussette.readthedocs.org/ para todas as opções.

Sua marca rede de apoio social I usar Circo em vez disso of X ?
1. Circo simplifica sua web pilha processo de grupos

Circus sabe como gerenciar processos e soquetes, para que você não precise delegar web
gerenciamento de trabalhadores para um servidor WGSI.

Veja por que circussockets

2. Circo fornece pub / sub e pol notificações via ZeroMQ
O Circus tem um canal pub / sub que você pode assinar. Este canal recebe todos os eventos
acontecendo no circo. Por exemplo, você pode ser notificado quando um processo está falhando, ou
construir um cliente que dispara um aviso quando alguns processos estão consumindo toda a CPU ou
RAM.

Esses eventos são enviados por meio de um canal ZeroMQ, o que o torna diferente do stdin
stream Supervisord usa:

· O Circo envia eventos de forma instantânea, então não há necessidade de fazer um loop manualmente
através de todos os ouvintes e manter seus estados.

· Os assinantes podem estar localizados em um host remoto.

O Circus também fornece maneiras de obter atualizações de status por meio de pesquisas únicas em um req / representante
canal. Isso significa que você pode obter suas informações sem ter que se inscrever em um
Stream. O comando cli fornecido pelo Circus usa este canal.

Veja exemplos.

3. Circo is (Pitão) revelador amigável
Enquanto o Circus pode ser conduzido inteiramente por um arquivo de configuração e o circo / circo
comandos, é fácil reutilizar todo ou parte do sistema para construir seu próprio
observador de processos em Python.

Cada camada do sistema é isolada, para que você possa reutilizar de forma independente:

· O envoltório do processo (Extração)

· O gerente de processos (Observador)

· O gerente global que executa vários gerentes de processos (Árbitro)

· e assim por diante…

4. Circo Escalas
Um dos casos de uso do Circus é gerenciar milhares de processos sem adicionar
sobrecarga - estamos empenhados em nos concentrar nisso.

Vinda da Supervisor
Supervisor é uma solução muito popular no mundo Python e frequentemente nos perguntam como o Circus
compara com ele.

Se você vem de Supervisor, esta página tenta dar uma visão geral de como as ferramentas
diferem.

Diferenças Visão geral
Supervisor & Circus têm os mesmos objetivos - ambos gerenciam processos e fornecem uma
script de linha de comando - respectivamente Supervisor e circo - que lê uma configuração
arquivo, bifurca novos processos e os mantém vivos.

O Circus tem um recurso extra: a capacidade de ligar soquetes e permitir que os processos que gerencia
usa-os. Este modelo "pré-bifurcação" é usado por muitos servidores da web, como apache or
Unicorn. Ter esta opção no Circus pode simplificar uma pilha de aplicativos da web: todos os processos e
os soquetes são gerenciados por uma única ferramenta.

Ambos os projetos fornecem uma maneira de controlar um daemon em execução por meio de outro script. respectivamente
supervisorctl e circo. Eles também têm eventos e uma maneira de se inscrever neles.
A principal diferença é a tecnologia subjacente: o Supervisor usa XML-RPC para interagir
com o daemon, enquanto Circus usa ZeroMQ.

O Circus e o Supervisor possuem uma interface da web para exibir o que está acontecendo. Circo é mais
avançado porque você pode acompanhar em tempo real o que está acontecendo e interagir com o daemon.
Ele usa web sockets e é desenvolvido em um projeto separado (circo-teia.)

Existem muitas outras diferenças sutis no design do núcleo, podemos listar aqui um dia ... Em
Nesse ínterim, você pode aprender mais sobre peças internas de circo em design.

Configuração
Ambos os sistemas usam um arquivo do tipo ini como configuração.

· Supervisor documentação

· Circo documentação

Aqui está um pequeno exemplo de execução de um aplicativo com o Supervisor. Neste caso, o
o aplicativo será iniciado e reiniciado em caso de falha

[programa: exemplo]
comando = npm start
diretório = / home / www / meu-servidor /
user = www-data
autostart = true
autorestart = true
redirect_stderr = True

No Circus, a mesma configuração é feita por:

[observador: exemplo]
cmd = npm start
working_dir = / home / www / my-server /
user = www-data
stderr_stream.class = StdoutStream

Observe que o redirecionamento stderr é ligeiramente diferente no Circus. A ferramenta não tem
a cauda recurso como no Supervisor, mas permitirá que você conecte qualquer pedaço de código para lidar com
o fluxo de entrada. Você pode criar seu próprio gancho de fluxo (como uma classe) e fazer tudo o que você
deseja com o fluxo de entrada. Circus oferece algumas classes de fluxo integradas, como
StdoutStreamName, Filestream, Assistido FileStream, ou TimedRotatingFileStream.

Circo for Ops
AVISO:
Por padrão, o Circus não protege suas mensagens ao enviar informações através do ZeroMQ.
Antes de executar o Circus em um ambiente de produção, certifique-se de ler a página Segurança.

O primeiro passo para gerenciar um daemon Circus é escrever seu arquivo de configuração. Ver
configuração. Se você estiver implantando uma pilha da web, dê uma olhada nos sockets.

O Circus pode ser implantado usando Python 2.6, 2.7, 3.2 ou 3.3 - a maioria das implantações que existem
feito em 2.7. Para saber como implantar o Circus, verifique a implantação.

Para gerenciar um daemon Circus, você deve se familiarizar com a lista de comandos que você pode usar
in circo. Observe que você pode ter a mesma ajuda online ao executar circo como um
Concha.

Nós também fornecemos circo, veja CLI e um bom painel da web. veja circushttpd.

Por último, para obter o máximo do Circus, certifique-se de verificar como usar plug-ins e ganchos.
Veja plug-ins e ganchos.

Ops documentação índice
Configuração
O Circus pode ser configurado usando um arquivo de configuração no estilo ini.

Exemplo:

[circo]
check_delay = 5
endpoint = tcp: //127.0.0.1: 5555
pubsub_endpoint = tcp: //127.0.0.1: 5556
include = \ *. more.config.ini
umask = 002

[observador: meuprograma]
cmd=píton
args = -u meuprograma.py $ (circus.wid) $ (CIRCUS.ENV.VAR)
aquecimento_atraso = 0
numprocessos = 5

# gancho
ganchos.before_start = meus.hooks.control_redis

# enviará test.log para o stream a cada 300 ms
stdout_stream.class = FileStream
stdout_stream.filename = teste.log

# opcionalmente, gire o arquivo de log quando atingir 1 gb
# e salve 5 cópias de arquivos girados
stdout_stream.max_bytes=1073741824
stdout_stream.backup_count = 5

[env: meuprograma]
PATH = $ PATH:/ bin
BOLO = mentira

[plugin: statsd]
usar=circus.plugins.statsd.StatsdEmitter
host = host local
porta = 8125
taxa_amostra = 1.0
application_name = exemplo

[socket: web]
host = host local
porta = 8080

circo - solteiro seção
Ponto final
O soquete ZMQ usado para gerenciar o Circus via circo. (predefinição:
tcp: //127.0.0.1: 5555)

endpoint_owner
Se definido como um nome de usuário do sistema e o endpoint é um soquete ipc como
ipc: //var/run/circusd.sock, então a propriedade do arquivo de soquete será alterada para
esse usuário na inicialização. Para mais detalhes, consulte segurança. (padrão: nenhum)

pubsub_endpoint
O soquete ZMQ PUB / SUB recebendo publicações de eventos. (padrão:
tcp: //127.0.0.1: 5556)

papa_endpoint
Se estiver usando papa, você pode especificar o ponto de extremidade, como ipc: //var/run/circusd.sock.
(padrão: tcp: //127.0.0.1: 20202)

estatísticasd Se definido como True, Circus executa o daemon circusd-stats. (padrão: falso)

stats_endpoint
O soquete ZMQ PUB / SUB recebendo publicações de estatísticas. (padrão:
tcp: //127.0.0.1: 5557)

estatísticasd_close_outputs
Se True, envia o circusd-stats stdout / stderr para / dev / null. (padrão: falso)

check_delay
O intervalo de pesquisa em segundos para o soquete ZMQ. (padrão: 5)

incluir
Lista de arquivos de configuração a serem incluídos. Você pode usar curingas (*) para incluir
esquemas para seus arquivos. Os caminhos são absolutos ou relativos ao arquivo de configuração.
(padrão: nenhum)

include_dir
Lista de diretórios de configuração. Todos os arquivos correspondentes * .ini em cada diretório irá
ser incluido. Os caminhos são absolutos ou relativos ao arquivo de configuração. (padrão:
Nenhum)

stream_backend
Define o tipo de back-end a ser usado para o streaming. Os valores possíveis são fio
or evento. (padrão: tópico)

aquecimento_atraso
O intervalo em segundos entre o início de dois observadores. Deve ser um int. (padrão: 0)

httpd Se definido como True, Circus executa o daemon circushttpd. (padrão: falso)

httpd_host
O host foi executado pelo daemon circushttpd. (padrão: localhost)

httpd_port
A porta executada pelo daemon circushttpd. (padrão: 8080)

httpd_close_outputs
Se for Verdadeiro, envia o circushttpd stdout / stderr para / dev / null. (padrão: falso)

depurar Se definido como True, todos os daemons Circus stout / stderr são redirecionados para circusd
stdout / stderr (padrão: False)

debug_gc
Se definido como True, circusd gera informações de log adicionais do coletor de lixo.
Isso pode ser útil para rastrear vazamentos de memória. (padrão: falso)

arquivo pid
O arquivo que deve ser usado para manter o daemon pid.

umask Valor para umask. Se não for definido, o circusd não tentará modificar umask.

nível de log
O nível de log que queremos ver (padrão: INFO)

sair
O arquivo de saída de log em que queremos registrar (padrão: - para fazer logon stdout). Você pode
logar em um syslog remoto usando a seguinte sintaxe:
syslog: // host: porta? facilidade onde host é o seu servidor syslog, a porta é opcional
e facilidade é o recurso syslog a ser usado. Se você deseja entrar em um syslog local
você pode usar syslog: /// path / to / syslog / socket? facilidade ao invés.

loggerconfig
Um caminho para um arquivo INI, JSON ou YAML para configurar o registro Python padrão para o
Árbitro. O valor especial "default" usa a configuração de registro embutida
com base nas opções opcionais de nível de log e saída de log.

Exemplo Yaml Configuração Envie o

version: 1
disable_existing_loggers: falso
formatadores:
simples:
formato: '% (asctime) s -% (name) s - [% (levelname) s]% (message) s'
manipuladores:
arquivo de log:
classe: logging.FileHandler
nome do arquivo: logoutput.txt
nível: DEBUG
formatador: simples
madeireiros:
circo:
nível: DEBUG
manipuladores: [logfile]
propagar: não
raiz:
nível: DEBUG
manipuladores: [logfile]

observador: NAME - as muitos seções as Você queremos
NOME O nome do observador. Este nome é usado em circo

cmd O programa executável a ser executado.

args Argumentos da linha de comando a serem transmitidos ao programa. Você pode usar o formato python
sintaxe aqui para construir os parâmetros. Variáveis ​​de ambiente estão disponíveis, como
bem como o id do trabalhador e as variáveis ​​de ambiente que você passou, se houver,
com o parâmetro "env". Ver formatação da comandos e argumentos com dinâmico
variáveis para mais informações sobre isso.

concha Se for True, os processos são executados no shell (padrão: False)

shell_args
Argumentos de linha de comando para passar para o comando shell quando concha é verdade. Funciona
apenas para o sistema * nix (padrão: nenhum)

work_dir
O diretório de trabalho para os processos (padrão: Nenhum)

uid O ID do usuário ou nome com o qual o comando deve ser executado. (O uid atual é o
predefinição).

guia A identificação ou nome do grupo com o qual o comando deve ser executado. (O gid atual é o
predefinição).

copy_env
Se definido como verdadeiro, as variáveis ​​de ambiente locais serão copiadas e passadas para o
trabalhadores ao gerá-los. (Padrão: False)

copy_path
Se definido como verdadeiro, caminho do sistema é passado no ambiente de subprocesso usando PITONPATO.
copy_env tem que ser verdade. (Padrão: False)

aquecimento_atraso
O atraso (em segundos) entre os processos em execução.

começo automático
Se definido como falso, o observador não será iniciado automaticamente quando o árbitro
começa. O observador pode ser iniciado explicitamente (exemplo: circo começo
meu programa) (Padrão: Verdadeiro)

numprocessos
O número de processos a serem executados para este inspetor.

rlimit_LIMIT
Defina o limite de recursos LIMIT para os processos monitorados. O nome da configuração deve corresponder
as constantes RLIMIT_ * (não diferencia maiúsculas de minúsculas) listadas no Python recurso módulo
referência. Por exemplo, a linha de configuração 'rlimit_nofile = 500' define o máximo
número de arquivos abertos para 500. Para definir um valor limite para RLIM_INFINITY, não defina um
valor, como esta linha de configuração: 'rlimit_nofile ='.

stderr_stream.class
Um nome de classe Python totalmente qualificado que será instanciado e receberá
da stderr fluxo de todos os processos em seu __ligar__() método.

Circus fornece algumas classes de fluxo que você pode usar sem prefixo:

· Filestream: escreve em um arquivo e pode fazer rotação automática de log

· Assistido FileStream: grava em um arquivo e depende de rotação de log externo

· TimedRotatingFileStream: escreve em um arquivo e pode girar em determinado momento
intervalos.

· QueueStream: escrever em uma fila de memória

· StdoutStreamName: escreve no stdout

· FancyStdoutStream: escreve a saída colorida com prefixos de tempo no stdout

stderr_stream. *
Todas as opções começando com stderr_stream. exceto classe será passado o
construtor ao criar uma instância da classe definida em
stderr_stream.class.

stdout_stream.class
Um nome de classe Python totalmente qualificado que será instanciado e receberá
da stdout fluxo de todos os processos em seu __ligar__() método.

Circus fornece algumas classes de fluxo que você pode usar sem prefixo:

· Filestream: escreve em um arquivo e pode fazer rotação automática de log

· Assistido FileStream: grava em um arquivo e depende de rotação de log externo

· TimedRotatingFileStream: escreve em um arquivo e pode girar em determinado momento
intervalos.

· QueueStream: escrever em uma fila de memória

· StdoutStreamName: escreve no stdout

· FancyStdoutStream: escreve a saída colorida com prefixos de tempo no stdout

stdout_stream. *
Todas as opções começando com stdout_stream. exceto classe será passado o
construtor ao criar uma instância da classe definida em
stdout_stream.class.

close_child_stdout
Se definido como True, o fluxo stdout de cada processo será enviado para / dev / null
após o garfo. O padrão é falso.

close_child_stderr
Se definido como True, o fluxo stderr de cada processo será enviado para / dev / null
após o garfo. O padrão é falso.

enviar_hup
Se for True, uma recarga do processo será feita enviando o sinal SIGHUP. Padrões
para False.

sinal_de_parada
O sinal a enviar ao interromper o processo. Pode ser especificado como um número ou um
nome do sinal. Os nomes dos sinais não diferenciam maiúsculas de minúsculas e podem incluir 'SIG' ou não. assim
exemplos válidos incluem desistir, INT, PRAZO META e 3. O padrão é SIGTERM.

parar_crianças
Ao enviar o sinal_de_parada, envie para as crianças também. Padrões para
Falso.

max_retria
O número de vezes que tentamos iniciar um processo, antes de abandonar e parar
todo o observador. O padrão é 5. Defina como -1 para desativar max_retry e tentar novamente
indefinidamente.

Graceful_timeout
O número de segundos de espera para um processo terminar normalmente antes
a matá-lo.

Ao interromper um processo, primeiro enviamos a ele um sinal_de_parada. Um trabalhador pode pegar isso
sinal para realizar operações de limpeza antes de sair. Se o trabalhador ainda está
ativo após graceful_timeout segundos, enviamos um sinal SIGKILL. Não é
possível captar os sinais SIGKILL para que o trabalhador pare.

O padrão é 30s.

prioridade
Inteiro que define uma prioridade para o inspetor. Quando o Árbitro faz alguma
operações em todos os observadores, ele irá classificá-los com este campo, do maior
número ao menor. O padrão é 0.

coisa única
Se definido como True, este inspetor terá no máximo um processo. Padrões para
Falso.

use_sockets
Se definido como True, este inspetor será capaz de acessar sockets definidos por meio de seus
descritores de arquivo. Se for False, todos os fds pais serão fechados quando o processo filho for
bifurcado. O padrão é falso.

max_idade
Se definido, o processo será reiniciado em algum momento após max_age segundos. Isto
é útil quando os processos lidam com conjunto de conectores: reiniciando processos
melhora o balanceamento de carga. O padrão é ser desativado.

max_age_variance
Se max_age for definido, então o processo viverá entre max_age e max_age +
segundos aleatórios (0, max_age_variance). Isso evita reiniciar todos os processos por um
observador de uma vez. O padrão é 30 segundos.

sob demanda
Se definido como True, os processos serão iniciados somente após a primeira conexão com
um dos soquetes configurados (veja abaixo). Se for necessário reiniciar, será
acionado apenas no próximo evento de soquete.

ganchos. *
Ganchos disponíveis: antes_iniciar, após_início, antes_spawn, depois_spawn,
antes_parada, depois_parada, sinal_antes, pós_sinal, extend_stats

Defina funções de retorno de chamada que se conectam ao processo de inicialização / desligamento do inspetor.

Se o gancho retornar Falso e se o gancho for um dos antes_iniciar, antes_spawn,
após_início or depois_spawn, a inicialização será abortada.

Se o gancho for sinal_antes e retornos Falso, então o sinal correspondente
não será enviado (exceto SIGKILL que é sempre enviado)

Observe que um gancho que falha durante o processo de parada não o abortará.

A definição de retorno de chamada pode ser seguida por um sinalizador booleano separado por uma vírgula.
Quando a bandeira está definida para verdadeiro, qualquer erro que ocorra no gancho será ignorado. Se
definido para falso (o padrão), o gancho retornará Falso.

Mais sobre ganchos.

virtualenv
Quando fornecido, aponta para a raiz de um diretório Virtualenv. O observador vai
escaneie o local pacotes de sites e carrega seu conteúdo na execução
ambiente. Deve ser usado com copy_env definido como True. O padrão é Nenhum.

virtualenv_py_ver
Especifica a versão python do virtualenv (por exemplo, "3.3"). É útil se
circo executado com outra versão do python (por exemplo, "2.7") O observador fará a varredura do
local pacotes de sites da versão especificada do python e carregue seu conteúdo em
o ambiente de execução. Deve ser usado com virtualenv. O padrão é Nenhum.

reaparecimento
Se definido como False, os processos gerenciados por um inspetor não serão restaurados
automaticamente. Os processos podem ser restaurados manualmente com o começo comando.
(padrão: verdadeiro)

use_papa
Defina como true para usar o papai.

soquete: NAME - as muitos seções as Você queremos
hospedeiro O hospedeiro do soquete. O padrão é 'localhost'

porta O Porto. O padrão é 8080.

família A família de soquetes. Pode ser 'AF_UNIX', 'AF_INET' ou 'AF_INET6'. Padrões para
'AF_INET'.

tipo O tipo de soquete. Pode ser 'SOCK_STREAM', 'SOCK_DGRAM', 'SOCK_RAW', 'SOCK_RDM' ou
'SOCK_SEQPACKET'. O padrão é 'SOCK_STREAM'.

interface
Quando fornecido um nome de interface de rede como 'eth0', liga o soquete a esse
dispositivo específico, de modo que apenas os pacotes recebidos dessa interface específica
são processados ​​pelo soquete. Isso pode ser usado, por exemplo, para limitar qual dispositivo
para ligar ao ligar em IN_ADDR_ANY (0.0.0.0) ou IN_ADDR_BROADCAST
(255.255.255.255). Observe que isso só funciona para alguns tipos de soquete, particularmente
Soquetes AF_INET.

caminho Quando fornecido um caminho para um arquivo que será usado como um arquivo de socket unix. Se um
caminho é fornecido, família é forçado a AF_UNIX e hospedeiro e porta são ignorados.

umask Quando fornecido, define o umask que será usado para criar um socket AF_UNIX. Por
exemplo, umask = 000 irá produzir um soquete com permissão 777.

substituir
Ao criar sockets Unix ('AF_UNIX'), um arquivo existente pode indicar um problema
portanto, o padrão é falhar. Especificamos a Verdadeira para simplesmente remover o arquivo antigo se você estiver
certifique-se de que o soquete é gerenciado apenas pelo Circus.

so_reuseport
Se definido como True e SO_REUSEPORT estiver disponível na plataforma de destino, o circo irá
criar e vincular novo (s) soquete (s) SO_REUSEPORT para cada trabalhador que ele iniciar, que é um
usuário deste (s) soquete (s).

use_papa
Defina como true para usar o papai.

Depois que um soquete é criado, o $ {circus.sockets.NAME} string pode ser usada no comando
(cmd or args) de um observador. Circus irá substituí-lo pelo valor FD. O observador também deve
use_sockets definido para a Verdadeira caso contrário, o soquete será fechado e você obterá
erros quando o observador tenta usá-lo.

Exemplo:

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

[socket: webapp]
hospedeiro = 127.0.0.1
porta = 8888

plugin: NAME - as muitos seções as Você queremos
usar O nome totalmente qualificado que aponta para a classe de plug-in.

nada outro
Todas as outras chaves encontradas na seção são passadas para o construtor do plugin no
configuração mapeamento.

Você pode usar todas as opções do observador, desde que um plugin seja iniciado como um observador.

O Circus vem com alguns plug-ins pré-enviados, mas você também pode estendê-los facilmente
desenvolvendo o seu próprio.

env or env [: WATCHERS] - as muitos seções as Você queremos
nada
O nome de uma variável de ambiente à qual atribuir valor. ambiente de estilo bash
substituições são suportadas. por exemplo, anexar / bin para PATH 'PATH =
$ PATH:/ bin'

Seção responsável por entregar variáveis ​​de ambiente para executar processos.

Exemplo:

[observador: trabalhador1]
cmd=ping 127.0.0.1

[observador: trabalhador2]
cmd=ping 127.0.0.1

[ambiente]
BOLO = mentira

A variável BOLO será propagado para todos os observadores definidos no arquivo de configuração.

WATCHERS pode ser uma lista separada por vírgulas de seções do inspetor para aplicar este ambiente.
se várias seções env corresponderem a um observador, elas serão combinadas na ordem em que aparecem
o arquivo de configuração. entradas posteriores terão precedência.

Exemplo:

[observador: trabalhador1]
cmd=ping 127.0.0.1

[observador: trabalhador2]
cmd=ping 127.0.0.1

[env: trabalhador1, trabalhador2]
CAMINHO = / bin

[env: trabalhador1]
PATH = $ PATH

[env: trabalhador2]
BOLO = mentira

trabalhador 1 será executado com PATH = $ PATH (expandido do ambiente circusd em que foi executado)
trabalhador 2 será executado com PATH = / bin e BOLO = mentira

Também é possível usar curingas.

Exemplo:

[observador: trabalhador1]
cmd=ping 127.0.0.1

[observador: trabalhador2]
cmd=ping 127.0.0.1

[env: trabalhador *]
CAMINHO = / bin

Ambos trabalhador 1 e trabalhador 2 será executado com PATH = / bin

utilização meio Ambiente variáveis
Ao escrever seu arquivo de configuração, você pode usar variáveis ​​de ambiente definidas no env
seção ou em os.ambiente si.

Você apenas tem que usar o circo.env. prefixo.

Exemplo:

[observador: trabalhador1]
cmd = $ (circus.env.shell)

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

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

[plugin: plugin1]
use = algum.caminho
parâmetro1 = $ (circus.env.plugin_param)

[ambiente]
sim = boo

[env: trabalhador2]
ah = ok

Se uma variável é definida em vários lugares, o valor mais especializado tem precedência: a
variável definida em env: XXX irá substituir uma variável definida em env, que substituirá um
variável definida em os.ambiente.

substituições de ambiente podem ser usadas em qualquer seção da configuração em qualquer seção
variável.

formatação da comandos e argumentos com dinâmico variáveis
Como você deve ter visto, é possível passar algumas informações que são computadas
dinamicamente ao executar os processos. Entre outras coisas, você pode obter a id do trabalhador
(WID) e todas as opções que são passadas para o Extração. Além disso, é possível
acessar as opções passadas para o Observador que instanciava o processo.

OBSERVAÇÃO:
O id do trabalhador é diferente do id do processo. É um valor único, começando em 1,
que é exclusivo para o observador.

Por exemplo, se você deseja acessar algumas variáveis ​​que estão contidas no ambiente,
você precisaria fazer isso com uma configuração como esta:

cmd = "faça-me-um-café --sugar $ (CIRCUS.ENV.SUGAR_AMOUNT)"

Isso funciona com ambos cmd e args.

importante:

· Todas as variáveis ​​são prefixadas com circo.

· A substituição não diferencia maiúsculas de minúsculas.

Corrente • Configuração
Classe de fluxo simples como QueueStream e StdoutStreamName não tem atributos específicos, mas
alguma outra classe de fluxo pode ter alguns:

Filestream
nome do arquivo
O caminho do arquivo onde o log será gravado.

formato_tempo
O formato strftime que será usado para prefixar cada vez com um carimbo de data / hora. Por
padrão eles não serão prefixados.

ie:% Y-% m-% d% H:% M:% S

max_bytes
O tamanho máximo do arquivo de log antes de um novo arquivo ser iniciado. Se não for fornecido, o
arquivo não é rolado.

contagem_de_backup
O número de arquivos de log que serão mantidos. Por padrão, backup_count é nulo.

OBSERVAÇÃO:
O rollover ocorre sempre que o arquivo de log atual tem quase max_bytes de comprimento. Se
backup_count é> = 1, o sistema criará sucessivamente novos arquivos com o mesmo
nome do caminho como o arquivo base, mas com extensões ".1", ".2" etc. anexadas a ele. Por
exemplo, com um backup_count de 5 e um nome de arquivo base de "app.log", você obteria
"app.log", "app.log.1", "app.log.2", ... até "app.log.5". O arquivo sendo escrito
para é sempre "app.log" - quando fica cheio, é fechado e renomeado para
"app.log.1" e se os arquivos "app.log.1", "app.log.2" etc. existirem, eles serão renomeados
para "app.log.2", "app.log.3" etc. respectivamente.

Exemplo:

[observador: meuprograma]
cmd = python -m meuaplicativo.servidor

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

Assistido FileStream
nome do arquivo
O caminho do arquivo onde o log será gravado.

formato_tempo
O formato strftime que será usado para prefixar cada vez com um carimbo de data / hora. Por
padrão eles não serão prefixados.

ie:% Y-% m-% d% H:% M:% S

OBSERVAÇÃO:
WatchedFileStream depende de uma ferramenta externa de rotação de log para garantir que os arquivos de log
não se torne muito grande. O arquivo de saída será monitorado e se for excluído ou
movido pela ferramenta de rotação de log externa, o identificador do arquivo de saída será
recarregado automaticamente.

Exemplo:

[observador: meuprograma]
cmd = python -m meuaplicativo.servidor

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

TimedRotatingFileStream
nome do arquivo
O caminho do arquivo onde o log será gravado.

contagem_de_backup
O número de arquivos de log que serão mantidos. Por padrão, backup_count é nulo.

formato_tempo
O formato strftime que será usado para prefixar cada vez com um carimbo de data / hora. Por
padrão eles não serão prefixados.

ie:% Y-% m-% d% H:% M:% S

girar_quando
O tipo de intervalo. A lista de valores possíveis está abaixo. Observe que eles são
não diferencia maiúsculas de minúsculas.

┌──────────────┬─────────────────────────
│Valor │ Tipo de intervalo │
├──────────────┼─────────────────────────
│'S '│ segundos │
├──────────────┼─────────────────────────
│'M '│ Minutos │
├──────────────┼─────────────────────────
│'H '│ Horas │
├──────────────┼─────────────────────────
│'D '│ Dias │
├──────────────┼─────────────────────────
│ 'S0' - 'S6' │ Dia da semana (0 = segunda-feira) │
├──────────────┼─────────────────────────
│'meia-noite '│ Role à meia-noite │
└──────────────┴─────────────────────────

girar_intervalo
O intervalo de rollover.

OBSERVAÇÃO:
TimedRotatingFileStream gira os arquivos de log em determinados intervalos de tempo. Intervalo de rollover
é determinado por uma combinação de rotate_when e rotate_interval.

Exemplo:

[observador: meuprograma]
cmd = python -m meuaplicativo.servidor

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

FancyStdoutStream
cor

O nome of an ascii cor:

· vermelho

· verde

· amarelo

· azul

· Magenta

· Ciano

· Branco

formato_tempo
O formato strftime com o qual cada linha será prefixada.

Padrão para:% Y-% m-% d% H:% M:% S

Exemplo:

[observador: meuprograma]
cmd = python -m meuaplicativo.servidor
stdout_stream.class=FancyStdoutStream
stdout_stream.color = verde
stdout_stream.time_format =% Y /% m /% d | % H:% M:% S

comandos
No epicentro do circo vivem os sistemas de comando. circo é apenas um cliente zeromq,
e se necessário, você pode conduzir programaticamente o sistema Circus escrevendo seu próprio zmq
cliente.

Todas as mensagens são mapeamentos JSON.

Para cada comando abaixo, fornecemos um exemplo de uso com circusctl, mas também a entrada /
enviar mensagens zmq.

circo-ctl comandos
· adicionar: comandos / adicionar

· diminuir: comandos / decr

· estatísticas: comandos / dstats

· ter: comandos / get

· opções globais: comandos / opções globais

· aumento: comandos / incr

· Pitão: comandos / ipython

· Lista: comandos / lista

· : comandos / ouvir

· encaixes de listas: comandos / listsockets

· numprocessos: comandos / numprocesses

· numeradores: comandos / numwatchers

· opções: comandos / opções

· desistir: comandos / sair

· recarregar: comandos / recarregar

· recarregar configuração: comandos / reloadconfig

· restart: comandos / reiniciar

· rm: comandos / rm

· conjunto: comandos / set

· sinal: comandos / sinal

· começo: comandos / start

· stats: comandos / estatísticas

· estado: comandos / status

· Pare: comandos / parar

Adicione a observador
Este comando adiciona um observador dinamicamente a um árbitro.

ZMQ Mensagem
{
"command": "add",
"propriedades": {
"cmd": "/ caminho / para / linha de comando - opção"
"nome": "nome do observador"
"args": [],
"opções": {},
"start": falso
}
}

Uma mensagem contém 2 propriedades:

· Cmd: Linha de comando completa para executar em um processo

· Args: array, argumentos passados ​​para o comando (opcional)

· Nome: nome do observador

· Opções: opções de um observador

· Iniciar: iniciar o observador após a criação

A resposta retornou um status "ok".

Command linha
$ circusctl add [--start]

Opções
· : nome do observador a ser criado

· : linha de comando completa para executar em um processo

· --Start: inicia o observador imediatamente

Decrementar da número of processos in a observador
Este comentário diminui o número de processos em um observador em , Sendo 1 o
padrão.

ZMQ Mensagem
{
"command": "decr",
"propriedades": {
"nome": " "
"nb":
"esperando": Falso
}
}

A resposta retorna o número de processos na propriedade 'numprocesses`:

{"status": "ok", "numprocesses": , "hora", "carimbo de data / hora"}

Command linha
$ circusctl decr [ ] [--esperando]

Opções
· : nome do observador

· : o número de processos a serem removidos.

Get circo stats
Você pode obter a qualquer momento algumas estatísticas sobre circusd com o comando dstat.

ZMQ Mensagem
Para obter as estatísticas do circusd, basta executar:

{
"command": "dstats"
}

A resposta retorna um mapeamento da propriedade "infos" contendo algumas informações do processo:

{
"info": {
"crianças": [],
"cmdline": "python",
"cpu": 0.1,
"ctime": "0: 00.41",
"mem": 0.1,
"mem_info1": "3M",
"mem_info2": "2G",
"legal": 0,
"pid": 47864,
"nome de usuário": "root"
},
"status": "ok",
"tempo": 1332265655.897085
}

Command Line
$ circusctl dstats

Get da valor of aplicação observador opções
Este comando pode ser usado para consultar o valor atual de uma ou mais opções do inspetor.

ZMQ Mensagem
{
"command": "get",
"propriedades": {
"keys": ["key1," key2 "]
"nome": "nome do observador"
}
}

Uma mensagem de solicitação contém duas propriedades:

· Chaves: lista, as chaves de opção para as quais você deseja obter os valores

· Nome: nome do observador

O objeto de resposta tem uma propriedade opções que é um dicionário de nomes de opções e
valores.

por exemplo:

{
"status": "ok",
"opções": {
"graceful_timeout": 300,
"send_hup": Verdadeiro,
},
time ': 1332202594.754644
}

Command linha
$ circusctl get

Get da árbitro opções
Este comando retorna as opções do árbitro

ZMQ Mensagem
{
"command": "globaloptions",
"propriedades": {
"key1": "val1",
..
}
}

Uma mensagem contém 2 propriedades:

· Chaves: lista, as chaves de opção para as quais você deseja obter os valores

A resposta retorna um objeto com uma propriedade "options" contendo a lista de chave / valor
devolvido pelo circo.

por exemplo:

{
"status": "ok",
"opções": {
"check_delay": 1,
...
},
time ': 1332202594.754644
}

Command linha
$ circusctl opções globais

Opções
As chaves de opções são:

· Endpoint: o endpoint controlador ZMQ

· Pubsub_endpoint: o endpoint pubsub

· Check_delay: o atraso entre dois pontos do controlador

· Multicast_endpoint: o endpoint multicast para autodescoberta circusd cluster

Incremento da número of processos in a observador
Este comentário incrementa o número de processos em um observador por , Sendo 1 o
omissão

ZMQ Mensagem
{
"command": "incr",
"propriedades": {
"nome": " ",
"nb": ,
"esperando": Falso
}
}

A resposta retorna o número de processos na propriedade 'numprocesses`:

{"status": "ok", "numprocesses": , "hora", "carimbo de data / hora"}

Command linha
$ circusctl incr [ ] [--esperando]

Opções
· : nome do observador.

· : o número de processos a serem adicionados.

Crie concha para dentro circo processo
Este comando só é útil se você tiver o pacote ipython instalado.

Command Line
$ circusctl ipython

Get Lista of observadores or processos in a observador
ZMQ Mensagem
Para obter a lista de todos os observadores:

{
"command": "list",
}

Para obter a lista de processos ativos em um inspetor:

{
"command": "list",
"propriedades": {
"nome": "nome do observador",
}
}

A resposta retorna a lista solicitada. o mapeamento retornado pode ser 'observadores' ou
'pids' dependendo da solicitação.

Command linha
$ circusctl list [ ]

Subscrever para a observador evento
ZMQ
A qualquer momento você pode se inscrever em um evento de circo. Circus fornece um feed PUB / SUB no qual
qualquer cliente pode se inscrever. O URI do endpoint do assinante é definido no circus.ini
arquivo de configuração.

Eventos são tópicos pubsub:

· observador. .colher: quando um processo é colhido

· observador. .spawn: quando um processo é gerado

· observador. .matar: quando um processo é eliminado

· observador. .Atualizada: quando a configuração do inspetor é atualizada

· observador. .Pare: quando um observador está parado

· observador. .começar: quando um observador é iniciado

Todas as mensagens de eventos estão em uma estrutura json.

Command linha
O cliente foi atualizado para fornecer uma maneira simples de ouvir os eventos:

circusctl ouvir [ , ...]

Exemplo of resultado:
$ circusctl listen tcp: //127.0.0.1: 5556
watcher.refuge.spawn: {u'process_id ': 6, u'process_pid': 72976,
u'time ': 1331681080.985104}
watcher.refuge.spawn: {u'process_id ': 7, u'process_pid': 72995,
u'time ': 1331681086.208542}
watcher.refuge.spawn: {u'process_id ': 8, u'process_pid': 73014,
u'time ': 1331681091.427005}

Get da Lista of soquetes
ZMQ Mensagem
Para obter a lista de soquetes:

{
"command": "listsockets",
}

A resposta retorna uma lista de mapeamentos json com chaves para fd, nome, host e porta.

Command linha
$ circusctl listsockets

Get da número of processos
Obtenha o número de processos em um observador ou árbitro

ZMQ Mensagem
{
"command": "numprocesses",
"propriedades": {
"nome": " "
}

}

A resposta retorna o número de processos na propriedade 'numprocesses`:

{"status": "ok", "numprocesses": , "hora", "carimbo de data / hora"}

Se o nome da propriedade não for especificado, a soma de todos os processos gerenciados é retornada.

Command linha
$ circusctl numprocesses [ ]

Opções
· : nome do observador

Get da número of observadores
Obtenha o número de observadores em um árbitro

ZMQ Mensagem
{
"command": "numwatchers",
}

A resposta retorna o número de observadores na propriedade 'numwatchers`:

{"status": "ok", "numwatchers": , "hora", "carimbo de data / hora"}

Command linha
$ circusctl numwatchers

Get da valor of todos os opções for a observador
Este comando retorna todos os valores de opção para um determinado inspetor.

ZMQ Mensagem
{
"command": "options",
"propriedades": {
"nome": "nome do observador",
}
}

Uma mensagem contém 1 propriedade:

· Nome: nome do observador

O objeto de resposta tem uma propriedade opções que é um dicionário de nomes de opções e
valores.

por exemplo:

{
"status": "ok",
"opções": {
"graceful_timeout": 300,
"send_hup": Verdadeiro,
...
},
time ': 1332202594.754644
}

Command linha
opções de $ circusctl

Opções
· : nome do observador

As chaves de opções são:

· Numprocesses: número inteiro, número de processos

· Warmup_delay: inteiro ou número, demora para esperar entre a geração do processo em segundos

· Working_dir: string, diretório onde o processo será executado

· Uid: string ou inteiro, ID do usuário usado para iniciar o processo

· Gid: string ou inteiro, ID do grupo usado para iniciar o processo

· Send_hup: booleano, se TRU o sinal HUP será usado na recarga

· Shell: booleano, executará o comando no ambiente do shell se verdadeiro

· Cmd: string, a linha de comando usada para iniciar o processo

· Env: objeto, define o ambiente em que o processo será lançado

· Retry_in: inteiro ou número, tempo em segundos que esperamos antes de tentar novamente para lançar o
processo se o número máximo de tentativas foi atingido.

· Max_retry: inteiro, o máximo de loops de novas tentativas

· Graceful_timeout: inteiro ou número, tempo que esperamos antes de encerrar definitivamente um processo.

· Prioridade: usado para classificar observadores no árbitro

· Singleton: se True, um observador singleton.

· Max_age: tempo que um processo pode viver antes de ser reiniciado

· Max_age_variance: variável adicional de tempo de vida, evita o estouro do rebanho.

desistir da árbitro imediatamente
Quando o árbitro recebe este comando, ele sai.

ZMQ Mensagem
{
"command": "quit",
"esperando": Falso
}

A resposta retorna o status "ok".

If espera for False (padrão), a chamada retornará imediatamente após chamar sinal_de_parada
em cada processo.

If espera for True, a chamada retornará somente quando o processo de parada for completamente encerrado.
Por causa da opção graceful_timeout, pode levar algum tempo.

Command linha
$ circusctl sair [--waiting]

Recarregar da árbitro or a observador
Este comando recarrega todo o processo em um inspetor ou em todos os observadores. Isso vai acontecer em um
de 3 maneiras:

· Se graceful for falso, ocorre uma reinicialização simples.

· Se enviar_hup é verdade para o observador, um sinal HUP é enviado para cada processo.

·

De outra forma:

· Se sequencial for falso, o árbitro tentará desovar numprocessos novo
processos. Se os novos processos forem gerados com sucesso, o resultado é que
todos os processos antigos são interrompidos, já que por padrão os processos mais antigos são
interrompido quando o número real de processos para um inspetor é maior que
numprocessos.

· Se sequencial for verdadeiro, o árbitro irá reiniciar cada processo em uma sequência
maneira (com um aquecimento_atraso pausa entre cada etapa)

ZMQ Mensagem
{
"command": "reload",
"propriedades": {
"nome": ' ",
"gracioso": verdadeiro,
"sequencial": falso,
"esperando": Falso
}
}

A resposta retorna o status "ok". Se a propriedade graceful for definida como verdadeira, os processos
será encerrado com elegância.

Se o nome da propriedade estiver presente, o recarregamento será aplicado ao inspetor.

Command linha
$ circusctl reload [ ] [--terminar] [--esperando]
[--sequencial]

Opções
· : nome do observador

· --Terminar; saia do nó imediatamente

Recarregar da • Configuração lima
Este comando recarrega o arquivo de configuração, então as mudanças no arquivo de configuração serão
refletido na configuração do circo.

ZMQ Mensagem
{
"command": "reloadconfig",
"esperando": Falso
}

A resposta retorna o status "ok". Se a propriedade graceful for definida como verdadeira, os processos
será encerrado com elegância.

Command linha
$ circusctl reloadconfig [--esperando]

Reiniciar da árbitro or a observador
Este comando reinicia todo o processo em um inspetor ou em todos os observadores. Esta função simplesmente
pare um observador e reinicie-o.

ZMQ Mensagem
{
"comando": "reiniciar",
"propriedades": {
"nome": " ",
"esperando": Falso,
"match": "[simple | glob | regex]"
}
}

A resposta retorna o status "ok".

Se o nome da propriedade estiver presente, o recarregamento será aplicado ao inspetor.

If espera for False (padrão), a chamada retornará imediatamente após chamar sinal_de_parada
em cada processo.

If espera for True, a chamada retornará somente quando o processo de reinicialização for completamente
terminou. Por causa da opção graceful_timeout, pode levar algum tempo.

O partida parâmetro pode ter o valor simples para comparação de strings, glob para curinga
correspondência (padrão) ou regex para correspondência de regex.

Command linha
$ circusctl restart [name] [--waiting] [--match = simple | glob | regex]

Opções
· : nome ou padrão do (s) observador (es)

· : método de correspondência do observador

Eliminar a observador
Este comando remove um inspetor dinamicamente do árbitro. Os observadores são graciosamente
interrompido por padrão.

ZMQ Mensagem
{
"command": "rm",
"propriedades": {
"nome": " ",
"nostop": Falso,
"esperando": Falso
}
}

A resposta retornou um status "ok".

If não pare for True (padrão: False), os processos do inspetor não serão interrompidos -
em vez disso, o observador será apenas esquecido pelo circo e os processos do observador serão
responsáveis ​​por se impedirem. Se não pare não é especificado ou é falso, então o
os processos do observador serão interrompidos normalmente.

If espera for False (padrão), a chamada retornará imediatamente após iniciar a remoção
e pare o observador correspondente.

If espera for True, a chamada retornará apenas quando o processo de remoção e parada for
terminou completamente. Por causa da opção graceful_timeout, pode levar algum tempo.

Command linha
$ circusctl rm [--esperando] [--nostop]

Opções
· : nome do observador a ser removido

· Nostop: não interrompe os processos do observador, apenas remova o observador

Conjunto a observador opção
ZMQ Mensagem
{
"command": "set",
"propriedades": {
"nome": "nome do observador",
"opções": {
"key1": "val1",
..
}
"esperando": Falso
}
}

A resposta retorna o status "ok". Consulte o comando Opções para obter uma lista de chaves a serem definidas.

Command linha
$ circusctl set --esperando

Enviar a sinal
Este comando permite que você envie um sinal para todos os processos em um inspetor, um processo específico
em um observador ou em seus filhos.

ZMQ Mensagem
Para enviar um sinal a todos os processos de um inspetor:

{
"comando": "sinal",
"propriedade": {
"nome": ,
"signum":
}

Para enviar um sinal a um processo:

{
"comando": "sinal",
"propriedade": {
"nome": ,
"pid": ,
"signum":
}

Uma propriedade opcional "filhos" pode ser usada para enviar o sinal para todos os filhos, em vez
do que o próprio processo:

{
"comando": "sinal",
"propriedade": {
"nome": ,
"pid": ,
"signum": ,
"crianças": Verdadeiro
}

Para enviar um sinal para um filho de processo:

{
"comando": "sinal",
"propriedade": {
"nome": ,
"pid": ,
"signum": ,
"child_pid": ,
}

Também é possível enviar um sinal para todos os filhos do observador:

{
"comando": "sinal",
"propriedade": {
"nome": ,
"signum": ,
"crianças": Verdadeiro
}

Por último, você pode enviar um sinal para o processo e seus filhos, com o recursiva opção:

{
"comando": "sinal",
"propriedade": {
"nome": ,
"signum": ,
"recursivo": verdadeiro
}

Command linha
sinal $ circusctl [ ] [--crianças]
[--recursivo]

opções:
· : o nome do observador

· : inteiro, o id do processo.

· : o número do sinal (ou nome) a enviar.

· : o pid de uma criança, se houver

· : booleano, envia o sinal para todos os filhos

· : booleano, envia o sinal para o processo e seus filhos

Início da árbitro or a observador
Este comando inicia todos os processos em um inspetor ou em todos os observadores.

ZMQ Mensagem
{
"command": "start",
"propriedades": {
"nome": ' ",
"esperando": Falso,
"match": "[simple | glob | regex]"
}
}

A resposta retorna o status "ok".

Se o nome da propriedade estiver presente, o inspetor será iniciado.

If espera for False (padrão), a chamada retornará imediatamente após chamar começo on
cada processo.

If espera for True, a chamada retornará somente quando o processo de início for totalmente encerrado.
Por causa da opção graceful_timeout, pode levar algum tempo.

O partida parâmetro pode ter o valor simples para comparação de strings, glob para curinga
correspondência (padrão) ou regex para correspondência de regex.

Command linha
$ circusctl restart [name] [--waiting] [--match = simple | glob | regex]

Opções
· : nome ou padrão do (s) observador (es)

· : método de correspondência do observador

Get processo informação
Você pode obter a qualquer momento algumas estatísticas sobre seus processos com o comando stat.

ZMQ Mensagem
Para obter estatísticas para todos os observadores:

{
"command": "estatísticas"
}

Para obter estatísticas para um observador:

{
"comando": "estatísticas",
"propriedades": {
"nome":
}
}

Para obter estatísticas de um processo:

{
"comando": "estatísticas",
"propriedades": {
"nome": ,
"processo":
}
}

Estatísticas podem ser estendidas com o gancho extended_stats, mas estatísticas estendidas precisam ser
Requeridos:

{
"comando": "estatísticas",
"propriedades": {
"nome": ,
"processo": ,
"estendido": Verdadeiro
}
}

A resposta retorna um objeto por processo com a propriedade "info" contendo algum processo
informações:

{
"info": {
"crianças": [],
"cmdline": "python",
"cpu": 0.1,
"ctime": "0: 00.41",
"mem": 0.1,
"mem_info1": "3M",
"mem_info2": "2G",
"legal": 0,
"pid": 47864,
"nome de usuário": "root"
},
"processo": 5,
"status": "ok",
"tempo": 1332265655.897085
}

Command Line
$ circusctl stats [--extended] [ ] [ ]

Get da estado of a observador or todos os observadores
Este comando start obtém o status de um inspetor ou de todos os observadores.

ZMQ Mensagem
{
"command": "status",
"propriedades": {
"nome": ' ",
}
}

A resposta retorna o status "ativo" ou "interrompido" ou o status / observadores.

Command linha
$ circusctl status [ ]

Opções
· : nome do observador

Exemplo
manequim de status $ circusctl
ativo
$ status circusctl
manequim: ativo
dummy2: ativo
refúgio: ativo

Dê um basta observadores
Este comando interrompe um determinado observador ou todos os observadores.

ZMQ Mensagem
{
"command": "stop",
"propriedades": {
"nome": " ",
"esperando": Falso,
"match": "[simple | glob | regex]"
}
}

A resposta retorna o status "ok".

Se o nome propriedade estiver presente, então a parada será aplicada ao observador
correspondendo a esse nome. Caso contrário, todos os observadores serão parados.

If espera for False (padrão), a chamada retornará imediatamente após chamar sinal_de_parada
em cada processo.

If espera for True, a chamada retornará somente quando o processo de parada for completamente encerrado.
Por causa da opção graceful_timeout, pode levar algum tempo.

O partida parâmetro pode ter o valor simples para comparação de strings, glob para curinga
correspondência (padrão) ou regex para correspondência de regex.

Command linha
$ circusctl stop [name] [--waiting] [--match = simple | glob | regex]

Opções
· : nome ou padrão do (s) observador (es)

· : método de correspondência do observador

CLI ferramentas
circo
circo é um console semelhante ao de topo que você pode executar para assistir ao vivo o seu sistema Circus em execução. Isto
irá exibir a CPU, uso de memória e acertos de soquete, se você tiver algum.

Exemplo de saída:

-------------------------------------------------- ---------------------
estatísticas de circo
CPU PID (%) MEMÓRIA (%)
14252 0.8 0.4
0.8 (média) 0.4 (soma)

manequim
CPU PID (%) MEMÓRIA (%)
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 (média) 0.5 (soma)

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

circo é um console somente leitura. Se você deseja interagir com o sistema, use circo.

circo
circo pode ser usado para executar qualquer comando listado em comandos. Por exemplo, você pode obter um
lista de todos os observadores, você pode fazer

lista de $ circusctl

Além de oferecer suporte a um punhado de opções, você também pode especificar o ponto de extremidade circo rede de apoio social
usar usando o CIRCUSCTL_ENDPOINT variável de ambiente.

O Site: cônsul
O Circus vem com um console da Web que pode ser usado para gerenciar o sistema.

O console da web permite que você:

· Conecte-se a qualquer sistema Circus em execução

· Assistir os processos de uso de CPU e memória em tempo real

· Adicionar ou eliminar processos

· Adicionar novos observadores

OBSERVAÇÃO:
O recurso de uso de CPU e memória em tempo real usa o soquete de estatísticas. Se você quiser
ative-o, certifique-se de que o sistema Circus ao qual você se conectará tem o ponto de estatísticas
habilitado em sua configuração:

[circo]
statsd = Verdadeiro

Por padrão, esta opção não está ativada.

O console da web é um pacote próprio, você precisa instalar:

$ pip instalar circus-web

Para habilitar o console, adicione algumas opções no arquivo Circus ini:

[circo]
httpd = Verdadeiro
httpd_host=localhost
httpd_port=8080

httpd_host e httpd_port são opcionais e o padrão para localhost e 8080.

Se você deseja executar o aplicativo da web por conta própria, basta executar o circohttpd script:

$ circohttpd
Servidor Bottle sendo inicializado ...
Ouvindo em http://localhost: 8080 /
Pressione Ctrl-C para sair.

Por padrão, o script executará o console da Web na porta 8080, mas a opção --port pode ser
usado para mudar isso.

utilização da consolá
Assim que o script estiver em execução, você pode abrir um navegador e visitar http://localhost: 8080. Você
deve obter esta tela: [imagem]

O Web Console está pronto para ser conectado a um sistema Circus, dado o seu Ponto final. Por
padrão, o endpoint é tcp: //127.0.0.1: 5555.

Depois de bater Conecte-se, o aplicativo da web se conectará ao sistema Circus.

Com o console da web conectado, você deve obter uma lista de observadores e um status em tempo real
dos dois processos do Circo (circusd e circusd-stats).

Você pode clicar no status de cada observador para alterná-lo de Ativo (verde) para Inativo
(vermelho). Essa mudança entra em vigor imediatamente e permite que você inicie e interrompa os observadores.

Se você clicar no nome do observador, obterá uma página da web para esse observador em particular,
com seus processos:

Nesta tela, você pode adicionar ou remover processos e eliminar os existentes.

Por último, mas não menos importante, você pode adicionar um novo observador clicando no Adicione Observador link em
o menu esquerdo: .SS rodando atrás do Nginx

O Nginx pode atuar como proxy e camada de segurança na frente do circus-web.

OBSERVAÇÃO:
Para receber atualizações de status em tempo real e gráficos no circus-web, você deve fornecer um Nginx
solução de proxy que tem suporte para websocket

nginx >= 1.3.13
A partir de Nginx> = 1.3.13, o suporte para websocket está integrado, portanto, não há necessidade de combinar Nginx
com verniz ou HAProxy. Um exemplo de configuração Nginx com suporte para websocket:

circusweb_server a montante {
servidor 127.0.0.1:8080;
}

Servidor {
escute 80;
nome do servidor _;

Localização /
proxy_pass http://circusweb_server;
proxy_http_versão 1.1;
proxy_set_header Atualizar $ http_upgrade;
proxy_set_header Conexão "upgrade";
proxy_set_header Host $ host;
proxy_set_header X-Real-IP $ remote_addr;
proxy_set_header X-Forwarded-For $ proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto http;
proxy_redirect desligado;
}

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

nginx < 1.3.13
As versões do Nginx <1.3.13 não têm suporte para websocket integrado.

Para fornecer suporte de websocket para circus-web ao usar Nginx <1.3.13, você pode combinar
Nginx com verniz ou HAProxy. Ou seja, Nginx na frente da teia de circo, com verniz ou
HAProxy na frente do Nginx.

O exemplo abaixo mostra a configuração combinada de Nginix e Varnish necessária para proxy
circus-web e fornecer suporte para websocket.

nginx configuração:

circusweb_server a montante {
servidor 127.0.0.1:8080;
}

Servidor {
escute 8001;
nome do servidor _;

Localização /
proxy_set_header X-Forwarded-For $ proxy_add_x_forwarded_for;
proxy_set_header Host $ http_host;
proxy_redirect desligado;
proxy_pass http://circusweb_server;
}

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

Se você quiser mais opções de configuração Nginx, consulte http://wiki.nginx.org/HttpProxyModule.

Verniz configuração:

padrão de back-end {
.host = "127.0.0.1";
.port = "8001";
}

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

sub vcl_pipe {
if (req.http.atualização) {
definir bereq.http.upgrade = req.http.upgrade;
}
}

sub vcl_recv {
if (req.http.Upgrade ~ "(?i)websocket") {
definir req.backend = socket;
retorno (tubo);
}
}

No exemplo de configuração do Varnish acima, dois backends são definidos. Um servindo a web
console e um servindo as conexões de soquete. As solicitações do console da Web são vinculadas à porta
8001. A diretiva Nginx 'server' deve ser configurada para escutar na porta 8001.

As conexões de websocket são atualizadas e canalizadas diretamente para o processo circushttpd escutando
na porta 8080 por Varnish. ou seja, ignorando o proxy Nginx.

Ubuntu
Desde a versão 13.10 (Picante), o Ubuntu inclui o Nginx com suporte a websocket em seu próprio
repositórios. Para versões mais antigas, você pode instalar o Nginx>=1.3.13 do Nginx oficial
PPA estável, assim:

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

Proteger com senha circohttpd
Conforme explicado na página Segurança, executar circohttpd é bastante inseguro. Nós não fornecemos
qualquer segurança no próprio Circus, mas você pode proteger seu console no nível NGinx,
utilização http://wiki.nginx.org/HttpAuthBasicModule

Exemplo:

Localização /
proxy_set_header X-Forwarded-For $ proxy_add_x_forwarded_for;
proxy_set_header Host $ http_host;
proxy_set_header X-Forwarded-Host: $http_host;
proxy_set_header X-Forwarded-Proto: $esquema;
proxy_redirect desligado;
proxy_pass http://127.0.0.1: 8080;
auth_basic "Restrito";
auth_basic_user_file /caminho/para/htpasswd;
}

O htpasswd arquivo contém usuários e suas senhas, e um prompt de senha irá aparecer quando
você acessa o console.

Você pode usar o script htpasswd do Apache para editá-lo ou o script Python que eles fornecem em:
http://trac.edgewall.org/browser/trunk/contrib/htpasswd.py

No entanto, não há suporte nativo para o uso combinado de autenticação HTTP e
WebSockets (o servidor lançará códigos de erro HTTP 401). Uma solução é desabilitar tais
autenticação para o servidor socket.io.

Exemplo (precisa ser adicionado antes da regra anterior):

localização /socket.io {
proxy_set_header X-Forwarded-For $ proxy_add_x_forwarded_for;
proxy_set_header Host $ http_host;
proxy_set_header X-Forwarded-Host: $http_host;
proxy_set_header X-Forwarded-Proto: $esquema;
proxy_redirect desligado;
proxy_pass http://127.0.0.1: 8080;
}

Claro que é apenas uma maneira de proteger seu console web, você pode usar muitas outras
técnicas.

Estendendo da web consolá
Nós escolhemos garrafa para construir o webconsole, principalmente porque é um framework muito pequeno que
não faz muito. Dando uma olhada no código do console web, você eventualmente encontrará
fora que é muito simples de entender.

Veja como está dividido:

· O circohttpd.py contém as definições de "views" e algum código para lidar com o
conexão de soquete (via socketio).

· a controlador.py contém uma única classe que se encarrega de fazer a comunicação
com o controlador do circo. Permite ter uma API de alto nível mais agradável ao definir o
servidor web.

Se você quiser adicionar um recurso no console da Web, poderá reutilizar o código existente. UMA
algumas ferramentas estão à sua disposição para facilitar o processo:

· Existe um render_template função, que recebe os argumentos nomeados que você passa para ela e
passá-los para o renderizador de modelo e retornar o HTML resultante. Também passa alguns
variáveis ​​adicionais, como a sessão, a versão do circo e o cliente, se definido.

· Se você quiser rodar comandos e fazer um redirecionamento dependendo do resultado disso, você pode usar
da comando de execução função, que recebe um callable como primeiro argumento, uma mensagem no caso
de sucesso e um URL de redirecionamento.

O StatsNamespace A classe é responsável por gerenciar a comunicação do websocket no
lado do servidor. Sua documentação deve ajudá-lo a entender o que ele faz.

Trabalho com soquetes
O Circus pode vincular soquetes de rede e gerenciá-los como faz para processos.

A ideia principal é que um processo filho criado pelo Circus para executar um dos
comando pode herdar de todos os descritores de arquivo abertos.

É assim que o Apache ou o Unicorn funcionam, e muitas outras ferramentas por aí.

Objetivo
O objetivo de ter sockets gerenciados pelo Circus é poder gerenciar aplicativos de rede
no Circus exatamente como outros aplicativos.

Por exemplo, se você usar Circus com Meia -- um servidor WGSI, você pode obter um acesso muito rápido
servidor web rodando e gerenciando "Rede Trabalhadores" no Circus como você faria para qualquer outro
processo.

Dividir o gerenciamento de soquetes do próprio aplicativo de rede oferece muitas
oportunidades para dimensionar e gerenciar sua pilha.

Projeto
A essência do recurso é feita ligando o soquete e começando a ouvi-lo em
circo:

soquete de importação

meia = socket.socket(FAMÍLIA, TIPO)
sock.bind((HOST, PORTA))
meia.ouvir(BACKLOG)
fd = meia.fileno()

O Circus então mantém o controle de todos os fds abertos e deixa os processos executados como filhos
tenham acesso a eles se quiserem.

Se você criar um pequeno script de rede Python que pretende executar no Circus, ele pode
parece com isso:

soquete de importação
import sys

fd = int(sys.argv[1]) # pegando o FD do circo
meia = socket.fromfd(fd, FAMÍLIA, TIPO)

# lidando com um pedido de cada vez
enquanto True:
conn, addr = meia.aceitar()
pedido = conexão.recv(1024).
.. faça alguma coisa ..
conn.sendall(resposta)
conexão.close()

Então o Circus poderia funcionar assim:

[circo]
check_delay = 5
endpoint = tcp: //127.0.0.1: 5555
pubsub_endpoint = tcp: //127.0.0.1: 5556
stats_endpoint = tcp: //127.0.0.1: 5557

[observador: manequim]
cmd = mycoolscript $(circus.sockets.foo)
use_sockets = Verdadeiro
aquecimento_atraso = 0
numprocessos = 5

[soquete: foo]
hospedeiro = 127.0.0.1
porta = 8888

$(circo.sockets.foo) será substituído pelo valor FD assim que o soquete for criado e
ligado no 8888 porta.

OBSERVAÇÃO:
A partir do Circus 0.8 há uma sintaxe alternativa para evitar alguns conflitos com alguns
analisadores de configuração. Você pode escrever:

((circo.soquetes.foo))

Mundo real exemplo
Meia é o companheiro Circus perfeito se você deseja executar seu aplicativo WSGI.

Uma vez instalado, executando 5 Meinheld trabalhadores podem ser feitos criando um socket e
chamando o chaussette comando em um trabalhador, assim:

[circo]
endpoint = tcp: //127.0.0.1: 5555
pubsub_endpoint = tcp: //127.0.0.1: 5556
stats_endpoint = tcp: //127.0.0.1: 5557

[observador: web]
cmd = chaussette --fd $(circus.sockets.web) --backend meinheld mycool.app
use_sockets = Verdadeiro
numprocessos = 5

[socket: web]
hospedeiro = 0.0.0.0
porta = 8000

Ainda não publicamos benchmarks, mas um cluster Web gerenciado pela Circus com um Gevent ou
O back-end Meinheld é tão rápido quanto qualquer servidor WSGI pré-fork existente.

utilização construídas em plugins
Circus vem com alguns plugins embutidos. Esta seção apresenta esses plugins e seus
opções de configuração.

Estatísticas
usar definido como 'circus.plugins.statsd.StatsdEmitter'

Nome da Aplicação
o nome usado para identificar o prefixo do bucket para o qual emitir as estatísticas (será
prefixado com circo. e sufixado com .observador)

hospedeiro o host para postar os dados de estatísticas para

porta a porta em que o daemon statsd escuta

taxa de amostragem
se você preferir uma taxa de amostragem diferente de 1, você pode defini-la aqui

Estatísticas completas
Uma extensão no plugin Statsd que também publica as estatísticas do processo. Como tal
tem as mesmas opções de configuração que o Statsd e o seguinte.

usar definido para circus.plugins.statsd.FullStats

taxa_do_loop
a frequência que o plugin deve pedir as estatísticas em segundos. Padrão: 60.

Observador Redis
Este serviço observa um processo de redis para você, publica as informações no statsd
e se oferece para reiniciar o observador quando ele não reagir em um determinado tempo limite. Este plug-in
exige redis-py para correr.

Ele tem a mesma configuração do statsd e adiciona o seguinte:

usar definido para circus.plugins.redis_observer.RedisObserver

taxa_do_loop
a frequência que o plugin deve pedir as estatísticas em segundos. Padrão: 60.

redis_url
o banco de dados a ser verificado como um URL redis. Padrão: "redis://localhost:6379/0"

tempo limite
o tempo limite em segundos que a solicitação pode levar antes de ser considerada inativa.
O padrão é 5.

restart_on_timeout
o nome do processo a ser reiniciado quando a solicitação expirou. Sem reinicialização
acionado quando não dado. Padrão: Nenhum.

HttpObservador
Este serviço observa um processo http para você, pingando um determinado site regularmente.
Semelhante ao observador redis, ele oferece para reiniciar o observador em caso de erro. Isso requer
tornado para correr.

Ele tem a mesma configuração do statsd e adiciona o seguinte:

usar definido para circus.plugins.http_observer.HttpObserver

taxa_do_loop
a frequência que o plugin deve pedir as estatísticas em segundos. Padrão: 60.

verificar_url
o URL a ser verificado. Padrão: http://localhost/

tempo limite
o tempo limite em segundos que a solicitação pode levar antes de ser considerada inativa.
O padrão é 10.

restart_on_error
o nome do processo a ser reiniciado quando a solicitação expirou ou retornou qualquer
outro tipo de erro. Nenhum reinício acionado quando não dado. Padrão: Nenhum.

Observador de recursos
Este serviço observa os recursos de um determinado processo e aciona uma reinicialização quando
eles excedem certas limitações com muita frequência seguidas.

Ele tem a mesma configuração do statsd e adiciona o seguinte:

usar definido para circus.plugins.resource_watcher.ResourceWatcher

taxa_do_loop
a frequência que o plugin deve pedir as estatísticas em segundos. Padrão: 60.

observador
o observador que este observador de recursos deve cuidar. (anteriormente chamado
serviço mas a serviço agora está obsoleto)

max_cpu
A CPU máxima que um processo pode consumir (em %). Padrão: 90

min_cpu
A CPU mínima que um processo deve consumir (em %). Padrão: Nenhum (sem mínimo)
Você pode definir o min_cpu para 0 (zero), neste caso se um processo consumir exatamente
0% cpu, ele acionará um limite excedido.

max_mem
A quantidade de memória que um processo deste observador pode consumir. Padrão:
90. Se nenhuma unidade for especificada, o valor estará em %. Exemplo: 50 Se uma unidade é
especificado, o valor está em bytes. As unidades suportadas são B, K, M, G, T, P, E, Z, Y.
Exemplo: 250M

min_mem
A memória mínima que um processo deste observador deve consumir. Padrão: Nenhum (não
mínimo). Se nenhuma unidade for especificada, o valor estará em %. Exemplo: 50 Se uma unidade é
especificado, o valor está em bytes. As unidades suportadas são B, K, M, G, T, P, E, Z, Y.
Exemplo: 250M

limite_saúde
A saúde é a média de CPU e memória (em %) os processos dos observadores são
permitido consumir (em %). Padrão: 75

contagem_máx.
Com que frequência esses limites (cada um é contado separadamente) podem ser
excedido antes que uma reinicialização seja acionada. Padrão: 3

Exemplo:

[circo]
; ...

[observador: programa]
cmd = dormir 120

[plugin:meuplugin]
usar=circus.plugins.resource_watcher.ResourceWatcher
observador = programa
min_cpu = 10
máx_cpu = 70
min_mem = 0
máx_mem = 20

Cão de guarda
Plugin que liga um socket udp e aguarda mensagens de watchdog. Para "vigiado"
processos, o watchdog irá matá-los se eles não enviarem uma pulsação em um determinado
período de tempo materializado por loop_rate * max_count. (o circo será automaticamente
reinicie os processos ausentes no watcher)

Cada processo monitorado deve enviar mensagem udp pelo menos no loop_rate. O UDP
formato de mensagem é uma linha de texto, decodificada usando msg_regex parâmetro. O batimento cardíaco
mensagem DEVE conter pelo menos o pid do processo de envio da mensagem.

A lista de observadores monitorados é determinada pelo parâmetro observadores_regex no
configuração.

Parâmetros de configuração:

usar definido para circo.plugins.watchdog.WatchDog

taxa_do_loop
taxa de loop de watchdog em segundos. Em cada loop, o WatchDog procurará por "morto"
processos.

observadores_regex
regex para combinar nomes de observadores que devem ser monitorados pelo watchdog
(padrão: .* todos os observadores são monitorados)

msg_regex
regex para decodificar a mensagem de pulsação recebida em udp (padrão:
^(?P .*);(?P .*)$) o formato padrão é uma mensagem de texto simples:
pid; timestamp

contagem_máx.
número máximo de loops passados ​​sem receber nenhuma pulsação antes de reiniciar
processo (padrão: 3)

ip ip o watchdog irá ligar (padrão: 127.0.0.1)

porta porta em que o watchdog se ligará (padrão: 1664)

Agitando
Quando um trabalhador reinicia com muita frequência, dizemos que é agitando. Este plugin acompanha
do trabalhador reinicia e para o observador correspondente caso esteja batendo. Isto
plugin pode ser usado para parar automaticamente os trabalhadores que são reiniciados constantemente porque
eles não estão funcionando corretamente.

usar definido para circo.plugins.flapping.Flapping

tentativas
o número de vezes que um processo pode reiniciar, dentro de janela segundos, antes de
considerá-lo batendo (padrão: 2)

janela a janela de tempo em segundos para testar a oscilação. Se o processo reiniciar mais
do que tentativas vezes dentro dessa janela de tempo, consideramos um processo de oscilação.
(padrão: 1)

repetir em
tempo em segundos para esperar até tentarmos reiniciar um processo que foi
batendo. (padrão: 7)

max_retria
o número de vezes que tentamos iniciar um processo que estava oscilando, antes
abandonamos e paramos todo o observador. (padrão: 5) Defina como -1 para desabilitar
max_retry e tente novamente indefinidamente.

ativo definir se o plugin está ativo ou não (padrão: True). Se a bandeira global for
definido como False, o plugin não é iniciado.

As opções podem ser substituídas na seção do observador usando um batendo. prefixo. Por exemplo,
aqui está como você configuraria um max_retria valor para nginx:

[observador:nginx]
cmd = /caminho/para/nginx
batendo.max_retry = 2

[observador:meuscript]
cmd = ./meu_script.py

; ... outros observadores

[plugin: batendo]
use = circo.plugins.flapping.Flapping
max_retry = 5

CommandReloader
Este plugin reiniciará os observadores quando seu arquivo de comando for modificado. Ele funciona por
verificando o tempo de modificação e o caminho do arquivo apontado pelo cmd opção a cada
taxa_do_loop segundos. Isso pode ser útil ao desenvolver processos de trabalho ou até mesmo para
atualização de código em produção.

usar definido para circus.plugins.command_reloader.CommandReloader

taxa_do_loop
a frequência que o plugin deve verificar para modificação em segundos. Padrão: 1.

desenvolvimento
Embora o daemon Circus possa ser gerenciado com o comando circusd, é mais fácil tê-lo
iniciar na inicialização. Se o seu sistema suporta Upstart, você pode criar este script Upstart em
/etc/init/circus.conf.

inicie no sistema de arquivos e net-device-up IFACE=lo
parar no nível de execução [016]

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

Isso pressupõe que circusd.ini está localizado em /etc/circus/circusd.ini. Após a reinicialização, você
pode controlar o circusd com o comando service:

# start/stop/restart do circo de serviço

Se o seu sistema suporta systemd, você pode criar este arquivo de unidade systemd em
/etc/systemd/system/circus.service.service

[Unidade]
Description=Gerente de processo Circus
Depois=syslog.target network.target nss-lookup.target

[Serviço]
Tipo = simples
ExecReload=/usr/bin/circusctl recarregar
ExecStart=/usr/bin/circusd /etc/circus/circus.ini
Reiniciar = sempre
RestartSec = 5

[Instalar]
WantedBy = default.target

Uma reinicialização não é necessária se você executar o comando daemon-reload abaixo:

# systemctl --sistema daemon-reload

Então o circo pode ser gerenciado através de:

# systemctl iniciar/parar/status/recarregar circo

Receitas
Esta seção conterá receitas para implantar o Circus. Até lá você pode olhar para o Pete's
Fantoche receita ou na casa de Rémy Chefe de cozinha receita

Papa Extração Núcleo
Um problema comum aos gerenciadores de processos é que você não pode reiniciar o gerenciador de processos
sem reiniciar todos os processos que gerencia. Isso dificulta a implantação de um
nova versão do Circus ou novas versões de qualquer uma das bibliotecas das quais depende.

Se você estiver em um sistema do tipo Unix, o Circus pode usar o kernel do processo Papa. Quando usado, papai
irácriar um daemon de longa duração que servirá de anfitrião para quaisquer processos e sockets
você cria com ele. Se o circo for encerrado, Papa manterá tudo o que está hospedando.

instalação
Comece instalando o papai e definirproctitle módulos:

pip instalar papai
pip instalar setproctitle

O definirproctitle módulo é opcional. Será usado se estiver presente para renomear o daemon Papa
for topo e ps para algo como "papa daemon do circo". Se você não instalar o
definirproctitle módulo, esse título será a linha de comando do processo que o iniciou.
Muito confuso.

Depois que o Papa estiver instalado, adicione use_papa=verdadeiro aos seus processos e soquetes críticos.
Geralmente você quer hospedar todos os processos de sua pilha no Papa, e nenhum dos
Processos de suporte do Circus, como os plugins de flapping e stats.

[circo]
nível de log = informações

[observador: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
aquecimento_atraso = 3
Graceful_timeout = 10
max_retry = 5
único = verdadeiro
send_hup = verdadeiro
stop_signal = SAIR
stdout_stream.class = FileStream
stdout_stream.filename = /var/logs/web-server.log
stdout_stream.max_bytes=10000000
stdout_stream.backup_count = 10
stderr_stream.class=FileStream
stderr_stream.filename = /var/logs/web-server-error.log
stderr_stream.max_bytes = 1000000
stderr_stream.backup_count = 10
ativo = verdadeiro
use_papa = verdadeiro

[observador: registrador]
cmd = /my_service/env/bin/python logger.py executar
work_dir = /meu_serviço
Graceful_timeout = 10
único = verdadeiro
sinal_parada = INT
stdout_stream.class = FileStream
stdout_stream.filename = /var/logs/logger.log
stdout_stream.max_bytes=10000000
stdout_stream.backup_count = 10
stderr_stream.class=FileStream
stderr_stream.filename = /var/logs/logger.log
stderr_stream.max_bytes = 1000000
stderr_stream.backup_count = 10
prioridade = 50
use_papa = verdadeiro

[observador:web_app]
cmd = /meu_serviço/env/bin/uwsgi --ini uwsgi-live.ini --socket fd://$(circus.sockets.web) --stats 127.0.0.1:809$(circus.wid)
working_dir = /meu_serviço/web_app
Graceful_timeout=10
stop_signal = SAIR
use_sockets = Verdadeiro
stdout_stream.class = FileStream
stdout_stream.filename = /var/logs/web_app.log
stdout_stream.max_bytes=10000000
stdout_stream.backup_count = 10
stderr_stream.class=FileStream
stderr_stream.filename = /var/logs/web_app.log
stderr_stream.max_bytes = 1000000
stderr_stream.backup_count = 10
hooks.after_spawn = exemplos.uwsgi_lossless_reload.children_started
hooks.before_signal = exemplos.uwsgi_lossless_reload.clean_stop
hooks.extended_stats = exemplos.uwsgi_lossless_reload.extended_stats
prioridade = 40
use_papa = verdadeiro

[socket: web]
caminho = /my_service/sock/uwsgi
use_papa = verdadeiro

[plugin: batendo]
use = circo.plugins.flapping.Flapping
janela = 10
prioridade = 1000

OBSERVAÇÃO:
Se os processos Papa usarem algum soquete, esses soquetes também deverão usar papa.

Projeto Objetivo
O Papa foi projetado para ser muito minimalista em recursos e requisitos. Ele faz:

· Soquetes de partida e parada

· Fornecer um armazenamento de chave/valor

· Iniciar processos e retornar stdout, stderr e o código de saída

Isso não:

· Reiniciar processos

· Fornecer uma maneira de parar processos

· Fornecer qualquer informação sobre os processos que não estejam ou não em execução

O Papa não requer bibliotecas de terceiros para que possa ser executado apenas na biblioteca padrão do Python.
Pode fazer uso do definirproctitle pacote, mas que é usado apenas para fazer o título
mais bonita para ps e topo e não é essencial.

A funcionalidade foi reduzida ao mínimo para que você nunca precise reiniciar o
Papai daemon. A maior parte da funcionalidade foi enviada para a biblioteca cliente
possível. Dessa forma, você poderá implantar uma nova cópia do Papa para novos recursos do cliente
sem precisar reiniciar o daemon Papa. Papa deve ser um pilar de estabilidade na
um mar de bibliotecas de terceiros em constante mudança.

Divisão de
A maioria das coisas permanece inalterada, quer você use Papa ou não. Você ainda pode começar e parar
processos. Você ainda pode obter status e estatísticas para processos. A principal coisa que muda
é que quando você faz circo desistir, todos os processos Papa são deixados em execução. Quando você
começo circo backup, esses processos são recuperados.

OBSERVAÇÃO:
Quando os processos são recuperados, antes_iniciar e antes_spawn ganchos são ignorados.

Logging
Enquanto o Circus estiver desligado, o Papa armazenará até 2M de saída por processo. Então vai
comece a despejar os dados mais antigos. Quando você reiniciar o Circus, esta saída em cache será rapidamente
recuperados e enviados para os fluxos de saída. Papa exige que o recebimento da saída seja
reconhecido, então você não deve perder nenhuma saída durante um desligamento.

Não apenas isso, mas o Papa salva o timestamp da saída. O circo foi aprimorado para
aproveitar os dados de carimbo de data/hora, se presentes. Então, se você estiver gravando a saída em arquivos de log
ou em algum lugar, seus timestamps devem estar todos corretos.

Problemas
Se você usar o aumento or diminuir comando para alterar a contagem de processos para um observador, isso
ser redefinido para o nível especificado no arquivo INI quando circo é reiniciado.

Além disso, tive problemas com a combinação de copy_env e virtualenv. Você pode
observe que o exemplo INI acima contorna esse problema com caminhos explícitos.

Telnet Interface
O Papa tem uma interface básica de linha de comando que você pode acessar por telnet:

host local telnet 20202
ajudar

Circo for desenvolvedores
utilização Circo as a biblioteca
Circus fornece classes e funções de alto nível que permitem gerenciar processos em
seus próprios aplicativos.

Por exemplo, se você deseja executar quatro processos para sempre, pode escrever:

de circo importação get_arbiter

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

árbitro = get_arbiter([meuprograma])
tente:
árbitro.start()
finalmente:
árbitro.stop()

Este snippet executará quatro instâncias de meu programa e assista-os para você, reiniciando-os
se eles morrerem inesperadamente.

Para saber mais sobre isso, consulte biblioteca

Estendendo Circo
É fácil estender o Circus para criar um sistema mais complexo, ouvindo todos os
circo eventos por meio de seu canal pub/sub e conduzindo-o por meio de comandos.

É assim que o recurso de flapping funciona, por exemplo: ele ouve todos os processos morrendo,
mede a frequência com que isso acontece e interrompe os observadores incriminados após muitas reinicializações
tentativas.

O Circus vem com um sistema de plug-ins para ajudá-lo a escrever essas extensões e alguns
plugins que você pode reutilizar. Veja plug-ins.

Você também pode ter um comportamento de inicialização e desligamento mais sutil usando o ganchos sistema.
que permitirá que você execute código arbitrário antes e depois de alguns processos serem iniciados ou
parado. Veja ganchos.

Por último, mas não menos importante, você também pode adicionar novos comandos. Consulte adicionando cmds.

Desenvolvedores Documentação Índice
Circo Biblioteca
O pacote Circus é composto por um pacote de alto nível get_arbiter() função e muitas classes. Dentro
maioria dos casos, usar a função de alto nível deve ser suficiente, pois cria tudo o que
é necessário para o Circus funcionar.

Você pode subclassificar as classes do Circus se precisar de mais granularidade do que o oferecido pelo
configuração.

O get_arbiter função
get_arbiter() é apenas uma conveniência em cima das várias aulas de circo. Ele cria um
árbitro (classe Árbitro) com as opções fornecidas, que por sua vez executa um único
Observador com um único Extração.

circo.get_arbiter()

Exemplo:

de circo importação get_arbiter

árbitro = get_arbiter([{"cmd": "meuprograma", "numprocesses": 3}])
tente:
árbitro.start()
finalmente:
árbitro.stop()

Classes
Circus fornece uma série de classes que você pode usar para implementar seu próprio gerenciador de processos:

· Extração: envolve um processo em execução e fornece alguns auxiliares sobre ele.

· Observador: execute várias instâncias de Extração contra o mesmo comando. Gerenciar a morte e
vida dos processos.

· Árbitro: gere vários Observador.

classe circo.processo.Processo(nome, largura, cmd, args=Nenhum, working_dir=Nenhum, shell=Falso,
uid=Nenhum, gid=Nenhum, env=Nenhum, rlimits=Nenhum, executável=Nenhum, use_fds=Falso, observador=Nenhum,
spawn=Verdadeiro, pipe_stdout=Verdadeiro, pipe_stderr=Verdadeiro, close_child_stdout=Falso,
close_child_stderr=Falso)
Envolve um processo.

opções:

· wid: o identificador exclusivo do processo. Este valor será usado para substituir o $WID
string na linha de comando, se presente.

· cmd: o comando a ser executado. Pode conter qualquer uma das variáveis ​​disponíveis que são
sendo passado para esta classe. Eles serão substituídos usando a sintaxe do formato python.

· args: os argumentos para que o comando seja executado. Pode ser uma lista ou uma string. Se args is
uma string, ela é dividida usando shlex.split (). O padrão é Nenhum.

· executável: Quando o executável é fornecido, o primeiro item na sequência args
obtido de cmd ainda é tratado pela maioria dos programas como o nome do comando, que
pode então ser diferente do nome executável real. Torna-se a exibição
nome para o programa em execução em utilitários como ps.

· work_dir: o diretório de trabalho para executar o comando. Se não for fornecido,
padrão para o diretório de trabalho atual.

· concha: E se a Verdadeira, executará o comando no ambiente shell. Falso por padrão.
Atenção: esse is a segurança perigo.

· uid: se fornecido, é o ID do usuário ou nome com o qual o comando deve ser executado. O actual
uid é o padrão.

· guia: se fornecido, é o id ou nome do grupo com o qual o comando deve ser executado. O actual
gid é o padrão.

· env: um mapeamento contendo as variáveis ​​de ambiente com as quais o comando será executado.
Opcional.

· limites: um mapeamento contendo nomes e valores rlimit que serão definidos antes do
o comando é executado.

· use_fds: se True, não fechará o fds no subprocesso. Deve ser definido para
True no Windows se stdout ou stderr forem redirecionados. padrão: falso.

· pipe_stdout: se True, abrirá um PIPE no stdout. padrão: Verdadeiro.

· pipe_stderr: se True, abrirá um PIPE no stderr. padrão: Verdadeiro.

· close_child_stdout: Se True, redireciona o stdout do processo filho para /dev/null
depois do garfo. padrão: falso.

· close_child_stderr: Se True, redireciona o stdout do processo filho para /dev/null
depois do garfo. padrão: falso.

era() Retorna a idade do processo em segundos.

crianças()
Retorna uma lista de pids filhos.

info () Informações do processo de devolução.

A informação retornada é um mapeamento com estas chaves:

· mem_info1: Memória de tamanho do conjunto residente em bytes (RSS)

· mem_info2: Tamanho da memória virtual em bytes (VMS).

· cpu: % de uso da CPU.

· mem: % de uso de memória.

· ctime: processa o tempo da CPU (usuário + sistema) em segundos.

· pid: identificação do processo.

· nome de usuário: nome de usuário que possui o processo.

· agradável: gentileza do processo (entre -20 e 20)

· cmdline: a linha de comando com a qual o processo foi executado.

é_filho(pid)
Return True é o dado pid é filho desse processo.

pid Devolver o pid

send_signal(*args, **k)
Envia um sinal sig para o processo.

send_signal_child(*args, **k)
Enviar sinal assinar para criança pid.

send_signal_children(*args, **k)
Enviar sinal assinar a todas as crianças.

estado Retornar o status do processo como uma constante

· CORRIDA

· MORTO_OU_ZOMBIE

· INEXISTENTE

· DE OUTROS

stderr Devolver o stdout transmitir canais

stdout Devolver o stdout transmitir canais

pare(*args, **k)
Pare o processo e feche stdout/stderr

Se o processo correspondente ainda estiver aqui (normalmente já foi morto por
o observador), um SIGTERM é enviado e, em seguida, um SIGKILL após 1 segundo.

O processo de desligamento (SIGTERM depois SIGKILL) é normalmente realizado pelo
observador. Então, se o processo ainda está lá, é um tipo de mau comportamento
porque o tempo limite normal não será respeitado aqui.

Exemplo:

>>> from circus.process Processo de importação
>>> processo = Process('Top', 'top', shell=True)
>>> processo.idade()
3.0107998847961426
>>> processo.info()
'Topo: 6812 N/A Tarek Zombie N/AN/AN/AN/AN/A'
>>> processo.status
1
>>> processo.stop()
>>> processo.status
2
>>> processo.info()
'Nenhum tal processo (parado?)'

classe circo.observador.Observador(nome, cmd, args=Nenhum, numprocessos=1, aquecimento_atraso=0.0,
working_dir=Nenhum, shell=Falso, shell_args=Nenhum, uid=Nenhum, max_retry = 5, gid=Nenhum,
send_hup=Falso, stop_signal = 15, stop_children=Falso, env=Nenhum, Graceful_timeout=30.0,
prereload_fn=Nenhum, rlimits=Nenhum, executável=Nenhum, stdout_stream=Nenhum, stderr_stream=Nenhum,
prioridade=0, loop=Nenhum, singleton=Falso, use_sockets=Falso, copy_env=Falso,
copy_path=Falso, max_idade=0, max_age_variance=30, ganchos=Nenhum, respawn=Verdadeiro, autostart=Verdadeiro,
on_demand=Falso, virtualenv=Nenhum, close_child_stdout=Falso, close_child_stderr=Falso,
virtualenv_py_ver=Nenhum, use_papa=Falso, **opções)
Classe que gerencia uma lista de processos para um determinado comando.

opções:

· nome: nome dado ao observador. Usado para identificá-lo exclusivamente.

· cmd: o comando a ser executado. Pode conter $WID, que será substituído por wid.

· args: os argumentos para que o comando seja executado. Pode ser uma lista ou uma string. Se args is
uma string, ela é dividida usando shlex.split (). O padrão é Nenhum.

· numprocessos: Número de processos a serem executados.

· work_dir: o diretório de trabalho para executar o comando. Se não for fornecido,
padrão para o diretório de trabalho atual.

· concha: E se a Verdadeira, executará o comando no ambiente shell. Falso por padrão.
Atenção: esse is a segurança perigo.

· uid: se fornecido, é o ID do usuário ou nome com o qual o comando deve ser executado. O actual
uid é o padrão.

· guia: se fornecido, é o id ou nome do grupo com o qual o comando deve ser executado. O actual
gid é o padrão.

· enviar_hup: se True, será feito um recarregamento do processo enviando o sinal SIGHUP.
Padrões para Falso.

· sinal_de_parada: o sinal a enviar ao parar o processo. O padrão é SIGTERM.

· parar_crianças: envie o sinal_de_parada para as crianças também. Padrões para Falso.

· env: um mapeamento contendo as variáveis ​​de ambiente com as quais o comando será executado.
Opcional.

· limites: um mapeamento contendo nomes e valores rlimit que serão definidos antes do
o comando é executado.

· stdout_stream: um mapeamento que define o fluxo para o processo stdout. Padrões
para Nenhum.

Opcional. Quando fornecido, stdout_stream é um mapeamento contendo até três chaves:

· classe: a classe de fluxo. Padrões para circo.stream.FileStream

· nome do arquivo: o nome do arquivo, se estiver usando um FileStream

· max_bytes: tamanho máximo do arquivo, após o qual um novo arquivo de saída é aberto. padrões
para 0, o que significa que não há tamanho máximo (aplicável apenas com FileStream).

· contagem_de_backup: quantos backups reter ao girar arquivos de acordo com o
parâmetro max_bytes. o padrão é 0, o que significa que nenhum backup é feito (somente
aplicável com FileStream)

Esse mapeamento será usado para criar um fluxo que pode ser chamado da classe especificada.
Cada entrada recebida pelo callable é um mapeamento contendo:

· pid - o processo pid

· nome - o nome do fluxo (stderr or stdout)

· dados, - os dados

Isso não é suportado no Windows.

· stderr_stream: um mapeamento que define o fluxo para o processo stderr. Padrões
para Nenhum.

Opcional. Quando fornecido, stderr_stream é um mapeamento contendo até três chaves:
- classe: a classe de fluxo. Padrões para circo.stream.FileStream - nome do arquivo:
nome do arquivo, se estiver usando um FileStream - max_bytes: tamanho máximo do arquivo, após o qual um novo
arquivo de saída é
aberto. padrão para 0, o que significa que não há tamanho máximo (aplicável apenas com
Fluxo de arquivos)

· contagem_de_backup: quantos backups reter ao girar arquivos de acordo com o
parâmetro max_bytes. o padrão é 0, o que significa que nenhum backup é feito (somente
aplicável com FileStream).

Esse mapeamento será usado para criar um fluxo que pode ser chamado da classe especificada.

Cada entrada recebida pelo callable é um mapeamento contendo:

· pid - o processo pid

· nome - o nome do fluxo (stderr or stdout)

· dados, - os dados

Isso não é suportado no Windows.

· prioridade -- inteiro que define uma prioridade para o observador. Quando o Árbitro faz
algumas operações em todos os observadores, ele irá classificá-los com este campo, do
número maior para o menor. (padrão: 0)

· coisa única -- Se True, este observador tem um único processo. (padrão: Falso)

· use_sockets -- Se True, os processos herdarão os descritores de arquivo, podendo assim
reutilizar as tomadas abertas pelo circusd. (padrão: Falso)

· sob demanda -- Se True, os processos serão iniciados apenas na primeira conexão
para o soquete (padrão: False)

· copy_env -- Se True, o ambiente em que o circo está rodando será
reproduzido para os trabalhadores. O padrão é True no Windows, pois você não pode executar
qualquer executável sem o RAIZ DO SISTEMA variável. (padrão: Falso)

· copy_path -- Se for verdade, circusd caminho do sistema é enviado para o processo através PITONPATO.
Você deve ativar copy_env for copy_path trabalhar. (padrão: Falso)

· max_idade: Se definido após cerca de max_age segundos, o processo é substituído por um novo
0. (padrão: XNUMX, Desativado)

· max_age_variance: o número máximo de segundos que podem ser adicionados a max_age.
Esse valor extra é para evitar reiniciar todos os processos ao mesmo tempo. UMA
processo viverá entre max_age e max_age + max_age_variance segundos.

· ganchos: funções de retorno de chamada para conectar-se à inicialização e desligamento do observador
processo. ganchos é um dict onde cada chave é o nome do gancho e cada valor é um
2-tupla com o nome do callable ou o próprio callabled e um sinalizador booleano
indicando se uma exceção que ocorre no gancho não deve ser ignorada. Possível
valores para o nome do gancho: antes_iniciar, após_início, antes_spawn, depois_spawn,
antes_parada, depois_parada., sinal_antes, pós_sinal or extend_stats.

· opções -- opções extras para o trabalhador. Todas as opções encontradas na configuração
por exemplo, são passados ​​neste mapeamento -- isso pode ser usado por plugins para
opções específicas do observador.

· reaparecimento -- Se definido como False, os processos manipulados por um observador não serão
ressurgiu automaticamente. (padrão: Verdadeiro)

· virtualenv -- O diretório raiz de um virtualenv. Se fornecido, o observador
carregue o ambiente para sua execução. (padrão: Nenhum)

· close_child_stdout: Se True, fecha o stdout após a bifurcação. padrão: falso.

· close_child_stderr: Se True, fecha o stderr após o fork. padrão: falso.

· use_papa: Se True, use o kernel do processo papa para este processo. padrão: falso.

kill_process(*args, ** kwargs)
Matar processo (stop_signal, graceful_timeout e SIGKILL)

kill_processes(*args, ** kwargs)
Mate todos os processos (stop_signal, graceful_timeout e SIGKILL)

gerenciar_processos(*args, ** kwargs)
Gerenciar processos.

notify_event(tópico, mensagem)
Publicar uma mensagem no canal do editor de eventos

reap_and_manage_processes(*args, ** kwargs)
Colher e gerenciar processos.

reap_processes(*args, **k)
Colha todos os processos para este observador.

send_signal_child(*args, **k)
Enviar sinal para uma criança.

spawn_process(recovery_wid=Nenhum)
Processo de desova.

Retorna True se ok, False se o observador deve ser parado

spawn_processes(*args, ** kwargs)
Gerar processos.

classe circo.árbitro.Árbitro(observadores, ponto final, pubsub_endpoint, verificação_atraso = 1.0,
prereload_fn=Nenhum, contexto=Nenhum, loop=Nenhum, statsd=Falso, stats_endpoint=Nenhum,
statsd_close_outputs=Falso, multicast_endpoint=Nenhum, plugins=Nenhum, soquetes=Nenhum,
aquecimento_atraso=0, httpd=Falso, httpd_host='localhost', httpd_port=8080,
httpd_close_outputs=Falso, debug=Falso, debug_gc=Falso, ssh_server=Nenhum,
proc_name='circusd', pidfile=Nenhum, loglevel=Nenhum, logooutput=Nenhum, loggerconfig=Nenhum,
fqdn_prefix=Nenhum, umask=Nenhum, endpoint_owner=Nenhum, papa_endpoint=Nenhum)
Classe usada para controlar uma lista de observadores.

opções:

· observadores -- uma lista de objetos Watcher

· Ponto final -- o terminal ZMQ do controlador

· pubsub_endpoint -- o ponto final do pubsub

· estatísticasd -- Se True, um processo circusd-stats é executado (padrão: False)

· stats_endpoint -- o ponto final das estatísticas.

· estatísticasd_close_outputs -- se True envia o circusd-stats stdout/stderr para
/dev/null (padrão: False)

· multicast_endpoint -- o endpoint multicast para descoberta automática de cluster circusd
(padrão: udp://237.219.251.97:12027) O endereço de multicast deve estar entre 224.0.0.0
para 239.255.255.255 e o mesmo para todos os clusters.

· check_delay -- o atraso entre dois pontos do controlador (padrão: 1 s)

· prereload_fn -- callable que será executado em cada recarregamento (padrão: Nenhum)

· contexto -- se fornecido, o contexto zmq a ser reutilizado. (padrão: Nenhum)

·

loop: if forneceu, a zmq.eventloop.ioloop.IOLoop instância
para reutilizar. (padrão: Nenhum)

· plugins -- uma lista de plugins. Cada item é um mapeamento com:

· usar -- Nome totalmente qualificado que aponta para a classe do plugin

· todos os outros valores são passados ​​para o plugin no configuração opção

· soquetes -- um mapeamento de soquetes. Cada chave é o nome do soquete e cada valor um
CircusSocket classe. (padrão: Nenhum)

· aquecimento_atraso -- um atraso em segundos entre a inicialização de dois observadores. (padrão: 0)

· httpd -- Se True, um processo circushttpd é executado (padrão: False)

· httpd_host -- o host circushttpd (padrão: localhost)

· httpd_port -- a porta circushttpd (padrão: 8080)

· httpd_close_outputs -- se True, envia circushttpd stdout/stderr para /dev/null.
(padrão: falso)

· depurar -- se True, adiciona muitas informações de depuração no stdout (padrão: False)

· debug_gc -- se True, faz gc.set_debug(gc.DEBUG_LEAK) (padrão: False) para circusd
para analisar problemas (padrão: False)

· nome_proc -- o nome do processo de arbitragem

·

fqdn_prefix -- a prefixo for da único identificador of da circo
instância no cluster.

· endpoint_owner -- usuário unix para chown o ponto de extremidade se estiver usando ipc.

· papa_endpoint -- o ponto de extremidade do kernel do processo papa

add_watcher(*args, ** kwargs)
Adiciona um observador.

opções:

· nome: nome do observador a ser adicionado

· cmd: comando para executar.

· todas as outras opções definidas no construtor Watcher.

get_watcher(nome)
Devolva o observador nome.

numprocessos()
Retorna o número de processos em execução em todos os observadores.

numwatchers()
Retorna o número de observadores.

recarregar(*args, ** kwargs)
Recarrega tudo.

execute o prereload_fn() pode ser chamado se houver, então recarregue todos os observadores graciosamente.

inicio(*args, ** kwargs)
Inicia todos os observadores.

Se o ioloop foi fornecido durante a chamada __init__(), inicia todos os observadores
como uma corrotina padrão

Se o ioloop não foi fornecido durante a chamada __init__() (padrão), inicia
todos os observadores e o eventloop (e blocos aqui). Neste modo o método
NÃO DEVE render nada porque é chamado como um método padrão.

Parâmetros Técnicos
cb -- Callback chamado após todos os watchers terem sido iniciados, quando
o loop não foi fornecido.

Escrevendo plugins
Circus vem com um sistema de plugins que permite interagir com circo.

OBSERVAÇÃO:
Podemos adicionar suporte circusd-stats a plugins mais tarde.

Um Plugin é composto de duas partes:

· um assinante ZMQ para todos os eventos publicados por circo

· um cliente ZMQ para enviar comandos para circo

Cada plugin é executado como um processo separado sob um observador personalizado.

Alguns exemplos de alguns plugins que você pode criar com este sistema:

· um sistema de notificação que envia alertas por e-mail quando um observador está batendo asas

· um registrador

· uma ferramenta que adiciona ou remove processos dependendo da carga

· Etc.

O próprio Circus vem com alguns plugins embutidos.

O Plugin Circus classe
Circus fornece uma classe base para ajudá-lo a implementar plugins: circus.plugins.CircusPlugin

classe circus.plugins.CircusPlugin(ponto final, pubsub_endpoint, check_delay, ssh_server=Nenhum,
**configuração)
Classe base para escrever plugins.

opções:

· contexto -- o contexto ZMQ a ser usado

· Ponto final -- o endpoint ZMQ circusd

· pubsub_endpoint -- o endpoint de publicação/sub do ZMQ circusd

· check_delay -- o atraso de verificação configurado

· configuração -- mapeamento de configuração gratuito

chamada(comando, **adereços)
Envia o comando para circo

opções:

· comando -- o comando para chamar

· adereços -- argumentos de palavra-chave para adicionar à chamada

Retorna o mapeamento JSON enviado de volta por circo

cast(comando, **adereços)
Dispare e esqueça um comando para circo

opções:

· comando -- o comando para chamar

· adereços -- argumentos de palavra-chave para adicionar à chamada

handle_init()
Chamado logo antes de um plugin ser iniciado - no contexto do thread.

handle_recv(dados)
Recebe todos os eventos publicados por circo

opções:

· dados, -- uma tupla contendo o tópico e a mensagem.

handle_stop()
Chamado logo antes do plugin ser interrompido pelo Circus.

Quando inicializada pelo Circus, esta classe cria seu próprio event loop que recebe todos os
circo eventos e passá-los para handle_recv(). Os dados recebidos são uma tupla contendo o
tópico e os dados em si.

handle_recv() devo ser implementado pelo plugin.

O ligar() e elencar() métodos podem ser usados ​​para interagir com circo se você está construindo um
Plugin que interage ativamente com o daemon.

handle_init() e handle_stop() são apenas métodos de conveniência que você pode usar para inicializar e
limpe seu código. handle_init() é chamado dentro do thread que acabou de ser iniciado.
handle_stop() é chamado no encadeamento principal logo antes do encadeamento ser interrompido e unido.

Escrevendo a plug-in
Vamos escrever um plugin que registre em um arquivo todos os eventos que acontecem em circo. É preciso um
argumento que é o nome do arquivo.

O plugin pode ficar assim:

de circus.plugins importar CircusPlugin

registrador de classe (CircusPlugin):

nome = 'registrador'

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

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

def handle_stop(self):
self.arquivo.close()

def handle_recv(auto, dados):
watcher_name, ação, msg = self.split_data(data)
msg_dict = self.load_message(mensagem)
self.file.write('%s %s::%r\n' % (ação, watcher_name, msg_dict))

É isso ! Esta classe pode ser salva em qualquer pacote/módulo, desde que possa ser vista por
Python

Por exemplo, nos Logger pode ser encontrado em um plugins módulo dentro de um meu projeto pacote.

Assíncrono pedidos
Caso você queira fazer alguma operação assíncrona (como uma chamada de Tornado ou usando
periodCall) certifique-se de estar usando o loop correto. O loop que você sempre quer usar
é self.loop conforme é configurado pela classe base. O loop padrão geralmente não é o mesmo
e, portanto, o código pode não ser executado conforme o esperado.

tentando a plug-in
Você pode executar um plugin através da linha de comando com o plug-in de circo comando, por
especificando o nome totalmente qualificado do plug-in:

$ circus-plugin --endpoint tcp://127.0.0.1:5555 --pubsub tcp://127.0.0.1:5556 --config nome do arquivo:circus-events.log myproject.plugins.Logger
[INFO] Carregando o plugin...
[INFO] Endpoint: 'tcp://127.0.0.1:5555'
[INFO] Pub/sub: 'tcp://127.0.0.1:5556'
[INFO] Começando

Outra maneira de executar um plugin é deixar o Circus lidar com sua inicialização. Isso é feito por
adicionando um [plug-in:NOME] seção no arquivo de configuração, onde NOME é um nome único para
seu plug-in:

[plugin: registrador]
use = meuprojeto.plugins.Logger
nome do arquivo = /var/myproject/circus.log

usar é obrigatório e aponta para o nome totalmente qualificado do plugin.

Quando o Circus é iniciado, ele cria um watcher com um processo que executa a classe apontada e
passe qualquer outra variável contida na seção para o construtor do plugin através do configuração
mapeamento.

Você também pode adicionar plugins programaticamente ao criar um circo.árbitro.árbitro classe
ou uso circo.get_arbiter(), consulte biblioteca.

Performances
Como cada plug-in é carregado em seu próprio processo, isso não deve afetar o desempenho geral
performances do sistema desde que o trabalho feito pelo plugin não esteja fazendo muitos
chamadas para o circo processo.

Gancho para Bolsas
Circus fornece ganchos que podem ser usados ​​para acionar ações em eventos de observador. Disponível
ganchos são:

· antes_iniciar: chamado antes do watcher ser iniciado. Se o gancho retornar Falso da
inicialização é abortada.

· após_início: chamado após o watcher ser iniciado. Se o gancho retornar Falso o vigia
é imediatamente interrompido e a inicialização é abortada.

· antes_spawn: chamado antes que o observador gere um novo processo. Se o gancho retornar Falso
o observador é imediatamente interrompido e a inicialização é abortada.

· depois_spawn: chamado após o watcher gerar um novo processo. Se o gancho retornar Falso
o observador é imediatamente interrompido e a inicialização é abortada.

· antes_parada: chamado antes que o observador seja interrompido. O resultado do gancho é ignorado.

· depois_parada: chamado depois que o observador é interrompido. O resultado do gancho é ignorado.

· sinal_antes: chamado antes de um sinal ser enviado ao processo de um observador. Se o gancho
Retorna Falso o sinal não é enviado (exceto SIGKILL que é sempre enviado)

· pós_sinal: chamado depois que um sinal é enviado ao processo de um observador.

· extend_stats: chamado quando as estatísticas são solicitadas com extended=True. Usado para adicionar
estatísticas específicas do processo para a saída regular de estatísticas.

Exemplo
Um caso de uso típico é controlar que todas as condições sejam atendidas para que um processo seja iniciado.
Digamos que você tenha um observador que execute Redis e um observador que executa um script Python que
trabalha com Redis. Com Circus você pode ordenar a inicialização usando o prioridade opção:

[observador:trabalhador da fila]
cmd = python -u trabalhador.py
prioridade = 1

[observador: redis]
cmd = servidor redis
prioridade = 2

Com esta configuração, o Circus iniciará Redis primeiro e, em seguida, ele iniciará o trabalhador de fila.
Mas o Circus realmente não controla isso Redis está em funcionamento. Ele apenas inicia o
processo que foi solicitado a iniciar. O que sentimos falta aqui é uma maneira de controlar isso Redis is
iniciado e totalmente funcional. Uma função que controla isso pode ser:

importar redis
tempo de importação

def check_redis(*args, **kw):
time.sleep(.5) # dá uma chance de começar
r = redis.StrictRedis(host='localhost', porta=6379, db=0)
r.set('foo', 'bar')
return r.get('foo') == 'bar'

Esta função pode ser conectada ao Circus como um antes_iniciar gancho:

[observador:trabalhador da fila]
cmd = python -u trabalhador.py
hooks.before_start=mycoolapp.myplugins.check_redis
prioridade = 1

[observador: redis]
cmd = servidor redis
prioridade = 2

Uma vez que o Circus começou a redis observador, ele iniciará o trabalhador de fila observador, desde
ele segue o prioridade encomenda. Pouco antes de iniciar o segundo observador, ele será executado
da check_redis função, e caso retorne Falso irá abortar o início do observador
processo.

Gancho assinatura
Um gancho deve seguir esta assinatura:

def hook(observador, árbitro, nome_do_gancho, **kwargs):
...
# Se você não retornar True, o gancho pode mudar
# o comportamento do circo (dependendo do gancho)
retornar verdadeiro

Onde observador é o Observador instância de classe, árbitro da Árbitro 1, nome_do_gancho O gancho
nome e kwargs alguns parâmetros opcionais adicionais (dependendo do tipo de gancho).

O depois_spawn hook adiciona os parâmetros pid:

def after_spawn(observador, árbitro, hook_name, pid, **kwargs):
...
# Se você não retornar True, o circus irá matar o processo
retornar verdadeiro

Onde pid é o PID do processo correspondente.

Da mesma forma, sinal_antes e pós_sinal hooks adicionam pid e signum:

def before_signal_hook(observador, árbitro, hook_name, pid, signum, **kwargs):
...
# Se você não retornar True, o circus não enviará o sinal signum
# (SIGKILL é sempre enviado)
retornar verdadeiro

Onde pid é o PID do processo correspondente e assinar é o sinal correspondente.

Você pode ignorá-los, mas poder usar os dados e métodos do observador e/ou árbitro pode
ser útil em alguns ganchos.

Observe que os ganchos são chamados com argumentos nomeados. Então use a assinatura do gancho sem
alterando os nomes dos argumentos.

O extend_stats hook tem seus próprios parâmetros adicionais em kwargs:

def extended_stats_hook(observador, árbitro, nome_do_gancho, pid, estatísticas, **kwargs):
...

Onde pid é o PID do processo correspondente e stats as estatísticas regulares a serem
devolvida. Adicione suas próprias estatísticas em stats. Um exemplo está em
exemplos/uwsgi_lossless_reload.py.py.

Como último exemplo, aqui está um super gancho que pode lidar com todos os tipos de sinais:

def super_hook(observador, árbitro, hook_name, **kwargs):
pid = Nenhum
signum = Nenhum
if hook_name in ('before_signal', 'after_signal'):
pid = kwargs['pid']
signum = kwargs['signum']
...
retornar verdadeiro

Gancho semelhantes
Toda vez que um gancho é executado, seu resultado é notificado como um evento no Circus.

Existem dois eventos relacionados aos ganchos:

· gancho_sucesso: um gancho foi chamado com sucesso. As teclas de eventos são nome o nome se
evento, e tempo: a data dos eventos.

· gancho_falha: um gancho falhou. As teclas de eventos são nome o nome se o evento, tempo:
a data dos eventos e erro: a exceção que ocorreu no evento, se houver.

Adicionando novo comandos
Tentamos tornar a adição de novos comandos o mais simples possível.

Você precisa fazer três coisas:

1. crie um seu_comando.py arquivo sob circo/comandos/.

2. Implemente uma única classe lá, com métodos predefinidos

3. Adicione o novo comando em circo/comandos/__init__.py.

Digamos que queremos adicionar um comando que retorne o número de observadores atualmente em uso,
faríamos algo assim (comentado extensamente para permitir que você siga mais
facilmente):

do comando circus.commands.base import
de circus.exc importar ArgumentError, MessageError
class NumWatchers(Comando):
"""É uma boa prática descrever o que a classe faz aqui.

Dê uma olhada em outros comandos para ver como estamos acostumados a formatar
esse texto. Ele será automaticamente incluído na documentação,
então não tenha medo de ser exaustivo, isso é o que é feito
para.
"" "
# todos os comandos herdam de `circus.commands.base.Command`

# você precisa especificar um nome para encontrarmos o comando de alguma forma
nome = "numwatchers"

# Defina a espera como True ou False para definir seu comportamento padrão
# - Se wait for True, o comando é executado de forma síncrona e o cliente pode obter
# resultados de volta.
# - Se wait for False, o comando é executado de forma assíncrona no servidor e no cliente imediatamente
# recebe uma resposta 'ok'
#
# Por padrão, os comandos são configurados para aguardar = False
esperando = Verdadeiro

# opções
options = [('', 'optname', default_value, 'description')]

propriedades = ['foo', 'bar']
# propriedades listam os argumentos de comando que são obrigatórios. Se eles são
# não fornecido, então um erro será lançado

def execute(self, árbitro, props):
# o método execute é o núcleo do comando: coloque aqui todos os
# lógica do comando e retorna um dict contendo os valores que você
# deseja retornar, se houver
return {"numwatchers": arbiter.numwatchers()}

def console_msg(self, mensagem):
# msg é o que é retornado pelo método execute.
# este método é usado para formatar a resposta para um console (é
# usado por exemplo por circusctl para imprimir suas mensagens)
return "uma string que será exibida"

def mensagem(self, *args, **opts):
# mensagem manipula a entrada do console.
# este método é usado para mapear os argumentos do console para o comando
# opções. (é usado, por exemplo, ao chamar o comando via
#circusctl)
# NotImplementedError será lançado se a função estiver ausente
numArgs = 1
se não len(args) == numArgs:
raise ArgumentError('Número inválido de argumentos.')
outro:
opts['optname'] = args[0]
retornar self.make_message(**opções)

def validar(self, props):
# este método é usado para validar que os argumentos passados ​​para o
# comando estão corretos. Um ArgumentError deve ser lançado no caso
# há um erro nos argumentos passados ​​(por exemplo, se eles
# não combinam.
# Caso haja algum problema com seu conteúdo, um MessageError
# deve ser lançado. Este método pode modificar o conteúdo dos adereços
# dict, ele será passado para execução depois.

Uso casos exemplos
Este capítulo apresenta alguns casos de uso, para dar uma ideia de como usar o Circus em seu
ambiente.

Corrida a WSGI Formulário on line
Executar um aplicativo WSGI com o Circus é bastante interessante porque você pode assistir e gerenciar
sua web trabalhadores utilização circo, circo ou a interface da Web.

Isso é possível usando soquetes Circus. Veja porquecircussockets.

Vamos dar um exemplo com um mínimo Pirâmide aplicação:

do Configurador de importação de pirâmide.config
from Pyramid.response import Response

def hello_world(pedido):
return Response('Olá %(name)s!' % request.matchdict)

config = Configurador()
config.add_route('hello', '/hello/{name}')
config.add_view(hello_world, route_name='hello')
aplicativo = config.make_wsgi_app()

Salve este script em um aplicativo.py arquivo e instale esses projetos:

$ pip instalar pirâmide
$ pip instalar chaussette

Em seguida, verifique se você pode executar seu aplicativo Pyramid usando o chaussette script do console:

$ chaussette app.application
A aplicação é
Servindo no localhost: 8080
Usando como back-end

E verifique se você pode alcançá-lo visitando http://localhost:8080/olá/tarek

Agora que seu aplicativo está funcionando, vamos criar um arquivo de configuração do Circus:

[circo]
check_delay = 5
endpoint = tcp: //127.0.0.1: 5555
pubsub_endpoint = tcp: //127.0.0.1: 5556
stats_endpoint = tcp: //127.0.0.1: 5557

[observador: webworker]
cmd = chaussette --fd $(circus.sockets.webapp) app.application
use_sockets = Verdadeiro
numprocessos = 3

[socket: webapp]
hospedeiro = 127.0.0.1
porta = 8080

Este arquivo diz ao Circus para vincular um soquete na porta 8080 e corra chaussette trabalhadores nisso
socket -- passando seu fd.

Salvar em servidor.ini e tente executá-lo usando circo

$ circusd servidor.ini
[INFO] Iniciando mestre no pid 8971
[INFO] soquetes iniciados
[INFO] estatísticas de circo iniciadas
[INFO] webapp iniciado
[INFO] Árbitro agora aguardando comandos

Certifique-se de que você ainda tenha o aplicativo ativado http://localhost:8080/olá/tarek.

Parabéns ! você tem um aplicativo WSGI executando 3 trabalhadores.

Você pode executar o circushttpd ou o cli e aproveitar o gerenciamento do Circus.

Corrida a Django Formulário on line
Executar um aplicativo Django é feito exatamente como executar um aplicativo WSGI. Use o
PITONPATO para importar o diretório em que o projeto está, o diretório que contém o
diretório que tem settings.py nele (com Django 1.4+ este diretório tem manage.py nele)
:

[soquete:dwebapp]
hospedeiro = 127.0.0.1
porta = 8080

[observador:dwebworker]
cmd = chaussette --fd $(circus.sockets.dwebapp) dproject.wsgi.application
use_sockets = Verdadeiro
numprocessos = 2

[env:dwebworker]
PYTHONPATH = /caminho/para/pai-do-projeto

Se você precisa passar o DJANGO_SETTINGS_MODULE para um trabalhador de back-end, por exemplo, você pode
passar isso também embora o env opção de configuração:

[observador:dbackend]
cmd = /caminho/para/script.py
numprocessos=3

[env:dback-end]
PYTHONPATH = /caminho/para/pai-do-projeto
DJANGO_SETTINGS_MODULE=dproject.settings

See http://chaussette.readthedocs.org para saber mais sobre chaussette.

Projeto decisões
No geral arquitetura
[Imagem]

O circo é composto por um processo principal chamado circo que se encarrega de executar todos os
processos. Cada processo gerenciado pelo Circus é um processo filho de circo.

Os processos são organizados em grupos chamados observadores. UMA observador é basicamente um comando
circo roda em seu sistema, e para cada comando você pode configurar quantos processos você
quer correr.

O conceito de observador é útil quando você deseja gerenciar todos os processos que executam o
mesmo comando - como reiniciá-los, etc.

circo vincula dois soquetes ZeroMQ:

· REQ/REP -- um soquete usado para controlar circo usando baseado em json comandos.

· PUB/SUB -- uma tomada onde circo publica eventos, como quando um processo é iniciado ou
parado.

OBSERVAÇÃO:
Apesar do nome, ZeroMQ não é um sistema de gerenciamento de filas. Pense nisso como um
biblioteca de comunicação entre processos (IPC).

Outro processo chamado estatísticas de circo é administrado por circo quando a opção é ativada.
estatísticas de circoO trabalho de é publicar estatísticas de uso de CPU/memória em um PUB/SUB
canal.

Este canal especializado é usado por circo e circo-httpd para exibir uma transmissão ao vivo
da atividade.

circo é um script de console que imita topo para exibir todo o uso de CPU e memória de
os processos geridos pela Circus.

circo-httpd é a interface de gestão web que lhe permite interagir com o Circus. Isto
exibe uma transmissão ao vivo usando soquetes da web e o estatísticas de circo canal, mas também deixá-lo
interagir com circo através do seu REQ/REP canal.

Por último, mas não menos importante, circo é uma ferramenta de linha de comando que permite que você dirija circo através do seu
REQ/REP canal.

Você também pode ter plugins que se inscrevem circo's PUB/SUB canal e deixá-lo enviar
comandos para o REQ/REP canal como circo seria.

Segurança
O Circus é construído no topo da biblioteca ZeroMQ e vem sem nenhuma segurança em seu
protocolos. No entanto, você pode executar um sistema Circus em um servidor e configurar um túnel SSH para
acessá-lo de outra máquina.

Esta seção explica o que o Circus faz em seu sistema quando você o executa e acaba
descrevendo como usar um túnel SSH.

Você também pode ler http://www.zeromq.org/area:faq#toc5

TCP portas
Por padrão, o Circus abre as seguintes portas TCP no host local:

· 5555 -- a porta usada para controlar o circo via circo

· 5556 -- a porta usada para o canal Publicador/Assinante.

· 5557 -- a porta usada para o canal de estatísticas -- se ativado.

· 8080 -- a porta usada pela IU da Web -- se ativada.

Essas portas permitem que aplicativos clientes interajam com seu sistema Circus e, dependendo de como
sua infraestrutura está organizada, você pode querer proteger essas portas por meio de firewalls or
configurar o Circus para ser executado usando IPC Portos.

Aqui está um exemplo de execução do Circus usando apenas pontos de entrada IPC:

[circo]
check_delay = 5
ponto final = ipc:///var/circus/ponto final
pubsub_endpoint = ipc:///var/circus/pubsub
stats_endpoint = ipc:///var/circus/stats

Quando configurado usando IPC, os comandos devem ser executados da mesma caixa, mas ninguém pode
acessá-los de fora, ao contrário do TCP. Os comandos também devem ser executados como um usuário que
tem acesso de gravação aos caminhos do soquete ipc. Você pode modificar o proprietário do Ponto final utilização
da endpoint_owner opção de configuração. Isso permite que você execute o circusd como usuário root, mas
permitir que processos não raiz enviem comandos para circo. Observe que ao usar endpoint_owner,
para evitar que processos não raiz possam iniciar processos arbitrários que
executado com maiores privilégios, o comando add irá impor que novos Watchers devem ser executados como
da endpoint_owner do utilizador. As definições do observador nos arquivos de configuração locais não serão
restrito desta forma.

Claro, se você ativar a interface do usuário da Web, o 8080 a porta ainda estará aberta.

circohttpd
Quando você corre circohttpd manualmente, ou quando você usa o httpd opção no arquivo ini como
esta:

[circo]
check_delay = 5
ponto final = ipc:///var/circus/ponto final
pubsub_endpoint = ipc:///var/circus/pubsub
stats_endpoint = ipc:///var/circus/stats
httpd = 1

O aplicativo da web será executado na porta 8080 e permitirá que qualquer pessoa acesse a página da web
gerenciar o circo demônio.

Isso inclui a criação de novos observadores que podem executar qualquer comando em seu sistema!

Do não fazer it publicamente disponível

Se você deseja proteger o acesso ao painel da web, pode servi-lo por trás do Nginx ou
Apache ou qualquer servidor web com capacidade de proxy, que possa cuidar da segurança.

Utilizador e Grupo Permissões
Por padrão, todos os processos iniciados com Circus serão executados com o mesmo usuário e grupo
as circo. Dependendo dos privilégios que o usuário tem no sistema, você pode não ter
acesso a todos os recursos que o Circus oferece.

Por exemplo, alguns recursos de estatísticas em processos em execução requerem privilégios estendidos.
Normalmente, se os números de uso da CPU que você obtém usando o stats comando são N/D, isso significa o seu
usuário não pode acessar os arquivos proc. Este será o caso por padrão no Mac OS X.

Você pode correr circo como root para corrigir isso, e defina o uid e guia valores para cada observador
para obter todos os recursos.

Mas cuidado que correr circo pois o root expõe você a uma potencial escalada de privilégios
insetos. Enquanto estamos fazendo o nosso melhor para evitar bugs, rodando como root e enfrentando um bug que
executa ações indesejadas em seu sistema pode ser perigoso.

A melhor maneira de evitar isso é certificar-se de que o sistema que executa o Circus está completamente
isolado (como uma VM) or para executar todo o sistema sob um usuário controlado.

SSH tunneling
Os clientes podem se conectar a um circo instância criando um túnel SSH. Para isso, passe o
opção de linha de comando --ssh seguido usuário@endereço, Onde usuário é o usuário no controle remoto
servidor e endereço é o endereço do servidor visto pelo cliente. O protocolo SSH irá
exigem credenciais para concluir o login.

If circo como visto pelo servidor SSH não está no endereço de terminal padrão localhost: 5555
em seguida, especifique o circo endereço usando a opção --ponto final

Secured instalação exemplo
A configuração de um servidor Circus seguro pode ser feita por:

· Executando um servidor SSH

· Executando Apache ou Nginx no 80 porta, e fazendo um proxy reverso no 8080 porta.

· Bloqueando o 8080 porta de acesso externo.

· Executando todas as portas ZMQ Circusd usando arquivos IPC em vez de portas TCP e encapsulando todas
chamadas via SSH.
[Imagem]

Contribuindo para Circo
O Circus começou na Mozilla mas seu objetivo não é ficar só lá. Estavam tentando
para construir uma ferramenta que seja útil para outros e facilmente extensível.

Estamos realmente abertos a quaisquer contribuições, na forma de código, documentação, discussões,
proposta de recurso etc.

Você pode iniciar um tópico em nossa lista de discussão: http://tech.groups.yahoo.com/group/circus-dev/

Ou adicione um problema em nosso erro perseguidor

Fixação erros de digitação e aprimorando da documentação
É totalmente possível que seus olhos estejam sangrando ao ler este meio inglês
documentação meio francesa, não hesite em contribuir com qualquer reformulação / aprimoramento
o formulário na documentação. Você provavelmente nem precisa entender como o Circus funciona
sob o capô para fazer isso.

Adicionando novo características
Os novos recursos são, obviamente, muito apreciados. Se você tiver a necessidade e o tempo para
trabalhar em novos recursos, adicioná-los ao Circus não deve ser tão complicado. Nós tentamos muito
difícil ter uma API limpa e compreensível, espero que sirva ao propósito.

Você precisará adicionar documentação e testes junto com o código do novo recurso.
Caso contrário, não poderemos aceitar o patch.

Como para enviar sua alterar
Estamos usando o git como um DVCS. A melhor maneira de propor mudanças é criar uma ramificação em seu
lado (via git checkout -b nome do ramo) e confirme suas alterações lá. Uma vez que você tenha
algo pronto para o horário nobre, emita um pull request para este branch.

Estamos seguindo este modelo para permitir um baixo acoplamento entre os recursos que você está
propondo. Por exemplo, podemos aceitar um pull request enquanto ainda estamos em discussão
para outro.

Antes de propor suas alterações, verifique se elas não estão quebrando nada! Você pode
use o tox comando para garantir isso, ele executará o testsuite sob as diferentes
versões python suportadas.

Por favor, use : http://issue2pr.herokuapp.com/ para fazer referência a um compromisso com um circo existente
questão, se houver.

Evitando fundir compromete-se
Evitar commits de mesclagem permite ter um histórico limpo e legível. Para isso, em vez de
fazendo "git pull" e deixando o git manipular as mesclagens para você, usando git pull --rebase irá
coloque suas alterações após as alterações que são confirmadas na ramificação, ou ao trabalhar em
mestre.

Ou seja, para nós desenvolvedores principais, não é mais possível usar o prático github green
botão em pull requests se os desenvolvedores não reformularam seu trabalho ou se esperarmos
muito tempo entre a solicitação e a mesclagem real. Em vez disso, o fluxo fica assim:

git remote adicionar nome repo-url
git busca nome
git checkout feature-branch
mestre de rebase git

# verifica se tudo está funcionando corretamente e depois mescla no master
mestre de checkout git
git merge feature-branch

Discutindo
Se você precisar de ajuda enquanto procura o código do Circus, pode ir
e encontre-nos no irc em #tenda de circo on irc.freenode.org (ou se você não tiver nenhum IRC
cliente, uso da web chat)

Você também pode iniciar um tópico em nossa lista de discussão -
http://tech.groups.yahoo.com/group/circus-dev

Perguntas Perguntei Frequentes
Aqui está uma lista de perguntas frequentes sobre o Circus:

Como parece Circo pilha comparar para a clássico pilha?
Em uma pilha WSGI clássica, você tem um servidor como Gunicorn que serve em uma porta ou
soquete unix e geralmente é implantado atrás de um servidor web como o Nginx: [imagem]

Os clientes chamam o Nginx, que faz proxy reverso de todas as chamadas para o Gunicorn.

Se você quer ter certeza de que o processo Gunicorn continua funcionando, você tem que usar um
programa como Supervisord ou upstart.

Gunicorn, por sua vez, observa seus processos ("trabalhadores").

Em outras palavras, você está usando dois níveis de gerenciamento de processos. Um que você gerencia e
controle (supervisord), e um segundo que você deve gerenciar em uma interface de usuário diferente, com um
filosofia diferente e menos controle sobre o que está acontecendo (a do servidor wsgi)

Isso é verdade para o Gunicorn e para a maioria dos servidores WSGI multiprocessos que eu conheço.
uWsgi é um pouco diferente, pois oferece inúmeras opções.

Mas se você quiser adicionar um servidor Redis em sua pilha, você precisarão acabar com a gestão do seu
empilhar processos em dois lugares diferentes.

A abordagem da Circus sobre isso é gerenciar processos e tomadas.

Uma pilha Circus pode ser assim: [imagem]

Assim, como o Gunicorn, o Circus é capaz de vincular um soquete que será procurado pelo Nginx. Circo
não lida com as solicitações, mas simplesmente vincula o soquete. Cabe então a um web worker
processo para aceitar conexões no soquete e fazer o trabalho.

Ele fornece recursos equivalentes ao do Supervisord, mas também permite gerenciar todos os
processos no mesmo nível, sejam eles web workers ou Redis ou qualquer outra coisa. Adicionando um
novo web worker é feito exatamente como adicionar um novo processo Redis.

Bancos
Fizemos alguns bancos para comparar Circus & Chaussette com Gunicorn. Para resumir, o Circo é
sem adicionar nenhuma sobrecarga e você pode pegar muitos back-ends diferentes para seus trabalhadores da web.

Vejo:

· http://blog.ziade.org/2012/06/28/wgsi-web-servers-bench

· http://blog.ziade.org/2012/07/03/wsgi-web-servers-bench-part-2

Como para solucionar problemas Circo?
Por padrão, o circo mantém seu registro para stdout bastante escasso. Essa falta de saída pode
tornar as coisas difíceis de solucionar quando os processos parecem estar tendo problemas para iniciar.

Para aumentar o registro circo fornece, tente aumentar o nível de log. Para ver o
níveis de log disponíveis basta usar o --Socorro bandeira.

$ circus --log-level debug test.ini

Uma palavra de advertência. Se um processo estiver oscilando e o nível de log de depuração estiver ativado, você
verá mensagens para cada tentativa de partida. Pode ser útil configurar o aplicativo que está
batendo para usar um aquecimento_atraso para desacelerar as mensagens para um ritmo gerenciável.

[observador: webapp]
cmd = python -m meuapp.wsgi
aquecimento_atraso = 5

Por padrão, o stdout e stderr são capturados pelo circo processo. Se você estiver testando seu
config e deseja ver a saída alinhada com a saída circusd, você pode configurar seu
observador para usar o StdoutStreamName classe.

[observador: webapp]
cmd = python -m meuapp.wsgi
stdout_stream.class=StdoutStream
stderr_stream.class=StdoutStream

Se seu aplicativo está produzindo um traceback ou erro ao tentar inicializá-lo
deve ser capaz de vê-lo na saída.

Changelog história
0.12.1 - 2015-08-05
· Corrigir erro ao reiniciar um observador com um fluxo de saída - #913

· Pequenos ajustes de documentos

0.12 - 2015-06-02
Esta versão traz suporte para Python 3.4, Tornado 4 e Windows, entre vários
funcionalidades e correções.

O suporte do Windows ainda é experimental e não lida com fluxos.

Grandes mudanças:

· Compatibilidade com Python 3.4 - #768

· Suporte experimental ao Windows - #788

· Compatibilidade com Tornado 4 - #872

· Embalagem Debian renovada - #896 - #903

· Adicionar suporte para o kernel do processo Papa - #850

· Adicione correspondência de globing e regex para iniciar, parar e reiniciar observadores - #829 -
#902

Mais alterações:

· Otimização do desligamento - #784 - #842

· Adicionada a possibilidade de especificar a versão virtualenv para os observadores - #805

· Adicione a opção --nostop ao comando rmwatcher - #777

· Adicione um retorno de chamada ao Arbiter.start - #840

· Corrige o recarregamento de observadores com letras maiúsculas - #823

· Remova o soquete com vazamento no daemon de estatísticas - #843

· Corrigir multicast no SunOS - #876

· Fechar fluxos de saída ao parar um observador - #885

· Corrigir o envio de sinal para netos com --recursive - #888

0.11.1 - 2014-05-22
· Corrigida uma regressão que quebrou o Circus em 2.6 - #782

0.11 - 2014-05-21
Esta versão não está introduzindo muitos recursos e focada em tornar o Circus mais
robusto e estável.

Principais alterações/correções:

· Certifique-se de que não podemos executar dois comandos conflitantes no árbitro simultaneamente.

· temos 2 novas classes de streams: TimedRotatingFileStream, WatchedFileStream

· temos um novo gancho: gancho after_spawn

· CircusPlugin é mais fácil de usar

· corrigir autostart=Falso observador durante o início (regressão)

Mais alterações:

· mensagens de circo podem ser roteadas para syslog agora - #748

· opção endpoint_owner adicionada para que possamos definir qual usuário possui arquivos de soquete ipc criados por
circo.

· Suporte ao Windows iniciado (apenas circusctl por enquanto)

· corrigiu muitos vazamentos nos testes

· Permitir variáveis ​​de ambiente sensíveis a maiúsculas e minúsculas

· O plugin de recursos agora aceita valores absolutos de memória - #609

· Adicionar suporte ao comando add para a opção 'singleton' - #767

· Permitir o envio de sinais arbitrários para procs filho via observador de recursos - #756

· Permitir configuração INI/JSON/YAML para registro

· Verifique se somos compatíveis com psutil 2.x e 3.x

· Adicionadas mais métricas ao provedor statsd - #698

· Descoberta multicast corrigida - #731

· Dê partida, reinicie e recarregue de forma mais uniforme - #673

· Inicialize corretamente todos os grupos de uso - #635

· estabilidade de testes melhorada

· muitas, muitas outras coisas....

0.10 - 2013-11-04
Grandes mudanças:

· Agora compatível com Python 3.2 e 3.3 - #586

· Movido o núcleo para um modelo totalmente assíncrono - #569

· Documentação melhorada - #622

Mais alterações:

· Adicionado stop_signal & stop_children - #594

· Certifique-se de que o plugin watchdog fecha os soquetes - #588

· Alterado para o analisador ZMQ JSON

· IN não suportado em todas as plataformas - #573

· Permitir substituições globais de ambiente em qualquer seção de configuração - #560

· Permitir traços nos nomes das seções - #546

· Agora as variáveis ​​são expandidas em todos os lugares da configuração - #554

· Adicionado o plugin CommandReloader

· Adicionados ganchos before_signal e after_signal

· Permitir que o plugin flapping tente novamente indefinidamente

· Não respawn procs quando o watcher está parando - #529 - #536

· Adicionado um id exclusivo para cada mensagem do cliente - #517

· IDs de trabalhadores agora são "slots" -

· Corrigido o comportamento de desligamento normal - #515

· Certifique-se de que podemos adicionar observadores mesmo que o árbitro não seja iniciado - #503

· Certifique-se de abrir o processo expirado - #510

· Certifique-se de que o comando set pode definir vários ganchos

· Suporta corretamente soquetes ipv6 - #507

· Permitir opções personalizadas para stdout_stream e stderr_stream - #495

· Adicionado time_format para FileStream - #493

· Adicionada nova opção de configuração de soquete para vincular a uma interface específica por nome

0.9.3 - 2013-09-04
· Certifique-se de que podemos adicionar observadores mesmo que o árbitro não seja iniciado

· Certifique-se de abrir o processo expirado

· Certifique-se de que o comando set pode definir um ou vários ganchos

· Suporta corretamente soquetes ipv6 e melhorias de CircusSockets

· Dê o valor padrão do caminho para evitar UnboundLocalError

· Adicionado um teste para a existência multicast_endpoint na inicialização do Controller

· Não convertendo mais cada string de dígitos para inteiros

· Adicionar testes

· Não há necessidade de casos especiais ao converter opções stdout_stream

· também aceita umask como argumento para consistência

· Permitir opções personalizadas para stdout_stream e stderr_stream.

· Adicionar nova opção de configuração de soquete para vincular a uma interface específica por nome

· Adicionar time_format para FileStream + testes

· Atualizar circus.upstart

0.9.2 - 2013-07-17
· Quando um PYTHONPATH é definido em um arquivo de configuração, ele é carregado em sys.path para que os ganchos possam ser
localizado lá - # 477, # 481

· Use um único argumento para add_callback para que funcione com PyZMQ < 13.1.x - veja #478

0.9 - 2013-07-16
· adicionados curingas de seções [env]

· adicionada seção global [env]

· corrigida exceção oculta quando o circus-web não está instalado - #424

· certifique-se de que os comandos incr/decr realmente usem a opção nb - #421

· Corrige pacotes de site virtualenv do watcher que não estão em PYTHONPATH

· certifique-se de que não tentamos remover mais processos do que 0 - #429

· bootstrap.py atualizado - #436

· separador multiplataforma fixo no pythonpath virtualenv watcher

· função de fechamento de soquete refatorada

· Certifique-se de que as seções de env sejam aplicadas a todos os observadores - #437

· adicionou o comando reloadconfig

· adicionado circus.green e removido gevent do núcleo - #441, #452

· stdout e avisos espúrios silenciados nos testes - #438

· $(circus.env.*) pode ser usado para todas as opções na configuração agora

· adicionado um gancho before_spawn

· corrigir o caminho do circusd no arquivo de serviço systemd - #450

· certifique-se de que podemos alterar ganchos e definir fluxos via CLI - #455

· documento melhorado

· adicionou uma estatística spawn_count no watcher

· adicionados parâmetros min_cpu e min_mem no plugin ResourceWatcher

· adicionou as informações do FQDN ao árbitro.

0.8.1 - 2013-05-28
· circusd-stats estava engasgando em soquetes unix - #415

· circusd-stats & circushttpd processos filhos stdout/stderr agora são deixados abertos por padrão.
Python <= 2.7.5 engasgaria no módulo de log caso os 2/3 fds fossem fechados - #415

· Agora redirecionando para /dev/null no processo filho em vez de fechar. #417

0.8 - 2013-05-24
· Manipuladores de log integrados no loop io do zmq.

· Tornar o redirecionador reiniciável e, posteriormente, mais robusto.

· Usa zmq.green.eventloop quando gevent é detectado

· Adicionado suporte para a variável de ambiente CIRCUSCTL_ENDPOINT para circusctl - #396

· util: corrigir bug na função to_uid - #397

· Remova o manipulador no erro ioloop - #398.

· Cobertura de teste aprimorada

· Descontinuada a opção 'serviço' para o plugin ResourceWatcher - #404

· removeu o uso de psutil.error

· Adicionada descoberta de UDP no circusd - #407

· Agora permitindo globs em níveis de diretório arbitrários - #388

· Adicionada a opção de configuração 'statd' - #408

· Adicione a opção pidfile, logoutput e loglevel ao arquivo de configuração do circo - #379

· Adicionado um tutorial na documentação.

· verifique se estamos mesclando todas as seções ao usar include - #414

· adicionou as opções pipe_stdout, pipe_stderr, close_child_stderr & close_child_stdout ao
Classe de processo

· adicionou as opções close_child_stderr e close_child_stdout ao observador

0.7.1 - 2013-05-02
· Corrigida a opção de respawn - #382

· Certifique-se de usar um int para o tempo limite - #380

· exibir os soquetes unix também - #381

· Certifique-se de que funciona com o pyzmq mais recente

· introduziu uma segunda sintaxe para a notação fd

0.7 - 2013-04-08
· Corrigido o exemplo get_arbiter para usar um dict para o argumento dos observadores. #304

· Adicione alguma documentação de solução de problemas #323

· Adicionar suporte para build de python

· Removido o gevent e os redirecionadores de thread. agora usando o ioloop - corrige #346.
Relacionado #340

· circus.web agora é seu próprio projeto

· removeu o patch pyzmq

· Permitir que o observador seja configurado mas não iniciado #283

· Adicione uma opção para carregar um diretório de site virtualenv

· adicionados observadores sob demanda

· documento adicionado sobre nginx+websockets #371

· agora analisando corretamente a lista de opções de cada comando #369

· Corrigidos eventos circusd-stats manipulando #372

· corrigiu o problema de estouro no circo nº 378

· muitas outras coisas...

0.6 - 2012-12-18
· Nome dos protocolos de patch para sockets - #248

· Não dimensione automaticamente os gráficos. #240

· circusctl: adicione ajuda por comando, de docstrings #217

· Ganchos de trabalhadores adicionados

· Adicionado pacote Debian - #227

· Adicionado Redis, HTTP Observer, estatísticas completas e plugins de recursos

· Agora os processos podem ter títulos

· Adicionado preenchimento automático

· Adicionada idade do processo/observador na webui

· Adicionado suporte ao túnel SSH

· Agora usando pyzmq.green

· Adicionado script upstart e documento de verniz

· Variáveis ​​e seções de ambiente adicionadas

· Adicionado suporte a soquetes unix

· Adicionado o reaparecimento opção de ter observadores de execução única

· Agora usando tox nos testes

· Permitir substituição de soquete em argumentos

· Novo tema do documento

· Novas opções de rotação para streams: max_bytes/backup_count

0.5.2 - 2012-07-26
· agora corrigindo o módulo de thread do stdlib para evitar alguns bugs do Python - #203

· tela de ajuda circusctl mais bonita

· usa pustil get_nice() quando disponível (nice foi preterido) - #208

· adicionado suporte max_age - #221

· apenas chame listen() nos soquetes SOCK_STREAM ou SOCK_SEQPACKET

· certifique-se de que o controlador esvazie a lista de plugins em update_watchers() - #220

· adicionado --log-level e --log-output ao circushttpd

· corrigir a morte do processo através da interface do usuário da web - #219

· agora o circus é compatível com zc.buildout para scripts.

· limpar o websocket quando o cliente se desconectar - #225

· fixou o valor padrão para o endpoint - #199

· split circushttpd em módulos lógicos

0.5.1 - 2012-07-11
· Corrigido um monte de erros de digitação na documentação

· Adicionada a opção de depuração

· Empacote web-requirements.txt corretamente

· Adicionado um código de erro errno nas mensagens - correções #111

0.5 - 2012-07-06
· suporte de soquete adicionado

· adicionou um comando listsocket

· soquetes também têm estatísticas!

· corrigiu muitos pequenos bugs

· removeu o wid - agora usando pid em todos os lugares

· testes mais rápidos

· mudou a sintaxe das variáveis

· use o ioloop do pyzmq em mais lugares

· agora usando iowait para todas as chamadas select()

· comandos incr/decr agora possuem um parâmetro nbprocess

· Adicione uma opção de playback_env aos observadores

· Adicionar um novo status INEXISTENTE aos processos

· Adicionado o global httpd opção para executar circushttpd como observador

0.4 - 2012-06-12
· Adicionado um sistema de plugins

· Adicionada uma opção "singleton" para observadores

· Corrigida a cintilação da tela superior do circo

· Tópicos removidos do circus.stats em favor dos retornos de chamada periódicos do zmq

· Aprimorou a documentação

· O cliente Circus agora tem uma API send_message

· O recurso de bater agora é um plugin

· Toda ferramenta de linha de comando tem uma opção --version

· Adicionado um plugin statsd (envia os eventos do circo para o statsd)

· A interface do usuário da web agora usa websockets (via socketio) para obter as estatísticas

· A interface do usuário da web agora usa sessões para "mensagens flash" na interface do usuário da web

0.3.4 - 2012-05-30
· Corrigida uma condição de corrida que impedia o controlador de colher os processos concluídos de forma limpa.

· Agora check_flapping pode ser controlado na configuração. E ativado/desativado
por observador.

0.3.3 - 2012-05-29
· Corrigida a regressão no manuseio do uid

0.3.2 - 2012-05-24
· permite a propriedade opcional args ao comando add_watcher.

· adicionado circushttpd, circus-top e circusd-stats

· permitindo que Arbiter.add_watcher() defina todas as opções do Watcher

· certifique-se de que os redirecionadores sejam recriados nas reinicializações

0.3.1 - 2012-04-18
· correção: certifique-se de que os padrões do observador não sejam substituídos

· adicionou uma classe StdoutStream.

0.3 - 2012-04-18
· adicionou o recurso de streaming

· agora exibindo cobertura no documento Sphinx

· corrigiu a forma como os processos são eliminados (não há mais SIGQUIT)

· a configuração foi fatorada

· suporte setproctitle

0.2 - 2012-04-04
· Removeu o mostrar nome. substituído por observador.

· Adicionado suporte para processo de configuração rlimite.

· Adicionado suporte para incluir diretórios no arquivo de configuração.

· Corrigido um par de descritores de arquivos vazando.

· Corrigido um core dump no flapping

· Melhorias de documentos

· Certifique-se de que os erros do circusd estejam corretos quando outro circusd estiver rodando no mesmo soquete.

· get_arbiter agora aceita vários observadores.

· Corrigido o cmd vs args vs executável no processo init.

· Corrigido --start on circusctl add

0.1 - 2012-03-20
· lançamento inicial

homem páginas
circo homem página
Sinopse
circusd [opções] [configuração]

Descrição
circusd é o processo principal da arquitetura do Circo. Ele cuida de executar todos os
processos. Cada processo gerenciado pelo Circus é um processo filho de circo.

Argumentos
configuração arquivo de configuração

Opções
-h, --Socorro
Mostre a mensagem de ajuda e saia

--log-level NÍVEL
Especifique o nível de registro. NÍVEL pode ser info, depurar, crítico, aviso or erro.

--log-saída SAÍDA DE LOGOTIPO
O local onde os logs serão gravados. O comportamento padrão é escrever para
stdout (você pode forçá-lo passando '-' para esta opção). Pega um nome de arquivo
de outra forma.

--logger-config CONFIGURAÇÃO DO REGISTRO
O local onde um arquivo INI, JSON ou YAML de configuração do logger Python padrão
pode ser encontrado. Isso pode ser usado para substituir a configuração de registro padrão para
o árbitro.

--daemon
Comece o circo em segundo plano.

--pidfile PIDFILE
A localização do arquivo PID.

--versão
Exibe a versão Circus e sai.

See tb
circo (1) circo (1) estatísticas de circo (1) plug-in de circo (1) circo (1).

A documentação completa está disponível em http://circus.readthedocs.org

circo homem página
Sinopse
circusctl [opções] comando [args]

Descrição
circusctl é o front-end para controlar o daemon de circo. É projetado para ajudar o
o administrador controla o funcionamento do Circud circo demônio.

comandos
adicionar Adicionar um observador

diminuir Diminuir o número de processos em um inspetor

estatísticas Obtenha estatísticas circusd

ter Obtenha o valor de opções específicas do inspetor

opções globais
Obtenha as opções do árbitro

aumento Incrementar o número de processos em um inspetor

Pitão
Criar concha no processo circusd

Lista Obtenha uma lista de observadores ou processos em um observador

Inscreva-se em um evento de observador

encaixes de listas
Obtenha a lista de sockets

numprocessos
Obtenha o número de processos

numeradores
Obtenha o número de observadores

opções
Obtenha o valor de todas as opções para um observador

desistir Saia do árbitro imediatamente

recarregar Recarregue o árbitro ou um observador

recarregar configuração
Recarregue o arquivo de configuração

restart
Reinicie o árbitro ou um observador

rm Remover um observador

conjunto Definir uma opção de observador

sinal Envie um sinal

começo Comece o árbitro ou um observador

stats Obtenha informações sobre o processo

estado Obtenha o status de um observador ou de todos os observadores

Pare Cronômetros

Opções
--ponto final PONTO FINAL
ponto final de conexão

-h, --Socorro
Mostre a mensagem de ajuda e saia

--json saída para JSON

--embelezar
embelezar a saída

--ssh SSH
Servidor SSH no formato usuário @ host: porta

--ssh_keyfile SSH_KEYFILE
caminho para o arquivo-chave para autorizar o usuário

--tempo esgotado TIMEOUT
tempo limite de conexão

--versão
Exibe a versão Circus e sai.

See tb
circo (1) circo (1) estatísticas de circo (1) plug-in de circo (1) circo (1).

A documentação completa está disponível em http://circus.readthedocs.org

plug-in de circo homem página
Sinopse
circus-plugin [opções] [plugin]

Descrição
circus-plugin permite lançar um plugin a partir de um daemon Circus em execução.

Argumentos
plug-in Nome totalmente qualificado da classe do plugin.

Opções
--ponto final PONTO FINAL
Ponto final de conexão.

--pubsub PUBUB
O soquete pub / sub circusd ZeroMQ ao qual se conectar.

--config CONFIG
O arquivo de configuração do plugin.

--check-atraso CHECK_DELAY
Verifique o atraso.

--log-level NÍVEL
Especifique o nível de registro. NÍVEL pode ser info, depurar, crítico, aviso or erro.

--log-saída SAÍDA DE LOGOTIPO
O local onde os logs serão gravados. O comportamento padrão é escrever para
stdout (você pode forçá-lo passando '-' para esta opção). Pega um nome de arquivo
de outra forma.

--ssh SSH
Servidor SSH no formato usuário @ host: porta.

-h, --Socorro
Mostre a mensagem de ajuda e saia.

--versão
Exibe a versão Circus e sai.

See tb
circo (1) circo (1) circo (1) estatísticas de circo (1) circo (1).

A documentação completa está disponível em http://circus.readthedocs.org

circo homem página
Sinopse
circus-top [opções]

Descrição
circus-top é um topo-como comando para exibir o daemon Circus e processos gerenciados por
circo.

Opções
--ponto final PONTO FINAL
Ponto final de conexão.

--ssh SSH
Servidor SSH no formato usuário @ host: porta.

--tempo limite do processo PROCESS_TIMEOUT
Após este atraso de inatividade, um processo será removido.

-h, --Socorro
Mostre a mensagem de ajuda e saia.

--versão
Exibe a versão Circus e sai.

See tb
circo (1) circo (1) circo (1) estatísticas de circo (1) plug-in de circo (1).

A documentação completa está disponível em http://circus.readthedocs.org

estatísticas de circo homem página
Sinopse
circusd-stats [opções]

Descrição
circusd-stats executa o agregador de estatísticas para Circus.

Opções
--ponto final PONTO FINAL
Ponto final de conexão.

--pubsub PUBUB
O soquete pub / sub circusd ZeroMQ ao qual se conectar.

--statspoint PONTO DE ESTATUTO
O soquete pub / sub ZeroMQ para o qual enviar dados.

--log-level NÍVEL
Especifique o nível de registro. NÍVEL pode ser info, depurar, crítico, aviso or erro.

--log-saída SAÍDA DE LOGOTIPO
O local onde os logs serão gravados. O comportamento padrão é escrever para
stdout (você pode forçá-lo passando '-' para esta opção). Pega um nome de arquivo
de outra forma.

--ssh SSH
Servidor SSH no formato usuário @ host: porta.

-h, --Socorro
Mostre a mensagem de ajuda e saia.

--versão
Exibe a versão Circus e sai.

See tb
circo (1) circo (1) circo (1) plug-in de circo (1) circo (1).

A documentação completa está disponível em http://circus.readthedocs.org

Glossário: Específico para circo condições
árbitro
O árbitro é responsável por gerenciar todos os observadores dentro do circo, garantindo
todos os processos são executados corretamente.

controlador
A controlador contém o conjunto de ações que podem ser executadas no árbitro.

agitando
O agitando detecção assina eventos e detecta quando alguns processos são
reiniciando constantemente.

pub / sub
O circo tem um pubsub que recebe eventos dos observadores e os despacha para
todos os assinantes.

remoto controlador
O remoto controlador permite que você se comunique com o controlador via ZMQ para
controle Circo.

observador, observadores
A observador é o programa que você diz ao Circus para executar. Uma única instância do Circus pode ser executada
um ou mais observadores.

trabalhador, trabalhadores processo, processos
A processo é uma instância de processo do sistema operacional independente do seu programa. Um único observador
pode executar um ou mais processos. Também os chamamos de trabalhadores.

Direitos de Autor
Circus foi iniciado por Tarek Ziade e é licenciado sob APLv2

Benoit Chesneau foi um dos primeiros colaboradores e fez muitas coisas, como a maioria dos
circus.commands funciona.

Licença
Copyright 2012 - Fundação Mozilla
Direitos autorais 2012 - Benoit Chesneau

Licenciado sob a Licença Apache, Versão 2.0 (a "Licença");
você não pode usar este arquivo, exceto em conformidade com a Licença.
Você pode obter uma cópia da Licença em

http://www.apache.org/licenses/LICENSE-2.0

A menos que exigido pela lei aplicável ou acordado por escrito, o software
distribuído sob a Licença é distribuído "COMO ESTÁ",
SEM GARANTIAS OU CONDIÇÕES DE QUALQUER TIPO, expressas ou implícitas.
Consulte a Licença para obter o idioma específico que rege as permissões e
limitações sob a Licença.

Contribuintes
Veja a lista completa em https://github.com/circus-tent/circus/blob/master/CONTRIBUTORS.txt

Use o circo online usando os serviços onworks.net