修复可用空间不可用问题

主板CPU温度获取优化，改为sensors方式获取。有主板CPU温度获取错误的情况提交issues，并带上sensors命令的输出日志，我会做适配。

custom_components/fn_nas/coordinator.py

@@ -1,4 +1,3 @@
-# coordinator.py (文档9)
 import logging
 import asyncio
 import asyncssh
@@ -36,6 +35,10 @@ class FlynasCoordinator(DataUpdateCoordinator):
         self.docker_manager = DockerManager(self) if self.enable_docker else None
         self.ssh = None
         self.ssh_closed = True
+        # SSH连接池管理
+        self.ssh_pool = []
+        self.ssh_pool_size = 3  # 连接池大小
+        self.ssh_pool_lock = asyncio.Lock()
         self.ups_manager = UPSManager(self)
         self.vm_manager = VMManager(self)
         self.use_sudo = False
@@ -61,6 +64,9 @@ class FlynasCoordinator(DataUpdateCoordinator):
         self._last_command_time = 0
         self._command_count = 0
     
+        # 添加日志方法
+        self.debug_enabled = _LOGGER.isEnabledFor(logging.DEBUG)
+    
     def get_default_data(self):
         """返回默认的数据结构"""
         return {
@@ -76,153 +82,236 @@ class FlynasCoordinator(DataUpdateCoordinator):
             "docker_containers": []
         }
     
-    async def async_connect(self):
-        """建立并保持持久SSH连接"""
-        if self.ssh is not None and not self.ssh_closed:
-            try:
-                # 测试连接是否仍然活跃
-                await self.ssh.run("echo 'connection_test'", timeout=1)
-                return True
-            except (asyncssh.Error, TimeoutError):
-                _LOGGER.debug("现有连接失效，准备重建")
-                await self.async_disconnect()
-        
+    def _debug_log(self, message: str):
+        """只在调试模式下输出详细日志"""
+        if self.debug_enabled:
+            _LOGGER.debug(message)
+
+    def _info_log(self, message: str):
+        """重要信息日志"""
+        _LOGGER.info(message)
+
+    def _warning_log(self, message: str):
+        """警告日志"""
+        _LOGGER.warning(message)
+
+    def _error_log(self, message: str):
+        """错误日志"""
+        _LOGGER.error(message)
+
+    async def get_ssh_connection(self):
+        """从连接池获取可用的SSH连接"""
+        async with self.ssh_pool_lock:
+            # 检查现有连接
+            for i, (ssh, in_use) in enumerate(self.ssh_pool):
+                if not in_use:
+                    try:
+                        # 测试连接是否活跃
+                        await asyncio.wait_for(ssh.run("echo 'test'", timeout=1), timeout=2)
+                        self.ssh_pool[i] = (ssh, True)  # 标记为使用中
+                        self._debug_log(f"复用连接池中的连接 {i}")
+                        return ssh, i
+                    except Exception:
+                        # 连接失效，移除
+                        try:
+                            ssh.close()
+                        except:
+                            pass
+                        self.ssh_pool.pop(i)
+                        break
+            
+            # 如果连接池未满，创建新连接
+            if len(self.ssh_pool) < self.ssh_pool_size:
+                try:
+                    ssh = await asyncssh.connect(
+                        self.host,
+                        port=self.port,
+                        username=self.username,
+                        password=self.password,
+                        known_hosts=None,
+                        connect_timeout=5
+                    )
+                    
+                    # 检查并设置权限状态
+                    await self._setup_connection_permissions(ssh)
+                    
+                    connection_id = len(self.ssh_pool)
+                    self.ssh_pool.append((ssh, True))
+                    self._debug_log(f"创建新的SSH连接 {connection_id}")
+                    return ssh, connection_id
+                except Exception as e:
+                    self._debug_log(f"创建SSH连接失败: {e}")
+                    raise
+            
+            # 连接池满且所有连接都在使用中，等待可用连接
+            self._debug_log("所有连接都在使用中，等待可用连接...")
+            for _ in range(50):  # 最多等待5秒
+                await asyncio.sleep(0.1)
+                for i, (ssh, in_use) in enumerate(self.ssh_pool):
+                    if not in_use:
+                        try:
+                            await asyncio.wait_for(ssh.run("echo 'test'", timeout=1), timeout=2)
+                            self.ssh_pool[i] = (ssh, True)
+                            self._debug_log(f"等待后获得连接 {i}")
+                            return ssh, i
+                        except Exception:
+                            try:
+                                ssh.close()
+                            except:
+                                pass
+                            self.ssh_pool.pop(i)
+                            break
+            
+            raise Exception("无法获取SSH连接")
+
+    async def _setup_connection_permissions(self, ssh):
+        """为新连接设置权限状态"""
         try:
-            self.ssh = await asyncssh.connect(
-                self.host,
-                port=self.port,
-                username=self.username,
-                password=self.password,
-                known_hosts=None,
-                connect_timeout=5
-            )
-            
-            self.ssh_closed = False
-            _LOGGER.info("已建立持久SSH连接到 %s", self.host)
-            
-            # 检查权限状态
-            if await self.is_root_user():
-                _LOGGER.debug("当前用户是 root")
+            # 检查是否为root用户
+            result = await ssh.run("id -u", timeout=3)
+            if result.stdout.strip() == "0":
+                self._debug_log("当前用户是 root")
                 self.use_sudo = False
-            else:
-                # 尝试切换到root会话
-                if await self.try_switch_to_root():
-                    self.use_sudo = False
+                return
             
-            return True
-        
-        except Exception as e:
-            self.ssh = None
-            self.ssh_closed = True
-            _LOGGER.debug("连接失败: %s", str(e))
-            return False
-    
-    async def try_switch_to_root(self):
-        """尝试切换到root会话"""
-        try:
+            # 尝试切换到root会话
             if self.root_password:
-                result = await self.ssh.run(
-                    f"echo '{self.root_password}' | sudo -S -i",
-                    input=self.root_password + "\n",
+                try:
+                    await ssh.run(
+                        f"echo '{self.root_password}' | sudo -S -i",
+                        input=self.root_password + "\n",
+                        timeout=5
+                    )
+                    whoami = await ssh.run("whoami")
+                    if "root" in whoami.stdout:
+                        self._info_log("成功切换到 root 会话（使用 root 密码）")
+                        self.use_sudo = False
+                        return
+                except Exception:
+                    pass
+            
+            # 尝试使用登录密码sudo
+            try:
+                await ssh.run(
+                    f"echo '{self.password}' | sudo -S -i",
+                    input=self.password + "\n",
                     timeout=5
                 )
-                whoami = await self.ssh.run("whoami")
+                whoami = await ssh.run("whoami")
                 if "root" in whoami.stdout:
-                    _LOGGER.info("成功切换到 root 会话（使用 root 密码）")
-                    return True
-                
-            result = await self.ssh.run(
-                f"echo '{self.password}' | sudo -S -i",
-                input=self.password + "\n",
-                timeout=5
-            )
-            whoami = await self.ssh.run("whoami")
-            if "root" in whoami.stdout:
-                _LOGGER.info("成功切换到 root 会话（使用登录密码）")
-                return True
+                    self._info_log("成功切换到 root 会话（使用登录密码）")
+                    self.use_sudo = False
+                    return
+            except Exception:
+                pass
                 
+            # 设置为使用sudo模式
             self.use_sudo = True
-            return False
-        except Exception:
+            self._debug_log("设置为使用sudo模式")
+            
+        except Exception as e:
+            self._debug_log(f"设置连接权限失败: {e}")
             self.use_sudo = True
-            return False
+
+    async def release_ssh_connection(self, connection_id):
+        """释放SSH连接回连接池"""
+        async with self.ssh_pool_lock:
+            if 0 <= connection_id < len(self.ssh_pool):
+                ssh, _ = self.ssh_pool[connection_id]
+                self.ssh_pool[connection_id] = (ssh, False)  # 标记为可用
+                self._debug_log(f"释放SSH连接 {connection_id}")
     
-    async def is_root_user(self):
+    async def close_all_ssh_connections(self):
+        """关闭所有SSH连接"""
+        async with self.ssh_pool_lock:
+            for ssh, _ in self.ssh_pool:
+                try:
+                    ssh.close()
+                except:
+                    pass
+            self.ssh_pool.clear()
+            self._debug_log("已关闭所有SSH连接")
+    
+    async def async_connect(self):
+        """建立并保持持久SSH连接 - 兼容旧代码"""
         try:
-            result = await self.ssh.run("id -u", timeout=3)
-            return result.stdout.strip() == "0"
+            ssh, connection_id = await self.get_ssh_connection()
+            await self.release_ssh_connection(connection_id)
+            return True
         except Exception:
             return False
     
     async def async_disconnect(self):
-        """断开SSH连接"""
-        if self.ssh is not None and not self.ssh_closed:
-            try:
-                self.ssh.close()
-                self.ssh_closed = True
-                _LOGGER.debug("已关闭SSH连接")
-            except Exception as e:
-                _LOGGER.debug("关闭SSH连接时出错: %s", str(e))
-            finally:
-                self.ssh = None
+        """断开SSH连接 - 兼容旧代码"""
+        await self.close_all_ssh_connections()
     
     async def run_command(self, command: str, retries=2) -> str:
-        """执行SSH命令，使用持久连接"""
-        current_time = asyncio.get_event_loop().time()
-        
-        # 连接冷却机制：避免短时间内频繁创建新连接
-        if current_time - self._last_command_time < 1.0 and self._command_count > 5:
-            await asyncio.sleep(0.5)
-        
-        self._last_command_time = current_time
-        self._command_count += 1
-        
+        """执行SSH命令，使用连接池"""
         # 系统离线时直接返回空字符串
         if not self._system_online:
             return ""
-            
+        
+        ssh = None
+        connection_id = None
+        
         try:
-            # 确保连接有效
-            if not await self.async_connect():
-                return ""
-                
-            # 使用sudo执行命令
+            # 从连接池获取连接
+            ssh, connection_id = await self.get_ssh_connection()
+            
+            # 构建完整命令
             if self.use_sudo:
                 if self.root_password or self.password:
                     password = self.root_password if self.root_password else self.password
                     full_command = f"sudo -S {command}"
-                    result = await self.ssh.run(full_command, input=password + "\n", timeout=10)
+                    result = await ssh.run(full_command, input=password + "\n", timeout=10)
                 else:
                     full_command = f"sudo {command}"
-                    result = await self.ssh.run(full_command, timeout=10)
+                    result = await ssh.run(full_command, timeout=10)
             else:
-                result = await self.ssh.run(command, timeout=10)
-                
+                result = await ssh.run(command, timeout=10)
+            
             return result.stdout.strip()
         
-        except (asyncssh.Error, TimeoutError) as e:
-            _LOGGER.debug("命令执行失败: %s, 错误: %s", command, str(e))
-            # 标记连接失效
-            self.ssh_closed = True
-            return ""
         except Exception as e:
-            _LOGGER.debug("执行命令时出现意外错误: %s", str(e))
-            self.ssh_closed = True
+            self._debug_log(f"命令执行失败: {command}, 错误: {str(e)}")
             return ""
+        
+        finally:
+            # 释放连接回连接池
+            if connection_id is not None:
+                await self.release_ssh_connection(connection_id)
     
-    async def _monitor_system_status(self):
-        """系统离线时轮询检测状态"""
-        self.logger.debug("启动系统状态监控，每%d秒检测一次", self._retry_interval)
-        while True:
-            await asyncio.sleep(self._retry_interval)
+    async def run_command_direct(self, command: str) -> str:
+        """直接执行命令，获取独立连接 - 用于并发任务"""
+        if not self._system_online:
+            return ""
+        
+        ssh = None
+        connection_id = None
+        
+        try:
+            ssh, connection_id = await self.get_ssh_connection()
             
-            if await self.ping_system():
-                self.logger.info("检测到系统已开机，触发重新加载")
-                # 触发集成重新加载
-                self.hass.async_create_task(
-                    self.hass.config_entries.async_reload(self.config_entry.entry_id)
-                )
-                break
+            if self.use_sudo:
+                if self.root_password or self.password:
+                    password = self.root_password if self.root_password else self.password
+                    full_command = f"sudo -S {command}"
+                    result = await ssh.run(full_command, input=password + "\n", timeout=10)
+                else:
+                    full_command = f"sudo {command}"
+                    result = await ssh.run(full_command, timeout=10)
+            else:
+                result = await ssh.run(command, timeout=10)
+            
+            return result.stdout.strip()
+        
+        except Exception as e:
+            self._debug_log(f"直接命令执行失败: {command}, 错误: {str(e)}")
+            return ""
+        
+        finally:
+            if connection_id is not None:
+                await self.release_ssh_connection(connection_id)
     
     async def ping_system(self) -> bool:
         """轻量级系统状态检测"""
@@ -231,58 +320,96 @@ class FlynasCoordinator(DataUpdateCoordinator):
             return True
             
         try:
-            # 使用异步ping检测
+            # 使用异步ping检测，减少超时时间
             proc = await asyncio.create_subprocess_exec(
                 'ping', '-c', '1', '-W', '1', self.host,
                 stdout=asyncio.subprocess.DEVNULL,
                 stderr=asyncio.subprocess.DEVNULL
             )
-            await proc.wait()
+            await asyncio.wait_for(proc.wait(), timeout=2)  # 总超时时间2秒
             return proc.returncode == 0
         except Exception:
             return False
     
+    async def _monitor_system_status(self):
+        """系统离线时轮询检测状态"""
+        self._debug_log(f"启动系统状态监控，每{self._retry_interval}秒检测一次")
+        
+        # 使用指数退避策略，避免频繁检测
+        check_interval = self._retry_interval
+        max_interval = 300  # 最大5分钟检测一次
+        
+        while True:
+            await asyncio.sleep(check_interval)
+            
+            if await self.ping_system():
+                self._info_log("检测到系统已开机，触发重新加载")
+                # 触发集成重新加载
+                self.hass.async_create_task(
+                    self.hass.config_entries.async_reload(self.config_entry.entry_id)
+                )
+                break
+            else:
+                # 系统仍然离线，增加检测间隔（指数退避）
+                check_interval = min(check_interval * 1.5, max_interval)
+                self._debug_log(f"系统仍离线，下次检测间隔: {check_interval}秒")
+    
     async def _async_update_data(self):
         """数据更新入口，优化命令执行频率"""
-        _LOGGER.debug("开始数据更新...")
+        self._debug_log("开始数据更新...")
         is_online = await self.ping_system()
         self._system_online = is_online
         
         if not is_online:
-            _LOGGER.debug("系统离线，跳过数据更新")
+            self._debug_log("系统离线，跳过数据更新")
             # 启动后台监控任务
             if not self._ping_task or self._ping_task.done():
                 self._ping_task = asyncio.create_task(self._monitor_system_status())
-            await self.async_disconnect()
+            await self.close_all_ssh_connections()
             return self.get_default_data()
         
         # 系统在线处理
         try:
-            # 确保连接有效
-            if not await self.async_connect():
-                return self.get_default_data()
-                
+            # 预热连接池并确保权限设置正确
+            await self.async_connect()
+            
             # 获取系统状态信息
             status = "on"
-            # 并行获取磁盘、UPS和系统信息
-            system_task = asyncio.create_task(self.system_manager.get_system_info())
-            disks_task = asyncio.create_task(self.disk_manager.get_disks_info())
-            ups_task = asyncio.create_task(self.ups_manager.get_ups_info())
-            vms_task = asyncio.create_task(self.vm_manager.get_vm_list())
             
-            # 等待并行任务完成
-            system, disks, ups_info, vms = await asyncio.gather(
-                system_task, disks_task, ups_task, vms_task
-            )
+            # 串行获取信息以确保稳定性
+            self._debug_log("开始获取系统信息...")
+            system = await self.system_manager.get_system_info()
+            self._debug_log("系统信息获取完成")
+            
+            self._debug_log("开始获取磁盘信息...")
+            disks = await self.disk_manager.get_disks_info()
+            self._debug_log(f"磁盘信息获取完成，数量: {len(disks)}")
+            
+            self._debug_log("开始获取UPS信息...")
+            ups_info = await self.ups_manager.get_ups_info()
+            self._debug_log("UPS信息获取完成")
+            
+            self._debug_log("开始获取虚拟机信息...")
+            vms = await self.vm_manager.get_vm_list()
+            self._debug_log(f"虚拟机信息获取完成，数量: {len(vms)}")
             
             # 为每个虚拟机获取标题
             for vm in vms:
-                vm["title"] = await self.vm_manager.get_vm_title(vm["name"])
+                try:
+                    vm["title"] = await self.vm_manager.get_vm_title(vm["name"])
+                except Exception as e:
+                    self._debug_log(f"获取VM标题失败 {vm['name']}: {e}")
+                    vm["title"] = vm["name"]
             
             # 获取Docker容器信息
             docker_containers = []
-            if self.enable_docker:
-                docker_containers = await self.docker_manager.get_containers()
+            if self.enable_docker and self.docker_manager:
+                self._debug_log("开始获取Docker信息...")
+                try:
+                    docker_containers = await self.docker_manager.get_containers()
+                    self._debug_log(f"Docker信息获取完成，数量: {len(docker_containers)}")
+                except Exception as e:
+                    self._debug_log(f"Docker信息获取失败: {e}")
             
             data = {
                 "disks": disks,
@@ -292,40 +419,24 @@ class FlynasCoordinator(DataUpdateCoordinator):
                 "docker_containers": docker_containers
             }
             
+            self._debug_log(f"数据更新完成: disks={len(disks)}, vms={len(vms)}, containers={len(docker_containers)}")
             return data
         
         except Exception as e:
-            _LOGGER.debug("数据更新失败: %s", str(e))
+            self._error_log(f"数据更新失败: {str(e)}")
             self._system_online = False
             if not self._ping_task or self._ping_task.done():
                 self._ping_task = asyncio.create_task(self._monitor_system_status())
                 
             return self.get_default_data()
-    
-    def get_default_data(self):
-        """获取默认数据（离线状态）"""
-        return {
-            "disks": [],
-            "system": {
-                "uptime": "未知",
-                "cpu_temperature": "未知",
-                "motherboard_temperature": "未知",
-                "status": "off"
-            },
-            "ups": {},
-            "vms": [],
-            "docker_containers": []
-        }
+
+    async def shutdown_system(self):
+        """关闭系统 - 委托给SystemManager"""
+        return await self.system_manager.shutdown_system()
     
     async def reboot_system(self):
-        await self.system_manager.reboot_system()
-    
-    async def shutdown_system(self):
-        await self.system_manager.shutdown_system()
-        # 更新状态，但使用安全的方式
-        if self.data and isinstance(self.data, dict) and "system" in self.data:
-            self.data["system"]["status"] = "off"
-        self.async_update_listeners()
+        """重启系统 - 委托给SystemManager"""
+        return await self.system_manager.reboot_system()
 
 class UPSDataUpdateCoordinator(DataUpdateCoordinator):
     def __init__(self, hass: HomeAssistant, config, main_coordinator):
@@ -357,10 +468,7 @@ class UPSDataUpdateCoordinator(DataUpdateCoordinator):
 
     async def control_vm(self, vm_name, action):
         try:
-            if not hasattr(self, 'vm_manager'):
-                self.vm_manager = VMManager(self)
-            
-            result = await self.vm_manager.control_vm(vm_name, action)
+            result = await self.main_coordinator.vm_manager.control_vm(vm_name, action)
             return result
         except Exception as e:
             _LOGGER.debug("虚拟机控制失败: %s", str(e))

custom_components/fn_nas/disk_manager.py

@@ -14,6 +14,7 @@ class DiskManager:
         self.disk_full_info_cache = {}  # 缓存磁盘完整信息
         self.first_run = True  # 首次运行标志
         self.initial_detection_done = False  # 首次完整检测完成标志
+        self.disk_io_stats_cache = {}  # 缓存磁盘I/O统计信息
     
     def extract_value(self, text: str, patterns, default="未知", format_func=None):
         if not text:
@@ -38,10 +39,9 @@ class DiskManager:
     async def check_disk_active(self, device: str, window: int = 30) -> bool:
         """检查硬盘在指定时间窗口内是否有活动"""
         try:
-            # 正确的路径是 /sys/block/{device}/stat
             stat_path = f"/sys/block/{device}/stat"
             
-            # 读取统计文件
+            # 读取当前统计文件
             stat_output = await self.coordinator.run_command(f"cat {stat_path} 2>/dev/null")
             if not stat_output:
                 self.logger.debug(f"无法读取 {stat_path}，默认返回活跃状态")
@@ -52,52 +52,148 @@ class DiskManager:
             if len(stats) < 11:
                 self.logger.debug(f"无效的统计信息格式：{stat_output}")
                 return True
-                
-            # 关键字段：当前正在进行的I/O操作数量（第9个字段，索引8）
-            in_flight = int(stats[8])
             
-            # 如果当前有I/O操作，直接返回活跃状态
-            if in_flight > 0:
+            try:
+                # /sys/block/{device}/stat 字段说明：
+                # 0: read I/Os requests      读请求次数
+                # 1: read I/Os merged        读请求合并次数
+                # 2: read sectors            读扇区数
+                # 3: read ticks              读操作耗时(ms)
+                # 4: write I/Os requests     写请求次数
+                # 5: write I/Os merged       写请求合并次数
+                # 6: write sectors           写扇区数
+                # 7: write ticks             写操作耗时(ms)
+                # 8: in_flight               当前进行中的I/O请求数
+                # 9: io_ticks                I/O活动时间(ms)
+                # 10: time_in_queue          队列中的总时间(ms)
+                
+                current_stats = {
+                    'read_ios': int(stats[0]),
+                    'write_ios': int(stats[4]),
+                    'in_flight': int(stats[8]),
+                    'io_ticks': int(stats[9])
+                }
+                
+                # 如果当前有正在进行的I/O操作，直接返回活跃状态
+                if current_stats['in_flight'] > 0:
+                    self.logger.debug(f"磁盘 {device} 有正在进行的I/O操作: {current_stats['in_flight']}")
+                    self.disk_io_stats_cache[device] = current_stats
+                    return True
+                
+                # 检查是否有缓存的统计信息
+                cached_stats = self.disk_io_stats_cache.get(device)
+                
+                if cached_stats:
+                    # 比较I/O请求次数的变化
+                    read_ios_diff = current_stats['read_ios'] - cached_stats['read_ios']
+                    write_ios_diff = current_stats['write_ios'] - cached_stats['write_ios']
+                    io_ticks_diff = current_stats['io_ticks'] - cached_stats['io_ticks']
+                    
+                    self.logger.debug(f"磁盘 {device} I/O变化: 读={read_ios_diff}, 写={write_ios_diff}, 活动时间={io_ticks_diff}ms")
+                    
+                    # 如果在检测窗口内有I/O活动，认为磁盘活跃
+                    if read_ios_diff > 0 or write_ios_diff > 0 or io_ticks_diff > 100:  # 100ms内的活动
+                        self.logger.debug(f"磁盘 {device} 在窗口期内有I/O活动")
+                        self.disk_io_stats_cache[device] = current_stats
+                        return True
+                    
+                    # 检查io_ticks是否表明最近有活动
+                    # io_ticks是累积值，如果在合理范围内增长，说明有轻微活动
+                    if io_ticks_diff > 0 and io_ticks_diff < window * 1000:  # 在窗口时间内的轻微活动
+                        self.logger.debug(f"磁盘 {device} 有轻微I/O活动")
+                        self.disk_io_stats_cache[device] = current_stats
+                        return True
+                else:
+                    # 首次检测，保存当前状态并认为活跃
+                    self.logger.debug(f"磁盘 {device} 首次检测，保存统计信息")
+                    self.disk_io_stats_cache[device] = current_stats
+                    return True
+                
+                # 更新缓存
+                self.disk_io_stats_cache[device] = current_stats
+                
+                # 检查硬盘电源状态
+                power_state = await self.get_disk_power_state(device)
+                if power_state in ["standby", "sleep", "idle"]:
+                    self.logger.debug(f"磁盘 {device} 处于省电状态: {power_state}")
+                    return False
+                
+                # 所有检查都通过，返回非活跃状态
+                self.logger.debug(f"磁盘 {device} 判定为非活跃状态")
+                return False
+                
+            except (ValueError, IndexError) as e:
+                self.logger.debug(f"解析统计信息失败: {e}")
                 return True
                 
-            # 检查I/O操作时间（第10个字段，索引9） - io_ticks（单位毫秒）
-            io_ticks = int(stats[9])
-            
-            # 如果设备在窗口时间内有I/O活动，返回活跃状态
-            if io_ticks > window * 1000:
-                return True
-                
-            # 所有检查都通过，返回非活跃状态
-            return False
-            
         except Exception as e:
-            self.logger.error(f"检测硬盘活动状态失败: {str(e)}", exc_info=True)
+            self.logger.error(f"检测硬盘活动状态失败: {str(e)}")
             return True  # 出错时默认执行检测
     
-    async def get_disk_activity(self, device: str) -> str:
-        """获取硬盘活动状态（活动中/空闲中/休眠中）"""
+    async def get_disk_power_state(self, device: str) -> str:
+        """获取硬盘电源状态"""
         try:
-            # 检查硬盘是否处于休眠状态
+            # 检查 SCSI 设备状态
             state_path = f"/sys/block/{device}/device/state"
             state_output = await self.coordinator.run_command(f"cat {state_path} 2>/dev/null || echo 'unknown'")
             state = state_output.strip().lower()
             
-            if state in ["standby", "sleep"]:
+            if state in ["running", "active"]:
+                return "active"
+            elif state in ["standby", "sleep"]:
+                return state
+            
+            # 对于某些设备，尝试通过hdparm检查状态（非侵入性）
+            hdparm_output = await self.coordinator.run_command(f"hdparm -C /dev/{device} 2>/dev/null || echo 'unknown'")
+            if "standby" in hdparm_output.lower():
+                return "standby" 
+            elif "sleeping" in hdparm_output.lower():
+                return "sleep"
+            elif "active/idle" in hdparm_output.lower():
+                return "active"
+            
+            return "unknown"
+            
+        except Exception as e:
+            self.logger.debug(f"获取磁盘 {device} 电源状态失败: {e}")
+            return "unknown"
+    
+    async def get_disk_activity(self, device: str) -> str:
+        """获取硬盘活动状态（活动中/空闲中/休眠中）"""
+        try:
+            # 先检查电源状态
+            power_state = await self.get_disk_power_state(device)
+            if power_state in ["standby", "sleep"]:
                 return "休眠中"
             
-            # 检查最近一分钟内的硬盘活动
+            # 检查最近的I/O活动
             stat_path = f"/sys/block/{device}/stat"
-            stat_output = await self.coordinator.run_command(f"cat {stat_path}")
-            stats = stat_output.split()
+            stat_output = await self.coordinator.run_command(f"cat {stat_path} 2>/dev/null")
             
-            if len(stats) >= 11:
-                # 第9个字段是最近完成的读操作数
-                # 第10个字段是最近完成的写操作数
-                recent_reads = int(stats[8])
-                recent_writes = int(stats[9])
-                
-                if recent_reads > 0 or recent_writes > 0:
-                    return "活动中"
+            if stat_output:
+                stats = stat_output.split()
+                if len(stats) >= 11:
+                    try:
+                        in_flight = int(stats[8])  # 当前进行中的I/O
+                        
+                        # 如果有正在进行的I/O，返回活动中
+                        if in_flight > 0:
+                            return "活动中"
+                        
+                        # 检查缓存的统计信息来判断近期活动
+                        cached_stats = self.disk_io_stats_cache.get(device)
+                        if cached_stats:
+                            current_read_ios = int(stats[0])
+                            current_write_ios = int(stats[4])
+                            
+                            read_diff = current_read_ios - cached_stats.get('read_ios', 0)
+                            write_diff = current_write_ios - cached_stats.get('write_ios', 0)
+                            
+                            if read_diff > 0 or write_diff > 0:
+                                return "活动中"
+                        
+                    except (ValueError, IndexError):
+                        pass
             
             return "空闲中"
             

custom_components/fn_nas/manifest.json

@@ -1,7 +1,7 @@
 {
   "domain": "fn_nas",
   "name": "飞牛NAS",
-  "version": "1.3.5",
+  "version": "1.3.7",
   "documentation": "https://github.com/anxms/fn_nas",
   "dependencies": [],
   "codeowners": ["@anxms"],

custom_components/fn_nas/system_manager.py

@@ -9,10 +9,41 @@ class SystemManager:
     def __init__(self, coordinator):
         self.coordinator = coordinator
         self.logger = _LOGGER.getChild("system_manager")
-        self.logger.setLevel(logging.DEBUG)
-        self.debug_enabled = False  # 调试模式开关
-        self.sensors_debug_path = "/config/fn_nas_debug"  # 调试文件保存路径
-    
+        # 根据Home Assistant的日志级别动态设置
+        self.logger.setLevel(logging.DEBUG if _LOGGER.isEnabledFor(logging.DEBUG) else logging.INFO)
+        self.debug_enabled = _LOGGER.isEnabledFor(logging.DEBUG)  # 基于HA调试模式
+        self.sensors_debug_path = "/config/fn_nas_debug"
+        
+        # 温度传感器缓存
+        self.cpu_temp_cache = {
+            "hwmon_id": None,
+            "temp_id": None,
+            "driver_type": None,
+            "label": None
+        }
+        self.mobo_temp_cache = {
+            "hwmon_id": None,
+            "temp_id": None,
+            "label": None
+        }
+
+    def _debug_log(self, message: str):
+        """只在调试模式下输出详细日志"""
+        if self.debug_enabled:
+            self.logger.debug(message)
+
+    def _info_log(self, message: str):
+        """重要信息日志"""
+        self.logger.info(message)
+
+    def _warning_log(self, message: str):
+        """警告日志"""
+        self.logger.warning(message)
+
+    def _error_log(self, message: str):
+        """错误日志"""
+        self.logger.error(message)
+
     async def get_system_info(self) -> dict:
         """获取系统信息"""
         system_info = {}
@@ -31,13 +62,10 @@ class SystemManager:
                 system_info["uptime_seconds"] = 0
                 system_info["uptime"] = "未知"
 
-            # 只通过内核方式获取温度
-            cpu_temp = await self.get_cpu_temp_from_kernel()
-            system_info["cpu_temperature"] = cpu_temp
-
-            mobo_temp = await self.get_mobo_temp_from_kernel()
-            system_info["motherboard_temperature"] = mobo_temp
-
+            # 一次性获取CPU和主板温度
+            temps = await self.get_temperatures_from_sensors()
+            system_info["cpu_temperature"] = temps["cpu"]
+            system_info["motherboard_temperature"] = temps["motherboard"]
 
             mem_info = await self.get_memory_info()
             system_info.update(mem_info)
@@ -58,41 +86,163 @@ class SystemManager:
                 "volumes": {}
             }
 
+    async def get_temperatures_from_sensors(self) -> dict:
+        """一次性获取CPU和主板温度"""
+        try:
+            command = "sensors"
+            self._debug_log(f"执行sensors命令获取温度: {command}")
+            
+            sensors_output = await self.coordinator.run_command(command)
+            if self.debug_enabled:
+                self._debug_log(f"sensors命令输出长度: {len(sensors_output) if sensors_output else 0}")
+            
+            if not sensors_output:
+                self._warning_log("sensors命令无输出")
+                return {"cpu": "未知", "motherboard": "未知"}
+            
+            # 同时解析CPU和主板温度
+            cpu_temp = self.extract_cpu_temp_from_sensors(sensors_output)
+            mobo_temp = self.extract_mobo_temp_from_sensors(sensors_output)
+            
+            # 记录获取结果
+            if cpu_temp != "未知":
+                self._info_log(f"通过sensors获取CPU温度成功: {cpu_temp}")
+            else:
+                self._warning_log("sensors命令未找到CPU温度")
+                
+            if mobo_temp != "未知":
+                self._info_log(f"通过sensors获取主板温度成功: {mobo_temp}")
+            else:
+                self._warning_log("sensors命令未找到主板温度")
+            
+            return {"cpu": cpu_temp, "motherboard": mobo_temp}
+            
+        except Exception as e:
+            self._error_log(f"使用sensors命令获取温度失败: {e}")
+            return {"cpu": "未知", "motherboard": "未知"}
+
     async def get_cpu_temp_from_kernel(self) -> str:
-        # 获取CPU温度
-        for i in range(5):
-            for j in range(5):
-                label_path = f"/sys/class/hwmon/hwmon{i}/temp{j}_label"
-                label = await self.coordinator.run_command(f"cat {label_path} 2>/dev/null")
-                if label and ("cpu" in label.lower() or "package" in label.lower()):
-                    temp_path = f"/sys/class/hwmon/hwmon{i}/temp{j}_input"
-                    temp_str = await self.coordinator.run_command(f"cat {temp_path} 2>/dev/null")
-                    if temp_str and temp_str.isdigit():
-                        temp = float(temp_str) / 1000.0
-                        return f"{temp:.1f} °C"
-        return "未知"
+        """获取CPU温度 - 向后兼容"""
+        temps = await self.get_temperatures_from_sensors()
+        return temps["cpu"]
 
     async def get_mobo_temp_from_kernel(self) -> str:
-        # 获取主板温度
-        for i in range(5):
-            for j in range(5):
-                label_path = f"/sys/class/hwmon/hwmon{i}/temp{j}_label"
-                label = await self.coordinator.run_command(f"cat {label_path} 2>/dev/null")
-                if label and ("mobo" in label.lower() or "mb" in label.lower() or "sys" in label.lower() or "pch" in label.lower()):
-                    temp_path = f"/sys/class/hwmon/hwmon{i}/temp{j}_input"
-                    temp_str = await self.coordinator.run_command(f"cat {temp_path} 2>/dev/null")
-                    if temp_str and temp_str.isdigit():
-                        temp = float(temp_str) / 1000.0
-                        return f"{temp:.1f} °C"
-        return "未知"
-    
-    def extract_cpu_temp(self, sensors_output: str) -> str:
-        """兼容旧接口，直接返回未知"""
-        return "未知"
+        """获取主板温度 - 向后兼容"""
+        temps = await self.get_temperatures_from_sensors()
+        return temps["motherboard"]
 
-    def extract_mobo_temp(self, sensors_output: str) -> str:
-        """兼容旧接口，直接返回未知"""
-        return "未知"
+    async def get_cpu_temp_from_sensors(self) -> str:
+        """使用sensors命令获取CPU温度 - 向后兼容"""
+        temps = await self.get_temperatures_from_sensors()
+        return temps["cpu"]
+
+    async def get_mobo_temp_from_sensors(self) -> str:
+        """使用sensors命令获取主板温度 - 向后兼容"""
+        temps = await self.get_temperatures_from_sensors()
+        return temps["motherboard"]
+
+    def extract_cpu_temp_from_sensors(self, sensors_output: str) -> str:
+        """从sensors输出中提取CPU温度"""
+        try:
+            lines = sensors_output.split('\n')
+            self._debug_log(f"解析sensors输出，共{len(lines)}行")
+            
+            for i, line in enumerate(lines):
+                line_lower = line.lower().strip()
+                if self.debug_enabled:
+                    self._debug_log(f"第{i+1}行: {line_lower}")
+                
+                # AMD CPU温度关键词
+                if any(keyword in line_lower for keyword in [
+                    "tctl", "tdie", "k10temp"
+                ]):
+                    self._debug_log(f"找到AMD CPU温度行: {line}")
+                    if '+' in line and '°c' in line_lower:
+                        try:
+                            temp_match = line.split('+')[1].split('°')[0].strip()
+                            temp = float(temp_match)
+                            if 0 < temp < 150:
+                                self._info_log(f"从sensors提取AMD CPU温度: {temp:.1f}°C")
+                                return f"{temp:.1f} °C"
+                        except (ValueError, IndexError) as e:
+                            self._debug_log(f"解析AMD温度失败: {e}")
+                            continue
+                
+                # Intel CPU温度关键词
+                if any(keyword in line_lower for keyword in [
+                    "package id", "core 0", "coretemp"
+                ]) and not any(exclude in line_lower for exclude in ["fan"]):
+                    self._debug_log(f"找到Intel CPU温度行: {line}")
+                    if '+' in line and '°c' in line_lower:
+                        try:
+                            temp_match = line.split('+')[1].split('°')[0].strip()
+                            temp = float(temp_match)
+                            if 0 < temp < 150:
+                                self._info_log(f"从sensors提取Intel CPU温度: {temp:.1f}°C")
+                                return f"{temp:.1f} °C"
+                        except (ValueError, IndexError) as e:
+                            self._debug_log(f"解析Intel温度失败: {e}")
+                            continue
+                
+                # 通用CPU温度模式
+                if ('cpu' in line_lower or 'processor' in line_lower) and '+' in line and '°c' in line_lower:
+                    self._debug_log(f"找到通用CPU温度行: {line}")
+                    try:
+                        temp_match = line.split('+')[1].split('°')[0].strip()
+                        temp = float(temp_match)
+                        if 0 < temp < 150:
+                            self._info_log(f"从sensors提取通用CPU温度: {temp:.1f}°C")
+                            return f"{temp:.1f} °C"
+                    except (ValueError, IndexError) as e:
+                        self._debug_log(f"解析通用CPU温度失败: {e}")
+                        continue
+            
+            self._warning_log("未在sensors输出中找到CPU温度")
+            return "未知"
+            
+        except Exception as e:
+            self._error_log(f"解析sensors CPU温度输出失败: {e}")
+            return "未知"
+
+    def extract_mobo_temp_from_sensors(self, sensors_output: str) -> str:
+        """从sensors输出中提取主板温度"""
+        try:
+            lines = sensors_output.split('\n')
+            self._debug_log(f"解析主板温度，共{len(lines)}行")
+            
+            for i, line in enumerate(lines):
+                line_lower = line.lower().strip()
+                
+                # 主板温度关键词
+                if any(keyword in line_lower for keyword in [
+                    "motherboard", "mobo", "mb", "system", "chipset", 
+                    "ambient", "temp1:", "temp2:", "temp3:", "systin"
+                ]) and not any(cpu_keyword in line_lower for cpu_keyword in [
+                    "cpu", "core", "package", "processor", "tctl", "tdie"
+                ]) and not any(exclude in line_lower for exclude in ["fan", "rpm"]):
+                    
+                    self._debug_log(f"找到可能的主板温度行: {line}")
+                    
+                    if '+' in line and '°c' in line_lower:
+                        try:
+                            temp_match = line.split('+')[1].split('°')[0].strip()
+                            temp = float(temp_match)
+                            # 主板温度通常在15-70度之间
+                            if 15 <= temp <= 70:
+                                self._info_log(f"从sensors提取主板温度: {temp:.1f}°C")
+                                return f"{temp:.1f} °C"
+                            else:
+                                self._debug_log(f"主板温度值超出合理范围: {temp:.1f}°C")
+                        except (ValueError, IndexError) as e:
+                            self._debug_log(f"解析主板温度失败: {e}")
+                            continue
+            
+            self._warning_log("未在sensors输出中找到主板温度")
+            return "未知"
+            
+        except Exception as e:
+            self._error_log(f"解析sensors主板温度输出失败: {e}")
+            return "未知"
 
     def format_uptime(self, seconds: float) -> str:
         """格式化运行时间为易读格式"""
@@ -139,118 +289,259 @@ class SystemManager:
             }
             
         except Exception as e:
-            self.logger.error("获取内存信息失败: %s", str(e))
+            self._error_log(f"获取内存信息失败: {str(e)}")
             return {}
     
     async def get_vol_usage(self) -> dict:
-        """获取 /vol* 开头的存储卷使用信息"""
+        """获取 /vol* 开头的存储卷使用信息，避免唤醒休眠磁盘"""
         try:
-            # 优先使用字节单位
-            df_output = await self.coordinator.run_command("df -B 1 /vol* 2>/dev/null")
-            if df_output:
-                return self.parse_df_bytes(df_output)
+            # 首先尝试智能检测活跃卷
+            active_vols = await self.check_active_volumes()
             
-            df_output = await self.coordinator.run_command("df -h /vol*")
-            if df_output:
-                return self.parse_df_human_readable(df_output)
+            if active_vols:
+                # 只查询活跃的卷，避免使用通配符可能唤醒所有磁盘
+                vol_list = " ".join(active_vols)
+                df_output = await self.coordinator.run_command(f"df -B 1 {vol_list} 2>/dev/null")
+                if df_output:
+                    result = self.parse_df_bytes(df_output)
+                    if result:  # 确保有数据返回
+                        return result
                 
+                df_output = await self.coordinator.run_command(f"df -h {vol_list} 2>/dev/null")
+                if df_output:
+                    result = self.parse_df_human_readable(df_output)
+                    if result:  # 确保有数据返回
+                        return result
+            
+            # 如果智能检测失败，回退到传统方法（仅在必要时）
+            self._debug_log("智能卷检测无结果，回退到传统检测方法")
+            
+            # 优先使用字节单位，但添加错误处理
+            df_output = await self.coordinator.run_command("df -B 1 /vol* 2>/dev/null || true")
+            if df_output and "No such file or directory" not in df_output:
+                result = self.parse_df_bytes(df_output)
+                if result:
+                    return result
+            
+            df_output = await self.coordinator.run_command("df -h /vol* 2>/dev/null || true")
+            if df_output and "No such file or directory" not in df_output:
+                result = self.parse_df_human_readable(df_output)
+                if result:
+                    return result
+            
+            # 最后的回退：尝试检测任何挂载的卷
+            mount_output = await self.coordinator.run_command("mount | grep '/vol' || true")
+            if mount_output:
+                vol_points = []
+                for line in mount_output.splitlines():
+                    parts = line.split()
+                    for part in parts:
+                        if part.startswith('/vol') and part not in vol_points:
+                            vol_points.append(part)
+                
+                if vol_points:
+                    self._debug_log(f"从mount输出检测到卷: {vol_points}")
+                    vol_list = " ".join(vol_points)
+                    df_output = await self.coordinator.run_command(f"df -h {vol_list} 2>/dev/null || true")
+                    if df_output:
+                        return self.parse_df_human_readable(df_output)
+            
+            self._debug_log("所有存储卷检测方法都失败，返回空字典")
             return {}
