- QoL retry for cache rebuild on file in use errors.

- Wrapped more semaphore releases in finally blocks to help avoid deadlocks with unexpected index read errors.

Author: Lunaretic

xivModdingFramework/Cache/XivCache.cs

@@ -297,7 +297,22 @@ private static void CreateCache()
             // manually replaces the roots DB.  (It takes an hour or more to build)
             SQLiteConnection.ClearAllPools();
             GC.WaitForPendingFinalizers();
-            File.Delete(_dbPath.FullName);
+
+
+            try
+            {
+                File.Delete(_dbPath.FullName);
+            } catch
+            {
+                // In some select situations sometimes the DB can still be in use
+                // if we were asyncing other things.  Sleep a bit and see if we can succeed after.
+
+                // ( The primary case of this happening is a START OVER without Index backups, where we
+                // transition straight from a full modlist disable into a cache rebuild, without waiting
+                // on the Cache to finish queueing entries into the DB. )
+                Thread.Sleep(1000);
+                File.Delete(_dbPath.FullName);
+            }
 
             using (var db = new SQLiteConnection(CacheConnectionString))
             {

xivModdingFramework/SqPack/FileTypes/Index.cs

@@ -60,12 +60,18 @@ public void UpdateIndexDatCount(XivDataFile dataFile, int datNum)
             foreach (var indexPath in indexPaths)
             {
                 _semaphoreSlim.Wait();
-                using (var bw = new BinaryWriter(File.OpenWrite(indexPath)))
+                try
                 {
-                    bw.BaseStream.Seek(1104, SeekOrigin.Begin);
-                    bw.Write(datCount);
+                    using (var bw = new BinaryWriter(File.OpenWrite(indexPath)))
+                    {
+                        bw.BaseStream.Seek(1104, SeekOrigin.Begin);
+                        bw.Write(datCount);
+                    }
+                }
+                finally
+                {
+                    _semaphoreSlim.Release();
                 }
-                _semaphoreSlim.Release();
             }
         }
 
@@ -261,33 +267,39 @@ public async Task<int> GetDataOffsetIndex2(string fullPath)
 
 
             await _semaphoreSlim.WaitAsync();
-
-            // Dump the index into memory, since we're going to have to inject data.
-            byte[] originalIndex = File.ReadAllBytes(index2Path);
-
-            // Get all the segment header data
-            for (int i = 0; i < SegmentHeaders.Length; i++)
+            try
             {
-                SegmentOffsets[i] = BitConverter.ToInt32(originalIndex, SegmentHeaders[i] + 4);
-                SegmentSizes[i] = BitConverter.ToInt32(originalIndex, SegmentHeaders[i] + 8);
-            }
 
-            int fileCount = SegmentSizes[0] / 8;
+                // Dump the index into memory, since we're going to have to inject data.
+                byte[] originalIndex = File.ReadAllBytes(index2Path);
 
-            for (int i = 0; i < fileCount; i++)
-            {
-                int position = SegmentOffsets[0] + (i * 8);
-                uint iFullPathHash = BitConverter.ToUInt32(originalIndex, position);
-                uint iOffset = BitConverter.ToUInt32(originalIndex, position + 4);
+                // Get all the segment header data
+                for (int i = 0; i < SegmentHeaders.Length; i++)
+                {
+                    SegmentOffsets[i] = BitConverter.ToInt32(originalIndex, SegmentHeaders[i] + 4);
+                    SegmentSizes[i] = BitConverter.ToInt32(originalIndex, SegmentHeaders[i] + 8);
+                }
+
+                int fileCount = SegmentSizes[0] / 8;
 
-                // Index 2 is just in hash order, so find the spot where we fit in.
-                if (iFullPathHash == uFullPathHash)
+                for (int i = 0; i < fileCount; i++)
                 {
-                    int signedOffset= BitConverter.ToInt32(originalIndex, position + 4);
-                    return signedOffset * 8;
+                    int position = SegmentOffsets[0] + (i * 8);
+                    uint iFullPathHash = BitConverter.ToUInt32(originalIndex, position);
+                    uint iOffset = BitConverter.ToUInt32(originalIndex, position + 4);
+
+                    // Index 2 is just in hash order, so find the spot where we fit in.
+                    if (iFullPathHash == uFullPathHash)
+                    {
+                        int signedOffset = BitConverter.ToInt32(originalIndex, position + 4);
+                        return signedOffset * 8;
+                    }
                 }
             }
