io.reactivex.netty.protocol.http.ws.client.internal.WebSocketResponseImpl Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of rxnetty-http Show documentation
rxnetty-http
There is a newer version: 0.5.3-rc.2
/*
 * 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.ws.client.internal;

import io.netty.channel.Channel;
import io.netty.handler.codec.http.HttpResponseStatus;
import io.netty.handler.codec.http.HttpVersion;
import io.netty.handler.codec.http.cookie.Cookie;
import io.netty.handler.codec.http.websocketx.WebSocketFrame;
import io.reactivex.netty.channel.Connection;
import io.reactivex.netty.channel.ContentSource;
import io.reactivex.netty.client.ClientConnectionToChannelBridge;
import io.reactivex.netty.protocol.http.client.HttpClientResponse;
import io.reactivex.netty.protocol.http.internal.AbstractHttpConnectionBridge;
import io.reactivex.netty.protocol.http.sse.ServerSentEvent;
import io.reactivex.netty.protocol.http.ws.WebSocketConnection;
import io.reactivex.netty.protocol.http.ws.client.WebSocketResponse;
import rx.Observable;
import rx.Observable.Transformer;

import java.text.ParseException;
import java.util.Date;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

public final class WebSocketResponseImpl extends WebSocketResponse {

    private final HttpClientResponse delegate;
    private final WebSocketConnection wsConnection;
    private final Channel channel;

    public WebSocketResponseImpl(HttpClientResponse delegate) {
        this.delegate = delegate;
        @SuppressWarnings("unchecked")
        Connection cast =
                (Connection) delegate.unsafeConnection();
        channel = cast.unsafeNettyChannel();
        wsConnection = new WebSocketConnection(cast);
    }

    @Override
    public Observable getWebSocketConnection() {
        if (isUpgraded()) {
            /*Do not pool connection once upgraded to WS. A closing handshake closes the channel*/
            channel.attr(ClientConnectionToChannelBridge.DISCARD_CONNECTION).set(true);
            channel.attr(AbstractHttpConnectionBridge.CONNECTION_UPGRADED).set(true);
            return Observable.just(wsConnection);
        } else {
            return Observable.error(new IllegalStateException("WebSocket upgrade rejected by the server."));
        }
    }

    @Override
    public HttpVersion getHttpVersion() {
        return delegate.getHttpVersion();
    }

    @Override
    public HttpResponseStatus getStatus() {
        return delegate.getStatus();
    }

    @Override
    public Map> getCookies() {
        return delegate.getCookies();
    }

    @Override
    public boolean containsHeader(CharSequence name) {
        return delegate.containsHeader(name);
    }

    @Override
    public boolean containsHeader(CharSequence name, CharSequence value, boolean ignoreCaseValue) {
        return delegate.containsHeader(name, value, ignoreCaseValue);
    }

    @Override
    public Iterator> headerIterator() {
        return delegate.headerIterator();
    }

    @Override
    public String getHeader(CharSequence name) {
        return delegate.getHeader(name);
    }

    @Override
    public String getHeader(CharSequence name, String defaultValue) {
        return delegate.getHeader(name, defaultValue);
    }

    @Override
    public List getAllHeaderValues(CharSequence name) {
        return delegate.getAllHeaderValues(name);
    }

    @Override
    public long getContentLength() {
        return delegate.getContentLength();
    }

    @Override
    public long getContentLength(long defaultValue) {
        return delegate.getContentLength(defaultValue);
    }

    @Override
    public long getDateHeader(CharSequence name) throws ParseException {
        return delegate.getDateHeader(name);
    }

    @Override
    public long getDateHeader(CharSequence name, long defaultValue) {
        return delegate.getDateHeader(name, defaultValue);
    }

    @Override
    public String getHostHeader() {
        return delegate.getHostHeader();
    }

    @Override
    public String getHost(String defaultValue) {
        return delegate.getHost(defaultValue);
    }

    @Override
    public int getIntHeader(CharSequence name) {
        return delegate.getIntHeader(name);
    }

    @Override
    public int getIntHeader(CharSequence name, int defaultValue) {
        return delegate.getIntHeader(name, defaultValue);
    }

    @Override
    public boolean isContentLengthSet() {
        return delegate.isContentLengthSet();
    }

    @Override
    public boolean isKeepAlive() {
        return delegate.isKeepAlive();
    }

    @Override
    public boolean isTransferEncodingChunked() {
        return delegate.isTransferEncodingChunked();
    }

    @Override
    public Set getHeaderNames() {
        return delegate.getHeaderNames();
    }

    @Override
    public HttpClientResponse addHeader(CharSequence name,
                                           Object value) {
        return delegate.addHeader(name, value);
    }

    @Override
    public HttpClientResponse addCookie(
            Cookie cookie) {
        return delegate.addCookie(cookie);
    }

    @Override
    public HttpClientResponse addDateHeader(CharSequence name,
                                               Date value) {
        return delegate.addDateHeader(name, value);
    }

    @Override
    public HttpClientResponse addDateHeader(CharSequence name,
                                               Iterable values) {
        return delegate.addDateHeader(name, values);
    }

    @Override
    public HttpClientResponse addHeader(CharSequence name,
                                           Iterable