215 lines
10 KiB
C#
215 lines
10 KiB
C#
using System.Text.Json;
|
|
using System.Text.Json.Serialization;
|
|
using ZB.MOM.WW.OtOpcUa.Core.Hosting;
|
|
using ZB.MOM.WW.OtOpcUa.Driver.FOCAS.Ipc;
|
|
|
|
namespace ZB.MOM.WW.OtOpcUa.Driver.FOCAS;
|
|
|
|
/// <summary>
|
|
/// Static factory registration helper for <see cref="FocasDriver"/>. Server's Program.cs
|
|
/// calls <see cref="Register"/> once at startup; the bootstrapper (task #248) then
|
|
/// materialises FOCAS DriverInstance rows from the central config DB into live driver
|
|
/// instances. Mirrors <c>GalaxyProxyDriverFactoryExtensions</c>; no dependency on
|
|
/// Microsoft.Extensions.DependencyInjection so the driver project stays DI-free.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// The DriverConfig JSON selects the <see cref="IFocasClientFactory"/> backend:
|
|
/// <list type="bullet">
|
|
/// <item><c>"Backend": "ipc"</c> (default) — wires <see cref="IpcFocasClientFactory"/>
|
|
/// against a named-pipe <see cref="FocasIpcClient"/> talking to a separate
|
|
/// <c>Driver.FOCAS.Host</c> process (Tier-C isolation). Requires <c>PipeName</c> +
|
|
/// <c>SharedSecret</c>.</item>
|
|
/// <item><c>"Backend": "fwlib"</c> — direct in-process Fwlib32.dll P/Invoke via
|
|
/// <see cref="FwlibFocasClientFactory"/>. Use only when the main server is licensed
|
|
/// for FOCAS and you accept the native-crash blast-radius trade-off.</item>
|
|
/// <item><c>"Backend": "unimplemented"</c> — returns the no-op factory; useful for
|
|
/// scaffolding DriverInstance rows before the Host is deployed so the server boots.</item>
|
|
/// </list>
|
|
/// Devices / Tags / Probe / Timeout / Series come from the same JSON and feed directly
|
|
/// into <see cref="FocasDriverOptions"/>.
|
|
/// </remarks>
|
|
public static class FocasDriverFactoryExtensions
|
|
{
|
|
public const string DriverTypeName = "FOCAS";
|
|
|
|
/// <summary>
|
|
/// Register the FOCAS driver factory in the supplied <see cref="DriverFactoryRegistry"/>.
|
|
/// Throws if 'FOCAS' is already registered — single-instance per process.
|
|
/// </summary>
|
|
public static void Register(DriverFactoryRegistry registry)
|
|
{
|
|
ArgumentNullException.ThrowIfNull(registry);
|
|
registry.Register(DriverTypeName, CreateInstance);
|
|
}
|
|
|
|
internal static FocasDriver CreateInstance(string driverInstanceId, string driverConfigJson)
|
|
{
|
|
ArgumentException.ThrowIfNullOrWhiteSpace(driverInstanceId);
|
|
ArgumentException.ThrowIfNullOrWhiteSpace(driverConfigJson);
|
|
|
|
var dto = JsonSerializer.Deserialize<FocasDriverConfigDto>(driverConfigJson, JsonOptions)
|
|
?? throw new InvalidOperationException(
|
|
$"FOCAS driver config for '{driverInstanceId}' deserialised to null");
|
|
|
|
// Eager-validate top-level Series so a typo fails fast regardless of whether Devices
|
|
// are populated yet (common during rollout when rows are seeded before CNCs arrive).
|
|
_ = ParseSeries(dto.Series);
|
|
|
|
var options = new FocasDriverOptions
|
|
{
|
|
Devices = dto.Devices is { Count: > 0 }
|
|
? [.. dto.Devices.Select(d => new FocasDeviceOptions(
|
|
HostAddress: d.HostAddress ?? throw new InvalidOperationException(
|
|
$"FOCAS config for '{driverInstanceId}' has a device missing HostAddress"),
|
|
DeviceName: d.DeviceName,
|
|
Series: ParseSeries(d.Series ?? dto.Series)))]
|
|
: [],
|
|
Tags = dto.Tags is { Count: > 0 }
|
|
? [.. dto.Tags.Select(t => new FocasTagDefinition(
|
|
Name: t.Name ?? throw new InvalidOperationException(
|
|
$"FOCAS config for '{driverInstanceId}' has a tag missing Name"),
|
|
DeviceHostAddress: t.DeviceHostAddress ?? throw new InvalidOperationException(
|
|
$"FOCAS tag '{t.Name}' in '{driverInstanceId}' missing DeviceHostAddress"),
|
|
Address: t.Address ?? throw new InvalidOperationException(
|
|
$"FOCAS tag '{t.Name}' in '{driverInstanceId}' missing Address"),
|
|
DataType: ParseDataType(t.DataType, t.Name!, driverInstanceId),
|
|
// Per-tag Writable defaults to false post-F4-a (issue #268). A config-DB row
|
|
// with Writable null means "not opted in" — operators must explicitly flip
|
|
// the flag per tag before writes flow.
|
|
Writable: t.Writable ?? false,
|
|
WriteIdempotent: t.WriteIdempotent ?? false))]
|
|
: [],
|
|
Probe = new FocasProbeOptions
|
|
{
|
|
Enabled = dto.Probe?.Enabled ?? true,
|
|
Interval = TimeSpan.FromMilliseconds(dto.Probe?.IntervalMs ?? 5_000),
|
|
Timeout = TimeSpan.FromMilliseconds(dto.Probe?.TimeoutMs ?? 2_000),
|
|
},
|
|
Timeout = TimeSpan.FromMilliseconds(dto.TimeoutMs ?? 2_000),
|
|
// Driver-level write opt-in (issue #268, plan PR F4-a). Default false — config rows
|
|
// that omit the section keep the safer-by-default read-only posture; flipping it on
|
|
// requires an explicit deployment-time choice.
|
|
Writes = new FocasWritesOptions
|
|
{
|
|
Enabled = dto.Writes?.Enabled ?? false,
|
|
},
|
|
};
|
|
|
|
var clientFactory = BuildClientFactory(dto, driverInstanceId);
|
|
return new FocasDriver(options, driverInstanceId, clientFactory);
|
|
}
|
|
|
|
internal static IFocasClientFactory BuildClientFactory(
|
|
FocasDriverConfigDto dto, string driverInstanceId)
|
|
{
|
|
var backend = (dto.Backend ?? "ipc").Trim().ToLowerInvariant();
|
|
return backend switch
|
|
{
|
|
"ipc" => BuildIpcFactory(dto, driverInstanceId),
|
|
"fwlib" or "fwlib32" => new FwlibFocasClientFactory(),
|
|
"unimplemented" or "none" or "stub" => new UnimplementedFocasClientFactory(),
|
|
_ => throw new InvalidOperationException(
|
|
$"FOCAS driver config for '{driverInstanceId}' has unknown Backend '{dto.Backend}'. " +
|
|
"Expected one of: ipc, fwlib, unimplemented."),
|
|
};
|
|
}
|
|
|
|
private static IpcFocasClientFactory BuildIpcFactory(
|
|
FocasDriverConfigDto dto, string driverInstanceId)
|
|
{
|
|
var pipeName = dto.PipeName
|
|
?? throw new InvalidOperationException(
|
|
$"FOCAS driver config for '{driverInstanceId}' missing required PipeName (Tier-C ipc backend)");
|
|
var sharedSecret = dto.SharedSecret
|
|
?? throw new InvalidOperationException(
|
|
$"FOCAS driver config for '{driverInstanceId}' missing required SharedSecret (Tier-C ipc backend)");
|
|
var connectTimeout = TimeSpan.FromMilliseconds(dto.ConnectTimeoutMs ?? 10_000);
|
|
var series = ParseSeries(dto.Series);
|
|
|
|
// Each IFocasClientFactory.Create() call opens a fresh pipe to the Host — matches the
|
|
// driver's one-client-per-device invariant. FocasIpcClient.ConnectAsync is awaited
|
|
// synchronously via GetAwaiter().GetResult() because IFocasClientFactory.Create is a
|
|
// sync contract; the blocking call lands inside FocasDriver.EnsureConnectedAsync,
|
|
// which immediately awaits IFocasClient.ConnectAsync afterwards so the perceived
|
|
// latency is identical to a fully-async factory.
|
|
return new IpcFocasClientFactory(
|
|
ipcClientFactory: () => FocasIpcClient.ConnectAsync(
|
|
pipeName: pipeName,
|
|
sharedSecret: sharedSecret,
|
|
connectTimeout: connectTimeout,
|
|
ct: CancellationToken.None).GetAwaiter().GetResult(),
|
|
series: series);
|
|
}
|
|
|
|
private static FocasCncSeries ParseSeries(string? raw)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(raw)) return FocasCncSeries.Unknown;
|
|
return Enum.TryParse<FocasCncSeries>(raw, ignoreCase: true, out var s)
|
|
? s
|
|
: throw new InvalidOperationException(
|
|
$"FOCAS Series '{raw}' is not one of {string.Join(", ", Enum.GetNames<FocasCncSeries>())}");
|
|
}
|
|
|
|
private static FocasDataType ParseDataType(string? raw, string tagName, string driverInstanceId)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(raw))
|
|
throw new InvalidOperationException(
|
|
$"FOCAS tag '{tagName}' in '{driverInstanceId}' missing DataType");
|
|
return Enum.TryParse<FocasDataType>(raw, ignoreCase: true, out var dt)
|
|
? dt
|
|
: throw new InvalidOperationException(
|
|
$"FOCAS tag '{tagName}' has unknown DataType '{raw}'. " +
|
|
$"Expected one of {string.Join(", ", Enum.GetNames<FocasDataType>())}");
|
|
}
|
|
|
|
private static readonly JsonSerializerOptions JsonOptions = new()
|
|
{
|
|
PropertyNameCaseInsensitive = true,
|
|
ReadCommentHandling = JsonCommentHandling.Skip,
|
|
AllowTrailingCommas = true,
|
|
};
|
|
|
|
internal sealed class FocasDriverConfigDto
|
|
{
|
|
public string? Backend { get; init; }
|
|
public string? PipeName { get; init; }
|
|
public string? SharedSecret { get; init; }
|
|
public int? ConnectTimeoutMs { get; init; }
|
|
public string? Series { get; init; }
|
|
public int? TimeoutMs { get; init; }
|
|
public List<FocasDeviceDto>? Devices { get; init; }
|
|
public List<FocasTagDto>? Tags { get; init; }
|
|
public FocasProbeDto? Probe { get; init; }
|
|
public FocasWritesDto? Writes { get; init; }
|
|
}
|
|
|
|
internal sealed class FocasWritesDto
|
|
{
|
|
public bool? Enabled { get; init; }
|
|
}
|
|
|
|
internal sealed class FocasDeviceDto
|
|
{
|
|
public string? HostAddress { get; init; }
|
|
public string? DeviceName { get; init; }
|
|
public string? Series { get; init; }
|
|
}
|
|
|
|
internal sealed class FocasTagDto
|
|
{
|
|
public string? Name { get; init; }
|
|
public string? DeviceHostAddress { get; init; }
|
|
public string? Address { get; init; }
|
|
public string? DataType { get; init; }
|
|
public bool? Writable { get; init; }
|
|
public bool? WriteIdempotent { get; init; }
|
|
}
|
|
|
|
internal sealed class FocasProbeDto
|
|
{
|
|
public bool? Enabled { get; init; }
|
|
public int? IntervalMs { get; init; }
|
|
public int? TimeoutMs { get; init; }
|
|
}
|
|
}
|