com.sun.grizzly
Class SSLConnectorHandler

java.lang.Object
  extended by com.sun.grizzly.SSLConnectorHandler
All Implemented Interfaces:
AsyncQueueReadable, AsyncQueueWritable, ConnectorHandler<SSLSelectorHandler,SSLCallbackHandler>, Handler, Closeable

public class SSLConnectorHandler
extends Object
implements ConnectorHandler<SSLSelectorHandler,SSLCallbackHandler>, AsyncQueueWritable, AsyncQueueReadable

Non blocking SSL Connector Handler. The recommended way to use this class is by creating an external Controller and share the same SelectorHandler instance.

Recommended -----------


 Controller controller = new Controller();
 // new SSLSelectorHandler(true) means the Selector will be used only
 // for client operation (OP_READ, OP_WRITE, OP_CONNECT).
 SSLSelectorHandler sslSelectorHandler = new SSLSelectorHandler(true);
 controller.setSelectorHandler(sslSelectorHandler);
 SSLConnectorHandler sslConnectorHandler = new SSLConnectorHandler();
 sslConnectorHandler.connect(localhost,port, new SSLCallbackHandler(){...},
                             sslSelectorHandler);
 SSLConnectorHandler sslConnectorHandler2 = new SSLConnectorHandler();
 sslConnectorHandler2.connect(localhost,port, new SSLCallbackHandler(){...},
                             sslSelectorHandler);
 

Not recommended (but still works) ---------------------------------


 SSLConnectorHandler sslConnectorHandler = new SSLConnectorHandler();
 sslConnectorHandler.connect(localhost,port);

 Internally, an new Controller will be created everytime connect(localhost,port)
 is invoked, which has an impact on performance.

 As common comment: developer should be very careful if dealing directly with
 SSLConnectorHandler's underlying socket channel! In most cases
 there is no need to do this, but use read, write methods provided
 by SSLConnectorHandler
 

Author:
Alexey Stashok, Jeanfrancois Arcand

Field Summary
protected  SSLSelectorHandler selectorHandler
          The underlying SSLSelectorHandler used to mange SelectionKeys.
 
Constructor Summary
SSLConnectorHandler()
           
SSLConnectorHandler(SSLConfig sslConfig)
           
