@Test public void testNonConfirmable() throws Exception { // send request Request req2acc = new Request(Code.POST); req2acc.setConfirmable(false); req2acc.setURI("localhost:" + serverPort + "/" + ACC_RESOURCE); req2acc.setPayload("client says hi"); req2acc.send(); // receive response and check Response response = req2acc.waitForResponse(100); assertNotNull(response); assertEquals(response.getPayloadString(), SERVER_RESPONSE); assertEquals(response.getType(), Type.NON); Request req2noacc = new Request(Code.POST); req2noacc.setConfirmable(false); req2noacc.setURI("coap://localhost:" + serverPort + "/" + NO_ACC_RESOURCE); req2noacc.setPayload("client says hi"); req2noacc.send(); // receive response and check response = req2noacc.waitForResponse(100); assertNotNull(response); assertEquals(response.getPayloadString(), SERVER_RESPONSE); assertEquals(response.getType(), Type.NON); }
/** * 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); }
protected boolean checkResponse(Request request, Response response) { boolean success = true; success &= checkType(Type.NON, response.getType()); success &= checkInt(EXPECTED_RESPONSE_CODE.value, response.getCode().value, "code"); success &= hasContentType(response); success &= hasNonEmptyPalyoad(response); return success; }
/** * 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); } }
/* * The endpoint's executor executes this method to convert the raw bytes * into a message, look for an associated exchange and forward it to * the stack of layers. */ private void receiveMessage(RawData raw) { DataParser parser = new DataParser(raw.getBytes()); if (parser.isRequest()) { // This is a request Request request; try { request = parser.parseRequest(); } catch (IllegalStateException e) { StringBuffer log = new StringBuffer("message format error caused by ") .append(raw.getInetSocketAddress()); if (!parser.isReply()) { // manually build RST from raw information EmptyMessage rst = new EmptyMessage(Type.RST); rst.setDestination(raw.getAddress()); rst.setDestinationPort(raw.getPort()); rst.setMID(parser.getMID()); for (MessageInterceptor interceptor : interceptors) interceptor.sendEmptyMessage(rst); connector.send(serializer.serialize(rst)); log.append(" and reset"); } if (LOGGER.isLoggable(Level.INFO)) { LOGGER.info(log.toString()); } return; } request.setSource(raw.getAddress()); request.setSourcePort(raw.getPort()); request.setSenderIdentity(raw.getSenderIdentity()); /* * Logging here causes significant performance loss. * If necessary, add an interceptor that logs the messages, * e.g., the MessageTracer. */ for (MessageInterceptor interceptor : interceptors) interceptor.receiveRequest(request); // MessageInterceptor might have canceled if (!request.isCanceled()) { Exchange exchange = matcher.receiveRequest(request); if (exchange != null) { exchange.setEndpoint(CoAPEndpoint.this); coapstack.receiveRequest(exchange, request); } } } else if (parser.isResponse()) { // This is a response Response response = parser.parseResponse(); response.setSource(raw.getAddress()); response.setSourcePort(raw.getPort()); /* * Logging here causes significant performance loss. * If necessary, add an interceptor that logs the messages, * e.g., the MessageTracer. */ for (MessageInterceptor interceptor : interceptors) interceptor.receiveResponse(response); // MessageInterceptor might have canceled if (!response.isCanceled()) { Exchange exchange = matcher.receiveResponse(response); if (exchange != null) { exchange.setEndpoint(CoAPEndpoint.this); response.setRTT(System.currentTimeMillis() - exchange.getTimestamp()); coapstack.receiveResponse(exchange, response); } else if (response.getType() != Type.ACK) { LOGGER.fine("Rejecting unmatchable response from " + raw.getInetSocketAddress()); reject(response); } } } else if (parser.isEmpty()) { // This is an empty message EmptyMessage message = parser.parseEmptyMessage(); message.setSource(raw.getAddress()); message.setSourcePort(raw.getPort()); /* * Logging here causes significant performance loss. * If necessary, add an interceptor that logs the messages, * e.g., the MessageTracer. */ for (MessageInterceptor interceptor : interceptors) interceptor.receiveEmptyMessage(message); // MessageInterceptor might have canceled if (!message.isCanceled()) { // CoAP Ping if (message.getType() == Type.CON || message.getType() == Type.NON) { LOGGER.info("Responding to ping by " + raw.getInetSocketAddress()); reject(message); } else { Exchange exchange = matcher.receiveEmptyMessage(message); if (exchange != null) { exchange.setEndpoint(CoAPEndpoint.this); coapstack.receiveEmptyMessage(exchange, message); } } } } else { LOGGER.finest("Silently ignoring non-CoAP message from " + raw.getInetSocketAddress()); } }
@Override protected synchronized void executeRequest( Request request, String serverURI, String resourceUri) { // defensive check for slash if (!serverURI.endsWith("/") && !resourceUri.startsWith("/")) { resourceUri = "/" + resourceUri; } URI uri = null; try { uri = new URI(serverURI + resourceUri); } catch (URISyntaxException use) { throw new IllegalArgumentException("Invalid URI: " + use.getMessage()); } request.setURI(uri); // for observing int observeLoop = 2; // print request info if (verbose) { System.out.println("Request for test " + this.testName + " sent"); Utils.prettyPrint(request); } // execute the request try { Response response = null; boolean success = true; long time = 5000; request.send(); System.out.println(); System.out.println("**** TEST: " + testName + " ****"); System.out.println("**** BEGIN CHECK ****"); response = request.waitForResponse(time); if (response != null) { success &= checkType(Type.ACK, response.getType()); success &= checkInt(EXPECTED_RESPONSE_CODE.value, response.getCode().value, "code"); success &= checkToken(request.getToken(), response.getToken()); success &= hasContentType(response); success &= hasNonEmptyPalyoad(response); success &= hasObserve(response); if (success) { time = response.getOptions().getMaxAge() * 1000; System.out.println("+++++ Max-Age: " + time + " +++++"); if (time == 0) time = 5000; for (int l = 0; success && (l < observeLoop); ++l) { response = request.waitForResponse(time + 1000); // checking the response if (response != null) { System.out.println("Received notification " + l); // print response info if (verbose) { System.out.println("Response received"); System.out.println("Time elapsed (ms): " + response.getRTT()); Utils.prettyPrint(response); } success &= checkResponse(request, response); } else { System.out.println("FAIL: Notifications stopped"); success = false; break; } // response != null } // observeLoop if (response != null) { System.out.println("+++++++ Canceling +++++++"); request.cancel(); // stack should send RST Thread.sleep(time + time / 2); } else { System.out.println("FAIL: Notifications stopped"); success = false; } } } else { System.out.println("FAIL: No notification after registration"); success = false; } if (success) { System.out.println("**** TEST PASSED ****"); addSummaryEntry(testName + ": PASSED (conditionally)"); } else { System.out.println("**** TEST FAILED ****"); addSummaryEntry(testName + ": --FAILED--"); } tickOffTest(); } catch (InterruptedException e) { System.err.println("Interupted during receive: " + e.getMessage()); System.exit(-1); } }