org.apache.thrift.transport.TIOStreamTransport.java Source code

Introduction

Here is the source code for org.apache.thrift.transport.TIOStreamTransport.java

Source

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements. See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership. The ASF licenses this file
 * to you 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 org.apache.thrift.transport;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

/**
 * This is the most commonly used base transport. It takes an InputStream or
 * an OutputStream or both and uses it/them to perform transport operations.
 * This allows for compatibility with all the nice constructs Java already
 * has to provide a variety of types of streams.
 *
 */
public class TIOStreamTransport extends TTransport {

    private static final Logger LOGGER = LoggerFactory.getLogger(TIOStreamTransport.class.getName());

    /** Underlying inputStream */
    protected InputStream inputStream_ = null;

    /** Underlying outputStream */
    protected OutputStream outputStream_ = null;

    /**
     * Subclasses can invoke the default constructor and then assign the input
     * streams in the open method.
     */
    protected TIOStreamTransport() {
    }

    /**
     * Input stream constructor, constructs an input only transport.
     *
     * @param is Input stream to read from
     */
    public TIOStreamTransport(InputStream is) {
        inputStream_ = is;
    }

    /**
     * Output stream constructor, constructs an output only transport.
     *
     * @param os Output stream to write to
     */
    public TIOStreamTransport(OutputStream os) {
        outputStream_ = os;
    }

    /**
     * Two-way stream constructor.
     *
     * @param is Input stream to read from
     * @param os Output stream to read from
     */
    public TIOStreamTransport(InputStream is, OutputStream os) {
        inputStream_ = is;
        outputStream_ = os;
    }

    /**
     *
     * @return false after close is called.
     */
    public boolean isOpen() {
        return inputStream_ != null || outputStream_ != null;
    }

    /**
     * The streams must already be open. This method does nothing.
     */
    public void open() throws TTransportException {
    }

    /**
     * Closes both the input and output streams.
     */
    public void close() {
        try {
            if (inputStream_ != null) {
                try {
                    inputStream_.close();
                } catch (IOException iox) {
                    LOGGER.warn("Error closing input stream.", iox);
                }
            }
            if (outputStream_ != null) {
                try {
                    outputStream_.close();
                } catch (IOException iox) {
                    LOGGER.warn("Error closing output stream.", iox);
                }
            }
        } finally {
            inputStream_ = null;
            outputStream_ = null;
        }
    }

    /**
     * Reads from the underlying input stream if not null.
     */
    public int read(byte[] buf, int off, int len) throws TTransportException {
        if (inputStream_ == null) {
            throw new TTransportException(TTransportException.NOT_OPEN, "Cannot read from null inputStream");
        }
        int bytesRead;
        try {
            bytesRead = inputStream_.read(buf, off, len);
        } catch (IOException iox) {
            throw new TTransportException(TTransportException.UNKNOWN, iox);
        }
        if (bytesRead < 0) {
            throw new TTransportException(TTransportException.END_OF_FILE, "Socket is closed by peer.");
        }
        return bytesRead;
    }

    /**
     * Writes to the underlying output stream if not null.
     */
    public void write(byte[] buf, int off, int len) throws TTransportException {
        if (outputStream_ == null) {
            throw new TTransportException(TTransportException.NOT_OPEN, "Cannot write to null outputStream");
        }
        try {
            outputStream_.write(buf, off, len);
        } catch (IOException iox) {
            throw new TTransportException(TTransportException.UNKNOWN, iox);
        }
    }

    /**
     * Flushes the underlying output stream if not null.
     */
    public void flush() throws TTransportException {
        if (outputStream_ == null) {
            throw new TTransportException(TTransportException.NOT_OPEN, "Cannot flush null outputStream");
        }
        try {
            outputStream_.flush();
        } catch (IOException iox) {
            throw new TTransportException(TTransportException.UNKNOWN, iox);
        }
    }
}