private static void DebugCallback(DebugSource source, DebugType type, int id, DebugSeverity severity, int length, IntPtr message, IntPtr userParam) { string messageString = Marshal.PtrToStringAnsi(message, length); DebugMessage?.Invoke(messageString, source, type, severity, id); _log.Debug($"{severity.GetName()} {type.GetName()} | {messageString}"); // if (type == DebugType.DebugTypePerformance) // { // throw new Exception("Performance Error"); // } if (type == DebugType.DebugTypeError && severity == DebugSeverity.DebugSeverityHigh) { throw new Exception(messageString); } }
/// <summary> /// Event handler that occurs whenever we recieve a response from the host. /// Executes the associated callback if nessesary. /// </summary> private void ReceivedResponse(CommunicationMessage message) { if (!IsMe(message.To)) { DebugMessage?.Invoke($"Received an invalid response: addressed to someone other than me - to: {message.To.Name}, {message.Type}, from {message.From.Name})"); return; } CurrentStatus.LastResponseReceived = DateTime.UtcNow; var responseData = message.GetValue <ResponseMessage>(); DebugMessage?.Invoke($"{message.To.Name} << Received ({message.Type}) from {message.From.Name}: {responseData.ResponseText}"); switch (message.From.Role) { case IdentityRole.Host: if (responseData.Clients.Any()) { UpdateClientList(responseData); } break; case IdentityRole.Client: RequestClientListFromHost(); break; } FireCallbacks(message, responseData); }
/// <summary> /// Keep track of who sent a message /// </summary> private void UpdateHostClientList(Identity id, CommunicationMessage message = null) { var found = false; foreach (var client in _hostClientsList.ToList()) { if (client.Identity.Equals(id)) { found = true; client.State = ClientState.Active; client.LastMessage = message; } else if (DateTime.UtcNow.Subtract(client.LastMessage.Received) > ClientExpiryTime) { _hostClientsList.Remove(client); } else if (DateTime.UtcNow.Subtract(client.LastMessage.Received) > ClientInactiveTime) { client.State = ClientState.Inactive; } } if (!found) { DebugMessage?.Invoke($"{_hostId.Name}: Adding new client information - {id}"); _hostClientsList.Add(new RemoteClient(id, message)); } }
private void UpdateClientList(ResponseMessage responseData) { CurrentStatus.LastUpdatedClients = DateTime.UtcNow; Clients = responseData.Clients; ClientsUpdated?.Invoke(Clients); DebugMessage?.Invoke($"{_clientId.Name}: Client List Updated ({Clients.Count})"); }
/// <summary> /// Actually send a message. /// </summary> private void SendMessageInternal(CommunicationMessage message, Identity to = null) { try { var senderId = message.From.Equals(ClientDevice.Identity) ? message.From : _hostId; var receiverId = to ?? _hostId; //var uri = to?.Role == IdentityRole.Client && !to.Equals(HostDevice.Identity) ? HostDevice.GetUri(to) : HostDevice.Uri; var uri = to?.Address ?? HostDevice.Uri; var binding = HostDevice.CreateBinding(); var proxy = ChannelFactory <ITransmissionService> .CreateChannel(binding, new EndpointAddress(uri)); message.Sent = DateTime.UtcNow; message.To = receiverId; Task.Run(() => { DebugMessage?.Invoke($"{senderId.Name} >> Sending {message.Name} ({message.Type}) to {receiverId.Name}"); CurrentStatus.LastSendTime = DateTime.UtcNow; try { proxy.SendData(TransmissionService.PrepareMessage(message)); } //catch (EndpointNotFoundException ex) catch (Exception ex) { DebugMessage?.Invoke($"Exception: {ex.GetType().Name} {ex.Message}"); } }); } catch (Exception ex) { DebugMessage?.Invoke($"Exception: {ex.GetType().Name} {ex.Message}"); } }
public SwarmClient(Uri addr, string pipeName = null) { _coordinator = new CommunicationCoordinator(CommunicationMethod.Tcp, addr, pipeName); _coordinator.DebugMessage += msg => DebugMessage?.Invoke(msg); _coordinator.ClientDevice.MessageReceived += HandleMessageReceived; _coordinator.ClientDevice.ResponseReceived += HandleResponseReceived; _coordinator.ClientsUpdated += UpdatedClients; }
/// <summary> /// Send a message on the host channel to see if we get a response. /// </summary> public void Ping() { var msg = new CommunicationMessage { Name = "Ping", From = _clientId }; AddCallback(msg, HandlePingSuccess); SendMessageInternal(msg); DebugMessage?.Invoke($"Ping..."); }
/// <summary> /// Event handler that occurs when we recieve a response from the host to our Ping(). /// </summary> private void HandlePingSuccess(CallbackArgs obj) { DebugMessage?.Invoke($"Pong.. ({obj.OriginalMessage.TransmissionTime.TotalSeconds}s)"); CurrentStatus.IsConnected = true; CurrentStatus.IsHost = false; CurrentStatus.LastResponseReceived = DateTime.UtcNow; if (_actionQueue.Any()) { DebugMessage?.Invoke($"{_clientId.Name}: Sending Queued Messages ({_actionQueue.Count})"); while (_actionQueue.Count > 0 && CurrentStatus.IsConnected) { var message = _actionQueue.Dequeue(); message?.Callback(obj); } } }
private void ReceivedMessage(CommunicationMessage message) { if (!IsMe(message.To)) { DebugMessage?.Invoke($"Received an invalid message: addressed to someone other than me - to: {message.To.Name}, {message.Type}, from {message.From.Name})"); return; } DebugMessage?.Invoke($"{message.To.Name} << Received ({message.Type}) from {message.From.Name}"); if (message.To.Role == IdentityRole.Host && !message.From.Equals(_hostId)) { UpdateHostClientList(message.From, message); } else { RequestClientListFromHost(); } SendResponse(message.To, message, _hostClientsList); }
public void DebugMsg(string Msg) { DebugMessage?.Invoke(Msg); }
protected virtual void OnDebugMessage(string message, bool lineFeed, bool timeStamp) { DebugMessage?.Invoke(this, new DebugLogMessageEventArgs(message, lineFeed, timeStamp)); }
protected virtual void OnDebugMessage(object sender, EventArgs e) { DebugMessage?.Invoke(sender, e); }
protected virtual void OnDebugMessage(string text) { DebugMessage?.Invoke(this, new DebugLogMessageEventArgs(text)); }
/// <summary>Raises the <see cref="DebugMessage"/> event.</summary> /// <param name="e"> /// The <see cref="DebugEventArgs" /> instance containing the /// event data. /// </param> /// <autogeneratedoc /> /// TODO Edit XML Comment Template for OnDebugMessage private void OnDebugMessage(DebugEventArgs e) { Logger?.Debug(e.Message); DebugMessage?.Invoke(this, e); }
public void Debug(string message) { DebugMessage?.Invoke(DateTime.Now, message); }
public static void DebugLog(Func <DebugEventArgs> getArgs) { DebugMessage?.Invoke(null, getArgs()); }
private static void OnDebugMessage(string message) { DebugMessage?.Invoke(null, new EventArgs <string>(message)); }
internal void OnDebugMessage(string value) { DebugMessage?.Invoke(value); }
public void Debug(string s) { DebugMessage?.Invoke(s); }
internal void Debug(string log) { DebugMessage?.Invoke(this, log); }
private void CloseHost() { DebugMessage?.Invoke($"Closing Host"); HostDevice?.Stop(); }