@Override public RequestContext requestContext() { return delegate.requestContext(); }
@Override public RequestContext requestContext() { return inReplyTo().requestContext(); }
public ResourceRequestWrapper(ResourceRequest resourceRequest) { super(resourceRequest); this.requestContext = new ApplicationContextRequestContext(resourceRequest.requestContext()); }
@Override public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception { if (msg instanceof ResourceResponse) { ((ResourceResponse) msg).inReplyTo().requestContext().dispose(); } super.write(ctx, msg, promise); }
@Override public void onInbound(InboundInterceptorContext context) throws Exception { ResourceRequest req = context.request(); final RequestContext requestContext = req.requestContext(); final DefaultSecurityContext securityContext = (DefaultSecurityContext) requestContext.securityContext(); final String token = getBearerToken(requestContext); if (token != null) { initSecurityContext(context, req, securityContext, token); } else { context.forward(); } }
public Builder(ResourceRequest original) { obj = new DefaultResourceRequest(original); mediaTypeMatcher(original.mediaTypeMatcher()); pagination(original.requestContext().pagination()); resourceState(original.state()); }
HttpRequest original = (HttpRequest) request.requestContext().requestAttributes().getAttribute("HTTP_REQUEST");
@Override public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception { if (msg instanceof ByteBuf) { bytesRead += ((ByteBuf) msg).readableBytes(); startTime = startTime != 0 ? startTime : System.currentTimeMillis(); } else if (msg instanceof DefaultHttpRequest) { DefaultHttpRequest req = (DefaultHttpRequest) msg; event = new AnalyticsEvent(); startTime = startTime != 0 ? startTime : System.currentTimeMillis(); event.setTimestamp(startTime); event.setMethod(req.getMethod().name()); event.setUri(req.getUri()); event.clientAddress(ctx.channel().remoteAddress()); //event.uri(req.resourcePath().toString()); } else if (msg instanceof ResourceRequest) { ResourceRequest req = (ResourceRequest) msg; event.setApplication(req.resourcePath().head().toString()); event.setUserId(req.requestContext().securityContext().getSubject()); event.setApiRequest(true); } super.channelRead(ctx, msg); }
Application app = msg.inReplyTo().requestContext().application(); if (app != null && app instanceof InternalApplication) { ResourcePath htmlAppPath = ((InternalApplication)app).htmlApplicationResourcePath(); .requestAttributes(msg.inReplyTo().requestContext().requestAttributes()).build(); ctx.channel().pipeline().fireChannelRead(htmlAppRequest); return; encodingResult = encodeState(msg.inReplyTo().requestContext(), matcher, msg); } catch (IncompatibleMediaTypeException e) { log.error("Incompatible media type", e); bin.readContent(msg.inReplyTo().requestContext(), new BinaryContentSink() {
/** * Encode (for some cheap value of 'encode') a resulting resource into a ResourceState. * * @param ctx * @param response The response to encode. * @throws Exception */ protected void encode(ChannelHandlerContext ctx, ResourceResponse response, ChannelPromise promise) { final ClientResourceResponse.ResponseType responseType = ClientResourceResponse.ResponseType.OK; if (response.resource() == null) { ctx.writeAndFlush(new ClientResourceResponseImpl(response.inReplyTo(), responseType, response.inReplyTo().resourcePath().toString(), null)); ctx.fireUserEventTriggered(new RequestCompleteEvent(response.requestId())); return; } final ResourceStateEncoder encoder = new ResourceStateEncoder(); RootEncodingDriver driver = new RootEncodingDriver(response.inReplyTo().requestContext(), encoder, response.resource(), () -> { ResourceState state = encoder.root(); response.setState(state); ctx.writeAndFlush(response, promise).addListener(ChannelFutureListener.FIRE_EXCEPTION_ON_FAILURE).addListener(ChannelFutureListener.CLOSE_ON_FAILURE); }, t -> handleError(ctx, response.inReplyTo(), t)); try { driver.encode(); } catch (Throwable e) { handleError(ctx, response.inReplyTo(), e); } }
@Override public void onOutbound(OutboundInterceptorContext context) throws Exception { ResourceResponse response = context.response(); if (context.request().requestType() == RequestType.READ && response.responseType() == ResourceResponse.ResponseType.READ && response.state() != null) { ResourcePath resourcePath = new ResourcePath(response.resource().uri().toString()); SecurityContext securityContext = context.request().requestContext().securityContext(); // Process just members of response.state() and not the state itself as resource has been already authorized at onInbound processMembers(resourcePath, response.state(), securityContext, new Consumer<ResourceState>() { @Override public void accept(ResourceState authorizedState) { response.setState(authorizedState); context.forward(); } }); } else { super.onOutbound(context); } }
@Override public void accept(ClientResourceResponse resourceResponse) { if (resourceResponse.responseType() == ClientResourceResponse.ResponseType.NO_SUCH_RESOURCE) { ctx.forward(); return; } try { ResourceState state = resourceResponse.state(); boolean authorized = (Boolean) state.getProperty(AuthzConstants.ATTR_AUTHZ_RESULT); if (authorized) { ctx.forward(); } else { boolean authenticated = req.requestContext().securityContext().isAuthenticated(); ResourceErrorResponse.ErrorType errorType = authenticated ? ResourceErrorResponse.ErrorType.FORBIDDEN : ResourceErrorResponse.ErrorType.NOT_AUTHORIZED; ctx.replyWith(new DefaultResourceErrorResponse(req, errorType)); } } catch (Throwable t) { ctx.replyWith(new DefaultResourceErrorResponse(req, ResourceErrorResponse.ErrorType.INTERNAL_ERROR)); } } });
attribs.setAttribute(AuthzConstants.ATTR_REQUEST_CONTEXT, req.requestContext()); attribs.setAttribute(AuthzConstants.ATTR_REQUEST_RESOURCE_STATE, req.state()); RequestContext authzRequest = new RequestContext.Builder().requestAttributes(attribs).build();