tomcat-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ma...@apache.org
Subject svn commit: r1680661 - in /tomcat/trunk/java/org/apache/coyote/http2: AbstractStream.java Http2UpgradeHandler.java LocalStrings.properties Stream.java WriteStateMachine.java
Date Wed, 20 May 2015 19:21:52 GMT
Author: markt
Date: Wed May 20 19:21:52 2015
New Revision: 1680661

URL: http://svn.apache.org/r1680661
Log:
More plumbing for write.
Generally:
 - uses a state machine to co-orindate writes across multiple threads
 - all writes are done on the main Connection thread, not on the Stream threads
 - if there is a read thread, see if we need to (and can) write when it finishes
 - written with an eye on non-blocking IO but that side of things isn't fully thought through


Also some improvements to debug logging. Added a connection ID and made logs slightly less
verbose.

Added:
    tomcat/trunk/java/org/apache/coyote/http2/WriteStateMachine.java   (with props)
Modified:
    tomcat/trunk/java/org/apache/coyote/http2/AbstractStream.java
    tomcat/trunk/java/org/apache/coyote/http2/Http2UpgradeHandler.java
    tomcat/trunk/java/org/apache/coyote/http2/LocalStrings.properties
    tomcat/trunk/java/org/apache/coyote/http2/Stream.java

