/** * If we receive an ACK or RST, we mark the outgoing request or response as acknowledged or * rejected respectively and cancel its retransmission. */ @Override public void receiveEmptyMessage(Exchange exchange, EmptyMessage message) { exchange.setFailedTransmissionCount(0); // TODO: If this is an observe relation, the current response might not // be the one that is being acknowledged. The current response might // already be the next NON notification. if (message.getType() == Type.ACK) { if (exchange.getOrigin() == Origin.LOCAL) { exchange.getCurrentRequest().setAcknowledged(true); } else { exchange.getCurrentResponse().setAcknowledged(true); } } else if (message.getType() == Type.RST) { if (exchange.getOrigin() == Origin.LOCAL) { exchange.getCurrentRequest().setRejected(true); } else { exchange.getCurrentResponse().setRejected(true); } } else { LOGGER.warning("Empty messgae was not ACK nor RST: " + message); } LOGGER.finer("Cancel retransmission"); exchange.setRetransmissionHandle(null); super.receiveEmptyMessage(exchange, message); }
/** * When we receive a duplicate of a request, we stop it here and do not forward it to the upper * layer. If the server has already sent a response, we send it again. If the request has only * been acknowledged (but the ACK has gone lost or not reached the client yet), we resent the ACK. * If the request has neither been responded, acknowledged or rejected yet, the server has not yet * decided what to do with the request and we cannot do anything. */ @Override public void receiveRequest(Exchange exchange, Request request) { if (request.isDuplicate()) { // Request is a duplicate, so resend ACK, RST or response if (exchange.getCurrentResponse() != null) { LOGGER.fine("Respond with the current response to the duplicate request"); // Do not restart retransmission cycle super.sendResponse(exchange, exchange.getCurrentResponse()); } else if (exchange.getCurrentRequest().isAcknowledged()) { LOGGER.fine( "The duplicate request was acknowledged but no response computed yet. Retransmit ACK"); EmptyMessage ack = EmptyMessage.newACK(request); sendEmptyMessage(exchange, ack); } else if (exchange.getCurrentRequest().isRejected()) { LOGGER.fine("The duplicate request was rejected. Reject again"); EmptyMessage rst = EmptyMessage.newRST(request); sendEmptyMessage(exchange, rst); } else { LOGGER.fine( "The server has not yet decided what to do with the request. We ignore the duplicate."); // The server has not yet decided, whether to acknowledge or // reject the request. We know for sure that the server has // received the request though and can drop this duplicate here. } } else { // Request is not a duplicate exchange.setCurrentRequest(request); super.receiveRequest(exchange, request); } }
/** * Makes sure that the response type is correct. The response type for a NON can be NON or CON. * The response type for a CON should either be an ACK with a piggy-backed response or, if an * empty ACK has already be sent, a CON or NON with a separate response. */ @Override public void sendResponse(final Exchange exchange, final Response response) { LOGGER.finer("Send response, failed transmissions: " + exchange.getFailedTransmissionCount()); // If a response type is set, we do not mess around with it. // Only if none is set, we have to decide for one here. Type respType = response.getType(); if (respType == null) { Type reqType = exchange.getCurrentRequest().getType(); if (reqType == Type.CON) { if (exchange.getCurrentRequest().isAcknowledged()) { // send separate response response.setType(Type.CON); } else { exchange.getCurrentRequest().setAcknowledged(true); // send piggy-backed response response.setType(Type.ACK); response.setMID(exchange.getCurrentRequest().getMID()); } } else { // send NON response response.setType(Type.NON); } LOGGER.finest( "Switched response message type from " + respType + " to " + response.getType() + " (request was " + reqType + ")"); } else if (respType == Type.ACK || respType == Type.RST) { response.setMID(exchange.getCurrentRequest().getMID()); } if (response.getType() == Type.CON) { LOGGER.finer("Scheduling retransmission for " + response); prepareRetransmission( exchange, new RetransmissionTask(exchange, response) { public void retransmit() { sendResponse(exchange, response); } }); } super.sendResponse(exchange, response); }
/** * When we receive a Confirmable response, we acknowledge it and it also counts as acknowledgment * for the request. If the response is a duplicate, we stop it here and do not forward it to the * upper layer. */ @Override public void receiveResponse(Exchange exchange, Response response) { exchange.setFailedTransmissionCount(0); exchange.getCurrentRequest().setAcknowledged(true); LOGGER.finest("Cancel any retransmission"); exchange.setRetransmissionHandle(null); if (response.getType() == Type.CON && !exchange.getRequest().isCanceled()) { LOGGER.finer("Response is confirmable, send ACK"); EmptyMessage ack = EmptyMessage.newACK(response); sendEmptyMessage(exchange, ack); } if (response.isDuplicate()) { LOGGER.fine("Response is duplicate, ignore it"); } else { super.receiveResponse(exchange, response); } }