salt api接口python封装

import requests
import functools
import ast


class SaltClient(object):
    auth_token_key = "salt:netapi:auth:token"

    def __init__(self):
        self._redis = get_redis_client()  # redis 客户端
        self._api = https://0.0.0.0:8008
        self._client = requests.Session()
        self._client.headers.update({
            "Content-Type": "application/json",
            "Accept": "application/json",
        })
        self.set_auth_token()

    def set_auth_token(self):
        token = self._redis.get(self.auth_token_key) # redis缓存
        if token is None:
            token = self._get_auth_token()
        self._client.headers["X-Auth-Token"] = token

    def clear_token_cache(self):
        self._redis.delete(self.auth_token_key)

    def _get_auth_token(self):
        data = {
            "username": "saltapi",
            "password": "saltapi",
            "eauth": "pam",
        }
        rsp = self.post("/login", data)
        if rsp.status_code != 200:
            raise SaltAuthError(rsp.status_code, rsp.content)
        ret = rsp.json()["return"][0]
        token = ret["token"]
        start = ret["start"]
        expire = ret["expire"]
        print(start, expire)
        self._redis.set(self.auth_token_key, token, ex=int(expire-start))
        return token

    def post(self, url, data, timeout=None):
        full_path = "{}{}".format(self._api, url)
        if settings.SALT_API.startswith("https://"):
            func = functools.partial(self._client.post, verify=False)
        else:
            func = self._client.post
        rsp = func(full_path, json=data, timeout=timeout)
        if rsp.status_code == 401:
            self.clear_token_cache()
            self.set_auth_token()
            rsp = func(full_path, json=data, timeout=timeout)
        return rsp

    def get(self, url, params=None, timeout=None):
        full_path = "{}{}".format(settings.SALT_API, url)
        if settings.SALT_API.startswith("https://"):
            func = functools.partial(self._client.get, verify=False)
        else:
            func = self._client.get
        rsp = func(full_path, params=params, timeout=timeout)
        if rsp.status_code == 401:
            self.clear_token_cache()
            self.set_auth_token()
            rsp = func(full_path, params=params, timeout=timeout)
        return rsp

    def run(self, tgt, fun, arg=(), tgt_type='glob',
                timeout=None, kwarg=None):
        data = [{
            "client": "local",
            "tgt": tgt,
            "tgt_type": tgt_type,
            "expr_form": tgt_type,
            "fun": fun,
            "arg": arg,
            "timeout": timeout,
            "kwarg": kwarg,
        }]
        rsp = self.post("/", data)
        return rsp.json()["return"][0]

    def run_async(self, tgt, fun, arg=(), tgt_type='glob',
                  timeout=None, kwarg=None):
        data = [{
            "client": "local_async",
            "tgt": tgt,
            "tgt_type": tgt_type,
            "expr_form": tgt_type,
            "fun": fun,
            "arg": arg,
            "timeout": timeout,
            "kwarg": kwarg,
        }]
        rsp = self.post("/", data)
        return rsp.json()["return"][0]

    def list_key(self):
        data = [{
            "client": "wheel",
            "fun": "key.list_all",
        }]
        rsp = self.post("/", data)
        print(rsp.json())

    def get_jobs(self):
        rsp = self.get("/jobs")
        return rsp.json()

    def get_job_result(self, jid, timeout=2):
        try:
            rsp = self.get("/jobs/{}".format(jid), timeout=timeout)
        except requests.exceptions.Timeout:
            logger.error("get job %s timeout", jid)
            return None
        else:
            Result = rsp.json()["return"][0]["Result"]
            result = {}
            for minion, ret in Result.items():
                try:
                    result[minion] = ast.literal_eval(ret.get("return", ""))
                except (ValueError, SyntaxError):
                    result[minion] = ret.get("return", "")
                except Exception:
                    result[minion] = ""
            return result

    def get_minions(self):
        rsp = self.get("/minions")
        return rsp.json()["return"][0]

    def get_minion(self, minion_id):
        rsp = self.get("/minions/{}".format(minion_id))
        return rsp.json()["return"][0]

    def __del__(self):
        self._client.close()


if __name__ == "__main__":
    salt_client = SaltClient()
    import time
    # 异步方式
    ret = salt_client.run_async("*", "sys.list_modules")
    time.sleep(3)
    #data = salt_client.get_job_result(ret["jid"])
    # 同步方式
    data = salt_client.run("*", "test.ping", tgt_type="list", timeout=10)