【python用法】property

# !/usr/bin/env python
# coding:utf-8


class TestProperty:

    def __init__(self):
        self.num = 1

    @property
    def get_num(self):
        return self.num

    @property
    def set_num(self):
        self.num += 1
        return self.num

    def del_num(self):
        del self.num


class TestProperty1(object):

    def __init__(self):
        self.num = 1

    @property
    def get_num(self):
        return self.num

    @get_num.setter
    def set_num(self, value):
        self.num = value

    @get_num.deleter
    def del_num(self):
        del self.num


class TestProperty2(object):

    def __init__(self):
        self.num = 1

    def get_num(self):
        return self.num

    def set_num(self, value):
        self.num = value

    def del_num(self):
        del self.num

    BAR = property(get_num, set_num, del_num,)


if __name__ == '__main__':
    t = TestProperty2()
    # t.set_num = 3\
    t.BAR = 3
    print(t.BAR)

 

#!/usr/bin/env python
# encoding: utf-8

import json
import os


class TemplateSchemaCenter(object):

    @staticmethod
    def get_template_schema(list_path, func_name):
        """
        获取各模块目录下的json模板和schema模板
        :param list_path:调用者的文件路径
        :param func_name:函数名
        :return: 该函数的json模板，schema模板
        """
        # 暂时处理，template非必需品
        template = ""
        schema = ""
        schema_file_path = os.path.join(list_path, "json_schema", "%s_schema.json" % func_name)
        template_file_path = os.path.join(list_path, "json_template", "%s.json" % func_name)

        print(template_file_path)
        print(os.path.isfile(template_file_path))
        if os.path.exists(template_file_path):
            template = json.loads(open(template_file_path).read())
        if os.path.exists(schema_file_path):
            schema = json.loads(open(schema_file_path).read())
        return template, schema

#!/usr/bin/env python
# encoding: utf-8


class AutoInsertJson(object):
    """stage
    st1: complete path
    st2: part path"""
    key_paths = []

    def _get_key_path(self, json_template, field_name="", path_sep="->"):
        """

        :param json_template: json模板
        :param field_name: 直接取默认值，不用填，递归自调
        :param path_sep:
        :return:
        """

        for field in json_template:
            if not isinstance(json_template[field], dict):
                self.key_paths.append(field_name + field)
            elif json_template[field] == {}:
                self.key_paths.append(field)
            else:
                self._get_key_path(json_template[field], field_name + field + path_sep)

    def _get_key_path_list(self, json_template, field_name="", path_sep="->"):
        """
        return key_path_list
        [["a","b"], ["a","b", "c"]] ...
        :param json_template:
        :param field_name:
        :param path_sep:
        :return:
        """
        key_path_list = []
        self._get_key_path(json_template, field_name, path_sep)
        # LOG_DEBUG("field path is %s" % self.key_paths)

        for key_path in self.key_paths:
            temp = key_path.split(path_sep)
            key_path_list.append(temp)

        # LOG_DEBUG("field path list is %s" % key_path_list)
        return key_path_list

    def _set_field(self, target_dict, field_path, value, path_sep="->"):
        """

        :param target_dict:
        :param field_path: a -> b -> c...
        :param value:
        :param path_sep: ->
        :return:
        """
        field_list = field_path.split(path_sep)
        field_list = map(lambda x: x.strip(), field_list)
        temp_dict = target_dict

        for index in range(0, len(field_list) - 1):
            temp_dict = temp_dict[field_list[index]]

        temp_dict[field_list[-1]] = value
        return target_dict

    def _is_exist_key_path(self, src_dict, key_path, path_sep="->"):
        """

        :param src_dict:
        :param key_path:
        :param path_sep:
        :return:
        """
        all_key_path_list = self._get_key_path_list(json_template=src_dict, path_sep=path_sep)
        key_path_list = key_path.split(path_sep)
        key_path_list = map(lambda x: x.strip(), key_path_list)
        result = key_path_list in all_key_path_list
        return result

    def change_json(self, json_template, conf, path_sep="->"):
        """
        stage1:  complete path
        stage2:  part path
        :param json_template:
        :param conf:
        :param path_sep:
        :return:
        """
        for replaced_path in conf:
            replaced_value = conf[replaced_path]
            if not self._is_exist_key_path(json_template, replaced_path, path_sep):
                print("input conf is invalid")
                return False
            # LOG_DEBUG("set %s value %s" % (replaced_path, replaced_value))
            self._set_field(json_template, field_path=replaced_path, value=replaced_value, path_sep=path_sep)

        return json_template


if __name__ == '__main__':
    src_json = dict()
    src_json["data"] = dict()
    src_json["data"]["a"] = dict()
    src_json["data"]["a"]["a1"] = 1
    src_json["data"]["b"] = 2
    print(src_json)
    setting_conf = {"data->a->a1": 1, "data->b": 3}
    AutoInsertJson().change_json(src_json, conf=setting_conf)
    print(src_json)

