core/system.py - master - HookDev-Arch/ServerMonitor

core/system.py
152 строки6 KB
HookDev-Arch
upload files
09 окт 2025, 02:25
09 окт 2025, 02:258bd6873
import psutil
from datetime import datetime
import time
from .utils import get_size, get_public_ip, GPU_BACKEND

# Глобальные переменные для отслеживания скорости сети
_prev_net_io = None
_prev_time = None


def get_network_speed():
    """Рассчитывает скорость загрузки и выгрузки сети"""
    global _prev_net_io, _prev_time
    
    current_time = time.time()
    current_net_io = psutil.net_io_counters()
    
    if _prev_net_io is None or _prev_time is None:
        _prev_net_io = current_net_io
        _prev_time = current_time
        return {'download_speed': '0 B/s', 'upload_speed': '0 B/s'}
    
    # Рассчитываем разность байтов и времени
    time_diff = current_time - _prev_time
    bytes_sent_diff = current_net_io.bytes_sent - _prev_net_io.bytes_sent
    bytes_recv_diff = current_net_io.bytes_recv - _prev_net_io.bytes_recv
    
    # Рассчитываем скорости в байтах в секунду
    if time_diff > 0:
        upload_speed_bps = bytes_sent_diff / time_diff
        download_speed_bps = bytes_recv_diff / time_diff
    else:
        upload_speed_bps = 0
        download_speed_bps = 0
    
    # Обновляем предыдущие значения
    _prev_net_io = current_net_io
    _prev_time = current_time
    
    return {
        'download_speed': get_size(download_speed_bps) + '/s',
        'upload_speed': get_size(upload_speed_bps) + '/s'
    }


def top_processes(mem_total):
    procs = []
    cpu_cores = max(1.0, psutil.cpu_count() or 1)
    for proc in psutil.process_iter(['pid', 'name', 'cpu_percent', 'memory_info']):
        try:
            pinfo = proc.info
            mem_bytes = pinfo['memory_info'].rss if pinfo['memory_info'] else 0
            mem_percent = (mem_bytes / mem_total) * 100 if mem_total > 0 else 0
            cpu_norm = pinfo['cpu_percent'] / cpu_cores
            procs.append({
                'pid': pinfo['pid'],
                'name': pinfo['name'],
                'cpu': max(0.0, cpu_norm),
                'memory': max(0.0, mem_percent),
                'rss': get_size(mem_bytes),
                'rss_bytes': int(mem_bytes)
            })
        except (psutil.NoSuchProcess, psutil.AccessDenied):
            pass
    return sorted(procs, key=lambda x: x['cpu'], reverse=True)[:200]


def get_gpu_stats():
    def na():
        return {'name': 'N/A', 'gpu_util': 0, 'memory_used': '0 B', 'memory_total': '0 B',
                'memory_percent': 0, 'temperature': 'N/A', 'power': 'N/A'}

    if GPU_BACKEND == "nvml":
        try:
            import pynvml
            count = pynvml.nvmlDeviceGetCount()
            if count < 1:
                return na()
            handle = pynvml.nvmlDeviceGetHandleByIndex(0)
            name_val = pynvml.nvmlDeviceGetName(handle)
            name = name_val.decode("utf-8") if isinstance(name_val, bytes) else name_val
            mem_info = pynvml.nvmlDeviceGetMemoryInfo(handle)
            util = pynvml.nvmlDeviceGetUtilizationRates(handle)
            temp = pynvml.nvmlDeviceGetTemperature(handle, pynvml.NVML_TEMPERATURE_GPU)
            try:
                power = pynvml.nvmlDeviceGetPowerUsage(handle) / 1000.0
                power_str = f"{power:.1f}W"
            except Exception:
                power_str = "N/A"
            return {
                "name": str(name),
                "memory_used": get_size(mem_info.used),
                "memory_total": get_size(mem_info.total),
                "memory_percent": (mem_info.used / mem_info.total) * 100 if mem_info.total else 0.0,
                "gpu_util": float(util.gpu),
                "temperature": int(temp),
                "power": power_str,
            }
        except Exception:
            return na()
    return na()


def local_stats():
    cpu_percent = psutil.cpu_percent(interval=None)
    cpu_count = psutil.cpu_count() or 1
    cpu_freq = psutil.cpu_freq()
    mem = psutil.virtual_memory()
    swap = psutil.swap_memory()
    disk = psutil.disk_usage('/')
    net_io = psutil.net_io_counters()
    gpu = get_gpu_stats()
    network_speed = get_network_speed()

    return {
        'timestamp': datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
        'cpu': {
            'percent': round(cpu_percent, 1),
            'count': cpu_count,
            'freq': f"{cpu_freq.current:.0f} MHz" if cpu_freq else "N/A"
        },
        'memory': {
            'total': get_size(mem.total),
            'used': get_size(mem.used),
            'available': get_size(mem.available),
            'percent': round(mem.percent, 1)
        },
        'swap': {
            'total': get_size(swap.total),
            'used': get_size(swap.used),
            'free': get_size(swap.free),
            'percent': int(swap.percent)
        },
        'disk': {
            'total': get_size(disk.total),
            'used': get_size(disk.used),
            'free': get_size(disk.free),
            'percent': int(disk.percent)
        },
        'network': {
            'sent': get_size(net_io.bytes_sent),
            'recv': get_size(net_io.bytes_recv),
            'public_ip': get_public_ip(),
            'download_speed': network_speed['download_speed'],
            'upload_speed': network_speed['upload_speed'],
            'packets_sent': net_io.packets_sent,
            'packets_recv': net_io.packets_recv
        },
        'gpu': gpu,
        'gpu_backend': GPU_BACKEND or 'none',
        'processes': top_processes(mem_total=mem.total)
    }