Refine search
@Override public void completed(ClientConnection connection) { ClientRequest request = new ClientRequest().setMethod(Methods.POST).setPath(url.getPath()); HttpString headerName = HttpString.tryFromString(HttpHeaders.HOST); request.getRequestHeaders().add(headerName, url.getHost()); addHttpHeaders(request, headers); HttpHeaders httpHeaders = transportRequest.getHttpRequestHeaders(); connection.sendRequest(request, createReceiveCallback(transportRequest, url, httpHeaders, session, connectFuture)); }
if (current == Type.BASIC) { String challenge = principal.getName() + ":" + new String(password); request.getRequestHeaders().put(Headers.AUTHORIZATION, "Basic " + FlexBase64.encodeString(challenge.getBytes(StandardCharsets.UTF_8), false)); return true; } else if (current == Type.DIGEST) { String path; String query; int pos = request.getPath().indexOf("?"); if (pos > 0) { path = request.getPath().substring(0, pos); query = request.getPath().substring(pos + 1); } else { path = request.getPath(); query = null; request.putAttachment(DIGEST, current); StringBuilder sb = new StringBuilder("Digest username=\""); sb.append(principal.getName()); String a2 = request.getMethod().toString() + ":" + digestUri; sb.append(HexConverter.convertToHexString(digest.digest())); sb.append("\""); request.getRequestHeaders().put(Headers.AUTHORIZATION, sb.toString()); return true; } catch (NoSuchAlgorithmException e) {
@Override public void run() { final ClientRequest request = new ClientRequest().setMethod(Methods.POST).setPath(path); request.getRequestHeaders().put(Headers.TRANSFER_ENCODING, "chunked"); request.getRequestHeaders().put(Headers.HOST, "localhost"); connection.sendRequest(request, client.createClientCallback(reference, latch, body)); } });
public ClientRequest createRequest(String mountPoint) { ClientRequest clientRequest = new ClientRequest(); if (invocationType == InvocationType.METHOD_INVOCATION) { clientRequest.setMethod(Methods.POST); clientRequest.getRequestHeaders().add(Headers.ACCEPT, INVOCATION_ACCEPT); if (invocationId != null) { clientRequest.getRequestHeaders().put(EjbHeaders.INVOCATION_ID, invocationId); } clientRequest.setPath(buildPath(mountPoint, "invoke", appName, moduleName, distinctName, beanName, beanId, view, method)); clientRequest.getRequestHeaders().put(Headers.CONTENT_TYPE, EjbHeaders.INVOCATION_VERSION_ONE); } else if (invocationType == InvocationType.STATEFUL_CREATE) { clientRequest.setMethod(Methods.POST); clientRequest.getRequestHeaders().put(Headers.CONTENT_TYPE, EjbHeaders.SESSION_OPEN_VERSION_ONE); clientRequest.setPath(buildPath(mountPoint,"open", appName, moduleName, distinctName, beanName)); clientRequest.getRequestHeaders().add(Headers.ACCEPT, STATEFUL_CREATE_ACCEPT); } else if(invocationType == InvocationType.CANCEL) { clientRequest.setMethod(Methods.DELETE); clientRequest.setPath(buildPath(mountPoint,"cancel", appName, moduleName, distinctName, beanName, invocationId, cancelIfRunning)); } return clientRequest; }
public static String derefToken(DerefRequest derefRequest) throws ClientException { final Http2Client client = Http2Client.getInstance(); final CountDownLatch latch = new CountDownLatch(1); final ClientConnection connection; try { connection = client.connect(new URI(derefRequest.getServerUrl()), Http2Client.WORKER, Http2Client.SSL, Http2Client.BUFFER_POOL, derefRequest.enableHttp2 ? OptionMap.create(UndertowOptions.ENABLE_HTTP2, true): OptionMap.EMPTY).get(); } catch (Exception e) { throw new ClientException(e); } final AtomicReference<ClientResponse> reference = new AtomicReference<>(); try { ClientRequest request = new ClientRequest().setPath(derefRequest.getUri()).setMethod(Methods.GET); request.getRequestHeaders().put(Headers.AUTHORIZATION, getBasicAuthHeader(derefRequest.getClientId(), derefRequest.getClientSecret())); request.getRequestHeaders().put(Headers.HOST, "localhost"); connection.sendRequest(request, client.createClientCallback(reference, latch)); latch.await(); } catch (Exception e) { logger.error("Exception: ", e); throw new ClientException(e); } finally { IoUtils.safeClose(connection); } return reference.get().getAttachment(Http2Client.RESPONSE_BODY); }
private void processInvocation(Name name, HttpString method, Object object, String pathSegment) throws NamingException { ProviderEnvironment environment = httpNamingProvider.getProviderEnvironment(); final RetryContext context = canRetry(environment) ? new RetryContext() : null; performWithRetry((contextOrNull, name1, param) -> { HttpNamingProvider.HttpPeerIdentity peerIdentity = (HttpNamingProvider.HttpPeerIdentity) httpNamingProvider.getPeerIdentityForNamingUsingRetry(contextOrNull); try { StringBuilder sb = new StringBuilder(); String uriPath = peerIdentity.getUri().getPath(); sb.append(uriPath); if (!uriPath.endsWith("/")) { sb.append("/"); } sb.append(pathSegment).append(URLEncoder.encode(name.toString(), StandardCharsets.UTF_8.name())); final ClientRequest clientRequest = new ClientRequest() .setPath(sb.toString()) .setMethod(method); clientRequest.getRequestHeaders().put(Headers.ACCEPT, ACCEPT_VALUE); if (object != null) { clientRequest.getRequestHeaders().put(Headers.CONTENT_TYPE, VALUE_TYPE.toString()); } performOperation(peerIdentity.getUri(), object, clientRequest); return null; } catch (UnsupportedEncodingException e) { NamingException namingException = new NamingException(e.getMessage()); namingException.initCause(e); throw namingException; } }, environment, context, name, object); }
public PortForwarder(Config config, String podName) throws Exception { try { this.portForwardURI = URI.create(String.format(PORT_FWD, config.getMasterUrl(), config.getNamespace(), podName)); ClientRequest request = new ClientRequest() .setMethod(Methods.POST) .setPath(portForwardURI.getPath()); request.getRequestHeaders() .put(Headers.HOST, this.portForwardURI.getHost()) .put(Headers.CONNECTION, "Upgrade") .put(Headers.UPGRADE, "SPDY/3.1"); if (config.getOauthToken() != null) { request.getRequestHeaders().put(Headers.AUTHORIZATION, "Bearer " + config.getOauthToken()); connection.sendRequest(request, new ClientCallback<ClientExchange>() { @Override public void completed(ClientExchange result) { IoUtils.safeClose(connection);
@Override public void completed(final ClientConnection connection) { int port = uri.getPort() > 0 ? uri.getPort() : uri.getScheme().equals("https") || uri.getScheme().equals("wss") ? 443 : 80; ClientRequest cr = new ClientRequest() .setMethod(Methods.CONNECT) .setPath(uri.getHost() + ":" + port) .setProtocol(Protocols.HTTP_1_1); cr.getRequestHeaders().put(Headers.HOST, proxyUri.getHost() + ":" + (proxyUri.getPort() > 0 ? proxyUri.getPort() : 80)); connection.sendRequest(cr, new ClientCallback<ClientExchange>() { @Override public void completed(ClientExchange result) {
ClientRequest request = builder.createRequest(targetContext.getUri().getPath()); if (compressResponse) { request.getRequestHeaders().put(Headers.ACCEPT_ENCODING, Headers.GZIP.toString()); request.getRequestHeaders().put(Headers.TRANSFER_ENCODING, Headers.CHUNKED.toString()); final boolean compressRequest = receiverContext.getClientInvocationContext().isCompressRequest(); if (compressRequest) { request.getRequestHeaders().put(Headers.CONTENT_ENCODING, Headers.GZIP.toString()); final int defaultPort = uri.getScheme().equals("https") ? 443 : 80; final AuthenticationConfiguration authenticationConfiguration = client.getAuthenticationConfiguration(uri, context, defaultPort, "jndi", "jboss"); final SSLContext sslContext = client.getSSLContext(uri, context, "jndi", "jboss"); marshalEJBRequest(Marshalling.createByteOutput(data), clientInvocationContext, targetContext); } finally { IoUtils.safeClose(data);
public void connect() { try { if (connection != null) { return; } connection = UndertowClient.getInstance().connect( URI.create(url), worker, new DefaultByteBufferPool(false, 8192), OptionMap.EMPTY) .get(); final ClientRequest request = new ClientRequest().setMethod(Methods.GET).setPath(url); request.getRequestHeaders().put(Headers.CONNECTION, "keep-alive"); request.getRequestHeaders().put(Headers.ACCEPT, "text/event-stream"); request.getRequestHeaders().put(Headers.HOST, url); //TODO get from URI // request.getRequestHeaders().put(Headers.ORIGIN, "http://localhost"); if (lastEventId != null && !lastEventId.isEmpty()) { request.getRequestHeaders().put(HttpString.tryFromString("Last-Event-ID"), lastEventId); } connection.sendRequest(request, createClientCallback()); } catch (Exception e) { throw new RuntimeException(e); } }
private void acquireSessionAffinity(CountDownLatch latch, AuthenticationConfiguration authenticationConfiguration) { ClientRequest clientRequest = new ClientRequest(); clientRequest.setMethod(Methods.GET); clientRequest.setPath(uri.getPath() + "/common/v1/affinity"); AuthenticationContext context = AuthenticationContext.captureCurrent(); SSLContext sslContext; try { sslContext = AUTH_CONTEXT_CLIENT.getSSLContext(uri, context); } catch (GeneralSecurityException e) { latch.countDown(); HttpClientMessages.MESSAGES.failedToAcquireSession(e); return; } sendRequest(clientRequest, sslContext, authenticationConfiguration, null, null, (e) -> { latch.countDown(); HttpClientMessages.MESSAGES.failedToAcquireSession(e); }, null, latch::countDown); }
final boolean authAdded = retry || connection.getAuthenticationContext().prepareRequest(connection.getUri(), request, authenticationConfiguration); if (!request.getRequestHeaders().contains(Headers.HOST)) { String host; int port = connection.getUri().getPort(); if (port == -1) { host = connection.getUri().getHost(); } else { host = connection.getUri().getHost() + ":" + port; request.getRequestHeaders().put(Headers.HOST, host); if (request.getRequestHeaders().contains(Headers.CONTENT_TYPE)) { request.getRequestHeaders().put(Headers.TRANSFER_ENCODING, Headers.CHUNKED.toString()); connection.getConnection().sendRequest(request, new ClientCallback<ClientExchange>() { @Override public void completed(ClientExchange result) {
private ClientRequest buildClientRequest(AuthContext context) { ClientRequest request = new ClientRequest().setMethod(POST).setPath(ACCESS_URI); String host = kubernetesMasterUri.getHost(); int port = kubernetesMasterUri.getPort(); String hostHeader = (port == -1) ? host : (host + ":" + port); request.getRequestHeaders() .add(HOST, hostHeader) .add(ACCEPT, "application/json") .add(CONTENT_TYPE, "application/json") .add(AUTHORIZATION, context.authorizationHeader) .add(CONTENT_LENGTH, context.subjectAccessReview.length()); return request; }
@Override public void run() { final ClientRequest request = new ClientRequest(); request.setPath(requestURI.toString()) .setMethod(exchange.getRequestMethod()); final HeaderMap inboundRequestHeaders = exchange.getRequestHeaders(); final HeaderMap outboundRequestHeaders = request.getRequestHeaders(); copyHeaders(outboundRequestHeaders, inboundRequestHeaders); remoteHost = ((InetSocketAddress) address).getHostString(); if(!((InetSocketAddress) address).isUnresolved()) { request.putAttachment(ProxiedRequestAttachments.REMOTE_ADDRESS, ((InetSocketAddress) address).getAddress().getHostAddress()); request.putAttachment(ProxiedRequestAttachments.REMOTE_HOST, remoteHost); if (reuseXForwarded && request.getRequestHeaders().contains(Headers.X_FORWARDED_FOR)) { final String current = request.getRequestHeaders().getFirst(Headers.X_FORWARDED_FOR); if (current == null || current.isEmpty()) { request.getRequestHeaders().put(Headers.X_FORWARDED_FOR, remoteHost); request.getRequestHeaders().put(Headers.X_FORWARDED_FOR, current + "," + remoteHost); request.getRequestHeaders().put(Headers.X_FORWARDED_FOR, remoteHost); if(!exchange.getConnection().isPushSupported() && clientConnection.getConnection().isPushSupported()) { request.getRequestHeaders().put(Headers.X_DISABLE_PUSH, "true");
return; request.getRequestHeaders().put(METHOD, request.getMethod().toString()); boolean connectRequest = request.getMethod().equals(Methods.CONNECT); if(!connectRequest) { request.getRequestHeaders().put(PATH, request.getPath()); request.getRequestHeaders().put(SCHEME, secure ? "https" : "http"); final String host = request.getRequestHeaders().getFirst(Headers.HOST); if(host != null) { request.getRequestHeaders().put(AUTHORITY, host); } else { request.getRequestHeaders().put(AUTHORITY, defaultHost); request.getRequestHeaders().remove(Headers.HOST); String fixedLengthString = request.getRequestHeaders().getFirst(CONTENT_LENGTH); String transferEncodingString = request.getRequestHeaders().getLast(TRANSFER_ENCODING); if (fixedLengthString != null) { try { request.getRequestHeaders().remove(Headers.CONNECTION); request.getRequestHeaders().remove(Headers.KEEP_ALIVE); request.getRequestHeaders().remove(Headers.TRANSFER_ENCODING); sinkChannel = http2Channel.createStream(request.getRequestHeaders()); } catch (Throwable t) { IOException e = t instanceof IOException ? (IOException) t : new IOException(t);
final Http2StreamSourceChannel streamSourceChannel = (Http2StreamSourceChannel) result; int statusCode = Integer.parseInt(streamSourceChannel.getHeaders().getFirst(STATUS)); Http2ClientExchange request = currentExchanges.get(streamSourceChannel.getStreamId()); if(statusCode < 200) { } else if(request == null) { channel.sendGoAway(Http2Channel.ERROR_PROTOCOL_ERROR); IoUtils.safeClose(Http2ClientConnection.this); return; channel.sendRstStream(stream.getPushedStreamId(), Http2Channel.ERROR_REFUSED_STREAM); } else { ClientRequest cr = new ClientRequest(); cr.setMethod(new HttpString(stream.getHeaders().getFirst(METHOD))); cr.setPath(stream.getHeaders().getFirst(PATH)); cr.setProtocol(Protocols.HTTP_1_1); for (HeaderValues header : stream.getHeaders()) { cr.getRequestHeaders().putAll(header.getHeaderName(), header); IoUtils.safeClose(stream); } else { currentExchanges.put(stream.getPushedStreamId(), newExchange);
ClientRequest request = httpClientExchange.getRequest(); String connectionString = request.getRequestHeaders().getFirst(Headers.CONNECTION); if (connectionString != null) { if (Headers.CLOSE.equalToString(connectionString)) { state |= CLOSE_REQ; } else if (Headers.UPGRADE.equalToString(connectionString)) { state |= UPGRADE_REQUESTED; } else if (request.getProtocol() != Protocols.HTTP_1_1) { state |= CLOSE_REQ; if (request.getRequestHeaders().contains(Headers.UPGRADE)) { state |= UPGRADE_REQUESTED; if(request.getMethod().equals(Methods.CONNECT)) { conduit = httpRequestConduit; String fixedLengthString = request.getRequestHeaders().getFirst(Headers.CONTENT_LENGTH); String transferEncodingString = request.getRequestHeaders().getLast(Headers.TRANSFER_ENCODING); return; conduit = new ChunkedStreamSinkConduit(conduit, httpClientExchange.getConnection().getBufferPool(), false, false, httpClientExchange.getRequest().getRequestHeaders(), requestFinishListener, httpClientExchange); } else { conduit = new ClientFixedLengthStreamSinkConduit(conduit, 0, false, false, currentRequest);
@Override public void sendRequest(final ClientRequest request, final ClientCallback<ClientExchange> clientCallback) { if(http2Delegate != null) { http2Delegate.sendRequest(request, clientCallback); return; } if (anyAreSet(state, UPGRADE_REQUESTED | UPGRADED | CLOSE_REQ | CLOSED)) { clientCallback.failed(UndertowClientMessages.MESSAGES.invalidConnectionState()); return; } final HttpClientExchange httpClientExchange = new HttpClientExchange(clientCallback, request, this); boolean ssl = this.connection instanceof SslConnection; if(!ssl && !http2Tried && options.get(UndertowOptions.ENABLE_HTTP2, false) && !request.getRequestHeaders().contains(Headers.UPGRADE)) { //this is the first request, as we want to try a HTTP2 upgrade request.getRequestHeaders().put(new HttpString("HTTP2-Settings"), Http2ClearClientProvider.createSettingsFrame(options, bufferPool)); request.getRequestHeaders().put(Headers.UPGRADE, Http2Channel.CLEARTEXT_UPGRADE_STRING); request.getRequestHeaders().put(Headers.CONNECTION, "Upgrade, HTTP2-Settings"); http2Tried = true; } if (currentRequest == null) { initiateRequest(httpClientExchange); } else { pendingQueue.add(httpClientExchange); } }
if(res == -1) { UndertowLogger.CLIENT_LOGGER.debugf("Connection to %s was closed by the target server", connection.getPeerAddress()); safeClose(HttpClientConnection.this); } else if(res != 0) { UndertowLogger.CLIENT_LOGGER.debugf("Target server %s sent unexpected data when no request pending, closing connection", connection.getPeerAddress()); safeClose(HttpClientConnection.this); UndertowLogger.CLIENT_LOGGER.debugf(e, "Connection closed with IOException"); safeClose(connection); String connectionString = response.getResponseHeaders().getFirst(Headers.CONNECTION); if ((connectionString == null || !Headers.UPGRADE.equalToString(connectionString)) && !response.getResponseHeaders().contains(Headers.UPGRADE)) { if(!currentRequest.getRequest().getMethod().equals(Methods.CONNECT) || response.getResponseCode() != 200) { //make sure it was not actually a connect request if (Headers.CLOSE.equalToString(connectionString)) { close = true; } else if(!response.getProtocol().equals(Protocols.HTTP_1_1)) { if(response.getResponseCode() == StatusCodes.SWITCHING_PROTOCOLS && Http2Channel.CLEARTEXT_UPGRADE_STRING.equals(response.getResponseHeaders().getFirst(Headers.UPGRADE))) { currentRequest.setResponse(response); if(response.getResponseCode() == StatusCodes.EXPECTATION_FAILED) { if(HttpContinue.requiresContinueResponse(currentRequest.getRequest().getRequestHeaders())) { HttpClientConnection.this.state |= CLOSE_REQ; ConduitStreamSinkChannel sinkChannel = HttpClientConnection.this.connection.getSinkChannel();
int len = request.getMethod().length() + request.getPath().length() + request.getProtocol().length() + 4; request.getMethod().appendTo(buffer); buffer.put((byte) ' '); string = request.getPath(); length = string.length(); for (charIndex = 0; charIndex < length; charIndex++) { request.getProtocol().appendTo(buffer); buffer.put((byte) '\r').put((byte) '\n'); } else { StringBuilder sb = new StringBuilder(len); sb.append(request.getMethod().toString()); sb.append(" "); sb.append(request.getPath()); sb.append(" "); sb.append(request.getProtocol()); sb.append("\r\n"); string = sb.toString(); HeaderMap headers = request.getRequestHeaders(); nameIterator = headers.getHeaderNames().iterator(); if (! nameIterator.hasNext()) { log.trace("No request headers"); valueIterator = request.getRequestHeaders().get(headerName).iterator(); HeaderMap headers = request.getRequestHeaders(); nameIterator = headers.getHeaderNames().iterator();