/** * Clear the state for deduplication in both default endpoints. */ public static void clear() { EndpointManager it = getEndpointManager(); if (it.default_endpoint != null) it.default_endpoint.clear(); if (it.default_secure_endpoint != null) it.default_secure_endpoint.clear(); }
@Override public int getNextMessageId(final InetSocketAddress destination) { MessageIdTracker tracker = getTracker(destination); if (tracker == null) { // we have reached the maximum number of active peers // TODO: throw an exception? return Message.NONE; } else { return tracker.getNextMessageId(); } }
private TcpMatcher newMatcher(boolean useStrictMatching) { NetworkConfig config = NetworkConfig.createStandardWithoutFile(); config.setBoolean(NetworkConfig.Keys.USE_STRICT_RESPONSE_MATCHING, useStrictMatching); TokenProvider tokenProvider = new InMemoryRandomTokenProvider(config); MessageExchangeStore messageExchangeStore = new InMemoryMessageExchangeStore(config, tokenProvider); TcpMatcher matcher = new TcpMatcher(config, messageExchangeStore); matcher.start(); return matcher; }
@Override public final Endpoint getEndpoint(NetworkConfig config, InetSocketAddress address) { CoapEndpoint endpoint = new CoapEndpoint(address, config); return endpoint; }
public void testRegisterOutboundRequestAcceptsRetransmittedRequest() { Exchange exchange = newOutboundRequest(); store.registerOutboundRequest(exchange); // WHEN registering the same request as a re-transmission exchange.setFailedTransmissionCount(1); store.registerOutboundRequest(exchange); // THEN the store contains the re-transmitted request KeyMID key = KeyMID.fromOutboundMessage(exchange.getCurrentRequest()); Exchange exchangeFromStore = store.get(key); assertThat(exchangeFromStore, is(exchange)); assertThat(exchangeFromStore.getFailedTransmissionCount(), is(1)); }
/** * Reset default endpoints. Destroy all default endpoints. */ public static void reset() { EndpointManager it = getEndpointManager(); if (it.default_endpoint != null) { it.default_endpoint.destroy(); it.default_endpoint = null; } if (it.default_secure_endpoint != null) { it.default_secure_endpoint.destroy(); it.default_secure_endpoint = null; } }
public InetSocketAddress getUnsecuredAddress() { if (unsecuredEndpoint != null) { return unsecuredEndpoint.getAddress(); } else { return null; } }
private static void addPeers(final MessageIdProvider provider, final int peerCount) { for (int i = 0; i < peerCount; i++) { provider.getNextMessageId(getPeerAddress(i)); } }
@Override public synchronized void start() { if (!running) { exchangeStore.start(); running = true; } }
@Override public void onContextEstablished(final CorrelationContext context) { exchange.setCorrelationContext(context); } };
/** * Reject the exchange if it is impossible to be processed, e.g. if it * carries an unknown critical option. In most cases, it is better to * respond with an error response code to bad requests though. */ public void reject() { exchange.sendReject(); }
@Override protected void updateEstimator(long measuredRTT, int estimatorType, RemoteEndpoint endpoint){ // Use last RTT measurement, which is then multiplied by a static factor (dithering) long newRTO = measuredRTT; //; (long) (measuredRTT * 1.5); //System.out.println("Basic RTO: " + measuredRTT ); endpoint.updateRTO(newRTO); }
@Override public void sendRequest(final Request request) { // always use endpoint executor runInProtocolStage(new Runnable() { @Override public void run() { coapstack.sendRequest(request); } }); }
/** * Registers this matcher's {@link ExchangeObserver} on a given exchange. * * @param exchange The exchange to observe. */ void observe(final Exchange exchange) { if (exchange != null) { exchange.setObserver(exchangeObserver); } }
@Override public void run() { if (endpoint.removeExchangeInfo(exchange) == false) { // The entry already was removed } else { // Entry was removed, check if there are more messages in the // queue checkRemoteEndpointQueue(exchange); } } }
@Override public boolean isFulFilled() throws IllegalStateException { return exchangeStore.isEmpty(); } });
/** * Clear the state for deduplication in both default endpoints. */ public static void clear() { EndpointManager it = getEndpointManager(); if (it.default_endpoint != null) it.default_endpoint.clear(); if (it.default_secure_endpoint != null) it.default_secure_endpoint.clear(); if (it.default_tcp_endpoint != null) it.default_tcp_endpoint.clear(); if (it.default_secure_tpc_endpoint != null) it.default_secure_tpc_endpoint.clear(); }
public InetSocketAddress getSecuredAddress() { if (securedEndpoint != null) { return securedEndpoint.getAddress(); } else { return null; } } }
public InetSocketAddress getSecuredAddress() { if (securedEndpoint != null) { return securedEndpoint.getAddress(); } else { return null; } }