From dcf8c6d1239d90bdf3c6d5bad89802ff18c7de40 Mon Sep 17 00:00:00 2001 From: markt Date: Fri, 8 Jul 2011 17:19:38 +0000 Subject: [PATCH] Pull up Handler.process for the Http11 connectors. Note that this is an intermediate step. The aim is to pull this up to AbstractProtocol git-svn-id: https://svn.apache.org/repos/asf/tomcat/trunk@1144391 13f79535-47bb-0310-9956-ffa450edef68 --- .../coyote/http11/AbstractHttp11Processor.java | 6 +- .../coyote/http11/AbstractHttp11Protocol.java | 95 ++++++++++++++++++++++ .../apache/coyote/http11/Http11AprProcessor.java | 3 +- .../apache/coyote/http11/Http11AprProtocol.java | 91 ++------------------- .../apache/coyote/http11/Http11NioProcessor.java | 3 +- .../apache/coyote/http11/Http11NioProtocol.java | 93 ++------------------- java/org/apache/coyote/http11/Http11Processor.java | 3 +- java/org/apache/coyote/http11/Http11Protocol.java | 92 ++------------------- 8 files changed, 126 insertions(+), 260 deletions(-) diff --git a/java/org/apache/coyote/http11/AbstractHttp11Processor.java b/java/org/apache/coyote/http11/AbstractHttp11Processor.java index e3e489ce0..54a3f4ca4 100644 --- a/java/org/apache/coyote/http11/AbstractHttp11Processor.java +++ b/java/org/apache/coyote/http11/AbstractHttp11Processor.java @@ -47,9 +47,10 @@ import org.apache.tomcat.util.http.MimeHeaders; import org.apache.tomcat.util.net.AbstractEndpoint; import org.apache.tomcat.util.net.AbstractEndpoint.Handler.SocketState; import org.apache.tomcat.util.net.SocketStatus; +import org.apache.tomcat.util.net.SocketWrapper; import org.apache.tomcat.util.res.StringManager; -public abstract class AbstractHttp11Processor extends AbstractProcessor { +public abstract class AbstractHttp11Processor extends AbstractProcessor { protected abstract Log getLog(); @@ -1211,6 +1212,9 @@ public abstract class AbstractHttp11Processor extends AbstractProcessor { } + public abstract SocketState process(SocketWrapper socket) + throws IOException; + public SocketState asyncDispatch(SocketStatus status) { RequestInfo rp = request.getRequestProcessor(); diff --git a/java/org/apache/coyote/http11/AbstractHttp11Protocol.java b/java/org/apache/coyote/http11/AbstractHttp11Protocol.java index 0d1aca45a..b15c35b35 100644 --- a/java/org/apache/coyote/http11/AbstractHttp11Protocol.java +++ b/java/org/apache/coyote/http11/AbstractHttp11Protocol.java @@ -16,7 +16,12 @@ */ package org.apache.coyote.http11; +import java.util.concurrent.ConcurrentHashMap; + import org.apache.coyote.AbstractProtocol; +import org.apache.tomcat.util.ExceptionUtils; +import org.apache.tomcat.util.net.SocketStatus; +import org.apache.tomcat.util.net.SocketWrapper; import org.apache.tomcat.util.res.StringManager; public abstract class AbstractHttp11Protocol extends AbstractProtocol { @@ -182,4 +187,94 @@ public abstract class AbstractHttp11Protocol extends AbstractProtocol { public void setMaxKeepAliveRequests(int mkar) { endpoint.setMaxKeepAliveRequests(mkar); } + + + protected abstract static class AbstractHttp11ConnectionHandler> + extends AbstractConnectionHandler { + + protected ConcurrentHashMap,P> connections = + new ConcurrentHashMap,P>(); + + protected RecycledProcessors

recycledProcessors = + new RecycledProcessors

