automated_task_monitor/monitor/views.py

from django.http import JsonResponse
from .tasks import monitor_process, get_process_gpu_usage
import threading
import psutil
from .models import HighCPUProcess, HighGPUProcess, HighMemoryProcess, AllResourceProcess
import logging
import os
from datetime import datetime
import time
import nvidia_smi
from django.utils import timezone
from django.views.decorators.http import require_http_methods
from django.views.decorators.csrf import csrf_exempt
from django.shortcuts import render
import pytz
from pathlib import Path  # 使用 pathlib 处理跨平台路径
import json
from django.conf import settings



import threading
directory_monitoring = {}

# 全局变量来控制检测线程
monitor_thread = None
is_monitoring = False

# 在文件开头定义日志目录
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
LOG_DIR = os.path.join(BASE_DIR, 'logs', 'process_monitor')

# 确保基础目录结构存在，添加 'all' 目录
for resource_type in ['cpu', 'memory', 'gpu', 'all']:
    os.makedirs(os.path.join(LOG_DIR, resource_type), exist_ok=True)

# 获取应用专属的logger
logger = logging.getLogger('monitor')

# 全局变量来跟踪监控的目录
monitored_directories = set()

# 添加新的监控线程函数
def monitor_directory(directory):
    """持续监控目录的后台任务"""
    monitor_interval = settings.MONITOR_INTERVAL  # 监控间隔（5秒）
    log_interval = settings.LOG_INTERVAL  # 日志写入间隔（60秒）
    processed_pids = set()  # 用于跟踪已处理的PID
    last_log_time = {}  # 每个进程的最后日志时间
    
    while directory_monitoring.get(directory, False):
        try:
            next_update = timezone.now() + timezone.timedelta(seconds=monitor_interval)
            
            processes = find_python_processes_in_dir(directory)
            for proc in processes:
                pid = proc['pid']
                try:
                    # 设置日志文件
                    log_file = setup_process_logger(pid, 'all')
                    if log_file:
                        process = psutil.Process(pid)
                        data = get_process_data(process)
                        
                        # 更新数据库
                        AllResourceProcess.objects.update_or_create(
                            pid=pid,
                            defaults={
                                'process_name': process.name(),
                                'cpu_usage': float(data['cpu']['usage'].replace('%', '')),
                                'cpu_user_time': float(data['cpu']['user_time'].replace('s', '')),
                                'cpu_system_time': float(data['cpu']['system_time'].replace('s', '')),
                                'memory_usage': float(data['memory']['physical'].split('MB')[0].strip()),
                                'memory_percent': float(data['memory']['physical'].split('(')[1].split('%')[0].strip()),
                                'virtual_memory': float(data['memory']['virtual'].split('MB')[0].strip()),
                                'gpu_usage': float(data['gpu']['usage'].replace('%', '')),
                                'gpu_memory': float(data['gpu']['memory'].replace('MB', '')),
                                'net_io_sent': float(data['io']['write'].split('MB')[0].strip()),
                                'net_io_recv': float(data['io']['read'].split('MB')[0].strip()),
                                'is_active': True,
                                'status': 1,
                                'log_file': log_file
                            }
                        )
                        
                        now = timezone.now()
                        # 如果是新检测到的进程，立即写入日志
                        if pid not in processed_pids:
                            print(f"首次检测到进程，立即写入日志: PID={pid}")  # 调试日志
                            log_process_metrics(pid, data, log_file)
                            processed_pids.add(pid)
                            last_log_time[pid] = now
                        # 对于已知进程，每隔一分钟写入一次
                        elif (now - last_log_time.get(pid, now)).total_seconds() >= log_interval:
                            print(f"定期写入日志: PID={pid}")  # 调试日志
                            log_process_metrics(pid, data, log_file)
                            last_log_time[pid] = now
                        
                except Exception as e:
                    logger.error(f"监控进程 {pid} 失败: {str(e)}")
            
            # 计算需要等待的时间
            now = timezone.now()
            if next_update > now:
                time.sleep((next_update - now).total_seconds())
                
        except Exception as e:
            logger.error(f"目录监控出错: {str(e)}")
            time.sleep(5)

