dsh-provider-proxy 0.6.0 → 0.6.1

package/README.md

@@ -77,6 +77,11 @@ Host catalog 是否列出某个 provider（`live`）不影响已保存路由的
   因为成功判据在响应头到达时就已成立（流式转发不能靠消费 body 来判断）。
   「最近调用」的时间取请求**发起**时刻；「最近成功 / 失败」的结果与时间来自最近一次**结束**的请求——
   两者分开记录，并发调用下不会把一次请求的发起时间配到另一次的结果上。
+  **这条记录只属于当前路由配置**：改代理端点、凭据、`useDefault` 的默认端点、目标域名规则或
+  `localDirect` 后，该 provider 的「最近调用」会变成「尚无代理记录」；`testUrl` / `testTarget`
+  只影响测试，不会清掉它。仅关闭再打开代理开关也保留记录。修改配置前已经启动的请求不会把旧结果
+  写回新配置；删除后重新添加同名 provider 同样视为一条新路由。`hits` 命中计数是历史累计，
+  上述配置变化都不会清空它。
 
 页面顶部与顶层还有三项整页设置（写在 `cordis.patch.yml`，也可以直接编辑）：
 

package/lib/index.js

@@ -1203,6 +1203,28 @@ function deadRuleEntries(raw) {
 }
 
 // src/proxy-table.ts
