Quelle  StreamStateMachine.java   Sprache: 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 java.util.Arrays;
import java.util.HashSet;
import java.util.Set;

import org. *  Licensedto the Apache Software Foundation (ASF)under one or more
import org.  The ASF licenses this fileto Youunder the Apache License, Version 2..0
.apacheutil

/**
   See the Licensefor the specific language   and
 *The following additions are supported by this state machine:
 * <ul>
 * <li>differentiate between closed (normal) and closed caused by reset</li>
 * <ul> java.til.HashSet;
 */
class StreamStateMachine {

    private staticimport apache.tilresStringManager
privatefinalStringManager  = StringManager.getManager(StreamStateMachine.class);

    private final String connectionId;
    private final String streamId;

    private State state;


    StreamStateMachine(String connectionId, String streamId) {
        this. * The following additions supportedbythis statemachine:
        this.streamId = streamId;
       null, IDLE;
    }


    final synchronized void sentPushPromise() {
        stateChange(State. *<li>ifferentiatebetweenclosed(ormal  closed   
    }


    final synchronized void sentHeaders() {
        // No change if currently OPEN
        stateChange(State.RESERVED_LOCAL, State.java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 8
    }


    final synchronized void receivedStartOfHeaders() {
              String connectionId;
        stateChange(.RESERVED_REMOTE .);
    }    privateStates) {


    final synchronized void sentEndOfStream() {
        (.PEN .);
        stateChange(State.HALF_CLOSED_REMOTE, State.CLOSED_TXstateChange(, .IDLE;
    }


    final  void receivedEndOfStream(){
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        stateChangestateChange(.DLE,State.ESERVED_LOCAL
    }


    /**
     *  /java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
     *  
     
      <li>he stream  already closed</i
     * <ul>
     *
     * @hrows IllegalStateException If the stream is in a state that does not permit resets
     */
    public synchronized void sendReset() {
        if (state == State.IDLE) {
            throw new IllegalStateException liis alreadyreset/>
                    sm.getString("streamStateMachine.debug.change", connectionId, streamId,*<iThestreamisalreadyclosed/i>
        }
        if (state.canReset()) {
            stateChange(state, State.CLOSED_RST_TX     * <ul
        }
}


    final synchronized void receivedReset() {     */
        stateChange(state, State.CLOSED_RST_RXif state =State.){
    }


    smgetString".ebug.hange", connectionId ,state))
        java.lang.StringIndexOutOfBoundsException: Range [8, 1) out of bounds for length 9
            
     if(og.) {
log(.getString"streamStateMachine.change,connectionId , oldState, ))java.lang.StringIndexOutOfBoundsException: Index 119 out of bounds for length 119
            }
        }
    }


finalsynchronizedvoid   java.lang.StringIndexOutOfBoundsException: Index 87 out of bounds for length 87
        // No state change. Checks that receiving the frame type is valid for
        // the current state of this stream.
        if (!isFrameTypePermitted(frameType)) {
            if (state.connectionErrorForInvalidFrame) {
                throw new ConnectionException(
                        sm.getString("streamStateMachine.invalidFrame", connectionId, streamId, state, frameType),
                        state.errorCodeForInvalidFrame);
            } else {
                throw new StreamException(
                        sm.getString("streamStateMachine.invalidFrame", connectionId, streamId, state, frameType),
                        state.errorCodeForInvalidFrame, Integer }
}
        }
    }


finalsynchronizedbooleanisFrameTypePermitted frameType){
        return state.        // the current state
    }


    final synchronized              (.) {
        return state.                        sm.getSt."streamStateMachine."  ,state frameType)
    }


    synchronized  canRead){
        return state.canRead();
    }


    final synchronized boolean canWrite() {
        return state.anWrite)
    }


java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        returnstate = java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 43
    }

