codosdk 1.0.0__py2.py3-none-any.whl

websdk2/salt_api.py

@@ -0,0 +1,107 @@
+#!/usr/bin/env python
+# -*-coding:utf-8-*-
+'''
+Author : SS
+date   : 2017年12月29日14:43:24
+role   : 集中化管理工具的使用
+'''
+
+import requests
+import json
+import time
+
+try:
+    import cookielib
+except:
+    import http.cookiejar as cookielib
+
+import ssl
+
+context = ssl._create_unverified_context()
+import urllib3
+
+urllib3.disable_warnings()
+
+
+class SaltApi:
+    """
+    定义salt api接口的类
+    初始化获得token
+    """
+
+    def __init__(self, url='https://127.0.0.1:8001/', username="saltapi", password="shenshuo"):
+        self.__url = url
+        self.__username = username
+        self.__password = password
+        self.headers = {
+            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/50.0.2661.102 Safari/537.36",
+            "Content-type": "application/json"
+            # "Content-type": "application/x-yaml"
+        }
+        self.params = {'client': 'local', 'fun': '', 'tgt': ''}
+        self.login_url = self.__url + "login"
+        self.login_params = {'username': self.__username, 'password': self.__password, 'eauth': 'pam'}
+        self.token = self.get_data(self.login_url, self.login_params)['token']
+        self.headers['X-Auth-Token'] = self.token
+
+    def get_data(self, url, params):
+        send_data = json.dumps(params)
+        request = requests.post(url, data=send_data, headers=self.headers, verify=False)
+        response = request.json()
+        result = dict(response)
+        return result['return'][0]
+
+    def salt_command(self, tgt, method, arg=None):
+        """远程执行命令，相当于salt 'client1' cmd.run 'free -m'"""
+        if arg:
+            params = {'client': 'local', 'fun': method, 'tgt': tgt, 'arg': arg}
+        else:
+            params = {'client': 'local', 'fun': method, 'tgt': tgt}
+        result = self.get_data(self.__url, params)
+        return result
+
+    def salt_async_command(self, tgt, method, arg=None):  # 异步执行salt命令，根据jid查看执行结果
+
+        """远程异步执行命令"""
+        if arg:
+            params = {'client': 'local_async', 'fun': method, 'tgt': tgt, 'arg': arg}
+        else:
+            params = {'client': 'local_async', 'fun': method, 'tgt': tgt}
+        jid = self.get_data(self.__url, params).get('jid', None)
+        return jid
+
+    def look_jid(self, jid):  # 根据异步执行命令返回的jid查看事件结果
+        params = {'client': 'runner', 'fun': 'jobs.lookup_jid', 'jid': jid}
+        result = self.get_data(self.__url, params)
+        return result
+
+    def run(self, salt_client='*', salt_method='cmd.run_all', salt_params='w', timeout=1800):
+        try:
+            if not self.salt_command(salt_client, 'test.ping')[salt_client]:
+                return -98, 'test.ping error 98', ''
+        except Exception as e:
+            return -99, 'test.ping error 99', str(e)
+
+        t = 0
+        jid = self.salt_async_command(salt_client, salt_method, salt_params)
+        if not jid:
+            return -100, '连接失败', '连接失败或主机不存在'
+
+        while True:
+            time.sleep(5)
+            if t == timeout:
+                print('exec timeout!')
+                break
+            else:
+                t += 5
+            result = self.look_jid(jid)
+            for i in result.keys():
+                return result[i]['retcode'], result[i]['stdout'], result[i]['stderr']
+
+
+if __name__ == '__main__':
+    pass
+    # salt1 = SaltApi()
+    # req = salt1.run('*', 'cmd.run_all', 'w')
+    # status, stdout, stderr = req[0], req[1], req[2]
+    # print(status, stdout, stderr)

websdk2/sqlalchemy_pagination.py