+            
         except Exception as e:
-            self.logger.error("获取存储卷信息失败: %s", str(e))
+            self._error_log(f"获取存储卷信息失败: {str(e)}")
             return {}
     
-    def parse_df_bytes(self, df_output: str) -> dict:
-        volumes = {}
-        for line in df_output.splitlines()[1:]:
-            parts = line.split()
-            if len(parts) < 6:
-                continue
-                
-            mount_point = parts[-1]
-            # 只处理 /vol 开头的挂载点
-            if not mount_point.startswith("/vol"):
-                continue
-                
-            try:
-                size_bytes = int(parts[1])
-                used_bytes = int(parts[2])
-                avail_bytes = int(parts[3])
-                use_percent = parts[4]
-                
-                def bytes_to_human(b):
-                    for unit in ['', 'K', 'M', 'G', 'T']:
-                        if abs(b) < 1024.0:
-                            return f"{b:.1f}{unit}"
-                        b /= 1024.0
-                    return f"{b:.1f}P"
-                
-                volumes[mount_point] = {
-                    "filesystem": parts[0],
-                    "size": bytes_to_human(size_bytes),
-                    "used": bytes_to_human(used_bytes),
-                    "available": bytes_to_human(avail_bytes),
-                    "use_percent": use_percent
-                }
-            except (ValueError, IndexError) as e:
-                self.logger.debug("解析存储卷行失败: %s - %s", line, str(e))
-                continue
+    async def check_active_volumes(self) -> list:
+        """检查当前活跃的存储卷，避免唤醒休眠磁盘"""
+        try:
+            # 获取所有挂载点，这个操作不会访问磁盘内容
+            mount_output = await self.coordinator.run_command("mount | grep '/vol' 2>/dev/null || true")
+            if not mount_output:
+                self._debug_log("未找到任何/vol挂载点")
+                return []
+            
+            active_vols = []
+            
+            for line in mount_output.splitlines():
+                if '/vol' in line:
+                    # 提取挂载点
+                    parts = line.split()
+                    mount_point = None
                     
