using System.Collections.Concurrent;
using System.Text.Json;
using ClassNotify.Shared.Models;
namespace ClassNotify.Shared.Services;
///
/// 命令认领抢占状态
///
public enum CommandClaimResult
{
/// 成功抢占并在内存与磁盘物理账本中双重持久化成功
Claimed,
/// 命令此前已执行完毕,持有已完成缓存结果
AlreadyCompleted,
/// 命令当前正处于执行流中,尚未得出最终结果
InFlight,
/// 持久化账本写入失败或本地账本文件已损坏,Fail-Closed 拒绝执行任何副作用
StorageError
}
///
/// 专用远程命令幂等去重器与持久化本地账本 (Windows Service 端)
/// 保证同一 CommandId 在网络抖动、SignalR 重连、重复派发、乃至 Service 崩溃或重启后,
/// 严格至多在物理终端执行一次实际副作用,并能安全幂等返回先前的执行结果。
/// 严格遵循 Fail-Closed 原则:当磁盘持久化失败或文件损坏时,决不允许在不具备持久保证的情况下执行副作用。
///
public class DeviceCommandDeduplicator
{
public class CommandExecutionRecord
{
public bool IsCompleted { get; set; }
public DateTimeOffset Timestamp { get; set; }
public DeviceCommandResultDto? Result { get; set; }
}
private readonly ConcurrentDictionary _records = new();
private readonly TimeSpan _slidingWindow;
private readonly int _maxCapacity;
private readonly string? _ledgerFilePath;
private readonly object _fileLock = new();
private volatile bool _isCorrupted = false;
public int Count => _records.Count;
public string? LedgerFilePath => _ledgerFilePath;
public bool IsCorrupted => _isCorrupted;
public DeviceCommandDeduplicator(
TimeSpan? slidingWindow = null,
int maxCapacity = 1000,
string? ledgerFilePath = null)
{
_slidingWindow = slidingWindow ?? TimeSpan.FromHours(1);
_maxCapacity = maxCapacity;
_ledgerFilePath = ledgerFilePath;
LoadLedgerFromDisk();
}
///
/// 尝试以持久化 Fail-Closed 保证抢占执行锁。
/// 只有在内存认领成功 且 磁盘持久化写入原子成功时,才返回 Claimed;
/// 若账本损坏或持久化失败,立即回滚内存状态并返回 StorageError,阻断副作用执行。
///
public CommandClaimResult TryDurablyClaim(string commandId, DateTimeOffset? nowUtc = null)
{
if (string.IsNullOrWhiteSpace(commandId)) return CommandClaimResult.StorageError;
if (_isCorrupted) return CommandClaimResult.StorageError;
var now = nowUtc ?? DateTimeOffset.UtcNow;
PruneIfNeeded(now);
if (_records.TryGetValue(commandId, out var existing))
{
return existing.IsCompleted ? CommandClaimResult.AlreadyCompleted : CommandClaimResult.InFlight;
}
var record = new CommandExecutionRecord
{
IsCompleted = false,
Timestamp = now
};
if (!_records.TryAdd(commandId, record))
{
return _records.TryGetValue(commandId, out var r) && r.IsCompleted
? CommandClaimResult.AlreadyCompleted
: CommandClaimResult.InFlight;
}
try
{
SaveLedgerToDisk();
return CommandClaimResult.Claimed;
}
catch
{
// Fail-closed: 回滚内存记录,确保没有虚假的 InFlight 状态残留在内存中
_records.TryRemove(commandId, out _);
return CommandClaimResult.StorageError;
}
}
///
/// 尝试抢占执行锁(兼容既有布尔接口,底层严格遵循 TryDurablyClaim 的 Fail-Closed 保证)。
///
public bool TryBeginExecution(string commandId, DateTimeOffset? nowUtc = null)
{
return TryDurablyClaim(commandId, nowUtc) == CommandClaimResult.Claimed;
}
///
/// 命令执行完毕后记录最终执行结果并持久化至磁盘
///
public void CompleteExecution(string commandId, DeviceCommandResultDto result, DateTimeOffset? nowUtc = null)
{
if (string.IsNullOrWhiteSpace(commandId)) return;
var now = nowUtc ?? DateTimeOffset.UtcNow;
if (_records.TryGetValue(commandId, out var record))
{
record.IsCompleted = true;
record.Timestamp = now;
record.Result = result;
}
else
{
_records[commandId] = new CommandExecutionRecord
{
IsCompleted = true,
Timestamp = now,
Result = result
};
}
try
{
SaveLedgerToDisk();
}
catch
{
// 写入失败时保留内存记录
}
}
///
/// 查询已完成命令的历史缓存结果(用于重复到达时直接返回原结果)
///
public bool TryGetCachedResult(string commandId, out DeviceCommandResultDto? result)
{
result = null;
if (string.IsNullOrWhiteSpace(commandId)) return false;
if (_records.TryGetValue(commandId, out var record) && record.IsCompleted && record.Result != null)
{
result = record.Result;
return true;
}
return false;
}
public void Clear()
{
_records.Clear();
_isCorrupted = false;
try
{
SaveLedgerToDisk();
}
catch
{
}
}
private void PruneIfNeeded(DateTimeOffset now)
{
bool pruned = false;
var cutoff = now.Subtract(_slidingWindow);
if (_records.Count > _maxCapacity)
{
foreach (var kvp in _records)
{
if (kvp.Value.Timestamp < cutoff)
{
if (_records.TryRemove(kvp.Key, out _))
{
pruned = true;
}
}
}
}
if (pruned)
{
try
{
SaveLedgerToDisk();
}
catch
{
}
}
}
private void LoadLedgerFromDisk()
{
if (string.IsNullOrWhiteSpace(_ledgerFilePath)) return;
try
{
lock (_fileLock)
{
if (!File.Exists(_ledgerFilePath)) return;
var json = File.ReadAllText(_ledgerFilePath);
if (string.IsNullOrWhiteSpace(json))
{
// 存在但为空,视同损坏文件以防读取非预期状态
_isCorrupted = true;
return;
}
var data = JsonSerializer.Deserialize>(json);
if (data != null)
{
var now = DateTimeOffset.UtcNow;
var cutoff = now.Subtract(_slidingWindow);
foreach (var (k, v) in data)
{
if (v.Timestamp >= cutoff)
{
_records[k] = v;
}
}
}
else
{
_isCorrupted = true;
}
}
}
catch
{
// Fail-closed: 遇到反序列化异常或文件损坏时标记 Corrupted,阻止无保护的执行
_isCorrupted = true;
}
}
private void SaveLedgerToDisk()
{
if (string.IsNullOrWhiteSpace(_ledgerFilePath)) return;
lock (_fileLock)
{
var dir = Path.GetDirectoryName(_ledgerFilePath);
if (!string.IsNullOrEmpty(dir) && !Directory.Exists(dir))
{
Directory.CreateDirectory(dir);
}
var snapshot = _records.ToDictionary(k => k.Key, v => v.Value);
var json = JsonSerializer.Serialize(snapshot, new JsonSerializerOptions { WriteIndented = true });
var tmp = _ledgerFilePath + $".{Guid.NewGuid():N}.tmp";
File.WriteAllText(tmp, json);
File.Move(tmp, _ledgerFilePath, overwrite: true);
}
}
}