SSLConnectorHandler(SSLContext sslContext)
           
 
Method Summary
 void close()
          Close the underlying connection.
 void configure(SSLConfig sslConfig)
          Configure SSLConnectorHandler's SSL settings.
 void connect(SocketAddress remoteAddress)
          Connect to hostname:port.
 void connect(SocketAddress remoteAddress, SocketAddress localAddress)
          Connect to hostname:port.
 void connect(SocketAddress remoteAddress, SocketAddress localAddress, SSLCallbackHandler callbackHandler)
          Connect to hostname:port.
 void connect(SocketAddress remoteAddress, SocketAddress localAddress, SSLCallbackHandler callbackHandler, SSLSelectorHandler selectorHandler)
          Connect to hostname:port.
 void connect(SocketAddress remoteAddress, SSLCallbackHandler callbackHandler)
          Connect to hostname:port.
 void connect(SocketAddress remoteAddress, SSLCallbackHandler callbackHandler, SSLSelectorHandler selectorHandler)
          Connect to hostname:port.
 void finishConnect(SelectionKey key)
          Finish handling the OP_CONNECT interest ops.
 void finishHandshake()
          Changes SSLConnectorHandler state, after handshake operation is done.
 int getApplicationBufferSize()
          Gets the size of the largest application buffer that may occur when using this session.
 SSLCallbackHandler getCallbackHandler()
          Return the CallbackHandler.
 Controller getController()
          Return the Controller
 boolean getDelegateSSLTasks()
           
 ByteBuffer getSecuredInputBuffer()
          Returns SSLConnectorHandler's secured input buffer, it uses for reading data from a socket channel.
 ByteBuffer getSecuredOutputBuffer()
          Returns SSLConnectorHandler's secured output buffer, it uses for writing data to a socket channel.
 SSLSelectorHandler getSelectorHandler()
          Return the associated SelectorHandler.
 SSLContext getSSLContext()
          Get SSLConnector's SSLContext
 SSLEngine getSSLEngine()
          Returns SSLConnector'sSSLEngine
 SelectableChannel getUnderlyingChannel()
          Return the current SocketChannel used.
 boolean handshake(ByteBuffer byteBuffer, boolean blocking)
          Initiate SSL handshake phase.
 boolean isConnected()
          Is the underlying SocketChannel connected.
 boolean isHandshakeDone()
          Is the underlying SocketChannel connected.
 Controller.Protocol protocol()
          A token decribing the protocol supported by an implementation of this interface
 long read(ByteBuffer byteBuffer, boolean blocking)
          Read bytes.
 Future<AsyncQueueReadUnit> readFromAsyncQueue(ByteBuffer buffer, AsyncReadCallbackHandler callbackHandler)
          Method reads data to the ByteBuffer using async read queue.
 Future<AsyncQueueReadUnit> readFromAsyncQueue(ByteBuffer buffer, AsyncReadCallbackHandler callbackHandler, AsyncReadCondition condition)
          Method reads data to the ByteBuffer using async read queue.
 Future<AsyncQueueReadUnit> readFromAsyncQueue(ByteBuffer buffer, AsyncReadCallbackHandler callbackHandler, AsyncReadCondition condition, AsyncQueueDataProcessor readPostProcessor)
          Method reads data to the ByteBuffer using async read queue.
 void setCallbackHandler(SSLCallbackHandler callbackHandler)
          Set the CallbackHandler.
 void setController(Controller controller)
          Set the Controller to use with this instance.
 void setDelegateSSLTasks(boolean delegateSSLTasks)
           
 void setSSLContext(SSLContext sslContext)
          Set SSLContext.
 void setSSLEngine(SSLEngine sslEngine)
          SetSSLEngine
protected  void setUnderlyingChannel(SocketChannel socketChannel)
          Set the SocketChannel.
 long write(ByteBuffer byteBuffer, boolean blocking)
          Writes bytes.
 Future<AsyncQueueWriteUnit> writeToAsyncQueue(ByteBuffer buffer)
          Method writes ByteBuffer using async write queue.
 Future<AsyncQueueWriteUnit> writeToAsyncQueue(ByteBuffer buffer, AsyncWriteCallbackHandler callbackHandler)
          Method writes ByteBuffer using async write queue.
 Future<AsyncQueueWriteUnit> writeToAsyncQueue(ByteBuffer buffer, AsyncWriteCallbackHandler callbackHandler, AsyncQueueDataProcessor writePreProcessor)
          Method writes ByteBuffer using async write queue.
 Future<AsyncQueueWriteUnit> writeToAsyncQueue(ByteBuffer buffer, AsyncWriteCallbackHandler callbackHandler, AsyncQueueDataProcessor writePreProcessor, ByteBufferCloner cloner)
          Method writes ByteBuffer using async write queue.
 Future<AsyncQueueWriteUnit> writeToAsyncQueue(SocketAddress dstAddress, ByteBuffer buffer)
          Method sends ByteBuffer using async write queue.
 Future<AsyncQueueWriteUnit> writeToAsyncQueue(SocketAddress dstAddress, ByteBuffer buffer, AsyncWriteCallbackHandler callbackHandler)
          Method sends ByteBuffer using async write queue.
 Future<AsyncQueueWriteUnit> writeToAsyncQueue(SocketAddress dstAddress, ByteBuffer buffer, AsyncWriteCallbackHandler callbackHandler, AsyncQueueDataProcessor writePreProcessor)
          Method sends ByteBuffer using async write queue.
 Future<AsyncQueueWriteUnit> writeToAsyncQueue(SocketAddress dstAddress, ByteBuffer buffer, AsyncWriteCallbackHandler callbackHandler, AsyncQueueDataProcessor writePreProcessor, ByteBufferCloner cloner)
          Method sends ByteBuffer using async write queue.
 
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
 

