public ReloadMessage(ReloadConfig rc, NodeId OriginatorNodeID, Destination destination, UInt64 trans_id, RELOAD_MessageBody reload_content) { m_ReloadConfig = rc; forwarding_header.version = ReloadGlobals.RELOAD_VERSION; forwarding_header.ttl = ReloadGlobals.TTL; forwarding_header.overlay = m_ReloadConfig.OverlayHash; forwarding_header.transaction_id = trans_id; reload_message_body = reload_content; forwarding_header.via_list = new List<Destination>(); forwarding_header.via_list.Add(new Destination(OriginatorNodeID)); forwarding_header.destination_list = new List<Destination>(); forwarding_header.destination_list.Add(destination); SignerIdentity myId = m_ReloadConfig.AccessController.MyIdentity; security_block = new SecurityBlock(rc, myId); /* Sign the message, create stream of body */ security_block.SignMessage(m_ReloadConfig.OverlayHash, trans_id.ToString(), reload_message_body); }
/// <summary> /// Creates a FetchAns /// </summary> /// <param name="destination"></param> /// <param name="p"></param> /// <param name="fetchKindResponses"></param> /// <returns></returns> private ReloadMessage create_fetch_answ(Destination destination, UInt64 trans_id, List<FetchKindResponse> fetchKindResponses) { return create_reload_message(destination, trans_id, new FetchAns(fetchKindResponses, m_machine.UsageManager)); }
public IEnumerator<ITask> AppAttachProcedure(Destination dest) { ReloadMessage reloadSendMsg; reloadSendMsg = create_app_attach_req(dest); if (dest.type != DestinationType.node) { m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_ERROR, String.Format("AppAttachProcedure failed: unexpected destination type")); yield break; } if (dest.destination_data.node_id == m_topology.Id) { m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_INFO, String.Format("local AppAttachProcedure dropped")); yield break; } Node node = m_topology.routing_table.FindNextHopTo(dest.destination_data.node_id, true, false); if (node == null) { m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_ERROR, String.Format("AppAttachProcedure: failed, did not found next hop to {0}", dest.destination_data.node_id)); yield break; } ReloadDialog reloadDialog = null; int RetransmissionTime = ReloadGlobals.RetransmissionTime + ReloadGlobals.MaxTimeToSendPacket; int iRetrans = ReloadGlobals.MaxRetransmissions; m_topology.routing_table.SetNodeState(dest.destination_data.node_id, NodeState.attaching); while (iRetrans >= 0 && m_ReloadConfig.State < ReloadConfig.RELOAD_State.Shutdown) { try { /* use a new ReloadDialog instance for every usage, Monitor requires it */ reloadDialog = new ReloadDialog(m_ReloadConfig, m_flm, node); m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_RELOAD, String.Format("{0} via {1} ==> Dest={2} TransId={3:x16}", RELOAD_MessageCode.App_Attach_Request.ToString().PadRight(16, ' '), node, dest.ToString(), reloadSendMsg.TransactionID)); Arbiter.Activate(m_DispatcherQueue, new IterativeTask<ReloadMessage, ReloadMessageFilter, int>( reloadSendMsg, new ReloadMessageFilter(reloadSendMsg.TransactionID), RetransmissionTime, reloadDialog.Execute)); } catch (Exception ex) { m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_ERROR, "AppAttachProcedure: " + ex.Message); } yield return Arbiter.Receive(false, reloadDialog.Done, done => { }); if (!reloadDialog.Error && reloadDialog.ReceivedMessage != null) break; /* If a response has not been received when the timer fires, the request is retransmitted with the same transaction identifier. */ --iRetrans; } try { if (!reloadDialog.Error && reloadDialog.ReceivedMessage != null) { //the SourceNodeID delivered from reloadDialog comes from connection table and is the last hop of the message ReloadMessage reloadRcvMsg = reloadDialog.ReceivedMessage; if (reloadRcvMsg.reload_message_body.RELOAD_MsgCode == RELOAD_MessageCode.App_Attach_Answer) { AppAttachReqAns answ = (AppAttachReqAns)reloadRcvMsg.reload_message_body; if (answ != null) { node = new Node(reloadRcvMsg.OriginatorID, answ.ice_candidates); /* An Attach in and of itself does not result in updating the routing * table of either node. * Note: We use the routing table here only for storing ice candidates * for later use, we will not update successor or predecessor list */ m_topology.routing_table.AddNode(node); if (m_topology.routing_table.GetNodeState(node.Id) < NodeState.attached) m_topology.routing_table.SetNodeState(node.Id, NodeState.attached); m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_RELOAD, String.Format("{0} <== {1} last={2} TransId={3:x16}", reloadRcvMsg.reload_message_body.RELOAD_MsgCode.ToString().PadRight(16, ' '), reloadRcvMsg.OriginatorID, reloadRcvMsg.LastHopNodeId, reloadRcvMsg.TransactionID)); m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_USAGE, String.Format("AppAttach returns IP: {0}", answ.ice_candidates[0].addr_port.ipaddr.ToString())); /* Proprietary registry interface function to support external clients */ ReloadGlobals.StoreRegAnswer("sip:" + answ.ice_candidates[0].addr_port.ipaddr.ToString() + ":5060"); m_ReloadConfig.ConnEstEnd = DateTime.Now; if (AppAttachDone != null) appAttachDone.Post(answ.ice_candidates[0]); if (ReloadGlobals.AutoExe) { TimeSpan appAttachTime = DateTime.Now - m_ReloadConfig.StartFetchAttach; m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_MEASURE, String.Format("Fetch:{0}", appAttachTime.TotalSeconds)); } } } else if (reloadRcvMsg.reload_message_body.RELOAD_MsgCode == RELOAD_MessageCode.Error) { // TODO } } else { m_topology.routing_table.SetNodeState(dest.destination_data.node_id, NodeState.unknown); } } catch (Exception ex) { m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_ERROR, "AppAttachProcedure: " + ex.Message); m_topology.routing_table.SetNodeState(dest.destination_data.node_id, NodeState.unknown); } }
public ReloadMessage create_ping_answ(Destination destination, UInt64 trans_id) { Random rand = new Random(); return create_reload_message(destination, trans_id, new PingReqAns((UInt64)rand.Next(int.MinValue, int.MaxValue), false)); }
/// <summary> /// Creates a StoreAns message accoriding to RELOAD base -12 p.90 /// </summary> /// <param name="destination">The answer destination address</param> /// <param name="trans_id">The transaction ID corresponding to the StoreReq</param> /// <param name="usage">The Usage data corresponding to the StoreReq</param> /// <returns></returns> public ReloadMessage create_store_answ(Destination dest, UInt64 trans_id, List<StoreKindData> skd, List<NodeId> replicas) { return create_reload_message(dest, trans_id, new StoreAns(skd, replicas)); }
public ReloadMessage create_update_answ(Destination destination, UInt64 trans_id, RELOAD_ErrorCode result) { return create_reload_message(destination, trans_id, new UpdateReqAns(result)); }
public ReloadMessage create_leave_answ(Destination destination, UInt64 trans_id) { return create_reload_message(destination, trans_id, new LeaveReqAns(m_topology.LocalNode, false)); }
/// <summary> /// Proprietary: Tries to fetch the Data specified by the StoredDataSpecifier List from different RELOAD overlay using viaGateWay as gateway /// </summary> /// <param name="resourceName"></param> /// <param name="specifiers"></param> /// <param name="viaGateWay"></param> /// <returns></returns> public IEnumerator<ITask> Fetch(string resourceName, List<StoredDataSpecifier> specifiers, NodeId viaGateWay) { ReloadDialog reloadDialog = null; ReloadMessage reloadSendMsg; List<IUsage> recUsages = new List<IUsage>(); ResourceId res_id = new ResourceId(resourceName); Node node = null; List<FetchKindResponse> fetchKindResponses = new List<FetchKindResponse>(); FetchKindResponse fetchKindResponse = null; if (viaGateWay != null) { m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_USAGE, String.Format("Fetch {0} as ResID: {1} via Gateway {2}", resourceName, res_id, viaGateWay)); node = m_topology.routing_table.FindNextHopTo(viaGateWay, true, false); //node = m_topology.routing_table.FindNextHopTo(new NodeId(res_id), true, false); if (m_ReloadConfig.IamClient && node == null) { node = m_ReloadConfig.AdmittingPeer; } Destination gateway = new Destination(new NodeId(viaGateWay.Data)); Destination fetchDestination = new Destination(res_id); //reloadSendMsg = create_fetch_req(gateway, specifiers); FetchReq fetchRequest = new FetchReq(fetchDestination.destination_data.ressource_id, specifiers, m_machine.UsageManager); reloadSendMsg = create_reload_message(gateway, ++m_ReloadConfig.TransactionID, fetchRequest); reloadSendMsg.forwarding_header.destination_list.Add(fetchDestination); //reloadSendMsg = create_fetch_req(new Destination(res_id), specifiers); //reloadSendMsg.AddViaHeader(viaGateWay); if (reloadSendMsg.AddDestinationOverlay(resourceName)) m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_ERROR, "AddDestinationOverlay successful"); } else { m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_USAGE, String.Format("Fetch {0} as ResID: {1}", resourceName, res_id)); node = m_topology.routing_table.FindNextHopTo(new NodeId(res_id), true, false); if (m_ReloadConfig.IamClient && node == null) { node = m_ReloadConfig.AdmittingPeer; } List<Destination> dest_list = new List<Destination>(); dest_list.Add(new Destination(m_topology.LocalNode.Id)); if (node == null || node.Id == m_ReloadConfig.LocalNodeID) { m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_TOPO, "Local Fetch."); m_ReloadConfig.StartFetchAttach = DateTime.Now; foreach (StoredDataSpecifier specifier in specifiers) { var responses = new List<FetchKindResponse>(); if (m_topology.Fetch(res_id, specifier, out fetchKindResponse)) { responses.Add(fetchKindResponse); foreach (StoredData sd in fetchKindResponse.values) { if (m_ReloadConfig.AccessController.validateDataSignature(res_id, fetchKindResponse.kind, sd)) recUsages.Add(sd.Value.GetUsageValue); else { m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_TOPO, "DATA SIGNATURE INVALID!!"); } m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_TOPO, String.Format("Fetch successful, got {0}", sd.Value.GetUsageValue.Report())); } m_ReloadConfig.ConnEstEnd = DateTime.Now; } OnFetchedData(res_id, responses); } if (fetchDone != null) { if (recUsages.Count == 0) { foreach (StoredDataSpecifier specifier in specifiers) recUsages.Add(new NoResultUsage(specifier.ResourceName)); } fetchDone.Post(recUsages); } yield break; } else { reloadSendMsg = create_fetch_req(new Destination(res_id), specifiers); } } int RetransmissionTime = ReloadGlobals.RetransmissionTime + ReloadGlobals.MaxTimeToSendPacket; int iRetrans = ReloadGlobals.MaxRetransmissions; while (iRetrans >= 0 && m_ReloadConfig.State < ReloadConfig.RELOAD_State.Shutdown) { try { reloadDialog = new ReloadDialog(m_ReloadConfig, m_flm, node); m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_RELOAD, String.Format("{0} ==> {1} TransId={2:x16}", reloadSendMsg.reload_message_body.RELOAD_MsgCode.ToString(). PadRight(16, ' '), node.Id, reloadSendMsg.TransactionID)); m_ReloadConfig.StartFetchAttach = DateTime.Now; Arbiter.Activate(m_DispatcherQueue, new IterativeTask<ReloadMessage, ReloadMessageFilter, int>( reloadSendMsg, new ReloadMessageFilter(reloadSendMsg.TransactionID), RetransmissionTime, reloadDialog.Execute)); } catch (Exception ex) { fetchDone.Post(new List<IUsage> { new NullUsage() }); m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_ERROR, "Fetch: " + ex.Message); } yield return Arbiter.Receive(false, reloadDialog.Done, done => { }); if (!reloadDialog.Error && reloadDialog.ReceivedMessage != null) break; /* If a response has not been received when the timer fires, the request is retransmitted with the same transaction identifier. */ --iRetrans; } try { if (!reloadDialog.Error && reloadDialog.ReceivedMessage != null) { //the SourceNodeID delivered from reloadDialog comes from connection table and is the last hop of the message ReloadMessage reloadRcvMsg = reloadDialog.ReceivedMessage; RELOAD_MessageCode recMsgCode = reloadRcvMsg.reload_message_body.RELOAD_MsgCode; if (recMsgCode == RELOAD_MessageCode.Fetch_Answer) { m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_RELOAD, String.Format("{0} <== {1} TransId={2:x16}", recMsgCode.ToString().PadRight(16, ' '), reloadRcvMsg.OriginatorID, reloadRcvMsg.TransactionID)); FetchAns answ = (FetchAns)reloadRcvMsg.reload_message_body; if (answ != null) { fetchKindResponses = answ.KindResponses; foreach (FetchKindResponse kind in fetchKindResponses) { foreach (StoredData sd in kind.values) { if (m_ReloadConfig.AccessController.validateDataSignature(res_id, kind.kind, sd)) recUsages.Add(sd.Value.GetUsageValue); else { m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_TOPO, "DATA SIGNATURE INVALID!!"); } m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_TOPO, String.Format("Fetch successful, got {0}", sd.Value.GetUsageValue.Report())); } } OnFetchedData(res_id, fetchKindResponses); if (fetchDone != null) { if (recUsages.Count == 0) { foreach (StoredDataSpecifier specifier in specifiers) recUsages.Add(new NoResultUsage(specifier.ResourceName)); } fetchDone.Post(recUsages); } } } } else { m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_WARNING, String.Format("Fetch failed")); foreach (StoredDataSpecifier specifier in specifiers) recUsages.Add(new NoResultUsage(specifier.ResourceName)); fetchDone.Post(recUsages); m_statistics.IncTransmissionError(); } } catch (Exception ex) { m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_ERROR, "Fetch: " + ex.Message); } }
public IEnumerator<ITask> SendUpdate(Node node, Node nexthopnode) { ReloadDialog reloadDialog = null; ReloadMessage reloadSendMsg; /*if (m_topology.routing_table.isFinger(node.Id)) m_topology.routing_table.AddFinger(node);*/ if (nexthopnode == null) nexthopnode = node; Destination dest = new Destination(node.Id); reloadSendMsg = create_update_req(dest, m_topology.routing_table, ChordUpdateType.neighbors); int RetransmissionTime = ReloadGlobals.RetransmissionTime + ReloadGlobals.MaxTimeToSendPacket; int iRetrans = ReloadGlobals.MaxRetransmissions; while (iRetrans >= 0 && m_ReloadConfig.State < ReloadConfig.RELOAD_State.Shutdown) { try { reloadDialog = new ReloadDialog(m_ReloadConfig, m_flm, nexthopnode); m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_RELOAD, String.Format("{0} ==> {1} TransId={2:x16}", RELOAD_MessageCode.Update_Request.ToString().PadRight(16, ' '), node.Id, reloadSendMsg.TransactionID)); //m_ReloadConfig.start Arbiter.Activate(m_DispatcherQueue, new IterativeTask<ReloadMessage, ReloadMessageFilter, int>( reloadSendMsg, new ReloadMessageFilter(reloadSendMsg.TransactionID), RetransmissionTime, reloadDialog.Execute)); } catch (Exception ex) { m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_ERROR, "Send Update: " + ex.Message); yield break; } yield return Arbiter.Receive(false, reloadDialog.Done, done => { }); if (!reloadDialog.Error && reloadDialog.ReceivedMessage != null) break; /* If a response has not been received when the timer fires, the request is retransmitted with the same transaction identifier. */ --iRetrans; if (iRetrans > 0) { m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_WARNING, String.Format("Retrans {0} SendUpdate {1}:{2} TransId={3:x16}", iRetrans, node, nexthopnode, reloadSendMsg.TransactionID)); m_statistics.IncRetransmission(); } else { m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_ERROR, String.Format("Failed! SendUpdate {0}:{1} TransId={2:x16}", node, nexthopnode, reloadSendMsg.TransactionID)); m_statistics.IncTransmissionError(); } } try { if (!reloadDialog.Error && reloadDialog.ReceivedMessage != null) { //the SourceNodeID delivered from reloadDialog comes from connection table and is the last hop of the message ReloadMessage reloadRcvMsg = reloadDialog.ReceivedMessage; RELOAD_MessageCode msgCode = reloadRcvMsg.reload_message_body.RELOAD_MsgCode; if (msgCode == RELOAD_MessageCode.Update_Answer) { m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_RELOAD, String.Format("{0} <== {1} TransId={2:x16}", msgCode.ToString().PadRight(16, ' '), reloadRcvMsg.OriginatorID, reloadRcvMsg.TransactionID)); UpdateReqAns answ = (UpdateReqAns)reloadRcvMsg.reload_message_body; if (answ != null) { NodeId originator = reloadRcvMsg.OriginatorID; if (m_topology.routing_table.FingerSuccessors.Contains(originator)) { //m_topology.routing_table.GetNode(originator).Successors = answ.Successors; //m_topology.routing_table.GetNode(originator).Predecessors = answ.Predecessors; m_topology.routing_table.SetFingerState(originator, NodeState.updates_received); } if (m_topology.routing_table.RtTable.ContainsKey(originator.ToString())) { m_topology.routing_table.SetNodeState(originator, NodeState.updates_received); m_topology.routing_table.GetNode(originator).Successors = answ.Successors; m_topology.routing_table.GetNode(originator).Predecessors = answ.Predecessors; } } } } } catch (Exception ex) { m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_ERROR, "Send Update: " + ex.Message); } }
public IEnumerator<ITask> SendPing(Destination dest, PingOption pingOption) { ReloadDialog reloadDialog = null; ReloadMessage reloadSendMsg; reloadSendMsg = create_ping_req(dest); int RetransmissionTime = ReloadGlobals.RetransmissionTime + ReloadGlobals.MaxTimeToSendPacket; Boolean NextHopIsDestination = false; Node NextHopNode = NextHopToDestination(dest, ref NextHopIsDestination); if (NextHopNode == null) yield break; if (NextHopNode.Id == m_topology.LocalNode.Id) yield break; if (dest.type == DestinationType.node) { /* This code assumes, that a node we want to ping is already attached and added to the routing table */ NodeState nodestate = m_topology.routing_table.GetNodeState(dest.destination_data.node_id); bool pinging = m_topology.routing_table.GetPing(dest.destination_data.node_id); if (((pingOption & PingOption.standard | PingOption.finger) != 0) && nodestate == NodeState.unknown && !pinging) { m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_INFO, String.Format("Ignoring redundant Ping for {0}", dest)); yield break; } m_topology.routing_table.SetPinging(dest.destination_data.node_id, true, false); } else if (!NextHopIsDestination && ((pingOption & PingOption.direct) != 0)) { m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_ERROR, String.Format("Direct Ping for {0} ignored, no entry in routing table", dest)); yield break; } /* Don't spend too much time on connectivity checks */ int iRetrans = 3; while (iRetrans > 0 && m_ReloadConfig.State < ReloadConfig.RELOAD_State.Shutdown) { try { reloadDialog = new ReloadDialog(m_ReloadConfig, m_flm, NextHopNode); m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_RELOAD, String.Format("{0} ==> {1} TransId={2:x16}", reloadSendMsg.reload_message_body.RELOAD_MsgCode.ToString().PadRight(16, ' '), NextHopNode.Id, reloadSendMsg.TransactionID)); Arbiter.Activate(m_DispatcherQueue, new IterativeTask<ReloadMessage, ReloadMessageFilter, int>(reloadSendMsg, new ReloadMessageFilter(reloadSendMsg.TransactionID), RetransmissionTime, reloadDialog.Execute)); } catch (Exception ex) { m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_ERROR, "Send Ping: " + ex.Message); yield break; } yield return Arbiter.Receive(false, reloadDialog.Done, done => { }); if (!reloadDialog.Error && reloadDialog.ReceivedMessage != null) break; /* If a response has not been received when the timer fires, the request is retransmitted with the same transaction identifier. */ --iRetrans; } try { PingReqAns answ = null; if (reloadDialog != null && !reloadDialog.Error && reloadDialog.ReceivedMessage != null) { //the SourceNodeID delivered from reloadDialog comes from connection table and is the last hop of the message ReloadMessage reloadRcvMsg = reloadDialog.ReceivedMessage; if (reloadRcvMsg.reload_message_body.RELOAD_MsgCode == RELOAD_MessageCode.Ping_Answer) { m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_RELOAD, String.Format("{0} <== {1} TransId={2:x16}", reloadRcvMsg.reload_message_body.RELOAD_MsgCode.ToString().PadRight(16, ' '), reloadRcvMsg.OriginatorID, reloadRcvMsg.TransactionID)); answ = (PingReqAns)reloadRcvMsg.reload_message_body; if (answ != null) { if ((pingOption & PingOption.finger) != 0) { foreach (Topology.TopologyPlugin.RoutingTable.FTableEntry fte in m_topology.routing_table.FingerTable) { if (fte.Finger == dest.destination_data.ressource_id) { fte.dtLastSuccessfullFinger = DateTime.Now; fte.Successor = reloadRcvMsg.OriginatorID; fte.pinging = true; } } /* Attach if not attached */ if (!m_topology.routing_table.IsAttached(reloadRcvMsg.OriginatorID)) Arbiter.Activate(m_DispatcherQueue, new IterativeTask<Destination, NodeId, AttachOption>(new Destination(reloadRcvMsg.OriginatorID), reloadRcvMsg.LastHopNodeId, AttachOption.sendping, AttachProcedure)); else if (reloadRcvMsg.OriginatorID != reloadRcvMsg.LastHopNodeId)// Send ping to get/keep a physical connection Arbiter.Activate(m_DispatcherQueue, new IterativeTask<Destination, PingOption>(new Destination(reloadRcvMsg.OriginatorID), PingOption.direct, SendPing)); } } } } else { if (dest.type == DestinationType.node) { m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_WARNING, String.Format("Ping failed: removing node {0}", dest.destination_data.node_id)); m_topology.routing_table.Leave(dest.destination_data.node_id); } m_statistics.IncTransmissionError(); } if (dest.type == DestinationType.node) m_topology.routing_table.SetPinging(dest.destination_data.node_id, false, answ != null); } catch (Exception ex) { m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_ERROR, "Send Ping: " + ex.Message); } }
// --josch /// <summary> /// Proprietary: Stores the Usage data in a different RELOAD overlay using viaGateWay as gateway /// </summary> /// <param name="ResourceName"></param> /// <param name="kind_data"></param> /// <param name="viaGateWay"></param> /// <returns></returns> public IEnumerator<ITask> Store(string ResourceName, List<StoreKindData> kind_data, NodeId viaGateWay) { if (m_ReloadConfig.IamClient) m_ReloadConfig.StartStoreMobile = DateTime2.Now; else m_ReloadConfig.StartStore = DateTime.Now; ReloadDialog reloadDialog = null; ReloadMessage reloadSendMsg; ResourceId res_id = new ResourceId(ResourceName); //List<StoreKindData> kind_data = new List<StoreKindData>(); Node node = null; if (viaGateWay != null) { //NodeId gateway = new ResourceId(viaGateWay); node = m_topology.routing_table.FindNextHopTo(viaGateWay, true, false); m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_USAGE, String.Format("Store {0} as ResID: {1} via Gateway {2}", ResourceName, res_id, viaGateWay)); if (m_ReloadConfig.IamClient && node == null) { node = m_ReloadConfig.AdmittingPeer; } foreach (StoreKindData storeKindData in kind_data) { if (node == null || node.Id == m_ReloadConfig.LocalNodeID) { m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_TOPO, String.Format("Local storage at NodeId {0}", node.Id)); m_topology.Store(res_id, storeKindData); yield break; } } Destination gateway = new Destination(new NodeId(viaGateWay.Data)); Destination storeDestination = new Destination(res_id); StoreReq storeRequest = new StoreReq(storeDestination.destination_data.ressource_id, kind_data, m_machine.UsageManager, false); reloadSendMsg = create_reload_message(gateway, ++m_ReloadConfig.TransactionID, storeRequest); reloadSendMsg.forwarding_header.destination_list.Add(storeDestination); //this is the real destination if (reloadSendMsg.AddDestinationOverlay(ResourceName)) m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_ERROR, "AddDestinationOverlay successful"); } else { res_id = new ResourceId(ResourceName); m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_USAGE, String.Format("Store {0} as ResID: {1}", ResourceName, res_id)); node = m_topology.routing_table.FindNextHopTo(new NodeId(res_id), true, false); if (m_ReloadConfig.IamClient && node == null) { node = m_ReloadConfig.AdmittingPeer; } if (node == null || node.Id == m_ReloadConfig.LocalNodeID) { foreach (StoreKindData storeKindData in kind_data) { m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_TOPO, String.Format("Local storage at NodeId {0}", node.Id)); m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_MEASURE, "Store:0,011111"); m_topology.Store(res_id, storeKindData); } if (storeDone != null) storeDone.Post(reloadDialog); yield break; } reloadSendMsg = create_store_req(new Destination(res_id), kind_data, false); } int RetransmissionTime = ReloadGlobals.RetransmissionTime + ReloadGlobals.MaxTimeToSendPacket; int iRetrans = ReloadGlobals.MaxRetransmissions; while (iRetrans >= 0 && m_ReloadConfig.State < ReloadConfig.RELOAD_State.Exit) { try { reloadDialog = new ReloadDialog(m_ReloadConfig, m_flm, node); m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_RELOAD, String.Format("{0} ==> {1} TransId={2:x16}", reloadSendMsg.reload_message_body.RELOAD_MsgCode.ToString().PadRight(16, ' '), node.Id, reloadSendMsg.TransactionID)); Arbiter.Activate(m_DispatcherQueue, new IterativeTask<ReloadMessage, ReloadMessageFilter, int>(reloadSendMsg, new ReloadMessageFilter(reloadSendMsg.TransactionID), RetransmissionTime, reloadDialog.Execute)); } catch (Exception ex) { storeDone.Post(reloadDialog); m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_ERROR, "Send Store: " + ex.Message); ReloadGlobals.PrintException(m_ReloadConfig, ex); } yield return Arbiter.Receive(false, reloadDialog.Done, done => { }); if (!reloadDialog.Error && reloadDialog.ReceivedMessage != null) break; /* If a response has not been received when the timer fires, the request is retransmitted with the same transaction identifier. */ --iRetrans; } try { if (!reloadDialog.Error && reloadDialog.ReceivedMessage != null) { //the SourceNodeID delivered from reloadDialog comes from connection table and is the last hop of the message ReloadMessage reloadRcvMsg = reloadDialog.ReceivedMessage; if (reloadRcvMsg.reload_message_body.RELOAD_MsgCode == RELOAD_MessageCode.Store_Answer) { m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_USAGE, String.Format("Store successful:{0} <== {1} TransId={2:x16}", reloadRcvMsg.reload_message_body.RELOAD_MsgCode.ToString().PadRight(16, ' '), reloadRcvMsg.OriginatorID, reloadRcvMsg.TransactionID)); m_ReloadConfig.EndStore = DateTime.Now; TimeSpan storeSpan = storeSpan = m_ReloadConfig.EndStore - m_ReloadConfig.StartStore; if (m_ReloadConfig.IamClient) storeSpan = DateTime2.Now - m_ReloadConfig.StartStoreMobile; m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_MEASURE, String.Format("Store:{0}", storeSpan.TotalSeconds.ToString())); if (storeDone != null) storeDone.Post(reloadDialog); } } else { m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_WARNING, String.Format("Store failed")); m_statistics.IncTransmissionError(); } } catch (Exception ex) { m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_ERROR, "Send Store 2: " + ex.Message); ReloadGlobals.PrintException(m_ReloadConfig, ex); } if (m_ReloadConfig.State == ReloadConfig.RELOAD_State.Shutdown) m_machine.Finish(); }
/// <summary> /// Stores the Usage data in the RELOAD overlay /// </summary> /// <param name="ResourceName"></param> /// <param name="DestUrl"></param> /// <param name="exists">if true, stores the values, else stores a "non-existent" value.</param> /// <param name="usages">The Usage data to be stored.</param> /// <returns></returns> public IEnumerator<ITask> Store(string ResourceName, List<StoreKindData> kind_data) { if (m_ReloadConfig.IamClient) m_ReloadConfig.StartStoreMobile = DateTime2.Now; else m_ReloadConfig.StartStore = DateTime.Now; ReloadDialog reloadDialog = null; ReloadMessage reloadSendMsg; ResourceId res_id = new ResourceId(ResourceName); m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_USAGE, String.Format("Store {0} as ResID: {1}", ResourceName, res_id)); Node node = m_topology.routing_table.FindNextHopTo(new NodeId(res_id), true, false); if (m_ReloadConfig.IamClient && node == null) { node = m_ReloadConfig.AdmittingPeer; } if (node == null || node.Id == m_ReloadConfig.LocalNodeID) { foreach (StoreKindData storeKindData in kind_data) { m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_TOPO, String.Format("Local storage at NodeId {0}", node.Id)); m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_MEASURE, "Store:0,011111"); m_topology.Store(res_id, storeKindData); } // REPLICATEST // incoming store request is not a replication request int numberReplicas = m_topology.routing_table.Successors.Count >= 2 ? 2 : m_topology.routing_table.Successors.Count; // Replica number is max 2 // send replica to all successors for (int i = 0; i < numberReplicas; i++) { NodeId successorNode = m_topology.routing_table.Successors[i]; ReloadMessage replica = create_store_req(new Destination(successorNode), res_id, kind_data, true); send(replica, m_topology.routing_table.GetNode(successorNode)); } if (storeDone != null) storeDone.Post(reloadDialog); yield break; } Destination dest = new Destination(res_id); reloadSendMsg = create_store_req(dest, kind_data, false); int RetransmissionTime = ReloadGlobals.RetransmissionTime + ReloadGlobals.MaxTimeToSendPacket; int iRetrans = ReloadGlobals.MaxRetransmissions; while (iRetrans >= 0 && m_ReloadConfig.State < ReloadConfig.RELOAD_State.Exit) { try { reloadDialog = new ReloadDialog(m_ReloadConfig, m_flm, node); m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_RELOAD, String.Format("{0} ==> {1} TransId={2:x16}", reloadSendMsg.reload_message_body.RELOAD_MsgCode.ToString().PadRight(16, ' '), node.Id, reloadSendMsg.TransactionID)); Arbiter.Activate(m_DispatcherQueue, new IterativeTask<ReloadMessage, ReloadMessageFilter, int>(reloadSendMsg, new ReloadMessageFilter(reloadSendMsg.TransactionID), RetransmissionTime, reloadDialog.Execute)); } catch (Exception ex) { storeDone.Post(reloadDialog); m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_ERROR, "Send Store: " + ex.Message); ReloadGlobals.PrintException(m_ReloadConfig, ex); break; } yield return Arbiter.Receive(false, reloadDialog.Done, done => { }); //if (!reloadDialog.Error && reloadDialog.ReceivedMessage != null && reloadDialog.ReceivedMessage.reload_message_body.RELOAD_MsgCode == RELOAD_MessageCode.Store_Answer) // break; if (!reloadDialog.Error && reloadDialog.ReceivedMessage != null && reloadDialog.ReceivedMessage.reload_message_body.RELOAD_MsgCode == RELOAD_MessageCode.Store_Answer) { ReloadMessage reloadRcvMsg = reloadDialog.ReceivedMessage; if (dest.type == DestinationType.node) { if (reloadRcvMsg.OriginatorID != dest.destination_data.node_id) { // drop message and retransmit request reloadRcvMsg = null; } } else if (dest.type == DestinationType.resource) { int suc = m_topology.routing_table.GetSuccessorCount(false); int pre = m_topology.routing_table.GetPredecessorCount(false); if (suc >= 2 && pre >= 2) { // check if resource is mapping to a node in my routing table if (dest.destination_data.ressource_id.ElementOfInterval( m_topology.routing_table.Predecessors[pre - 2], m_topology.routing_table.Successors[suc - 1], true) ) { if (reloadRcvMsg.OriginatorID < m_topology.routing_table.Predecessors[pre - 2] && reloadRcvMsg.OriginatorID > m_topology.routing_table.Successors[suc - 1]) { // drop message and retransmit request reloadRcvMsg = null; } } } } if (reloadRcvMsg != null) break; } /* If a response has not been received when the timer fires, the request is retransmitted with the same transaction identifier. */ --iRetrans; } try { if (!reloadDialog.Error && reloadDialog.ReceivedMessage != null) { //the SourceNodeID delivered from reloadDialog comes from connection table and is the last hop of the message ReloadMessage reloadRcvMsg = reloadDialog.ReceivedMessage; if (reloadRcvMsg.reload_message_body.RELOAD_MsgCode == RELOAD_MessageCode.Store_Answer) { m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_USAGE, String.Format("Store successful:{0} <== {1} TransId={2:x16}", reloadRcvMsg.reload_message_body.RELOAD_MsgCode.ToString().PadRight(16, ' '), reloadRcvMsg.OriginatorID, reloadRcvMsg.TransactionID)); m_ReloadConfig.EndStore = DateTime.Now; TimeSpan storeSpan = storeSpan = m_ReloadConfig.EndStore - m_ReloadConfig.StartStore; if (m_ReloadConfig.IamClient) storeSpan = DateTime2.Now - m_ReloadConfig.StartStoreMobile; m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_MEASURE, String.Format("Store:{0}", storeSpan.TotalSeconds.ToString())); if (storeDone != null) storeDone.Post(reloadDialog); } } else { m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_WARNING, String.Format("Store failed")); m_statistics.IncTransmissionError(); } } catch (Exception ex) { m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_ERROR, "Send Store 2: " + ex.Message); ReloadGlobals.PrintException(m_ReloadConfig, ex); } if (m_ReloadConfig.State == ReloadConfig.RELOAD_State.Shutdown) m_machine.Finish(); }
} // End PreJoin /// <summary> /// Attaches to a node needed to enrich the finger table. /// </summary> /// <param name="finger"></param> /// <returns></returns> public IEnumerator<ITask> AttachFinger(FTEntry finger, Port<bool> attachNext) { Destination dest = new Destination(finger.Finger); ReloadMessage reloadSendMsg = create_attach_req(dest, false); ReloadDialog reloadDialog = null; int RetransmissionTime = ReloadGlobals.RetransmissionTime + ReloadGlobals.MaxTimeToSendPacket; int iRetrans = ReloadGlobals.MaxRetransmissions; Boolean NextHopIsDestination = false; var myNodeId = m_topology.LocalNode.Id; Node nextHopNode = NextHopToDestination(dest, ref NextHopIsDestination); if (nextHopNode == null || nextHopNode.Id == m_ReloadConfig.LocalNodeID) nextHopNode = m_ReloadConfig.AdmittingPeer; if (nextHopNode == null) //{ m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_ERROR, String.Format("No Route to Finger! {0}", finger.Finger)); //attachNext.Post(true); // yield break; //} //else { while (iRetrans >= 0 && m_ReloadConfig.State < ReloadConfig.RELOAD_State.Shutdown) { try { reloadDialog = new ReloadDialog(m_ReloadConfig, m_flm, nextHopNode); m_forwarding.LoopedTrans = new Port<UInt64>(); if (reloadDialog == null) m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_RELOAD, "ReloadDialog null!"); m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_TOPO, String.Format("Finger-{0} via {1} ==> Dest={2} TransId={3:x16}", RELOAD_MessageCode.Attach_Request.ToString().PadRight(16, ' '), nextHopNode, dest.ToString(), reloadSendMsg.TransactionID)); Arbiter.Activate(m_DispatcherQueue, new IterativeTask<ReloadMessage, ReloadMessageFilter, int>(reloadSendMsg, new ReloadMessageFilter(reloadSendMsg.TransactionID), RetransmissionTime, reloadDialog.Execute)); } catch (Exception e) { m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_ERROR, String.Format("AttachFinger: " + e)); attachNext.Post(true); yield break; } bool gotLoop = false; yield return Arbiter.Choice( /* Success, Attached to finger */ Arbiter.Receive(false, reloadDialog.Done, done => { }), /* Loop detected */ Arbiter.Receive(false, m_forwarding.LoopedTrans, transId => { if (transId == reloadSendMsg.TransactionID) { m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_ERROR, String.Format("Not re-sending transaction: {0:x16}=> a loopback detected!", reloadSendMsg.TransactionID)); gotLoop = true; m_forwarding.LoopedTrans = new Port<ulong>(); } })); if (gotLoop) { attachNext.Post(true); yield break; ; } if (!reloadDialog.Error && reloadDialog.ReceivedMessage != null) break; // If a response has not been received when the timer fires, the request // is retransmitted with the same transaction identifier. --iRetrans; if (iRetrans >= 0) { m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_WARNING, String.Format("Retrans {0} SendAttach via {1} TransId={2:x16}", iRetrans, nextHopNode, reloadSendMsg.TransactionID)); m_ReloadConfig.Statistics.IncRetransmission(); } else { m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_ERROR, String.Format("Failed! SendAttach via {0} TransId={1:x16}", nextHopNode, reloadSendMsg.TransactionID)); m_ReloadConfig.Statistics.IncTransmissionError(); if (dest.destination_data.node_id != null) m_topology.routing_table.SetNodeState(dest.destination_data.node_id, NodeState.unknown); } // } } try { if (reloadDialog != null && !reloadDialog.Error && reloadDialog.ReceivedMessage != null) { /*the SourceNodeID delivered from reloadDialog comes from connection * table and is the last hop of the message */ ReloadMessage reloadRcvMsg = reloadDialog.ReceivedMessage; RELOAD_MessageCode msgCode = reloadRcvMsg.reload_message_body.RELOAD_MsgCode; AttachReqAns answ = null; if (msgCode == RELOAD_MessageCode.Attach_Answer) { answ = (AttachReqAns)reloadRcvMsg.reload_message_body; m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_TOPO, String.Format("Finger-{0} <== {1} TransId={2:x16}", msgCode.ToString().PadRight(16, ' '), reloadRcvMsg.OriginatorID, reloadRcvMsg.TransactionID)); Node originator = new Node(reloadRcvMsg.OriginatorID, answ.ice_candidates); NodeState nodeState = m_topology.routing_table.GetNodeState(originator.Id); if (nodeState == NodeState.unknown) { attachNext.Post(true); m_topology.routing_table.AddNode(originator); m_topology.routing_table.SetNodeState(originator.Id, NodeState.attached); m_topology.routing_table.AddFinger(originator, NodeState.attached); m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_USAGE, String.Format("Got a finger! {0}", originator.Id)); } /* we know this peer, further Attaches will return same peer */ else attachNext.Post(false); } } } catch (Exception e) { m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_ERROR, String.Format("AttachFingers:" + e)); } }
/// <summary> /// JP also needs to populate its finger table (for the Chord based DHT). /// It issues an Attach to a variety of locations around the overlay. /// see RELOAD base -17 p.129 /// </summary> /// <returns></returns> public List<FTableEntry> AttachFingers() { var fingerCount = ReloadGlobals.FINGER_TABLE_ENTRIES; if (!((fingerCount & (fingerCount - 1)) == 0)) // fingerCount = 2^n ? fingerCount = 16; // fallback to 16 entries List<FTableEntry> fingers = new List<FTableEntry>(); int offset = m_FingerTable.Count / fingerCount; for (int i = 0; i < m_FingerTable.Count; i += offset) { var res = m_FingerTable[i].Finger; Destination dest = new Destination(m_FingerTable[i].Finger); fingers.Add(m_FingerTable[i]); } return fingers; } // end AttachFingers
public ReloadMessage create_join_answ(Destination destination, UInt64 trans_id) { return create_reload_message(destination, trans_id, new JoinReqAns(null, false)); }
public IEnumerator<ITask> AttachProcedure(Destination dest, NodeId NextHopId, AttachOption attach_option) { ReloadMessage reloadSendMsg; /* 9.5.1 * When a peer needs to Attach to a new peer in its neighbor table, it MUST source-route the Attach request through the peer from which it learned the new peer's Node-ID. Source-routing these requests allows the overlay to recover from instability. */ reloadSendMsg = create_attach_req(dest, (attach_option & AttachOption.forceupdate) != 0); if (dest.type == DestinationType.node) { NodeState nodestate = m_topology.routing_table.GetNodeState(dest.destination_data.node_id); if (nodestate == NodeState.attaching) { m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_INFO, String.Format("Ignoring redundant Attach for {0}", dest)); yield break; } } Boolean NextHopIsDestination = false; Node NextHopNode = null; if (NextHopId != null) NextHopNode = m_topology.routing_table.GetNode(NextHopId); if (NextHopNode == null) NextHopNode = NextHopToDestination(dest, ref NextHopIsDestination); if (NextHopNode == null) yield break; if (dest.type == DestinationType.node) m_topology.routing_table.SetNodeState(dest.destination_data.node_id, NodeState.attaching); ReloadDialog reloadDialog = null; int RetransmissionTime = ReloadGlobals.RetransmissionTime + ReloadGlobals.MaxTimeToSendPacket; int iRetrans = ReloadGlobals.MaxRetransmissions; while (iRetrans >= 0 && m_ReloadConfig.State < ReloadConfig.RELOAD_State.Shutdown) { try { /* use a new ReloadDialog instance for every usage, Monitor requires it */ reloadDialog = new ReloadDialog(m_ReloadConfig, m_flm, NextHopNode); m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_RELOAD, String.Format("{0} via {1} ==> Dest={2} TransId={3:x16}", RELOAD_MessageCode.Attach_Request.ToString().PadRight(16, ' '), NextHopNode, dest.ToString(), reloadSendMsg.TransactionID)); Arbiter.Activate(m_DispatcherQueue, new IterativeTask<ReloadMessage, ReloadMessageFilter, int>(reloadSendMsg, new ReloadMessageFilter(reloadSendMsg.TransactionID), RetransmissionTime, reloadDialog.Execute)); } catch (Exception ex) { m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_ERROR, "AttachProcedure: " + ex.Message); yield break; } yield return Arbiter.Receive(false, reloadDialog.Done, done => { }); if (!reloadDialog.Error && reloadDialog.ReceivedMessage != null) { ReloadMessage reloadRcvMsg = reloadDialog.ReceivedMessage; if (dest.type == DestinationType.node) { if (reloadRcvMsg.OriginatorID != dest.destination_data.node_id) { // drop message and retransmit request m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_ERROR, String.Format("Received answer from unexpected peer")); reloadRcvMsg = null; } } else if (dest.type == DestinationType.resource) { int suc = m_topology.routing_table.GetSuccessorCount(false); int pre = m_topology.routing_table.GetPredecessorCount(false); if (suc >= 2 && pre >= 2) { // check if resource is mapping to a node in my routing table if (dest.destination_data.ressource_id.ElementOfInterval( m_topology.routing_table.Predecessors[pre - 2], m_topology.routing_table.Successors[suc - 1], true) ) { if (reloadRcvMsg.OriginatorID < m_topology.routing_table.Predecessors[pre - 2] && reloadRcvMsg.OriginatorID > m_topology.routing_table.Successors[suc - 1]) { // drop message and retransmit request m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_ERROR, String.Format("Received answer from unexpected peer")); reloadRcvMsg = null; } } } } if (reloadRcvMsg != null) break; } /* If a response has not been received when the timer fires, the request is retransmitted with the same transaction identifier. */ --iRetrans; if (iRetrans >= 0) { m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_WARNING, String.Format("Retrans {0} SendAttach via {1} TransId={2:x16}", iRetrans, NextHopNode, reloadSendMsg.TransactionID)); m_ReloadConfig.Statistics.IncRetransmission(); } else { m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_ERROR, String.Format("Failed! SendAttach via {0} TransId={1:x16}", NextHopNode, reloadSendMsg.TransactionID)); m_ReloadConfig.Statistics.IncTransmissionError(); if (dest.destination_data.node_id != null) { //m_topology.routing_table.SetNodeState(dest.destination_data.node_id, NodeState.unknown); m_topology.routing_table.Leave(dest.destination_data.node_id); } } } try { if (reloadDialog != null && !reloadDialog.Error && reloadDialog.ReceivedMessage != null) { /*the SourceNodeID delivered from reloadDialog comes from connection * table and is the last hop of the message */ ReloadMessage reloadRcvMsg = reloadDialog.ReceivedMessage; RELOAD_MessageCode msgCode = reloadRcvMsg.reload_message_body.RELOAD_MsgCode; AttachReqAns answ = (AttachReqAns)reloadRcvMsg.reload_message_body; if (msgCode == RELOAD_MessageCode.Attach_Answer) { /* TKTODO * 1. The response to a message sent to a specific Node-ID MUST have been sent by that Node-ID. 2. The response to a message sent to a Resource-Id MUST have been sent by a Node-ID which is as close to or closer to the target Resource-Id than any node in the requesting node's neighbor table. */ if (answ != null) { Node Originator = new Node(reloadRcvMsg.OriginatorID, answ.ice_candidates); /* An Attach in and of itself does not result in updating the routing * table of either node. * Note: We use the routing table here only for storing ice candidates * for later use, we will not update successor or predecessor list */ m_topology.routing_table.AddNode(Originator); m_topology.routing_table.SetNodeState(Originator.Id, NodeState.attached); m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_RELOAD, String.Format("{0} <== {1} last={2} TransId={3:x16}", msgCode.ToString().PadRight(16, ' '), reloadRcvMsg.OriginatorID, reloadRcvMsg.LastHopNodeId, reloadRcvMsg.TransactionID)); if ((CheckAndSetAdmittingPeer(Originator) && Originator.Id != reloadRcvMsg.LastHopNodeId) || (attach_option & AttachOption.sendping) != 0) { // Send ping to get a physical connection Arbiter.Activate(m_DispatcherQueue, new IterativeTask<Destination, PingOption>(new Destination(Originator.Id), PingOption.direct, SendPing)); } } } else if (msgCode == RELOAD_MessageCode.Error) { if (dest.type == DestinationType.node) { ErrorResponse error = (ErrorResponse)reloadRcvMsg.reload_message_body; if (error != null) { m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_ERROR, String.Format("AttachProcedure: Got Error {0} from {1} deleting {2}", error.ErrorMsg, reloadRcvMsg.OriginatorID, dest.destination_data.node_id)); m_topology.routing_table.Leave(dest.destination_data.node_id); } } } } } catch (Exception ex) { m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_ERROR, "AttachProcedure: " + ex.Message); if (dest.destination_data.node_id != null) m_topology.routing_table.SetNodeState(dest.destination_data.node_id, NodeState.unknown); } }
public ReloadMessage create_update_req(Destination destination, TopologyPlugin.RoutingTable rt, ChordUpdateType type) { return create_reload_message(destination, ++m_ReloadConfig.TransactionID, new UpdateReqAns(rt.GetApproved(rt.Successors), rt.GetApproved(rt.Predecessors), type, m_ReloadConfig.StartTime)); }
public Node NextHopToDestination(Destination dest, ref bool direct) { Node NextHopNode = null; direct = false; if (dest.type == DestinationType.node) { NextHopNode = m_topology.routing_table.GetNode(dest.destination_data.node_id); if (NextHopNode == null) /* The Topology Plugin is responsible for maintaining the overlay algorithm Routing Table, which is consulted by the Forwarding and Link Management Layer before routing a message. */ NextHopNode = m_topology.routing_table.FindNextHopTo( dest.destination_data.node_id, true, false); else direct = true; } else { NextHopNode = m_topology.routing_table.FindNextHopTo(new NodeId( dest.destination_data.ressource_id), true, false); } if (NextHopNode == null) m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_ERROR, "Did not found next hop to: " + dest); return NextHopNode; }
public ReloadMessage create_leave_req(Destination destination) { return create_reload_message(destination, ++m_ReloadConfig.TransactionID, new LeaveReqAns(m_topology.LocalNode, true)); }
private ReloadMessage create_reload_message(Destination destination, UInt64 trans_id, RELOAD_MessageBody reload_content) { // markus if (reload_content.RELOAD_MsgCode == RELOAD_MessageCode.Attach_Request) { try { m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_INFO, String.Format("Add candidates to Dictionary: Transaction ID: {0:x}", trans_id)); foreach (IceCandidate cand in ((AttachReqAns)reload_content).ice_candidates) m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_INFO, String.Format("Add candidate: {0}:{1}", cand.addr_port.ipaddr.ToString(), cand.addr_port.port)); if (!m_attachRequestCandidates.ContainsKey(trans_id)) // because retry uses same transid m_attachRequestCandidates.Add(trans_id, ((AttachReqAns)reload_content).ice_candidates); } catch (Exception) { throw; } } // markus end return new ReloadMessage(m_ReloadConfig, m_topology.LocalNode.Id, destination, trans_id, reload_content); }
public ReloadMessage create_ping_req(Destination destination) { return create_reload_message(destination, ++m_ReloadConfig.TransactionID, new PingReqAns(0, true)); }
/// <summary> /// Creates an Attach request /// </summary> /// <param name="destination">The destination of this attach</param> /// <param name="fForceSendUpdate">Flag ForceSendUpdate</param> /// <returns></returns> public ReloadMessage create_attach_req(Destination destination, Boolean fForceSendUpdate) { //return create_reload_message(destination, ++m_ReloadConfig.TransactionID, // markus: commented out // new AttachReqAns(m_topology.LocalNode, true, fForceSendUpdate)); bool gatherActiveHostOnly = false; if (destination == new Destination(new ResourceId(m_topology.LocalNode.Id + (byte)1))) gatherActiveHostOnly = true; else { foreach (BootstrapServer bss in m_machine.BootstrapServer) { var test = new Destination(new ResourceId(bss.NodeId)); if (destination == new Destination(new ResourceId(bss.NodeId + (byte)1))) { gatherActiveHostOnly = true; break; } } //if (!gatherActiveHostOnly) //{ // foreach (FTEntry ftentry in m_topology.routing_table.FingerTable) // { // var test = new Destination(ftentry.Finger); // if (destination == new Destination(ftentry.Finger)) // { // gatherActiveHostOnly = true; // break; // } // } //} } // markus return create_reload_message(destination, ++m_ReloadConfig.TransactionID, new AttachReqAns(m_topology.LocalNode, true, fForceSendUpdate, m_ReloadConfig.IsBootstrap, gatherActiveHostOnly)); }
/// <summary> /// Creates a StoreReq that can be directed a specific NodeId /// </summary> /// <param name="destination">The store destination NodeId</param> /// <param name="resourceId">The Id of the resource to store</param> /// <returns>A complete RELOAD StoreReq message including all headers</returns> public ReloadMessage create_store_req(Destination destination, ResourceId resourceId, List<StoreKindData> stored_kind_data, bool replica) { return create_reload_message(destination, ++m_ReloadConfig.TransactionID, new StoreReq(resourceId, stored_kind_data, m_machine.UsageManager, replica)); }
public ReloadMessage create_app_attach_req(Destination destination) { return create_reload_message(destination, ++m_ReloadConfig.TransactionID, new AppAttachReqAns(m_topology.LocalNode, true)); }
/// <summary> /// Creates a FetchReq using the given StoredDataSpecifiers /// </summary> /// <param name="destination">The destination</param> /// <param name="specifiers">The StoredDataSpecifiers</param> /// <returns>A FetchReq</returns> private ReloadMessage create_fetch_req(Destination destination, List<StoredDataSpecifier> specifiers) { return create_reload_message(destination, ++m_ReloadConfig.TransactionID, new FetchReq(destination.destination_data.ressource_id, specifiers, m_machine.UsageManager)); }
public ReloadMessage create_attach_answ(Destination destination, UInt64 trans_id) { //return create_reload_message(destination, trans_id, new AttachReqAns(m_topology.LocalNode, false, true)); //return create_reload_message(destination, trans_id, // markus: commented out // new AttachReqAns(m_topology.LocalNode, false, false)); // markus return create_reload_message(destination, trans_id, new AttachReqAns(m_topology.LocalNode, false, false, m_ReloadConfig.IsBootstrap, false)); // bootstrap doesnt send attach requests => attach answer never goes to bootstrap => 4th parameter false }
public ReloadMessage create_erro_reply(Destination destination, RELOAD_ErrorCode error, string errmsg, UInt64 trans_id) { return create_reload_message(destination, trans_id, new ErrorResponse(error, errmsg)); }
public ReloadMessage create_app_attach_answ(Destination destination, UInt64 trans_id) { return create_reload_message(destination, trans_id, new AppAttachReqAns(m_topology.LocalNode, false)); }
public IEnumerator<ITask> PreJoinProdecure(List<BootstrapServer> BootstrapServerList) { bool attached = false; ulong bsTransId = 0; if (m_topology.LocalNode.Id == null) yield break; ReloadMessage reloadSendMsg; ReloadMessage reloadRcvMsg = null; /* This is the begin of populating the neighbor table convert local node to resource id + 1 and sent an attach to it */ Destination dest = new Destination(new ResourceId( m_topology.LocalNode.Id + (byte)1)); Destination last_destination = null; Node NextHopNode = null; int succSize = m_ReloadConfig.IamClient ? 1 : ReloadGlobals.SUCCESSOR_CACHE_SIZE; for (int i = 0; i < succSize; i++) { //if (last_destination != null && last_destination == dest) if (last_destination != null && last_destination.Equals(dest)) // markus: we have to use Equals method break; if (m_ReloadConfig.IamClient) reloadSendMsg = create_attach_req(dest, false); else reloadSendMsg = create_attach_req(dest, true); //we do not know the bootstrap peer's node id so far so we leave that parameter empty Node(null) ReloadDialog reloadDialog = null; int RetransmissionTime = ReloadGlobals.RetransmissionTime + ReloadGlobals.MaxTimeToSendPacket; /* Modification for Clients out of draft, TLS stack will take some time * to initialize, add another 10s waiting */ if (m_ReloadConfig.IamClient && i == 0) RetransmissionTime += 10000; int iRetrans = ReloadGlobals.MaxRetransmissions; int iCycleBootstrap = 0; while (iRetrans >= 0 && m_ReloadConfig.State < ReloadConfig.RELOAD_State.Shutdown) { /* This is the first bootstrap contacting sequence if NextHopNode * is still zero, in any other case * use an attach to the node where we got the last answer from */ if (NextHopNode == null) { /* we could use a foreach loop, but CCR would multitask it, but we * want serialize that here */ if (iCycleBootstrap >= BootstrapServerList.Count()) iCycleBootstrap = 0; BootstrapServer bss = BootstrapServerList[iCycleBootstrap++]; if (attached == true) break; //TKTODO Rejoin of bootstrap server not solved List<IceCandidate> ics = new List<IceCandidate>(); IceCandidate ice = new IceCandidate(new IpAddressPort( AddressType.IPv4_Address, ReloadGlobals.IPAddressFromHost( m_ReloadConfig, bss.Host), (UInt16)bss.Port), Overlay_Link.TLS_TCP_FH_NO_ICE); // markus: change cand_type to bootstrap ice.cand_type = CandType.tcp_bootstrap; ics.Add(ice); NextHopNode = new Node(reloadRcvMsg == null ? null : reloadRcvMsg.OriginatorID, ics); } try { /* use a new ReloadDialog instance for every usage, Monitor requires it */ reloadDialog = new ReloadDialog(m_ReloadConfig, m_flm, NextHopNode); if (iCycleBootstrap > 0) { // save transaction id from request to bootstrap if (NextHopNode.IceCandidates[0].addr_port.ipaddr.ToString() == BootstrapServerList[iCycleBootstrap - 1].Host && NextHopNode.IceCandidates[0].addr_port.port == BootstrapServerList[iCycleBootstrap - 1].Port) bsTransId = reloadSendMsg.TransactionID; } m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_RELOAD, String.Format("{0} ==> {1} Dest={2} TransId={3:x16}", RELOAD_MessageCode.Attach_Request.ToString().PadRight(16, ' '), NextHopNode, dest.ToString(), reloadSendMsg.TransactionID)); Arbiter.Activate(m_DispatcherQueue, new IterativeTask<ReloadMessage, ReloadMessageFilter, int>( reloadSendMsg, new ReloadMessageFilter(reloadSendMsg.TransactionID), RetransmissionTime, reloadDialog.Execute)); } catch (Exception ex) { m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_ERROR, "PreJoinProcedure: " + ex.Message); } yield return Arbiter.Receive(false, reloadDialog.Done, done => { }); if (!reloadDialog.Error && reloadDialog.ReceivedMessage != null) { if (reloadDialog.ReceivedMessage.TransactionID == bsTransId) { if (reloadDialog.ReceivedMessage.forwarding_header.via_list.Count == 1) { BootstrapServer bsServer = BootstrapServerList[iCycleBootstrap - 1]; bsServer.NodeId = reloadDialog.ReceivedMessage.forwarding_header.via_list[0].destination_data.node_id; BootstrapServerList.RemoveAt(iCycleBootstrap - 1); BootstrapServerList.Insert(iCycleBootstrap - 1, bsServer); m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_RELOAD, String.Format("Bootstrap ID: {0}", reloadDialog.ReceivedMessage.forwarding_header.via_list[0].destination_data.node_id)); //Console.WriteLine("Bootstrap ID: {0}", reloadDialog.ReceivedMessage.forwarding_header.via_list[0].destination_data.node_id); } else if (reloadDialog.ReceivedMessage.forwarding_header.via_list.Count == 2) { BootstrapServer bsServer = BootstrapServerList[iCycleBootstrap - 1]; bsServer.NodeId = reloadDialog.ReceivedMessage.forwarding_header.via_list[1].destination_data.node_id; BootstrapServerList.RemoveAt(iCycleBootstrap - 1); BootstrapServerList.Insert(iCycleBootstrap - 1, bsServer); m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_RELOAD, String.Format("Bootstrap ID: {0}", reloadDialog.ReceivedMessage.forwarding_header.via_list[1].destination_data.node_id)); //Console.WriteLine("Bootstrap ID: {0}", reloadDialog.ReceivedMessage.forwarding_header.via_list[1].destination_data.node_id); } bsTransId = 0; } break; } /* still bootstrapping, allow cycling trough different bootstraps by * resetting NextHopNode */ if (i == 0) NextHopNode = null; /* If a response has not been received when the timer fires, the request is retransmitted with the same transaction identifier. */ --iRetrans; if (iRetrans >= 0) { m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_WARNING, String.Format("Retrans {0} Attach {1} TransId={2:x16}", iRetrans, NextHopNode, reloadSendMsg.TransactionID)); m_statistics.IncRetransmission(); } else { m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_ERROR, String.Format("Failed! Attach {0} TransId={1:x16}", NextHopNode, reloadSendMsg.TransactionID)); m_statistics.IncTransmissionError(); if (ReloadGlobals.AutoExe) { m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_ERROR, "PreJoin: Exit because initial Attach Faild!"); m_machine.SendCommand("Exit"); } } } try { if (reloadDialog != null && !reloadDialog.Error && reloadDialog.ReceivedMessage != null) { //the SourceNodeID delivered from reloadDialog comes from connection table and is the last hop of the message reloadRcvMsg = reloadDialog.ReceivedMessage; RELOAD_MessageCode msgCode = reloadRcvMsg.reload_message_body.RELOAD_MsgCode; if (reloadRcvMsg != null) { if (msgCode == RELOAD_MessageCode.Attach_Answer) { m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_RELOAD, String.Format("{0} <== {1} last={2} TransId={3:x16}", msgCode.ToString().PadRight(16, ' '), reloadRcvMsg.OriginatorID, reloadRcvMsg.LastHopNodeId, reloadRcvMsg.TransactionID)); AttachReqAns answ = (AttachReqAns)reloadRcvMsg.reload_message_body; if (answ != null) { m_ReloadConfig.State = ReloadConfig.RELOAD_State.PreJoin; m_machine.StateUpdates(ReloadConfig.RELOAD_State.PreJoin); /* An Attach in and of itself does not result in updating the routing * table of either node. * Note: We use the routing table here only for storing ice candidates * for later use, we will not update successor or predecessor list */ NextHopNode = new Node(reloadRcvMsg.OriginatorID, answ.ice_candidates); /* An Attach in and of itself does not result in updating the routing * table of either node. * Note: We use the routing table here only for storing ice candidates * for later use, we will not update successor or predecessor list */ m_topology.routing_table.AddNode(NextHopNode); m_topology.routing_table.SetNodeState(NextHopNode.Id, NodeState.attached); if (CheckAndSetAdmittingPeer(NextHopNode) && NextHopNode.Id != reloadRcvMsg.LastHopNodeId) // Send ping to establish a physical connection Arbiter.Activate(m_DispatcherQueue, new IterativeTask<Destination, PingOption>(new Destination( NextHopNode.Id), PingOption.direct, SendPing)); if (m_ReloadConfig.IamClient) { m_ReloadConfig.LastJoinedTime = DateTime2.Now; TimeSpan joiningTime = m_ReloadConfig.LastJoinedTime - m_ReloadConfig.StartJoinMobile; m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_MEASURE, "Join:" + joiningTime.TotalSeconds.ToString()); } attached = true; } } else if (msgCode == RELOAD_MessageCode.Error) { if (dest.type == DestinationType.node) { ErrorResponse error = (ErrorResponse)reloadRcvMsg.reload_message_body; if (error != null) { m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_ERROR, String.Format("Prejoin: Got Error {0} from {1} deleting {2}", error.ErrorMsg, reloadRcvMsg.OriginatorID, dest.destination_data.node_id)); m_topology.routing_table.Leave(dest.destination_data.node_id); } } } } else { m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_ERROR, "PreJoinProcedure: reloadRcvMsg == null!!"); } last_destination = dest; dest = new Destination(new ResourceId(reloadRcvMsg.OriginatorID) + (byte)1); } else break; } catch (Exception ex) { m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_ERROR, "PreJoinProcedure: " + ex.Message); } } // End Successor Search // FingerTable enrichment if (!m_ReloadConfig.IamClient) { List<FTEntry> fingers = m_topology.routing_table.AttachFingers(); Port<bool> attachNextPort = null; Boolean attachNext = true; /* JP SHOULD send Attach requests to initiate connections to each of * the peers in the neighbor table as well as to the desired finger * table entries. */ foreach (FTEntry finger in fingers) { attachNextPort = new Port<bool>(); Arbiter.Activate(m_DispatcherQueue, new IterativeTask<FTEntry, Port<bool>>( finger, attachNextPort, AttachFinger)); /* Wait for finger attach */ yield return Arbiter.Receive(false, attachNextPort, next => { attachNext = next; }); if (!attachNext) break; } } /* see base -18 p.106 /* 4. JP MUST enter all the peers it has contacted into its routing /* table. */ m_topology.routing_table.Conn2Route(); /* Once JP has a reasonable set of connections it is ready to take its * place in the DHT. It does this by sending a Join to AP. */ if (m_ReloadConfig.AdmittingPeer != null) if (!m_ReloadConfig.IamClient) { m_ReloadConfig.State = ReloadConfig.RELOAD_State.Joining; m_machine.StateUpdates(ReloadConfig.RELOAD_State.Joining); m_topology.routing_table.SetWaitForJoinAnsw( m_ReloadConfig.AdmittingPeer.Id, true); reloadSendMsg = create_join_req( new Destination(m_ReloadConfig.AdmittingPeer.Id)); ReloadDialog reloadDialog = null; int RetransmissionTime = ReloadGlobals.RetransmissionTime + ReloadGlobals.MaxTimeToSendPacket; int iRetrans = ReloadGlobals.MaxRetransmissions; while (iRetrans >= 0 && m_ReloadConfig.State < ReloadConfig.RELOAD_State.Shutdown) { reloadDialog = new ReloadDialog(m_ReloadConfig, m_flm, m_ReloadConfig.AdmittingPeer); m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_RELOAD, String.Format("{0} ==> {1} TransId={2:x16}", RELOAD_MessageCode.Join_Request.ToString().PadRight(16, ' '), m_ReloadConfig.AdmittingPeer, reloadSendMsg.TransactionID)); Arbiter.Activate(m_DispatcherQueue, new IterativeTask<ReloadMessage, ReloadMessageFilter, int>(reloadSendMsg, new ReloadMessageFilter(reloadSendMsg.TransactionID), RetransmissionTime, reloadDialog.Execute)); yield return Arbiter.Receive(false, reloadDialog.Done, done => { }); if (!reloadDialog.Error && reloadDialog.ReceivedMessage != null) break; /* If a response has not been received when the timer fires, the request is retransmitted with the same transaction identifier. */ --iRetrans; if (iRetrans >= 0) { m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_WARNING, String.Format("Retrans {0} Join {1} TransId={2:x16}", iRetrans, m_ReloadConfig.AdmittingPeer, reloadSendMsg.TransactionID)); m_statistics.IncRetransmission(); } else { m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_ERROR, String.Format("Failed! Join {0} TransId={1:x16}", m_ReloadConfig.AdmittingPeer, reloadSendMsg.TransactionID)); m_statistics.IncTransmissionError(); } } try { if (!reloadDialog.Error) { reloadRcvMsg = reloadDialog.ReceivedMessage; RELOAD_MessageCode msgCode = reloadRcvMsg.reload_message_body.RELOAD_MsgCode; if (reloadRcvMsg != null) { if (msgCode == RELOAD_MessageCode.Join_Answer) { m_topology.routing_table.SetWaitForJoinAnsw(reloadRcvMsg.OriginatorID, false); m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_RELOAD, String.Format("{0} <== {1} TransId={2:x16}", msgCode.ToString().PadRight(16, ' '), reloadRcvMsg.OriginatorID, reloadRcvMsg.TransactionID)); NodeState nodestate = m_topology.routing_table.GetNodeState(reloadRcvMsg.OriginatorID); if (nodestate == NodeState.updates_received) { /* we previously received an update from admitting peer (maybe * race condition), now joining is complete in any other case * wait for updates to come from this node */ m_ReloadConfig.State = ReloadConfig.RELOAD_State.Joined; m_machine.StateUpdates(ReloadConfig.RELOAD_State.Joined); m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_RELOAD, String.Format("Joining completed")); m_ReloadConfig.LastJoinedTime = DateTime.Now; TimeSpan joiningTime = m_ReloadConfig.LastJoinedTime - m_ReloadConfig.StartJoining; m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_MEASURE, String.Format("Join:{0}", joiningTime.TotalSeconds.ToString())); m_topology.routing_table.SendUpdateToAllNeighbors(); } else { m_ReloadConfig.LastJoinedTime = DateTime.Now; TimeSpan joiningTime = m_ReloadConfig.LastJoinedTime - m_ReloadConfig.StartTime; m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_MEASURE, String.Format("Join:{0}", joiningTime.TotalSeconds.ToString())); m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_WARNING, String.Format("Prejoin: nodestate != update_recv at Node {0}", m_machine.ReloadConfig.ListenPort)); } //m_topology.routing_table.SendUpdatesToAllFingers(); } } else { m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_ERROR, "PreJoinProcedure: reloadRcvMsg == null!!"); } } } catch (Exception ex) { m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_ERROR, "PreJoinProcedure: " + ex.Message); } } else { if (m_ReloadConfig.SipUri == "") m_ReloadConfig.SipUri = String.Format("{0}@{1}", ReloadGlobals.HostName, m_ReloadConfig.OverlayName); if (m_ReloadConfig.SipUri != null && m_ReloadConfig.SipUri != "") { // explictite SIP registration as minimal config for RELOAD clients IUsage sipRegistration = m_machine.UsageManager.CreateUsage(Usage_Code_Point.SIP_REGISTRATION, 2, m_ReloadConfig.SipUri); sipRegistration.ResourceName = m_ReloadConfig.SipUri; List<StoreKindData> clientRegistrationList = new List<StoreKindData>(); StoreKindData sipKindData = new StoreKindData(sipRegistration.KindId, 0, new StoredData(sipRegistration.Encapsulate(true))); clientRegistrationList.Add(sipKindData); Arbiter.Activate(m_DispatcherQueue, new IterativeTask<string, List<StoreKindData>>(m_ReloadConfig.SipUri, clientRegistrationList, Store)); } } else { m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_MEASURE, String.Format("PreJoinPredure => Node {0} has no admitting peer = {1}!", m_machine.ReloadConfig.ListenPort, m_ReloadConfig.AdmittingPeer)); if (ReloadGlobals.AutoExe) { m_machine.SendCommand("Exit"); } } } // End PreJoin
public bool Equals(Destination dest) { // If parameter is null return false: if ((object)dest == null) { return false; } // Return true if the fields match: return (this.type == dest.type && this.destination_data.node_id == dest.destination_data.node_id && this.destination_data.ressource_id == dest.destination_data.ressource_id); }