use of com.linkedin.r2.message.RequestContext in project rest.li by linkedin.
the class TransportClientAdapter method streamRequest.
@Override
public void streamRequest(StreamRequest request, RequestContext requestContext, Callback<StreamResponse> callback) {
final Map<String, String> wireAttrs = new HashMap<String, String>();
//make a copy of the caller's RequestContext to ensure that we have a unique instance per-request
_client.streamRequest(request, new RequestContext(requestContext), wireAttrs, new TransportCallbackAdapter<StreamResponse>(callback));
}
use of com.linkedin.r2.message.RequestContext in project rest.li by linkedin.
the class TransportDispatcherImpl method handleStreamRequest.
@Override
public void handleStreamRequest(StreamRequest req, Map<String, String> wireAttrs, RequestContext requestContext, TransportCallback<StreamResponse> callback) {
final URI address = req.getURI();
final StreamRequestHandler handler = _streamHandlers.get(address);
if (handler == null) {
final RestResponse response = RestStatus.responseForStatus(RestStatus.NOT_FOUND, "No resource for URI: " + address);
callback.onResponse(TransportResponseImpl.success(Messages.toStreamResponse(response)));
req.getEntityStream().setReader(new DrainReader());
return;
}
try {
handler.handleRequest(req, requestContext, new TransportCallbackAdapter<StreamResponse>(callback));
} catch (Exception e) {
final Exception ex = RestException.forError(RestStatus.INTERNAL_SERVER_ERROR, e);
callback.onResponse(TransportResponseImpl.<StreamResponse>error(ex));
}
}
use of com.linkedin.r2.message.RequestContext in project rest.li by linkedin.
the class QueryTunnelUtil method encode.
/**
* @param request a StreamRequest object to be encoded as a tunneled POST
* @param requestContext a RequestContext object associated with the request
* @param threshold the size of the query params above which the request will be encoded
* @param callback the callback to be executed with the encoded request
*/
public static void encode(final StreamRequest request, RequestContext requestContext, int threshold, final Callback<StreamRequest> callback) {
URI uri = request.getURI();
// Check to see if we should tunnel this request by testing the length of the query
// if the query is NULL, we won't bother to encode.
// 0 length is a special case that could occur with a url like http://www.foo.com?
// which we don't want to encode, because we'll lose the "?" in the process
// Otherwise only encode queries whose length is greater than or equal to the
// threshold value.
String query = uri.getRawQuery();
boolean forceQueryTunnel = requestContext.getLocalAttr(R2Constants.FORCE_QUERY_TUNNEL) != null && (Boolean) requestContext.getLocalAttr(R2Constants.FORCE_QUERY_TUNNEL);
if (query == null || query.length() == 0 || (query.length() < threshold && !forceQueryTunnel)) {
callback.onSuccess(request);
} else {
// If we need to encode, we'll fully buffer the request first. See class doc for the reasoning.
Messages.toRestRequest(request, new Callback<RestRequest>() {
@Override
public void onError(Throwable e) {
callback.onError(e);
}
@Override
public void onSuccess(RestRequest result) {
RestRequest encodedRequest;
try {
encodedRequest = doEncode(result);
} catch (Exception ex) {
callback.onError(ex);
return;
}
callback.onSuccess(Messages.toStreamRequest(encodedRequest));
}
});
}
}
use of com.linkedin.r2.message.RequestContext in project rest.li by linkedin.
the class TestServerTimeout method setup.
@BeforeClass
public void setup() throws IOException {
_clientFactory = new HttpClientFactory();
Map<String, Object> clientProperties = new HashMap<String, Object>();
clientProperties.put(HttpClientFactory.HTTP_REQUEST_TIMEOUT, String.valueOf(SERVER_IOHANDLER_TIMEOUT * 20));
clientProperties.put(HttpClientFactory.HTTP_POOL_MIN_SIZE, "1");
clientProperties.put(HttpClientFactory.HTTP_POOL_SIZE, "1");
_client = new TransportClientAdapter(_clientFactory.getClient(clientProperties), true);
final Map<URI, StreamRequestHandler> handlers = new HashMap<URI, StreamRequestHandler>();
handlers.put(BUGGY_SERVER_URI, new BuggyRequestHandler());
handlers.put(THROW_BUT_SHOULD_NOT_TIMEOUT_URI, new ThrowHandler());
handlers.put(BUGGY_FILTER_URI, new NormalHandler());
TransportDispatcher transportDispatcher = new TransportDispatcher() {
@Override
public void handleRestRequest(RestRequest req, Map<String, String> wireAttrs, RequestContext requestContext, TransportCallback<RestResponse> callback) {
throw new UnsupportedOperationException("This dispatcher only supports stream");
}
@Override
public void handleStreamRequest(StreamRequest req, Map<String, String> wireAttrs, RequestContext requestContext, TransportCallback<StreamResponse> callback) {
StreamRequestHandler handler = handlers.get(req.getURI());
if (handler != null) {
handler.handleRequest(req, requestContext, new TransportCallbackAdapter<StreamResponse>(callback));
} else {
req.getEntityStream().setReader(new DrainReader());
callback.onResponse(TransportResponseImpl.<StreamResponse>error(new IllegalStateException("Handler not found for URI " + req.getURI())));
}
}
};
FilterChain filterChain = FilterChains.createStreamChain(new BuggyFilter());
_server = new HttpServerFactory(filterChain).createRAPServer(PORT, transportDispatcher, SERVER_IOHANDLER_TIMEOUT, true);
_server.start();
}
use of com.linkedin.r2.message.RequestContext in project rest.li by linkedin.
the class TestServerTimeoutAsyncEvent method setup.
@BeforeClass
public void setup() throws IOException {
_clientFactory = new HttpClientFactory();
Map<String, Object> clientProperties = new HashMap<String, Object>();
clientProperties.put(HttpClientFactory.HTTP_REQUEST_TIMEOUT, String.valueOf(ASYNC_EVENT_TIMEOUT * 20));
clientProperties.put(HttpClientFactory.HTTP_POOL_MIN_SIZE, "1");
clientProperties.put(HttpClientFactory.HTTP_POOL_SIZE, "1");
_client = new TransportClientAdapter(_clientFactory.getClient(clientProperties), true);
final Map<URI, StreamRequestHandler> handlers = new HashMap<URI, StreamRequestHandler>();
handlers.put(TIMEOUT_BEFORE_SENDING_RESPONSE_SERVER_URI, new TimeoutBeforeRespondingRequestHandler());
handlers.put(TIMEOUT_AFTER_SENDING_RESPONSE_SERVER_URI, new TimeoutAfterRespondingRequestHandler());
handlers.put(THROW_BUT_SHOULD_NOT_TIMEOUT_URI, new ThrowHandler());
handlers.put(BUGGY_FILTER_URI, new NormalHandler());
TransportDispatcher transportDispatcher = new TransportDispatcher() {
@Override
public void handleRestRequest(RestRequest req, Map<String, String> wireAttrs, RequestContext requestContext, TransportCallback<RestResponse> callback) {
throw new UnsupportedOperationException("This dispatcher only supports stream");
}
@Override
public void handleStreamRequest(StreamRequest req, Map<String, String> wireAttrs, RequestContext requestContext, TransportCallback<StreamResponse> callback) {
StreamRequestHandler handler = handlers.get(req.getURI());
if (handler != null) {
handler.handleRequest(req, requestContext, new TransportCallbackAdapter<StreamResponse>(callback));
} else {
req.getEntityStream().setReader(new DrainReader());
callback.onResponse(TransportResponseImpl.<StreamResponse>error(new IllegalStateException("Handler not found for URI " + req.getURI())));
}
}
};
FilterChain filterChain = FilterChains.createStreamChain(new BuggyFilter());
_server = new HttpServerFactory(filterChain, HttpJettyServer.ServletType.ASYNC_EVENT).createServer(PORT, transportDispatcher, ASYNC_EVENT_TIMEOUT, true);
_server.start();
_asyncExecutor = Executors.newSingleThreadExecutor();
}
Aggregations