Field Detail

selectorHandler

protected SSLSelectorHandler selectorHandler
The underlying SSLSelectorHandler used to mange SelectionKeys.

Constructor Detail

SSLConnectorHandler

public SSLConnectorHandler()

SSLConnectorHandler

public SSLConnectorHandler(SSLConfig sslConfig)

SSLConnectorHandler

public SSLConnectorHandler(SSLContext sslContext)
Method Detail

getDelegateSSLTasks

public boolean getDelegateSSLTasks()

setDelegateSSLTasks

public void setDelegateSSLTasks(boolean delegateSSLTasks)

connect

public void connect(SocketAddress remoteAddress,
                    SSLCallbackHandler callbackHandler)
             throws IOException
Connect to hostname:port. When an aysnchronous event happens (e.g OP_READ or OP_WRITE), the Controller will invoke the CallbackHandler.

Specified by:
connect in interface ConnectorHandler<SSLSelectorHandler,SSLCallbackHandler>
Parameters:
remoteAddress - remote address to connect
callbackHandler - the handler invoked by its associated SelectorHandler when a non blocking operation is ready to be handled. When null, all read and write operation will be delegated to the default ProtocolChain and its list of ProtocolFilter . When null, this ConnectorHandler will create an instance of DefaultCallbackHandler.
Throws:
IOException

connect

public void connect(SocketAddress remoteAddress,
                    SocketAddress localAddress,
                    SSLCallbackHandler callbackHandler)
             throws IOException
Connect to hostname:port. When an aysnchronous event happens (e.g OP_READ or OP_WRITE), the Controller will invoke the CallbackHandler.

Specified by:
connect in interface ConnectorHandler<SSLSelectorHandler,SSLCallbackHandler>
Parameters:
remoteAddress - remote address to connect
localAddress - local address to bind
callbackHandler - the handler invoked by its associated SelectorHandler when a non blocking operation is ready to be handled. When null, all read and write operation will be delegated to the default ProtocolChain and its list of ProtocolFilter . When null, this ConnectorHandler will create an instance of DefaultCallbackHandler.
Throws:
IOException

connect

public void connect(SocketAddress remoteAddress,
                    SSLCallbackHandler callbackHandler,
                    SSLSelectorHandler selectorHandler)
             throws IOException
Connect to hostname:port. When an aysnchronous event happens (e.g OP_READ or OP_WRITE), the Controller will invoke the CallbackHandler.

Specified by:
connect in interface ConnectorHandler<SSLSelectorHandler,SSLCallbackHandler>
Parameters:
remoteAddress - remote address to connect
callbackHandler - the handler invoked by the Controller when an non blocking operation is ready to be handled.
selectorHandler - an instance of SelectorHandler.
Throws:
IOException

connect

public void connect(SocketAddress remoteAddress,
                    SocketAddress localAddress,
                    SSLCallbackHandler callbackHandler,
                    SSLSelectorHandler selectorHandler)
             throws IOException
Connect to hostname:port. When an aysnchronous event happens (e.g OP_READ or OP_WRITE), the Controller will invoke the CallbackHandler.

Specified by:
connect in interface ConnectorHandler<SSLSelectorHandler,SSLCallbackHandler>
Parameters:
remoteAddress - remote address to connect
localAddress - local address to bin
callbackHandler - the handler invoked by its associated SelectorHandler when a non blocking operation is ready to be handled. When null, all read and write operation will be delegated to the default ProtocolChain and its list of ProtocolFilter . When null, this ConnectorHandler will create an instance of DefaultCallbackHandler.
selectorHandler - an instance of SelectorHandler.
Throws:
IOException

connect

public void connect(SocketAddress remoteAddress)
             throws IOException