Modified: tomcat/trunk/java/org/apache/coyote/http2/AbstractStream.java
URL: http://svn.apache.org/viewvc/tomcat/trunk/java/org/apache/coyote/http2/AbstractStream.java?rev=1680661&r1=1680660&r2=1680661&view=diff
==============================================================================
--- tomcat/trunk/java/org/apache/coyote/http2/AbstractStream.java (original)
+++ tomcat/trunk/java/org/apache/coyote/http2/AbstractStream.java Wed May 20 19:21:52 2015
@@ -48,8 +48,9 @@ abstract class AbstractStream {
 
     public void rePrioritise(AbstractStream parent, boolean exclusive, int weight) {
         if (getLog().isDebugEnabled()) {
-            getLog().debug(sm.getString("abstractStream.reprioritisation.debug", identifier,
-                    Boolean.toString(exclusive), parent.getIdentifier(), Integer.toString(weight)));
+            getLog().debug(sm.getString("abstractStream.reprioritisation.debug",
+                    Long.toString(getConnectionId()), identifier, Boolean.toString(exclusive),
+                    parent.getIdentifier(), Integer.toString(weight)));
         }
 
         // Check if new parent is a descendant of this stream
@@ -120,4 +121,6 @@ abstract class AbstractStream {
     }
 
     protected abstract Log getLog();
+
+    protected abstract int getConnectionId();
 }

Modified: tomcat/trunk/java/org/apache/coyote/http2/Http2UpgradeHandler.java
URL: http://svn.apache.org/viewvc/tomcat/trunk/java/org/apache/coyote/http2/Http2UpgradeHandler.java?rev=1680661&r1=1680660&r2=1680661&view=diff
==============================================================================
--- tomcat/trunk/java/org/apache/coyote/http2/Http2UpgradeHandler.java (original)
+++ tomcat/trunk/java/org/apache/coyote/http2/Http2UpgradeHandler.java Wed May 20 19:21:52
2015
@@ -22,11 +22,15 @@ import java.nio.ByteBuffer;
 import java.nio.charset.StandardCharsets;
 import java.util.HashMap;
 import java.util.Map;
+import java.util.Queue;
+import java.util.concurrent.ConcurrentLinkedQueue;
+import java.util.concurrent.atomic.AtomicInteger;
 
 import javax.servlet.http.WebConnection;
 
 import org.apache.coyote.Adapter;
 import org.apache.coyote.http11.upgrade.InternalHttpUpgradeHandler;
+import org.apache.coyote.http2.WriteStateMachine.WriteState;
 import org.apache.juli.logging.Log;
 import org.apache.juli.logging.LogFactory;
 import org.apache.tomcat.util.net.AbstractEndpoint.Handler.SocketState;
@@ -52,6 +56,7 @@ public class Http2UpgradeHandler extends
     private static final Log log = LogFactory.getLog(Http2UpgradeHandler.class);
     private static final StringManager sm = StringManager.getManager(Http2UpgradeHandler.class);
 
+    private static final AtomicInteger connectionIdGenerator = new AtomicInteger(0);
     private static final Integer STREAM_ID_ZERO = Integer.valueOf(0);
 
     private static final int FRAME_TYPE_HEADERS = 1;
@@ -63,6 +68,7 @@ public class Http2UpgradeHandler extends
     private static final byte[] SETTINGS_ACK = { 0x00, 0x00, 0x00, 0x04, 0x01, 0x00, 0x00,
0x00, 0x00 };
     private static final byte[] GOAWAY = { 0x07, 0x00, 0x00, 0x00, 0x00 };
 
+    private final int connectionId;
     private final Adapter adapter;
     private volatile SocketWrapperBase<?> socketWrapper;
     private volatile boolean initialized = false;
@@ -81,15 +87,22 @@ public class Http2UpgradeHandler extends
 
     private final Map<Integer,Stream> streams = new HashMap<>();
 
+    private final WriteStateMachine writeStateMachine = new WriteStateMachine();
+    private final Queue<Object> writeQueue = new ConcurrentLinkedQueue<>();
 
     public Http2UpgradeHandler(Adapter adapter) {
         super (STREAM_ID_ZERO);
         this.adapter = adapter;
+        this.connectionId = connectionIdGenerator.getAndIncrement();
     }
 
 
     @Override
     public void init(WebConnection unused) {
+        if (log.isDebugEnabled()) {
+            log.debug(sm.getString("upgradeHandler.init", Long.toString(connectionId)));
+        }
+
         initialized = true;
 
         // Send the initial settings frame
@@ -110,13 +123,21 @@ public class Http2UpgradeHandler extends
 
     @Override
     public SocketState upgradeDispatch(SocketStatus status) {
+        if (log.isDebugEnabled()) {
+            log.debug(sm.getString("upgradeHandler.upgradeDispatch.entry",
+                    Long.toString(connectionId), status));
+        }
+
         if (!initialized) {
             // WebConnection is not used so passing null here is fine
             init(null);
         }
 
+        SocketState result = SocketState.CLOSED;
+
         switch(status) {
         case OPEN_READ:
+            writeStateMachine.startRead();
             // Gets set to null once the connection preface has been
             // successfully parsed.
             if (connectionPrefaceParser != null) {
@@ -124,10 +145,11 @@ public class Http2UpgradeHandler extends
                     if (connectionPrefaceParser.isError()) {
                         // Any errors will have already been logged.
                         close();
-                        return SocketState.CLOSED;
+                        break;
                     } else {
                         // Incomplete
-                        return SocketState.LONG;
+                        result = SocketState.UPGRADED;
+                        break;
                     }
                 }
             }
@@ -142,7 +164,7 @@ public class Http2UpgradeHandler extends
                     // Connection error
                     log.warn(sm.getString("upgradeHandler.connectionError"), h2e);
                     close(h2e);
-                    return SocketState.CLOSED;
+                    break;
                 } else {
                     // Stream error
                     // TODO Reset stream
@@ -152,15 +174,22 @@ public class Http2UpgradeHandler extends
                     log.debug(sm.getString("upgradeHandler.processFrame.ioerror"), ioe);
                 }
                 close();
-                return SocketState.CLOSED;
+                result = SocketState.CLOSED;
+                break;
             }
 
-            // TODO process writes
+            if (writeStateMachine.endRead()) {
+                processWrites();
+            }
 
-            return SocketState.LONG;
+            result = SocketState.UPGRADED;
+            break;
 
         case OPEN_WRITE:
-            // TODO
+            if (writeStateMachine.startWrite()) {
+                processWrites();
+            }
+            result = SocketState.UPGRADED;
             break;
 
         case ASYNC_READ_ERROR:
@@ -178,13 +207,15 @@ public class Http2UpgradeHandler extends
             // For all of the above, including the unexpected values, close the
             // connection.
             close();
-            return SocketState.CLOSED;
+            result = SocketState.CLOSED;
+            break;
         }
 
-        // TODO This is for debug purposes to make sure ALPN is working.
-        log.fatal("TODO: Handle SocketStatus: " + status);
-        close();
-        return SocketState.CLOSED;
+        if (log.isDebugEnabled()) {
+            log.debug(sm.getString("upgradeHandler.upgradeDispatch.exit",
+                    Long.toString(connectionId), result));
+        }
+        return result;
     }
 
 
@@ -224,8 +255,8 @@ public class Http2UpgradeHandler extends
     private void processFrameHeaders(int flags, int streamId, int payloadSize) throws IOException
{
         if (log.isDebugEnabled()) {
             log.debug(sm.getString("upgradeHandler.processFrame",
-                    Integer.toString(FRAME_TYPE_HEADERS), Integer.toString(flags),
-                    Integer.toString(streamId), Integer.toString(payloadSize)));
+                    Long.toString(connectionId), Integer.toString(streamId),
+                    Integer.toString(flags), Integer.toString(payloadSize)));
         }
 
         // Validate the stream
