[fanfix.git] / src / jexer / io / TimeoutInputStream.java

/*
 * Jexer - Java Text User Interface
 *
 * The MIT License (MIT)
 *
 * Copyright (C) 2019 Kevin Lamonte
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 *
 * @author Kevin Lamonte [kevin.lamonte@gmail.com]
 * @version 1
 */
package jexer.io;

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

/**
 * This class provides an optional millisecond timeout on its read()
 * operations.  This permits callers to bail out rather than block.
 */
public class TimeoutInputStream extends InputStream {

    // ------------------------------------------------------------------------
    // Variables --------------------------------------------------------------
    // ------------------------------------------------------------------------

    /**
     * The wrapped stream.
     */
    private InputStream stream;

    /**
     * The timeout value in millis.  If it takes longer than this for bytes
     * to be available for read then a ReadTimeoutException is thrown.  A
     * value of 0 means to block as a normal InputStream would.
     */
    private int timeoutMillis;

    /**
     * If true, the current read() will timeout soon.
     */
    private volatile boolean cancel = false;

    // ------------------------------------------------------------------------
    // Constructors -----------------------------------------------------------
    // ------------------------------------------------------------------------

    /**
     * Public constructor, at the default timeout of 10000 millis (10
     * seconds).
     *
     * @param stream the wrapped InputStream
     */
    public TimeoutInputStream(final InputStream stream) {
        this.stream             = stream;
        this.timeoutMillis      = 10000;
    }

    /**
     * Public constructor.
     *
     * @param stream the wrapped InputStream
     * @param timeoutMillis the timeout value in millis.  If it takes longer
     * than this for bytes to be available for read then a
     * ReadTimeoutException is thrown.  A value of 0 means to block as a
     * normal InputStream would.
     */
    public TimeoutInputStream(final InputStream stream,
        final int timeoutMillis) {

        if (timeoutMillis < 0) {
            throw new IllegalArgumentException("Invalid timeoutMillis value, " +
                "must be >= 0");
        }

        this.stream             = stream;
        this.timeoutMillis      = timeoutMillis;
    }

    // ------------------------------------------------------------------------
    // InputStream ------------------------------------------------------------
    // ------------------------------------------------------------------------

    /**
     * Reads the next byte of data from the input stream.
     *
     * @return the next byte of data, or -1 if there is no more data because
     * the end of the stream has been reached.
     * @throws IOException if an I/O error occurs
     */
    @Override
    public int read() throws IOException {

        if (timeoutMillis == 0) {
            // Block on the read().
            return stream.read();
        }

        if (stream.available() > 0) {
            // A byte is available now, return it.
            return stream.read();
        }

        // We will wait up to timeoutMillis to see if a byte is available.
        // If not, we throw ReadTimeoutException.
        long checkTime = System.currentTimeMillis();
        while (stream.available() == 0) {
            long now = System.currentTimeMillis();
            synchronized (this) {
                if ((now - checkTime > timeoutMillis) || (cancel == true)) {
                    if (cancel == true) {
                        cancel = false;
                    }
                    throw new ReadTimeoutException("Timeout on read(): " +
                        (int) (now - checkTime) + " millis and still no data");
                }
            }
            try {
                // How long do we sleep for, eh?  For now we will go with 2
                // millis.
                Thread.sleep(2);
            } catch (InterruptedException e) {
                // SQUASH
            }
        }

        if (stream.available() > 0) {
            // A byte is available now, return it.
            return stream.read();
        }

        throw new IOException("InputStream claimed a byte was available, but " +
            "now it is not.  What is going on?");
    }

