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