#!/usr/bin/env python
# encoding: utf-8
import os
from .get_template_schema import TemplateSchemaCenter
from .auto_insert_json import AutoInsertJson

LIST_PATH = os.path.dirname(os.path.dirname(os.path.realpath(__file__)))


def modify_pc_request_json(json_dir_path, json_name, replaced_conf):
    result = TemplateSchemaCenter.get_template_schema(json_dir_path, json_name)
    post_data = result[0]
    # post_json = str(AutoInsertJson().change_json(post_data, replaced_conf)).replace('\'', '\\\"').replace('u\\', '\\').replace(' ', '')
    # print("[REPLACE] post json %s " % post_json)
    return post_data


replaced_conf = {
    "auto_test": False,
}
post_data = modify_pc_request_json(LIST_PATH, "asset_info_box", replaced_conf)
print(post_data)

 

#!/usr/bin/env python
# encoding: utf-8
import ctypes
import time, datetime
from threading import Thread
from mgr.common.logger import *
import subprocess as sp
import paramiko
import platform
import shutil
import socket
import sys
import subprocess
from ea.tests.common.func_call_count import *
from ea.tests.common.ftp_down_upload import *
import re
import codecs
import inspect
import traceback


def robust(func):
    """
    异常追踪装饰器
    :param func:
    :return:
    """
    def add_robust(*args, **kwargs):
        try:
            previous_frame = inspect.currentframe().f_back
            caller_filename, caller_line_number, caller_function_name, caller_lines, caller_index = inspect.getframeinfo(
                previous_frame)
            LOG_DEBUG('caller_filename: {}, caller_line_number: {}, caller_function_name: {}'.format(caller_filename,
                                                                                                 caller_line_number,
                                                                                                 caller_function_name))
            return func(*args, **kwargs)
        except Exception:
            LOG_ERROR('Error execute func:{}'.format(func.__name__))
            traceback.print_exc()
    return add_robust


def time_limit_ex(timeout, func, args=[], kwargs=None):
    """
    函数运行时间限制，超时后会报错误,成功返回运行结果
    :param timeout: 超时时间
    :param func: 函数
    :param args: 传给函数的参数args
    :param kwargs: 传给函数的参数kwargs
    :return: 成功返回，func运行结果
    """
    if kwargs is None:
        kwargs = {}
    if not isinstance(timeout, (int, float)) or timeout <= 0:
        raise Exception("timeout param error:%s" % timeout)

    class FuncThread(Thread):
        def __init__(self):
            Thread.__init__(self)
            self.result = None

        def run(self):
            try:
                self.result = func(*args, **kwargs)
            except Exception, e:
                self.result = e

        def stop(self):
            if self.isAlive():
                Thread._Thread__stop(self)

    thread = FuncThread()
    thread.start()
    thread.join(timeout)
    if thread.isAlive():
        thread.stop()
        return "time out"
    else:
        return thread.result


def time_limit(timeout, func, args=[], kwargs=None):
    """
    函数运行时间限制，超时后会报错误,成功返回运行结果
    :param timeout: 超时时间
    :param func: 函数
    :param args: 传给函数的参数args
    :param kwargs: 传给函数的参数kwargs
    :return: 成功返回，func运行结果
    """
    if kwargs is None:
        kwargs = {}
    if not isinstance(timeout, (int, float)) or timeout <= 0:
        raise Exception("timeout param error:%s" % timeout)

    class FuncThread(Thread):
        def __init__(self):
            Thread.__init__(self)
            self.result = None

        def run(self):
            try:
                self.result = func(*args, **kwargs)
            except Exception, e:
                self.result = e

        def stop(self):
            if self.isAlive():
                Thread._Thread__stop(self)

    thread = FuncThread()
    thread.start()
    thread.join(timeout)
    if thread.isAlive():
        thread.stop()
        raise Exception("run function %s time out" % func)
    else:
        return thread.result


