Hi Alexey,
I have latest ReadFilter.java from grizzly trunk. I still have this issue.
Thanks,
Kshitiz
Oleksiy Stashok wrote:
>
>>>
>>> Thanks a lot. Well, I get AlreadyConnectedExceptions if I connect
>>> more than once, the aquired connector seems to be already in use.
>>> What was the reason I could not allocate a new ConnectorHandler with
>>> new TCPConnectorHandler()? Well, but this helps
>>> also only limited: Every second connection does not work.
>>>
>> Looks like ConnectorHandler.close() wasn't called.
> Seems it was ReadFilter problem. Please retry after svn update.
>
> Alexey.
>
>
>>
>>> I have spend the day to get an own solution, but I failed. The first
>>> SelectionKey which is processed is always OP_READ, not an OP_ACCEPT.
>>> I noticed that the ProtocolFilter chain is only used if no
>>> CallbackHandler is attached
>> As JF wrote, CallbackHandler currently is used as *client side*
>> connection implementation. It was recently added, so there could be
>> some drawbacks, but with your feedback we can improve it.
>> ProtocolFilter is the part of *server side* processing chain.
>> OP_ACCEPT with default TCPSelectorHandler implementation will not be
>> passed for processing by server-chain. But in case of "tunnel" seems
>> it's not required, as connection initiator should send something, right?
>>
>> WBR,
>> Alexey.
>>
>>> (for which scenario is a CallbackHandler good for, and when a
>>> ProtocolFilter if they exclude each other?), so I attached null to
>>> the key after I got a connection. The sources are attached. I don't
>>> know why this programm fails.
>>>
>>> I also attached a modified version of the ConnectorHandler
>>> interface. A Channel can now be attached. For me it was useful or
>>> the only way I had seen to reuse a the convenient TCPConnectorHandler.
>>>
>>> Best Regards, Karsten
>>>
>>>
>>>> WBR,
>>>> Alexey.
>>>>
>>>> Karsten Ohme wrote:
>>>>
>>>>> On Fri, Jun 01, 2007 at 05:26:18PM +0200, Oleksiy Stashok wrote:
>>>>>
>>>>>
>>>>>> Hello Karsten,
>>>>>>
>>>>>> let me try to help you.
>>>>>> Let's start from the beginning and will not use cache for
>>>>>> simplicity, we can always add it later...
>>>>>> As I understood, you are not making http proxy, but some tunnel
>>>>>> for socket connections. In other words nothing http specific?
>>>>>>
>>>>>> So I would advice you to start implementing something called...
>>>>>> let's say ProxyProtocolFilter (as Jeanfrancois proposed) :)
>>>>>> To see how you can implement the Filter - please find EchoFilter
>>>>>> in Grizzly/framework test folder.
>>>>>>
>>>>>> As for proxy-to-tomcat connections - please use ConnectorHandlers
>>>>>> (to get one use controller.aquireConnectorHandler(), and don't
>>>>>> forget to release it).
>>>>>> We're working on documentations, but you can take a look at unit
>>>>>> tests we have to understand how you can use Grizzly both for
>>>>>> client and server sides.
>>>>>>
>>>>>> If you'll have questions - please ask.
>>>>>>
>>>>> OK, I have a ProxyProtocolFilter and I also found out that the
>>>>> WorkerThread contains the ByteBuffer. So I would do the following
>>>>>
>>>>> Use the returned ByteBuffer from the WorkerThread aquire a
>>>>> TCPConnectorHandler from the Controller in the Context
>>>>>
>>>>> register a CallBackHandler with a reference to the
>>>>> SocketConnection for the way from client to proxy and an
>>>>> implemented onConnect() method
>>>>>
>>>>> write out the data with write(byteBuffer, true)
>>>>>
>>>>> When do I release the TCPConnectorHandler? I store the
>>>>> TCPConnector with the SocketChannel for the way client-proxy in a
>>>>> Map in the Context. So the connection can be reused. What is better?
>>>>>
>>>>> When the connection is done onConnect gets executed and I can get
>>>>> the SocketChannel for the line proxy - Tomcat server
>>>>> The pair of SocketConnections client-proxy and proxy-Tomcat server
>>>>> is kept in a mapping in the context. This is important to remember
>>>>> who is talking over the proxy to whom.
>>>>>
>>>>> For the way server-proxy to proxy-client I have to write back the
>>>>> data. Problem I see no way how I can use here an
>>>>> TCPConnectorHandler. The TCPSelectorHandler offers no possibility
>>>>> to use an existing SocketChannel. I would change this to simplify
>>>>> my life or how is it intended?
>>>>>
>>>>> Why are there two methods: register(CallbackHandler) and
>>>>> setCallbackHandler(...)?
>>>>>
>>>>> Thanks,
>>>>> Karsten
>>>>>
>>>>>
>>>>>
>>>>>> WBR,
>>>>>> Alexey.
>>>>>>
>>>>>> Karsten Ohme wrote:
>>>>>>
>>>>>>> On Thu, May 31, 2007 at 02:43:43PM -0400, Jeanfrancois Arcand
>>>>>>> wrote:
>>>>>>>
>>>>>>>
>>>>>>>> Hi Karsten,
>>>>>>>>
>>>>>>>> don't stop the feedback!
>>>>>>>>
>>>>>>>> Karsten Ohme wrote:
>>>>>>>>
>>>>>>>>> Hi,
>>>>>>>>>
>>>>>>>>> I want to program a proxy (actually tunnel). All connections
>>>>>>>>> are made to the proxy, the proxy makes some decisions and
>>>>>>>>> forwards them to the server. For my situation many clients
>>>>>>>>> connect to the proxy on port 80, the proxy forwards the
>>>>>>>>> requests to a Tomcat server on port 8080 and writes the
>>>>>>>>> response back to the client.
>>>>>>>>>
>>>>>>>> Stupid question: can the client connect directly to Tomcat or
>>>>>>>> does all connection must go to the proxy? I suspect all
>>>>>>>> connections have to pass through the proxy, but in case not,
>>>>>>>> the proxy can always send a redirect to the client (using the
>>>>>>>> location: header).
>>>>>>>>
>>>>>>>>
>>>>>>>>
>>>>>>>>> How can I acieve this with Grizzly? I though I had to extend
>>>>>>>>> the TCPSelectorHandler, overwrite the onAcceptInterest method,
>>>>>>>>> establish there a new TCPConnectorHandler for the path
>>>>>>>>> client-proxy and one for proxy-server and register
>>>>>>>>> CallbackHandlers wo propagate the read and write operations.
>>>>>>>>>
>>>>>>>> I would not override the onAcceptInterest but instead let the
>>>>>>>> default workflow happen. On of the reason is onAcceptInterest
>>>>>>>> is executed on the same thread as the Selector.select(), which
>>>>>>>> is a performance bottleneck. I would instead implement two
>>>>>>>> ProtocolFilters that uses the newly added ConnectionPool/Cache.
>>>>>>>> My recommendation is to do:
>>>>>>>>
>>>>>>>> 1. Use the default ReadFilter to execute the first read to make
>>>>>>>> sure the connection hasn't been closed between the accept() and
>>>>>>>> the first read.
>>>>>>>> 2. Add a new ProxyProtocolFilter:
>>>>>>>>
>>>>>>>> + When initializing, create a pool of connection your remote
>>>>>>>> server (Tomcat). I recommend you take a look at the new
>>>>>>>> ConnectionPool/Cache Alexey demonstrated yesterday at the
>>>>>>>> Grizzly meeting.
>>>>>>>>
>>>>>>> I don't know how to use it. What is a ConnectionPool? There is
>>>>>>> only a class ConnectionCache. What is it useful for? From the
>>>>>>> name I suspect that some sort of connections are cached and I
>>>>>>> have a method to get free connections which I can use. I would
>>>>>>> expect a constructor with a given number where this amount of
>>>>>>> connections are created. For me this would be always the same
>>>>>>> type of connection from the proxy to the client, for the
>>>>>>> way
>>>>>> >from client to proxy I need for each client a single connection
>>>>>> or not?
>>>>>>> What are doing requestReceived(), requestProcessed() and
>>>>>>> responseSent( C conn ). Which connection I have to pass in as
>>>>>>> parameter? What means cached? In the sources it looks like i
>>>>>>> have to pass the connectiosn on my own. From which class must
>>>>>>> the methods be called? How can I reuese such a cached exception
>>>>>>> when it is idle? There is not get method.
>>>>>>>
>>>>>>> Regards,
>>>>>>> Karsten
>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>>> + When execute() is invoked, use a StreamAlgorithm
>>>>>>>> implementation to make sure you can read the complete HTTP
>>>>>>>> request (note: you gonna need to buffer the body as well). The
>>>>>>>> module/http sub module have a StreamAlgorithm implementations
>>>>>>>> called ContentLengthAlgorithm|StateMachineAlgoruithm that can
>>>>>>>> be reused. Mainly those classes will make sure the entire
>>>>>>>> headers + body are read.
>>>>>>>> + Once you have read all the bytes, get a connection from the
>>>>>>>> connection pool and flush the bytes to Tomcat. Make the
>>>>>>>> TCPConnectionHandler.write(bb,TRUE) so the temporary Selector
>>>>>>>> trick can be reused.
>>>>>>>> + Then read back the response and flush it back to the client.
>>>>>>>>
>>>>>>>> Would that make sense? You might also want to create two
>>>>>>>> ProtocolFilter, one for reading the request, and one for
>>>>>>>> writing the response to the active connection to Tomcat.
>>>>>>>>
>>>>>>>>
>>>>>>>>> But I don't know how the ProtocolFilter fits into the picture.
>>>>>>>>> How do I use it? I also want to use TLS connections. How can I
>>>>>>>>> get the data which is decoded?
>>>>>>>>>
>>>>>>>>> Is there any documentation or tutorial for the new Grizzly API?
>>>>>>>>>
>>>>>>>> Take a look at the following talks:
>>>>>>>>
>>>>>>>> https://grizzly.dev.java.net/presentations/FISL-2007.pdf
>>>>>>>> http://weblogs.java.net/blog/jfarcand/archive/BOF-4989-Grizzly.pdf
>>>>>>>>
>>>>>>>> We don't have yet tutorials but I'm working on one right now.
>>>>>>>>
>>>>>>>> Hope that help.
>>>>>>>>
>>>>>>>> -- Jeanfrancois
>>>>>>>>
>>>>>>>>
>>>>>>>>> Regards,
>>>>>>>>> Karsten
>>>>>>>>>
>>>>>>>>> ---------------------------------------------------------------------
>>>>>>>>>
>>>>>>>>> To unsubscribe, e-mail: users-unsubscribe_at_grizzly.dev.java.net
>>>>>>>>> For additional commands, e-mail: users-help_at_grizzly.dev.java.net
>>>>>>>>>
>>>>>>>>>
>>>>>>>> ---------------------------------------------------------------------
>>>>>>>>
>>>>>>>> To unsubscribe, e-mail: users-unsubscribe_at_grizzly.dev.java.net
>>>>>>>> For additional commands, e-mail: users-help_at_grizzly.dev.java.net
>>>>>>>>
>>>>>>>>
>>>>>>> ---------------------------------------------------------------------
>>>>>>>
>>>>>>> To unsubscribe, e-mail: users-unsubscribe_at_grizzly.dev.java.net
>>>>>>> For additional commands, e-mail: users-help_at_grizzly.dev.java.net
>>>>>>>
>>>>>>>
>>>>>>>
>>>>>> ---------------------------------------------------------------------
>>>>>>
>>>>>> To unsubscribe, e-mail: users-unsubscribe_at_grizzly.dev.java.net
>>>>>> For additional commands, e-mail: users-help_at_grizzly.dev.java.net
>>>>>>
>>>>>>
>>>>> ---------------------------------------------------------------------
>>>>> To unsubscribe, e-mail: users-unsubscribe_at_grizzly.dev.java.net
>>>>> For additional commands, e-mail: users-help_at_grizzly.dev.java.net
>>>>>
>>>>>
>>>>>
>>>
>>>
>>>
>>>> ---------------------------------------------------------------------
>>>> To unsubscribe, e-mail: users-unsubscribe_at_grizzly.dev.java.net
>>>> For additional commands, e-mail: users-help_at_grizzly.dev.java.net
>>>>
>>>> ------------------------------------------------------------------------
>>>>
>>>>
>>>> /*
>>>> * The contents of this file are subject to the terms
>>>> * of the Common Development and Distribution License
>>>> * (the License). You may not use this file except in
>>>> * compliance with the License.
>>>> *
>>>> * You can obtain a copy of the license at
>>>> * https://glassfish.dev.java.net/public/CDDLv1.0.html or
>>>> * glassfish/bootstrap/legal/CDDLv1.0.txt.
>>>> * See the License for the specific language governing
>>>> * permissions and limitations under the License.
>>>> *
>>>> * When distributing Covered Code, include this CDDL
>>>> * Header Notice in each file and include the License file
>>>> * at glassfish/bootstrap/legal/CDDLv1.0.txt.
>>>> * If applicable, add the following below the CDDL Header,
>>>> * with the fields enclosed by brackets [] replaced by
>>>> * you own identifying information:
>>>> * "Portions Copyrighted [year] [name of copyright owner]"
>>>> *
>>>> * Copyright 2007 Sun Microsystems, Inc. All rights reserved.
>>>> */
>>>> package com.sun.grizzly;
>>>>
>>>> import java.io.Closeable;
>>>> import java.io.IOException;
>>>> import java.net.SocketAddress;
>>>> import java.nio.ByteBuffer;
>>>> import java.nio.channels.SelectableChannel;
>>>> import java.nio.channels.SelectionKey;
>>>>
>>>> /**
>>>> * Client side interface used to implement non blocking client
>>>> operation.
>>>> * Implementation of this class must make sure the following
>>>> methods are invoked
>>>> * in that order:
>>>> * * (1) connect() (2) read() or write().
>>>> * * * @param E a <code>SelectorHandler</code>
>>>> * @author Jeanfrancois Arcand
>>>> */
>>>> public interface ConnectorHandler<E extends SelectorHandler, C
>>>> extends SelectableChannel> extends Handler, Closeable {
>>>>
>>>>
>>>> /**
>>>> * A token decribing the protocol supported by an
>>>> implementation of this
>>>> * interface
>>>> * @return <code>Controller.Protocol</code>
>>>> */
>>>> public Controller.Protocol protocol();
>>>>
>>>>
>>>> /**
>>>> * Connect to hostname:port. When an aysnchronous event happens
>>>> (e.g OP_READ
>>>> * or OP_WRITE), the <code>Controller</code> will invoke the
>>>> * CallBackHandler.
>>>> * * @param remoteAddress remote address to connect
>>>> * @param callbackHandler the handler invoked by the Controller
>>>> when an non
>>>> * blocking operation is ready to be handled.
>>>> * @param e <code>SelectorHandler</code>
>>>> * @throws java.io.IOException */
>>>> public void connect(SocketAddress remoteAddress,
>>>> CallbackHandler callbackHandler, E e) throws IOException;
>>>>
>>>>
>>>> /**
>>>> * Connect to hostname:port. When an aysnchronous event happens
>>>> (e.g OP_READ
>>>> * or OP_WRITE), the <code>Controller</code> will invoke the
>>>> * CallBackHandler.
>>>> * * @param remoteAddress remote address to connect *
>>>> @param callbackHandler the handler invoked by the Controller when
>>>> * an non blocking operation is ready to be handled.
>>>> * @throws java.io.IOException
>>>> */ public void connect(SocketAddress remoteAddress,
>>>> CallbackHandler callbackHandler) 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.
>>>> * * @param remoteAddress remote address to connect
>>>> * @throws java.io.IOException */
>>>> public void connect(SocketAddress remoteAddress) throws
>>>> IOException;
>>>>
>>>>
>>>> /**
>>>> * Connect to hostname:port. When an aysnchronous event happens
>>>> (e.g OP_READ
>>>> * or OP_WRITE), the <code>Controller</code> will invoke the
>>>> * CallBackHandler.
>>>> * * @param remoteAddress remote address to connect *
>>>> @param localAddress local address to bind
>>>> * @param callbackHandler the handler invoked by the Controller
>>>> when * an non blocking operation is ready to be
>>>> handled. * @param e <code>SelectorHandler</code>
>>>> * @throws java.io.IOException
>>>> */
>>>> public void connect(SocketAddress remoteAddress, SocketAddress
>>>> localAddress, CallbackHandler callbackHandler, E e) throws
>>>> IOException;
>>>>
>>>>
>>>> /**
>>>> * Connect to hostname:port. When an aysnchronous event happens
>>>> (e.g OP_READ
>>>> * or OP_WRITE), the <code>Controller</code> will invoke the
>>>> * CallBackHandler.
>>>> * * @param remoteAddress remote address to connect
>>>> * @param localAddress local address to bind
>>>> * @param callbackHandler the handler invoked by the Controller
>>>> when * an non blocking operation is ready to be handled.
>>>> * @throws java.io.IOException */ public void
>>>> connect(SocketAddress remoteAddress, SocketAddress localAddress,
>>>> CallbackHandler callbackHandler) 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.
>>>> * * @param remoteAddress remote address to connect
>>>> * @param localAddress local address to bind
>>>> * @throws java.io.IOException */
>>>> public void connect(SocketAddress remoteAddress, SocketAddress
>>>> localAddress) throws IOException;
>>>>
>>>>
>>>> /**
>>>> * Read bytes. If blocking is set to <tt>true</tt>, a pool of
>>>> temporary
>>>> * <code>Selector</code> will be used to read bytes.
>>>> * * @param byteBuffer The byteBuffer to store bytes.
>>>> * @param blocking <tt>true</tt> if a a pool of temporary
>>>> Selector is
>>>> * required to handle a blocking read.
>>>> * @return number of bytes read
>>>> * @throws java.io.IOException */
>>>> public long read(ByteBuffer byteBuffer, boolean blocking)
>>>> throws IOException;
>>>>
>>>>
>>>> /**
>>>> * Writes bytes. If blocking is set to <tt>true</tt>, a pool of
>>>> temporary
>>>> * <code>Selector</code> will be used to writes bytes.
>>>> * * @param byteBuffer The byteBuffer to write.
>>>> * @param blocking <tt>true</tt> if a a pool of temporary Selector
>>>> * is required to handle a blocking write.
>>>> * @return number of bytes written
>>>> * @throws java.io.IOException */ public long
>>>> write(ByteBuffer byteBuffer, boolean blocking) throws IOException;
>>>> /**
>>>> * Close the underlying connection.
>>>> * * @throws java.io.IOException
>>>> */
>>>> public void close() throws IOException;
>>>>
>>>>
>>>> /**
>>>> * Decide how the OP_CONNECT final steps are handled.
>>>> * @param key <code>SelectionKey</code>
>>>> */
>>>> public void finishConnect(SelectionKey key);
>>>>
>>>>
>>>> /**
>>>> * Set the <code>Controller</code> associated with this instance.
>>>> * @param controller <code>Controller</code>
>>>> */
>>>> public void setController(Controller controller);
>>>>
>>>>
>>>> /**
>>>> * Return the <code>Controller</code>
>>>> * * @return
>>>> */
>>>> public Controller getController();
>>>>
>>>> /**
>>>> * Method returns <code>SelectorHandler</code>, which manages this
>>>> * <code>ConnectorHandler</code>
>>>> * * @return <code>SelectorHandler</code>
>>>> */
>>>> public E getSelectorHandler();
>>>>
>>>> /**
>>>> * Method returns <code>ConnectorHandler</code>'s underlying
>>>> channel
>>>> * * @return channel
>>>> */
>>>> public C getUnderlyingChannel();
>>>>
>>>> /**
>>>> * Returns <code>ConnectorHandler</code>'s callback handler
>>>> instance,
>>>> * which is used to process occuring events
>>>> * * @return callback handler
>>>> */
>>>> public CallbackHandler getCallbackHandler();
>>>>
>>>> /**
>>>> * Sets an existing channel for this ConnectorHandler. This can
>>>> be used to
>>>> * (re)use this ConnectorHandler for an already existing
>>>> connection.
>>>> * <p>
>>>> * The controller which controls the channel must also be set.
>>>> * @param channel The channel to use. * @see
>>>> #setController(Controller).
>>>> */
>>>> public void setUnderlyingChannel(C channel);
>>>>
>>>> /**
>>>> * Sets <code>ConnectorHandler</code>'s callback handler
>>>> instance, which
>>>> * is used to process occuring events
>>>> * * @param callbackHandler handler
>>>> */
>>>> public void setCallbackHandler(CallbackHandler callbackHandler);
>>>> }
>>>>
>>>> ------------------------------------------------------------------------
>>>>
>>>>
>>>> /*
>>>> * The contents of this file are subject to the terms
>>>> * of the Common Development and Distribution License
>>>> * (the License). You may not use this file except in
>>>> * compliance with the License.
>>>> *
>>>> * You can obtain a copy of the license at
>>>> * https://glassfish.dev.java.net/public/CDDLv1.0.html or
>>>> * glassfish/bootstrap/legal/CDDLv1.0.txt.
>>>> * See the License for the specific language governing
>>>> * permissions and limitations under the License.
>>>> *
>>>> * When distributing Covered Code, include this CDDL
>>>> * Header Notice in each file and include the License file
>>>> * at glassfish/bootstrap/legal/CDDLv1.0.txt.
>>>> * If applicable, add the following below the CDDL Header,
>>>> * with the fields enclosed by brackets [] replaced by
>>>> * you own identifying information:
>>>> * "Portions Copyrighted [year] [name of copyright owner]"
>>>> *
>>>> * Copyright 2007 Sun Microsystems, Inc. All rights reserved.
>>>> */
>>>>
>>>> package com.sun.grizzly;
>>>>
>>>> import com.sun.grizzly.Controller;
>>>> import com.sun.grizzly.util.ByteBufferInputStream;
>>>> import java.io.IOException;
>>>> import java.net.SocketAddress;
>>>> import java.nio.ByteBuffer;
>>>> import java.nio.channels.AlreadyConnectedException;
>>>> import java.nio.channels.NotYetConnectedException;
>>>> import java.nio.channels.SelectionKey;
>>>> import java.nio.channels.DatagramChannel;
>>>> import java.util.concurrent.CountDownLatch;
>>>> import java.util.concurrent.TimeUnit;
>>>>
>>>> /**
>>>> * Client side interface used to implement non blocking client
>>>> operation. * Implementation of this class must make sure the
>>>> following methods are * invoked in that order:
>>>> * * (1) connect()
>>>> * (2) read() or write().
>>>> * * @author Jeanfrancois Arcand
>>>> */
>>>> public class UDPConnectorHandler implements
>>>> ConnectorHandler<UDPSelectorHandler, DatagramChannel>{
>>>> /**
>>>> * The underlying UDPSelectorHandler used to mange SelectionKeys.
>>>> */
>>>> private UDPSelectorHandler selectorHandler;
>>>> /**
>>>> * A <code>CallbackHandler</code> handler invoked by the
>>>> UDPSelectorHandler
>>>> * when a non blocking operation is ready to be processed.
>>>> */
>>>> private CallbackHandler callbackHandler;
>>>>
>>>> /**
>>>> * The connection's DatagramChannel.
>>>> */
>>>> private DatagramChannel datagramChannel;
>>>> /**
>>>> * Is the connection established.
>>>> */
>>>> private volatile boolean isConnected;
>>>> /**
>>>> * The internal Controller used (in case not specified).
>>>> */
>>>> private Controller controller;
>>>>
>>>> /**
>>>> * IsConnected Latch related
>>>> */
>>>> private CountDownLatch isConnectedLatch; /**
>>>> * Are we creating a controller every run.
>>>> */
>>>> private boolean isStandalone = false;
>>>> /**
>>>> * A blocking <code>InputStream</code> that use a pool of Selector
>>>> * to execute a blocking read operation.
>>>> */
>>>> private ByteBufferInputStream inputStream; /**
>>>> * Connect to hostname:port. When an aysnchronous event happens
>>>> (e.g * OP_READ or OP_WRITE), the <code>Controller</code> will
>>>> invoke * the CallBackHandler.
>>>> * @param remoteAddress remote address to connect
>>>> * @param callbackHandler the handler invoked by the Controller
>>>> when * an non blocking operation is ready to be handled.
>>>> */
>>>> public void connect(SocketAddress remoteAddress,
>>>> CallbackHandler callbackHandler) throws
>>>> IOException {
>>>> connect(remoteAddress,null,callbackHandler); }
>>>> /**
>>>> * Connect to hostname:port. When an aysnchronous event happens
>>>> (e.g * OP_READ or OP_WRITE), the <code>Controller</code> will
>>>> invoke * the CallBackHandler.
>>>> * @param remoteAddress remote address to connect
>>>> * @param localAddress local address to bind
>>>> * @param callbackHandler the handler invoked by the Controller
>>>> when * an non blocking operation is ready to be handled.
>>>> */
>>>> public void connect(SocketAddress remoteAddress, SocketAddress
>>>> localAddress,
>>>> CallbackHandler callbackHandler) throws
>>>> IOException { if (controller == null){
>>>> throw new IllegalStateException("Controller cannot be
>>>> null");
>>>> }
>>>> connect(remoteAddress,localAddress,callbackHandler,
>>>>
>>>> (UDPSelectorHandler)controller.getSelectorHandler(protocol()));
>>>> }
>>>> /**
>>>> * Connect to hostname:port. When an aysnchronous event happens
>>>> (e.g * OP_READ or OP_WRITE), the <code>Controller</code> will
>>>> invoke * the CallBackHandler.
>>>> * @param remoteAddress remote address to connect
>>>> * @param callbackHandler the handler invoked by the Controller
>>>> when * an non blocking operation is ready to be handled.
>>>> * @param selectorHandler an instance of SelectorHandler.
>>>> */
>>>> public void connect(SocketAddress remoteAddress,
>>>> CallbackHandler callbackHandler,
>>>> UDPSelectorHandler selectorHandler) throws
>>>> IOException {
>>>> connect(remoteAddress,null,callbackHandler,selectorHandler);
>>>> } /**
>>>> * Connect to hostname:port. When an aysnchronous event happens
>>>> (e.g * OP_READ or OP_WRITE), the <code>Controller</code> will
>>>> invoke * the CallBackHandler.
>>>> * @param remoteAddress remote address to connect
>>>> * @param localAddress local address to bin
>>>> * @param callbackHandler the handler invoked by the Controller
>>>> when * an non blocking operation is ready to be handled.
>>>> * @param selectorHandler an instance of SelectorHandler.
>>>> */
>>>> public void connect(SocketAddress remoteAddress, SocketAddress
>>>> localAddress,
>>>> CallbackHandler callbackHandler,
>>>> UDPSelectorHandler selectorHandler) throws
>>>> IOException {
>>>> if (isConnected){
>>>> throw new AlreadyConnectedException();
>>>> }
>>>> if (controller == null){
>>>> throw new IllegalStateException("Controller cannot be
>>>> null");
>>>> }
>>>> if (selectorHandler == null){
>>>> throw new IllegalStateException("Controller cannot be
>>>> null");
>>>> }
>>>> this.selectorHandler = selectorHandler;
>>>> this.callbackHandler = callbackHandler;
>>>> // Wait for the onConnect to be invoked.
>>>> isConnectedLatch = new CountDownLatch(1);
>>>> selectorHandler.connect(remoteAddress,localAddress,callbackHandler);
>>>> inputStream = new ByteBufferInputStream();
>>>> try {
>>>> isConnectedLatch.await(30, TimeUnit.SECONDS);
>>>> } catch (InterruptedException ex) {
>>>> throw new IOException(ex.getMessage());
>>>> }
>>>> }
>>>>
>>>> /**
>>>> * 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.
>>>> * @param remoteAddress remote address to connect
>>>> */
>>>> public void connect(SocketAddress remoteAddress)
>>>> throws IOException {
>>>> connect(remoteAddress,(SocketAddress)null); }
>>>> /**
>>>> * 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.
>>>> * @param remoteAddress remote address to connect
>>>> * @param localAddress local address to bin
>>>> */
>>>> public void connect(SocketAddress remoteAddress, SocketAddress
>>>> localAddress) throws IOException {
>>>> if (isConnected){
>>>> throw new AlreadyConnectedException();
>>>> }
>>>> if (controller == null){ isStandalone
>>>> = true;
>>>> controller = new Controller();
>>>> controller.setSelectorHandler(new
>>>> UDPSelectorHandler(true));
>>>> DefaultPipeline pipeline = new DefaultPipeline();
>>>> pipeline.initPipeline();
>>>> pipeline.startPipeline();
>>>> controller.setPipeline(pipeline);
>>>>
>>>> callbackHandler = new CallbackHandler<Context>(){
>>>> public void onConnect(IOEvent<Context> ioEvent) {
>>>> SelectionKey key =
>>>> ioEvent.attachment().getSelectionKey();
>>>> finishConnect(key);
>>>> }
>>>> public void onRead(IOEvent<Context> ioEvent) {
>>>> }
>>>> public void onWrite(IOEvent<Context> ioEvent) {
>>>> }
>>>> };
>>>>
>>>> final CountDownLatch latch = new CountDownLatch(1);
>>>> try{
>>>> pipeline.execute(new Context(){
>>>> public Object call() throws Exception {
>>>> latch.countDown();
>>>> controller.start();
>>>> return null;
>>>> } });
>>>> } catch (PipelineFullException ex){
>>>> throw new IOException(ex.getMessage());
>>>> }
>>>> try {
>>>> latch.await(); Thread.sleep(1000);
>>>> } catch (InterruptedException ex) {
>>>> }
>>>> }
>>>> connect(remoteAddress,localAddress,callbackHandler,
>>>>
>>>> (UDPSelectorHandler)controller.getSelectorHandler(protocol()));
>>>> }
>>>> /**
>>>> * Read bytes. If blocking is set to <tt>true</tt>, a pool of
>>>> temporary
>>>> * <code>Selector</code> will be used to read bytes.
>>>> * @param byteBuffer The byteBuffer to store bytes.
>>>> * @param blocking <tt>true</tt> if a a pool of temporary Selector
>>>> * is required to handle a blocking read.
>>>> */
>>>> public long read(ByteBuffer byteBuffer, boolean blocking)
>>>> throws IOException {
>>>> if (!isConnected){
>>>> throw new NotYetConnectedException();
>>>> }
>>>> SelectionKey key =
>>>> datagramChannel.keyFor(selectorHandler.getSelector());
>>>> if (blocking){
>>>> inputStream.setSelectionKey(key);
>>>> inputStream.setChannelType(
>>>>
>>>> ByteBufferInputStream.ChannelType.DatagramChannel);
>>>> int nRead = inputStream.read(byteBuffer);
>>>> return nRead;
>>>> } else {
>>>> if (callbackHandler == null){
>>>> throw new IllegalStateException
>>>> ("Non blocking read needs a CallbackHandler");
>>>> }
>>>> int nRead = datagramChannel.read(byteBuffer);
>>>>
>>>> if (nRead == 0){
>>>> key.attach(callbackHandler);
>>>> selectorHandler.register(key,
>>>> SelectionKey.OP_READ|SelectionKey.OP_WRITE);
>>>> }
>>>> return nRead;
>>>> }
>>>> }
>>>> /**
>>>> * Writes bytes. If blocking is set to <tt>true</tt>, a pool of
>>>> temporary
>>>> * <code>Selector</code> will be used to writes bytes.
>>>> * @param byteBuffer The byteBuffer to write.
>>>> * @param blocking <tt>true</tt> if a a pool of temporary Selector
>>>> * is required to handle a blocking write.
>>>> */ public long write(ByteBuffer byteBuffer, boolean
>>>> blocking) throws IOException {
>>>> if (!isConnected){
>>>> throw new NotYetConnectedException();
>>>> }
>>>> SelectionKey key =
>>>> datagramChannel.keyFor(selectorHandler.getSelector());
>>>> if (blocking){
>>>> throw new IllegalStateException("Blocking mode not
>>>> supported");
>>>> } else {
>>>> if (callbackHandler == null){
>>>> throw new IllegalStateException
>>>> ("Non blocking write needs a
>>>> CallbackHandler");
>>>> }
>>>> int nWrite = datagramChannel.write(byteBuffer);
>>>> if (nWrite == 0){
>>>> key.attach(callbackHandler);
>>>> selectorHandler.register(key,
>>>> SelectionKey.OP_READ|SelectionKey.OP_WRITE);
>>>> } return nWrite;
>>>> }
>>>> }
>>>> /**
>>>> * Receive bytes.
>>>> * @param byteBuffer The byteBuffer to store bytes.
>>>> * @param socketAddress * @return number bytes sent
>>>> * @throws java.io.IOException */
>>>> public long send(ByteBuffer byteBuffer, SocketAddress
>>>> socketAddress) throws IOException {
>>>> if (!isConnected){
>>>> throw new NotYetConnectedException();
>>>> }
>>>> if (callbackHandler == null){
>>>> throw new IllegalStateException
>>>> ("Non blocking read needs a CallbackHandler");
>>>> }
>>>>
>>>> return datagramChannel.send(byteBuffer,socketAddress);
>>>> }
>>>> /**
>>>> * Receive bytes.
>>>> * @param byteBuffer The byteBuffer to store bytes.
>>>> * @return <code>SocketAddress</code>
>>>> * @throws java.io.IOException */
>>>> public SocketAddress receive(ByteBuffer byteBuffer) throws
>>>> IOException {
>>>> if (!isConnected){
>>>> throw new NotYetConnectedException();
>>>> }
>>>> SelectionKey key =
>>>> datagramChannel.keyFor(selectorHandler.getSelector());
>>>> if (callbackHandler == null){
>>>> throw new IllegalStateException
>>>> ("Non blocking read needs a CallbackHandler");
>>>> }
>>>> SocketAddress socketAddress =
>>>> datagramChannel.receive(byteBuffer);
>>>> return socketAddress;
>>>> }
>>>> /**
>>>> * Close the underlying connection.
>>>> */
>>>> public void close() throws IOException{
>>>> if (datagramChannel != null){
>>>> if (selectorHandler != null){
>>>> SelectionKey key =
>>>> datagramChannel.keyFor(selectorHandler.getSelector());
>>>> if (key == null) return;
>>>> key.cancel();
>>>> key.attach(null);
>>>> }
>>>> datagramChannel.close(); }
>>>> if (controller != null && isStandalone){
>>>> controller.stop();
>>>> controller = null;
>>>> } isStandalone = false;
>>>> }
>>>>
>>>> /**
>>>> * Finish handling the OP_CONNECT interest ops.
>>>> */
>>>> public void finishConnect(SelectionKey key){
>>>> datagramChannel = (DatagramChannel)key.channel();
>>>> isConnected = datagramChannel.isConnected();
>>>> isConnectedLatch.countDown();
>>>> }
>>>> /**
>>>> * A token decribing the protocol supported by an
>>>> implementation of this
>>>> * interface
>>>> */
>>>> public Controller.Protocol protocol(){
>>>> return Controller.Protocol.UDP;
>>>> }
>>>> /**
>>>> * Is the underlying DatagramChannel connected.
>>>> * @return true if connected, othewise false
>>>> */
>>>> public boolean isConnected(){
>>>> return isConnected;
>>>> } public Controller getController() {
>>>> return controller;
>>>> }
>>>>
>>>> public void setController(Controller controller) {
>>>> this.controller = controller;
>>>> }
>>>>
>>>> public DatagramChannel getUnderlyingChannel() {
>>>> return datagramChannel;
>>>> }
>>>>
>>>> public CallbackHandler getCallbackHandler() {
>>>> return callbackHandler;
>>>> }
>>>>
>>>> public void setCallbackHandler(CallbackHandler callbackHandler) {
>>>> this.callbackHandler = callbackHandler;
>>>> }
>>>>
>>>> public UDPSelectorHandler getSelectorHandler() {
>>>> return selectorHandler;
>>>> }
>>>>
>>>> public void setChannel(DatagramChannel channel,
>>>> UDPSelectorHandler selectorHandler) {
>>>> this.selectorHandler = selectorHandler;
>>>> this.datagramChannel = channel;
>>>> }
>>>>
>>>> public void setUnderlyingChannel(DatagramChannel channel) {
>>>> this.datagramChannel = channel;
>>>> }
>>>> }
>>>>
>>>> ------------------------------------------------------------------------
>>>>
>>>>
>>>> /*
>>>> * The contents of this file are subject to the terms
>>>> * of the Common Development and Distribution License
>>>> * (the License). You may not use this file except in
>>>> * compliance with the License.
>>>> *
>>>> * You can obtain a copy of the license at
>>>> * https://glassfish.dev.java.net/public/CDDLv1.0.html or
>>>> * glassfish/bootstrap/legal/CDDLv1.0.txt.
>>>> * See the License for the specific language governing
>>>> * permissions and limitations under the License.
>>>> *
>>>> * When distributing Covered Code, include this CDDL
>>>> * Header Notice in each file and include the License file
>>>> * at glassfish/bootstrap/legal/CDDLv1.0.txt.
>>>> * If applicable, add the following below the CDDL Header,
>>>> * with the fields enclosed by brackets [] replaced by
>>>> * you own identifying information:
>>>> * "Portions Copyrighted [year] [name of copyright owner]"
>>>> *
>>>> * Copyright 2007 Sun Microsystems, Inc. All rights reserved.
>>>> */
>>>> package com.sun.grizzly;
>>>>
>>>> import com.sun.grizzly.Controller.Protocol;
>>>> import com.sun.grizzly.util.ByteBufferInputStream;
>>>> import com.sun.grizzly.util.OutputWriter;
>>>> import java.io.IOException;
>>>> import java.net.SocketAddress;
>>>> import java.nio.ByteBuffer;
>>>> import java.nio.channels.AlreadyConnectedException;
>>>> import java.nio.channels.NotYetConnectedException;
>>>> import java.nio.channels.SelectableChannel;
>>>> import java.nio.channels.SelectionKey;
>>>> import java.nio.channels.SocketChannel;
>>>> import java.util.concurrent.CountDownLatch;
>>>> import java.util.concurrent.TimeUnit;
>>>>
>>>> /**
>>>> * Non blocking TCP 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 TCPSelectorHandler(true) means the Selector will be used
>>>> only
>>>> * // for client operation (OP_READ, OP_WRITE, OP_CONNECT).
>>>> * TCPSelectorHandler tcpSelectorHandler = new
>>>> TCPSelectorHandler(true); *
>>>> controller.setSelectorHandler(tcpSelectorHandler);
>>>> * TCPConnectorHandler tcpConnectorHandler = new
>>>> TCPConnectorHandler();
>>>> * tcpConnectorHandler.connect(localhost,port, new
>>>> CallbackHandler(){...},
>>>> * tcpSelectorHandler);
>>>> * TCPConnectorHandler tcpConnectorHandler2 = new
>>>> TCPConnectorHandler();
>>>> * tcpConnectorHandler2.connect(localhost,port, new
>>>> CallbackHandler(){...},
>>>> * tcpSelectorHandler);
>>>> *
>>>> * Not recommended (but still works)
>>>> * ---------------------------------
>>>> * TCPConnectorHandler tcpConnectorHandler = new
>>>> TCPConnectorHandler();
>>>> * tcpConnectorHandler.connect(localhost,port);
>>>> *
>>>> * Internally, an new Controller will be created everytime
>>>> connect(localhost,port)
>>>> * is invoked, which has an impact on performance.
>>>> *
>>>> * @author Jeanfrancois Arcand
>>>> */
>>>> public class TCPConnectorHandler implements
>>>> ConnectorHandler<TCPSelectorHandler, SocketChannel>{
>>>> /**
>>>> * The underlying TCPSelectorHandler used to mange SelectionKeys.
>>>> */
>>>> private TCPSelectorHandler selectorHandler;
>>>> /**
>>>> * A <code>CallbackHandler</code> handler invoked by the
>>>> TCPSelectorHandler
>>>> * when a non blocking operation is ready to be processed.
>>>> */
>>>> private CallbackHandler callbackHandler;
>>>> /**
>>>> * A blocking <code>InputStream</code> that use a pool of Selector
>>>> * to execute a blocking read operation.
>>>> */
>>>> private ByteBufferInputStream inputStream;
>>>> /**
>>>> * The connection's SocketChannel.
>>>> */
>>>> private SocketChannel socketChannel;
>>>> /**
>>>> * Is the connection established.
>>>> */
>>>> private volatile boolean isConnected;
>>>> /**
>>>> * The internal Controller used (in case not specified).
>>>> */
>>>> private Controller controller;
>>>>
>>>> /**
>>>> * IsConnected Latch related
>>>> */
>>>> private CountDownLatch isConnectedLatch; /**
>>>> * Are we creating a controller every run.
>>>> */
>>>> private boolean isStandalone = false;
>>>> /**
>>>> * Connect to hostname:port. When an aysnchronous event happens
>>>> (e.g * OP_READ or OP_WRITE), the <code>Controller</code> will
>>>> invoke * the CallBackHandler.
>>>> * @param remoteAddress remote address to connect
>>>> * @param callbackHandler the handler invoked by the Controller
>>>> when * an non blocking operation is ready to be handled.
>>>> * @throws java.io.IOException */
>>>> public void connect(SocketAddress remoteAddress,
>>>> CallbackHandler callbackHandler) throws
>>>> IOException {
>>>> connect(remoteAddress,null,callbackHandler); }
>>>> /**
>>>> * Connect to hostname:port. When an aysnchronous event happens
>>>> (e.g * OP_READ or OP_WRITE), the <code>Controller</code> will
>>>> invoke * the CallBackHandler.
>>>> * @param remoteAddress remote address to connect
>>>> * @param localAddress local address to bind
>>>> * @param callbackHandler the handler invoked by the Controller
>>>> when * an non blocking operation is ready to be handled.
>>>> * @throws java.io.IOException */
>>>> public void connect(SocketAddress remoteAddress, SocketAddress
>>>> localAddress,
>>>> CallbackHandler callbackHandler) throws
>>>> IOException { if (controller == null){
>>>> throw new IllegalStateException("Controller cannot be
>>>> null");
>>>> }
>>>> connect(remoteAddress,localAddress,callbackHandler,
>>>>
>>>> (TCPSelectorHandler)controller.getSelectorHandler(protocol()));
>>>> }
>>>> /**
>>>> * Connect to hostname:port. When an aysnchronous event happens
>>>> (e.g * OP_READ or OP_WRITE), the <code>Controller</code> will
>>>> invoke * the CallBackHandler.
>>>> * @param remoteAddress remote address to connect
>>>> * @param callbackHandler the handler invoked by the Controller
>>>> when * an non blocking operation is ready to be handled.
>>>> * @param selectorHandler an instance of SelectorHandler.
>>>> * @throws java.io.IOException */
>>>> public void connect(SocketAddress remoteAddress,
>>>> CallbackHandler callbackHandler,
>>>> TCPSelectorHandler selectorHandler) throws
>>>> IOException {
>>>> connect(remoteAddress,null,callbackHandler,selectorHandler);
>>>> } /**
>>>> * Connect to hostname:port. When an aysnchronous event happens
>>>> (e.g * OP_READ or OP_WRITE), the <code>Controller</code> will
>>>> invoke * the CallBackHandler.
>>>> * @param remoteAddress remote address to connect
>>>> * @param localAddress local address to bin
>>>> * @param callbackHandler the handler invoked by the Controller
>>>> when * an non blocking operation is ready to be handled.
>>>> * @param selectorHandler an instance of SelectorHandler.
>>>> * @throws java.io.IOException */
>>>> public void connect(SocketAddress remoteAddress, SocketAddress
>>>> localAddress,
>>>> CallbackHandler callbackHandler,
>>>> TCPSelectorHandler selectorHandler) throws
>>>> IOException {
>>>> if (isConnected){
>>>> throw new AlreadyConnectedException();
>>>> }
>>>> if (controller == null){
>>>> throw new IllegalStateException("Controller cannot be
>>>> null");
>>>> }
>>>> if (selectorHandler == null){
>>>> throw new IllegalStateException("Controller cannot be
>>>> null");
>>>> }
>>>> this.selectorHandler = selectorHandler;
>>>> this.callbackHandler = callbackHandler;
>>>> // Wait for the onConnect to be invoked.
>>>> isConnectedLatch = new CountDownLatch(1);
>>>> selectorHandler.connect(remoteAddress,localAddress,callbackHandler);
>>>> inputStream = new ByteBufferInputStream();
>>>>
>>>> try {
>>>> isConnectedLatch.await(30, TimeUnit.SECONDS);
>>>> } catch (InterruptedException ex) {
>>>> throw new IOException(ex.getMessage());
>>>> }
>>>> }
>>>>
>>>> /**
>>>> * 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.
>>>> * @param remoteAddress remote address to connect
>>>> * @throws java.io.IOException */
>>>> public void connect(SocketAddress remoteAddress)
>>>> throws IOException {
>>>> connect(remoteAddress,(SocketAddress)null); }
>>>> /**
>>>> * 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.
>>>> * @param remoteAddress remote address to connect
>>>> * @throws java.io.IOException * @param localAddress local
>>>> address to bin
>>>> */
>>>> public void connect(SocketAddress remoteAddress, SocketAddress
>>>> localAddress) throws IOException {
>>>> if (isConnected){
>>>> throw new AlreadyConnectedException();
>>>> }
>>>> if (controller == null){ isStandalone
>>>> = true;
>>>> controller = new Controller();
>>>> controller.setSelectorHandler(new
>>>> TCPSelectorHandler(true));
>>>> DefaultPipeline pipeline = new DefaultPipeline();
>>>> pipeline.initPipeline();
>>>> pipeline.startPipeline();
>>>> controller.setPipeline(pipeline);
>>>>
>>>> callbackHandler = new CallbackHandler<Context>(){
>>>> public void onConnect(IOEvent<Context> ioEvent) {
>>>> SelectionKey key =
>>>> ioEvent.attachment().getSelectionKey();
>>>> socketChannel = (SocketChannel)key.channel();
>>>> finishConnect(key);
>>>>
>>>> getController().registerKey(key,SelectionKey.OP_WRITE,
>>>> Protocol.TCP);
>>>> }
>>>> public void onRead(IOEvent<Context> ioEvent) {
>>>> }
>>>> public void onWrite(IOEvent<Context> ioEvent) {
>>>> }
>>>> };
>>>>
>>>> final CountDownLatch latch = new CountDownLatch(1);
>>>> try{
>>>> pipeline.execute(new Context(){
>>>> public Object call() throws Exception {
>>>> latch.countDown();
>>>> controller.start();
>>>> return null;
>>>> } });
>>>> } catch (PipelineFullException ex){
>>>> throw new IOException(ex.getMessage());
>>>> }
>>>> try {
>>>> latch.await(); Thread.sleep(1000);
>>>> } catch (InterruptedException ex) {
>>>> }
>>>> }
>>>> connect(remoteAddress,localAddress,callbackHandler,
>>>>
>>>> (TCPSelectorHandler)controller.getSelectorHandler(protocol()));
>>>> }
>>>> /**
>>>> * Read bytes. If blocking is set to <tt>true</tt>, a pool of
>>>> temporary
>>>> * <code>Selector</code> will be used to read bytes.
>>>> * @param byteBuffer The byteBuffer to store bytes.
>>>> * @param blocking <tt>true</tt> if a a pool of temporary Selector
>>>> * is required to handle a blocking read.
>>>> * @return number of bytes read
>>>> * @throws java.io.IOException */
>>>> public long read(ByteBuffer byteBuffer, boolean blocking)
>>>> throws IOException {
>>>> if (!isConnected){
>>>> throw new NotYetConnectedException();
>>>> }
>>>> SelectionKey key =
>>>> socketChannel.keyFor(selectorHandler.getSelector());
>>>> if (blocking){
>>>> inputStream.setSelectionKey(key);
>>>> return inputStream.read(byteBuffer);
>>>> } else {
>>>> if (callbackHandler == null){
>>>> throw new IllegalStateException
>>>> ("Non blocking read needs a CallbackHandler");
>>>> }
>>>> int nRead = socketChannel.read(byteBuffer);
>>>>
>>>> if (nRead == 0){
>>>> key.attach(callbackHandler);
>>>> selectorHandler.register(key,SelectionKey.OP_READ);
>>>> }
>>>> return nRead;
>>>> }
>>>> }
>>>> /**
>>>> * Writes bytes. If blocking is set to <tt>true</tt>, a pool of
>>>> temporary
>>>> * <code>Selector</code> will be used to writes bytes.
>>>> * @param byteBuffer The byteBuffer to write.
>>>> * @param blocking <tt>true</tt> if a a pool of temporary Selector
>>>> * is required to handle a blocking write.
>>>> * @return number of bytes written
>>>> * @throws java.io.IOException */ public long
>>>> write(ByteBuffer byteBuffer, boolean blocking) throws IOException {
>>>> if (!isConnected){
>>>> throw new NotYetConnectedException();
>>>> }
>>>> SelectionKey key =
>>>> socketChannel.keyFor(selectorHandler.getSelector());
>>>> if (blocking){
>>>> return
>>>> OutputWriter.flushChannel(socketChannel,byteBuffer);
>>>> } else {
>>>> if (callbackHandler == null){
>>>> throw new IllegalStateException
>>>> ("Non blocking write needs a
>>>> CallbackHandler");
>>>> }
>>>> int nWrite = 1;
>>>> while (nWrite > 0 && byteBuffer.hasRemaining()){
>>>> nWrite = socketChannel.write(byteBuffer);
>>>> }
>>>> if (nWrite == 0 && byteBuffer.hasRemaining()){
>>>> key.attach(callbackHandler);
>>>> selectorHandler.register(key,SelectionKey.OP_WRITE);
>>>> } return nWrite;
>>>> }
>>>> }
>>>>
>>>> /**
>>>> * Close the underlying connection.
>>>> */
>>>> public void close() throws IOException{
>>>> if (socketChannel != null){
>>>> if (selectorHandler != null){
>>>> SelectionKey key =
>>>> socketChannel.keyFor(selectorHandler.getSelector());
>>>> if (key == null) return;
>>>> key.cancel();
>>>> key.attach(null);
>>>> }
>>>> socketChannel.close(); }
>>>> if (controller != null && isStandalone){
>>>> controller.stop();
>>>> controller = null;
>>>> } isStandalone = false;
>>>> }
>>>>
>>>> /**
>>>> * Finish handling the OP_CONNECT interest ops.
>>>> * @param key - a <code>SelectionKey</code>
>>>> */
>>>> public void finishConnect(SelectionKey key){
>>>> try{
>>>> socketChannel = (SocketChannel)key.channel();
>>>> socketChannel.finishConnect();
>>>> isConnected = socketChannel.isConnected();
>>>> } catch (IOException ex){
>>>> // XXX LOG ME
>>>> ex.printStackTrace();
>>>> } finally {
>>>> isConnectedLatch.countDown();
>>>> }
>>>> }
>>>> public void setUnderlyingChannel(SocketChannel
>>>> socketChannel) {
>>>> this.socketChannel = socketChannel;
>>>> }
>>>> /**
>>>> * A token decribing the protocol supported by an
>>>> implementation of this
>>>> * interface
>>>> * @return this <code>ConnectorHandler</code>'s protocol
>>>> */
>>>> public Controller.Protocol protocol(){
>>>> return Controller.Protocol.TCP;
>>>> }
>>>> /**
>>>> * Is the underlying SocketChannel connected.
>>>> * @return <tt>true</tt> if connected, otherwise <tt>false</tt>
>>>> */
>>>> public boolean isConnected(){
>>>> return isConnected;
>>>> } public Controller getController() {
>>>> return controller;
>>>> }
>>>>
>>>> public void setController(Controller controller) {
>>>> this.controller = controller;
>>>> }
>>>>
>>>> public SocketChannel getUnderlyingChannel() {
>>>> return socketChannel;
>>>> }
>>>>
>>>> public CallbackHandler getCallbackHandler() {
>>>> return callbackHandler;
>>>> }
>>>>
>>>> public void setCallbackHandler(CallbackHandler callbackHandler) {
>>>> this.callbackHandler = callbackHandler;
>>>> }
>>>>
>>>> public TCPSelectorHandler getSelectorHandler() {
>>>> return selectorHandler;
>>>> }
>>>> }
>>>>
>>>>
>>>> ------------------------------------------------------------------------
>>>>
>>>>
>>>> ---------------------------------------------------------------------
>>>> To unsubscribe, e-mail: users-unsubscribe_at_grizzly.dev.java.net
>>>> For additional commands, e-mail: users-help_at_grizzly.dev.java.net
>>>>
>>
>> ---------------------------------------------------------------------
>> To unsubscribe, e-mail: users-unsubscribe_at_grizzly.dev.java.net
>> For additional commands, e-mail: users-help_at_grizzly.dev.java.net
>>
>
> ---------------------------------------------------------------------
> To unsubscribe, e-mail: users-unsubscribe_at_grizzly.dev.java.net
> For additional commands, e-mail: users-help_at_grizzly.dev.java.net
>