+                    # 查找挂载点（通常在 'on' 关键词之后）
+                    try:
+                        on_index = parts.index('on')
+                        if on_index + 1 < len(parts):
+                            candidate = parts[on_index + 1]
+                            # 严格检查是否以/vol开头
+                            if candidate.startswith('/vol'):
+                                mount_point = candidate
+                    except ValueError:
+                        # 如果没有 'on' 关键词，查找以/vol开头的部分
+                        for part in parts:
+                            if part.startswith('/vol'):
+                                mount_point = part
+                                break
+                    
+                    # 过滤挂载点：只保留根级别的/vol*挂载点
+                    if mount_point and self.is_root_vol_mount(mount_point):
+                        # 检查这个卷对应的磁盘是否活跃
+                        is_active = await self.is_volume_disk_active(mount_point)
+                        if is_active:
+                            active_vols.append(mount_point)
+                            self._debug_log(f"添加活跃卷: {mount_point}")
+                        else:
+                            # 即使磁盘不活跃，也添加到列表中，但标记为可能休眠
+                            # 这样可以保证有基本的存储信息
+                            active_vols.append(mount_point)
+                            self._debug_log(f"卷 {mount_point} 对应磁盘可能休眠，但仍包含在检测中")
+                    else:
+                        self._debug_log(f"跳过非根级别vol挂载点: {mount_point}")
+            
+            # 去重并排序
+            active_vols = sorted(list(set(active_vols)))
+            self._debug_log(f"最终检测到的根级别/vol存储卷: {active_vols}")
+            return active_vols
+            
+        except Exception as e:
+            self._debug_log(f"检查活跃存储卷失败: {e}")
+            return []
+    
+    def is_root_vol_mount(self, mount_point: str) -> bool:
+        """检查是否为根级别的/vol挂载点"""
+        if not mount_point or not mount_point.startswith('/vol'):
+            return False
+        
+        # 移除开头的/vol部分进行分析
+        remainder = mount_point[4:]  # 去掉'/vol'
+        
+        # 如果remainder为空，说明是/vol，这是根级别
+        if not remainder:
+            return True
+        
+        # 如果remainder只是数字（如/vol1, /vol2），这是根级别
+        if remainder.isdigit():
+            return True
+        
+        # 如果remainder是单个字母或字母数字组合且没有斜杠，也认为是根级别
+        # 例如：/vola, /volb, /vol1a 等
+        if '/' not in remainder and len(remainder) <= 3:
+            return True
+        
+        # 其他情况都认为是子目录，如：
+        # /vol1/docker/overlay2/...
+        # /vol1/data/...
+        # /vol1/config/...
+        self._debug_log(f"检测到子目录挂载点: {mount_point}")
+        return False
+
+    def parse_df_bytes(self, df_output: str) -> dict:
+        """解析df命令的字节输出"""
+        volumes = {}
+        try:
+            for line in df_output.splitlines()[1:]:  # 跳过标题行
+                parts = line.split()
+                if len(parts) < 6:
+                    continue
+                    
+                mount_point = parts[-1]
+                # 严格检查只处理根级别的 /vol 挂载点
+                if not self.is_root_vol_mount(mount_point):
+                    self._debug_log(f"跳过非根级别vol挂载点: {mount_point}")
+                    continue
+                    
+                try:
+                    size_bytes = int(parts[1])
+                    used_bytes = int(parts[2])
+                    avail_bytes = int(parts[3])
+                    use_percent = parts[4]
+                    
+                    def bytes_to_human(b):
+                        for unit in ['', 'K', 'M', 'G', 'T']:
+                            if abs(b) < 1024.0:
+                                return f"{b:.1f}{unit}"
+                            b /= 1024.0
+                        return f"{b:.1f}P"
+                    
+                    volumes[mount_point] = {
+                        "filesystem": parts[0],
+                        "size": bytes_to_human(size_bytes),
+                        "used": bytes_to_human(used_bytes),
+                        "available": bytes_to_human(avail_bytes),
+                        "use_percent": use_percent
+                    }
+                    self._debug_log(f"添加根级别/vol存储卷信息: {mount_point}")
+                except (ValueError, IndexError) as e:
+                    self._debug_log(f"解析存储卷行失败: {line} - {str(e)}")
+                    continue
+        except Exception as e:
+            self._error_log(f"解析df字节输出失败: {e}")
+            
         return volumes
     
     def parse_df_human_readable(self, df_output: str) -> dict:
+        """解析df命令输出"""
         volumes = {}
-        for line in df_output.splitlines()[1:]:
-            parts = line.split()
-            if len(parts) < 6:
-                continue
+        try:
+            for line in df_output.splitlines()[1:]:  # 跳过标题行
+                parts = line.split()
+                if len(parts) < 6:
+                    continue
+                    
+                mount_point = parts[-1]
+                # 严格检查只处理根级别的 /vol 挂载点
+                if not self.is_root_vol_mount(mount_point):
+                    self._debug_log(f"跳过非根级别vol挂载点: {mount_point}")
+                    continue
+                    
+                try:
+                    size = parts[1]
+                    used = parts[2]
+                    avail = parts[3]
+                    use_percent = parts[4]
+                    
+                    volumes[mount_point] = {
+                        "filesystem": parts[0],
+                        "size": size,
+                        "used": used,
+                        "available": avail,
+                        "use_percent": use_percent
+                    }
+                    self._debug_log(f"添加根级别/vol存储卷信息: {mount_point}")
+                except (ValueError, IndexError) as e:
+                    self._debug_log(f"解析存储卷行失败: {line} - {str(e)}")
+                    continue
+        except Exception as e:
+            self._error_log(f"解析df输出失败: {e}")
                 
-            mount_point = parts[-1]
-            if not mount_point.startswith("/vol"):
-                continue
-                
-            try:
-                size = parts[1]
-                used = parts[2]
-                avail = parts[3]
-                use_percent = parts[4]
-                
-                volumes[mount_point] = {
-                    "filesystem": parts[0],
-                    "size": size,
-                    "used": used,
-                    "available": avail,
-                    "use_percent": use_percent
-                }
-            except (ValueError, IndexError) as e:
-                self.logger.debug("解析存储卷行失败: %s - %s", line, str(e))
-                continue
-                
-        return volumes              
-        
+        return volumes
+    
     async def reboot_system(self):
         """重启系统"""
