Windows CI exposing some problems, try to fix...

Author: Thorium

.github/workflows/CI.yml

@@ -6,6 +6,7 @@ on:
 
 env:
   DOTNET_VERSION: '6.0.428'
+  DOTNET_SDK_VERSION: '10.0.x'
 
 jobs:
   buildAndTestWindows:
@@ -16,9 +17,13 @@ jobs:
     steps:
     - uses: actions/checkout@v4
     - name: Setup .NET
-      uses: actions/setup-dotnet@v3
+      uses: actions/setup-dotnet@v4
       with:
-        dotnet-version: ${{ env.DOTNET_VERSION }}
+        # .NET 6 runtime for the FAKE build tool (net6.0); .NET 10 SDK for the net10.0 targets
+        # and to satisfy global.json. Installed explicitly rather than relying on the runner image.
+        dotnet-version: |
+          ${{ env.DOTNET_VERSION }}
+          ${{ env.DOTNET_SDK_VERSION }}
     - name: Build & Run Tests
       run: |
         .\build.cmd
@@ -41,9 +46,13 @@ jobs:
     steps:
     - uses: actions/checkout@v4
     - name: Setup .NET
-      uses: actions/setup-dotnet@v3
+      uses: actions/setup-dotnet@v4
       with:
-        dotnet-version: ${{ env.DOTNET_VERSION }}
+        # .NET 6 runtime for the FAKE build tool (net6.0); .NET 10 SDK for the net10.0 targets
+        # and to satisfy global.json. Installed explicitly rather than relying on the runner image.
+        dotnet-version: |
+          ${{ env.DOTNET_VERSION }}
+          ${{ env.DOTNET_SDK_VERSION }}
     - name: Build & Run Tests
       run: |
         ./build.sh
@@ -66,9 +75,13 @@ jobs:
     steps:
     - uses: actions/checkout@v4
     - name: Setup .NET
-      uses: actions/setup-dotnet@v3
+      uses: actions/setup-dotnet@v4
       with:
-        dotnet-version: ${{ env.DOTNET_VERSION }}
+        # .NET 6 runtime for the FAKE build tool (net6.0); .NET 10 SDK for the net10.0 targets
+        # and to satisfy global.json. Installed explicitly rather than relying on the runner image.
+        dotnet-version: |
+          ${{ env.DOTNET_VERSION }}
+          ${{ env.DOTNET_SDK_VERSION }}
     - name: Build & Run Tests
       run: |
         ./build.sh

src/SQLProvider.DesignTime/SqlDesignTime.fs

@@ -1289,19 +1289,18 @@ type SqlRuntimeInfo (config : TypeProviderConfig) =
     member __.RuntimeAssembly = runtimeAssembly
 
 /// One generation of provided types for one set of static parameters.
-/// Reference equality so that ConcurrentDictionary.TryUpdate swaps compare generations,
-/// not their (concurrently mutated) field values.
 [<ReferenceEquality>]
 type DesignCacheEntry =
-    { /// The provided root type, when it was built, and how old the build may get before a
-      /// background refresh is started (adapted to build duration on slow systems).
-      Root : Lazy<ProvidedTypeDefinition * DateTime * TimeSpan>
-      /// Last access in UTC ticks. Updated lock-free on every instantiation request;
-      /// entries idle longer than the expiration are dropped to free memory.
-      mutable LastAccess : int64
-      /// 1 while a background refresh build is in flight: at most one refresh per entry,
-      /// no matter how many Visual Studio threads request the type concurrently.
-      mutable Refreshing : int }
+    { /// The lazily-built provided root type, paired with the idle window this entry should survive
+      /// once unused (a back-pressure guard proportional to this build's eager connect cost — see
+      /// buildRoot). Once built the root is returned unchanged for the life of the entry: never swapped
+      /// for a freshly-built generation while live, because erased provided types are compared by
+      /// reference identity and mixing two generations within one compilation makes two
+      /// identical-looking types (e.g. 'CustomersEntity') fail to unify (FS0001/FS0193).
+      Root : Lazy<ProvidedTypeDefinition * TimeSpan>
+      /// Last access in UTC ticks, updated lock-free on every instantiation request. Entries idle
+      /// (unaccessed) for their whole idle window are dropped to free memory.
+      mutable LastAccess : int64 }
 
 module DesignTimeCache =
     let cache = System.Collections.Concurrent.ConcurrentDictionary<DesignCacheKey,DesignCacheEntry>()
@@ -1523,11 +1522,8 @@ type public SqlTypeProvider(config: TypeProviderConfig) as this =
             args.[12] :?> string,                   // SSDT Path
             typeName)
 
