【Python学习】psutil获取进行资源

!/usr/bin/env python
# encoding: utf-8
from __future__ import division
import codecs
import os
import platform
import psutil
import re
import socket
import sys
import time
import datetime
import json
import threading
import xlrd
import xlwt
from xlutils.copy import copy
from loadrunner.common.logger import *
try:
    import platform
    if platform.system() == 'Windows':
        import wmi
except Exception as e:
    LOG_DEBUG(e)
def release(obj=r'C:ProgramDataSangforEDRSAVcache'):
   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
')
        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 winrar(opr, tar_name, compressed_files, winrar_exe=r'"C:Program FilesWinRARWinRAR.exe"'):
    """
    win解压缩
    :param opr: 解压/压缩
                decompress/compress
    :param tar_name: 压缩包绝对路径 后缀为tar/zip/rar
    :param compressed_files: 压缩文件绝对路径   如果是解压：请输入目录
    :param winrar_exe: winexe执行文件路径
    :return:
    """
    if opr == 'compress':
        LOG_DEBUG('开始winrar压缩文件')
        timer = time.time()
        ret = exec_command_with_popen('{} a -r -ep1 -df {} {}'.format(winrar_exe, tar_name, compressed_files))
        usetime = round(time.time() - timer, 4)
        LOG_DEBUG("winrar压缩文件返回值:{}".format(ret))
        if ret:
            LOG_ERROR('winrar压缩文件失败')
            usetime = 0
        return usetime
    elif opr == 'decompress':
        LOG_DEBUG('开始winrar解压文件')
        timer = time.time()
        ret = exec_command_with_popen('{} x {} {}'.format(winrar_exe, tar_name, compressed_files))
        usetime = round(time.time() - timer, 4)
        LOG_DEBUG("winrar解压文件返回值:{}".format(ret))
        if ret:
            LOG_ERROR('winrar解压文件失败')
            usetime = 0
        return usetime
    else:
        raise Exception("请输入opr参数['decompress', 'compress']")


def rar7z(opr, tar_name, compressed_files, winrar_exe=r'"C:Program Files7-Zip7z.exe"'):
    """
    7z解压缩
    :param opr: 解压/压缩
                decompress/compress
    :param tar_name: 压缩包绝对路径 后缀为7z
    :param compressed_files: 压缩文件绝对路径   如果是解压：请输入目录
    :param winrar_exe: winexe执行文件路径
    :return:
    """
    if opr == 'compress':
        LOG_DEBUG('开始rar7z压缩文件')
        timer = time.time()
        ret = exec_command_with_popen('{} a -t7z {} {} -r'.format(winrar_exe, tar_name, compressed_files))
        usetime = round(time.time() - timer, 4)
        LOG_DEBUG("rar7z压缩文件返回值:{}".format(ret))
        if 'Ok' not in ret:
            LOG_ERROR('rar7z压缩文件失败')
            usetime = 0
        return usetime
    elif opr == 'decompress':
        LOG_DEBUG('开始rar7z压缩文件')
        timer = time.time()
        ret = exec_command_with_popen('{} x {} -o{} -aoa'.format(winrar_exe, tar_name, compressed_files))
        usetime = round(time.time() - timer, 4)
        LOG_DEBUG("rar7z解压文件返回值:{}".format(ret))
        if 'Ok' not in ret:
            LOG_ERROR('rar7z解压文件失败')
            usetime = 0
        return usetime
    else:
        raise Exception("请输入opr参数['decompress', 'compress']")


