123 lines
3.4 KiB
C#
123 lines
3.4 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using Dinah.Core.Collections.Immutable;
|
|
using FileManager;
|
|
using Newtonsoft.Json;
|
|
|
|
#nullable enable
|
|
namespace LibationFileManager
|
|
{
|
|
public static class FilePathCache
|
|
{
|
|
public record CacheEntry(string Id, FileType FileType, LongPath Path);
|
|
|
|
private const string FILENAME = "FileLocations.json";
|
|
|
|
public static event EventHandler<CacheEntry>? Inserted;
|
|
public static event EventHandler<CacheEntry>? Removed;
|
|
|
|
private static Cache<CacheEntry> cache { get; } = new Cache<CacheEntry>();
|
|
|
|
private static LongPath jsonFile => Path.Combine(Configuration.Instance.LibationFiles, FILENAME);
|
|
|
|
static FilePathCache()
|
|
{
|
|
// load json into memory. if file doesn't exist, nothing to do. save() will create if needed
|
|
if (!File.Exists(jsonFile))
|
|
return;
|
|
|
|
try
|
|
{
|
|
var list = JsonConvert.DeserializeObject<List<CacheEntry>>(File.ReadAllText(jsonFile));
|
|
if (list is null)
|
|
throw new NullReferenceException("File exists but deserialize is null. This will never happen when file is healthy.");
|
|
|
|
cache = new Cache<CacheEntry>(list);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Serilog.Log.Logger.Error(ex, "Error deserializing file. Wrong format. Possibly corrupt. Deleting file. {@DebugInfo}", new { jsonFile });
|
|
lock (locker)
|
|
File.Delete(jsonFile);
|
|
return;
|
|
}
|
|
}
|
|
|
|
public static bool Exists(string id, FileType type) => GetFirstPath(id, type) is not null;
|
|
|
|
public static List<(FileType fileType, LongPath path)> GetFiles(string id)
|
|
=> getEntries(entry => entry.Id == id)
|
|
.Select(entry => (entry.FileType, entry.Path))
|
|
.ToList();
|
|
|
|
public static LongPath? GetFirstPath(string id, FileType type)
|
|
=> getEntries(entry => entry.Id == id && entry.FileType == type)
|
|
?.FirstOrDefault()
|
|
?.Path;
|
|
|
|
private static IEnumerable<CacheEntry> getEntries(Func<CacheEntry, bool> predicate)
|
|
{
|
|
var entries = cache.Where(predicate).ToList();
|
|
if (entries is null || !entries.Any())
|
|
return Enumerable.Empty<CacheEntry>();
|
|
|
|
remove(entries.Where(e => !File.Exists(e.Path)).ToList());
|
|
|
|
return cache.Where(predicate).ToList();
|
|
}
|
|
|
|
private static void remove(List<CacheEntry> entries)
|
|
{
|
|
if (entries is null)
|
|
return;
|
|
|
|
lock (locker)
|
|
{
|
|
foreach (var entry in entries)
|
|
{
|
|
cache.Remove(entry);
|
|
Removed?.Invoke(null, entry);
|
|
}
|
|
save();
|
|
}
|
|
}
|
|
|
|
public static void Insert(string id, string path)
|
|
{
|
|
var type = FileTypes.GetFileTypeFromPath(path);
|
|
Insert(new CacheEntry(id, type, path));
|
|
}
|
|
|
|
public static void Insert(CacheEntry entry)
|
|
{
|
|
cache.Add(entry);
|
|
Inserted?.Invoke(null, entry);
|
|
save();
|
|
}
|
|
|
|
// cache is thread-safe and lock free. but file saving is not
|
|
private static object locker { get; } = new object();
|
|
private static void save()
|
|
{
|
|
// create json if not exists
|
|
static void resave() => File.WriteAllText(jsonFile, JsonConvert.SerializeObject(cache.ToList(), Formatting.Indented));
|
|
|
|
lock (locker)
|
|
{
|
|
try { resave(); }
|
|
catch (IOException)
|
|
{
|
|
try { resave(); }
|
|
catch (IOException ex)
|
|
{
|
|
Serilog.Log.Logger.Error(ex, $"Error saving {FILENAME}");
|
|
throw;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|