    /**
     * Reads some number of bytes from the input stream and stores them into
     * the buffer array b.
     *
     * @param b the buffer into which the data is read.
     * @return the total number of bytes read into the buffer, or -1 if there
     * is no more data because the end of the stream has been reached.
     * @throws IOException if an I/O error occurs
     */
    @Override
    public int read(final byte[] b) throws IOException {
        if (timeoutMillis == 0) {
            // Block on the read().
            return stream.read(b);
        }

        int remaining = b.length;

        if (stream.available() >= remaining) {
            // Enough bytes are available now, return them.
            return stream.read(b);
        }

        while (remaining > 0) {

            // We will wait up to timeoutMillis to see if a byte is
            // available.  If not, we throw ReadTimeoutException.
            long checkTime = System.currentTimeMillis();
            while (stream.available() == 0) {
                if (remaining > 0) {
                    return (b.length - remaining);
                }

                long now = System.currentTimeMillis();
                synchronized (this) {
                    if ((now - checkTime > timeoutMillis) || (cancel == true)) {
                        if (cancel == true) {
                            cancel = false;
                        }
                        throw new ReadTimeoutException("Timeout on read(): " +
                            (int) (now - checkTime) + " millis and still no " +
                            "data");
                    }
                }
                try {
                    // How long do we sleep for, eh?  For now we will go with
                    // 2 millis.
                    Thread.sleep(2);
                } catch (InterruptedException e) {
                    // SQUASH
                }
            }

            if (stream.available() > 0) {
                // At least one byte is available now, read it.
                int n = stream.available();
                if (remaining < n) {
                    n = remaining;
                }
                int rc = stream.read(b, b.length - remaining, n);
                if (rc == -1) {
                    // This shouldn't happen.
                    throw new IOException("InputStream claimed bytes were " +
                        "available, but read() returned -1.  What is going " +
                        "on?");
                }
                remaining -= rc;
                if (remaining == 0) {
                    return b.length;
                }
            }
        }

        throw new IOException("InputStream claimed all bytes were available, " +
            "but now it is not.  What is going on?");
    }

    /**
     * Reads up to len bytes of data from the input stream into an array of
     * bytes.
     *
     * @param b the buffer into which the data is read.
     * @param off the start offset in array b at which the data is written.
     * @param len the maximum number of bytes to read.
     * @return the total number of bytes read into the buffer, or -1 if there
     * is no more data because the end of the stream has been reached.
     * @throws IOException if an I/O error occurs
     */
    @Override
    public int read(final byte[] b, final int off,
        final int len) throws IOException {

        if (timeoutMillis == 0) {
            // Block on the read().
            return stream.read(b, off, len);
        }

        int remaining = len;

        if (stream.available() >= remaining) {
            // Enough bytes are available now, return them.
            return stream.read(b, off, remaining);
        }

        while (remaining > 0) {

            // We will wait up to timeoutMillis to see if a byte is
            // available.  If not, we throw ReadTimeoutException.
            long checkTime = System.currentTimeMillis();
            while (stream.available() == 0) {
                if (remaining > 0) {
                    return (len - remaining);
                }

                long now = System.currentTimeMillis();
                synchronized (this) {
                    if ((now - checkTime > timeoutMillis) || (cancel == true)) {
                        if (cancel == true) {
                            cancel = false;
                        }
                        throw new ReadTimeoutException("Timeout on read(): " +
                            (int) (now - checkTime) + " millis and still no " +
                            "data");
                    }
                }
                try {
                    // How long do we sleep for, eh?  For now we will go with
                    // 2 millis.
                    Thread.sleep(2);
                } catch (InterruptedException e) {
                    // SQUASH
                }
            }

            if (stream.available() > 0) {
                // At least one byte is available now, read it.
                int n = stream.available();
                if (remaining < n) {
                    n = remaining;
                }
                int rc = stream.read(b, off + len - remaining, n);
                if (rc == -1) {
                    // This shouldn't happen.
                    throw new IOException("InputStream claimed bytes were " +
                        "available, but read() returned -1.  What is going " +
                        "on?");
                }
                remaining -= rc;
                if (remaining == 0) {
                    return len;
                }
            }
        }

        throw new IOException("InputStream claimed all bytes were available, " +
            "but now it is not.  What is going on?");
    }

    /**
     * Returns an estimate of the number of bytes that can be read (or
     * skipped over) from this input stream without blocking by the next
     * invocation of a method for this input stream.
     *
     * @return an estimate of the number of bytes that can be read (or
     * skipped over) from this input stream without blocking or 0 when it
     * reaches the end of the input stream.
     * @throws IOException if an I/O error occurs
     */
    @Override
    public int available() throws IOException {
        return stream.available();
    }

    /**
     * Closes this input stream and releases any system resources associated
     * with the stream.
     *
     * @throws IOException if an I/O error occurs
     */
    @Override
    public void close() throws IOException {
        stream.close();
    }

    /**
     * Marks the current position in this input stream.
     *
     * @param readLimit the maximum limit of bytes that can be read before
     * the mark position becomes invalid
     */
    @Override
    public void mark(final int readLimit) {
        stream.mark(readLimit);
    }

