Nio2Endpoint.Nio2SocketWrapper (Apache Tomcat 8.5.59 API Documentation)

java.lang.Object
- org.apache.tomcat.util.net.SocketWrapperBase<Nio2Channel>
- - org.apache.tomcat.util.net.Nio2Endpoint.Nio2SocketWrapper

Enclosing class:: Nio2Endpoint

public static class Nio2Endpoint.Nio2SocketWrapper
extends SocketWrapperBase<Nio2Channel>

Nested Class Summary
- Nested classes/interfaces inherited from class org.apache.tomcat.util.net.SocketWrapperBase
  SocketWrapperBase.BlockingMode, SocketWrapperBase.CompletionCheck, SocketWrapperBase.CompletionHandlerCall, SocketWrapperBase.CompletionState, SocketWrapperBase.OperationState<A>, SocketWrapperBase.VectoredIOCompletionHandler<A>

Field Summary
- Fields inherited from class org.apache.tomcat.util.net.SocketWrapperBase
  bufferedWriteSize, COMPLETE_READ, COMPLETE_READ_WITH_COMPLETION, COMPLETE_WRITE, COMPLETE_WRITE_WITH_COMPLETION, localAddr, localName, localPort, nonBlockingWriteBuffer, READ_DATA, readOperation, remoteAddr, remoteHost, remotePort, sm, socketBufferHandler, writeOperation

Constructor Summary

Constructors
Constructor and Description

Nio2Endpoint.Nio2SocketWrapper(Nio2Channel channel, Nio2Endpoint endpoint)

Constructors
Constructor and Description
`Nio2Endpoint.Nio2SocketWrapper(Nio2Channel channel, Nio2Endpoint endpoint)`

Method Summary

Methods
Modifier and Type	Method and Description
`boolean`	`awaitReadComplete(long timeout, TimeUnit unit)` If an asynchronous read operation is pending, this method will block until the operation completes, or the specified amount of time has passed.
`boolean`	`awaitWriteComplete(long timeout, TimeUnit unit)` If an asynchronous write operation is pending, this method will block until the operation completes, or the specified amount of time has passed.
`void`	`close()`
`SendfileDataBase`	`createSendfileData(String filename, long pos, long length)`
`void`	`doClientAuth(SSLSupport sslSupport)` Require the client to perform CLIENT-CERT authentication if it hasn't already done so.
`protected void`	`doWrite(boolean block, ByteBuffer from)` Write the contents of the ByteBuffer to the socket.
`protected void`	`flushBlocking()`
`protected boolean`	`flushNonBlocking()`
`Nio2Endpoint.SendfileData`	`getSendfileData()`
`SSLSupport`	`getSslSupport(String clientCertProvider)`
`boolean`	`hasAsyncIO()` Allows using NIO2 style read/write.
`boolean`	`hasDataToRead()`
`boolean`	`hasDataToWrite()`
`boolean`	`hasPerOperationTimeout()` Allows indicating if the connector supports per operation timeout.
`boolean`	`isClosed()`
`boolean`	`isReadPending()` Allows checking if an asynchronous read operation is currently pending.
`boolean`	`isReadyForRead()`
`boolean`	`isReadyForWrite()` Checks to see if there are any writes pending and if there are calls `SocketWrapperBase.registerWriteInterest()` to trigger a callback once the pending writes have completed.
`boolean`	`isWritePending()` Allows checking if an asynchronous write operation is currently pending.
`boolean`	`needSemaphores()` Allows indicating if the connector needs semaphores.
`protected <A> SocketWrapperBase.OperationState<A>`	`newOperationState(boolean read, ByteBuffer[] buffers, int offset, int length, SocketWrapperBase.BlockingMode block, long timeout, TimeUnit unit, A attachment, SocketWrapperBase.CompletionCheck check, CompletionHandler<Long,? super A> handler, Semaphore semaphore, SocketWrapperBase.VectoredIOCompletionHandler<A> completion)`
`protected void`	`populateLocalAddr()`
`protected void`	`populateLocalName()`
`protected void`	`populateLocalPort()`
`protected void`	`populateRemoteAddr()`
`protected void`	`populateRemoteHost()`
`protected void`	`populateRemotePort()`
`SendfileState`	`processSendfile(SendfileDataBase sendfileData)` Starts the sendfile process.
`int`	`read(boolean block, byte[] b, int off, int len)`
`int`	`read(boolean block, ByteBuffer to)`
`void`	`registerReadInterest()`
`void`	`registerWriteInterest()`
`void`	`setAppReadBufHandler(ApplicationBufferHandler handler)`
`void`	`setSendfileData(Nio2Endpoint.SendfileData sf)`
`protected void`	`writeNonBlocking(byte[] buf, int off, int len)` Transfers the data to the socket write buffer (writing that data to the socket if the buffer fills up using a non-blocking write) until either all the data has been transferred and space remains in the socket write buffer or a non-blocking write leaves data in the socket write buffer.
`protected void`	`writeNonBlocking(ByteBuffer from)` Transfers the data to the socket write buffer (writing that data to the socket if the buffer fills up using a non-blocking write) until either all the data has been transferred and space remains in the socket write buffer or a non-blocking write leaves data in the socket write buffer.
`protected void`	`writeNonBlockingInternal(ByteBuffer from)` Separate method so it can be re-used by the socket write buffer to write data to the network