def loop_assert(func, _result=None, retry_count=1, interval=1, timeout=0, args=[], kwargs=None, comparator='eq',
                comparator_target=None, eval_func_name=''):
    """
    轮询模块
    :param func:需要执行的function
    :param _result: 执行function预期返回结果
    :param retry_count: 重试次数 正整数大于0
    :param interval: 重试时间间隔   正整数大于0，如果为0 则没有超时时间
    :param timeout: 函数执行的超时时间 正整数大于0,默认为0时,不做超时处理
    :param args: 传给函数的参数args 元祖类型
    :param kwargs: 传给函数的参数kwargs 字典类型
    :param comparator: 比较器, ['eq', 'neq, 'gt', 'ge', 'lt', 'le', 'len_eq', 'len_gt', 'len_lt',
                                'contains', 'contains_by', 'startswith', 'endswith']
    :param comparator_target: 用于分解func的返回结果，用于比较验证
        e.g. resp = {'success': True, 'data': [{'name':'test'}, {'agents':[1,2,3]} ] }
        ===> comparator_target = ('data', 1, 'agent', 0)
        ===> 解析出 1,用于后续和_result比较
    :param eval_func_name: type:str 用于将返回的结果进一步解析，在和_result比对,参数为函数名字符串, e.g. 'len', ...
    :return: list(bool,str) 成功返回True,None ；失败返回False,msg
    """
    # 参数校验
    if not isinstance(retry_count, int) or retry_count <= 0:
        raise Exception("retry_count param error:%s" % retry_count)
    if not isinstance(interval, (int, float)) or interval < 0:
        raise Exception("interval param error:%s" % interval)
    if not isinstance(timeout, (int, float)) or timeout < 0:
        raise Exception("timeout param error:%s" % timeout)
    if kwargs is None:
        kwargs = {}
    res = False
    result = None
    while retry_count:
        try:
            if timeout == 0:
                res_fun = func(*args, **kwargs)
            else:
                res_fun = time_limit(timeout, func, args, kwargs)
        except Exception as e:
            LOG_EXCEPTION(e)
            retry_count -= 1
            time.sleep(interval)
        else:
            if comparator_target:
                res_fun_value = res_fun
                try:
                    for i in comparator_target:
                        res_fun_value = res_fun_value[i]
                except Exception as e:
                    LOG_DEBUG('Decomposition result exception: {}'.format(e))
                    res_fun_value = res_fun
            else:
                res_fun_value = res_fun
            if eval_func_name:
                try:
                    res_fun_value = eval(eval_func_name + '({})'.format(res_fun_value))
                except Exception as e:
                    LOG_DEBUG(e)
                    res_fun_value = res_fun_value
            if comparator == 'eq':
                res = bool(res_fun_value == _result)
            elif comparator == 'neq':
                res = not bool(res_fun_value == _result)
            elif comparator == 'gt':
                res = bool(res_fun_value > _result)
            elif comparator == 'ge':
                res = bool(res_fun_value >= _result)
            elif comparator == 'lt':
                res = bool(res_fun_value < _result)
            elif comparator == 'le':
                res = bool(res_fun_value <= _result)
            elif comparator == 'len_eq':
                res = bool(len(res_fun_value) == len(_result))
            elif comparator == 'len_gt':
                res = bool(len(res_fun_value) >= len(_result))
            elif comparator == 'len_lt':
                res = bool(len(res_fun_value) <= len(_result))
            elif comparator == 'contains':
                res = bool(str(_result) in str(res_fun_value))
            elif comparator == 'contains_by':
                res = bool(str(res_fun_value) in str(_result))
            elif comparator == 'startswith':
                res = bool(str(res_fun_value).startswith(str(_result)))
            elif comparator == 'endswith':
                res = bool(str(res_fun_value).endswith(str(_result)))
            else:
                LOG_DEBUG('Not support comparator: {}'.format(comparator))
                # raise AssertionError
                res = False
                res_fun_value = 'Not support comparator: {}'.format(comparator)
            if res:
                break
            else:
                retry_count -= 1
                time.sleep(interval)
                # 出错时返回错误信息
                result = res_fun_value
    LOG_DEBUG('loop_res: {}, loop_result: {}'.format(res, result))
    return res, result


def exec_command(ip, username, password, cmd, port=1, option=0, timeout=5):
    """
    远程Linux端,执行命令
    :param ip:IP
    :param username:str 用户名
    :param password:str 密码
    :param cmd:str 命令 可输入：linux命令/tcp/udp
    :param port:str 端口
    :param timeout:超时时间
    :param option：命令项控制参数  0 cmd = "nohup python [cmd] -p [port] > /dev/null 2>&1 &"
                                          [cmd]:传入tcp_server.py/udp_server.py
                                 1 cmd = cmd
    :return:
    """
    previous_frame = inspect.currentframe().f_back
    caller_filename, caller_line_number, caller_function_name, caller_lines, caller_index = inspect.getframeinfo(
        previous_frame)
    LOG_DEBUG('caller_filename: {}, caller_line_number: {}, caller_function_name: {}'.format(caller_filename,
                                                                                             caller_line_number,
                                                                                             caller_function_name))
    ret = False
    if option == 0:
        cmd = "nohup python %s -p %r > /dev/null 2>&1 &" % (cmd, port)
    LOG_DEBUG("Exec commman:%s" % cmd)
    try:
        ssh = paramiko.SSHClient()
        key = paramiko.AutoAddPolicy()
        ssh.set_missing_host_key_policy(key)
        ssh.connect(ip, 22, username, password, timeout=timeout)
        stdin, stdout, stderr = ssh.exec_command(cmd)
        out, err = stdout.read(), stderr.read()
        if err:
            LOG_ERROR("Exec command %s err message: %s" % (cmd, err))
        else:
            LOG_DEBUG("Exec command %s out message: %s" % (cmd, out))

    except Exception, e:
        LOG_DEBUG("Connect %s failed,%s" % (ip, e))
    else:
        if option == 0:
            ret = True
        else:
            if out.replace("\n", "") == "TCP_Server_TestTEST":
                ret = True
            elif option == 1:
                ret = False
            ##用于执行其他命令
            else:
                ret = True
        ssh.close()
    return ret


