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); }