Methods inherited from class org.apache.tomcat.util.net.SocketWrapperBase
buffersArrayHasRemaining, canWrite, checkError, decrementKeepAlive, doWrite, execute, flush, getEndpoint, getError, getLocalAddr, getLocalName, getLocalPort, getNegotiatedProtocol, getReadTimeout, getRemoteAddr, getRemoteHost, getRemotePort, getSocket, getSocketBufferHandler, getWriteTimeout, isSecure, isUpgraded, populateReadBuffer, populateReadBuffer, processSocket, read, read, read, setError, setKeepAliveLeft, setNegotiatedProtocol, setReadTimeout, setSecure, setUpgraded, setWriteTimeout, toString, transfer, transfer, unRead, vectoredOperation, write, write, write, write, write, writeBlocking, writeBlocking

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

- Constructor Detail
  - Nio2Endpoint.Nio2SocketWrapper
```
public Nio2Endpoint.Nio2SocketWrapper(Nio2Channel channel,
                              Nio2Endpoint endpoint)
```
- Method Detail
  - setSendfileData
```
public void setSendfileData(Nio2Endpoint.SendfileData sf)
```
  - getSendfileData
```
public Nio2Endpoint.SendfileData getSendfileData()
```
  - isReadyForRead
```
public boolean isReadyForRead()
                       throws IOException
```
    Specified by:
    
    isReadyForRead in class SocketWrapperBase<Nio2Channel>
    
    Throws:
    
    IOException
  - isReadyForWrite
```
public boolean isReadyForWrite()
```
    Description copied from class: SocketWrapperBase
    
    Checks to see if there are any writes pending and if there are calls SocketWrapperBase.registerWriteInterest() to trigger a callback once the pending writes have completed.
    Note: Once this method has returned false it MUST NOT be called again until the pending write has completed and the callback has been fired. TODO: Modify SocketWrapperBase.registerWriteInterest() so the above restriction is enforced there rather than relying on the caller.
    
    Overrides:
    
    isReadyForWrite in class SocketWrapperBase<Nio2Channel>
    
    Returns:
    true if no writes are pending and data can be written otherwise false
  - read
```
public int read(boolean block,
       byte[] b,
       int off,
       int len)
         throws IOException
```
    Specified by:
    
    read in class SocketWrapperBase<Nio2Channel>
    
    Throws:
    
    IOException
  - read
```
public int read(boolean block,
       ByteBuffer to)
         throws IOException
```
    Specified by:
    
    read in class SocketWrapperBase<Nio2Channel>
    
    Throws:
    
    IOException
  - close
