public ResourceInvoker getInvoker(HttpRequest request) throws Failure {
logger.debug("PathInfo: " + request.getUri().getPath());
if (!request.isInitial()) {
throw new InternalServerErrorException(
request.getUri().getPath()
+ " is not initial request. Its suspended and retried. Aborting.");
}
ResourceInvoker invoker = registry.getResourceInvoker(request);
if (invoker == null) {
throw new NotFoundException(
"Unable to find JAX-RS resource associated with path: " + request.getUri().getPath());
}
return invoker;
}
public BuiltResponse invoke(HttpRequest request, HttpResponse response, Object target) {
request.setAttribute(ResourceMethod.class.getName(), this);
incrementMethodCount(request.getHttpMethod());
ResteasyUriInfo uriInfo = (ResteasyUriInfo) request.getUri();
uriInfo.pushCurrentResource(target);
try {
BuiltResponse jaxrsResponse = invokeOnTarget(request, response, target);
if (jaxrsResponse != null && jaxrsResponse.getEntity() != null) {
// if the content type isn't set, then set it to be either most desired type from the Accept
// header
// or the first media type in the @Produces annotation
// See RESTEASY-144
Object type = jaxrsResponse.getMetadata().getFirst(HttpHeaderNames.CONTENT_TYPE);
if (type == null)
jaxrsResponse
.getMetadata()
.putSingle(
HttpHeaderNames.CONTENT_TYPE,
resolveContentType(request, jaxrsResponse.getEntity()));
}
return jaxrsResponse;
} finally {
uriInfo.popCurrentResource();
}
}
public HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
ResteasyRequestWrapper requestWrapper =
RequestUtil.getRequestWrapper(request, request.getMethod(), prefix);
try {
// NOTE: if invoker isn't found, RESTEasy throw NoReourceFoundFailure
HttpRequest httpRequest = requestWrapper.getHttpRequest();
if (!httpRequest.isInitial()) {
String message =
httpRequest.getUri().getPath()
+ " is not initial request. Its suspended and retried. Aborting.";
logger.error(message);
requestWrapper.setError(500, message);
} else {
Response response = dispatcher.preprocess(httpRequest);
if (response != null) {
requestWrapper.setAbortedResponse(response);
} else {
requestWrapper.setInvoker(getInvoker(httpRequest));
}
}
return new HandlerExecutionChain(requestWrapper, interceptors);
} catch (NotFoundException e) {
if (throwNotFound) {
throw e;
}
logger.error("Resource Not Found: " + e.getMessage(), e);
} catch (Failure e) {
logger.error("ResourceFailure: " + e.getMessage(), e);
throw e;
}
return null;
}
public void handleException(HttpRequest request, HttpResponse response, Throwable e) {
// See if there is an ExceptionMapper for the exact class of the exception instance being thrown
if (executeExactExceptionMapper(request, response, e)) return;
// These are wrapper exceptions so they need to be processed first as they map e.getCause()
if (e instanceof ApplicationException) {
handleApplicationException(request, response, (ApplicationException) e);
return;
} else if (e instanceof WriterException) {
handleWriterException(request, response, (WriterException) e);
return;
} else if (e instanceof ReaderException) {
handleReaderException(request, response, (ReaderException) e);
return;
}
// First try and handle it with a mapper
if (executeExceptionMapper(request, response, e)) {
return;
}
// Otherwise do specific things
else if (e instanceof WebApplicationException) {
handleWebApplicationException(request, response, (WebApplicationException) e);
} else if (e instanceof Failure) {
handleFailure(request, response, (Failure) e);
} else {
logger.error(
"Unknown exception while executing "
+ request.getHttpMethod()
+ " "
+ request.getUri().getPath(),
e);
throw new UnhandledException(e);
}
}
public static MockHttpRequest deepCopy(HttpRequest request) throws IOException {
MockHttpRequest mock = new MockHttpRequest();
mock.uri = request.getUri();
mock.httpHeaders = (ResteasyHttpHeaders) request.getHttpHeaders();
mock.httpMethod = request.getHttpMethod();
byte[] bytes = ReadFromStream.readFromStream(1024, request.getInputStream());
mock.inputStream = new ByteArrayInputStream(bytes);
return mock;
}
public BuiltResponse invoke(HttpRequest request, HttpResponse response, Object target) {
request.setAttribute(ResourceMethodInvoker.class.getName(), this);
incrementMethodCount(request.getHttpMethod());
ResteasyUriInfo uriInfo = (ResteasyUriInfo) request.getUri();
if (method.getPath() != null) {
uriInfo.pushMatchedURI(uriInfo.getMatchingPath());
}
uriInfo.pushCurrentResource(target);
BuiltResponse rtn = invokeOnTarget(request, response, target);
return rtn;
}
public void pushContextObjects(HttpRequest request, HttpResponse response) {
Map contextDataMap = ResteasyProviderFactory.getContextDataMap();
contextDataMap.put(HttpRequest.class, request);
contextDataMap.put(HttpResponse.class, response);
contextDataMap.put(HttpHeaders.class, request.getHttpHeaders());
contextDataMap.put(UriInfo.class, request.getUri());
contextDataMap.put(Request.class, new RequestImpl(request));
contextDataMap.put(ResteasyAsynchronousContext.class, request.getAsyncContext());
contextDataMap.putAll(defaultContextObjects);
}
public ServerResponse preProcess(HttpRequest request, ResourceMethod method)
throws Failure, WebApplicationException {
ServerResponse response = null;
Long requestId = RequestLogger.getInstance().getLogger().getRequestId();
logger.info("Request Interceptor: Processing request #%d", requestId);
List<NameValuePair> params = URLEncodedUtils.parse(request.getUri().getRequestUri(), "UTF-8");
// Handle paging parameters.
processPaging(request, params, requestId);
return response;
}
/**
* Interrogates the request and sets the principal for the request.
*
* @throws WebApplicationException when no auths result in a valid principal
* @throws Failure when there is an unkown failure in the code
* @return the Server Response
*/
public ServerResponse preProcess(HttpRequest request, ResourceMethod method)
throws Failure, WebApplicationException {
SecurityHole securityHole = AuthUtil.checkForSecurityHoleAnnotation(method.getMethod());
Principal principal = null;
if (log.isDebugEnabled()) {
log.debug("Authentication check for " + request.getUri().getPath());
}
// Check for anonymous calls, and let them through
if (securityHole != null && securityHole.anon()) {
log.debug("Request is anonymous, adding NoAuth Principal");
principal = new NoAuthPrincipal();
} else {
// This method is not anonymous, so attempt to
// establish the identity.
for (AuthProvider provider : providers) {
principal = provider.getPrincipal(request);
if (principal != null) {
break;
}
}
}
// At this point, there is no provider that has given a valid principal,
// so we use the NoAuthPrincipal here if it is set.
if (principal == null) {
if (securityHole != null && securityHole.noAuth()) {
log.debug("No auth allowed for resource; setting NoAuth principal");
principal = new NoAuthPrincipal();
} else {
throw new UnauthorizedException("Invalid credentials.");
}
}
// Expose the principal for Resteasy to inject via @Context
ResteasyProviderFactory.pushContext(Principal.class, principal);
if (principal instanceof ConsumerPrincipal) {
// HACK: We need to do this after the principal has been pushed,
// lest our security settings start getting upset when we try to
// update a consumer without any roles:
ConsumerPrincipal p = (ConsumerPrincipal) principal;
consumerCurator.updateLastCheckin(p.getConsumer());
}
return null;
}
protected void handleFailure(HttpRequest request, HttpResponse response, Failure failure) {
if (failure.isLoggable())
logger.error(
"Failed executing " + request.getHttpMethod() + " " + request.getUri().getPath(),
failure);
else
logger.debug(
"Failed executing " + request.getHttpMethod() + " " + request.getUri().getPath(),
failure);
if (failure.getResponse() != null) {
writeFailure(request, response, failure.getResponse());
} else {
try {
if (failure.getMessage() != null) {
response.sendError(failure.getErrorCode(), failure.getMessage());
} else {
response.sendError(failure.getErrorCode());
}
} catch (IOException e1) {
throw new UnhandledException(e1);
}
}
}
public static ChannelFuture handshake(
final ChannelHandlerContext ctx,
final HttpRequest request,
final String websocketPath,
final ChannelHandler handler) {
final String connHead = request.getHttpHeaders().getHeaderString(HttpHeaders.Names.CONNECTION);
final String upHead = request.getHttpHeaders().getHeaderString(HttpHeaders.Names.UPGRADE);
final String sockHead =
request.getHttpHeaders().getHeaderString(HttpHeaders.Names.SEC_WEBSOCKET_VERSION);
final String keyHead =
request.getHttpHeaders().getHeaderString(HttpHeaders.Names.SEC_WEBSOCKET_KEY);
try {
DefaultHttpRequest req =
new DefaultHttpRequest(
HttpVersion.HTTP_1_0, HttpMethod.GET, request.getUri().getAbsolutePath().toString());
req.setHeader(HttpHeaders.Names.SEC_WEBSOCKET_VERSION, sockHead);
req.setHeader(HttpHeaders.Names.SEC_WEBSOCKET_KEY, keyHead);
final Channel channel = ctx.channel();
final String location = getWebSocketLocation(channel.pipeline(), request, websocketPath);
final WebSocketServerHandshakerFactory wsFactory =
new WebSocketServerHandshakerFactory(location, null, false);
final WebSocketServerHandshaker handshaker = wsFactory.newHandshaker(req);
if (handshaker == null) {
WebSocketServerHandshakerFactory.sendUnsupportedWebSocketVersionResponse(channel);
return null;
} else if (!connHead.toLowerCase().contains(HttpHeaders.Values.UPGRADE.toLowerCase())
|| !upHead.toLowerCase().contains(HttpHeaders.Values.WEBSOCKET.toLowerCase())) {
// Not a valid socket open request
logger.info("Invalid request: " + request.getUri());
return null;
} else {
// We need to remove the RESTEasy stuff otherwise the Netty logic to write the handshake to
// the channel
// will never make it back to the client
channel.pipeline().remove("resteasyEncoder");
channel.pipeline().remove("resteasyDecoder");
final ChannelFuture handshakeFuture = handshaker.handshake(channel, req);
handshakeFuture.addListener(
new ChannelFutureListener() {
@Override
public void operationComplete(ChannelFuture future) throws Exception {
if (!future.isSuccess()) {
ctx.fireExceptionCaught(future.cause());
} else {
final ChannelPipeline pipeline = future.channel().pipeline();
pipeline.replace(pipeline.last(), "customSocketHandler", handler);
pipeline.addBefore(
"customSocketHandler", "socketHandler", new WebSocketProtocolHandler());
}
}
});
WebSocketProtocolHandler.setHandshaker(ctx, handshaker);
return handshakeFuture;
// channel.pipeline().addBefore("timeout", "WS403Responder",
// WebSocketProtocolHandler.forbiddenHttpRequestResponder());
}
} catch (Exception e) {
logger.error("Error trying to upgrade the channel to a socket", e);
}
return null;
}