Este es el circo de comandos que se puede ejecutar en el proveedor de alojamiento gratuito de OnWorks utilizando una de nuestras múltiples estaciones de trabajo en línea gratuitas, como Ubuntu Online, Fedora Online, emulador en línea de Windows o emulador en línea de MAC OS.
PROGRAMA:
NOMBRE
circo - Documentación del circo [imagen]
Circus es un programa de Python que se puede usar para monitorear y controlar procesos y sockets.
Circus se puede manejar a través de una interfaz de línea de comandos, una interfaz web o mediante programación
a través de su API de Python.
Para instalarlo y probar sus características, consulte los ejemplos o lea el resto de esta página.
para una introducción rápida.
RUNNING A CIRCO DEMONIO
Circus proporciona una llamada de script de línea de comandos circo que se puede utilizar para gestionar procesos
organizado en uno o más observadores.
La herramienta de línea de comandos de Circus se puede configurar mediante un archivo de configuración de estilo ini.
Aquí hay un ejemplo mínimo:
[observador: programa]
cmd = python miprograma.py
numprocesos = 5
[observador: otro programa]
cmd = otro_programa
numprocesos = 2
Luego, el archivo se pasa a circo:
$ circusd ejemplo.ini
Además de los procesos, Circus también puede enlazar sockets. Dado que todos los procesos gestionados por Circus son
un hijo del demonio principal de Circus, eso significa que cualquier programa controlado por Circus puede
use esos enchufes.
Ejecutar un socket es tan simple como agregar un enchufe sección en el archivo de configuración:
[socket: mysocket]
host = host local
port = 8080
Para obtener más información sobre los sockets, consulte sockets.
Para entender por qué es una característica excelente, lea por quécircussockets.
CONTROLADOR CIRCO
Circus proporciona dos herramientas de línea de comandos para administrar su demonio en ejecución:
· circoctl, una consola de administración que puede utilizar para realizar acciones como agregar o
removiendo trabajadores
· circo-top, una consola superior que puede usar para mostrar la memoria y el uso de la CPU de su
corriendo Circus.
Para obtener más información sobre estos, consulte cli
Circus también ofrece un panel web que puede conectarse a un demonio Circus en ejecución y le permite
monitorear e interactuar con él.
Para obtener más información sobre esta función, consulte circushttpd
What ahora ?
Si es un desarrollador y desea aprovechar Circus en su propio proyecto, escriba complementos o
ganchos, vaya a fordevs.
Si eres un operador y quieres gestionar tus procesos usando Circus, ve a forops.
Contribuciones y Comentarios
Más sobre la contribución: contribuciones.
Enlaces útiles:
· Hay una lista de correo para cualquier comentario o pregunta:
http://tech.groups.yahoo.com/group/circus-dev/
· El repositorio y el rastreador de problemas están en GitHub: https://github.com/circus-tent/circus
· Únase a nosotros en el IRC: Freenode, canal #tienda de circo
Documentación índice
Instalación Circo
Circus es un paquete de Python que se publica en PyPI, el índice de paquetes de Python.
La forma más sencilla de instalarlo es usar pip, una herramienta para instalar y administrar Python
paquetes:
$ pip instalar circo
O descarga el Archivo on PyPI, extráigalo e instálalo manualmente con:
$ python setup.py instalar
Si quieres probar Circus, mira los ejemplos.
Si está usando debian o cualquier distribución basada en debian, también puede usar ppa para
instalar circo, está en https://launchpad.net/~roman-imankulov/+archive/circus
zc.construir
Proporcionamos un sistema de zc.construir configuración, puede usarlo simplemente ejecutando el bootstrap
script, luego llamando a buildout:
$ python bootstrap.py
$ bin / buildout
Más on Requisitos
Circus trabaja con:
· Python 2.6, 2.7, 3.2 o 3.3
·
ceromq >= 2.1.10
· La versión de zeromq admitida está determinada en última instancia por la versión de
pyzmq se instala por pip durante la instalación del circo.
· Su versión actual es compatible con las versiones 2.x (limitada), 3.xy 4.x de ZeroMQ.
· Nota: Si está utilizando PyPy en lugar de CPython, asegúrese de leer su
Los documentos de instalación ya que el soporte de la versión ZeroMQ no es el mismo en PyPy.
Cuando instale circus, se eliminarán las últimas versiones de las dependencias de Python
para ti.
También puede instalarlos manualmente utilizando el archivo pip-requirements.txt que proporcionamos:
$ pip install -r pip-requisitos.txt
Si desea ejecutar la consola web, deberá instalar circo-web:
$ pip instalar circus-web
Tutorial
Paso a paso tutoriales
El ejemplos directorio en el repositorio de Circus contiene muchos ejemplos para que pueda
comenzó, pero aquí hay un tutorial completo que le brinda una descripción general de las funciones.
Vamos a supervisar una aplicación WSGI.
Instalación
Circus se prueba en Mac OS X y Linux con las últimas Python 2.6, 2.7, 3.2 y 3.3. Para
ejecutar un circo completo, también necesitará libzmq, liberador & virtualenv.
En sistemas basados en Debian:
$ sudo apt-get install libzmq-dev libevent-dev python-dev python-virtualenv
Crea un virtualenv e instala circo, circo-web y calcetín en eso
$ virtualenv / tmp / circus
$ cd / tmp / circo
$ bin / pip install circus
$ bin / pip instalar circus-web
$ bin / pip instalar chaussette
Una vez hecho esto, encontrará una gran cantidad de comandos en el directorio bin local.
Uso
Chaussette viene con una aplicación Hello World predeterminada, intente ejecutarla:
$ bin / chaussette
Deberías poder visitar http://localhost: 8080 y ver ¡Hola mundo.
Detenga Chaussette y agregue un archivo circus.ini en el directorio que contiene:
[circo]
estadísticasd = 1
httpd = 1
[observador: webapp]
cmd = bin / chaussette --fd $ (circus.sockets.web)
numprocesos = 3
use_sockets = Verdadero
[socket: web]
anfitrión = 127.0.0.1
port = 9999
Este archivo de configuración le dice a Circus que vincule un socket en el puerto 9999 y ejecutar 3 chaussettes trabajadores
En contra. También activa el panel de control web Circus y el módulo de estadísticas.
Guárdelo y ejecútelo usando circo:
$ bin / circusd --daemon circus.ini
Ahora visita http://127.0.0.1: 9999, debería ver la aplicación Hola mundo. La diferencia ahora es
que el socket está gestionado por Circus y hay varios web Workers que aceptan
conexiones en su contra.
NOTA:
El equilibrio de carga es operado por el sistema operativo, por lo que obtienes la misma velocidad
como cualquier otro servidor web previo a la bifurcación como Apache o NGinx. El circo no interfiere con
los datos que pasan.
También visita http://localhost: 8080 / y disfruta del panel web de Circus.
Interacción
Usemos el shell circusctl mientras el sistema se está ejecutando:
$ bin / circusctl
circoctl 0.7.1
circusd-stats: activo
circushttpd: activo
webapp: activo
(circunvalación)
Entras en un caparazón interactivo. Escribe ayuda para obtener todos los comandos:
(circusctl) ayuda
Comandos documentados (escriba ayuda ):
========================================
agregar obtener lista numprocesses salir rm iniciar detener
decr globaloptions escuchar numwatchers recargar establecer estadísticas
dstats incr listsockets opciones reiniciar estado de la señal
Comandos indocumentados:
======================
Ayuda EOF
Probemos cosas básicas. Hagamos una lista de los procesos de los trabajadores web y agreguemos uno nuevo:
(circusctl) lista de aplicaciones web
13712,13713,13714
(circusctl) incr aplicación web
4
(circusctl) lista de aplicaciones web
13712,13713,13714,13973
¡Felicidades, has interactuado con tu circo! Sal del caparazón con Ctrl + D y ahora ejecuta
circo-top:
$ bin / circus-top
Este es un comando tipo top para observar la memoria de todos sus procesos y el uso de la CPU en tiempo real.
Presione Ctrl + C y ahora salgamos de Circus por completo a través de circus-ctl:
$ bin / circusctl salir
ok
Siguiente pasos
Puede conectar su propia aplicación WSGI en lugar del hola mundo de Chaussette simplemente por
apuntando la aplicación invocable.
Chaussette también viene con muchos backends como Gevent o Meinheld.
Read https://chaussette.readthedocs.org/ para todas las opciones.
¿Por Qué should I use Circo of X ?
1. Circo simplifica a tu manera web montón de enfermedades hepáticas
Circus sabe gestionar procesos y sockets, para que no tengas que delegar web
gestión de trabajadores a un servidor WGSI.
Vea por quécircussockets
2. Circo proporciona un pub / sub y encuesta notificaciones vía CeroMQ
Circus tiene un canal pub / sub al que puede suscribirse. Este canal recibe todos los eventos
sucediendo en el circo. Por ejemplo, puede recibir una notificación cuando un proceso se agita, o
crear un cliente que active una advertencia cuando algunos procesos consuman toda la CPU o
RAM.
Estos eventos se envían a través de un canal ZeroMQ, lo que lo hace diferente del stdin
Stream Supervisord utiliza:
· Circus envía eventos en forma de disparar y olvidar, por lo que no es necesario realizar un bucle manual
atravesar all oyentes y mantener sus estados.
· Los suscriptores pueden ubicarse en un host remoto.
Circus también proporciona formas de obtener actualizaciones de estado a través de encuestas únicas en un req / rep.
canal. Esto significa que puede obtener su información sin tener que suscribirse a un
Arroyo. El comando cli proporcionado por Circus usa este canal.
Ver ejemplos.
3. Circo is (Pitón) revelador amigable
Mientras que Circus puede ser manejado completamente por un archivo de configuración y el circoctl / circo
comandos, es fácil reutilizar todo o parte del sistema para crear su propio
monitor de procesos en Python.
Cada capa del sistema está aislada, por lo que puede reutilizarla de forma independiente:
· La envoltura del proceso (Proceso)
· El gerente de procesos (Vigilante)
· El administrador global que ejecuta varios administradores de procesos (Árbitro)
· etcétera…
4. Circo escamas
Uno de los casos de uso de Circus es administrar miles de procesos sin agregar
gastos generales: estamos dedicados a centrarnos en esto.
Se estrena obtenidos de Supervisor
Supervisor es una solución muy popular en el mundo de Python y a menudo nos preguntan cómo Circus
se compara con él.
Si vienes de Supervisor, esta página intenta ofrecer una descripción general de cómo las herramientas
diferir de.
Diferencias visión de conjunto
Supervisor & Circus tienen los mismos objetivos: ambos administran procesos y brindan un
secuencia de comandos de línea de comandos, respectivamente supervisor y circo - que lee una configuración
file, bifurca nuevos procesos y los mantiene vivos.
Circus tiene una característica adicional: la capacidad de enlazar sockets y dejar que los procesos que administra
usalos, usalos a ellos. Este modelo de "pre-bifurcación" es utilizado por muchos servidores web, como APACHE or
Unicornio. Tener esta opción en Circus puede simplificar una pila de aplicaciones web: todos los procesos y
Los enchufes se gestionan con una sola herramienta.
Ambos proyectos proporcionan una forma de controlar un demonio en ejecución a través de otro script. respectivamente
supervisorctl y circoctl. Ambos también tienen eventos y una forma de suscribirse a ellos.
La principal diferencia es la tecnología subyacente: Supervisor usa XML-RPC para interactuar
con el demonio, mientras que Circus usa ZeroMQ.
Circus y Supervisor tienen una interfaz web para mostrar lo que está sucediendo. Circus 'es más
avanzado porque puede seguir en tiempo real lo que está sucediendo e interactuar con el demonio.
Utiliza web sockets y se desarrolla en un proyecto separado (circo-web.)
Hay muchas otras diferencias sutiles en el diseño principal, podríamos enumerarlas aquí algún día ... En
Mientras tanto, puede obtener más información sobre los aspectos internos del circo en el diseño.
Configuration
Ambos sistemas utilizan un archivo tipo ini como configuración.
· Supervisor documentación
· Circo documentación
A continuación, se muestra un pequeño ejemplo de ejecución de una aplicación con Supervisor. En este caso, el
la aplicación se iniciará y reiniciará en caso de que falle
[programa: ejemplo]
comando = npm start
directorio = / inicio / www / mi-servidor /
usuario = www-datos
inicio automático = verdadero
autorestart = true
redirect_stderr = Verdadero
En Circus, la misma configuración se realiza mediante:
[observador: ejemplo]
cmd = npm inicio
dir_trabajo = / inicio / www / mi-servidor /
usuario = www-datos
stderr_stream.class = StdoutStream
Tenga en cuenta que la redirección de stderr es ligeramente diferente en Circus. La herramienta no tiene
a cola función como en Supervisor, pero le permitirá conectar cualquier fragmento de código para manejar
la corriente entrante. Puede crear su propio enlace de transmisión (como clase) y hacer lo que quiera
quiero con la corriente entrante. Circus ofrece algunas clases de transmisión integradas como
Corriente estándar, FileStream, WatchedFileStreamo Flujo de archivos giratorio cronometrado.
Circo for ops
ADVERTENCIA:
De forma predeterminada, Circus no protege sus mensajes cuando envía información a través de ZeroMQ.
Antes de ejecutar Circus en un entorno de producción, asegúrese de leer la página de Seguridad.
El primer paso para administrar un demonio Circus es escribir su archivo de configuración. Ver
configuración. Si está implementando una pila web, eche un vistazo a los sockets.
Circus se puede implementar con Python 2.6, 2.7, 3.2 o 3.3; la mayoría de las implementaciones existen
hecho en 2.7. Para aprender cómo implementar Circus, consulte la implementación.
Para administrar un demonio de Circus, debe familiarizarse con la lista de comandos que puede usar
in circoctl. Tenga en cuenta que puede tener la misma ayuda en línea cuando ejecuta circoctl como herramienta de edición del
cáscara.
También ofrecemos circo-top, vea cli y un agradable panel web. ver circushttpd.
Por último, para aprovechar al máximo Circus, asegúrese de consultar cómo usar complementos y ganchos.
Ver complementos y ganchos.
ops documentación índice
Configuration
Circus se puede configurar usando un archivo de configuración de estilo ini.
Ejemplo:
[circo]
verificar_retraso = 5
punto final = tcp: //127.0.0.1: 5555
pubsub_endpoint = tcp: //127.0.0.1: 5556
include = \ *. more.config.ini
máscara = 002
[observador: myprogram]
cmd = pitón
args = -u myprogram.py $ (circus.wid) $ (CIRCUS.ENV.VAR)
calentamiento_retraso = 0
numprocesos = 5
# gancho
hooks.before_start = mis.hooks.control_redis
# empujará test.log la secuencia cada 300 ms
stdout_stream.class = Flujo de archivos
stdout_stream.filename = prueba.log
# opcionalmente rotar el archivo de registro cuando alcance 1 gb
# y guardar 5 copias de archivos rotados
stdout_stream.max_bytes = 1073741824
stdout_stream.backup_count = 5
[env: myprogram]
RUTA = $ RUTA:/compartimiento
TORTA = mentir
[complemento: statsd]
uso = circo.plugins.statsd.StatsdEmitter
host = host local
port = 8125
tasa_de_muestra = 1.0
application_name = ejemplo
[socket: web]
host = host local
port = 8080
circo - soltero .
punto final
El zócalo ZMQ utilizado para gestionar Circus a través de circoctl. (defecto:
tcp: //127.0.0.1: 5555)
endpoint_propietario
Si se establece en un nombre de usuario del sistema y el punto final es un socket ipc como
ipc: //var/run/circusd.sock, entonces la propiedad del archivo de socket se cambiará a
ese usuario al inicio. Para obtener más detalles, consulte seguridad. (predeterminado: Ninguno)
pubsub_punto final
El zócalo ZMQ PUB / SUB que recibe publicaciones de eventos. (defecto:
tcp: //127.0.0.1: 5556)
papa_endpoint
Si usa papa, puede especificar el punto final, como ipc: //var/run/circusd.sock.
(defecto: tcp: //127.0.0.1: 20202)
estadísticas Si se establece en Verdadero, Circus ejecuta el demonio circusd-stats. (predeterminado: falso)
stats_endpoint
El zócalo ZMQ PUB / SUB que recibe publicaciones de estadísticas. (defecto:
tcp: //127.0.0.1: 5557)
statsd_close_outputs
Si es True envía el stdout / stderr de circusd-stats a / dev / null. (predeterminado: falso)
verificar_retraso
El intervalo de sondeo en segundos para el zócalo ZMQ. (predeterminado: 5)
incluir
Lista de archivos de configuración para incluir. Puede utilizar comodines (*) para incluir particular
esquemas para sus archivos. Las rutas son absolutas o relativas al archivo de configuración.
(predeterminado: Ninguno)
incluir_dir
Lista de directorios de configuración. Todos los archivos coinciden * .ini debajo de cada directorio
ser incluido. Las rutas son absolutas o relativas al archivo de configuración. (defecto:
Ninguno)
flujo_backend
Define el tipo de backend que se usará para la transmisión. Los valores posibles son o fresa de hueso denso
or evento. (predeterminado: hilo)
calentamiento_retraso
Comienza el intervalo en segundos entre dos observadores. Debe ser un int. (predeterminado: 0)
httpd Si se establece en True, Circus ejecuta el demonio circushttpd. (predeterminado: falso)
httpd_host
El anfitrión corrió por el demonio circushttpd. (predeterminado: localhost)
puerto_httpd
El puerto lo ejecuta el demonio circushttpd. (predeterminado: 8080)
httpd_close_outputs
Si es True, envía circushttpd stdout / stderr a / dev / null. (predeterminado: falso)
depurar Si se establece en Verdadero, todos los demonios Circus stout / stderr se redirigen a circusd
stdout / stderr (predeterminado: falso)
depuración_gc
Si se establece en Verdadero, circusd genera información de registro adicional del recolector de basura.
Esto puede resultar útil para rastrear pérdidas de memoria. (predeterminado: falso)
archivo pid
El archivo que se debe usar para mantener el pid del demonio.
umask Valor de umask. Si no se configura, circusd no intentará modificar umask.
nivel de registro
El nivel de registro que queremos ver (predeterminado: INFO)
salida de sesión
El archivo de salida de registro donde queremos registrar (predeterminado: - para iniciar sesión en stdout). Usted puede
iniciar sesión en un syslog remoto utilizando la siguiente sintaxis:
syslog: // host: puerto? instalación donde host es su servidor syslog, el puerto es opcional
y la facilidad es la facilidad de syslog a utilizar. Si desea iniciar sesión en un syslog local
puedes usar syslog: /// ruta / a / syslog / socket? facilidad preferiblemente.
registradorconfig
Una ruta a un archivo INI, JSON o YAML para configurar el registro estándar de Python para el
Árbitro. El valor especial "predeterminado" usa la configuración de registro incorporada
basado en las opciones opcionales de nivel de registro y salida de registro.
Ejemplo YAML Configuration Archive
Versión: 1
disable_existing_loggers: falso
formateadores:
sencillo:
formato: '% (asctime) s -% (name) s - [% (levelname) s]% (message) s'
manipuladores:
archivo de registro:
clase: logging.FileHandler
nombre de archivo: logoutput.txt
nivel: DEPURACIÓN
formateador: simple
registradores:
circo:
nivel: DEPURACIÓN
controladores: [archivo de registro]
propagar: no
raíz:
nivel: DEPURACIÓN
controladores: [archivo de registro]
observador: NOMBRE - as muchos (secciones) as ustedes want
NOMBRE El nombre del observador. Este nombre se usa en circoctl
cmd El programa ejecutable que se ejecutará.
args Argumentos de la línea de comandos para pasar al programa. Puedes usar el formato python
sintaxis aquí para construir los parámetros. Las variables de entorno están disponibles, como
así como la identificación del trabajador y las variables de entorno que pasó, si las hubiera,
con el parámetro "env". Ver Maquetación de la forma más comandos y argumentos con lugar de trabajo dinámico
las variables Para más información sobre esto.
shell Si es Verdadero, los procesos se ejecutan en el shell (predeterminado: Falso)
shell_args
Argumentos de la línea de comandos para pasar al comando de shell cuando shell es verdad. Obras
solo para el sistema * nix (predeterminado: Ninguno)
directorio_de_trabajo
El directorio de trabajo para los procesos (predeterminado: Ninguno)
UID La identificación de usuario o el nombre con el que se debe ejecutar el comando. (El uid actual es el
defecto).
gid El ID de grupo o el nombre con el que debe ejecutarse el comando. (El gid actual es el
defecto).
copiar_env
Si se establece en verdadero, las variables de entorno local se copiarán y pasarán al
trabajadores al desovarlos. (Predeterminado: falso)
copiar_ruta
Si se establece en verdadero, sys.ruta se pasa en el entorno de subproceso usando PITONPATO.
copiar_env tiene que ser verdad. (Predeterminado: falso)
calentamiento_retraso
La demora (en segundos) entre los procesos en ejecución.
inicio automático
Si se establece en falso, el observador no se iniciará automáticamente cuando el árbitro
empieza. El observador se puede iniciar explícitamente (ejemplo: circoctrl comienzo
mi programa). (Predeterminado: verdadero)
numprocesos
La cantidad de procesos que se ejecutarán para este observador.
rlimit_LIMIT
Establezca el límite de recursos LIMIT para los procesos supervisados. El nombre de la configuración debe coincidir
las constantes RLIMIT_ * (no distingue entre mayúsculas y minúsculas) enumeradas en el Python Recurso módulo
referencia. Por ejemplo, la línea de configuración 'rlimit_nofile = 500' establece el máximo
número de archivos abiertos a 500. Para establecer un valor límite en RLIM_INFINITY, no establezca un
valor, como esta línea de configuración: 'rlimit_nofile ='.
stderr_stream.clase
Un nombre de clase de Python completamente calificado que se instanciará y recibirá
de la forma más stderr flujo de todos los procesos en su __llamada__() método.
Circus proporciona algunas clases de transmisión que puede usar sin prefijo:
· FileStream: escribe en un archivo y puede realizar una rotación automática de registros
· WatchedFileStream: escribe en un archivo y se basa en la rotación de registros externos
· Flujo de archivos giratorio cronometrado: escribe en un archivo y puede rotar en cierto tiempo
intervalos.
· Flujo de cola: escribir en una cola de memoria
· Corriente estándar: escribe en la salida estándar
· FancyStdoutCorriente: escribe la salida en color con prefijos de tiempo en la salida estándar
stderr_stream. *
Todas las opciones comienzan con stderr_stream. que no sea clase se pasará el
constructor al crear una instancia de la clase definida en
stderr_stream.clase.
stdout_stream.clase
Un nombre de clase de Python completamente calificado que se instanciará y recibirá
de la forma más stdout flujo de todos los procesos en su __llamada__() método.
Circus proporciona algunas clases de transmisión que puede usar sin prefijo:
· FileStream: escribe en un archivo y puede realizar una rotación automática de registros
· WatchedFileStream: escribe en un archivo y se basa en la rotación de registros externos
· Flujo de archivos giratorio cronometrado: escribe en un archivo y puede rotar en cierto tiempo
intervalos.
· Flujo de cola: escribir en una cola de memoria
· Corriente estándar: escribe en la salida estándar
· FancyStdoutCorriente: escribe la salida en color con prefijos de tiempo en la salida estándar
stdout_stream. *
Todas las opciones comienzan con flujo_stdout. que no sea clase se pasará el
constructor al crear una instancia de la clase definida en
stdout_stream.clase.
close_child_stdout
Si se establece en True, el flujo de salida estándar de cada proceso se enviará a / dev / null
después de la bifurcación. El valor predeterminado es Falso.
close_child_stderr
Si se establece en True, el flujo stderr de cada proceso se enviará a / dev / null
después de la bifurcación. El valor predeterminado es Falso.
enviar_hup
Si es Verdadero, se realizará una recarga del proceso enviando la señal SIGHUP. Defaults
a falso.
señal_parada
La señal a enviar al detener el proceso. Puede especificarse como un número o un
nombre de la señal. Los nombres de las señales no distinguen entre mayúsculas y minúsculas y pueden incluir 'SIG' o no. Entonces
los ejemplos válidos incluyen renuncia, INT, SIGNO y 3. Por defecto es SIGTERM.
detener_los_niños
Al enviar el señal_parada, envíelo a los niños también. Predeterminado a
Falso.
max_reintentar
La cantidad de veces que intentamos iniciar un proceso, antes de abandonarlo y detenerlo.
todo el observador. El valor predeterminado es 5. Establecer en -1 para deshabilitar max_retry y reintentar
indefinidamente.
agraciado_tiempo de espera
El número de segundos para esperar a que un proceso termine correctamente antes de
matandolo.
Al detener un proceso, primero le enviamos un señal_parada. Un trabajador puede captar esto
señal para realizar operaciones de limpieza antes de salir. Si el trabajador sigue
activo después de graceful_timeout segundos, le enviamos una señal SIGKILL. No lo es
posible captar las señales SIGKILL para que el trabajador se detenga.
El valor predeterminado es 30 segundos.
lista de prioridades
Número entero que define una prioridad para el observador. Cuando el árbitro hace algo
operaciones en todos los observadores, los ordenará con este campo, desde el más grande
número al más pequeño. El valor predeterminado es 0.
Singleton
Si se establece en Verdadero, este observador tendrá como máximo un proceso. Predeterminado a
Falso.
usar_sockets
Si se establece en Verdadero, este observador podrá acceder a los sockets definidos a través de su
descriptores de archivos. Si es False, todos los fds padre se cierran cuando el proceso hijo es
ahorquillado. El valor predeterminado es Falso.
edad_máxima
Si se establece, el proceso se reiniciará en algún momento después de max_age segundos. Esta
es útil cuando los procesos tratan con un grupo de conectores: reiniciar procesos
mejora el equilibrio de carga. Por defecto está deshabilitado.
varianza_edad_max
Si se establece max_age, el proceso vivirá entre max_age y max_age +
segundos aleatorios (0, max_age_variance). Esto evita reiniciar todos los procesos para un
observador a la vez. El valor predeterminado es 30 segundos.
Bajo demanda
Si se establece en Verdadero, los procesos se iniciarán solo después de la primera conexión a
uno de los enchufes configurados (ver más abajo). Si es necesario reiniciar, será
solo se activa en el siguiente evento de socket.
manos.*
Ganchos disponibles: antes de comenzar, Después de empezar, antes_spawn, después_spawn,
antes_parar, después de la parada, señal_antes, después de la señal, Extended_stats
Defina funciones de devolución de llamada que se enganchan al proceso de inicio / apagado del observador.
Si el anzuelo regresa Falso y si el anzuelo es uno de antes de comenzar, antes_spawn,
Después de empezar or después_spawn, se cancelará el inicio.
Si el anzuelo es señal_antes y devoluciones Falso, luego la señal correspondiente
no se enviará (excepto SIGKILL que siempre se envía)
Observe que un gancho que falla durante el proceso de detención no lo abortará.
La definición de devolución de llamada puede ir seguida de una bandera booleana separada por una coma.
Cuando la bandera se pone en su verdadero, se ignorará cualquier error que se produzca en el gancho. Si
establecido en false (el valor predeterminado), el gancho volverá Falso.
Más sobre ganchos.
virtualenv
Cuando se proporciona, apunta a la raíz de un directorio Virtualenv. El observador
escanear el local paquetes de sitio y carga su contenido en la ejecución
medio ambiente. Debe usarse con copiar_env establecido en Verdadero. El valor predeterminado es Ninguno.
virtualenv_py_ver
Especifica la versión python del virtualenv (por ejemplo, "3.3"). Es útil si
circo con otra versión de Python (por ejemplo, "2.7") El observador escaneará el
local paquetes de sitio de la versión de Python especificada y cargue su contenido en
el entorno de ejecución. Debe usarse con virtualenv. El valor predeterminado es Ninguno.
respawn
Si se establece en False, los procesos manejados por un observador no se reaparecerán.
automáticamente. Los procesos se pueden reaparecer manualmente con el comienzo mando.
(predeterminado: verdadero)
usar_papa
Ajústelo a verdadero para usar el papá.
enchufe: NOMBRE - as muchos (secciones) as ustedes want
fortaleza El anfitrión del socket. Por defecto es 'localhost'
Puerto El puerto. El valor predeterminado es 8080.
- La familia de los zócalos. Puede ser 'AF_UNIX', 'AF_INET' o 'AF_INET6'. Predeterminado a
'AF_INET'.
tipo El tipo de enchufe. Puede ser 'SOCK_STREAM', 'SOCK_DGRAM', 'SOCK_RAW', 'SOCK_RDM' o
'SOCK_SEQPACKET'. El valor predeterminado es 'SOCK_STREAM'.
interfaz.
Cuando se proporciona un nombre de interfaz de red como 'eth0', vincula el socket a ese
dispositivo en particular para que solo los paquetes recibidos de esa interfaz en particular
son procesados por el zócalo. Esto se puede utilizar, por ejemplo, para limitar qué dispositivo
para enlazar al enlazar en IN_ADDR_ANY (0.0.0.0) o IN_ADDR_BROADCAST
(255.255.255.255). Tenga en cuenta que esto solo funciona para algunos tipos de socket, particularmente
Zócalos AF_INET.
camino Cuando se proporciona una ruta a un archivo que se utilizará como un archivo de socket Unix. Si un
se proporciona la ruta, - se fuerza a AF_UNIX y fortaleza y Puerto se ignoran
umask Cuando se proporciona, establece la umask que se utilizará para crear un socket AF_UNIX. Para
ejemplo, umask = 000 producirá un enchufe con permiso 777.
reemplazar
Al crear sockets Unix ('AF_UNIX'), un archivo existente puede indicar un problema
por lo que el valor predeterminado es fallar. Especificar ¿Editas con tu equipo de forma remota? para eliminar simplemente el archivo antiguo si está
asegúrese de que el enchufe sea gestionado únicamente por Circus.
tan_reutilizarport
Si se establece en Verdadero y SO_REUSEPORT está disponible en la plataforma de destino, circus
crear y vincular nuevos sockets SO_REUSEPORT para cada trabajador que inicie, que es un
usuario de este enchufe (s).
usar_papa
Ajústelo a verdadero para usar el papá.
Una vez que se crea un socket, el $ {circus.sockets.NAME} cadena se puede utilizar en el comando
(cmd or args) de un observador. Circus lo reemplazará por el valor FD. El observador también debe
have usar_sockets establecido en ¿Editas con tu equipo de forma remota? de lo contrario, el enchufe se habrá cerrado y obtendrá
errores cuando el observador intenta usarlo.
Ejemplo:
[observador: webworker]
cmd = chaussette --fd $ (circus.sockets.webapp) chaussette.util.bench_app
use_sockets = Verdadero
[socket: webapp]
anfitrión = 127.0.0.1
port = 8888
complemento: NAME - as muchos (secciones) as ustedes want
use El nombre completo que apunta a la clase de complemento.
cualquier cosa más
Todas las demás claves que se encuentran en la sección se pasan al constructor del complemento en el
config cartografía.
Puede utilizar todas las opciones de observador, ya que un complemento se inicia como un observador.
Circus viene con algunos complementos enviados previamente, pero también puede extenderlos fácilmente al
desarrollando el tuyo propio.
env or env [: WATCHERS] - as muchos (secciones) as ustedes want
cualquier cosa
El nombre de una variable de entorno a la que asignarle valor. entorno de estilo bash
se admiten sustituciones. por ejemplo, anexar /compartimiento a TRAYECTORIA 'RUTA =
$ RUTA:/compartimiento'
Sección responsable de entregar la variable de entorno para ejecutar procesos.
Ejemplo:
[observador: trabajador1]
cmd=ping 127.0.0.1
[observador: trabajador2]
cmd=ping 127.0.0.1
[entorno]
TORTA = mentir
La variable TARTA se propagará a todos los observadores definidos en el archivo de configuración.
WATCHERS puede ser una lista separada por comas de secciones de observadores para aplicar este entorno.
si varias secciones env coinciden con un observador, se combinarán en el orden en que aparecen en
el archivo de configuración. las entradas posteriores tendrán prioridad.
Ejemplo:
[observador: trabajador1]
cmd=ping 127.0.0.1
[observador: trabajador2]
cmd=ping 127.0.0.1
[env: trabajador1, trabajador2]
RUTA = /compartimiento
[env: trabajador1]
RUTA = $ RUTA
[env: trabajador2]
TORTA = mentir
Trabajador1 se ejecutará con PATH = $ PATH (expandido del entorno en el que se ejecutó circusd)
Trabajador2 se ejecutará con PATH = /compartimiento y CAKE = mentir
También es posible utilizar comodines.
Ejemplo:
[observador: trabajador1]
cmd=ping 127.0.0.1
[observador: trabajador2]
cmd=ping 127.0.0.1
[env: trabajador *]
RUTA = /compartimiento
Ambos Trabajador1 y Trabajador2 se ejecutará con PATH = /compartimiento
Gracias a entorno las variables
Al escribir su archivo de configuración, puede utilizar las variables de entorno definidas en el env
sección o en os.medio ambiente misma.
Solo tienes que usar el circo.env. prefijo.
Ejemplo:
[observador: trabajador1]
cmd = $ (circus.env.shell)
[observador: trabajador2]
baz = $ (circus.env.user)
bar = $ (circus.env.yeah)
sup = $ (circus.env.oh)
[socket: socket1]
puerto = $ (circus.env.port)
[complemento: complemento1]
uso = alguna.ruta
parámetro1 = $ (circus.env.plugin_param)
[entorno]
sí = boo
[env: trabajador2]
ay = bien
Si una variable se define en varios lugares, el valor más especializado tiene prioridad: a
variable definida en env: XXX anulará una variable definida en env, que anulará un
variable definida en os.medio ambiente.
Las sustituciones de entorno se pueden utilizar en cualquier sección de la configuración en cualquier sección.
variable.
Maquetación de la forma más comandos y argumentos con lugar de trabajo dinámico las variables
Como habrá visto, es posible pasar cierta información que se calcula
dinámicamente al ejecutar los procesos. Entre otras cosas, puede obtener la identificación del trabajador.
(WID) y todas las opciones que se pasan al Proceso. Además, es posible
acceder a las opciones pasadas al Vigilante que instancia el proceso.
NOTA:
La identificación del trabajador es diferente de la identificación del proceso. Es un valor único, a partir de 1,
que es único para el observador.
Por ejemplo, si desea acceder a algunas variables contenidas en el entorno,
tendría que hacerlo con una configuración como esta:
cmd = "hazme-un-café --azúcar $ (CIRCUS.ENV.SUGAR_AMOUNT)"
Esto funciona con ambos cmd y args.
Importante::
· Todas las variables tienen el prefijo circo.
· El reemplazo no distingue entre mayúsculas y minúsculas.
Transmite configuración
Clase de flujo simple como Flujo de cola y Corriente estándar no tiene atributos específicos pero
alguna otra clase de transmisión puede tener algunos:
FileStream
nombre de archivo
La ruta del archivo donde se escribirá el registro.
formato de tiempo
El formato strftime que se usará para prefijar cada vez con una marca de tiempo. Por
por defecto no tendrán prefijo.
es decir:% Y-% m-% d% H:% M:% S
max_bytes
El tamaño máximo del archivo de registro antes de que se inicie un nuevo archivo. Si no se proporciona, el
el archivo no se renueva.
recuento_copia de seguridad
El número de archivos de registro que se guardarán Por defecto, backup_count es nulo.
NOTA:
La renovación se produce siempre que el archivo de registro actual tenga una longitud de casi max_bytes. Si
backup_count es> = 1, el sistema creará sucesivamente nuevos archivos con el mismo
nombre de ruta como el archivo base, pero con las extensiones ".1", ".2", etc. añadidas. Para
ejemplo, con un backup_count de 5 y un nombre de archivo base de "app.log", obtendría
"app.log", "app.log.1", "app.log.2", ... hasta "app.log.5". El archivo que se está escribiendo
to es siempre "app.log": cuando se llena, se cierra y se cambia el nombre a
"app.log.1", y si existen archivos "app.log.1", "app.log.2", etc., se les cambia el nombre.
a "app.log.2", "app.log.3", etc. respectivamente.
Ejemplo:
[observador: myprogram]
cmd = python -m miaplicación.servidor
stdout_stream.class = Flujo de archivos
stdout_stream.filename = prueba.log
stdout_stream.time_format =% Y-% m-% d% H:% M:% S
stdout_stream.max_bytes = 1073741824
stdout_stream.backup_count = 5
WatchedFileStream
nombre de archivo
La ruta del archivo donde se escribirá el registro.
formato de tiempo
El formato strftime que se usará para prefijar cada vez con una marca de tiempo. Por
por defecto no tendrán prefijo.
es decir:% Y-% m-% d% H:% M:% S
NOTA:
WatchedFileStream se basa en una herramienta de rotación de registros externa para garantizar que los archivos de registro
no te hagas demasiado grande. El archivo de salida será monitoreado y si alguna vez se elimina o
movido por la herramienta de rotación de registro externa, entonces el identificador del archivo de salida será
recargado automáticamente.
Ejemplo:
[observador: myprogram]
cmd = python -m miaplicación.servidor
stdout_stream.class = WatchedFileStream
stdout_stream.filename = prueba.log
stdout_stream.time_format =% Y-% m-% d% H:% M:% S
Flujo de archivos giratorio cronometrado
nombre de archivo
La ruta del archivo donde se escribirá el registro.
recuento_copia de seguridad
El número de archivos de registro que se guardarán Por defecto, backup_count es nulo.
formato de tiempo
El formato strftime que se usará para prefijar cada vez con una marca de tiempo. Por
por defecto no tendrán prefijo.
es decir:% Y-% m-% d% H:% M:% S
rotar_cuando
El tipo de intervalo. La lista de valores posibles está a continuación. Tenga en cuenta que son
no entre mayúsculas y minúsculas.
┌───────────┬───────────────────────┐
│Valor │ Tipo de intervalo │
├───────────┼───────────────────────┤
│'S '│ Segundos │
├───────────┼───────────────────────┤
│'M '│ Minutos │
├───────────┼───────────────────────┤
│'H '│ Horas │
├───────────┼───────────────────────┤
│'D '│ Días │
├───────────┼───────────────────────┤
│'W0 '-' W6 '│ Día de la semana (0 = lunes) │
├───────────┼───────────────────────┤
│'midnight '│ Da la vuelta a la medianoche │
└───────────┴───────────────────────┘
intervalo_de_rotación
El intervalo de renovación.
NOTA:
TimedRotatingFileStream rota los archivos de registro en ciertos intervalos cronometrados. Intervalo de renovación
está determinado por una combinación de rotate_when y rotate_interval.
Ejemplo:
[observador: myprogram]
cmd = python -m miaplicación.servidor
stdout_stream.class = TimedRotatingFileStream
stdout_stream.filename = prueba.log
stdout_stream.time_format =% Y-% m-% d% H:% M:% S
stdout_stream.utc = Verdadero
stdout_stream.rotate_when = H
stdout_stream.rotate_interval = 1
FancyStdoutCorriente
Color
El nombre of an ascii color:
· rojo
· verde
· amarillo
· azul
· Magenta
· Cian
· blanco
formato de tiempo
El formato strftime con el que se antepondrá cada línea.
Por defecto:% Y-% m-% d% H:% M:% S
Ejemplo:
[observador: myprogram]
cmd = python -m miaplicación.servidor
stdout_stream.class = FancyStdoutStream
stdout_stream.color = verde
stdout_stream.time_format =% Y /% m /% d | % H:% M:% S
Comandos
En el epicentro del circo viven los sistemas de mando. circoctl es solo un cliente zeromq,
y si es necesario, puede manejar programáticamente el sistema Circus escribiendo su propio zmq
cliente.
Todos los mensajes son asignaciones JSON.
Para cada comando a continuación, proporcionamos un ejemplo de uso con circusctl pero también la entrada /
salida de mensajes zmq.
circo-ctl comandos
· add: comandos / agregar
· dic: comandos / decr
· estadísticas: comandos / dstats
· get: comandos / obtener
· opciones globales: comandos / opciones globales
· aumentar: comandos / incr
· ipython: comandos / ipython
· lista: comandos / lista
· escuchan: comandos / escuchar
· listas de enchufes: comandos / listsockets
· numprocesos: comandos / numprocesses
· observadores numéricos: comandos / numwatchers
· opciones: comandos / opciones
· renuncia: comandos / salir
· recargar: comandos / recarga
· recargar configuración: comandos / reloadconfig
· reanudar: comandos / reiniciar
· rm: comandos / rm
· para reinventar la industria logística y redefinir las soluciones ecológicas para reinventar la industria logística y redefinir las soluciones ecológicas.: comandos / set
· señal: comandos / señal
· comienzo: comandos / inicio
· estadísticas: comandos / estadísticas
· estado: comandos / estado
· detener: comandos / parada
Añadir el archivo a observador
Este comando agrega un observador dinámicamente a un árbitro.
ZMQ Mensaje
{
"comando": "agregar",
"propiedades": {
"cmd": "/ ruta / a / línea de comandos - opción"
"nombre": "nombre del observador"
"argumentos": [],
"opciones": {},
"inicio": falso
}
}
Un mensaje contiene 2 propiedades:
· Cmd: línea de comando completa para ejecutar en un proceso
· Args: matriz, argumentos pasados al comando (opcional)
· Nombre: nombre del observador
· Opciones: opciones de un observador
· Inicio: inicia el observador después de la creación
La respuesta devuelve un estado "ok".
Comando línea
$ circusctl agregar [--start]
De Seguros
· : nombre del observador a crear
· : línea de comando completa para ejecutar en un proceso
· --Start: inicia el observador inmediatamente
Decremento de la forma más número of en costes in a observador
Este comentario reduce el número de procesos en un observador por , Siendo 1 el
predeterminada.
ZMQ Mensaje
{
"comando": "decr",
"propiedades": {
"nombre": " "
"nótese bien":
"esperando": falso
}
}
La respuesta devuelve el número de procesos en la propiedad 'numprocesses':
{"status": "ok", "numprocesses": , "hora", "marca de tiempo"}
Comando línea
$ circusctl decr [ ] [--esperando]
De Seguros
· : nombre del observador
· : el número de procesos a eliminar.
Get circo estadísticas
Puede obtener en cualquier momento algunas estadísticas sobre circusd con el comando dstat.
ZMQ Mensaje
Para obtener las estadísticas de circusd, simplemente ejecute:
{
"comando": "dstats"
}
La respuesta devuelve un mapeo de la propiedad "infos" que contiene algunas informaciones del proceso:
{
"información": {
"niños": [],
"cmdline": "python",
"cpu": 0.1,
"ctime": "0: 00.41",
"mem": 0.1,
"mem_info1": "3M",
"mem_info2": "2G",
"agradable": 0,
"pid": 47864,
"nombre de usuario": "root"
},
"estado": "ok",
"tiempo": 1332265655.897085
}
Comando Line
$ circoctl dstats
Get de la forma más propuesta de of soluciones y observador opciones
Este comando se puede utilizar para consultar el valor actual de una o más opciones del observador.
ZMQ Mensaje
{
"comando": "obtener",
"propiedades": {
"claves": ["clave1," clave2 "]
"nombre": "nombre del observador"
}
}
Un mensaje de solicitud contiene dos propiedades:
· Claves: lista, las claves de opción para las que desea obtener los valores
· Nombre: nombre del observador
El objeto de respuesta tiene una propiedad opciones que es un diccionario de nombres de opciones y
valores.
p.ej:
{
"estado": "ok",
"opciones": {
"graceful_timeout": 300,
"send_hup": verdadero,
},
tiempo ': 1332202594.754644
}
Comando línea
$ circusctl get
Get de la forma más árbitro opciones
Este comando devuelve las opciones de árbitro
ZMQ Mensaje
{
"comando": "opciones globales",
"propiedades": {
"key1": "val1",
..
}
}
Un mensaje contiene 2 propiedades:
· Claves: lista, las claves de opción para las que desea obtener los valores
La respuesta devuelve un objeto con una propiedad "opciones" que contiene la lista de clave / valor
devuelto por circo.
p.ej:
{
"estado": "ok",
"opciones": {
"check_delay": 1,
...
},
tiempo ': 1332202594.754644
}
Comando línea
$ circusctl opciones globales
De Seguros
Las teclas de opciones son:
· Punto final: el punto final del controlador ZMQ
· Pubsub_endpoint: el punto final de pubsub
· Check_delay: el retraso entre dos puntos del controlador
· Multicast_endpoint: el punto final de multidifusión para el autodescubrimiento de clústeres de circusd
Incremento de la forma más número of en costes in a observador
Este comentario incrementa el número de procesos en un observador en , Siendo 1 el
tu préstamo estudiantil
ZMQ Mensaje
{
"comando": "incr",
"propiedades": {
"nombre": " ",
"nótese bien": ,
"esperando": falso
}
}
La respuesta devuelve el número de procesos en la propiedad 'numprocesses':
{"status": "ok", "numprocesses": , "hora", "marca de tiempo"}
Comando línea
$ circusctl incr [ ] [--esperando]
De Seguros
· : nombre del observador.
· : el número de procesos a agregar.
Create shell into circo
Este comando solo es útil si tiene instalado el paquete ipython.
Comando Line
$ circoctl ipython
Get lista of observadores or en costes in a observador
ZMQ Mensaje
Para obtener la lista de todos los observadores:
{
"comando": "lista",
}
Para obtener la lista de procesos activos en un observador:
{
"comando": "lista",
"propiedades": {
"nombre": "nombre del observador",
}
}
La respuesta devuelve la lista solicitada. el mapeo devuelto puede ser 'observadores' o
'pids' dependiendo de la solicitud.
Comando línea
$ circusctl list [ ]
Suscríbete a a observador evento
ZMQ
En cualquier momento puedes suscribirte a un evento de circo. Circus proporciona un feed PUB / SUB en el que
cualquier cliente puede suscribirse. El URI del punto final del suscriptor se establece en circus.ini
archivo de configuración.
Los eventos son temas de pubsub:
· vigilante. .recoger: cuando se cosecha un proceso
· vigilante. .Aparecer: cuando se genera un proceso
· vigilante. .matar: cuando se mata un proceso
· vigilante. .actualizado: cuando se actualiza la configuración del observador
· vigilante. .parada: cuando un observador se detiene
· vigilante. .comienzo: cuando se inicia un observador
Todos los mensajes de eventos están en una estructura json.
Comando línea
El cliente se ha actualizado para proporcionar una forma sencilla de escuchar los eventos:
circusctl listen [ , ...]
Ejemplo of resultado:
$ circusctl escuchar 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 de la forma más lista of tomas
ZMQ Mensaje
Para obtener la lista de sockets:
{
"comando": "listsockets",
}
La respuesta devuelve una lista de asignaciones json con claves para fd, nombre, host y puerto.
Comando línea
$ circusctl listas de enchufes
Get de la forma más número of en costes
Obtenga la cantidad de procesos en un observador o en un árbitro
ZMQ Mensaje
{
"comando": "numprocesses",
"propiedades": {
"nombre": " "
}
}
La respuesta devuelve el número de procesos en la propiedad 'numprocesses':
{"status": "ok", "numprocesses": , "hora", "marca de tiempo"}
Si no se especifica el nombre de la propiedad, se devuelve la suma de todos los procesos administrados.
Comando línea
$ circusctl numprocesses [ ]
De Seguros
· : nombre del observador
Get de la forma más número of observadores
Obtenga el número de observadores en un árbitro
ZMQ Mensaje
{
"comando": "numwatchers",
}
La respuesta devuelve el número de observadores en la propiedad 'numwatchers':
{"status": "ok", "numwatchers": , "hora", "marca de tiempo"}
Comando línea
$ vigilantes numéricos circusctl
Get de la forma más propuesta de of all opciones for a observador
Este comando devuelve todos los valores de opción para un observador determinado.
ZMQ Mensaje
{
"comando": "opciones",
"propiedades": {
"nombre": "nombre del observador",
}
}
Un mensaje contiene 1 propiedad:
· Nombre: nombre del observador
El objeto de respuesta tiene una propiedad opciones que es un diccionario de nombres de opciones y
valores.
p.ej:
{
"estado": "ok",
"opciones": {
"graceful_timeout": 300,
"send_hup": verdadero,
...
},
tiempo ': 1332202594.754644
}
Comando línea
$ circusctl opciones
De Seguros
· : nombre del observador
Las teclas de opciones son:
· Numprocesses: número entero, número de procesos
· Warmup_delay: entero o número, demora para esperar entre el proceso de desove en segundos
· Working_dir: cadena, directorio donde se ejecutará el proceso
· Uid: cadena o entero, ID de usuario utilizado para iniciar el proceso
· Gid: cadena o entero, ID de grupo utilizado para iniciar el proceso
· Send_hup: booleano, si TRU la señal HUP se utilizará en la recarga
· Shell: booleano, ejecutará el comando en el entorno de shell si es verdadero
· Cmd: cadena, la línea de comando utilizada para iniciar el proceso
· Env: objeto, define el entorno en el que se lanzará el proceso
· Retry_in: entero o número, tiempo en segundos que esperamos antes de volver a intentar lanzar el
proceso si se ha alcanzado el número máximo de intentos.
· Max_retry: entero, el máximo de reintentos de bucles
· Graceful_timeout: entero o número, tiempo que esperamos antes de matar definitivamente un proceso.
· Prioridad: se utiliza para clasificar a los observadores en el árbitro
· Singleton: si es Verdadero, un observador singleton.
· Max_age: tiempo que un proceso puede vivir antes de reiniciarse
· Max_age_variance: tiempo adicional de vida variable, evita la estampida del rebaño.
Dejar de la forma más árbitro inmediatamente
Cuando el árbitro recibe este comando, el árbitro sale.
ZMQ Mensaje
{
"comando": "salir",
"esperando": falso
}
La respuesta devuelve el estado "ok".
If estaba es Falso (predeterminado), la llamada regresará inmediatamente después de llamar señal_parada
en cada proceso.
If estaba es Verdadero, la llamada regresará solo cuando el proceso de detención haya finalizado por completo.
Debido a la opción graceful_timeout, puede llevar algún tiempo.
Comando línea
$ circusctl salir [--esperando]
Recargar de la forma más árbitro or a observador
Este comando recarga todo el proceso en un observador o en todos los observadores. Esto sucederá en uno
de 3 formas:
· Si elegante es falso, se produce un reinicio simple.
· Si enviar_hup es cierto para el observador, se envía una señal HUP a cada proceso.
·
De otra manera:
· Si secuencial es falso, el árbitro intentará generar numprocesos new
Procesos. Si los nuevos procesos se generan con éxito, el resultado es que
todos los procesos antiguos se detienen, ya que por defecto los procesos más antiguos son
se detiene cuando el número real de procesos para un observador es mayor que
numprocesos.
· Si secuencial es verdadero, el árbitro reiniciará cada proceso en una secuencia
camino (con un calentamiento_retraso pausa entre cada paso)
ZMQ Mensaje
{
"comando": "recargar",
"propiedades": {
"nombre": ' ",
"agraciado": cierto,
"secuencial": falso,
"esperando": falso
}
}
La respuesta devuelve el estado "ok". Si la propiedad graceful se establece en true, los procesos
saldrá con gracia.
Si el nombre de la propiedad está presente, la recarga se aplicará al observador.
Comando línea
$ circusctl reload [ ] [--terminate] [--waiting]
[--secuencial]
De Seguros
· : nombre del observador
· --Terminar; salir del nodo inmediatamente
Recargar de la forma más configuración presentar
Este comando recarga el archivo de configuración, por lo que los cambios en el archivo de configuración serán
reflejado en la configuración del circo.
ZMQ Mensaje
{
"comando": "reloadconfig",
"esperando": falso
}
La respuesta devuelve el estado "ok". Si la propiedad graceful se establece en true, los procesos
saldrá con gracia.
Comando línea
$ circusctl reloadconfig [- en espera]
Reanudar de la forma más árbitro or a observador
Este comando reinicia todo el proceso en un observador o en todos los observadores. Esta funcion simplemente
detenga un observador y luego reinícielo.
ZMQ Mensaje
{
"comando": "reiniciar",
"propiedades": {
"nombre": " ",
"esperando": Falso,
"coincidencia": "[simple | glob | regex]"
}
}
La respuesta devuelve el estado "ok".
Si el nombre de la propiedad está presente, la recarga se aplicará al observador.
If estaba es Falso (predeterminado), la llamada regresará inmediatamente después de llamar señal_parada
en cada proceso.
If estaba es Verdadero, la llamada regresará solo cuando el proceso de reinicio esté completamente
terminó. Debido a la opción graceful_timeout, puede llevar algún tiempo.
El partido el parámetro puede tener el valor simples para comparar cadenas, glob para comodín
coincidente (predeterminado) o expresiones regulares para la coincidencia de expresiones regulares.
Comando línea
$ circusctl restart [nombre] [--esperando] [--match = simple | glob | regex]
De Seguros
· : nombre o patrón del observador (es)
· : método de coincidencia del observador
Eliminar a observador
Este comando elimina un observador dinámicamente del árbitro. Los vigilantes son graciosamente
detenido por defecto.
ZMQ Mensaje
{
"comando": "rm",
"propiedades": {
"nombre": " ",
"nostop": falso,
"esperando": falso
}
}
La respuesta devuelve un estado "ok".
If no te detengas es Verdadero (predeterminado: Falso), los procesos para el observador no se detendrán -
en cambio, el espectador simplemente será olvidado por el circo y los procesos del observador serán
responsables de detenerse. Si no te detengas no está especificado o es Falso, entonces el
Los procesos del observador se detendrán con gracia.
If estaba es Falso (predeterminado), la llamada regresará inmediatamente después de comenzar a eliminar
y detenga al observador correspondiente.
If estaba es Verdadero, la llamada regresará solo cuando el proceso de remoción y detención sea
terminado completamente. Debido a la opción graceful_timeout, puede llevar algún tiempo.
Comando línea
$ circusctl rm [--esperando] [--nostop]
De Seguros
· : nombre del observador a eliminar
· Nostop: no detenga los procesos del observador, simplemente elimine el observador
Set a observador opción
ZMQ Mensaje
{
"comando": "establecer",
"propiedades": {
"nombre": "nombre del observador",
"opciones": {
"key1": "val1",
..
}
"esperando": falso
}
}
La respuesta devuelve el estado "ok". Consulte el comando Opciones para obtener una lista de claves a configurar.
Comando línea
$ circusctl set --esperando
Enviar a señal
Este comando le permite enviar una señal a todos los procesos en un observador, un proceso específico
en un vigilante o sus hijos.
ZMQ Mensaje
Para enviar una señal a todos los procesos para un observador:
{
"comando": "señal",
"propiedad": {
"nombre": ,
"signum":
}
Para enviar una señal a un proceso:
{
"comando": "señal",
"propiedad": {
"nombre": ,
"pid": ,
"signum":
}
Se puede utilizar una propiedad opcional "niños" para enviar la señal a todos los niños en lugar de
que el proceso en sí:
{
"comando": "señal",
"propiedad": {
"nombre": ,
"pid": ,
"signum": ,
"niños": Verdadero
}
Para enviar una señal a un hijo de proceso:
{
"comando": "señal",
"propiedad": {
"nombre": ,
"pid": ,
"signum": ,
"child_pid": ,
}
También es posible enviar una señal a todos los hijos del observador:
{
"comando": "señal",
"propiedad": {
"nombre": ,
"signum": ,
"niños": Verdadero
}
Por último, puede enviar una señal al proceso. y sus hijos, con el recursiva opción:
{
"comando": "señal",
"propiedad": {
"nombre": ,
"signum": ,
"recursivo": verdadero
}
Comando línea
$ circusctl señal [ ] [--niños]
[--recursivo]
Opciones:
· : el nombre del observador
· : entero, el ID del proceso.
· : el número de señal (o nombre) a enviar.
· : el pid de un niño, si lo hay
· : booleano, envía la señal a todos los niños
· : booleano, envía la señal al proceso y sus hijos
Inicio de la forma más árbitro or a observador
Este comando inicia todos los procesos en un observador o en todos los observadores.
ZMQ Mensaje
{
"comando": "iniciar",
"propiedades": {
"nombre": ' ",
"esperando": Falso,
"coincidencia": "[simple | glob | regex]"
}
}
La respuesta devuelve el estado "ok".
Si el nombre de la propiedad está presente, se iniciará el observador.
If estaba es Falso (predeterminado), la llamada regresará inmediatamente después de llamar comienzo on
cada proceso.
If estaba es Verdadero, la llamada regresará solo cuando el proceso de inicio haya finalizado por completo.
Debido a la opción graceful_timeout, puede llevar algún tiempo.
El partido el parámetro puede tener el valor simples para comparar cadenas, glob para comodín
coincidente (predeterminado) o expresiones regulares para la coincidencia de expresiones regulares.
Comando línea
$ circusctl restart [nombre] [--esperando] [--match = simple | glob | regex]
De Seguros
· : nombre o patrón del observador (es)
· : método de coincidencia del observador
Get info
Puede obtener en cualquier momento algunas estadísticas sobre sus procesos con el comando stat.
ZMQ Mensaje
Para obtener estadísticas de todos los observadores:
{
"comando": "estadísticas"
}
Para obtener estadísticas para un observador:
{
"comando": "estadísticas",
"propiedades": {
"nombre":
}
}
Para obtener estadísticas de un proceso:
{
"comando": "estadísticas",
"propiedades": {
"nombre": ,
"proceso":
}
}
Las estadísticas se pueden extender con el gancho extended_stats, pero las estadísticas extendidas deben ser
solicitado:
{
"comando": "estadísticas",
"propiedades": {
"nombre": ,
"proceso": ,
"extendido": verdadero
}
}
La respuesta devuelve un objeto por proceso con la propiedad "info" que contiene algún proceso.
informaciones:
{
"información": {
"niños": [],
"cmdline": "python",
"cpu": 0.1,
"ctime": "0: 00.41",
"mem": 0.1,
"mem_info1": "3M",
"mem_info2": "2G",
"agradable": 0,
"pid": 47864,
"nombre de usuario": "root"
},
"proceso": 5,
"estado": "ok",
"tiempo": 1332265655.897085
}
Comando Line
$ circusctl stats [--extended] [ ] [ ]
Get de la forma más estado of a observador or all observadores
Este comando comienza a obtener el estado de un observador o de todos los observadores.
ZMQ Mensaje
{
"comando": "estado",
"propiedades": {
"nombre": ' ",
}
}
La respuesta devuelve el estado "activo" o "detenido" o el estado / observadores.
Comando línea
$ circusctl status [ ]
De Seguros
· : nombre del observador
Ejemplo
$ circusctl estado ficticio
lector activo
estado de $ circusctl
ficticio: activo
dummy2: activo
refugio: activo
Parada observadores
Este comando detiene a un observador determinado oa todos los observadores.
ZMQ Mensaje
{
"comando": "detener",
"propiedades": {
"nombre": " ",
"esperando": Falso,
"coincidencia": "[simple | glob | regex]"
}
}
La respuesta devuelve el estado "ok".
Si nombre la propiedad está presente, entonces la parada se aplicará al observador
correspondiente a ese nombre. De lo contrario, todos los observadores se detendrán.
If estaba es Falso (predeterminado), la llamada regresará inmediatamente después de llamar señal_parada
en cada proceso.
If estaba es Verdadero, la llamada regresará solo cuando el proceso de detención haya finalizado por completo.
Debido a la opción graceful_timeout, puede llevar algún tiempo.
El partido el parámetro puede tener el valor simples para comparar cadenas, glob para comodín
coincidente (predeterminado) o expresiones regulares para la coincidencia de expresiones regulares.
Comando línea
$ circusctl stop [nombre] [- esperando] [--match = simple | glob | regex]
De Seguros
· : nombre o patrón del observador (es)
· : método de coincidencia del observador
CLI
circo-top
circo-top es una consola superior que puede ejecutar para ver en vivo su sistema Circus en ejecución. Eso
mostrará la CPU, el uso de memoria y los hits de socket si tiene alguno.
Ejemplo de salida:
-------------------------------------------------- ---------------------
Circusd-estadísticas
PID CPU (%) MEMORIA (%)
14252 0.8 0.4
0.8 (promedio) 0.4 (suma)
maniquí
PID CPU (%) MEMORIA (%)
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 (promedio) 0.5 (suma)
-------------------------------------------------- --------------------
circo-top es una consola de solo lectura. Si desea interactuar con el sistema, utilice circoctl.
circoctl
circoctl se puede utilizar para ejecutar cualquier comando enumerado en los comandos. Por ejemplo, puede obtener un
lista de todos los observadores, puedes hacer
$ circoctl lista
Además de admitir un puñado de opciones, también puede especificar el punto final circoctl should
usar usando el CIRCUSCTL_ENDPOINT Variable ambiental.
El Webtracking Consola
Circus viene con una consola web que se puede utilizar para administrar el sistema.
La consola web le permite:
· Conéctese a cualquier sistema Circus en funcionamiento
· Observa los procesos de uso de la CPU y la memoria en tiempo real
· Agregar o matar procesos
· Agregar nuevos observadores
NOTA:
La función de uso de CPU y memoria en tiempo real utiliza el socket de estadísticas. Si quieres
actívelo, asegúrese de que el sistema Circus al que se conectará tenga las estadísticas en punto
habilitado en su configuración:
[circo]
statsd = Verdadero
De forma predeterminada, esta opción no está activada.
La consola web es su propio paquete, necesita instalar:
$ pip instalar circus-web
Para habilitar la consola, agregue algunas opciones en el archivo ini de Circus:
[circo]
httpd = Verdadero
httpd_host = servidor local
httpd_puerto = 8080
httpd_host y puerto_httpd son opcionales y por defecto localhost y 8080.
Si desea ejecutar la aplicación web por sí sola, simplemente ejecute el circo script:
$ circohttpd
El servidor de botellas se está iniciando ...
Escuchando http://localhost: 8080 /
Presione Ctrl-C para salir.
De forma predeterminada, la secuencia de comandos ejecutará la consola web en el puerto 8080, pero la opción --port puede ser
utilizado para cambiarlo.
Gracias a de la forma más un mueble consola
Una vez que se ejecuta el script, puede abrir un navegador y visitar http://localhost: 8080. Usted
debería aparecer esta pantalla: [imagen]
La Consola Web está lista para conectarse a un sistema Circus, dado su punto final. Por
predeterminado, el punto final es tcp: //127.0.0.1: 5555.
Una vez que golpeas conéctese, la aplicación web se conectará al sistema Circus.
Con la consola web iniciada, debería obtener una lista de observadores y un estado en tiempo real
de los dos procesos Circus (circusd y circusd-stats).
Puede hacer clic en el estado de cada observador para alternar entre Active (verde) a Inactivo
(rojo). Este cambio es efectivo de inmediato y le permite iniciar y detener a los observadores.
Si hace clic en el nombre del observador, obtendrá una página web para ese observador en particular,
con sus procesos:
En esta pantalla, puede agregar o eliminar procesos y eliminar los existentes.
Por último, pero no menos importante, puede agregar un nuevo observador haciendo clic en el Añadir el archivo Vigilante enlace en
el menú de la izquierda: .SS Corriendo detrás de Nginx
Nginx puede actuar como un proxy y una capa de seguridad frente a circus-web.
NOTA:
Para recibir gráficos y actualizaciones de estado en tiempo real en circus-web, debe proporcionar un Nginx
solución de proxy que tiene soporte websocket
Nginx >= 1.3.13
A partir de Nginx> = 1.3.13, el soporte websocket está integrado, por lo que no es necesario combinar Nginx
con Barniz o HAProxy. Un ejemplo de configuración de Nginx con soporte websocket:
circusweb_server aguas arriba {
servidor 127.0.0.1:8080;
}
servidor {
escuchar 80;
nombre del servidor _;
ubicación /
contraseña_proxy http://circusweb_server;
proxy_http_versión 1.1;
actualización de proxy_set_header $ http_upgrade;
proxy_set_header Conexión "actualización";
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-Fordered-Proto http;
proxy_redirect desactivado;
}
località ~ / media /\ * (. png | .jpg | .css | .js | .ico) $ {
alias / ruta_al_sitio-paquetes / circusweb / media /;
}
}
Nginx < 1.3.13
Las versiones de Nginx <1.3.13 no tienen soporte websocket integrado.
Para proporcionar compatibilidad con websocket para circus-web cuando se usa Nginx <1.3.13, puede combinar
Nginx con Barniz o HAProxy. Es decir, Nginx frente a circus-web, con Varnish o
HAProxy frente a Nginx.
El siguiente ejemplo muestra la configuración combinada de Nginix y Varnish requerida para proxy
circus-web y proporcionar soporte websocket.
Nginx de configuración:
circusweb_server aguas arriba {
servidor 127.0.0.1:8080;
}
servidor {
escuchar 8001;
nombre del servidor _;
ubicación /
proxy_set_header X-Forwarded-For $ proxy_add_x_forwarded_for;
proxy_set_header Host $ http_host;
proxy_redirect desactivado;
contraseña_proxy http://circusweb_server;
}
località ~ / media /\ * (. png | .jpg | .css | .js | .ico) $ {
alias / ruta_al_sitio-paquetes / circusweb / media /;
}
}
Si desea más opciones de configuración de Nginx, consulte http://wiki.nginx.org/HttpProxyModule.
Barniz de configuración:
backend predeterminado {
.host = "127.0.0.1";
.port = "8001";
}
socket de backend {
.host = "127.0.0.1";
.port = "8080";
.connect_timeout = 1s;
.first_byte_timeout = 2s;
.between_bytes_timeout = 60 s;
}
subvcl_pipe {
si (req.http.actualización) {
establecer bereq.http.upgrade = req.http.upgrade;
}
}
subvcl_recv {
if (req.http.Upgrade ~ "(? i) websocket") {
establecer req.backend = socket;
retorno (tubería);
}
}
En el ejemplo de configuración de Varnish anterior, se definen dos backends. Uno al servicio de la web
consola y una que sirve a las conexiones del zócalo. Las solicitudes de la consola web están vinculadas al puerto
8001. La directiva de 'servidor' de Nginx debe configurarse para escuchar en el puerto 8001.
Las conexiones de Websocket se actualizan y canalizan directamente al proceso de escucha de circushttpd
en el puerto 8080 de Varnish. es decir, sin pasar por el proxy Nginx.
Ubuntu
Desde la versión 13.10 (Fresco), Ubuntu incluye Nginx con soporte websocket en su propio
repositorios. Para versiones anteriores, puede instalar Nginx> = 1.3.13 desde el Nginx oficial
PPA estable, así:
sudo apt-get install python-software-propiedades
sudo add-apt-repository ppa: nginx / estable
apt-get update sudo
sudo apt-get install nginx
nginx -v
Proteger con contraseña circo
Como se explica en la página Seguridad, ejecutar circo es bastante inseguro. No proporcionamos
cualquier seguridad en el propio Circus, pero puede proteger su consola en el nivel NGinx, por
usando http://wiki.nginx.org/HttpAuthBasicModule
Ejemplo:
ubicación /
proxy_set_header X-Forwarded-For $ proxy_add_x_forwarded_for;
proxy_set_header Host $ http_host;
proxy_set_header X-Reenviado-Host: $ http_host;
proxy_set_header X-Fordered-Proto: $ esquema;
proxy_redirect desactivado;
contraseña_proxy http://127.0.0.1: 8080;
auth_basic "Restringido";
auth_basic_user_file / ruta / a / htpasswd;
}
El htpasswd El archivo contiene usuarios y sus contraseñas, y aparecerá un mensaje de contraseña cuando
accedes a la consola.
Puede usar el script htpasswd de Apache para editarlo, o el script de Python que proporcionan en:
http://trac.edgewall.org/browser/trunk/contrib/htpasswd.py
Sin embargo, no hay soporte nativo para el uso combinado de autenticación HTTP y
WebSockets (el servidor arrojará códigos de error HTTP 401). Una solución alternativa es deshabilitar
autenticación para el servidor socket.io.
Ejemplo (debe agregarse antes de la regla anterior):
ubicación /socket.io {
proxy_set_header X-Forwarded-For $ proxy_add_x_forwarded_for;
proxy_set_header Host $ http_host;
proxy_set_header X-Reenviado-Host: $ http_host;
proxy_set_header X-Fordered-Proto: $ esquema;
proxy_redirect desactivado;
contraseña_proxy http://127.0.0.1: 8080;
}
Por supuesto, esa es solo una forma de proteger su consola web, podría usar muchas otras
técnicas.
Extensión de la forma más web un mueble consola
Elegimos botella para construir la consola web, principalmente porque es un marco realmente pequeño que
no hace mucho. Al echar un vistazo al código de la consola web, eventualmente encontrará
que es realmente simple de entender.
Así es como se divide:
· Los circohttpd.py El archivo contiene las definiciones de "vistas" y algo de código para manejar el
conexión de enchufe (a través de socketio).
· los controlador.py contiene una sola clase que se encarga de hacer la comunicación
con el controlador de circo. Permite tener una API de alto nivel más agradable al definir el
Servidor web.
Si desea agregar una función en la consola web, puede reutilizar el código existente. A
pocas herramientas están a su disposición para facilitar el proceso:
· Hay un plantilla_de_procesamiento función, que toma los argumentos nombrados que le pasas y
pasarlos al renderizador de plantillas y devolver el HTML resultante. También pasa algunos
variables adicionales, como la sesión, la versión circense y el cliente si está definido.
· Si desea ejecutar comandos y realizar una redirección en función del resultado, puede utilizar
de la forma más ejecutar_comando función, que toma un invocable como primer argumento, un mensaje en caso de
de éxito y una URL de redireccionamiento.
El Estadísticas La clase es responsable de gestionar la comunicación websocket en el
lado del servidor. Su documentación debería ayudarlo a comprender lo que hace.
Acoplar con tomas
Circus puede enlazar tomas de red y gestionarlas como lo hace con los procesos.
La idea principal es que un proceso secundario creado por Circus para ejecutar uno de los
El comando puede heredar de todos los descriptores de archivos abiertos.
Así es como funcionan Apache o Unicorn, y muchas otras herramientas que existen.
Objetivo
El objetivo de tener sockets administrados por Circus es poder administrar aplicaciones de red.
en Circus exactamente como otras aplicaciones.
Por ejemplo, si usa Circus con Chaussette - un servidor WGSI, puede obtener un muy rápido
servidor web en ejecución y gestión "Web Trabajadores " en el circo como lo harías con cualquier otro
.
Dividir la gestión de sockets de la propia aplicación de red ofrece una gran cantidad de
oportunidades para escalar y administrar su pila.
Diseño
La esencia de la función se realiza vinculando el zócalo y comenzando a escucharlo en
circo:
importar socket
sock = socket.socket (FAMILIA, TIPO)
sock.bind ((HOST, PORT))
sock.listen (BACKLOG)
fd = calcetín.fileno ()
Circus luego realiza un seguimiento de todos los fds abiertos y deja que los procesos que se ejecutan como niños
tener acceso a ellos si lo desean.
Si crea un pequeño script de red Python que tiene la intención de ejecutar en Circus, podría
se parece a esto:
importar socket
importación de sistemas
fd = int (sys.argv [1]) # obteniendo el FD del circo
calcetín = enchufe.fromfd (fd, FAMILIA, TIPO)
# tratar con una solicitud a la vez
mientras cierto:
conn, addr = sock.accept ()
solicitud = conn.recv(1024)
.. hacer algo ..
conn.sendall (respuesta)
conn.close ()
Entonces Circus podría funcionar así:
[circo]
verificar_retraso = 5
punto final = tcp: //127.0.0.1: 5555
pubsub_endpoint = tcp: //127.0.0.1: 5556
stats_endpoint = tcp: //127.0.0.1: 5557
[observador: tonto]
cmd = mycoolscript $ (circus.sockets.foo)
use_sockets = Verdadero
calentamiento_retraso = 0
numprocesos = 5
[socket: foo]
anfitrión = 127.0.0.1
port = 8888
$ (circus.sockets.foo) será reemplazado por el valor FD una vez que se crea el zócalo y
atado en el 8888 Puerto.
NOTA:
A partir de Circus 0.8 hay una sintaxis alternativa para evitar algunos conflictos con algunos
analizadores de configuración. Puedes escribir:
((circo.sockets.foo))
Mundo real (aqui)
Chaussette es el compañero de circo perfecto si desea ejecutar su aplicación WSGI.
Una vez que esté instalado, ejecutando 5 me encerrado los trabajadores se pueden hacer creando un socket y
llamando al calcetín comando en un trabajador, así:
[circo]
punto final = 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 = Verdadero
numprocesos = 5
[socket: web]
anfitrión = 0.0.0.0
port = 8000
Aún no publicamos puntos de referencia, pero un clúster web administrado por Circus con Gevent o
El backend de Meinheld es tan rápido como cualquier servidor WSGI previo a la bifurcación.
Gracias a incorporado plugins
Circus viene con algunos complementos integrados. Esta sección presenta estos complementos y sus
opciones de configuración.
Estadísticas
use establecido en 'circus.plugins.statsd.StatsdEmitter'
Nombre de la aplicación
el nombre utilizado para identificar el prefijo del depósito al que emitir las estadísticas (será
prefijado con circo. y con el sufijo .observador)
fortaleza el anfitrión para publicar los datos estadísticos en
Puerto el puerto en el que escucha el demonio statsd
tasa_de_muestra
si prefiere una frecuencia de muestreo diferente a 1, puede configurarla aquí
Estadísticas completas
Una extensión del complemento Statsd que también publica las estadísticas del proceso. Como tal
tiene las mismas opciones de configuración que Statsd y las siguientes.
use establecido en circo.plugins.statsd.FullStats
velocidad_bucle
la frecuencia con la que el complemento debe solicitar las estadísticas en segundos. Predeterminado: 60.
RedisObservador
Este servicio observa un proceso de redis para usted, publica la información en statsd
y ofrece reiniciar el observador cuando no reacciona en un tiempo de espera determinado. Este complemento
requiere redis-py correr.
Tiene la misma configuración que statsd y agrega lo siguiente:
use establecido en circo.plugins.redis_observer.RedisObserver
velocidad_bucle
la frecuencia con la que el complemento debe solicitar las estadísticas en segundos. Predeterminado: 60.
redis_url
la base de datos para verificar como una URL de redis. Predeterminado: "redis: // localhost: 6379/0"
tiempo de espera
el tiempo de espera en segundos que puede tomar la solicitud antes de que se considere inactiva.
El valor predeterminado es 5.
reiniciar_en_tiempo de espera
el nombre del proceso que se reiniciará cuando se agote el tiempo de espera de la solicitud. No reiniciar
desencadenado cuando no se da. Predeterminado: Ninguno.
HttpObserver
Este servicio observa un proceso http para usted haciendo ping a un determinado sitio web con regularidad.
Similar al observador de redis, ofrece reiniciar el observador en caso de error. Requiere
tornado correr.
Tiene la misma configuración que statsd y agrega lo siguiente:
use establecido en circo.plugins.http_observer.HttpObserver
velocidad_bucle
la frecuencia con la que el complemento debe solicitar las estadísticas en segundos. Predeterminado: 60.
comprobar_url
la URL a buscar. Defecto: http://localhost/
tiempo de espera
el tiempo de espera en segundos que puede tomar la solicitud antes de que se considere inactiva.
El valor predeterminado es 10.
reiniciar_en_error
el nombre del proceso que se reiniciará cuando se agote el tiempo de espera de la solicitud o devolvió algún
otro tipo de error. No se activa el reinicio cuando no se proporciona. Predeterminado: Ninguno.
Observador de recursos
Este servicio observa los recursos del proceso dado y desencadena un reinicio cuando
superan ciertas limitaciones con demasiada frecuencia seguidas.
Tiene la misma configuración que statsd y agrega lo siguiente:
use establecido en circo.plugins.resource_watcher.ResourceWatcher
velocidad_bucle
la frecuencia con la que el complemento debe solicitar las estadísticas en segundos. Predeterminado: 60.
observador
el observador que debe cuidar este observador de recursos. (anteriormente llamado
Service but Service ahora está en desuso)
máx_cpu
El máximo de CPU que puede consumir un proceso (en%). Predeterminado: 90
min_cpu
La CPU mínima que debe consumir un proceso (en%). Predeterminado: Ninguno (sin mínimo)
Puede establecer min_cpu en 0 (cero), en este caso si un proceso consume exactamente
0% cpu, activará un límite excedido.
max_mem
La cantidad de memoria que puede consumir un proceso de este observador. Defecto:
90. Si no se especifica ninguna unidad, el valor está en%. Ejemplo: 50 Si una unidad es
especificado, el valor está en bytes. Las unidades compatibles son B, K, M, G, T, P, E, Z, Y.
Ejemplo: 250M
min_mem
La memoria mínima que debe consumir un proceso de este observador. Predeterminado: Ninguno (no
mínimo). Si no se especifica ninguna unidad, el valor está en%. Ejemplo: 50 Si una unidad es
especificado, el valor está en bytes. Las unidades compatibles son B, K, M, G, T, P, E, Z, Y.
Ejemplo: 250M
umbral_de_salud
La salud es el promedio de CPU y memoria (en%) que los procesos de los observadores están
permitido consumir (en%). Predeterminado: 75
cuenta_max
¿Con qué frecuencia se permiten estos límites (cada uno se cuenta por separado)
excedido antes de que se active un reinicio. Predeterminado: 3
Ejemplo:
[circo]
; ...
[observador: programa]
cmd = dormir 120
[complemento: myplugin]
uso = circo.plugins.resource_watcher.ResourceWatcher
observador = programa
CPU_min = 10
máx_cpu = 70
min_mem = 0
memoria_máx = 20
Perro guardián
Complemento que enlaza un socket udp y espera mensajes de vigilancia. Para "vigilado"
procesos, el perro guardián los matará si no envían un latido en un cierto
período de tiempo materializado por loop_rate * max_count. (el circo automáticamente
reiniciar los procesos que faltan en el observador)
Cada proceso monitoreado debe enviar un mensaje udp al menos a loop_rate. El udp
El formato del mensaje es una línea de texto, decodificada usando msg_regex parámetro. El latido del corazón
el mensaje DEBE contener al menos el pid del proceso que envía el mensaje.
La lista de observadores monitoreados está determinada por el parámetro observadores_regex en la categoría Industrial.
configuración.
Parámetros de configuración:
use establecido en circo.plugins.perro guardián.perro guardián
velocidad_bucle
Tasa de bucle de vigilancia en segundos. En cada bucle, WatchDog buscará "muertos"
de los empleados.
observadores_regex
regex para los nombres de observadores coincidentes que deben ser monitoreados por el perro guardián
(defecto: .* todos los observadores son monitoreados)
msg_regex
regex para decodificar el mensaje de latido recibido en udp (predeterminado:
^ (? P .*);(?PAG PS) el formato predeterminado es un mensaje de texto simple:
pid; marca de tiempo
cuenta_max
número máximo de bucle pasado sin recibir ningún latido antes de reiniciar
proceso (predeterminado: 3)
ip ip el perro guardián se vinculará (predeterminado: 127.0.0.1)
Puerto puerto al que se vinculará el perro guardián (predeterminado: 1664)
Aleteo
Cuando un trabajador reinicia con demasiada frecuencia, decimos que es aleteo. Este complemento realiza un seguimiento
de trabajador reinicia y detiene el vigilante correspondiente en caso de que esté aleteando. Esta
El complemento se puede usar para detener automáticamente a los trabajadores que se reinician constantemente porque
no funcionan correctamente.
use establecido en circus.plugins.flapping.flapping
Los intentos
la cantidad de veces que un proceso puede reiniciarse, dentro de ventana segundos, antes de que nosotros
considérelo aleteo (predeterminado: 2)
ventana la ventana de tiempo en segundos para probar el aleteo. Si el proceso se reinicia más
than Los intentos veces dentro de esta ventana de tiempo, lo consideramos un proceso de aleteo.
(predeterminado: 1)
re-intentar en
tiempo en segundos para esperar hasta que intentemos comenzar de nuevo un proceso que ha sido
aleteo. (predeterminado: 7)
max_reintentar
la cantidad de veces que intentamos iniciar un proceso que ha estado batiendo, antes
abandonamos y detenemos a todo el observador. (predeterminado: 5) Establecer en -1 para deshabilitar
max_retry y reintentar indefinidamente.
lector activo defina si el complemento está activo o no (predeterminado: Verdadero). Si la bandera global es
establecido en False, el complemento no se inicia.
Las opciones se pueden anular en la sección del observador usando un aleteo. prefijo. Por ejemplo,
así es como se configuraría un max_reintentar valor para nginx:
[observador: nginx]
cmd = / ruta / a / nginx
aleteo.max_retry = 2
[observador: myscript]
cmd = ./mi_script.py
; ... otros observadores
[complemento: aleteo]
uso = circo.plugins.flapping.Flapping
max_reintentar = 5
ComandoRecargador
Este complemento reiniciará a los observadores cuando se modifique su archivo de comando. Funciona por
comprobando la hora de modificación y la ruta del archivo apuntado por el cmd opción cada
velocidad_bucle segundos. Esto puede resultar útil al desarrollar procesos de trabajo o incluso para
actualización de código en producción.
use establecido en circo.plugins.command_reloader.CommandReloader
velocidad_bucle
la frecuencia con la que el complemento debe verificar la modificación en segundos. Predeterminado: 1.
Despliegue
Aunque el demonio Circus se puede administrar con el comando circusd, es más fácil tenerlo
inicie en el arranque. Si su sistema es compatible con Upstart, puede crear este script Upstart en
/etc/init/circus.conf.
iniciar en el sistema de archivos y en el dispositivo de red IFACE = lo
detener en el nivel de ejecución [016]
respawn
exec / usr / local / bin / circusd /etc/circus/circusd.ini
Esto supone que circusd.ini se encuentra en /etc/circus/circusd.ini. Después de reiniciar,
puede controlar circusd con el comando de servicio:
# servicio de inicio / parada / reinicio del circo
Si su sistema es compatible con systemd, puede crear este archivo de unidad systemd en
/etc/systemd/system/circus.servicio.
[Unidad]
Descripción = Gestor de procesos de circo
Después = syslog.target network.target nss-lookup.target
[Servicio]
Tipo = simple
ExecReload = / usr / bin / circusctl recargar
ExecStart = / usr / bin / circusd /etc/circus/circus.ini
Reinicio = Siempre
RestartSec = 5
[Instalar]
WantedBy = default.target
No es necesario reiniciar si ejecuta el comando daemon-reload a continuación:
# systemctl --system demonio-recargar
Entonces el circo se puede gestionar a través de:
# systemctl start / stop / status / reload circus
Recetas
Esta sección contendrá recetas para implementar Circus. Hasta entonces puedes mirar a Pete
Marioneta recetas o en casa de Remy Chef recetas
Papa Proceso Núcleo
Un problema común a los administradores de procesos es que no puede reiniciar el administrador de procesos.
sin reiniciar todos los procesos que gestiona. Esto dificulta la implementación de un
nueva versión de Circus o nuevas versiones de cualquiera de las bibliotecas de las que depende.
Si está en un sistema de tipo Unix, Circus puede usar el núcleo del proceso Papa. Cuando se usa, papá
creará un demonio de larga duración que servirá como host para cualquier proceso y sockets
creas con él. Si el circo se cierra, Papá mantendrá todo lo que aloja.
Preparar
Comience instalando el papá y establecerproctítulo módulos:
pip instalar papa
pip instalar setproctitle
El establecerproctítulo el módulo es opcional. Se usará si está presente para cambiar el nombre del demonio Papa
for parte superior y ps a algo como "papa daemon from circusd". Si no instala el
establecerproctítulo módulo, ese título será la línea de comando del proceso que lo inició.
Muy confuso.
Una vez que Papa esté instalado, agregue use_papa = verdadero a sus procesos críticos y enchufes.
Generalmente desea albergar todos los procesos de su pila en Papa, y ninguno de los
Procesos de soporte de circo, como los complementos de aleteo y estadísticas.
[circo]
nivel de registro = información
[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
calentamiento_retraso = 3
agraciado_tiempo de espera = 10
max_reintentar = 5
singleton = verdadero
send_hup = verdadero
stop_signal = SALIR
stdout_stream.class = Flujo de archivos
stdout_stream.filename = /var/logs/web-server.log
stdout_stream.max_bytes = 10000000
stdout_stream.backup_count = 10
stderr_stream.class = Corriente de archivos
stderr_stream.filename = /var/logs/web-server-error.log
stderr_stream.max_bytes = 1000000
stderr_stream.backup_count = 10
activo = verdadero
use_papa = verdadero
[observador: registrador]
cmd = / my_service / env / bin / python logger.py ejecutar
dir_trabajo = / mi_servicio
agraciado_tiempo de espera = 10
singleton = verdadero
señal_parada = INT
stdout_stream.class = Flujo de archivos
stdout_stream.filename = /var/logs/logger.log
stdout_stream.max_bytes = 10000000
stdout_stream.backup_count = 10
stderr_stream.class = Corriente de archivos
stderr_stream.filename = /var/logs/logger.log
stderr_stream.max_bytes = 1000000
stderr_stream.backup_count = 10
prioridad = 50
use_papa = verdadero
[observador: web_app]
cmd = / mi_servicio / env / bin / uwsgi --ini uwsgi-live.ini --socket fd: // $ (circus.sockets.web) --stats 127.0.0.1:809$(circus.wid)
dir_trabajo = / my_service / web_app
graceful_timeout = 10
stop_signal = SALIR
use_sockets = Verdadero
stdout_stream.class = Flujo de archivos
stdout_stream.nombre de archivo = /var/logs/web_app.log
stdout_stream.max_bytes = 10000000
stdout_stream.backup_count = 10
stderr_stream.class = Corriente de archivos
stderr_stream.filename = /var/logs/web_app.log
stderr_stream.max_bytes = 1000000
stderr_stream.backup_count = 10
hooks.after_spawn = ejemplos.uwsgi_lossless_reload.children_started
ganchos.before_signal = ejemplos.uwsgi_lossless_reload.clean_stop
hooks.extended_stats = ejemplos.uwsgi_lossless_reload.extended_stats
prioridad = 40
use_papa = verdadero
[socket: web]
ruta = / mi_servicio / calcetín / uwsgi
use_papa = verdadero
[complemento: aleteo]
uso = circo.plugins.flapping.Flapping
ventana = 10
prioridad = 1000
NOTA:
Si los procesos de Papa usan algún conector, esos conectores también deben usar papa.
Diseño Objetivo
Papa está diseñado para ser muy minimalista en características y requisitos. Lo hace:
· Iniciar y detener tomas
· Proporcionar un almacén de clave / valor
· Iniciar procesos y devolver stdout, stderr y el código de salida
No es asi:
· Reiniciar procesos
· Proporcionar una forma de detener los procesos
· Proporcionar cualquier información sobre los procesos que no sea si aún se están ejecutando o no.
Papa no requiere bibliotecas de terceros, por lo que puede ejecutarse solo en la biblioteca estándar de Python.
Puede hacer uso del establecerproctítulo paquete pero que solo se usa para hacer el título
más bonito para ps y parte superior y no es imprescindible.
La funcionalidad se ha mantenido al mínimo, por lo que nunca debería tener que reiniciar el
Papá demonio. La mayor parte de la funcionalidad se ha enviado a la biblioteca cliente como
posible. De esa manera, debería poder implementar una nueva copia de Papa para las nuevas funciones del cliente
sin necesidad de reiniciar el demonio Papa. Papá está destinado a ser un pilar de estabilidad en
un mar cambiante de bibliotecas de terceros.
Operación
La mayoría de las cosas permanecen sin cambios si usa Papa o no. Todavía puedes empezar y parar
Procesos. Aún puede obtener el estado y las estadísticas de los procesos. Lo principal que cambia
es que cuando lo haces circoctl renuncia, todos los procesos de Papa se dejan en ejecución. Cuando usted
comienzo circo copia de seguridad, esos procesos se recuperan.
NOTA:
Cuando se recuperan los procesos, antes de comenzar y antes_spawn se saltan los ganchos.
Inicio de sesión
Mientras Circus está cerrado, Papa almacenará hasta 2M de producción por proceso. Entonces lo hará
comience a descargar los datos más antiguos. Cuando reinicie Circus, esta salida almacenada en caché será rápidamente
recuperado y enviado a los flujos de salida. Papá requiere que el recibo de salida sea
reconocido, por lo que no debe perder ninguna salida durante un apagado.
No solo eso, sino que Papa guarda la marca de tiempo de la salida. Circus se ha mejorado para
aproveche los datos de la marca de tiempo, si están presentes. Entonces, si está escribiendo la salida en archivos de registro
o en algún lugar, todas las marcas de tiempo deben ser correctas.
Problemas
Si utiliza la opcion de aumentar or dic comando para cambiar el recuento de procesos para un observador, esto
restablecerse al nivel especificado en el archivo INI cuando circo se reinicia.
Además, he tenido problemas con la combinación de copiar_env y virtualenv. Usted puede
tenga en cuenta que la muestra INI anterior evita este problema con rutas explícitas.
Telnet Fácil de usar
Papa tiene una interfaz de línea de comandos básica a la que puede acceder a través de telnet:
telnet localhost 20202
ayuda
Circo for desarrolladores
Gracias a Circo as a bibliotecas
Circus ofrece clases y funciones de alto nivel que le permitirán gestionar procesos en
sus propias aplicaciones.
Por ejemplo, si desea ejecutar cuatro procesos para siempre, puede escribir:
de importación de circo get_arbiter
myprogram = {"cmd": "python myprogram.py", "numprocesses": 4}
árbitro = get_arbiter ([myprogram])
tratar:
arbiter.start ()
finalmente:
árbitro.stop ()
Este fragmento ejecutará cuatro instancias de mi programa y míralos por ti, reiniciándolos
si mueren inesperadamente.
Para obtener más información sobre esto, consulte la biblioteca.
Extensión Circo
Es fácil ampliar Circus para crear un sistema más complejo, escuchando todas las
circo eventos a través de su canal pub / sub, y manejándolo a través de comandos.
Así es como funciona la función de aleteo, por ejemplo: escucha todos los procesos que mueren,
mide la frecuencia con la que sucede y detiene a los observadores incriminados después de demasiados reinicios
intentos.
Circus viene con un sistema de complementos para ayudarlo a escribir tales extensiones, y algunas incorporadas
complementos que puede reutilizar. Ver complementos.
También puede tener un comportamiento de inicio y apagado más sutil utilizando el manos te
que le permitirá ejecutar código arbitrario antes y después de que se inicien algunos procesos o
interrumpido. Ver ganchos.
Por último, pero no menos importante, también puede agregar nuevos comandos. Consulte agregar cmds.
Desarrolladores Documentación Home
Circo Biblioteca
El paquete Circus se compone de un paquete de alto nivel. get_arbiter () función y muchas clases. En
En la mayoría de los casos, usar la función de alto nivel debería ser suficiente, ya que crea todo lo que
es necesario para que Circus funcione.
Puede subclasificar las clases de Circus si necesita más granularidad de la que ofrece el
configuración.
El obtener_árbitro función
get_arbiter () es solo una conveniencia además de las diversas clases de circo. Crea un
árbitro (clase Árbitro) instancia con las opciones proporcionadas, que a su vez ejecuta una única
Vigilante con un solo Proceso.
circus.get_arbiter ()
Ejemplo:
de importación de circo get_arbiter
árbitro = get_arbiter ([{"cmd": "myprogram", "numprocesses": 3}])
tratar:
arbiter.start ()
finalmente:
árbitro.stop ()
Clases
Circus ofrece una serie de clases que puede utilizar para implementar su propio administrador de procesos:
· Proceso: envuelve un proceso en ejecución y proporciona algunos ayudantes además.
· Vigilante: ejecutar varias instancias de Proceso contra el mismo comando. Manejar la muerte y
vida de los procesos.
· Árbitro: gestiona varios Vigilante.
clase circus.process.Process (nombre, wid cmd args = Ninguno, working_dir = Ninguno, shell = Falso,
uid = Ninguno, gid = Ninguno, env = Ninguno, rlimits = Ninguno, ejecutable = Ninguno, use_fds = Falso, observador = Ninguno,
spawn = Verdadero, pipe_stdout = Verdadero, pipe_stderr = Verdadero, close_child_stdout = Falso,
close_child_stderr = Falso)
Envuelve un proceso.
Opciones:
· wid: el identificador único del proceso. Este valor se utilizará para reemplazar el $ WID
cadena en la línea de comando si está presente.
· cmd: el comando para ejecutar. Puede contener cualquiera de las variables disponibles que son
pasando a esta clase. Serán reemplazados usando la sintaxis del formato Python.
· args: los argumentos para que se ejecute el comando. Puede ser una lista o una cadena. Si args is
una cuerda, se divide usando shlex.split (). El valor predeterminado es Ninguno.
· ejecutable: Cuando se proporciona un ejecutable, el primer elemento de la secuencia de argumentos
obtenido de cmd la mayoría de los programas todavía lo tratan como el nombre del comando, que
entonces puede ser diferente del nombre real del ejecutable. Se convierte en la pantalla
nombre del programa en ejecución en utilidades como ps.
· directorio_de_trabajo: el directorio de trabajo en el que ejecutar el comando. Si no se proporciona,
predeterminado al directorio de trabajo actual.
· shell: Si ¿Editas con tu equipo de forma remota?, ejecutará el comando en el entorno de shell. Falso por defecto
advertencia: este vídeo is a EN LINEA peligro.
· UID: si se proporciona, es la identificación de usuario o el nombre con el que se debe ejecutar el comando. La corriente
uid es el predeterminado.
· gid: si se proporciona, es el ID de grupo o el nombre con el que se debe ejecutar el comando. La corriente
gid es el predeterminado.
· env: un mapeo que contiene las variables de entorno con las que se ejecutará el comando.
Opcional.
· límites: un mapeo que contiene los nombres y valores de rlimit que se establecerán antes del
se ejecuta el comando.
· usar_fds: si es True, no cerrará los fds en el subproceso. Debe estar configurado en
Verdadero en Windows si se redirigen stdout o stderr. predeterminado: falso.
· tubería_stdout: si es Verdadero, abrirá un TUBO en la salida estándar. predeterminado: Verdadero.
· tubería_stderr: si es True, abrirá un PIPE en stderr. predeterminado: Verdadero.
· close_child_stdout: Si es True, redirige el proceso secundario 'stdout a / dev / null
después de la bifurcación. predeterminado: falso.
· close_child_stderr: Si es True, redirige el proceso secundario 'stdout a / dev / null
después de la bifurcación. predeterminado: falso.
la edad() Devuelve la edad del proceso en segundos.
niños()
Devuelve una lista de pids de niños.
info () Información del proceso de devolución.
La información devuelta es una asignación con estas claves:
· mem_info1: Memoria de tamaño del conjunto residente en bytes (RSS)
· mem_info2: Tamaño de la memoria virtual en bytes (VMS).
· cpu:% de uso de la CPU.
· Miembro:% de uso de memoria.
· ctime: proceso CPU (usuario + sistema) tiempo en segundos.
· pid: identificacion de proceso.
· nombre de usuario: nombre de usuario propietario del proceso.
· agradable: proceso de bondad (entre -20 y 20)
· cmdline: la línea de comando con la que se ejecutó el proceso.
is_child (pid)
Devolver Verdadero es el dado pid es un hijo de ese proceso.
pid Devuelve el pid
send_signal (* argumentos, ** kw)
Envía una señal sig al proceso.
send_signal_child (* argumentos, ** kw)
Enviar señal signum al niño pid.
send_signal_children (* argumentos, ** kw)
Enviar señal signum a todos los niños.
estado Devuelve el estado del proceso como una constante
· CORRIENDO
· MUERTO_O_ZOMBIE
· INEXISTENTE
· OTRO
stderr Devuelve el stdout stream
stdout Devuelve el stdout stream
detener (* argumentos, ** kw)
Detenga el proceso y cierre stdout / stderr
Si el proceso correspondiente todavía está aquí (normalmente ya lo ha matado
el observador), se envía un SIGTERM, luego un SIGKILL después de 1 segundo.
El proceso de apagado (SIGTERM luego SIGKILL) normalmente lo toma el
vigilante. Entonces, si el proceso todavía está ahí, es una especie de mal comportamiento
porque el tiempo de espera elegante no se respetará aquí.
Ejemplo:
>>> del proceso de importación circus.process
>>> proceso = Proceso ('Top', 'top', shell = True)
>>> process.age ()
3.0107998847961426
>>> process.info ()
'Arriba: 6812 N / A tarek Zombie N / AN / AN / AN / AN / A'
>>> process.status
1
>>> process.stop ()
>>> process.status
2
>>> process.info ()
'No tal proceso (¿detenido?)'
clase Circus.watcher.Watcher (nombre, cmd args = Ninguno, numprocesses = 1, warmup_delay = 0.0,
working_dir = Ninguno, shell = Falso, shell_args = Ninguno, uid = Ninguno, max_retry = 5, gid = Ninguno,
send_hup = Falso, stop_signal = 15, stop_children = Falso, env = Ninguno, graceful_timeout = 30.0,
prereload_fn = Ninguno, rlimits = Ninguno, ejecutable = Ninguno, stdout_stream = Ninguno, stderr_stream = Ninguno,
prioridad = 0, loop = Ninguno, singleton = Falso, use_sockets = Falso, copy_env = Falso,
copy_path = Falso, edad_máxima = 0, max_age_variance = 30, ganchos = Ninguno, respawn = Verdadero, inicio automático = Verdadero,
on_demand = Falso, virtualenv = Ninguno, close_child_stdout = Falso, close_child_stderr = Falso,
virtualenv_py_ver = Ninguno, use_papa = Falso, ** opciones)
Clase que gestiona una lista de procesos para un comando determinado.
Opciones:
· nombre : nombre dado al observador. Se utiliza para identificarlo de forma única.
· cmd: el comando para ejecutar. Puede contener $ WID, que será reemplazado por wid.
· args: los argumentos para que se ejecute el comando. Puede ser una lista o una cadena. Si args is
una cuerda, se divide usando shlex.split (). El valor predeterminado es Ninguno.
· numprocesos: Número de procesos a ejecutar.
· directorio_de_trabajo: el directorio de trabajo en el que ejecutar el comando. Si no se proporciona,
predeterminado al directorio de trabajo actual.
· shell: Si ¿Editas con tu equipo de forma remota?, ejecutará el comando en el entorno de shell. Falso por defecto
advertencia: este vídeo is a EN LINEA peligro.
· UID: si se proporciona, es la identificación de usuario o el nombre con el que se debe ejecutar el comando. La corriente
uid es el predeterminado.
· gid: si se proporciona, es el ID de grupo o el nombre con el que se debe ejecutar el comando. La corriente
gid es el predeterminado.
· enviar_hup: si es Verdadero, se realizará una recarga del proceso enviando la señal SIGHUP.
El valor predeterminado es Falso.
· señal_parada: la señal a enviar al detener el proceso. Por defecto es SIGTERM.
· detener_los_niños: envía el señal_parada a los niños también. El valor predeterminado es Falso.
· env: un mapeo que contiene las variables de entorno con las que se ejecutará el comando.
Opcional.
· límites: un mapeo que contiene los nombres y valores de rlimit que se establecerán antes del
se ejecuta el comando.
· stdout_stream: un mapeo que define la secuencia para el proceso stdout. Defaults
a Ninguno.
Opcional. Cuando se proporciona, stdout_stream es un mapeo que contiene hasta tres claves:
· clase: la clase de flujo. Predeterminado a circo.stream.FileStream
· nombre de archivo: el nombre del archivo, si usa un FileStream
· max_bytes: tamaño máximo de archivo, después del cual se abre un nuevo archivo de salida. valores predeterminados
a 0, lo que significa que no hay tamaño máximo (solo se aplica con FileStream).
· recuento_copia de seguridad: cuántas copias de seguridad se deben retener al rotar archivos de acuerdo con el
parámetro max_bytes. el valor predeterminado es 0, lo que significa que no se realizan copias de seguridad (solo
aplicable con FileStream)
Este mapeo se utilizará para crear un flujo invocable de la clase especificada.
Cada entrada recibida por el llamante es un mapeo que contiene:
· pid - el proceso pid
· nombre - el nombre de la transmisión (stderr or stdout)
· datos - los datos
Esto no es compatible con Windows.
· stderr_stream: un mapeo que define la secuencia para el proceso stderr. Defaults
a Ninguno.
Opcional. Cuando se proporciona, stderr_stream es un mapeo que contiene hasta tres claves:
- clase: la clase de flujo. Predeterminado a circo.stream.FileStream - nombre de archivo: el
nombre de archivo, si usa un FileStream - max_bytes: tamaño máximo de archivo, después de lo cual un nuevo
el archivo de salida es
abrió. el valor predeterminado es 0, lo que significa que no hay tamaño máximo (solo se aplica con
flujo de archivos)
· recuento_copia de seguridad: cuántas copias de seguridad se deben retener al rotar archivos de acuerdo con el
parámetro max_bytes. el valor predeterminado es 0, lo que significa que no se realizan copias de seguridad (solo
aplicable con FileStream).
Este mapeo se utilizará para crear un flujo invocable de la clase especificada.
Cada entrada recibida por el llamante es un mapeo que contiene:
· pid - el proceso pid
· nombre - el nombre de la transmisión (stderr or stdout)
· datos - los datos
Esto no es compatible con Windows.
· lista de prioridades - entero que define una prioridad para el observador. Cuando el Árbitro lo haga
algunas operaciones en todos los observadores, las clasificará con este campo, desde el
mayor número al menor. (predeterminado: 0)
· Singleton - Si es Verdadero, este observador tiene un solo proceso. (predeterminado: falso)
· usar_sockets - Si es Verdadero, los procesos heredarán los descriptores de archivo, por lo que pueden
reutilizar los enchufes abiertos por circusd. (predeterminado: falso)
· Bajo demanda - Si es True, los procesos se iniciarán solo en la primera conexión
al enchufe (predeterminado: falso)
· copiar_env - Si es Verdadero, el entorno en el que se ejecuta el circo será
reproducido para los trabajadores. Este valor predeterminado es Verdadero en Windows, ya que no puede ejecutar
cualquier ejecutable sin el SYSTEMROOT variable. (predeterminado: falso)
· copiar_ruta - Si es cierto, circo sys.ruta se envía al proceso a través de PITONPATO.
Debes activar copiar_env for copiar_ruta trabajar. (predeterminado: falso)
· edad_máxima: Si se establece después de aproximadamente max_age segundos, el proceso se reemplaza con un nuevo
uno. (predeterminado: 0, deshabilitado)
· varianza_edad_max: El número máximo de segundos que se pueden agregar a max_age.
Este valor adicional es para evitar reiniciar todos los procesos al mismo tiempo. A
El proceso vivirá entre max_age y max_age + max_age_variance segundos.
· manos: funciones de devolución de llamada para conectarse al inicio y apagado del observador
. manos es un dict donde cada clave es el nombre del gancho y cada valor es un
2-tupla con el nombre del invocable o el invocable en sí mismo y una bandera booleana
indicando si una excepción que ocurre en el gancho no debe ignorarse. Posible
valores para el nombre del gancho: antes de comenzar, Después de empezar, antes_spawn, después_spawn,
antes_parar, después de la parada., señal_antes, después de la señal or Extended_stats.
· opciones - opciones extra para el trabajador. Todas las opciones encontradas en la configuración
archivo, por ejemplo, se pasan en este mapeo; esto puede ser utilizado por complementos para
opciones específicas del observador.
· respawn - Si se establece en False, los procesos manejados por un observador no serán
reapareció automáticamente. (predeterminado: verdadero)
· virtualenv - El directorio raíz de un virtualenv. Si se proporciona, el observador
cargar el entorno para su ejecución. (predeterminado: Ninguno)
· close_child_stdout: Si es True, cierra la salida estándar después de la bifurcación. predeterminado: falso.
· close_child_stderr: Si es True, cierra el stderr después de la bifurcación. predeterminado: falso.
· usar_papa: Si es True, use el kernel del proceso papa para este proceso. predeterminado: falso.
kill_process (* argumentos, ** kwargs)
Matar proceso (stop_signal, graceful_timeout y luego SIGKILL)
kill_processes (* argumentos, ** kwargs)
Mata todos los procesos (stop_signal, graceful_timeout y luego SIGKILL)
manage_processes (* argumentos, ** kwargs)
Gestionar procesos.
notificar_evento (tema, mensaje)
Publica un mensaje en el canal del editor de eventos.
reap_and_manage_processes (* argumentos, ** kwargs)
Recolectar y gestionar procesos.
reap_processes (* argumentos, ** kw)
Coseche todos los procesos para este observador.
send_signal_child (* argumentos, ** kw)
Envía una señal a un niño.
spawn_process (recovery_wid = Ninguno)
Proceso de generación.
Devuelve Verdadero si está bien, Falso si el observador debe detenerse
spawn_processes (* argumentos, ** kwargs)
Procesos de generación.
clase Circus.arbiter.Arbiter (observadores, punto final pubsub_punto final, check_delay = 1.0,
prereload_fn = Ninguno, contexto = Ninguno, loop = Ninguno, statsd = Falso, stats_endpoint = Ninguno,
statsd_close_outputs = Falso, multicast_endpoint = Ninguno, plugins = Ninguno, sockets = Ninguno,
warmup_delay = 0, httpd = Falso, httpd_host = 'localhost', httpd_port = 8080,
httpd_close_outputs = Falso, debug = False, debug_gc = Falso, ssh_server = Ninguno,
proc_name = 'circusd', pidfile = Ninguno, loglevel = Ninguno, logoutput = Ninguno, loggerconfig = Ninguno,
fqdn_prefix = Ninguno, umask = Ninguno, endpoint_owner = Ninguno, papa_endpoint = Ninguno)
Clase utilizada para controlar una lista de observadores.
Opciones:
· observadores - una lista de objetos Watcher
· punto final - el punto final del controlador ZMQ
· pubsub_punto final - el punto final de pubsub
· estadísticas - Si es Verdadero, se ejecuta un proceso circusd-stats (predeterminado: Falso)
· stats_endpoint - el punto final de las estadísticas.
· statsd_close_outputs - si True envía el stdout / stderr de circusd-stats a
/ dev / null (predeterminado: falso)
· punto final_multidifusión - el punto final de multidifusión para el autodescubrimiento de clústeres de circusd
(predeterminado: udp: //237.219.251.97: 12027) La dirección de multidifusión debe estar entre 224.0.0.0
a 239.255.255.255 y lo mismo para todo el clúster.
· verificar_retraso - el retraso entre dos puntos del controlador (predeterminado: 1 s)
· prerecargar_fn - invocable que se ejecutará en cada recarga (predeterminado: Ninguno)
· contexto - si se proporciona, el contexto zmq para reutilizar. (predeterminado: Ninguno)
·
bucle: if previsto, a zmq.eventloop.ioloop.IOLoop ejemplo
reutilizar. (predeterminado: Ninguno)
· plugins - una lista de complementos. Cada elemento es un mapeo con:
· use - Nombre completamente calificado que apunta a la clase del complemento
· Todos los demás valores se pasan al complemento en el config opción
· tomas - un mapeo de enchufes. Cada clave es el nombre del conector y cada valor es un
CircoSocket clase. (predeterminado: Ninguno)
· calentamiento_retraso - un retraso en segundos entre el inicio de dos observadores. (predeterminado: 0)
· httpd - Si es Verdadero, se ejecuta un proceso circushttpd (predeterminado: Falso)
· httpd_host - el anfitrión circushttpd (predeterminado: localhost)
· puerto_httpd - el puerto circushttpd (predeterminado: 8080)
· httpd_close_outputs - si es True, envía circushttpd stdout / stderr a / dev / null.
(predeterminado: falso)
· depurar - si es Verdadero, agrega mucha información de depuración en la salida estándar (predeterminado: Falso)
· depuración_gc - si es Verdadero, gc.set_debug (gc.DEBUG_LEAK) (predeterminado: Falso) a circusd
para analizar problemas (predeterminado: falso)
· nombre_proc - el nombre del proceso de árbitro
·
prefijo_fqdn -- a prefijo for de la forma más único identificador of de la forma más circo
instancia en el clúster.
· endpoint_propietario - usuario de Unix al que se le asignará el endpoint si se usa ipc.
· papa_endpoint - el punto final del kernel del proceso papa
add_watcher (* argumentos, ** kwargs)
Agrega un observador.
Opciones:
· nombre : nombre del observador que se agregará
· cmd: comando para ejecutar.
· Todas las demás opciones definidas en el constructor Watcher.
get_watcher (nombre)
Devuelve el vigilante nombre .
numprocesses ()
Devuelve el número de procesos que se ejecutan en todos los observadores.
numwatchers ()
Devuelve el número de observadores.
recargar (* argumentos, ** kwargs)
Recarga todo.
Ejecute el prereload_fn () invocable si hay alguno, entonces recargue con gracia todos los observadores.
inicio (* argumentos, ** kwargs)
Inicia todos los observadores.
Si el ioloop se ha proporcionado durante la llamada __init __ (), inicia todos los observadores
como una corrutina estándar
Si no se ha proporcionado el ioloop durante la llamada __init __ () (predeterminado), se inicia
todos los observadores y el eventloop (y los bloques aquí). En este modo el método
NO DEBE ceder nada porque se llama como método estándar.
parámetros
cb - Devolución de llamada llamada después de que se hayan iniciado todos los observadores, cuando
no se ha proporcionado el bucle.
Escribiendo plugins
Circus viene con un sistema de complementos que te permite interactuar con circo.
NOTA:
Podríamos agregar soporte circusd-stats a los complementos más adelante.
Un complemento se compone de dos partes:
· Un suscriptor de ZMQ a todos los eventos publicados por circo
· Un cliente ZMQ al que enviar comandos circo
Cada complemento se ejecuta como un proceso independiente bajo un observador personalizado.
Algunos ejemplos de algunos complementos que podría crear con este sistema:
· Un sistema de notificación que envía alertas por correo electrónico cuando un observador está agitando
· Un registrador
· Una herramienta que agrega o elimina procesos dependiendo de la carga
· Etc.
Circus en sí viene con algunos complementos integrados.
El CircoPlugin clase
Circus proporciona una clase base para ayudarlo a implementar complementos: circo.plugins.CircusPlugin
clase circus.plugins.CircusPlugin (punto final, pubsub_punto final, verificar_retraso, ssh_server = Ninguno,
** config)
Clase base para escribir complementos.
Opciones:
· contexto - el contexto ZMQ a utilizar
· punto final - el punto final de circusd ZMQ
· pubsub_punto final - el punto final pub / sub de circusd ZMQ
· verificar_retraso - el retardo de verificación configurado
· config - mapeo de configuración gratuito
llamar (comando, **accesorios)
Envía el comando a circo
Opciones:
· comando - el comando para llamar
· accesorios - argumentos de palabras clave para agregar a la llamada
Devuelve el mapeo JSON enviado de vuelta por circo
emitir (comando, **accesorios)
Dispara y olvida un comando para circo
Opciones:
· comando - el comando para llamar
· accesorios - argumentos de palabras clave para agregar a la llamada
handle_init ()
Se llama justo antes de que se inicie un complemento, en el contexto del hilo.
handle_recv (datos)
Recibe todos los eventos publicados por circo
Opciones:
· datos - una tupla que contiene el tema y el mensaje.
handle_stop ()
Llamado justo antes de que Circus detenga el complemento.
Cuando la inicializa Circus, esta clase crea su propio bucle de eventos que recibe todos los
circo eventos y pasarlos a handle_recv (). Los datos recibidos son una tupla que contiene el
tema y los datos en sí.
handle_recv () deben ser implementado por el complemento.
El llamada() y emitir() Los métodos se pueden utilizar para interactuar con circo si estas construyendo un
Complemento que interactúa activamente con el demonio.
handle_init () y handle_stop () son sólo métodos prácticos que puede utilizar para inicializar y
limpia tu código. handle_init () se llama dentro del hilo que acaba de comenzar.
handle_stop () se llama en el hilo principal justo antes de que el hilo se detenga y se una.
Escribiendo a plugin
Escribamos un complemento que registre en un archivo cada evento que suceda en circo. Se necesita uno
argumento que es el nombre del archivo.
El complemento puede verse así:
de circus.plugins importar CircusPlugin
clase Logger (CircusPlugin):
nombre = 'registrador'
def __init __ (self, * args, ** config):
super (Logger, self) .__ init __ (* args, ** config)
self.filename = config.get ('nombre de archivo')
self.file = Ninguno
def handle_init (yo):
self.file = open (self.filename, 'a +', buffering = 1)
def handle_stop (auto):
self.file.close ()
def handle_recv (self, data):
watcher_name, action, msg = self.split_data (datos)
msg_dict = self.load_message(mensaje)
self.file.write ('% s% s ::% r \ n'% (action, watcher_name, msg_dict))
Eso es todo ! Esta clase se puede guardar en cualquier paquete / módulo, siempre que pueda ser vista por
Python.
Por ejemplo, Logger se puede encontrar en un plugins módulo dentro de un mi proyecto Pack
Asíncrono solicitudes
En caso de que desee realizar operaciones asincrónicas (como una llamada Tornado o el uso de
periodicCall) asegúrese de que está utilizando el bucle correcto. El bucle que siempre quieres usar
es self.loop cuando lo configura la clase base. El bucle predeterminado a menudo no es el mismo
y, por lo tanto, es posible que el código no se ejecute como se esperaba.
Molesto a plugin
Puede ejecutar un complemento a través de la línea de comando con el circo-plugin comando, por
especificando el nombre completo del complemento:
$ circus-plugin --endpoint tcp: //127.0.0.1: 5555 --pubsub tcp: //127.0.0.1: 5556 --config nombre de archivo: circus-events.log myproject.plugins.Logger
[INFO] Cargando el complemento ...
[INFO] Extremo: 'tcp: //127.0.0.1: 5555'
[INFO] Pub / sub: 'tcp: //127.0.0.1: 5556'
[INFO] Comenzando
Otra forma de ejecutar un complemento es dejar que Circus se encargue de su inicialización. Esto es hecho por
agregando un [complemento: NAME] sección en el archivo de configuración, donde NOMBRE es un nombre único para
su complemento:
[complemento: logger]
uso = miproyecto.plugins.Logger
nombre de archivo = /var/myproject/circus.log
use es obligatorio y apunta al nombre completo del complemento.
Cuando Circus comienza, crea un observador con un proceso que ejecuta la clase señalada y
pasar cualquier otra variable contenida en la sección al constructor del complemento a través de la config
cartografía.
También puede agregar complementos mediante programación al crear un Circus.arbiter.Arbiter clase
vea la sección circus.get_arbiter (), ver biblioteca.
Actuaciones
Dado que cada complemento se carga en su propio proceso, no debería afectar al
rendimiento del sistema siempre que el trabajo realizado por el complemento no esté haciendo demasiados
llamadas al circo .
Manos
Circus proporciona ganchos que pueden usarse para desencadenar acciones en eventos de observadores. Disponible
los ganchos son:
· antes de comenzar: llamado antes de que se inicie el observador. Si el anzuelo regresa Falso de la forma más
el inicio se cancela.
· Después de empezar: llamado después de que se inicia el observador. Si el anzuelo regresa Falso el vigilante
se detiene inmediatamente y se cancela la puesta en marcha.
· antes_spawn: llamado antes de que el observador genere un nuevo proceso. Si el anzuelo regresa Falso
el observador se detiene inmediatamente y se aborta el inicio.
· después_spawn: llamado después de que el observador genera un nuevo proceso. Si el anzuelo regresa Falso
el observador se detiene inmediatamente y se aborta el inicio.
· antes_parar: llamado antes de que el observador se detenga. El resultado del gancho se ignora.
· después de la parada: llamado después de que el observador se detiene. El resultado del gancho se ignora.
· señal_antes: llamado antes de que se envíe una señal al proceso de un observador. Si el anzuelo
devoluciones Falso la señal no se envía (excepto SIGKILL que siempre se envía)
· después de la señal: llamado después de que se envía una señal al proceso de un observador.
· Extended_stats: se llama cuando se solicitan estadísticas con extendido = Verdadero. Usado para agregar
estadísticas específicas del proceso a la salida de estadísticas regular.
Ejemplo
Un caso de uso típico es controlar que se cumplan todas las condiciones para que se inicie un proceso.
Digamos que tienes un observador que corre Redis y un observador que ejecuta un script de Python que
con obras Redis. Con Circus puedes ordenar la puesta en marcha usando el lista de prioridades opción:
[observador: trabajador en cola]
cmd = python -u trabajador.py
prioridad = 1
[observador: redis]
cmd = servidor-redis
prioridad = 2
Con esta configuración, Circus comenzará Redis primero y luego iniciará el trabajador de cola.
Pero Circus realmente no controla eso Redis está en funcionamiento. Simplemente comienza el
proceso que se le pidió que comenzara. Lo que echamos de menos aquí es una forma de controlar eso Redis is
iniciado y completamente funcional. Una función que controla esto podría ser:
importar redis
tiempo de importación
def check_redis (* argumentos, ** kw):
time.sleep (.5) # dale la oportunidad de comenzar
r = redis.StrictRedis (host = 'localhost', puerto = 6379, db = 0)
r.set ('foo', 'bar')
return r.get ('foo') == 'bar'
Esta función se puede conectar a Circus como antes de comenzar gancho:
[observador: trabajador en cola]
cmd = python -u trabajador.py
ganchos.before_start = mycoolapp.myplugins.check_redis
prioridad = 1
[observador: redis]
cmd = servidor-redis
prioridad = 2
Una vez que Circus ha comenzado redis observador, iniciará el trabajador de cola vigilante, ya que
sigue el lista de prioridades ordenar. Justo antes de iniciar el segundo observador, se ejecutará
de la forma más comprobar_redis función, y en caso de que regrese Falso abortará al observador comenzando
.
Gancho firma
Un gancho debe seguir esta firma:
def hook (observador, árbitro, hook_name, ** kwargs):
...
# Si no devuelve True, el gancho puede cambiar
# el comportamiento del circo (según el gancho)
volver verdadero
Dónde observador son los Vigilante instancia de clase, árbitro de la forma más Árbitro uno, gancho_nombre el gancho
nombre y kwargs algunos parámetros opcionales adicionales (dependiendo del tipo de gancho).
El después_spawn hook agrega los parámetros pid:
def after_spawn (observador, árbitro, nombre de gancho, pid, ** kwargs):
...
# Si no devuelve True, el circo matará el proceso
volver verdadero
Dónde pid es el PID del proceso correspondiente.
Asimismo, señal_antes y después de la señal los ganchos agregan pid y signum:
def before_signal_hook (observador, árbitro, nombre de gancho, pid, signum, ** kwargs):
...
# Si no devuelve True, circus no enviará la señal signum
# (SIGKILL siempre se envía)
volver verdadero
Dónde pid es el PID del proceso correspondiente y signum es la señal correspondiente.
Puede ignorarlos, pero poder usar los datos y métodos del observador y / o árbitro puede
ser útil en algunos ganchos.
Tenga en cuenta que los ganchos se llaman con argumentos con nombre. Así que usa la firma del gancho sin
cambiar los nombres de los argumentos.
El Extended_stats hook tiene sus propios parámetros adicionales en kwargs:
def Extended_stats_hook (observador, árbitro, nombre de gancho, pid, estadísticas, ** kwargs):
...
Dónde pid es el PID del proceso correspondiente y estadísticas las estadísticas regulares para ser
regresó. Agrega tus propias estadísticas a estadísticas. Un ejemplo está en
ejemplos / uwsgi_lossless_reload.py.
Como último ejemplo, aquí hay un supergancho que puede manejar todo tipo de señales:
def super_hook (observador, árbitro, nombre de gancho, ** kwargs):
pid = Ninguno
signum = Ninguno
si hook_name en ('before_signal', 'after_signal'):
pid = kwargs ['pid']
signum = kwargs ['signum']
...
volver verdadero
Gancho eventos
Cada vez que se ejecuta un gancho, su resultado se notifica como un evento en Circus.
Hay dos eventos relacionados con los ganchos:
· gancho_éxito: se llamó correctamente a un gancho. Las claves del evento son nombre el nombre si el
evento, y time: la fecha de los hechos.
· gancho_fallo: ha fallado un gancho. Las claves del evento son nombre el nombre si el evento, time:
la fecha de los hechos y error: la excepción que ocurrió en el evento, en su caso.
Adición new comandos
Intentamos que la adición de nuevos comandos sea lo más simple posible.
Debes hacer tres cosas:
1. crea un su_comando.py archivar bajo circo / comandos /.
2. Implemente una sola clase allí, con métodos predefinidos
3. Agregue el nuevo comando en circo/comandos/__init__.py.
Digamos que queremos agregar un comando que devuelva la cantidad de observadores actualmente en uso,
haríamos algo como esto (extensamente comentado para permitirle seguir más
fácilmente):
from circus.commands.base Comando de importación
de circus.exc import ArgumentError, MessageError
clase NumWatchers (comando):
"""Es una buena práctica describir lo que hace la clase aquí.
Eche un vistazo a otros comandos para ver cómo estamos acostumbrados a formatear
este texto. Se incluirá automáticamente en la documentación,
así que no tengas miedo de ser exhaustivo, para eso está hecho
para.
""
# todos los comandos heredan de `circus.commands.base.Command`
# necesita especificar un nombre para que encontremos el comando de alguna manera
nombre = "numwatchers"
# Configure la espera en Verdadero o Falso para definir su comportamiento predeterminado
# - Si la espera es Verdadera, el comando se ejecuta de forma síncrona y el cliente puede obtener
# resultados anteriores.
# - Si la espera es Falso, el comando se ejecuta de forma asíncrona en el servidor y el cliente inmediatamente
# recibe una respuesta 'ok'
#
# De forma predeterminada, los comandos están configurados en espera = Falso
esperando = Verdadero
# opciones
opciones = [('', 'optname', default_value, 'description')]
propiedades = ['foo', 'bar']
# propiedades enumera los argumentos de comando que son obligatorios. Si ellos estan
# no proporcionado, entonces se lanzará un error
def ejecutar(uno mismo, árbitro, apoyos):
# el método de ejecución es el núcleo del comando: pon aquí todos los
# lógica del comando y devuelve un dictado que contiene los valores que
# quiero volver, si hay alguno
volver {"observadores del número": árbitro.observadores del número()}
def console_msg(self, mensaje):
# msg es lo que devuelve el método de ejecución.
# este método se usa para formatear la respuesta para una consola (es
# utilizado por ejemplo por circusctl para imprimir sus mensajes)
devolver "una cadena que se mostrará"
def mensaje(self, *args, **opts):
# el mensaje maneja la entrada de la consola.
# este método se usa para asignar argumentos de la consola al comando
# opciones. (se usa, por ejemplo, cuando se llama al comando a través de
#circoctl)
# NotImplementedError se lanzará si falta la función
númArgs = 1
si no len(argumentos) == numArgs:
aumentar ArgumentError('Número de argumentos no válido.')
más:
opciones['optname'] = argumentos[0]
volver self.make_message(**opciones)
def validar (auto, apoyos):
# este método se usa para validar que los argumentos pasados al
# comando son correctos. Se debe lanzar un ArgumentError en caso
# hay un error en los argumentos pasados (por ejemplo, si
# no coinciden.
# En caso de que haya un problema con su contenido, un MessageError
# debe ser lanzado. Este método puede modificar el contenido de los accesorios.
# dict, se pasará a ejecutar después.
Usa cases ejemplos
Este capítulo presenta algunos casos de uso, para darle una idea de cómo usar Circus en su
ambiente.
Correr a WSGI solicitud en línea.
Ejecutar una aplicación WSGI con Circus es bastante interesante porque puede ver y administrar
a tu manera web los trabajadores. usando circo-top, circoctl o la interfaz web.
Esto es posible gracias al uso de enchufes Circus. Vea por quécircussockets.
Tomemos un ejemplo con un mínimo Pirámide solicitud:
del configurador de importación pyramid.config
from pyramid.response import Respuesta
def hola_mundo(solicitud):
return Response('¡Hola %(nombre)s!' % request.matchdict)
config = Configurador()
config.add_route('hola', '/hola/{nombre}')
config.add_view(hola_mundo, ruta_nombre='hola')
aplicación = config.make_wsgi_app()
Guarde este script en un aplicación.py archivo, luego instale esos proyectos:
$ pip instalar Pirámide
$ pip instalar chaussette
A continuación, asegúrese de que puede ejecutar su aplicación Pyramid usando el calcetín guión de la consola:
$ chaussette app.aplicación
La aplicación es
Sirviendo en localhost: 8080
Utilizando como back-end
Y comprueba que puedes llegar visitando http://localhost:8080/hola/tarek
Ahora que su aplicación está funcionando, creemos un archivo de configuración de Circus:
[circo]
verificar_retraso = 5
punto final = 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) aplicación.aplicación
use_sockets = Verdadero
numprocesos = 3
[socket: webapp]
anfitrión = 127.0.0.1
port = 8080
Este archivo le dice a Circus que vincule un socket en el puerto 8080 y correr calcetín trabajadores en eso
socket -- pasando su fd.
Guárdalo en servidor.ini e intenta ejecutarlo usando circo
$ servidor de circo.ini
[INFO] Iniciando maestro en pid 8971
[INFO] sockets iniciados
[INFO] circusd-stats comenzó
[INFO] aplicación web iniciada
[INFO] Arbiter ahora esperando comandos
Asegúrate de seguir activando la aplicación http://localhost:8080/hola/tarek.
Felicitaciones ! tiene una aplicación WSGI que ejecuta 3 trabajadores.
Puede ejecutar circushttpd o cli y disfrutar de la gestión de Circus.
Correr a Django solicitud en línea.
La ejecución de una aplicación Django se realiza exactamente igual que la ejecución de una aplicación WSGI. Utilizar el
PITONPATO para importar el directorio en el que se encuentra el proyecto, el directorio que contiene el
directorio que tiene settings.py (con Django 1.4+ este directorio tiene manage.py)
:
[zócalo: dwebapp]
anfitrión = 127.0.0.1
port = 8080
[observador:dwebworker]
cmd = chaussette --fd $(circus.sockets.dwebapp) dproject.wsgi.application
use_sockets = Verdadero
numprocesos = 2
[env:trabajadorweb]
PYTHONPATH = /ruta/al/padre-del-proyecto
Si necesita pasar el DJANGO_SETTINGS_MODULE para un trabajador de back-end, por ejemplo, puede
pasa eso también por el env opción de configuración:
[observador:dbackend]
cmd = /ruta/al/script.py
numprocesos=3
[env: dbackend]
PYTHONPATH = /ruta/al/padre-del-proyecto
DJANGO_SETTINGS_MODULE=dproyecto.configuraciones
See http://chaussette.readthedocs.org para obtener más información sobre chaussette.
Diseño decisiones
En general arquitectura
[imagen]
Circus se compone de un proceso principal llamado circo que se encarga de hacer funcionar todo el
Procesos. Cada proceso gestionado por Circus es un proceso secundario de circo.
Los procesos se organizan en grupos llamados observadores. La observador es básicamente un comando
circo se ejecuta en su sistema, y para cada comando puede configurar cuántos procesos
quiero correr
El concepto de observador es útil cuando desea administrar todos los procesos que ejecutan el
mismo comando, como reiniciarlos, etc.
circo une dos sockets ZeroMQ:
· SOLICITUD/REP. -- un enchufe usado para controlar circo usando json-based comandos.
· PUB / SUB -- un enchufe donde circo publica eventos, como cuando se inicia un proceso o
detenido.
NOTA:
A pesar de su nombre, ZeroMQ no es un sistema de gestión de colas. Piense en ello como un
Biblioteca de comunicación entre procesos (IPC).
Otro proceso llamado Circusd-estadísticas está dirigido por circo cuando la opción está activada.
Circusd-estadísticasEl trabajo de es publicar estadísticas de uso de CPU/memoria en un PUB / SUB
canal.
Este canal especializado es utilizado por circo-top y circo-httpd para mostrar una transmisión en vivo
de la actividad.
circo-top es un script de consola que imita parte superior para mostrar todo el uso de CPU y memoria de
los procesos gestionados por Circus.
circo-httpd es la interfaz de gestión web que te permitirá interactuar con Circus. Eso
muestra una transmisión en vivo usando sockets web y el Circusd-estadísticas canal, pero también te permite
interactuar con circo a través de su SOLICITUD/REP. canal.
Por último, pero no menos importante circoctl es una herramienta de línea de comandos que le permite conducir circo a través de su
SOLICITUD/REP. canal.
También puede tener complementos a los que suscribirse circo's PUB / SUB canalizar y dejarte enviar
comandos a la SOLICITUD/REP. canal como circoctl haría.
Seguridad
Circus está construido sobre la biblioteca ZeroMQ y viene sin ningún tipo de seguridad en su
protocolos Sin embargo, puede ejecutar un sistema Circus en un servidor y configurar un túnel SSH para
acceder desde otra máquina.
Esta sección explica qué hace Circus en su sistema cuando lo ejecuta y termina
describiendo cómo usar un túnel SSH.
También puede leer http://www.zeromq.org/area:preguntas frecuentes#toc5
TCP puertos
De forma predeterminada, Circus abre los siguientes puertos TCP en el host local:
· 5555 -- el puerto usado para controlar el circo vía circoctl
· 5556 -- el puerto utilizado para el canal del publicador/suscriptor.
· 5557 -- el puerto utilizado para el canal de estadísticas -- si está activado.
· 8080 -- el puerto utilizado por la Web UI -- si está activado.
Estos puertos permiten que las aplicaciones cliente interactúen con su sistema Circus y, dependiendo de cómo
su infraestructura está organizada, es posible que desee proteger estos puertos a través de firewalls or
configurar Circus para que se ejecute usando IPC puertos
Aquí hay un ejemplo de cómo ejecutar Circus usando solo puntos de entrada de IPC:
[circo]
verificar_retraso = 5
punto final = ipc:///var/circus/punto final
pubsub_punto final = ipc:///var/circus/pubsub
stats_endpoint = ipc:///var/circus/stats
Cuando se configura usando IPC, los comandos deben ejecutarse desde el mismo cuadro, pero nadie puede
acceder a ellos desde el exterior, a diferencia de usar TCP. Los comandos también deben ejecutarse como un usuario que
tiene acceso de escritura a las rutas del socket ipc. Puede modificar el propietario de la punto final usando
de la forma más endpoint_propietario opción de configuración. Esto le permite ejecutar circusd como usuario raíz, pero
permitir que los procesos no root envíen comandos a circo. Tenga en cuenta que al usar endpoint_propietario,
para evitar que los procesos no root puedan iniciar procesos arbitrarios que
ejecutar con mayores privilegios, el comando agregar impondrá que los nuevos Vigilantes se ejecuten como
de la forma más endpoint_propietario usuario. Las definiciones de Watcher en los archivos de configuración locales no serán
restringido de esta manera.
Por supuesto, si activa la Web UI, la 8080 el puerto seguirá abierto.
circo
Cuando corres circo manualmente, o cuando utiliza el httpd opción en el archivo ini como
modo:
[circo]
verificar_retraso = 5
punto final = ipc:///var/circus/punto final
pubsub_punto final = ipc:///var/circus/pubsub
stats_endpoint = ipc:///var/circus/stats
httpd = 1
La aplicación web se ejecutará en el puerto 8080 y permitirá que cualquier persona acceda a la página web
gestionar el circo demonio.
¡Eso incluye la creación de nuevos observadores que puedan ejecutar cualquier comando en su sistema!
Do no make it en público Hoy Disponibles
Si desea proteger el acceso al panel web, puede servirlo detrás de Nginx o
Apache o cualquier servidor web compatible con proxy, que pueda cuidar la seguridad.
User y Grupo procesos Permisos
De forma predeterminada, todos los procesos iniciados con Circus se ejecutarán con el mismo usuario y grupo
as circo. Dependiendo de los privilegios que tenga el usuario en el sistema, es posible que no tenga
acceso a todas las funciones que ofrece Circus.
Por ejemplo, algunas características de estadísticas en procesos en ejecución requieren privilegios extendidos.
Por lo general, si los números de uso de la CPU que obtiene utilizando el estadísticas comando son N/A, significa tu
el usuario no puede acceder a los archivos proc. Este será el caso por defecto en Mac OS X.
Puedes correr circo como root para arreglar esto, y establecer el UID y gid valores para cada observador
para obtener todas las características.
Pero cuidado con correr circo como root lo expone a una posible escalada de privilegios
insectos. Si bien estamos haciendo todo lo posible para evitar errores, ejecutar como root y enfrentar un error que
realiza acciones no deseadas en su sistema puede ser peligroso.
La mejor manera de evitar esto es asegurarse de que el sistema que ejecuta Circus esté completamente
aislado (como una máquina virtual) or para ejecutar todo el sistema bajo un usuario controlado.
SSH tunelización
Los clientes pueden conectarse a un circo instancia creando un túnel SSH. Para ello, pase el
opción de línea de comando --ssh seguido por usuario@dirección, donde el usuario es el usuario en el control remoto
servidor y dirección es la dirección del servidor tal como la ve el cliente. El protocolo SSH
requieren credenciales para completar el inicio de sesión.
If circo como lo ve el servidor SSH no está en la dirección del punto final predeterminado localhost: 5555
luego especificar el circo dirección usando la opción --punto final
asegurado Configure (aqui)
La configuración de un servidor Circus seguro se puede realizar de la siguiente manera:
· Ejecución de un servidor SSH
· Ejecutar Apache o Nginx en el 80 puerto, y haciendo un proxy inverso en el 8080 Puerto.
· Bloqueo de la 8080 puerto desde el acceso exterior.
· Ejecutar todos los puertos ZMQ Circusd utilizando archivos IPC en lugar de puertos TCP y tunelizar todos
llamadas a través de SSH.
[imagen]
Contribuir a Circo
Circus se ha iniciado en Mozilla pero su objetivo no es quedarse solo ahí. estamos intentando
para construir una herramienta que sea útil para otros y fácilmente extensible.
Realmente estamos abiertos a cualquier contribución, en forma de código, documentación, debates,
propuesta de características, etc.
Puede iniciar un tema en nuestra lista de correo: http://tech.groups.yahoo.com/group/circus-dev/
O añade un problema en nuestro error rastreador
Fijación typos y mejorar de la forma más documentación
Es totalmente posible que te sangren los ojos mientras lees este medio inglés.
documentación medio francesa, no dude en contribuir con cualquier reformulación / mejora en
el formulario en la documentación. Probablemente ni siquiera necesites entender cómo funciona Circus
bajo el capó para hacer eso.
Adición new Características
Las nuevas características son, por supuesto, muy apreciadas. Si tienes la necesidad y el tiempo para
trabajar en nuevas funciones, agregarlas a Circus no debería ser tan complicado. Lo intentamos muy
es difícil tener una API limpia y comprensible, espero que sirva para el propósito.
Deberá agregar documentación y pruebas junto con el código de la nueva función.
De lo contrario, no podremos aceptar el parche.
Cómo a enviar a tu manera cambios
Estamos usando git como DVCS. La mejor manera de proponer cambios es crear una rama en su
lado (a través de git caja -b nombre de rama) y confirme sus cambios allí. Una vez que tengas
algo listo para el horario de máxima audiencia, emita una solicitud de incorporación de cambios en esta rama.
Estamos siguiendo este modelo para permitir tener un bajo acoplamiento entre las características que está
proponiendo Por ejemplo, podemos aceptar una solicitud de extracción mientras aún estamos en discusión
por otro
¡Antes de proponer sus cambios, verifique que no estén rompiendo nada! Usted puede
utilice el tox comando para garantizar esto, ejecutará el conjunto de pruebas bajo los diferentes
Versiones de python compatibles.
Por favor use : http://issue2pr.herokuapp.com/ para hacer referencia a un compromiso con un circo existente
problema, si lo hay.
Evitar unir confirma
Evitar las confirmaciones de fusión permite tener un historial limpio y legible. Para hacerlo, en lugar de
haciendo "git pull" y dejando que git maneje las fusiones por ti, usando git pull --rebase
coloque sus cambios después de los cambios que se confirman en la rama, o cuando trabaje en
Maestro.
Es decir, para nosotros, los desarrolladores principales, ya no es posible usar el práctico github green
botón en las solicitudes de incorporación de cambios si los desarrolladores no reorganizaron su trabajo ellos mismos o si esperamos
demasiado tiempo entre la solicitud y la fusión real. En cambio, el flujo se ve así:
git remoto agregar nombre repo-url
git buscar nombre
rama de función de pago de git
maestro de git rebase
# verifique que todo funcione correctamente y luego fusione en el maestro
GIT Checkout Master
rama de funciones de git merge
Que se discute
Si necesita ayuda mientras mira el código de Circus, puede ir
y encuéntranos en irc en #tienda de circo on irc.freenode.org (o si no tienes ningún IRC
cliente, uso de la forma más chat web)
También puede iniciar un hilo en nuestra lista de correo:
http://tech.groups.yahoo.com/group/circus-dev
Preguntas Frecuentes Preguntas
Aquí hay una lista de preguntas frecuentes sobre Circus:
Cómo sí Circo montón comparar a a clásico apilar?
En una pila WSGI clásica, tiene un servidor como Gunicorn que sirve en un puerto o en un
unix socket y generalmente se implementa detrás de un servidor web como Nginx: [imagen]
Los clientes llaman a Nginx, que revierte todas las llamadas a Gunicorn.
Si desea asegurarse de que el proceso de Gunicorn se mantenga en funcionamiento, debe utilizar un
programa como Supervisord o advenedizo.
Gunicorn a su vez vigila sus procesos ("trabajadores").
En otras palabras, está utilizando dos niveles de gestión de procesos. Uno que tu manejas y
control (supervisado), y un segundo que debe administrar en una interfaz de usuario diferente, con un
filosofía diferente y menos control sobre lo que está pasando (la del servidor wsgi)
Esto es cierto para Gunicorn y la mayoría de los servidores WSGI de procesos múltiples que conozco.
uWsgi es un poco diferente ya que ofrece una gran cantidad de opciones.
Pero si desea agregar un servidor Redis en su pila, debe will terminar con la gestión de su
apilar procesos en dos lugares diferentes.
El enfoque de Circus en esto es gestionar procesos y enchufes
Una pila de Circus puede verse así: [imagen]
Entonces, al igual que Gunicorn, Circus puede vincular un socket que será representado por Nginx. Circo
no se ocupe de las solicitudes, sino que simplemente vincula el socket. Entonces depende de un trabajador web
proceso para aceptar conexiones en el zócalo y hacer el trabajo.
Proporciona funciones equivalentes a las de Supervisord, pero también le permitirá administrar todos
procesos al mismo nivel, ya sean trabajadores web o Redis o lo que sea. Agregar un
El nuevo trabajador web se realiza exactamente igual que agregar un nuevo proceso de Redis.
Bancos
Hicimos algunos bancos para comparar Circus & Chaussette con Gunicorn. En resumen, Circus es
sin agregar gastos generales y puede elegir muchos backends diferentes para sus trabajadores web.
Ver:
· http://blog.ziade.org/2012/06/28/wgsi-web-servers-bench
· http://blog.ziade.org/2012/07/03/wsgi-web-servers-bench-part-2
Cómo a solucionar problemas ¿Circo?
De forma predeterminada, circo mantiene su registro en stdout bastante escaso. Esta falta de producción puede
hacer que las cosas sean difíciles de solucionar cuando los procesos parecen tener problemas para iniciarse.
Para aumentar el registro circo proporciona, intente aumentar el nivel de registro. Ver el
niveles de registro disponibles solo use el --ayuda bandera.
$ circo --prueba de depuración de nivel de registro.ini
Una palabra de advertencia. Si un proceso está fallando y el nivel de registro de depuración está activado,
verá mensajes para cada intento de inicio. Puede ser útil configurar la aplicación que está
aleteando para usar un calentamiento_retraso para reducir la velocidad de los mensajes a un ritmo manejable.
[observador: webapp]
cmd = python -m miaplicación.wsgi
calentamiento_retraso = 5
De forma predeterminada, stdout y stderr son capturados por el circo proceso. Si está probando su
config y desea ver la salida en línea con la salida de circusd, puede configurar su
observador para usar el Corriente estándar clase.
[observador: webapp]
cmd = python -m miaplicación.wsgi
stdout_stream.class = CorrienteStdout
stderr_stream.class=StdoutStream
Si su aplicación produce un rastreo o un error cuando intenta iniciarlo
debería poder verlo en la salida.
Registro de Cambio historia
0.12.1 - 2015-08-05
· Corrección de error al reiniciar un observador con un flujo de salida - #913
· Ajustes menores de documentos
0.12 - 2015-06-02
Esta versión ofrece soporte para Python 3.4, Tornado 4 y Windows, entre varios
características y correcciones.
El soporte de Windows aún es experimental y no maneja flujos.
Cambios principales:
· Compatibilidad con Python 3.4 - #768
· Soporte experimental de Windows - #788
· Compatibilidad con Tornado 4 - #872
· Paquete Debian renovado - #896 - #903
· Agregar soporte para el núcleo del proceso Papa - #850
· Agregar coincidencia de expresiones regulares y globing para iniciar, detener y reiniciar observadores - #829 -
#902
Más cambios:
· Optimización de la parada - #784 - #842
· Agregar posibilidad de especificar la versión virtualenv para los observadores - #805
· Agregue la opción --nostop al comando rmwatcher - #777
· Agregar una devolución de llamada a Arbiter.start - #840
· Arreglar la recarga de los observadores con letras mayúsculas - #823
· Quitar socket con fugas en el demonio de estadísticas - #843
· Arreglar multidifusión en SunOS - #876
· Cerrar flujos de salida al detener un observador - #885
· Arreglar el envío de señales a los nietos con --recursive - #888
0.11.1 - 2014-05-22
· Se corrigió una regresión que rompió Circus en 2.6 - #782
0.11 - 2014-05-21
Esta versión no presenta muchas características y se enfoca en hacer que Circus sea más
robusto y estable.
Cambios/correcciones importantes:
· Asegúrese de que no podamos ejecutar dos comandos en conflicto en el árbitro simultáneamente.
· tenemos 2 nuevas clases de flujos: TimedRotatingFileStream, WatchedFileStream
· tenemos un gancho nuevo: gancho after_spawn
· CircusPlugin es más fácil de usar
· arreglar autostart=falsos observadores durante el inicio (regresión)
Más cambios:
· Los mensajes de circo se pueden enrutar a syslog ahora - #748
· Se agregó la opción endpoint_owner para que podamos definir qué usuario posee los archivos de socket ipc creados por
circo.
· Compatibilidad con Windows iniciada (solo circusctl por ahora)
· corrigió muchas fugas en las pruebas
· Permitir variables de entorno sensibles a mayúsculas y minúsculas
· El complemento de recursos ahora acepta valores de memoria absolutos - #609
· Agregar soporte al comando agregar para la opción 'singleton' - #767
· Permitir el envío de señales arbitrarias a procesos secundarios a través del observador de recursos - #756
· Permitir la configuración INI/JSON/YAML para iniciar sesión
· Asegúrese de que seamos compatibles con psutil 2.x y 3.x
· Se agregaron más métricas al proveedor statsd - #698
· Detección de multidifusión fija - #731
· Haz que el inicio, el reinicio y la recarga sean más uniformes - #673
· Inicializar correctamente todos los grupos de uso - #635
· mejora de la estabilidad de las pruebas
· muchas, muchas cosas más....
0.10 - 2013-11-04
Cambios principales:
· Ahora compatible con Python 3.2 y 3.3 - #586
· Movió el núcleo a un modelo completamente asíncrono - #569
· Documentación mejorada - #622
Más cambios:
· Se agregaron stop_signal y stop_children - #594
· Asegúrese de que el complemento de vigilancia cierre los sockets - #588
· Cambiado al analizador ZMQ JSON
· IN no es compatible con todas las plataformas - #573
· Permitir sustituciones de entorno global en cualquier sección de configuración - #560
· Permitir guiones en los nombres de las secciones - #546
· Ahora las variables se expanden por todas partes en la configuración - #554
· Se agregó el complemento CommandReloader
· Se agregaron ganchos before_signal y after_signal
· Permitir que el complemento de aleteo vuelva a intentarlo indefinidamente
· No reaparecer procesos cuando el observador se detiene - #529 - #536
· Se agregó una identificación única para cada mensaje de cliente - #517
· las identificaciones de los trabajadores ahora son "ranuras" -
· Se corrigió el comportamiento de apagado correcto - #515
· Asegúrese de que podamos agregar observadores incluso si el árbitro no está iniciado - #503
· Asegúrese de que aparezca el proceso caducado - #510
· Asegúrese de que el comando set pueda establecer varios ganchos
· Soporta correctamente sockets ipv6 - #507
· Permitir opciones personalizadas para stdout_stream y stderr_stream - #495
· Añadido time_format para FileStream - #493
· Se agregó una nueva opción de configuración de socket para enlazar a una interfaz específica por nombre
0.9.3 - 2013-09-04
· Asegúrese de que podamos agregar observadores incluso si el árbitro no está iniciado
· Asegúrese de abrir el proceso caducado
· Asegúrese de que el comando set pueda establecer uno o varios ganchos
· Compatibilidad correcta con sockets ipv6 y mejoras de CircusSockets
· Proporcione el valor predeterminado de la ruta para evitar UnboundLocalError
· Se agregó una prueba para la existencia de multicast_endpoint en la inicialización del controlador
· Ya no convertir cada cadena de dígitos a enteros
· Añadir pruebas
· No hay necesidad de casos especiales al convertir las opciones de stdout_stream
· también acepta umask como un argumento a favor de la consistencia
· Permitir opciones personalizadas para stdout_stream y stderr_stream.
· Agregue una nueva opción de configuración de socket para enlazar a una interfaz específica por nombre
· Agregar time_format para FileStream + pruebas
· Actualizar circus.upstart
0.9.2 - 2013-07-17
· Cuando se define un PYTHONPATH en un archivo de configuración, se carga en sys.path para que los enlaces puedan ser
ubicado allí - #477, #481
· Usa un único argumento para add_callback para que funcione con PyZMQ < 13.1.x - consulta el n.º 478
0.9 - 2013-07-16
· comodines añadidos a las secciones [env]
· sección global [env] agregada
· Excepción oculta fija cuando Circus-Web no está instalado - #424
· asegúrese de que los comandos incr/decr realmente usen la opción nb - #421
· Repara los paquetes del sitio virtualenv del observador que no están en PYTHONPATH
· asegúrese de que no intentemos eliminar más procesos que 0 - #429
· bootstrap.py actualizado - #436
· separador multiplataforma fijo en pythonpath virtualenv watcher
· función de cierre de socket refactorizada
· Asegúrese de que las secciones env se apliquen a todos los observadores - #437
· agregó el comando reloadconfig
· se agregó circus.green y se eliminó gevent del núcleo - #441, #452
· salida estándar espuria silenciada y advertencias en las pruebas - #438
· $(circus.env.*) se puede usar para todas las opciones en la configuración ahora
· agregó un anzuelo before_spawn
· corregir la ruta de circusd en el archivo de servicio systemd - #450
· asegúrese de que podamos cambiar los ganchos y establecer flujos a través de CLI - #455
· documento mejorado
· agregó una estadística spawn_count en el observador
· Se agregaron los parámetros min_cpu y min_mem en el complemento ResourceWatcher.
· agregó la información FQDN al árbitro.
0.8.1 - 2013-05-28
· circusd-stats se estaba ahogando en los sockets de Unix - #415
· Los procesos secundarios stdout/stderr de circusd-stats y circushttpd ahora se dejan abiertos de forma predeterminada.
Python <= 2.7.5 se ahogaría en el módulo de registro en caso de que se cerraran los 2/3 fds - #415
· Ahora se redirige a /dev/null en el proceso secundario en lugar de cerrar. #417
0.8 - 2013-05-24
· Controladores de registro integrados en zmq io loop.
· Hacer que el redirector sea reiniciable y posteriormente más robusto.
· Utiliza zmq.green.eventloop cuando se detecta gevent
· Compatibilidad agregada para la variable de entorno CIRCUSCTL_ENDPOINT en circusctl - #396
· util: corrección de error en la función to_uid - #397
· Elimina el controlador en el error ioloop - #398.
· Cobertura de prueba mejorada
· Opción obsoleta de 'servicio' para el complemento ResourceWatcher - #404
· eliminado el uso de psutil.error
· Añadido descubrimiento de UDP en circusd - #407
· Ahora permite globs en niveles de directorio arbitrarios - #388
· Se agregó la opción de configuración 'statd' - #408
· Agregue la opción pidfile, logoutput y loglevel al archivo de configuración de Circus - #379
· Se agregó un tutorial en los documentos.
· asegúrese de fusionar todas las secciones cuando use include - #414
· Se agregaron las opciones pipe_stdout, pipe_stderr, close_child_stderr y close_child_stdout al
Clase de proceso
· Se agregaron las opciones close_child_stderr y close_child_stdout al observador.
0.7.1 - 2013-05-02
· Se corrigió la opción de reaparición - #382
· Asegúrese de usar un int para el tiempo de espera - #380
· mostrar también los sockets de Unix - #381
· Asegúrese de que funcione con la última versión de pyzmq
· introdujo una segunda sintaxis para la notación fd
0.7 - 2013-04-08
· Corrige el ejemplo de get_arbiter para usar un dict para el argumento de los observadores. #304
· Agregar alguna documentación de resolución de problemas #323
· Agregar soporte de compilación de python
· Eliminado el gevent y los redirectores de subprocesos. ahora usando ioloop - corrige #346.
Relaciona #340
· circus.web es ahora su propio proyecto
· eliminado el parche pyzmq
· Permitir que el observador sea configurado pero no iniciado #283
· Agregar una opción para cargar un directorio de sitio virtualenv
· añadido on_demand observadores
· documento agregado sobre nginx+websockets #371
· ahora analiza correctamente la lista de opciones de cada comando #369
· Manejo de eventos de circusd-stats fijos #372
· solucionado el problema de desbordamiento en circus-top #378
· muchas cosas más...
0.6 - 2012-12-18
· Nombre de protocolos de parcheo para sockets - #248
· No escalar automáticamente los gráficos. #240
· circusctl: agregar ayuda por comando, de docstrings #217
· Ganchos de trabajadores agregados
· Paquete Debian agregado - #227
· Se agregaron Redis, HTTP Observer, estadísticas completas y complementos de recursos
· Ahora los procesos pueden tener títulos
· Autocompletado añadido
· Proceso agregado/edad del observador en webui
· Añadido soporte de túnel SSH
· Ahora usando pyzmq.green
· Añadido guión advenedizo y documento Varnish
· Variables de entorno y secciones añadidas
· Compatibilidad con sockets Unix agregados
· Agregó el respawn opción de tener observadores de una sola carrera
· Ahora usando tox en las pruebas
· Permitir la sustitución de socket en args
· Nuevo tema de documento
· Nuevas opciones de rotación para flujos: max_bytes/backup_count
0.5.2 - 2012-07-26
· ahora parcheando el módulo de subprocesos desde stdlib para evitar algunos errores de Python - #203
· mejor apariencia de la pantalla de ayuda de circusctl
· usa pustil get_nice() cuando está disponible (nice estaba en desuso) - #208
· soporte max_age agregado - #221
· solo llama a listen() en los sockets SOCK_STREAM o SOCK_SEQPACKET
· asegúrese de que el controlador vacíe la lista de complementos en update_watchers() - #220
· agregó --log-level y --log-output a circushttpd
· corregir el proceso de eliminación a través de la interfaz de usuario web - #219
· ahora circus es compatible con zc.buildout para scripts.
· limpiar el websocket cuando el cliente se desconecte - #225
· fijo el valor predeterminado para el punto final - #199
· splitted circushttpd en módulos lógicos
0.5.1 - 2012-07-11
· Se corrigieron un montón de errores tipográficos en la documentación
· Añadida la opción de depuración
· Empaquetar web-requirements.txt correctamente
· Se agregó un código de error errno en los mensajes - arreglos #111
0.5 - 2012-07-06
· soporte de enchufe añadido
· agregó un comando listsocket
· ¡Los enchufes también tienen estadísticas!
· corrigió muchos errores pequeños
· eliminado el wid - ahora usando pid en todas partes
· pruebas más rápidas
· cambió la sintaxis de las variables
· usar ioloop de pyzmq en más lugares
· ahora usando iowait para todas las llamadas select()
· Los comandos incr/decr ahora tienen un parámetro nbprocess
· Agregar una opción reproducir_env a los observadores
· Agregar un nuevo estado INEXISTENTE a los procesos
· Agregó el global httpd opción para ejecutar circushttpd como observador
0.4 - 2012-06-12
· Se agregó un sistema de complementos
· Se agregó una opción de "singleton" para los observadores
· Parpadeo fijo de la pantalla superior del circo
· Hilos eliminados de circus.stats a favor de devoluciones de llamadas periódicas zmq
· Mejoró la documentación
· El cliente Circus ahora tiene una API send_message
· La función de aleteo ahora es un complemento
· Cada herramienta de línea de comandos tiene una opción --version
· Se agregó un complemento de statsd (envía los eventos de circus a statsd)
· La interfaz de usuario web ahora usa websockets (a través de socketio) para obtener las estadísticas
· La interfaz de usuario web ahora usa sesiones para "mensajes flash" en la interfaz de usuario web
0.3.4 - 2012-05-30
· Se corrigió una condición de carrera que impedía que el controlador cosechara limpiamente los procesos terminados.
· Ahora se puede controlar check_flapping en la configuración. Y activado/desactivado
por observador.
0.3.3 - 2012-05-29
· Se corrigió la regresión en el manejo de uid
0.3.2 - 2012-05-24
· permite la propiedad args opcional al comando add_watcher.
· Circushttpd, circus-top y circusd-stats agregados
· permitir que Arbiter.add_watcher() configure todas las opciones de Watcher
· asegúrese de que los redirectores se vuelvan a crear en los reinicios
0.3.1 - 2012-04-18
· solución: asegúrese de que los valores predeterminados del observador no se anulen
· agregó una clase StdoutStream.
0.3 - 2012-04-18
· agregó la función de transmisión
· ahora mostrando la cobertura en el documento Sphinx
· corrigió la forma en que se matan los procesos (no más SIGQUIT)
· la configuración ha sido factorizada
· compatibilidad con setproctitle
0.2 - 2012-04-04
· Retiró el show nombre. reemplazado por observador.
· Se agregó soporte para el proceso de configuración limite.
· Compatibilidad añadida para incluir directorios en el archivo de configuración.
· Se corrigieron un par de descriptores de archivos con fugas.
· Se corrigió un volcado de núcleo en el aleteo
· Mejoras en documentos
· Asegúrese de que circusd produzca errores correctamente cuando otro circusd se esté ejecutando en el mismo zócalo.
· get_arbiter ahora acepta varios observadores.
· Se corrigió el cmd vs args vs ejecutable en el proceso init.
· Arreglado --start on circusctl add
0.1 - 2012-03-20
· Versión inicial
hombre paginas
circo hombre página
Sinopsis
circusd [opciones] [config]
Descripción
circusd es el proceso principal de la arquitectura del circo. Se encarga de ejecutar todos los
Procesos. Cada proceso gestionado por Circus es un proceso secundario de circo.
Argumentos
config archivo de configuración
De Seguros
-h, --ayuda
Muestre el mensaje de ayuda y salga
--nivel de registro NIVEL
Especifique el nivel de registro. NIVEL puede ser info, depurar, crítico, advertencia or error.
--salida de registro SALIR
La ubicación donde se escribirán los registros. El comportamiento predeterminado es escribir en
stdout (puede forzarlo pasando '-' a esta opción). Toma un nombre de archivo
de otra manera.
--registrador-config CONFIGURACIÓN DE REGISTRADOR
La ubicación donde se encuentra un archivo INI, JSON o YAML de configuración del registrador de Python estándar
puede ser encontrado. Esto se puede utilizar para anular la configuración de registro predeterminada para
el árbitro.
--demonio
Inicie circusd de fondo.
--pidfile ARCHIVO PID
La ubicación del archivo PID.
--versión
Muestra la versión Circus y sale.
See also
circo (1) circoctl (1) Circusd-estadísticas (1) circo-plugin (1) circo-top (1).
La documentación completa está disponible en http://circus.readthedocs.org
circoctl hombre página
Sinopsis
circusctl [opciones] comando [args]
Descripción
circusctl es la interfaz para controlar el demonio Circus. Está diseñado para ayudar al
administrador controla el funcionamiento del Circud circo demonio.
Comandos
add Agregar un observador
dic Disminuir el número de procesos en un observador
estadísticas Obtener estadísticas de circo
get Obtenga el valor de las opciones específicas de los observadores
opciones globales
Obtenga las opciones de árbitro
aumentar Incrementar el número de procesos en un observador
ipython
Crear caparazón en el proceso de circo
lista Obtener una lista de observadores o procesos en un observador
escuchan Suscríbete a un evento de observadores
listas de enchufes
Obtener la lista de enchufes
numprocesos
Obtenga la cantidad de procesos
observadores numéricos
Obtenga la cantidad de observadores
opciones
Obtenga el valor de todas las opciones para un observador
renuncia Salir del árbitro inmediatamente
recargar Recarga al árbitro o al observador
recargar configuración
Vuelva a cargar el archivo de configuración
reanudar
Reiniciar el árbitro o un observador
rm Quitar un observador
para reinventar la industria logística y redefinir las soluciones ecológicas para reinventar la industria logística y redefinir las soluciones ecológicas. Establecer una opción de observador
señal Enviar una señal
comienzo Inicie el árbitro o un observador
estadísticas Obtener información sobre el proceso
estado Obtenga el estado de un observador o de todos los observadores
detener Detener a los observadores
De Seguros
--punto final PUNTO FINAL
punto final de conexión
-h, --ayuda
Muestre el mensaje de ayuda y salga
--json salida a JSON
--embellecer
embellecer la salida
--ssh SSH
Servidor SSH en el formato usuario @ host: puerto
--ssh_archivo_clave SSH_ARCHIVO DE CLAVE
ruta al archivo de claves para autorizar al usuario
--se acabó el tiempo TIMEOUT
el tiempo de conexión expiro
--versión
Muestra la versión Circus y sale.
See También
circo (1) circo (1) Circusd-estadísticas (1) circo-plugin (1) circo-top (1).
La documentación completa está disponible en http://circus.readthedocs.org
circo-plugin hombre página
Sinopsis
circus-plugin [opciones] [complemento]
Descripción
circus-plugin permite iniciar un complemento desde un demonio Circus en ejecución.
Argumentos
plugin Nombre completo de la clase de complemento.
De Seguros
--punto final PUNTO FINAL
Punto final de conexión.
--pubsub PUBSUB
El zócalo pub / sub de circusd ZeroMQ al que conectarse.
--config CONFIG
El archivo de configuración del complemento.
--verificar-retraso CHECK_DELAY
Verifique el retraso.
--nivel de registro NIVEL
Especifique el nivel de registro. NIVEL puede ser info, depurar, crítico, advertencia or error.
--salida de registro SALIR
La ubicación donde se escribirán los registros. El comportamiento predeterminado es escribir en
stdout (puede forzarlo pasando '-' a esta opción). Toma un nombre de archivo
de otra manera.
--ssh SSH
Servidor SSH en el formato usuario @ host: puerto.
-h, --ayuda
Muestre el mensaje de ayuda y salga.
--versión
Muestra la versión Circus y sale.
See also
circo (1) circo (1) circoctl (1) Circusd-estadísticas (1) circo-top (1).
La documentación completa está disponible en http://circus.readthedocs.org
circo-top hombre página
Sinopsis
circus-top [opciones]
Descripción
circus-top es un parte superior-como comando para mostrar el demonio Circus y los procesos administrados por
circo.
De Seguros
--punto final PUNTO FINAL
Punto final de conexión.
--ssh SSH
Servidor SSH en el formato usuario @ host: puerto.
- tiempo de espera del proceso PROCESO_TIEMPO DE ESPERA
Después de este retraso de inactividad, se eliminará un proceso.
-h, --ayuda
Muestre el mensaje de ayuda y salga.
--versión
Muestra la versión Circus y sale.
See also
circo (1) circoctl (1) circo (1) Circusd-estadísticas (1) circo-plugin (1).
La documentación completa está disponible en http://circus.readthedocs.org
Circusd-estadísticas hombre página
Sinopsis
circusd-stats [opciones]
Descripción
circusd-stats ejecuta el agregador de estadísticas de Circus.
De Seguros
--punto final PUNTO FINAL
Punto final de conexión.
--pubsub PUBSUB
El zócalo pub / sub de circusd ZeroMQ al que conectarse.
--punto de estadísticas PUNTO ESTADÍSTICO
El zócalo pub / sub de ZeroMQ al que enviar datos.
--nivel de registro NIVEL
Especifique el nivel de registro. NIVEL puede ser info, depurar, crítico, advertencia or error.
--salida de registro SALIR
La ubicación donde se escribirán los registros. El comportamiento predeterminado es escribir en
stdout (puede forzarlo pasando '-' a esta opción). Toma un nombre de archivo
de otra manera.
--ssh SSH
Servidor SSH en el formato usuario @ host: puerto.
-h, --ayuda
Muestre el mensaje de ayuda y salga.
--versión
Muestra la versión Circus y sale.
See also
circo (1) circo (1) circoctl (1) circo-plugin (1) circo-top (1).
La documentación completa está disponible en http://circus.readthedocs.org
Glosario: Específico del circo términos
árbitro
El árbitro es responsable de gestionar a todos los observadores dentro del circo, asegurando
todos los procesos se ejecutan correctamente.
controlador
A controlador contiene el conjunto de acciones que se pueden realizar en el árbitro.
aleteo
El aleteo detección se suscribe a eventos y detecta cuando algunos procesos están
reiniciando constantemente.
pub / sub
el circo tiene pubsub que recibe eventos de los observadores y los envía a
todos los suscriptores.
sanaciones controlador
El sanaciones controlador le permite comunicarse con el controlador a través de ZMQ para
controlar el circo.
observador, observadores
A observador es el programa que le dices a Circus que ejecute. Se puede ejecutar una sola instancia de Circus
uno o más observadores.
trabajador, los trabajadores, de compra, en costes
A es una instancia de proceso de sistema operativo independiente de su programa. Un solo observador
puede ejecutar uno o más procesos. También los llamamos trabajadores.
Derechos de Autor
Circus fue iniciado por Tarek Ziade y tiene licencia bajo APLv2
Benoit Chesneau fue uno de los primeros colaboradores e hizo muchas cosas, como la mayoría de los
circus.commands trabajo.
Licencia
Copyright 2012 - Fundación Mozilla
Copyright 2012 - Benoît Chesneau
Con licencia de Apache License, Versión 2.0 (la "Licencia");
no puede utilizar este archivo, excepto en cumplimiento con la Licencia.
Puede obtener una copia de la licencia en
http://www.apache.org/licenses/LICENSE-2.0
A menos que sea requerido por la ley aplicable o acordado por escrito, software
distribuido bajo la Licencia se distribuye "TAL CUAL",
SIN GARANTÍAS O CONDICIONES DE NINGÚN TIPO, ya sea expresa o implícita.
Consulte la Licencia para el idioma específico que rige los permisos y
Limitaciones bajo la Licencia.
Colaboradores
Vea la lista completa en https://github.com/circus-tent/circus/blob/master/CONTRIBUTORS.txt
Utilice Circus Online con los servicios de onworks.net