import io.undertow.server.ServerConnection; //导入依赖的package包/类
public HttpServerConnection(StreamConnection channel, final Pool<ByteBuffer> bufferPool, final HttpHandler rootHandler, final OptionMap undertowOptions, final int bufferSize) {
    super(channel, bufferPool, rootHandler, undertowOptions, bufferSize);
    if (channel instanceof SslChannel) {
        sslSessionInfo = new ConnectionSSLSessionInfo(((SslChannel) channel), this);
    }
    this.responseConduit = new HttpResponseConduit(channel.getSinkChannel().getConduit(), bufferPool);

    fixedLengthStreamSinkConduit = new ServerFixedLengthStreamSinkConduit(responseConduit, false, false);
    readDataStreamSourceConduit = new ReadDataStreamSourceConduit(channel.getSourceChannel().getConduit(), this);
    //todo: do this without an allocation
    addCloseListener(new CloseListener() {
        @Override
        public void closed(ServerConnection connection) {
            responseConduit.freeBuffers();
        }
    });
}
 

import io.undertow.server.ServerConnection; //导入依赖的package包/类
@Override
public void completed(final ClientConnection connection) {
    final ServerConnection serverConnection = exchange.getConnection();
    //we attach to the connection so it can be re-used
    serverConnection.putAttachment(clientAttachmentKey, connection);
    serverConnection.addCloseListener(serverConnection1 -> IoUtils.safeClose(connection));
    connection.getCloseSetter().set((ChannelListener<Channel>) channel -> serverConnection.removeAttachment(clientAttachmentKey));

    exchange.setRelativePath("/");
    Realm realm = realmCache.matches(exchange.getRequestPath());
    Application application = realmCache.getApplication(realm);
    String path = exchange.getRequestURI();
    if (path.startsWith(application.getVirtualPath())) {
        String passTo = calculatePathTo(path, application);
        exchange.setRequestPath(passTo);
        exchange.setRequestURI(passTo);
    }
    callback.completed(exchange, new ProxyConnection(connection, "/"));
}
 

import io.undertow.server.ServerConnection; //导入依赖的package包/类
@Before
public void setUp() {
  sut = new GreetingController();
  connection = mock(ServerConnection.class);

  exchange = mock(HttpServerExchange.class);
  request = mock(HttpServletRequestImpl.class);
  pushBuilder = mock(PushBuilder.class);

  when(exchange.getConnection()).thenReturn(connection);
  when(exchange.getRequestHeaders()).thenReturn(new HeaderMap());
  when(request.getExchange()).thenReturn(exchange);

}
 

import io.undertow.server.ServerConnection; //导入依赖的package包/类
@Override
public AuthenticationMechanismOutcome authenticate(final HttpServerExchange exchange,
                                                   final SecurityContext securityContext) {
    ServerConnection connection = exchange.getConnection();
    NegotiationContext negContext = connection.getAttachment(NegotiationContext.ATTACHMENT_KEY);
    if (negContext != null) {
        exchange.putAttachment(NegotiationContext.ATTACHMENT_KEY, negContext);
        if (negContext.isEstablished()) {
            IdentityManager identityManager = securityContext.getIdentityManager();
            final Account account = identityManager.verify(new GSSContextCredential(negContext.getGssContext()));
            if (account != null) {
                securityContext.authenticationComplete(account, name, false);
                return AuthenticationMechanismOutcome.AUTHENTICATED;
            } else {
                return AuthenticationMechanismOutcome.NOT_AUTHENTICATED;
            }
        }
    }

    List<String> authHeaders = exchange.getRequestHeaders().get(AUTHORIZATION);
    if (authHeaders != null) {
        for (String current : authHeaders) {
            if (current.startsWith(NEGOTIATE_PREFIX)) {
                String base64Challenge = current.substring(NEGOTIATE_PREFIX.length());
                try {
                    ByteBuffer challenge = FlexBase64.decode(base64Challenge);
                    return runGSSAPI(exchange, challenge, securityContext);
                } catch (IOException e) {
                }

                // By this point we had a header we should have been able to verify but for some reason
                // it was not correctly structured.
                return AuthenticationMechanismOutcome.NOT_AUTHENTICATED;
            }
        }
    }

    // No suitable header was found so authentication was not even attempted.
    return AuthenticationMechanismOutcome.NOT_ATTEMPTED;
}
 

import io.undertow.server.ServerConnection; //导入依赖的package包/类
@Override
public void closed(ServerConnection connection) {
    if(handle != null) {
        handle.remove();
        handle = null;
    }
}
 

import io.undertow.server.ServerConnection; //导入依赖的package包/类
@Override
public void completed(final ClientConnection connection) {
    final ServerConnection serverConnection = exchange.getConnection();
    //we attach to the connection so it can be re-used
    serverConnection.putAttachment(clientAttachmentKey, connection);
    serverConnection.addCloseListener(serverConnection1 -> IoUtils.safeClose(connection));
    connection.getCloseSetter().set(channel -> serverConnection.removeAttachment(clientAttachmentKey));
    callback.completed(exchange, new ProxyConnection(connection, ""));
}
 

import io.undertow.server.ServerConnection; //导入依赖的package包/类
public void send(final ReadableByteChannel source, final HttpServerExchange exchange,
        final IoCallback callback) {
    this.source = source;
    this.exchange = exchange;
    this.callback = callback;
    this.sender = exchange.getResponseSender();
    ServerConnection connection = exchange.getConnection();
    this.pooled = connection.getByteBufferPool().allocate();
    this.bufferSize = connection.getBufferSize();

    onComplete(exchange, sender);
}
 

import io.undertow.server.ServerConnection; //导入依赖的package包/类
public void send(final ReadableByteChannel source, final HttpServerExchange exchange,
    final IoCallback callback) {
  this.source = source;
  this.exchange = exchange;
  this.callback = callback;
  this.sender = exchange.getResponseSender();
  ServerConnection connection = exchange.getConnection();
  this.pooled = connection.getByteBufferPool().allocate();
  this.bufferSize = connection.getBufferSize();

  onComplete(exchange, sender);
}
 

import io.undertow.server.ServerConnection; //导入依赖的package包/类
public UndertowHttpChannel(final HttpServerExchange exchange,
                           final OnOpen onOpen,
                           final OnError onError,
                           final OnClose onClose) {
    super(Methods.HEAD.equals(exchange.getRequestMethod()), onOpen, onError, onClose);
    this.exchange = exchange.setPersistent(true).dispatch();
    this.exchange.getConnection().addCloseListener(new ServerConnection.CloseListener() {
        @Override
        public void closed(ServerConnection _) {
            notifyClose();
        }
    });
}
 

import io.undertow.server.ServerConnection; //导入依赖的package包/类
@LogMessage(level = Logger.Level.ERROR)
@Message(id = 5018, value = "Exception invoking close listener %s")
void exceptionInvokingCloseListener(ServerConnection.CloseListener l, @Cause Throwable e);
 

import io.undertow.server.ServerConnection; //导入依赖的package包/类
/**
 * Creates new instance of ParseTimeoutSourceConduit.
 *  @param channel             Channel which will be closed in case of timeout.
 * @param requestParseTimeout Timeout value. Negative value will indicate that this updated is disabled.
 * @param requestIdleTimeout
 */
public ParseTimeoutUpdater(ServerConnection channel, long requestParseTimeout, long requestIdleTimeout) {
    this.connection = channel;
    this.requestParseTimeout = requestParseTimeout;
    this.requestIdleTimeout = requestIdleTimeout;
}