def ssh_connect(ip, port=22, username="root", password="root", cmd="", timeout=5, read_timeout=10):
    """
    远程连接Linux终端
    :param ip:
    :param username:
    :param password:
    :param port:
    :param cmd:
    :param timeout:
    :return:
    """

    ret = False
    LOG_DEBUG("执行命令:%s" % cmd)
    try:
        ssh = paramiko.SSHClient()
        key = paramiko.AutoAddPolicy()
        ssh.set_missing_host_key_policy(key)
        ssh.connect(ip, port, username, password, timeout=timeout)
        if cmd != "":
            stdin, stdout, stderr = ssh.exec_command(cmd, timeout=read_timeout)
            out, err = stdout.read(), stderr.read()
            if err:
                LOG_ERROR("exec command %s err message: %s" % (cmd, err))
            else:
                LOG_DEBUG("exec command %s out message: %s" % (cmd, out))
    except Exception, e:
        LOG_ERROR("Ssh connect %s exception：%s" % (ip, e))
    else:
        LOG_DEBUG("Ssh connect %s success" % ip)
        ret = True
    return ret


def ssh_connect_with_output(ip, port=22, username="root", password="root", cmd="", timeout=5, read_timeout=10):
    """
    和上一个方法基本一致，仅返回参数多了out，怕影响其他代码，重新定义一个方法
    远程连接Linux终端,返回带输入结果
    :param ip:
    :param username:
    :param password:
    :param port:
    :param cmd:
    :param timeout:
    :return:(ret, out)
    """

    ret = False
    out = ''
    LOG_DEBUG("Exec command:%s" % cmd)
    previous_frame = inspect.currentframe().f_back
    caller_filename, caller_line_number, caller_function_name, caller_lines, caller_index = inspect.getframeinfo(
        previous_frame)
    LOG_DEBUG('caller_filename: {}, caller_line_number: {}, caller_function_name: {}'.format(caller_filename,
                                                                                             caller_line_number,
                                                                                             caller_function_name))
    try:
        ssh = paramiko.SSHClient()
        key = paramiko.AutoAddPolicy()
        ssh.set_missing_host_key_policy(key)
        ssh.connect(ip, port, username, password, timeout=timeout)
        if cmd != "":
            stdin, stdout, stderr = ssh.exec_command(cmd, timeout=read_timeout)
            out, err = stdout.read(), stderr.read()
            if err:
                LOG_ERROR("exec command %s err message: %s" % (cmd, err))
            else:
                LOG_DEBUG("exec command %s out message: %s" % (cmd, out))
        ssh.close()
    except Exception, e:
        LOG_ERROR("Ssh connect exception：%s" % (e))
    else:
        LOG_DEBUG("Ssh connect %s success" % ip)
        ret = True
    return (ret, out.strip())


def get_local_ip():
    # 部分linux系统无法获取ip
    try:
        local_ip_addr = socket.gethostbyname(socket.getfqdn(socket.gethostname()))
    except Exception as e:
        LOG_DEBUG('Get local IP address error:{}'.format(e))
        local_ip_addr = '127.0.0.1'
    return local_ip_addr


def get_format_system_info():
    # 获取当前系统版本信息,转换为自动化环境命名规则,对于特殊系统，进行特殊匹配
    # 格式规则: 系统 + 版本号 + _ + 32/64
    # win7_32/win7_64_sp1/win10_64/win8_32/win8.1_32/win8.1_64/vista/xpsp3
    # win2008R2_64(sp1)/server2008_32/win2012_64/win2016_64/server2003_64/server2019_64/server2003_32/server2019_64
    # centos7_64/ubuntu13_64/ubuntu16_64/debian9_64/RHEL7_64

    platform_uname = platform.uname()
    if platform_uname[0] == 'Windows':
        cur_system_info = 'win' + platform_uname[2][:4] + '_' + platform_uname[4][-2:]  # e.g. win7_64
    if platform_uname[0] == 'Linux':
        linux_distribution_info = platform.linux_distribution()
        linux_name = linux_distribution_info[0].split(' ')[0]
        linux_version_tuple = linux_distribution_info[1].split('.')
        linux_version = linux_version_tuple[0]
        linux_bit = platform.architecture()[0][:2]
        cur_system_info = linux_name + linux_version + '_' + linux_bit
    else:
        pass
    return cur_system_info.lower()