Connect to hostname:port. Internally an instance of Controller and its default SelectorHandler will be created everytime this method is called. This method should be used only and only if no external Controller has been initialized.

Specified by:
connect in interface ConnectorHandler<SSLSelectorHandler,SSLCallbackHandler>
Parameters:
remoteAddress - remote address to connect
Throws:
IOException

connect

public void connect(SocketAddress remoteAddress,
                    SocketAddress localAddress)
             throws IOException
Connect to hostname:port. Internally an instance of Controller and its default SelectorHandler will be created everytime this method is called. This method should be used only and only if no external Controller has been initialized.

Specified by:
connect in interface ConnectorHandler<SSLSelectorHandler,SSLCallbackHandler>
Parameters:
remoteAddress - remote address to connect
localAddress - local address to bin
Throws:
IOException

handshake

public boolean handshake(ByteBuffer byteBuffer,
                         boolean blocking)
                  throws IOException
Initiate SSL handshake phase. Handshake is required to be done after connection established.

Parameters:
byteBuffer - Application ByteBuffer, where application data will be stored
blocking - true, if handshake should be done in blocking mode, for non-blocking false
Returns:
If blocking parameter is true - method should always return true if handshake is done, or throw IOException otherwise. For non-blocking mode method returns true if handshake is done, or false if handshake will be completed in non-blocking manner. If False returned - SSLConnectorHandler will call callbackHandler.onHandshake() to notify about finishing handshake phase.
Throws:
IOException - if some error occurs during processing I/O operations/

read

public long read(ByteBuffer byteBuffer,
                 boolean blocking)
          throws IOException
Read bytes. If blocking is set to true, a pool of temporary Selector will be used to read bytes.

Specified by:
read in interface ConnectorHandler<SSLSelectorHandler,SSLCallbackHandler>
Parameters:
byteBuffer - The byteBuffer to store bytes.
blocking - true if a a pool of temporary Selector is required to handle a blocking read.
Returns:
number of bytes read from a channel. Be careful, because return value represents the length of encrypted data, which was read from a channel. Don't use return value to determine the availability of a decrypted data to process, but use byteBuffer.remaining().
Throws:
IOException

write

public long write(ByteBuffer byteBuffer,
                  boolean blocking)
           throws IOException
Writes bytes. If blocking is set to true, a pool of temporary Selector will be used to writes bytes.

Specified by:
write in interface ConnectorHandler<SSLSelectorHandler,SSLCallbackHandler>
Parameters:
byteBuffer - The byteBuffer to write.
blocking - true if a a pool of temporary Selector is required to handle a blocking write.
Returns:
number of bytes written on a channel. Be careful, as non-crypted data is passed, but crypted data is written on channel. Don't use return value to determine the number of bytes from original buffer, which were written.
Throws:
IOException

readFromAsyncQueue

public Future<AsyncQueueReadUnit> readFromAsyncQueue(ByteBuffer buffer,
                                                     AsyncReadCallbackHandler callbackHandler)
                                              throws IOException
Method reads data to the ByteBuffer using async read queue. First, if read queue is empty - it tries to read to the ByteBuffer directly (without putting to the queue). If associated read queue is not empty or after direct reading ByteBuffer still has remaining place for next read - ByteBuffer will be added to AsyncQueue. If an exception occurs, during direct reading - it will be propagated to the caller directly, otherwise, if the ByteBuffer is added to a reading queue - exception notification will come via AsyncReadCallbackHandler.onIOException()

Specified by:
readFromAsyncQueue in interface AsyncQueueReadable
Parameters:
buffer - ByteBuffer
callbackHandler - AsyncReadCallbackHandler, which will get notified, when ByteBuffer will get full
Returns:
true, if ByteBuffer was read completely, false if read operation was put to queue
Throws:
IOException

readFromAsyncQueue

public Future<AsyncQueueReadUnit> readFromAsyncQueue(ByteBuffer buffer,
                                                     AsyncReadCallbackHandler callbackHandler,
                                                     AsyncReadCondition condition)
                                              throws IOException