def get_python_processes(directory):
    """获取指定目录下的Python进程"""
    directory = str(Path(directory).resolve()).lower()
    processes = []
    
    for proc in psutil.process_iter(['pid', 'name', 'cmdline']):
        try:
            if 'python' in proc.info['name'].lower():
                process = psutil.Process(proc.info['pid'])
                try:
                    proc_cwd = str(Path(process.cwd()).resolve()).lower()
                    if directory in proc_cwd or proc_cwd.startswith(directory):
                        processes.append(process)
                except (psutil.NoSuchProcess, psutil.AccessDenied):
                    continue
        except (psutil.NoSuchProcess, psutil.AccessDenied):
            continue
            
    return processes

def get_process_info(process):
    """获取进程详细信息"""
    try:
        with process.oneshot():
            info = {
                'pid': process.pid,
                'name': process.name(),
                'cpu_usage': process.cpu_percent(),
                'memory_usage': process.memory_info().rss / (1024 * 1024),  # MB
                'command_line': ' '.join(process.cmdline()),
                'create_time': process.create_time(),
                'status': process.status(),
                'threads': process.num_threads(),
                'working_directory': process.cwd(),
                'gpu_info': {
                    'usage': 0,
                    'memory': 0
                }
            }
            
            # 获取IO信息
            try:
                io = process.io_counters()
                info['io'] = {
                    'read_bytes': io.read_bytes / (1024 * 1024),  # MB
                    'write_bytes': io.write_bytes / (1024 * 1024),  # MB
                    'read_count': io.read_count,
                    'write_count': io.write_count
                }
            except (psutil.NoSuchProcess, psutil.AccessDenied):
                info['io'] = {
                    'read_bytes': 0,
                    'write_bytes': 0,
                    'read_count': 0,
                    'write_count': 0
                }
                
            return info
    except (psutil.NoSuchProcess, psutil.AccessDenied) as e:
        logger.error(f"获取进程 {process.pid} 信息失败: {str(e)}")
        return None

@csrf_exempt
@require_http_methods(["POST"])
def scan_directory(request):
    """扫描目录下的 Python 进程"""
    try:
        data = json.loads(request.body)
        directory = data.get('directory')
        
        if not directory:
            return JsonResponse({
                'status': 'error',
                'message': '请提供目录路径'
            })
        
        # 添加到监控目录集合
        directory = str(Path(directory).resolve())
        monitored_directories.add(directory)
        logger.info(f"开始监控目录: {directory}")
        
        return JsonResponse({
            'status': 'success',
            'message': f'开始监控目录: {directory}',
            'directory': directory
        })
        
    except Exception as e:
        logger.error(f"启动目录监控失败: {str(e)}")
        return JsonResponse({
            'status': 'error',
            'message': str(e)
        })

@require_http_methods(["GET"])
def get_directory_status(request):
    """获取目录下的进程状态"""
    try:
        directory = request.GET.get('directory')
        if not directory:
            return JsonResponse({
                'status': 'error',
                'message': '未提供目录路径'
            })
            
        # 获取目录下的Python进程
        processes = get_python_processes(directory)
        
        # 获取每个进程的详细信息
        process_info = []
        for proc in processes:
            info = get_process_info(proc)
            if info:
                process_info.append(info)
        
        return JsonResponse({
            'status': 'success',
            'processes': process_info,
            'timestamp': timezone.now().strftime('%Y-%m-%d %H:%M:%S')
        })
        
    except Exception as e:
        logger.error(f"获取目录状态失败: {str(e)}")
        return JsonResponse({
            'status': 'error',
            'message': str(e)
        })

@require_http_methods(["POST"])
def stop_directory_monitor(request):
    """停止目录监控"""
    try:
        data = json.loads(request.body)
        directory = data.get('directory')
        
        if not directory:
            return JsonResponse({
                'status': 'error',
                'message': '未提供目录路径'
            })

        # 从监控集合中移除
        directory = str(Path(directory).resolve())
        if directory in monitored_directories:
            monitored_directories.remove(directory)
            logger.info(f"停止监控目录: {directory}")
        
        return JsonResponse({
            'status': 'success',
            'message': '监控已停止'
        })
        
    except Exception as e:
        logger.error(f"停止监控失败: {str(e)}")
        return JsonResponse({
            'status': 'error',
            'message': str(e)
        })