def run_system(system_info):
    # 用于ea层的装饰器，仅当system_info与当前系统版本一致时，才跑指定的测试用例
    system_info_list = system_info.split(',')
    # 兼容将86系统写成32
    # ['win7_32', 'win7_64'] ==> ['win7_32', 'win7_64', 'win7_86']
    system_info_list_plus = []
    for item in system_info_list:
        system_info_list_plus.append(item)
        if item[-2:] == '32':
            system_info_list_plus.append(item[:-2]+'86')

    def decorator(func):
        def wrapper(*args, **kwargs):
            # 对无法获取系统信息的操作系统做特殊匹配, system_map 后续持续添加
            system_map = {'win2016_64': ['10.186.0.35', '10.186.1.35', '10.186.2.35', '10.186.3.35', '10.186.4.35',
                                         '10.186.5.35'],
                          'server2019_64': ['10.186.0.64', '10.186.1.64', '10.186.2.64', '10.186.3.64', '10.186.4.64',
                                            '10.186.5.64'],
                          '中标麒麟': ['10.186.0.61', '10.186.1.61', '10.186.2.61', '10.186.3.61', '10.186.4.61',
                                   '10.186.5.61'],
                          '银河麒麟': ['10.186.0.62', '10.186.1.62', '10.186.2.62', '10.186.3.62', '10.186.4.62',
                                   '10.186.5.62']}
            for system_info_ in system_info_list_plus:
                if system_info_ in system_map:
                    # 该操作系统指定规划的ip
                    map_ip = system_map[system_info_]
                    local_ip = get_local_ip()
                    if local_ip in map_ip:
                        return func(*args)
                    else:
                        LOG_DEBUG('System IP not match： {} != {}, skip'.format(map_ip, local_ip))
                cur_system_info = get_format_system_info()
                if system_info_.lower() == cur_system_info.lower():
                    return func(*args)
                else:
                    LOG_DEBUG('System version not match： {} != {}, skip'.format(system_info_, cur_system_info))

        return wrapper

    return decorator


def limit_system(system_info):
    # 用于ea层的装饰器，仅当system_info与当前系统版本一致时，不跑指定的测试用例
    system_info_list = system_info.split(',')
    # 兼容将86系统写成32
    # ['win7_32', 'win7_64'] ==> ['win7_32', 'win7_64', 'win7_86']
    system_info_list_plus = []
    for item in system_info_list:
        system_info_list_plus.append(item)
        if item[-2:] == '32':
            system_info_list_plus.append(item[:-2] + '86')

    def decorator(func):
        def wrapper(*args, **kwargs):
            # 对无法获取系统信息的操作系统做特殊匹配, system_map 后续持续添加
            system_map = {'win2016_64': '10.186.3.35', 'server2019_64': '10.186.3.64', '中标麒麟': '10.186.3.61',
                          '银河麒麟': '10.186.3.62'}
            for system_info_ in system_info_list_plus:
                if system_info_ in system_map:
                    # 该操作系统指定规划的ip
                    map_ip = system_map[system_info_]
                    local_ip = get_local_ip()
                    if map_ip == local_ip:
                        LOG_DEBUG('System IP not match： {} != {}, skip'.format(map_ip, local_ip))
                    else:
                        return func(*args)
                cur_system_info = get_format_system_info()
                if system_info_.lower() == cur_system_info.lower():
                    LOG_DEBUG('System version not match： {} != {}, skip'.format(system_info_, cur_system_info))
                else:
                    return func(*args)

        return wrapper

    return decorator


# def lock_resource_on_func(cls, resource_list):
#     """
#     资源锁加锁装饰器, 装饰在 测试方法上
#     :param cls: type: TestSomething 某个测试模块的类实例
#     :param resource_list: type:list 需要加锁的资源 具体字段看resource表
#     :return:
#     """
#     update_params = {item: cls.cur_node_id for item in resource_list}
#
#     def decorator(func):
#         def wrapper(*args, **kwargs):
#             try:
#                 func(*args, **kwargs)
#                 cls.redis_queue.lock_resource(update_param=update_params)
#             except Exception as e:
#                 LOG_DEBUG(e)
#             finally:
#                 cls.clear_env()
#
#         return wrapper
#
#     return decorator


@total
def os_system_exec_command(cmd):
        """
        执行命令
        :param cmd:
        :return:
        """
        if platform.system() == 'Linux':
            os.system(cmd)
        else:
            os.system(cmd + '&&exit')
        return False


