From 41916e4de1a6294bcf240780d3fea80076e579ad Mon Sep 17 00:00:00 2001 From: Roland Weber Date: Sun, 18 Feb 2007 08:25:55 +0000 Subject: [PATCH] new port of 3.1 AutoCloseInputStream git-svn-id: https://svn.apache.org/repos/asf/jakarta/httpcomponents/httpclient/trunk@508886 13f79535-47bb-0310-9956-ffa450edef68 --- .../http/conn/EofSensorInputStream.java | 250 ++++++++++++++++++ .../apache/http/conn/EofSensorWatcher.java | 88 ++++++ 2 files changed, 338 insertions(+) create mode 100644 src/java/org/apache/http/conn/EofSensorInputStream.java create mode 100644 src/java/org/apache/http/conn/EofSensorWatcher.java diff --git a/src/java/org/apache/http/conn/EofSensorInputStream.java b/src/java/org/apache/http/conn/EofSensorInputStream.java new file mode 100644 index 000000000..255db482c --- /dev/null +++ b/src/java/org/apache/http/conn/EofSensorInputStream.java @@ -0,0 +1,250 @@ +/* + * $Header$ + * $Revision$ + * $Date$ + * + * ==================================================================== + * + * 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. + * ==================================================================== + * + * This software consists of voluntary contributions made by many + * individuals on behalf of the Apache Software Foundation. For more + * information on the Apache Software Foundation, please see + * . + * + */ + +package org.apache.http.conn; + +import java.io.InputStream; +import java.io.IOException; + + +/** + * A stream wrapper that triggers actions on {@link #close close()} and EOF. + * Primarily used to auto-release an underlying + * {@link ManagedClientConnection connection} + * when the response body is consumed or no longer needed. + * + *

+ * This class is based on AutoCloseInputStream in HttpClient 3.1, + * but has notable differences. It does not allow mark/reset, distinguishes + * different kinds of event, and does not always close the underlying stream + * on EOF. That decision is left to the {@link EofSensorWatcher watcher}. + *

