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*:)?|(true|false|null)|-?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>';
            });
        }