@Override protected Request newRequest() { return new Request(loader, URI.create(requestUri)); }
public boolean sendRequest(Request request, ResponseHandler responseHandler) { request.connect(responseHandler).close(null); return true; }
@Override public Object getAttribute(String name) { return request.context().get(name); }
@Override public synchronized void scheduleTimeout(Request request) { if (responded) { return; } if (timeoutQueueEntry == null) { timeoutQueueEntry = schedules[(++nextScheduler & 0xffff) % schedules.length].newEntry(this); } timeoutQueueEntry.scheduleAt(request.creationTime(TimeUnit.MILLISECONDS) + request.getTimeout(TimeUnit.MILLISECONDS)); ++queueSize; }
public MockResponseHandler sendRequest(String uri, HttpRequest.Method method, ByteBuffer body, String contentType) { responseHandler = new MockResponseHandler(); Request request = HttpRequest.newServerRequest(driver, URI.create(uri), method); request.context().put("contextVariable", 37); // TODO: Add a method for accepting a Request instead request.headers().put(com.yahoo.jdisc.http.HttpHeaders.Names.CONTENT_TYPE, contentType); ContentChannel requestContent = request.connect(responseHandler); requestContent.write(body, null); requestContent.close(null); request.release(); return responseHandler; }
private static com.yahoo.jdisc.Request createDiscRequest(Request request, CurrentContainer currentContainer) { String scheme = getScheme(request.getUri()); com.yahoo.jdisc.Request discRequest; if ("http".equals(scheme) || "https".equals(scheme)) { com.yahoo.jdisc.http.HttpRequest httpRequest = com.yahoo.jdisc.http.HttpRequest.newServerRequest(currentContainer, URI.create(request.getUri()), com.yahoo.jdisc.http.HttpRequest.Method.valueOf(request.getMethod().name())); request.getUserPrincipal().ifPresent(httpRequest::setUserPrincipal); discRequest = httpRequest; } else { discRequest = new com.yahoo.jdisc.Request(currentContainer, URI.create(request.getUri())); } for (Map.Entry<String, List<String>> entry : request.getHeaders().entrySet()) { discRequest.headers().add(entry.getKey(), entry.getValue()); } discRequest.context().putAll(request.getAttributes()); return discRequest; }
public MockResponseHandler sendRequest(String uri, HttpRequest.Method method, ByteBuffer body) { responseHandler = new MockResponseHandler(); Request request = HttpRequest.newServerRequest(driver, URI.create(uri), method); request.context().put("contextVariable", 37); // TODO: Add a method for accepting a Request instead ContentChannel requestContent = request.connect(responseHandler); requestContent.write(body, null); requestContent.close(null); request.release(); return responseHandler; }
/** * <p>Factory method to create a {@link Request} without an associated {@link Container}. The design of jDISC does * not allow this, so this method internally creates TestDriver, activates a Container, and creates a new Request * from that Container. Before returning, this method {@link Request#release() closes} the Request, and calls {@link * TestDriver#close()} on the TestDriver. This means that you MUST NOT attempt to access any Container features * through the created Request. This factory is only for directed feature tests that require a non-null * Request.</p> * * @param uri The URI string to assign to the Request. * @param guiceModules The guice modules to inject into the {@link Application}. * @return A non-working Request. */ public static Request newInstance(String uri, Module... guiceModules) { TestDriver driver = TestDriver.newSimpleApplicationInstanceWithoutOsgi(guiceModules); driver.activateContainer(driver.newContainerBuilder()); Request request = new Request(driver, URI.create(uri)); request.release(); driver.close(); return request; } }
@Override public RequestHandler resolveHandler(Request request) { BindingMatch<RequestHandler> match = request.isServerRequest() ? serverBindings.match(request.getUri()) : clientBindings.match(request.getUri()); if (match == null) { return null; } request.setBindingMatch(match); RequestHandler ret = new NullContentRequestHandler(match.target()); if (request.getTimeoutManager() == null) { ret = timeoutMgr.manageHandler(ret); } return ret; }
RequestTask(Request request, BufferedContentChannel content, ResponseHandler responseHandler) { this.request = request; this.requestReference = request.refer(); this.content = content; this.responseHandler = responseHandler; }
@Override public void handleMessage(Message msg) { if (!running.get()) { dispatchErrorReply(msg, ErrorCode.SESSION_BUSY, "Session temporarily closed."); return; } if (msg.getTrace().shouldTrace(6)) { msg.getTrace().trace(6, "Message received by MbusServer."); } Request request = null; ContentChannel content = null; try { request = new MbusRequest(container, uri, msg); content = request.connect(new ServerResponseHandler(msg)); } catch (RuntimeException e) { dispatchErrorReply(msg, ErrorCode.APP_FATAL_ERROR, e.toString()); } finally { if (request != null) { request.release(); } } if (content != null) { content.close(IgnoredCompletionHandler.INSTANCE); } }
/** * <p>Constructs a new instance of this class with a detail message that contains the {@link URI} of the {@link * Request} that was denied.</p> * * @param request The Request that was denied. */ public RequestDeniedException(Request request) { super("Request with URI '" + request.getUri() + "' denied."); this.request = request; }
/** * Handles a request by assigning a worker thread to it. * * @throws OverloadException if thread pool has no available thread */ @Override public final ContentChannel handleRequest(Request request, ResponseHandler responseHandler) { metric.add("handled.requests", 1, contextFor(request.getBindingMatch())); if (request.getTimeout(TimeUnit.SECONDS) == null) { Duration timeout = getTimeout(); if (timeout != null) { request.setTimeout(timeout.getSeconds(), TimeUnit.SECONDS); } } BufferedContentChannel content = new BufferedContentChannel(); final RequestTask command = new RequestTask(request, content, responseHandler); try { executor.execute(command); } catch (RejectedExecutionException e) { command.failOnOverload(); throw new OverloadException("No available threads for " + getClass().getSimpleName(), e); } finally { logRejectedRequests(); } return content; }
Objects.requireNonNull(originalResponseHandler, "responseHandler"); RequestFilter requestFilter = requestFilters.resolve(request.getUri()); ResponseFilter responseFilter = responseFilters.resolve(request.getUri()); RequestHandler resolvedRequestHandler = request.container().resolveHandler(request); throw new BindingNotFoundException(request.getUri());
@Nonnull @Override public List<String> getHeaders(String name) { List<String> headers = request.headers().get(name); return headers == null ? Collections.emptyList() : Collections.unmodifiableList(headers); }
/** * <p>Returns the {@link Container} for which this Request was created.</p> * * @return The container instance. */ public Container container() { return parent != null ? parent.container() : container; }
/** * <p>Attempts to resolve and connect to the {@link RequestHandler} appropriate for the {@link URI} of this Request. * An exception is thrown if this operation fails at any point. This method is exception-safe.</p> * * @param responseHandler The handler to pass the corresponding {@link Response} to. * @return The {@link ContentChannel} to write the Request content to. * @throws NullPointerException If the {@link ResponseHandler} is null. * @throws BindingNotFoundException If the corresponding call to {@link Container#resolveHandler(Request)} returns * null. */ public ContentChannel connect(ResponseHandler responseHandler) { try { Objects.requireNonNull(responseHandler, "responseHandler"); RequestHandler requestHandler = container().resolveHandler(this); if (requestHandler == null) { throw new BindingNotFoundException(uri); } requestHandler = new ProxyRequestHandler(requestHandler); ContentChannel content = requestHandler.handleRequest(this, responseHandler); if (content == null) { throw new RequestDeniedException(this); } return content; } catch (Throwable t) { cancel(); throw t; } }
@Override public final ContentChannel handleRequest(Request request, ResponseHandler responseHandler) { if (timeout > 0) { request.setTimeout(timeout, TimeUnit.MILLISECONDS); } BufferedContentChannel content = new BufferedContentChannel(); executor.execute(new RequestTask(request, content, responseHandler)); return content; }
RequestTask(Request request, BufferedContentChannel content, ResponseHandler responseHandler) { this.request = request; this.content = content; this.responseHandler = responseHandler; this.requestReference = request.refer(); }