+ * + * @see EofSensorWatcher EofSensorWatcher + * + * @author Roland Weber + * @author Ortwin Glueck + * @author Eric Johnson + * @author Mike Bowler + * + * + * + * @version $Revision$ + * + * @since 4.0 + */ +public class EofSensorInputStream extends InputStream { + // don't use FilterInputStream as the base class, we'd have to + // override markSupported(), mark(), and reset() to disable them + + /** + * The wrapped input stream, while accessible. + * The value changes to null when the wrapped stream + * becomes inaccessible. + */ + protected InputStream wrappedStream; + + + /** + * Indicates whether this stream itself is closed. + * If it isn't, but {@link #wrappedStream wrappedStream} + * is null, we're running in EOF mode. + * All read operations will indicate EOF without accessing + * the underlying stream. After closing this stream, read + * operations will trigger an {@link IOException IOException}. + * + * @see #isReadAllowed isReadAllowed + */ + private boolean selfClosed; + + /** The watcher to be notified, if any. */ + private EofSensorWatcher eofWatcher; + + + /** + * Creates a new EOF sensor. + * If no watcher is passed, the underlying stream will simply be + * closed when EOF is detected or {@link #close close} is called. + * Otherwise, the watcher decides whether the underlying stream + * should be closed before detaching from it. + * + * @param in the wrapped stream + * @param watcher the watcher for events, or null for + * auto-close behavior without notification + */ + public EofSensorInputStream(final InputStream in, + final EofSensorWatcher watcher) { + if (in == null) { + throw new IllegalArgumentException + ("Wrapped stream may not be null."); + } + + wrappedStream = in; + selfClosed = false; + eofWatcher = watcher; + } + + + /** + * Checks whether the underyling stream can be read from. + * + * @return true if the underlying stream is accessible, + * false if this stream is in EOF mode and + * detached from the underlying stream + * + * @throws IOException if this stream is already closed + */ + protected boolean isReadAllowed() throws IOException { + if (selfClosed) { + throw new IOException("Attempted read on closed stream."); + } + return (wrappedStream != null); + } + + + // non-javadoc, see base class InputStream + public int read() throws IOException { + int l = -1; + + if (isReadAllowed()) { + l = wrappedStream.read(); + checkEOF(l); + } + + return l; + } + + + // non-javadoc, see base class InputStream + public int read(byte[] b, int off, int len) throws IOException { + int l = -1; + + if (isReadAllowed()) { + l = wrappedStream.read(b, off, len); + checkEOF(l); + } + + return l; + } + + + // non-javadoc, see base class InputStream + public int read(byte[] b) throws IOException { + int l = -1; + + if (isReadAllowed()) { + l = wrappedStream.read(b); + checkEOF(l); + } + return l; + } + + + // non-javadoc, see base class InputStream + public int available() throws IOException { + int a = 0; // not -1 + + if (isReadAllowed()) { + a = wrappedStream.available(); + // no checkEOF() here, available() can't trigger EOF + } + + return a; + } + + + // non-javadoc, see base class InputStream + public void close() throws IOException { + // tolerate multiple calls to close() + selfClosed = true; + checkClose(); + } + + + /** + * Detects EOF and notifies the watcher. + * This method should only be called while the underlying stream is + * still accessible. Use {@link #isReadAllowed isReadAllowed} to + * check that condition. + *
+ * If EOF is detected, the watcher will be notified and this stream + * is detached from the underlying stream. This prevents multiple + * notifications from this stream. + * + * @param eof the result of the calling read operation. + * A negative value indicates that EOF is reached. + * + * @throws IOException + * in case of an IO problem on closing the underlying stream + */ + protected void checkEOF(int eof) throws IOException { + + if ((wrappedStream != null) && (eof < 0)) { + try { + boolean scws = true; // should close wrapped stream? + if (eofWatcher != null) + scws = eofWatcher.eofDetected(wrappedStream); + if (scws) + wrappedStream.close(); + } finally { + wrappedStream = null; + } + } + } + + + /** + * Detects stream close and notifies the watcher. + * There's not much to detect since this is called by {@link #close close}. + * The watcher will only be notified if this stream is closed + * for the first time and before EOF has been detected. + * This stream will be detached from the underlying stream to prevent + * multiple notifications to the watcher. + * + * @throws IOException + * in case of an IO problem on closing the underlying stream + */ + protected void checkClose() throws IOException { + + if (wrappedStream != null) { + try { + boolean scws = true; // should close wrapped stream? + if (eofWatcher != null) + scws = eofWatcher.streamClosed(wrappedStream); + if (scws) + wrappedStream.close(); + } finally { + wrappedStream = null; + } + } + } + +} // class EOFSensorInputStream + diff --git a/src/java/org/apache/http/conn/EofSensorWatcher.java b/src/java/org/apache/http/conn/EofSensorWatcher.java new file mode 100644 index 000000000..c90b42786 --- /dev/null +++ b/src/java/org/apache/http/conn/EofSensorWatcher.java @@ -0,0 +1,88 @@ +/* + * $Header$ + * $Revision$ + * $Date$ + * + * ==================================================================== + * + * 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. + * ==================================================================== + * + * This software consists of voluntary contributions made by many + * individuals on behalf of the Apache Software Foundation. For more + * information on the Apache Software Foundation, please see + * . + * + */ + +package org.apache.http.conn; + +import java.io.InputStream; +import java.io.IOException; + + +/** + * A watcher for {@link EofSensorInputStream EofSensorInputStream}. + * Each stream will notify it's watcher at most once. + * + * @author Roland Weber + * + * + * + * @version $Revision$ + * + * @since 4.0 + */ +public interface EofSensorWatcher { + + /** + * Indicates that EOF is detected. + * + * @param wrapped the underlying stream which has reached EOF + * + * @return true if wrapped should be closed, + * false if it should be left alone + * + * @throws IOException + * in case of an IO problem, for example if the watcher itself + * closes the underlying stream. The caller will leave the + * wrapped stream alone, as if false was returned. + */ + boolean eofDetected(InputStream wrapped) + throws IOException + ; + + + /** + * Indicates that the {@link EofSensorInputStream stream} is closed. + * This method will be called only if EOF was not detected + * before closing. Otherwise, {@link #eofDetected eofDetected} is called. + * + * @param wrapped the underlying stream which has not reached EOF + * + * @return true if wrapped should be closed, + * false if it should be left alone + * + * @throws IOException + * in case of an IO problem, for example if the watcher itself + * closes the underlying stream. The caller will leave the + * wrapped stream alone, as if false was returned. + */ + boolean streamClosed(InputStream wrapped) + throws IOException + ; + +} // interface EofSensorWatcher