internal async Task <bool> CloseAsync(WebSocketCloseStatus status, string description, CancellationToken token) { bool result = false; try { await _sendLock.WaitAsync(); await _socket.CloseAsync(status, description, token); result = true; } catch (Exception e) { if (e.GetType() != typeof(TaskCanceledException)) { MsgLogger.Exception($"{GetType().Name} - CloseAsync", e); } else { MsgLogger.WriteDebug($"{GetType().Name} - CloseAsync", "close requested"); } } finally { _sendLock.Release(); } return(result); }
private bool GetHashCodeFromFile(string filePath, out string hashCode) { bool result = false; hashCode = string.Empty; try { var bytes = File.ReadAllBytes(filePath); if (bytes != null && bytes.Length > 0) { var encodedBytes = Convert.ToBase64String(bytes); hashCode = CryptHelpers.ToMD5(encodedBytes); result = true; } } catch (Exception e) { MsgLogger.Exception($"{GetType().Name}", e); } return(result); }
internal async Task <UserIdentity> CreateAlias(string role) { UserIdentity result = null; try { var query = HttpUtility.ParseQueryString(string.Empty); query["role"] = role; var url = UrlHelper.BuildUrl(Url, "api/user/create-alias", query); var json = await Transporter.Get(_identity, url); if (!string.IsNullOrEmpty(json)) { result = json.TryDeserializeObject <UserIdentity>(); } } catch (Exception e) { MsgLogger.Exception($"{GetType().Name} - CreateAlias", e); } return(result); }
/// <summary> /// Receive /// </summary> /// <param name="uniqueId"></param> /// <param name="shouldRunFunc"></param> /// <returns></returns> public async Task <string> Receive(string uniqueId, Func <bool> shouldRunFunc) { const int executeIntervalWs = 1; string result = string.Empty; try { string msg = string.Empty; do { msg = await Receive(uniqueId); if (shouldRunFunc()) { await Task.Delay(executeIntervalWs); } }while ((msg == "KEEPALIVE" || msg == "ACK") && shouldRunFunc()); result = msg; } catch (Exception e) { MsgLogger.Exception($"{GetType().Name} - Receive", e); } 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); }
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); }
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); }
public static string GetLocalIpAddress() { const string host = "8.8.8.8"; string result = string.Empty; try { using (var socket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, 0)) { socket.Connect(host, 65530); var endPoint = socket.LocalEndPoint as IPEndPoint; if (endPoint != null) { result = endPoint.Address.ToString(); } } } catch (Exception e) { MsgLogger.Exception($"IpHelper - GetLocalIpAddress", e); } return(result); }
private List <string> GetProtocolInterfaceNames(string deviceName, string protocolStackName) { var result = new List <string>(); uint errorCode = 0; int endOfSelection = 0; int startOfSelection = 1; string interfaceName = string.Empty; int selectionResult = 1; try { while (endOfSelection == 0 && selectionResult > 0) { selectionResult = VcsWrapper.Device.VcsGetInterfaceNameSelection(deviceName, protocolStackName, startOfSelection, ref interfaceName, ref endOfSelection, ref errorCode); if (selectionResult > 0) { result.Add(interfaceName); } startOfSelection = 0; } } catch (Exception e) { MsgLogger.Exception($"{GetType().Name} - method", e); } return(result); }
public override async Task <bool> PushCommand(ExecuteCommand execCommand) { bool result = false; try { var device = execCommand?.Command?.Device; if (device != null) { var wsChannelId = GetActiveChannelName(execCommand.SourceChannelId, device.NodeId); if (!string.IsNullOrEmpty(wsChannelId)) { var start = MsgLogger.BeginTimeMeasure(); if (ConnectionManager != null && ConnectionManager.IsConnected(wsChannelId)) { if (await ConnectionManager.Send(wsChannelId, _userIdentity, execCommand)) { result = true; } } MsgLogger.EndTimeMeasure($"{GetType().Name} - PushCommand", start, $"push command='{execCommand.Command.Name}' to device='{device.Family}':0x{device.NodeId}"); } } } catch (Exception e) { MsgLogger.Exception($"{GetType().Name} - PushCommand", e); } return(result); }
public async Task <ParameterValue> GetParameterValue(string channelId, int nodeId, ushort index, byte subIndex) { ParameterValue result = null; try { MsgLogger.WriteLine($"get parameter, index=0x{index:X4}, subindex=0x{subIndex:X4}, device node id={nodeId}"); var query = HttpUtility.ParseQueryString(string.Empty); query["callerId"] = channelId; query["nodeId"] = $"{nodeId}"; query["index"] = $"{index}"; query["subIndex"] = $"{subIndex}"; var url = UrlHelper.BuildUrl(Url, "api/parameter/value", query); var json = await Transporter.Get(_identity, url); var parameterValue = json.TryDeserializeObject <ParameterValue>(); if (parameterValue != null) { result = parameterValue; MsgLogger.WriteLine($"get parameter, index=0x{index:X4}, subindex=0x{subIndex:X4}, device node id={nodeId} - success"); } } catch (Exception e) { MsgLogger.Exception($"{GetType().Name} - GetParameterValue", e); } return(result); }
public bool Register(RegisteredParameter registeredParameter) { bool result = false; MsgLogger.WriteFlow($"{GetType().Name} - Register", $"Register parameter source = '{registeredParameter.Key}', index = {registeredParameter.Parameter.Index:X4}, subindex = {(registeredParameter.Parameter as XddParameter).SubIndex:X4}"); try { lock (RegisteredParametersLock) { if (!_registeredParameters.ContainsKey(registeredParameter.Key)) { result = AddToRegisteredParameters(registeredParameter); } else { result = UpdateParameterRefCount(registeredParameter); } } } catch (Exception e) { MsgLogger.Exception($"{GetType().Name} - Register", e); } MsgLogger.WriteDebug($"{GetType().Name} - Register", $"Register Parameter '{registeredParameter.Key}' - OK"); return(result); }
public async Task <bool> ExecuteCommands() { bool result = true; try { foreach (var deviceNode in SafeDevicesArray) { var executeCommands = await DeviceControllerAdapter.PopCommands(deviceNode, ExecCommandStatus.Waiting); foreach (var executeCommand in executeCommands) { if (!await ExecuteCommand(deviceNode, executeCommand)) { result = false; } } if (result) { result = DeviceControllerAdapter.Good; } } } catch (Exception e) { MsgLogger.Exception($"{GetType().Name} - ExecuteCommands", e); result = false; } return(result); }
private Task SetMuteAsync(bool muteValue) { var result = Task.Run(() => { if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) { try { string muteString = muteValue ? "mute" : "unmute"; string args = $"-D pulse sset Master {muteString}"; var startInfo = new ProcessStartInfo("amixer"); startInfo.WindowStyle = ProcessWindowStyle.Hidden; startInfo.Arguments = args; SetExecutionStatus(StatusWordEnums.PendingExecution); var startResult = Process.Start(startInfo); MsgLogger.WriteFlow($"{GetType().Name} - SetMuteAsync", $"Mute request: {muteString}, result = {startResult!=null}"); SetExecutionStatus(startResult != null ? StatusWordEnums.ExecutedSuccessfully : StatusWordEnums.ExecutionFailed); } catch (Exception e) { MsgLogger.Exception($"{GetType().Name} - SetMuteAsync", e); } } }); return(result); }
public async Task <bool> Exists(DeviceDescriptionPayload deviceDescription) { bool result = false; try { var query = HttpUtility.ParseQueryString(string.Empty); query["callerId"] = deviceDescription.ChannelId; query["nodeId"] = $"{deviceDescription.NodeId}"; query["hashCode"] = deviceDescription.HashCode; var url = UrlHelper.BuildUrl(Url, "api/description/exists", query); var json = await Transporter.Get(_identity, url); if (!string.IsNullOrEmpty(json)) { var requestResult = json.TryDeserializeObject <RequestResult>(); if (requestResult != null) { result = requestResult.Result; } } } catch (Exception e) { MsgLogger.Exception($"{GetType().Name} - Exists", e); } return(result); }
private List <string> GetPortNames(string deviceName, string protocolStackName, string interfaceName) { var result = new List <string>(); uint errorCode = 0; int endOfSelection = 0; int startOfSelection = 1; string portName = string.Empty; int selectionResult = 1; try { MsgLogger.WriteDebug($"{GetType().Name} - method", $"VcsGetPortNameSelection - enter - device = {deviceName}, protocol = {protocolStackName}, interface = {interfaceName}"); while (endOfSelection == 0 && selectionResult > 0) { selectionResult = VcsWrapper.Device.VcsGetPortNameSelection(deviceName, protocolStackName, interfaceName, startOfSelection, ref portName, ref endOfSelection, ref errorCode); if (selectionResult > 0) { result.Add(portName); } startOfSelection = 0; } MsgLogger.WriteDebug($"{GetType().Name} - method", "VcsGetPortNameSelection - leave"); } catch (Exception e) { MsgLogger.Exception($"{GetType().Name} - method", e); } return(result); }
public async Task <DeviceDescriptionPayload> Download(string channelId, DeviceVersion deviceVersion) { DeviceDescriptionPayload result = null; try { var query = HttpUtility.ParseQueryString(string.Empty); query["callerId"] = channelId; query["hardwareVersion"] = $"{deviceVersion.HardwareVersion}"; query["softwareVersion"] = $"{deviceVersion.SoftwareVersion}"; query["applicationNumber"] = $"{deviceVersion.ApplicationNumber}"; query["applicationVersion"] = $"{deviceVersion.ApplicationVersion}"; var url = UrlHelper.BuildUrl(Url, "api/description/download", query); var json = await Transporter.Get(_identity, url); if (!string.IsNullOrEmpty(json)) { result = json.TryDeserializeObject <DeviceDescriptionPayload>(); if (result != null) { result.Version = deviceVersion; } } } catch (Exception e) { MsgLogger.Exception($"{GetType().Name} - Download", e); } return(result); }
protected override void Dispose(bool disposing) { if (disposing) { Abort(); try { if (Client.Connected) { Client.Disconnect(false); } } catch (Exception e) { MsgLogger.Exception($"{GetType().Name} - Dispose", e); } int minWaitTime = 10; int maxWaitTime = 3000; var sw = new Stopwatch(); sw.Start(); while (_activityCounter > 0 && sw.ElapsedMilliseconds < maxWaitTime) { Thread.Sleep(minWaitTime); } } base.Dispose(disposing); }
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 async Task <UdpReceiveResult> Receive() { UdpReceiveResult result; try { _activityCounter++; result = await ReceiveAsync().WithCancellation(_tokenSource.Token); } catch (Exception e) { if (e.GetType() != typeof(OperationCanceledException)) { MsgLogger.Exception($"{GetType().Name} - Receive", e); } else { MsgLogger.WriteDebug($"{GetType().Name} - Receive", "close requested"); } } finally { _activityCounter--; } return(result); }
/// <summary> /// Receive /// </summary> /// <param name="uniqueId"></param> /// <returns></returns> public async Task <string> Receive(string uniqueId) { string result = string.Empty; var connections = FindConnections(uniqueId); foreach (var connection in connections) { try { var receiveResult = await connection.Receive(); if (!string.IsNullOrEmpty(receiveResult)) { result = receiveResult; break; } } catch (Exception e) { MsgLogger.Exception($"{GetType().Name} - Receive", e); } } return(result); }
public async new Task <int> Send(byte[] datagram, int bytes) { int result = 0; try { _activityCounter++; result = await SendAsync(datagram, bytes).WithCancellation(_tokenSource.Token); } catch (Exception e) { if (e.GetType() != typeof(OperationCanceledException)) { MsgLogger.Exception($"{GetType().Name} - Send", e); } else { MsgLogger.WriteDebug($"{GetType().Name} - Send", "close requested"); } } finally { _activityCounter--; } return(result); }
/// <summary> /// Receive /// </summary> /// <typeparam name="T"></typeparam> /// <param name="uniqueId"></param> /// <returns></returns> public async Task <T> Receive <T>(string uniqueId) { T result = default; var connections = FindConnections(uniqueId); foreach (var connection in connections) { if (connection.ReceiveSupported) { try { var receiveResult = await connection.Receive <T>(); if (receiveResult != null) { result = receiveResult; break; } } catch (Exception e) { MsgLogger.Exception($"{GetType().Name} - Receive", e); } } } return(result); }
public bool SetConnected() { bool result = false; try { if (Mutex.TryOpenExisting(LockingObjectName, out var lockingObject)) { result = lockingObject.WaitOne(0); } else { _lockingObject = new Mutex(true, LockingObjectName); result = _lockingObject != null; } } catch (AbandonedMutexException e) { MsgLogger.Exception($"{GetType().Name} - method", e); } catch (Exception e) { MsgLogger.Exception($"{GetType().Name} - method", e); } MsgLogger.WriteLine($"Set device {_device.Family} connected = {result}"); 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); }
public void SetDisconnected() { bool result = false; if (Mutex.TryOpenExisting(LockingObjectName, out var lockingObject)) { try { if (lockingObject.WaitOne(0)) { lockingObject.ReleaseMutex(); } lockingObject.Close(); _lockingObject.Dispose(); } catch (AbandonedMutexException e) { MsgLogger.Exception($"{GetType().Name} - method", e); } catch (Exception e) { MsgLogger.Exception($"{GetType().Name} - method", e); } _lockingObject = null; result = true; } MsgLogger.WriteLine($"Set device {_device.Family} disconnected = {result}"); }
private EltraPluginCacheItem FindPluginInFileSystem(DeviceToolPayload payload) { EltraPluginCacheItem result = null; var pluginFilePath = GetPluginFilePath(GetPluginFileName(payload.Id)); try { if (File.Exists(pluginFilePath)) { if (payload.Mode == DeviceToolPayloadMode.Development) { result = UpdateCache(payload, pluginFilePath); } else { if (GetHashCodeFromFile(pluginFilePath, out var hashCode) && hashCode == payload.HashCode) { result = UpdateCache(payload, pluginFilePath); } } } } catch (Exception e) { MsgLogger.Exception($"{GetType().Name} - FindPluginInFileSystem", e); } return(result); }
internal async Task <bool> PayloadExists(DeviceToolPayload payload) { bool result = false; try { var query = HttpUtility.ParseQueryString(string.Empty); query["callerId"] = payload.ChannelId; query["nodeId"] = $"{payload.NodeId}"; query["uniqueId"] = payload.Id; query["hashCode"] = payload.HashCode; query["mode"] = $"{payload.Mode}"; query["type"] = $"{payload.Type}"; var url = UrlHelper.BuildUrl(Url, "api/description/payload-exists", query); result = await Transporter.Get(_identity, url, CancellationToken.None); } catch (Exception e) { MsgLogger.Exception($"{GetType().Name} - PayloadExists", e); } return(result); }
internal async Task <string> GetChannelId() { string result = string.Empty; try { var query = HttpUtility.ParseQueryString(string.Empty); var url = UrlHelper.BuildUrl(Url, "api/channel/id", query); var json = await Transporter.Get(_identity, url); if (!string.IsNullOrEmpty(json)) { var channelIdentification = json.TryDeserializeObject <ChannelIdentification>(); if (channelIdentification != null) { result = channelIdentification.Id; } } } catch (Exception e) { MsgLogger.Exception($"{GetType().Name} - GetChannelId", e); } 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); }