```
public void close()
```
    Specified by:
    
    close in class SocketWrapperBase<Nio2Channel>
  - isClosed
```
public boolean isClosed()
```
    Specified by:
    
    isClosed in class SocketWrapperBase<Nio2Channel>
  - hasAsyncIO
```
public boolean hasAsyncIO()
```
    Description copied from class: SocketWrapperBase
    
    Allows using NIO2 style read/write.
    
    Overrides:
    
    hasAsyncIO in class SocketWrapperBase<Nio2Channel>
    
    Returns:
    true if the connector has the capability enabled
  - needSemaphores
```
public boolean needSemaphores()
```
    Description copied from class: SocketWrapperBase
    
    Allows indicating if the connector needs semaphores.
    
    Overrides:
    
    needSemaphores in class SocketWrapperBase<Nio2Channel>
    
    Returns:
    This default implementation always returns false
  - hasPerOperationTimeout
```
public boolean hasPerOperationTimeout()
```
    Description copied from class: SocketWrapperBase
    
    Allows indicating if the connector supports per operation timeout.
    
    Overrides:
    
    hasPerOperationTimeout in class SocketWrapperBase<Nio2Channel>
    
    Returns:
    This default implementation always returns false
  - newOperationState
```
protected <A> SocketWrapperBase.OperationState<A> newOperationState(boolean read,
                                                        ByteBuffer[] buffers,
                                                        int offset,
                                                        int length,
                                                        SocketWrapperBase.BlockingMode block,
                                                        long timeout,
                                                        TimeUnit unit,
                                                        A attachment,
                                                        SocketWrapperBase.CompletionCheck check,
                                                        CompletionHandler<Long,? super A> handler,
                                                        Semaphore semaphore,
                                                        SocketWrapperBase.VectoredIOCompletionHandler<A> completion)
```
    Specified by:
    
    newOperationState in class SocketWrapperBase<Nio2Channel>
  - writeNonBlocking
```
protected void writeNonBlocking(byte[] buf,
                    int off,
                    int len)
                         throws IOException
```
    Transfers the data to the socket write buffer (writing that data to the socket if the buffer fills up using a non-blocking write) until either all the data has been transferred and space remains in the socket write buffer or a non-blocking write leaves data in the socket write buffer. After an incomplete write, any data remaining to be transferred to the socket write buffer will be copied to the socket write buffer. If the remaining data is too big for the socket write buffer, the socket write buffer will be filled and the additional data written to the non-blocking write buffer.
    Overridden for NIO2 to enable a gathering write to be used to write all of the remaining data in a single additional write should a non-blocking write leave data in the buffer.
    
    Overrides:
    
    writeNonBlocking in class SocketWrapperBase<Nio2Channel>
    
    Parameters:
    buf - The byte array containing the data to be written
    off - The offset within the byte array of the data to be written
    len - The length of the data to be written
    
    Throws:
    
    IOException - If an IO error occurs during the write
  - writeNonBlocking
```
protected void writeNonBlocking(ByteBuffer from)
                         throws IOException
```
    Transfers the data to the socket write buffer (writing that data to the socket if the buffer fills up using a non-blocking write) until either all the data has been transferred and space remains in the socket write buffer or a non-blocking write leaves data in the socket write buffer. After an incomplete write, any data remaining to be transferred to the socket write buffer will be copied to the socket write buffer. If the remaining data is too big for the socket write buffer, the socket write buffer will be filled and the additional data written to the non-blocking write buffer.
    Overridden for NIO2 to enable a gathering write to be used to write all of the remaining data in a single additional write should a non-blocking write leave data in the buffer.
    
    Overrides:
    
    writeNonBlocking in class SocketWrapperBase<Nio2Channel>
    
    Parameters:
    from - The ByteBuffer containing the data to be written
    
    Throws:
    
    IOException - If an IO error occurs during the write
  - writeNonBlockingInternal