def setup_process_logger(pid, monitor_type):
    """为进程设置独立的日志记录器"""
    try:
        # 验证监控类型
        if monitor_type not in ['cpu', 'memory', 'gpu', 'all']:
            print(f"警告：无效的监控类型 {monitor_type}")
            return None

        # 获取当前时间（使用本地时区）
        local_tz = pytz.timezone('Asia/Shanghai')
        current_time = timezone.localtime(timezone.now(), local_tz)
        current_date = current_time.strftime("%Y%m%d")
        
        # 如果是从目录扫描启动的监控，使用 'all' 类型
        if monitor_type == 'scan':
            monitor_type = 'all'
        
        # 构建日志文件路径
        log_dir = os.path.join(LOG_DIR, monitor_type)
        log_file = os.path.join(log_dir, f'{pid}_{current_date}_{monitor_type}.log')
        
        # 确保目录存在
        os.makedirs(os.path.dirname(log_file), exist_ok=True)
        
        print(f"设置日志文件: {log_file}")  # 调试信息
        return log_file
        
    except Exception as e:
        print(f"设置日志文件失败: {str(e)}")
        raise

def log_process_metrics(pid, data, log_file):
    """记录进程指标到日志文件"""
    try:
        # 确保目录存在
        os.makedirs(os.path.dirname(log_file), exist_ok=True)
        
        # 获取当前时间（使用本地时区）
        local_tz = pytz.timezone('Asia/Shanghai')  # 使用中国时区
        current_time = timezone.localtime(timezone.now(), local_tz)
        timestamp = current_time.strftime('%Y-%m-%d %H:%M:%S')
        
        # 格式化日志内容
        log_content = f"=== {timestamp} ===\n"
        
        # CPU信息
        log_content += "CPU信息:\n"
        log_content += f"├─ 使用率: {data['cpu']['usage']}\n"
        log_content += f"├─ 用户态时间: {data['cpu']['user_time']}\n"
        log_content += f"├─ 内核态时间: {data['cpu']['system_time']}\n"
        log_content += f"├─ CPU核心数: {data['cpu']['cores']}\n"
        log_content += f"├─ CPU频率: {data['cpu']['frequency']}\n"
        log_content += f"└─ 上下文切换: {data['cpu']['context_switches']}\n"
        
        # 内存信息
        log_content += "内存信息:\n"
        log_content += f"├─ 物理内存: {data['memory']['physical']}\n"
        log_content += f"├─ 虚拟内存: {data['memory']['virtual']}\n"
        log_content += f"├─ 内存映射: {data['memory']['mappings']}\n"
        log_content += f"├─ 系统内存使用: {data['memory']['system_usage']}\n"
        log_content += f"└─ 交换空间使用: {data['memory']['swap_usage']}\n"
        
        # GPU信息
        log_content += "GPU信息:\n"
        log_content += f"├─ 使用率: {data['gpu']['usage']}\n"
        log_content += f"└─ 显存使用: {data['gpu']['memory']}\n"
        
        # IO信息
        log_content += "IO信息:\n"
        log_content += f"├─ 读取: {data['io']['read']}\n"
        log_content += f"├─ 写入: {data['io']['write']}\n"
        log_content += f"└─ 其他IO: {data['io']['other']}\n"
        
        # 进程状态
        log_content += f"进程状态: {data['status']}\n"
        log_content += "-" * 50 + "\n"
        
        # 写入日志文件
        with open(log_file, 'a', encoding='utf-8') as f:
            f.write(log_content)
            
        print(f"已写入日志到: {log_file}")  # 调试信息
        
    except Exception as e:
        print(f"写入日志失败: {str(e)}")
        raise

def get_process_by_name(process_name):
    """根据进程名称获取进程PID"""
    pids = []
    for proc in psutil.process_iter(['pid', 'name']):
        try:
            if process_name.lower() in proc.info['name'].lower():
                pids.append(proc.info['pid'])
        except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess):
            pass
    return pids

def get_process_gpu_usage(pid):
    """获取进程的GPU使用情况"""
    try:
        # 如果没有GPU或无法获取GPU信息，返回默认值
        return 0.0, 0.0
    except Exception as e:
        logger.error(f"获取GPU信息失败: {str(e)}")
        return 0.0, 0.0

