private string ExtractTargetClientId(ITransportEnvelopeHeader header)
{
if (header.TargetId.Contains(","))
{
return(header.TargetId.Substring(header.TargetId.LastIndexOf(",") + 1));
}
return(header.TargetId);
}
private bool IsMessageTypeInReceivableTypesFilter(ITransportEnvelopeHeader header,
IClientConfiguration clientConfiguration)
{
// empty receivable types filter equates to getting all messages
if (clientConfiguration.ReceivableTypesFilter.Count() == 0)
{
return(true);
}
// check receivable types filter
return((from x in clientConfiguration.ReceivableTypesFilter
where header.IsEnvelopeType(x)
select x).FirstOrDefault() != null);
}
private bool CanSendEnvelope(ITransportEnvelopeHeader header,
IClientConfiguration clientConfiguration,
IEnumerable <IPayloadTypeInfo> overrideTypesFilter)
{
var sendMessage = false;
// **** check for override message
if (IsOverrideMessage(header, overrideTypesFilter))
{
sendMessage = true;
}
else
{
// **** check self-sent message flag
if (clientConfiguration.Id == ExtractSourceClientId(header.ClientId))
{
if ((clientConfiguration.ReceiveSelfSentMessages) &&
(IsMessageTypeInReceivableTypesFilter(header, clientConfiguration)))
{
sendMessage = true;
}
}
else
{
var headerTargetClientId = ExtractTargetClientId(header);
if (!string.IsNullOrWhiteSpace(headerTargetClientId))
{
// ######## TARGETED MESSAGE
// check for valid receiver
if (clientConfiguration.Id == headerTargetClientId)
{
if (IsMessageTypeInReceivableTypesFilter(header, clientConfiguration))
{
sendMessage = true;
}
}
}
else
{
// ######## NON-TARGETED MESSAGE
if (IsMessageTypeInReceivableTypesFilter(header, clientConfiguration))
{
sendMessage = true;
}
}
}
}
//
return(sendMessage);
}
public TransportEnvelopeGroup(string id, ITransportEnvelopeHeader header)
: this()
{
Id = id;
Header = header;
}
private bool IsOverrideMessage(ITransportEnvelopeHeader header, IEnumerable <IPayloadTypeInfo> overrideTypesFilter)
{
return((from x in overrideTypesFilter
where header.IsEnvelopeType(x)
select x).FirstOrDefault() != null);
}
/// <summary>
/// Transmits the <see cref="TransportEnvelope"/> to the server.
/// </summary>
/// <param name="envelope">The <see cref="TransportEnvelope"/> to send to the server.</param>
public void PushEnvelopeToServer(TransportEnvelope envelope)
{
// ******** RECIEVED ENVELOPE FROM CLIENT ********
if (envelope != null)
{
System.Threading.Tasks.Task.Run(() =>
{
// extract header, update stats
ITransportEnvelopeHeader header = null;
lock (_SyncRootTransporterController)
{
TransporterController.TransportStatisticsLive.IncomingEnvelopes++;
TransporterController.TransportStatisticsLive.IncomingBytes += (envelope.Header.Length + envelope.Payload.Length);
header = TransporterController.ExtractHeader(envelope);
}
// get list of registered clients
List <KeyValuePair <string, DataHolder> > workerList = null;
var removableClients = new List <string>();
lock (_SyncRootRegisteredCallbackClients)
{
workerList = new List <KeyValuePair <string, DataHolder> >(_RegisteredCallbackClients);
}
// send envelope to each registered client, that will accept it
System.Threading.Tasks.Parallel.ForEach(workerList, new Action <KeyValuePair <string, DataHolder> >(
(x) =>
{
try
{
// handle type-based traffic filtering
if (CanSendEnvelope(header, x.Value.ClientConfiguration, OverrideTypesFilter))
{
lock (_SyncRootTransporterController)
{
TransporterController.TransportStatisticsLive.OutgoingEnvelopes++;
TransporterController.TransportStatisticsLive.OutgoingBytes += (envelope.Header.Length + envelope.Payload.Length);
}
InternalSendEnvelopeToClient(envelope, x.Value);
}
else
{
}
}
catch
{
removableClients.Add(x.Value.ClientConfiguration.Id);
}
}));
// **** unregister unresponsive clients
foreach (var clientId in removableClients)
{
if (clientId != null)
{
lock (_SyncRootRegisteredCallbackClients)
{
if (_RegisteredCallbackClients.ContainsKey(clientId))
{
_RegisteredCallbackClients.Remove(clientId);
}
}
}
}
});
}
else
{
// TODO: A null envelope? what could have caused this and what should I do about it?
}
}
