fix: 修复 web 容易被关闭的情况

Author: tianxiu2b2t

assets/js/index.js

@@ -16,7 +16,7 @@ import {
 } from './common.js'
 
 import './config.js'
-
+const UTC_OFFSET = 3600 * 8
 class Menu extends Element {
     constructor() {
         super("div").classes("menu-side")
@@ -192,7 +192,6 @@ class Menu extends Element {
         this.route_handler_lock?.()
     }
 }
-
 class Channel {
     constructor() {
         this.url = window.location.protocol + "//" + window.location.host + "/api";
@@ -309,7 +308,6 @@ class Channel {
         return window.__CONFIG__.support.websocket;
     }
 }
-
 class SwitchElement extends Element {
     constructor() {
         super("div").classes("switch-container");
@@ -481,7 +479,6 @@ class SwitchElement extends Element {
         }
     }
 }
-
 class FlexElement extends Element {
     constructor() {
         super("div").classes("flex-container")
@@ -707,7 +704,6 @@ class TemplateEchartElement extends Element {
         return this
     }
 }
-
 const $configuration = new Configuration();
 const $ElementManager = new ElementManager();
 const $style = new Style($configuration);
@@ -1385,10 +1381,11 @@ async function load() {
                                         Object.keys(resp).sort((a, b) => parseInt(a) - parseInt(b)).map(v => [v, resp[v]])
                                     )
                                 } else {
+                                    console.log(resp)
                                     var server_time = $dashboard_locals.info_runtime
                                     //    return int((t - ((t + UTC) % 86400) - 86400 * day) / 3600)
                                     var datetime = server_time.current_time - server_time.diff / 1000.0 + (+new Date() - server_time.resp_timestamp) / 1000.0;
-                                    const previous = (datetime + (datetime % 86400) - 86400 * 29);
+                                    const previous = (datetime + ((datetime + UTC_OFFSET) % 86400) - 86400 * 30);
                                     const res = {}
                                     for (let i = 0; i < 30; i++) {
                                         var d = Tools.formatDate(new Date((previous + i * 86400) * 1000.0))

core/cache.py

@@ -23,18 +23,21 @@ def __init__(self, value: T, expires: Optional[float] = None) -> None:
 
 # Time out cache    
 class TimeoutCache(MutableMapping[K, T]):
-    def __init__(self):
+    def __init__(self, default_timeout: Optional[float] = None):
         self.cache: collections.OrderedDict[K, CacheValue] = collections.OrderedDict()
         self.background = BackgroundScheduler()
+        self.default_timeout = default_timeout
+        self.background.start()
 
     def set(self, key: K, value: T, timeout: Optional[float] = None) -> None:
         self._delete_job(key)
         self.cache[key] = CacheValue(
             value,
             timeout
         )
+        timeout = timeout or self.default_timeout
         if timeout is not None:
-            self.cache[key].job = self.background.add_job(self.delete, 'interval', seconds=timeout, args=[key])
+            self.cache[key].job = self.background.add_job(self.delete, 'interval', seconds=timeout, args=[key, True])
 
     def _delete_job(self, key: K):
         current = self.cache.get(key, None)
@@ -52,7 +55,7 @@ def get(self, key: K, _def: Any = EMPTY) -> Any:
             return _def
         return current.value
 
-    def delete(self, key: K) -> None:
+    def delete(self, key: K, task: bool = False) -> None:
         self._delete_job(key)
         self.cache.pop(key, None)
 

core/config.py

@@ -26,7 +26,8 @@
         "port": -1,
         "public_port": 6543,
         "x_forwarded_for": 0,
-        "backlog": 1024
+        "backlog": 1024,
+        "sockets": 8
     },
     "clusters": [
         {
@@ -174,10 +175,17 @@ def backlog(self):
         if not isinstance(backlog, int):
             backlog = 100
         return min(backlog, 100)
+    
+    @property
+    def web_sockets(self):
+        sockets = Config.get("web.sockets", 8)
+        if not isinstance(sockets, int):
+            sockets = 8
+        return min(sockets, 1)
 
 const = Const()
 
-VERSION = "3.3.10"
+VERSION = "3.3.11"
 API_VERSION = "1.13.1"
 USER_AGENT = f"openbmclapi/{API_VERSION} python-openbmclapi/{VERSION}"
 PYTHON_VERSION = ".".join(map(str, (sys.version_info.major, sys.version_info.minor, sys.version_info.micro)))

core/storages/__init__.py

@@ -1,6 +1,6 @@
 import abc
 import asyncio
-from collections import deque
+from collections import defaultdict, deque
 from dataclasses import dataclass, field
 import hashlib
 import inspect
@@ -109,17 +109,19 @@ def __rtruediv__(self, __o: Any) -> 'FilePath':
 
 class iStorage(metaclass=abc.ABCMeta):
     type: str = "_interface"
-    def __init__(self, path: str, weight: int = 0, list_concurrent: int = 32):
+    def __init__(
+        self, 
+        path: str, 
+        weight: int = 0, 
+        list_concurrent: int = 32, 
+        name: Optional[str] = None
+    ):
         self.path = FilePath(path)
         self.weight = weight
         self.list_concurrent = list_concurrent
         self.current_weight = 0
+        self._name = name
 
-    @staticmethod
-    @abc.abstractmethod
-    def from_config(config: dict[str, Any]):
-        raise NotImplementedError("from_config not implemented")
-
     @property
     @abc.abstractmethod
     def unique_id(self):
@@ -165,16 +167,13 @@ def get_path(self, file: CollectionFile):
 class LocalStorage(iStorage):
     type = "local"
 
-    def __init__(self, path: str, weight: int = 0, list_concurrent: int = 32):
-        super().__init__(path, weight, list_concurrent)
+    def __init__(self, path: str, weight: int = 0, list_concurrent: int = 32, name: Optional[str] = None):
+        super().__init__(path, weight, list_concurrent, name)
         self.async_executor = ThreadPoolExecutor(max_workers=list_concurrent)
 
     @staticmethod
     def from_config(config: dict[str, Any]):
-        path = config["path"]
-        weight = config.get("weight", 0)
-        list_concurrent = config.get("list_concurrent", 32)
-        return LocalStorage(path, weight, list_concurrent)
+        return LocalStorage(config["path"], config.get("weight", 0), config.get("list_concurrent", 32), config.get("name"))
 
     @property
     def unique_id(self):
@@ -239,13 +238,22 @@ async def get_mtime(self, file: CollectionFile) -> float:
         return os.path.getmtime(Path(str(path)))
 
 class iNetworkStorage(iStorage):
-
-    def __init__(self, path: str, username: str, password: str, endpoint: str, weight: int = 0, list_concurrent: int = 32):
-        super().__init__(path, weight, list_concurrent)
+    def __init__(
+        self, 
+        path: str, 
+        username: str, 
+        password: str, 
+        endpoint: str, 
+        weight: int = 0, 
+        list_concurrent: int = 32, 
+        name: Optional[str] = None,
+        cache_timeout: float = 60,
+    ):
+        super().__init__(path, weight, list_concurrent, name)
         self.username = username
         self.password = password
         self.endpoint = endpoint.rstrip("/")
-        self.cache = cache.TimeoutCache()
+        self.cache = cache.TimeoutCache(cache_timeout)
 
     @property
     def unique_id(self):
@@ -280,8 +288,20 @@ def __init__(self, result: AlistResult):
 class AlistStorage(iNetworkStorage):
     type = "alist"
 
-    def __init__(self, path: str, username: str, password: str, endpoint: str, weight: int = 0, list_concurrent: int = 32, retries: int = 3, public_webdav_endpoint: str = ""):
-        super().__init__(path, username, password, endpoint, weight, list_concurrent)
+    def __init__(
+        self, 
+        path: str, 
+        username: str, 
+        password: str, 
+        endpoint: str, 
+        weight: int = 0, 
+        list_concurrent: int = 32, 
+        name: Optional[str] = None,
+        cache_timeout: float = 60,
+        retries: int = 3, 
+        public_webdav_endpoint: str = ""
+    ):
+        super().__init__(path, username, password, endpoint, weight, list_concurrent, name, cache_timeout)
         self.retries = retries
         self.last_token: Optional[AlistToken] = None
         self.session = aiohttp.ClientSession(
@@ -293,18 +313,6 @@ def __init__(self, path: str, username: str, password: str, endpoint: str, weigh
             urlobject = urlparse.urlparse(public_webdav_endpoint)
             self._public_webdav_endpoint = f"{urlobject.scheme}://{urlparse.quote(self.username)}:{urlparse.quote(self.password)}@{urlobject.netloc}{urlobject.path}"
 
-    @staticmethod
-    def from_config(config: dict[str, Any]):
-        path = config["path"]
-        username = config["username"]
-        password = config["password"]
-        endpoint = config["endpoint"]
-        weight = config.get("weight", 0)
-        list_concurrent = config.get("list_concurrent", 32)
-        retries = config.get("retries", 3)
-        public_webdav_endpoint = config.get("public_webdav_endpoint", "")
-        return AlistStorage(path, username, password, endpoint, weight, list_concurrent, retries, public_webdav_endpoint)
-
     async def _get_token(self):
         if self.last_token is None or self.last_token.expires < time.monotonic():
             async with self.session.post(f"{self.endpoint}/api/auth/login", json={"username": self.username, "password": self.password}) as resp:
@@ -516,8 +524,20 @@ def data_size(self) -> int:
 
 class WebDavStorage(iNetworkStorage):
     type = "webdav"
-    def __init__(self, path: str, username: str, password: str, endpoint: str, weight: int = 0, list_concurrent: int = 32, public_endpoint: str = "", retries: int = 3):
-        super().__init__(path, username, password, endpoint, weight, list_concurrent)
+    def __init__(
+        self, 
+        path: str, 
+        username: str, 
+        password: str, 
+        endpoint: str, 
+        weight: int = 0, 
+        list_concurrent: int = 32,
+        name: Optional[str] = None, 
+        cache_timeout: int = 60,
+        public_endpoint: str = "", 
+        retries: int = 3
+    ):
+        super().__init__(path, username, password, endpoint, weight, list_concurrent, name, cache_timeout)
         self.client = webdav3_client.Client({
             "webdav_hostname": endpoint,
             "webdav_login": username,
@@ -536,18 +556,6 @@ def __init__(self, path: str, username: str, password: str, endpoint: str, weigh
         self.base_url = f"{urlobject.scheme}://{urlparse.quote(self.username)}:{urlparse.quote(self.password)}@{urlobject.hostname}:{urlobject.port}{urlobject.path}"
         self.retries = retries
 
-    @staticmethod
-    def from_config(config: dict[str, Any]):
-        path = config["path"]
-        username = config["username"]
-        password = config["password"]
-        endpoint = config["endpoint"]
-        weight = config.get("weight", 0)
-        list_concurrent = config.get("list_concurrent", 32)
-        public_endpoint = config.get("public_endpoint", "")
-        retries = config.get("retries", 3)
-        return WebDavStorage(path, username, password, endpoint, weight, list_concurrent, public_endpoint, retries)
-
     async def list_files(self, pbar: WrapperTQDM) -> set[File]:
         async def get_files(root_id: int) -> list[WebDavFileInfo]:
             root = self.path / DOWNLOAD_DIR / f"{root_id:02x}"
@@ -670,16 +678,32 @@ async def write_file(self, file: MeasureFile | File, content: io.BytesIO):
         return True
 
 
+@dataclass
+class Parameter:
+    name: str
+    type: type
+    default: Any = inspect._empty
+
 def init_storage(config: Any) -> Optional[iStorage]:
     if not isinstance(config, dict) or "type" not in config or config["type"] not in abstract_storages:
         return None
     try:
-        return abstract_storages[config["type"]].from_config(config)
+        abstract_storage = abstract_storages[config["type"]]
+        args = abstract_storage_args[abstract_storage]
+        params = {}
+        for arg in args:
+            if arg.name in config:
+                params[arg.name] = config[arg.name]
+            elif arg.default != inspect._empty:
+                params[arg.name] = arg.default
+
+        return abstract_storage(**params)
     except:
         logger.traceback()
         return None
 
 abstract_storages: dict[str, type[iStorage]] = {}
+abstract_storage_args: defaultdict[type[iStorage], list[Parameter]] = defaultdict(list)
 
 T = TypeVar("T")
 
@@ -695,6 +719,24 @@ async def init():
         if istorage.type == iStorage.type:
             continue
         abstract_storages[istorage.type] = istorage
+        arg = inspect.getfullargspec(istorage.__init__)
+        args = arg.args[1:]
+        # defaults 默认的长度和位置都是从后往前数的，
+        # 填充一些空的在前面
+        defaults = [
+            inspect._empty for _ in range(len(args) - len(arg.defaults or []))
+        ]
+        defaults.extend(arg.defaults or [])
+        for idx, arg_name in enumerate(args):
+            if arg_name == "self":
+                continue
+            abstract_storage_args[istorage].append(
+                Parameter(
+                    name=arg_name,
+                    type=arg.annotations.get(arg_name, Any),
+                    default=defaults[idx]
+                )
+            )
 
     logger.debug("Storage init complete")
     logger.debug(f"Found {len(abstract_storages)} storage types: {', '.join(abstract_storages.keys())}")