Method reads data to the ByteBuffer using async read queue. First, if read queue is empty - it tries to read to the ByteBuffer directly (without putting to the queue). If associated read queue is not empty or after direct reading ByteBuffer still has remaining place for next read - ByteBuffer will be added to AsyncQueue. If an exception occurs, during direct reading - it will be propagated to the caller directly, otherwise, if the ByteBuffer is added to a reading queue - exception notification will come via AsyncReadCallbackHandler.onIOException()

Specified by:
readFromAsyncQueue in interface AsyncQueueReadable
Parameters:
buffer - ByteBuffer
callbackHandler - AsyncReadCallbackHandler, which will get notified, when ByteBuffer will get full
condition - AsyncReadCondition, which will be called to check if read data is complete, and callbackHandler could be called
Returns:
true, if ByteBuffer was read completely, false if read operation was put to queue
Throws:
IOException

readFromAsyncQueue

public Future<AsyncQueueReadUnit> readFromAsyncQueue(ByteBuffer buffer,
                                                     AsyncReadCallbackHandler callbackHandler,
                                                     AsyncReadCondition condition,
                                                     AsyncQueueDataProcessor readPostProcessor)
                                              throws IOException
Method reads data to the ByteBuffer using async read queue. First, if read queue is empty - it tries to read to the ByteBuffer directly (without putting to the queue). If associated read queue is not empty or after direct reading ByteBuffer still has remaining place for next read - ByteBuffer will be added to AsyncQueue. If an exception occurs, during direct reading - it will be propagated to the caller directly, otherwise, if the ByteBuffer is added to a reading queue - exception notification will come via AsyncReadCallbackHandler.onIOException()

Specified by:
readFromAsyncQueue in interface AsyncQueueReadable
Parameters:
buffer - ByteBuffer
callbackHandler - AsyncReadCallbackHandler, which will get notified, when ByteBuffer will get full
condition - AsyncReadCondition, which will be called to check if read data is complete, and callbackHandler could be called
readPostProcessor - post processor, to be called to process read data
Returns:
true, if ByteBuffer was read completely, false if read operation was put to queue
Throws:
IOException

writeToAsyncQueue

public Future<AsyncQueueWriteUnit> writeToAsyncQueue(ByteBuffer buffer)
                                              throws IOException
Method writes ByteBuffer using async write queue. First, if write queue is empty - it tries to write ByteBuffer directly (without putting to the queue). If associated write queue is not empty or after direct writing ByteBuffer still has ready data to be written - ByteBuffer will be added to AsyncQueue. If an exception occurs, during direct writing - it will be propagated to the caller directly, otherwise it will be just logged by Grizzly framework.

Specified by:
writeToAsyncQueue in interface AsyncQueueWritable
Parameters:
buffer - ByteBuffer
Throws:
IOException

writeToAsyncQueue

public Future<AsyncQueueWriteUnit> writeToAsyncQueue(ByteBuffer buffer,
                                                     AsyncWriteCallbackHandler callbackHandler)
                                              throws IOException
Method writes ByteBuffer using async write queue. First, if write queue is empty - it tries to write ByteBuffer directly (without putting to the queue). If associated write queue is not empty or after direct writing ByteBuffer still has ready data to be written - ByteBuffer will be added to AsyncQueue. If an exception occurs, during direct writing - it will be propagated to the caller directly, otherwise, if the ByteBuffer is added to a writing queue - exception notification will come via AsyncWriteCallbackHandler.onIOException()

Specified by:
writeToAsyncQueue in interface AsyncQueueWritable
Parameters:
buffer - ByteBuffer
callbackHandler - AsyncWriteCallbackHandler, which will get notified, when ByteBuffer will be completely written
Throws:
IOException

writeToAsyncQueue

public Future<AsyncQueueWriteUnit> writeToAsyncQueue(ByteBuffer buffer,
                                                     AsyncWriteCallbackHandler callbackHandler,
                                                     AsyncQueueDataProcessor writePreProcessor)
                                              throws IOException
