Nio write problem: server data sent isn't fully read by client

Question

Hi everyone,
still writing away with my nio server and once again have run into
some problems. Essentially my main problem is that when the server
writes to the client, the write appears to output all the bytes in the
write operation, but the client never accepts them all, even if a
buffer has been manually allocated to the correct size of the data.
As background my server will accept connections. When a connection
is established I register OP_READ on the key. When a OP_READ trigger
occurs the server accepts the clients request, processes it, then
attaches the output to the SelectionKey as a ByteBuffer that has
already been encoded. At this point I then register OP_WRITE on that
SelectionKey (as a side note i'm running this server on XP and had
read that registering OP_READ and OP_WRITE on the same selector was
bad, but then it looked like there was a work around to this) and wait
for an OP_WRITE trigger.
When an OP_WRITE occurs on that key I run a new method (with heavy
influences from the thread: http://forum.java.sun.com/thread.jsp?forum=11&thread=530825 and the taming the nio circus thread) which will grab the attachment and attempt to send it. The code has been written that IF the send cannot complete it should re-attach the remaining bytebuffer to the key and wait for another OP_WRITE to occur so it can send the remainder.
The problem is that whenever I write (and for this test the amount im writing is approx 10100 bytes) the server appears to send it all (by checking the int returned from socketchannel.write()), but at the client end it never reads all the data that is sent.
If i'm using a blocking socket client, then I get a java.net.SocketException: Connection Reset exception, whilst if i'm using a non-blocking client, I get no exception, just not the whole amount of data, even when i've statically allocated a receiving bytebuffer that is big enough.
The following code is a class that is used to do the writing from the server:
   /* code for nio write model referenced from:
     * http://forum.java.sun.com/thread.jsp?forum=11&thread=530825
    class NIOWriteHandler {
        private ByteBuffer sendBuffer;
        private SelectionKey localSelectionKey;
        NIOWriteHandler(SelectionKey currentKey) {
            localSelectionKey = currentKey;
        public void doWrite() {
            localSelectionKey.interestOps(SelectionKey.OP_READ);  //deselect write,
            sendBuffer = (ByteBuffer)localSelectionKey.attachment();
            // perform the writing
            SocketChannel writingChannel = (SocketChannel)localSelectionKey.channel();
            if (writingChannel.isOpen()) {
                int len = 0;
                if (sendBuffer.hasRemaining()) {
                    try {
                        System.out.println("Sending chunks o data");
                        len = writingChannel.write(sendBuffer);
                        System.out.println("value of len: " + len);
                    } catch (IOException ioe) {
                        ioe.printStackTrace();
                        // call close method
                        System.out.println("CLOSE INVOKED at POINT 8");
                        closeComplete(localSelectionKey);
                System.out.println("Second IF coming...");
                if (sendBuffer.hasRemaining()) {
                    // if we get here then the previous write did not fully
                    // complete, so need to save data etc
                    System.out.println("Couldn't send all data this time...");
                    localSelectionKey.interestOps(SelectionKey.OP_WRITE|SelectionKey.OP_READ);
                    localSelectionKey.attach(sendBuffer);
                } else {
                    sendBuffer = null;
                    closeComplete(localSelectionKey);
            // write complete at this stage
    }This is the basic block client that is incredibly dumb:
import java.net.*;
import java.util.*;
import java.io.*;
import java.nio.charset.*;
import java.nio.channels.*;
import java.nio.*;
import java.nio.ByteBuffer;
public class ServerTest {
    /* args 0 - the IP of the machine to connect to
       args 1 - the port number
       Simple client that connects to a specified IP & port, takes a line
       of input via stdin, sends that to the connected machine and prints
       out the response.
       Error handling and such isn't accounted for.
   public static void main (String args[]) throws Exception{
        Socket socket = new Socket(args[0], Integer.parseInt(args[1]));
        BufferedReader buffRead = new
            BufferedReader(new InputStreamReader((socket.getInputStream())));
        PrintStream ps =
            new PrintStream(socket.getOutputStream());
        Charset charset = Charset.forName("ISO-8859-1");
        BufferedReader stdin = new BufferedReader(new InputStreamReader(System.in));
        System.out.println("[CLIENT]Data to send: ");
        String data = stdin.readLine();
        ps.println(data);
        String returned = buffRead.readLine();
        while (returned != null) {
            System.out.println(returned);
            returned = buffRead.readLine();
        System.out.println("[CLIENT]End server response");
        buffRead.close();
        ps.close();
        socket.close();
}And here is the non-blocking basic client (which dosn't actually close at the moment):
import java.net.*;
import java.util.*;
import java.io.*;
import java.nio.charset.*;
import java.nio.channels.*;
import java.nio.*;
public class ServerTestNonBlock {
    /* args 0 - the IP of the machine to connect to
       args 1 - the port number
       Simple client that connects to a specified IP & port, takes a line
       of input via stdin, sends that to the connected machine and prints
       out the response.
       Error handling and such isn't accounted for.
   public static void main (String args[]) throws Exception{
        InetSocketAddress addr = new InetSocketAddress
            (args[0], Integer.parseInt(args[1]));
        SocketChannel sc = SocketChannel.open();
        sc.configureBlocking(false);
        Selector selector = Selector.open();
        System.out.println("Starting connection...");
        sc.connect(addr);
        while(!sc.finishConnect()) {
           System.out.println("1,2,3,4 I will keep on counting...");
        System.out.println("Connection established..");       
        Charset charset = Charset.forName("ISO-8859-1");
        CharsetEncoder encoder = charset.newEncoder();
        sc.register(selector, SelectionKey.OP_READ | SelectionKey.OP_WRITE);
        while (true) {
           int n = selector.select();
           if (n==0) {
              continue;
           Set keys = selector.selectedKeys();
           Iterator it = keys.iterator();
           while (it.hasNext()) {
              SelectionKey selKey = (SelectionKey)it.next();
              if (selKey.isReadable()) {
                 // time to setup read
                 ByteBuffer incomingData =
                    ByteBuffer.allocateDirect(102000);
                 incomingData.clear();
                 int count;
                 while ((count = sc.read(incomingData)) > 0) {
                    System.out.println("Value of count: " + count);
                    // reading the data
                 System.out.println("Count value: " + count);       
                 int pos = incomingData.position();
                 incomingData.flip();
                 CharBuffer content = charset.decode(incomingData);
                 String inData = content.toString();
                 System.out.println(inData.trim());
                 System.out.println("[CLIENT]End server response");
                 System.out.println("Count value: " + count);       
                 System.out.println("Position value: " + pos);       
                 //sc.close();
                 //break;
              if (selKey.isWritable()) {
                 BufferedReader stdin = new BufferedReader
                   (new InputStreamReader(System.in));
                 System.out.println("[CLIENT]Data to send: ");
                 String data = stdin.readLine();
                 ByteBuffer byteBufferOut = encoder.encode
                    (CharBuffer.wrap(data));
                 int length = sc.write(byteBufferOut);
                 System.out.println("Wrote: " + length + " bytes.");
                 selKey.interestOps(SelectionKey.OP_READ);
}I'm kinda stuck at the moment and am making change for the sake of change without getting a good grasp of what is going on. If anyone can provide any help that'd be fantastic. If in the mean time I figgure something out i'll post a response.
If you've gotten this far thanks a bunch for reading :)
Cheers,
Pete

Answer 1

Hi Meesum,
thanks for the reply :)
I'm not convinced this is the error - as i've got two clients listed there, and the odd behaviour from both is that neither is getting through to the last of the data that is sent.
If the null were the problem (which is only checked for in the basic dumb blocking client) i'd be expecting some sort of infinite loop or wait for more data from the server, not an abnormal termination (ala connection reset) from the server. I'll give it a shot anyhow, but I know that under a blocking write operation that that code worked fine.
Thanks again though for the post, has got some of my cogs slowly turning :)
Cheers,
Pete