public async Task <IPeeringResult> PeerChildAsync(IDipNode child)
{
if (m_parentNode == child)
{
throw new InvalidOperationException("Cannot create circular child/parent dependency");
}
if (m_peeringChildren.Contains(child) || m_children.Contains(child))
{
m_peeringChildren.TryRemove(child);
return(PeeringSuccess(child));
}
else
{
m_peeringChildren.TryAdd(child);
var result = this.PeerChild(child);
m_peeringChildren.TryRemove(child);
if (result.PeeringState == PeeringState.Connected)
{
m_children.TryAdd(child);
m_peersByGuid.TryAdd(child.Guid, child);
}
return(result);
}
}
public NetworkContext(INetworkBootstrapper bootstrapper, DtpNode node, IDipNode globalNetwork, IDipNode hostNetwork, IDipNode localRouter)
{
Bootstrapper = bootstrapper;
Node = node;
GlobalNetwork = globalNetwork;
HostNetwork = hostNetwork;
LocalRouter = localRouter;
}
public NetworkContext(INetworkBootstrapper bootstrapper, DtpNode node, IDipNode globalNetwork, IDipNode hostNetwork, IDipNode localRouter)
{
Bootstrapper = bootstrapper;
Node = node;
GlobalNetwork = globalNetwork;
HostNetwork = hostNetwork;
LocalRouter = localRouter;
}
private void SendPingAndPong(IDipNode a, IDipNode b)
{
object ping = 1;
object pong = 2;
a.Send(b, new Message<object>(ping));
Assert.AreEqual(ping, b.DequeueMessage().Content);
b.Send(a, new Message<object>(pong));
Assert.AreEqual(pong, a.DequeueMessage().Content);
}
private void SendPingAndPong(IDipNode a, IDipNode b)
{
object ping = 1;
object pong = 2;
a.Send(b, new Message <object>(ping));
Assert.AreEqual(ping, b.DequeueMessage().Content);
b.Send(a, new Message <object>(pong));
Assert.AreEqual(pong, a.DequeueMessage().Content);
}
protected override IPeeringResult PeerChild(IDipNode child)
{
if (child.Role.HasFlag(DipRole.RemoteTerminal))
{
return(PeeringFailure(child, new InvalidOperationException("Local nodes cannot directly peer with remote terminals")));
}
var result = child.PeerParentAsync(this).Result;
return(new PeeringResult(result.PeeringState, child, result.Exception));
}
protected override IPeeringResult PeerParent(IDipNode parent)
{
if (parent.Role.HasFlag(DipRole.Remote))
{
PeeringFailure(parent, new InvalidOperationException("Local terminals cannot peer with remote nodes"));
}
var result = parent.PeerChildAsync(this).Result;
return(new PeeringResult(result.PeeringState, parent, result.Exception));
}
public void Send <T>(IDipNode recipient, IMessage <T> message)
{
if (this.m_peersByGuid.ContainsKey(recipient.Guid))
{
var envelope = EnvelopeFactory.NewDirectEnvelopeFromMessage(this, recipient, message);
Send(envelope);
}
else
{
RerouteEnvelope(EnvelopeFactory.NewUnroutedEnvelopeToRecipient(this, recipient, message));
}
}
protected override IPeeringResult PeerChild(IDipNode child)
{
if (child.Role == DipRole.HostNetwork || child.Role == DipRole.RemoteNetwork)
{
var result = child.PeerParentAsync(this).Result;
return(new PeeringResult(result.PeeringState, child));
}
else
{
return(PeeringFailure(child, new InvalidOperationException("Global node cannot have parent node")));
}
}
protected override IPeeringResult PeerChild(IDipNode child)
{
if (child.Role.HasFlag(DipRole.Local) || child.Role.HasFlag(DipRole.Host))
{
var result = child.PeerParentAsync(this).Result;
return(new PeeringResult(result.PeeringState, child, result.Exception));
}
else
{
return(PeeringFailure(child, new InvalidOperationException("Localhost Network may only parent local and host nodes.")));
}
}
protected override IPeeringResult PeerParent(IDipNode parent)
{
if (parent.Role == DipRole.GlobalNetwork)
{
var result = parent.PeerChildAsync(this).Result;
return(new PeeringResult(result.PeeringState, parent, result.Exception));
}
else
{
return(PeeringFailure(parent, new InvalidOperationException("Localhost Network may only child to Global Network.")));
}
}
public async Task <IPeeringResult> PeerParentAsync(IDipNode parent)
{
if (parent == null)
{
throw new ArgumentNullException("parent");
}
if (m_peeringParent == parent)
{
m_peeringParent = null;
return(PeeringSuccess(parent));
}
try
{
this.m_parentNodeSemaphore.WaitOne();
m_peeringParent = parent;
if (m_parentNode == parent)
{
return(PeeringSuccess(parent));
}
if (m_children.Contains(parent))
{
throw new InvalidOperationException("Cannot create circular child/parent dependency");
}
var result = PeerParent(parent);
if (result.PeeringState == PeeringState.Connected)
{
m_parentNode = parent;
m_peersByGuid.TryAdd(parent.Guid, parent);
m_identifier.Parent = parent.Identifier;
}
return(result);
}
finally
{
this.m_parentNodeSemaphore.Release();
}
}
public void Run()
{
SuccessfullyPeerRouterWithChild(rootRouter, terminal1);
SuccessfullyPeerRouterWithChild(rootRouter, innerRouter1);
SuccessfullyPeerRouterWithChild(innerRouter1, terminal2);
SuccessfullyPeerRouterWithChild(innerRouter1, innerRouter1_1);
SuccessfullyPeerRouterWithChild(innerRouter1_1, terminal3);
SuccessfullyPeerRouterWithChild(innerRouter1_1, terminal4);
SuccessfullyPeerRouterWithChild(innerRouter1, innerRouter1_2);
SuccessfullyPeerRouterWithChild(innerRouter1_2, terminal5);
SuccessfullyPeerRouterWithChild(innerRouter1_2, terminal6);
SuccessfullyPeerRouterWithChild(rootRouter, innerRouter2);
SuccessfullyPeerRouterWithChild(innerRouter2, terminal7);
var nodes = new IDipNode[] { rootRouter, innerRouter1, innerRouter1_1, innerRouter1_2, innerRouter2, terminal1, terminal2, terminal3, terminal4, terminal5, terminal6, terminal7 };
for (var i = 0; i < nodes.Length; i++)
{
for (var j = i + 1; j < nodes.Length; j++)
{
SendPingAndPong(nodes[i], nodes[j]);
}
}
}
public void Run()
{
SuccessfullyPeerRouterWithChild(rootRouter, terminal1);
SuccessfullyPeerRouterWithChild(rootRouter, innerRouter1);
SuccessfullyPeerRouterWithChild(innerRouter1, terminal2);
SuccessfullyPeerRouterWithChild(innerRouter1, innerRouter1_1);
SuccessfullyPeerRouterWithChild(innerRouter1_1, terminal3);
SuccessfullyPeerRouterWithChild(innerRouter1_1, terminal4);
SuccessfullyPeerRouterWithChild(innerRouter1, innerRouter1_2);
SuccessfullyPeerRouterWithChild(innerRouter1_2, terminal5);
SuccessfullyPeerRouterWithChild(innerRouter1_2, terminal6);
SuccessfullyPeerRouterWithChild(rootRouter, innerRouter2);
SuccessfullyPeerRouterWithChild(innerRouter2, terminal7);
var nodes = new IDipNode[] { rootRouter, innerRouter1, innerRouter1_1, innerRouter1_2, innerRouter2, terminal1, terminal2, terminal3, terminal4, terminal5, terminal6, terminal7 };
for (var i = 0; i < nodes.Length; i++)
{
for (var j = i + 1; j < nodes.Length; j++)
{
SendPingAndPong(nodes[i], nodes[j]);
}
}
}
public static IEnvelopeV1 <TMessageContent> NewUnroutedEnvelopeToRecipient <TMessageContent>(IDipNode sender, IDipNode recipient, IMessage <TMessageContent> message)
{
return(new EnvelopeV1 <TMessageContent>(sender.Identifier, recipient.Identifier, null, DateTime.Now, DateTime.Now, message));
}
protected override IPeeringResult PeerParent(IDipNode parent)
{
var result = parent.PeerChildAsync(this).Result;
return(new PeeringResult(result.PeeringState, parent, result.Exception));
}
protected override IPeeringResult PeerChild(IDipNode child)
{
return(PeeringFailure(child, new InvalidOperationException("Terminals cannot have child nodes!")));
}
protected override IPeeringResult PeerParent(IDipNode parent)
{
return(PeeringFailure(parent, new InvalidOperationException("Global node cannot have parent node")));
}
protected abstract IPeeringResult PeerParent(IDipNode parent);
protected IPeeringResult PeeringFailure(IDipNode node, Exception e = null)
{
return(new PeeringResult(PeeringState.Disconnected, node, e));
}
public static IEnvelopeV1 <TMessageContent> NewDirectEnvelopeFromMessage <TMessageContent>(IDipNode sender, IDipNode receiver, IMessage <TMessageContent> message)
{
return(NewDirectEnvelopeFromMessageV1(sender, receiver, message));
}
protected IPeeringResult PeeringSuccess(IDipNode node, Exception e = null)
{
return(new PeeringResult(PeeringState.Connected, node, e));
}
protected bool HasPeer(IDipNode node)
{
return(this.HasPeer(node.Guid));
}
public static IEnvelopeV1 <TMessageContent> NewDirectEnvelopeFromMessageV1 <TMessageContent>(IDipNode sender, IDipNode receiver, IMessage <TMessageContent> message)
{
return(new EnvelopeV1 <TMessageContent>(sender.Identifier, receiver.Identifier, new Guid[] { sender.Guid, receiver.Guid }, DateTime.Now, DateTime.Now, message));
}
public PeeringResult(PeeringState peeringState, IDipNode peer = null, Exception exception = null)
{
PeeringState = peeringState;
Peer = peer;
Exception = exception;
}
private void SuccessfullyPeerRouterWithChild(LocalRouter router, IDipNode node)
{
var result = node.PeerParentAsync(router).Result;
Assert.AreEqual(PeeringState.Connected, result.PeeringState);
}
public PeeringResult(PeeringState peeringState, IDipNode peer = null, Exception exception = null)
{
PeeringState = peeringState;
Peer = peer;
Exception = exception;
}
private void SuccessfullyPeerRouterWithChild(LocalRouter router, IDipNode node)
{
var result = node.PeerParentAsync(router).Result;
Assert.AreEqual(PeeringState.Connected, result.PeeringState);
}
public static IEnvelopeV1 <TMessageContent> NewDirectEnvelopeFromContent <TMessageContent>(IDipNode sender, IDipNode receiver, TMessageContent content)
{
return(NewDirectEnvelopeFromContentV1(sender, receiver, content));
}
protected abstract IPeeringResult PeerChild(IDipNode child);