```
protected void writeNonBlockingInternal(ByteBuffer from)
                                 throws IOException
```
    Separate method so it can be re-used by the socket write buffer to write data to the network
    Overridden for NIO2 to enable a gathering write to be used to write all of the remaining data in a single additional write should a non-blocking write leave data in the buffer.
    
    Overrides:
    
    writeNonBlockingInternal in class SocketWrapperBase<Nio2Channel>
    
    Parameters:
    from - The ByteBuffer containing the data to be written
    
    Throws:
    
    IOException - If an IO error occurs during the write
  - doWrite
```
protected void doWrite(boolean block,
           ByteBuffer from)
                throws IOException
```
    Description copied from class: SocketWrapperBase
    
    Write the contents of the ByteBuffer to the socket. For blocking writes either then entire contents of the buffer will be written or an IOException will be thrown. Partial blocking writes will not occur.
    
    Specified by:
    
    doWrite in class SocketWrapperBase<Nio2Channel>
    
    Parameters:
    block - Ignored since this method is only called in the blocking case
    from - the ByteBuffer containing the data to be written
    
    Throws:
    
    IOException - If an I/O error such as a timeout occurs during the write
  - flushBlocking
```
protected void flushBlocking()
                      throws IOException
```
    Overrides:
    
    flushBlocking in class SocketWrapperBase<Nio2Channel>
    
    Throws:
    
    IOException
  - flushNonBlocking
```
protected boolean flushNonBlocking()
                            throws IOException
```
    Overrides:
    
    flushNonBlocking in class SocketWrapperBase<Nio2Channel>
    
    Throws:
    
    IOException
  - hasDataToRead
```
public boolean hasDataToRead()
```
    Overrides:
    
    hasDataToRead in class SocketWrapperBase<Nio2Channel>
  - hasDataToWrite
```
public boolean hasDataToWrite()
```
    Overrides:
    
    hasDataToWrite in class SocketWrapperBase<Nio2Channel>
  - isReadPending
```
public boolean isReadPending()
```
    Description copied from class: SocketWrapperBase
    
    Allows checking if an asynchronous read operation is currently pending.
    
    Overrides:
    
    isReadPending in class SocketWrapperBase<Nio2Channel>
    
    Returns:
    true if the endpoint supports asynchronous IO and a read operation is being processed asynchronously
  - isWritePending
```
public boolean isWritePending()
```
    Description copied from class: SocketWrapperBase
    
    Allows checking if an asynchronous write operation is currently pending.
    
    Overrides:
    
    isWritePending in class SocketWrapperBase<Nio2Channel>
    
    Returns:
    true if the endpoint supports asynchronous IO and a write operation is being processed asynchronously
  - awaitReadComplete
```
public boolean awaitReadComplete(long timeout,
                        TimeUnit unit)
```
    Description copied from class: SocketWrapperBase
    
    If an asynchronous read operation is pending, this method will block until the operation completes, or the specified amount of time has passed.
    
    Overrides:
    
    awaitReadComplete in class SocketWrapperBase<Nio2Channel>
    
    Parameters:
    timeout - The maximum amount of time to wait
    unit - The unit for the timeout
    
    Returns:
    true if the read operation is complete, false if the operation is still pending and the specified timeout has passed
  - awaitWriteComplete
```
public boolean awaitWriteComplete(long timeout,
                         TimeUnit unit)
```
    Description copied from class: SocketWrapperBase
    
    If an asynchronous write operation is pending, this method will block until the operation completes, or the specified amount of time has passed.
    
    Overrides:
    
    awaitWriteComplete in class SocketWrapperBase<Nio2Channel>
    
    Parameters:
    timeout - The maximum amount of time to wait
    unit - The unit for the timeout
    
    Returns:
    true if the read operation is complete, false if the operation is still pending and the specified timeout has passed
  - registerReadInterest
```
public void registerReadInterest()
```
    Specified by:
    
    registerReadInterest in class SocketWrapperBase<Nio2Channel>
  - registerWriteInterest
```
public void registerWriteInterest()
```
    Specified by:
    
    registerWriteInterest in class SocketWrapperBase<Nio2Channel>
  - createSendfileData
