private IRelayTransport _createTransportDelegate(RelayNodeDefinition nodeDefinition,
RelayNodeGroupDefinition groupDefinition)
{
var transport = new MockTransport(nodeDefinition, groupDefinition);
transport.DoDispatchMessages = true;
transport.MessageRecievedMethod = _receiveMessage;
transport.MessageListRecievedMethod = _receiveMessageList;
IRelayTransport[] otherTransports = null;
if (_createTransports != null)
{
var count = _createTransports.Length;
if (count > 0)
{
otherTransports = new IRelayTransport[count];
for (var idx = 0; idx < count; ++idx)
{
otherTransports[idx] = _createTransports[idx](
nodeDefinition, groupDefinition);
}
}
}
if (otherTransports == null)
{
return(transport);
}
var transports = new List <IRelayTransport>();
transports.AddRange(otherTransports);
transports.Add(transport);
return(new RelayTransportStack(transports.ToArray()));
}
/// <summary>
/// Creates a new instance of <see cref="IRelayTransport"/> for the given <see cref="RelayNodeDefinition"/>
/// and <see cref="RelayNodeGroupDefinition"/>.
/// </summary>
/// <param name="nodeDefinition">The node definition.</param>
/// <param name="group">The group.</param>
/// <param name="chunkLength">The chunk length</param>
/// <returns></returns>
internal static IRelayTransport CreateTransportForNode(RelayNodeDefinition nodeDefinition,
RelayNodeGroupDefinition group, int chunkLength)
{
CreateTransportDelegate creator = CreateTransportMethod;
if (creator == null)
{
return(new SocketTransportAdapter(nodeDefinition, group, chunkLength));
}
IRelayTransport transport = creator(nodeDefinition, group) ?? new NullTransport();
return(transport);
}
internal Node(RelayNodeDefinition nodeDefinition, NodeGroup ownerGroup, NodeCluster ownerCluster, ForwardingConfig forwardingConfig, DispatcherQueue inMessageQueue, DispatcherQueue outMessageQueue)
{
DetectedZone = 0;
NodeDefinition = nodeDefinition;
NodeGroup = ownerGroup;
NodeCluster = ownerCluster;
_messageCounts = new int[RelayMessage.NumberOfTypes];
_lastMessageTimes = new double[RelayMessage.NumberOfTypes];
_averageMessageTimes = new double[RelayMessage.NumberOfTypes];
if (EndPoint != null)
{
_transport = TransportFactory.CreateTransportForNode(nodeDefinition, ownerGroup.GroupDefinition, forwardingConfig.MessageChunkLength);
DetectedZone = NodeManager.Instance.GetZoneForAddress(EndPoint.Address);
if (forwardingConfig.MapNetwork)
{
HopsFromHere = HowManyHopsFromHere();
}
else
{
HopsFromHere = 0;
}
}
else
{
_transport = new NullTransport();
}
_inMessageQueue = inMessageQueue;
_outMessageQueue = outMessageQueue;
if (forwardingConfig != null)
{
_messageBurstLength = forwardingConfig.MessageBurstLength;
_messageBurstTimeout = forwardingConfig.MessageBurstTimeout;
_messageBurstTimeoutSpan = TimeSpan.FromMilliseconds(_messageBurstTimeout);
MessageErrorQueue = new MessageQueue(ownerGroup.GetQueueConfig());
_repostMessageLists = forwardingConfig.RepostMessageLists;
}
ActivateBurstReceive(1); //the burst length will be used after the first message is received
// async, no skipping of the error queue (duh)
Arbiter.Activate(_inMessageQueue,
Arbiter.Receive<List<SerializedRelayMessage>>(true, _inMessagesPort,
messages => DoHandleInMessages(messages, false)));
Arbiter.Activate(_outMessageQueue,
Arbiter.Receive<MessagesWithLock>(true, _outMessagesPort,
delegate(MessagesWithLock messages) { HandleOutMessages(messages.Messages); messages.Locker.Decrement(); }));
}
