java.nioで他のチャネルを正しく発火させる方法は？

Question

キー入力とソケット通信を非同期に取り扱いたく、java.nioを使ってお試しプログラムを作ってみました。キー入力する側をstdinPipe、ソケット通信する側をSocketChannelとしています。

stdinPipeでキー入力を受け取った時、SocketChannelにそのバッファを書き込み、送信タイミングを作るためにSelectionKey.interestOps(SelectionKey.OP_WRITE);するようにコーディングしています。

実行した結果、SocketChannel.write()は成功（送信バイト数が返る）しているように見えるのですが、ネットワーク上にデータが流れず、又、SelectionKey.OP_WRITEが無限ループしてしまいます。

あるチャネル（stdinPipe)から、他のチャネル（SocketChannel）を発火させる正しい方法は、どのようなコードになるのでしょうか？何か良い例があればご教授いただけないでしょうか。

以下、期待通り動かないプログラムを載せておきます。

Main:

    	public static void main(String[] args) throws Exception {
		Selector selector = Selector.open();
		
		final Socket socket = new Socket();
		SocketChannel socketChannel = SocketChannel.open();
		socketChannel.configureBlocking(true);
		socketChannel.connect(new InetSocketAddress("localhost", 50000));
		System.out.println("connected.");
		socketChannel.configureBlocking(false);
		IOHandler ioHandler = new IOHandler();
		SelectionKey sckey = socketChannel.register(
			selector, 
			SelectionKey.OP_READ, 
			ioHandler
		);

		SystemInPipe stdinPipe = new SystemInPipe();
		SelectableChannel stdinChannel = stdinPipe.getStdinChannel();
		stdinChannel.register(
			selector,
			SelectionKey.OP_READ,
			new StdinHandler(sckey)
		);
		stdinPipe.start();
		
		System.out.println("selecting...");
		while(selector.select() > 0) {
			Set keys = selector.selectedKeys();

			for (Iterator it = keys.iterator(); it.hasNext(); ) {
				SelectionKey key = (SelectionKey)it.next();
				it.remove();
				Handler handler = (Handler)key.attachment();
                handler.handle(key);
            }
		}

	}

stdinPipe:

package example;

import java.io.DataOutputStream;
import java.io.IOException;
import java.net.Socket;
import java.nio.ByteBuffer;
import java.nio.channels.ClosedChannelException;
import java.nio.channels.ReadableByteChannel;
import java.nio.channels.SelectionKey;

public class StdinHandler implements Handler {
	private SelectionKey selectionKey = null;

	public StdinHandler(SelectionKey selectionKey) {
		this.selectionKey = selectionKey;
	}

	@Override
	public void handle(SelectionKey key) throws ClosedChannelException, IOException {
		ByteBuffer buffer = ByteBuffer.allocate(32);
		ReadableByteChannel channel = (ReadableByteChannel) key.channel();
		if (channel.read(buffer) <= 1) {
			System.out.println("program completed.");
			channel.close();
			System.exit(-1); // @TODO 段取りを踏んだ終わり方に変更する
		}
		buffer.flip();
		while (buffer.hasRemaining()) {
			System.out.print((char) buffer.get());
		}
		System.out.println();		
		
		buffer.flip();
		if (selectionKey != null) {
			IOHandler handler = (IOHandler)selectionKey.attachment();
			handler.setBuffer(buffer);
			selectionKey.interestOps(SelectionKey.OP_WRITE);
		}
		
		buffer.clear();
	}

}

socketChannel:

package example;

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.ClosedChannelException;
import java.nio.channels.SelectionKey;
import java.nio.channels.SocketChannel;
import java.util.ArrayList;
import java.util.List;

import javax.xml.bind.DatatypeConverter;

/*
 * @see 出典: http://itpro.nikkeibp.co.jp/article/COLUMN/20060515/237871/
 */
public class IOHandler implements Handler {
    private final static int BUFFER_SIZE = 4096;

    private List<ByteBuffer> buffers;

    public IOHandler() {
        // 読み込んだデータを格納するためのリストの初期化
        buffers = new ArrayList<ByteBuffer>();
    }
    
    public void setBuffer(ByteBuffer buffer) {
    	buffers.add(buffer);
    }
    
    public void handle(SelectionKey key)
                    throws ClosedChannelException, IOException {
        SocketChannel channel = (SocketChannel)key.channel();

        // 読みこみ可であれば、読みこみを行う
        if (key.isReadable()) {
            read(key);
        }

        // 書きこみ可であれば、書きこみを行う
        if (key.isWritable() && key.isValid()) {
            write(key);
        }
    }

