feat(upserver): 接入认证与KV存档并完成限定钓鱼闭环

Client/Assets/Scripts/Services/PlayerData/PlayerKVControlledLoadCapability.cs

@@ -0,0 +1,105 @@
+using System;
+using System.Net;
+using System.Net.Http;
+using System.Threading;
+using System.Threading.Tasks;
+using game.Account;
+
+namespace game.PlayerDataStorage
+{
+    // The lease-only capability remains source-compatible with the independent 4B1 regression host.
+    // This separate capability supplies every dependency required by a complete controlled load.
+    internal sealed class PlayerKVGameLoadCapability
+    {
+        internal PlayerKVIdentitySnapshot Identity { get; }
+        internal PlayerKVSchemaSnapshot Snapshot { get; }
+        internal Uri Api { get; }
+        internal string CacheRoot { get; }
+        internal int LoginObserveMs { get; }
+        internal int QuitObserveMs { get; }
+        internal Func<int,CancellationToken,Task> Delay { get; }
+        internal PlayerKVControlledLoadCapability LeaseCapability { get; private set; }
+        readonly PlayerKVControlledLoadCapability auth,kv,lease;
+        readonly object gate=new object();
+        CookieContainer cookies;
+        HttpMessageHandler pendingKV,pendingLease;
+        Exception cleanupFailure;
+        readonly System.Collections.Generic.List<HttpMessageHandler> failedHandlers=new System.Collections.Generic.List<HttpMessageHandler>();
+        bool claimed;
+        private PlayerKVGameLoadCapability(PlayerKVIdentitySnapshot identity,PlayerKVSchemaSnapshot snapshot,Uri api,string cacheRoot,
+            int loginMs,int quitMs,Func<int,CancellationToken,Task> delay,
+            PlayerKVControlledLoadCapability auth,PlayerKVControlledLoadCapability kv,PlayerKVControlledLoadCapability lease)
+        {
+            Identity=identity ?? throw new ArgumentNullException(nameof(identity)); Snapshot=snapshot ?? throw new ArgumentNullException(nameof(snapshot));
+            if(api==null || !api.IsAbsoluteUri || (api.Scheme!="http" && api.Scheme!="https") || !string.IsNullOrEmpty(api.UserInfo) ||
+                !string.IsNullOrEmpty(api.Query) || !string.IsNullOrEmpty(api.Fragment) || string.IsNullOrEmpty(cacheRoot) ||
+                loginMs<1000 || loginMs>15000 || quitMs<1000 || quitMs>15000) throw new ArgumentException("Controlled load configuration invalid.");
+            Api=new Uri(api.AbsoluteUri.TrimEnd('/')+"/"); CacheRoot=cacheRoot;
+            LoginObserveMs=loginMs; QuitObserveMs=quitMs; Delay=delay ?? Task.Delay; this.auth=auth; this.kv=kv; this.lease=lease;
+        }
+#if UNITY_EDITOR
+        internal static PlayerKVGameLoadCapability CreateForValidation(PlayerKVIdentitySnapshot identity,PlayerKVSchemaSnapshot snapshot,
+            Uri api,string cacheRoot,Func<CookieContainer,HttpMessageHandler> auth,Func<CookieContainer,HttpMessageHandler> kv,
+            Func<CookieContainer,HttpMessageHandler> lease,int loginMs=10000,int quitMs=5000,Func<int,CancellationToken,Task> delay=null)
+        {
+            var capability=new PlayerKVGameLoadCapability(identity,snapshot,api,cacheRoot,loginMs,quitMs,delay,
+                PlayerKVControlledLoadCapability.CreateForValidation(auth),PlayerKVControlledLoadCapability.CreateForValidation(kv),
+                PlayerKVControlledLoadCapability.CreateForValidation(lease));
+            capability.LeaseCapability=PlayerKVControlledLoadCapability.CreateForValidation(capability.TakeLease);
+            return capability;
+        }
+#endif
+        internal PlayerKVLoginContext CreateContext(string id,long epoch,Func<long,bool> current)
+        {
+            lock(gate) { if(claimed) throw new InvalidOperationException("Controlled capability already used."); claimed=true; }
+            return new PlayerKVLoginContext(id,CacheRoot,epoch,current,Api,
+                ()=>new S101AccountSession(Api,CreateAuthentication),()=>new PlayerKVGameSessionBridge(TakeKV));
+        }
+        HttpMessageHandler CreateAuthentication(CookieContainer jar)
+        {
+            lock(gate)
+            {
+                if(cookies!=null) throw new InvalidOperationException("Repeated authentication factory.");
+                cookies=jar; HttpMessageHandler authentication=null;
+                try
+                {
+                    // Validate all three returned handler graphs before the first authentication send.
+                    authentication=auth.CreateHandler(jar); pendingKV=kv.CreateHandler(jar); pendingLease=lease.CreateHandler(jar);
+                    if(ReferenceEquals(authentication,pendingKV) || ReferenceEquals(authentication,pendingLease) || ReferenceEquals(pendingKV,pendingLease))
+                        throw new InvalidOperationException("Distinct transport ownership required.");
+                    return authentication;
+                }
+                catch
+                {
+                    try { authentication?.Dispose(); } catch(Exception ex) { cleanupFailure=ex; failedHandlers.Add(authentication); }
+                    try { CloseUnused(); } catch { }
+                    throw;
+                }
+            }
+        }
+        HttpMessageHandler TakeKV(CookieContainer jar)
+        {
+            lock(gate)
+            { if(!ReferenceEquals(jar,cookies) || pendingKV==null) throw new InvalidOperationException("KV transport ownership invalid.");
+              var result=pendingKV; pendingKV=null; return result; }
+        }
+        HttpMessageHandler TakeLease(CookieContainer jar)
+        {
+            lock(gate)
+            { if(!ReferenceEquals(jar,cookies) || pendingLease==null) throw new InvalidOperationException("Lease transport ownership invalid.");
+              var result=pendingLease; pendingLease=null; return result; }
+        }
+        internal void CloseUnused()
+        {
+            lock(gate)
+            {
+                // Attempt every owned cleanup once; retain a failure even if a later Dispose succeeds.
+                var ownedLease=pendingLease; pendingLease=null;
+                var ownedKV=pendingKV; pendingKV=null;
+                try { ownedLease?.Dispose(); } catch(Exception ex) { cleanupFailure=cleanupFailure ?? ex; failedHandlers.Add(ownedLease); }
+                try { ownedKV?.Dispose(); } catch(Exception ex) { cleanupFailure=cleanupFailure ?? ex; failedHandlers.Add(ownedKV); }
+                if(cleanupFailure!=null) throw new InvalidOperationException("Controlled transport cleanup failed.",cleanupFailure);
+            }
+        }
+    }
+}