现在终于开始学习salt的api了，有些小激动啊，我们执行命令的时候，后台到底是如何处理的，发生什么了事情，我对着一切有着强烈的好奇心啊。
这些是saltstack命令对应的api:
salt --->salt.client.LocalClient salt-minion --->salt.minion.Minion salt-cp --->salt.cli.cp.SaltCP salt-key --->salt.key.KeyCLI salt-call --->salt.cli.caller.caller salt-run --->salt.runner.Runner salt-ssh --->salt.client.ssh.SSH
首先学习的是salt命令对应的api:salt.client.LocalClient。
首先我们以一个简单的命令去讲解salt是如何处理。
salt '*' test.ping
这个首先会调用salt.cli.SaltCMD类实例化一个对象
主要代码如下：salt/cli/__init__.py
class SaltCMD(parsers.SaltCMDOptionParser):
def run(self):
... # 设置日志的
# 调用salt.client.LocalClient api
try:
local = salt.client.LocalClient(self.get_config_file_path())
except SaltClientError as exc:
self.exit(2, '{0}\n'.format(exc))
return
# self.options是命令行参数的集合
# 通过optparse模块解析命令行参数
# 批量执行的,salt -b
if self.options.batch:
batch = salt.cli.batch.Batch(self.config)
# Printing the output is already taken care of in run() itself
for res in batch.run():
pass
else:
# 处理需要传递的参数,kwargs是参数字典，传递时使用**kwargs
....
# 异步执行，不等待结果返回
if self.config['async']:
jid = local.cmd_async(**kwargs) # 返回jid
print('Executed command with job ID: {0}'.format(jid))
return
try:
# 接下来是主要逻辑
# 默认调用cmd_cli方法返回生成器，循环输出结果
# 在cmd_cli里有个get_cli_event_returns方法会去调用gather_job_info
# gather_job_info是去触发saltutil.find_job任务
# 是去验证操作是否还在执行
if local:
if self.options.subset: # 选择几个Minion调用cmd_cli
cmd_func = local.cmd_subset
kwargs['sub'] = self.options.subset
kwargs['cli'] = True
else:
cmd_func = local.cmd_cli
if self.options.static:
if self.options.verbose:
kwargs['verbose'] = True
full_ret = local.cmd_full_return(**kwargs)
ret, out = self._format_ret(full_ret)
self._output_ret(ret, out)
elif self.config['fun'] == 'sys.doc':
ret = {}
out = ''
for full_ret in local.cmd_cli(**kwargs):
ret_, out = self._format_ret(full_ret)
ret.update(ret_)
self._output_ret(ret, out)
else:
if self.options.verbose:
kwargs['verbose'] = True
for full_ret in cmd_func(**kwargs):
ret, out = self._format_ret(full_ret)
self._output_ret(ret, out)
从上面代码片段我们知道SaltCMD主要是解析命令行参数,通过参数来决定调用salt.client.LocalClient的哪个方法，默认是调用cmd_cli方法。
那么真正处理操作的是LocalClient类，LocalClient主要包含的方法是cmd_*,get_*_returns,gather_job_info,run_job,pub。
首先学习下它怎么使用吧。使用的是ipython学习的
:import salt.client
# 初始化实例，参数必须是master的配置文件路径
:local = salt.client.LocalClient('/opt/app/salt/etc/master')
# cmd(tgt,fun,arg,expr_form='glob',...)
:local.cmd('192.168.110.132','test.ping')
#返回的结果
: {'192.168.110.132': True}
# local.cmd_async('192.168.110.132','test.ping')
# 返回结果是个jid
: '20140813164423244819'
cmd代码片段如下：
def cmd(
self,
tgt, # salt target '192.168.110.132' 'os:Linux'
fun, # 执行模块 test.ping
arg=(), # 模块参数
timeout=None,
expr_form='glob', # target的类型,
ret='', # returners
kwarg=None,
**kwargs):
arg = condition_kwarg(arg, kwarg) # 将参数合并成一个列表
# run_job返回的结果形式：
#{'jid': '20131219215650131543', 'minions': ['jerry','sdfsd',]}
pub_data = self.run_job(tgt,
fun,
arg,
expr_form,
ret,
timeout,
**kwargs)
if not pub_data:
return pub_data
# 需要等待timeout时间才会返回结果
return self.get_returns(pub_data['jid'],
pub_data['minions'],
self._get_timeout(timeout))
其他的cmd_*形式都相似的，都会调用run_job方法，只不过返回结果不一样而已，比如cmd_async是异步执行的，不用等待，直接返回一个jid。cmd_cli返回的是生成器并会调用
gather_job_info方法去触发saltutil.find_job任务。cmd_cli是默认的处理方法。
run_job代码如下：
# run_job返回的结果形式：
# {'jid': '20131219215650131543', 'minions': ['jerry','sdfsd',]}
def run_job(
self,
tgt,
fun,
arg=(),
expr_form='glob',
ret='',
timeout=None,
kwarg=None,
**kwargs):
arg = condition_kwarg(arg, kwarg)
jid = '' # 这个可以自定义jid
# Subscribe to all events and subscribe as early as possible
self.event.subscribe(jid) # 订阅event
pub_data = self.pub(
tgt,
fun,
arg,
expr_form,
ret,
jid=jid,
timeout=self._get_timeout(timeout),
**kwargs)
return self._check_pub_data(pub_data)
pub代码片段如下：
#payload_kwargs信息如下：
{
'cmd': 'publish',
'tgt': tgt,
'fun': fun,
'arg': arg,
'key': self.key,
'tgt_type': expr_form,
'ret': ret,
'jid': jid,
'user':'root'
}
master_uri = 'tcp://' + salt.utils.ip_bracket(self.opts['interface']) + \
':' + str(self.opts['ret_port'])
sreq = salt.transport.Channel.factory(self.opts, crypt='clear', master_uri=master_uri)
# 使用zeromq通信,使用的是rep/req socket
# payload信息
#{'enc': 'clear',
# 'load': {'jid': '20140807004713142582',
# 'minions': ['192.168.79.47', '192.168.110.132', '192.168.110.133']}}
try:
payload = sreq.send(payload_kwargs)
except SaltReqTimeoutError:
log.error(
'Salt request timed out. If this error persists, '
'worker_threads may need to be increased.'
)
return {}
讲了这么多，现在总结下流程。
salt '*' test.ping的流程，类似于卸妆的过程，看到最后的面目。
1、调用SaltCMD处理命令行参数，决定调用LocalClient的哪个方法(默认是cmd_cli)
2、调用LocalClient处理
3、默认调用cmd_cli方法处理
4、调用run_job方法处理
5、调用pub方法处理
6、使用zmq req/req socket通信
7、调用gather_job_info触发saltutil.find_job任务
8、一层层返回结果
从这个流程可知，其实最终调用的就是pub方法。
local.cmd_async('192.168.110.132','test.ping')
local.pub('192.168.110.132','test.ping')
salt命令行的API的讲解就到这里。