def exec_command_with_popen(cmd):
    """
    执行windows或者linux命令行
    :param cmd: 命令
    :return: 返回值
    """
    f = os.popen(cmd + '&&exit', "r")
    ret = f.read()  # 读文件
    if platform.system().lower() == 'windows':
        ret = ret.decode('gbk', errors='ignore')
        ret = ret.encode('utf-8', errors='ignore')
    else:
        pass
    LOG_DEBUG(r'Exec command: {}'.format(cmd))
    LOG_DEBUG(r'Result：{}'.format(ret))
    f.close()
    return ret


def loop_exec_command(cmd, _result=True, retry_count=5, interval=1, timeout=3):
    """
    循环执行同一个命令
    :param cmd:
    :param retry_count:
    :param interval:
    :param timeout:
    :return:
    """
    loop_assert(os_system_exec_command, _result, retry_count, interval, timeout,args=(cmd,))


def time_exec_command(command, timeout=2):
    """call shell-command and either return its output or kill it
    if it doesn't normally exit within timeout seconds and return None"""

    command = command + '&&exit'
    cmd = command.split(" ")
    start = datetime.datetime.now()
    process = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)
    while process.poll() is None:
        time.sleep(1)
        now = datetime.datetime.now()
        if (now - start).seconds > timeout:
            subprocess.Popen("cmd /c taskkill /f /im notepad.exe")

            return False
    return True


def exec_command_as_admin(cmd):
    """
    以administrator权限运行命令
    :param cmd: type:str 要执行的cmd命令,若多行,使用换行符\n
    :return:
    """
    # 兼容winServer系统,运行脚本会有"运行身份"窗口拦截,若为server和linux,则使用os.system()代替
    LOG_DEBUG('admin cmd: {}'.format(cmd))
    system_info = get_format_system_info()
    if 'server' in system_info or 'server' in platform.platform().lower() or 'Linux' == platform.system():
        cmd_list = cmd.split(r'\n')
        for cmd in cmd_list:
            os.system(cmd)
    else:
        src_path = os.path.abspath(
            os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(os.path.dirname(os.path.dirname(__file__))))),
                         'Swiss-Knife\\tools\\admin_cmd.bat'))
        cp_path = os.path.abspath(
            os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(os.path.dirname(os.path.dirname(__file__))))),
                         'Swiss-Knife\\tools\\admin_cmd_cp.bat'))
        try:
            cp_cmd = shutil.copyfile(src=src_path, dst=cp_path)
            with open(cp_path, 'a+') as f:
                f.write(cmd.decode('utf-8', 'ignore').encode('gbk', 'ignore'))
            os.system(cp_path)
            time.sleep(2)
        except Exception as e:

            # 解决工程是以包的形式部署，导致路径不一致
            try:
                agent_name = '.'
                for name in os.listdir("C:\\jenkins\\workspace\\"):
                    if 'agent_' in name:
                        agent_name = name
                        break
                src_path = r'C:\jenkins\workspace\{}\Swiss-Knife\tools\adkmin_cmd.bat'.format(agent_name)
                cp_path = r'C:\jenkins\workspace\{}\Swiss-Knife\tools\admin_cmd_cp.bat'.format(agent_name)
                cp_cmd = shutil.copyfile(src=src_path, dst=cp_path)
                with open(cp_path, 'a+') as f:
                    f.write(cmd.decode('utf-8', 'ignore').encode('gbk', 'ignore'))
                os.system(cp_path)
                time.sleep(2)
            except Exception as e:
                LOG_DEBUG(e)


def wait_result(wait_time=3):
    """
    等待结果
    :param wait_time:
    :return:
    """
    time.sleep(wait_time)


def release(obj=r'C:\ProgramData\Sangfor\EDR\SAV\cache'):
    try:
        if os.path.isfile(obj):
            return
        cmd = 'cacls ' + obj + '\*.* /g everyone:f'
        print(cmd)
        # os.system(cmd)
        p = os.popen(cmd, "w")  # auto confirm
        p.write('y\n')
        subobjs = os.path.os.listdir(obj)
        if subobjs == []:
            return
        else:
            for temp in subobjs:
                tempobj = os.path.join(obj, temp)
                release(tempobj)
    except Exception as e:
        LOG_ERROR(e)


def search_file_by_re(file_path, pattern, encode ="utf-16-le"):
    """
    读取文件（一般为日志）,并通过正则表达式寻找内容
    :param file_path:
    :return:
    """
    patt = re.compile(pattern)
    with codecs.open(file_path, "r", encoding=encode) as f:
        re_list = patt.findall(f.read())
    return re_list