    private void read(SelectionKey key)
                    throws ClosedChannelException, IOException {
        SocketChannel channel = (SocketChannel)key.channel();

        // 読みこみ用のバッファの生成
        ByteBuffer buffer = ByteBuffer.allocate(BUFFER_SIZE);
 
        // 読みこみ
        channel.read(buffer);

        // フリップしてからリストに追加
        buffer.flip();
        buffers.add(buffer);
        
        if (key.interestOps()
            != (SelectionKey.OP_READ | SelectionKey.OP_WRITE)) {
            // 読みこみ操作に対する監視を行う
            key.interestOps(SelectionKey.OP_READ 
                            | SelectionKey.OP_WRITE);
        }
    }

    private void write(SelectionKey key)
                    throws ClosedChannelException, IOException {
        SocketChannel channel = (SocketChannel)key.channel();

        if (!buffers.isEmpty()) {
            // リストが空でなければ、先頭のバッファを取り出し
            // 書きこみを行う
            ByteBuffer buffer = buffers.get(0);
            int size = channel.write(buffer);
            System.out.println("write size= " + size);
            String hexString = DatatypeConverter.printHexBinary(buffer.array());
            System.out.println(hexString);
            
            key.interestOps(SelectionKey.OP_READ);
            
            try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
            
            // 書きこみが終わったバッファは削除する
            buffers.remove(0);
        } else {
            // 書きこむデータがなければ、書きこみ操作の監視をやめる
            key.interestOps(SelectionKey.OP_READ);
        }
    }
}

Answer 1

自己解決しました。ただ期待通りに動かなかったのは私の設計ミスが原因でした。
申し訳ありません。
java.nioの使い方はまずくなかったようです。

私の設計では、サーバクライアントともport=50000で待つことになります。
実行環境はサーバ、クライアントともlocalhostだったためです。
（クライアント側も上記ポートでreadしていました）

相手（サーバ）に送ったはずのメッセージが、自分自身（クライアント）で受信されていました。

まだ詳細は掴み切れていないため、
詳しい状況が判明した上でご報告すべきだと思うのですが、
見てくださっている方々に無駄なお手数をかけていただくまいと思い、
中途半端な状況ではありますが、
自身で解決すべきと思い、クローズさせていただきます。

Comments

[eripong]

了解です。
クライアントでも50000ポートでlistenしている箇所があったと言うことでしょうか？

できれば、解決した後でいいので、
結果を教えていただけると嬉しいです。

一応、現時点で気になっていることは、

1.そう言えばWireSharkはローカルの通信は
キャプチャー出来なかったような。未確認です。

2.クライアントでもサーバから受信したデータを
そのままサーバに送信するようなコードがあるが、
これだとデータをエコーし合ってしまうのではないか？

です。関係無さそうなら無視してください。

Answer 2

StdinHandlerのーhandleメソッドの最後でbuffer.clear();していますが、
これがあると余計な0がwriteされてしまいそうですが、
意図通りでしょうか？

何故動作しないのかについては、
まだ分からないので、追加で情報をいただきたいです。
私が自分で試せればよいのですが、ちょっと今は使える環境がないもので、
できればお願いします。

ネットワークにパケットが流れないというのは、
何を持って判断していますか？
また、無限ループとは、どこからどこまでの処理がどの様に無限ループするのでしょうか？
通信先のプログラムはどの様なものですか？

Comments

[eripong]

実行した結果のコンソール出力内容も、できれば欲しいです。

[tchofu]

追加情報をご報告いたします。
サーバは、末尾に引用したサーバ（ネットで見つけたシンプルなEchoServer）を使っています。パケットはWireSharkでモニタしています。

```python:
#!/usr/bin/env python

"""
A simple echo server

http://ilab.cs.byu.edu/python/socket/echoserver.html

"""

import socket

host = ''
port = 50000
backlog = 5
size = 1024
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.bind((host,port))
s.listen(backlog)
while 1:
client, address = s.accept()
data = client.recv(size)
if data:
client.send(data)

```

[eripong]

コメントありがとうございます。

WireSharkで、接続で3way handshakeが終わった後、何もパケットが流れないということで認識あっていますでしょうか？
また、貼っていただいたEchoServerは、recv、sendした後、
またacceptしてclientを上書きしていますが、これは意図通りでしょうか？
whileの前でacceptした方が良いのかなと思います。

それと、他の質問については、
追加情報いただけないでしょうか？

[tchofu]

お詫びさせてください。
Java.nioの使い方ではなく、私のプログラムの設計が間違えていました。
親身になっていただき、ありがとうございました。
詳細は自己解決欄にて