dohertj2/mxaccess
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
eb6c689f0916a5fbd2fc1dfd005b2ce418e8bf29
mxaccess/analysis/decompiled/ASBIDataV2Adapter/ArchestrAServices.ASBContract/ASBIDataV1Shim.cs
T
Joseph Doherty fe2a6db786
rust / build / test / clippy / fmt (push) Has been cancelled
Details
Initial project state: .NET reference, design, Rust port (M0+M1), evidence 
Layout:
- src/                    .NET 10 x64 reference: MxNativeCodec, MxNativeClient,
                          MxAsbClient, probes, tests, harnesses. Executable spec.
- design/                 Architectural plan for the Rust port (M0–M6), error
                          model, protocol invariants, risks (R1–R16), adversarial
                          review log (review.md).
- rust/                   Rust workspace. M0 skeleton + M1 codec parity.
                          mxaccess-codec: 215 unit tests + 2 cross-implementation
                          parity tests (byte-identical against .NET reference).
                          Other crates are M0 stubs awaiting M2+.
- captures/               Frida + netsh + pcap evidence per CLAUDE.md
                          ("captures are evidence, not throwaway logs").
- analysis/               Decompiled C# (frida/proxy/decompiled-*),
                          Ghidra exports for native DLLs (`exports/` only —
                          working state at `projects/` and AVEVA's input
                          binaries at `input/` are gitignored).
- docs/                   Reverse-engineering reference docs.
- tools/                  Setup-LiveProbeEnv.ps1 (Infisical credential fetcher),
                          Compute-Crc.ps1 (.NET parity helper).
- .github/workflows/      Rust CI: fmt + build + test + clippy on Windows.
- LICENSE                 MIT (Joseph Doherty, 2026).

Verified:
- cargo test --workspace → 217 passed (215 unit + 2 .NET parity), 0 failed
- cargo clippy --workspace -- -D warnings → clean
- cargo fmt --all -- --check → clean
- cargo publish --dry-run -p mxaccess-codec → packages cleanly

Excluded from history (see .gitignore):
- **/bin, **/obj, **/target — build artifacts
- analysis/ghidra/projects/ — Ghidra working state (regenerable)
- analysis/ghidra/input/ — AVEVA proprietary DLLs (vendor IP)

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
2026-05-05 06:21:00 -04:00

1444 lines
63 KiB
C#
Raw Blame History