+function normalizedRuleSet(raw) {
+  const rules = (raw ?? "").split(/[,\s]+/).map(normalizeHostRule).filter((entry) => entry.length > 0);
+  return [...new Set(rules)].sort();
+}
+function routeFingerprint(input) {
+  return JSON.stringify([
+    input.protocol ?? "http",
+    String(input.host ?? "").trim(),
+    input.port ?? 0,
+    String(input.username ?? "").trim(),
+    input.password ?? "",
+    normalizedRuleSet(input.onlyHosts),
+    normalizedRuleSet(input.bypassHosts),
+    input.localDirect !== false
+  ]);
+}
+function routeStateDecision(previous, next) {
+  if (previous === void 0) return { token: "new", clearLastUse: false };
+  if (previous.fingerprint !== next.fingerprint) return { token: "new", clearLastUse: true };
+  if (previous.enabled !== next.enabled) return { token: "new", clearLastUse: false };
+  return { token: "keep", clearLastUse: false };
+}
 function proxyUrl(route) {
   const credentials = route.username.length === 0 ? "" : route.password.length > 0 && route.protocol !== "socks5" ? `${encodeURIComponent(route.username)}:${encodeURIComponent(route.password)}@` : `${encodeURIComponent(route.username)}@`;
   const host = route.host.includes(":") && !route.host.startsWith("[") ? `[${route.host}]` : route.host;
@@ -1372,12 +1394,16 @@ function apply(ctx, config) {
   let closed = false;
   let webAvailable = false;
   const hits = /* @__PURE__ */ new Map();
+  const routeStates = /* @__PURE__ */ new Map();
+  let nextRouteToken = 1;
   const lastUse = /* @__PURE__ */ new Map();
-  const bump = (provider) => {
+  const bump = (provider, token) => {
     hits.set(provider, (hits.get(provider) ?? 0) + 1);
+    if (routeStates.get(provider)?.token !== token) return;
     lastUse.set(provider, { ...lastUse.get(provider), startedAt: Date.now() });
   };
-  const settle = (provider) => (ok, detail) => {
+  const settle = (provider, token) => (ok, detail) => {
+    if (routeStates.get(provider)?.token !== token) return;
     const previous = lastUse.get(provider);
     lastUse.set(provider, {
       startedAt: previous?.startedAt ?? Date.now(),
@@ -1393,7 +1419,60 @@ function apply(ctx, config) {
   const MAX_REQUEST_BYTES = 8 * 1024;
   const selfChecks = /* @__PURE__ */ new Map();
   const SELF_CHECK_COOLDOWN_MS = 3e3;
+  const MAX_CHECK_ENTRIES_PER_PROVIDER = 8;
+  const MAX_CHECK_PROVIDERS = 64;
   const lastChecks = /* @__PURE__ */ new Map();
+  const checkKeyOf = (provider, key) => key.slice(provider.length);
+  const pruneCheckCache = (now = Date.now()) => {
+    for (const [provider, entries] of lastChecks) {
+      for (const [key, entry] of entries) {
+        if (now - entry.at >= SELF_CHECK_COOLDOWN_MS) entries.delete(key);
+      }
+      if (entries.size === 0) lastChecks.delete(provider);
+    }
+    while (lastChecks.size > MAX_CHECK_PROVIDERS) {
+      let oldestProvider;
+      let oldestAt = Infinity;
+      for (const [provider, entries] of lastChecks) {
+        let latest = -Infinity;
+        for (const entry of entries.values()) latest = Math.max(latest, entry.at);
+        if (latest < oldestAt) {
+          oldestAt = latest;
+          oldestProvider = provider;
+        }
+      }
+      if (oldestProvider === void 0) break;
+      lastChecks.delete(oldestProvider);
+    }
+  };
+  const rememberCheck = (provider, key, result) => {
+    pruneCheckCache();
+    let entries = lastChecks.get(provider);
+    if (entries === void 0) {
+      entries = /* @__PURE__ */ new Map();
+      lastChecks.set(provider, entries);
+    }
+    entries.set(checkKeyOf(provider, key), { at: Date.now(), result });
+    while (entries.size > MAX_CHECK_ENTRIES_PER_PROVIDER) {
+      let oldestKey;
+      let oldestAt = Infinity;
+      for (const [candidate, entry] of entries) {
+        if (entry.at < oldestAt) {
+          oldestAt = entry.at;
+          oldestKey = candidate;
+        }
+      }
+      if (oldestKey === void 0) break;
+      entries.delete(oldestKey);
+    }
+    pruneCheckCache();
+  };
+  const forgetChecks = (provider) => {
+    lastChecks.delete(provider);
+    for (const key of [...selfChecks.keys()]) {
+      if (key.startsWith(`${provider}\0`)) selfChecks.delete(key);
+    }
+  };
   const plainTestUrls = () => {
     const raw = config?.testUrl;
     const snapshot2 = raw?.get;
@@ -1651,17 +1730,56 @@ function apply(ctx, config) {
     ctx.logger.info("dsh-provider-proxy mounted (pid %d)", process.pid);
   } catch {
   }
-  const rebuild = async () => {
-    const next = createProxyTable(plainProviders(config), {
-      defaultProxy: plainDefaultProxy(config),
-      localDirect: plainLocalDirect(config)
-    });
+  const rebuild = () => {
+    const providers = plainProviders(config);
+    const defaultProxy = plainDefaultProxy(config);
+    const localDirect = plainLocalDirect(config);
+    const next = createProxyTable(providers, { defaultProxy, localDirect });
     const previous = current;
     current = next.entries;
     problems = next.problems;
+    const configured = new Set(Object.keys(providers));
+    for (const provider of [...routeStates.keys()]) {
+      if (configured.has(provider)) continue;
+      routeStates.delete(provider);
+      lastUse.delete(provider);
+      forgetChecks(provider);
+    }
+    for (const [provider, raw] of Object.entries(providers)) {
+      const effective = raw?.useDefault === true ? { ...raw, ...defaultProxy } : raw;
+      const fingerprint = routeFingerprint({
+        ...effective,
+        localDirect
+      });
+      const decision = routeStateDecision(routeStates.get(provider), {
+        fingerprint,
+        enabled: raw?.enabled === true
+      });
+      const token = decision.token === "new" ? nextRouteToken++ : routeStates.get(provider).token;
+      if (decision.clearLastUse) {
+        lastUse.delete(provider);
+        forgetChecks(provider);
+      }
+      routeStates.set(provider, { fingerprint, enabled: raw?.enabled === true, token });
+    }
+    pruneCheckCache();
     void closeTable(previous);
+    return Promise.resolve();
   };
-  const ready = rebuild();
+  let rebuildQueue = Promise.resolve();
+  const enqueueRebuild = () => {
+    if (closed) return Promise.resolve();
+    try {
+      const done = rebuild();
+      rebuildQueue = rebuildQueue.then(() => done).catch(() => void 0);
+      return done;
+    } catch (error) {
+      const failed = Promise.reject(error);
+      rebuildQueue = failed.catch(() => void 0);
+      return failed;
+    }
+  };
+  enqueueRebuild();
   const catalog = () => {
     const live = /* @__PURE__ */ new Set();
     const out = [];
@@ -1777,16 +1895,20 @@ function apply(ctx, config) {
                 send(400, { ok: false, kind: "body", error: "\u7F3A\u5C11 provider" });
                 return;
               }
-              const key = selfCheckKey(provider);
+              const key = `${provider}\0${selfCheckKey(provider)}`;
               let pending = selfChecks.get(key);
               if (pending === void 0) {
-                const last = lastChecks.get(key);
+                pruneCheckCache();
+                const last = lastChecks.get(provider)?.get(checkKeyOf(provider, key));
                 if (last !== void 0 && Date.now() - last.at < SELF_CHECK_COOLDOWN_MS) {
                   send(200, { ...last.result, cached: true });
                   return;
                 }
+                const checkToken = routeStates.get(provider)?.token;
                 pending = runSelfCheck(provider).then((result) => {
-                  lastChecks.set(key, { at: Date.now(), result });
+                  if (checkToken !== void 0 && routeStates.get(provider)?.token === checkToken) {
+                    rememberCheck(provider, key, result);
+                  }
                   return result;
                 });
                 selfChecks.set(key, pending);
@@ -1813,11 +1935,13 @@ function apply(ctx, config) {
     const patched = function(request, signal) {
       const route = current.get(WEB_SEARCH_KEY);
       if (route === void 0) return original.call(this, request, signal);
+      const token = routeStates.get(WEB_SEARCH_KEY)?.token;
+      if (token === void 0) return original.call(this, request, signal);
       return router.run(
         {
           dispatcher: route.dispatcher,
-          onHit: () => bump(WEB_SEARCH_KEY),
-          onSettle: settle(WEB_SEARCH_KEY),
+          onHit: () => bump(WEB_SEARCH_KEY, token),
+          onSettle: settle(WEB_SEARCH_KEY, token),
           decide: route.decide
         },
         () => original.call(this, request, signal)
@@ -1837,11 +1961,13 @@ function apply(ctx, config) {
         if (typeof provider !== "string") return next();
         const route = current.get(provider);
         if (route === void 0) return next();
+        const token = routeStates.get(provider)?.token;
+        if (token === void 0) return next();
         return router.wrap(
           {
             dispatcher: route.dispatcher,
-            onHit: () => bump(provider),
-            onSettle: settle(provider),
+            onHit: () => bump(provider, token),
+            onSettle: settle(provider, token),
             decide: route.decide
           },
           next
@@ -1850,14 +1976,14 @@ function apply(ctx, config) {
       { global: true }
     );
     const onConfig = () => {
-      void rebuild();
+      void enqueueRebuild();
     };
     ctx.on("loader/volatile-update", onConfig, { global: true });
     return async () => {
       stop();
       if (closed) return;
       closed = true;
-      await ready.catch(() => void 0);
+      await rebuildQueue.catch(() => void 0);
       await closeTable(current);
       current = /* @__PURE__ */ new Map();
       router.release();
@@ -1872,7 +1998,26 @@ function apply(ctx, config) {
       })),
       problems: Object.fromEntries(problems),
       hits: Object.fromEntries(hits),
-      lastUse: Object.fromEntries(lastUse)
+      lastUse: Object.fromEntries(lastUse),
+      selfCheckCache: (() => {
+        let expiredEntries = 0;
+        let maxPerProvider = 0;
+        let totalEntries = 0;
+        for (const entries of lastChecks.values()) {
+          totalEntries += entries.size;
+          maxPerProvider = Math.max(maxPerProvider, entries.size);
+          for (const entry of entries.values()) {
+            if (Date.now() - entry.at >= SELF_CHECK_COOLDOWN_MS) expiredEntries += 1;
+          }
+        }
+        return {
+          providers: lastChecks.size,
+          pending: selfChecks.size,
+          expiredEntries,
+          totalEntries,
+          maxPerProvider
+        };
+      })()
     })
   });
 }
@@ -1897,6 +2042,8 @@ export {
   parseHostList,
   proxyHostProblem,
   proxyUrl,
+  routeFingerprint,
+  routeStateDecision,
   splitHostRules
 };
 //# sourceMappingURL=index.js.map