    /**
     * Tests if this input stream supports the mark and reset methods.
     *
     * @return true if this stream instance supports the mark and reset
     * methods; false otherwise
     */
    @Override
    public boolean markSupported() {
        return stream.markSupported();
    }

    /**
     * Repositions this stream to the position at the time the mark method
     * was last called on this input stream.
     *
     * @throws IOException if an I/O error occurs
     */
    @Override
    public void reset() throws IOException {
        stream.reset();
    }

    /**
     * Skips over and discards n bytes of data from this input stream.
     *
     * @param n the number of bytes to be skipped
     * @return the actual number of bytes skipped
     * @throws IOException if an I/O error occurs
     */
    @Override
    public long skip(final long n) throws IOException {
        return stream.skip(n);
    }

    // ------------------------------------------------------------------------
    // TimeoutInputStream -----------------------------------------------------
    // ------------------------------------------------------------------------

    /**
     * Request that the current read() operation timeout immediately.
     */
    public synchronized void cancelRead() {
        cancel = true;
    }

}
Commit	Line	Data
	1	/*
	2	* Jexer - Java Text User Interface
	3	*
	4	* The MIT License (MIT)
	5	*
	6	* Copyright (C) 2019 Kevin Lamonte
	7	*
	8	* Permission is hereby granted, free of charge, to any person obtaining a
	9	* copy of this software and associated documentation files (the "Software"),
	10	* to deal in the Software without restriction, including without limitation
	11	* the rights to use, copy, modify, merge, publish, distribute, sublicense,
	12	* and/or sell copies of the Software, and to permit persons to whom the
	13	* Software is furnished to do so, subject to the following conditions:
	14	*
	15	* The above copyright notice and this permission notice shall be included in
	16	* all copies or substantial portions of the Software.
	17	*
	18	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	19	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	20	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
	21	* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
	22	* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
	23	* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
	24	* DEALINGS IN THE SOFTWARE.
	25	*
	26	* @author Kevin Lamonte [kevin.lamonte@gmail.com]
	27	* @version 1
	28	*/
	29	package jexer.io;
	30
	31	import java.io.IOException;
	32	import java.io.InputStream;
	33
	34	/**
	35	* This class provides an optional millisecond timeout on its read()
	36	* operations. This permits callers to bail out rather than block.
	37	*/
	38	public class TimeoutInputStream extends InputStream {
	39
	40	// ------------------------------------------------------------------------
	41	// Variables --------------------------------------------------------------
	42	// ------------------------------------------------------------------------
	43
	44	/**
	45	* The wrapped stream.
	46	*/
	47	private InputStream stream;
	48
	49	/**
	50	* The timeout value in millis. If it takes longer than this for bytes
	51	* to be available for read then a ReadTimeoutException is thrown. A
	52	* value of 0 means to block as a normal InputStream would.
	53	*/
	54	private int timeoutMillis;
	55
	56	/**
	57	* If true, the current read() will timeout soon.
	58	*/
	59	private volatile boolean cancel = false;
	60
	61	// ------------------------------------------------------------------------
	62	// Constructors -----------------------------------------------------------
	63	// ------------------------------------------------------------------------
	64
	65	/**
	66	* Public constructor, at the default timeout of 10000 millis (10
	67	* seconds).
	68	*
	69	* @param stream the wrapped InputStream
	70	*/
	71	public TimeoutInputStream(final InputStream stream) {
	72	this.stream = stream;
	73	this.timeoutMillis = 10000;
	74	}
	75
	76	/**
	77	* Public constructor.
	78	*
	79	* @param stream the wrapped InputStream
	80	* @param timeoutMillis the timeout value in millis. If it takes longer
	81	* than this for bytes to be available for read then a
	82	* ReadTimeoutException is thrown. A value of 0 means to block as a
	83	* normal InputStream would.
	84	*/
	85	public TimeoutInputStream(final InputStream stream,
	86	final int timeoutMillis) {
	87
	88	if (timeoutMillis < 0) {
	89	throw new IllegalArgumentException("Invalid timeoutMillis value, " +
	90	"must be >= 0");
	91	}
	92
	93	this.stream = stream;
	94	this.timeoutMillis = timeoutMillis;
	95	}
	96
	97	// ------------------------------------------------------------------------
	98	// InputStream ------------------------------------------------------------
	99	// ------------------------------------------------------------------------
	100
	101	/**
	102	* Reads the next byte of data from the input stream.
	103	*
	104	* @return the next byte of data, or -1 if there is no more data because
	105	* the end of the stream has been reached.
	106	* @throws IOException if an I/O error occurs
	107	*/
	108	@Override
	109	public int read() throws IOException {
	110
	111	if (timeoutMillis == 0) {
	112	// Block on the read().
	113	return stream.read();
	114	}
	115
	116	if (stream.available() > 0) {
	117	// A byte is available now, return it.
	118	return stream.read();
	119	}
	120
	121	// We will wait up to timeoutMillis to see if a byte is available.
	122	// If not, we throw ReadTimeoutException.
	123	long checkTime = System.currentTimeMillis();
	124	while (stream.available() == 0) {
	125	long now = System.currentTimeMillis();
	126	synchronized (this) {
	127	if ((now - checkTime > timeoutMillis) \|\| (cancel == true)) {
	128	if (cancel == true) {
	129	cancel = false;
	130	}
	131	throw new ReadTimeoutException("Timeout on read(): " +
	132	(int) (now - checkTime) + " millis and still no data");
	133	}
	134	}
	135	try {
	136	// How long do we sleep for, eh? For now we will go with 2
	137	// millis.
	138	Thread.sleep(2);
	139	} catch (InterruptedException e) {
	140	// SQUASH
	141	}
	142	}
	143
	144	if (stream.available() > 0) {
	145	// A byte is available now, return it.
	146	return stream.read();
	147	}
	148
	149	throw new IOException("InputStream claimed a byte was available, but " +
	150	"now it is not. What is going on?");
	151	}
	152
	153	/**
	154	* Reads some number of bytes from the input stream and stores them into
	155	* the buffer array b.
	156	*
	157	* @param b the buffer into which the data is read.
	158	* @return the total number of bytes read into the buffer, or -1 if there
	159	* is no more data because the end of the stream has been reached.
	160	* @throws IOException if an I/O error occurs
	161	*/
	162	@Override
	163	public int read(final byte[] b) throws IOException {
	164	if (timeoutMillis == 0) {
	165	// Block on the read().
	166	return stream.read(b);
	167	}
	168
	169	int remaining = b.length;
	170
	171	if (stream.available() >= remaining) {
	172	// Enough bytes are available now, return them.
	173	return stream.read(b);
	174	}
	175
	176	while (remaining > 0) {
	177
	178	// We will wait up to timeoutMillis to see if a byte is
	179	// available. If not, we throw ReadTimeoutException.
	180	long checkTime = System.currentTimeMillis();
	181	while (stream.available() == 0) {
	182	if (remaining > 0) {
	183	return (b.length - remaining);
	184	}
	185
	186	long now = System.currentTimeMillis();
	187	synchronized (this) {
	188	if ((now - checkTime > timeoutMillis) \|\| (cancel == true)) {
	189	if (cancel == true) {
	190	cancel = false;
	191	}
	192	throw new ReadTimeoutException("Timeout on read(): " +
	193	(int) (now - checkTime) + " millis and still no " +
	194	"data");
	195	}
	196	}
	197	try {
	198	// How long do we sleep for, eh? For now we will go with
	199	// 2 millis.
	200	Thread.sleep(2);
	201	} catch (InterruptedException e) {
	202	// SQUASH
	203	}
	204	}
	205
	206	if (stream.available() > 0) {
	207	// At least one byte is available now, read it.
	208	int n = stream.available();
	209	if (remaining < n) {
	210	n = remaining;
	211	}
	212	int rc = stream.read(b, b.length - remaining, n);
	213	if (rc == -1) {
	214	// This shouldn't happen.
	215	throw new IOException("InputStream claimed bytes were " +
	216	"available, but read() returned -1. What is going " +
	217	"on?");
	218	}
	219	remaining -= rc;
	220	if (remaining == 0) {
	221	return b.length;
	222	}
	223	}
	224	}
	225
	226	throw new IOException("InputStream claimed all bytes were available, " +
	227	"but now it is not. What is going on?");
	228	}
	229
	230	/**
	231	* Reads up to len bytes of data from the input stream into an array of
	232	* bytes.
	233	*
	234	* @param b the buffer into which the data is read.
	235	* @param off the start offset in array b at which the data is written.
	236	* @param len the maximum number of bytes to read.
	237	* @return the total number of bytes read into the buffer, or -1 if there
	238	* is no more data because the end of the stream has been reached.
	239	* @throws IOException if an I/O error occurs
	240	*/
	241	@Override
	242	public int read(final byte[] b, final int off,
	243	final int len) throws IOException {
	244
	245	if (timeoutMillis == 0) {
	246	// Block on the read().
	247	return stream.read(b, off, len);
	248	}
	249
	250	int remaining = len;
	251
	252	if (stream.available() >= remaining) {
	253	// Enough bytes are available now, return them.
	254	return stream.read(b, off, remaining);
	255	}
	256
	257	while (remaining > 0) {
	258
	259	// We will wait up to timeoutMillis to see if a byte is
	260	// available. If not, we throw ReadTimeoutException.
	261	long checkTime = System.currentTimeMillis();
	262	while (stream.available() == 0) {
	263	if (remaining > 0) {
	264	return (len - remaining);
	265	}
	266
	267	long now = System.currentTimeMillis();
	268	synchronized (this) {
	269	if ((now - checkTime > timeoutMillis) \|\| (cancel == true)) {
	270	if (cancel == true) {
	271	cancel = false;
	272	}
	273	throw new ReadTimeoutException("Timeout on read(): " +
	274	(int) (now - checkTime) + " millis and still no " +
	275	"data");
	276	}
	277	}
	278	try {
	279	// How long do we sleep for, eh? For now we will go with
	280	// 2 millis.
	281	Thread.sleep(2);
	282	} catch (InterruptedException e) {
	283	// SQUASH
	284	}
	285	}
	286
	287	if (stream.available() > 0) {
	288	// At least one byte is available now, read it.
	289	int n = stream.available();
	290	if (remaining < n) {
	291	n = remaining;
	292	}
	293	int rc = stream.read(b, off + len - remaining, n);
	294	if (rc == -1) {
	295	// This shouldn't happen.
	296	throw new IOException("InputStream claimed bytes were " +
	297	"available, but read() returned -1. What is going " +
	298	"on?");
	299	}
	300	remaining -= rc;
	301	if (remaining == 0) {
	302	return len;
	303	}
	304	}
	305	}
	306
	307	throw new IOException("InputStream claimed all bytes were available, " +
	308	"but now it is not. What is going on?");
	309	}
	310
	311	/**
	312	* Returns an estimate of the number of bytes that can be read (or
	313	* skipped over) from this input stream without blocking by the next
	314	* invocation of a method for this input stream.
	315	*
	316	* @return an estimate of the number of bytes that can be read (or
	317	* skipped over) from this input stream without blocking or 0 when it
	318	* reaches the end of the input stream.
	319	* @throws IOException if an I/O error occurs
	320	*/
	321	@Override
	322	public int available() throws IOException {
	323	return stream.available();
	324	}
	325
	326	/**
	327	* Closes this input stream and releases any system resources associated
	328	* with the stream.
	329	*
	330	* @throws IOException if an I/O error occurs
	331	*/
	332	@Override
	333	public void close() throws IOException {
	334	stream.close();
	335	}
	336
	337	/**
	338	* Marks the current position in this input stream.
	339	*
	340	* @param readLimit the maximum limit of bytes that can be read before
	341	* the mark position becomes invalid
	342	*/
	343	@Override
	344	public void mark(final int readLimit) {
	345	stream.mark(readLimit);
	346	}
	347
	348	/**
	349	* Tests if this input stream supports the mark and reset methods.
	350	*
	351	* @return true if this stream instance supports the mark and reset
	352	* methods; false otherwise
	353	*/
	354	@Override
	355	public boolean markSupported() {
	356	return stream.markSupported();
	357	}
	358
	359	/**
	360	* Repositions this stream to the position at the time the mark method
	361	* was last called on this input stream.
	362	*
	363	* @throws IOException if an I/O error occurs
	364	*/
	365	@Override
	366	public void reset() throws IOException {
	367	stream.reset();
	368	}
	369
	370	/**
	371	* Skips over and discards n bytes of data from this input stream.
	372	*
	373	* @param n the number of bytes to be skipped
	374	* @return the actual number of bytes skipped
	375	* @throws IOException if an I/O error occurs
	376	*/
	377	@Override
	378	public long skip(final long n) throws IOException {
	379	return stream.skip(n);
	380	}
	381
	382	// ------------------------------------------------------------------------
	383	// TimeoutInputStream -----------------------------------------------------
	384	// ------------------------------------------------------------------------
	385
	386	/**
	387	* Request that the current read() operation timeout immediately.
	388	*/
	389	public synchronized void cancelRead() {
	390	cancel = true;
	391	}
	392
	393	}