Method writes ByteBuffer using async write queue. First, if write queue is empty - it tries to write ByteBuffer directly (without putting to the queue). If associated write queue is not empty or after direct writing ByteBuffer still has ready data to be written - ByteBuffer will be added to AsyncQueue. If an exception occurs, during direct writing - it will be propagated to the caller directly, otherwise, if the ByteBuffer is added to a writing queue - exception notification will come via AsyncWriteCallbackHandler.onIOException() Before data will be written on SelectableChannel, first it will be passed for preprocessing to AsyncQueueDataProcessor, and then preprocessor result data (AsyncQueueDataProcessor.getResultByteBuffer()) will be written on the SelectableChannel.

Specified by:
writeToAsyncQueue in interface AsyncQueueWritable
Parameters:
buffer - ByteBuffer
callbackHandler - AsyncWriteCallbackHandler, which will get notified, when ByteBuffer will be completely written
writePreProcessor - AsyncQueueDataProcessor, which will perform data processing, before it will be written on SelectableChannel
Throws:
IOException

writeToAsyncQueue

public Future<AsyncQueueWriteUnit> writeToAsyncQueue(ByteBuffer buffer,
                                                     AsyncWriteCallbackHandler callbackHandler,
                                                     AsyncQueueDataProcessor writePreProcessor,
                                                     ByteBufferCloner cloner)
                                              throws IOException
Method writes ByteBuffer using async write queue. First, if write queue is empty - it tries to write ByteBuffer directly (without putting to the queue). If associated write queue is not empty or after direct writing ByteBuffer still has ready data to be written - ByteBuffer will be added to AsyncQueue. If an exception occurs, during direct writing - it will be propagated to the caller directly, otherwise, if the ByteBuffer is added to a writing queue - exception notification will come via AsyncWriteCallbackHandler.onIOException() Before data will be written on SelectableChannel, first it will be passed for preprocessing to AsyncQueueDataProcessor, and then preprocessor result data (AsyncQueueDataProcessor.getResultByteBuffer()) will be written on the SelectableChannel.

Specified by:
writeToAsyncQueue in interface AsyncQueueWritable
Parameters:
buffer - ByteBuffer
callbackHandler - AsyncWriteCallbackHandler, which will get notified, when ByteBuffer will be completely written
writePreProcessor - AsyncQueueDataProcessor, which will perform data processing, before it will be written on SelectableChannel
Throws:
IOException

writeToAsyncQueue

public Future<AsyncQueueWriteUnit> writeToAsyncQueue(SocketAddress dstAddress,
                                                     ByteBuffer buffer)
                                              throws IOException
Method sends ByteBuffer using async write queue. First, if write queue is empty - it tries to send ByteBuffer to the given SocketAddress directly (without putting to the queue). If associated write queue is not empty or after direct sending ByteBuffer still has ready data to be written - ByteBuffer will be added to AsyncQueue. If an exception occurs, during direct writing - it will be propagated to the caller directly, otherwise it will be just logged by Grizzly framework.

Specified by:
writeToAsyncQueue in interface AsyncQueueWritable
Parameters:
dstAddress - destination SocketAddress data will be sent to
buffer - ByteBuffer
Throws:
IOException

writeToAsyncQueue

public Future<AsyncQueueWriteUnit> writeToAsyncQueue(SocketAddress dstAddress,
                                                     ByteBuffer buffer,
                                                     AsyncWriteCallbackHandler callbackHandler)
                                              throws IOException
Method sends ByteBuffer using async write queue. First, if write queue is empty - it tries to send ByteBuffer to the given SocketAddress directly (without putting to the queue). If associated write queue is not empty or after direct sending ByteBuffer still has ready data to be written - ByteBuffer will be added to AsyncQueue. If an exception occurs, during direct writing - it will be propagated to the caller directly, otherwise, if the ByteBuffer is added to a writing queue - exception notification will come via AsyncWriteCallbackHandler.onIOException()