@@ -309,8 +340,8 @@ public class Http2UpgradeHandler extends
     private void processFramePriority(int flags, int streamId, int payloadSize) throws IOException
{
         if (log.isDebugEnabled()) {
             log.debug(sm.getString("upgradeHandler.processFrame",
-                    Integer.toString(FRAME_TYPE_PRIORITY), Integer.toString(flags),
-                    Integer.toString(streamId), Integer.toString(payloadSize)));
+                    Long.toString(connectionId), Integer.toString(streamId),
+                    Integer.toString(flags), Integer.toString(payloadSize)));
         }
         // Validate the frame
         if (streamId == 0) {
@@ -353,8 +384,8 @@ public class Http2UpgradeHandler extends
     private void processFrameSettings(int flags, int streamId, int payloadSize) throws IOException
{
         if (log.isDebugEnabled()) {
             log.debug(sm.getString("upgradeHandler.processFrame",
-                    Integer.toString(FRAME_TYPE_SETTINGS), Integer.toString(flags),
-                    Integer.toString(streamId), Integer.toString(payloadSize)));
+                    Long.toString(connectionId), Integer.toString(streamId),
+                    Integer.toString(flags), Integer.toString(payloadSize)));
         }
         // Validate the frame
         if (streamId != 0) {
@@ -401,8 +432,8 @@ public class Http2UpgradeHandler extends
             throws IOException {
         if (log.isDebugEnabled()) {
             log.debug(sm.getString("upgradeHandler.processFrame",
-                    Integer.toString(FRAME_TYPE_WINDOW_UPDATE), Integer.toString(flags),
-                    Integer.toString(streamId), Integer.toString(payloadSize)));
+                    Long.toString(connectionId), Integer.toString(streamId),
+                    Integer.toString(flags), Integer.toString(payloadSize)));
         }
         // Validate the frame
         if (payloadSize != 4) {
@@ -417,7 +448,8 @@ public class Http2UpgradeHandler extends
 
         if (log.isDebugEnabled()) {
             log.debug(sm.getString("upgradeHandler.processFrameWindowUpdate.debug",
-                    Integer.toString(streamId), Integer.toString(windowSizeIncrement)));
+                    Long.toString(connectionId), Integer.toString(streamId),
+                    Integer.toString(windowSizeIncrement)));
         }
 
         // Validate the data
@@ -579,6 +611,44 @@ public class Http2UpgradeHandler extends
     }
 
 
+    private void processWrites() {
+        Object obj;
+        while ((obj = getThingToWrite()) != null) {
+            // TODO
+            log.debug("TODO: write [" + obj.toString() + "]");
+        }
+    }
+
+
+    private Object getThingToWrite() {
+        synchronized (writeStateMachine) {
+            // TODO This is more complicated than pulling an object off a queue.
+
+            // Note: The checking of the queue for something to write and the
+            //       calling of endWrite() if nothing is found must be kept
+            //       within the same sync to avoid race conditions with adding
+            //       entries to the queue.
+            Object obj = writeQueue.poll();
+            if (obj == null) {
+                 writeStateMachine.endWrite(WriteState.IDLE);
+            }
+            return obj;
+        }
+    }
+
+
+    void addWrite(Object obj) {
+        boolean needDispatch;
+        synchronized (writeStateMachine) {
+            writeQueue.add(obj);
+            needDispatch = writeStateMachine.addWrite();
+        }
+        if (needDispatch) {
+            socketWrapper.processSocket(SocketStatus.OPEN_WRITE, true);
+        }
+    }
+
+
     private Stream getStream(int streamId) {
         Integer key = Integer.valueOf(streamId);
 
@@ -608,6 +678,12 @@ public class Http2UpgradeHandler extends
     }
 
 