def get_high_resource_processes():
    """获取高资源占用的进程"""
    high_resource_pids = []
    for proc in psutil.process_iter(['pid', 'name', 'cpu_percent', 'memory_percent']):
        try:
            if proc.info['cpu_percent'] > 50 or proc.info['memory_percent'] > 50:
                high_resource_pids.append({
                    'pid': proc.info['pid'],
                    'name': proc.info['name'],
                    'cpu_percent': proc.info['cpu_percent'],
                    'memory_percent': proc.info['memory_percent']
                })
        except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess):
            continue
    return high_resource_pids

def auto_detect_high_resource_processes(request):
    """自动检测高资源进程的API端点"""
    try:
        # 获取高资源进程
        high_resource_procs = get_high_resource_processes()
        
        # 启动监控
        for proc in high_resource_procs:
            try:
                process = psutil.Process(proc['pid'])
                # 设置日志文件
                log_file = setup_process_logger(proc['pid'], 'auto')
                # 记录进程数据
                data = get_process_data(process)
                log_process_metrics(proc['pid'], data, log_file)
            except psutil.NoSuchProcess:
                continue
            except Exception as e:
                logger.error(f"监控进程 {proc['pid']} 时出错: {str(e)}")
        
        return JsonResponse({
            'status': 'success',
            'message': '已开始自动检测高资源进程',
            'processes': high_resource_procs
        }, json_dumps_params={'ensure_ascii': False})
        
    except Exception as e:
        logger.error(f"自动检测失败: {str(e)}")
        return JsonResponse({
            'status': 'error',
            'message': f'自动检测失败: {str(e)}'
        }, json_dumps_params={'ensure_ascii': False})

def setup_logger(pid):
    """为每个进程设置独立的日志记录器"""
    log_file = os.path.join(os.path.dirname(os.path.dirname(__file__)), 'logs', 'process_monitor', f'process_{pid}_{datetime.now().strftime("%Y%m%d")}.log')
    process_logger = logging.getLogger(f'monitor.process.process_{pid}')
    process_logger.setLevel(logging.INFO)
    
    handler = logging.FileHandler(log_file)
    formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
    handler.setFormatter(formatter)
    process_logger.addHandler(handler)
    
    return process_logger, log_file

def continuous_monitor():
    """持续监控高资源进程的线程函数"""
    global is_monitoring
    logger = logging.getLogger('monitor')
    interval = 60  # 设置为60秒间隔
    
    while is_monitoring:
        try:
            next_update = timezone.now() + timezone.timedelta(seconds=interval)
            
            # 获取所有活跃的监控记录
            monitors = {
                'cpu': HighCPUProcess.objects.filter(is_active=True),
                'memory': HighMemoryProcess.objects.filter(is_active=True),
                'gpu': HighGPUProcess.objects.filter(is_active=True)
            }
            
            for monitor_type, processes in monitors.items():
                for proc in processes:
                    try:
                        process = psutil.Process(proc.pid)
                        data = get_process_data(process)
                        log_file = setup_process_logger(proc.pid, monitor_type)
                        log_process_metrics(proc.pid, data, log_file)
                        
                    except psutil.NoSuchProcess:
                        proc.is_active = False
                        proc.save()
                    except Exception as e:
                        logger.error(f"监控进程 {proc.pid} 时出错: {str(e)}")
            
            # 计算需要等待的时间
            now = timezone.now()
            if next_update > now:
                time.sleep((next_update - now).total_seconds())
            
        except Exception as e:
            logger.error(f"持续监控出错: {str(e)}")
            time.sleep(5)

