这是可以使用我们的多个免费在线工作站之一在 OnWorks 免费托管服务提供商中运行的命令马戏团，例如 Ubuntu Online、Fedora Online、Windows 在线模拟器或 MAC OS 在线模拟器
程序：
您的姓名
马戏团 - 马戏团文档 [图片]
Circus 是一个 Python 程序，可用于监视和控制进程和套接字。
Circus 可以通过命令行界面、Web 界面或以编程方式驱动
通过它的python API。
要安装它并尝试其功能，请查看示例，或阅读本页的其余部分
快速介绍。
跑步 A 马戏团 达蒙
Circus 提供命令行脚本调用 马戏团 可用于管理流程
组织在一个或多个观察者中。
Circus 的命令行工具可以使用 ini 样式的配置文件进行配置。
这是一个非常小的例子：
[观察者：节目]
cmd = python 我的程序.py
进程数 = 5
[观察者：另一个程序]
cmd = 另一个程序
进程数 = 2
然后将文件传递给 马戏团:
$马戏团示例.ini
除了进程，Circus 还可以绑定套接字。 由于 Circus 管理的每个流程都是
主要 Circus 守护进程的子进程，这意味着任何由 Circus 控制的程序都可以
使用那些插座。
运行一个套接字就像添加一个 插座 配置文件中的部分：
[套接字：mysocket]
主机 = 本地主机
端口 = 8080
要了解有关套接字的更多信息，请参阅套接字。
要了解为什么它是一个杀手级功能，请阅读whycircussockets。
控制 马戏团
Circus 提供了两个命令行工具来管理您正在运行的守护进程：
· 马戏团，一个管理控制台，您可以使用它来执行诸如添加或
移除工人
· 马戏团顶，一个类似顶部的控制台，您可以用来显示您的内存和 CPU 使用情况
运行马戏团。
要了解有关这些的更多信息，请参阅 cli
Circus 还提供了一个 Web 仪表板，可以连接到正在运行的 Circus 守护程序并让您
监视它并与之交互。
要了解有关此功能的更多信息，请参阅 circushttpd
什么是 现在 ?
如果您是开发人员并希望在您自己的项目中利用 Circus，请编写插件或
钩子，去fordevs。
如果您是操作员并希望使用 Circus 管理您的流程，请转到 forops。
捐款 和 反馈
更多关于贡献：贡献。
有用链接：
· 有任何反馈或问题的邮件列表：
http://tech.groups.yahoo.com/group/circus-dev/
· 存储库和问题跟踪器位于 GitHub 上： https://github.com/circus-tent/circus
· 加入我们的 IRC : Freenode, 频道 #马戏团帐篷
文件记录 指数
安装 马戏团
Circus 是一个 Python 包，它发布在 PyPI - Python 包索引上。
最简单的安装方式是使用pip，一个安装和管理Python的工具
包：
$ pip 安装马戏团
或者下载 档案 on 的PyPI，手动解压并安装：
$ python setup.py 安装
如果您想尝试 Circus，请参阅示例。
如果您使用的是 debian 或任何基于 debian 的发行版，您还可以使用 ppa
安装马戏团，它在 https://launchpad.net/~roman-imankulov/+archive/circus
zc.buildout
我们提供了一个 zc.buildout 配置，您可以通过简单地运行引导程序来使用它
脚本，然后调用 buildout：
$ python 引导程序.py
$箱/扩建
更多 on 操作系统需求
马戏团与：
· Python 2.6、2.7、3.2 或 3.3
·
零米 >= 2.1.10
· 支持的 zeromq 版本最终是由什么版本决定的
pyzmq 在马戏团安装期间由 pip 安装。
· 他们当前的版本支持 2.x（有限）、3.x 和 4.x ZeroMQ 版本。
· 备注：如果您使用的是 PyPy 而不是 CPython，请务必阅读他们的
安装文档作为 ZeroMQ 版本支持与 PyPy 不同。
安装 circus 时，会拉出最新版本的 Python 依赖项
为你。
您还可以使用我们提供的 pip-requirements.txt 文件手动安装它们：
$ pip install -r pip-requirements.txt
如果要运行 Web 控制台，则需要安装 马戏团网:
$ pip 安装马戏团网络
教程
一步步 教程
这个 例子 目录 在 Circus 存储库中包含许多示例来帮助您
开始，但这里有一个完整的教程，可以让您概述功能。
我们将监督一个 WSGI 应用程序。
安装
Circus 在 Mac OS X 和 Linux 上使用最新的 Python 2.6、2.7、3.2 和 3.3 进行了测试。 到
运行一个完整的马戏团，你还需要 libzmq, 自由事件 & 的virtualenv.
在基于 Debian 的系统上：
$ sudo apt-get 安装 libzmq-dev libevent-dev python-dev python-virtualenv
创建一个 virtualenv 并安装 马戏团, 马戏团网 和 袜子 在里面
$ virtualenv /tmp/马戏团
$ cd /tmp/马戏团
$ bin/pip 安装马戏团
$ bin/pip 安装 circus-web
$ bin/pip 安装 chaussette
完成此操作后，您将在本地 bin 目录中找到大量命令。
用法
袜子 附带一个默认的 Hello world 应用程序，尝试运行它：
$ bin/chausette
你应该可以访问 http://localhost：8080 并看到 hello 世界.
停止 Chaussette 并在包含以下内容的目录中添加一个 circus.ini 文件：
[马戏表演]
统计数据 = 1
httpd = 1
[观察者：webapp]
cmd = bin/chausette --fd $(circus.sockets.web)
进程数 = 3
use_sockets = 真
[套接字：网络]
主机 = 127.0.0.1
端口 = 9999
这个配置文件告诉 Circus 在端口上绑定一个套接字 9999 并运行 3 名 chaussettes 工人
反对。 它还激活 Circus 网络仪表板和统计模块。
保存并运行它 马戏团:
$ bin/circusd --daemon circus.ini
现在访问 http://127.0.0.1：9999，您应该会看到 hello world 应用程序。 现在的区别是
该套接字由 Circus 管理，并且有几个网络工作者正在接受
反对它的联系。
注意:
负载平衡由操作系统操作，因此您获得相同的速度
与任何其他 pre-fork 网络服务器一样，如 Apache 或 NGinx。 马戏团不干扰
通过的数据。
你也可以参观 http://localhost：8080 / 并享受 Circus 网络仪表板。
互动
让我们在系统运行时使用 circusctl shell：
$ bin/circusctl
马戏团 0.7.1
circusd-stats：活动
circushttpd：活动
网络应用程序：活动
（马戏团）
您将进入交互式 shell。 类型 帮助 获取所有命令：
(circusctl) 帮助
记录的命令（键入 help )：
========================================
添加获取列表 numprocesses 退出 rm 开始停止
decr globaloptions 监听 numwatchers 重新加载设置统计信息
dstats incr listsockets 选项重启信号状态
未记录的命令：
======================
EOF 帮助
让我们尝试一些基本的东西。 让我们列出 Web Worker 进程并添加一个新进程：
(circusctl) 列出 webapp
13712,13713,13714
（circusctl）incr webapp
4
(circusctl) 列出 webapp
13712,13713,13714,13973
恭喜，您已经与您的马戏团互动了！ 使用 Ctrl+D 离开外壳，现在运行
马戏团顶：
$ bin/马戏团顶
这是一个类似 top 的命令，用于实时查看所有进程的内存和 CPU 使用情况。
按 Ctrl+C，现在让我们通过 circus-ctl 完全退出 Circus：
$ bin/circusctl 退出
ok
下一页 步骤
你可以简单地插入你自己的 WSGI 应用程序而不是 Chaussette 的 hello world
指向可调用的应用程序。
Chaussette 还带有许多后端，如 Gevent 或 Meinheld。
阅读 https://chaussette.readthedocs.org/ 对于所有选项。
应该 I 使用 马戏团 代替 of X ?
1. 马戏团 简化 您的 卷筒纸 堆 工艺 管理
马戏团知道如何管理流程 和 套接字，因此您不必委派网络
工作人员管理到 WGSI 服务器。
看看为什么circussockets
2. 马戏团 提供 发布/订阅 和 英寸 通知 通过 零MQ
Circus 有一个您可以订阅的发布/订阅频道。 该频道接收所有事件
发生在马戏团。 例如，您可以在进程抖动时收到通知，或者
构建一个客户端，当某些进程占用所有 CPU 或
内存。
这些事件是通过 ZeroMQ 通道发送的，这使得它不同于标准输入
流 Supervisord 使用：
· Circus 以即发即忘的方式发送事件，因此无需手动循环
通过 所有 听众并保持他们的状态。
· 订户可以位于远程主机上。
Circus 还提供了通过对 req/rep 的一次性投票来获取状态更新的方法
渠道。 这意味着您无需订阅即可获取您的信息
溪流。 Circus 提供的 cli 命令使用这个通道。
请参阅示例。
3. 马戏团 is （Python） 开发人员 友好
虽然 Circus 可以完全由配置文件驱动，但 马戏团 / 马戏团
命令，很容易重用全部或部分系统来构建您自己的自定义
Python 中的进程观察器。
系统的每一层都是隔离的，所以你可以独立重用：
· 进程包装器（流程)
· 流程管理器（守望者)
· 运行多个进程管理器的全局管理器（仲裁者)
· 等等…
4. 马戏团 秤
Circus 的用例之一是管理数千个进程而无需添加
开销——我们致力于专注于此。
未来 ， 监
Supervisor 是 Python 世界中非常流行的解决方案，我们经常被问到 Circus 如何
与之相比。
如果你来自 监，此页面试图概述工具如何
不同。
差异 简介
Supervisor & Circus 有相同的目标——他们都管理流程并提供
命令行脚本——分别 主管 和 马戏团 — 读取配置
文件，派生新进程并使它们保持活动状态。
Circus 有一个额外的功能：能够绑定套接字并让其管理的进程
使用它们。 许多网络服务器都使用这种“预分叉”模型，例如 阿帕奇 or
独角兽. 在 Circus 中使用此选项可以简化 Web 应用程序堆栈：所有进程和
套接字由单个工具管理。
这两个项目都提供了一种通过另一个脚本控制正在运行的守护进程的方法。 分别
监督者 和 马戏团. 它们也都有事件和订阅它们的方法。
主要区别在于底层技术：Supervisor使用XML-RPC进行交互
使用守护进程，而 Circus 使用 ZeroMQ。
Circus 和 Supervisor 都有一个 Web 界面来显示正在发生的事情。 马戏团的更多
先进，因为您可以实时跟踪正在发生的事情并与守护程序进行交互。
它使用网络套接字并在一个单独的项目中开发（马戏团网.)
核心设计还有许多其他细微的差异，我们可能有一天会在这里列出......
同时，您可以在设计中了解更多有关马戏团内部结构的信息。
配置
两个系统都使用类似 ini 的文件作为配置。
· 监 文件
· 马戏团 文件
这是一个使用 Supervisor 运行应用程序的小示例。 在这种情况下，
应用程序将启动并重新启动以防它崩溃
[程序：示例]
命令= npm 启动
目录=/home/www/my-server/
用户=www-数据
自动启动=真
自动重启=真
redirect_stderr=真
在 Circus 中，通过以下方式完成相同的配置：
[观察者：例子]
cmd=npm 开始
working_dir=/home/www/我的服务器/
用户=www-数据
stderr_stream.class=标准输出流
请注意，Circus 中的 stderr 重定向略有不同。 该工具没有
a 尾巴 功能类似于 Supervisor 中的功能，但可以让您挂钩任何代码来处理
传入的流。 你可以创建你自己的流钩子（作为一个类）并做任何你想做的事情
想要传入的流。 Circus 提供了一些内置的流类，如
标准输出流, 的FileStream, 监视文件流或 定时旋转文件流.
马戏团 HPMC胶囊 行动
警告：
默认情况下，当通过 ZeroMQ 发送信息时，Circus 不保护其消息。
在生产环境中运行 Circus 之前，请务必阅读安全页面。
管理 Circus 守护进程的第一步是编写其配置文件。 看
配置。 如果您正在部署 Web 堆栈，请查看套接字。
可以使用 Python 2.6、2.7、3.2 或 3.3 部署 Circus - 大多数部署都是
在 2.7 中完成。 要了解如何部署 Circus，请查看部署。
要管理 Circus 守护进程，您应该熟悉可以使用的命令列表
in 马戏团. 请注意，您可以在运行时在线获得相同的帮助 马戏团 作为一个
贝壳。
我们提供 马戏团顶，请参阅 cli 和一个不错的 Web 仪表板。 见马戏团httpd。
最后，要充分利用 Circus，请务必查看如何使用插件和挂钩。
查看插件和钩子。
行动 文件 指数
配置
可以使用 ini 样式的配置文件来配置 Circus。
计费示例：
[马戏表演]
检查延迟 = 5
端点 = tcp://127.0.0.1:5555
pubsub_端点 = tcp://127.0.0.1:5556
包括 = \*.more.config.ini
掩码 = 002
[观察者：我的程序]
cmd = 蟒蛇
args = -u myprogram.py $(circus.wid) $(CIRCUS.ENV.VAR)
预热延迟 = 0
进程数 = 5
＃ 钩
hooks.before_start = my.hooks.control_redis
# 将每 300 毫秒推入 test.log 流
stdout_stream.class = 文件流
stdout_stream.filename = test.log
# 可选地在日志文件达到 1 GB 时轮换它
# 并保存 5 个旋转文件的副本
标准输出流.max_bytes = 1073741824
stdout_stream.backup_count = 5
[环境：我的程序]
路径 = $路径：/箱
蛋糕 = 谎言
[插件：statsd]
使用 = circus.plugins.statsd.StatsdEmitter
主机 = 本地主机
端口 = 8125
采样率 = 1.0
application_name = 示例
[套接字：网络]
主机 = 本地主机
端口 = 8080
马戏团 - 单 部分
端点
用于管理 Circus 的 ZMQ 套接字 马戏团. （默认：
tcp：//127.0.0.1：5555)
端点所有者
如果设置为系统用户名并且端点是一个 ipc 套接字，如
ipc://var/run/circusd.sock，则套接字文件的所有权将更改为
该用户在启动时。 有关更多详细信息，请参阅安全性。 （默认：无）
发布订阅端点
ZMQ PUB/SUB 套接字接收事件的发布。 （默认：
tcp：//127.0.0.1：5556)
爸爸端点
如果使用papa，则可以指定端点，例如 ipc://var/run/circusd.sock.
（默认： tcp：//127.0.0.1：20202)
统计数据 如果设置为 True，Circus 将运行 circusd-stats 守护进程。 （默认：假）
统计端点
ZMQ PUB/SUB 套接字接收统计信息的发布。 （默认：
tcp：//127.0.0.1：5557)
statsd_close_outputs
如果 True 将 circusd-stats stdout/stderr 发送到 /dev/null。 （默认：假）
检查延迟
ZMQ 套接字的轮询间隔（以秒为单位）。 （默认：5）
包括
要包含的配置文件列表。 您可以使用通配符 (*) 包括特定的
您的文件的方案。 路径是绝对的或相对于配置文件的。
（默认：无）
包含目录
配置目录列表。 所有文件匹配 *.ini文件 每个目录下都会
被包括在内。 路径是绝对的或相对于配置文件的。 （默认：
没有任何）
流后端
定义用于流式传输的后端类型。 可能的值为 绪
or 事件. （默认：线程）
预热延迟
两个观察者开始之间的时间间隔（以秒为单位）。 必须是整数。 （默认值：0）
httpd的 如果设置为 True，Circus 将运行 circushttpd 守护进程。 （默认：假）
httpd_主机
主机由 circushttpd 守护进程运行。 （默认：本地主机）
httpd_端口
由 circushttpd 守护进程运行的端口。 （默认：8080）
httpd_close_outputs
如果为 True，则将 circushttpd stdout/stderr 发送到 /dev/null。 （默认：假）
调试 如果设置为 True，所有 Circus stout/stderr 守护进程都被重定向到 circusd
标准输出/标准错误（默认值：False）
调试_gc
如果设置为 True，circusd 会从垃圾收集器输出额外的日志信息。
这对于跟踪内存泄漏很有用。 （默认：假）
pid文件
必须用于保留守护进程 pid 的文件。
遮罩 umask 的价值。 如果未设置，circusd 将不会尝试修改 umask。
日志级别
我们想要查看的日志级别（默认值：INFO）
日志输出
我们要记录的日志输出文件（默认： - 登录标准输出）。 你可以
使用以下语法登录到远程系统日志：
系统日志：//主机：端口？设施 其中主机是您的系统日志服务器，端口是可选的
和设施是要使用的系统日志设施。 如果您希望登录到本地系统日志
您可以使用 syslog:///path/to/syslog/socket?facility 代替。
记录器配置
用于配置标准 Python 日志记录的 INI、JSON 或 YAML 文件的路径
仲裁者。 特殊值“default”使用内置日志配置
基于可选的日志级别和日志输出选项。
例如： Yaml 配置 文件
版本：1
disable_existing_loggers: 假
格式化程序：
简单：
格式：'%(asctime)s - %(name)s - [%(levelname)s] %(message)s'
处理程序：
日志文件：
类：logging.FileHandler
文件名：logoutput.txt
级别：调试
格式化程序：简单
记录器：
马戏团：
级别：调试
处理程序：[日志文件]
传播：没有
根：
级别：调试
处理程序：[日志文件]
观察者：NAME - as 许多 部分 as 想
您的姓名 观察者的名字。 此名称用于 马戏团
CMD 要运行的可执行程序。
ARGS 传递给程序的命令行参数。 您可以使用python格式
此处的语法来构建参数。 环境变量可用，如
以及您传递的工作人员 ID 和环境变量（如果有）
使用“env”参数。 看 格式化 这些因素包括原料奶的可用性以及达到必要粉末质量水平所需的工艺。 命令 和 参数 - 动态
变量 更多信息。
壳 如果为 True，则进程在 shell 中运行（默认值：False）
shell_args
传递给 shell 命令的命令行参数 壳 是真的。 作品
仅适用于 *nix 系统（默认值：无）
工作目录
进程的工作目录（默认：无）
的uid 运行命令时应使用的用户 ID 或名称。 （当前的 uid 是
默认）。
GID 命令运行时应使用的组 ID 或名称。 （当前的 gid 是
默认）。
复制环境
如果设置为 true，则本地环境变量将被复制并传递给
工人在产卵时。 （默认：假）
复制路径
如果设置为真， 系统路径 在子流程环境中使用 路径.
复制环境 必须是真的。 （默认：假）
预热延迟
运行进程之间的延迟（以秒为单位）。
自动开启
如果设置为false，当仲裁者
开始。 可以显式启动观察器（例如： 马戏团 开始
我的程序）。 （默认：真）
进程数
为此观察者运行的进程数。
rlimit_LIMIT 限制
为被监视的进程设置资源限制 LIMIT。 配置名称应该匹配
中列出的 RLIMIT_* 常量（不区分大小写） Python 资源 模块
参考. 例如，配置行 'rlimit_nofile = 500' 设置最大值
将打开文件的数量设置为 500。要将限制值设置为 RLIM_INFINITY，请不要设置
值，就像这个配置行：'rlimit_nofile = '。
stderr_stream.class
一个完全限定的 Python 类名，它将被实例化，并将接收
这些因素包括原料奶的可用性以及达到必要粉末质量水平所需的工艺。 斯特德 其所有进程的流 __称呼__（） 方法。
Circus 提供了一些无需前缀即可使用的流类：
· 的FileStream: 写入文件并可以进行自动日志轮换
· 监视文件流: 写入文件并依赖外部日志轮换
· 定时旋转文件流: 写入文件并可以在特定时间进行轮换
间隔。
· 队列流: 写入内存队列
· 标准输出流: 写入标准输出
· 花式标准输出流: 在标准输出中写入带有时间前缀的彩色输出
标准错误流。*
开头的所有选项 标准错误流。 以外 程 将通过
创建类的实例时的构造函数
stderr_stream.class.
标准输出流.class
一个完全限定的 Python 类名，它将被实例化，并将接收
这些因素包括原料奶的可用性以及达到必要粉末质量水平所需的工艺。 标准输出 其所有进程的流 __称呼__（） 方法。
Circus 提供了一些无需前缀即可使用的流类：
· 的FileStream: 写入文件并可以进行自动日志轮换
· 监视文件流: 写入文件并依赖外部日志轮换
· 定时旋转文件流: 写入文件并可以在特定时间进行轮换
间隔。
· 队列流: 写入内存队列
· 标准输出流: 写入标准输出
· 花式标准输出流: 在标准输出中写入带有时间前缀的彩色输出
标准输出流。*
开头的所有选项 标准输出流。 以外 程 将通过
创建类的实例时的构造函数
标准输出流.class.
关闭子标准输出
如果设置为 True，每个进程的 stdout 流将被发送到 /dev/null
在叉子之后。 默认为假。
close_child_stderr
如果设置为 True，每个进程的 stderr 流将被发送到 /dev/null
在叉子之后。 默认为假。
发送_hup
如果为 True，将通过发送 SIGHUP 信号来完成进程重新加载。 默认值
为假。
停止信号
停止进程时发送的信号。 可以指定为数字或
信号名称。 信号名称不区分大小写，可以包含或不包含“SIG”。 所以
有效的例子包括 退出, INT, 目标期限 和 3. 默认为 SIGTERM。
停止子项
发送时 停止信号，也送给孩子们。 默认为
假。
最大重试
在我们放弃和停止之前，我们尝试启动进程的次数
整个观察者。 默认为 5。设置为 -1 以禁用 max_retry 和重试
无限期。
优雅超时
等待进程正常终止之前的秒数
杀了它。
当停止一个进程时，我们首先向它发送一个 停止信号. 工人可能会抓住这个
退出前执行清理操作的信号。 如果工人还在
在graceful_timeout 秒后激活，我们向它发送一个SIGKILL 信号。 它不是
可能会捕捉到 SIGKILL 信号，因此工作人员将停止。
默认为 30 秒。
优先
定义观察者优先级的整数。 当仲裁者做一些事情时
对所有观察者的操作，它会用这个字段对它们进行排序，从较大的
数到最小。 默认为 0。
独生子
如果设置为 True，这个观察者最多只有一个进程。 默认为
假。
使用套接字
如果设置为 True，此观察者将能够通过其访问定义的套接字
文件描述符。 如果为 False，则当子进程处于关闭状态时，所有父 fds 都将关闭
分叉。 默认为假。
最大年龄
如果设置，则进程将在 max_age 秒后的某个时间重新启动。 这
当进程处理连接器池时很有用：重新启动进程
改善负载均衡。 默认为禁用。
最大年龄方差
如果设置了 max_age，则进程将在 max_age 和 max_age + 之间
随机（0，max_age_variance）秒。 这避免了重新启动所有进程
立即观察者。 默认为 30 秒。
一经请求
如果设置为 True，则只有在第一次连接到
配置的套接字之一（见下文）。 如果需要重新启动，它将是
仅在下一个套接字事件时触发。
钩子。*
可用挂钩： 开始前, 开始后, 生成前, 产卵后,
前_停止, 停止后, 前信号, 后信号, 扩展统计
定义挂钩到观察者启动/关闭过程的回调函数。
如果钩子返回 假 如果钩子是其中之一 开始前, 生成前,
开始后 or 产卵后，启动将被中止。
如果钩子是 前信号 并返回 假，那么对应的信号
不会被发送（除了总是发送的 SIGKILL）
请注意，在停止过程中失败的钩子不会中止它。
回调定义后可以跟一个由逗号分隔的布尔标志。
当标志设置为 true，钩子中发生的任何错误都将被忽略。 如果
设置 false （默认），钩子将返回 假.
更多关于钩子。
的virtualenv
提供时，指向 Virtualenv 目录的根目录。 观察者将
扫描本地 网站包装 并将其内容加载到执行中
环境。 必须与 复制环境 设置为真。 默认为无。
虚拟环境_py_ver
指定virtualenv 的python 版本（例如“3.3”）。 有用的话
使用另一个 python 版本（例如“2.7”）运行的马戏团观察者将扫描
本地 网站包装 指定的python版本并将其内容加载到
执行环境。 必须与 的virtualenv. 默认为无。
重生
如果设置为 False，则不会重新生成由观察者处理的进程
自动地。 这些进程可以手动重生 开始 命令。
（默认：真）
使用_papa
设置为 true 以使用爸爸。
插座：名称 - as 许多 部分 as 想
主持人 套接字的主机。 默认为“本地主机”
端口 港口。 默认为 8080。
家庭 插座家族。 可以是“AF_UNIX”、“AF_INET”或“AF_INET6”。 默认为
'AF_INET'。
类型 插座类型。 可以是“SOCK_STREAM”、“SOCK_DGRAM”、“SOCK_RAW”、“SOCK_RDM”或
'SOCK_SEQPACKET'。 默认为“SOCK_STREAM”。
接口
当提供了一个像“eth0”这样的网络接口名称时，将套接字绑定到那个
特定设备，以便仅从该特定接口接收数据包
由套接字处理。 这可以用于例如限制哪个设备
在 IN_ADDR_ANY (0.0.0.0) 或 IN_ADDR_BROADCAST 上绑定时绑定
(255.255.255.255)。 请注意，这仅适用于某些套接字类型，尤其是
AF_INET 套接字。
径 当提供将用作 unix 套接字文件的文件的路径时。 如果一个
提供了路径， 家庭 被迫使用 AF_UNIX 和 主持人 和 端口 被忽略了。
遮罩 提供时，设置将用于创建 AF_UNIX 套接字的 umask。 为了
例， 掩码=000 将产生一个获得许可的套接字 777.
更换
创建 Unix 套接字 ('AF_UNIX') 时，现有文件可能表明存在问题
所以默认是失败。 指定 真 如果您是，只需删除旧文件
确保套接字仅由 Circus 管理。
so_reuseport
如果设置为 True 并且 SO_REUSEPORT 在目标平台上可用，马戏团将
为它启动的每个工作线程创建并绑定新的 SO_REUSEPORT 套接字，这是一个
此套接字的用户。
使用_papa
设置为 true 以使用爸爸。
创建套接字后， ${circus.sockets.NAME} 字符串可以在命令中使用
(CMD or ARGS) 的观察者。 Circus 将用 FD 值替换它。 观察者还必须
它们在许多情况下都能提供类似的结果。 使用套接字 设置 真 否则套接字将被关闭，你会得到
当观察者尝试使用它时出错。
计费示例：
[观察者：网络工作者]
cmd = chausette --fd $(circus.sockets.webapp) chausette.util.bench_app
use_sockets = 真
[套接字：webapp]
主机 = 127.0.0.1
端口 = 8888
插件：NAME - as 许多 部分 as 想
使用 指向插件类的完全限定名称。
什么 其他
该部分中找到的所有其他键都传递给
配置 映射。
您可以使用所有观察者选项，因为插件像观察者一样启动。
Circus 附带了一些预装的插件，但您也可以通过以下方式轻松扩展它们
开发自己的。
ENV or 环境 [:观察者] - as 许多 部分 as 想
什么
要为其赋值的环境变量的名称。 bash 风格的环境
支持替换。 例如，追加 /箱 至 PATH '路径 =
$路径：/箱'
负责提供环境变量以运行进程的部分。
计费示例：
[观察者：worker1]
命令 = ping 127.0.0.1
[观察者：worker2]
命令 = ping 127.0.0.1
[环境]
蛋糕 = 谎言
变量 蛋糕 将传播到配置文件中定义的所有观察者。
WATCHERS 可以是要应用此环境的观察者部分的逗号分隔列表。
如果多个 env 部分匹配一个观察者，它们将按照它们出现的顺序组合
配置文件。 后面的条目将优先。
计费示例：
[观察者：worker1]
命令 = ping 127.0.0.1
[观察者：worker2]
命令 = ping 127.0.0.1
[环境：工人1，工人2]
路径 = /箱
[环境：worker1]
路径 = $路径
[环境：worker2]
蛋糕 = 谎言
工人1 将使用 PATH = $PATH 运行（从运行 circusd 的环境中扩展）
工人2 将与 PATH = 一起运行 /箱 和蛋糕 = 谎言
也可以使用通配符。
计费示例：
[观察者：worker1]
命令 = ping 127.0.0.1
[观察者：worker2]
命令 = ping 127.0.0.1
[环境：工人*]
路径 = /箱
以上皆是 工人1 和 工人2 将与 PATH = 一起运行 /箱
运用 环境 变量
在编写配置文件时，您可以使用在配置文件中定义的环境变量 ENV
部分或在 操作系统环境 本身。
你只需要使用 马戏团.env。 字首。
计费示例：
[观察者：worker1]
cmd = $(circus.env.shell)
[观察者：worker2]
baz = $(circus.env.user)
酒吧 = $(circus.env.yeah)
sup = $(circus.env.oh)
[插座：插座1]
端口 = $(circus.env.port)
[插件：插件1]
使用 = some.path
参数 1 = $(circus.env.plugin_param)
[环境]
是的 = 嘘
[环境：worker2]
哦=好的
如果在多个地方定义了一个变量，则最特殊的值具有优先权：a
变量定义在 环境：XXX 将覆盖定义的变量 ENV，这将覆盖一个
变量定义在 操作系统环境.
环境替换可以在任何部分的配置的任何部分中使用
变量。
格式化 这些因素包括原料奶的可用性以及达到必要粉末质量水平所需的工艺。 命令 和 参数 - 动态 变量
正如您可能已经看到的，可以传递一些计算的信息
动态运行进程时。 除其他外，您可以获得工人 ID
(WID) 和所有传递给 流程. 此外，还可以
访问传递给 守望者 这实例化了这个过程。
注意:
工人 ID 与进程 ID 不同。 这是一个独特的值，从 1 开始，
这仅对观察者而言是唯一的。
例如，如果要访问环境中包含的某些变量，
你需要用这样的设置来做：
cmd = "让我喝咖啡 --sugar $(CIRCUS.ENV.SUGAR_AMOUNT)"
这适用于两者 CMD 和 ARGS.
重要提示:
· 所有变量都以 马戏表演。
· 替换不区分大小写。
资讯 配置
简单的流类，如 队列流 和 标准输出流 没有特定的属性但是
其他一些流类可能有一些：
的FileStream
文件名
将写入日志的文件路径。
时间格式
strftime 格式将用于为每次添加时间戳前缀。 经过
默认情况下，它们不会被前缀。
即：%Y-%m-%d %H:%M:%S
最大字节数
启动新文件之前日志文件的最大大小。 如果未提供，则
文件不翻转。
备份计数
将保留的日志文件数 默认情况下，backup_count 为空。
注意:
只要当前日志文件的长度接近 max_bytes，就会发生翻转。 如果
backup_count >= 1，系统会依次创建相同的新文件
路径名作为基本文件，但附加了扩展名“.1”、“.2”等。 为了
例如，backup_count 为 5，基本文件名为“app.log”，你会得到
“app.log”、“app.log.1”、“app.log.2”、...一直到“app.log.5”。 正在写入的文件
to 总是“app.log” - 当它被填满时，它被关闭并重命名为
“app.log.1”，如果文件“app.log.1”、“app.log.2”等存在，则重命名它们
分别为“app.log.2”、“app.log.3”等。
计费示例：
[观察者：我的程序]
cmd = python -m myapp.server
stdout_stream.class = 文件流
stdout_stream.filename = test.log
stdout_stream.time_format = %Y-%m-%d %H:%M:%S
标准输出流.max_bytes = 1073741824
stdout_stream.backup_count = 5
监视文件流
文件名
将写入日志的文件路径。
时间格式
strftime 格式将用于为每次添加时间戳前缀。 经过
默认情况下，它们不会被前缀。
即：%Y-%m-%d %H:%M:%S
注意:
WatchedFileStream 依赖外部日志轮换工具来确保日志文件
不要变得太大。 输出文件将被监控，如果它被删除或
由外部日志轮换工具移动，那么输出文件句柄将是
自动重新加载。
计费示例：
[观察者：我的程序]
cmd = python -m myapp.server
stdout_stream.class = WatchedFileStream
stdout_stream.filename = test.log
stdout_stream.time_format = %Y-%m-%d %H:%M:%S
定时旋转文件流
文件名
将写入日志的文件路径。
备份计数
将保留的日志文件数 默认情况下，backup_count 为空。
时间格式
strftime 格式将用于为每次添加时间戳前缀。 经过
默认情况下，它们不会被前缀。
即：%Y-%m-%d %H:%M:%S
旋转时
间隔的类型。 可能的值列表如下。 请注意，它们是
不区分大小写。
┌─────────────┬──────────────────────────┐
│数值 │ 区间类型 │
├────────────┼─────────────────────────┤
│'S' │ 秒 │
├────────────┼─────────────────────────┤
│'M' │ 分钟 │
├────────────┼─────────────────────────┤
│'H' │ 小时 │
├────────────┼─────────────────────────┤
│'D' │ 天 │
├────────────┼─────────────────────────┤
│'W0'-'W6' │ 工作日（0=星期一）│
├────────────┼─────────────────────────┤
│'午夜' │ 半夜翻身│
└──────────────┴──────────────────────────┘
旋转间隔
翻转间隔。
注意:
TimedRotatingFileStream 以特定的时间间隔轮换日志文件。 翻转间隔
由rotate_when 和rotate_interval 的组合决定。
计费示例：
[观察者：我的程序]
cmd = python -m myapp.server
stdout_stream.class = TimedRotatingFileStream
stdout_stream.filename = test.log
stdout_stream.time_format = %Y-%m-%d %H:%M:%S
stdout_stream.utc = 真
stdout_stream.rotate_when = H
stdout_stream.rotate_interval = 1
花式标准输出流
颜色
这个 姓名 of an ASCII 颜色：
· 红色的
· 绿色
· 黄色的
· 蓝色
·洋红色
·青色
· 白色的
时间格式
每行都将带有前缀的 strftime 格式。
默认为：%Y-%m-%d %H:%M:%S
计费示例：
[观察者：我的程序]
cmd = python -m myapp.server
stdout_stream.class = FancyStdoutStream
stdout_stream.color = 绿色
stdout_stream.time_format = %Y/%m/%d | stdout_stream.time_format = %Y/%m/%d | %H:%M:%S
命令
指挥系统位于马戏团的中心。 马戏团 只是一个 zeromq 客户端，
如果需要，您可以通过编写自己的 zmq 以编程方式驱动 Circus 系统
顾客。
所有消息都是 JSON 映射。
对于下面的每个命令，我们提供了一个带有 circusctl 的用法示例以及输入 /
输出 zmq 消息。
马戏团-ctl 命令
· 加: 命令/添加
· 递减: 命令/decr
· 数据统计: 命令/数据统计
· 得到: 命令/获取
· 全局选项: 命令/全局选项
· 增量: 命令/增量
· 蟒蛇: 命令/ipython
· 名单: 命令/列表
· 听: 命令/听
· 列表套接字: 命令/列表套接字
· 进程数: 命令/进程数
· 观察者人数: 命令/观察者
· 选项: 命令/选项
· 退出: 命令/退出
· 重载: 命令/重新加载
· 重新加载配置: 命令/重新加载配置
· 重新开始: 命令/重启
· rm: 命令/rm
· 集: 命令/设置
· 信号: 命令/信号
· 开始: 命令/开始
· 统计: 命令/统计
· 状态: 命令/状态
· 停止: 命令/停止
添加 a 守望者
此命令将观察者动态添加到仲裁者。
ZMQ 留言
{
“命令”：“添加”，
“特性”： {
"cmd": "/path/to/commandline --option"
"name": "nameofwatcher"
“参数”：[]，
“选项”： {}，
“开始”：假
}
}
一条消息包含 2 个属性：
· cmd：在进程中执行的完整命令行
· args：数组，传递给命令的参数（可选）
· name：观察者的名字
· 选项：观察者的选项
· start：创建后启动watcher
响应返回状态“ok”。
命令 线
$ circusctl add [--start]
可选项
· : 要创建的观察者的名称
· : 在进程中执行的完整命令行
· --start：立即启动观察者
减量 这些因素包括原料奶的可用性以及达到必要粉末质量水平所需的工艺。 数 of 工艺 in a 守望者
此注释将观察者中的进程数减少, 1 是
默认。
ZMQ 留言
{
"命令": "decr",
“属性”：{
“名称”： ” ”
“nb”：
“等待”：错误
}
}
响应返回“numprocesses”属性中的进程数：
{ "status": "ok", "numprocesses": ，“时间”，“时间戳”}
命令 线
$ circusctl decr [ ] [ - 等待]
可选项
· : 观察者的名字
· ：要删除的进程数。
积极 马戏团 统计
您可以随时使用 dstat 命令获取有关 circusd 的一些统计信息。
ZMQ 留言
要获取 circusd 统计信息，只需运行：
{
“命令”：“数据统计”
}
响应返回包含一些进程信息的属性“infos”的映射：
{
“信息”：{
“孩子们”： []，
"cmdline": "python",
“CPU”：0.1，
"ctime": "0:00.41",
“记忆”：0.1，
"mem_info1": "3M",
"mem_info2": "2G",
“不错”：0，
“pid”：47864，
“用户名”：“root”
},
"状态": "好的",
“时间”：1332265655.897085
}
命令 LINE
$ circusctl 数据统计
积极 这些因素包括原料奶的可用性以及达到必要粉末质量水平所需的工艺。 折扣值 of 具体的 守望者 选项
该命令可用于查询一个或多个观察者选项的当前值。
ZMQ 留言
{
“命令”：“获取”，
“特性”： {
"keys": ["key1, "key2"]
"name": "nameofwatcher"
}
}
请求消息包含两个属性：
· 键：列表，要获取其值的选项键
· name：观察者的名字
响应对象有一个属性 选项 这是一个选项名称字典和
值。
例如：
{
"状态": "好的",
“选项”： {
"graceful_timeout": 300,
“send_hup”：对，
},
时间'：1332202594.754644
}
命令 线
$ circusctl 得到
积极 这些因素包括原料奶的可用性以及达到必要粉末质量水平所需的工艺。 仲裁者 选项
此命令返回仲裁器选项
ZMQ 留言
{
“命令”：“全局选项”，
“特性”： {
"key1": "val1",
..
}
}
一条消息包含 2 个属性：
· 键：列表，要获取其值的选项键
响应返回一个带有属性“options”的对象，其中包含键/值列表
马戏团归还。
例如：
{
"状态": "好的",
“选项”： {
“check_delay”：1，
...
},
时间'：1332202594.754644
}
命令 线
$ circusctl 全局选项
可选项
选项键是：
·端点：控制器ZMQ端点
· pubsub_endpoint：pubsub端点
· check_delay：两个控制器点之间的延迟
· multicast_endpoint：circusd集群自动发现的组播端点
增量 这些因素包括原料奶的可用性以及达到必要粉末质量水平所需的工艺。 数 of 工艺 in a 守望者
此注释将观察者中的进程数增加, 1 是
默认
ZMQ 留言
{
“命令”：“增量”，
“特性”： {
“名称”： ” ”，
“nb”： ,
“等待”：错误
}
}
响应返回“numprocesses”属性中的进程数：
{ "status": "ok", "numprocesses": ，“时间”，“时间戳”}
命令 线
$ circusctl incr [ ] [ - 等待]
可选项
· : 观察者的名字。
· : 要添加的进程数。
创建 壳 成 马戏团 工艺
此命令仅在您安装了 ipython 包时才有用。
命令 LINE
$ circusctl ipython
积极 名单 of 观察家 or 工艺 in a 守望者
ZMQ 留言
要获取所有观察者的列表：
{
“命令”：“列表”，
}
要获取观察者中的活动进程列表：
{
“命令”：“列表”，
“特性”： {
"name": "nameofwatcher",
}
}
响应返回询问的列表。 返回的映射可以是“观察者”或
'pids' 取决于请求。
命令 线
$ circusctl 列表 [ ]
订阅 至 a 守望者 活动
ZMQ
您可以随时订阅马戏团活动。 Circus 提供了一个 PUB/SUB 提要，在该提要上
任何客户都可以订阅。 订阅者端点 URI 在 circus.ini 中设置
配置文件。
事件是 pubsub 主题：
· 观察者。 .收割: 当一个进程被收割时
· 观察者。 .spawn: 当一个进程产生时
· 观察者。 。杀: 当一个进程被杀死时
· 观察者。 。更新: 当观察者配置更新时
· 观察者。 。停止: 当观察者停止时
· 观察者。 。开始: 当观察者启动时
所有事件消息都在一个 json 结构中。
命令 线
客户端已更新以提供一种简单的方法来监听事件：
马戏团听[ , ...]
例如： of 结果：
$ circusctl 听 tcp://127.0.0.1:5556
watcher.refuge.spawn: {u'process_id': 6, u'process_pid': 72976,
你的时间：1331681080.985104}
watcher.refuge.spawn: {u'process_id': 7, u'process_pid': 72995,
你的时间：1331681086.208542}
watcher.refuge.spawn: {u'process_id': 8, u'process_pid': 73014,
你的时间：1331681091.427005}
积极 这些因素包括原料奶的可用性以及达到必要粉末质量水平所需的工艺。 名单 of 插座
ZMQ 留言
要获取套接字列表：
{
"command": "listsockets",
}
响应返回一个 json 映射列表，其中包含 fd、名称、主机和端口的键。
命令 线
$ circusctl 列表套接字
积极 这些因素包括原料奶的可用性以及达到必要粉末质量水平所需的工艺。 数 of 工艺
获取观察者或仲裁者中的进程数
ZMQ 留言
{
“命令”：“进程数”，
“属性”：{
“名称”： ” ”
}
}
响应返回“numprocesses”属性中的进程数：
{ "status": "ok", "numprocesses": ，“时间”，“时间戳”}
如果未指定属性名称，则返回所有受管进程的总和。
命令 线
$ circusctl numprocesses [ ]
可选项
· : 观察者的名字
积极 这些因素包括原料奶的可用性以及达到必要粉末质量水平所需的工艺。 数 of 观察家
获取仲裁器中的观察者数量
ZMQ 留言
{
"command": "numwatchers",
}
响应在 'numwatchers` 属性中返回观察者的数量：
{ "status": "ok", "numwatchers": ，“时间”，“时间戳”}
命令 线
$ circusctl numwatchers
积极 这些因素包括原料奶的可用性以及达到必要粉末质量水平所需的工艺。 折扣值 of 所有 选项 HPMC胶囊 a 守望者
此命令返回给定观察者的所有选项值。
ZMQ 留言
{
“命令”：“选项”，
“特性”： {
"name": "nameofwatcher",
}
}
一条消息包含 1 个属性：
· name：观察者的名字
响应对象有一个属性 选项 这是一个选项名称字典和
值。
例如：
{
"状态": "好的",
“选项”： {
"graceful_timeout": 300,
“send_hup”：对，
...
},
时间'：1332202594.754644
}
命令 线
$ circusctl 选项
可选项
· : 观察者的名字
选项键是：
· numprocesses：整数，进程数
·warmup_delay：整数或数字，以秒为单位在进程生成之间等待的延迟
·working_dir：字符串，进程将执行的目录
· uid：字符串或整数，用于启动进程的用户ID
· gid：字符串或整数，用于启动进程的组ID
· send_hup: 布尔值，如果 TRU 信号 HUP 将用于重新加载
· shell：boolean，如果为true，将在shell环境中运行命令
· cmd：字符串，用于启动进程的命令行
· env：对象，定义进程将在其中启动的环境
· retry_in：整数或数字，我们在重试启动之前等待的时间（以秒为单位）
如果已达到最大尝试次数，则处理。
· max_retry：整数，最大重试循环次数
· graceful_timeout：整数或数字，我们在确定杀死进程之前等待的时间。
· 优先级：用于对仲裁器中的观察者进行排序
·单例：如果为True，单例观察者。
· max_age：进程在重新启动之前可以存活的时间
· max_age_variance：可变的额外生存时间，避免踩踏羊群。
退出 这些因素包括原料奶的可用性以及达到必要粉末质量水平所需的工艺。 仲裁者 立即
当仲裁器收到该命令时，仲裁器退出。
ZMQ 留言
{
“命令”：“退出”，
“等待”：错误
}
响应返回状态“ok”。
If 等候 为 False（默认），调用后会立即返回 停止信号
在每个过程中。
If 等候 为 True，只有在停止过程完全结束时调用才会返回。
由于graceful_timeout 选项，它可能需要一些时间。
命令 线
$ circusctl 退出 [--waiting]
刷新 这些因素包括原料奶的可用性以及达到必要粉末质量水平所需的工艺。 仲裁者 or a 守望者
此命令在一个观察者或所有观察者中重新加载所有进程。 这将发生在一
3种方式：
· 如果graceful 为false，则发生简单的重启。
· 如果 发送_hup 对于观察者来说也是如此，一个 HUP 信号被发送到每个进程。
·
除此以外：
· 如果sequential 为false，仲裁器将尝试生成 进程数 新
过程。 如果新进程成功生成，结果是
所有旧进程都停止了，因为默认情况下最旧的进程是
当观察者的实际进程数大于
进程数.
· 如果sequential 为真，仲裁器将按顺序重新启动每个进程
方式（用 预热延迟 每一步之间暂停）
ZMQ 留言
{
“命令”：“重新加载”，
“特性”： {
“名称”： ' ”，
“优雅”：真实，
“顺序”：假，
“等待”：错误
}
}
响应返回状态“ok”。 如果属性优雅设置为 true 进程
将优雅地退出。
如果存在属性名称，则重新加载将应用于观察者。
命令 线
$ circusctl 重新加载 [ ] [--终止] [--等待]
[--顺序]
可选项
· : 观察者的名字
· --终止； 立即退出节点
刷新 这些因素包括原料奶的可用性以及达到必要粉末质量水平所需的工艺。 配置 文件
此命令重新加载配置文件，因此配置文件中的更改将
体现在马戏团的配置上。
ZMQ 留言
{
“命令”：“重新加载配置”，
“等待”：错误
}
响应返回状态“ok”。 如果属性优雅设置为 true 进程
将优雅地退出。
命令 线
$ circusctl reloadconfig [--等待]
重新启动 这些因素包括原料奶的可用性以及达到必要粉末质量水平所需的工艺。 仲裁者 or a 守望者
此命令重新启动一个观察者或所有观察者中的所有进程。 这个功能简直了
停止观察者然后重新启动它。
ZMQ 留言
{
“命令”：“重启”，
“特性”： {
“名称”： ” ”，
“等待”：错误，
“匹配”：“[简单|glob|regex]”
}
}
响应返回状态“ok”。
如果存在属性名称，则重新加载将应用于观察者。
If 等候 为 False（默认），调用后会立即返回 停止信号
在每个过程中。
If 等候 为True，只有在重启过程完成后调用才会返回
结束了。 由于graceful_timeout 选项，它可能需要一些时间。
这个 匹配 参数可以有值 简单 对于字符串比较， 水珠 通配符
匹配（默认）或 正则表达式 用于正则表达式匹配。
命令 线
$ circusctl restart [名称] [--waiting] [--match=simple|glob|regex]
可选项
· : 观察者的名字或模式
· : 观察者匹配方法
删除 a 守望者
此命令从仲裁器中动态删除观察者。 旁观者优雅
默认停止。
ZMQ 留言
{
“命令”：“rm”，
“特性”： {
“名称”： ” ”，
“nostop”：错误，
“等待”：错误
}
}
响应返回状态“ok”。
If 不停 为 True（默认值：False），不会停止观察者的进程 -
相反，观察者将被马戏团遗忘，观察者进程将被
负责阻止自己。 如果 不停 未指定或为 False，则
观察者进程将正常停止。
If 等候 为 False（默认），调用将在开始删除后立即返回
并停止相应的观察者。
If 等候 为真，只有当remove和stop过程是，调用才会返回
完全结束了。 由于graceful_timeout 选项，它可能需要一些时间。
命令 线
$ circusctl rm [--等待] [--nostop]
可选项
· : 要删除的观察者的名称
· nostop：不停止watcher进程，只移除watcher
选择 a 守望者 选项
ZMQ 留言
{
“命令”：“设置”，
“特性”： {
"name": "nameofwatcher",
“选项”： {
"key1": "val1",
..
}
“等待”：错误
}
}
响应返回状态“ok”。 有关要设置的密钥列表，请参阅命令选项。
命令 线
$ circusctl 集 - 等待
发送 a 信号
此命令允许您向观察者中的所有进程发送信号，特定进程
在观察者或其孩子中。
ZMQ 留言
向观察者的所有进程发送信号：
{
“命令”：“信号”，
“财产”： {
“名称”： ,
“签名”：
}
向进程发送信号：
{
“命令”：“信号”，
“财产”： {
“名称”： ,
“pid”： ,
“签名”：
}
一个可选的属性“children”可用于将信号发送给所有的孩子而不是
比过程本身：
{
“命令”：“信号”，
“财产”： {
“名称”： ,
“pid”： ,
“签名”： ,
“孩子”：真的
}
向进程子进程发送信号：
{
“命令”：“信号”，
“财产”： {
“名称”： ,
“pid”： ,
“签名”： ,
“child_pid”： ,
}
也可以向观察者的所有孩子发送信号：
{
“命令”：“信号”，
“财产”： {
“名称”： ,
“签名”： ,
“孩子”：真的
}
最后，您可以向进程发送信号 和 它的孩子们，与 递归 选项：
{
“命令”：“信号”，
“财产”： {
“名称”： ,
“签名”： ,
“递归”：真
}
命令 线
$ circusctl 信号[ ] [ - 孩子们]
[--递归]
选项：
· : 观察者的名字
· ：整数，进程ID。
· ：要发送的信号编号（或名称）。
· : 孩子的pid，如果有的话
· : boolean, 发送信号给所有的孩子
· : boolean, 将信号发送给进程及其子进程
开始 这些因素包括原料奶的可用性以及达到必要粉末质量水平所需的工艺。 仲裁者 or a 守望者
此命令启动一个观察者或所有观察者中的所有进程。
ZMQ 留言
{
“命令”：“开始”，
“特性”： {
“名称”： ' ”，
“等待”：错误，
“匹配”：“[简单|glob|regex]”
}
}
响应返回状态“ok”。
如果存在属性名称，则将启动观察器。
If 等候 为 False（默认），调用后会立即返回 开始 on
每个过程。
If 等候 为 True，只有在启动过程完全结束时调用才会返回。
由于graceful_timeout 选项，它可能需要一些时间。
这个 匹配 参数可以有值 简单 对于字符串比较， 水珠 通配符
匹配（默认）或 正则表达式 用于正则表达式匹配。
命令 线
$ circusctl restart [名称] [--waiting] [--match=simple|glob|regex]
可选项
· : 观察者的名字或模式
· : 观察者匹配方法
积极 工艺 信息
您可以随时使用 stat 命令获取有关进程的一些统计信息。
ZMQ 留言
获取所有观察者的统计信息：
{
“命令”：“统计信息”
}
要获取观察者的统计信息：
{
“命令”：“统计数据”，
“特性”： {
“名称”：
}
}
要获取进程的统计信息：
{
“命令”：“统计数据”，
“特性”： {
“名称”： ,
“过程”：
}
}
可以使用 extended_stats 钩子扩展统计数据，但扩展统计数据需要
要求：
{
“命令”：“统计数据”，
“特性”： {
“名称”： ,
“过程”： ,
“扩展”：真
}
}
响应为每个进程返回一个对象，其属性“info”包含一些进程
信息：
{
“信息”：{
“孩子们”： []，
"cmdline": "python",
“CPU”：0.1，
"ctime": "0:00.41",
“记忆”：0.1，
"mem_info1": "3M",
"mem_info2": "2G",
“不错”：0，
“pid”：47864，
“用户名”：“root”
},
“过程”：5，
"状态": "好的",
“时间”：1332265655.897085
}
命令 LINE
$ circusctl stats [--extended] [ ] [ ]
积极 这些因素包括原料奶的可用性以及达到必要粉末质量水平所需的工艺。 状态 of a 守望者 or 所有 观察家
此命令开始获取观察者或所有观察者的状态。
ZMQ 留言
{
“命令”：“状态”，
“特性”： {
“名称”： ' ”，
}
}
响应返回状态“活动”或“停止”或状态/观察者。
命令 线
$ circusctl 状态 [ ]
可选项
· : 观察者的名字
例如：
$ circusctl 状态虚拟
要积极。
$ circusctl 状态
假人：活跃
dummy2：活动
避难所：活跃
Stop 停止 观察家
此命令停止给定的观察者或所有观察者。
ZMQ 留言
{
“命令”：“停止”，
“特性”： {
“名称”： ” ”，
“等待”：错误，
“匹配”：“[简单|glob|regex]”
}
}
响应返回状态“ok”。
如果 姓名 属性存在，那么停止将应用于观察者
对应那个名字。 否则，所有观察者都会被停止。
If 等候 为 False（默认），调用后会立即返回 停止信号
在每个过程中。
If 等候 为真，只有在停止过程完全结束时调用才会返回。
由于graceful_timeout 选项，它可能需要一些时间。
这个 匹配 参数可以有值 简单 对于字符串比较， 水珠 通配符
匹配（默认）或 正则表达式 用于正则表达式匹配。
命令 线
$ circusctl stop [名称] [--waiting] [--match=simple|glob|regex]
可选项
· : 观察者的名字或模式
· : 观察者匹配方法
CLI 工具
马戏团顶
马戏团顶 是一个顶级控制台，您可以运行以实时观看正在运行的 Circus 系统。 它
如果您有一些，将显示 CPU、内存使用情况和套接字命中率。
输出示例：
-------------------------------------------------- ---------------------
马戏团统计
PID CPU (%) 内存 (%)
14252 0.8 0.4
0.8（平均） 0.4（总和）
假的
PID CPU (%) 内存 (%)
14257 78.6 0.1
14256 76.6 0.1
14258 74.3 0.1
14260 71.4 0.1
14259 70.7 0.1
74.32（平均） 0.5（总和）
-------------------------------------------------- --------------------
马戏团顶 是一个只读控制台。 如果要与系统交互，请使用 马戏团.
马戏团
马戏团 可用于运行 commands 中列出的任何命令。 例如，你可以得到一个
所有观察者的列表，你可以做
$ circusctl 列表
除了支持少数选项之外，您还可以指定端点 马戏团 应该
使用使用 CIRCUSCTL_ENDPOINT 环境变量。
这个 网上 安慰
Circus 带有一个 Web 控制台，可用于管理系统。
Web 控制台可让您：
· 连接到任何正在运行的马戏团系统
· 实时查看进程CPU和内存使用情况
· 添加或终止进程
· 添加新的观察者
注意:
实时 CPU 和内存使用功能使用 stats 套接字。 如果你想
激活它，确保您将连接的 Circus 系统具有统计数据
在其配置中启用：
[马戏表演]
统计数据 = 真
默认情况下，此选项未激活。
web控制台是它自己的包，你需要安装：
$ pip 安装马戏团网络
要启用控制台，请在 Circus ini 文件中添加几个选项：
[马戏表演]
httpd = 真
httpd_host = 本地主机
httpd_端口 = 8080
httpd_主机 和 httpd_端口 是可选的，默认为 本地 和 8080.
如果您想自己运行 Web 应用程序，只需运行 马戏团httpd 脚本：
$马戏团httpd
瓶子服务器正在启动...
聆听 http://localhost：8080 /
按 Ctrl-C 退出。
默认情况下，脚本将在端口 8080 上运行 Web 控制台，但 --port 选项可以
用来改变它。
运用 这些因素包括原料奶的可用性以及达到必要粉末质量水平所需的工艺。 领事
脚本运行后，您可以打开浏览器并访问 http://localhost：8080。 您
应该得到这个屏幕：[图像]
鉴于 Web 控制台已准备好连接到 Circus 系统 端点。 通过
默认端点是 tcp：//127.0.0.1：5555.
一旦你打了 连接，Web 应用程序将连接到 Circus 系统。
登录 Web 控制台后，您应该获得观察者列表和实时状态
两个 Circus 进程（circusd 和 circusd-stats）。
你可以点击每个观察者的状态来切换它 活跃 （绿色）到 过去的
（红色的）。 此更改立即生效，可让您启动和停止观察者。
如果您点击观察者名称，您将获得该特定观察者的网页，
其流程：
在此屏幕上，您可以添加或删除进程，并终止现有进程。
最后但并非最不重要的是，您可以通过单击添加一个全新的观察者 添加 守望者 连结
左侧菜单：.SS 在 Nginx 后面运行
Nginx 可以作为 circus-web 前面的代理和安全层。
注意:
要在 circus-web 中接收实时状态更新和图表，您必须提供 Nginx
具有 websocket 支持的代理解决方案
Nginx的 >= 1.3.13
由于Nginx>=1.3.13 内置websocket支持，所以不需要结合Nginx
使用清漆或 HAProxy。 一个支持 websocket 的 Nginx 配置示例：
上游 circusweb_server {
服务器 127.0.0.1:8080;
}
服务器{
听80;
服务器名称 _;
位置/
代理通行证 http://circusweb_server;
proxy_http_version 1.1；
proxy_set_header 升级 $http_upgrade;
proxy_set_header 连接“升级”；
proxy_set_header 主机 $host;
proxy_set_header X-真实IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for；
proxy_set_header X-Forwarded-Proto http；
proxy_redirect 关闭；
}
！ 〜/媒体/\*(.png|.jpg|.css|.js|.ico)${
别名 /path_to_site-packages/circusweb/media/;
}
}
Nginx的 < 1.3.13
Nginx 版本 < 1.3.13 没有内置 websocket 支持。
要在使用 Nginx < 1.3.13 时为 circus-web 提供 websocket 支持，您可以结合
带有 Varnish 或 HAProxy 的 Nginx。 也就是在circus-web前面的Nginx，用Varnish或者
Nginx 前的 HAProxy。
下面的示例显示了代理所需的组合 Nginix 和 Varnish 配置
circus-web 并提供 websocket 支持。
Nginx的 配置：
上游 circusweb_server {
服务器 127.0.0.1:8080;
}
服务器{
听8001;
服务器名称 _;
位置/
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for；
proxy_set_header 主机 $http_host;
proxy_redirect 关闭；
代理通行证 http://circusweb_server;
}
！ 〜/媒体/\*(.png|.jpg|.css|.js|.ico)${
别名 /path_to_site-packages/circusweb/media/;
}
}
如果您想要更多 Nginx 配置选项，请参阅 http://wiki.nginx.org/HttpProxyModule.
漆 配置：
后端默认{
.host = "127.0.0.1";
.port = "8001";
}
后端套接字{
.host = "127.0.0.1";
.port = "8080";
.connect_timeout = 1s;
.first_byte_timeout = 2s;
. Between_bytes_timeout = 60s;
}
子 vcl_pipe {
如果（req.http.upgrade）{
设置 bereq.http.upgrade = req.http.upgrade;
}
}
子 vcl_recv {
if (req.http.Upgrade ~ "(?i)websocket") {
设置 req.backend = 套接字；
返回（管道）；
}
}
在上面的 Varnish 配置示例中，定义了两个后端。 一个服务于网络
控制台和一个服务于套接字连接。 Web 控制台请求绑定到端口
8001. Nginx 'server' 指令应配置为侦听端口 8001。
Websocket 连接升级并直接通过管道传输到 circushttpd 进程监听
在 Varnish 的 8080 端口上。 即绕过 Nginx 代理。
Ubuntu
从版本 13.10 (俏皮), Ubuntu 包含了 Nginx 和它自己的 websocket 支持
存储库。 老版本可以从Nginx官方安装Nginx>=1.3.13
稳定的 PPA，如下所示：
sudo apt-get 安装 python-software-properties
须藤添加-apt-repository ppa:nginx/stable
sudo易于得到更新
sudo apt-get安装nginx
nginx -v
密码保护 马戏团httpd
如安全页面中所述，运行 马戏团httpd 很不安全。 我们不提供
Circus 本身的任何安全性，但您可以通过以下方式在 NGinx 级别保护您的控制台
运用 http://wiki.nginx.org/HttpAuthBasicModule
计费示例：
位置/
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for；
proxy_set_header 主机 $http_host;
proxy_set_header X-Forwarded-Host: $http_host;
proxy_set_header X-Forwarded-Proto: $scheme;
proxy_redirect 关闭；
代理通行证 http://127.0.0.1：8080；
auth_basic "受限";
auth_basic_user_file /路径/到/htpasswd；
}
这个 密码 文件包含用户和他们的密码，当出现密码提示时会弹出
您访问控制台。
您可以使用 Apache 的 htpasswd 脚本对其进行编辑，或者使用它们在以下位置提供的 Python 脚本：
http://trac.edgewall.org/browser/trunk/contrib/htpasswd.py
但是，对于结合使用 HTTP 身份验证和
WebSockets（服务器将抛出 HTTP 401 错误代码）。 解决方法是禁用此类
socket.io 服务器的身份验证。
示例（需要在之前的规则之前添加）：
位置/socket.io {
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for；
proxy_set_header 主机 $http_host;
proxy_set_header X-Forwarded-Host: $http_host;
proxy_set_header X-Forwarded-Proto: $scheme;
proxy_redirect 关闭；
代理通行证 http://127.0.0.1：8080；
}
当然，这只是保护您的 Web 控制台的一种方法，您可以使用许多其他方法
技术。
扩展 这些因素包括原料奶的可用性以及达到必要粉末质量水平所需的工艺。 卷筒纸 领事
我们选了 瓶 构建 webconsole，主要是因为它是一个非常小的框架
没有多大作用。 通过查看 Web 控制台的代码，您最终会发现
很容易理解。
这是它的拆分方式：
· 马戏团httpd.py 文件包含“视图”定义和一些代码来处理
套接字连接（通过 socketio）。
· 这 控制器.py 包含一个负责进行通信的类
与马戏团控制器。 它允许在定义时有一个更好的高级 API
网络服务器。
如果您想在 Web 控制台中添加功能，您可以重用现有的代码。 一个
您可以使用一些工具来简化流程：
·有一个 渲染模板 函数，它接受你传递给它的命名参数和
将它们传递给模板渲染器并返回生成的 HTML。 它也通过一些
附加变量，例如会话、马戏团版本和客户端（如果已定义）。
· 如果你想根据它的结果运行命令和 doa 重定向，你可以使用
这些因素包括原料奶的可用性以及达到必要粉末质量水平所需的工艺。 运行命令 函数，它将可调用对象作为第一个参数，以防万一
成功和重定向网址。
这个 统计命名空间 类负责管理 websocket 通信
服务器端。 它的文档应该可以帮助您了解它的作用。
工进 - 插座
Circus 可以绑定网络套接字并像处理进程一样管理它们。
主要思想是由 Circus 创建的一个子进程来运行观察者的一个
命令可以从所有打开的文件描述符继承。
这就是 Apache 或 Unicorn 以及许多其他工具的工作方式。
目标
由 Circus 管理套接字的目标是能够管理网络应用程序
在 Circus 中与其他应用程序完全一样。
例如，如果您将 Circus 与 袜子 -- 一个WGSI服务器，你可以得到一个非常快的
网络服务器运行和管理 “网络 工人” 在马戏团，就像在其他任何地方一样
的过程。
从网络应用程序本身分离套接字管理提供了很多
扩展和管理堆栈的机会。
工艺设计
该功能的要点是通过绑定套接字并开始监听它来完成的
马戏团:
进口插座
袜子 = socket.socket（家庭，类型）
袜子绑定（（主机，端口））
袜子听（积压）
fd = sock.fileno()
Circus 然后跟踪所有打开的 fds，并让它作为子进程运行
如果他们愿意，可以访问它们。
如果您创建了一个打算在 Circus 中运行的小型 Python 网络脚本，它可以
看起来像这样：
进口插座
导入系统
fd = int(sys.argv[1]) # 从马戏团获取 FD
袜子 = socket.fromfd(fd, FAMILY, TYPE)
# 一次处理一个请求
而True：
conn, addr = sock.accept()
请求 = 连接接收(1024)
.. 做一点事 ..
conn.sendall（响应）
conn.close()
然后 Circus 可以这样运行：
[马戏表演]
检查延迟 = 5
端点 = tcp://127.0.0.1:5555
pubsub_端点 = tcp://127.0.0.1:5556
stats_endpoint = tcp://127.0.0.1:5557
[观察者：假人]
cmd = mycoolscript $(circus.sockets.foo)
use_sockets = 真
预热延迟 = 0
进程数 = 5
[套接字：foo]
主机 = 127.0.0.1
端口 = 8888
$(circus.sockets.foo) 创建套接字后，将被 FD 值替换，并且
绑定在 8888 端口.
注意:
从 Circus 0.8 开始，有一种替代语法可以避免与某些
配置解析器。 你可以写：
(((circus.sockets.foo))
真实世界 例子
袜子 如果你想运行你的 WSGI 应用程序，它是完美的马戏团伙伴。
安装后，运行 5 迈因海德 工人可以通过创建一个套接字和
称呼 袜子 在工人中命令，像这样：
[马戏表演]
端点 = tcp://127.0.0.1:5555
pubsub_端点 = tcp://127.0.0.1:5556
stats_endpoint = tcp://127.0.0.1:5557
[观察者：网络]
cmd = chausette --fd $(circus.sockets.web) --backend meinheld mycool.app
use_sockets = 真
进程数 = 5
[套接字：网络]
主机 = 0.0.0.0
端口 = 8000
我们还没有发布基准测试，而是一个由 Circus 管理的带有 Gevent 或
Meinheld 后端与任何 pre-fork WSGI 服务器一样快。
运用 内建的 插件
Circus 带有一些内置插件。 本节介绍这些插件及其
配置选项。
统计数据
使用 设置为“circus.plugins.statsd.StatsdEmitter”
应用名称
用于标识要将统计信息发送到的存储桶前缀的名称（它将是
前缀为 马戏表演。 并以 .观察者)
主持人 将 statds 数据发布到的主机
端口 statsd 守护进程监听的端口
采样率
如果您更喜欢与 1 不同的采样率，则可以在此处进行设置
完整统计
Statsd 插件的扩展，也发布进程统计信息。 因此它
具有与 Statsd 和以下相同的配置选项。
使用 设置 马戏团.plugins.statsd.FullStats
循环速率
插件应以秒为单位询问统计信息的频率。 默认值：60。
Redis观察者
这个服务为你观察一个redis进程，将信息发布到statsd
并提供在给定的超时时间内没有反应时重新启动观察者。 这个插件
过程需要在牛奶或乳清产品在管式降膜蒸发器中浓缩至约XNUMX%固体含量之前，进行初始的热处理和巴氏杀菌步骤。 重新分配 跑步。
它与 statsd 具有相同的配置，并添加了以下内容：
使用 设置 circus.plugins.redis_observer.RedisObserver
循环速率
插件应以秒为单位询问统计信息的频率。 默认值：60。
redis_url
要检查的数据库作为 redis url。 默认值：“redis://localhost:6379/0”
超时
请求在被视为关闭之前可以花费的超时时间（以秒为单位）。
默认为5。
重启超时
请求超时时要重新启动的进程的名称。 无需重启
未给出时触发。 默认值：无。
HTTPObserver
该服务通过定期 ping 某个网站来为您观察 http 进程。
与 redis 观察者类似，它提供在错误时重新启动观察者。 这个需要
龙卷风 跑步。
它与 statsd 具有相同的配置，并添加了以下内容：
使用 设置 马戏团.plugins.http_observer.HttpObserver
循环速率
插件应以秒为单位询问统计信息的频率。 默认值：60。
检查网址
要检查的网址。 默认： http://localhost/
超时
请求在被视为关闭之前可以花费的超时时间（以秒为单位）。
默认为10。
重新启动错误
请求超时或返回任何内容时要重新启动的进程的名称
其他类型的错误。 未给出时不会触发重新启动。 默认值：无。
资源观察者
此服务监视给定进程的资源并在以下情况下触发重新启动
它们经常连续超过某些限制。
它与 statsd 具有相同的配置，并添加了以下内容：
使用 设置 马戏团.plugins.resource_watcher.ResourceWatcher
循环速率
插件应以秒为单位询问统计信息的频率。 默认值：60。
守望者
这个资源观察者应该照顾的观察者。 （以前称为
服务 但是 服务 现在已弃用）
最大处理器
一个进程允许消耗的最大 CPU（以 % 为单位）。 默认值：90
最小 cpu
一个进程应该消耗的最小 CPU（以 % 为单位）。 默认值：无（无最小值）
您可以将 min_cpu 设置为 0（零），在这种情况下，如果一个进程完全消耗
0% cpu，它会触发超出限制。
最大内存
允许此观察者的一个进程消耗的内存量。 默认：
90. 如果未指定单位，则该值以 % 为单位。 示例：50 如果一个单位是
指定，该值以字节为单位。 支持的单位有 B、K、M、G、T、P、E、Z、Y。
示例：250M
最小内存
这个观察者的一个进程应该消耗的最小内存。 默认值：无（无
最低限度）。 如果未指定单位，则该值以 % 为单位。 示例：50 如果一个单位是
指定，该值以字节为单位。 支持的单位有 B、K、M、G、T、P、E、Z、Y。
示例：250M
健康阈值
运行状况是观察者进程的 CPU 和内存的平均值（以 % 为单位）
允许消费（%）。 默认值：75
最大计数
这些限制（每个限制单独计算）的频率是多少？
在触发重新启动之前超出。 默认值：3
计费示例：
[马戏表演]
; ......
[观察者：节目]
cmd = 睡眠 120
[插件：myplugin]
使用 = circus.plugins.resource_watcher.ResourceWatcher
观察者 = 程序
最小 CPU = 10
最大 CPU = 70
最小内存 = 0
最大内存 = 20
看门狗
绑定 udp 套接字并等待看门狗消息的插件。 对于“看门狗”
进程，如果它们在特定时间内不发送心跳，看门狗将杀死它们
由 loop_rate * max_count 实现的时间段。 （马戏团会自动
重新启动观察者中丢失的进程）
每个被监控的进程应该至少以 loop_rate 发送 udp 消息。 UDP
消息格式是一行文本，解码使用 消息正则表达式 范围。 心跳
消息必须至少包含发送消息的进程的 pid。
被监控的观察者列表由参数决定 观察者正则表达式 ，在
组态。
配置参数：
使用 设置 马戏团.plugins.watchdog.WatchDog
循环速率
看门狗循环速率（以秒为单位）。 在每个循环中，WatchDog 都会寻找“死”
流程。
观察者正则表达式
正则表达式，用于匹配应由看门狗监控的观察者名称
（默认： .* 所有观察者都受到监控）
消息正则表达式
用于解码 udp 中接收到的心跳消息的正则表达式（默认：
^(?P .*);(?P .*)$) 默认格式是简单的文本消息：
pid；时间戳
最大计数
在重新启动之前没有收到任何心跳的最大循环次数
进程（默认：3）
ip 看门狗将绑定的 ip（默认值：127.0.0.1）
端口 看门狗将绑定的端口（默认值：1664）
扑
当一个工人重启太频繁时，我们说它是 扑. 这个插件会跟踪
的工人重新启动并停止相应的观察者，以防它摆动。 这
插件可用于自动停止不断重启的工作人员，因为
他们工作不正常。
使用 设置 马戏团.plugins.flapping.Flapping
尝试
进程可以重新启动的次数，在 窗口 几秒钟，在我们之前
认为它在摆动（默认值：2）
窗口 以秒为单位的时间窗口来测试扑动。 如果进程重新启动更多
比 尝试 在这个时间窗口内，我们认为这是一个扑朔迷离的过程。
（默认：1）
重试
以秒为单位的时间，直到我们尝试重新启动一个已经被执行的进程
扑。 （默认：7）
最大重试
在此之前，我们尝试启动一个一直在抖动的进程的次数
我们放弃并停止整个观察者。 （默认值：5）设置为 -1 以禁用
max_retry 并无限期重试。
要积极。 定义插件是否处于活动状态（默认值：True）。 如果全局标志是
设置为 False，插件不启动。
选项可以在观察者部分使用 扑。 字首。 例如，
这是您如何配置特定的 最大重试 nginx 的价值：
[观察者：nginx]
cmd = /路径/到/nginx
拍打.max_retry = 2
[观察者：我的脚本]
cmd = ./my_script.py
; ... 其他观察者
[插件：拍打]
使用 = circus.plugins.flapping.Flapping
最大重试 = 5
命令重载器
当修改他们的命令文件时，这个插件将重新启动观察者。 它的工作原理
检查修改时间和指向的文件的路径 CMD 选项每
循环速率 秒。 这在开发工作进程时可能很有用，甚至对于热
生产中的代码升级。
使用 设置 马戏团.plugins.command_reloader.CommandReloader
循环速率
插件应该在几秒钟内检查修改的频率。 默认值：1。
部署
虽然可以使用 circusd 命令管理 Circus 守护进程，但使用它更容易
开机启动。 如果您的系统支持 Upstart，您可以在
/etc/init/circus.conf。
从文件系统和网络设备启动 IFACE=lo
在运行级别停止 [016]
重生
执行 /usr/local/bin/circusd /etc/circus/circusd.ini
这假设 circusd.ini 位于 /etc/circus/circusd.ini。 重启后，你
可以使用 service 命令控制 circusd：
# 服务马戏团开始/停止/重启
如果你的系统支持 systemd，你可以在下面创建这个 systemd 单元文件
/etc/systemd/system/circus.service。
[单元]
说明=马戏团流程管理器
after=syslog.target network.target nss-lookup.target
[服务]
类型=简单
ExecReload=/usr/bin/circusctl 重载
ExecStart=/usr/bin/circusd /etc/circus/circus.ini
重启=总是
RestartSec = 5
[安装]
WantedBy = default.target
如果您运行以下 daemon-reload 命令，则不需要重新启动：
# systemctl --system 守护进程重新加载
然后可以通过以下方式管理马戏团：
# systemctl 开始/停止/状态/重新加载马戏团
食谱
本节将包含部署 Circus 的方法。 在那之前你可以看看皮特的
木偶 食谱 或在雷米 厨师 食谱
教皇 流程 核心
流程管理器常见的一个问题是您无法重新启动流程管理器
无需重新启动它管理的所有进程。 这使得部署一个
Circus 的新版本或它所依赖的任何库的新版本。
如果您使用的是 Unix 类型的系统，Circus 可以使用 Papa 进程内核。 使用时，爸爸
将创建一个长期存在的守护进程，作为任何进程和套接字的主机
你用它创造。 如果马戏团关闭，Papa 将维护它主持的所有内容。
设置
首先安装 爸爸 和 设置程序标题 模块：
pip安装爸爸
pip 安装 setproctitle
这个 设置程序标题 模块是可选的。 如果存在，它将用于重命名 Papa 守护进程
HPMC胶囊 最佳 和 ps 类似于“来自 circusd 的爸爸守护进程”。 如果不安装
设置程序标题 模块，该标题将是启动它的进程的命令行。
很混乱。
安装好爸爸后，添加 使用爸爸=真 到您的关键进程和套接字。
通常，您希望将堆栈中的所有进程都存放在 Papa 中，而不是
Circus 支持进程，例如flapping 和stats 插件。
[马戏表演]
日志级别 = 信息
[观察者：nginx]
cmd = /usr/local/nginx/sbin/nginx -p /Users/scottmax/Source/service-framework/Common/conf/nginx -c /Users/scottmax/Source/service-framework/Common/conf/nginx/nginx .conf
预热延迟 = 3
优雅超时 = 10
最大重试 = 5
单身=真
send_hup = 真
停止信号 = 退出
stdout_stream.class = 文件流
stdout_stream.filename = /var/logs/web-server.log
标准输出流.max_bytes = 10000000
stdout_stream.backup_count = 10
stderr_stream.class = 文件流
stderr_stream.filename = /var/logs/web-server-error.log
stderr_stream.max_bytes = 1000000
stderr_stream.backup_count = 10
活动 = 真
use_papa = 真
[观察者：记录者]
cmd = /my_service/env/bin/python logger.py 运行
工作目录 = /my_service
优雅超时 = 10
单身=真
停止信号 = INT
stdout_stream.class = 文件流
stdout_stream.filename = /var/logs/logger.log
标准输出流.max_bytes = 10000000
stdout_stream.backup_count = 10
stderr_stream.class = 文件流
stderr_stream.filename = /var/logs/logger.log
stderr_stream.max_bytes = 1000000
stderr_stream.backup_count = 10
优先级 = 50
use_papa = 真
[观察者：web_app]
cmd = /my_service/env/bin/uwsgi --ini uwsgi-live.ini --socket fd://$(circus.sockets.web) --stats 127.0.0.1:809$(circus.wid)
工作目录 = /my_service/web_app
优雅超时=10
停止信号 = 退出
use_sockets = 真
stdout_stream.class = 文件流
stdout_stream.filename = /var/logs/web_app.log
标准输出流.max_bytes = 10000000
stdout_stream.backup_count = 10
stderr_stream.class = 文件流
stderr_stream.filename = /var/logs/web_app.log
stderr_stream.max_bytes = 1000000
stderr_stream.backup_count = 10
hooks.after_spawn = Examples.uwsgi_lossless_reload.children_started
hooks.before_signal = Examples.uwsgi_lossless_reload.clean_stop
hooks.extended_stats = Examples.uwsgi_lossless_reload.extended_stats
优先级 = 40
use_papa = 真
[套接字：网络]
路径 = /my_service/sock/uwsgi
use_papa = 真
[插件：拍打]
使用 = circus.plugins.flapping.Flapping
窗口 = 10
优先级 = 1000
注意:
如果 Papa 进程使用任何套接字，则这些套接字也必须使用 papa。
工艺设计 目标
Papa 的设计在功能和要求方面非常简约。 它确实：
· 启动和停止套接字
· 提供键/值存储
· 启动进程并返回标准输出、标准错误和退出代码
它不是：
· 重启进程
· 提供一种停止进程的方法
· 提供有关进程的任何信息，而不是它们是否仍在运行
Papa 不需要第三方库，因此它可以仅在标准 Python 库上运行。
它可以利用 设置程序标题 包，但仅用于制作标题
更漂亮 ps 和 最佳 并且不是必需的。
该功能已保持在最低限度，因此您永远不需要重新启动
爸爸守护进程。 尽可能多的功能已被推送到客户端库
可能的。 这样，您应该能够为新的客户端功能部署 Papa 的新副本
无需重新启动 Papa 守护进程。 爸爸注定要成为稳定的支柱
不断变化的第 3 方库海洋。
操作
无论您是否使用 Papa，大多数事情都保持不变。 你仍然可以开始和停止
过程。 您仍然可以获得进程的状态和统计信息。 主要改变的是
是当你做 马戏团 退出，所有 Papa 进程都保持运行。 当你
开始 马戏团 备份，这些进程被恢复。
注意:
当进程恢复时， 开始前 和 生成前 钩子被跳过。
记录
当 Circus 关闭时，Papa 将在每个进程中存储多达 2M 的输出。 然后它会
开始转储最旧的数据。 当你重新启动 Circus 时，这个缓存的输出会很快
检索并发送到输出流。 爸爸要求收到输出
已确认，因此您不应在关机期间丢失任何输出。
不仅如此，Papa 还保存了输出的时间戳。 马戏团已增强为
利用时间戳数据（如果存在）。 因此，如果您将输出写入日志文件
或者在某个地方，您的时间戳应该都是正确的。
问题
如果使用 增量 or 递减 命令更改观察者的进程计数，这将
重置为 INI 文件中指定的级别时 马戏团 重新启动。
另外，我遇到了组合的问题 复制环境 和 的virtualenv。 您可以
请注意，上面的 INI 示例通过显式路径规避了这个问题。
远程登录 接口
爸爸有一个基本的命令行界面，您可以通过 telnet 访问：
远程登录本地主机 20202
帮助
马戏团 HPMC胶囊 开发
运用 马戏团 as a 图书馆
Circus 提供了高级类和函数，可以让您在
您自己的应用程序。
例如，如果你想永远运行四个进程，你可以这样写：
从马戏团进口 get_arbiter
myprogram = {"cmd": "python myprogram.py", "numprocesses": 4}
仲裁者 = get_arbiter([我的程序])
尝试：
仲裁者.start()
最后：
仲裁者.stop()
此代码段将运行四个实例 我的程序 并为你观察它们，重新启动它们
如果他们意外死亡。
要了解更多信息，请参阅图书馆
扩展 马戏团
很容易扩展 Circus 以创建更复杂的系统，通过聆听所有
马戏团 事件通过其发布/订阅通道，并通过命令驱动它。
例如，这就是扑翼功能的工作原理：它侦听所有正在死亡的进程，
测量它发生的频率，并在太多重启后停止受牵连的观察者
尝试。
Circus 自带了一个插件系统来帮助你编写这样的扩展，还有一些内置的
您可以重复使用的插件。 见插件。
您还可以通过使用更微妙的启动和关闭行为 挂钩 系统
这将允许您在启动某些进程之前和之后运行任意代码或
停了下来。 见钩子。
最后但并非最不重要的是，您还可以添加新命令。 请参阅添加cmds。
开发工具 文件记录 索引
马戏团 自学资料库
Circus 包由高级 获取仲裁者() 函数和许多类。 在
大多数情况下，使用高级函数应该就足够了，因为它创建了所有
是 Circus 运行所必需的。
如果您需要比
组态。
这个 获取仲裁者 function
获取仲裁者() 只是各种马戏班之上的便利。 它创造了一个
仲裁者（类 仲裁者) 实例与提供的选项，依次运行单个
守望者 与一个 流程.
马戏团.get_arbiter()
计费示例：
从马戏团进口 get_arbiter
仲裁者 = get_arbiter([{"cmd": "myprogram", "numprocesses": 3}])
尝试：
仲裁者.start()
最后：
仲裁者.stop()
精品团课
Circus 提供了一系列可用于实现您自己的流程管理器的类：
· 流程: 包装一个正在运行的进程并在它之上提供一些帮助程序。
· 守望者: 运行多个实例 流程 反对同一个命令。 管理死亡和
进程的生命周期。
· 仲裁者: 管理几个 守望者.
程 circus.process.Process（名称， 宽， CMD， 参数=无， 工作目录=无， 壳=假，
uid=无， gid=无， 环境=无， rlimits=无， 可执行=无， use_fds=假， 观察者=无，
产卵=真， pipe_stdout=真， pipe_stderr=真， close_child_stdout=假，
close_child_stderr=假）
包装一个过程。
选项：
· WID：进程唯一标识符。 该值将用于替换 $WID
命令行中的字符串（如果存在）。
· CMD: 要运行的命令。 可能包含任何可用的变量
被传递给这个类。 它们将使用 python 格式语法替换。
· ARGS：要运行的命令的参数。 可以是列表或字符串。 如果 ARGS is
一个字符串，它被分割使用 shlex.split() 函数. 默认为无。
· 可执行: 当给出可执行文件时，args 序列中的第一项
从...获取 CMD 大多数程序仍将其视为命令名称，即
然后可以与实际的可执行文件名称不同。 变成显示器
实用程序中执行程序的名称，例如 ps.
· 工作目录: 运行命令的工作目录。如果未提供，将
默认为当前工作目录。
· 壳：如果 真, 将在 shell 环境中运行命令。 假 默认情况下。
警告： Free Introduction is a 安全 风险.
· 的uid: 如果给定，则是运行命令时应使用的用户 ID 或名称。 目前
uid 是默认值。
· GID: 如果给定，是命令应该运行的组 ID 或名称。 目前
gid 是默认值。
· ENV：包含命令将运行的环境变量的映射。
可选的。
· 限制: 包含将在 rlimit 名称和值之前设置的映射
命令运行。
· 使用_fds: 如果为 True，则不会关闭子进程中的 fds。 必须设置为
如果 stdout 或 stderr 被重定向，则在 Windows 上为 True。 默认值：假。
· 管道标准输出: 如果为 True，将在标准输出上打开一个 PIPE。 默认值：真。
· 管道标准错误: 如果为 True，将在 stderr 上打开一个 PIPE。 默认值：真。
· 关闭子标准输出: 如果为 True，则将子进程的标准输出重定向到 /dev/null
在叉子之后。 默认值：假。
· close_child_stderr: 如果为 True，则将子进程的标准输出重定向到 /dev/null
在叉子之后。 默认值：假。
年龄（） 以秒为单位返回进程的年龄。
孩子们（）
返回子 pid 列表。
信息（） 返回进程信息。
返回的信息是与这些键的映射：
· 内存信息1：以字节为单位的常驻集大小内存 (RSS)
· 内存信息2: 以字节为单位的虚拟内存大小 (VMS)。
· CPU: % cpu 使用率。
· 成员: % 的内存使用量。
· 时间：以秒为单位的进程 CPU（用户 + 系统）时间。
· PID: 进程号。
· 用户名: 拥有进程的用户名。
· 不错: 处理好度（在 -20 到 20 之间）
· CMDLINE: 运行进程的命令行。
is_child(pid)
返回 True 是给定的 PID 是那个过程的孩子。
PID 返回 PID
发送信号（*参数， **千瓦)
发送信号 SIG 到过程。
send_signal_child(*args, **千瓦)
发送信号 信号 给孩子 PID.
send_signal_children(*args, **千瓦)
发送信号 信号 给所有孩子。
状态 将进程状态作为常量返回
· 跑步
· 死亡或僵尸
· 不存在的
· 其他
斯特德 返回 标准输出 流
标准输出 返回 标准输出 流
停止（*参数， **千瓦)
停止进程并关闭 stdout/stderr
如果对应的进程还在的话（一般已经被杀掉了
观察者），发送 SIGTERM，然后在 1 秒后发送 SIGKILL。
关闭过程（SIGTERM 然后 SIGKILL）通常由
观察者。 所以如果进程还在这里，这是一种不良行为
因为这里不会尊重优雅的超时。
计费示例：
>>> from circus.process 导入流程
>>> process = Process('top', 'top', shell=True)
>>> process.age()
3.0107998847961426
>>> process.info()
'顶部：6812 N/A tarek Zombie N/AN/AN/AN/AN/A'
>>> 进程.status
1
>>> process.stop()
>>> 进程.status
2
>>> process.info()
'没有这样的过程（停止？）'
程 circus.watcher.Watcher（名字， CMD， 参数=无， 进程数=1， 预热延迟=0.0,
工作目录=无， 壳=假， shell_args=无， uid=无， 最大重试=5， gid=无，
send_hup=假， 停止信号=15， stop_children=假， 环境=无， 优雅超时=30.0，
prereload_fn=无， rlimits=无， 可执行=无， stdout_stream=无， stderr_stream=无，
优先级=0， 循环=无， 单身=假， use_sockets=假， copy_env=假，
复制路径=假， 最大年龄=0， 最大年龄方差=30， 钩子=无， 重生=真， 自动启动=真，
on_demand=假， 虚拟环境=无， close_child_stdout=假， close_child_stderr=假，
virtualenv_py_ver=无， 使用_papa=假， **选项）
管理给定命令的进程列表的类。
选项：
· 姓名: 给观察者的名字。 用于唯一标识它。
· CMD: 要运行的命令。 可能含有 $WID，它将被替换为 WID.
· ARGS：要运行的命令的参数。 可以是列表或字符串。 如果 ARGS is
一个字符串，它被分割使用 shlex.split() 函数. 默认为无。
· 进程数：要运行的进程数。
· 工作目录: 运行命令的工作目录。如果未提供，将
默认为当前工作目录。
· 壳：如果 真, 将在 shell 环境中运行命令。 假 默认情况下。
警告： Free Introduction is a 安全 风险.
· 的uid: 如果给定，则是运行命令时应使用的用户 ID 或名称。 目前
uid 是默认值。
· GID: 如果给定，是命令应该运行的组 ID 或名称。 目前
gid 是默认值。
· 发送_hup: 如果为 True，将通过发送 SIGHUP 信号来完成进程重新加载。
默认为假。
· 停止信号：停止进程时发送的信号。 默认为 SIGTERM。
· 停止子项： 发送 停止信号 也给孩子们。 默认为假。
· ENV：包含命令将运行的环境变量的映射。
可选的。
· 限制: 包含将在 rlimit 名称和值之前设置的映射
命令运行。
· 标准输出流：定义流程标准输出流的映射。 默认值
无。
选修的。 提供时， 标准输出流 是一个包含最多三个键的映射：
· 程: 流类。 默认为 马戏团.stream.FileStream
· 文件名: 文件名，如果使用 FileStream
· 最大字节数: 最大文件大小，之后将打开一个新的输出文件。 默认值
到 0，这意味着没有最大大小（仅适用于 FileStream）。
· 备份计数: 旋转文件时要保留多少备份
max_bytes 参数。 默认为 0，这意味着不进行备份（仅
适用于 FileStream)
此映射将用于创建指定类的可调用流。
可调用对象接收到的每个条目都是一个映射，其中包含：
· PID - 进程pid
· 姓名 - 流名称（斯特德 or 标准输出)
· data - 数据
这在 Windows 上不受支持。
· 标准错误流：定义进程stderr的流的映射。 默认值
无。
选修的。 提供时， 标准错误流 是一个包含最多三个键的映射：
- 程: 流类。 默认为 马戏团.stream.FileStream - 文件名提供两款控制器：一款是
文件名，如果使用 FileStream - 最大字节数: 最大文件大小，之后是一个新的
输出文件是
打开。 默认为 0，这意味着没有最大大小（仅适用于
文件流）
· 备份计数: 旋转文件时要保留多少备份
max_bytes 参数。 默认为 0，这意味着不进行备份（仅
适用于 FileStream）。
此映射将用于创建指定类的可调用流。
可调用对象接收到的每个条目都是一个映射，其中包含：
· PID - 进程pid
· 姓名 - 流名称（斯特德 or 标准输出)
· data - 数据
这在 Windows 上不受支持。
· 优先 -- 定义观察者优先级的整数。 当仲裁者做
对所有观察者的一些操作，它会用这个字段对它们进行排序，从
从大到小。 （默认值：0）
· 独生子 -- 如果为 True，则此观察者只有一个进程。 （默认：假）
· 使用套接字 -- 如果为 True，进程将继承文件描述符，因此可以
重用由 circusd 打开的套接字。 （默认：假）
· 一经请求 -- 如果为 True，进程将仅在第一次连接时启动
到套接字（默认值：False）
· 复制环境 -- 如果为True，马戏团运行的环境将是
复制给工人。 这在 Windows 上默认为 True，因为您无法运行
任何没有 系统根 多变的。 （默认：假）
· 复制路径 -- 如果为真，则 circusd 系统路径 通过发送到进程 路径.
您必须激活 复制环境 HPMC胶囊 复制路径 去工作。 （默认：假）
· 最大年龄: 如果在大约 max_age 秒后设置，则进程将替换为新的
一。 （默认值：0，禁用）
· 最大年龄方差: 可以添加到 max_age 的最大秒数。
这个额外的值是为了避免同时重新启动所有进程。 一个
进程将存在于 max_age 和 max_age + max_age_variance 秒之间。
· 挂钩: 回调函数，用于挂钩 watcher 的启动和关闭
的过程。 挂钩 是一个字典，其中每个键是钩子名称，每个值是一个
具有可调用名称或可调用本身和布尔标志的 2 元组
指示是否不应忽略钩子中发生的异常。 可能的
钩子名称的值： 开始前, 开始后, 生成前, 产卵后,
前_停止, 停止后., 前信号, 后信号 or 扩展统计.
· 选项 -- 工人的额外选择。 在配置中找到的所有选项
例如文件，在这个映射中传递——这可以被插件用于
特定于观察者的选项。
· 重生 -- 如果设置为 False，则观察者处理的进程将不会被
自动重生。 （默认：真）
· 的virtualenv -- virtualenv 的根目录。 如果提供，观察者将
加载环境以执行。 （默认：无）
· 关闭子标准输出: 如果为 True，则在分叉后关闭标准输出。 默认值：假。
· close_child_stderr: 如果为 True，则在 fork 之后关闭 stderr。 默认值：假。
· 使用_papa: 如果为 True，则为该进程使用 papa 进程内核。 默认值：假。
kill_process（*参数， **夸格）
杀死进程（stop_signal，graceful_timeout 然后 SIGKILL）
kill_processes（*参数， **夸格）
杀死所有进程（stop_signal、graceful_timeout 然后 SIGKILL）
管理进程（*参数， **夸格）
管理流程。
通知事件（主题， 留言）
在事件发布者频道上发布消息
reap_and_manage_processes（*参数， **夸格）
收割和管理流程。
reap_processes（*参数， **千瓦)
获取此观察者的所有进程。
send_signal_child(*args, **千瓦)
给孩子发送信号。
spawn_process（recovery_wid=无）
产卵过程。
如果正常则返回 True，如果观察者必须停止则返回 False
spawn_processes（*参数， **夸格）
产生过程。
程 circus.arbiter.Arbiter（观察者， 端点， pubsub_端点， 检查延迟=1.0，
prereload_fn=无， 上下文=无， 循环=无， 统计数据=假， stats_endpoint=无，
statsd_close_outputs=假， 多播端点=无， 插件=无， 套接字=无，
预热延迟=0, httpd=假， httpd_host='localhost', httpd_端口=8080，
httpd_close_outputs=假， 调试=假， debug_gc=假， ssh_server=无，
proc_name='circusd'， pidfile=无， 日志级别=无， 日志输出=无， loggerconfig=无，
fqdn_prefix=无， umask=无， endpoint_owner=无， papa_endpoint=无）
用于控制观察者列表的类。
选项：
· 观察家 -- Watcher 对象列表
· 端点 -- 控制器 ZMQ 端点
· 发布订阅端点 -- 发布订阅端点
· 统计数据 -- 如果为 True，则运行 circusd-stats 进程（默认值：False）
· 统计端点 -- 统计端点。
· statsd_close_outputs -- 如果 True 将 circusd-stats stdout/stderr 发送到
/dev/null（默认值：False）
· 多播端点 -- circusd 集群自动发现的多播端点
（默认：udp://237.219.251.97:12027）组播地址应该在 224.0.0.0 之间
到 239.255.255.255 和所有集群相同。
· 检查延迟 -- 两个控制器点之间的延迟（默认：1 s）
· 预重载_fn -- 每次重新加载时将执行的可调用（默认值：无）
· 上下文 -- 如果提供，要重用的 zmq 上下文。 （默认：无）
·
循环： if 假如， a zmq.eventloop.ioloop.IOLoop 例
重用。 （默认：无）
· 插件 -- 插件列表。 每个项目都是一个映射：
· 使用 -- 指向插件类的完全限定名称
· 每隔一个值传递给插件 配置 选项
· 插座 -- 套接字的映射。 每个键是套接字名称，每个值是一个
马戏团套接字 班级。 （默认：无）
· 预热延迟 -- 两个观察者启动之间的延迟（以秒为单位）。 （默认值：0）
· httpd的 -- 如果为 True，则运行 circushttpd 进程（默认值：False）
· httpd_主机 -- circushttpd 主机（默认：localhost）
· httpd_端口 -- circushttpd 端口（默认：8080）
· httpd_close_outputs -- 如果为 True，则将 circushttpd stdout/stderr 发送到 /dev/null。
（默认：假）
· 调试 -- 如果为 True，则在标准输出中添加大量调试信息（默认值：False）
· 调试_gc -- 如果为 True，是否将 gc.set_debug(gc.DEBUG_LEAK)（默认值：False）转为 circusd
分析问题（默认：False）
· 进程名称 -- 仲裁进程名称
·
FQDN_前缀 -- a 字首 HPMC胶囊 这些因素包括原料奶的可用性以及达到必要粉末质量水平所需的工艺。 独特的 识别码 of 这些因素包括原料奶的可用性以及达到必要粉末质量水平所需的工艺。 马戏团
集群上的实例。
· 端点所有者 -- unix 用户如果使用 ipc 将端点更改为 chown。
· 爸爸端点 -- papa 进程内核端点
添加_观察者（*参数， **夸格）
添加观察者。
选项：
· 姓名: 要添加的观察者的名称
· CMD: 命令运行。
· Watcher 构造函数中定义的所有其他选项。
get_watcher（名称）
返回观察者 姓名.
进程数（）
返回在所有观察者上运行的进程数。
观察者数（）
返回观察者的数量。
重新加载（*参数， **夸格）
重新加载一切。
运行 预重载_fn() 可调用（如果有），然后优雅地重新加载所有观察者。
开始（*参数， **夸格）
启动所有观察者。
如果在 __init__() 调用期间提供了 ioloop，则启动所有观察者
作为标准协程
如果在 __init__() 调用期间未提供 ioloop（默认），则启动
所有观察者和事件循环（和块在这里）。 在这种模式下方法
不得产生任何东西，因为它被称为标准方法。
参数
cb -- 在所有观察者启动后调用回调，当
尚未提供循环。
撰稿 插件
Circus 带有一个插件系统，可让您与 马戏团.
注意:
稍后我们可能会为插件添加 circusd-stats 支持。
一个插件由两部分组成：
· ZMQ 订阅者发布的所有事件 马戏团
· 一个 ZMQ 客户端发送命令到 马戏团
每个插件都在自定义观察器下作为单独的进程运行。
您可以使用此系统创建的一些插件示例：
·当观察者拍打时发送电子邮件警报的通知系统
·一个记录器
· 根据负载添加或删除进程的工具
· 等等。
Circus 本身带有一些内置插件。
这个 马戏团插件 程
Circus 提供了一个基类来帮助你实现插件： 马戏团.plugins.CircusPlugin
程 circus.plugins.CircusPlugin（端点， pubsub_端点， 检查延迟， ssh_server=无，
**配置）
编写插件的基类。
选项：
· 上下文 -- 要使用的 ZMQ 上下文
· 端点 -- circusd ZMQ 端点
· 发布订阅端点 -- circusd ZMQ 发布/订阅端点
· 检查延迟 -- 配置的检查延迟
· 配置 -- 免费配置映射
调用（命令， **道具）
将命令发送到 马戏团
选项：
· 命令 -- 调用命令
· 道具 -- 添加到调用中的关键字参数
返回发回的 JSON 映射 马戏团
演员（命令， **道具）
即发即忘的命令 马戏团
选项：
· 命令 -- 调用命令
· 道具 -- 添加到调用中的关键字参数
句柄初始化（）
在插件启动之前调用 - 在线程上下文中。
handle_recv（数据）
接收由发布的每个事件 马戏团
选项：
· data -- 包含主题和消息的元组。
句柄停止（）
在 Circus 停止插件之前调用。
当由 Circus 初始化时，这个类会创建自己的事件循环来接收所有
马戏团 事件并将它们传递给 处理接收（）. 接收到的数据是一个元组，包含
主题和数据本身。
处理接收（） 必须 由插件实现。
这个 称呼（） 和 投掷（） 方法可以用来与 马戏团 如果你正在构建一个
与守护进程主动交互的插件。
句柄初始化（） 和 句柄停止（） 只是您可以用来初始化和
清理你的代码。 句柄初始化（） 在刚启动的线程内调用。
句柄停止（） 在线程停止并加入之前在主线程中调用。
撰稿 a 插入
让我们编写一个插件，将每个事件发生在一个文件中 马戏团. 需要一个
参数是文件名。
该插件可能如下所示：
从 circus.plugins 导入 CircusPlugin
类记录器（CircusPlugin）：
名称 = '记录器'
def __init__(self, *args, **config):
超级（记录器，自我）.__init__（*args，**配置）
self.filename = config.get('文件名')
self.file = 无
def handle_init（自我）：
self.file = open(self.filename, 'a+', buffering=1)
def 句柄停止（自我）：
self.file.close()
def handle_recv（自我，数据）：
watcher_name, action, msg = self.split_data(数据)
消息字典= self.load_message(味精)
self.file.write('%s %s::%r\n' % (action, watcher_name, msg_dict))
而已 ！ 这个类可以保存在任何包/模块中，只要它可以被看到
蟒蛇。
例如， 记录仪 可以在一个 插件 模块内 我的项目 包。
异步 要求
如果您想进行任何异步操作（例如 Tornado 调用或使用
periodCall) 确保您使用正确的循环。 您一直想使用的循环
是 self.loop，因为它由基类设置。 默认循环通常不一样
因此代码可能不会按预期执行。
试 a 插入
您可以通过命令行运行插件 马戏团插件 命令，由
指定插件完全限定名称：
$ circus-plugin --endpoint tcp://127.0.0.1:5555 --pubsub tcp://127.0.0.1:5556 --config 文件名：circus-events.log myproject.plugins.Logger
[信息] 正在加载插件...
[信息] 端点：'tcp://127.0.0.1:5555'
[信息] 发布/订阅：'tcp://127.0.0.1:5556'
[信息] 开始
另一种运行插件的方法是让 Circus 处理它的初始化。 这是由
添加一个 [插件：NAME] 配置文件中的部分，其中 您的姓名 是一个独特的名字
你的插件：
[插件：记录器]
使用 = myproject.plugins.Logger
文件名 = /var/myproject/circus.log
使用 是强制性的，指向插件的完全限定名称。
当 Circus 启动时，它会创建一个观察者，其中有一个运行指向类的进程，并且
通过该部分中包含的任何其他变量传递给插件构造函数 配置
映射。
您还可以在创建插件时以编程方式添加插件 马戏团.仲裁者.仲裁者 程
或使用 马戏团.get_arbiter()，见图书馆。
表演
由于每个插件都是在自己的进程中加载的，所以它不应该影响整体
只要插件完成的工作不是做太多，系统的性能
调用 马戏团 的过程。
钩
Circus 提供了可用于根据观察者事件触发操作的钩子。 可用的
钩子是：
· 开始前: 在观察者启动之前调用。 如果钩子返回 假 这些因素包括原料奶的可用性以及达到必要粉末质量水平所需的工艺。
启动被中止。
· 开始后: 在 watcher 启动后调用。 如果钩子返回 假 守望者
立即停止并中止启动。
· 生成前: 在观察者产生新进程之前调用。 如果钩子返回 假
观察者立即停止并中止启动。
· 产卵后: 在观察者产生一个新进程后调用。 如果钩子返回 假
观察者立即停止并中止启动。
· 前_停止: 在观察者停止之前调用。 钩子结果被忽略。
· 停止后: 在观察者停止后调用。 钩子结果被忽略。
· 前信号: 在信号发送到观察者进程之前调用。 如果钩
回报 假 不发送信号（除了始终发送的 SIGKILL）
· 后信号: 在信号发送到观察者进程后调用。
· 扩展统计: 当使用extended=True 请求统计信息时调用。 用于添加
特定于流程的统计信息到常规统计信息输出。
例如：
一个典型的用例是控制是否满足所有条件才能启动进程。
假设你有一个运行的观察者 Redis的 和一个运行 Python 脚本的观察者
作品 Redis的. 使用 Circus，您可以使用 优先 选项：
[观察者：队列工作者]
cmd = python -uworker.py
优先级 = 1
[观察者：redis]
cmd = redis 服务器
优先级 = 2
有了这个设置，马戏团将开始 Redis的 首先，然后它将启动队列工作器。
但马戏团并没有真正控制 Redis的 正在运行。 它只是开始
它被要求启动的过程。 我们在这里错过的是一种控制它的方法 Redis的 is
已启动且功能齐全。 控制它的函数可能是：
导入redis
进口时间
def check_redis(*args, **kw):
time.sleep(.5) # 给它一个开始的机会
r = redis.StrictRedis(host='localhost', port=6379, db=0)
r.set('foo', 'bar')
返回 r.get('foo') == 'bar'
此功能可以作为一个插入到 Circus 中 开始前 钩：
[观察者：队列工作者]
cmd = python -uworker.py
hooks.before_start = mycoolapp.myplugins.check_redis
优先级 = 1
[观察者：redis]
cmd = redis 服务器
优先级 = 2
一旦马戏团开始 Redis的 观察者，它将启动 排队工人 观察者，因为
它遵循 优先 订购。 就在启动第二个观察者之前，它会运行
这些因素包括原料奶的可用性以及达到必要粉末质量水平所需的工艺。 检查_redis 函数，如果它返回 假 将中止观察者启动
的过程。
钩 签名
一个钩子必须遵循这个签名：
def hook（观察者，仲裁者，hook_name，**kwargs）：
...
# 如果不返回True，钩子可以改变
# 马戏团的行为（取决于钩子）
返回True
其中 守望者 是 守望者 类实例， 仲裁者 这些因素包括原料奶的可用性以及达到必要粉末质量水平所需的工艺。 仲裁者 一， 钩子名称 钩子
名称和 夸格斯 一些额外的可选参数（取决于钩子类型）。
这个 产卵后 hook 添加 pid 参数：
def after_spawn(观察者, 仲裁者, hook_name, pid, **kwargs):
...
# 如果不返回True，circus 会杀掉进程
返回True
其中 PID 是对应进程的PID。
同样， 前信号 和 后信号 钩子添加pid和signum：
def before_signal_hook（观察者，仲裁者，hook_name，pid，signum，**kwargs）：
...
# 如果你不返回True，马戏团不会发送signum信号
#（总是发送SIGKILL）
返回True
其中 PID 是相应进程的PID和 信号 是对应的信号。
您可以忽略这些但能够使用观察者和/或仲裁者数据和方法可以
在某些钩子中很有用。
请注意，钩子是使用命名参数调用的。 所以使用钩子签名而不
改变参数名称。
这个 扩展统计 钩子有自己的附加参数 夸格斯:
defextended_stats_hook(watcher, arbiter, hook_name, pid, stats, **kwargs):
...
其中 PID 是相应进程的PID和 统计 常规统计数据
回。 将您自己的统计数据添加到 统计. 一个例子在
示例/uwsgi_lossless_reload.py。
作为最后一个例子，这是一个可以处理各种信号的超级钩子：
def super_hook(观察者, 仲裁者, hook_name, **kwargs):
pid = 无
符号 = 无
如果 hook_name 在 ('before_signal', 'after_signal'):
pid = kwargs['pid']
signum = kwargs['signum']
...
返回True
钩 事件
每次运行一个钩子时，它的结果都会在 Circus 中作为事件通知。
有两个与钩子相关的事件：
· 钩子成功: 成功调用了一个钩子。 事件键是 姓名 名称，如果
事件，以及 次: 事件的日期。
· 钩子失败: 一个钩子失败了。 事件键是 姓名 如果事件的名称， 次:
事件的日期和 错误：事件中发生的异常（如果有）。
添加 新 命令
我们试图使添加新命令尽可能简单。
你需要做三件事：
1.创建一个 你的命令.py 文件下 马戏团/命令/.
2. 在那里实现一个类，使用预定义的方法
3.在新命令中添加 马戏团/命令/__init__.py.
假设我们要添加一个命令来返回当前正在使用的观察者的数量，
我们会做这样的事情（广泛评论以允许您关注更多
容易地）：
from circus.commands.base 导入命令
从 circus.exc 导入参数错误，消息错误
类 NumWatchers（命令）：
"""描述类在这里做什么是一个很好的做法。
看看其他命令，看看我们是如何格式化的
本文。 它将自动包含在文档中，
所以不要害怕详尽无遗，这就是它所做的
为。
“”“
# 所有命令都继承自 `circus.commands.base.Command`
# 您需要指定一个名称，以便我们以某种方式找回命令
name = "numwatchers"
# 将等待设置为 True 或 False 以定义您的默认行为
# - 如果waiting为True，则命令同步运行，客户端可能会得到
# 返回结果。
# - 如果waiting 为False，则命令立即在服务器和客户端上异步运行
# 得到一个 'ok' 的响应
#
# 默认情况下，命令设置为waiting = False
等待 = 真
＃ 选项
options = [('', 'optname', default_value, 'description')]
属性 = ['foo', 'bar']
# 属性列出了强制性的命令参数。 如果它们是
# 不提供，则抛出错误
def执行（自我，仲裁者，道具）：
# execute 方法是命令的核心：把所有的都放在这里
# 命令的逻辑并返回一个包含你的值的字典
# 想要返回，如果有的话
返回 {"numwatchers": arbiter.numwatchers()}
def console_msg（自我，味精）：
# msg 是execute 方法返回的内容。
# 此方法用于格式化控制台的响应（它是
# 例如由 circusctl 用于打印其消息）
返回“将显示的字符串”
def 消息(self, *args, **opts):
# 消息处理控制台输入。
# 此方法用于将控制台参数映射到命令
＃ 选项。 （例如在通过调用命令时使用它
#马戏团）
# 如果函数缺失，将抛出 NotImplementedError
数字参数 = 1
如果不是 len(args) == numArgs：
raise ArgumentError('参数个数无效。')
其他：
opts['optname'] = args[0]
返回 self.make_message(**opts)
def 验证（自我，道具）：
# 此方法用于验证传递给
# 命令是正确的。 应抛出 ArgumentError 以防万一
# 传递的参数中有错误（例如，如果他们
# 不匹配在一起。
# 如果他们的内容有问题，MessageError
# 应该被抛出。 这个方法可以修改props的内容
# dict，它会被传递到之后执行。
使用 VHDL 语言编写 例 例子
本章介绍了几个用例，让您了解如何在您的应用程序中使用 Circus
环境。
运行 a WSGI 应用
使用 Circus 运行 WSGI 应用程序非常有趣，因为您可以观看和管理
您的 卷筒纸 工人 运用 马戏团顶, 马戏团 或网络界面。
这可以通过使用 Circus 插座来实现。 查看为什么使用circussockets。
让我们举一个最小的例子 金字塔 应用程序：
从 pyramid.config 导入配置器
从金字塔.响应导入响应
def hello_world（请求）：
return Response('Hello %(name)s!' % request.matchdict)
配置 = 配置器（）
config.add_route('hello', '/hello/{name}')
config.add_view(hello_world, route_name='hello')
应用程序 = config.make_wsgi_app()
将此脚本保存到 应用程序 文件，然后安装这些项目：
$ pip 安装金字塔
$ pip 安装 chaussette
接下来，确保您可以使用以下命令运行 Pyramid 应用程序 袜子 控制台脚本：
$ chausette app.application
申请是
在本地主机上服务：8080
使用作为后端
并检查您是否可以访问它 http://localhost:8080/你好/塔瑞克
现在您的应用程序已启动并运行，让我们创建一个 Circus 配置文件：
[马戏表演]
检查延迟 = 5
端点 = tcp://127.0.0.1:5555
pubsub_端点 = tcp://127.0.0.1:5556
stats_endpoint = tcp://127.0.0.1:5557
[观察者：网络工作者]
cmd = chausette --fd $(circus.sockets.webapp) app.application
use_sockets = 真
进程数 = 3
[套接字：webapp]
主机 = 127.0.0.1
端口 = 8080
该文件告诉 Circus 在端口上绑定一个套接字 8080 并运行 袜子 那个工人
socket -- 通过传递它的 fd。
保存到 服务器配置文件 并尝试使用 马戏团
$ 马戏团服务器.ini
[INFO] 在 pid 8971 上启动 master
[INFO] 套接字已启动
[INFO] circusd-stats 开始
[INFO] webapp 已启动
[INFO] 仲裁器现在正在等待命令
确保您仍然可以打开应用程序 http://localhost:8080/你好/塔瑞克.
恭喜 ！ 你有一个运行 3 个 worker 的 WSGI 应用程序。
您可以运行 circushttpd 或 cli，并享受 Circus 管理。
运行 a Django的 应用
运行 Django 应用程序与运行 WSGI 应用程序完全一样。 使用
路径 导入项目所在的目录，该目录包含
包含 settings.py 的目录（对于 Django 1.4+，此目录包含 manage.py）
:
[套接字：dwebapp]
主机 = 127.0.0.1
端口 = 8080
[观察者：dwebworker]
cmd = chaussette --fd $(circus.sockets.dwebapp) dproject.wsgi.application
use_sockets = 真
进程数 = 2
[环境：dwebworker]
PYTHONPATH = /path/to/parent-of-dproject
如果你需要通过 DJANGO_SETTINGS_MODULE 例如，对于后端工作人员，您可以
通过那也尽管 ENV 配置选项：
[观察者：dbackend]
cmd = /path/to/script.py
进程数=3
[环境：dbackend]
PYTHONPATH = /path/to/parent-of-dproject
DJANGO_SETTINGS_MODULE=dproject.settings
参见 http://chaussette.readthedocs.org 有关 chausette 的更多信息。
工艺设计 决定
整体 架构
[图片]
Circus 由一个名为 马戏团 它负责运行所有
过程。 Circus 管理的每个进程都是一个子进程 马戏团.
进程被组织成组，称为 观察家。 一个 守望者 基本上是一个命令
马戏团 在您的系统上运行，并且对于每个命令，您可以配置您的进程数
想跑。
的概念 守望者 当你想管理所有运行的进程时很有用
相同的命令——比如重新启动它们等。
马戏团 绑定两个 ZeroMQ 套接字：
· 请求/代表 -- 一个用来控制的套接字 马戏团 使用基于 json 的 命令.
· 发布/订阅 -- 一个套接字，其中 马戏团 发布事件，例如进程启动时或
停了
注意:
尽管有它的名字，ZeroMQ 并不是一个队列管理系统。 把它想象成一个
进程间通信（IPC）库。
另一个过程称为 马戏团统计 由...运行 马戏团 激活选项时。
马戏团统计的工作是在专用的 发布/订阅
频道。
该专用通道由 马戏团顶 和 马戏团-httpd 显示直播
的活动。
马戏团顶 是一个控制台脚本，模仿 最佳 显示所有的 CPU 和内存使用情况
Circus 管理的流程。
马戏团-httpd 是 Web 管理界面，可让您与 Circus 进行交互。 它
使用 Web 套接字和 马戏团统计 渠道，也让你
与。。。相互作用 马戏团 通过其 请求/代表 频道。
最后，但并非最不重要的， 马戏团 是一个命令行工具，可以让你开车 马戏团 通过其
请求/代表 频道。
您还可以拥有订阅的插件 马戏团's 发布/订阅 频道，让你发送
命令给 请求/代表 频道喜欢 马戏团 将。
安全性
Circus 建立在 ZeroMQ 库之上，并且完全没有任何安全性
协议。 但是，您可以在服务器上运行 Circus 系统并设置 SSH 隧道以访问
从另一台机器访问它。
本节解释了当你运行 Circus 时它在你的系统上做了什么，并结束了
描述如何使用 SSH 隧道。
你也可以阅读 http://www.zeromq.org/area：常见问题#toc5
TCP 港口
默认情况下，Circus 在本地主机上打开以下 TCP 端口：
· 5555 -- 用于控制马戏团的端口 马戏团
· 5556 -- 用于发布者/订阅者通道的端口。
· 5557 -- 用于统计通道的端口 -- 如果已激活。
· 8080 -- Web UI 使用的端口 -- 如果已激活。
这些端口允许客户端应用程序与您的 Circus 系统进行交互，具体取决于如何
您的基础设施是有组织的，您可能希望通过防火墙保护这些端口 or
将 Circus 配置为使用 IPC 端口。
这是仅使用 IPC 入口点运行 Circus 的示例：
[马戏表演]
检查延迟 = 5
端点 = ipc:///var/circus/endpoint
pubsub_endpoint = ipc:///var/circus/pubsub
stats_endpoint = ipc:///var/circus/stats
使用 IPC 配置时，命令必须从同一个盒子运行，但没有人可以
与使用 TCP 不同，从外部访问它们。 这些命令还必须以用户身份运行
对 ipc 套接字路径具有写访问权。 可以修改所有者 端点 运用
这些因素包括原料奶的可用性以及达到必要粉末质量水平所需的工艺。 端点所有者 配置选项。 这允许您以 root 用户身份运行 circusd，但是
允许非 root 进程发送命令到 马戏团. 请注意，使用时 端点所有者,
为了防止非根进程能够启动任意进程
以更高的权限运行，添加命令将强制新的观察者必须以
这些因素包括原料奶的可用性以及达到必要粉末质量水平所需的工艺。 端点所有者 用户。 本地配置文件中的观察者定义不会
限制这种方式。
当然，如果您激活 Web UI， 8080 端口仍将开放。
马戏团httpd
当你跑步 马戏团httpd 手动，或者当您使用 httpd的 ini文件中的选项，例如
这个：
[马戏表演]
检查延迟 = 5
端点 = ipc:///var/circus/endpoint
pubsub_endpoint = ipc:///var/circus/pubsub
stats_endpoint = ipc:///var/circus/stats
httpd = 1
Web 应用程序将在端口上运行 8080 并允许任何人访问该网页
管理 马戏团 守护进程。
这包括创建可以在您的系统上运行任何命令的新观察者！
Do 而不去 使 it 公然 可使用
如果你想保护对 web 面板的访问，你可以在 Nginx 或
Apache 或任何具有代理功能的 Web 服务器，可以负责安全性。
用户 和 团队 权限
默认情况下，所有使用 Circus 启动的进程都将使用相同的用户和组运行
as 马戏团. 根据用户在系统上的权限，您可能没有
访问 Circus 提供的所有功能。
例如，正在运行的进程的某些统计功能需要扩展权限。
通常，如果您使用 统计 命令是 无，这意味着你的
用户无法访问 proc 文件。 在 Mac OS X 下默认情况下会出现这种情况。
你可以跑步 马戏团 以 root 身份修复此问题，并设置 的uid 和 GID 每个观察者的值
获得所有功能。
但要注意运行 马戏团 作为 root 使您面临潜在的特权升级
错误。 虽然我们正在尽最大努力避免任何错误，但以 root 身份运行并面临一个错误
在您的系统上执行不需要的操作可能很危险。
防止这种情况的最好方法是确保运行 Circus 的系统完全
隔离（如虚拟机） or 在受控用户下运行整个系统。
SSH的 隧道
客户端可以连接到 马戏团 通过创建 SSH 隧道来创建实例。 为此，请通过
命令行选项 --ssh 其次是 用户@地址，在 Moku:Pro 上 用户 是遥控器上的用户
服务器和 地址 是客户端看到的服务器地址。 SSH 协议将
需要凭据才能完成登录。
If 马戏团 如 SSH 服务器所见，不在默认端点地址 本地主机：5555
然后指定 马戏团 使用选项的地址 --端点
担保 格局 例子
可以通过以下方式设置安全的 Circus 服务器：
· 运行 SSH 服务器
· 在服务器上运行 Apache 或 Nginx 80 端口，并在 8080 港口。
· 封锁 8080 从外部访问端口。
· 使用 IPC 文件而不是 TCP 端口运行所有 ZMQ Circusd 端口，并通过隧道连接所有
通过 SSH 调用。
[图片]
特约 至 马戏团
Circus 已经在 Mozilla 开始，但它的目标不仅仅是留在那里。 我们正在努力
构建一个对其他人有用且易于扩展的工具。
我们真的对任何贡献开放，以代码、文档、讨论的形式，
功能提案等
您可以在我们的邮件列表中开始一个主题： http://tech.groups.yahoo.com/group/circus-dev/
或者在我们的添加一个问题 错误 跟踪
定影 错别字 和 加强 这些因素包括原料奶的可用性以及达到必要粉末质量水平所需的工艺。 文件
看这半个英文，完全有可能眼睛在流血
半法语文档，请不要犹豫，贡献任何改写/增强
文档中的表格。 您可能甚至不需要了解 Circus 的工作原理
在引擎盖下做到这一点。
添加 新 功能
新功能当然非常感谢。 如果您有需要和时间
开发新功能，将它们添加到 Circus 应该不会那么复杂。 我们非常努力
很难有一个干净易懂的 API，希望它能达到目的。
您将需要添加文档和测试以及新功能的代码。
否则我们将无法接受补丁。
创新中心 至 提交 您的 变化
我们使用 git 作为 DVCS。 建议更改的最佳方法是在您的
侧面（通过 混帐 结帐 -b 分店名称) 并在那里提交您的更改。 一旦你有
准备好黄金时段的东西，向这个分支发出拉取请求。
我们遵循此模型以允许您的功能之间具有低耦合
提议。 例如，我们可以在仍在讨论的同时接受一个拉取请求
对于另一个。
在提出您的更改之前，请仔细检查它们是否没有破坏任何东西！ 你可以
使用 TOX 命令来确保这一点，它将在不同的环境下运行测试套件
支持的python版本。
请用 ： http://issue2pr.herokuapp.com/ 引用对现有马戏团的承诺
问题，如果有的话。
避免 合并 提交
避免合并提交允许拥有干净且可读的历史记录。 这样做，而不是
使用 git pull --rebase 执行“git pull”并让 git 为您处理合并
将您的更改放在分支中提交的更改之后，或者在处理时
主。
也就是对于我们核心开发者来说，用得心应手的 github green 已经不行了
如果开发人员没有自己重新调整他们的工作或者我们等待，则拉取请求上的按钮
请求和实际合并之间的时间过长。 相反，流程如下所示：
git 远程添加名称 repo-url
git 获取名字
git checkout 功能分支
git rebase 大师
# 检查一切是否正常，然后在 master 上合并
git checkout主
git 合并功能分支
讨论
如果你在查看 Circus 的代码时发现自己需要任何帮助，你可以去
并在 irc 上找到我们 #马戏团帐篷 on irc.freenode.org （或者如果你没有任何 IRC
客户端，使用 这些因素包括原料奶的可用性以及达到必要粉末质量水平所需的工艺。 网络聊天)
您也可以在我们的邮件列表中创建一个主题 -
http://tech.groups.yahoo.com/group/circus-dev
频繁 问 有疑问吗？
以下是有关 Circus 的常见问题列表：
创新中心 不 马戏团 堆 我们的 至 a 古典 堆栈？
在经典的 WSGI 堆栈中，您有一个像 Gunicorn 这样的服务器，它服务于一个端口或一个
unix 套接字，通常部署在 Nginx 等 Web 服务器后面：[图片]
客户端调用 Nginx，Nginx 反向代理所有对 Gunicorn 的调用。
如果你想确保 Gunicorn 进程保持正常运行，你必须使用
像Supervisord或upstart这样的程序。
Gunicorn 反过来监视它的进程（“工人”）。
换句话说，您正在使用两个级别的流程管理。 您管理和
控制（supervisord），以及您必须在不同的 UI 中管理的第二个，带有
不同的理念和对正在发生的事情的较少控制（wsgi服务器的）
这对于 Gunicorn 和我所知道的大多数多进程 WSGI 服务器都是如此。
uWsgi 有点不同，因为它提供了过多的选项。
但是如果你想在你的堆栈中添加一个 Redis 服务器，你 将 最终管理您的
在两个不同的地方堆叠进程。
马戏团对此的方法是管理流程 和 插座。
Circus 堆栈可能如下所示：[图片]
因此，像 Gunicorn 一样，Circus 能够绑定一个将由 Nginx 代理的套接字。 马戏团
不处理请求，而只是绑定套接字。 然后由网络工作者决定
进程接受套接字上的连接并完成工作。
它提供了与 Supervisord 相同的功能，但也可以让您管理所有
同一级别的进程，无论他们是网络工作者还是 Redis 或其他任何东西。 添加一个
新的 web worker 就像添加一个新的 Redis 进程一样。
长凳
我们做了几条长凳来比较 Circus & Chaussette 和 Gunicorn。 总而言之，马戏团是
不增加任何开销，您可以为您的网络工作者选择许多不同的后端。
请参见：
· http://blog.ziade.org/2012/06/28/wgsi-web-servers-bench
· http://blog.ziade.org/2012/07/03/wsgi-web-servers-bench-part-2
创新中心 至 故障排除 马戏团？
默认情况下， 马戏团 保持其日志记录 标准输出 比较稀疏。 这种输出不足可以
当进程似乎无法启动时，让事情变得难以解决。
增加日志记录 马戏团 提供，尝试增加日志级别。 要查看
可用的日志级别只需使用 - 帮帮我 旗。
$ circus --日志级别调试 test.ini
一句话警告。 如果一个进程正在抖动并且调试日志级别已打开，您
将看到每次启动尝试的消息。 配置应用程序可能会有所帮助
拍打使用 预热延迟 将消息放慢到可控的速度。
[观察者：webapp]
cmd = python -m myapp.wsgi
预热延迟 = 5
默认情况下， 标准输出 和 斯特德 被捕获 马戏团 过程。 如果您正在测试您的
config 并希望看到与 circusd 输出一致的输出，您可以配置您的
观察者使用 标准输出流 类。
[观察者：webapp]
cmd = python -m myapp.wsgi
stdout_stream.class = 标准输出流
stderr_stream.class = 标准输出流
如果您的应用程序在尝试启动您时产生回溯或错误
应该能够在输出中看到它。
更新日志 历史
0.12.1 - 2015-08-05
· 修复使用输出流重启观察者时的错误 - #913
· 小的文档调整
0.12 - 2015-06-02
此版本带来了 Python 3.4、Tornado 4 和 Windows 支持，以及几个令人兴奋的
功能和修复。
Windows 支持仍处于试验阶段，不处理流。
主要变化：
· 兼容 Python 3.4 - #768
· 实验性 Windows 支持 - #788
· 与 Tornado 4 的兼容性 - #872
· 改进的 Debian 包装 - #896 - #903
· 添加对 Papa 进程内核的支持 - #850
· 为启动、停止和重新启动观察者添加 globing 和正则表达式匹配 - #829 -
#902 展位
更多更改：
· 关机优化 - #784 - #842
· 添加为观察者指定 virtualenv 版本的可能性 - #805
· 在 rmwatcher 命令中添加 --nostop 选项 - #777
· 为 Arbiter.start 添加回调 - #840
· 修复使用大写字母重新加载观察者 - #823
· 删除 stats 守护进程中的泄漏套接字 - #843
· 修复 SunOS 上的多播 - #876
· 停止观察者时关闭输出流 - #885
· 修复使用 --recursive 向孙子发送信号的问题 - #888
0.11.1 - 2014-05-22
· 修复了在 2.6 - #782 上破坏 Circus 的回归
0.11 - 2014-05-21
这个版本没有引入很多功能，而是专注于让 Circus
健壮和稳定。
主要更改/修复：
· 确保我们不能同时在仲裁器上执行两个冲突的命令。
· 我们有 2 个新的流类：TimedRotatingFileStream、WatchedFileStream
· 我们有一个新的钩子：after_spawn 钩子
· CircusPlugin 更易于使用
· 修复 autostart=False 启动期间的观察者（回归）
更多更改：
· 马戏团消息现在可以路由到系统日志 - #748
· 添加了 endpoint_owner 选项，因此我们可以定义哪个用户拥有由创建的 IPC 套接字文件
马戏表演。
· 开始支持 Windows（现在只是 circusctl）
· 修复了测试中的大量漏洞
· 允许区分大小写的环境变量
· 资源插件现在接受绝对内存值 - #609
· 添加对“singleton”选项的添加命令的支持 - #767
· 允许通过资源观察器向子进程发送任意信号 - #756
· 允许 INI/JSON/YAML 配置进行日志记录
· 确保我们与 psutil 2.x 兼容 和 3.x
· 向 statsd 提供程序添加了更多指标 - #698
· 固定多播发现 - #731
· 使启动、重启和重新加载更加统一 - #673
· 正确初始化所有使用组 - #635
· 提高测试稳定性
· 很多很多的东西......
0.10 - 2013-11-04
主要变化：
· 现在兼容 Python 3.2 & 3.3 - #586
· 将核心移至完全异步模型 - #569
· 改进的文档 - #622
更多更改：
· 添加了 stop_signal 和 stop_children - #594
· 确保看门狗插件关闭套接字 - #588
· 改用 ZMQ JSON 解析器
· 并非所有平台都支持 IN - #573
· 允许在任何配置部分进行全局环境替换 - #560
· 允许在部分名称中使用破折号 - #546
· 现在变量在配置中随处展开 - #554
· 添加了 CommandReloader 插件
· 添加了 before_signal 和 after_signal 钩子
· 允许摆动插件无限期重试
·当观察者停止时不要重生触发 - #529 - #536
· 为每条客户端消息添加了唯一的 id - #517
·工人ID现在是“插槽” -
· 修复优雅关机行为 - #515
· 确保即使仲裁器没有启动，我们也可以添加观察者 - #503
· 确保我们弹出过期进程 - #510
· 确保set命令可以设置多个hook
· 正确支持 ipv6 套接字 - #507
· 允许 stdout_stream 和 stderr_stream 的自定义选项 - #495
· 为 FileStream 添加 time_format - #493
· 添加了新的套接字配置选项以按名称绑定到特定接口
0.9.3 - 2013-09-04
· 确保即使仲裁器没有启动我们也可以添加观察者
· 确保我们弹出过期进程
· 确保set命令可以设置一个或多个钩子
· 正确支持 ipv6 套接字和 CircusSockets 的改进
· 给路径默认值以防止 UnboundLocalError
· 在Controller初始化中增加了multicast_endpoint是否存在的测试
· 不再将每个数字字符串转换为整数
· 添加测试
· 转换 stdout_stream 选项时无需特殊情况
· 也接受 umask 作为一致性的论据
· 允许 stdout_stream 和 stderr_stream 的自定义选项。
· 添加新的套接字配置选项以按名称绑定到特定接口
· 为 FileStream + 测试添加 time_format
· 更新 circus.upstart
0.9.2 - 2013-07-17
· 在配置文件中定义 PYTHONPATH 时，它会加载到 sys.path 中，因此可以使用钩子
位于那里 - #477, #481
· 为 add_callback 使用单个参数，因此它适用于 PyZMQ < 13.1.x - 请参阅 #478
0.9 - 2013-07-16
· 添加 [env] 部分通配符
· 添加了全局 [env] 部分
· 修复未安装 circus-web 时的隐藏异常 - #424
· 确保 incr/decr 命令真正使用 nb 选项 - #421
· 修复不在 PYTHONPATH 中的 watcher virtualenv 站点包
· 确保我们不会尝试删除多于 0 的进程 - #429
· 更新 bootstrap.py - #436
· 修复了 pythonpath virtualenv watcher 中的多平台分隔符
· 重构套接字关闭函数
· 确保 env 部分适用于所有观察者 - #437
· 添加了 reloadconfig 命令
· 添加 circus.green 并从核心中删除 gevent - #441、#452
· 在测试中消除虚假的标准输出和警告 - #438
· $(circus.env.*) 现在可以用于配置中的所有选项
· 添加了一个 before_spawn 钩子
· 更正 systemd 服务文件中 circusd 的路径 - #450
· 确保我们可以通过 CLI 更改挂钩和设置流 - #455
· 改进的文档
· 在观察者中添加了 spawn_count 统计信息
· 在 ResourceWatcher 插件中添加 min_cpu 和 min_mem 参数
· 将 FQDN 信息添加到仲裁器。
0.8.1 - 2013-05-28
· circusd-stats 在 unix 套接字上卡住了 - #415
· circusd-stats 和 circushttpd 子进程 stdout/stderr 现在默认保持打开状态。
如果 2.7.5/2 fds 关闭，Python <= 3 会阻塞日志模块 - #415
· 现在在子进程中重定向到 /dev/null 而不是关闭。 #417
0.8 - 2013-05-24
· 将日志处理程序集成到 zmq io 循环中。
· 使重定向器可重新启动并随后更加健壮。
· 检测到 gevent 时使用 zmq.green.eventloop
· circusctl 添加了对 CIRCUSCTL_ENDPOINT 环境变量的支持 - #396
· util: 修复 to_uid 函数中的错误 - #397
· 删除 ioloop 错误处理程序 - #398。
· 提高测试覆盖率
· 弃用 ResourceWatcher 插件的“服务”选项 - #404
· 删除了 psutil.error 用法
· 在 circusd 中添加了 UDP 发现 - #407
· 现在允许在任意目录级别使用 glob - #388
· 添加了 'statd' 配置选项 - #408
· 在 circus 配置文件中添加 pidfile、logoutput 和 loglevel 选项 - #379
· 在文档中添加了教程。
· 确保我们在使用 include 时合并所有部分 - #414
· 添加了 pipe_stdout、pipe_stderr、close_child_stderr 和 close_child_stdout 选项到
进程类
· 为观察者添加了 close_child_stderr 和 close_child_stdout 选项
0.7.1 - 2013-05-02
· 修复了重生选项 - #382
· 确保我们使用 int 作为超时 - #380
· 显示 unix 套接字 - #381
· 确保它适用于最新的 pyzmq
· 为 fd 符号引入了第二种语法
0.7 - 2013-04-08
· 修复 get_arbiter 示例以使用 dict 作为 watchers 参数。 #304
· 添加一些故障排除文档 #323
· 添加python构建支持
· 删除了 gevent 和线程重定向器。 现在使用 ioloop - 修复 #346。
相关#340
· circus.web 现在是它自己的项目
· 移除 pyzmq 补丁
· 允许观察者被配置但未启动 #283
· 添加选项以加载 virtualenv 站点目录
· 添加了 on_demand 观察者
· 添加了关于 nginx+websockets 的文档 #371
· 现在正确解析每个命令的选项列表 #369
· 修复 circusd-stats 事件处理 #372
· 修复了 circus-top #378 的溢出问题
· 还有很多...
0.6 - 2012-12-18
· 为套接字修补协议名称 - #248
· 不要自动缩放图表。 #240
· circusctl：添加每个命令的帮助，来自 docstrings #217
· 添加了工人钩子
· 添加 Debian 软件包 - #227
· 添加了 Redis、HTTP Observer、完整的统计信息和资源插件
· 现在流程可以有标题
· 增加了自动补全
· 在 webui 中添加进程/观察者年龄
· 增加 SSH 隧道支持
· 现在使用pyzmq.green
· 添加新贵脚本和清漆文档
· 添加了环境变量和部分
· 添加了 unix 套接字支持
· 增加了 重生 拥有单次运行观察者的选项
· 现在在测试中使用 tox
· 允许在 args 中替换套接字
· 新的文档主题
· 流的新轮换选项：max_bytes/backup_count
0.5.2 - 2012-07-26
· 现在修补 stdlib 中的线程模块以避免一些 Python 错误 - #203
· 更好看的 circusctl 帮助屏幕
· 在可用时使用 pustil get_nice() (nice 已被弃用) - #208
· 添加 max_age 支持 - #221
· 仅在 SOCK_STREAM 或 SOCK_SEQPACKET 套接字上调用 listen()
· 确保控制器清空 update_watchers() 中的插件列表 - #220
· 添加--log-level 和--log-output 到circushttpd
· 修复通过 Web UI 杀死进程的问题 - #219
· 现在 circus 与脚本兼容 zc.buildout。
· 客户端断开连接时清理 websocket - #225
· 修复了端点的默认值 - #199
· 在逻辑模块中拆分 circushttpd
0.5.1 - 2012-07-11
· 修正了文档中的一堆错别字
· 增加了调试选项
· 正确打包 web-requirements.txt
· 在消息中添加了 errno 错误代码 - 修复 #111
0.5 - 2012-07-06
· 增加了套接字支持
· 添加了 listsocket 命令
· 插座也有统计数据！
· 修复了很多小错误
· 删除了 wid - 现在到处都使用 pid
· 更快的测试
· 改变了变量的语法
· 更多地方使用pyzmq的ioloop
· 现在对所有 select() 调用使用 iowait
· incr/decr 命令现在有一个 nbprocess 参数
· 为观察者添加一个reproduce_env 选项
· 为进程添加一个新的 UNEXISTING 状态
· 增加了全局 httpd的 将 circushttpd 作为观察者运行的选项
0.4 - 2012-06-12
· 增加了插件系统
· 为观察者添加了“单例”选项
· 固定马戏团顶部屏幕闪烁
· 从 circus.stats 中删除线程以支持 zmq 定期回调
· 增强文档
· Circus 客户端现在有一个 send_message api
· 拍打功能现在是一个插件
· 每个命令行工具都有一个 --version 选项
· 添加了一个 statsd 插件（将事件从 circus 发送到 statsd）
· Web UI 现在使用 websockets（通过 socketio）来获取统计信息
· Web UI 现在在 Web ui 中使用会话来处理“Flash 消息”
0.3.4 - 2012-05-30
· 修复了阻止控制器干净地获取已完成进程的竞争条件。
· 现在可以在配置中控制 check_flapping。 并激活/停用
每个观察者。
0.3.3 - 2012-05-29
· 修复了 uid 处理的回归问题
0.3.2 - 2012-05-24
· 允许可选的 args 属性添加到 add_watcher 命令。
· 添加了 circushttpd、circus-top 和 circusd-stats
· 允许 Arbiter.add_watcher() 设置所有 Watcher 选项
· 确保在重新启动时重新创建重定向器
0.3.1 - 2012-04-18
· 修复：确保观察者的默认值没有被覆盖
· 添加了一个StdoutStream 类。
0.3 - 2012-04-18
· 增加了流媒体功能
· 现在在 Sphinx 文档中显示覆盖范围
· 修复了进程被杀死的方式（不再有 SIGQUIT）
· 配置已被分解
· setproctitle 支持
0.2 - 2012-04-04
· 删除了 显示 名称。 取而代之 守望者.
· 增加了对设置过程的支持 限制.
· 在配置文件中添加了对包含目录的支持。
· 修复了几个泄漏的文件描述符。
· 修正了扑动中的核心转储
· 文档改进
· 当另一个马戏团在同一个套接字上运行时，确保马戏团错误正确。
· get_arbiter 现在接受多个观察者。
· 修复了进程初始化中的 cmd vs args vs 可执行文件。
· 修正--start on circusctl add
0.1 - 2012-03-20
· 初始发行
男子 网页
马戏团 男子 页
简介
circusd [选项] [配置]
描述
circusd 是 Circus 架构的主要进程。 它负责运行所有
过程。 Circus 管理的每个进程都是一个子进程 马戏团.
参数
配置 配置文件
可选项
-H， - 帮帮我
显示帮助信息并退出
--日志级别 LEVEL
指定日志级别。 LEVEL 可 info, 调试, 危急, 警告 or 错误.
--日志输出 注销
将写入日志的位置。 默认行为是写入
标准输出（您可以通过将“-”传递给此选项来强制它）。 获取文件名
除此以外。
--记录器配置 记录器配置
标准 Python 记录器配置 INI、JSON 或 YAML 文件的位置
可以被找寻到。 这可用于覆盖默认的日志记录配置
仲裁者。
--守护进程
在后台启动 circusd。
--pid文件 PID文件
PID 文件的位置。
- 版
显示 Circus 版本并退出。
参见 还
马戏团 （1） 马戏团 （1） 马戏团统计 （1） 马戏团插件 （1） 马戏团顶 （1）。
完整文档可在 http://circus.readthedocs.org
马戏团 男子 页
简介
circusctl [选项] 命令 [参数]
描述
circusctl 是控制 Circus 守护进程的前端。 它旨在帮助
管理员控制 Circud 的功能 马戏团 守护进程。
命令
加 添加观察者
递减 减少观察者中的进程数
数据统计 获取马戏团统计数据
得到 获取特定观察者选项的价值
全局选项
获取仲裁器选项
增量 增加观察者中的进程数
蟒蛇
在 circusd 进程中创建 shell
名单 获取观察者或观察者中的进程列表
听 订阅观察者事件
列表套接字
获取套接字列表
进程数
获取进程数
观察者人数
获取观察者数量
选项
获取观察者所有选项的值
退出 立即退出仲裁者
重载 重新加载仲裁者或观察者
重新加载配置
重新加载配置文件
重新开始
重启仲裁者或观察者
rm 移除观察者
集 设置观察者选项
信号 发送信号
开始 启动仲裁者或观察者
统计 获取进程信息
状态 获取一个观察者或所有观察者的状态
停止 停止观察者
可选项
--端点 端点
连接端点
-H， - 帮帮我
显示帮助信息并退出
--json 输出到 JSON
- 美化
美化输出
--ssh SSH的
SSH 服务器格式 用户@主机：端口
--ssh_密钥文件 SSH_KEYFILE
用于授权用户的密钥文件的路径
- 暂停 超时
连接超时
- 版
显示 Circus 版本并退出。
参见 还
马戏团 （1） 马戏团 （1） 马戏团统计 （1） 马戏团插件 （1） 马戏团顶 （1）。
完整文档可在 http://circus.readthedocs.org
马戏团插件 男子 页
简介
马戏团插件 [选项] [插件]
描述
circus-plugin 允许从正在运行的 Circus 守护进程启动插件。
参数
插入 插件类的完全限定名称。
可选项
--端点 端点
连接端点。
--发布订阅 发布订阅
要连接的 circusd ZeroMQ 发布/订阅套接字。
--配置 配置
插件配置文件。
--检查延迟 检查延迟
检查延迟。
--日志级别 LEVEL
指定日志级别。 LEVEL 可 info, 调试, 危急, 警告 or 错误.
--日志输出 注销
将写入日志的位置。 默认行为是写入
标准输出（您可以通过将“-”传递给此选项来强制它）。 获取文件名
除此以外。
--ssh SSH的
SSH 服务器格式 用户@主机：端口.
-H， - 帮帮我
显示帮助信息并退出。
- 版
显示 Circus 版本并退出。
参见 还
马戏团 （1） 马戏团 （1） 马戏团 （1） 马戏团统计 （1） 马戏团顶 （1）。
完整文档可在 http://circus.readthedocs.org
马戏团顶 男子 页
简介
马戏团顶 [选项]
描述
马戏团顶是一个 最佳- 类似命令来显示 Circus 守护进程和由其管理的进程
马戏表演。
可选项
--端点 端点
连接端点。
--ssh SSH的
SSH 服务器格式 用户@主机：端口.
--进程超时 进程超时
在这种不活动的延迟之后，将删除一个进程。
-H， - 帮帮我
显示帮助信息并退出。
- 版
显示 Circus 版本并退出。
参见 还
马戏团 （1） 马戏团 （1） 马戏团 （1） 马戏团统计 （1） 马戏团插件 （1）。
完整文档可在 http://circus.readthedocs.org
马戏团统计 男子 页
简介
circusd-stats [选项]
描述
circusd-stats 运行 Circus 的统计信息聚合器。
可选项
--端点 端点
连接端点。
--发布订阅 发布订阅
要连接的 circusd ZeroMQ 发布/订阅套接字。
--统计点 统计点
将数据发送到的 ZeroMQ 发布/订阅套接字。
--日志级别 LEVEL
指定日志级别。 LEVEL 可 info, 调试, 危急, 警告 or 错误.
--日志输出 注销
将写入日志的位置。 默认行为是写入
标准输出（您可以通过将“-”传递给此选项来强制它）。 获取文件名
除此以外。
--ssh SSH的
SSH 服务器格式 用户@主机：端口.
-H， - 帮帮我
显示帮助信息并退出。
- 版
显示 Circus 版本并退出。
参见 还
马戏团 （1） 马戏团 （1） 马戏团 （1） 马戏团插件 （1） 马戏团顶 （1）。
完整文档可在 http://circus.readthedocs.org
名词解释： 马戏团专用 条款
仲裁者
这个 仲裁者 负责管理马戏团内的所有观察员，确保
所有进程正常运行。
调节器
A 调节器 包含可以在仲裁器上执行的一组操作。
扑
这个 扑 发现 订阅事件并检测某些进程何时
不断重启。
发布/订阅
马戏团有一个 发布订阅 从观察者那里接收事件并将它们分派到
所有订阅者。
远程 调节器
这个 远程 调节器 允许您通过 ZMQ 与控制器进行通信以
控制马戏团。
观察者， 观察家
A 守望者 是您告诉 Circus 运行的程序。 单个 Circus 实例可以运行
一名或多名观察者。
工人， 工人， 过程中， 工艺
A 工艺 是您程序的独立操作系统进程实例。 单一的观察者
可以运行一个或多个进程。 我们也称他们为工人。
版权
Circus 由 Tarek Ziade 发起并获得 APLv2 许可
Benoit Chesneau 是早期的贡献者，做了很多事情，就像大多数
circus.commands 工作。
执照
版权所有 2012 - Mozilla 基金会
版权所有 2012 - Benoit Chesneau
根据Apache许可证2.0版（“许可证”）获得许可；
除非符合许可，否则您不得使用此文件。
您可以在以下位置获取许可证副本
http://www.apache.org/licenses/LICENSE-2.0
除非适用法律要求或书面同意，否则软件
根据许可分发的内容按“原样”分发，
不附带任何明示或暗示的保证或条件。
有关管理权限的特定语言，请参阅许可证
许可证下的限制。
合作者
完整列表见 https://github.com/circus-tent/circus/blob/master/CONTRIBUTORS.txt
使用 onworks.net 服务在线使用马戏团