-        // Entries idle longer than this are dropped to free memory. An actively used entry is
-        // never dropped on a timer; instead it is refreshed in the background once its build is
-        // older than its staleness interval, so database schema changes are still picked up
-        // without IntelliSense ever stalling on a synchronous rebuild.
-        let idleExpiration = TimeSpan.FromMinutes 3.0
+        // Minimum time an unused entry is kept before it may be reclaimed.
+        let idleFloor = TimeSpan.FromMinutes 3.0
 
         let buildRoot (args:DesignCacheKey) =
             let struct(_,_,_,_,_,_,_,_,_,_,_,_,_, rootTypeName) = args
@@ -1540,100 +1536,77 @@ type public SqlTypeProvider(config: TypeProviderConfig) as this =
             createTypes rootType serviceType readServiceType config sqlRuntimeInfo invalidate registerDispose args
             createConstructors config (rootType, serviceType, readServiceType, args)
 
-            // Refresh no sooner than the idle expiration, and on a slow system no sooner than
-            // 10x the time a build takes. Fetching the full schema of a big database is heavy;
-            // the staleness window must stay well above the fetch time so a refresh always
-            // finishes long before the next one is due. Otherwise refreshes (each followed by a
-            // re-check) would overlap and build back-pressure that eventually stalls the UI.
-            // The window is derived from this build's own duration, so it adapts as the schema grows.
+            // Back-pressure guard: keep an idle entry cached for at least the floor, and longer in
+            // proportion to how long this build took, so we don't drop and rebuild an expensive entry
+            // faster than a rebuild completes (which would pile up and stall the host). Only the eager
+            // part of the build is timed here — creating the provider, opening the design-time
+            // connection and reading type mappings; the per-table schema is lazy and forced later — so
+            // in practice this extends retention for sources that are slow to connect (typically remote
+            // servers) and stays at the floor for fast/local ones. max() also guards a clock that
+            // jumps backwards mid-build (negative duration falls back to the floor).
             let buildDuration = DateTime.UtcNow - buildStarted
-            let staleAfter = max idleExpiration (TimeSpan.FromTicks(buildDuration.Ticks * 10L))
-            rootType, DateTime.UtcNow, staleAfter
+            let idleWindow = max idleFloor (TimeSpan.FromTicks(buildDuration.Ticks * 5L))
+            rootType, idleWindow
 
         let dropDesignTimeDcProvider (key:DesignCacheKey) =
-            // Release the design-time data context provider (used by the Individuals feature)
-            // together with its type tree generation, so it cannot pin stale schema in memory.
+            // Release the design-time data context provider (used by the Individuals feature) when
+            // its cache entry is evicted, so it cannot pin stale schema in memory.
             let struct(_,_,_,_,_,_,_,_,_,_,_,_,_, rootTypeName) = key
             DcCache.providerCache.TryRemove rootTypeName |> ignore
 
-        let rec idleWatcher (key:DesignCacheKey) =
+        let rec idleWatcher (key:DesignCacheKey) (idleWindow:TimeSpan) =
             async {
-                do! Async.Sleep (int idleExpiration.TotalMilliseconds)
+                // Clamp to Int32 range: Async.Sleep takes int milliseconds, and a pathologically
+                // large window (only reachable via an absurd connect time) would otherwise overflow
+                // to a negative value and throw. On overflow we just sleep the max and re-loop.
+                do! Async.Sleep (int (min idleWindow.TotalMilliseconds (float System.Int32.MaxValue)))
                 match DesignTimeCache.cache.TryGetValue key with
                 | true, entry ->
                     let lastAccess = DateTime(System.Threading.Interlocked.Read(&entry.LastAccess), DateTimeKind.Utc)
-                    if DateTime.UtcNow - lastAccess >= idleExpiration then
+                    if DateTime.UtcNow - lastAccess >= idleWindow then
                         DesignTimeCache.cache.TryRemove key |> ignore
                         dropDesignTimeDcProvider key
                     else
-                        do! idleWatcher key
+                        do! idleWatcher key idleWindow
                 | _ -> ()
             }
 
