/** * Sends the request over the specified endpoint to its destination and * expects a response back. * * @param endpoint the endpoint * @return this request */ public Request send(Endpoint endpoint) { validateBeforeSending(); endpoint.sendRequest(this); return this; }
/** * Sends this request over the specified endpoint to its destination and * expects a response back. * * @param endpoint the endpoint * @return this request * @throws NullPointerException if this request has no destination set. */ public Request send(Endpoint endpoint) { validateBeforeSending(); endpoint.sendRequest(this); return this; }
/** * Sends the request over the default endpoint to its destination and * expects a response back. * @return this request */ public Request send() { validateBeforeSending(); if (CoAP.COAP_SECURE_URI_SCHEME.equals(getScheme())) { // This is the case when secure coap is supposed to be used EndpointManager.getEndpointManager().getDefaultSecureEndpoint().sendRequest(this); } else { // This is the normal case EndpointManager.getEndpointManager().getDefaultEndpoint().sendRequest(this); } return this; }
/** * Sends the request over the default endpoint to its destination and * expects a response back. * * @return this request * @throws NullPointerException if this request has no destination set. */ public Request send() { validateBeforeSending(); if (CoAP.COAP_SECURE_URI_SCHEME.equals(getScheme())) { // This is the case when secure coap is supposed to be used EndpointManager.getEndpointManager().getDefaultSecureEndpoint().sendRequest(this); } else { // This is the normal case EndpointManager.getEndpointManager().getDefaultEndpoint().sendRequest(this); } return this; }
/** * Sends the specified request over the specified endpoint. * * @param request the request * @param outEndpoint the endpoint * @return the request */ protected Request send(Request request, Endpoint outEndpoint) { if (blockwise!=0) { request.getOptions().setBlock2(new BlockOption(BlockOption.size2Szx(this.blockwise), false, 0)); } outEndpoint.sendRequest(request); return request; }
/** * Sends the specified request over the specified endpoint. * * @param request the request * @param outEndpoint the endpoint * @return the request */ protected Request send(Request request, Endpoint outEndpoint) { // use the specified message type request.setType(this.type); if (blockwise!=0) { request.getOptions().setBlock2(new BlockOption(BlockOption.size2Szx(this.blockwise), false, 0)); } outEndpoint.sendRequest(request); return request; }
@Override public <T extends LwM2mResponse> void send(InetSocketAddress serverAddress, boolean secure, final UplinkRequest<T> request, long timeout, ResponseCallback<T> responseCallback, ErrorCallback errorCallback) { // Create the CoAP request from LwM2m request CoapRequestBuilder coapClientRequestBuilder = new CoapRequestBuilder(serverAddress); request.accept(coapClientRequestBuilder); Request coapRequest = coapClientRequestBuilder.getRequest(); // Add CoAP request callback MessageObserver obs = new AsyncRequestObserver<T>(coapRequest, responseCallback, errorCallback, timeout) { @Override public T buildResponse(Response coapResponse) { // Build LwM2m response LwM2mClientResponseBuilder<T> lwm2mResponseBuilder = new LwM2mClientResponseBuilder<>(coapResponse); request.accept(lwm2mResponseBuilder); return lwm2mResponseBuilder.getResponse(); } }; coapRequest.addMessageObserver(obs); // Send CoAP request asynchronously endpointsManager.getEndpoint(null).sendRequest(coapRequest); } }
@Override public <T extends LwM2mResponse> void send(final Client destination, final DownlinkRequest<T> request, final ResponseConsumer<T> responseCallback, final ExceptionConsumer errorCallback) { // Create the CoAP request from LwM2m request final CoapRequestBuilder CoapRequestBuilder = new CoapRequestBuilder(destination); request.accept(CoapRequestBuilder); final Request coapRequest = CoapRequestBuilder.getRequest(); // Add CoAP request callback coapRequest.addMessageObserver(new AsyncRequestObserver<T>(coapRequest, destination, responseCallback, errorCallback) { @Override public T buildResponse(final Response coapResponse) { // Build LwM2m response final LwM2mResponseBuilder<T> lwm2mResponseBuilder = new LwM2mResponseBuilder<T>(coapRequest, coapResponse, client, observationRegistry); request.accept(lwm2mResponseBuilder); return lwm2mResponseBuilder.getResponse(); } }); // Send CoAP request asynchronously final Endpoint endpoint = getEndpointForClient(destination); endpoint.sendRequest(coapRequest); }
@Override public <T extends LwM2mResponse> T send(InetSocketAddress serverAddress, boolean secure, final UplinkRequest<T> request, long timeout) throws InterruptedException { // Create the CoAP request from LwM2m request CoapRequestBuilder coapClientRequestBuilder = new CoapRequestBuilder(serverAddress); request.accept(coapClientRequestBuilder); Request coapRequest = coapClientRequestBuilder.getRequest(); // Send CoAP request synchronously SyncRequestObserver<T> syncMessageObserver = new SyncRequestObserver<T>(coapRequest, timeout) { @Override public T buildResponse(Response coapResponse) { // Build LwM2m response LwM2mClientResponseBuilder<T> lwm2mResponseBuilder = new LwM2mClientResponseBuilder<>(coapResponse); request.accept(lwm2mResponseBuilder); return lwm2mResponseBuilder.getResponse(); } }; coapRequest.addMessageObserver(syncMessageObserver); // Send CoAP request asynchronously endpointsManager.getEndpoint(null).sendRequest(coapRequest); // Wait for response, then return it return syncMessageObserver.waitForResponse(); }
@Test public void testRequestForOversizedBodyGetsCanceled() throws InterruptedException { final CountDownLatch latch = new CountDownLatch(1); Request req = Request.newGet().setURI(getUri(serverEndpoint, RESOURCE_BIG)); req.addMessageObserver(new MessageObserverAdapter() { @Override public void onCancel() { latch.countDown(); } }); clientEndpoint.sendRequest(req); assertTrue(latch.await(1000, TimeUnit.MILLISECONDS)); }
@Override public <T extends LwM2mResponse> T send(final Client destination, final DownlinkRequest<T> request) { // Create the CoAP request from LwM2m request final CoapRequestBuilder CoapRequestBuilder = new CoapRequestBuilder(destination); request.accept(CoapRequestBuilder); final Request coapRequest = CoapRequestBuilder.getRequest(); // Send CoAP request synchronously final SyncRequestObserver<T> syncMessageObserver = new SyncRequestObserver<T>(coapRequest, destination, timeoutMillis) { @Override public T buildResponse(final Response coapResponse) { // Build LwM2m response final LwM2mResponseBuilder<T> lwm2mResponseBuilder = new LwM2mResponseBuilder<T>(coapRequest, coapResponse, client, observationRegistry); request.accept(lwm2mResponseBuilder); return lwm2mResponseBuilder.getResponse(); } }; coapRequest.addMessageObserver(syncMessageObserver); // Send CoAP request asynchronously final Endpoint endpoint = getEndpointForClient(destination); endpoint.sendRequest(coapRequest); // Wait for response, then return it return syncMessageObserver.waitForResponse(); }
@Override public void sendCoapRequest(final Registration destination, final Request coapRequest, long timeout, CoapResponseCallback responseCallback, ErrorCallback errorCallback) { // Define destination EndpointContext context = EndpointContextUtil.extractContext(destination.getIdentity()); coapRequest.setDestinationContext(context); // Add CoAP request callback MessageObserver obs = new CoapAsyncRequestObserver(coapRequest, responseCallback, errorCallback, timeout); coapRequest.addMessageObserver(obs); // Store pending request to cancel it on de-registration addPendingRequest(destination.getId(), coapRequest); // Send CoAP request asynchronously Endpoint endpoint = getEndpointForClient(destination); endpoint.sendRequest(coapRequest); }
@Override public void send(final LwM2mClientRequest request, final ResponseCallback responseCallback) { // Create the CoAP request from LwM2m request final CoapClientRequestBuilder coapClientRequestBuilder = new CoapClientRequestBuilder(serverAddress, clientObjectModel); request.accept(coapClientRequestBuilder); if (!coapClientRequestBuilder.areParametersValid()) { responseCallback.onFailure(OperationResponse.failure(ResponseCode.INTERNAL_SERVER_ERROR, "Request has invalid parameters. Not sending.")); return; } final Request coapRequest = coapClientRequestBuilder.getRequest(); // Add CoAP request callback coapRequest.addMessageObserver(new AsyncRequestObserver(coapRequest, responseCallback) { @Override public OperationResponse buildResponse(final Response coapResponse) { // Build LwM2m response final LwM2mClientResponseBuilder lwm2mResponseBuilder = new LwM2mClientResponseBuilder(coapRequest, coapResponse, CaliforniumLwM2mClientRequestSender.this); request.accept(lwm2mResponseBuilder); return lwm2mResponseBuilder.getResponse(); } }); // Send CoAP request asynchronously clientEndpoint.sendRequest(coapRequest); }
@Override public void send(final LwM2mClientRequest request, final ResponseCallback responseCallback) { // Create the CoAP request from LwM2m request final CoapClientRequestBuilder coapClientRequestBuilder = new CoapClientRequestBuilder(serverAddress, clientObjectModel); request.accept(coapClientRequestBuilder); if (!coapClientRequestBuilder.areParametersValid()) { responseCallback.onFailure(OperationResponse.failure(ResponseCode.INTERNAL_SERVER_ERROR, "Request has invalid parameters. Not sending.")); return; } final Request coapRequest = coapClientRequestBuilder.getRequest(); // Add CoAP request callback coapRequest.addMessageObserver(new AsyncRequestObserver(coapRequest, responseCallback) { @Override public OperationResponse buildResponse(final Response coapResponse) { // Build LwM2m response final LwM2mClientResponseBuilder lwm2mResponseBuilder = new LwM2mClientResponseBuilder(coapRequest, coapResponse, CaliforniumLwM2mClientRequestSender.this); request.accept(lwm2mResponseBuilder); return lwm2mResponseBuilder.getResponse(); } }); // Send CoAP request asynchronously clientEndpoint.sendRequest(coapRequest); }
@Override public Response sendCoapRequest(final Registration destination, final Request coapRequest, long timeout) throws InterruptedException { // Define destination EndpointContext context = EndpointContextUtil.extractContext(destination.getIdentity()); coapRequest.setDestinationContext(context); // Send CoAP request synchronously CoapSyncRequestObserver syncMessageObserver = new CoapSyncRequestObserver(coapRequest, timeout); coapRequest.addMessageObserver(syncMessageObserver); // Store pending request to cancel it on de-registration addPendingRequest(destination.getId(), coapRequest); // Send CoAP request asynchronously Endpoint endpoint = getEndpointForClient(destination); endpoint.sendRequest(coapRequest); // Wait for response, then return it return syncMessageObserver.waitForCoapResponse(); }
/** * Send request with option "cancel observe" (GET with Observe=1). */ private void sendCancelObserve() { Request request = this.request; Request cancel = Request.newGet(); cancel.setDestination(request.getDestination()); cancel.setDestinationPort(request.getDestinationPort()); // use same Token cancel.setToken(request.getToken()); // copy options, but set Observe to cancel cancel.setOptions(request.getOptions()); cancel.setObserveCancel(); // dispatch final response to the same message observers for (MessageObserver mo : request.getMessageObservers()) { cancel.addMessageObserver(mo); } endpoint.sendRequest(cancel); }
/** * Send request with option "cancel observe" (GET with Observe=1). */ private void sendCancelObserve() { Request request = this.request; Request cancel = Request.newGet(); cancel.setDestination(request.getDestination()); cancel.setDestinationPort(request.getDestinationPort()); // use same Token cancel.setToken(request.getToken()); // copy options, but set Observe to cancel cancel.setOptions(request.getOptions()); cancel.setObserveCancel(); // dispatch final response to the same message observers for (MessageObserver mo: request.getMessageObservers()) { cancel.addMessageObserver(mo); } endpoint.sendRequest(cancel); }
@Override public <T extends LwM2mResponse> void send(final Registration destination, final DownlinkRequest<T> request, long timeout, ResponseCallback<T> responseCallback, ErrorCallback errorCallback) { // Retrieve the objects definition final LwM2mModel model = modelProvider.getObjectModel(destination); // Create the CoAP request from LwM2m request CoapRequestBuilder coapRequestBuilder = new CoapRequestBuilder(destination.getIdentity(), destination.getRootPath(), destination.getId(), destination.getEndpoint(), model, encoder); request.accept(coapRequestBuilder); final Request coapRequest = coapRequestBuilder.getRequest(); // Add CoAP request callback MessageObserver obs = new AsyncRequestObserver<T>(coapRequest, responseCallback, errorCallback, timeout) { @Override public T buildResponse(Response coapResponse) { // Build LwM2m response LwM2mResponseBuilder<T> lwm2mResponseBuilder = new LwM2mResponseBuilder<>(coapRequest, coapResponse, destination, model, observationService, decoder); request.accept(lwm2mResponseBuilder); return lwm2mResponseBuilder.getResponse(); } }; coapRequest.addMessageObserver(obs); // Store pending request to cancel it on de-registration addPendingRequest(destination.getId(), coapRequest); // Send CoAP request asynchronously Endpoint endpoint = getEndpointForClient(destination); endpoint.sendRequest(coapRequest); }
private void executePOSTRequest(final boolean shortRequest, final boolean respondShort) throws Exception { String payload = "--no payload--"; try { interceptor.clear(); Request request = Request.newPost().setURI(getUri(serverEndpoint, RESOURCE_TEST)); if (shortRequest) { request.setPayload(SHORT_POST_REQUEST); request.getOptions().addUriQuery(PARAM_SHORT_REQ); } else { request.setPayload(LONG_POST_REQUEST); } if (respondShort) { request.getOptions().addUriQuery(PARAM_SHORT_RESP); } clientEndpoint.sendRequest(request); // receive response and check Response response = request.waitForResponse(2000); assertNotNull("Client received no response", response); payload = response.getPayloadString(); if (respondShort) { assertEquals(SHORT_POST_RESPONSE, payload); } else { assertEquals(LONG_POST_RESPONSE, payload); } } finally { Thread.sleep(100); // Quickly wait until last ACKs arrive System.out.println("Client received payload [" + payload + "]" + System.lineSeparator() + interceptor.toString() + System.lineSeparator()); } }
client.sendRequest(request); client.sendRequest(request);