/** * Checks whether this response is a notification for * an observed resource. * * @return {@code true} if this response has the observe option set. */ public boolean isNotification() { return getOptions().hasObserve(); }
@Override public boolean isObserve() { return exchange.getRequestOptions().hasObserve() && exchange.getRequestCode() == CoAP.Code.GET; }
@Override public boolean isObserve() { return exchange.getRequestOptions().hasObserve() && exchange.getRequestCode() == CoAP.Code.GET; }
protected final void appendObserveOption(final OptionSet options) { if (options != null && options.hasObserve()) { buffer.append(", observe(").append(options.getObserve()).append(")"); } }
/** * Checks if this request is used to establish an observe relation. * * @return {@code true} if this request's <em>observe</em> option is set to 0. */ public final boolean isObserve() { return getOptions().hasObserve() && getOptions().getObserve() == 0; }
@Override public void receiveResponse(final Exchange exchange, final Response response) { if (!response.getOptions().hasObserve()) { exchange.setComplete(); } if (hasDeliverer()) { // notify request that response has arrived deliverer.deliverResponse(exchange, response); } else { LOGGER.severe("Top of CoAP stack has no deliverer to deliver response"); } }
@Override public void receiveResponse(Exchange exchange, Response response) { if (!response.getOptions().hasObserve() && !exchange.getCurrentRequest().isMulticast()) exchange.setComplete(); if (deliverer != null) { deliverer.deliverResponse(exchange, response); // notify request that response has arrived } else { LOGGER.severe("Top of CoAP stack has no deliverer to deliver response"); } }
@Override public void receiveResponse(final Exchange exchange, final Response response) { if (response.getOptions().hasObserve() && exchange.getRequest().isCanceled()) { // The request was canceled and we no longer want notifications LOGGER.finer("Ignore notification for canceled TCP Exchange"); } else { // No observe option in response => always deliver upper().receiveResponse(exchange, response); } } }
private CoapObserveRelation observe(Request request, CoapHandler handler) { if (request.getOptions().hasObserve()) { Endpoint outEndpoint = getEffectiveEndpoint(request); CoapObserveRelation relation = new CoapObserveRelation(request, outEndpoint); request.addMessageObserver(new ObserveMessageObserverImpl(handler, relation)); send(request, outEndpoint); return relation; } else { throw new IllegalArgumentException("please make sure that the request has observe option set."); } }
private CoapObserveRelation observeAndWait(Request request, CoapHandler handler) { if (request.getOptions().hasObserve()) { Endpoint outEndpoint = getEffectiveEndpoint(request); CoapObserveRelation relation = new CoapObserveRelation(request, outEndpoint); request.addMessageObserver(new ObserveMessageObserverImpl(handler, relation)); CoapResponse response = synchronous(request, outEndpoint); if (response == null || !response.advanced().getOptions().hasObserve()) { relation.setCanceled(true); } return relation; } else { throw new IllegalArgumentException("please make sure that the request has observe option set."); } }
@Override public void receiveResponse(Exchange exchange, Response response) { if (response.getOptions().hasObserve() && exchange.getRequest().isCanceled()) { // The request was canceled and we no longer want notifications LOGGER.finer("Rejecting notification for canceled Exchange"); EmptyMessage rst = EmptyMessage.newRST(response); sendEmptyMessage(exchange, rst); // Matcher sets exchange as complete when RST is sent } else { // No observe option in response => always deliver super.receiveResponse(exchange, response); } }
@Override public void receiveResponse(final Exchange exchange, final Response response) { if (response.getOptions().hasObserve() && exchange.getRequest().isCanceled()) { // The request was canceled and we no longer want notifications LOGGER.finer("Rejecting notification for canceled Exchange"); EmptyMessage rst = EmptyMessage.newRST(response); sendEmptyMessage(exchange, rst); // Matcher sets exchange as complete when RST is sent } else { // No observe option in response => always deliver upper().receiveResponse(exchange, response); } }
@Override public void onLoad(final CoapResponse response) { String responseDescription = String.format("onLoad(%d) '%s'", onLoadCounter.incrementAndGet(), response.getResponseText()); System.out.println(responseDescription); if (response.getResponseText().startsWith(CONTENT_1) && response.advanced().getOptions().hasObserve()) { try { assertAwait("assert missing", barrier, 2000, TimeUnit.MILLISECONDS); } catch (InterruptedException e) { } } } });
public void check(Response response) { assertTrue("Has no observe option", response.getOptions().hasObserve()); storage.put(key, response.getOptions().getObserve()); } });
public void check(Response response) { assertTrue("Has no observe option", response.getOptions().hasObserve()); Object value = storage.get(key); if (value == null) { throw new IllegalArgumentException("Key " + key + " not found"); } int V1 = (Integer) value; int V2 = response.getOptions().getObserve(); boolean fresh = V1 < V2 && V2 - V1 < 1 << 23 || V1 > V2 && V1 - V2 > 1 << 23; assertTrue("Was not a fresh notification. Last obs=" + V1 + ", new=" + V2, fresh); } });
@Override public void onLoad(CoapResponse response) { notifications.incrementAndGet(); String payload = response.getResponseText(); Assert.assertEquals(expected, payload); Assert.assertTrue(response.advanced().getOptions().hasObserve()); } @Override public void onError() {
private void registerWithToken(final Exchange exchange) { Request request = exchange.getCurrentRequest(); KeyToken idByToken; if (request.getToken() == null) { idByToken = tokenProvider.getUnusedToken(request); request.setToken(idByToken.getToken()); } else { idByToken = KeyToken.fromOutboundMessage(request); // ongoing requests may reuse token if (!(exchange.getFailedTransmissionCount() > 0 || request.getOptions().hasBlock1() || request.getOptions().hasBlock2() || request.getOptions().hasObserve()) && tokenProvider.isTokenInUse(idByToken)) { LOGGER.log(Level.WARNING, "Manual token overrides existing open request: {0}", idByToken); } } exchangesByToken.put(idByToken, exchange); }
@Override public void sendResponse(final Exchange exchange, final Response response) { final ObserveRelation relation = exchange.getRelation(); if (relation != null && relation.isEstablished()) { if (!response.getOptions().hasObserve()) { /* response for cancel request */ relation.cancel(); response.setLast(true); } else { response.setLast(false); } } // else no observe was requested or the resource does not allow it lower().sendResponse(exchange, response); }
public void check(Response response) { assertTrue("No observe option:", response.getOptions().hasObserve()); int expected = (Integer) storage.get(key); int actual = response.getOptions().getObserve(); assertEquals("Wrong observe sequence number:", expected, actual); print("Correct observe sequence number: " + expected); } });
public void check(Message message) { assertTrue("No observe option:", message.getOptions().hasObserve()); int actual = message.getOptions().getObserve(); assertEquals("Wrong observe sequence number:", observe, actual); print("Correct observe sequence number: " + observe); }