【SaltStack官方版】—— Events&Reactor系统—EVENT SYSTEM

Events&Reactor系统 EVENT SYSTEM

The Salt Event System is used to fire off events enabling third party applications or external processes to react to behavior within Salt. The event system uses a publish-subscribe pattern, otherwise know as pub/sub.

Salt事件系统用于触发第三方应用或外部过程对Salt内行为做出反应的事件。事件系统使用发布订阅模式，否则称为PUB/SUB。

event bus

The event system is comprised of a two primary components, which make up the concept of an Event Bus:

事件系统由两个主要组成部分组成，它们构成事件总线的概念：

• The event sockets which publishes events. 发布事件的事件套接字。
• The event library which can listen to events and send events into the salt system. 事件库，它可以侦听事件并将事件发送到salt系统

Events are published onto the event bus and event bus subscribers listen for the published events.

事件发布到事件总线上，事件总线订阅服务器侦听已发布事件。

The event bus is used for both inter-process communication as well as network transport in Salt. Inter-process communication is provided through UNIX domain sockets (UDX).

事件总线既用于进程间通信，又用于网络传输。进程间通信是通过UNIX域套接字（UDX）提供的。

The Salt Master and each Salt Minion has their own event bus.

Salt Master和每个Salt Minion都有他们自己的事件bus。

event types

Salt Master Events

• Authentication events  认证事件
• Start events                 启动事件
• Key events                  key事件
• Job events                   job事件
• Runner Events            runner事件
• Presence Events         存在事件
• Cloud Events               云事件

listening for events

Salt's event system is used heavily within Salt and it is also written to integrate heavily with existing tooling and scripts. There is a variety of ways to consume it.

Salt的事件系统在Salt中大量使用，它也被写为与现有的工具和脚本紧密结合。有各种各样的方式来消费它。

from the cli

The quickest way to watch the event bus is by calling the state.event runner:

查看事件总线的最快方法是调用 state.event runner:

salt-run state.event pretty=True

That runner is designed to interact with the event bus from external tools and shell scripts. See the documentation for more examples.

该转发器被设计为与外部总线和外壳脚本交互的事件总线。有关更多示例，请参阅文档。

remotely via the rest api 通过REST API远程访问

Salt's event bus can be consumed salt.netapi.rest_cherrypy.app.Events as an HTTP stream from external tools or services.

可以将Salt事件总线作为来自外部工具或服务的HTTP流来消耗salt.netapi.rest_cherrypy.app.Events。

curl -SsNk https://salt-api.example.com:8000/events?token=05A3

from python

Python scripts can access the event bus only as the same system user that Salt is running as.

Python脚本只能像salt一样运行的系统用户访问事件总线。 

The event system is accessed via the event library and can only be accessed by the same system user that Salt is running as. To listen to events a SaltEvent object needs to be created and then the get_event function needs to be run. The SaltEvent object needs to know the location that the Salt Unix sockets are kept. In the configuration this is the sock_dir option. The sock_dir option defaults to "/var/run/salt/master" on most systems.

事件系统是通过事件库访问的，并且只能由同一系统用户访问，即salt正在运行。要侦听事件，需要创建一个saltevent对象，然后需要运行getyengenter函数。saltever对象需要知道salt unix插座的位置。在配置中，这是sokkddir选项。sokkydir选项默认为大多数系统上的“/var/run/salt/master”。

The following code will check for a single event:

下面的代码将检查单个事件：

import salt.config
import salt.utils.event

opts = salt.config.client_config('/etc/salt/master')

event = salt.utils.event.get_event(
        'master',
        sock_dir=opts['sock_dir'],
        transport=opts['transport'],
        opts=opts)

data = event.get_event()

Events will also use a "tag". Tags allow for events to be filtered by prefix. By default all events will be returned. If only authentication events are desired, then pass the tag "salt/auth".

