456 lines
14 KiB
Python
456 lines
14 KiB
Python
#!/bin/python
|
||
# coding: utf-8
|
||
# +-------------------------------------------------------------------
|
||
# | django-vue-lyadmin
|
||
# +-------------------------------------------------------------------
|
||
# | Author: lybbn
|
||
# +-------------------------------------------------------------------
|
||
# | QQ: 1042594286
|
||
# +-------------------------------------------------------------------
|
||
|
||
# ------------------------------
|
||
# windows系统命令工具类封装
|
||
# ------------------------------
|
||
|
||
import sys
|
||
import platform
|
||
import os, time
|
||
import psutil
|
||
import winreg
|
||
from config import EXEC_LOG_PATH, TEMP_EXEC_PATH
|
||
from django.core.cache import cache
|
||
from pathlib import Path
|
||
|
||
BASE_DIR = Path(__file__).resolve().parent
|
||
|
||
|
||
def ReadReg(path, key):
|
||
"""
|
||
读取注册表
|
||
@path 注册表路径
|
||
@key 注册表键值
|
||
"""
|
||
import winreg
|
||
try:
|
||
newKey = winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE, path)
|
||
value, type = winreg.QueryValueEx(newKey, key)
|
||
return value
|
||
except:
|
||
return False
|
||
|
||
|
||
def get_mac_address():
|
||
"""
|
||
获取mac
|
||
"""
|
||
import uuid
|
||
mac = uuid.UUID(int=uuid.getnode()).hex[-12:]
|
||
return ":".join([mac[e:e + 2] for e in range(0, 11, 2)])
|
||
|
||
|
||
def md5(strings):
|
||
"""
|
||
@name 生成md5
|
||
@param strings 要被处理的字符串
|
||
@return string(32)
|
||
"""
|
||
if type(strings) != bytes:
|
||
strings = strings.encode()
|
||
import hashlib
|
||
m = hashlib.md5()
|
||
m.update(strings)
|
||
return m.hexdigest()
|
||
|
||
|
||
def to_size(size):
|
||
"""
|
||
字节单位转换
|
||
@size 字节大小
|
||
return 返回带单位的格式(如：1 GB)
|
||
"""
|
||
if not size: return '0.00 b'
|
||
size = float(size)
|
||
|
||
d = ('b', 'KB', 'MB', 'GB', 'TB');
|
||
s = d[0];
|
||
for b in d:
|
||
if size < 1024: return ("%.2f" % size) + ' ' + b;
|
||
size = size / 1024;
|
||
s = b;
|
||
return ("%.2f" % size) + ' ' + b;
|
||
|
||
|
||
def is_64bitos():
|
||
"""
|
||
判断是否x64系统(windows\linux都适用)
|
||
利用platform.uname()
|
||
windows:uname_result(system='Windows', node='xxxxx', release='10', version='10.0.19042', machine='AMD64')
|
||
linux:uname_result(system='Linux', node='xxxx', release='5.10.134-12.2.al8.x86_64', version='#1 SMP Thu Oct 27 10:07:15 CST 2022', machine='x86_64', processor='x86_64')
|
||
"""
|
||
info = platform.uname()
|
||
return info.machine.endswith('64')
|
||
|
||
|
||
def get_registry_value(key, subkey, value):
|
||
"""
|
||
读取注册表信息
|
||
@key 注册表类型
|
||
@subkey 注册表路径
|
||
@value 注册表具体key值
|
||
"""
|
||
key = getattr(winreg, key)
|
||
handle = winreg.OpenKey(key, subkey)
|
||
(value, type) = winreg.QueryValueEx(handle, value)
|
||
return value
|
||
|
||
|
||
def WriteLog(logMsg):
|
||
"""
|
||
写入LOG日志
|
||
"""
|
||
try:
|
||
with open(EXEC_LOG_PATH, 'w+') as f:
|
||
f.write(logMsg)
|
||
f.close()
|
||
except:
|
||
pass
|
||
|
||
|
||
def GetSystemVersion():
|
||
"""
|
||
取操作系统版本
|
||
"""
|
||
try:
|
||
key = 'lybbn_sys_version'
|
||
version = cache.get(key)
|
||
if version: return version
|
||
bit = 'x86'
|
||
if is_64bitos(): bit = 'x64'
|
||
|
||
def get(key):
|
||
return get_registry_value("HKEY_LOCAL_MACHINE", "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion", key)
|
||
|
||
os = get("ProductName")
|
||
build = get("CurrentBuildNumber")
|
||
|
||
version = "%s (build %s) %s (Py%s)" % (os, build, bit, platform.python_version())
|
||
cache.set(key, version, 10000)
|
||
return version
|
||
except Exception as ex:
|
||
WriteLog('获取系统版', '获取系统版本失败,注册表无法打开,报错信息：%s'%(str(ex)))
|
||
version = "未知系统版本"
|
||
cache.set(key, version, 10000)
|
||
return version
|
||
|
||
|
||
def GetLoadAverage():
|
||
"""
|
||
取负载信息
|
||
"""
|
||
data = {}
|
||
data['one'] = 0
|
||
data['five'] = 0
|
||
data['fifteen'] = 0
|
||
data['max'] = psutil.cpu_count() * 2
|
||
data['limit'] = data['max']
|
||
data['safe'] = data['max'] * 0.75
|
||
data['percent'] = 0
|
||
return data
|
||
|
||
|
||
def GetMemInfo():
|
||
"""
|
||
取内存信息
|
||
"""
|
||
mem = psutil.virtual_memory()
|
||
memInfo = {}
|
||
memInfo['percent'] = mem.percent
|
||
memInfo['total'] = round(float(mem.total) / 1024 / 1024 / 1024, 2)
|
||
memInfo['free'] = round(float(mem.free) / 1024 / 1024 / 1024, 2)
|
||
memInfo['used'] = round(float(mem.used) / 1024 / 1024 / 1024, 2)
|
||
return memInfo
|
||
|
||
def get_disk_iostat():
|
||
"""
|
||
获取磁盘IO
|
||
"""
|
||
iokey = 'iostat'
|
||
diskio = cache.get(iokey)
|
||
mtime = int(time.time())
|
||
if not diskio:
|
||
diskio = {}
|
||
diskio['info'] = None
|
||
diskio['time'] = mtime
|
||
diskio_1 = diskio['info']
|
||
stime = mtime - diskio['time']
|
||
if not stime: stime = 1
|
||
diskInfo = {}
|
||
diskInfo['ALL'] = {}
|
||
diskInfo['ALL']['read_count'] = 0
|
||
diskInfo['ALL']['write_count'] = 0
|
||
diskInfo['ALL']['read_bytes'] = 0
|
||
diskInfo['ALL']['write_bytes'] = 0
|
||
diskInfo['ALL']['read_time'] = 0
|
||
diskInfo['ALL']['write_time'] = 0
|
||
diskInfo['ALL']['read_merged_count'] = 0
|
||
diskInfo['ALL']['write_merged_count'] = 0
|
||
try:
|
||
diskio_2 = psutil.disk_io_counters(perdisk=True)
|
||
if not diskio_1:
|
||
diskio_1 = diskio_2
|
||
i = 0
|
||
for disk_name in diskio_2.keys():
|
||
disk_name_alias = "磁盘"+str(0)
|
||
diskInfo[disk_name_alias] = {}
|
||
diskInfo[disk_name_alias]['read_count'] = int((diskio_2[disk_name].read_count - diskio_1[disk_name].read_count) / stime)
|
||
diskInfo[disk_name_alias]['write_count'] = int((diskio_2[disk_name].write_count - diskio_1[disk_name].write_count) / stime)
|
||
diskInfo[disk_name_alias]['read_bytes'] = int((diskio_2[disk_name].read_bytes - diskio_1[disk_name].read_bytes) / stime)
|
||
diskInfo[disk_name_alias]['write_bytes'] = int((diskio_2[disk_name].write_bytes - diskio_1[disk_name].write_bytes) / stime)
|
||
diskInfo[disk_name_alias]['read_time'] = int((diskio_2[disk_name].read_time - diskio_1[disk_name].read_time) / stime)
|
||
diskInfo[disk_name_alias]['write_time'] = int((diskio_2[disk_name].write_time - diskio_1[disk_name].write_time) / stime)
|
||
diskInfo[disk_name_alias]['read_merged_count'] = 0
|
||
diskInfo[disk_name_alias]['write_merged_count'] = 0
|
||
|
||
diskInfo['ALL']['read_count'] += diskInfo[disk_name_alias]['read_count']
|
||
diskInfo['ALL']['write_count'] += diskInfo[disk_name_alias]['write_count']
|
||
diskInfo['ALL']['read_bytes'] += diskInfo[disk_name_alias]['read_bytes']
|
||
diskInfo['ALL']['write_bytes'] += diskInfo[disk_name_alias]['write_bytes']
|
||
if diskInfo['ALL']['read_time'] < diskInfo[disk_name_alias]['read_time']:
|
||
diskInfo['ALL']['read_time'] = diskInfo[disk_name_alias]['read_time']
|
||
if diskInfo['ALL']['write_time'] < diskInfo[disk_name_alias]['write_time']:
|
||
diskInfo['ALL']['write_time'] = diskInfo[disk_name_alias]['write_time']
|
||
diskInfo['ALL']['read_merged_count'] += diskInfo[disk_name_alias]['read_merged_count']
|
||
diskInfo['ALL']['write_merged_count'] += diskInfo[disk_name_alias]['write_merged_count']
|
||
i = i+1
|
||
|
||
cache.set(iokey, {'info': diskio_2, 'time': mtime})
|
||
except:
|
||
return diskInfo
|
||
return diskInfo
|
||
|
||
def GetNetWork():
|
||
"""
|
||
获取网卡信息
|
||
"""
|
||
|
||
cache_timeout = 86400
|
||
otime = cache.get("otime")
|
||
ntime = time.time()
|
||
networkInfo = {}
|
||
networkInfo['network'] = {}
|
||
networkInfo['upTotal'] = 0
|
||
networkInfo['downTotal'] = 0
|
||
networkInfo['up'] = 0
|
||
networkInfo['down'] = 0
|
||
networkInfo['downPackets'] = 0
|
||
networkInfo['upPackets'] = 0
|
||
networkIo_list = psutil.net_io_counters(pernic=True)
|
||
|
||
for net_key in networkIo_list.keys():
|
||
if net_key.find('Loopback') >= 0 or net_key.find('Teredo') >= 0 or net_key.find('isatap') >= 0: continue
|
||
|
||
networkIo = networkIo_list[net_key][:4]
|
||
up_key = "{}_up".format(net_key)
|
||
down_key = "{}_down".format(net_key)
|
||
otime_key = "otime"
|
||
|
||
if not otime:
|
||
otime = time.time()
|
||
|
||
cache.set(up_key, networkIo[0], cache_timeout)
|
||
cache.set(down_key, networkIo[1], cache_timeout)
|
||
cache.set(otime_key, otime, cache_timeout)
|
||
|
||
networkInfo['network'][net_key] = {}
|
||
up = cache.get(up_key)
|
||
down = cache.get(down_key)
|
||
if not up:
|
||
up = networkIo[0]
|
||
if not down:
|
||
down = networkIo[1]
|
||
networkInfo['network'][net_key]['upTotal'] = networkIo[0]
|
||
networkInfo['network'][net_key]['downTotal'] = networkIo[1]
|
||
try:
|
||
networkInfo['network'][net_key]['up'] = round(float(networkIo[0] - up) / 1024 / (ntime - otime), 2)
|
||
networkInfo['network'][net_key]['down'] = round(float(networkIo[1] - down) / 1024 / (ntime - otime), 2)
|
||
except:
|
||
networkInfo['up'] = 0
|
||
networkInfo['down'] = 0
|
||
|
||
networkInfo['network'][net_key]['up'] = 0
|
||
networkInfo['network'][net_key]['down'] = 0
|
||
|
||
networkInfo['network'][net_key]['downPackets'] = networkIo[3]
|
||
networkInfo['network'][net_key]['upPackets'] = networkIo[2]
|
||
|
||
networkInfo['upTotal'] += networkInfo['network'][net_key]['upTotal']
|
||
networkInfo['downTotal'] += networkInfo['network'][net_key]['downTotal']
|
||
networkInfo['up'] += networkInfo['network'][net_key]['up']
|
||
networkInfo['down'] += networkInfo['network'][net_key]['down']
|
||
networkInfo['downPackets'] += networkInfo['network'][net_key]['downPackets']
|
||
networkInfo['upPackets'] += networkInfo['network'][net_key]['upPackets']
|
||
|
||
cache.set(up_key, networkIo[0], cache_timeout)
|
||
cache.set(down_key, networkIo[1], cache_timeout)
|
||
cache.set(otime_key, time.time(), cache_timeout)
|
||
|
||
networkInfo['up'] = round(float(networkInfo['up']), 2)
|
||
networkInfo['down'] = round(float(networkInfo['down']), 2)
|
||
networkInfo['iostat'] = get_disk_iostat()
|
||
|
||
return networkInfo
|
||
|
||
|
||
def GetBootTime():
|
||
"""
|
||
取系统启动时间
|
||
"""
|
||
key = 'lybbn_sys_time'
|
||
sys_time = cache.get(key)
|
||
if sys_time: return sys_time
|
||
import math
|
||
tStr = time.time() - psutil.boot_time()
|
||
min = tStr / 60;
|
||
hours = min / 60;
|
||
days = math.floor(hours / 24);
|
||
hours = math.floor(hours - (days * 24));
|
||
min = math.floor(min - (days * 60 * 24) - (hours * 60));
|
||
sys_time = "{}天".format(int(days))
|
||
cache.set(key, sys_time, 1800)
|
||
return sys_time
|
||
|
||
|
||
def GetCpuInfo(interval=1):
|
||
"""
|
||
取CPU详细信息
|
||
"""
|
||
cpuCount = cache.get('lybbn_cpu_cpuCount')
|
||
if not cpuCount:
|
||
cpuCount = psutil.cpu_count()
|
||
cache.set('lybbn_cpu_cpuCount', cpuCount, 86400)
|
||
cpuNum = cache.get('lybbn_cpu_cpuNum')
|
||
if not cpuNum:
|
||
cpuNum = psutil.cpu_count(logical=False)
|
||
cache.set('lybbn_cpu_cpuNum', cpuNum, 86400)
|
||
|
||
# used = cache.get('lybbn_cpu_used')
|
||
# if not used:
|
||
# used = psutil.cpu_percent(interval)
|
||
# cache.set('lybbn_cpu_used',used,20)
|
||
|
||
used_all = cache.get('lybbn_cpu_used_all')
|
||
if not used_all:
|
||
used_all = psutil.cpu_percent(percpu=True)
|
||
|
||
used_total = 0
|
||
for x in used_all: used_total += x
|
||
|
||
cpuW = cache.get('lybbn_cpu_cpuW')
|
||
if not cpuW:
|
||
ret = os.popen('wmic cpu get NumberOfCores').read()
|
||
cpuW = 0
|
||
arrs = ret.strip().split('\n\n')
|
||
for x in arrs:
|
||
val = x.strip()
|
||
if not val: continue;
|
||
try:
|
||
val = int(val)
|
||
cpuW += 1;
|
||
except:
|
||
pass
|
||
|
||
cache.set('lybbn_cpu_cpuW', cpuW, 86400)
|
||
|
||
cpu_name = cache.get('lybbn_cpu_cpu_name')
|
||
if not cpu_name:
|
||
try:
|
||
cpu_name = '{} * {}'.format(
|
||
ReadReg(r'HARDWARE\DESCRIPTION\System\CentralProcessor\0', 'ProcessorNameString').strip(), cpuW);
|
||
except:
|
||
cpu_name = ''
|
||
cache.set('lybbn_cpu_cpu_name', cpu_name, 86400)
|
||
|
||
tmp = 0
|
||
if cpuW:
|
||
tmp = cpuNum / cpuW
|
||
|
||
used = 0
|
||
if used_total:
|
||
used = round(used_total / cpuCount, 2)
|
||
return used, cpuCount, used_all, cpu_name, tmp, cpuW
|
||
|
||
|
||
def GetDiskInfo():
|
||
"""
|
||
取磁盘分区信息
|
||
"""
|
||
key = 'lybbn_sys_disk'
|
||
diskInfo = cache.get(key)
|
||
if diskInfo: return diskInfo
|
||
try:
|
||
diskIo = psutil.disk_partitions();
|
||
except:
|
||
import string
|
||
diskIo = []
|
||
for c in string.ascii_uppercase:
|
||
disk = c + ':'
|
||
if os.path.isdir(disk):
|
||
data = {}
|
||
data['mountpoint'] = disk + '/'
|
||
diskIo.append(data)
|
||
|
||
diskInfo = []
|
||
for disk in diskIo:
|
||
try:
|
||
tmp = {}
|
||
tmp['path'] = disk.mountpoint.replace("\\", "/")
|
||
usage = psutil.disk_usage(disk.mountpoint)
|
||
tmp['size'] = [to_size(usage.total), to_size(usage.used), to_size(usage.free), usage.percent]
|
||
tmp['inodes'] = False
|
||
diskInfo.append(tmp)
|
||
except:
|
||
pass
|
||
cache.set(key, diskInfo, 10)
|
||
return diskInfo
|
||
|
||
def GetFileLastNumsLines(path,num=1000):
|
||
"""
|
||
获取指定文件的指定尾行数内容
|
||
"""
|
||
try:
|
||
if not os.path.exists(path): return ""
|
||
filesize = os.path.getsize(path)
|
||
if filesize == 0: return ""
|
||
num = int(num)
|
||
total_lines_wanted = num
|
||
BLOCK_SIZE = 4096
|
||
with open(path,"rb") as f:
|
||
f.seek(0, 2)
|
||
block_end_byte = f.tell()
|
||
lines_to_go = total_lines_wanted
|
||
block_number = -1
|
||
blocks = []
|
||
while lines_to_go > 0 and block_end_byte > 0:
|
||
if (block_end_byte - BLOCK_SIZE > 0):
|
||
f.seek(block_number*BLOCK_SIZE, 2)
|
||
blocks.append(f.read(BLOCK_SIZE))
|
||
else:
|
||
f.seek(0,0)
|
||
blocks.append(f.read(block_end_byte))
|
||
lines_found = blocks[-1].count(b'\n')
|
||
lines_to_go -= lines_found
|
||
block_end_byte -= BLOCK_SIZE
|
||
block_number -= 1
|
||
all_read_text = b''.join(reversed(blocks))
|
||
return b'\n'.join(all_read_text.splitlines()[-total_lines_wanted:])
|
||
except:
|
||
return ""
|
||
|
||
def RestartServer():
|
||
"""
|
||
重启系统
|
||
"""
|
||
try:
|
||
os.system("shutdown /r /f /t 0")
|
||
except:
|
||
pass |