def upload_file_to_mgr_tmp_dir(file_path, mgr_ip, host="10.186.0.185", username="root", password="root", port=21,mgr_sve_path=r'/tmp/'):
    """
    上传文件到mgr的tmp目录
    :param file_path: 本地文件路径  最好输入绝对路径
    :param mgr_ip: mgr ip
    :param host: ftp ip
    :param username: 用户名
    :param password: 密码
    :param port: 端口
    :return:
    """
    ftp = ftpconnect(host=host, username=username, password=password, port=port)
    #跳转机：10.186.0.185
    remotepath_185 = os.path.join(r'/var/www/html/download/upload_mgr/', os.path.basename(file_path))
    #mgr临时目录
    remotepath_mgr = os.path.join(mgr_sve_path, os.path.basename(file_path))
    uploadfile(ftp, remotepath_185, file_path)
    cmd = "/var/www/html/download/upload_mgr/LoadFile.sh {} {} {} {} {} {} upload".format(mgr_ip, 22, "root", "root",
                                                                                          remotepath_mgr, remotepath_185)
    ret, out = ssh_connect_with_output(ip=host, cmd=cmd)
    return ret


def get_win_type():
    try:
        cmd = "systeminfo"
        output = sp.check_output(cmd)
    except StandardError as e:
        LOG_EXCEPTION(e)
        return None
    else:
        if output:
            if re.search(r".*windows.*\s*server.*", output, re.I):
                return "server"
            else:
                return "pc"
        else:
            return None


class disable_file_system_redirection:
    """
    关闭64位系统的driver目录重定向
    使用方法：with disable_file_system_redirection():
                ...
    """
    try:
        _disable = ctypes.windll.kernel32.Wow64DisableWow64FsRedirection
        _revert = ctypes.windll.kernel32.Wow64RevertWow64FsRedirection
    except Exception as e:
        LOG_ERROR(str(e))

    def __enter__(self):
        self.old_value = ctypes.c_long()
        self.success = self._disable(ctypes.byref(self.old_value))

    def __exit__(self, type, value, traceback):
        if self.success:
            self._revert(self.old_value)


