internal void Send(NodePeer ToPeer, NodePeer FromPeer, NodeBase Message, NodeBase BasedOnMessage)
{
if (ToPeer == null)
{
throw new ArgumentNullException("ToPeer");
}
if (FromPeer == null)
{
throw new ArgumentNullException("FromPeer");
}
if (Message == null)
{
throw new ArgumentNullException("Message");
}
NodePeer to = RemotePeerList.FindPeerByID(ToPeer.ID);
NodePeer from = CommunicationManager.LocalPeerList.FindPeerByID(FromPeer.ID);
if (to != null && from != null)
{
string s = Message.ToXml(BasedOnMessage, to, from);
Send(s);
}
else
{
//TODO - log undeliverable message (peer lists changed?)
}
}
internal void ReceiveFromPeer(NodePeer FromPeer, NodeBase Message)
{
if (CommunicationManager.LocalPeerList.Peers.Contains(this))
{
OnReceive(FromPeer, Message);
}
}
/// <summary>
/// Registers a new local peer. The calling function has to pass
/// in a Code that is a unique name for the peer. No other peer
/// by this name can exist locally. Returns null if it already
/// exists, or a new NodePeer object if successful.
/// </summary>
/// <param name="Code">Unique name for the new peer</param>
/// <returns></returns>
public static NodePeer RegisterLocalPeer(FieldIdentifier Code)
{
if (Code == null)
{
throw new ArgumentNullException("Code");
}
lock (Instance.m_localPeerList_Lock)
{
//make sure "Local.{thisCode}" doesn't exist yet
//(no duplicate peer names)
bool found = false;
foreach (NodePeer p in Instance.m_localPeerList.Peers)
{
if (p.Code == Code)
{
found = true;
break;
}
}
if (found)
{
return(null);
}
else
{
NodePeer newPeer = NodePeer.BuildWith(Code);
LocalPeerList = LocalPeerList.Peers.Append(newPeer);
return(newPeer);
}
}
}
/// <summary>
/// Unregisters a peer that was created by calling the
/// RegisterLocalPeer function. Throws an exception if
/// the peer is not a local peer.
/// </summary>
/// <param name="Peer"></param>
/// <returns>True if successful, False otherwise</returns>
public static bool UnregisterLocalPeer(NodePeer Peer)
{
if (Peer == null)
{
throw new ArgumentNullException("Peer");
}
if (!Peer.IsLocal)
{
throw new ArgumentOutOfRangeException("Peer");
}
lock (Instance.m_localPeerList_Lock)
{
if (Instance.m_localPeerList.Peers.Contains(Peer))
{
Peer.Unregister(); //clears all event handlers
LocalPeerList = LocalPeerList.Peers.Remove(Peer);
return(true);
}
else
{
return(false);
}
}
}
static internal void SendDeltaToPeer(NodePeer ToPeer, NodePeer FromPeer, NodeBase Message, NodeBase BasedOnMessage)
{
if (BasedOnMessage == null)
{
SendToPeer(ToPeer, FromPeer, Message);
}
else
{
if (ToPeer == null)
{
throw new ArgumentNullException("ToPeer");
}
if (FromPeer == null)
{
throw new ArgumentNullException("FromPeer");
}
if (Message != null)
{
if (ToPeer.IsLocal)
{
ReceiveDeltaFromLocalPeerThreadStart(ToPeer, FromPeer, Message, BasedOnMessage);
}
else
{
ToPeer.Connection.Send(ToPeer, FromPeer, Message, BasedOnMessage);
}
}
}
}
public CommunicationService()
{
m_peer = SoapBox.Protocol.Base.CommunicationManager.RegisterLocalPeer(
new FieldIdentifier("P_" +
Guid.NewGuid().ToString().Replace("-",string.Empty)));
peer.OnReceive += new NodePeer.ReceiveHandler(peer_OnReceive);
peer.OnReceiveDelta += new NodePeer.ReceiveDeltaHandler(peer_OnReceiveDelta);
}
static private void ReceiveDeltaFromLocalPeerThreadStart(NodePeer ToPeer, NodePeer FromPeer, NodeBase Message, NodeBase BasedOnMessage)
{
NodeBase BasedOnMessage_rcv = ToPeer.ReceiveDeltaFromPeer(FromPeer, BasedOnMessage.ID);
if (BasedOnMessage_rcv != null)
{
ToPeer.ReceiveFromPeer(FromPeer, Message);
}
}
internal NodeBase ReceiveDeltaFromPeer(NodePeer FromPeer, FieldGuid BasedOnMessageID)
{
if (CommunicationManager.LocalPeerList.Peers.Contains(this))
{
return(OnReceiveDelta(FromPeer, BasedOnMessageID));
}
else
{
return(null);
}
}
private IRuntime getRelationship(NodePeer peer)
{
IRuntime runtime = null;
lock (m_runtimeLookup_Lock)
{
if (m_runtimeLookup.ContainsKey(peer))
{
runtime = m_runtimeLookup[peer];
}
}
return runtime;
}
internal static NodePeer BuildWith(FieldIdentifier Code)
{
//build fields
Dictionary <FieldIdentifier, FieldBase> mutableFields =
new Dictionary <FieldIdentifier, FieldBase>();
mutableFields.Add(new FieldIdentifier(m_CodeName), Code);
//build children
KeyedNodeCollection <NodeBase> mutableChildren =
new KeyedNodeCollection <NodeBase>();
//build node
NodePeer Builder = new NodePeer(
new ReadOnlyDictionary <FieldIdentifier, FieldBase>(mutableFields),
new ReadOnlyCollection <NodeBase>(mutableChildren),
true /* peers built by the Communication manager are local */);
return(Builder);
}
static internal void SendToPeer(NodePeer ToPeer, NodePeer FromPeer, NodeBase Message)
{
if (ToPeer == null)
{
throw new ArgumentNullException("ToPeer");
}
if (FromPeer == null)
{
throw new ArgumentNullException("FromPeer");
}
if (Message != null)
{
if (ToPeer.IsLocal)
{
ToPeer.ReceiveFromPeer(FromPeer, Message);
}
else
{
ToPeer.Connection.Send(ToPeer, FromPeer, Message);
}
}
}
void peer_OnReceive(NodePeer FromPeer, NodeBase Message)
{
IRuntime runtime = getRelationship(FromPeer);
if (runtime != null)
{
runtime.MessageReceivedFromPeer(Message);
}
}
public void SendToPeer(NodePeer ToPeer, NodeBase Message)
{
CommunicationManager.SendToPeer(ToPeer, this, Message);
}
public void SendDeltaToPeer(NodePeer ToPeer, NodeBase Message, NodeBase BasedOnMessage)
{
CommunicationManager.SendDeltaToPeer(ToPeer, this, Message, BasedOnMessage);
}
private void Receive(string message)
{
//TextWriter tw = new StreamWriter("receive_" + this.ID.ToString() + ".txt", true);
//tw.WriteLine(message);
//tw.Close();
if (ValidateXmlToSchema(message))
{
FieldGuid toPeerID = NodeBase.ToPeerFromXML(message);
FieldGuid fromPeerID = NodeBase.FromPeerFromXML(message);
if (toPeerID != null && fromPeerID != null)
{
//it's a peer-to-peer message
//find the ToPeer in the local peer list
NodePeer ToPeer = CommunicationManager.LocalPeerList.FindPeerByID(toPeerID);
//find the FromPeer in the remote peer list
NodePeer FromPeer = RemotePeerList.FindPeerByID(fromPeerID);
if (ToPeer != null && FromPeer != null)
{
//see if this message is based on another node
FieldGuid BasedOnNodeID = NodeBase.BasedOnNodeIDFromXML(message);
NodeBase basedOnNode = null;
if (BasedOnNodeID != null)
{
basedOnNode = ToPeer.ReceiveDeltaFromPeer(FromPeer, BasedOnNodeID);
NodeBase msg = NodeBase.NodeFromXML(message, basedOnNode.GetChildrenRecursive());
CommunicationManager.SendDeltaToPeer(ToPeer, FromPeer, msg, basedOnNode);
}
else
{
NodeBase msg = NodeBase.NodeFromXML(message, null);
CommunicationManager.SendToPeer(ToPeer, FromPeer, msg);
}
}
else
{
//TODO - log this - undeliverable message (peer lists not up to date?)
}
}
else
{
//it's a system message (not peer-to-peer)
FieldNodeType nodeType = NodeBase.NodeTypeFromXML(message);
if (nodeType.ToString() == typeof(NodePeerList).FullName)
{
lock (m_remotePeerList_Lock) //lock so we read/write in one operation
{
//When we receive a remote peer list, it is generally just a diff
//from the last peer list.
RemotePeerList = (NodePeerList)NodeBase.NodeFromXML(
message, RemotePeerList.GetChildrenRecursive());
}
}
else
{
//TODO - log this? Unknown root message type?
}
}
}
else
{
//TODO - log this? Unknown garbage message?
}
}
internal void Send(NodePeer ToPeer, NodePeer FromPeer, NodeBase Message)
{
Send(ToPeer, FromPeer, Message, null);
}
static private void ReceiveDeltaFromLocalPeerThreadStart(NodePeer ToPeer, NodePeer FromPeer, NodeBase Message, NodeBase BasedOnMessage)
{
NodeBase BasedOnMessage_rcv = ToPeer.ReceiveDeltaFromPeer(FromPeer, BasedOnMessage.ID);
if (BasedOnMessage_rcv != null)
{
ToPeer.ReceiveFromPeer(FromPeer, Message);
}
}
/// <summary>
/// Unregisters a peer that was created by calling the
/// RegisterLocalPeer function. Throws an exception if
/// the peer is not a local peer.
/// </summary>
/// <param name="Peer"></param>
/// <returns>True if successful, False otherwise</returns>
public static bool UnregisterLocalPeer(NodePeer Peer)
{
if (Peer == null)
{
throw new ArgumentNullException("Peer");
}
if (!Peer.IsLocal)
{
throw new ArgumentOutOfRangeException("Peer");
}
lock (Instance.m_localPeerList_Lock)
{
if (Instance.m_localPeerList.Peers.Contains(Peer))
{
Peer.Unregister(); //clears all event handlers
LocalPeerList = LocalPeerList.Peers.Remove(Peer);
return true;
}
else
{
return false;
}
}
}
public void SendDeltaToPeer(NodePeer ToPeer, NodeBase Message, NodeBase BasedOnMessage)
{
CommunicationManager.SendDeltaToPeer(ToPeer, this, Message, BasedOnMessage);
}
internal void Send(NodePeer ToPeer, NodePeer FromPeer, NodeBase Message)
{
Send(ToPeer, FromPeer, Message, null);
}
internal NodeBase ReceiveDeltaFromPeer(NodePeer FromPeer, FieldGuid BasedOnMessageID)
{
if (CommunicationManager.LocalPeerList.Peers.Contains(this))
{
return OnReceiveDelta(FromPeer, BasedOnMessageID);
}
else
{
return null;
}
}
public void SendToPeer(NodePeer ToPeer, NodeBase Message)
{
CommunicationManager.SendToPeer(ToPeer, this, Message);
}
private void setRelationship(NodePeer peer, IRuntime runtime)
{
lock (m_runtimeLookup_Lock)
{
if(!m_runtimeLookup.ContainsKey(peer))
{
m_runtimeLookup.Add(peer, runtime);
}
}
}
static internal void SendToPeer(NodePeer ToPeer, NodePeer FromPeer, NodeBase Message)
{
if (ToPeer == null)
{
throw new ArgumentNullException("ToPeer");
}
if (FromPeer == null)
{
throw new ArgumentNullException("FromPeer");
}
if (Message != null)
{
if (ToPeer.IsLocal)
{
ToPeer.ReceiveFromPeer(FromPeer, Message);
}
else
{
ToPeer.Connection.Send(ToPeer, FromPeer, Message);
}
}
}
internal void SetLocalRuntimePeer(NodePeerList list)
{
foreach (var peer in list.Peers)
{
if (peer.Code.ToString() == Engine.PEER_CODE)
{
localRuntimePeer = peer;
break;
}
}
}
public void SendToPeer(IRuntime fromRuntime, NodePeer toPeer, NodeBase message)
{
setRelationship(toPeer, fromRuntime);
peer.SendToPeer(toPeer, message);
}
internal void Send(NodePeer ToPeer, NodePeer FromPeer, NodeBase Message, NodeBase BasedOnMessage)
{
if (ToPeer == null)
{
throw new ArgumentNullException("ToPeer");
}
if (FromPeer == null)
{
throw new ArgumentNullException("FromPeer");
}
if (Message == null)
{
throw new ArgumentNullException("Message");
}
NodePeer to = RemotePeerList.FindPeerByID(ToPeer.ID);
NodePeer from = CommunicationManager.LocalPeerList.FindPeerByID(FromPeer.ID);
if (to != null && from != null)
{
string s = Message.ToXml(BasedOnMessage, to, from);
Send(s);
}
else
{
//TODO - log undeliverable message (peer lists changed?)
}
}
internal static NodePeer BuildWith(FieldIdentifier Code)
{
//build fields
Dictionary<FieldIdentifier, FieldBase> mutableFields =
new Dictionary<FieldIdentifier, FieldBase>();
mutableFields.Add(new FieldIdentifier(m_CodeName), Code);
//build children
KeyedNodeCollection<NodeBase> mutableChildren =
new KeyedNodeCollection<NodeBase>();
//build node
NodePeer Builder = new NodePeer(
new ReadOnlyDictionary<FieldIdentifier, FieldBase>(mutableFields),
new ReadOnlyCollection<NodeBase>(mutableChildren),
true /* peers built by the Communication manager are local */);
return Builder;
}
static internal void SendDeltaToPeer(NodePeer ToPeer, NodePeer FromPeer, NodeBase Message, NodeBase BasedOnMessage)
{
if (BasedOnMessage == null)
{
SendToPeer(ToPeer, FromPeer, Message);
}
else
{
if (ToPeer == null)
{
throw new ArgumentNullException("ToPeer");
}
if (FromPeer == null)
{
throw new ArgumentNullException("FromPeer");
}
if (Message != null)
{
if (ToPeer.IsLocal)
{
ReceiveDeltaFromLocalPeerThreadStart(ToPeer, FromPeer, Message, BasedOnMessage);
}
else
{
ToPeer.Connection.Send(ToPeer, FromPeer, Message,BasedOnMessage);
}
}
}
}
internal void ReceiveFromPeer(NodePeer FromPeer, NodeBase Message)
{
if (CommunicationManager.LocalPeerList.Peers.Contains(this))
{
OnReceive(FromPeer, Message);
}
}
NodeBase peer_OnReceiveDelta(NodePeer FromPeer, FieldGuid BasedOnMessageID)
{
NodeBase originalMessage = null;
IRuntime runtime = getRelationship(FromPeer);
if (runtime != null)
{
originalMessage = runtime.DeltaReceivedFromPeer(BasedOnMessageID);
}
return originalMessage;
}