def get_process_data(process):
    """获取进程的详细数据"""
    with process.oneshot():
        cpu_times = process.cpu_times()
        cpu_freq = psutil.cpu_freq() or psutil._common.scpufreq(current=0, min=0, max=0)
        cpu_ctx = process.num_ctx_switches()
        mem = process.memory_info()
        
        try:
            mem_maps = len(process.memory_maps())
        except (psutil.AccessDenied, psutil.TimeoutExpired):
            mem_maps = 0
            
        sys_mem = psutil.virtual_memory()
        swap = psutil.swap_memory()
        
        try:
            io = process.io_counters()
        except (psutil.AccessDenied, psutil.TimeoutExpired):
            io = psutil._common.pio(read_count=0, write_count=0, read_bytes=0, write_bytes=0,
                                  read_chars=0, write_chars=0, other_count=0, other_bytes=0)
        
        gpu_usage, gpu_memory = get_process_gpu_usage(process.pid)
        
        return {
            'timestamp': timezone.now().strftime('%Y-%m-%d %H:%M:%S'),
            'cpu': {
                'usage': f"{process.cpu_percent()}%",
                'user_time': f"{cpu_times.user:.1f}s",
                'system_time': f"{cpu_times.system:.1f}s",
                'cores': str(psutil.cpu_count()),
                'frequency': f"{getattr(cpu_freq, 'current', 0):.1f}MHz",
                'context_switches': f"{cpu_ctx.voluntary}/{cpu_ctx.involuntary}"
            },
            'memory': {
                'physical': f"{mem.rss/1024/1024:.1f}MB ({process.memory_percent():.1f}%)",
                'virtual': f"{mem.vms/1024/1024:.1f}MB",
                'mappings': f"{mem_maps}个",
                'system_usage': f"{sys_mem.percent:.1f}%",
                'swap_usage': f"{swap.percent:.1f}%"
            },
            'gpu': {
                'usage': f"{gpu_usage:.1f}%",
                'memory': f"{gpu_memory:.1f}MB"
            },
            'io': {
                'read': f"{getattr(io, 'read_bytes', 0)/1024/1024:.1f}MB ({getattr(io, 'read_count', 0)}次)",
                'write': f"{getattr(io, 'write_bytes', 0)/1024/1024:.1f}MB ({getattr(io, 'write_count', 0)}次)",
                'other': f"{getattr(io, 'other_count', 0)}次"
            },
            'status': process.status()
        }

@csrf_exempt
@require_http_methods(["GET", "POST"])
def start_monitor(request):
    """开始监控进程"""
    global monitor_thread, is_monitoring
    try:
        pid = request.GET.get('pid')
        monitor_type = request.GET.get('type')
        
        if not pid:
            return JsonResponse({
                'status': 'error',
                'message': '请输入进程ID'
            }, json_dumps_params={'ensure_ascii': False})
            
        pid = int(pid)
        
        try:
            process = psutil.Process(pid)
            process_name = process.name()
            
            # 启动监控线程
            if not is_monitoring:
                is_monitoring = True
                monitor_thread = threading.Thread(target=continuous_monitor)
                monitor_thread.daemon = True
                monitor_thread.start()
            
            return JsonResponse({
                'status': 'success',
                'message': f'开始监控进程 {pid} ({process_name})'
            }, json_dumps_params={'ensure_ascii': False})
            
        except psutil.NoSuchProcess:
            return JsonResponse({
                'status': 'error',
                'message': f'进程 {pid} 不存在'
            }, json_dumps_params={'ensure_ascii': False})
            
    except Exception as e:
        logger.error(f"启动监控失败: {str(e)}")
        return JsonResponse({
            'status': 'error',
            'message': f'启动监控失败: {str(e)}'
        }, json_dumps_params={'ensure_ascii': False})

@csrf_exempt
@require_http_methods(["GET", "POST"])
def stop_monitor(request):
    """停止监控进程"""
    global is_monitoring
    try:
        pid = request.GET.get('pid')
        
        if not pid:
            return JsonResponse({
                'status': 'error',
                'message': '请输入进程ID'
            }, json_dumps_params={'ensure_ascii': False})
            
        pid = int(pid)
        
        # 停止监控线程
        is_monitoring = False
        
        return JsonResponse({
            'status': 'success',
            'message': f'停止监控进程 {pid}'
        }, json_dumps_params={'ensure_ascii': False})
            
    except Exception as e:
        logger.error(f"停止监控失败: {str(e)}")
        return JsonResponse({
            'status': 'error',
            'message': f'停止监控失败: {str(e)}'
        }, json_dumps_params={'ensure_ascii': False})

