private void OnChannelRegistered(object sender, ChannelRegistrationEventArgs e)
{
_channel = e.Channel;
_channel.StatusChanged += (a, f) => {
if (Status == AgentStatus.Starting && f.Status == ChannelStatus.Online)
{
Status = AgentStatus.Online;
}
else if (Status == AgentStatus.Online && f.Status == ChannelStatus.Offline)
{
Status = AgentStatus.Offline;
}
ChannelStatus = f.Status;
};
if (e.Success)
{
_channel.Status = ChannelStatus.Online;
}
else
{
MsgLogger.WriteError($"{GetType().Name} - OnChannelRegistered", $"channel id='{_channel.Id}' registration failed!");
}
}
public bool RegisterParameter(string source, ushort index, byte subIndex, ParameterUpdatePriority priority)
{
bool result = false;
var objectDictionary = _device?.ObjectDictionary;
var parameter = objectDictionary?.SearchParameter(index, subIndex);
if (parameter != null)
{
var registeredParameter = new RegisteredParameter {
Source = source, Parameter = parameter, Priority = priority
};
MsgLogger.WriteFlow($"{GetType().Name} - RegisterParameter", $"register parameter index = 0x{index:X4}, subindex = 0x{subIndex:X4}, add to queue ...");
lock (RegisterParametersQueueLock)
{
_registerParametersQueue.Add(registeredParameter);
result = true;
}
MsgLogger.WriteFlow($"{GetType().Name} - RegisterParameter", $"register parameter index = 0x{index:X4}, subindex = 0x{subIndex:X4}, added to queue");
}
else
{
MsgLogger.WriteError($"{GetType().Name} - RegisterParameter", $"parameter index = 0x{index:X4}, subindex = 0x{subIndex:X4}, not found");
}
return(result);
}
private async void OnDeviceDetected(object sender, ScannerDeviceStatusChangedEventArgs e)
{
var device = e.Device;
if (device is EposDevice eposDevice)
{
AddDevice(device);
RegisterDeviceEvents(eposDevice);
MsgLogger.WriteDebug($"{GetType().Name} - method", $"try to connect to device {eposDevice.Family}");
if (!await ConnectDevice(eposDevice))
{
MsgLogger.WriteError($"{GetType().Name} - OnDeviceDetected", $"connect to device {eposDevice.Family} failed!");
UnregisterDeviceEvents(eposDevice);
}
else
{
MsgLogger.WriteDebug($"{GetType().Name} - method", $"connect to device {eposDevice.Family} successful");
}
}
else
{
MsgLogger.WriteLine($"device: {device.Family} not supported!");
}
}
public double ToDouble()
{
double result = double.NaN;
try
{
var byteArray = Convert.FromBase64String(Value);
if (DataType != null)
{
if (TypeCode.Double == DataType.Type)
{
result = BitConverter.ToInt32(byteArray, 0);
}
else
{
MsgLogger.WriteError($"{GetType().Name} - ToDouble", $"Cannot convert base64 value = {Value}, to data type {DataType.Type}!");
}
}
else
{
MsgLogger.WriteWarning($"{GetType().Name} - ToDouble", $"Cannot convert base64 value = {Value}, unknown data type!");
result = BitConverter.ToInt32(byteArray, 0);
}
}
catch (Exception e)
{
MsgLogger.Exception($"{GetType().Name} - ToDouble", e);
}
return(result);
}
public bool Run()
{
bool result = false;
try
{
if (File.Exists(InputFileName))
{
MsgLogger.WriteLine($"Read input file '{InputFileName}'");
if (ReadInput(out var base64EncodedInput))
{
result = GenerateOutput(base64EncodedInput);
}
else
{
MsgLogger.WriteError($"{GetType().Name} - Run", $"Reading file '{InputFileName}' failed!");
}
}
else
{
MsgLogger.WriteError($"{GetType().Name} - Run", $"Specified file '{InputFileName}' doesn't exist!");
}
}
catch (Exception e)
{
MsgLogger.Exception($"{GetType().Name} - Run", e);
}
return(result);
}
public override async Task <bool> SetCommandStatus(ExecuteCommandStatus status)
{
bool result = false;
if (ConnectionManager != null && status != null)
{
var wsChannelId = GetActiveChannelName(status.ChannelId, status.NodeId);
if (!string.IsNullOrEmpty(wsChannelId))
{
MsgLogger.WriteLine($"set (WS) command='{status.CommandName}' status='{status.Status}' for device with nodeid={status.NodeId}");
if (await ConnectionManager.Send(wsChannelId, _userIdentity, status))
{
result = true;
}
else
{
MsgLogger.WriteError($"{GetType().Name} - SetCommandStatus",
$"set (WS) command='{status.CommandName}' status='{status.Status}' for device with nodeid={status.NodeId} failed");
}
}
}
return(result);
}
public XddUnit GetActiveUnit()
{
XddUnit result = null;
if (Units.Count == 1)
{
result = Units[0];
}
else
{
foreach (var unit in Units)
{
string uniqueIdRef = unit.GetConfigurationParameterIdRef();
var parameter = _parameterList.FindParameter(uniqueIdRef) as Parameter;
if (unit.HasMatchingValue(parameter))
{
result = unit;
break;
}
else
{
MsgLogger.WriteError($"{GetType().Name} - GetActiveUnit", $"GetActiveUnit - Parameter '{uniqueIdRef}' not found!");
}
}
}
return(result);
}
/// <summary>
/// Stop
/// </summary>
/// <returns></returns>
public virtual bool Stop()
{
const int minWaitTimeMs = 10;
bool result = false;
int maxWaitTime = (int)TimeSpan.FromSeconds(60).TotalMilliseconds;
if (IsRunning && ShouldRun())
{
lock (_lock)
{
RequestStop();
var timeout = new Stopwatch();
timeout.Start();
while (_running.WaitOne(minWaitTimeMs) && timeout.ElapsedMilliseconds < maxWaitTime)
{
Thread.Sleep(minWaitTimeMs);
}
if (timeout.ElapsedMilliseconds > maxWaitTime)
{
MsgLogger.WriteError($"{GetType().Name}::Stop", "stop thread timeout");
}
else
{
result = true;
}
}
}
return(result);
}
internal async Task <bool> CloseOutputAsync(WebSocketCloseStatus status, string description, CancellationToken token)
{
bool result = false;
try
{
if (_socket.State == WebSocketState.Open || _socket.State == WebSocketState.CloseSent)
{
await _socket.CloseOutputAsync(status, description, token);
result = true;
}
else
{
MsgLogger.WriteError($"{GetType().Name} - CloseOutputAsync", $"wrong socket state = {_socket.State}");
}
}
catch (Exception e)
{
if (e.GetType() != typeof(TaskCanceledException))
{
MsgLogger.Exception($"{GetType().Name} - CloseOutputAsync", e);
}
else
{
MsgLogger.WriteDebug($"{GetType().Name} - CloseOutputAsync", "close requested");
}
}
return(result);
}
private bool GenerateOutput(string base64EncodedInput)
{
bool result = false;
if (FileHelper.ChangeFileNameExtension(InputFileName, "md5", out var md5Path))
{
try
{
string hashCode = CryptHelpers.ToMD5(base64EncodedInput);
OutputHashCode = hashCode;
File.WriteAllText(md5Path, hashCode);
OutputFileName = md5Path;
}
catch (Exception e)
{
MsgLogger.Exception($"{GetType().Name} - GenerateOutput", e);
}
result = true;
}
else
{
MsgLogger.WriteError($"{GetType().Name} - Run", $"Cannot change file '{InputFileName}' extension!");
}
return(result);
}
private string GetRsdxXmlDownloadName(string rsdxXmlContent)
{
string result = string.Empty;
try
{
var rsdxXmlDoc = new XmlDocument();
rsdxXmlDoc.LoadXml(rsdxXmlContent);
var downloadNameNode = rsdxXmlDoc.SelectSingleNode("RadioSure/Stations/BaseFile/DownloadName");
if (downloadNameNode != null && !string.IsNullOrEmpty(downloadNameNode.InnerXml))
{
result = downloadNameNode.InnerXml;
}
else
{
MsgLogger.WriteError($"{GetType().Name} - GetRsdxXmlDownloadName", "download name node not found!");
}
}
catch (Exception e)
{
MsgLogger.Exception($"{GetType().Name} - GetRsdxXmlDownloadName", e);
}
return(result);
}
private async Task <string> DownloadRsdxXml()
{
string result = string.Empty;
try
{
var client = new HttpClient();
var rsdxXmlContent = await client.GetStringAsync(RsdxUrl);
if (!string.IsNullOrEmpty(rsdxXmlContent))
{
result = rsdxXmlContent;
}
else
{
MsgLogger.WriteError($"{GetType().Name} - DownloadRsdxXml", "download content is empty!");
}
}
catch (Exception e)
{
MsgLogger.Exception($"{GetType().Name} - DownloadRsdxXml", e);
}
return(result);
}
protected bool ConnectToChannel()
{
bool result = false;
var t = Task.Run(async() =>
{
if (ConnectionManager != null)
{
MsgLogger.WriteLine($"{GetType().Name} - ConnectToChannel, connect to channel = {WsChannelName}");
if (await ConnectionManager.Connect(WsChannelId, WsChannelName))
{
if (!await SendChannelIdentyficationRequest())
{
MsgLogger.WriteError($"{GetType().Name} - ConnectToChannel", $"send ident request failed, channel = {WsChannelName}");
}
else
{
result = true;
}
}
}
});
t.Wait();
return(result);
}
public async Task <bool> DownloadTool(UserIdentity identity, EltraDevice device)
{
bool result = false;
var deviceToolSet = device?.ToolSet;
if (PurgeToolStorage)
{
if (!PurgeToolFileSystem(device))
{
MsgLogger.WriteError($"{GetType().Name} - DownloadTool", "purge file system failed!");
}
}
if (deviceToolSet != null)
{
foreach (var tool in deviceToolSet.Tools)
{
if (tool.Status == DeviceToolStatus.Enabled)
{
result = await UpdateTool(identity, tool);
if (!result)
{
break;
}
}
}
}
return(result);
}
internal bool StartCounting(int step, int delay)
{
Console.WriteLine($"start counting (node id = {Device.NodeId}), step = {step}, delay = {delay}");
StopCounting();
_countingTask = Task.Run(async() => {
_countingRunning = true;
_counterValue = 0;
do
{
_counterValue = _counterValue + step;
if (!_counterParameter.SetValue(_counterValue))
{
MsgLogger.WriteError($"{GetType().Name} - DummyDeviceCommunication", "set counter parameter value failed!");
}
await Task.Delay(delay);
}while (_countingRunning);
});
return(true);
}
public async Task <bool> Disconnect()
{
bool result = false;
try
{
if (IsConnected)
{
if (!_disconnectTokenSource.IsCancellationRequested)
{
_disconnectTokenSource.Cancel();
}
if (Socket.State == WebSocketState.Open)
{
await Socket.CloseAsync(WebSocketCloseStatus.Empty, "", _cancellationTokenSource.Token);
}
else if (Socket.State == WebSocketState.Closed)
{
MsgLogger.WriteDebug($"{GetType().Name} - Disconnect", $"Disconnect, state = {Socket.State}");
}
if (Socket.State == WebSocketState.Closed)
{
result = true;
}
}
else
{
MsgLogger.WriteDebug($"{GetType().Name} - Disconnect", $"Disconnect, state = {Socket.State}");
}
}
catch (WebSocketException e)
{
MsgLogger.Exception($"{GetType().Name} - Disconnect", e);
HandleBrokenConnection(e.WebSocketErrorCode);
}
catch (Exception e)
{
unchecked
{
if (e.HResult == (int)0x80131620)
{
MsgLogger.WriteError($"{GetType().Name} - Disconnect", "connection failed, reconnect");
Initialize();
}
else
{
MsgLogger.Exception($"{GetType().Name} - Disconnect", e);
}
}
}
return(result);
}
private void InitStateMachine()
{
_controlWordParameter = Vcs.SearchParameter("PARAM_ControlWord") as XddParameter;
_statusWordParameter = Vcs.SearchParameter("PARAM_StatusWord") as XddParameter;
if (!SetExecutionStatus(StatusWordEnums.Waiting))
{
MsgLogger.WriteError($"{GetType().Name} - InitStateMachine", "Set execution state (waiting) failed!");
}
}
/// <summary>
/// RegisterParameterUpdate
/// </summary>
/// <param name="device"></param>
/// <param name="uniqueId"></param>
/// <param name="priority"></param>
/// <param name="waitForResult"></param>
public bool RegisterParameterUpdate(EltraDevice device, string uniqueId, ParameterUpdatePriority priority = ParameterUpdatePriority.Low, bool waitForResult = false)
{
#pragma warning disable 4014
if (!string.IsNullOrEmpty(uniqueId) && device != null && device.SearchParameter(uniqueId) is XddParameter parameterEntry)
{
bool result = false;
if (!ParameterRegistrationCache.IsParameterRegistered(uniqueId, parameterEntry.Index, parameterEntry.SubIndex, out var instanceCount))
{
Task.Run(async() => {
var command = await GetDeviceCommand(device, "RegisterParameterUpdate");
if (command != null)
{
command.SetParameterValue("Index", parameterEntry.Index);
command.SetParameterValue("SubIndex", parameterEntry.SubIndex);
command.SetParameterValue("Priority", (int)priority);
result = await ExecuteCommandAsync(command);
if (!result)
{
instanceCount = ParameterRegistrationCache.RemoveParameter(uniqueId);
MsgLogger.WriteError($"{GetType().Name} - RegisterParameterUpdate", $"parameter could't be registered - '{uniqueId}'");
}
else
{
MsgLogger.WriteDebug($"{GetType().Name} - RegisterParameterUpdate", $"registered parameter '{uniqueId}', instance count = {instanceCount}");
}
}
}).ConfigureAwait(waitForResult);
}
else
{
if (ParameterRegistrationCache.IncreaseCounter(uniqueId, out var registeredParameter))
{
MsgLogger.WriteDebug($"{GetType().Name} - RegisterParameterUpdate", $"register parameter '{uniqueId}', instance count = {registeredParameter.InstanceCount}");
}
else
{
MsgLogger.WriteError($"{GetType().Name} - RegisterParameterUpdate", $"register parameter '{uniqueId}', instance count = {instanceCount}");
}
}
}
else
{
MsgLogger.WriteError($"{GetType().Name} - RegisterParameterUpdate", $"parameter '{uniqueId}' not found");
}
#pragma warning restore 4014
return(true);
}
private void OnChannelRegistered(object sender, ChannelRegistrationEventArgs e)
{
var channel = e.Channel;
if (e.Success)
{
channel.Status = ChannelStatus.Online;
}
else
{
MsgLogger.WriteError($"{GetType().Name} - OnChannelRegistered", $"Channel ({channel.Id}) registration failed!");
}
}
private async void HandleBrokenConnection(WebSocketError errorCode)
{
MsgLogger.WriteError($"{GetType().Name} - HandleBrokenConnection", $"Connection to '{Url}' failed, error code = {errorCode}");
if (errorCode == WebSocketError.ConnectionClosedPrematurely && Socket.State == WebSocketState.Open)
{
MsgLogger.WriteLine("try recover connection ...");
Initialize();
}
await Task.Delay(100);
}
public ulong ToULong()
{
ulong result = ulong.MinValue;
try
{
var byteArray = Convert.FromBase64String(Value);
if (DataType != null)
{
switch (DataType.Type)
{
case TypeCode.Byte:
result = BitConverter.ToChar(byteArray, 0);
break;
case TypeCode.SByte:
result = BitConverter.ToChar(byteArray, 0);
break;
case TypeCode.UInt16:
result = BitConverter.ToUInt16(byteArray, 0);
break;
case TypeCode.UInt32:
result = BitConverter.ToUInt32(byteArray, 0);
break;
case TypeCode.UInt64:
result = BitConverter.ToUInt64(byteArray, 0);
break;
default:
MsgLogger.WriteError($"{GetType().Name} - ToULong", $"Cannot convert base64 value = {Value}, to data type {DataType.Type}!");
break;
}
}
else
{
MsgLogger.WriteWarning($"{GetType().Name} - ToULong", $"Cannot convert base64 value = {Value}, unknown data type!");
result = BitConverter.ToUInt64(byteArray, 0);
}
}
catch (Exception e)
{
MsgLogger.Exception($"{GetType().Name} - ToULong", e);
}
return(result);
}
private static void RunOptionsAndReturnExitCode(MasterOptions opts)
{
var appName = AppDomain.CurrentDomain.FriendlyName;
var settings = new MasterSettings();
var host = settings.Host;
string login = settings.Identity.AuthData.Login;
string password = settings.Identity.AuthData.Password;
if (!string.IsNullOrEmpty(opts.Host))
{
host = opts.Host;
}
if (!string.IsNullOrEmpty(opts.Login))
{
login = opts.Login;
}
if (!string.IsNullOrEmpty(opts.Password))
{
password = opts.Password;
}
var master = new EltraMasterConnector();
master.Host = host;
master.ConnectionSettings = new ConnectionSettings()
{
UpdateInterval = settings.UpdateInterval, Timeout = settings.Timeout
};
var t = Task.Run(async() => {
Console.WriteLine($"Sign-in login={login}, passwd={password}");
var di = new UserIdentity()
{
Login = login, Name = settings.Identity.Name, Password = password, Role = settings.Identity.Role
};
if (await master.SignIn(di, true))
{
if (!master.StartService(appName, new EposDeviceManager(settings)))
{
MsgLogger.WriteError(appName, "starting master service failed!");
}
}
});
t.Wait();
}
/// <summary>
/// UnregisterParameterUpdate
/// </summary>
/// <param name="device"></param>
/// <param name="uniqueId"></param>
/// <param name="priority"></param>
/// <param name="waitForResult"></param>
public bool UnregisterParameterUpdate(EltraDevice device, string uniqueId, ParameterUpdatePriority priority = ParameterUpdatePriority.Low, bool waitForResult = false)
{
if (device != null && !string.IsNullOrEmpty(uniqueId) && device.SearchParameter(uniqueId) is Parameter parameterEntry)
{
bool result = false;
if (ParameterRegistrationCache.CanUnregister(uniqueId, out var registeredParameter))
{
var t = Task.Run(async() =>
{
var command = await GetDeviceCommand(device, "UnregisterParameterUpdate");
if (command != null)
{
command.SetParameterValue("Index", parameterEntry.Index);
command.SetParameterValue("SubIndex", parameterEntry.SubIndex);
command.SetParameterValue("Priority", (int)priority);
result = await ExecuteCommandAsync(command);
if (!result)
{
ParameterRegistrationCache.AddParameter(registeredParameter);
MsgLogger.WriteError($"{GetType().Name} - UnregisterParameterUpdate", $"parameter could't be unregistered - '{uniqueId}'");
}
else
{
MsgLogger.WriteDebug($"{GetType().Name} - UnregisterParameterUpdate", $"unregistered parameter '{uniqueId}'");
}
}
}).ConfigureAwait(waitForResult);
}
else
{
registeredParameter?.Release();
MsgLogger.WriteDebug($"{GetType().Name} - UnregisterParameterUpdate", $"unregister parameter '{uniqueId}', instance count = {registeredParameter?.InstanceCount}");
result = true;
}
}
else
{
MsgLogger.WriteError($"{GetType().Name} - UnregisterParameterUpdate", $"unregister: cannot find registered parameter '{uniqueId}'");
}
return(true);
}
private void OnDeviceDescriptionChanged()
{
if (DeviceDescription != null)
{
if (!CreateObjectDictionary())
{
MsgLogger.WriteError($"{GetType().Name} - OnDeviceDescriptionFileStateChanged", $"create object dictionary failed!");
}
else
{
Name = DeviceDescription?.Profile?.ProfileBody?.DeviceIdentity?.ProductName;
ProductPicture = DeviceDescription?.Profile?.ProfileBody?.DeviceIdentity?.ProductPicture;
}
}
}
private async Task HandleWebSocketException(WebSocketException e, CancellationToken token)
{
var errorCode = e.WebSocketErrorCode;
if (errorCode == WebSocketError.ConnectionClosedPrematurely ||
errorCode == WebSocketError.Faulted ||
errorCode == WebSocketError.InvalidState)
{
MsgLogger.WriteError($"{GetType().Name} - HandleWebSocketException", "socket error, close socket");
await CloseOutputAsync(WebSocketCloseStatus.Empty, string.Empty, token);
Initialize();
}
}
private void OnDeviceDescriptionFileStateChanged(object sender, DeviceDescriptionFileEventArgs e)
{
if (e.State == DeviceDescriptionState.Read)
{
Status = DeviceStatus.DescriptionAvailable;
if (!CreateDeviceDescription(e.DeviceDescriptionFile))
{
MsgLogger.WriteError($"{GetType().Name} - OnDeviceDescriptionFileStateChanged", $"create device description failed!");
}
}
else if (e.State == DeviceDescriptionState.Failed)
{
MsgLogger.WriteError($"{GetType().Name} - OnDeviceDescriptionFileStateChanged", $"device description read failed!, reason = '{e?.Exception?.Message}'");
}
}
protected virtual void OnDeviceRegistrationStateChanged(object sender, RegistrationEventArgs e)
{
var device = e.Device;
if (e.State == RegistrationState.Registered)
{
ParameterControllerAdapter.ParametersUpdated -= OnParametersUpdated;
ParameterControllerAdapter.ParametersUpdated += OnParametersUpdated;
ParameterControllerAdapter.RegisterDevice(device);
}
else if (e.State == RegistrationState.Failed)
{
MsgLogger.WriteError($"{GetType().Name} - OnDeviceRegistrationStateChanged", $"Device ({device.Family}) registration failed!");
}
}
private async Task <bool> ConnectDevice(EposDevice device)
{
bool result = false;
if (CloudAgent != null)
{
device.CloudAgent = CloudAgent;
result = await device.Connect();
}
else
{
MsgLogger.WriteError($"{GetType().Name} - ConnectDevice", $"connection to {device.Family} failed, agent not ready!");
}
return(result);
}
protected override void OnConnectionManagerChanged()
{
var t = Task.Run(async() => {
if (ConnectionManager != null)
{
if (await ConnectionManager.Connect(WsChannelId, WsChannelName))
{
if (!await SendChannelIdentyficationRequest())
{
MsgLogger.WriteError($"{GetType().Name} - OnConnectionManagerChanged", $"send ident request failed, channel = {WsChannelName}");
}
}
}
});
t.Wait();
}
private async Task <bool> UpdateParameterValue(int nodeId, ushort index, byte subIndex, ParameterValue actualValue)
{
bool result = false;
try
{
var parameterUpdate = new ParameterValueUpdate
{
ChannelId = Channel.Id,
NodeId = nodeId,
ParameterValue = actualValue,
Index = index,
SubIndex = subIndex
};
var path = $"api/parameter/value";
var json = parameterUpdate.ToJson();
var response = await Transporter.Put(_identity, Url, path, json);
if (response != null)
{
if (response.StatusCode == HttpStatusCode.OK)
{
MsgLogger.WriteDebug($"{GetType().Name} - UpdateParameterValue", $"Device Node id = {nodeId}, Parameter Index = 0x{index:X4}, Subindex = 0x{subIndex} value successfully written");
result = true;
}
else
{
MsgLogger.WriteError($"{GetType().Name} - UpdateParameterValue", $"Device Node id = {nodeId}, Parameter Index = 0x{index:X4}, Subindex = 0x{subIndex} value write failed, status code = {response.StatusCode}!");
}
}
else
{
MsgLogger.WriteError($"{GetType().Name} - UpdateParameterValue", $"Device Node id = {nodeId}, Parameter Index = 0x{index:X4}, Subindex = 0x{subIndex} value write failed!");
}
}
catch (Exception)
{
result = false;
}
return(result);
}
