personal-experiment/advanced_monitor.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
高级网络监控器
集成日志记录和通知功能
"""

import sys
import time
from datetime import datetime
from typing import Optional

from network_monitor import NetworkMonitor
from logger import Logger
from notifier import NotificationManager, ConsoleNotifier, DesktopNotifier


class AdvancedNetworkMonitor(NetworkMonitor):
    """高级网络监控器，继承自基础监控器"""
    
    def __init__(self, target_ip: str, delay_threshold: float = 30.0, 
                 ping_interval: float = 5.0, enable_logging: bool = True,
                 enable_notifications: bool = True):
        """
        初始化高级网络监控器
        
        Args:
            target_ip: 要监控的IP地址
            delay_threshold: 延迟阈值（秒）
            ping_interval: ping检测间隔（秒）
            enable_logging: 是否启用日志记录
            enable_notifications: 是否启用通知
        """
        super().__init__(target_ip, delay_threshold, ping_interval)
        
        # 初始化日志记录器
        self.enable_logging = enable_logging
        if self.enable_logging:
            self.logger = Logger()
            print(f"[{self._get_timestamp()}] 日志记录已启用")
        
        # 初始化通知管理器
        self.enable_notifications = enable_notifications
        if self.enable_notifications:
            self.notification_manager = NotificationManager(
                enable_console=True,
                enable_desktop=False  # 可设置为True启用桌面通知
            )
            print(f"[{self._get_timestamp()}] 通知功能已启用")
        
        print("-" * 60)
    
    def ping_host(self) -> bool:
        """执行ping操作并记录日志"""
        start_time = time.time()
        is_connected = super().ping_host()
        latency = (time.time() - start_time) * 1000  # 转换为毫秒
        
        if self.enable_logging:
            self.logger.log_ping(is_connected, latency)
        
        return is_connected
    
    def shutdown_system(self):
        """执行系统关机操作并发送通知"""
        print(f"\n[{self._get_timestamp()}] !!! 连续{self.delay_threshold}秒无法连接，准备关机 !!!")
        
        if self.enable_logging:
            self.logger.log_shutdown(
                f"连续{self.delay_threshold}秒无法连接到 {self.target_ip}"
            )
        
        if self.enable_notifications:
            self.notification_manager.notify_shutdown(
                f"连续{self.delay_threshold}秒无法连接到 {self.target_ip}"
            )
        
        # 保存日志
        if self.enable_logging:
            log_file = self.logger.save_session()
            print(f"[{self._get_timestamp()}] 日志已保存到: {log_file}")
        
        # 执行关机
        super().shutdown_system()
    
    def monitor(self):
        """启动网络监控"""
        print(f"[{self._get_timestamp()}] 开始高级监控...")
        print(f"[{self._get_timestamp()}] 每 {self.ping_interval} 秒执行一次ping操作")
        print("-" * 60)
        
        consecutive_failures = 0
        last_status = None
        
        try:
            while self.is_running:
                # 执行ping操作
                is_connected = self.ping_host()
                
                # 显示ping结果
                status_str = " → ✓ 连接正常" if is_connected else " → ✗ 连接失败"
                print(status_str)
                
                # 状态变化时额外输出日志和通知
                if last_status != is_connected:
                    if not is_connected:
                        print(f"[{self._get_timestamp()}] 状态变化: 检测到连接失败")
                        if self.enable_logging:
                            self.logger.log_status_change("disconnected")
                    else:
                        print(f"[{self._get_timestamp()}] 状态变化: 连接已恢复")
                        if self.enable_logging:
                            self.logger.log_status_change("connected")
                    last_status = is_connected
                
                if is_connected:
                    # 连接成功，重置失败计数
                    consecutive_failures = 0
                    self.failure_start_time = None
                else:
                    # 连接失败
                    consecutive_failures += 1
                    
                    if self.failure_start_time is None:
                        # 第一次失败，记录开始时间
                        self.failure_start_time = time.time()
                        print(f"[{self._get_timestamp()}] 开始记录连接失败时间")
                    else:
                        # 计算失败持续时间
                        failure_duration = time.time() - self.failure_start_time
                        remaining_time = self.delay_threshold - failure_duration
                        
                        if remaining_time > 0:
                            print(f"[{self._get_timestamp()}] 连续失败: {consecutive_failures}次, "
                                  f"已持续: {failure_duration:.1f}秒, "
                                  f"剩余: {remaining_time:.1f}秒")
                            
                            # 每隔一定时间发送通知
                            if int(failure_duration) % 10 == 0 and failure_duration > 0:
                                if self.enable_notifications:
                                    self.notification_manager.notify_connection_lost(
                                        self.target_ip, failure_duration
                                    )
                        
                        if failure_duration >= self.delay_threshold:
                            # 超过阈值，执行关机
                            self.shutdown_system()
                            self.is_running = False
                            break
                
                # 按照设定的间隔等待下一次ping操作
                print(f"[{self._get_timestamp()}] 等待 {self.ping_interval} 秒后执行下一次ping...")
                time.sleep(self.ping_interval)
                
        except KeyboardInterrupt:
            print(f"\n[{self._get_timestamp()}] 用户中断，监控已停止")
            print(f"[{self._get_timestamp()}] 总共执行了 {self.ping_count} 次ping操作")
            
            # 显示统计信息
            if self.enable_logging:
                stats = self.logger.get_statistics()
                print(f"[{self._get_timestamp()}] 统计信息:")
                print(f"  - 总ping次数: {stats['total_pings']}")
                print(f"  - 成功次数: {stats['successful_pings']}")
                print(f"  - 失败次数: {stats['failed_pings']}")
                print(f"  - 成功率: {stats['success_rate']}")
                print(f"  - 运行时长: {stats['session_duration']:.1f}秒")
                
                # 保存日志
                log_file = self.logger.save_session()
                print(f"[{self._get_timestamp()}] 日志已保存到: {log_file}")
                
        except Exception as e:
            print(f"\n[{self._get_timestamp()}] 监控过程中发生错误: {e}")
            print(f"[{self._get_timestamp()}] 总共执行了 {self.ping_count} 次ping操作")


def main():
    """主函数"""
    # 可配置参数
    CONFIG = {
        "target_ip": "8.8.8.8",  # 默认使用Google DNS
        "delay_threshold": 30.0,  # 延迟阈值（秒）
        "ping_interval": 5.0,     # Ping检测间隔（秒）
        "enable_logging": True,   # 启用日志记录
        "enable_notifications": True  # 启用通知
    }
    
    # 可以通过命令行参数覆盖配置
    if len(sys.argv) > 1:
        CONFIG["target_ip"] = sys.argv[1]
    if len(sys.argv) > 2:
        CONFIG["delay_threshold"] = float(sys.argv[2])
    if len(sys.argv) > 3:
        CONFIG["ping_interval"] = float(sys.argv[3])
    
    # 创建并启动监控器
    monitor = AdvancedNetworkMonitor(
        target_ip=CONFIG["target_ip"],
        delay_threshold=CONFIG["delay_threshold"],
        ping_interval=CONFIG["ping_interval"],
        enable_logging=CONFIG["enable_logging"],
        enable_notifications=CONFIG["enable_notifications"]
    )
    
    monitor.monitor()


if __name__ == "__main__":
    main()