@require_http_methods(["GET"])
def get_process_status(request, pid):
    """获取进程监控状态的API"""
    try:
        monitor_type = request.GET.get('type')
        logger.info(f"获取进程状态: pid={pid}, type={monitor_type}")
        
        # 先设置日志文件路径
        log_file = setup_process_logger(pid, monitor_type)
        if not log_file:
            raise ValueError(f"无法创建日志文件，监控类型: {monitor_type}")
        
        process = psutil.Process(pid)
        data = get_process_data(process)
        
        # 同步数据到数据库
        try:
            # 更新 all 资源记录
            AllResourceProcess.objects.update_or_create(
                pid=pid,
                defaults={
                    'process_name': process.name(),
                    'cpu_usage': float(data['cpu']['usage'].replace('%', '')),
                    'cpu_user_time': float(data['cpu']['user_time'].replace('s', '')),
                    'cpu_system_time': float(data['cpu']['system_time'].replace('s', '')),
                    'memory_usage': float(data['memory']['physical'].split('MB')[0].strip()),
                    'memory_percent': float(data['memory']['physical'].split('(')[1].split('%')[0].strip()),
                    'virtual_memory': float(data['memory']['virtual'].split('MB')[0].strip()),
                    'gpu_usage': float(data['gpu']['usage'].replace('%', '')),
                    'gpu_memory': float(data['gpu']['memory'].replace('MB', '')),
                    'net_io_sent': float(data['io']['write'].split('MB')[0].strip()),
                    'net_io_recv': float(data['io']['read'].split('MB')[0].strip()),
                    'is_active': True,
                    'status': 1,
                    'log_file': log_file
                }
            )

            # 根据监控类型选择对应的模型
            if monitor_type == 'cpu':
                # 从字符串中提取CPU使用率数值
                cpu_usage = float(data['cpu']['usage'].replace('%', ''))
                logger.info(f"CPU使用率: {cpu_usage}%")  # 调试日志
                
                process_obj, created = HighCPUProcess.objects.update_or_create(
                    pid=pid,
                    defaults={
                        'process_name': process.name(),
                        'cpu_usage': cpu_usage,
                        'is_active': True,
                        'status': 1,
                        'log_file': log_file
                    }
                )
                logger.info(f"{'创建' if created else '更新'}CPU进程记录: {process_obj}")
                
            elif monitor_type == 'memory':
                # 从字符串中提取内存使用量和百分比
                memory_info = data['memory']['physical']
                memory_usage = float(memory_info.split('MB')[0].strip())
                memory_percent = float(memory_info.split('(')[1].split('%')[0].strip())
                
                HighMemoryProcess.objects.update_or_create(
                    pid=pid,
                    defaults={
                        'process_name': process.name(),
                        'memory_usage': memory_usage,
                        'memory_percent': memory_percent,
                        'is_active': True,
                        'status': 1,
                        'log_file': log_file
                    }
                )
                
            elif monitor_type == 'gpu':
                # 从字符串中提取GPU使用率和显存
                gpu_usage = float(data['gpu']['usage'].replace('%', ''))
                gpu_memory = float(data['gpu']['memory'].replace('MB', ''))
                
                HighGPUProcess.objects.update_or_create(
                    pid=pid,
                    defaults={
                        'process_name': process.name(),
                        'gpu_usage': gpu_usage,
                        'gpu_memory': gpu_memory,
                        'is_active': True,
                        'status': 1,
                        'log_file': log_file
                    }
                )

            return JsonResponse({
                'status': 'success',
                'data': data
            })

        except psutil.NoSuchProcess:
            # 进程已终止
            monitor.is_active = False
            monitor.status = 0
            monitor.save()
            
            return JsonResponse({
                'status': 'error',
                'message': f'进程 {pid} 已终止'
            })

    except Exception as e:
        return JsonResponse({
            'status': 'error',
            'message': str(e)
        })

def update_process_status(pid, monitor_type, is_active=False, status=0):
    """更新进程状态"""
    try:
        if monitor_type == 'cpu':
            HighCPUProcess.objects.filter(pid=pid).update(
                is_active=is_active,
                status=status
            )
        elif monitor_type == 'memory':
            HighMemoryProcess.objects.filter(pid=pid).update(
                is_active=is_active,
                status=status
            )
        elif monitor_type == 'gpu':
            HighGPUProcess.objects.filter(pid=pid).update(
                is_active=is_active,
                status=status
            )
    except Exception as e:
        logger.error(f"更新进程状态失败: {str(e)}")

def index(request):
    """渲染主页"""
    return render(request, 'index.html')

@csrf_exempt
@require_http_methods(["POST"])
def stop_auto_detect(request):
    """停止自动检测的API端点"""
    try:
        return JsonResponse({
            'status': 'success',
            'message': '已停止自动检测'
        }, json_dumps_params={'ensure_ascii': False})
    except Exception as e:
        logger.error(f"停止自动检测失败: {str(e)}")
        return JsonResponse({
            'status': 'error',
            'message': f'停止自动检测失败: {str(e)}'
        }, json_dumps_params={'ensure_ascii': False})

