fix storage logging

app/modules/filemanager/storages/alipan.py

@@ -52,9 +52,9 @@ class AliPan(StorageBase, metaclass=Singleton):
         try:
             subprocess.run(['aria2c', '-h'], capture_output=True)
             self._has_aria2c = True
-            logger.debug('发现 aria2c, 将使用 aria2c 下载文件')
+            logger.debug('【alipan】发现 aria2c, 将使用 aria2c 下载文件')
         except FileNotFoundError:
-            logger.debug('未发现 aria2c')
+            logger.debug('【alipan】未发现 aria2c')
             self._has_aria2c = False
         self.init_storage()
 
@@ -67,7 +67,7 @@ class AliPan(StorageBase, metaclass=Singleton):
             """
             显示二维码
             """
-            logger.info(f"请用阿里云盘 App 扫码登录：{qr_link}")
+            logger.info(f"【alipan】请用阿里云盘 App 扫码登录：{qr_link}")
 
         refresh_token = self.__auth_params.get("refreshToken")
         if refresh_token:
@@ -75,7 +75,7 @@ class AliPan(StorageBase, metaclass=Singleton):
                 self.aligo = Aligo(refresh_token=refresh_token, show=show_qrcode, use_aria2=self._has_aria2c, # noqa
                                    name="MoviePilot V2", level=logging.ERROR, re_login=False)
             except Exception as err:
-                logger.error(f"初始化阿里云盘失败：{str(err)}")
+                logger.error(f"【alipan】初始化阿里云盘失败：{str(err)}")
                 self.__clear_params()
 
     @property

app/modules/filemanager/storages/alist.py

@@ -1,5 +1,4 @@
 import json
-import logging
 from datetime import datetime
 from pathlib import Path
 from typing import Optional, List, Dict
@@ -102,20 +101,20 @@ class Alist(StorageBase, metaclass=Singleton):
         """
 
         if resp is None:
-            logger.warning("请求登录失败，无法连接alist服务")
+            logger.warning("【alist】请求登录失败，无法连接alist服务")
             return ""
 
         if resp.status_code != 200:
-            logger.warning(f"更新令牌请求发送失败，状态码：{resp.status_code}")
+            logger.warning(f"【alist】更新令牌请求发送失败，状态码：{resp.status_code}")
             return ""
 
         result = resp.json()
 
         if result["code"] != 200:
-            logger.critical(f'更新令牌，错误信息：{result["message"]}')
+            logger.critical(f'【alist】更新令牌，错误信息：{result["message"]}')
             return ""
 
-        logger.debug("AList获取令牌成功")
+        logger.debug("【alist】AList获取令牌成功")
         return result["data"]["token"]
 
     def __get_header_with_token(self) -> dict:
@@ -200,19 +199,19 @@ class Alist(StorageBase, metaclass=Singleton):
         """
 
         if resp is None:
-            logging.warning(f"请求获取目录 {fileitem.path} 的文件列表失败，无法连接alist服务")
+            logger.warn(f"【alist】请求获取目录 {fileitem.path} 的文件列表失败，无法连接alist服务")
             return []
         if resp.status_code != 200:
-            logging.warning(
-                f"请求获取目录 {fileitem.path} 的文件列表失败，状态码：{resp.status_code}"
+            logger.warn(
+                f"【alist】请求获取目录 {fileitem.path} 的文件列表失败，状态码：{resp.status_code}"
             )
             return []
 
         result = resp.json()
 
         if result["code"] != 200:
-            logging.warning(
-                f'获取目录 {fileitem.path} 的文件列表失败，错误信息：{result["message"]}'
+            logger.warn(
+                f'【alist】获取目录 {fileitem.path} 的文件列表失败，错误信息：{result["message"]}'
             )
             return []
 
@@ -258,15 +257,15 @@ class Alist(StorageBase, metaclass=Singleton):
         }
         """
         if resp is None:
-            logging.warning(f"请求创建目录 {path} 失败，无法连接alist服务")
+            logger.warn(f"【alist】请求创建目录 {path} 失败，无法连接alist服务")
             return None
         if resp.status_code != 200:
-            logging.warning(f"请求创建目录 {path} 失败，状态码：{resp.status_code}")
+            logger.warn(f"【alist】请求创建目录 {path} 失败，状态码：{resp.status_code}")
             return None
 
         result = resp.json()
         if result["code"] != 200:
-            logging.warning(f'创建目录 {path} 失败，错误信息：{result["message"]}')
+            logger.warn(f'【alist】创建目录 {path} 失败，错误信息：{result["message"]}')
             return None
 
         return self.get_item(path)
@@ -348,15 +347,15 @@ class Alist(StorageBase, metaclass=Singleton):
         }
         """
         if resp is None:
-            logging.warning(f"请求获取文件 {path} 失败，无法连接alist服务")
+            logger.warn(f"【alist】请求获取文件 {path} 失败，无法连接alist服务")
             return None
         if resp.status_code != 200:
-            logging.warning(f"请求获取文件 {path} 失败，状态码：{resp.status_code}")
+            logger.warn(f"【alist】请求获取文件 {path} 失败，状态码：{resp.status_code}")
             return None
 
         result = resp.json()
         if result["code"] != 200:
-            logging.debug(f'获取文件 {path} 失败，错误信息：{result["message"]}')
+            logger.debug(f'【alist】获取文件 {path} 失败，错误信息：{result["message"]}')
             return None
 
         return schemas.FileItem(
@@ -405,18 +404,18 @@ class Alist(StorageBase, metaclass=Singleton):
         }
         """
         if resp is None:
-            logging.warning(f"请求删除文件 {fileitem.path} 失败，无法连接alist服务")
+            logger.warn(f"【alist】请求删除文件 {fileitem.path} 失败，无法连接alist服务")
             return False
         if resp.status_code != 200:
-            logging.warning(
-                f"请求删除文件 {fileitem.path} 失败，状态码：{resp.status_code}"
+            logger.warn(
+                f"【alist】请求删除文件 {fileitem.path} 失败，状态码：{resp.status_code}"
             )
             return False
 
         result = resp.json()
         if result["code"] != 200:
-            logging.warning(
-                f'删除文件 {fileitem.path} 失败，错误信息：{result["message"]}'
+            logger.warn(
+                f'【alist】删除文件 {fileitem.path} 失败，错误信息：{result["message"]}'
             )
             return False
         return True
@@ -447,18 +446,18 @@ class Alist(StorageBase, metaclass=Singleton):
         }
         """
         if not resp:
-            logging.warning(f"请求重命名文件 {fileitem.path} 失败，无法连接alist服务")
+            logger.warn(f"【alist】请求重命名文件 {fileitem.path} 失败，无法连接alist服务")
             return False
         if resp.status_code != 200:
-            logging.warning(
-                f"请求重命名文件 {fileitem.path} 失败，状态码：{resp.status_code}"
+            logger.warn(
+                f"【alist】请求重命名文件 {fileitem.path} 失败，状态码：{resp.status_code}"
             )
             return False
 
         result = resp.json()
         if result["code"] != 200:
-            logging.warning(
-                f'重命名文件 {fileitem.path} 失败，错误信息：{result["message"]}'
+            logger.warn(
+                f'【alist】重命名文件 {fileitem.path} 失败，错误信息：{result["message"]}'
             )
             return False
 
@@ -512,15 +511,15 @@ class Alist(StorageBase, metaclass=Singleton):
         }
         """
         if not resp:
-            logging.warning(f"请求获取文件 {path} 失败，无法连接alist服务")
+            logger.warn(f"【alist】请求获取文件 {path} 失败，无法连接alist服务")
             return None
         if resp.status_code != 200:
-            logging.warning(f"请求获取文件 {path} 失败，状态码：{resp.status_code}")
+            logger.warn(f"【alist】请求获取文件 {path} 失败，状态码：{resp.status_code}")
             return None
 
         result = resp.json()
         if result["code"] != 200:
-            logging.warning(f'获取文件 {path} 失败，错误信息：{result["message"]}')
+            logger.warn(f'【alist】获取文件 {path} 失败，错误信息：{result["message"]}')
             return None
 
         if result["data"]["raw_url"]:
@@ -568,7 +567,7 @@ class Alist(StorageBase, metaclass=Singleton):
             )
 
         if resp.status_code != 200:
-            logging.warning(f"请求上传文件 {path} 失败，状态码：{resp.status_code}")
+            logger.warn(f"【alist】请求上传文件 {path} 失败，状态码：{resp.status_code}")
             return None
 
         new_item = self.get_item(Path(fileitem.path) / path.name)
@@ -617,20 +616,20 @@ class Alist(StorageBase, metaclass=Singleton):
         }
         """
         if resp is None:
-            logging.warning(
-                f"请求复制文件 {fileitem.path} 失败，无法连接alist服务"
+            logger.warn(
+                f"【alist】请求复制文件 {fileitem.path} 失败，无法连接alist服务"
             )
             return False
         if resp.status_code != 200:
-            logging.warning(
-                f"请求复制文件 {fileitem.path} 失败，状态码：{resp.status_code}"
+            logger.warn(
+                f"【alist】请求复制文件 {fileitem.path} 失败，状态码：{resp.status_code}"
             )
             return False
 
         result = resp.json()
         if result["code"] != 200:
-            logging.warning(
-                f'复制文件 {fileitem.path} 失败，错误信息：{result["message"]}'
+            logger.warn(
+                f'【alist】复制文件 {fileitem.path} 失败，错误信息：{result["message"]}'
             )
             return False
         # 重命名
@@ -676,20 +675,20 @@ class Alist(StorageBase, metaclass=Singleton):
         }
         """
         if resp is None:
-            logging.warning(
-                f"请求移动文件 {fileitem.path} 失败，无法连接alist服务"
+            logger.warn(
+                f"【alist】请求移动文件 {fileitem.path} 失败，无法连接alist服务"
             )
             return False
         if resp.status_code != 200:
-            logging.warning(
-                f"请求移动文件 {fileitem.path} 失败，状态码：{resp.status_code}"
+            logger.warn(
+                f"【alist】请求移动文件 {fileitem.path} 失败，状态码：{resp.status_code}"
             )
             return False
 
         result = resp.json()
         if result["code"] != 200:
-            logging.warning(
-                f'移动文件 {fileitem.path} 失败，错误信息：{result["message"]}'
+            logger.warn(
+                f'【alist】移动文件 {fileitem.path} 失败，错误信息：{result["message"]}'
             )
             return False
         return True

app/modules/filemanager/storages/local.py

@@ -95,7 +95,7 @@ class LocalStorage(StorageBase):
         # 遍历目录
         path_obj = Path(path)
         if not path_obj.exists():
-            logger.warn(f"目录不存在：{path}")
+            logger.warn(f"【local】目录不存在：{path}")
             return []
 
         # 如果是文件
@@ -167,7 +167,7 @@ class LocalStorage(StorageBase):
             else:
                 shutil.rmtree(path_obj, ignore_errors=True)
         except Exception as e:
-            logger.error(f"删除文件失败：{e}")
+            logger.error(f"【local】删除文件失败：{e}")
             return False
         return True
 
@@ -181,7 +181,7 @@ class LocalStorage(StorageBase):
         try:
             path_obj.rename(path_obj.parent / name)
         except Exception as e:
-            logger.error(f"重命名文件失败：{e}")
+            logger.error(f"【local】重命名文件失败：{e}")
             return False
         return True
 
@@ -202,7 +202,7 @@ class LocalStorage(StorageBase):
         target_path = dir_path / (new_name or path.name)
         code, message = SystemUtils.move(path, target_path)
         if code != 0:
-            logger.error(f"移动文件失败：{message}")
+            logger.error(f"【local】移动文件失败：{message}")
             return None
         return self.get_item(target_path)
 
@@ -213,7 +213,7 @@ class LocalStorage(StorageBase):
         file_path = Path(fileitem.path)
         code, message = SystemUtils.link(file_path, target_file)
         if code != 0:
-            logger.error(f"硬链接文件失败：{message}")
+            logger.error(f"【local】硬链接文件失败：{message}")
             return False
         return True
 
@@ -224,7 +224,7 @@ class LocalStorage(StorageBase):
         file_path = Path(fileitem.path)
         code, message = SystemUtils.softlink(file_path, target_file)
         if code != 0:
-            logger.error(f"软链接文件失败：{message}")
+            logger.error(f"【local】软链接文件失败：{message}")
             return False
         return True
 
@@ -238,7 +238,7 @@ class LocalStorage(StorageBase):
         file_path = Path(fileitem.path)
         code, message = SystemUtils.copy(file_path, path / new_name)
         if code != 0:
-            logger.error(f"复制文件失败：{message}")
+            logger.error(f"【local】复制文件失败：{message}")
             return False
         return True
 
@@ -252,7 +252,7 @@ class LocalStorage(StorageBase):
         file_path = Path(fileitem.path)
         code, message = SystemUtils.move(file_path, path / new_name)
         if code != 0:
-            logger.error(f"移动文件失败：{message}")
+            logger.error(f"【local】移动文件失败：{message}")
             return False
         return True
 

app/modules/filemanager/storages/rclone.py

@@ -39,8 +39,8 @@ class Rclone(StorageBase):
         super().set_config(conf)
         filepath = conf.get("filepath")
         if not filepath:
-            logger.warn("Rclone保存配置失败：未设置配置文件路径")
-        logger.info(f"Rclone配置写入文件：{filepath}")
+            logger.warn("【rclone】保存配置失败：未设置配置文件路径")
+        logger.info(f"【rclone】配置写入文件：{filepath}")
         path = Path(filepath)
         if not path.parent.exists():
             path.parent.mkdir(parents=True)
@@ -95,7 +95,7 @@ class Rclone(StorageBase):
             if retcode == 0:
                 return True
         except Exception as err:
-            logger.error(f"rclone存储检查失败：{err}")
+            logger.error(f"【rclone】存储检查失败：{err}")
         return False
 
     def list(self, fileitem: schemas.FileItem) -> List[schemas.FileItem]:
@@ -117,7 +117,7 @@ class Rclone(StorageBase):
                 items = json.loads(ret.stdout)
                 return [self.__get_rcloneitem(item, parent=fileitem.path) for item in items]
         except Exception as err:
-            logger.error(f"rclone浏览文件失败：{err}")
+            logger.error(f"【rclone】浏览文件失败：{err}")
         return []
 
     def create_folder(self, fileitem: schemas.FileItem, name: str) -> Optional[schemas.FileItem]:
@@ -137,7 +137,7 @@ class Rclone(StorageBase):
             if retcode == 0:
                 return self.get_item(Path(fileitem.path) / name)
         except Exception as err:
-            logger.error(f"rclone创建目录失败：{err}")
+            logger.error(f"【rclone】创建目录失败：{err}")
         return None
 
     def get_folder(self, path: Path) -> Optional[schemas.FileItem]:
@@ -169,7 +169,7 @@ class Rclone(StorageBase):
             else:
                 dir_file = self.create_folder(fileitem, part)
                 if not dir_file:
-                    logger.warn(f"rclone创建目录 {fileitem.path}{part} 失败！")
+                    logger.warn(f"【rclone】创建目录 {fileitem.path}{part} 失败！")
                     return None
                 fileitem = dir_file
         return fileitem
@@ -194,7 +194,7 @@ class Rclone(StorageBase):
                         return self.__get_rcloneitem(item, parent=str(path.parent) + "/")
             return None
         except Exception as err:
-            logger.debug(f"rclone获取文件项失败：{err}")
+            logger.debug(f"【rclone】获取文件项失败：{err}")
         return None
 
     def delete(self, fileitem: schemas.FileItem) -> bool:
@@ -212,7 +212,7 @@ class Rclone(StorageBase):
             if retcode == 0:
                 return True
         except Exception as err:
-            logger.error(f"rclone删除文件失败：{err}")
+            logger.error(f"【rclone】删除文件失败：{err}")
         return False
 
     def rename(self, fileitem: schemas.FileItem, name: str) -> bool:
@@ -231,7 +231,7 @@ class Rclone(StorageBase):
             if retcode == 0:
                 return True
         except Exception as err:
-            logger.error(f"rclone重命名文件失败：{err}")
+            logger.error(f"【rclone】重命名文件失败：{err}")
         return False
 
     def download(self, fileitem: schemas.FileItem, path: Path = None) -> Optional[Path]:
@@ -251,7 +251,7 @@ class Rclone(StorageBase):
             if retcode == 0:
                 return path
         except Exception as err:
-            logger.error(f"rclone复制文件失败：{err}")
+            logger.error(f"【rclone】复制文件失败：{err}")
         return None
 
     def upload(self, fileitem: schemas.FileItem, path: Path,
@@ -275,7 +275,7 @@ class Rclone(StorageBase):
             if retcode == 0:
                 return self.get_item(new_path)
         except Exception as err:
-            logger.error(f"rclone上传文件失败：{err}")
+            logger.error(f"【rclone】上传文件失败：{err}")
         return None
 
     def detail(self, fileitem: schemas.FileItem) -> Optional[schemas.FileItem]:
@@ -295,7 +295,7 @@ class Rclone(StorageBase):
                 items = json.loads(ret.stdout)
                 return self.__get_rcloneitem(items[0])
         except Exception as err:
-            logger.error(f"rclone获取文件详情失败：{err}")
+            logger.error(f"【rclone】获取文件详情失败：{err}")
         return None
 
     def move(self, fileitem: schemas.FileItem, path: Path, new_name: str) -> bool:
@@ -317,7 +317,7 @@ class Rclone(StorageBase):
             if retcode == 0:
                 return True
         except Exception as err:
-            logger.error(f"rclone移动文件失败：{err}")
+            logger.error(f"【rclone】移动文件失败：{err}")
         return False
 
     def copy(self, fileitem: schemas.FileItem, path: Path, new_name: str) -> bool:
@@ -339,7 +339,7 @@ class Rclone(StorageBase):
             if retcode == 0:
                 return True
         except Exception as err:
-            logger.error(f"rclone复制文件失败：{err}")
+            logger.error(f"【rclone】复制文件失败：{err}")
         return False
 
     def link(self, fileitem: schemas.FileItem, target_file: Path) -> bool:
@@ -381,5 +381,5 @@ class Rclone(StorageBase):
                     available=items.get("free")
                 )
         except Exception as err:
-            logger.error(f"rclone获取存储使用情况失败：{err}")
+            logger.error(f"【rclone】获取存储使用情况失败：{err}")
         return None

app/modules/filemanager/storages/u115.py

@@ -117,7 +117,7 @@ class U115Pan(StorageBase, metaclass=Singleton):
         确认登录后，获取相关token
         """
         if not self._auth_state:
-            raise Exception("请先调用生成二维码方法")
+            raise Exception("【115】请先调用生成二维码方法")
         resp = self.session.post(
             "https://passportapi.115.com/open/deviceCodeToToken",
             data={
@@ -126,13 +126,13 @@ class U115Pan(StorageBase, metaclass=Singleton):
             }
         )
         if resp is None:
-            raise Exception("获取 access_token 失败")
+            raise Exception("【115】获取 access_token 失败")
         result = resp.json()
         if result.get("code") != 0:
             raise Exception(result.get("message"))
         return result["data"]
 
-    def __refresh_access_token(self, refresh_token: str) -> dict:
+    def __refresh_access_token(self, refresh_token: str) -> Optional[dict]:
         """
         刷新access_token
         """
@@ -143,10 +143,11 @@ class U115Pan(StorageBase, metaclass=Singleton):
             }
         )
         if resp is None:
-            raise Exception(f"刷新 access_token 失败：refresh_token={refresh_token}")
+            logger.error(f"【115】刷新 access_token 失败：refresh_token={refresh_token}")
+            return None
         result = resp.json()
         if result.get("code") != 0:
-            raise Exception(result.get("message"))
+            logger.warn(f"【115】刷新 access_token 失败：{result.get('code')} - {result.get('message')}！")
         return result.get("data")
 
     def _request_api(self, method: str, endpoint: str,
@@ -159,7 +160,7 @@ class U115Pan(StorageBase, metaclass=Singleton):
             **kwargs
         )
         if resp is None:
-            logger.warn(f"{method} 请求 {endpoint} 失败！")
+            logger.warn(f"【115】{method} 请求 {endpoint} 失败！")
             return None
 
         # 处理速率限制
@@ -175,27 +176,29 @@ class U115Pan(StorageBase, metaclass=Singleton):
         ret_data = resp.json()
 
         # 处理refresh_token失效
-        if ret_data.get("code") == 40140119:
+        if ret_data.get("code") in [40140116, 40140119]:
             self.set_config({})
-            raise Exception("refresh_token 失效，请重新扫描登录！")
+            logger.warn("【115】refresh_token 失效，请重新扫描登录！")
+            return None
 
         # 处理access_token失效
         if ret_data.get("code") == 40140125:
             refresh_token = self.get_conf().get("refresh_token")
             if refresh_token:
                 tokens = self.__refresh_access_token(refresh_token)
-                self.set_config({
-                    "refresh_time": int(time.time()),
-                    **tokens
-                })
-                return self._request_api(method, endpoint, result_key, **kwargs)
+                if tokens:
+                    self.set_config({
+                        "refresh_time": int(time.time()),
+                        **tokens
+                    })
+                    return self._request_api(method, endpoint, result_key, **kwargs)
             return None
 
+        if ret_data.get("code") != 0:
+            logger.warn(f"【115】{method} 请求 {endpoint} 出错：{ret_data.get('message')}！")
+
         if result_key:
-            result = ret_data.get(result_key)
-            if result is None:
-                logger.warn(f"{method} 请求 {endpoint} 出错：{ret_data.get('message')}！")
-            return result
+            return ret_data.get(result_key)
         return ret_data
 
     def _path_to_id(self, path: str) -> int:
@@ -231,7 +234,7 @@ class U115Pan(StorageBase, metaclass=Singleton):
                     current_id = item["fid"]
                     break
             else:
-                raise FileNotFoundError(f"路径不存在: {path}")
+                raise FileNotFoundError(f"【115】路径不存在: {path}")
         self._id_cache[path] = current_id
         return current_id
 
@@ -256,7 +259,7 @@ class U115Pan(StorageBase, metaclass=Singleton):
         )
         # 处理可能的空数据（如已删除文件）
         if not detail:
-            raise FileNotFoundError(f"{fid} 不存在")
+            raise FileNotFoundError(f"【115】{fid} 不存在")
         paths = detail["paths"]
         path_parts = [item["file_name"] for item in paths]
         # 构建完整路径
@@ -388,7 +391,7 @@ class U115Pan(StorageBase, metaclass=Singleton):
             if resp.get("code") == 20004:
                 # 目录已存在
                 return self.get_item(new_path)
-            logger.warn(f"创建目录失败: {resp.get('error')}")
+            logger.warn(f"【115】创建目录失败: {resp.get('error')}")
             return None
         # 缓存新目录
         self._id_cache[str(new_path)] = resp["data"]["file_id"]
@@ -434,7 +437,7 @@ class U115Pan(StorageBase, metaclass=Singleton):
         if not init_resp:
             return None
         if not init_resp.get("state"):
-            logger.warn(f"初始化上传失败: {init_resp.get('error')}")
+            logger.warn(f"【115】初始化上传失败: {init_resp.get('error')}")
             return None
 
         # 处理秒传成功
@@ -485,7 +488,7 @@ class U115Pan(StorageBase, metaclass=Singleton):
             "data"
         )
         if not token_resp:
-            logger.warn("获取上传凭证失败")
+            logger.warn("【115】获取上传凭证失败")
             return None
 
         # Step 4: 对象存储上传
@@ -495,7 +498,7 @@ class U115Pan(StorageBase, metaclass=Singleton):
             access_key_secret=token_resp['AccessKeySecret'],
             security_token=token_resp['SecurityToken']
         )
-        bucket = oss2.Bucket(auth, endpoint, init_result['bucket'])
+        bucket = oss2.Bucket(auth, endpoint, init_result['bucket']) # noqa
 
         # 分片上传
         headers = {
@@ -517,7 +520,7 @@ class U115Pan(StorageBase, metaclass=Singleton):
             bucket.complete_multipart_upload(target_name, upload_id, parts)
         except Exception as err:
             if "FileAlreadyExists" not in str(err):
-                logger.error(f"上传文件失败: {str(err)}")
+                logger.error(f"【115】上传文件失败: {str(err)}")
                 return None
 
         # 构造返回结果
@@ -633,7 +636,7 @@ class U115Pan(StorageBase, metaclass=Singleton):
                 modify_time=resp["utime"]
             )
         except Exception as e:
-            logger.debug(f"获取文件信息失败: {str(e)}")
+            logger.debug(f"【115】获取文件信息失败: {str(e)}")
             return None
 
     def get_folder(self, path: Path) -> Optional[schemas.FileItem]:
@@ -665,7 +668,7 @@ class U115Pan(StorageBase, metaclass=Singleton):
             else:
                 dir_file = self.create_folder(fileitem, part)
                 if not dir_file:
-                    logger.warn(f"115 创建目录 {fileitem.path}{part} 失败！")
+                    logger.warn(f"【115】创建目录 {fileitem.path}{part} 失败！")
                     return None
                 fileitem = dir_file
         return fileitem