TimeoutInputStream.java

/*
 * Copyright (C) 2009, 2013 Google Inc. and others
 *
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Distribution License v. 1.0 which is available at
 * https://www.eclipse.org/org/documents/edl-v10.php.
 *
 * SPDX-License-Identifier: BSD-3-Clause
 */

package org.eclipse.jgit.util.io;

import java.io.FilterInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InterruptedIOException;
import java.text.MessageFormat;

import org.eclipse.jgit.internal.JGitText;

/**
 * InputStream with a configurable timeout.
 */
public class TimeoutInputStream extends FilterInputStream {
    private final InterruptTimer myTimer;

    private int timeout;

    /**
     * Wrap an input stream with a timeout on all read operations.
     *
     * @param src
     *            base input stream (to read from). The stream must be
     *            interruptible (most socket streams are).
     * @param timer
     *            timer to manage the timeouts during reads.
     */
    public TimeoutInputStream(final InputStream src,
            final InterruptTimer timer) {
        super(src);
        myTimer = timer;
    }

    /**
     * Get number of milliseconds before aborting a read.
     *
     * @return number of milliseconds before aborting a read.
     */
    public int getTimeout() {
        return timeout;
    }

    /**
     * Set number of milliseconds before aborting a read.
     *
     * @param millis
     *            number of milliseconds before aborting a read. Must be > 0.
     */
    public void setTimeout(int millis) {
        if (millis < 0)
            throw new IllegalArgumentException(MessageFormat.format(
                    JGitText.get().invalidTimeout, Integer.valueOf(millis)));
        timeout = millis;
    }

    /** {@inheritDoc} */
    @Override
    public int read() throws IOException {
        try {
            beginRead();
            return super.read();
        } catch (InterruptedIOException e) {
            throw readTimedOut(e);
        } finally {
            endRead();
        }
    }

    /** {@inheritDoc} */
    @Override
    public int read(byte[] buf) throws IOException {
        return read(buf, 0, buf.length);
    }

    /** {@inheritDoc} */
    @Override
    public int read(byte[] buf, int off, int cnt) throws IOException {
        try {
            beginRead();
            return super.read(buf, off, cnt);
        } catch (InterruptedIOException e) {
            throw readTimedOut(e);
        } finally {
            endRead();
        }
    }

    /** {@inheritDoc} */
    @Override
    public long skip(long cnt) throws IOException {
        try {
            beginRead();
            return super.skip(cnt);
        } catch (InterruptedIOException e) {
            throw readTimedOut(e);
        } finally {
            endRead();
        }
    }

    private void beginRead() {
        myTimer.begin(timeout);
    }

    private void endRead() {
        myTimer.end();
    }

    private InterruptedIOException readTimedOut(InterruptedIOException e) {
        InterruptedIOException interrupted = new InterruptedIOException(
                MessageFormat.format(JGitText.get().readTimedOut,
                        Integer.valueOf(timeout)));
        interrupted.initCause(e);
        return interrupted;
    }
}