@csrf_exempt
@require_http_methods(["GET"])
def get_latest_log(request, pid):
    """获取最新的监控日志"""
    try:
        monitor_type = request.GET.get('type')  # 获取监控类型（cpu/gpu/memory）
        if not monitor_type:
            return JsonResponse({
                'status': 'error',
                'message': '请指定监控类型'
            })

        # 根据类型获取对应的监控记录
        monitor = None
        if monitor_type == 'cpu':
            monitor = HighCPUProcess.objects.filter(pid=pid, is_active=True).first()
        elif monitor_type == 'gpu':
            monitor = HighGPUProcess.objects.filter(pid=pid, is_active=True).first()
        elif monitor_type == 'memory':
            monitor = HighMemoryProcess.objects.filter(pid=pid, is_active=True).first()

        if not monitor:
            return JsonResponse({
                'status': 'error',
                'message': f'未找到进程 {pid} 的{monitor_type}监控记录'
            })

        # 获取最新数据
        try:
            process = psutil.Process(pid)
            with process.oneshot():
                data = {
                    'pid': pid,
                    'name': process.name(),
                    'status': 1,  # 1表示进程运行中
                }
                
                # 根据监控类型添加相应的数据
                if monitor_type == 'cpu':
                    data['cpu_percent'] = process.cpu_percent()
                elif monitor_type == 'memory':
                    memory_info = process.memory_info()
                    data['memory_gb'] = memory_info.rss / (1024 * 1024 * 1024)
                    data['memory_percent'] = process.memory_percent()
                elif monitor_type == 'gpu':
                    gpu_usage, gpu_memory = get_process_gpu_usage(pid)
                    data['gpu_usage'] = gpu_usage
                    data['gpu_memory'] = gpu_memory

            return JsonResponse({
                'status': 'success',
                'data': data
            })

        except psutil.NoSuchProcess:
            # 进程已终止
            monitor.is_active = False
            monitor.status = 0
            monitor.save()
            
            return JsonResponse({
                'status': 'error',
                'message': f'进程 {pid} 已终止'
            })

    except Exception as e:
        return JsonResponse({
            'status': 'error',
            'message': str(e)
        })

@csrf_exempt
@require_http_methods(["GET"])
def get_process_list(request):
    """获取当前监控的进程列表"""
    try:
        processes = []
        
        # 获取所有活跃的监控进程
        cpu_processes = HighCPUProcess.objects.filter(is_active=True)
        gpu_processes = HighGPUProcess.objects.filter(is_active=True)
        memory_processes = HighMemoryProcess.objects.filter(is_active=True)
        
        # 创建进程信息字典
        process_dict = {}
        
        # 处理 CPU 进程
        for proc in cpu_processes:
            if proc.pid not in process_dict:
                process_dict[proc.pid] = {
                    'pid': proc.pid,
                    'name': proc.process_name,
                    'cpu_percent': proc.cpu_usage,
                    'memory_gb': 0,
                    'memory_percent': 0,
                    'gpu_usage': 0,
                    'gpu_memory': 0,
                    'resource_types': ['cpu']
                }
            else:
                process_dict[proc.pid]['cpu_percent'] = proc.cpu_usage
                process_dict[proc.pid]['resource_types'].append('cpu')
        
        # 处理 GPU 进程
        for proc in gpu_processes:
            if proc.pid not in process_dict:
                process_dict[proc.pid] = {
                    'pid': proc.pid,
                    'name': proc.process_name,
                    'cpu_percent': 0,
                    'memory_gb': 0,
                    'memory_percent': 0,
                    'gpu_usage': proc.gpu_usage,
                    'gpu_memory': proc.gpu_memory,
                    'resource_types': ['gpu']
                }
            else:
                process_dict[proc.pid]['gpu_usage'] = proc.gpu_usage
                process_dict[proc.pid]['gpu_memory'] = proc.gpu_memory
                process_dict[proc.pid]['resource_types'].append('gpu')
        
        # 处理内存进程
        for proc in memory_processes:
            if proc.pid not in process_dict:
                process_dict[proc.pid] = {
                    'pid': proc.pid,
                    'name': proc.process_name,
                    'cpu_percent': 0,
                    'memory_gb': proc.memory_usage,
                    'memory_percent': proc.memory_percent,
                    'gpu_usage': 0,
                    'gpu_memory': 0,
                    'resource_types': ['memory']
                }
            else:
                process_dict[proc.pid]['memory_gb'] = proc.memory_usage
                process_dict[proc.pid]['memory_percent'] = proc.memory_percent
                process_dict[proc.pid]['resource_types'].append('memory')
        
        # 转换字典为列表
        processes = list(process_dict.values())
        
        # 按总资源占用率排序
        processes.sort(key=lambda x: (
            x['cpu_percent'] / 100 + 
            x['memory_percent'] / 100 + 
            x['gpu_usage'] / 100
        ), reverse=True)
        
        return JsonResponse({
            'status': 'success',
            'processes': processes
        }, json_dumps_params={'ensure_ascii': False})
        
    except Exception as e:
        return JsonResponse({
            'status': 'error',
            'message': str(e)
        }, json_dumps_params={'ensure_ascii': False})