-        self.logger.info("Initiating system reboot...")
+        self._info_log("Initiating system reboot...")
         try:
             await self.coordinator.run_command("sudo reboot")
-            self.logger.info("Reboot command sent")
+            self._info_log("Reboot command sent")
             
             if "system" in self.coordinator.data:
                 self.coordinator.data["system"]["status"] = "rebooting"
                 self.coordinator.async_update_listeners()
         except Exception as e:
-            self.logger.error("Failed to reboot system: %s", str(e))
+            self._error_log(f"Failed to reboot system: {str(e)}")
             raise
     
     async def shutdown_system(self):
         """关闭系统"""
-        self.logger.info("Initiating system shutdown...")
+        self._info_log("Initiating system shutdown...")
         try:
             await self.coordinator.run_command("sudo shutdown -h now")
-            self.logger.info("Shutdown command sent")
+            self._info_log("Shutdown command sent")
             
             if "system" in self.coordinator.data:
                 self.coordinator.data["system"]["status"] = "off"
                 self.coordinator.async_update_listeners()
         except Exception as e:
-            self.logger.error("Failed to shutdown system: %s", str(e))
+            self._error_log(f"Failed to shutdown system: {str(e)}")
             raise

custom_components/fn_nas/ups_manager.py

@@ -11,9 +11,27 @@ class UPSManager:
     def __init__(self, coordinator):
         self.coordinator = coordinator
         self.logger = _LOGGER.getChild("ups_manager")