+        // Start the (fire-and-forget) idle reclaimer with a failure boundary. Async.Catch keeps any
+        // exception — including the OperationCanceledException raised at host shutdown — from
+        // surfacing as an unobserved thread-pool exception. It is only a best-effort memory
+        // reclaimer, so on failure it just stops and the entry stays cached (safe: costs memory,
+        // never correctness).
+        let startIdleWatcher (key:DesignCacheKey) (idleWindow:TimeSpan) =
+            idleWatcher key idleWindow |> Async.Catch |> Async.Ignore |> Async.Start
+
         let addCache (key:DesignCacheKey) =
             { Root =
                 lazy
-                    let generation = buildRoot key
-                    // Only reclaim idle entries in a live host (IDE). In a batch compile
-                    // (fsc/CI, IsInvalidationSupported=false) the process is short-lived and an
-                    // eviction+rebuild would hand out a second generation of erased provided
-                    // types, which then fail to unify against the first.
-                    if config.IsInvalidationSupported then idleWatcher key |> Async.Start
+                    let (_, idleWindow) as generation = buildRoot key
+                    // Start reclaiming this entry once it goes idle. Eviction is last-access based,
+                    // so it only fires when nothing is using the entry (between compiles, never
+                    // during one) and the next use rebuilds one clean generation. There is
+                    // deliberately no background "refresh"/swap of a live entry: that is what mixed
+                    // two generations into a single compilation and broke Windows CI.
+                    startIdleWatcher key idleWindow
                     generation
-              LastAccess = DateTime.UtcNow.Ticks
-              Refreshing = 0 }
+              LastAccess = DateTime.UtcNow.Ticks }
 
+        // GetOrAdd only allocates the entry (its Lazy is not forced here) and Interlocked cannot
+        // throw, so only the build below needs the poisoned-entry cleanup.
+        let entry = DesignTimeCache.cache.GetOrAdd(arguments, addCache)
+        System.Threading.Interlocked.Exchange(&entry.LastAccess, DateTime.UtcNow.Ticks) |> ignore
         try
-            let entry = DesignTimeCache.cache.GetOrAdd(arguments, addCache)
-            System.Threading.Interlocked.Exchange(&entry.LastAccess, DateTime.UtcNow.Ticks) |> ignore
-
-            // Stale-while-revalidate: always serve the current tree; if it has gone stale,
-            // rebuild it once in the background and swap the entry atomically. Callers never
-            // wait on a refresh, and concurrent VS threads can never start a second one.
-            //
-            // Only ever swap generations in a live host (IDE, IsInvalidationSupported=true).
-            // In a batch compile (fsc/CI) the swap is unsafe: erased provided types have
-            // reference identity, so if a long compilation binds some sites to the original
-            // generation and later sites to the swapped-in one, the two identical-looking
-            // 'CustomersEntity' types fail to unify (FS0001/FS0193). Windows CI builds two
-            // target frameworks and so is slow enough to cross the staleness window mid-build,
-            // which is why it fails there while Linux/Mac and warm local builds pass.
-            if config.IsInvalidationSupported && entry.Root.IsValueCreated then
-                let _, builtAt, staleAfter = entry.Root.Value
-                if DateTime.UtcNow - builtAt >= staleAfter
-                   && System.Threading.Interlocked.CompareExchange(&entry.Refreshing, 1, 0) = 0 then
-                    async {
-                        try
-                            try
-                                // 1. Fetch/build the new generation fully in the background. Nothing
-                                //    waits on it: on-demand callers keep getting the previous tree, so
-                                //    a slow big-database schema fetch never blocks the editor.
-                                let freshGeneration = buildRoot arguments
-                                let freshEntry =
-                                    { Root = Lazy<_>.CreateFromValue freshGeneration
-                                      LastAccess = DateTime.UtcNow.Ticks
-                                      Refreshing = 0 }
-                                // 2. Only now that the new generation is ready, invalidate. This makes
-                                //    the host re-check bind straight to the finished tree instead of
-                                //    driving a fresh blocking build on demand. It fires at most once per
-                                //    staleness window (>= 10x the build time), so it cannot churn.
-                                this.Invalidate()
-                                // 3. Publish it. Invalidate() only schedules a later re-check, so the
-                                //    atomic swap always lands before the host re-reads the cache; the
-                                //    re-check then finds a fresh (non-stale) entry and triggers no rebuild.
-                                if DesignTimeCache.cache.TryUpdate(arguments, freshEntry, entry) then
-                                    dropDesignTimeDcProvider arguments
-                            with
-                            | _ -> () // keep serving the previous generation; retried on a later access
-                        finally
-                            System.Threading.Interlocked.Exchange(&entry.Refreshing, 0) |> ignore
-                    } |> Async.Start
-
-            let root, _, _ = entry.Root.Value
-            root
+            entry.Root.Value |> fst
         with
-        | e ->
-            DesignTimeCache.cache.TryRemove(arguments) |> ignore
+        | _ ->
+            // The build threw and its Lazy has cached that exception. Drop the poisoned entry so a
+            // genuine transient failure can be retried — but only if it is still the entry we hold,
+            // so we never evict a newer generation another thread has since rebuilt at this key.
+            match DesignTimeCache.cache.TryGetValue arguments with
+            | true, current when System.Object.ReferenceEquals(current, entry) ->
+                DesignTimeCache.cache.TryRemove arguments |> ignore
+            | _ -> ()
             reraise()
     )