Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
/*
* 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.coyote.Response;
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.getIdAsString(), 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.getIdAsString(), Long.toString(timeout)));
}
waitFor(CONNECTION, timeout);
}
void waitForStreamNonBlocking() {
if (log.isDebugEnabled()) {
log.debug(sm.getString("windowAllocationManager.waitForNonBlocking.stream",
stream.getConnectionId(), stream.getIdAsString()));
}
waitForNonBlocking(STREAM);
}
void waitForConnectionNonBlocking() {
if (log.isDebugEnabled()) {
log.debug(sm.getString("windowAllocationManager.waitForNonBlocking.connection",
stream.getConnectionId(), stream.getIdAsString()));
}
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.getIdAsString()));
}
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.getIdAsString()));
}
}
}
private void notify(int notifyTarget) {
if (log.isDebugEnabled()) {
log.debug(sm.getString("windowAllocationManager.notify", stream.getConnectionId(),
stream.getIdAsString(), 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;
Response response = stream.getCoyoteResponse();
if (response != null) {
if (response.getWriteListener() == null) {
// Blocking, so use notify to release StreamOutputBuffer
if (log.isDebugEnabled()) {
log.debug(sm.getString("windowAllocationManager.notified",
stream.getConnectionId(), stream.getIdAsString()));
}
stream.notify();
} else {
// Non-blocking so dispatch
if (log.isDebugEnabled()) {
log.debug(sm.getString("windowAllocationManager.dispatched",
stream.getConnectionId(), stream.getIdAsString()));
}
response.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
response.action(ActionCode.DISPATCH_EXECUTE, null);
}
}
}
}
}
}