-        self.logger.setLevel(logging.DEBUG)
-        self.debug_enabled = False  # UPS调试模式开关
-        self.ups_debug_path = "/config/fn_nas_ups_debug"  # UPS调试文件保存路径
+        # 根据Home Assistant的日志级别动态设置
+        self.logger.setLevel(logging.DEBUG if _LOGGER.isEnabledFor(logging.DEBUG) else logging.INFO)
+        self.debug_enabled = _LOGGER.isEnabledFor(logging.DEBUG)  # 基于HA调试模式
+        self.ups_debug_path = "/config/fn_nas_ups_debug"
+
+    def _debug_log(self, message: str):
+        """只在调试模式下输出详细日志"""
+        if self.debug_enabled:
+            self.logger.debug(message)
+
+    def _info_log(self, message: str):
+        """重要信息日志"""
+        self.logger.info(message)
+
+    def _warning_log(self, message: str):
+        """警告日志"""
+        self.logger.warning(message)
+
+    def _error_log(self, message: str):
+        """错误日志"""
+        self.logger.error(message)
     
     async def get_ups_info(self) -> dict:
         """获取连接的UPS信息"""
@@ -31,7 +49,7 @@ class UPSManager:
         
         try:
             # 尝试使用NUT工具获取UPS信息
-            self.logger.debug("尝试使用NUT工具获取UPS信息")
+            self._debug_log("尝试使用NUT工具获取UPS信息")
             output = await self.coordinator.run_command("upsc -l")
             
             if output and "No such file" not in output:
@@ -39,11 +57,11 @@ class UPSManager:
                 ups_names = output.splitlines()
                 if ups_names:
                     ups_name = ups_names[0].strip()
-                    self.logger.debug("发现UPS: %s", ups_name)
+                    self._debug_log(f"发现UPS: {ups_name}")
                     
                     # 获取详细的UPS信息
                     ups_details = await self.coordinator.run_command(f"upsc {ups_name}")
-                    self.logger.debug("UPS详细信息: %s", ups_details)
+                    self._debug_log(f"UPS详细信息: {ups_details}")
                     
                     # 保存UPS数据以便调试
                     self.save_ups_data_for_debug(ups_details)
@@ -51,20 +69,20 @@ class UPSManager:
                     # 解析UPS信息
                     return self.parse_nut_ups_info(ups_details)
                 else:
-                    self.logger.debug("未找到连接的UPS")
+                    self._debug_log("未找到连接的UPS")
             else:
-                self.logger.debug("未安装NUT工具，尝试备用方法")
+                self._debug_log("未安装NUT工具，尝试备用方法")
             
             # 备用方法：尝试直接读取UPS状态
             return await self.get_ups_info_fallback()
             
         except Exception as e:
-            self.logger.error("获取UPS信息时出错: %s", str(e), exc_info=True)
+            self._error_log(f"获取UPS信息时出错: {str(e)}")
             return ups_info
     
     async def get_ups_info_fallback(self) -> dict:
         """备用方法获取UPS信息"""
-        self.logger.info("尝试备用方法获取UPS信息")
+        self._info_log("尝试备用方法获取UPS信息")
         ups_info = {
             "status": "未知",
             "battery_level": "未知",
@@ -81,7 +99,7 @@ class UPSManager:
             # 方法1: 检查USB连接的UPS
             usb_ups_output = await self.coordinator.run_command("lsusb | grep -i ups || echo 'No USB UPS'")
             if usb_ups_output and "No USB UPS" not in usb_ups_output:
-                self.logger.debug("检测到USB UPS设备: %s", usb_ups_output)
+                self._debug_log(f"检测到USB UPS设备: {usb_ups_output}")
                 ups_info["ups_type"] = "USB"
                 
                 # 尝试从输出中提取型号
@@ -111,7 +129,7 @@ class UPSManager:
             return ups_info
             
         except Exception as e:
-            self.logger.error("备用方法获取UPS信息失败: %s", str(e))
+            self._error_log(f"备用方法获取UPS信息失败: {str(e)}")
             return ups_info
     
     def parse_nut_ups_info(self, ups_output: str) -> dict:
@@ -253,6 +271,6 @@ class UPSManager:
             with open(filename, "w") as f:
                 f.write(ups_output)
             
-            self.logger.info("保存UPS数据到 %s 用于调试", filename)
+            self._info_log(f"保存UPS数据到 {filename} 用于调试")
         except Exception as e:
-            self.logger.error("保存UPS数据失败: %s", str(e))
+            self._error_log(f"保存UPS数据失败: {str(e)}")

custom_components/fn_nas/vm_manager.py

@@ -8,15 +8,40 @@ class VMManager:
     def __init__(self, coordinator):
         self.coordinator = coordinator
         self.vms = []
+        self.logger = _LOGGER.getChild("vm_manager")
+        # 根据Home Assistant的日志级别动态设置
+        self.logger.setLevel(logging.DEBUG if _LOGGER.isEnabledFor(logging.DEBUG) else logging.INFO)
+        self.debug_enabled = _LOGGER.isEnabledFor(logging.DEBUG)
+
+    def _debug_log(self, message: str):
+        """只在调试模式下输出详细日志"""
+        if self.debug_enabled:
+            self.logger.debug(message)
+
+    def _info_log(self, message: str):
+        """重要信息日志"""
+        self.logger.info(message)
+
+    def _warning_log(self, message: str):
+        """警告日志"""
+        self.logger.warning(message)
+
+    def _error_log(self, message: str):
+        """错误日志"""
+        self.logger.error(message)
 
     async def get_vm_list(self):
         """获取虚拟机列表及其状态"""
         try:
+            self._debug_log("开始获取虚拟机列表")
             output = await self.coordinator.run_command("virsh list --all")
+            self._debug_log(f"virsh命令输出: {output}")
+            
             self.vms = self._parse_vm_list(output)
+            self._info_log(f"获取到{len(self.vms)}个虚拟机")
             return self.vms
         except Exception as e:
-            _LOGGER.error("获取虚拟机列表失败: %s", str(e))
+            self._error_log(f"获取虚拟机列表失败: {str(e)}")
             return []
 
     def _parse_vm_list(self, output):
@@ -43,14 +68,18 @@ class VMManager:
     async def get_vm_title(self, vm_name):
         """获取虚拟机的标题"""
         try:
+            self._debug_log(f"获取虚拟机{vm_name}的标题")
             output = await self.coordinator.run_command(f"virsh dumpxml {vm_name}")
             # 在XML输出中查找<title>标签
             match = re.search(r'<title>(.*?)</title>', output, re.DOTALL)
             if match:
-                return match.group(1).strip()
+                title = match.group(1).strip()
+                self._debug_log(f"虚拟机{vm_name}标题: {title}")
+                return title
+            self._debug_log(f"虚拟机{vm_name}无标题，使用名称")
             return vm_name  # 如果没有标题，则返回虚拟机名称
         except Exception as e:
-            _LOGGER.error("获取虚拟机标题失败: %s", str(e))
+            self._error_log(f"获取虚拟机标题失败: {str(e)}")
             return vm_name
 
     async def control_vm(self, vm_name, action):
@@ -61,8 +90,10 @@ class VMManager:
         
         command = f"virsh {action} {vm_name}"
         try:
+            self._info_log(f"执行虚拟机操作: {command}")
             await self.coordinator.run_command(command)
+            self._info_log(f"虚拟机{vm_name}操作{action}成功")
             return True
         except Exception as e:
-            _LOGGER.error("执行虚拟机操作失败: %s", str(e))
+            self._error_log(f"执行虚拟机操作失败: {str(e)}")
             return False