+    @Override
+    protected final int getConnectionId() {
+        return connectionId;
+    }
+
+
     @Override
     protected final Log getLog() {
         return log;

Modified: tomcat/trunk/java/org/apache/coyote/http2/LocalStrings.properties
URL: http://svn.apache.org/viewvc/tomcat/trunk/java/org/apache/coyote/http2/LocalStrings.properties?rev=1680661&r1=1680660&r2=1680661&view=diff
==============================================================================
--- tomcat/trunk/java/org/apache/coyote/http2/LocalStrings.properties (original)
+++ tomcat/trunk/java/org/apache/coyote/http2/LocalStrings.properties Wed May 20 19:21:52
2015
@@ -13,7 +13,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-abstractStream.reprioritisation.debug=Reprioritising stream [{0}] with exclusive [{1}], parent
[{2}] and weight [{3}]
+abstractStream.reprioritisation.debug=Connection [{0}], Stream [{1}], Exclusive [{2}], Parent
[{3}], Weight [{4}]
+
 connectionPrefaceParser.eos=Unexpected end of stream while reading opening client preface
byte sequence. Only [{0}] bytes read.
 connectionPrefaceParser.ioError=Failed to read opening client preface byte sequence
 connectionPrefaceParser.mismatch=An unexpected byte sequence was received at the start of
the client preface [{0}]
@@ -30,13 +31,15 @@ hpackdecoder.zeroNotValidHeaderTableInde
 
 hpackhuffman.huffmanEncodedHpackValueDidNotEndWithEOS=Huffman encoded value in HPACK headers
did not end with EOS padding
 
-stream.header.debug=Stream [{0}] recieved HTTP header [{1}] with value [{2}]
+stream.header.debug=Connection [{0}], Stream [{1}], HTTP header [{2}], Value [{3}]
+stream.write=Connection [{0}], Stream [{1}]
 
 streamProcessor.httpupgrade.notsupported=HTTP upgrade is not supported within HTTP/2 streams
 
 upgradeHandler.connectionError=An error occurred that requires the HTTP/2 connection to be
closed.
+upgradeHandler.init=Connection [{0}]
 upgradeHandler.payloadTooBig=The payload is [{0}] bytes long but the maximum frame size is
[{1}]
-upgradeHandler.processFrame=Processing frame of type [{0}] for stream [{2}] with flags [{1}]
and payload size [{3}]
+upgradeHandler.processFrame=Connection [{0}], Stream [{1}], Flags [{2}], Payload size [{3}]
 upgradeHandler.processFrame.ioerror=An I/O error occurred while reading an incoming HTTP/2
frame
 upgradeHandler.processFrameHeaders.invalidStream=Headers frame received for stream [0]
 upgradeHandler.processFrameHeaders.decodingFailed=There was an error during the HPACK decoding
of HTTP headers
@@ -46,11 +49,17 @@ upgradeHandler.processFramePriority.inva
 upgradeHandler.processFrameSettings.ackWithNonZeroPayload=Settings frame received with the
ACK flag set and payload present
 upgradeHandler.processFrameSettings.invalidPayloadSize=Settings frame received with a payload
size of [{0}] which is not a multiple of 6
 upgradeHandler.processFrameSettings.invalidStream=Settings frame received for stream [{0}]
-upgradeHandler.processFrameWindowUpdate.debug=Received notification to increment the flow
control window for stream [{0}] by [{1}]
+upgradeHandler.processFrameWindowUpdate.debug=Connection [{0}], Stream [{1}], Window size
increment [{2}]
 upgradeHandler.processFrameWindowUpdate.invalidIncrement=Window update frame received with
an invalid increment size of [0]
 upgradeHandler.processFrameWindowUpdate.invalidPayloadSize=Window update frame received with
an invalid payload size of [{0}]
 upgradeHandler.receivePrefaceNotSettings=The first frame received from the client was not
a settings frame
 upgradeHandler.sendPrefaceFail=Failed to send preface to client
 upgradeHandler.socketCloseFailed=Error closing socket
 upgradeHandler.unexpectedEos=Unexpected end of stream
-upgradeHandler.unexpectedStatus=An unexpected value of status ([{0}]) was passed to this
method
\ No newline at end of file
+upgradeHandler.unexpectedStatus=An unexpected value of status ([{0}]) was passed to this
method
+upgradeHandler.upgradeDispatch.entry=Entry, Connection [{0}], SocketStatus [{1}]
+upgradeHandler.upgradeDispatch.exit=Exit, Connection [{0}], SocketState [{1}]
+
+
+writeStateMachine.endWrite.ise=It is illegal to specify [{0}] for the new state once a write
has completed
+writeStateMachine.ise=It is illegal to call [{0}()] in state [{1}]
\ No newline at end of file

Modified: tomcat/trunk/java/org/apache/coyote/http2/Stream.java
URL: http://svn.apache.org/viewvc/tomcat/trunk/java/org/apache/coyote/http2/Stream.java?rev=1680661&r1=1680660&r2=1680661&view=diff
==============================================================================
--- tomcat/trunk/java/org/apache/coyote/http2/Stream.java (original)
+++ tomcat/trunk/java/org/apache/coyote/http2/Stream.java Wed May 20 19:21:52 2015
@@ -56,7 +56,8 @@ public class Stream extends AbstractStre
     @Override
     public void emitHeader(String name, String value, boolean neverIndex) {
         if (log.isDebugEnabled()) {
-            log.debug(sm.getString("stream.header.debug", getIdentifier(), name, value));
+            log.debug(sm.getString("stream.header.debug",
+                    Long.toString(getConnectionId()), getIdentifier(), name, value));
         }
 
         switch(name) {
@@ -95,13 +96,23 @@ public class Stream extends AbstractStre
 
 
     void writeHeaders() {
+        if (log.isDebugEnabled()) {
+            log.debug(sm.getString("stream.write",
+                    Long.toString(getConnectionId()), getIdentifier()));
+        }
         // Format the frames.
         // TODO
+        handler.addWrite("HEADERS");
     }
 
 
     void flushData() {
+        if (log.isDebugEnabled()) {
+            log.debug(sm.getString("stream.write",
+                    Long.toString(getConnectionId()), getIdentifier()));
+        }
         // TODO
+        handler.addWrite("DATA");
     }
 
 
@@ -111,6 +122,12 @@ public class Stream extends AbstractStre
     }
 
 
+    @Override
+    protected final int getConnectionId() {
+        return getParentStream().getConnectionId();
+    }
+
+
     public Request getCoyoteRequest() {
         return coyoteRequest;
     }

Added: tomcat/trunk/java/org/apache/coyote/http2/WriteStateMachine.java
URL: http://svn.apache.org/viewvc/tomcat/trunk/java/org/apache/coyote/http2/WriteStateMachine.java?rev=1680661&view=auto
==============================================================================
--- tomcat/trunk/java/org/apache/coyote/http2/WriteStateMachine.java (added)
+++ tomcat/trunk/java/org/apache/coyote/http2/WriteStateMachine.java Wed May 20 19:21:52 2015
@@ -0,0 +1,207 @@
+/*
+ *  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.coyote.http2;
+
+import org.apache.tomcat.util.res.StringManager;
+
+/**
+ * TODO. ASCII art state diagram once the state machine is stable.
+ */
+public class WriteStateMachine {
+
+    private static final StringManager sm = StringManager.getManager(WriteStateMachine.class);
+
+    private WriteState state = WriteState.IDLE;
+
+
+    synchronized void startRead() {
+        switch(state) {
+        case IDLE: {
+            state = WriteState.READ_IN_PROGRESS;
+            break;
+        }
+        case WRITE_PENDING: {
+            // NO-OP. Race condition between stream calling write() and poller
+            // triggering OPEN_READ
+            break;
+        }
+        case WRITE_PENDING_BLOCKED_IO:
+        case WRITE_PENDING_BLOCKED_FLOW_CONNECTION:
+        case WRITE_PENDING_BLOCKED_FLOW_STREAMS: {
+            // NO-OP for now. Incoming data may unblock flow control blocks
+            break;
+        }
+        case READ_IN_PROGRESS:
+        case WRITING: {
+            throw new IllegalStateException(
+                    sm.getString("writeStateMachine.ise", "startRead", state));
+        }
+        }
+    }
+
+    /**
+     * @return <code>true</code> if the state changed to WRITING.
+     */
+    synchronized boolean endRead() {
+        switch(state) {
+        case READ_IN_PROGRESS: {
+            state = WriteState.IDLE;
+            return false;
+        }
+        case WRITE_PENDING: {
+            state = WriteState.WRITING;
+            return true;
+        }
+        case IDLE:
+        case WRITING:
+        case WRITE_PENDING_BLOCKED_IO:
+        case WRITE_PENDING_BLOCKED_FLOW_STREAMS:
+        case WRITE_PENDING_BLOCKED_FLOW_CONNECTION:
+            throw new IllegalStateException(
+                    sm.getString("writeStateMachine.ise", "endRead", state));
+        }
+        // Never reaches here. This is just to keep the compiler happy.
+        return false;
+    }
+
+
+    synchronized void windowOpenedStream() {
+        switch (state) {
+        case WRITE_PENDING_BLOCKED_FLOW_STREAMS:
+            state = WriteState.WRITE_PENDING;
+            break;
+        case READ_IN_PROGRESS:
+        case WRITE_PENDING:
+        case WRITE_PENDING_BLOCKED_IO:
+        case WRITE_PENDING_BLOCKED_FLOW_CONNECTION:
+            // NO-OP
+            break;
+        case IDLE:
+        case WRITING:
+            throw new IllegalStateException(
+                    sm.getString("writeStateMachine.ise", "windowOpenedStream", state));
+        }
+    }
+
+
+    synchronized void windowOpenedConnection() {
+        switch (state) {
+        case WRITE_PENDING_BLOCKED_FLOW_CONNECTION:
+            state = WriteState.WRITE_PENDING;
+            break;
+        case READ_IN_PROGRESS:
+        case WRITE_PENDING:
+        case WRITE_PENDING_BLOCKED_IO:
+        case WRITE_PENDING_BLOCKED_FLOW_STREAMS:
+            // NO-OP
+            break;
+        case IDLE:
+        case WRITING:
+            throw new IllegalStateException(
+                    sm.getString("writeStateMachine.ise", "windowOpenedConnection", state));
+        }
+    }
+
+
+    synchronized boolean startWrite() {
+        switch (state) {
+        case WRITE_PENDING:
+        case WRITE_PENDING_BLOCKED_IO: {
+            state = WriteState.WRITING;
+            return true;
+        }
+        case IDLE:
+        case WRITE_PENDING_BLOCKED_FLOW_CONNECTION:
+        case WRITE_PENDING_BLOCKED_FLOW_STREAMS: {
+            // NO-OP. Race condition between stream calling write() and poller
+            // triggering OPEN_READ
+            return false;
+        }
+        case READ_IN_PROGRESS:
+        case WRITING:
+            throw new IllegalStateException(
+                    sm.getString("writeStateMachine.ise", "startWrite", state));
+        }
+        // Never reaches here. This is just to keep the compiler happy.
+        return false;
+    }
+
+
+    synchronized void endWrite(WriteState newState) {
+        switch (state) {
+        case WRITING: {
+            switch (newState) {
+            case IDLE:
+            case WRITE_PENDING_BLOCKED_IO:
+            case WRITE_PENDING_BLOCKED_FLOW_STREAMS:
+            case WRITE_PENDING_BLOCKED_FLOW_CONNECTION: {
+                state = newState;
+                break;
+            }
+            case WRITE_PENDING:
+            case WRITING:
+            case READ_IN_PROGRESS:
+                throw new IllegalStateException(
+                        sm.getString("writeStateMachine.endWrite.ise", newState));
+            }
+            break;
+        }
+        case IDLE:
+        case WRITE_PENDING:
+        case WRITE_PENDING_BLOCKED_FLOW_CONNECTION:
+        case WRITE_PENDING_BLOCKED_FLOW_STREAMS:
+        case WRITE_PENDING_BLOCKED_IO:
+        case READ_IN_PROGRESS:
+            throw new IllegalStateException(
+                    sm.getString("writeStateMachine.ise", "endWrite", state));
+        }
+    }
+
+
+    /**
+     * @return <code>true</code> if there needs to be a dispatch for OPEN_WRITE
+     *         to trigger the actual write.
+     */
+    synchronized boolean addWrite() {
+        switch(state) {
+        case IDLE:
+        case READ_IN_PROGRESS:
+        case WRITE_PENDING_BLOCKED_FLOW_STREAMS: {
+            state = WriteState.WRITE_PENDING;
+            return true;
+        }
+        case WRITE_PENDING:
+        case WRITE_PENDING_BLOCKED_FLOW_CONNECTION:
+        case WRITE_PENDING_BLOCKED_IO:
+        case WRITING:
+            // NO-OP
+            return false;
+        }
+        // Never reaches here. This is just to keep the compiler happy.
+        return false;
+    }
+
+    static enum WriteState {
+        IDLE,
+        READ_IN_PROGRESS,
+        WRITE_PENDING,
+        WRITE_PENDING_BLOCKED_IO,
+        WRITE_PENDING_BLOCKED_FLOW_STREAMS,
+        WRITE_PENDING_BLOCKED_FLOW_CONNECTION,
+        WRITING
+    }
+}

Propchange: tomcat/trunk/java/org/apache/coyote/http2/WriteStateMachine.java
------------------------------------------------------------------------------
    svn:eol-style = native



---------------------------------------------------------------------
To unsubscribe, e-mail: dev-unsubscribe@tomcat.apache.org
For additional commands, e-mail: dev-help@tomcat.apache.org


Mime
View raw message