66927a3faa
Dead config field (user decision: wire them all): the AdminUI form authors
probeTimeoutSeconds ("Admin UI probe timeout", default 5) but AbLegacyDriverProbe
never read it, so Test Connect always ran on the caller's budget. It now
tightens that budget (never raises it), the same rule as the Galaxy probe; a
non-positive value keeps the caller's budget.
Refs #738
Claude-Session: https://claude.ai/code/session_01Ub9hGmYLQvn9XETzw7CMsT
228 lines
11 KiB
C#
228 lines
11 KiB
C#
using System.Diagnostics;
|
|
using System.Net.Sockets;
|
|
using System.Text.Json;
|
|
using System.Text.Json.Serialization;
|
|
using ZB.MOM.WW.OtOpcUa.Driver.Ab.Transport;
|
|
using ZB.MOM.WW.OtOpcUa.Core.Abstractions;
|
|
using ZB.MOM.WW.OtOpcUa.Driver.AbLegacy.PlcFamilies;
|
|
|
|
namespace ZB.MOM.WW.OtOpcUa.Driver.AbLegacy;
|
|
|
|
/// <summary>
|
|
/// Two-phase Test-Connect probe for the <see cref="AbLegacyDriverOptions"/>-shaped driver config.
|
|
/// Phase 1: bare TCP connect to the first device's gateway host + EtherNet/IP port to
|
|
/// quickly reject unreachable targets. Phase 2: initialises a libplctag <see cref="LibplctagLegacyTagRuntime"/>
|
|
/// against the same device to open a real PCCC-over-EIP session — confirming the remote
|
|
/// endpoint actually speaks PCCC, not just accepts TCP.
|
|
/// A device that accepts the TCP connection but is not a PCCC controller (wrong path,
|
|
/// non-PCCC server) returns <c>Ok = false</c> with a "handshake failed" message instead of
|
|
/// a false-positive green tick.
|
|
/// <para>
|
|
/// Status-code discrimination: transport statuses that indicate the controller answered
|
|
/// the PCCC session but could not resolve the probe tag
|
|
/// (<see cref="AbStatus.NotFound"/>) are treated as "reachable — Ok = true" because
|
|
/// a non-existent tag name proves PCCC connectivity. Statuses that indicate a transport or
|
|
/// session failure (<see cref="AbStatus.Timeout"/>, <see cref="AbStatus.BadConnection"/>,
|
|
/// <see cref="AbStatus.BadReply"/>, <see cref="AbStatus.Partial"/>, <see cref="AbStatus.Abort"/>) are treated as
|
|
/// "handshake failed — Ok = false". All other error statuses default to
|
|
/// "handshake failed" (conservative).
|
|
/// </para>
|
|
/// </summary>
|
|
public sealed class AbLegacyDriverProbe : IDriverProbe
|
|
{
|
|
private readonly IAbLegacyTagFactory? _tagFactory;
|
|
|
|
/// <summary>Initializes a new instance of the <see cref="AbLegacyDriverProbe"/> class.</summary>
|
|
/// <param name="tagFactory">The tag factory used for the PCCC handshake; when null the config's
|
|
/// <c>Transport</c> selects the native or libplctag-backed one.</param>
|
|
public AbLegacyDriverProbe(IAbLegacyTagFactory? tagFactory = null) => _tagFactory = tagFactory;
|
|
|
|
private static readonly JsonSerializerOptions _opts = new()
|
|
{
|
|
PropertyNameCaseInsensitive = true,
|
|
UnmappedMemberHandling = JsonUnmappedMemberHandling.Skip,
|
|
Converters = { new JsonStringEnumConverter() },
|
|
};
|
|
|
|
/// <inheritdoc />
|
|
public string DriverType => "AbLegacy";
|
|
|
|
/// <inheritdoc />
|
|
public async Task<DriverProbeResult> ProbeAsync(string configJson, TimeSpan timeout, CancellationToken ct)
|
|
{
|
|
AbLegacyDriverOptions? opts;
|
|
try { opts = JsonSerializer.Deserialize<AbLegacyDriverOptions>(configJson, _opts); }
|
|
catch (Exception ex) { return new(false, $"Config JSON is invalid: {ex.Message}", null); }
|
|
if (opts is null) return new(false, "Config JSON deserialized to null.", null);
|
|
|
|
// The authored "Admin UI probe timeout" (probeTimeoutSeconds) tightens the caller's budget. It was parsed by
|
|
// nothing before: Test Connect always ran on the caller's budget alone.
|
|
timeout = EffectiveTimeout(timeout, opts.ProbeTimeoutSeconds);
|
|
|
|
var (parsed, firstDevice) = ExtractTarget(opts);
|
|
if (parsed is null || string.IsNullOrWhiteSpace(parsed.Gateway) || parsed.Port <= 0)
|
|
return new(false, "Config has no host/port to probe.", null);
|
|
|
|
var host = parsed.Gateway;
|
|
var port = parsed.Port;
|
|
|
|
// Bound both phases by the caller timeout, independent of `ct`, so a device that accepts
|
|
// TCP but stalls the PCCC session cannot hang the probe.
|
|
using var cts = CancellationTokenSource.CreateLinkedTokenSource(ct);
|
|
cts.CancelAfter(timeout);
|
|
|
|
// Phase 1: bare TCP preflight — fast rejection for unreachable hosts.
|
|
var sw = Stopwatch.StartNew();
|
|
try
|
|
{
|
|
using var socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
|
|
await socket.ConnectAsync(host, port, cts.Token);
|
|
}
|
|
catch (SocketException ex)
|
|
{
|
|
return new(false, $"Connect failed: {ex.SocketErrorCode}", null);
|
|
}
|
|
catch (OperationCanceledException)
|
|
{
|
|
return new(false, $"Probe timed out after {timeout.TotalSeconds:F0}s.", null);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return new(false, ex.Message, null);
|
|
}
|
|
|
|
// Phase 2: PCCC session via libplctag LibplctagLegacyTagRuntime.InitializeAsync.
|
|
// Open a real PCCC-over-EIP session to confirm the remote endpoint speaks PCCC, not just TCP.
|
|
var profile = AbLegacyPlcFamilyProfile.ForFamily(firstDevice?.PlcFamily ?? AbLegacyPlcFamily.Slc500);
|
|
|
|
// Use the configured probe address (defaults to "S:0" — status file, first word).
|
|
// S:0 is present on all PCCC PLCs that support the status file, so a "not found" response
|
|
// still proves PCCC connectivity; a successful read is the happy path.
|
|
var tagName = opts.Probe.ProbeAddress
|
|
?? FirstProbeableTagAddress(opts, firstDevice)
|
|
?? "S:0";
|
|
|
|
// Normalise through the same helper as the driver's probe loop: PLC-5 octal I/O -> decimal.
|
|
// An unparseable address is a clean failure here — the factory would otherwise throw outside the try.
|
|
var normalisedName = AbLegacyProbeAddress.Normalise(tagName, firstDevice?.PlcFamily ?? AbLegacyPlcFamily.Slc500);
|
|
if (normalisedName is null)
|
|
return new(false, $"Probe address '{tagName}' is not a valid AbLegacy address for this PLC family.", null);
|
|
|
|
var p = new AbLegacyTagCreateParams(
|
|
Gateway: parsed.Gateway,
|
|
Port: parsed.Port,
|
|
CipPath: parsed.CipPath,
|
|
LibplctagPlcAttribute: profile.LibplctagPlcAttribute,
|
|
TagName: normalisedName,
|
|
Timeout: timeout);
|
|
|
|
var factory = _tagFactory ?? (AbLegacyTransportResolver.Resolve(opts) == AbLegacyTransport.Native
|
|
? new NativeAbLegacyTagFactory()
|
|
: new LibplctagLegacyTagFactory());
|
|
var rt = factory.Create(p);
|
|
try
|
|
{
|
|
await rt.InitializeAsync(cts.Token);
|
|
sw.Stop();
|
|
|
|
// InitializeAsync completed without throwing — either the tag was found (Ok) or
|
|
// libplctag returned a non-exception status. Check via GetStatus().
|
|
var statusCode = (AbStatus)rt.GetStatus();
|
|
if (IsReachableStatus(statusCode))
|
|
{
|
|
var msg = statusCode == AbStatus.Ok
|
|
? "PCCC session OK"
|
|
: "PCCC session OK (controller reachable; probe tag not found)";
|
|
return new(true, msg, sw.Elapsed);
|
|
}
|
|
|
|
// Non-Ok but non-exception: a session/transport error surfaced in the status word.
|
|
return new(false, $"Reachable at {host}:{port} but PCCC handshake failed: {statusCode}", null);
|
|
}
|
|
catch (OperationCanceledException)
|
|
{
|
|
return new(false, $"Probe timed out after {timeout.TotalSeconds:F0}s.", null);
|
|
}
|
|
catch (AbTransportException ex)
|
|
{
|
|
// AbTransportException carries the Status; classify as reachable vs transport failure.
|
|
if (IsReachableStatus(ex.Status))
|
|
{
|
|
sw.Stop();
|
|
return new(true, "PCCC session OK (controller reachable; probe tag not found)", sw.Elapsed);
|
|
}
|
|
|
|
return new(false, $"Reachable at {host}:{port} but PCCC handshake failed: {ex.Message}", null);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return new(false, $"Reachable at {host}:{port} but PCCC handshake failed: {ex.Message}", null);
|
|
}
|
|
finally
|
|
{
|
|
rt.Dispose();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns <c>true</c> for statuses that indicate the PCCC controller answered but the
|
|
/// probe tag was not found — sufficient to confirm PCCC reachability. Also <c>true</c> for
|
|
/// <see cref="AbStatus.Ok"/> (tag was found).
|
|
/// </summary>
|
|
/// <param name="s">The transport status.</param>
|
|
/// <returns>Whether the status proves the controller answered.</returns>
|
|
internal static bool IsReachableStatus(AbStatus s) => s is AbStatus.Ok or AbStatus.NotFound;
|
|
|
|
/// <summary>
|
|
/// The deadline the probe runs under: the caller's budget, tightened by the config's
|
|
/// <see cref="AbLegacyDriverOptions.ProbeTimeoutSeconds"/> when that is positive and shorter (same rule as the
|
|
/// Galaxy probe). A non-positive caller budget is floored to 1 s first.
|
|
/// </summary>
|
|
/// <param name="callerTimeout">The budget the host handed the probe.</param>
|
|
/// <param name="configuredSeconds">The config's <c>probeTimeoutSeconds</c>; ignored when not positive.</param>
|
|
/// <returns>The effective probe deadline.</returns>
|
|
internal static TimeSpan EffectiveTimeout(TimeSpan callerTimeout, int configuredSeconds)
|
|
{
|
|
var caller = callerTimeout > TimeSpan.Zero ? callerTimeout : TimeSpan.FromSeconds(1);
|
|
if (configuredSeconds <= 0) return caller;
|
|
var configured = TimeSpan.FromSeconds(configuredSeconds);
|
|
return configured < caller ? configured : caller;
|
|
}
|
|
|
|
private static (AbLegacyHostAddress? parsed, AbLegacyDeviceOptions? device) ExtractTarget(AbLegacyDriverOptions opts)
|
|
{
|
|
// Parse the first device's ab:// host address to extract the gateway IP + EIP port.
|
|
var firstDevice = opts.Devices.FirstOrDefault();
|
|
if (firstDevice is null) return (null, null);
|
|
|
|
var parsed = AbLegacyHostAddress.TryParse(firstDevice.HostAddress);
|
|
return (parsed, firstDevice);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Pick a PCCC address to probe from the authored raw tags: prefer a tag owned by the device
|
|
/// being probed, else any authored tag. v3 tags carry no typed address — the RawTagEntry's
|
|
/// <c>TagConfig</c> blob is mapped through <see cref="AbLegacyTagDefinitionFactory.FromTagConfig"/>
|
|
/// to recover the PCCC address. Returns <see langword="null"/> when no tag maps, so the caller
|
|
/// falls back to the status file (<c>S:0</c>).
|
|
/// </summary>
|
|
/// <param name="opts">The deserialised driver options.</param>
|
|
/// <param name="firstDevice">The device being probed (matched by DeviceName / HostAddress).</param>
|
|
/// <returns>A probeable PCCC address, or <see langword="null"/>.</returns>
|
|
private static string? FirstProbeableTagAddress(AbLegacyDriverOptions opts, AbLegacyDeviceOptions? firstDevice)
|
|
{
|
|
static string? Address(RawTagEntry e) =>
|
|
AbLegacyTagDefinitionFactory.FromTagConfig(e.TagConfig, e.RawPath, out var d) ? d.Address : null;
|
|
|
|
foreach (var e in opts.RawTags)
|
|
if ((string.Equals(e.DeviceName, firstDevice?.DeviceName, StringComparison.OrdinalIgnoreCase)
|
|
|| string.Equals(e.DeviceName, firstDevice?.HostAddress, StringComparison.OrdinalIgnoreCase))
|
|
&& Address(e) is { } matched)
|
|
return matched;
|
|
foreach (var e in opts.RawTags)
|
|
if (Address(e) is { } any)
|
|
return any;
|
|
return null;
|
|
}
|
|
}
|