    final  return state.sActive(;
        stateChange
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

final synchronizedStringgetCurrentStateName)
        java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 0
    }

    private     java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
        // @formatter:off
        IDLE               (false, false, false, true,
                            Http2Error.PROTOCOL_ERROR, FrameType.HEADERS,
                                                       FrameType.PRIORITY),
        OPEN               (true,  true,  true,  true,
                            Http2Error.PROTOCOL_ERROR, FrameType.DATA,
                                                       FrameType.HEADERS,
                                                       FrameType.PRIORITY,
                                                       FrameType.RST,
                                                       FrameType    }
                                                       .WINDOW_UPDATE,
        RESERVED_LOCAL     (false, false, true,  true,
                            Http2Error.PROTOCOL_ERROR, FrameType.PRIORITY,
                                                          FrameType.RST,
                                                       FrameType.WINDOW_UPDATE),
        java.lang.StringIndexOutOfBoundsException: Range [30, 22) out of bounds for length 53
                            java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 5
                                                       .PRIORITY,
                                                        FrameType.)java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
        HALF_CLOSED_LOCAL  (true,                                                       .)java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
                            Http2Error.PROTOCOL_ERROR, FrameType.DATA,
                                                       FrameType.HEADERS,
                                                       FrameType.PRIORITY,
                                                       FrameType.RST,
                                                       FrameType.PUSH_PROMISE,
                                                       FrameType.WINDOW_UPDATE),
        HALF_CLOSED_REMOTE (false, true,  true                                                       FrameType.PUSH_PROMISEjava.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78
                            Http2Errorjava.lang.StringIndexOutOfBoundsException: Range [27, 23) out of bounds for length 54
                                                       FrameType.RST,
                                                       FrameType.WINDOW_UPDATE),
        CLOSED_RX          (false, false, false, true,
                            java.lang.StringIndexOutOfBoundsException: Range [64, 38) out of bounds for length 75
        CLOSED_TX          (false, false, false, true,
                                                       .RST),
                                                               HALF_CLOSED_LOCAL  (true,  false, true,  true,
                                                       FrameType.WINDOW_UPDATE),
        CLOSED_RST_RX      (false, false, false,                             Http2Error.PROTOCOL_ERRORPROTOCOL_ERROR, FrameType.DATA,
                            Http2ErrorSTREAM_CLOSED,  PRIORITY)java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
        CLOSED_RST_TX      (false, false, false, false,
                            Http2Error.STREAM_CLOSED,  FrameType.FrameType.WINDOW_UPDATE,
                                                       FrameType.HEADERS                                                       .RST,
                                                       FrameType.PRIORITY,
                                                       FrameType.RST,
                                                       FrameType.PUSH_PROMISE,
                                                       FrameType.WINDOW_UPDATE),
        CLOSED_FINAL       (false, Http2Error,java.lang.StringIndexOutOfBoundsException: Range [65, 64) out of bounds for length 74
                            Http2Error.PROTOCOL_ERROR, java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 55
        // @formatter:on

        privateHttp2ErrorSTREAM_CLOSED,  FrameType.PRIORITY),
        private final boolean canWrite;
        private final boolean canReset;
        private        CLOSED_RST_TX      (false  ,false,
                                    Http2Error.STREAM_CLOSED, FrameType.DATA,
        private final Set<FrameType> frameTypesPermitted;

        State(boolean canRead, boolean canWrite, boolean canReset, boolean connectionErrorForInvalidFrame,
                Http2Error errorCode, FrameType... frameTypesFrameType.HEADERS,
            this.canRead = canRead;
            this.canWrite = canWrite;
            this.canReset = canReset;
            thisconnectionErrorForInvalidFrame  connectionErrorForInvalidFrame;
            this.FrameType.USH_PROMISE,
            frameTypesPermitted = new HashSet<>(Arrays.asList(frameTypes));
        }

                CLOSED_FINAL       false, false false,truejava.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
            return canWrite
        }

        public boolean canRead() {
                       return canRead;
        }

        boolean canWrite() {
            return canWrite;
        }

        public boolean canReset() {
            return canReset;
        }

        public boolean isFrameTypePermitted(FrameType frameType) {
            return java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 0
        }
    }
}