def bandizip(opr, tar_name, compressed_files, winrar_exe=r'"C:Program FilesBandizipBandizip.exe"'):
    """
    bandizip解压缩
    :param opr: 解压/压缩
                decompress/compress
    :param tar_name: 压缩包绝对路径 后缀为zip
    :param compressed_files: 压缩文件绝对路径   如果是解压：请输入目录 压缩可输入目录或文件
    :param winrar_exe: winexe执行文件路径
    :return:
    """
    if opr == 'compress':
        LOG_DEBUG('开始bandizip压缩文件')
        timer = time.time()
        ret = exec_command_with_popen('{} a -y {} {}'.format(winrar_exe, tar_name, compressed_files))
        usetime = round(time.time() - timer, 4)
        LOG_DEBUG("bandizip压缩文件返回值:{}".format(ret))
        if ret:
            LOG_ERROR('bandizip压缩文件失败')
            usetime = 0
        return usetime
    elif opr == 'decompress':
        LOG_DEBUG('开始bandizip解压文件')
        timer = time.time()
        ret = exec_command_with_popen('{} x -y -o:{} {} '.format(winrar_exe, compressed_files, tar_name))
        usetime = round(time.time() - timer, 4)
        LOG_DEBUG("bandizip解压文件返回值:{}".format(ret))
        if ret:
 LOG_ERROR('bandizip解压文件失败')
            usetime = 0
        return usetime
    else:
        raise Exception("请输入opr参数['decompress', 'compress']")