def high_resource_list(request):
    """高资源进程列表视图"""
    context = {
        'cpu_processes': HighCPUProcess.objects.all().order_by('-updated_at'),
        'memory_processes': HighMemoryProcess.objects.all().order_by('-updated_at'),
        'gpu_processes': HighGPUProcess.objects.all().order_by('-updated_at'),
    }
    return render(request, 'high_resource_list.html', context)

def find_python_processes_in_dir(directory):
    """查找指定目录下运行的 Python 进程"""
    python_processes = []
    directory = str(Path(directory).resolve())  # 转换为绝对路径，并处理跨平台差异
    
    for proc in psutil.process_iter(['pid', 'name', 'cmdline', 'cwd']):
        try:
            # 检查是否是 Python 进程
            if proc.info['name'].lower().startswith('python'):
                # 检查进程的工作目录
                proc_cwd = str(Path(proc.info['cwd']).resolve())
                if proc_cwd.startswith(directory):
                    # 检查命令行参数
                    cmdline = proc.info['cmdline']
                    if cmdline:
                        python_processes.append({
                            'pid': proc.info['pid'],
                            'name': proc.info['name'],
                            'cmdline': ' '.join(cmdline),
                            'cwd': proc_cwd
                        })
        except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess):
            pass
    
    return python_processes

def get_gpu_info(pid):
    """获取进程的GPU使用信息"""
    try:
        import pynvml
        pynvml.nvmlInit()
        gpu_info = {
            'usage': 0,
            'memory': 0,
            'device_count': pynvml.nvmlDeviceGetCount()
        }
        
        for i in range(gpu_info['device_count']):
            handle = pynvml.nvmlDeviceGetHandleByIndex(i)
            procs = pynvml.nvmlDeviceGetComputeRunningProcesses(handle)
            for proc in procs:
                if proc.pid == pid:
                    gpu_info['memory'] = proc.usedGpuMemory / 1024 / 1024  # 转换为MB
                    gpu_info['usage'] = pynvml.nvmlDeviceGetUtilizationRates(handle).gpu
                    break
        return gpu_info
    except Exception as e:
        logger.error(f"获取GPU信息失败: {str(e)}")
        return {'usage': 0, 'memory': 0, 'device_count': 0}

def get_io_counters(proc):
    """获取进程的IO计数器信息"""
    try:
        io = proc.io_counters()
        return {
            'read_bytes': io.read_bytes / 1024 / 1024,  # 转换为MB
            'write_bytes': io.write_bytes / 1024 / 1024,
            'read_count': io.read_count,
            'write_count': io.write_count
        }
    except:
        return {'read_bytes': 0, 'write_bytes': 0, 'read_count': 0, 'write_count': 0}

def get_network_connections(proc):
    """获取进程的网络连接信息"""
    try:
        connections = []
        for conn in proc.connections():
            connections.append({
                'local_address': f"{conn.laddr.ip}:{conn.laddr.port}" if conn.laddr else "",
                'remote_address': f"{conn.raddr.ip}:{conn.raddr.port}" if conn.raddr else "",
                'status': conn.status
            })
        return connections
    except:
        return []

def get_open_files(proc):
    """获取进程打开的文件列表"""
    try:
        return [f.path for f in proc.open_files()]
    except:
        return []