Specified by:
writeToAsyncQueue in interface AsyncQueueWritable
Parameters:
dstAddress - destination SocketAddress data will be sent to
buffer - ByteBuffer
callbackHandler - AsyncWriteCallbackHandler, which will get notified, when ByteBuffer will be completely written
Throws:
IOException

writeToAsyncQueue

public Future<AsyncQueueWriteUnit> writeToAsyncQueue(SocketAddress dstAddress,
                                                     ByteBuffer buffer,
                                                     AsyncWriteCallbackHandler callbackHandler,
                                                     AsyncQueueDataProcessor writePreProcessor)
                                              throws IOException
Method sends ByteBuffer using async write queue. First, if write queue is empty - it tries to send ByteBuffer to the given SocketAddress directly (without putting to the queue). If associated write queue is not empty or after direct sending ByteBuffer still has ready data to be written - ByteBuffer will be added to AsyncQueue. If an exception occurs, during direct writing - it will be propagated to the caller directly, otherwise, if the ByteBuffer is added to a writing queue - exception notification will come via AsyncWriteCallbackHandler.onIOException() Before data will be written on SelectableChannel, first it will be passed for preprocessing to AsyncQueueDataProcessor, and then preprocessor result data (AsyncQueueDataProcessor.getResultByteBuffer()) will be written on the SelectableChannel.

Specified by:
writeToAsyncQueue in interface AsyncQueueWritable
Parameters:
dstAddress - destination SocketAddress data will be sent to
buffer - ByteBuffer
callbackHandler - AsyncWriteCallbackHandler, which will get notified, when ByteBuffer will be completely written
writePreProcessor - AsyncQueueDataProcessor, which will perform data processing, before it will be written on SelectableChannel
Throws:
IOException

writeToAsyncQueue

public Future<AsyncQueueWriteUnit> writeToAsyncQueue(SocketAddress dstAddress,
                                                     ByteBuffer buffer,
                                                     AsyncWriteCallbackHandler callbackHandler,
                                                     AsyncQueueDataProcessor writePreProcessor,
                                                     ByteBufferCloner cloner)
                                              throws IOException
Method sends ByteBuffer using async write queue. First, if write queue is empty - it tries to send ByteBuffer to the given SocketAddress directly (without putting to the queue). If associated write queue is not empty or after direct sending ByteBuffer still has ready data to be written - ByteBuffer will be added to AsyncQueue. If an exception occurs, during direct writing - it will be propagated to the caller directly, otherwise, if the ByteBuffer is added to a writing queue - exception notification will come via AsyncWriteCallbackHandler.onIOException() Before data will be written on SelectableChannel, first it will be passed for preprocessing to AsyncQueueDataProcessor, and then preprocessor result data (AsyncQueueDataProcessor.getResultByteBuffer()) will be written on the SelectableChannel.

Specified by:
writeToAsyncQueue in interface AsyncQueueWritable
Parameters:
dstAddress - destination SocketAddress data will be sent to
buffer - ByteBuffer
callbackHandler - AsyncWriteCallbackHandler, which will get notified, when ByteBuffer will be completely written
writePreProcessor - AsyncQueueDataProcessor, which will perform data processing, before it will be written on SelectableChannel
Throws:
IOException

close

public void close()
           throws IOException
Close the underlying connection.

Specified by:
close in interface ConnectorHandler<SSLSelectorHandler,SSLCallbackHandler>
Specified by:
close in interface Closeable
Throws:
IOException

finishConnect

public void finishConnect(SelectionKey key)
                   throws IOException
Finish handling the OP_CONNECT interest ops.

Specified by:
finishConnect in interface ConnectorHandler<SSLSelectorHandler,SSLCallbackHandler>
Parameters:
key - - a SelectionKey
Throws:
IOException

finishHandshake

public void finishHandshake()
Changes SSLConnectorHandler state, after handshake operation is done. Normally should not be called by outside Grizzly, just in case when custom handshake code was used.


