using System;
|
using System.Collections.Concurrent;
|
using System.Collections.Generic;
|
using System.Linq;
|
using System.Threading.Tasks;
|
using Microsoft.Extensions.Logging;
|
using WIDESEAWCS_S7Simulator.Core.Entities;
|
using WIDESEAWCS_S7Simulator.Core.Enums;
|
using WIDESEAWCS_S7Simulator.Core.Interfaces;
|
using WIDESEAWCS_S7Simulator.Core.Persistence;
|
using WIDESEAWCS_S7Simulator.Core.Server;
|
|
namespace WIDESEAWCS_S7Simulator.Core.Manager
|
{
|
/// <summary>
|
/// 仿真器实例管理器实现
|
/// 管理多个S7服务器实例的生命周期，提供线程安全的CRUD操作
|
/// </summary>
|
public class SimulatorInstanceManager : ISimulatorInstanceManager
|
{
|
private readonly ConcurrentDictionary<string, IS7ServerInstance> _instances = new();
|
private readonly IPersistenceService _persistenceService;
|
private readonly ILogger<SimulatorInstanceManager> _logger;
|
private readonly ILoggerFactory _loggerFactory;
|
|
/// <inheritdoc/>
|
public event EventHandler<InstanceStateChangedEventArgs>? InstanceStateChanged;
|
|
/// <summary>
|
/// 构造函数
|
/// </summary>
|
/// <param name="persistenceService">持久化服务</param>
|
/// <param name="logger">日志记录器</param>
|
/// <param name="loggerFactory">日志工厂</param>
|
public SimulatorInstanceManager(
|
IPersistenceService persistenceService,
|
ILogger<SimulatorInstanceManager> logger,
|
ILoggerFactory loggerFactory)
|
{
|
_persistenceService = persistenceService ?? throw new ArgumentNullException(nameof(persistenceService));
|
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
|
_loggerFactory = loggerFactory ?? throw new ArgumentNullException(nameof(loggerFactory));
|
}
|
|
/// <inheritdoc/>
|
public IReadOnlyList<IS7ServerInstance> GetAllInstances()
|
{
|
return _instances.Values.ToList().AsReadOnly();
|
}
|
|
/// <inheritdoc/>
|
public IS7ServerInstance? GetInstance(string instanceId)
|
{
|
if (string.IsNullOrWhiteSpace(instanceId))
|
{
|
return null;
|
}
|
|
_instances.TryGetValue(instanceId, out var instance);
|
return instance;
|
}
|
|
/// <inheritdoc/>
|
public bool InstanceExists(string instanceId)
|
{
|
return !string.IsNullOrWhiteSpace(instanceId) && _instances.ContainsKey(instanceId);
|
}
|
|
/// <inheritdoc/>
|
public async Task<IS7ServerInstance> CreateInstanceAsync(InstanceConfig config)
|
{
|
if (config == null)
|
{
|
throw new ArgumentNullException(nameof(config));
|
}
|
|
// 如果没有提供ID，生成新的GUID
|
if (string.IsNullOrWhiteSpace(config.Id))
|
{
|
config.Id = Guid.NewGuid().ToString("N");
|
_logger.LogDebug("为实例生成新ID: {InstanceId}", config.Id);
|
}
|
|
// 检查ID是否已存在
|
if (_instances.ContainsKey(config.Id))
|
{
|
throw new InvalidOperationException($"实例ID {config.Id} 已存在");
|
}
|
|
try
|
{
|
// 创建实例
|
var instanceLogger = _loggerFactory.CreateLogger<S7ServerInstance>();
|
var instance = new S7ServerInstance(config, instanceLogger);
|
|
// 添加到字典
|
if (!_instances.TryAdd(config.Id, instance))
|
{
|
throw new InvalidOperationException($"无法将实例 {config.Id} 添加到管理器");
|
}
|
|
// 保存配置
|
await _persistenceService.SaveInstanceConfigAsync(config);
|
|
// 触发状态变化事件
|
OnInstanceStateChanged(new InstanceStateChangedEventArgs
|
{
|
InstanceId = config.Id,
|
OldStatus = InstanceStatus.Stopped,
|
NewStatus = InstanceStatus.Stopped,
|
InstanceState = instance.GetState()
|
});
|
|
_logger.LogInformation("已创建实例 {InstanceId} ({InstanceName})", config.Id, config.Name);
|
return instance;
|
}
|
catch (Exception ex)
|
{
|
_logger.LogError(ex, "创建实例 {InstanceId} 时发生错误", config.Id);
|
throw;
|
}
|
}
|
|
/// <inheritdoc/>
|
public async Task<bool> StartInstanceAsync(string instanceId)
|
{
|
if (string.IsNullOrWhiteSpace(instanceId))
|
{
|
_logger.LogWarning("尝试启动实例时提供了空ID");
|
return false;
|
}
|
|
if (!_instances.TryGetValue(instanceId, out var instance))
|
{
|
_logger.LogWarning("尝试启动不存在的实例 {InstanceId}", instanceId);
|
return false;
|
}
|
|
try
|
{
|
var oldState = instance.GetState();
|
var oldStatus = oldState.Status;
|
|
// 启动实例
|
var success = instance.Start();
|
|
if (success)
|
{
|
var newState = instance.GetState();
|
|
// 触发状态变化事件
|
OnInstanceStateChanged(new InstanceStateChangedEventArgs
|
{
|
InstanceId = instanceId,
|
OldStatus = oldStatus,
|
NewStatus = newState.Status,
|
InstanceState = newState
|
});
|
|
_logger.LogInformation("实例 {InstanceId} 已启动", instanceId);
|
}
|
else
|
{
|
_logger.LogWarning("实例 {InstanceId} 启动失败", instanceId);
|
}
|
|
return success;
|
}
|
catch (Exception ex)
|
{
|
_logger.LogError(ex, "启动实例 {InstanceId} 时发生异常", instanceId);
|
return false;
|
}
|
}
|
|
/// <inheritdoc/>
|
public async Task StopInstanceAsync(string instanceId)
|
{
|
if (string.IsNullOrWhiteSpace(instanceId))
|
{
|
_logger.LogWarning("尝试停止实例时提供了空ID");
|
return;
|
}
|
|
if (!_instances.TryGetValue(instanceId, out var instance))
|
{
|
_logger.LogWarning("尝试停止不存在的实例 {InstanceId}", instanceId);
|
return;
|
}
|
|
try
|
{
|
var oldState = instance.GetState();
|
var oldStatus = oldState.Status;
|
|
// 停止实例
|
instance.Stop();
|
|
// 同步内存数据到持久化存储
|
await _persistenceService.SaveMemoryDataAsync(instanceId, instance.MemoryStore);
|
|
var newState = instance.GetState();
|
|
// 触发状态变化事件
|
OnInstanceStateChanged(new InstanceStateChangedEventArgs
|
{
|
InstanceId = instanceId,
|
OldStatus = oldStatus,
|
NewStatus = newState.Status,
|
InstanceState = newState
|
});
|
|
_logger.LogInformation("实例 {InstanceId} 已停止", instanceId);
|
}
|
catch (Exception ex)
|
{
|
_logger.LogError(ex, "停止实例 {InstanceId} 时发生异常", instanceId);
|
}
|
}
|
|
/// <inheritdoc/>
|
public async Task<bool> RestartInstanceAsync(string instanceId)
|
{
|
if (string.IsNullOrWhiteSpace(instanceId))
|
{
|
_logger.LogWarning("尝试重启实例时提供了空ID");
|
return false;
|
}
|
|
if (!_instances.TryGetValue(instanceId, out var instance))
|
{
|
_logger.LogWarning("尝试重启不存在的实例 {InstanceId}", instanceId);
|
return false;
|
}
|
|
try
|
{
|
var oldState = instance.GetState();
|
var oldStatus = oldState.Status;
|
|
// 重启实例
|
var success = instance.Restart();
|
|
if (success)
|
{
|
var newState = instance.GetState();
|
|
// 触发状态变化事件
|
OnInstanceStateChanged(new InstanceStateChangedEventArgs
|
{
|
InstanceId = instanceId,
|
OldStatus = oldStatus,
|
NewStatus = newState.Status,
|
InstanceState = newState
|
});
|
|
_logger.LogInformation("实例 {InstanceId} 已重启", instanceId);
|
}
|
else
|
{
|
_logger.LogWarning("实例 {InstanceId} 重启失败", instanceId);
|
}
|
|
return success;
|
}
|
catch (Exception ex)
|
{
|
_logger.LogError(ex, "重启实例 {InstanceId} 时发生异常", instanceId);
|
return false;
|
}
|
}
|
|
/// <inheritdoc/>
|
public async Task DeleteInstanceAsync(string instanceId, bool deleteConfig = true)
|
{
|
if (string.IsNullOrWhiteSpace(instanceId))
|
{
|
_logger.LogWarning("尝试删除实例时提供了空ID");
|
return;
|
}
|
|
if (!_instances.TryRemove(instanceId, out var instance))
|
{
|
_logger.LogWarning("尝试删除不存在的实例 {InstanceId}", instanceId);
|
return;
|
}
|
|
try
|
{
|
var oldState = instance.GetState();
|
|
// 停止实例
|
instance.Stop();
|
|
// 释放实例资源
|
instance.Dispose();
|
|
// 删除配置文件
|
if (deleteConfig)
|
{
|
await _persistenceService.DeleteInstanceConfigAsync(instanceId);
|
}
|
|
// 触发状态变化事件
|
OnInstanceStateChanged(new InstanceStateChangedEventArgs
|
{
|
InstanceId = instanceId,
|
OldStatus = oldState.Status,
|
NewStatus = InstanceStatus.Stopped,
|
InstanceState = oldState
|
});
|
|
_logger.LogInformation("实例 {InstanceId} 已删除", instanceId);
|
}
|
catch (Exception ex)
|
{
|
_logger.LogError(ex, "删除实例 {InstanceId} 时发生异常", instanceId);
|
}
|
}
|
|
/// <inheritdoc/>
|
public InstanceState? GetInstanceState(string instanceId)
|
{
|
if (string.IsNullOrWhiteSpace(instanceId))
|
{
|
return null;
|
}
|
|
if (!_instances.TryGetValue(instanceId, out var instance))
|
{
|
return null;
|
}
|
|
return instance.GetState();
|
}
|
|
/// <inheritdoc/>
|
public IReadOnlyList<InstanceState> GetAllInstanceStates()
|
{
|
return _instances.Values
|
.Select(i => i.GetState())
|
.ToList()
|
.AsReadOnly();
|
}
|
|
/// <inheritdoc/>
|
public async Task LoadSavedInstancesAsync(bool autoStart = true)
|
{
|
try
|
{
|
_logger.LogInformation("开始加载已保存的实例配置...");
|
|
// 加载所有配置
|
var configs = await _persistenceService.LoadAllInstanceConfigsAsync();
|
|
if (configs == null || configs.Count == 0)
|
{
|
_logger.LogInformation("没有找到已保存的实例配置");
|
return;
|
}
|
|
_logger.LogInformation("找到 {Count} 个已保存的实例配置", configs.Count);
|
|
foreach (var config in configs)
|
{
|
try
|
{
|
// 创建实例
|
var instanceLogger = _loggerFactory.CreateLogger<S7ServerInstance>();
|
var instance = new S7ServerInstance(config, instanceLogger);
|
|
// 添加到字典
|
if (_instances.TryAdd(config.Id, instance))
|
{
|
// 加载内存数据
|
try
|
{
|
await _persistenceService.LoadMemoryDataAsync(config.Id, instance.MemoryStore);
|
_logger.LogDebug("已加载实例 {InstanceId} 的内存数据", config.Id);
|
}
|
catch (Exception ex)
|
{
|
_logger.LogWarning(ex, "加载实例 {InstanceId} 的内存数据时发生警告", config.Id);
|
}
|
|
// 如果配置了自动启动，则启动实例
|
if (autoStart && config.AutoStart)
|
{
|
_logger.LogInformation("自动启动实例 {InstanceId} ({InstanceName})", config.Id, config.Name);
|
var success = instance.Start();
|
if (success)
|
{
|
_logger.LogInformation("实例 {InstanceId} 自动启动成功", config.Id);
|
}
|
else
|
{
|
_logger.LogWarning("实例 {InstanceId} 自动启动失败", config.Id);
|
}
|
}
|
|
// 触发状态变化事件
|
OnInstanceStateChanged(new InstanceStateChangedEventArgs
|
{
|
InstanceId = config.Id,
|
OldStatus = InstanceStatus.Stopped,
|
NewStatus = instance.State.Status,
|
InstanceState = instance.GetState()
|
});
|
|
_logger.LogInformation("已加载实例 {InstanceId} ({InstanceName})", config.Id, config.Name);
|
}
|
else
|
{
|
_logger.LogWarning("实例 {InstanceId} 已存在，跳过加载", config.Id);
|
}
|
}
|
catch (Exception ex)
|
{
|
_logger.LogError(ex, "加载实例 {InstanceId} 时发生错误", config.Id);
|
}
|
}
|
|
_logger.LogInformation("实例加载完成，共加载 {Count} 个实例", _instances.Count);
|
}
|
catch (Exception ex)
|
{
|
_logger.LogError(ex, "加载已保存的实例时发生异常");
|
}
|
}
|
|
/// <inheritdoc/>
|
public async Task StopAllInstancesAsync()
|
{
|
_logger.LogInformation("开始停止所有实例...");
|
|
var instanceIds = _instances.Keys.ToList();
|
|
foreach (var instanceId in instanceIds)
|
{
|
try
|
{
|
await StopInstanceAsync(instanceId);
|
}
|
catch (Exception ex)
|
{
|
_logger.LogError(ex, "停止实例 {InstanceId} 时发生异常", instanceId);
|
}
|
}
|
|
_logger.LogInformation("所有实例已停止");
|
}
|
|
/// <inheritdoc/>
|
public int GetRunningInstanceCount()
|
{
|
return _instances.Values.Count(i => i.State.Status == InstanceStatus.Running);
|
}
|
|
/// <inheritdoc/>
|
public int GetTotalInstanceCount()
|
{
|
return _instances.Count;
|
}
|
|
/// <summary>
|
/// 触发实例状态变化事件
|
/// </summary>
|
/// <param name="e">事件参数</param>
|
protected virtual void OnInstanceStateChanged(InstanceStateChangedEventArgs e)
|
{
|
InstanceStateChanged?.Invoke(this, e);
|
}
|
}
|
}
|
