@Override public void handleRequest(final HttpServerExchange exchange) throws Exception { exchange.addExchangeCompleteListener(exchangeCompletionListener); next.handleRequest(exchange); }
@Override public void handleRequest(HttpServerExchange exchange) throws Exception { exchange.addExchangeCompleteListener(exchangeCompletionListener); next.handleRequest(exchange); }
@Override public void handleRequest(HttpServerExchange exchange) throws Exception { if(!exchange.isComplete()) { final long start = System.currentTimeMillis(); exchange.addExchangeCompleteListener(new ExchangeCompletionListener() { @Override public void exchangeEvent(HttpServerExchange exchange, NextListener nextListener) { long time = System.currentTimeMillis() - start; totalResult.update((int) time, exchange.getStatusCode()); nextListener.proceed(); } }); } next.handleRequest(exchange); }
/** * Attached buffered data to the exchange. The will generally be used to allow data to be re-read. * * @param exchange The HTTP server exchange * @param buffers The buffers to attach */ public static void ungetRequestBytes(final HttpServerExchange exchange, PooledByteBuffer... buffers) { PooledByteBuffer[] existing = exchange.getAttachment(HttpServerExchange.BUFFERED_REQUEST_DATA); PooledByteBuffer[] newArray; if (existing == null) { newArray = new PooledByteBuffer[buffers.length]; System.arraycopy(buffers, 0, newArray, 0, buffers.length); } else { newArray = new PooledByteBuffer[existing.length + buffers.length]; System.arraycopy(existing, 0, newArray, 0, existing.length); System.arraycopy(buffers, 0, newArray, existing.length, buffers.length); } exchange.putAttachment(HttpServerExchange.BUFFERED_REQUEST_DATA, newArray); //todo: force some kind of wakeup? exchange.addExchangeCompleteListener(BufferedRequestDataCleanupListener.INSTANCE); }
@Override public void exchangeEvent(final HttpServerExchange exchange, final NextListener nextListener) { try { synchronized (RequestLimit.this) { final SuspendedRequest task = queue.poll(); if (task != null) { task.exchange.addExchangeCompleteListener(COMPLETION_LISTENER); task.exchange.dispatch(task.next); } else { decrementRequests(); } } } finally { nextListener.proceed(); } } };
@Override public void run() { //we have to try again in the sync block //we need to have already dispatched for thread safety reasons synchronized (RequestLimit.this) { int oldVal, newVal; do { oldVal = requests; if (oldVal >= max) { if (!queue.offer(new SuspendedRequest(exchange, next))) { Connectors.executeRootHandler(failureHandler, exchange); } return; } newVal = oldVal + 1; } while (!requestsUpdater.compareAndSet(RequestLimit.this, oldVal, newVal)); exchange.addExchangeCompleteListener(COMPLETION_LISTENER); exchange.dispatch(next); } } });
public void setup(HttpServerExchange exchange) { requestCountUpdater.incrementAndGet(this); long current = activeRequestsUpdater.incrementAndGet(this); long maxActiveRequests; do { maxActiveRequests = this.maxActiveRequests; if(current <= maxActiveRequests) { break; } } while (!maxActiveRequestsUpdater.compareAndSet(this, maxActiveRequests, current)); exchange.addExchangeCompleteListener(completionListener); }
private void connectionReady(final ConnectionHolder result, final ProxyCallback<ProxyConnection> callback, final HttpServerExchange exchange, final boolean exclusive) { try { exchange.addExchangeCompleteListener(new ExchangeCompletionListener() { @Override public void exchangeEvent(HttpServerExchange exchange, NextListener nextListener) { if (!exclusive) { returnConnection(result); } nextListener.proceed(); } }); } catch (Exception e) { returnConnection(result); callback.failed(exchange); return; } callback.completed(exchange, new ProxyConnection(result.clientConnection, uri.getPath() == null ? "/" : uri.getPath())); }
@Override public void handleRequest(final HttpServerExchange exchange) throws Exception { SimpleTimer respTimer = new SimpleTimer(); exchange.addExchangeCompleteListener((exchange1, nextListener) -> { Map<String, Object> auditInfo = exchange1.getAttachment(AuditHandler.AUDIT_INFO); if(auditInfo != null) { Map<String, String> tags = new HashMap<>(); tags.put("endpoint", (String)auditInfo.get(Constants.ENDPOINT_STRING)); tags.put("clientId", auditInfo.get(Constants.CLIENT_ID_STRING) != null ? (String)auditInfo.get(Constants.CLIENT_ID_STRING) : "unknown"); List<String> labels = new ArrayList<>(tags.keySet()); List<String> labelValues = new ArrayList<>(tags.values()); summary(RERSPONSE_TIME_SECOND, labels).labels(labelValues.stream().toArray(String[]::new)).observe(respTimer.elapsedSeconds()); incCounterForStatusCode(exchange1.getStatusCode(), labels, labelValues); } nextListener.proceed(); }); Handler.next(exchange, next); }
@Override public void handleRequest(HttpServerExchange exchange) throws Exception { HeaderMap requestHeaders = exchange.getRequestHeaders(); final String sessionId = requestHeaders.getFirst(SSL_SESSION_ID); final String cipher = requestHeaders.getFirst(SSL_CIPHER); String clientCert = requestHeaders.getFirst(SSL_CLIENT_CERT); //the proxy client replaces \n with ' ' if (clientCert != null && clientCert.length() > 28) { StringBuilder sb = new StringBuilder(clientCert.length() + 1); sb.append(Certificates.BEGIN_CERT); sb.append('\n'); sb.append(clientCert.replace(' ', '\n').substring(28, clientCert.length() - 26));//core certificate data sb.append('\n'); sb.append(Certificates.END_CERT); clientCert = sb.toString(); } if (clientCert != null || sessionId != null || cipher != null) { try { SSLSessionInfo info = new BasicSSLSessionInfo(sessionId, cipher, clientCert); exchange.setRequestScheme(HTTPS); exchange.getConnection().setSslSessionInfo(info); exchange.addExchangeCompleteListener(CLEAR_SSL_LISTENER); } catch (java.security.cert.CertificateException | CertificateException e) { UndertowLogger.REQUEST_LOGGER.debugf(e, "Could not create certificate from header %s", clientCert); } } next.handleRequest(exchange); }
@Override public void handleRequest(final HttpServerExchange exchange) throws Exception { exchange.putAttachment(SessionManager.ATTACHMENT_KEY, sessionManager); exchange.putAttachment(SessionConfig.ATTACHMENT_KEY, sessionConfig); final UpdateLastAccessTimeListener handler = new UpdateLastAccessTimeListener(sessionConfig, sessionManager); exchange.addExchangeCompleteListener(handler); next.handleRequest(exchange); }
@Override public void handleRequest(HttpServerExchange exchange) throws Exception { activeRequestsUpdater.incrementAndGet(this); if (shutdown) { decrementRequests(); exchange.setStatusCode(StatusCodes.SERVICE_UNAVAILABLE); exchange.endExchange(); return; } exchange.addExchangeCompleteListener(listener); next.handleRequest(exchange); }
private void registerListeners(HttpServerExchange exchange) { exchange.addExchangeCompleteListener((ex, next) -> { onAllDataRead(); next.proceed(); }); this.channel.getReadSetter().set(c -> onDataAvailable()); this.channel.getCloseSetter().set(c -> onAllDataRead()); this.channel.resumeReads(); }
@Override public void terminateRequestChannel(HttpServerExchange exchange) { if(HttpContinue.requiresContinueResponse(exchange.getRequestHeaders()) && !continueSent) { if(requestChannel != null) { //can happen on upgrade requestChannel.setIgnoreForceClose(true); requestChannel.close(); //if this request requires a 100-continue and it was not sent we have to reset the stream //we do it in a completion listener though, to make sure the response is sent first exchange.addExchangeCompleteListener(new ExchangeCompletionListener() { @Override public void exchangeEvent(HttpServerExchange exchange, NextListener nextListener) { try { channel.sendRstStream(responseChannel.getStreamId(), Http2Channel.ERROR_CANCEL); } finally { nextListener.proceed(); } } }); } } }
/** * Handle a proxy request for this context. * * @param target the proxy target * @param exchange the http server exchange * @param callback the proxy callback * @param timeout the timeout * @param timeUnit the time unit * @param exclusive whether this connection is exclusive */ void handleRequest(final ModClusterProxyTarget target, final HttpServerExchange exchange, final ProxyCallback<ProxyConnection> callback, long timeout, TimeUnit timeUnit, boolean exclusive) { if (addRequest()) { exchange.addExchangeCompleteListener(new ExchangeCompletionListener() { @Override public void exchangeEvent(HttpServerExchange exchange, NextListener nextListener) { requestDone(); nextListener.proceed(); } }); node.getConnectionPool().connect(target, exchange, callback, timeout, timeUnit, exclusive); } else { callback.failed(exchange); } }
@Override public void handleRequest(final HttpServerExchange exchange) throws Exception { long startTime = Clock.defaultClock().getTick(); exchange.addExchangeCompleteListener((exchange1, nextListener) -> { Map<String, Object> auditInfo = exchange1.getAttachment(AuditHandler.AUDIT_INFO); if(auditInfo != null) { Map<String, String> tags = new HashMap<>(); tags.put("endpoint", (String)auditInfo.get(Constants.ENDPOINT_STRING)); tags.put("clientId", auditInfo.get(Constants.CLIENT_ID_STRING) != null ? (String)auditInfo.get(Constants.CLIENT_ID_STRING) : "unknown"); long time = Clock.defaultClock().getTick() - startTime; MetricName metricName = new MetricName("response_time"); metricName = metricName.tagged(commonTags); metricName = metricName.tagged(tags); registry.getOrAdd(metricName, MetricRegistry.MetricBuilder.TIMERS).update(time, TimeUnit.NANOSECONDS); incCounterForStatusCode(exchange1.getStatusCode(), commonTags, tags); } nextListener.proceed(); }); Handler.next(exchange, next); }
private void registerListeners(HttpServerExchange exchange) { exchange.addExchangeCompleteListener((ex, next) -> { onAllDataRead(); next.proceed(); }); this.channel.getReadSetter().set(c -> onDataAvailable()); this.channel.getCloseSetter().set(c -> onAllDataRead()); this.channel.resumeReads(); }
@Override public FormDataParser create(final HttpServerExchange exchange) { String mimeType = exchange.getRequestHeaders().getFirst(Headers.CONTENT_TYPE); if (mimeType != null && mimeType.startsWith(MULTIPART_FORM_DATA)) { String boundary = Headers.extractQuotedValueFromHeader(mimeType, "boundary"); if (boundary == null) { UndertowLogger.REQUEST_LOGGER.debugf("Could not find boundary in multipart request with ContentType: %s, multipart data will not be available", mimeType); return null; } final MultiPartUploadHandler parser = new MultiPartUploadHandler(exchange, boundary, maxIndividualFileSize, fileSizeThreshold, defaultEncoding); exchange.addExchangeCompleteListener(new ExchangeCompletionListener() { @Override public void exchangeEvent(final HttpServerExchange exchange, final NextListener nextListener) { IoUtils.safeClose(parser); nextListener.proceed(); } }); Long sizeLimit = exchange.getConnection().getUndertowOptions().get(UndertowOptions.MULTIPART_MAX_ENTITY_SIZE); if(sizeLimit != null) { exchange.setMaxEntitySize(sizeLimit); } UndertowLogger.REQUEST_LOGGER.tracef("Created multipart parser for %s", exchange); return parser; } return null; }
@Override public void handleRequest(HttpServerExchange exchange) throws Exception { String fullPath; String requestPath; if(exchange.getQueryString().isEmpty()) { fullPath = exchange.getRequestURL(); requestPath = exchange.getRequestPath(); } else{ fullPath = exchange.getRequestURL() + "?" + exchange.getQueryString(); requestPath = exchange.getRequestPath() + "?" + exchange.getQueryString(); } doPush(exchange, fullPath); String referrer = exchange.getRequestHeaders().getFirst(Headers.REFERER); if (referrer != null) { String accept = exchange.getRequestHeaders().getFirst(Headers.ACCEPT); if (accept == null || !accept.contains("text/html")) { //if accept contains text/html it generally means the user has clicked //a link to move to a new page, and is not a resource load for the current page //we only care about resources for the current page exchange.addExchangeCompleteListener(new PushCompletionListener(fullPath, requestPath, referrer)); } } next.handleRequest(exchange); }
entryPoint.requestComplete(); } else if(result == RunResult.RUN) { exchange.addExchangeCompleteListener(listener);