def read_process_name_config():
    with codecs.open(filename='process_name_config.txt', mode='r', encoding='utf-8', errors='ignore') as f:
        content = str(f.read().lower())
    process_name_list = content.strip().replace('
', ' ').split(' ')
    process_name_list = [item for item in process_name_list if item]
    return process_name_list


def read_config():
    config_content = ''
    try:
        with codecs.open('config.json', 'r', 'utf-8', 'ignore') as f:
            config_content = f.read()
            config_content = json.loads(config_content)
    except Exception:
        config_content = {}
    return config_content


def get_host_ip():
    """
    查询本机ip地址
    :return:
    """
    try:
        s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        s.connect(('8.8.8.8', 80))
        ip = s.getsockname()[0]
    except Exception as e:
        print e
        f = os.popen('ipconfig', "rb")
        cmd_ret = f.read()
        cmd_ret = cmd_ret.decode('gbk', 'ignore')
        ip_list = re.findall(r'(d+.d+.d+.d+)', cmd_ret)
        ip = ip_list[0]
    finally:
        try:
            s.close()
        except Exception:
            pass
    return ip


def exec_command_with_popen(cmd):
    """
    执行windows或者linux命令行
    :param cmd: 命令
    :return: 返回值
    """
    LOG_DEBUG('执行cmd命令:{}'.format(cmd))
    f = os.popen(cmd, "r")
    ret = f.read()  # 读文件
    ret = ret.decode('gbk', errors='ignore')
    f.close()
    return ret


def get_all_windows_pid():
    """获取Windows进程PID"""
    content = exec_command_with_popen('tasklist').strip().lower().split('
')
    process_map = {}
    for item in content[2:]:
        item_split_list = item.split('  ')
        item_split_list = [i for i in item_split_list if i]
        key_name = item_split_list[0]
        key_value = item_split_list[1].strip().split(' ')[0]
        process_map[key_name] = key_value
    return process_map


def get_process_pid(process_name):
    """
    获取Linux/Windows系统进程的PID
    :param process_name:
    :return:
    """
    #{"进程名": 进程PID}
    process_map = {}
    for proc in psutil.process_iter():
        process_map[proc.name()] = proc.pid
    pid = process_map[process_name]
    LOG_DEBUG("process_name:[{}], pricess_pid:[{}]".format(process_name, pid))
    return pid


def get_pid_handle(process_map, process_name):
    """
    获取进程句柄数
    :param process_map:
    :param process_name:
    :return:
    """
    wmi_conn = wmi.WMI()
    process_name = process_name.lower()
    pid = int(process_map[process_name])
    handle_num = ''
    private_mem = ''
    try:
        handle_num = wmi_conn.Win32_Process(name=process_name)[0].HandleCount
    except Exception:
        handle_num = ' '
    try:
        private_mem = int(wmi_conn.Win32_Process(name=process_name)[0].PrivatePageCount) / 1024
    except Exception:
        private_mem = ' '
    finally:
        return (str(process_name), str(handle_num), str(private_mem))


def get_process_memory_percent(process_name):
    """
    获取进程内存占用
    :param process_name:
    :return:
    """
    try:
        process_pid = get_process_pid(process_name)
        p = psutil.Process(process_pid)
        memory_percent = round(p.memory_info().rss / 1024 / 1024, 4)
        LOG_DEBUG('process_name:[{}], process_memory:[{}MB]'.format(process_name, memory_percent))
        return memory_percent
    except Exception as e:
        LOG_ERROR("获取进程内存利用率异常{}".format(e))
        # 存在获取为空的现象,增加一次降低概率
        try:
            process_pid = get_process_pid(process_name)
            p = psutil.Process(process_pid)
            memory_percent = round(p.memory_info().rss / 1024 / 1024, 4)
            LOG_DEBUG('process_name:[{}], process_memory:[{}MB]'.format(process_name, memory_percent))
            return memory_percent
        except Exception as e:
　　         LOG_ERROR("获取进程内存利用率异常{}".format(e))
def get_process_io(process_name):
    """
    获取进程IO
    :param process_name:
    :return:
    """
    try:
        process_pid = get_process_pid(process_name)
        p = psutil.Process(process_pid)
        io_read = round(p.io_counters().read_count / 1024 / 1024, 4)
        io_write = round(p.io_counters().write_count / 1024 / 1024, 4)
        LOG_DEBUG('process_name:[{}], io_read:[{}Mbps/s], io_write:[{}Mbps/s]'.format(process_name, io_read, io_write))
        return (io_read,io_write)
    except Exception as e:
        LOG_ERROR("获取进程IO异常{}".format(e))
        # 存在获取为空的现象,增加一次降低概率
        try:
            process_pid = get_process_pid(process_name)
            p = psutil.Process(process_pid)
            io_read = round(p.io_counters().read_count / 1024 / 1024, 4)
            io_write = round(p.io_counters().write_count / 1024 / 1024, 4)
            LOG_DEBUG(
                'process_name:[{}], io_read:[{}Mbps/s], io_write:[{}Mbps/s]'.format(process_name, io_read, io_write))
            return (io_read, io_write)
        except Exception as e:
            LOG_ERROR("获取进程IO异常{}".format(e))


def get_process_cpu(process_name):
    """
    获取进程CPU占用率
    :param process_name:
    :return:
    """
    try:
        #物理cpu个数
        cpu_count = psutil.cpu_count(logical=False)
        process_pid = get_process_pid(process_name)
        p = psutil.Process(process_pid)
        cpu_percent = round(p.cpu_percent(interval=1) / cpu_count, 4)
        LOG_DEBUG('process_name:[{}], cpu_percent:[{}%]'.format(process_name, cpu_percent))
        return cpu_percent
    except Exception as e:
        LOG_ERROR("获取进程CPU占用率异常{}".format(e))
        #存在获取为空的现象,增加一次降低概率
        try:
            # 物理cpu个数
            cpu_count = psutil.cpu_count(logical=False)
            process_pid = get_process_pid(process_name)
            p = psutil.Process(process_pid)
            cpu_percent = round(p.cpu_percent(interval=1) / cpu_count, 4)
            LOG_DEBUG('process_name:[{}], cpu_percent:[{}%]'.format(process_name, cpu_percent))
            return cpu_percent
        except Exception as e:
            LOG_ERROR("获取进程CPU占用率异常{}".format(e))


def get_fs_info():
    """
    获取文件系统信息。
    包含分区的大小、已用量、可用量、使用率、挂载点信息。
    """
    tmplist = []
    c = wmi.WMI()
    for physical_disk in c.Win32_DiskDrive():
        for partition in physical_disk.associators("Win32_DiskDriveToDiskPartition"):
            for logical_disk in partition.associators("Win32_LogicalDiskToPartition"):
                tmpdict = {}
                tmpdict["Caption"] = logical_disk.Caption
                tmpdict["DiskTotal"] = long(logical_disk.Size) / 1024 / 1024
                tmpdict["UseSpace"] = (long(logical_disk.Size) - long(logical_disk.FreeSpace)) / 1024 / 1024
                tmpdict["FreeSpace"] = long(logical_disk.FreeSpace) / 1024 / 1024
                # tmpdict["Percent"] = int(
                #     100.0 * (long(logical_disk.Size) - long(logical_disk.FreeSpace)) / long(logical_disk.Size))
                tmplist.append(tmpdict)
    return tmplist[0]


def get_dir_space(dirpath):

    size = 0
    if os.path.exists(dirpath):
        if os.path.isdir(dirpath):
            for root, dirs, files in os.walk(dirpath):
                for name in files:
                    try:
                        size += os.path.getsize(os.path.join(root, name))
                    except:
                        continue
                #size += sum([getsize(join(root, name)) for name in files])
        elif os.path.isfile(dirpath):
            size = os.path.getsize(dirpath)
        else:
            pass
    size = round(size / 1024 / 1024, 4)
    LOG_DEBUG("Dir path:[{}], size:[{}M]".format(dirpath, size))
    return size
def loadrunner(process_name, PROCESS_CPU, PROCESS_MEM, PROCESS_IO_Read, PROCESS_IO_Write, row_num, cur_time):
    """
    获取性能监控数据
    :param process_name:
    :return:
    """
    #cur_time = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime())
    cpu_percent = get_process_cpu(process_name)
    mem_used = get_process_memory_percent(process_name)
    io_read, io_write = get_process_io(process_name)
    if process_name == LOADRUNNER_PROCESS[0]:
        PROCESS_CPU.write(row_num, 0, label=cur_time)
        PROCESS_MEM.write(row_num, 0, label=cur_time)
        PROCESS_IO_Read.write(row_num, 0, label=cur_time)
        PROCESS_IO_Write.write(row_num, 0, label=cur_time)
        PROCESS_CPU.write(row_num, 1, label=cpu_percent)
        PROCESS_MEM.write(row_num, 1, label=mem_used)
        PROCESS_IO_Read.write(row_num, 1, label=io_read)
        PROCESS_IO_Write.write(row_num, 1, label=io_write)
    else:
        for col in range(1, len(LOADRUNNER_PROCESS)):
            if process_name == LOADRUNNER_PROCESS[col]:
                PROCESS_CPU.write(row_num, col+1, label=cpu_percent)
                PROCESS_MEM.write(row_num, col+1, label=mem_used)
                PROCESS_IO_Read.write(row_num, col+1, label=io_read)
                PROCESS_IO_Write.write(row_num, col+1, label=io_write)


def write_data_in_xls():
    """
    写数据到xls
    :return:
    """
    write_xls_cursor = xlwt.Workbook(encoding='utf-8')
    return write_xls_cursor
    #worksheet.write(row, col, label=data)
    #write_xls_cursor.save(file_name)


def read_data_from_xls(file_path):
    """
    读取xls数据
    :return:
    """
    try:
        read_xls_cursor = xlrd.open_workbook(file_path, formatting_info=True)
        return read_xls_cursor
    except Exception:
        raise Exception, "读取xls报错"

def vital_xls_col_data(workbook, cols_name):
    """
    统计xls每列数据
    :return:
    """
    process_nrows = workbook.nrows
    process_data_dict = {}
    col = 1
    try:
        for p_name in cols_name:
            single_process_data = []
            for row in range(1, process_nrows):
                table_value = workbook.cell(row, col).value
                if table_value == "":
                    table_value = 0.0
                single_process_data.append(table_value)
            col += 1
            process_data_dict[p_name] = single_process_data
    except Exception as e:
        LOG_ERROR(e)
    return process_data_dict


def vital_xls_row_data(workbook):
    """
    统计每行数据
    :param workbook:
    :return:
    """
    process_nrows = workbook.nrows
    process_ncols = workbook.ncols

    process_rows_sum = []
    for row in range(1, process_nrows):
        process_row_data = []
        process_row_sum = 0
        for col in range(1, process_ncols):
            table_value = workbook.cell(row, col).value
            if table_value == "":
                table_value = 0.0
            process_row_data.append(table_value)
            process_row_sum = calc_average_value(process_row_data)[0]
        process_rows_sum.append(process_row_sum)
    return process_rows_sum