salt api

 #!/usr/bin/env python
 # -*- coding:utf8 -*-
 # __author__ = '北方姆Q'

 import requests
 import json
 from django.conf import settings
 from requests.packages.urllib3.exceptions import InsecureRequestWarning
 from plugins.duia.singleton import Singleton

 requests.packages.urllib3.disable_warnings(InsecureRequestWarning)

 class SaltFactory(Singleton):
     def __init__(self, url=settings.SALT_URL, username=settings.SALT_USER, password=settings.SALT_USER_PASSWORD):
         """

         :param url: 默认api url
         :param username: api 用户
         :param password: api 用户密码
         """
         self.url = url
         self.username = username
         self.password = password
         self.header = {"Content-type": "application/json"}
         self.login_url = url + "login" if url.endswith('/') else url + "/login"
         self.login_data = {'username': self.username, 'password': self.password, 'eauth': 'pam'}
         self.token = self.worker(self.login_url, self.login_data)['token']  # 获取该用户的token，便于操作
         self.header['X-Auth-Token'] = self.token
         self.minions_url = self.url + "minions" if self.url.endswith('/') else self.url + "/minions"

     def worker(self, url, data):
         """
         所有命令真实执行者，更细节的命令可以通过这个执行
         :param url: api下各url
         :param data: 需要传入的参数
         :return: 命令执行结果，dict
         """
         data = json.dumps(data)
         response = requests.post(url, headers=self.header, data=data, verify=False)
         return response.json()['return'][0]

     def get_data_by_jid(self, jid, display=False):
         """
         获取某个任务id的执行结果
         :param jid: 任务id，str
         :param display: 结果展示长度，默认精简展示
         :return: 命令执行结果，如果任务不存在或者未运行结束为空字典，dict
         """
         assert isinstance(jid, str)
         data = {
             'client': 'runner',
             'fun': 'jobs.lookup_jid',
             'jid': jid
         }
         ret = self.worker(self.url, data)

         if display is False:
             for node_value in ret.values():
                 for job_key, job_value in node_value.items():
                     node_value[job_key] = job_value['result']
         return ret

     def get_data(self, client='local_batch', tgt='*', fun='test.ping', arg=None, tgt_type='glob', batch='100%'):
         """
         运行一条命令并等待结果
         :param client: 连接方式

             * ``local`` - 普通执行
             * ``local_batch`` - 分批执行 - Default
             * ``local_async`` - 异步执行

         :param tgt: 受控目标
         :param fun: 执行模块
         :param arg: 运行参数（pillar也写在里面），list

             ['pwd', 'test=True']
             ['sleep 5 && touch /root/file || touch /root/test']
             ['keepalived.keepalived.', 'test=True', 'saltenv=prod']

         :param tgt_type: 受控目标类型

             * ``glob`` - Bash glob completion - Default
             * ``pcre`` - Perl style regular expression
             * ``list`` - Python list of hosts
             * ``grain`` - Match based on a grain comparison
             * ``grain_pcre`` - Grain comparison with a regex
             * ``pillar`` - Pillar data comparison
             * ``pillar_pcre`` - Pillar data comparison with a regex
             * ``nodegroup`` - Match on nodegroup
             * ``range`` - Use a Range server for matching
             * ``compound`` - Pass a compound match string
             * ``ipcidr`` - Match based on Subnet (CIDR notation) or IPv4 address.

         :param batch: 一批的数量，数字或者百分比，str
         :return: 命令执行结果，dict
         """
         data = {
             'client': client,
             'tgt': tgt,
             'fun': fun,
             'tgt_type': tgt_type,
             'batch': batch
         }
         if arg:
             data['arg'] = arg
         ret = self.worker(self.url, data)
         return ret

     def get_minions(self):
         """
         获取所有minions名
         :return: 全minions名的generator
         """
         response = requests.get(self.minions_url, headers=self.header, verify=False)
         minions_list = [minion for minion in response.json()['return'][0].keys()]
         return minions_list

前端json解析

         function syntaxHighlight(json) {
             if (typeof json != 'string') {
                 json = JSON.stringify(json, undefined, 2);
             }
             json = json.replace(/&/g, '&').replace(/</g, '<').replace(/>/g, '>');
             return json.replace(/("(\\u[a-zA-Z0-9]{4}|\\[^u]|[^\\"])*"(\s*:)?|\b(true|false|null)\b|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?)/g, function(match) {
                 var cls = 'number';
                 if (/^"/.test(match)) {
                     if (/:$/.test(match)) {
                         cls = 'key';
                     } else {
                         cls = 'string';
                     }
                 } else if (/true|false/.test(match)) {
                     cls = 'boolean';
                 } else if (/null/.test(match)) {
                     cls = 'null';
                 }
                 return '<span class="' + cls + '">' + match + '</span>';
             });
         }