if __name__ == "__main__":
    opr = 'enable'
    exec_command_as_admin(r'"C:\Program Files\Sangfor\EDR\agent\bin\generalcfg.exe" {} Edr_develop@123'.format(opr))
    exec_command_as_admin(
        r'"C:\Program Files\Sangfor\EDR\agent\bin\generalcfg.exe" query Edr_develop@123 > C:\opr_result.txt')
    with open(r"C:\opr_result.txt") as f:
        ret = f.readline()[:-1]
    if ret != 'generalcfg status is {}'.format(opr):
        os.system(r'"C:\Program Files\Sangfor\EDR\agent\bin\rtptool.exe" {} SangforEDRTool'.format(opr))
        exec_command_with_popen(
            r'"C:\Program Files\Sangfor\EDR\agent\bin\rtptool.exe" query SangforEDRTool > C:\opr_result.txt')
        with open(r"C:\opr_result.txt") as f:
            ret = f.readline()[:-1]
    assert ret == 'generalcfg status is {}'.format(opr), "自保护不工作，状态：{}".format(ret)
    if os.path.exists(r"C:\opr_result.txt"):
        os.remove(r"C:\opr_result.txt")
    # _, out = ssh_connect_with_output('10.186.0.200', 22, 'root', 'root', "/root/linkuploadlogserver/server/sfla_server.sh > /tmp/test.txt &",)
    # print out
    # ret = exec_command_with_popen(
    #     r'cd "C:\Program Files\Sangfor\EDR\agent\var\log\sfpatch\patch\down" && dir /B /O-D|findstr "log"')
    # ret = exec_command_with_popen(r'del "C:\ProgramData\...refuXWqypW\rVkmTMPs8f.db" /F /S /Q')
    # print ret
    # ssh_connect(ip='10.143.0.74', username='root', password='scloud',cmd=r'docker exec -i EDR-47727611.main /sf/edr/manager/bin/eps_services restart &', timeout=500)
    # ssh_connect(ip='10.143.0.74', username='root', password='scloud', cmd=r'docker exec -i EDR-47727611.main ls', timeout=50)

    # ssh_connect(ip='10.186.0.200',
    #             cmd=r'sh /tmp/update_upgraded_dump.bash',
    #             timeout=3)
    # print exec_command_with_popen(r'type C:\AutoTestTool\ScanState.json')
    # attack_count = 100
    # attacked_user = "fooName"
    # cpu_num = 16
    # attacked_ip = '10.186.4.23'
    # brute_type = 'smb'
    # cmd = 'rm -rf /root/dxx/pwd.txt;mkdir -p /root/dxx;for((i=1;i<={};i++));do echo root$i >> /root/dxx/pwd.txt;nohup hydra -l {} -P /root/dxx/password.txt -t {} {} {} > /dev/null 2>&1 &'.format(
    #     attack_count, attacked_user, cpu_num, attacked_ip, brute_type)
    # ssh_connect(ip='10.186.0.174', username='root', password='root', cmd=cmd, timeout=120,
    #             read_timeout=120)
    # exec_command_as_admin(
    #     r'rename "C:\Program Files\Sangfor\EDR\agent\bin\frep\local_certificate\black.dat" black_bak.dat')
    # exec_command_as_admin(
    #     r'rename "C:\Program Files\Sangfor\EDR\agent\bin\frep\local_certificate\white.dat" white_bak.dat')

    # exec_command_as_admin(
    #     r'copy /Y {} "C:\Program Files\Sangfor\EDR\agent\bin\frep\local_certificate\black.dat"'.format(
    #         os.path.join(r'C:\Users\Administrator\EDRT\Swiss-Knife', r'virus\digital_signature\black_model\black.dat')))
    # exec_command_as_admin(
    #     r'copy /Y {} "C:\Program Files\Sangfor\EDR\agent\bin\frep\local_certificate\white.dat"'.format(
    #         os.path.join(r'C:\Users\Administrator\EDRT\Swiss-Knife', r'virus\digital_signature\white_model\white.dat')))

    # 3.2.16
    # file_path = ['edr3.2.16_offline_20190920123612_Build961_sign.pkg', 'manager_deploy.sh', 'mgr_clean.sh']
    # 3.2.15en
    # file_path = ['edr3.2.15_offline_20200314070038_Build12319_sign.pkg', 'manager_deploy_en.sh', 'mgr_clean.sh']

    # # 第六套
    # mgr_ips = ['10.186.1.122', '10.186.1.123', '10.186.1.124','10.186.1.125',
    #            '10.186.1.126','10.186.1.128','10.186.1.130','10.186.1.131','10.186.1.135','10.186.1.155','10.186.1.156',]
    # 第五套
    # mgr_ips = ['10.186.2.122', '10.186.2.123', '10.186.2.124','10.186.2.125',
    #            '10.186.2.126','10.186.2.128','10.186.2.130','10.186.2.131','10.186.2.135','10.186.2.155','10.186.2.156',
    #            '10.186.2.138','10.186.2.140','10.186.2.141','10.186.2.144','10.186.2.145','10.186.2.161','10.186.2.162','10.186.2.163']
    # mgr_ips = [
    #            '10.186.2.126', '10.186.2.128', '10.186.2.130', '10.186.2.131', '10.186.2.135', '10.186.2.155',
    #            '10.186.2.156',
    #            '10.186.2.140', '10.186.2.141', '10.186.2.144', '10.186.2.161',
    #            '10.186.2.162', '10.186.2.163']

    # # 批量上传升级包和卸载/安装脚本
    # for file in file_path:
    #     for mgr_ip in mgr_ips:
    #         print "mgr_ip:{} file:{}".format(mgr_ip, file)
    #         upload_file_to_mgr_tmp_dir(file, mgr_ip, mgr_sve_path='/root/')

    # 批量卸载mgr后全新安装mgr
    # for mgr_ip in mgr_ips:
    #     _, ret = ssh_connect_with_output(ip=mgr_ip, cmd='cd /root;chmod 777 *; ./mgr_clean.sh;./mgr_clean.sh;', timeout=1000)
    #     print '卸载mgr{}：{}'.format(mgr_ip, ret)
    #     time.sleep(3)
    #     # 采用后台运行，需要等它执行完成
    #     _, ret = ssh_connect_with_output(ip=mgr_ip,
    #                                      cmd='/root/{} {} 10.186.0.1 &'.format(file_path[1], file_path[0]),
    #                                      timeout=1500)
    #     print '安装mgr{}：{}'.format(mgr_ip, ret)

    # 批量卸载agent后全新安装agent
    # for mgr_ip in mgr_ips:
    #     agent_ip = '.'.join(mgr_ip.split('.')[:-1]) + '.' + mgr_ip.split('.1')[-1]
    #     _, ret = ssh_connect_with_output(ip=agent_ip,
    #                                      cmd='/sangfor/edr/agent/bin/eps_uninstall.sh;cd /root; mkdir new;cd new;'
    #                                          'wget --no-check-certificate https://{0}/html/linux_edr_installer.tar.gz; '
    #                                          'tar -zxvf linux_edr_installer.tar.gz;chmod +x agent_installer.sh;'
    #                                          './agent_installer.sh -h {0} -p 443 -f y'.format(mgr_ip),timeout=1000)
    #     print '安装agent：{}'.format(ret)

    # ret = exec_command_with_popen(
    #     r'cd "C:\Program Files\Sangfor\EDR\agent\var\log\sfpatch\patch" && dir /B /O-D|findstr "log"')
    # file_name_list = ret.strip().split('\n')
    # print file_name_list
    # _, out = ssh_connect_with_output('10.186.3.126', username="root", password="root",
    #                                  cmd="grep '\[save_file1\]' /sf/edr/manager/var/log/evidenced/20200331-183620.log")
    # print out.split('\n')[0]