@@ -0,0 +1,73 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+Version : 0.0.1
+Contact : 191715030@qq.com
+Author  : shenshuo
+Date    : 2023/3/2 18:23
+Desc    : 分页
+"""
+
+import math
+from sqlalchemy import desc
+from .model_utils import queryset_to_list
+
+
+class Page(object):
+
+    def __init__(self, items, page, page_size, total):
+        self.items = items
+        self.previous_page = None
+        self.next_page = None
+        self.has_previous = page > 1
+        if self.has_previous: self.previous_page = page - 1
+        previous_items = (page - 1) * page_size
+        self.has_next = previous_items + len(items) < total
+        if self.has_next: self.next_page = page + 1
+        self.total = total
+        self.pages = int(math.ceil(total / float(page_size)))
+
+
+# def paginate(query, order_by: str = None, **query_params):
+#     page = int(query_params.get('page', 1)) if 'page' in query_params else int(query_params.get('page_number', 1))
+#     page_size = int(query_params.get('limit')) if 'limit' in query_params else int(query_params.get('page_size', 10))
+#
+#     if 'order_by' in query_params: order_by = query_params.get('order_by')
+#     items_not_to_list = query_params.get('items_not_to_list')  # 如果不序列化要额外加参数，主要为了连表查询
+#
+#     if page <= 0: raise AttributeError('page needs to be >= 1')
+#     if page_size <= 0: raise AttributeError('page_size needs to be >= 1')
+#     if order_by:
+#         items = query.order_by(order_by).all() if page_size >= 200 else query.order_by(order_by).limit(
+#             page_size).offset((page - 1) * page_size).all()
+#     else:
+#         items = query.all() if page_size >= 200 else query.limit(page_size).offset((page - 1) * page_size).all()
+#
+#     total = query.order_by(order_by).count()
+#     if not items_not_to_list: items = queryset_to_list(items)
+#     return Page(items, page, page_size, total)
+
+
+def paginate(query, order_by: str = None, **query_params):
+    page = int(query_params.get('page', 1)) if 'page' in query_params else int(query_params.get('page_number', 1))
+    page_size = int(query_params.get('limit')) if 'limit' in query_params else int(query_params.get('page_size', 10))
+
+    if 'order_by' in query_params: order_by = query_params.get('order_by')  # 排序字段
+    order = query_params.get('order', 'ascend')  # 正序 倒序 order descend  ascend
+    items_not_to_list = query_params.get('items_not_to_list')  # 如果不序列化要额外加参数，主要为了连表查询
+
+    if page <= 0: raise AttributeError('page needs to be >= 1')
+    if page_size <= 0: raise AttributeError('page_size needs to be >= 1')
+
+    if order_by and order != 'descend':
+        items = query.order_by(order_by).all() if page_size >= 200 else query.order_by(order_by).limit(
+            page_size).offset((page - 1) * page_size).all()
+    elif order_by and order == 'descend':
+        items = query.order_by(desc(order_by)).all() if page_size >= 200 else query.order_by(desc(order_by)).limit(
+            page_size).offset((page - 1) * page_size).all()
+    else:
+        items = query.all() if page_size >= 200 else query.limit(page_size).offset((page - 1) * page_size).all()
+
+    total = query.count()
+    if not items_not_to_list: items = queryset_to_list(items)
+    return Page(items, page, page_size, total)

websdk2/tools.py

@@ -0,0 +1,198 @@
+#!/usr/bin/env python
+# -*-coding:utf-8-*-
+"""
+Author : ss
+date   : 2018年4月12日
+role   : 工具类
+"""
+
+import sys
+import re
+import time
+import redis
+import subprocess
+from concurrent.futures import ThreadPoolExecutor
+from .consts import const
+
+def singleton(class_):
+    instances = {}
+
+    def getinstance(*args, **kwargs):
+        if class_ not in instances:
+            instances[class_] = class_(*args, **kwargs)
+        return instances[class_]
+
+    return getinstance
+
+
+def bytes_to_unicode(input_bytes):
+    if sys.version_info.major >= 3:
+        return str(input_bytes, encoding='utf-8')
+    else:
+        return (input_bytes).decode('utf-8')
+
+
+def convert(data):
+    if isinstance(data, bytes):  return data.decode('utf8')
+    if isinstance(data, dict):   return dict(map(convert, data.items()))
+    if isinstance(data, tuple):  return map(convert, data)
+    return data
+
+
+def check_password(data):
+    return True if re.search("^(?=.*\d)(?=.*[a-z])(?=.*[A-Z]).*$", data) and len(data) >= 8 else False
+
+
+def is_mail(text, login_mail=None):
+    if login_mail:
+        if re.match(r'[0-9a-zA-Z_]{0,19}@%s' % login_mail, text):
+            return True
+        else:
+            return False
+    p = re.compile(r"[^@]+@[^@]+\.[^@]+")
+    # if re.match(r'^[0-9a-zA-Z_]{0,19}@[0-9a-zA-Z]{1,13}\.[com,cn,net]{1,3}$', text):
+    if p.match(text):
+        return True
+    else:
+        return False
+
+
+def is_tel(tel):
+    ### 检查是否是手机号
+    ret = re.match(r"^1[35678]\d{9}$", tel)
+    if ret:
+        return True
+    else:
+        return False
+
+
+def check_contain_chinese(check_str):
+    ### 检查是否包含汉字
+    """
+    :param check_str:
+    :return:
+    """
+    for ch in check_str:
+        if u'\u4e00' <= ch <= u'\u9fff':
+            return True
+    return False
+
+
+class Executor(ThreadPoolExecutor):
+    """ 线程执行类 """
+    _instance = None
+
+    def __new__(cls, *args, **kwargs):
+        if not getattr(cls, '_instance', None):
+            cls._instance = ThreadPoolExecutor(max_workers=10)
+        return cls._instance
+
+
+def exec_shell(cmd):
+    '''执行shell命令函数'''
+    sub = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
+    stdout, stderr = sub.communicate()
+    ret = sub.returncode
+    if ret == 0:
+        return ret, stdout.decode('utf-8').split('\n')
+    else:
+        return ret, stdout.decode('utf-8').replace('\n', '')
+
+
+class RunningProcess:
+    def __init__(self, process):
+        self.process = process
+        self.start_time = time.time()
+
+    def is_running(self):
+        return bool(self.process.poll() is None)
+
+    def read_line(self):
+        return self.process.stdout.readline()
+
+    @property
+    def unread_lines(self):
+        lines = self.process.stdout.readlines()
+        self.process.stdout.close()
+        return lines
+
+    @property
+    def run_state(self):
+        return bool(self.process.poll() == 0)
+
+    def is_timeout(self, exec_time=600):
+        duration = time.time() - self.start_time
+        if duration > exec_time:
+            self.process.terminate()
+            self.process.wait()
+            self.process.communicate()
+            # print("execute timeout, execute time {}, it's killed.".format(duration))
+            return True
+        return False
+
+
+class RedisLock(object):
+    def __init__(self, key, **conf):
+        if not conf:
+            from .configs import configs
+            __redis_info = configs.get(const.REDIS_CONFIG_ITEM, None).get(const.DEFAULT_RD_KEY, None)
+            conf = dict(host=__redis_info.get(const.RD_HOST_KEY), port=__redis_info.get(const.RD_PORT_KEY, 6379),
+                        db=__redis_info.get(const.RD_DB_KEY, 0), password=__redis_info.get(const.RD_PASSWORD_KEY, None))
+
+        self.rdcon = redis.Redis(host=conf.get('host'), port=conf.get('port'), password=conf.get('password'),
+                                 db=conf.get('db', 0))
+        self._lock = 0
+        self.lock_key = "{}_dynamic_test".format(key)
+
+    @staticmethod
+    def get_lock(cls, key_timeout=59, func_timeout=59):
+        ### key过期时间为一分钟，30秒内key任务没有完成则返回失败
+        start_time = time.time()
+        while cls._lock != 1:
+            timestamp = time.time() + key_timeout + 1
+            cls._lock = cls.rdcon.setnx(cls.lock_key, timestamp)
+            lock_key = cls.rdcon.get(cls.lock_key)
+
+            if time.time() - start_time > func_timeout:
+                return False
+            if cls._lock == 1 or (
+                    time.time() > float(lock_key) and time.time() > float(cls.rdcon.getset(cls.lock_key, timestamp))):
+                return True
+            else:
+                time.sleep(1)
+
+    @staticmethod
+    def release(cls):
+        ### 释放lock
+        lock_key = cls.rdcon.get(cls.lock_key)
+        if lock_key and time.time() < float(lock_key): cls.rdcon.delete(cls.lock_key)
+
+
+def deco(cls, release=False):
+    """ 示例
+    @deco(RedisLock("redis_lock_key", **dict(host='127.0.0.1', port=6379, password="", db=1)))
+    def do_func():
+        print("the func called.")
+        time.sleep(50)
+        print("the func end")
+
+
+    do_func()
+    """
+
+    def _deco(func):
+        def __deco(*args, **kwargs):
+            if not cls.get_lock(cls): return False
+            try:
+                return func(*args, **kwargs)
+            finally:
+                ### 执行完就释放key，默认不释放
+                if release: cls.release(cls)
+
+        return __deco
+
+    return _deco
+
+
+def now_timestamp() -> int:
+    return int(round(time.time() * 1000))

websdk2/utils/__init__.py

@@ -0,0 +1,257 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+Contact : 191715030@qq.com
+Author  : shenshuo
+Date    : 2018/12/11
+Desc    : 
+"""
+
+import os
+import time
+import json
+import socket
+import smtplib
+from ..consts import const
+from email.mime.text import MIMEText
+from email.mime.multipart import MIMEMultipart
+import uuid
+
+
+class SendMail(object):
+    def __init__(self, mail_host, mail_port, mail_user, mail_password, mail_ssl=False, mail_tls=False):
+        """
+        :param mail_host:     SMTP主机
+        :param mail_port:     SMTP端口
+        :param mail_user:     SMTP账号
+        :param mail_password: SMTP密码
+        :param mail_ssl:      SSL=True, 如果SMTP端口是465，通常需要启用SSL，  如果SMTP端口是587，通常需要启用TLS
+        """
+        self.mail_host = mail_host
+        self.mail_port = mail_port
+        self.__mail_user = mail_user
+        self.__mail_password = mail_password
+        self.mail_ssl = mail_ssl
+        self.mail_tls = mail_tls
+
+    def send_mail(self, to_list, subject, content, subtype='plain', att=None):
+        """
+        :param to_list:  收件人，多收件人半角逗号分割， 必填
+        :param subject:  标题， 必填
+        :param content:  内容， 必填
+        :param subtype:  格式，默认：plain, 可选html
+        :param att:      附件，支持单附件，选填
+        """
+        msg = MIMEMultipart()
+        msg['Subject'] = subject  ## 标题
+        msg['From'] = self.__mail_user  ## 发件人
+        msg['To'] = to_list  # 收件人，必须是一个字符串
+        # 邮件正文内容
+        msg.attach(MIMEText(content, subtype, 'utf-8'))
+        if att:
+            if not os.path.isfile(att):
+                raise FileNotFoundError('{0} file does not exist'.format(att))
+
+            dirname, filename = os.path.split(att)
+            # 构造附件1，传送当前目录下的 test.txt 文件
+            att1 = MIMEText(open(att, 'rb').read(), 'base64', 'utf-8')
+            att1["Content-Type"] = 'application/octet-stream'
+            # 这里的filename可以任意写，写什么名字，邮件中显示什么名字
+            att1["Content-Disposition"] = 'attachment; filename="{0}"'.format(filename)
+            msg.attach(att1)
+
+        try:
+            if self.mail_ssl:
+                '''SSL加密方式，通信过程加密，邮件数据安全, 使用端口465'''
+                # print('Use SSL SendMail')
+                server = smtplib.SMTP_SSL(host=self.mail_host)
+                server.connect(self.mail_host, self.mail_port)  # 连接服务器
+                server.login(self.__mail_user, self.__mail_password)  # 登录操作
+                server.sendmail(self.__mail_user, to_list.split(','), msg.as_string())
+                server.close()
+            elif self.mail_tls:
+                # print('Use TLS SendMail')
+                '''使用TLS模式'''
+                server = smtplib.SMTP()
+                server.connect(self.mail_host, self.mail_port)  # 连接服务器
+                server.starttls()
+                server.login(self.__mail_user, self.__mail_password)  # 登录操作
+                server.sendmail(self.__mail_user, to_list.split(','), msg.as_string())
+                server.close()
+                return True
+            else:
+                '''使用普通模式'''
+                server = smtplib.SMTP()
+                server.connect(self.mail_host, self.mail_port)  # 连接服务器
+                server.login(self.__mail_user, self.__mail_password)  # 登录操作
+                server.sendmail(self.__mail_user, to_list.split(','), msg.as_string())
+                server.close()
+                return True
+        except Exception as e:
+            print(str(e))
+            return False
+
+
+
+def mail_login(user, password, mail_server='smtp.exmail.qq.com'):
+    ### 模拟登录来验证邮箱
+    try:
+        server = smtplib.SMTP()
+        server.connect(mail_server)
+        server.login(user, password)
+        return True
+    except Exception as e:
+        print(user, e)
+        return False
+
+
+# def get_contain_dict(src_data: dict, dst_data: dict) -> bool:
+#     if not isinstance(src_data, dict):
+#         try:
+#             src_data = json.loads(src_data)
+#         except Exception as err:
+#             return False
+#
+#     if not isinstance(dst_data, dict):
+#         try:
+#             dst_data = json.loads(dst_data)
+#         except Exception as err:
+#             return False
+#
+#     # src_key = list(src_data.keys())
+#     # dst_key = list(dst_data.keys())
+#     pd = [False for c in src_data.keys() if c not in dst_data]
+#     if pd:
+#         return False
+#     else:
+#         src_val = list(src_data.values())
+#         dst_val = list(dst_data.values())
+#         pds = [False for c in src_val if c not in dst_val]
+#         if pds:
+#             return False
+#         else:
+#             return True
+
+def get_contain_dict(src_data: dict, dst_data: dict) -> bool:
+    if not isinstance(src_data, dict):
+        try:
+            src_data = json.loads(src_data)
+        except Exception as err:
+            return False
+
+    if not isinstance(dst_data, dict):
+        try:
+            dst_data = json.loads(dst_data)
+        except Exception as err:
+            return False
+
+    ### 判断键是否存在
+    pd = [False for c in src_data.keys() if c not in dst_data]
+    if pd:
+        return False
+    else:
+        src_val = list(src_data.values())
+        dst_val = list(dst_data.values())
+        pds = [False for c in src_val if c not in dst_val]
+        if pds:
+            try:
+                for d in dst_val:
+                    if isinstance(d, dict) and src_val and isinstance(src_val[0], dict):
+                        pds1 = [True for sv in src_val[0].keys() if sv in d and d.get(sv) == src_val[0].get(sv)]
+                        if True in pds1: return True
+            except:
+                return False
+            return False
+        else:
+            return True
+
+def now_time_stamp() -> int:
+    """
+    秒时间戳
+    :return: int
+    """
+    return int(time.time())
+
+
+### 这个地址具有唯一性
+def get_node_address():
+    node_name = os.getenv(const.NODE_ADDRESS) if os.getenv(const.NODE_ADDRESS) else socket.gethostname()
+    mac = uuid.UUID(int=uuid.getnode()).hex[-12:]
+    return f'{node_name}--mac-{mac}'
+
+
+### 这个地址是默认可以通配的
+def get_node_topic(node=False):
+    if not node:
+        if os.getenv(const.NODE_ADDRESS): return os.getenv(const.NODE_ADDRESS) + '#'
+        mac = uuid.UUID(int=uuid.getnode()).hex[-12:]
+        return f'{socket.gethostname()}--mac-{mac}#'
+    else:
+        if os.getenv(const.NODE_ADDRESS): return os.getenv(const.NODE_ADDRESS)
+        mac = uuid.UUID(int=uuid.getnode()).hex[-12:]
+        return f'{socket.gethostname()}--mac-{mac}'
+
+
+### 令牌桶限流
+'''
+示例
+import time
+from settings import settings
+from websdk2.configs import configs
+from websdk2.cache_context import cache_conn
+
+if configs.can_import: configs.import_dict(**settings)
+
+redis_conn = cache_conn()
+obj = TokenBucket(redis_conn, 'ss', 5, 60)
+for i in range(120):
+    time.sleep(0.5)
+    status = obj.can_access('tuanzi')
+    print(status)
+'''
+
+
+class TokenBucket:
+    """令牌桶限流"""
+
+    # bucket_key  用来标记令牌
+    # func_name   第二段标记
+    # capacity = 5  # 桶容量
+    # rate = 1  # 速率 每分增加一个令牌
+
+    def __init__(self, cache, bucket_key, capacity: int = 5, rate: int = 1):
+        self.bucket_key = bucket_key  # 用来标记令牌桶
+        self.capacity = capacity  # 桶容量
+        self.rate = rate  # 速率 每分钟增加的令牌
+        self.cache = cache
+        if not isinstance(rate, int): raise Exception('Rate must be int')
+
+    def can_access(self, func_name) -> bool:
+        """令牌桶限流"""
+        redis_key = self.bucket_key + func_name
+
+        now = int(time.time())
+        current_tokens = self.cache.hget(redis_key, 'current_tokens')
+        last_time = self.cache.hget(redis_key, 'last_time')
+
+        current_tokens = current_tokens if current_tokens else self.capacity
+        try:
+            current_tokens = int(current_tokens)
+        except:
+            current_tokens = float(current_tokens)
+            self.capacity = float(self.capacity)
+
+        last_time = int(last_time) if last_time else now
+
+        increase_tokens = (now - last_time) * self.rate / 60  # 增加的令牌桶  按分钟计算
+        current_tokens = min(self.capacity, current_tokens + increase_tokens)
+        if current_tokens > 0:
+            self.cache.hset(redis_key, 'current_tokens', current_tokens - 1)
+            self.cache.hset(redis_key, 'last_time', int(time.time()))
+            return True
+        else:
+            return False
+
+
+if __name__ == '__main__':
+    pass