-            _semaphoreSlim.Release();
+            finally
+            {
+                _semaphoreSlim.Release();
+            }
             return 0;
         }
 
@@ -711,31 +723,36 @@ public async Task<List<int>> GetAllHashedFilesInFolder(int hashedFolder, XivData
             var indexPath = Path.Combine(_gameDirectory.FullName, $"{dataFile.GetDataFileName()}{IndexExtension}");
 
             await _semaphoreSlim.WaitAsync();
-            await Task.Run(() =>
+            try
             {
-                using (var br = new BinaryReader(File.OpenRead(indexPath)))
+                await Task.Run(() =>
                 {
-                    br.BaseStream.Seek(fileCountOffset, SeekOrigin.Begin);
-                    var totalFiles = br.ReadInt32();
-
-                    br.BaseStream.Seek(dataStartOffset, SeekOrigin.Begin);
-                    for (var i = 0; i < totalFiles; br.ReadBytes(4), i += 16)
+                    using (var br = new BinaryReader(File.OpenRead(indexPath)))
                     {
-                        var hashedFile = br.ReadInt32();
-
-                        var folderPathHash = br.ReadInt32();
+                        br.BaseStream.Seek(fileCountOffset, SeekOrigin.Begin);
+                        var totalFiles = br.ReadInt32();
 
-                        if (folderPathHash == hashedFolder)
+                        br.BaseStream.Seek(dataStartOffset, SeekOrigin.Begin);
+                        for (var i = 0; i < totalFiles; br.ReadBytes(4), i += 16)
                         {
-                            fileHashesList.Add(hashedFile);
-                        }
+                            var hashedFile = br.ReadInt32();
 
-                        br.ReadBytes(4);
-                    }
-                }
-            });
+                            var folderPathHash = br.ReadInt32();
 
-            _semaphoreSlim.Release();
+                            if (folderPathHash == hashedFolder)
+                            {
+                                fileHashesList.Add(hashedFile);
+                            }
+
+                            br.ReadBytes(4);
+                        }
+                    }
+                });
+            }
+            finally
+            {
+                _semaphoreSlim.Release();
+            }
             return fileHashesList;
         }
 
@@ -756,32 +773,38 @@ public async Task<Dictionary<int, int>> GetAllHashedFilesAndOffsetsInFolder(int
             var indexPath = Path.Combine(_gameDirectory.FullName, $"{dataFile.GetDataFileName()}{IndexExtension}");
 
             await _semaphoreSlim.WaitAsync();
-            await Task.Run(() =>
+            try
             {
-                using (var br = new BinaryReader(File.OpenRead(indexPath)))
+                await Task.Run(() =>
                 {
-                    br.BaseStream.Seek(fileCountOffset, SeekOrigin.Begin);
-                    var totalFiles = br.ReadInt32();
-
-                    br.BaseStream.Seek(dataStartOffset, SeekOrigin.Begin);
-                    for (var i = 0; i < totalFiles; br.ReadBytes(4), i += 16)
+                    using (var br = new BinaryReader(File.OpenRead(indexPath)))
                     {
-                        var hashedFile = br.ReadInt32();
-
-                        var folderPathHash = br.ReadInt32();
+                        br.BaseStream.Seek(fileCountOffset, SeekOrigin.Begin);
+                        var totalFiles = br.ReadInt32();
 
-                        if (folderPathHash == hashedFolder)
-                        {
-                            fileHashesDict.Add(hashedFile, br.ReadInt32() * 8);
-                        }
-                        else
+                        br.BaseStream.Seek(dataStartOffset, SeekOrigin.Begin);
+                        for (var i = 0; i < totalFiles; br.ReadBytes(4), i += 16)
                         {
-                            br.ReadBytes(4);
+                            var hashedFile = br.ReadInt32();
+
+                            var folderPathHash = br.ReadInt32();
+
+                            if (folderPathHash == hashedFolder)
+                            {
+                                fileHashesDict.Add(hashedFile, br.ReadInt32() * 8);
+                            }
+                            else
+                            {
+                                br.ReadBytes(4);
+                            }
                         }
                     }
-                }
-            });
-            _semaphoreSlim.Release();
+                });
+            }
+            finally
+            {
+                _semaphoreSlim.Release();
+            }
 
             return fileHashesDict;
         }