14947fde51
New project Driver.Historian.Wonderware.Client (net10 x64) implements both Core.Abstractions.IHistorianDataSource (read paths consumed by the server's IHistoryRouter) and Core.AlarmHistorian.IAlarmHistorianWriter (alarm-event drain consumed by SqliteStoreAndForwardSink) against the sidecar's PR 3.3 pipe protocol. Wire-format files (Framing/MessageKind, Hello, Contracts, FrameReader, FrameWriter) are byte-identical mirrors of the sidecar's net48 originals — the sidecar can't be referenced as a ProjectReference because of the runtime/bitness gap, so we duplicate and pin the wire bytes via tests. PipeChannel owns one bidirectional NamedPipeClientStream + Hello handshake + serializes calls. Single in-flight at a time (semaphore); transport failures trigger one in-flight reconnect-and-retry before propagating. Connect is abstracted behind a Func<CancellationToken, Task<Stream>> so tests inject in-process pipes. WonderwareHistorianClient maps: - HistorianSampleDto.Quality (raw OPC DA byte) → OPC UA StatusCode uint via QualityMapper (port of HistorianQualityMapper from sidecar). - HistorianAggregateSampleDto.Value=null → BadNoData (0x800E0000). - WriteAlarmEventsReply.PerEventOk[i]=true → Ack, false → RetryPlease. Whole-call failure or transport exception → RetryPlease for every event in the batch (drain worker handles backoff). - AlarmHistorianEvent → AlarmHistorianEventDto with severity bucketed via AlarmSeverity-to-ushort mapping (Low=250, Medium=500, High=700, Crit=900). GetHealthSnapshot tracks transport success + sidecar-reported failure separately; ConsecutiveFailures rises on operation-level errors, not just transport drops. 10 round-trip tests via FakeSidecarServer (in-process net10 fake using the client's own framing): byte→uint quality mapping, null-bucket BadNoData, at-time order preservation, event-field round-trip, sidecar error surfacing, WriteBatch per-event status, whole-call retry-please mapping, Hello shared-secret rejection, transport-drop reconnect-and-retry, health snapshot counters. PR 3.W will register this client as IHistorianDataSource + IAlarmHistorianWriter in OpcUaServerService DI. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
64 lines
2.3 KiB
C#
64 lines
2.3 KiB
C#
using MessagePack;
|
|
|
|
namespace ZB.MOM.WW.OtOpcUa.Driver.Historian.Wonderware.Client.Ipc;
|
|
|
|
/// <summary>
|
|
/// Reads length-prefixed, kind-tagged frames from a stream. Single-consumer — do not call
|
|
/// <see cref="ReadFrameAsync"/> from multiple threads against the same instance. Mirror of
|
|
/// the sidecar's <c>FrameReader</c>; kept byte-identical so the wire protocol stays stable.
|
|
/// </summary>
|
|
public sealed class FrameReader : IDisposable
|
|
{
|
|
private readonly Stream _stream;
|
|
private readonly bool _leaveOpen;
|
|
|
|
public FrameReader(Stream stream, bool leaveOpen = false)
|
|
{
|
|
_stream = stream ?? throw new ArgumentNullException(nameof(stream));
|
|
_leaveOpen = leaveOpen;
|
|
}
|
|
|
|
public async Task<(MessageKind Kind, byte[] Body)?> ReadFrameAsync(CancellationToken ct)
|
|
{
|
|
var lengthPrefix = new byte[Framing.LengthPrefixSize];
|
|
if (!await ReadExactAsync(lengthPrefix, ct).ConfigureAwait(false))
|
|
return null; // clean EOF on frame boundary
|
|
|
|
var length = (lengthPrefix[0] << 24) | (lengthPrefix[1] << 16) | (lengthPrefix[2] << 8) | lengthPrefix[3];
|
|
if (length < 0 || length > Framing.MaxFrameBodyBytes)
|
|
throw new InvalidDataException($"Sidecar IPC frame length {length} out of range.");
|
|
|
|
var kindByte = _stream.ReadByte();
|
|
if (kindByte < 0) throw new EndOfStreamException("EOF after length prefix, before kind byte.");
|
|
|
|
var body = new byte[length];
|
|
if (!await ReadExactAsync(body, ct).ConfigureAwait(false))
|
|
throw new EndOfStreamException("EOF mid-frame.");
|
|
|
|
return ((MessageKind)(byte)kindByte, body);
|
|
}
|
|
|
|
public static T Deserialize<T>(byte[] body) => MessagePackSerializer.Deserialize<T>(body);
|
|
|
|
private async Task<bool> ReadExactAsync(byte[] buffer, CancellationToken ct)
|
|
{
|
|
var offset = 0;
|
|
while (offset < buffer.Length)
|
|
{
|
|
var read = await _stream.ReadAsync(buffer.AsMemory(offset, buffer.Length - offset), ct).ConfigureAwait(false);
|
|
if (read == 0)
|
|
{
|
|
if (offset == 0) return false;
|
|
throw new EndOfStreamException($"Stream ended after reading {offset} of {buffer.Length} bytes.");
|
|
}
|
|
offset += read;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public void Dispose()
|
|
{
|
|
if (!_leaveOpen) _stream.Dispose();
|
|
}
|
|
}
|