```
public SendfileDataBase createSendfileData(String filename,
                                  long pos,
                                  long length)
```
    Specified by:
    
    createSendfileData in class SocketWrapperBase<Nio2Channel>
  - processSendfile
```
public SendfileState processSendfile(SendfileDataBase sendfileData)
```
    Description copied from class: SocketWrapperBase
    
    Starts the sendfile process. It is expected that if the sendfile process does not complete during this call and does not report an error, that the caller will not add the socket to the poller (or equivalent). That is the responsibility of this method.
    
    Specified by:
    
    processSendfile in class SocketWrapperBase<Nio2Channel>
    
    Parameters:
    sendfileData - Data representing the file to send
    
    Returns:
    The state of the sendfile process after the first write.
  - populateRemoteAddr
```
protected void populateRemoteAddr()
```
    Specified by:
    
    populateRemoteAddr in class SocketWrapperBase<Nio2Channel>
  - populateRemoteHost
```
protected void populateRemoteHost()
```
    Specified by:
    
    populateRemoteHost in class SocketWrapperBase<Nio2Channel>
  - populateRemotePort
```
protected void populateRemotePort()
```
    Specified by:
    
    populateRemotePort in class SocketWrapperBase<Nio2Channel>
  - populateLocalName
```
protected void populateLocalName()
```
    Specified by:
    
    populateLocalName in class SocketWrapperBase<Nio2Channel>
  - populateLocalAddr
```
protected void populateLocalAddr()
```
    Specified by:
    
    populateLocalAddr in class SocketWrapperBase<Nio2Channel>
  - populateLocalPort
```
protected void populateLocalPort()
```
    Specified by:
    
    populateLocalPort in class SocketWrapperBase<Nio2Channel>
  - getSslSupport
```
public SSLSupport getSslSupport(String clientCertProvider)
```
    Specified by:
    
    getSslSupport in class SocketWrapperBase<Nio2Channel>
    
    Parameters:
    clientCertProvider - Ignored for this implementation
  - doClientAuth
```
public void doClientAuth(SSLSupport sslSupport)
                  throws IOException
```
    Description copied from class: SocketWrapperBase
    
    Require the client to perform CLIENT-CERT authentication if it hasn't already done so.
    
    Specified by:
    
    doClientAuth in class SocketWrapperBase<Nio2Channel>
    
    Parameters:
    sslSupport - The SSL/TLS support instance currently being used by the connection that may need updating after the client authentication
    
    Throws:
    
    IOException - If authentication is required then there will be I/O with the client and this exception will be thrown if that goes wrong
  - setAppReadBufHandler
```
public void setAppReadBufHandler(ApplicationBufferHandler handler)
```
    Specified by:
    
    setAppReadBufHandler in class SocketWrapperBase<Nio2Channel>

Class Nio2Endpoint.Nio2SocketWrapper

Nested Class Summary

Nested classes/interfaces inherited from class org.apache.tomcat.util.net.SocketWrapperBase

Field Summary

Fields inherited from class org.apache.tomcat.util.net.SocketWrapperBase

Constructor Summary

Method Summary

Methods inherited from class org.apache.tomcat.util.net.SocketWrapperBase

Methods inherited from class java.lang.Object

Constructor Detail

Nio2Endpoint.Nio2SocketWrapper

Method Detail

setSendfileData

getSendfileData

isReadyForRead

isReadyForWrite

read

read

close

isClosed

hasAsyncIO

needSemaphores

hasPerOperationTimeout

newOperationState

writeNonBlocking

writeNonBlocking

writeNonBlockingInternal

doWrite

flushBlocking

flushNonBlocking

hasDataToRead

hasDataToWrite

isReadPending

isWritePending

awaitReadComplete

awaitWriteComplete

registerReadInterest

registerWriteInterest

createSendfileData

processSendfile

populateRemoteAddr

populateRemoteHost

populateRemotePort

populateLocalName

populateLocalAddr

populateLocalPort

getSslSupport

doClientAuth

setAppReadBufHandler