(this); + + @Override + public void recycle() { + recycledProcessors.clear(); + } + + public SocketState process(SocketWrapper socket, + SocketStatus status) { + P processor = connections.remove(socket); + + socket.setAsync(false); //no longer check for timeout + + try { + if (processor == null) { + processor = recycledProcessors.poll(); + } + if (processor == null) { + processor = createProcessor(); + } + + initSsl(socket, processor); + + SocketState state = SocketState.CLOSED; + do { + if (processor.isAsync() || state == SocketState.ASYNC_END) { + state = processor.asyncDispatch(status); + } else if (processor.comet) { + state = processor.event(status); + } else { + state = processor.process(socket); + } + + if (state != SocketState.CLOSED && processor.isAsync()) { + state = processor.asyncPostProcess(); + } + } while (state == SocketState.ASYNC_END); + + if (state == SocketState.LONG) { + // In the middle of processing a request/response. Keep the + // socket associated with the processor. Exact requirements + // depend on type of long poll + longPoll(socket, processor); + } else if (state == SocketState.OPEN){ + // In keep-alive but between requests. OK to recycle + // processor. Continue to poll for the next request. + release(socket, processor, false, true); + } else { + // Connection closed. OK to recycle the processor. + release(socket, processor, true, false); + } + return state; + } catch(java.net.SocketException e) { + // SocketExceptions are normal + getLog().debug(sm.getString( + "http11protocol.proto.socketexception.debug"), e); + } catch (java.io.IOException e) { + // IOExceptions are normal + getLog().debug(sm.getString( + "http11protocol.proto.ioexception.debug"), e); + } + // Future developers: if you discover any other + // rare-but-nonfatal exceptions, catch them here, and log as + // above. + catch (Throwable e) { + ExceptionUtils.handleThrowable(e); + // any other exception or error is odd. Here we log it + // with "ERROR" level, so it will show up even on + // less-than-verbose logs. + getLog().error(sm.getString("http11protocol.proto.error"), e); + } + release(socket, processor, true, false); + return SocketState.CLOSED; + } + + protected abstract P createProcessor(); + protected abstract void initSsl(SocketWrapper socket, P processor); + protected abstract void longPoll(SocketWrapper socket, P processor); + protected abstract void release(SocketWrapper socket, P processor, + boolean socketClosing, boolean addToPoller); + } } diff --git a/java/org/apache/coyote/http11/Http11AprProcessor.java b/java/org/apache/coyote/http11/Http11AprProcessor.java index 38fb8e916..14f664b16 100644 --- a/java/org/apache/coyote/http11/Http11AprProcessor.java +++ b/java/org/apache/coyote/http11/Http11AprProcessor.java @@ -45,7 +45,7 @@ import org.apache.tomcat.util.net.SocketWrapper; * * @author Remy Maucherat */ -public class Http11AprProcessor extends AbstractHttp11Processor { +public class Http11AprProcessor extends AbstractHttp11Processor { private static final Log log = LogFactory.getLog(Http11AprProcessor.class); @@ -163,6 +163,7 @@ public class Http11AprProcessor extends AbstractHttp11Processor { * * @throws IOException error during an I/O operation */ + @Override public SocketState process(SocketWrapper socket) throws IOException { RequestInfo rp = request.getRequestProcessor(); diff --git a/java/org/apache/coyote/http11/Http11AprProtocol.java b/java/org/apache/coyote/http11/Http11AprProtocol.java index b8ae0a84d..f630dfbf4 100644 --- a/java/org/apache/coyote/http11/Http11AprProtocol.java +++ b/java/org/apache/coyote/http11/Http11AprProtocol.java @@ -14,19 +14,14 @@ * See the License for the specific language governing permissions and * limitations under the License. */ - package org.apache.coyote.http11; -import java.util.concurrent.ConcurrentHashMap; - import org.apache.coyote.AbstractProtocol; import org.apache.juli.logging.Log; import org.apache.juli.logging.LogFactory; -import org.apache.tomcat.util.ExceptionUtils; import org.apache.tomcat.util.net.AbstractEndpoint; import org.apache.tomcat.util.net.AprEndpoint; import org.apache.tomcat.util.net.AprEndpoint.Handler; -import org.apache.tomcat.util.net.SocketStatus; import org.apache.tomcat.util.net.SocketWrapper; @@ -182,16 +177,10 @@ public class Http11AprProtocol extends AbstractHttp11Protocol { // -------------------- Connection handler -------------------- protected static class Http11ConnectionHandler - extends AbstractConnectionHandler implements Handler { + extends AbstractHttp11ConnectionHandler implements Handler { protected Http11AprProtocol proto; - protected ConcurrentHashMap connections = - new ConcurrentHashMap(); - - protected RecycledProcessors recycledProcessors = - new RecycledProcessors(this); - Http11ConnectionHandler(Http11AprProtocol proto) { this.proto = proto; } @@ -220,6 +209,7 @@ public class Http11AprProtocol extends AbstractHttp11Protocol { * @param isSocketClosing Not used in HTTP * @param addToPoller */ + @Override public void release(SocketWrapper socket, Http11AprProcessor processor, boolean isSocketClosing, boolean addToPoller) { @@ -232,83 +222,15 @@ public class Http11AprProtocol extends AbstractHttp11Protocol { } @Override - public SocketState process(SocketWrapper socket, - SocketStatus status) { - Http11AprProcessor processor = connections.remove(socket.getSocket()); - - socket.setAsync(false); - - try { - if (processor == null) { - processor = recycledProcessors.poll(); - } - if (processor == null) { - processor = createProcessor(); - } - - initSsl(socket, processor); - - SocketState state = SocketState.CLOSED; - do { - if (processor.isAsync() || state == SocketState.ASYNC_END) { - state = processor.asyncDispatch(status); - } else if (processor.comet) { - state = processor.event(status); - } else { - state = processor.process(socket); - } - - if (state != SocketState.CLOSED && processor.isAsync()) { - state = processor.asyncPostProcess(); - } - } while (state == SocketState.ASYNC_END); - - if (state == SocketState.LONG) { - // In the middle of processing a request/response. Keep the - // socket associated with the processor. Exact requirements - // depend on type of long poll - longPoll(socket, processor); - } else if (state == SocketState.OPEN){ - // In keep-alive but between requests. OK to recycle - // processor. Continue to poll for the next request. - release(socket, processor, false, true); - } else { - // Connection closed. OK to recycle the processor. - release(socket, processor, true, false); - } - return state; - } catch (java.net.SocketException e) { - // SocketExceptions are normal - log.debug(sm.getString( - "http11protocol.proto.socketexception.debug"), e); - } catch (java.io.IOException e) { - // IOExceptions are normal - log.debug(sm.getString( - "http11protocol.proto.ioexception.debug"), e); - } - // Future developers: if you discover any other - // rare-but-nonfatal exceptions, catch them here, and log as - // above. - catch (Throwable e) { - ExceptionUtils.handleThrowable(e); - // any other exception or error is odd. Here we log it - // with "ERROR" level, so it will show up even on - // less-than-verbose logs. - log.error(sm.getString("http11protocol.proto.error"), e); - } - release(socket, processor, true, false); - return SocketState.CLOSED; - } - - @SuppressWarnings("unused") - private void initSsl(SocketWrapper socket, + protected void initSsl(SocketWrapper socket, Http11AprProcessor processor) { // NOOP for APR } - private void longPoll(SocketWrapper socket, + @Override + protected void longPoll(SocketWrapper socket, Http11AprProcessor processor) { - connections.put(socket.getSocket(), processor); + connections.put(socket, processor); if (processor.isAsync()) { socket.setAsync(true); @@ -318,6 +240,7 @@ public class Http11AprProtocol extends AbstractHttp11Protocol { } } + @Override protected Http11AprProcessor createProcessor() { Http11AprProcessor processor = new Http11AprProcessor( proto.getMaxHttpHeaderSize(), (AprEndpoint)proto.endpoint, diff --git a/java/org/apache/coyote/http11/Http11NioProcessor.java b/java/org/apache/coyote/http11/Http11NioProcessor.java index fcc6b7515..599776bd2 100644 --- a/java/org/apache/coyote/http11/Http11NioProcessor.java +++ b/java/org/apache/coyote/http11/Http11NioProcessor.java @@ -45,7 +45,7 @@ import org.apache.tomcat.util.net.SocketWrapper; * @author Remy Maucherat * @author Filip Hanik */ -public class Http11NioProcessor extends AbstractHttp11Processor { +public class Http11NioProcessor extends AbstractHttp11Processor { private static final Log log = LogFactory.getLog(Http11NioProcessor.class); @Override @@ -194,6 +194,7 @@ public class Http11NioProcessor extends AbstractHttp11Processor { * * @throws IOException error during an I/O operation */ + @Override public SocketState process(SocketWrapper socket) throws IOException { RequestInfo rp = request.getRequestProcessor(); diff --git a/java/org/apache/coyote/http11/Http11NioProtocol.java b/java/org/apache/coyote/http11/Http11NioProtocol.java index 0711d7222..b3915ba42 100644 --- a/java/org/apache/coyote/http11/Http11NioProtocol.java +++ b/java/org/apache/coyote/http11/Http11NioProtocol.java @@ -14,18 +14,15 @@ * See the License for the specific language governing permissions and * limitations under the License. */ - package org.apache.coyote.http11; import java.nio.channels.SelectionKey; import java.nio.channels.SocketChannel; import java.util.Iterator; -import java.util.concurrent.ConcurrentHashMap; import org.apache.coyote.AbstractProtocol; import org.apache.juli.logging.Log; import org.apache.juli.logging.LogFactory; -import org.apache.tomcat.util.ExceptionUtils; import org.apache.tomcat.util.net.AbstractEndpoint; import org.apache.tomcat.util.net.NioChannel; import org.apache.tomcat.util.net.NioEndpoint; @@ -33,7 +30,6 @@ import org.apache.tomcat.util.net.NioEndpoint.Handler; import org.apache.tomcat.util.net.NioEndpoint.KeyAttachment; import org.apache.tomcat.util.net.SSLImplementation; import org.apache.tomcat.util.net.SecureNioChannel; -import org.apache.tomcat.util.net.SocketStatus; import org.apache.tomcat.util.net.SocketWrapper; @@ -152,16 +148,11 @@ public class Http11NioProtocol extends AbstractHttp11JsseProtocol { // -------------------- Connection handler -------------------- protected static class Http11ConnectionHandler - extends AbstractConnectionHandler implements Handler { + extends AbstractHttp11ConnectionHandler + implements Handler { protected Http11NioProtocol proto; - protected ConcurrentHashMap, Http11NioProcessor> connections = - new ConcurrentHashMap, Http11NioProcessor>(); - - protected RecycledProcessors recycledProcessors = - new RecycledProcessors(this); - Http11ConnectionHandler(Http11NioProtocol proto) { this.proto = proto; } @@ -182,11 +173,6 @@ public class Http11NioProtocol extends AbstractHttp11JsseProtocol { return proto.sslImplementation; } - @Override - public void recycle() { - recycledProcessors.clear(); - } - /** * Expected to be used by the Poller to release resources on socket * close, errors etc. @@ -235,6 +221,7 @@ public class Http11NioProtocol extends AbstractHttp11JsseProtocol { * @param isSocketClosing Not used in HTTP * @param addToPoller */ + @Override public void release(SocketWrapper socket, Http11NioProcessor processor, boolean isSocketClosing, boolean addToPoller) { @@ -247,75 +234,7 @@ public class Http11NioProtocol extends AbstractHttp11JsseProtocol { @Override - public SocketState process(SocketWrapper socket, - SocketStatus status) { - Http11NioProcessor processor = connections.remove(socket); - - socket.setAsync(false); //no longer check for timeout - - try { - if (processor == null) { - processor = recycledProcessors.poll(); - } - if (processor == null) { - processor = createProcessor(); - } - - initSsl(socket, processor); - - SocketState state = SocketState.CLOSED; - do { - if (processor.isAsync() || state == SocketState.ASYNC_END) { - state = processor.asyncDispatch(status); - } else if (processor.comet) { - state = processor.event(status); - } else { - state = processor.process(socket); - } - - if (state != SocketState.CLOSED && processor.isAsync()) { - state = processor.asyncPostProcess(); - } - } while (state == SocketState.ASYNC_END); - - if (state == SocketState.LONG) { - // In the middle of processing a request/response. Keep the - // socket associated with the processor. Exact requirements - // depend on type of long poll - longPoll(socket, processor); - } else if (state == SocketState.OPEN){ - // In keep-alive but between requests. OK to recycle - // processor. Continue to poll for the next request. - release(socket, processor, false, true); - } else { - // Connection closed. OK to recycle the processor. - release(socket, processor, true, false); - } - return state; - } catch (java.net.SocketException e) { - // SocketExceptions are normal - log.debug(sm.getString( - "http11protocol.proto.socketexception.debug"), e); - } catch (java.io.IOException e) { - // IOExceptions are normal - log.debug(sm.getString( - "http11protocol.proto.ioexception.debug"), e); - } - // Future developers: if you discover any other - // rare-but-nonfatal exceptions, catch them here, and log as - // above. - catch (Throwable e) { - ExceptionUtils.handleThrowable(e); - // any other exception or error is odd. Here we log it - // with "ERROR" level, so it will show up even on - // less-than-verbose logs. - log.error(sm.getString("http11protocol.proto.error"), e); - } - release(socket, processor, true, false); - return SocketState.CLOSED; - } - - private void initSsl(SocketWrapper socket, + protected void initSsl(SocketWrapper socket, Http11NioProcessor processor) { if (proto.isSSLEnabled() && (proto.sslImplementation != null) @@ -330,7 +249,8 @@ public class Http11NioProtocol extends AbstractHttp11JsseProtocol { } - private void longPoll(SocketWrapper socket, + @Override + protected void longPoll(SocketWrapper socket, Http11NioProcessor processor) { connections.put(socket, processor); @@ -349,6 +269,7 @@ public class Http11NioProtocol extends AbstractHttp11JsseProtocol { } } + @Override public Http11NioProcessor createProcessor() { Http11NioProcessor processor = new Http11NioProcessor( proto.getMaxHttpHeaderSize(), (NioEndpoint)proto.endpoint, diff --git a/java/org/apache/coyote/http11/Http11Processor.java b/java/org/apache/coyote/http11/Http11Processor.java index df77477e7..0b87894ad 100644 --- a/java/org/apache/coyote/http11/Http11Processor.java +++ b/java/org/apache/coyote/http11/Http11Processor.java @@ -41,7 +41,7 @@ import org.apache.tomcat.util.net.SocketWrapper; * @author Remy Maucherat * @author fhanik */ -public class Http11Processor extends AbstractHttp11Processor { +public class Http11Processor extends AbstractHttp11Processor { private static final Log log = LogFactory.getLog(Http11Processor.class); @Override @@ -129,6 +129,7 @@ public class Http11Processor extends AbstractHttp11Processor { * * @throws IOException error during an I/O operation */ + @Override public SocketState process(SocketWrapper socketWrapper) throws IOException { RequestInfo rp = request.getRequestProcessor(); diff --git a/java/org/apache/coyote/http11/Http11Protocol.java b/java/org/apache/coyote/http11/Http11Protocol.java index 5d188e332..0a9420c87 100644 --- a/java/org/apache/coyote/http11/Http11Protocol.java +++ b/java/org/apache/coyote/http11/Http11Protocol.java @@ -14,20 +14,16 @@ * See the License for the specific language governing permissions and * limitations under the License. */ - package org.apache.coyote.http11; import java.net.Socket; -import java.util.concurrent.ConcurrentHashMap; import org.apache.coyote.AbstractProtocol; import org.apache.juli.logging.Log; -import org.apache.tomcat.util.ExceptionUtils; import org.apache.tomcat.util.net.AbstractEndpoint; import org.apache.tomcat.util.net.JIoEndpoint; import org.apache.tomcat.util.net.JIoEndpoint.Handler; import org.apache.tomcat.util.net.SSLImplementation; -import org.apache.tomcat.util.net.SocketStatus; import org.apache.tomcat.util.net.SocketWrapper; @@ -101,16 +97,10 @@ public class Http11Protocol extends AbstractHttp11JsseProtocol { // ----------------------------------- Http11ConnectionHandler Inner Class protected static class Http11ConnectionHandler - extends AbstractConnectionHandler implements Handler { + extends AbstractHttp11ConnectionHandler implements Handler { protected Http11Protocol proto; - protected ConcurrentHashMap, Http11Processor> connections = - new ConcurrentHashMap, Http11Processor>(); - - protected RecycledProcessors recycledProcessors = - new RecycledProcessors(this); - Http11ConnectionHandler(Http11Protocol proto) { this.proto = proto; } @@ -130,11 +120,6 @@ public class Http11Protocol extends AbstractHttp11JsseProtocol { return proto.sslImplementation; } - @Override - public void recycle() { - recycledProcessors.clear(); - } - /** * Expected to be used by the handler once the processor is no longer * required. @@ -144,6 +129,7 @@ public class Http11Protocol extends AbstractHttp11JsseProtocol { * @param isSocketClosing Not used in HTTP * @param addToPoller Not used in BIO */ + @Override public void release(SocketWrapper socket, Http11Processor processor, boolean isSocketClosing, boolean addToPoller) { @@ -152,75 +138,7 @@ public class Http11Protocol extends AbstractHttp11JsseProtocol { } @Override - public SocketState process(SocketWrapper socket, - SocketStatus status) { - Http11Processor processor = connections.remove(socket); - - socket.setAsync(false); //no longer check for timeout - - try { - if (processor == null) { - processor = recycledProcessors.poll(); - } - if (processor == null) { - processor = createProcessor(); - } - - initSsl(socket, processor); - - SocketState state = SocketState.CLOSED; - do { - if (processor.isAsync() || state == SocketState.ASYNC_END) { - state = processor.asyncDispatch(status); - } else if (processor.comet) { - state = processor.event(status); - } else { - state = processor.process(socket); - } - - if (state != SocketState.CLOSED && processor.isAsync()) { - state = processor.asyncPostProcess(); - } - } while (state == SocketState.ASYNC_END); - - if (state == SocketState.LONG) { - // In the middle of processing a request/response. Keep the - // socket associated with the processor. Exact requirements - // depend on type of long poll - longPoll(socket, processor); - } else if (state == SocketState.OPEN){ - // In keep-alive but between requests. OK to recycle - // processor. Continue to poll for the next request. - release(socket, processor, false, true); - } else { - // Connection closed. OK to recycle the processor. - release(socket, processor, true, false); - } - return state; - } catch(java.net.SocketException e) { - // SocketExceptions are normal - log.debug(sm.getString( - "http11protocol.proto.socketexception.debug"), e); - } catch (java.io.IOException e) { - // IOExceptions are normal - log.debug(sm.getString( - "http11protocol.proto.ioexception.debug"), e); - } - // Future developers: if you discover any other - // rare-but-nonfatal exceptions, catch them here, and log as - // above. - catch (Throwable e) { - ExceptionUtils.handleThrowable(e); - // any other exception or error is odd. Here we log it - // with "ERROR" level, so it will show up even on - // less-than-verbose logs. - log.error(sm.getString("http11protocol.proto.error"), e); - } - release(socket, processor, true, false); - return SocketState.CLOSED; - } - - private void initSsl(SocketWrapper socket, + protected void initSsl(SocketWrapper socket, Http11Processor processor) { if (proto.isSSLEnabled() && (proto.sslImplementation != null)) { processor.setSSLSupport( @@ -232,11 +150,13 @@ public class Http11Protocol extends AbstractHttp11JsseProtocol { } - private void longPoll(SocketWrapper socket, + @Override + protected void longPoll(SocketWrapper socket, Http11Processor processor) { connections.put(socket, processor); } + @Override protected Http11Processor createProcessor() { Http11Processor processor = new Http11Processor( proto.getMaxHttpHeaderSize(), (JIoEndpoint)proto.endpoint, -- 2.11.0