事件也会使用“标签”。标签允许事件按照前缀过滤。默认情况下，所有的事件将被返回。如果只需要认证事件，然后传“salt/认证”事件。

The get_event method has a default poll time assigned of 5 seconds. To change this time set the "wait" option.

get_event方法的默认轮询时间分配为5秒。 要更改此时间，请设置“wait”选项。

The following example will only listen for auth events and will wait for 10 seconds instead of the default 5.

以下示例只会侦听auth事件，并会等待10秒而不是默认值5。

data = event.get_event(wait=10, tag='salt/auth')

To retrieve the tag as well as the event data, pass full=True:

要检索标签以及事件数据，请传递full = True：

evdata = event.get_event(wait=10, tag='salt/job', full=True)
tag, data = evdata['tag'], evdata['data']

Instead of looking for a single event, the iter_events method can be used to make a generator which will continually yield salt events.

iter_events方法可以用来生成一个不断产生salt事件的生成器，而不是寻找一个单个事件。

The iter_events method also accepts a tag but not a wait time:

iter_events方法也接受一个标签，但不是等待时间：

for data in event.iter_events(tag='salt/auth'):
    print(data)

And finally event tags can be globbed, such as they can be in the Reactor, using the fnmatch library.

最后，事件标记可以使用fnmatch库进行globbed，例如它们可以在Reactor中。

import fnmatch

import salt.config
import salt.utils.event

opts = salt.config.client_config('/etc/salt/master')

sevent = salt.utils.event.get_event(
        'master',
        sock_dir=opts['sock_dir'],
        transport=opts['transport'],
        opts=opts)

while True:
    ret = sevent.get_event(full=True)
    if ret is None:
        continue

    if fnmatch.fnmatch(ret['tag'], 'salt/job/*/ret/*'):
        do_something_with_job_return(ret['data'])

firing events

It is possible to fire events on either the minion's local bus or to fire events intended for the master.

可以在minion发射事件给local bus或者发送事件给master。

To fire a local event from the minion on the command line call the event.fire execution function:

在minion端的命令行上发射一个本地事件，请调用event.fire函数。

salt-call event.fire '{"data": "message to be sent in the event"}' 'tag'

To fire an event to be sent up to the master from the minion call the event.send execution function. Remember YAML can be used at the CLI in function arguments:

从minion发送一个事件发送给master，调用event.send执行函数。 记住YAML可以在函数参数的CLI中使用：

salt-call event.send 'myco/mytag/success' '{success: True, message: "It works!"}'

If a process is listening on the minion, it may be useful for a user on the master to fire an event to it:

如果minion上某个进程正在侦听，这有助于，master服务器上的用户能向其发送事件：

# Job on minion
import salt.utils.event

event = salt.utils.event.MinionEvent(**__opts__)

for evdata in event.iter_events(tag='customtag/'):
    return evdata # do your processing here...

salt minionname event.fire '{"data": "message for the minion"}' 'customtag/african/unladen'

firing events from python

from salt execution modules salt执行模块

Events can be very useful when writing execution modules, in order to inform various processes on the master when a certain task has taken place. This is easily done using the normal cross-calling syntax:

在编写执行模块时，事件可能非常有用，以便在发生特定任务时通知主服务器上的各种进程。 这很容易使用正常的交叉调用语法完成：

# /srv/salt/_modules/my_custom_module.py

def do_something():
    '''
    Do something and fire an event to the master when finished

    CLI Example::

        salt '*' my_custom_module:do_something
    '''
    # do something!
    __salt__['event.send']('myco/my_custom_module/finished', {
        'finished': True,
        'message': "The something is finished!",
    })

from custom python scripts

Firing events from custom Python code is quite simple and mirrors how it is done at the CLI:

从自定义Python代码触发事件非常简单，并反映了在CLI中完成事件的方式：

import salt.client

caller = salt.client.Caller()

caller.sminion.functions['event.send'](
    'myco/myevent/success',
    {
        'success': True,
        'message': "It works!",
    }
)