protocol

public Controller.Protocol protocol()
A token decribing the protocol supported by an implementation of this interface

Specified by:
protocol in interface ConnectorHandler<SSLSelectorHandler,SSLCallbackHandler>
Returns:
this ConnectorHandler's protocol

isConnected

public boolean isConnected()
Is the underlying SocketChannel connected.

Returns:
true if connected, otherwise false

isHandshakeDone

public boolean isHandshakeDone()
Is the underlying SocketChannel connected.

Returns:
true if connected, otherwise false

getSSLContext

public SSLContext getSSLContext()
Get SSLConnector's SSLContext


setSSLContext

public void setSSLContext(SSLContext sslContext)
Set SSLContext. Use this method to change SSLConnectorHandler configuration. New configuration will become active only after SSLConnector will be closed and connected again.


configure

public void configure(SSLConfig sslConfig)
Configure SSLConnectorHandler's SSL settings. Use this method to change SSLConnectorHandler configuration. New configuration will become active only after SSLConnector will be closed and connected again.


getSSLEngine

public SSLEngine getSSLEngine()
Returns SSLConnector'sSSLEngine


setSSLEngine

public void setSSLEngine(SSLEngine sslEngine)
SetSSLEngine

Parameters:
sslEngine{@link - SSLEngine}

getSecuredInputBuffer

public ByteBuffer getSecuredInputBuffer()
Returns SSLConnectorHandler's secured input buffer, it uses for reading data from a socket channel.

Returns:
secured input ByteBuffer

getSecuredOutputBuffer

public ByteBuffer getSecuredOutputBuffer()
Returns SSLConnectorHandler's secured output buffer, it uses for writing data to a socket channel.

Returns:
secured output ByteBuffer

getController

public Controller getController()
Return the Controller

Specified by:
getController in interface ConnectorHandler<SSLSelectorHandler,SSLCallbackHandler>
Returns:
the Controller

setController

public void setController(Controller controller)
Set the Controller to use with this instance.

Specified by:
setController in interface ConnectorHandler<SSLSelectorHandler,SSLCallbackHandler>
Parameters:
controller - the Controller to use with this instance.

getUnderlyingChannel

public SelectableChannel getUnderlyingChannel()
Return the current SocketChannel used.

Specified by:
getUnderlyingChannel in interface ConnectorHandler<SSLSelectorHandler,SSLCallbackHandler>
Returns:
the current SocketChannel used.

setUnderlyingChannel

protected void setUnderlyingChannel(SocketChannel socketChannel)
Set the SocketChannel.

Parameters:
the - SocketChannel to use.

getCallbackHandler

public SSLCallbackHandler getCallbackHandler()
Return the CallbackHandler.

Specified by:
getCallbackHandler in interface ConnectorHandler<SSLSelectorHandler,SSLCallbackHandler>
Returns:
the CallbackHandler.

setCallbackHandler

public void setCallbackHandler(SSLCallbackHandler callbackHandler)
Set the CallbackHandler.

Specified by:
setCallbackHandler in interface ConnectorHandler<SSLSelectorHandler,SSLCallbackHandler>
Parameters:
callbackHandler - the CallbackHandler.

getSelectorHandler

public SSLSelectorHandler getSelectorHandler()
Return the associated SelectorHandler.

Specified by:
getSelectorHandler in interface ConnectorHandler<SSLSelectorHandler,SSLCallbackHandler>
Returns:
the associated SelectorHandler.

getApplicationBufferSize

public int getApplicationBufferSize()
Gets the size of the largest application buffer that may occur when using this session. SSLEngine application data buffers must be large enough to hold the application data from any inbound network application data packet received. Typically, outbound application data buffers can be of any size. (javadoc is taken from SSLSession.getApplicationBufferSize())

Returns:
largets application buffer size, which may occur


Copyright © 2008 SUN Microsystems. All Rights Reserved.