private void OnExchangeCompleted(Object sender, EventArgs e) { Exchange exchange = (Exchange)sender; /* * Logging in this method leads to significant performance loss. * Uncomment logging code only for debugging purposes. */ if (exchange.Origin == Origin.Local) { // this endpoint created the Exchange by issuing a request Request request = exchange.Request; Exchange.KeyToken keyToken = new Exchange.KeyToken(exchange.CurrentRequest.Token, request.Destination); Exchange.KeyID keyID = new Exchange.KeyID(request.ID, request.Destination); if (log.IsDebugEnabled) { log.Debug("Exchange completed: Cleaning up " + keyToken); } _exchangesByToken.Remove(keyToken); // in case an empty ACK was lost _exchangesByID.Remove(keyID); } else { // this endpoint created the Exchange to respond a request Request request = exchange.CurrentRequest; if (request != null) { // TODO: We can optimize this and only do it, when the request really had blockwise transfer Exchange.KeyUri uriKey = new Exchange.KeyUri(request.URI, request.Source); //if (log.IsDebugEnabled) // log.Debug("++++++++++++++++++Remote ongoing completed, cleaning up "+uriKey); _ongoingExchanges.Remove(uriKey); } // TODO: What if the request is only a block? // TODO: This should only happen if the transfer was blockwise Response response = exchange.Response; if (response != null) { // only response MIDs are stored for ACK and RST, no reponse Tokens Exchange.KeyID midKey = new Exchange.KeyID(response.ID, response.Destination); //if (log.IsDebugEnabled) // log.Debug("++++++++++++++++++Remote ongoing completed, cleaning up " + midKey); _exchangesByID.Remove(midKey); } // Remove all remaining NON-notifications if this exchange is an observe relation ObserveRelation relation = exchange.Relation; if (relation != null) { RemoveNotificatoinsOf(relation); } } }
private void OnExchangeCompleted(Object sender, EventArgs e) { Exchange exchange = (Exchange)sender; /* * Logging in this method leads to significant performance loss. * Uncomment logging code only for debugging purposes. */ if (exchange.Origin == Origin.Local) { // this endpoint created the Exchange by issuing a request Exchange.KeyID keyID = new Exchange.KeyID(exchange.CurrentRequest.ID, null); Exchange.KeyToken keyToken = new Exchange.KeyToken(exchange.CurrentRequest.Token); if (log.IsDebugEnabled) { log.Debug("Exchange completed: Cleaning up " + keyToken); } _exchangesByToken.Remove(keyToken); // in case an empty ACK was lost _exchangesByID.Remove(keyID); } else // Origin.Remote { // this endpoint created the Exchange to respond a request Response response = exchange.CurrentResponse; if (response != null && response.Type != MessageType.ACK) { // only response MIDs are stored for ACK and RST, no reponse Tokens Exchange.KeyID midKey = new Exchange.KeyID(response.ID, null); //if (log.IsDebugEnabled) // log.Debug("Remote ongoing completed, cleaning up " + midKey); _exchangesByID.Remove(midKey); } Request request = exchange.CurrentRequest; if (request != null && (request.HasOption(OptionType.Block1) || response.HasOption(OptionType.Block2))) { Exchange.KeyUri uriKey = new Exchange.KeyUri(request.URI, request.Source); if (log.IsDebugEnabled) { log.Debug("Remote ongoing completed, cleaning up " + uriKey); } Exchange exc; _ongoingExchanges.TryRemove(uriKey, out exc); } // Remove all remaining NON-notifications if this exchange is an observe relation ObserveRelation relation = exchange.Relation; if (relation != null) { RemoveNotificatoinsOf(relation); } } }
/// <inheritdoc/> public Exchange ReceiveRequest(Request request) { /* * This request could be * - Complete origin request => deliver with new exchange * - One origin block => deliver with ongoing exchange * - Complete duplicate request or one duplicate block (because client got no ACK) * => * if ACK got lost => resend ACK * if ACK+response got lost => resend ACK+response * if nothing has been sent yet => do nothing * (Retransmission is supposed to be done by the retransm. layer) */ Exchange.KeyID keyId = new Exchange.KeyID(request.ID, request.Source); /* * The differentiation between the case where there is a Block1 or * Block2 option and the case where there is none has the advantage that * all exchanges that do not need blockwise transfer have simpler and * faster code than exchanges with blockwise transfer. */ if (!request.HasOption(OptionType.Block1) && !request.HasOption(OptionType.Block2)) { Exchange exchange = new Exchange(request, Origin.Remote); Exchange previous = _deduplicator.FindPrevious(keyId, exchange); if (previous == null) { exchange.Completed += OnExchangeCompleted; return(exchange); } else { if (log.IsInfoEnabled) { log.Info("Message is a duplicate, ignore: " + request); } request.Duplicate = true; return(previous); } } else { Exchange.KeyUri keyUri = new Exchange.KeyUri(request.URI, request.Source); if (log.IsDebugEnabled) { log.Debug("Lookup ongoing exchange for " + keyUri); } Exchange ongoing; if (_ongoingExchanges.TryGetValue(keyUri, out ongoing)) { Exchange prev = _deduplicator.FindPrevious(keyId, ongoing); if (prev != null) { if (log.IsInfoEnabled) { log.Info("Message is a duplicate: " + request); } request.Duplicate = true; } return(ongoing); } else { // We have no ongoing exchange for that request block. /* * Note the difficulty of the following code: The first message * of a blockwise transfer might arrive twice due to a * retransmission. The new Exchange must be inserted in both the * hash map 'ongoing' and the deduplicator. They must agree on * which exchange they store! */ Exchange exchange = new Exchange(request, Origin.Remote); Exchange previous = _deduplicator.FindPrevious(keyId, exchange); if (log.IsDebugEnabled) { log.Debug("New ongoing exchange for remote Block1 request with key " + keyUri); } if (previous == null) { exchange.Completed += OnExchangeCompleted; _ongoingExchanges[keyUri] = exchange; return(exchange); } else { if (log.IsInfoEnabled) { log.Info("Message is a duplicate: " + request); } request.Duplicate = true; return(previous); } } // if ongoing } // if blockwise }
/// <inheritdoc/> public void SendResponse(Exchange exchange, Response response) { if (response.ID == Message.None) { response.ID = System.Threading.Interlocked.Increment(ref _currentID) % (1 << 16); } /* * The response is a CON or NON or ACK and must be prepared for these * - CON => ACK/RST // we only care to stop retransmission * - NON => RST // we don't care * - ACK => nothing! * If this response goes lost, we must be prepared to get the same * CON/NON request with same MID again. We then find the corresponding * exchange and the ReliabilityLayer resends this response. */ if (response.Destination == null) { throw new InvalidOperationException("Response has no destination set"); } // If this is a CON notification we now can forget all previous NON notifications if (response.Type == MessageType.CON || response.Type == MessageType.ACK) { ObserveRelation relation = exchange.Relation; if (relation != null) { RemoveNotificatoinsOf(relation); } } if (response.HasOption(OptionType.Block2)) { Request request = exchange.Request; Exchange.KeyUri keyUri = new Exchange.KeyUri(request.URI, response.Destination); if (exchange.ResponseBlockStatus != null && !response.HasOption(OptionType.Observe)) { // Remember ongoing blockwise GET requests if (log.IsDebugEnabled) { log.Debug("Ongoing Block2 started, storing " + keyUri + "\nOngoing " + request + "\nOngoing " + response); } _ongoingExchanges[keyUri] = exchange; } else { if (log.IsDebugEnabled) { log.Debug("Ongoing Block2 completed, cleaning up " + keyUri + "\nOngoing " + request + "\nOngoing " + response); } _ongoingExchanges.Remove(keyUri); } } // Insert CON and NON to match ACKs and RSTs to the exchange // Do not insert ACKs and RSTs. if (response.Type == MessageType.CON || response.Type == MessageType.NON) { Exchange.KeyID keyID = new Exchange.KeyID(response.ID, response.Destination); _exchangesByID[keyID] = exchange; } if (response.Type == MessageType.ACK || response.Type == MessageType.NON) { // Since this is an ACK or NON, the exchange is over with sending this response. if (response.Last) { exchange.Complete = true; } } // else this is a CON and we need to wait for the ACK or RST }
/// <inheritdoc/> public void SendResponse(Exchange exchange, Response response) { if (response.ID == Message.None) { response.ID = System.Threading.Interlocked.Increment(ref _currentID) % (1 << 16); } /* * The response is a CON or NON or ACK and must be prepared for these * - CON => ACK / RST // we only care to stop retransmission * - NON => RST // we only care for observe * - ACK => nothing! * If this response goes lost, we must be prepared to get the same * CON/NON request with same MID again. We then find the corresponding * exchange and the ReliabilityLayer resends this response. */ // If this is a CON notification we now can forget all previous NON notifications if (response.Type == MessageType.CON || response.Type == MessageType.ACK) { ObserveRelation relation = exchange.Relation; if (relation != null) { RemoveNotificatoinsOf(relation); } } // Blockwise transfers are identified by URI and remote endpoint if (response.HasOption(OptionType.Block2)) { Request request = exchange.CurrentRequest; Exchange.KeyUri keyUri = new Exchange.KeyUri(request.URI, response.Destination); // Observe notifications only send the first block, hence do not store them as ongoing if (exchange.ResponseBlockStatus != null && !response.HasOption(OptionType.Observe)) { // Remember ongoing blockwise GET requests if (Utils.Put(_ongoingExchanges, keyUri, exchange) == null) { if (log.IsDebugEnabled) { log.Debug("Ongoing Block2 started late, storing " + keyUri + " for " + request); } } else { if (log.IsDebugEnabled) { log.Debug("Ongoing Block2 continued, storing " + keyUri + " for " + request); } } } else { if (log.IsDebugEnabled) { log.Debug("Ongoing Block2 completed, cleaning up " + keyUri + " for " + request); } Exchange exc; _ongoingExchanges.TryRemove(keyUri, out exc); } } // Insert CON and NON to match ACKs and RSTs to the exchange // Do not insert ACKs and RSTs. if (response.Type == MessageType.CON || response.Type == MessageType.NON) { Exchange.KeyID keyID = new Exchange.KeyID(response.ID, null); _exchangesByID[keyID] = exchange; } // Only CONs and Observe keep the exchange active if (response.Type != MessageType.CON && response.Last) { exchange.Complete = true; } }