apache-tomcat-8.5.51/java/org/apache/coyote/http2/WindowAllocationManager.java

/*
 *  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.coyote.ActionCode;
import org.apache.juli.logging.Log;
import org.apache.juli.logging.LogFactory;
import org.apache.tomcat.util.res.StringManager;

/**
 * Tracks whether the stream is waiting for an allocation to the stream flow
 * control window, to the connection flow control window or not waiting for an
 * allocation and only issues allocation notifications when the stream is known
 * to be waiting for the notification.
 *
 * It is possible for a stream to be waiting for a connection allocation when
 * a stream allocation is made. Therefore this class tracks the type of
 * allocation that the stream is waiting for to ensure that notifications are
 * correctly triggered.
 *
 * With the implementation at the time of writing, it is not possible for a
 * stream to receive an unexpected connection notification as these are only
 * issues to streams in the backlog and a stream must be waiting for a
 * connection allocation in order to be placed on the backlog. However, as a
 * precaution, this class protects against unexpected connection notifications.
 *
 * It is important for asynchronous processing not to notify unless a
 * notification is expected else a dispatch will be performed unnecessarily
 * which may lead to unexpected results.
 *
 * A previous implementation used separate locks for the stream and connection
 * notifications. However, correct handling of allocation waiting requires
 * holding the stream lock when making the decision to wait. Therefore both
 * allocations need to wait on the Stream.
 */
class WindowAllocationManager {

    private static final Log log = LogFactory.getLog(WindowAllocationManager.class);
    private static final StringManager sm = StringManager.getManager(WindowAllocationManager.class);

    private static final int NONE = 0;
    private static final int STREAM = 1;
    private static final int CONNECTION = 2;

    private final Stream stream;

    private int waitingFor = NONE;

    WindowAllocationManager(Stream stream) {
        this.stream = stream;
    }

    void waitForStream(long timeout) throws InterruptedException {
        if (log.isDebugEnabled()) {
            log.debug(sm.getString("windowAllocationManager.waitFor.stream",
                    stream.getConnectionId(), stream.getIdentifier(), Long.toString(timeout)));
        }

        waitFor(STREAM, timeout);
    }


    void waitForConnection(long timeout) throws InterruptedException {
        if (log.isDebugEnabled()) {
            log.debug(sm.getString("windowAllocationManager.waitFor.connection",
                    stream.getConnectionId(), stream.getIdentifier(), Long.toString(timeout)));
        }

        waitFor(CONNECTION, timeout);
    }


    void waitForStreamNonBlocking() {
        if (log.isDebugEnabled()) {
            log.debug(sm.getString("windowAllocationManager.waitForNonBlocking.stream",
                    stream.getConnectionId(), stream.getIdentifier()));
        }

        waitForNonBlocking(STREAM);
    }


    void waitForConnectionNonBlocking() {
        if (log.isDebugEnabled()) {
            log.debug(sm.getString("windowAllocationManager.waitForNonBlocking.connection",
                    stream.getConnectionId(), stream.getIdentifier()));
        }

        waitForNonBlocking(CONNECTION);
    }


    void notifyStream() {
        notify(STREAM);
    }


    void notifyConnection() {
        notify(CONNECTION);
    }


    void notifyAny() {
        notify(STREAM | CONNECTION);
    }


    boolean isWaitingForStream() {
        return isWaitingFor(STREAM);
    }


    boolean isWaitingForConnection() {
        return isWaitingFor(CONNECTION);
    }


    private boolean isWaitingFor(int waitTarget) {
        synchronized (stream) {
            return (waitingFor & waitTarget) > 0;
        }
    }


    private void waitFor(int waitTarget, long timeout) throws InterruptedException {
        synchronized (stream) {
            if (waitingFor != NONE) {
                throw new IllegalStateException(sm.getString("windowAllocationManager.waitFor.ise",
                        stream.getConnectionId(), stream.getIdentifier()));
            }

            waitingFor = waitTarget;

            if (timeout < 0) {
                stream.wait();
            } else {
                stream.wait(timeout);
            }
        }
    }


    private void waitForNonBlocking(int waitTarget) {
        synchronized (stream) {
            if (waitingFor == NONE) {
                waitingFor = waitTarget;
            } else if (waitingFor == waitTarget) {
                // NO-OP
                // Non-blocking post-processing may attempt to flush
            } else {
                throw new IllegalStateException(sm.getString("windowAllocationManager.waitFor.ise",
                        stream.getConnectionId(), stream.getIdentifier()));
            }

        }
    }


    private void notify(int notifyTarget) {
        if (log.isDebugEnabled()) {
            log.debug(sm.getString("windowAllocationManager.notify", stream.getConnectionId(),
                    stream.getIdentifier(), Integer.toString(waitingFor), Integer.toString(notifyTarget)));
        }

        synchronized (stream) {
            if ((notifyTarget & waitingFor) > NONE) {
                // Reset this here so multiple notifies (possible with a
                // backlog containing multiple streams and small window updates)
                // are handled correctly (only the first should trigger a call
                // to stream.notify(). Additional notify() calls may trigger
                // unexpected timeouts.
                waitingFor = NONE;
                if (stream.getCoyoteResponse().getWriteListener() == null) {
                    // Blocking, so use notify to release StreamOutputBuffer
                    if (log.isDebugEnabled()) {
                        log.debug(sm.getString("windowAllocationManager.notified",
                                stream.getConnectionId(), stream.getIdentifier()));
                    }
                    stream.notify();
                } else {
                    // Non-blocking so dispatch
                    if (log.isDebugEnabled()) {
                        log.debug(sm.getString("windowAllocationManager.dispatched",
                                stream.getConnectionId(), stream.getIdentifier()));
                    }
                    stream.getCoyoteResponse().action(ActionCode.DISPATCH_WRITE, null);
                    // Need to explicitly execute dispatches on the StreamProcessor
                    // as this thread is being processed by an UpgradeProcessor
                    // which won't see this dispatch
                    stream.getCoyoteResponse().action(ActionCode.DISPATCH_EXECUTE, null);
                }
            }
        }
    }
}