#define TRACE
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.ServiceModel;
using System.Threading;
using ArchestrAServices.ASBIDataV2Adapter;
using ArchestrAServices.ASBIDataV2Contract;
using ArchestrAServices.Common;
namespace ArchestrAServices.ASBContract;
[ServiceBehavior(InstanceContextMode = InstanceContextMode.PerCall, ConcurrencyMode = ConcurrencyMode.Multiple)]
public abstract class ASBIDataV1Shim : IASBIDataV2, IAuthenticateASB
{
private class ConnectionContext
{
public IContextChannel ConnectionChannel;
public IDataV2toV1 ConnectionImplementation;
public Timer ConnectionKeepaliveTimer;
private ConnectionContext()
{
}
public ConnectionContext(IContextChannel Channel, IDataV2toV1 Implementation, Timer KeepaliveTimer)
{
ConnectionChannel = Channel;
ConnectionImplementation = Implementation;
ConnectionKeepaliveTimer = KeepaliveTimer;
}
}
private static ReaderWriterLockSlim implementationLock = new ReaderWriterLockSlim();
private static Dictionary<Guid, ConnectionContext> m_Implementations = new Dictionary<Guid, ConnectionContext>();
private static int KeepaliveTimeout = 30000;
protected virtual IDataV2toV1 GetImplementation()
{
return null;
}
public ASBIDataV1Shim()
{
}
public virtual ConnectResponse Connect(ConnectRequest request)
{
ConnectResponse connectResponse = SysAuthServiceAuthentication.ProcessClientConnection(request);
SvcTrace.DiagDiagnostics.TraceEvent(TraceEventType.Information, 0, "Connect started new Authenticator for connection Id {0}", connectResponse.ConnectionValidator.ConnectionId.ToString());
SvcTrace.DiagCsv.TraceEvent(TraceEventType.Start, 100, string.Empty, "Connect started new Authenticator for connection Id =", connectResponse.ConnectionValidator.ConnectionId.ToString());
return connectResponse;
}
public virtual void AuthenticateMe(AuthenticateMe request)
{
SvcTrace.DiagCsv.TraceEvent(TraceEventType.Stop, 100, string.Empty, "AuthenticateMe entry Id =", request.ConnectionValidator.ConnectionId.ToString());
SysAuthServiceAuthentication serviceAuthenticator = SysAuthenticatorServiceCache.GetServiceAuthenticator(request.ConnectionValidator.ConnectionId);
if (serviceAuthenticator != null && (OperationContext.Current.Channel.LocalAddress.Uri.ToString().ToLower().StartsWith("http") || serviceAuthenticator.ProcessClientAuthenticateMe(request)))
{
SvcTrace.DiagDiagnostics.TraceEvent(TraceEventType.Information, 0, "AuthenticateMe found authenticator and validated request message, calling implementation OnConnect({0})", serviceAuthenticator.connectionID.ToString());
ConnectionId connectionId = new ConnectionId
{
Id = serviceAuthenticator.connectionID
};
IDataV2toV1 implementation = GetImplementation();
if (implementation != null)
{
Timer keepaliveTimer = new Timer(KeepaliveHandler, implementation, KeepaliveTimeout, -1);
try
{
SvcTrace.DiagCsv.TraceEvent(TraceEventType.Start, 100, string.Empty, "AuthenticateMe found authenticator and validated request message, calling implementation OnConnect Id =", serviceAuthenticator.connectionID.ToString());
implementation.OnConnect(connectionId, serviceAuthenticator.Lifetime);
implementationLock.EnterWriteLock();
try
{
m_Implementations.Add(serviceAuthenticator.connectionID, new ConnectionContext(OperationContext.Current.Channel, implementation, keepaliveTimer));
SvcTrace.DiagDiagnostics.TraceEvent(TraceEventType.Information, 0, "AuthenticateMe added implementation for ConnectionId {0}", serviceAuthenticator.connectionID);
}
finally
{
implementationLock.ExitWriteLock();
}
}
catch (Exception ex)
{
SvcTrace.DiagControl.TraceEvent(TraceEventType.Warning, 0, "AuthenticateMe caught exception from implementation for ConnectionId {0}: {1}", serviceAuthenticator.connectionID, ex.Message);
if (ex.InnerException != null)
{
SvcTrace.DiagControl.TraceEvent(TraceEventType.Warning, 0, " {0}", ex.InnerException.Message);
}
}
}
}
SvcTrace.DiagCsv.TraceEvent(TraceEventType.Start, 100, string.Empty, "AuthenticateMe exit Id =", serviceAuthenticator.connectionID.ToString());
}
public virtual RenewResponse Renew(RenewRequest request)
{
return SysAuthServiceAuthentication.ProcessClientRenew(request);
}
public virtual void UpdateSystemAuthenticationConfiguration(UpdateSystemAuthenticationConfiguration request)
{
SysAuthServiceAuthentication.ProcessClientUpdateSystemAuthenticationConfiguration(request);
}
public virtual void Disconnect(Disconnect request)
{
SvcTrace.DiagCsv.TraceEvent(TraceEventType.Stop, 100, string.Empty, "Disconnect entry Id =", request.ConnectionValidator.ConnectionId.ToString());
SysAuthServiceAuthentication serviceAuthenticator = SysAuthenticatorServiceCache.GetServiceAuthenticator(request.ConnectionValidator.ConnectionId);
if (serviceAuthenticator != null && serviceAuthenticator.ValidRequest(request))
{
OnDisconnect(request.ConnectionValidator.ConnectionId);
serviceAuthenticator.ProcessClientDisconnect(request);
}
SvcTrace.DiagCsv.TraceEvent(TraceEventType.Stop, 100, string.Empty, "Disconnect exit Id =", request.ConnectionValidator.ConnectionId.ToString());
}
private void OnDisconnect(Guid ConnectionId)
{
ConnectionId id = new ConnectionId
{
Id = ConnectionId
};
bool flag = false;
implementationLock.EnterReadLock();
ConnectionContext value;
try
{
flag = m_Implementations.TryGetValue(ConnectionId, out value);
}
finally
{
implementationLock.ExitReadLock();
}
if (!flag)
{
return;
}
IDataV2toV1 connectionImplementation = value.ConnectionImplementation;
Timer connectionKeepaliveTimer = value.ConnectionKeepaliveTimer;
connectionKeepaliveTimer.Change(-1, -1);
connectionKeepaliveTimer.Dispose();
try
{
SvcTrace.DiagCsv.TraceEvent(TraceEventType.Start, 100, string.Empty, "OnDisconnect found authenticator and validated request message, calling implementation OnDisconnect Id =", ConnectionId.ToString());
connectionImplementation.OnDisconnect(id);
}
catch (Exception ex)
{
SvcTrace.DiagControl.TraceEvent(TraceEventType.Warning, 0, "OnDisconnect caught exception from implementation for ConnectionId {0}: {1}", ConnectionId, ex.Message);
if (ex.InnerException != null)
{
SvcTrace.DiagControl.TraceEvent(TraceEventType.Warning, 0, " {0}", ex.InnerException.Message);
}
}
implementationLock.EnterWriteLock();
try
{
m_Implementations.Remove(ConnectionId);
SvcTrace.DiagDiagnostics.TraceEvent(TraceEventType.Information, 0, "OnDisconnect removed implementation for ConnectionId {0}", ConnectionId);
}
finally
{
implementationLock.ExitWriteLock();
}
}
public virtual void KeepAlive(KeepAlive request)
{
SvcTrace.DiagCsv.TraceEvent(TraceEventType.Information, 100, string.Empty, "KeepAlive entry Id =", request.ConnectionValidator.ConnectionId.ToString());
SysAuthServiceAuthentication serviceAuthenticator = SysAuthenticatorServiceCache.GetServiceAuthenticator(request.ConnectionValidator.ConnectionId);
if (serviceAuthenticator != null && serviceAuthenticator.ValidRequest(request))
{
bool flag = false;
implementationLock.EnterReadLock();
ConnectionContext value;
try
{
flag = m_Implementations.TryGetValue(request.ConnectionValidator.ConnectionId, out value);
}
finally
{
implementationLock.ExitReadLock();
}
if (flag)
{
value.ConnectionKeepaliveTimer.Change(KeepaliveTimeout, -1);
ConnectionId connectionId = new ConnectionId
{
Id = serviceAuthenticator.connectionID
};
IDataV2toV1 connectionImplementation = value.ConnectionImplementation;
try
{
connectionImplementation.KeepAlive(connectionId);
}
catch (Exception ex)
{
SvcTrace.DiagControl.TraceEvent(TraceEventType.Warning, 0, "KeepAlive caught exception from implementation for ConnectionId {0}: {1}", connectionId, ex.Message);
if (ex.InnerException != null)
{
SvcTrace.DiagControl.TraceEvent(TraceEventType.Warning, 0, " {0}", ex.InnerException.Message);
}
}
}
}
SvcTrace.DiagCsv.TraceEvent(TraceEventType.Information, 100, string.Empty, "KeepAlive exit Id =", request.ConnectionValidator.ConnectionId.ToString());
}
private void KeepaliveHandler(object Implementation)
{
Guid guid = Guid.Empty;
IContextChannel contextChannel = null;
implementationLock.EnterReadLock();
try
{
foreach (KeyValuePair<Guid, ConnectionContext> implementation in m_Implementations)
{
if (implementation.Value.ConnectionImplementation == Implementation)
{
guid = implementation.Key;
contextChannel = implementation.Value.ConnectionChannel;
break;
}
}
}
finally
{
implementationLock.ExitReadLock();
}
if (guid == Guid.Empty)
{
SvcTrace.DiagControl.TraceEvent(TraceEventType.Warning, 0, "Keepalive timeout triggered, could not find ConnectionId");
return;
}
OnDisconnect(guid);
SysAuthenticatorServiceCache.RemoveServiceAuthenticator(guid);
try
{
if (contextChannel != null)
{
SvcTrace.DiagControl.TraceEvent(TraceEventType.Warning, 0, "Keepalive timeout elapsed without any method calls, closing connection {0} and aborting service channel", guid.ToString());
contextChannel.Abort();
}
}
catch (Exception ex)
{
SvcTrace.DiagControl.TraceEvent(TraceEventType.Warning, 0, ex.StackTrace);
}
}
public virtual ActivateUserResponse ActivateUser(ActivateUserRequest request)
{
SvcTrace.DiagCsv.TraceEvent(TraceEventType.Information, 0, string.Empty, "ActivateUser entry Id =", request.ConnectionValidator.ConnectionId.ToString());
ActivateUserResponse activateUserResponse = new ActivateUserResponse();
activateUserResponse.Result = ResultFactory.MakeResult(EnumASBFactory.ArchestrAErrorToInt(ArchestrAError.InvalidConnectionId));
SysAuthServiceAuthentication serviceAuthenticator = SysAuthenticatorServiceCache.GetServiceAuthenticator(request.ConnectionValidator.ConnectionId);
if (serviceAuthenticator != null)
{
SvcTrace.DiagDiagnostics.TraceEvent(TraceEventType.Information, 0, "ActivateUser found authenticator for Connection Id {0}", request.ConnectionValidator.ConnectionId.ToString());
}
if (serviceAuthenticator != null && serviceAuthenticator.ValidRequest(request))
{
SvcTrace.DiagDiagnostics.TraceEvent(TraceEventType.Information, 0, "ActivateUser validated request, passing to service");
bool flag = false;
implementationLock.EnterReadLock();
ConnectionContext value;
try
{
flag = m_Implementations.TryGetValue(request.ConnectionValidator.ConnectionId, out value);
}
finally
{
implementationLock.ExitReadLock();
}
if (flag)
{
value.ConnectionKeepaliveTimer.Change(KeepaliveTimeout, -1);
ConnectionId id = new ConnectionId
{
Id = serviceAuthenticator.connectionID
};
IDataV2toV1 connectionImplementation = value.ConnectionImplementation;
try
{
activateUserResponse.Result = connectionImplementation.ActivateUser(id, request.UserToken.ToV1UserToken());
}
catch (Exception ex)
{
SvcTrace.DiagControl.TraceEvent(TraceEventType.Warning, 0, "ActivateUser caught exception from implementation for ConnectionId {0}: {1}", request.ConnectionValidator.ConnectionId, ex.Message);
if (ex.InnerException != null)
{
SvcTrace.DiagControl.TraceEvent(TraceEventType.Warning, 0, " {0}", ex.InnerException.Message);
}
activateUserResponse.Result = ResultFactory.MakeResult(EnumASBFactory.ArchestrAErrorToInt(ArchestrAError.OperationFailed));
activateUserResponse.Result.ErrorMessages = new string[1] { ex.Message };
}
}
}
SvcTrace.DiagCsv.TraceEvent(TraceEventType.Information, 0, string.Empty, "ActivateUser exit Id =", request.ConnectionValidator.ConnectionId.ToString());
return activateUserResponse;
}
public virtual ExchangeCapabilitiesResponse ExchangeCapabilities(ExchangeCapabilitiesRequest request)
{
SvcTrace.DiagCsv.TraceEvent(TraceEventType.Information, 0, string.Empty, "ExchangeCapabilities entry Id =", request.ConnectionValidator.ConnectionId.ToString());
ExchangeCapabilitiesResponse exchangeCapabilitiesResponse = new ExchangeCapabilitiesResponse();
exchangeCapabilitiesResponse.Result = ResultFactory.MakeResult(EnumASBFactory.ArchestrAErrorToInt(ArchestrAError.InvalidConnectionId));
SysAuthServiceAuthentication serviceAuthenticator = SysAuthenticatorServiceCache.GetServiceAuthenticator(request.ConnectionValidator.ConnectionId);
if (serviceAuthenticator != null)
{
SvcTrace.DiagDiagnostics.TraceEvent(TraceEventType.Information, 0, "ExchangeCapabilities found authenticator for Connection Id {0}", request.ConnectionValidator.ConnectionId.ToString());
}
if (serviceAuthenticator != null && serviceAuthenticator.ValidRequest(request))
{
SvcTrace.DiagDiagnostics.TraceEvent(TraceEventType.Information, 0, "ExchangeCapabilities validated request, passing to service");
bool flag = false;
implementationLock.EnterReadLock();
ConnectionContext value;
try
{
flag = m_Implementations.TryGetValue(request.ConnectionValidator.ConnectionId, out value);
}
finally
{
implementationLock.ExitReadLock();
}
if (flag)
{
value.ConnectionKeepaliveTimer.Change(KeepaliveTimeout, -1);
ConnectionId id = new ConnectionId
{
Id = serviceAuthenticator.connectionID
};
IDataV2toV1 connectionImplementation = value.ConnectionImplementation;
try
{
exchangeCapabilitiesResponse.Result = connectionImplementation.ExchangeCapabilities(out var ServiceCapabilities, id, request.ClientCapabilities);
exchangeCapabilitiesResponse.ServiceCapabilities = ServiceCapabilities;
}
catch (Exception ex)
{
SvcTrace.DiagControl.TraceEvent(TraceEventType.Warning, 0, "ExchangeCapabilities caught exception from implementation for ConnectionId {0}: {1}", request.ConnectionValidator.ConnectionId, ex.Message);
if (ex.InnerException != null)
{
SvcTrace.DiagControl.TraceEvent(TraceEventType.Warning, 0, " {0}", ex.InnerException.Message);
}
exchangeCapabilitiesResponse.Result = ResultFactory.MakeResult(EnumASBFactory.ArchestrAErrorToInt(ArchestrAError.OperationFailed));
exchangeCapabilitiesResponse.Result.ErrorMessages = new string[1] { ex.Message };
}
}
}
SvcTrace.DiagCsv.TraceEvent(TraceEventType.Information, 0, string.Empty, "ExchangeCapabilities exit Id =", request.ConnectionValidator.ConnectionId.ToString());
return exchangeCapabilitiesResponse;
}
public virtual ArchestrAServices.ASBIDataV2Contract.ReadResponse Read(ArchestrAServices.ASBIDataV2Contract.ReadRequest request)
{
SvcTrace.DiagCsv.TraceEvent(TraceEventType.Information, 0, string.Empty, "Read entry Id =", request.ConnectionValidator.ConnectionId.ToString());
ArchestrAServices.ASBIDataV2Contract.ReadResponse readResponse = new ArchestrAServices.ASBIDataV2Contract.ReadResponse();
readResponse.Result = ResultFactory.MakeResult(EnumASBFactory.ArchestrAErrorToInt(ArchestrAError.InvalidConnectionId));
SysAuthServiceAuthentication serviceAuthenticator = SysAuthenticatorServiceCache.GetServiceAuthenticator(request.ConnectionValidator.ConnectionId);
if (serviceAuthenticator != null && serviceAuthenticator.ValidRequest(request))
{
bool flag = false;
implementationLock.EnterReadLock();
ConnectionContext value;
try
{
flag = m_Implementations.TryGetValue(request.ConnectionValidator.ConnectionId, out value);
}
finally
{
implementationLock.ExitReadLock();
}
if (flag)
{
value.ConnectionKeepaliveTimer.Change(KeepaliveTimeout, -1);
ConnectionId id = new ConnectionId
{
Id = serviceAuthenticator.connectionID
};
IDataV2toV1 connectionImplementation = value.ConnectionImplementation;
try
{
ItemStatusV2[] Status = null;
RuntimeValue[] Values = null;
ItemIdentity[] items = null;
readResponse.Status = null;
readResponse.Values = null;
if (request.Items != null)
{
items = request.Items.ToV1ItemIdentityArray();
}
readResponse.Result = connectionImplementation.Read(out Status, out Values, id, items);
if (Status != null)
{
readResponse.Status = Status.ToTrueV2ItemStatusArray();
}
if (Values != null)
{
readResponse.Values = Values.ToV2RuntimeValueArray();
}
}
catch (Exception ex)
{
SvcTrace.DiagControl.TraceEvent(TraceEventType.Warning, 0, "Read caught exception from implementation for ConnectionId {0}: {1}", request.ConnectionValidator.ConnectionId, ex.Message);
if (ex.InnerException != null)
{
SvcTrace.DiagControl.TraceEvent(TraceEventType.Warning, 0, " {0}", ex.InnerException.Message);
}
readResponse.Result = ResultFactory.MakeResult(EnumASBFactory.ArchestrAErrorToInt(ArchestrAError.OperationFailed));
readResponse.Result.ErrorMessages = new string[1] { ex.Message };
}
}
}
SvcTrace.DiagCsv.TraceEvent(TraceEventType.Information, 0, string.Empty, "Read exit Id =", request.ConnectionValidator.ConnectionId.ToString());
return readResponse;
}
public virtual ArchestrAServices.ASBIDataV2Contract.WriteResponse Write(ArchestrAServices.ASBIDataV2Contract.WriteBasicRequest request)
{
SvcTrace.DiagCsv.TraceEvent(TraceEventType.Information, 0, string.Empty, "Write entry Id =", request.ConnectionValidator.ConnectionId.ToString());
ArchestrAServices.ASBIDataV2Contract.WriteResponse writeResponse = new ArchestrAServices.ASBIDataV2Contract.WriteResponse();
writeResponse.Result = ResultFactory.MakeResult(EnumASBFactory.ArchestrAErrorToInt(ArchestrAError.InvalidConnectionId));
SysAuthServiceAuthentication serviceAuthenticator = SysAuthenticatorServiceCache.GetServiceAuthenticator(request.ConnectionValidator.ConnectionId);
if (serviceAuthenticator != null && serviceAuthenticator.ValidRequest(request))
{
bool flag = false;
implementationLock.EnterReadLock();
ConnectionContext value;
try
{
flag = m_Implementations.TryGetValue(request.ConnectionValidator.ConnectionId, out value);
}
finally
{
implementationLock.ExitReadLock();
}
if (flag)
{
value.ConnectionKeepaliveTimer.Change(KeepaliveTimeout, -1);
ConnectionId id = new ConnectionId
{
Id = serviceAuthenticator.connectionID
};
IDataV2toV1 connectionImplementation = value.ConnectionImplementation;
try
{
WriteValueV2[] array = request.Values.ToMirroredV2WriteValueArray();
if (connectionImplementation.Settings != null)
{
int setting = connectionImplementation.Settings.GetSetting("ArrayBase", 0);
if (setting != 0)
{
for (int i = 0; i < array.Length; i++)
{
array[i].ArrayElementIndex += setting;
}
}
}
ItemIdentity[] items = null;
if (request.Items != null)
{
items = request.Items.ToV1ItemIdentityArray();
}
writeResponse.Result = connectionImplementation.Write(out var Status, id, items, array, request.WriteHandle);
writeResponse.Status = Status.ToTrueV2ItemStatusArray();
}
catch (Exception ex)
{
SvcTrace.DiagControl.TraceEvent(TraceEventType.Warning, 0, "Write caught exception from implementation for ConnectionId {0}: {1}", request.ConnectionValidator.ConnectionId, ex.Message);
if (ex.InnerException != null)
{
SvcTrace.DiagControl.TraceEvent(TraceEventType.Warning, 0, " {0}", ex.InnerException.Message);
}
writeResponse.Result = ResultFactory.MakeResult(EnumASBFactory.ArchestrAErrorToInt(ArchestrAError.OperationFailed));
writeResponse.Result.ErrorMessages = new string[1] { ex.Message };
}
}
}
SvcTrace.DiagCsv.TraceEvent(TraceEventType.Information, 0, string.Empty, "Write exit Id =", request.ConnectionValidator.ConnectionId.ToString());
return writeResponse;
}
public virtual ArchestrAServices.ASBIDataV2Contract.WriteUserResponse WriteUser(ArchestrAServices.ASBIDataV2Contract.WriteUserRequest request)
{
SvcTrace.DiagCsv.TraceEvent(TraceEventType.Information, 0, string.Empty, "WriteUser entry Id =", request.ConnectionValidator.ConnectionId.ToString());
ArchestrAServices.ASBIDataV2Contract.WriteUserResponse writeUserResponse = new ArchestrAServices.ASBIDataV2Contract.WriteUserResponse();
writeUserResponse.Result = ResultFactory.MakeResult(EnumASBFactory.ArchestrAErrorToInt(ArchestrAError.InvalidConnectionId));
SysAuthServiceAuthentication serviceAuthenticator = SysAuthenticatorServiceCache.GetServiceAuthenticator(request.ConnectionValidator.ConnectionId);
if (serviceAuthenticator != null && serviceAuthenticator.ValidRequest(request))
{
ConnectionId id = new ConnectionId
{
Id = serviceAuthenticator.connectionID
};
bool flag = false;
implementationLock.EnterReadLock();
ConnectionContext value;
try
{
flag = m_Implementations.TryGetValue(request.ConnectionValidator.ConnectionId, out value);
}
finally
{
implementationLock.ExitReadLock();
}
if (flag)
{
value.ConnectionKeepaliveTimer.Change(KeepaliveTimeout, -1);
IDataV2toV1 connectionImplementation = value.ConnectionImplementation;
try
{
WriteValueV2[] array = null;
ItemIdentity[] items = null;
if (request.Values != null)
{
array = request.Values.ToMirroredV2WriteValueArray();
if (connectionImplementation.Settings != null)
{
int setting = connectionImplementation.Settings.GetSetting("ArrayBase", 0);
if (setting != 0)
{
for (int i = 0; i < array.Length; i++)
{
array[i].ArrayElementIndex += setting;
}
}
}
}
if (request.Items != null)
{
items = request.Items.ToV1ItemIdentityArray();
}
writeUserResponse.Result = connectionImplementation.WriteUser(out var Status, id, items, array, request.User.ToV1UserToken(), request.WriteHandle);
writeUserResponse.Status = Status.ToTrueV2ItemStatusArray();
}
catch (Exception ex)
{
SvcTrace.DiagControl.TraceEvent(TraceEventType.Warning, 0, "WriteUser caught exception from implementation for ConnectionId {0}: {1}", request.ConnectionValidator.ConnectionId, ex.Message);
if (ex.InnerException != null)
{
SvcTrace.DiagControl.TraceEvent(TraceEventType.Warning, 0, " {0}", ex.InnerException.Message);
}
writeUserResponse.Result = ResultFactory.MakeResult(EnumASBFactory.ArchestrAErrorToInt(ArchestrAError.OperationFailed));
writeUserResponse.Result.ErrorMessages = new string[1] { ex.Message };
}
}
}
SvcTrace.DiagCsv.TraceEvent(TraceEventType.Information, 0, string.Empty, "WriteUser exit Id =", request.ConnectionValidator.ConnectionId.ToString());
return writeUserResponse;
}
public virtual ArchestrAServices.ASBIDataV2Contract.WriteVerifiedResponse WriteVerified(ArchestrAServices.ASBIDataV2Contract.WriteVerifiedRequest request)
{
SvcTrace.DiagCsv.TraceEvent(TraceEventType.Information, 0, string.Empty, "WriteVerified entry Id =", request.ConnectionValidator.ConnectionId.ToString());
ArchestrAServices.ASBIDataV2Contract.WriteVerifiedResponse writeVerifiedResponse = new ArchestrAServices.ASBIDataV2Contract.WriteVerifiedResponse();
writeVerifiedResponse.Result = ResultFactory.MakeResult(EnumASBFactory.ArchestrAErrorToInt(ArchestrAError.InvalidConnectionId));
SysAuthServiceAuthentication serviceAuthenticator = SysAuthenticatorServiceCache.GetServiceAuthenticator(request.ConnectionValidator.ConnectionId);
if (serviceAuthenticator != null && serviceAuthenticator.ValidRequest(request))
{
bool flag = false;
implementationLock.EnterReadLock();
ConnectionContext value;
try
{
flag = m_Implementations.TryGetValue(request.ConnectionValidator.ConnectionId, out value);
}
finally
{
implementationLock.ExitReadLock();
}
if (flag)
{
value.ConnectionKeepaliveTimer.Change(KeepaliveTimeout, -1);
ConnectionId id = new ConnectionId
{
Id = serviceAuthenticator.connectionID
};
IDataV2toV1 connectionImplementation = value.ConnectionImplementation;
try
{
WriteValueV2[] array = null;
ItemIdentity[] items = null;
writeVerifiedResponse.Status = null;
if (request.Values != null)
{
array = request.Values.ToMirroredV2WriteValueArray();
if (connectionImplementation.Settings != null)
{
int setting = connectionImplementation.Settings.GetSetting("ArrayBase", 0);
if (setting != 0)
{
for (int i = 0; i < array.Length; i++)
{
array[i].ArrayElementIndex += setting;
}
}
}
}
if (request.Items != null)
{
items = request.Items.ToV1ItemIdentityArray();
}
writeVerifiedResponse.Result = connectionImplementation.WriteVerified(out var Status, id, items, array, request.User.ToV1UserToken(), request.Supervisor.ToV1UserToken(), request.WriteHandle);
if (Status != null)
{
writeVerifiedResponse.Status = Status.ToTrueV2ItemStatusArray();
}
}
catch (Exception ex)
{
SvcTrace.DiagControl.TraceEvent(TraceEventType.Warning, 0, "WriteVerified caught exception from implementation for ConnectionId {0}: {1}", request.ConnectionValidator.ConnectionId, ex.Message);
if (ex.InnerException != null)
{
SvcTrace.DiagControl.TraceEvent(TraceEventType.Warning, 0, " {0}", ex.InnerException.Message);
}
writeVerifiedResponse.Result = ResultFactory.MakeResult(EnumASBFactory.ArchestrAErrorToInt(ArchestrAError.OperationFailed));
writeVerifiedResponse.Result.ErrorMessages = new string[1] { ex.Message };
}
}
}
SvcTrace.DiagCsv.TraceEvent(TraceEventType.Information, 0, string.Empty, "WriteVerified exit Id =", request.ConnectionValidator.ConnectionId.ToString());
return writeVerifiedResponse;
}
public virtual ArchestrAServices.ASBIDataV2Contract.WriteSecuredResponse WriteSecured(ArchestrAServices.ASBIDataV2Contract.WriteSecuredRequest request)
{
SvcTrace.DiagCsv.TraceEvent(TraceEventType.Information, 0, string.Empty, "WriteSecured entry Id =", request.ConnectionValidator.ConnectionId.ToString());
ArchestrAServices.ASBIDataV2Contract.WriteSecuredResponse writeSecuredResponse = new ArchestrAServices.ASBIDataV2Contract.WriteSecuredResponse();
writeSecuredResponse.Result = ResultFactory.MakeResult(EnumASBFactory.ArchestrAErrorToInt(ArchestrAError.InvalidConnectionId));
SysAuthServiceAuthentication serviceAuthenticator = SysAuthenticatorServiceCache.GetServiceAuthenticator(request.ConnectionValidator.ConnectionId);
if (serviceAuthenticator != null && serviceAuthenticator.ValidRequest(request))
{
bool flag = false;
implementationLock.EnterReadLock();
ConnectionContext value;
try
{
flag = m_Implementations.TryGetValue(request.ConnectionValidator.ConnectionId, out value);
}
finally
{
implementationLock.ExitReadLock();
}
if (flag)
{
value.ConnectionKeepaliveTimer.Change(KeepaliveTimeout, -1);
ConnectionId id = new ConnectionId
{
Id = serviceAuthenticator.connectionID
};
IDataV2toV1 connectionImplementation = value.ConnectionImplementation;
try
{
WriteValueV2[] array = null;
ItemIdentity[] items = null;
writeSecuredResponse.Status = null;
if (request.Values != null)
{
array = request.Values.ToMirroredV2WriteValueArray();
if (connectionImplementation.Settings != null)
{
int setting = connectionImplementation.Settings.GetSetting("ArrayBase", 0);
if (setting != 0)
{
for (int i = 0; i < array.Length; i++)
{
array[i].ArrayElementIndex += setting;
}
}
}
}
if (request.Items != null)
{
items = request.Items.ToV1ItemIdentityArray();
}
writeSecuredResponse.Result = connectionImplementation.WriteSecured(out var Status, id, items, array, request.User.ToV1UserToken(), request.WriteHandle);
if (Status != null)
{
writeSecuredResponse.Status = Status.ToTrueV2ItemStatusArray();
}
}
catch (Exception ex)
{
SvcTrace.DiagControl.TraceEvent(TraceEventType.Warning, 0, "WriteSecured caught exception from implementation for ConnectionId {0}: {1}", request.ConnectionValidator.ConnectionId, ex.Message);
if (ex.InnerException != null)
{
SvcTrace.DiagControl.TraceEvent(TraceEventType.Warning, 0, " {0}", ex.InnerException.Message);
}
writeSecuredResponse.Result = ResultFactory.MakeResult(EnumASBFactory.ArchestrAErrorToInt(ArchestrAError.OperationFailed));
writeSecuredResponse.Result.ErrorMessages = new string[1] { ex.Message };
}
}
}
SvcTrace.DiagCsv.TraceEvent(TraceEventType.Information, 0, string.Empty, "WriteSecured exit Id =", request.ConnectionValidator.ConnectionId.ToString());
return writeSecuredResponse;
}
public virtual ArchestrAServices.ASBIDataV2Contract.WriteConfirmedResponse WriteConfirmed(ArchestrAServices.ASBIDataV2Contract.WriteConfirmedRequest request)
{
SvcTrace.DiagCsv.TraceEvent(TraceEventType.Information, 0, string.Empty, "WriteConfirmed entry Id =", request.ConnectionValidator.ConnectionId.ToString());
ArchestrAServices.ASBIDataV2Contract.WriteConfirmedResponse writeConfirmedResponse = new ArchestrAServices.ASBIDataV2Contract.WriteConfirmedResponse();
writeConfirmedResponse.Result = ResultFactory.MakeResult(EnumASBFactory.ArchestrAErrorToInt(ArchestrAError.InvalidConnectionId));
SysAuthServiceAuthentication serviceAuthenticator = SysAuthenticatorServiceCache.GetServiceAuthenticator(request.ConnectionValidator.ConnectionId);
if (serviceAuthenticator != null && serviceAuthenticator.ValidRequest(request))
{
bool flag = false;
implementationLock.EnterReadLock();
ConnectionContext value;
try
{
flag = m_Implementations.TryGetValue(request.ConnectionValidator.ConnectionId, out value);
}
finally
{
implementationLock.ExitReadLock();
}
if (flag)
{
value.ConnectionKeepaliveTimer.Change(KeepaliveTimeout, -1);
ConnectionId id = new ConnectionId
{
Id = serviceAuthenticator.connectionID
};
IDataV2toV1 connectionImplementation = value.ConnectionImplementation;
try
{
if (connectionImplementation.Settings != null)
{
int setting = connectionImplementation.Settings.GetSetting("ArrayBase", 0);
if (setting != 0)
{
request.Value.ArrayElementIndex += setting;
}
}
writeConfirmedResponse.Result = connectionImplementation.WriteConfirmed(out var ValueReceived, out var WriteToken, id, request.Item.ToV1ItemIdentity(), request.Value.ToMirroredV2WriteValue(), request.User.ToV1UserToken(), request.Supervisor.ToV1UserToken());
if (connectionImplementation.Settings != null)
{
int setting2 = connectionImplementation.Settings.GetSetting("ArrayBase", 0);
if (setting2 != 0)
{
ValueReceived.ArrayElementIndex -= setting2;
}
}
writeConfirmedResponse.ValueReceived = ValueReceived.ToTrueV2WriteValue();
writeConfirmedResponse.WriteToken = WriteToken;
}
catch (Exception ex)
{
SvcTrace.DiagControl.TraceEvent(TraceEventType.Warning, 0, "WriteConfirmed caught exception from implementation for ConnectionId {0}: {1}", request.ConnectionValidator.ConnectionId, ex.Message);
if (ex.InnerException != null)
{
SvcTrace.DiagControl.TraceEvent(TraceEventType.Warning, 0, " {0}", ex.InnerException.Message);
}
writeConfirmedResponse.Result = ResultFactory.MakeResult(EnumASBFactory.ArchestrAErrorToInt(ArchestrAError.OperationFailed));
writeConfirmedResponse.Result.ErrorMessages = new string[1] { ex.Message };
}
}
}
SvcTrace.DiagCsv.TraceEvent(TraceEventType.Information, 0, string.Empty, "WriteConfirmed exit Id =", request.ConnectionValidator.ConnectionId.ToString());
return writeConfirmedResponse;
}
public virtual ArchestrAServices.ASBIDataV2Contract.ConfirmWriteResponse ConfirmWrite(ArchestrAServices.ASBIDataV2Contract.ConfirmWriteRequest request)
{
SvcTrace.DiagCsv.TraceEvent(TraceEventType.Information, 0, string.Empty, "ConfirmWrite entry Id =", request.ConnectionValidator.ConnectionId.ToString());
ArchestrAServices.ASBIDataV2Contract.ConfirmWriteResponse confirmWriteResponse = new ArchestrAServices.ASBIDataV2Contract.ConfirmWriteResponse();
confirmWriteResponse.Result = ResultFactory.MakeResult(EnumASBFactory.ArchestrAErrorToInt(ArchestrAError.InvalidConnectionId));
SysAuthServiceAuthentication serviceAuthenticator = SysAuthenticatorServiceCache.GetServiceAuthenticator(request.ConnectionValidator.ConnectionId);
if (serviceAuthenticator != null && serviceAuthenticator.ValidRequest(request))
{
bool flag = false;
implementationLock.EnterReadLock();
ConnectionContext value;
try
{
flag = m_Implementations.TryGetValue(request.ConnectionValidator.ConnectionId, out value);
}
finally
{
implementationLock.ExitReadLock();
}
if (flag)
{
value.ConnectionKeepaliveTimer.Change(KeepaliveTimeout, -1);
ConnectionId id = new ConnectionId
{
Id = serviceAuthenticator.connectionID
};
IDataV2toV1 connectionImplementation = value.ConnectionImplementation;
try
{
if (connectionImplementation.Settings != null)
{
int setting = connectionImplementation.Settings.GetSetting("ArrayBase", 0);
if (setting != 0)
{
request.Value.ArrayElementIndex += setting;
}
}
confirmWriteResponse.Result = connectionImplementation.ConfirmWrite(id, request.Item.ToV1ItemIdentity(), request.WriteToken, request.Value.ToMirroredV2WriteValue(), request.User.ToV1UserToken(), request.Supervisor.ToV1UserToken(), request.WriteHandle);
}
catch (Exception ex)
{
SvcTrace.DiagControl.TraceEvent(TraceEventType.Warning, 0, "ConfirmWrite caught exception from implementation for ConnectionId {0}: {1}", request.ConnectionValidator.ConnectionId, ex.Message);
if (ex.InnerException != null)
{
SvcTrace.DiagControl.TraceEvent(TraceEventType.Warning, 0, " {0}", ex.InnerException.Message);
}
confirmWriteResponse.Result = ResultFactory.MakeResult(EnumASBFactory.ArchestrAErrorToInt(ArchestrAError.OperationFailed));
confirmWriteResponse.Result.ErrorMessages = new string[1] { ex.Message };
}
}
}
SvcTrace.DiagCsv.TraceEvent(TraceEventType.Information, 0, string.Empty, "ConfirmWrite exit Id =", request.ConnectionValidator.ConnectionId.ToString());
return confirmWriteResponse;
}
public virtual ArchestrAServices.ASBIDataV2Contract.PublishWriteCompleteResponse PublishWriteComplete(ArchestrAServices.ASBIDataV2Contract.PublishWriteCompleteRequest request)
{
SvcTrace.DiagCsv.TraceEvent(TraceEventType.Information, 0, string.Empty, "PublishWriteComplete entry Id =", request.ConnectionValidator.ConnectionId.ToString());
ArchestrAServices.ASBIDataV2Contract.PublishWriteCompleteResponse publishWriteCompleteResponse = new ArchestrAServices.ASBIDataV2Contract.PublishWriteCompleteResponse();
publishWriteCompleteResponse.Result = ResultFactory.MakeResult(EnumASBFactory.ArchestrAErrorToInt(ArchestrAError.InvalidConnectionId));
SysAuthServiceAuthentication serviceAuthenticator = SysAuthenticatorServiceCache.GetServiceAuthenticator(request.ConnectionValidator.ConnectionId);
if (serviceAuthenticator != null && serviceAuthenticator.ValidRequest(request))
{
bool flag = false;
implementationLock.EnterReadLock();
ConnectionContext value;
try
{
flag = m_Implementations.TryGetValue(request.ConnectionValidator.ConnectionId, out value);
}
finally
{
implementationLock.ExitReadLock();
}
if (flag)
{
value.ConnectionKeepaliveTimer.Change(KeepaliveTimeout, -1);
ConnectionId id = new ConnectionId
{
Id = serviceAuthenticator.connectionID
};
IDataV2toV1 connectionImplementation = value.ConnectionImplementation;
try
{
publishWriteCompleteResponse.CompleteWrites = null;
publishWriteCompleteResponse.Result = connectionImplementation.PublishWriteComplete(out var CompleteWrites, id);
if (CompleteWrites != null)
{
publishWriteCompleteResponse.CompleteWrites = CompleteWrites.ToV2ItemWriteCompleteArray();
}
}
catch (Exception ex)
{
SvcTrace.DiagControl.TraceEvent(TraceEventType.Warning, 0, "PublishWriteComplete caught exception from implementation for ConnectionId {0}: {1}", request.ConnectionValidator.ConnectionId, ex.Message);
if (ex.InnerException != null)
{
SvcTrace.DiagControl.TraceEvent(TraceEventType.Warning, 0, " {0}", ex.InnerException.Message);
}
publishWriteCompleteResponse.Result = ResultFactory.MakeResult(EnumASBFactory.ArchestrAErrorToInt(ArchestrAError.OperationFailed));
publishWriteCompleteResponse.Result.ErrorMessages = new string[1] { ex.Message };
}
}
}
SvcTrace.DiagCsv.TraceEvent(TraceEventType.Information, 0, string.Empty, "PublishWriteComplete exit Id =", request.ConnectionValidator.ConnectionId.ToString());
return publishWriteCompleteResponse;
}
public virtual ArchestrAServices.ASBIDataV2Contract.CreateSubscriptionResponse CreateSubscription(ArchestrAServices.ASBIDataV2Contract.CreateSubscriptionRequest request)
{
SvcTrace.DiagCsv.TraceEvent(TraceEventType.Information, 0, string.Empty, "CreateSubscription entry Id =", request.ConnectionValidator.ConnectionId.ToString());
ArchestrAServices.ASBIDataV2Contract.CreateSubscriptionResponse createSubscriptionResponse = new ArchestrAServices.ASBIDataV2Contract.CreateSubscriptionResponse();
createSubscriptionResponse.Result = ResultFactory.MakeResult(EnumASBFactory.ArchestrAErrorToInt(ArchestrAError.InvalidConnectionId));
SysAuthServiceAuthentication serviceAuthenticator = SysAuthenticatorServiceCache.GetServiceAuthenticator(request.ConnectionValidator.ConnectionId);
if (serviceAuthenticator != null)
{
SvcTrace.DiagDiagnostics.TraceEvent(TraceEventType.Information, 0, "CreateSubscription found authenticator for Connection Id {0}", request.ConnectionValidator.ConnectionId.ToString());
}
if (serviceAuthenticator != null && serviceAuthenticator.ValidRequest(request))
{
SvcTrace.DiagDiagnostics.TraceEvent(TraceEventType.Information, 0, "CreateSubscription validated request, passing to service");
bool flag = false;
implementationLock.EnterReadLock();
ConnectionContext value;
try
{
flag = m_Implementations.TryGetValue(request.ConnectionValidator.ConnectionId, out value);
}
finally
{
implementationLock.ExitReadLock();
}
if (flag)
{
value.ConnectionKeepaliveTimer.Change(KeepaliveTimeout, -1);
ConnectionId id = new ConnectionId
{
Id = serviceAuthenticator.connectionID
};
IDataV2toV1 connectionImplementation = value.ConnectionImplementation;
try
{
createSubscriptionResponse.Result = connectionImplementation.CreateSubscription(out var SubscriptionId, id, request.MaxQueueSize, request.SampleInterval);
createSubscriptionResponse.SubscriptionId = SubscriptionId;
}
catch (Exception ex)
{
SvcTrace.DiagControl.TraceEvent(TraceEventType.Warning, 0, "CreateSubscription caught exception from implementation for ConnectionId {0}: {1}", request.ConnectionValidator.ConnectionId, ex.Message);
if (ex.InnerException != null)
{
SvcTrace.DiagControl.TraceEvent(TraceEventType.Warning, 0, " {0}", ex.InnerException.Message);
}
createSubscriptionResponse.Result = ResultFactory.MakeResult(EnumASBFactory.ArchestrAErrorToInt(ArchestrAError.OperationFailed));
createSubscriptionResponse.Result.ErrorMessages = new string[1] { ex.Message };
}
}
}
SvcTrace.DiagCsv.TraceEvent(TraceEventType.Information, 0, string.Empty, "CreateSubscription exit Id =", request.ConnectionValidator.ConnectionId.ToString());
return createSubscriptionResponse;
}
public virtual ArchestrAServices.ASBIDataV2Contract.SetSubscriptionStateResponse SetSubscriptionState(ArchestrAServices.ASBIDataV2Contract.SetSubscriptionStateRequest request)
{
SvcTrace.DiagCsv.TraceEvent(TraceEventType.Information, 0, string.Empty, "SetSubscriptionState entry Id =", request.ConnectionValidator.ConnectionId.ToString());
ArchestrAServices.ASBIDataV2Contract.SetSubscriptionStateResponse setSubscriptionStateResponse = new ArchestrAServices.ASBIDataV2Contract.SetSubscriptionStateResponse();
setSubscriptionStateResponse.Result = ResultFactory.MakeResult(EnumASBFactory.ArchestrAErrorToInt(ArchestrAError.InvalidConnectionId));
SysAuthServiceAuthentication serviceAuthenticator = SysAuthenticatorServiceCache.GetServiceAuthenticator(request.ConnectionValidator.ConnectionId);
if (serviceAuthenticator != null && serviceAuthenticator.ValidRequest(request))
{
bool flag = false;
implementationLock.EnterReadLock();
ConnectionContext value;
try
{
flag = m_Implementations.TryGetValue(request.ConnectionValidator.ConnectionId, out value);
}
finally
{
implementationLock.ExitReadLock();
}
if (flag)
{
value.ConnectionKeepaliveTimer.Change(KeepaliveTimeout, -1);
ConnectionId id = new ConnectionId
{
Id = serviceAuthenticator.connectionID
};
IDataV2toV1 connectionImplementation = value.ConnectionImplementation;
try
{
setSubscriptionStateResponse.Result = connectionImplementation.SetSubscriptionState(id, request.SubscriptionId, request.NewStateProperty.ToV1Variant(), request.StateToChange);
}
catch (Exception ex)
{
SvcTrace.DiagControl.TraceEvent(TraceEventType.Warning, 0, "SetSubscriptionState caught exception from implementation for ConnectionId {0}: {1}", request.ConnectionValidator.ConnectionId, ex.Message);
if (ex.InnerException != null)
{
SvcTrace.DiagControl.TraceEvent(TraceEventType.Warning, 0, " {0}", ex.InnerException.Message);
}
setSubscriptionStateResponse.Result = ResultFactory.MakeResult(EnumASBFactory.ArchestrAErrorToInt(ArchestrAError.OperationFailed));
setSubscriptionStateResponse.Result.ErrorMessages = new string[1] { ex.Message };
}
}
}
SvcTrace.DiagCsv.TraceEvent(TraceEventType.Information, 0, string.Empty, "SetSubscriptionState exit Id =", request.ConnectionValidator.ConnectionId.ToString());
return setSubscriptionStateResponse;
}
public virtual ArchestrAServices.ASBIDataV2Contract.GetSubscriptionStateResponse GetSubscriptionState(ArchestrAServices.ASBIDataV2Contract.GetSubscriptionStateRequest request)
{
SvcTrace.DiagCsv.TraceEvent(TraceEventType.Information, 0, string.Empty, "GetSubscriptionState entry Id =", request.ConnectionValidator.ConnectionId.ToString());
ArchestrAServices.ASBIDataV2Contract.GetSubscriptionStateResponse getSubscriptionStateResponse = new ArchestrAServices.ASBIDataV2Contract.GetSubscriptionStateResponse();
getSubscriptionStateResponse.Result = ResultFactory.MakeResult(EnumASBFactory.ArchestrAErrorToInt(ArchestrAError.InvalidConnectionId));
SysAuthServiceAuthentication serviceAuthenticator = SysAuthenticatorServiceCache.GetServiceAuthenticator(request.ConnectionValidator.ConnectionId);
if (serviceAuthenticator != null && serviceAuthenticator.ValidRequest(request))
{
bool flag = false;
implementationLock.EnterReadLock();
ConnectionContext value;
try
{
flag = m_Implementations.TryGetValue(request.ConnectionValidator.ConnectionId, out value);
}
finally
{
implementationLock.ExitReadLock();
}
if (flag)
{
value.ConnectionKeepaliveTimer.Change(KeepaliveTimeout, -1);
ConnectionId id = new ConnectionId
{
Id = serviceAuthenticator.connectionID
};
IDataV2toV1 connectionImplementation = value.ConnectionImplementation;
try
{
getSubscriptionStateResponse.Result = connectionImplementation.GetSubscriptionState(out var State, id, request.SubscriptionId, request.StateToGet);
getSubscriptionStateResponse.StateProperty = State.ToV2Variant();
}
catch (Exception ex)
{
SvcTrace.DiagControl.TraceEvent(TraceEventType.Warning, 0, "GetSubscriptionState caught exception from implementation for ConnectionId {0}: {1}", request.ConnectionValidator.ConnectionId, ex.Message);
if (ex.InnerException != null)
{
SvcTrace.DiagControl.TraceEvent(TraceEventType.Warning, 0, " {0}", ex.InnerException.Message);
}
getSubscriptionStateResponse.Result = ResultFactory.MakeResult(EnumASBFactory.ArchestrAErrorToInt(ArchestrAError.OperationFailed));
getSubscriptionStateResponse.Result.ErrorMessages = new string[1] { ex.Message };
}
}
}
SvcTrace.DiagCsv.TraceEvent(TraceEventType.Information, 0, string.Empty, "GetSubscriptionState exit Id =", request.ConnectionValidator.ConnectionId.ToString());
return getSubscriptionStateResponse;
}
public virtual ArchestrAServices.ASBIDataV2Contract.DeleteSubscriptionResponse DeleteSubscription(ArchestrAServices.ASBIDataV2Contract.DeleteSubscriptionRequest request)
{
SvcTrace.DiagCsv.TraceEvent(TraceEventType.Information, 0, string.Empty, "DeleteSubscription entry Id =", request.ConnectionValidator.ConnectionId.ToString());
ArchestrAServices.ASBIDataV2Contract.DeleteSubscriptionResponse deleteSubscriptionResponse = new ArchestrAServices.ASBIDataV2Contract.DeleteSubscriptionResponse();
deleteSubscriptionResponse.Result = ResultFactory.MakeResult(EnumASBFactory.ArchestrAErrorToInt(ArchestrAError.InvalidConnectionId));
SysAuthServiceAuthentication serviceAuthenticator = SysAuthenticatorServiceCache.GetServiceAuthenticator(request.ConnectionValidator.ConnectionId);
if (serviceAuthenticator != null && serviceAuthenticator.ValidRequest(request))
{
bool flag = false;
implementationLock.EnterReadLock();
ConnectionContext value;
try
{
flag = m_Implementations.TryGetValue(request.ConnectionValidator.ConnectionId, out value);
}
finally
{
implementationLock.ExitReadLock();
}
if (flag)
{
value.ConnectionKeepaliveTimer.Change(KeepaliveTimeout, -1);
ConnectionId id = new ConnectionId
{
Id = serviceAuthenticator.connectionID
};
IDataV2toV1 connectionImplementation = value.ConnectionImplementation;
try
{
deleteSubscriptionResponse.Result = connectionImplementation.DeleteSubscription(id, request.SubscriptionId);
}
catch (Exception ex)
{
SvcTrace.DiagControl.TraceEvent(TraceEventType.Warning, 0, "DeleteSubscription caught exception from implementation for ConnectionId {0}: {1}", request.ConnectionValidator.ConnectionId, ex.Message);
if (ex.InnerException != null)
{
SvcTrace.DiagControl.TraceEvent(TraceEventType.Warning, 0, " {0}", ex.InnerException.Message);
}
deleteSubscriptionResponse.Result = ResultFactory.MakeResult(EnumASBFactory.ArchestrAErrorToInt(ArchestrAError.OperationFailed));
deleteSubscriptionResponse.Result.ErrorMessages = new string[1] { ex.Message };
}
}
}
SvcTrace.DiagCsv.TraceEvent(TraceEventType.Information, 0, string.Empty, "DeleteSubscription exit Id =", request.ConnectionValidator.ConnectionId.ToString());
return deleteSubscriptionResponse;
}
public virtual ArchestrAServices.ASBIDataV2Contract.AddMonitoredItemsResponse AddMonitoredItems(ArchestrAServices.ASBIDataV2Contract.AddMonitoredItemsRequest request)
{
SvcTrace.DiagCsv.TraceEvent(TraceEventType.Information, 0, string.Empty, "AddMonitoredItems entry Id =", request.ConnectionValidator.ConnectionId.ToString());
ArchestrAServices.ASBIDataV2Contract.AddMonitoredItemsResponse addMonitoredItemsResponse = new ArchestrAServices.ASBIDataV2Contract.AddMonitoredItemsResponse();
addMonitoredItemsResponse.Result = ResultFactory.MakeResult(EnumASBFactory.ArchestrAErrorToInt(ArchestrAError.InvalidConnectionId));
SysAuthServiceAuthentication serviceAuthenticator = SysAuthenticatorServiceCache.GetServiceAuthenticator(request.ConnectionValidator.ConnectionId);
if (serviceAuthenticator != null && serviceAuthenticator.ValidRequest(request))
{
bool flag = false;
implementationLock.EnterReadLock();
ConnectionContext value;
try
{
flag = m_Implementations.TryGetValue(request.ConnectionValidator.ConnectionId, out value);
}
finally
{
implementationLock.ExitReadLock();
}
if (flag)
{
value.ConnectionKeepaliveTimer.Change(KeepaliveTimeout, -1);
ConnectionId id = new ConnectionId
{
Id = serviceAuthenticator.connectionID
};
IDataV2toV1 connectionImplementation = value.ConnectionImplementation;
try
{
MonitoredItem[] items = null;
addMonitoredItemsResponse.Status = null;
addMonitoredItemsResponse.ItemCapabilities = null;
if (request.Items != null)
{
items = request.Items.ToV1MonitoredItemArray();
}
addMonitoredItemsResponse.Result = connectionImplementation.AddMonitoredItems(out var Status, out var ItemCapabilities, id, request.SubscriptionId, items, (byte)(request.RequireId ? 1 : 0));
if (Status != null)
{
addMonitoredItemsResponse.Status = Status.ToV2ItemStatusArray();
}
if (ItemCapabilities != null)
{
addMonitoredItemsResponse.ItemCapabilities = ItemCapabilities.ToV2ItemRegistrationArray();
}
}
catch (Exception ex)
{
SvcTrace.DiagControl.TraceEvent(TraceEventType.Warning, 0, "AddMonitoredItems caught exception from implementation for ConnectionId {0}: {1}", request.ConnectionValidator.ConnectionId, ex.Message);
if (ex.InnerException != null)
{
SvcTrace.DiagControl.TraceEvent(TraceEventType.Warning, 0, " {0}", ex.InnerException.Message);
}
addMonitoredItemsResponse.Result = ResultFactory.MakeResult(EnumASBFactory.ArchestrAErrorToInt(ArchestrAError.OperationFailed));
addMonitoredItemsResponse.Result.ErrorMessages = new string[1] { ex.Message };
}
}
}
SvcTrace.DiagCsv.TraceEvent(TraceEventType.Information, 0, string.Empty, "AddMonitoredItems exit Id =", request.ConnectionValidator.ConnectionId.ToString());
return addMonitoredItemsResponse;
}
public virtual ArchestrAServices.ASBIDataV2Contract.DeleteMonitoredItemsResponse DeleteMonitoredItems(ArchestrAServices.ASBIDataV2Contract.DeleteMonitoredItemsRequest request)
{
SvcTrace.DiagCsv.TraceEvent(TraceEventType.Information, 0, string.Empty, "DeleteMonitoredItems entry Id =", request.ConnectionValidator.ConnectionId.ToString());
ArchestrAServices.ASBIDataV2Contract.DeleteMonitoredItemsResponse deleteMonitoredItemsResponse = new ArchestrAServices.ASBIDataV2Contract.DeleteMonitoredItemsResponse();
deleteMonitoredItemsResponse.Result = ResultFactory.MakeResult(EnumASBFactory.ArchestrAErrorToInt(ArchestrAError.InvalidConnectionId));
SysAuthServiceAuthentication serviceAuthenticator = SysAuthenticatorServiceCache.GetServiceAuthenticator(request.ConnectionValidator.ConnectionId);
if (serviceAuthenticator != null && serviceAuthenticator.ValidRequest(request))
{
bool flag = false;
implementationLock.EnterReadLock();
ConnectionContext value;
try
{
flag = m_Implementations.TryGetValue(request.ConnectionValidator.ConnectionId, out value);
}
finally
{
implementationLock.ExitReadLock();
}
if (flag)
{
value.ConnectionKeepaliveTimer.Change(KeepaliveTimeout, -1);
ConnectionId id = new ConnectionId
{
Id = serviceAuthenticator.connectionID
};
IDataV2toV1 connectionImplementation = value.ConnectionImplementation;
try
{
MonitoredItem[] items = null;
deleteMonitoredItemsResponse.Status = null;
if (request.Items != null)
{
items = request.Items.ToV1MonitoredItemArray();
}
deleteMonitoredItemsResponse.Result = connectionImplementation.DeleteMonitoredItems(out var Status, id, request.SubscriptionId, items);
if (Status != null)
{
deleteMonitoredItemsResponse.Status = Status.ToV2ItemStatusArray();
}
}
catch (Exception ex)
{
SvcTrace.DiagControl.TraceEvent(TraceEventType.Warning, 0, "DeleteMonitoredItems caught exception from implementation for ConnectionId {0}: {1}", request.ConnectionValidator.ConnectionId, ex.Message);
if (ex.InnerException != null)
{
SvcTrace.DiagControl.TraceEvent(TraceEventType.Warning, 0, " {0}", ex.InnerException.Message);
}
deleteMonitoredItemsResponse.Result = ResultFactory.MakeResult(EnumASBFactory.ArchestrAErrorToInt(ArchestrAError.OperationFailed));
deleteMonitoredItemsResponse.Result.ErrorMessages = new string[1] { ex.Message };
}
}
}
SvcTrace.DiagCsv.TraceEvent(TraceEventType.Information, 0, string.Empty, "DeleteMonitoredItems exit Id =", request.ConnectionValidator.ConnectionId.ToString());
return deleteMonitoredItemsResponse;
}
public virtual ArchestrAServices.ASBIDataV2Contract.GetMonitoredItemsResponse GetMonitoredItems(ArchestrAServices.ASBIDataV2Contract.GetMonitoredItemsRequest request)
{
SvcTrace.DiagCsv.TraceEvent(TraceEventType.Information, 0, string.Empty, "GetMonitoredItems entry Id =", request.ConnectionValidator.ConnectionId.ToString());
ArchestrAServices.ASBIDataV2Contract.GetMonitoredItemsResponse getMonitoredItemsResponse = new ArchestrAServices.ASBIDataV2Contract.GetMonitoredItemsResponse();
getMonitoredItemsResponse.Result = ResultFactory.MakeResult(EnumASBFactory.ArchestrAErrorToInt(ArchestrAError.InvalidConnectionId));
SysAuthServiceAuthentication serviceAuthenticator = SysAuthenticatorServiceCache.GetServiceAuthenticator(request.ConnectionValidator.ConnectionId);
if (serviceAuthenticator != null && serviceAuthenticator.ValidRequest(request))
{
bool flag = false;
implementationLock.EnterReadLock();
ConnectionContext value;
try
{
flag = m_Implementations.TryGetValue(request.ConnectionValidator.ConnectionId, out value);
}
finally
{
implementationLock.ExitReadLock();
}
if (flag)
{
value.ConnectionKeepaliveTimer.Change(KeepaliveTimeout, -1);
ConnectionId id = new ConnectionId
{
Id = serviceAuthenticator.connectionID
};
IDataV2toV1 connectionImplementation = value.ConnectionImplementation;
try
{
getMonitoredItemsResponse.Items = null;
getMonitoredItemsResponse.Result = connectionImplementation.GetMonitoredItems(out var Items, id, request.SubscriptionId);
if (Items != null)
{
getMonitoredItemsResponse.Items = Items.ToV2MonitoredItemArray();
}
}
catch (Exception ex)
{
SvcTrace.DiagControl.TraceEvent(TraceEventType.Warning, 0, "GetMonitoredItems caught exception from implementation for ConnectionId {0}: {1}", request.ConnectionValidator.ConnectionId, ex.Message);
if (ex.InnerException != null)
{
SvcTrace.DiagControl.TraceEvent(TraceEventType.Warning, 0, " {0}", ex.InnerException.Message);
}
getMonitoredItemsResponse.Result = ResultFactory.MakeResult(EnumASBFactory.ArchestrAErrorToInt(ArchestrAError.OperationFailed));
getMonitoredItemsResponse.Result.ErrorMessages = new string[1] { ex.Message };
}
}
}
SvcTrace.DiagCsv.TraceEvent(TraceEventType.Information, 0, string.Empty, "GetMonitoredItems exit Id =", request.ConnectionValidator.ConnectionId.ToString());
return getMonitoredItemsResponse;
}
public virtual ArchestrAServices.ASBIDataV2Contract.PublishResponse Publish(ArchestrAServices.ASBIDataV2Contract.PublishRequest request)
{
SvcTrace.DiagCsv.TraceEvent(TraceEventType.Information, 0, string.Empty, "Publish entry Id =", request.ConnectionValidator.ConnectionId.ToString());
ArchestrAServices.ASBIDataV2Contract.PublishResponse publishResponse = new ArchestrAServices.ASBIDataV2Contract.PublishResponse();
publishResponse.Result = ResultFactory.MakeResult(EnumASBFactory.ArchestrAErrorToInt(ArchestrAError.InvalidConnectionId));
SysAuthServiceAuthentication serviceAuthenticator = SysAuthenticatorServiceCache.GetServiceAuthenticator(request.ConnectionValidator.ConnectionId);
if (serviceAuthenticator != null && serviceAuthenticator.ValidRequest(request))
{
SvcTrace.DiagDiagnostics.TraceEvent(TraceEventType.Information, 0, "Publish validated request");
bool flag = false;
implementationLock.EnterReadLock();
ConnectionContext value;
try
{
flag = m_Implementations.TryGetValue(request.ConnectionValidator.ConnectionId, out value);
}
finally
{
implementationLock.ExitReadLock();
}
if (flag)
{
value.ConnectionKeepaliveTimer.Change(KeepaliveTimeout, -1);
ConnectionId id = new ConnectionId
{
Id = serviceAuthenticator.connectionID
};
IDataV2toV1 connectionImplementation = value.ConnectionImplementation;
try
{
publishResponse.Status = null;
publishResponse.Values = null;
publishResponse.Result = connectionImplementation.Publish(out var Status, out var Values, id, request.SubscriptionId);
if (Status != null)
{
publishResponse.Status = Status.ToV2ItemStatusArray();
}
if (Values != null)
{
publishResponse.Values = Values.ToV2MonitoredItemValueArray();
}
SvcTrace.DiagDiagnostics.TraceEvent(TraceEventType.Information, 0, "Publish found implementation, called user code with error {0}, {1} Statuses, {2} Values", publishResponse.Result.ErrorCode, (Status != null) ? Status.Length : 0, (Values != null) ? Values.Length : 0);
}
catch (Exception ex)
{
SvcTrace.DiagControl.TraceEvent(TraceEventType.Warning, 0, "Publish caught exception from implementation for ConnectionId {0}: {1}", request.ConnectionValidator.ConnectionId, ex.Message);
if (ex.InnerException != null)
{
SvcTrace.DiagControl.TraceEvent(TraceEventType.Warning, 0, " {0}", ex.InnerException.Message);
}
publishResponse.Result = ResultFactory.MakeResult(EnumASBFactory.ArchestrAErrorToInt(ArchestrAError.OperationFailed));
publishResponse.Result.ErrorMessages = new string[1] { ex.Message };
}
}
else
{
SvcTrace.DiagException.TraceEvent(TraceEventType.Warning, 0, "Publish could not find implementation for ConnectionId {0}", request.ConnectionValidator.ConnectionId);
}
}
else
{
SvcTrace.DiagException.TraceEvent(TraceEventType.Warning, 0, "Publish did not validate request for ConnectionId {0}", request.ConnectionValidator.ConnectionId);
}
SvcTrace.DiagCsv.TraceEvent(TraceEventType.Information, 0, string.Empty, "Publish exit Id =", request.ConnectionValidator.ConnectionId.ToString());
return publishResponse;
}
public virtual ArchestrAServices.ASBIDataV2Contract.RegisterItemsResponse RegisterItems(ArchestrAServices.ASBIDataV2Contract.RegisterItemsRequest request)
{
SvcTrace.DiagCsv.TraceEvent(TraceEventType.Information, 0, string.Empty, "RegisterItems entry Id =", request.ConnectionValidator.ConnectionId.ToString());
ArchestrAServices.ASBIDataV2Contract.RegisterItemsResponse registerItemsResponse = new ArchestrAServices.ASBIDataV2Contract.RegisterItemsResponse();
registerItemsResponse.Result = ResultFactory.MakeResult(EnumASBFactory.ArchestrAErrorToInt(ArchestrAError.InvalidConnectionId));
SysAuthServiceAuthentication serviceAuthenticator = SysAuthenticatorServiceCache.GetServiceAuthenticator(request.ConnectionValidator.ConnectionId);
if (serviceAuthenticator != null)
{
SvcTrace.DiagDiagnostics.TraceEvent(TraceEventType.Information, 0, "RegisterItems found authenticator from connection Id");
}
if (serviceAuthenticator != null && serviceAuthenticator.ValidRequest(request))
{
SvcTrace.DiagDiagnostics.TraceEvent(TraceEventType.Information, 0, "RegisterItems authenticator validated request message");
bool flag = false;
implementationLock.EnterReadLock();
ConnectionContext value;
try
{
flag = m_Implementations.TryGetValue(request.ConnectionValidator.ConnectionId, out value);
}
finally
{
implementationLock.ExitReadLock();
}
if (flag)
{
value.ConnectionKeepaliveTimer.Change(KeepaliveTimeout, -1);
ConnectionId id = new ConnectionId
{
Id = serviceAuthenticator.connectionID
};
IDataV2toV1 connectionImplementation = value.ConnectionImplementation;
try
{
SvcTrace.DiagDiagnostics.TraceEvent(TraceEventType.Information, 0, "RegisterItems calling implementation");
ItemIdentity[] items = null;
if (request.Items != null)
{
items = request.Items.ToV1ItemIdentityArray();
}
registerItemsResponse.Result = connectionImplementation.RegisterItems(out var Status, out var ItemCapabilities, id, items, (byte)(request.RequireId ? 1 : 0), (byte)(request.RegisterOnly ? 1 : 0));
if (Status != null)
{
registerItemsResponse.Status = Status.ToV2ItemStatusArray();
}
else
{
registerItemsResponse.Status = null;
}
if (ItemCapabilities != null)
{
registerItemsResponse.ItemCapabilities = ItemCapabilities.ToV2ItemRegistrationArray();
}
else
{
registerItemsResponse.ItemCapabilities = null;
}
}
catch (Exception ex)
{
SvcTrace.DiagControl.TraceEvent(TraceEventType.Warning, 0, "RegisterItems caught exception from implementation for ConnectionId {0}: {1}", request.ConnectionValidator.ConnectionId, ex.Message);
if (ex.InnerException != null)
{
SvcTrace.DiagControl.TraceEvent(TraceEventType.Warning, 0, " {0}", ex.InnerException.Message);
}
registerItemsResponse.Result = ResultFactory.MakeResult(EnumASBFactory.ArchestrAErrorToInt(ArchestrAError.OperationFailed));
registerItemsResponse.Result.ErrorMessages = new string[1] { ex.Message };
}
}
}
SvcTrace.DiagCsv.TraceEvent(TraceEventType.Information, 0, string.Empty, "RegisterItems exit Id =", request.ConnectionValidator.ConnectionId.ToString());
return registerItemsResponse;
}
public virtual ArchestrAServices.ASBIDataV2Contract.UnregisterItemsResponse UnregisterItems(ArchestrAServices.ASBIDataV2Contract.UnregisterItemsRequest request)
{
SvcTrace.DiagCsv.TraceEvent(TraceEventType.Information, 0, string.Empty, "UnregisterItems entry Id =", request.ConnectionValidator.ConnectionId.ToString());
ArchestrAServices.ASBIDataV2Contract.UnregisterItemsResponse unregisterItemsResponse = new ArchestrAServices.ASBIDataV2Contract.UnregisterItemsResponse();
unregisterItemsResponse.Result = ResultFactory.MakeResult(EnumASBFactory.ArchestrAErrorToInt(ArchestrAError.InvalidConnectionId));
SysAuthServiceAuthentication serviceAuthenticator = SysAuthenticatorServiceCache.GetServiceAuthenticator(request.ConnectionValidator.ConnectionId);
if (serviceAuthenticator != null && serviceAuthenticator.ValidRequest(request))
{
bool flag = false;
implementationLock.EnterReadLock();
ConnectionContext value;
try
{
flag = m_Implementations.TryGetValue(request.ConnectionValidator.ConnectionId, out value);
}
finally
{
implementationLock.ExitReadLock();
}
if (flag)
{
value.ConnectionKeepaliveTimer.Change(KeepaliveTimeout, -1);
ConnectionId id = new ConnectionId
{
Id = serviceAuthenticator.connectionID
};
IDataV2toV1 connectionImplementation = value.ConnectionImplementation;
try
{
ItemIdentity[] items = null;
if (request.Items != null)
{
items = request.Items.ToV1ItemIdentityArray();
}
unregisterItemsResponse.Result = connectionImplementation.UnregisterItems(out var Status, id, items);
unregisterItemsResponse.Status = Status.ToV2ItemStatusArray();
}
catch (Exception ex)
{
SvcTrace.DiagControl.TraceEvent(TraceEventType.Warning, 0, "UnregisterItems caught exception from implementation for ConnectionId {0}: {1}", request.ConnectionValidator.ConnectionId, ex.Message);
if (ex.InnerException != null)
{
SvcTrace.DiagControl.TraceEvent(TraceEventType.Warning, 0, " {0}", ex.InnerException.Message);
}
unregisterItemsResponse.Result = ResultFactory.MakeResult(EnumASBFactory.ArchestrAErrorToInt(ArchestrAError.OperationFailed));
unregisterItemsResponse.Result.ErrorMessages = new string[1] { ex.Message };
}
}
}
SvcTrace.DiagCsv.TraceEvent(TraceEventType.Information, 0, string.Empty, "UnregisterItems exit Id =", request.ConnectionValidator.ConnectionId.ToString());
return unregisterItemsResponse;
}
public bool ForceDisconnect()
{
return true;
}
}
Reference in New Issue View Git Blame Copy Permalink