io.reactivex.netty.protocol.http.client.HttpClientImpl Maven / Gradle / Ivy
/*
* Copyright 2016 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package io.reactivex.netty.protocol.http.client;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.ByteBufAllocator;
import io.netty.channel.ChannelHandler;
import io.netty.channel.ChannelOption;
import io.netty.channel.ChannelPipeline;
import io.netty.handler.codec.http.HttpClientCodec;
import io.netty.handler.codec.http.HttpMethod;
import io.netty.handler.codec.http.HttpVersion;
import io.netty.handler.logging.LogLevel;
import io.netty.util.concurrent.EventExecutorGroup;
import io.reactivex.netty.client.ChannelProviderFactory;
import io.reactivex.netty.client.ConnectionProvider;
import io.reactivex.netty.client.ConnectionProviderFactory;
import io.reactivex.netty.client.Host;
import io.reactivex.netty.client.HostConnector;
import io.reactivex.netty.protocol.http.HttpHandlerNames;
import io.reactivex.netty.protocol.http.client.events.HttpClientEventPublisher;
import io.reactivex.netty.protocol.http.client.events.HttpClientEventsListener;
import io.reactivex.netty.protocol.http.client.internal.HttpChannelProviderFactory;
import io.reactivex.netty.protocol.http.client.internal.HttpClientRequestImpl;
import io.reactivex.netty.protocol.http.client.internal.HttpClientToConnectionBridge;
import io.reactivex.netty.protocol.http.client.internal.Redirector;
import io.reactivex.netty.protocol.http.ws.client.Ws7To13UpgradeHandler;
import io.reactivex.netty.protocol.tcp.client.TcpClient;
import io.reactivex.netty.protocol.tcp.client.TcpClientImpl;
import io.reactivex.netty.ssl.SslCodec;
import rx.Observable;
import rx.Subscription;
import rx.functions.Action1;
import rx.functions.Func0;
import rx.functions.Func1;
import javax.net.ssl.SSLEngine;
import java.net.SocketAddress;
import java.util.concurrent.TimeUnit;
import static io.reactivex.netty.protocol.http.client.internal.HttpClientRequestImpl.*;
public final class HttpClientImpl extends HttpClient {
private final TcpClient> client;
private final int maxRedirects;
private final HttpClientEventPublisher clientEventPublisher;
private final RequestProvider requestProvider;
private HttpClientImpl(final TcpClient> client, final int maxRedirects,
HttpClientEventPublisher clientEventPublisher) {
this.client = client;
this.maxRedirects = maxRedirects;
this.clientEventPublisher = clientEventPublisher;
requestProvider = new RequestProvider() {
@Override
public HttpClientRequest createRequest(HttpVersion version, HttpMethod method, String uri) {
return HttpClientRequestImpl.create(version, method, uri, client, maxRedirects);
}
};
}
@Override
public HttpClientRequest createGet(String uri) {
return createRequest(HttpMethod.GET, uri);
}
@Override
public HttpClientRequest createPost(String uri) {
return createRequest(HttpMethod.POST, uri);
}
@Override
public HttpClientRequest createPut(String uri) {
return createRequest(HttpMethod.PUT, uri);
}
@Override
public HttpClientRequest createDelete(String uri) {
return createRequest(HttpMethod.DELETE, uri);
}
@Override
public HttpClientRequest createHead(String uri) {
return createRequest(HttpMethod.HEAD, uri);
}
@Override
public HttpClientRequest createOptions(String uri) {
return createRequest(HttpMethod.OPTIONS, uri);
}
@Override
public HttpClientRequest createPatch(String uri) {
return createRequest(HttpMethod.PATCH, uri);
}
@Override
public HttpClientRequest createTrace(String uri) {
return createRequest(HttpMethod.TRACE, uri);
}
@Override
public HttpClientRequest createConnect(String uri) {
return createRequest(HttpMethod.CONNECT, uri);
}
@Override
public HttpClientRequest createRequest(HttpMethod method, String uri) {
return createRequest(HttpVersion.HTTP_1_1, method, uri);
}
@Override
public HttpClientRequest createRequest(HttpVersion version, HttpMethod method, String uri) {
return requestProvider.createRequest(version, method, uri);
}
@Override
public HttpClientInterceptorChain intercept() {
return new HttpClientInterceptorChainImpl<>(requestProvider, clientEventPublisher);
}
@Override
public HttpClientImpl readTimeOut(int timeOut, TimeUnit timeUnit) {
return _copy(client.readTimeOut(timeOut, timeUnit), maxRedirects);
}
@Override
public HttpClientImpl followRedirects(int maxRedirects) {
return _copy(client, maxRedirects);
}
@Override
public HttpClientImpl followRedirects(boolean follow) {
return _copy(client, follow ? Redirector.DEFAULT_MAX_REDIRECTS : NO_REDIRECTS);
}
@Override
public HttpClientImpl channelOption(ChannelOption option, T value) {
return _copy(client.channelOption(option, value), maxRedirects);
}
@Override
public HttpClientImpl addChannelHandlerFirst(String name, Func0 handlerFactory) {
return _copy(HttpClientImpl.castClient(client.addChannelHandlerFirst(name, handlerFactory)),
maxRedirects);
}
@Override
public HttpClientImpl addChannelHandlerFirst(EventExecutorGroup group, String name,
Func0 handlerFactory) {
return _copy(HttpClientImpl.castClient(client.addChannelHandlerFirst(group, name, handlerFactory)),
maxRedirects);
}
@Override
public HttpClientImpl addChannelHandlerLast(String name, Func0 handlerFactory) {
return _copy(HttpClientImpl.castClient(client.addChannelHandlerLast(name, handlerFactory)),
maxRedirects);
}
@Override
public HttpClientImpl addChannelHandlerLast(EventExecutorGroup group, String name,
Func0 handlerFactory) {
return _copy(HttpClientImpl.castClient(client.addChannelHandlerLast(group, name, handlerFactory)),
maxRedirects);
}
@Override
public HttpClientImpl addChannelHandlerBefore(String baseName, String name,
Func0 handlerFactory) {
return _copy(HttpClientImpl.castClient(client.addChannelHandlerBefore(baseName, name, handlerFactory)),
maxRedirects);
}
@Override
public HttpClientImpl addChannelHandlerBefore(EventExecutorGroup group, String baseName, String name,
Func0 handlerFactory) {
return _copy(HttpClientImpl.castClient(client.addChannelHandlerBefore(group, baseName, name,
handlerFactory)),
maxRedirects);
}
@Override
public HttpClientImpl addChannelHandlerAfter(String baseName, String name,
Func0 handlerFactory) {
return _copy(HttpClientImpl.castClient(client.addChannelHandlerAfter(baseName, name, handlerFactory)),
maxRedirects);
}
@Override
public HttpClientImpl addChannelHandlerAfter(EventExecutorGroup group, String baseName, String name,
Func0 handlerFactory) {
return _copy(HttpClientImpl.castClient(client.addChannelHandlerAfter(group, baseName, name,
handlerFactory)),
maxRedirects);
}
@Override
public HttpClientImpl pipelineConfigurator(Action1 pipelineConfigurator) {
return _copy(HttpClientImpl.castClient(client.pipelineConfigurator(pipelineConfigurator)),
maxRedirects);
}
@Override
public HttpClientImpl secure(Func1 sslEngineFactory) {
return _copy(client.secure(sslEngineFactory), maxRedirects);
}
@Override
public HttpClientImpl secure(SSLEngine sslEngine) {
return _copy(client.secure(sslEngine), maxRedirects);
}
@Override
public HttpClientImpl secure(SslCodec sslCodec) {
return _copy(client.secure(sslCodec), maxRedirects);
}
@Override
public HttpClientImpl unsafeSecure() {
return _copy(client.unsafeSecure(), maxRedirects);
}
@Override
public HttpClientImpl enableWireLogging(LogLevel wireLoggingLevel) {
return _copy(client.enableWireLogging(wireLoggingLevel), maxRedirects);
}
@Override
public HttpClientImpl channelProvider(ChannelProviderFactory providerFactory) {
return _copy(client.channelProvider(new HttpChannelProviderFactory(clientEventPublisher, providerFactory)),
maxRedirects);
}
@Override
public Subscription subscribe(HttpClientEventsListener listener) {
return clientEventPublisher.subscribe(listener);
}
public static HttpClient create(final ConnectionProviderFactory providerFactory,
Observable hostStream) {
ConnectionProviderFactory cpf = new ConnectionProviderFactory() {
@Override
public ConnectionProvider newProvider(Observable> hosts) {
return providerFactory.newProvider(hosts.map(
new Func1, HostConnector>() {
@Override
public HostConnector call(HostConnector hc) {
HttpClientEventPublisher hcep = new HttpClientEventPublisher();
hc.subscribe(hcep);
return new HostConnector<>(hc.getHost(), hc.getConnectionProvider(), hcep, hcep, hcep);
}
}));
}
};
return _newClient(TcpClientImpl.create(cpf, hostStream));
}
public static HttpClient create(SocketAddress socketAddress) {
return _newClient(TcpClientImpl.create(socketAddress));
}
private static HttpClient _newClient(TcpClient tcpClient) {
HttpClientEventPublisher clientEventPublisher = new HttpClientEventPublisher();
TcpClient> client =
tcpClient.>pipelineConfigurator(new Action1() {
@Override
public void call(ChannelPipeline pipeline) {
pipeline.addLast(HttpHandlerNames.HttpClientCodec.getName(), new HttpClientCodec());
pipeline.addLast(new HttpClientToConnectionBridge<>());
pipeline.addLast(HttpHandlerNames.WsClientUpgradeHandler.getName(),
new Ws7To13UpgradeHandler());
}
}).channelProvider(new HttpChannelProviderFactory(clientEventPublisher));
client.subscribe(clientEventPublisher);
return new HttpClientImpl<>(client, NO_REDIRECTS, clientEventPublisher);
}
@SuppressWarnings("unchecked")
private static TcpClient> castClient(TcpClient rawTypes) {
return (TcpClient>) rawTypes;
}
private HttpClientImpl _copy(TcpClient> newClient, int maxRedirects) {
return new HttpClientImpl<>(newClient, maxRedirects, clientEventPublisher);
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy