public void Store(ResourceId resId, StoreKindData kindData) { string resourceId = resId.ToString(); lock (resources) { if (!resources.ContainsKey(resourceId)) { resources.Add(resourceId, new Resource(resId, s_ReloadConfig)); } Resource resource = resources[resourceId]; foreach (StoredData storedData in kindData.Values) { resource.AddStoredData(kindData.Kind, storedData, kindData.Generation_counter); } ResourceStored(resId, kindData); } }
/// <summary> /// Returns FetchKindResponse structs for a given ResourceId and Specifier /// </summary> /// <param name="resId">The ResourceId</param> /// <param name="specifier">The StoredDataSpecifier</param> /// <param name="fetchKindResponse">The Fetch result als FetchKindResonse</param> /// <returns>true, if value found</returns> public bool Fetch(ResourceId resId, StoredDataSpecifier specifier, out FetchKindResponse fetchKindResponse) { string resouceId = resId.ToString(); lock (resources) { if (!resources.ContainsKey(resouceId)) { fetchKindResponse = new FetchKindResponse(); return false; } Resource resource = resources[resouceId]; List<StoredData> machtes = resource.StoredData(specifier); if (machtes != null && machtes.Count >= 0) { fetchKindResponse = new FetchKindResponse( specifier.kindId, resource.GetGeneration(specifier.kindId), machtes); return true; } } fetchKindResponse = new FetchKindResponse(); return false; }
public UInt32 CurrentIndex(ResourceId resId, UInt32 kindId) { string resourceKindPair = resId.ToString() + kindId.ToString(); if (!indices.ContainsKey(resourceKindPair)) indices.Add(resourceKindPair, 0); UInt32 index = indices[resourceKindPair]; indices[resourceKindPair] = ++index; return index; }
/// <summary> /// Returns the current generation counter for a given Resource/Kind pair /// </summary> /// <param name="id">The resourceId</param> /// <param name="kindId"></param> /// <returns>The generation counter as UInt64</returns> public UInt64 GetGeneration(ResourceId id, UInt32 kindId) { if (resources.ContainsKey(id.ToString())) return resources[id.ToString()].GetGeneration(kindId); throw new KeyNotFoundException(String.Format("No Resouce found for Id {0}", id.ToString())); }
/// <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)); }
/// <summary> /// The Fetch request retrieves one or more data elements stored at a /// given Resource-ID. A single Fetch request can retrieve multiple /// different kinds. /// /// RELOAD base -13 p.92 /// --alex /// </summary> /// <param name="resourceName">The resouces name (human readable)</param> /// <param name="specifiers">StoredSpecifier objects</param> /// <returns></returns> public IEnumerator<ITask> Fetch(string resourceName, List<StoredDataSpecifier> specifiers) { ReloadDialog reloadDialog = null; ReloadMessage reloadSendMsg; List<IUsage> recUsages = new List<IUsage>(); ResourceId res_id = new ResourceId(resourceName); m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_ERROR, String.Format("Fetch {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; } List<Destination> dest_list = new List<Destination>(); dest_list.Add(new Destination(m_topology.LocalNode.Id)); List<FetchKindResponse> fetchKindResponses = new List<FetchKindResponse>(); FetchKindResponse fetchKindResponse = null; 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_ERROR, "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_ERROR, 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; // TODO: For now add certificate to global PKC Store, but they are only temporarilly needed in validateDataSignature m_ReloadConfig.AccessController.SetPKCs(reloadRcvMsg.security_block.Certificates); 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); } }
/// <summary> /// Store Replicas: My next two successors have changed. Replicate my data /// </summary> /// <param name="node"></param> /// <returns></returns> public IEnumerator<ITask> StoreReplicas(NodeId node) { // For each Resource stored at this Peer, handover StoredData List<string> storedKeys; if ((storedKeys = m_topology.Storage.StoredKeys) != null && storedKeys.Count > 0) { m_topology.Storage.RemoveExpired(); Dictionary<ResourceId, List<StoreKindData>> nodes = new Dictionary<ResourceId, List<StoreKindData>>(); foreach (string key in storedKeys) { ResourceId res_id = new ResourceId(ReloadGlobals.HexToBytes(key)); if (!m_topology.Replicas.Contains(key)) { m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_TOPO, "Store Replicas - will send store requests"); if (!nodes.ContainsKey(res_id)) { nodes.Add(res_id, new List<StoreKindData>()); nodes[res_id].AddRange(m_topology.Storage.GetStoreKindData(key)); } else { nodes[res_id].AddRange(m_topology.Storage.GetStoreKindData(key)); } } } ReloadDialog reloadDialog = null; ReloadMessage reloadSendMsg; List<StoreKindData> storeKindData; foreach (ResourceId res_id in nodes.Keys) { storeKindData = nodes[res_id]; m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_TOPO, "GOING TO REPLICATE UNDER RES_ID: " + res_id + " AT NODE: " + node); List<SignerIdentity> signers = new List<SignerIdentity>(); foreach (StoreKindData skd in storeKindData) { foreach (StoredData sd in skd.Values) { m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_TOPO, "STOREDATA: " + sd.Value.GetUsageValue.Report()); // add certificate if (!signers.Contains(sd.Signature.Identity)) signers.Add(sd.Signature.Identity); } } reloadSendMsg = create_store_req(new Destination(node), res_id, storeKindData, true); // get certificates for this data List<GenericCertificate> certs = new List<GenericCertificate>(); certs.AddRange(m_ReloadConfig.AccessController.GetPKCs(signers)); // add certificates to fetch answer reloadSendMsg.security_block.Certificates.AddRange(certs); 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, m_topology.routing_table.FindNextHopTo(node, false, false)); m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_RELOAD, String.Format("{0} ==> {1} TransId={2:x16}", reloadSendMsg.reload_message_body.RELOAD_MsgCode.ToString().PadRight(16, ' '), node, 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 Store: " + 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) { ReloadMessage reloadRcvMsg = reloadDialog.ReceivedMessage; if (reloadRcvMsg.reload_message_body.RELOAD_MsgCode == RELOAD_MessageCode.Store_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)); //StoreReqAns answ = (StoreReqAns)reloadRcvMsg.reload_message_body; --old StoreAns answ = (StoreAns)reloadRcvMsg.reload_message_body; // --alex if (answ != null) { } } } else { m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_WARNING, String.Format("Store Replica failed")); m_statistics.IncTransmissionError(); } } catch (Exception ex) { m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_ERROR, "Send Store Replica: " + 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> /// Computes the signature of the stored data. /// The input to the signature algorithm is: /// /// resource_id || kind || storage_time || StoredDataValue || /// SignerIdentity /// Where || indicates concatenation. /// </summary> /// <param name="resId"></param> /// <param name="kindId"></param> public void SignData(ResourceId resId, UInt32 kindId, SignerIdentity id, ReloadConfig rc) { signature = new Signature(resId, kindId, storage_time, value, id, rc); }
private void processFetchResult(ResourceId resid, List<RedirServiceProviderData> resultList) { machine.ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_REDIR, "REDIR: fetchResult resid=" + resid); List<NodeId> ServiceProviderIDs = new List<NodeId>(); string nameSpace = null; if (resultList != null) { machine.ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_REDIR, "fetchResult resultList.Count=" + resultList.Count); foreach (RedirServiceProviderData result in resultList) { ServiceProviderIDs.Add(result.serviceProvider); if (nameSpace != null && nameSpace != result.nameSpace) throw new System.Exception(String.Format("Invalid ReDiR Fetch: different Namespaces within one fetch")); else nameSpace = result.nameSpace; } } if (status == STATE.LOOKUP) { if (ServiceProviderIDs.Count == 0) { machine.ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_REDIR, "REDIR: No Successor found at " + resid); if (m_currentLevel == 0) { machine.ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_REDIR, "REDIR: FAILED " + resid); deliverResult(resid, null, null); status = STATE.IDLE; return; } else { m_currentLevel = m_currentLevel - 1; fetch(m_currentLevel); return; } } else if (ServiceProviderIDs.Count == 1) { NodeId id = ServiceProviderIDs[0]; machine.ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_REDIR, "REDIR: Successor found: NodeId=" + id + " at Level = " + m_currentLevel); deliverResult(resid, nameSpace, id); status = STATE.IDLE; return; } else ServiceProviderIDs.Sort(); if (ServiceProviderIDs.Count > 1 && ServiceProviderIDs.Last() > m_key && ServiceProviderIDs.First() < m_key) { machine.ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_REDIR, "REDIR: sandwiched in I(" + m_currentLevel + "," + m_key.ToString() + ")"); m_currentLevel = m_currentLevel + 1; fetch(m_currentLevel); return; } else if (ServiceProviderIDs.Last() == m_key || ServiceProviderIDs.First() == m_key) { NodeId id = ServiceProviderIDs[0]; machine.ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_REDIR, "REDIR: Successor found (its me!!!!): NodeId=" + id + " at Level = " + m_currentLevel); deliverResult(resid, nameSpace, id); status = STATE.IDLE; return; } else { NodeId id = ServiceProviderIDs[0]; machine.ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_REDIR, "REDIR: Successor found NodeId=" + id + " at Level = " + m_currentLevel); deliverResult(resid, nameSpace, id); } //if (ServiceProviderIDs.Count > 0 && m_currentLevel > 0) { // ServiceProviderIDs.Sort(); // if (ServiceProviderIDs.Last() < m_key) { // successor of node n is not present in the tree node associated with I(level,n.id) ?? // machine.ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_REDIR, "successor of node n is not present in the tree node at I(" + m_currentLevel + "," + m_key.ToString() + ")"); // m_currentLevel = m_currentLevel - 1; // fetch(m_currentLevel); // } // else if (ServiceProviderIDs.Count > 1 && ServiceProviderIDs.Last() >= m_key && ServiceProviderIDs.First() <= m_key) { // machine.ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_REDIR, "sandwiched in I(" + m_currentLevel + "," + m_key.ToString() + ")"); // m_currentLevel = m_currentLevel + 1; // fetch(m_currentLevel); // } // else { // foreach (NodeId id in ServiceProviderIDs) { // machine.ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_REDIR, "REDIR " + id); // if (id >= m_key) { // machine.ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_REDIR, "REDIR closest successor with NodeID=" + id + " found at Level=" + m_currentLevel); // deliverResult(resid, nameSpace, id); // status = STATE.IDLE; // return; // } // } // } //} //else if (m_currentLevel == 0) { // if (ServiceProviderIDs.Count > 0) { // ServiceProviderIDs.Sort(); // foreach (NodeId id in ServiceProviderIDs) { // machine.ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_REDIR, "REDIR" + id); // if (id >= m_key) { // machine.ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_REDIR, "REDIR closest successor with NodeID=" + id + " found at Level=" + m_currentLevel); // deliverResult(resid, nameSpace, id); // status = STATE.IDLE; // return; // } // } // machine.ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_REDIR, "REDIR closest successor with NodeID=" + ServiceProviderIDs.First().ToString() + " found at Level=" + m_currentLevel); // deliverResult(resid, nameSpace, ServiceProviderIDs.First()); // status = STATE.IDLE; // return; // } // else { // machine.ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_REDIR, "REDIR Nothin"); // deliverResult(resid, null, null); // status = STATE.IDLE; // return; // } //} //else { // m_currentLevel = m_currentLevel - 1; // //deliverResult(resid, null, null); // fetch(m_currentLevel); //} } else if (status != STATE.JOINED) { if (status == STATE.UPWALK) { ServiceProviderIDs.Sort(); store(m_currentLevel); //check if ServiceProviderID (my ID) is the numerically lowest of highest among the Node-IDs stored under res_id if (ServiceProviderIDs.Count == 0 || ServiceProviderIDs.Last() < m_key || ServiceProviderIDs.First() > m_key) { if (m_currentLevel > 0) { m_currentLevel = m_currentLevel - 1; fetch(m_currentLevel); } else { status = STATE.DOWNWALK; m_currentLevel = Lstart; fetch(m_currentLevel); } } else { status = STATE.DOWNWALK; m_currentLevel = Lstart; fetch(m_currentLevel); } } else if (status == STATE.DOWNWALK) { ServiceProviderIDs.Sort(); if (ServiceProviderIDs.Count == 1 && ServiceProviderIDs[0] == m_key) { status = STATE.JOINED; machine.ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_REDIR, String.Format("JOINED REDIR")); if (refreshTimer == null) refreshTimer = new Timer(refresh_callback, null, 60000, 60000); else refreshTimer.Change(60000, 60000); return; } if (ServiceProviderIDs.Count == 0) { store(m_currentLevel); status = STATE.JOINED; machine.ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_REDIR, String.Format("JOINED REDIR")); if (refreshTimer == null) refreshTimer = new Timer(refresh_callback, null, 60000, 60000); else refreshTimer.Change(60000, 60000); return; } //check if ServiceProviderID (my ID) is the numerically lowest of highest among the Node-IDs stored under res_id if (ServiceProviderIDs.Last() < m_key || ServiceProviderIDs.First() > m_key) { // if so: store yourself under res_id store(m_currentLevel); } // and probe the next level m_currentLevel = m_currentLevel + 1; fetch(m_currentLevel); } } }
private void deliverResult(ResourceId resid, string nameSpace, NodeId id) { if (nameSpace == null) { if (ReDiRLookupFailed != null) ReDiRLookupFailed(m_nameSpace); machine.ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_REDIR, "ReDiR: No Result for " + resid); } else { if ( ReDiRLookupCompleted != null) ReDiRLookupCompleted(nameSpace, id); machine.ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_REDIR, "ReDiR: Result for " + resid + " : nameSpace=" + nameSpace + "ID=" + id.ToString()); } }
/// <summary> /// This method validates if an ACP applies. /// </summary> /// <param name="resId">The requested resId</param> /// <param name="resId">The KindId</param> /// <param name="data">The StoredData</param> /// <returns>True, if ACP applies</returns> public Boolean ValuePermitted(ResourceId resId, UInt32 kindId, StoredData data) { //var nodeid = ReloadGlobals.retrieveNodeIDfromCertificate( signerCert, ref rfc822Name); return true; }
public bool validateDataSignature(ResourceId resId, uint kind, StoredData sd) { //FetchAns fetch_answer = (FetchAns)(reloadMsg.reload_message_body); var ascii = new ASCIIEncoding(); /* Set alogorithm and identity */ SignatureAndHashAlgorithm algorithm = new SignatureAndHashAlgorithm(HashAlgorithm.sha256, ReloadGlobals.SignatureAlg); /* Covert Idenity to string */ String identity = sd.Signature.Identity.ToString(); /* Get string of stored data value */ var ms = new MemoryStream(); var bw = new BinaryWriter(ms); sd.Value.Dump(bw); sd.Value.GetUsageValue.dump(bw); ms.Position = 0; var sr = new StreamReader(ms); string strValue = sr.ReadToEnd(); sr.Close(); bw.Close(); /* Concatenate signature input */ String strSignaturInput = String.Format("{0}{1}{2}{3}{4}", ascii.GetString(resId.Data, 0, resId.Data.Length), kind, sd.StoreageTime, strValue, identity); byte[] signatureInput = ascii.GetBytes(strSignaturInput); byte[] sigVal = sd.Signature.SignaureValue; GenericCertificate gencert = GetPKC(sd.Signature.Identity); byte[] bcert = gencert.Certificate; //TODO: TEST X509Certificate2 signerCert = new X509Certificate2(bcert); if (!Utils.X509Utils.VerifyCertificate(signerCert, m_ReloadConfig.RootCertificate)) { m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_ERROR, String.Format("validateDataSignatures: NodeID {0}, Certificate" + "validation failed (CA Issuer {1})", null, signerCert.Issuer)); //return false; } var cert = new X509Certificate2(bcert); switch (sd.Signature.Algorithm.signature) { case SignatureAlgorithm.rsa: var cryptoIPT = (RSACryptoServiceProvider)cert.PublicKey.Key; switch (sd.Signature.Algorithm.hash) { case HashAlgorithm.sha256: var sha256 = new SHA256CryptoServiceProvider(); if (!cryptoIPT.VerifyData(signatureInput, sha256, sigVal)) { throw new InvalidOperationException("Invalid signature"); return false; } else { m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_FORWARDING, "DATA SIGNATURE VALID!!"); return true; } break; default: throw new NotImplementedException("AccessController:" + "hash algoritm not implemented!"); } break; case SignatureAlgorithm.dsa: throw new NotImplementedException("AccessController:" + "DSA encryption not implemented!"); default: throw new NotImplementedException("AccessController:" + "encryption not implemented!"); } }
/// <summary> /// This method maintains data storage of incomming store requests. /// </summary> /// <param name="resource_id"></param> /// <param name="kind_data"></param> public void Store(ResourceId resource_id, StoreKindData kind_data) { storage.Store(resource_id, kind_data); }
private bool redir_FetchCompleted(List<IUsage> usages) { ResourceId resid = null; //machine.ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_REDIR, "redir_FetchCompleted usages.Count=" + usages.Count); if (usages.Count != 0) { List<RedirServiceProviderData> providerList = new List<RedirServiceProviderData>(); foreach (var usage in usages) { if (usage is NoResultUsage) { machine.ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_REDIR, "redir_FetchCompleted: NoResultUsage"); resid = new ResourceId(usages[0].ResourceName); //processFetchResult(resid, null); break; } else { machine.ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_REDIR, "redir_FetchCompleted: " + usage.Report()); if (usage.CodePoint == Usage_Code_Point.REDIR_SERVICE_PROVIDER) { providerList.Add(((RedirServiceProvider)usage).Data); resid = new ResourceId(usages[0].ResourceName); //TODO: cleanup if (resid != new ResourceId(usage.ResourceName)) { throw new System.Exception(String.Format("Invalid ReDiR Result: Different ResourceIds for one fetch")); } } } } processFetchResult(resid, providerList); } else { machine.ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_REDIR, "redir_FetchCompleted: usages.Count==0"); resid = new ResourceId(usages[0].ResourceName); processFetchResult(resid, null); } if (status == STATE.IDLE || status == STATE.JOINED) { machine.FetchCompleted -= new DFetchCompleted(redir_FetchCompleted); machine.ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_REDIR, String.Format("machine.FetchCompleted -= new DFetchCompleted(redir_FetchCompleted);")); } return true; }
public bool Fetch(ResourceId res_id, StoredDataSpecifier specifier, out FetchKindResponse kindResponse) { FetchKindResponse result = null; if (storage.Fetch(res_id, specifier, out result)) { kindResponse = result; return true; } kindResponse = new FetchKindResponse(); return false; }
public StoreReq(ResourceId resId, List<StoreKindData> store_kind_data, UsageManager manager, bool replica) { resourceId = resId; this.RELOAD_MsgCode = RELOAD_MessageCode.Store_Request; if (store_kind_data != null && store_kind_data.Count != 0) { this.store_kind_data = store_kind_data; } myManager = manager; if (replica) setReplicaNumber(); }
/// <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(); }
/// <summary> /// Deserializes a StoreReq message from wire. /// </summary> /// <param name="rm"></param> /// <param name="reader"></param> /// <param name="reload_msg_size"></param> /// <returns></returns> public override RELOAD_MessageBody FromReader(ReloadMessage rm, BinaryReader reader, long reload_msg_size) { UInt32 message_len = 0; /* try to read the packet as a StoreReq packet */ try { long posBeforeMsg = reader.BaseStream.Position; RELOAD_MsgCode = (RELOAD_MessageCode)(UInt16)IPAddress.NetworkToHostOrder(reader.ReadInt16()); message_len = (UInt32)(IPAddress.HostToNetworkOrder((int)reader.ReadInt32())); Byte res_id_length = reader.ReadByte(); if (res_id_length == 0) throw new System.Exception("Resource ID length == 0!"); resourceId = new ResourceId(reader.ReadBytes(res_id_length)); replica_number = reader.ReadByte(); long posBeforeRead = reader.BaseStream.Position; UInt32 kindDataLen = (UInt32)(IPAddress.NetworkToHostOrder(reader.ReadInt32())); /* StoreKindData Receive loop */ while (StreamUtil.ReadBytes(posBeforeRead, reader) < kindDataLen) { UInt32 kindId = (UInt32)(IPAddress.HostToNetworkOrder(reader.ReadInt32())); UInt64 generation = (UInt64)(IPAddress.NetworkToHostOrder(reader.ReadInt64())); var store_kind_data = new StoreKindData(kindId, generation); long posBeforeSD = reader.BaseStream.Position; UInt32 storedDataLen = (UInt32)(IPAddress.HostToNetworkOrder(reader.ReadInt32())); if (RELOAD_MsgCode == RELOAD_MessageCode.Store_Request) { while (StreamUtil.ReadBytes(posBeforeSD, reader) < storedDataLen) { /* reading properties of StoredData struct */ UInt32 stored_data_lenght = (UInt32)(IPAddress.NetworkToHostOrder(reader.ReadInt32())); UInt64 storage_time = (UInt64)(IPAddress.NetworkToHostOrder(reader.ReadInt64())); UInt32 lifetime = (UInt32)(IPAddress.NetworkToHostOrder(reader.ReadInt32())); ReloadGlobals.DataModel data_model = myManager.GetDataModelfromKindId(store_kind_data.Kind); Boolean exists; IUsage usage; StoredDataValue stored_data_value; switch (data_model) { case ReloadGlobals.DataModel.SINGLE_VALUE: throw new NotImplementedException("There is no Usage with Single Value atm"); case ReloadGlobals.DataModel.ARRAY: UInt32 index = (UInt32)(IPAddress.NetworkToHostOrder((int)reader.ReadInt32())); exists = (reader.ReadByte() == 0x00 ? false : true); usage = myManager.GetUsageFromReader(rm, reader, reload_msg_size, store_kind_data.Kind); stored_data_value = new StoredDataValue(index, usage, exists); break; case ReloadGlobals.DataModel.DICTIONARY: UInt16 keyLength = (UInt16)(IPAddress.NetworkToHostOrder((short)reader.ReadInt16())); string key = BitConverter.ToString(reader.ReadBytes(keyLength), 0, keyLength); //key is a hex string key = key.Replace("-", ""); exists = (reader.ReadByte() == 0x00 ? false : true); usage = myManager.GetUsageFromReader(rm, reader, reload_msg_size, store_kind_data.Kind); stored_data_value = new StoredDataValue(key, usage, exists); break; default: throw new NotSupportedException(String.Format("The data_model {0} is not supported", data_model)); } StoredData stored_data = new StoredData(storage_time, lifetime, stored_data_value); stored_data.Signature = new Signature(myManager.m_ReloadConfig).FromReader(reader, reload_msg_size); // TODO Process signature store_kind_data.Add(stored_data); appendStoreKindData(store_kind_data); } } } UInt32 totalRead = StreamUtil.ReadBytes(posBeforeMsg, reader); reload_msg_size = reload_msg_size - (totalRead + 1); } catch (Exception ex) { throw ex; } return this; }
// REPLICATEST public void EvaluateReplicas() { List<String> ReplicasToRemove = new List<string>(); foreach (String rep in m_topology.Replicas) { ResourceId id = new ResourceId(rep); if (m_topology.routing_table.Predecessors.Count > 0) m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_ALL, String.Format("EvaluateReplicas: Is data {0} in interval {1} - {2}", rep, m_topology.routing_table.Predecessors[0], m_topology.LocalNode.Id)); else m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_ALL, String.Format("Nobody is left. All the data belong to me")); if (m_topology.routing_table.Predecessors.Count > 0 && id.ElementOfInterval(m_topology.routing_table.Predecessors[0], m_topology.LocalNode.Id, false)) { ReplicasToRemove.Add(rep); m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_ALL, String.Format("EvaluateReplicas: I'm now responsible for data {0}", rep)); if (m_topology.routing_table.Successors.Count > 0) Arbiter.Activate(m_ReloadConfig.DispatcherQueue, new IterativeTask<NodeId>(m_topology.routing_table.Successors[0], StoreReplicas)); if (m_topology.routing_table.Successors.Count > 1) Arbiter.Activate(m_ReloadConfig.DispatcherQueue, new IterativeTask<NodeId>(m_topology.routing_table.Successors[1], StoreReplicas)); } } foreach (String rep in ReplicasToRemove) { m_topology.Replicas.Remove(rep); } }
public Destination(ResourceId id) { type = DestinationType.resource; destination_data.ressource_id = id; }
/// <summary> /// Handover key if: 1. leave overlay 2. I'm AP while a join req happens. /// </summary> /// <param name="fSendLeaveFirst"></param> /// <returns></returns> public IEnumerator<ITask> HandoverKeys(bool fSendLeaveFirst) { m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_TOPO, "Handover Keys!"); if (fSendLeaveFirst) { yield return Arbiter.ExecuteToCompletion(m_DispatcherQueue, new IterativeTask(Leave)); } // For each Resource stored at this Peer, handover StoredData List<string> storedKeys; if ((storedKeys = m_topology.Storage.StoredKeys) != null && storedKeys.Count > 0) { m_topology.Storage.RemoveExpired(); Dictionary<ResourceId, List<StoreKindData>> nodes = new Dictionary<ResourceId, List<StoreKindData>>(); Dictionary<ResourceId, Node> destinations = new Dictionary<ResourceId, Node>(); foreach (string key in storedKeys) { ResourceId res_id = new ResourceId(ReloadGlobals.HexToBytes(key)); Node currentNode = m_topology.routing_table.FindNextHopTo(new NodeId(res_id), true, fSendLeaveFirst); if (currentNode == null || currentNode.Id == m_ReloadConfig.LocalNodeID) { //everything's fine, key still belongs to me continue; } // REPLICATEST // peer is no longer in the replica set for the resource else if (m_topology.routing_table.Predecessors.Count > 2 && !res_id.ElementOfInterval(m_topology.routing_table.Predecessors[2], m_topology.LocalNode.Id, false)) { m_topology.Storage.Remove(res_id.ToString()); m_topology.Replicas.Remove(res_id.ToString()); m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_ALL, String.Format("Data {0} no longer in range. Delete replica", res_id.ToString())); } else { if (!m_topology.Replicas.Contains(key)) { m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_TOPO, "Handover Keys - will send store requests"); if (!nodes.ContainsKey(res_id)) { nodes.Add(res_id, new List<StoreKindData>()); nodes[res_id].AddRange(m_topology.Storage.GetStoreKindData(key)); destinations.Add(res_id, currentNode); } else { nodes[res_id].AddRange(m_topology.Storage.GetStoreKindData(key)); } } } } ReloadDialog reloadDialog = null; ReloadMessage reloadSendMsg; List<StoreKindData> storeKindData; foreach (ResourceId res_id in nodes.Keys) { Node node = destinations[res_id]; storeKindData = nodes[res_id]; List<SignerIdentity> signers = new List<SignerIdentity>(); m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_TOPO, "GOING TO STORE UNDER RES_ID: " + res_id); foreach (StoreKindData skd in storeKindData) { foreach (StoredData sd in skd.Values) { m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_TOPO, "STOREDATA: " + sd.Value.GetUsageValue.Report()); // add certificate if (!signers.Contains(sd.Signature.Identity)) signers.Add(sd.Signature.Identity); } } if (m_machine.ReloadConfig.State == ReloadConfig.RELOAD_State.Leave) { node = m_topology.routing_table.GetSuccessor(0); reloadSendMsg = create_store_req(new Destination(node.Id), res_id, storeKindData, false); } else { reloadSendMsg = create_store_req(new Destination(res_id), storeKindData, false); } // get certificates for this data List<GenericCertificate> certs = new List<GenericCertificate>(); certs.AddRange(m_ReloadConfig.AccessController.GetPKCs(signers)); // add certificates to fetch answer reloadSendMsg.security_block.Certificates.AddRange(certs); 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) { m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_ERROR, "Send Store: " + 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) { ReloadMessage reloadRcvMsg = reloadDialog.ReceivedMessage; if (reloadRcvMsg.reload_message_body.RELOAD_MsgCode == RELOAD_MessageCode.Store_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)); //StoreReqAns answ = (StoreReqAns)reloadRcvMsg.reload_message_body; --old StoreAns answ = (StoreAns)reloadRcvMsg.reload_message_body; // --alex if (answ != null) { // m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_WARNING, String.Format("Delete Key {0}", res_id)); // m_topology.StoredValues.Remove(StoredKey); --old // REPLICATEST // Keep stored data but mark it as replica if (!m_topology.Replicas.Contains(res_id.ToString())) m_topology.Replicas.Add(res_id.ToString()); //m_topology.Storage.Remove(res_id.ToString()); } } } 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: " + ex.Message); } } } // this code might be redundant to code in RoutingTable.Leave() //// check if there are replicas I should be responsible for //if (m_topology.routing_table.Predecessors.Count == 0) //{ // m_topology.Replicas.Clear(); //} //else //{ // List<string> removeReplicas = new List<string>(); // foreach (string replica in m_topology.Replicas) // { // // Convert the Resource String in a ResourceId // int NumberChars = replica.Length; // byte[] bytes = new byte[NumberChars / 2]; // for (int i = 0; i < NumberChars; i += 2) // bytes[i / 2] = Convert.ToByte(replica.Substring(i, 2), 16); // ResourceId id = new ResourceId(bytes); // if (id.ElementOfInterval(m_topology.routing_table.Predecessors[0], m_topology.LocalNode.Id, false)) // { // m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_ALL, String.Format("ResId: {0} is in interval [{1} - {2}]", id, m_topology.routing_table.Predecessors[0], m_topology.LocalNode.Id)); // removeReplicas.Add(replica); // } // } // foreach (string removeRep in removeReplicas) // { // m_topology.Replicas.Remove(removeRep); // Arbiter.Activate(m_ReloadConfig.DispatcherQueue, new IterativeTask<NodeId>(m_topology.routing_table.Successors[0], StoreReplicas)); // if(m_topology.routing_table.Successors.Count > 1) // Arbiter.Activate(m_ReloadConfig.DispatcherQueue, new IterativeTask<NodeId>(m_topology.routing_table.Successors[1], StoreReplicas)); // } //} if (m_ReloadConfig.State == ReloadConfig.RELOAD_State.Leave) m_machine.SendCommand("Exit"); if (fSendLeaveFirst) //this will reset neighbor tables m_topology.Leave(); }
public FetchReq(ResourceId resourceId, List<StoredDataSpecifier> specifiers, UsageManager manager) { this.RELOAD_MsgCode = RELOAD_MessageCode.Fetch_Request; this.resource = resourceId; this.specifiers = new List<StoredDataSpecifier>(); this.specifiers.AddRange(specifiers); myManager = manager; }
/// <summary> /// On data fetch execute the Usages AppProcedure /// </summary> /// <param name="res_id"></param> /// <param name="fetchKindResponse"></param> private void OnFetchedData(ResourceId res_id, List<FetchKindResponse> fetchKindResponses) { foreach (var fetchKindResponse in fetchKindResponses) { m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_USAGE, String.Format("Fetch on {0} returns {1}", res_id, fetchKindResponse.ToString())); } m_machine.UsageManager.AppProcedure(fetchKindResponses); }
public override RELOAD_MessageBody FromReader(ReloadMessage rm, BinaryReader reader, long reload_msg_size) { /* try to read the packet as a FetchReq packet */ try { long posBeforeMsg = reader.BaseStream.Position; RELOAD_MsgCode = (RELOAD_MessageCode)(UInt16)IPAddress.NetworkToHostOrder( reader.ReadInt16()); UInt32 message_len = (UInt32)(IPAddress.HostToNetworkOrder( reader.ReadInt32())); Byte res_id_length = reader.ReadByte(); if (res_id_length == 0) throw new System.Exception("Resource ID length == 0!"); resource = new ResourceId(reader.ReadBytes(res_id_length)); long posBeforeSpec = reader.BaseStream.Position; UInt16 specifiers_length = (UInt16)IPAddress.NetworkToHostOrder( reader.ReadInt16()); while (StreamUtil.ReadBytes(posBeforeSpec, reader) < specifiers_length) { UInt32 kindId = (UInt32)IPAddress.NetworkToHostOrder( reader.ReadInt32()); ReloadGlobals.DataModel model = myManager.GetDataModelfromKindId(kindId); UInt64 generation = (UInt64)IPAddress.NetworkToHostOrder( reader.ReadInt64()); long posBeforeIndex = reader.BaseStream.Position; UInt16 spec_length = (UInt16)IPAddress.NetworkToHostOrder( reader.ReadInt16()); var specifier = new StoredDataSpecifier(myManager); switch (model) { case ReloadGlobals.DataModel.SINGLE_VALUE: break; case ReloadGlobals.DataModel.ARRAY: List<ArrayRange> arrayRanges = new List<ArrayRange>(); while (StreamUtil.ReadBytes(posBeforeIndex, reader) < spec_length) { UInt32 first = (UInt32)IPAddress.NetworkToHostOrder( reader.ReadInt32()); UInt32 last = (UInt32)IPAddress.NetworkToHostOrder( reader.ReadInt32()); arrayRanges.Add(new ArrayRange(first, last)); } specifier = new StoredDataSpecifier(arrayRanges, kindId, generation, myManager); break; case ReloadGlobals.DataModel.DICTIONARY: List<string> keys = new List<string>(); if (spec_length == 0) { // wildcast specifier = new StoredDataSpecifier(keys, kindId, generation, myManager); } else { while (StreamUtil.ReadBytes(posBeforeIndex, reader) < spec_length) { UInt16 key_length = (UInt16)IPAddress.NetworkToHostOrder( reader.ReadInt16()); keys.Add(Encoding.ASCII.GetString(reader.ReadBytes((short)key_length), 0, key_length)); } specifier = new StoredDataSpecifier(keys, kindId, generation, myManager); } break; default: throw new Exception("An error at FetchReq.FromReader()"); } this.specifiers.Add(specifier); } UInt32 totalRead = StreamUtil.ReadBytes(posBeforeMsg, reader); reload_msg_size = reload_msg_size - (totalRead + 1); } catch (Exception ex) { myManager.m_ReloadConfig.Logger(ReloadGlobals.TRACEFLAGS.T_ERROR, String.Format("FetchReq.FromBytes: {0}", ex.Message)); } return this; }
/// <summary> /// Each StoredData element is individually signed. However, the /// signature also must be self-contained and cover the Kind-ID and /// Resource-ID even though they are not present in the StoredData /// structure. The input to the signature algorithm is: /// resource_id || kind || storage_time || StoredDataValue || /// SignerIdentity /// </summary> /// <param name="resId"></param> /// <param name="kind"></param> /// <param name="storageTime"></param> /// <param name="storedDataValue"></param> /// <param name="identity"></param> public Signature(ResourceId resId, UInt32 kind, UInt64 storageTime, StoredDataValue value, SignerIdentity signerIdentity, ReloadConfig config) { m_ReloadConfig = config; var ascii = new ASCIIEncoding(); /* Set alogorithm and identity */ algorithm = new SignatureAndHashAlgorithm(HashAlgorithm.sha256, ReloadGlobals.SignatureAlg); identity = signerIdentity; /* Get string of stored data value */ var ms = new MemoryStream(); var bw = new BinaryWriter(ms); value.Dump(bw); value.GetUsageValue.dump(bw); ms.Position = 0; var sr = new StreamReader(ms); string strValue = sr.ReadToEnd(); sr.Close(); bw.Close(); /* Concatenate signature input */ String signaturInput = String.Format("{0}{1}{2}{3}{4}", ascii.GetString(resId.Data, 0, resId.Data.Length), kind, storageTime, strValue, identity.ToString()); signatureValue = Sign(signaturInput); }
public NodeId(ResourceId resourceid) // call constructor above : this() { if (resourceid == null) System.Diagnostics.Debug.Assert(resourceid == null); else{ //the following function fills the array with zeros, the intention is to have leading zero padding bytes if resourceid is smaller Array.Clear(this.Data, 0, this.Data.Length); if (this.Data.Length > resourceid.Data.Length) Array.Copy(resourceid.Data, 0, this.Data, this.Data.Length - resourceid.Data.Length, resourceid.Data.Length); else Array.Copy(resourceid.Data, this.Data, this.Data.Length); } }