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 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 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; }
protected ServerResponse invokeOnTarget( HttpRequest request, HttpResponse response, Object target) { if (validator != null) { violationsContainer = new ViolationsContainer<Object>(validator.validate(target)); request.setAttribute(ViolationsContainer.class.getName(), violationsContainer); request.setAttribute(GeneralValidator.class.getName(), validator); } PostMatchContainerRequestContext requestContext = new PostMatchContainerRequestContext(request, this); for (ContainerRequestFilter filter : requestFilters) { try { filter.filter(requestContext); } catch (IOException e) { throw new RuntimeException(e); } ServerResponse serverResponse = (ServerResponse) requestContext.getResponseAbortedWith(); if (serverResponse != null) { return prepareResponse(serverResponse); } } Object rtn = null; try { rtn = methodInjector.invoke(request, response, target); } catch (WebApplicationException wae) { prepareResponse(ServerResponse.convertToServerResponse(wae.getResponse())); throw wae; } if (violationsContainer != null && violationsContainer.size() > 0) { throw new ResteasyViolationExceptionExtension(violationsContainer); } if (request.isSuspended()) { AbstractAsynchronousResponse asyncResponse = (AbstractAsynchronousResponse) request.getAsynchronousResponse(); if (asyncResponse == null) return null; asyncResponse.setAnnotations(method.getAnnotations()); asyncResponse.setWriterInterceptors(writerInterceptors); asyncResponse.setResponseFilters(responseFilters); return null; } if (rtn == null || method.getReturnType().equals(void.class)) { return prepareResponse((ServerResponse) Response.noContent().build()); } if (Response.class.isAssignableFrom(method.getReturnType()) || rtn instanceof Response) { return prepareResponse(ServerResponse.convertToServerResponse((Response) rtn)); } Response.ResponseBuilder builder = Response.ok(rtn); builder.type(resolveContentType(request, rtn)); ServerResponse jaxrsResponse = (ServerResponse) builder.build(); jaxrsResponse.setGenericType(genericReturnType); return prepareResponse(jaxrsResponse); }
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 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; }
protected BuiltResponse invokeOnTarget( HttpRequest request, HttpResponse response, Object target) { if (validator != null) { violationsContainer = new ViolationsContainer<Object>(validator.validate(target)); request.setAttribute(ViolationsContainer.class.getName(), violationsContainer); request.setAttribute(GeneralValidator.class.getName(), validator); } PostMatchContainerRequestContext requestContext = new PostMatchContainerRequestContext(request, this); for (ContainerRequestFilter filter : requestFilters) { try { filter.filter(requestContext); } catch (IOException e) { throw new ApplicationException(e); } BuiltResponse serverResponse = (BuiltResponse) requestContext.getResponseAbortedWith(); if (serverResponse != null) { return serverResponse; } } Object rtn = methodInjector.invoke(request, response, target); if (violationsContainer != null && violationsContainer.size() > 0) { throw new ResteasyViolationExceptionExtension(violationsContainer); } if (request.getAsyncContext().isSuspended()) { request.getAsyncContext().getAsyncResponse().setAnnotations(method.getAnnotations()); request.getAsyncContext().getAsyncResponse().setWriterInterceptors(writerInterceptors); request.getAsyncContext().getAsyncResponse().setResponseFilters(responseFilters); request.getAsyncContext().getAsyncResponse().setMethod(this); return null; } if (rtn == null || method.getReturnType().equals(void.class)) { BuiltResponse build = (BuiltResponse) Response.noContent().build(); build.setAnnotations(method.getAnnotations()); return build; } if (Response.class.isAssignableFrom(method.getReturnType()) || rtn instanceof Response) { BuiltResponse rtn1 = (BuiltResponse) rtn; rtn1.setAnnotations(method.getAnnotations()); return rtn1; } Response.ResponseBuilder builder = Response.ok(rtn); builder.type(resolveContentType(request, rtn)); BuiltResponse jaxrsResponse = (BuiltResponse) builder.build(); jaxrsResponse.setGenericType(genericReturnType); jaxrsResponse.setAnnotations(method.getAnnotations()); return jaxrsResponse; }
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; }
private SecurityContext basicAuthentication(HttpRequest request, HttpResponse response) throws IOException { List<String> headers = request.getHttpHeaders().getRequestHeader(HttpHeaderNames.AUTHORIZATION); if (!headers.isEmpty()) { String auth = headers.get(0); if (auth.length() > 5) { String type = auth.substring(0, 5); type = type.toLowerCase(); if ("basic".equals(type)) { String cookie = auth.substring(6); cookie = new String(Base64.decodeBase64(cookie.getBytes())); String[] split = cookie.split(":"); Principal user = null; try { user = domain.authenticate(split[0], split[1]); return new NettySecurityContext(user, domain, "BASIC", true); } catch (SecurityException e) { response.sendError(HttpResponseCodes.SC_UNAUTHORIZED); return null; } } else { response.sendError(HttpResponseCodes.SC_UNAUTHORIZED); return null; } } } return null; }
private static String getWebSocketLocation(ChannelPipeline cp, HttpRequest req, String path) { String protocol = "ws"; if (cp.get(SslHandler.class) != null) { // SSL in use so use Secure WebSockets protocol = "wss"; } return protocol + "://" + req.getHttpHeaders().getHeaderString(HttpHeaders.Names.HOST) + path; }
protected Response getResponse( HttpRequest request, HttpResponse response, ResourceInvoker invoker) { Response jaxrsResponse = null; try { jaxrsResponse = invoker.invoke(request, response); if (request.getAsyncContext().isSuspended()) { /** * Callback by the initial calling thread. This callback will probably do nothing in an * asynchronous environment but will be used to simulate AsynchronousResponse in vanilla * Servlet containers that do not support asychronous HTTP. */ request.getAsyncContext().getAsyncResponse().initialRequestThreadFinished(); jaxrsResponse = null; // we're handing response asynchronously } } catch (Exception e) { handleInvokerException(request, response, e); } return jaxrsResponse; }
public void build(HttpResponse response) { String origin = request.getHttpHeaders().getRequestHeaders().getFirst(ORIGIN_HEADER); if (origin == null) { logger.debug("No origin returning"); return; } if (!preflight && (allowedOrigins == null || (!allowedOrigins.contains(origin) && !allowedOrigins.contains(ACCESS_CONTROL_ALLOW_ORIGIN_WILDCARD)))) { logger.debug("!preflight and no origin"); return; } logger.debug("build CORS headers and return"); response.getOutputHeaders().add(ACCESS_CONTROL_ALLOW_ORIGIN, origin); if (preflight) { if (allowedMethods != null) { response .getOutputHeaders() .add(ACCESS_CONTROL_ALLOW_METHODS, CollectionUtil.join(allowedMethods)); } else { response.getOutputHeaders().add(ACCESS_CONTROL_ALLOW_METHODS, DEFAULT_ALLOW_METHODS); } } if (!preflight && exposedHeaders != null) { response .getOutputHeaders() .add(ACCESS_CONTROL_EXPOSE_HEADERS, CollectionUtil.join(exposedHeaders)); } response.getOutputHeaders().add(ACCESS_CONTROL_ALLOW_CREDENTIALS, Boolean.toString(auth)); if (preflight) { if (auth) { response .getOutputHeaders() .add( ACCESS_CONTROL_ALLOW_HEADERS, String.format("%s, %s", DEFAULT_ALLOW_HEADERS, AUTHORIZATION_HEADER)); } else { response.getOutputHeaders().add(ACCESS_CONTROL_ALLOW_HEADERS, DEFAULT_ALLOW_HEADERS); } } if (preflight) { response.getOutputHeaders().add(ACCESS_CONTROL_MAX_AGE, DEFAULT_MAX_AGE); } }
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; }
protected void handlePreflightRequest() { if (request.getHttpMethod().equalsIgnoreCase("OPTIONS")) { logger.debug("Cors admin pre-flight"); Response response = Cors.add(request, Response.ok()) .preflight() .allowedMethods("GET", "PUT", "POST", "DELETE") .auth() .build(); throw new NoLogWebApplicationException(response); } }
protected void writeJaxrsResponse( HttpRequest request, HttpResponse response, Response jaxrsResponse) throws WriterException { Object type = jaxrsResponse.getMetadata().getFirst(HttpHeaderNames.CONTENT_TYPE); if (type == null && jaxrsResponse.getEntity() != null) { ResourceMethod method = (ResourceMethod) request.getAttribute(ResourceMethod.class.getName()); if (method != null) { jaxrsResponse .getMetadata() .putSingle( HttpHeaderNames.CONTENT_TYPE, method.resolveContentType(request, jaxrsResponse.getEntity())); } else { MediaType contentType = resolveContentTypeByAccept( request.getHttpHeaders().getAcceptableMediaTypes(), jaxrsResponse.getEntity()); jaxrsResponse.getMetadata().putSingle(HttpHeaderNames.CONTENT_TYPE, contentType); } } ServerResponseWriter.writeResponse( (BuiltResponse) jaxrsResponse, request, response, providerFactory); }
/** * 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; }
public MediaType resolveContentType(HttpRequest in, Object entity) { MediaType chosen = (MediaType) in.getAttribute(Segment.RESTEASY_CHOSEN_ACCEPT); if (chosen != null && !chosen.equals(MediaType.WILDCARD_TYPE)) { return chosen; } List<MediaType> accepts = in.getHttpHeaders().getAcceptableMediaTypes(); if (accepts == null || accepts.size() == 0) { if (produces == null) return MediaType.WILDCARD_TYPE; else return produces[0]; } if (produces == null || produces.length == 0) { return resolveContentTypeByAccept(accepts, entity); } for (MediaType accept : accepts) { for (MediaType type : produces) { if (type.isCompatible(accept)) return type; } } return MediaType.WILDCARD_TYPE; }
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 Response build() { String origin = request.getHttpHeaders().getRequestHeaders().getFirst(ORIGIN_HEADER); if (origin == null) { return builder.build(); } if (!preflight && (allowedOrigins == null || (!allowedOrigins.contains(origin) && !allowedOrigins.contains(ACCESS_CONTROL_ALLOW_ORIGIN_WILDCARD)))) { return builder.build(); } builder.header(ACCESS_CONTROL_ALLOW_ORIGIN, origin); if (preflight) { if (allowedMethods != null) { builder.header(ACCESS_CONTROL_ALLOW_METHODS, CollectionUtil.join(allowedMethods)); } else { builder.header(ACCESS_CONTROL_ALLOW_METHODS, DEFAULT_ALLOW_METHODS); } } if (!preflight && exposedHeaders != null) { builder.header(ACCESS_CONTROL_EXPOSE_HEADERS, CollectionUtil.join(exposedHeaders)); } builder.header(ACCESS_CONTROL_ALLOW_CREDENTIALS, Boolean.toString(auth)); if (preflight) { if (auth) { builder.header( ACCESS_CONTROL_ALLOW_HEADERS, String.format("%s, %s", DEFAULT_ALLOW_HEADERS, AUTHORIZATION_HEADER)); } else { builder.header(ACCESS_CONTROL_ALLOW_HEADERS, DEFAULT_ALLOW_HEADERS); } } if (preflight) { builder.header(ACCESS_CONTROL_MAX_AGE, DEFAULT_MAX_AGE); } return builder.build(); }
public Response redirectAccessCode( AccessCodeEntry accessCode, UserSessionModel session, String state, String redirect, boolean rememberMe) { String code = accessCode.getCode(); UriBuilder redirectUri = UriBuilder.fromUri(redirect).queryParam(OAuth2Constants.CODE, code); log.debugv("redirectAccessCode: state: {0}", state); if (state != null) redirectUri.queryParam(OAuth2Constants.STATE, state); Response.ResponseBuilder location = Response.status(302).location(redirectUri.build()); Cookie remember = request.getHttpHeaders().getCookies().get(AuthenticationManager.KEYCLOAK_REMEMBER_ME); rememberMe = rememberMe || remember != null; // refresh the cookies! authManager.createLoginCookie(realm, accessCode.getUser(), session, uriInfo, rememberMe); if (rememberMe) authManager.createRememberMeCookie(realm, uriInfo); return location.build(); }
/** * Handle Paging Parameters * * @param params */ private void processPaging(HttpRequest request, List<NameValuePair> params, Long requestId) throws WebApplicationException { // Grab session header and pull out all common parameters. String page = null; String sortBy = null; String dir = null; String top = null; String pageSize = null; String count = null; PagingAttribute attr = null; for (NameValuePair nameValuePair : params) { if (nameValuePair.getName().equals("page")) page = nameValuePair.getValue(); else if (nameValuePair.getName().equals("top")) top = nameValuePair.getValue(); else if (nameValuePair.getName().equals("pageSize")) pageSize = nameValuePair.getValue(); else if (nameValuePair.getName().equals("sortBy")) sortBy = nameValuePair.getValue(); else if (nameValuePair.getName().equals("dir")) dir = nameValuePair.getValue(); else if (nameValuePair.getName().equals("count")) count = nameValuePair.getValue(); } if (page != null) { attr = new PagingAttribute(); int value = new Integer(page).intValue(); if (value == 0) ++value; // page=0 doesn't exist. attr.setPageNumber(value); attr.setActive(true); if (pageSize != null && !pageSize.isEmpty()) { attr.setPageSize(new Integer(pageSize)); } if (count != null && !Boolean.parseBoolean(count)) { attr.setType(PagingAttribute.PAGINABLE); } else { attr.setType(PagingAttribute.COUNT); } if (sortBy != null && !sortBy.isEmpty()) { attr.setSortBy(sortBy); if (dir != null) { if (dir.toLowerCase().equals("asc") || dir.toLowerCase().equals("desc")) { attr.setDir(dir); } else { logger.info("Request #%s rejected; dir parameter %s is not recognized", requestId, dir); throw new CustomWebApplicationException( HttpURLConnection.HTTP_BAD_REQUEST, "Request #" + requestId + " rejected; dir parameter " + dir + " is not recognized"); } } } } else if (top != null) { attr = new PagingAttribute(); int value = new Integer(top).intValue(); attr.setTop(value); attr.setType(PagingAttribute.PAGINABLE); } if (attr != null) { PagingContextHolder pagingContextHolder = new PagingContextHolder(attr); request.setAttribute( Key.get(PagingContextHolder.class, Names.named("pagingContextHolder")).toString(), pagingContextHolder); } }
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; }
public ServerResponse preProcess(HttpRequest request, ResourceMethodInvoker method) throws Failure, WebApplicationException { request.setAttribute(InputPart.DEFAULT_CONTENT_TYPE_PROPERTY, TEXT_PLAIN_WITH_CHARSET_UTF_8); return null; }
protected BuiltResponse invokeOnTarget( HttpRequest request, HttpResponse response, Object target) { ResteasyProviderFactory.pushContext( ResourceInfo.class, resourceInfo); // we don't pop so writer interceptors can get at this PostMatchContainerRequestContext requestContext = new PostMatchContainerRequestContext(request, this); for (ContainerRequestFilter filter : requestFilters) { try { filter.filter(requestContext); } catch (IOException e) { throw new ApplicationException(e); } BuiltResponse serverResponse = (BuiltResponse) requestContext.getResponseAbortedWith(); if (serverResponse != null) { return serverResponse; } } if (validator != null) { if (isValidatable) { validator.validate(request, target); } if (methodIsValidatable) { request.setAttribute(GeneralValidator.class.getName(), validator); } else if (isValidatable) { validator.checkViolations(request); } } Object rtn = null; try { rtn = methodInjector.invoke(request, response, target); } catch (RuntimeException ex) { if (request.getAsyncContext().isSuspended()) { try { request.getAsyncContext().getAsyncResponse().resume(ex); } catch (Exception e) { logger.error("Error resuming failed async operation", e); } return null; } else { throw ex; } } if (request.getAsyncContext().isSuspended() || request.wasForwarded()) { return null; } if (rtn == null || method.getReturnType().equals(void.class)) { BuiltResponse build = (BuiltResponse) Response.noContent().build(); build.addMethodAnnotations(method.getAnnotatedMethod()); return build; } if (Response.class.isAssignableFrom(method.getReturnType()) || rtn instanceof Response) { if (!(rtn instanceof BuiltResponse)) { Response r = (Response) rtn; Headers<Object> metadata = new Headers<Object>(); metadata.putAll(r.getMetadata()); rtn = new BuiltResponse(r.getStatus(), metadata, r.getEntity(), null); } BuiltResponse rtn1 = (BuiltResponse) rtn; rtn1.addMethodAnnotations(method.getAnnotatedMethod()); if (rtn1.getGenericType() == null) { if (getMethod().getReturnType().equals(Response.class)) { rtn1.setGenericType(rtn1.getEntityClass()); } else { rtn1.setGenericType(method.getGenericReturnType()); } } return rtn1; } Response.ResponseBuilder builder = Response.ok(rtn); BuiltResponse jaxrsResponse = (BuiltResponse) builder.build(); if (jaxrsResponse.getGenericType() == null) { if (getMethod().getReturnType().equals(Response.class)) { jaxrsResponse.setGenericType(jaxrsResponse.getEntityClass()); } else { jaxrsResponse.setGenericType(method.getGenericReturnType()); } } jaxrsResponse.addMethodAnnotations(method.getAnnotatedMethod()); return jaxrsResponse; }