# NIO:channel.close() auf Client scheinbar vom Server ignorier



## LarsbrauchtHilfe (16. Jan 2006)

Ich versuche im Rahmen eines Hochschul Softwareprojekts mit NewIO die Basis für einen performaten TCP/IP Server zu legen, auf dessen Basis ein Spiel entstehen soll. Auf der Server Seite kommen dazu Channel, Selector und Keys zum Einsatz. 

Im Prinzip funktioniert das ganze schon, und der Client kann eine kurze Nachricht in die "Leitung" stecken die der Server dann einfach per Systt.out.writln ausgibt. Wenn der Client allerdings beendet oder den Channel schließt, wird der Key beim Server nicht deregistriert, der Status des Channels scheint unverändert (isOpen gibt true zurück). Ich würde aber erwarten das der Server den Channel schließt und damit die Resourcen wieder freigibt. Hab ich da was falsch verstanden?

 Wird der Channel im Client erst in der Methode connect definiert, bekommt der Server interssanterweise eine IOException sobald der Scope verlassen wird, womit er dann selber die Verbindung beenden kann. Das ist aber normalerweise ja nicht der Fall. 

Hab als Basis für meine Entwicklung einen HTTP Server Modell genommen, dort wird nach jeder Anfrage die Verbindung vom Server eh beendet. Bei meinem Server soll die TCP verbindung allerdings aufrechterhalten werden. Möglicherweise liegt darin letztlich das Problem...

*Hier der Code für den Client:*


```
import java.io.IOException;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.net.SocketAddress;
import java.net.UnknownHostException;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;
import java.nio.charset.Charset;
import java.nio.charset.CharsetDecoder;
import java.nio.charset.CharsetEncoder;

public class Client {
	private SocketChannel channel;
	private Charset asciiCharset;
	private CharsetDecoder asciiCharsetDecoder;
	private CharsetEncoder asciiCharsetEncoder;
	private ByteBuffer readBuffer;
	
	public Client() {
	    // Für die ByteBuffer <-> String Umwandlung
	    asciiCharset = Charset.forName("US-ASCII");
	    asciiCharsetDecoder = asciiCharset.newDecoder();
	    asciiCharsetEncoder = asciiCharset.newEncoder();
	}
	
	public boolean connect(String address, int port) {
		try {
			channel = SocketChannel.open(new InetSocketAddress(address,port));
	} catch (UnknownHostException e) {
		e.printStackTrace();
		return false;
	} catch (IOException e){
		e.printStackTrace();
		return false;
	} 
		return true;
	}
	
	public boolean login(String username, String password) {
		try {
			channel.write(asciiCharset.encode("Hello World\r\n"));
			System.out.println("Wrote to channel :-)");
		} catch (IOException e) {
			e.printStackTrace();
		}
		return false;
	}
	
	public void close() {
		if(null!=channel) {
			try {
				channel.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
	
	
	public static void main (String[] args) {
		String host = "127.0.0.1";
		int port = 8000;
		
		Client client = new Client();
		if(client.connect(host,port)) {
			System.out.println("Connection to "+host+":"+port+" established.");
			client.login("lars","meinpw");
			client.close();
		}
	}
}
```

*Und Code für den Server, acceptConnectionThread und LoginManagerThread im Anschluss*


```
import java.nio.channels.Selector;

public class Server {
	  private static final int HTTPD_PORT = 8000;


	  private AcceptConnectionsThread acceptConnectionsThread;
	  private LoginManagerThread loginManagerThread;

	  public static void main(String[] args) {
	    int port = HTTPD_PORT;

	    try {
	      Server s = new Server(port);
	      s.start();
	    } catch(Exception ex) {
	      System.err.println(ex);
	    }
	  }

	  public Server(int port) throws Exception {
	    Selector acceptSelector = Selector.open();
	    Selector readSelector = Selector.open();
	    
	    ConnectionList connections = new ConnectionList(readSelector);
	    acceptConnectionsThread = new AcceptConnectionsThread(acceptSelector, connections, port);
	    loginManagerThread = new LoginManagerThread(readSelector, connections);
	  }

	  public void start() {
	    acceptConnectionsThread.start();
	    loginManagerThread.start();
	  }
	}
```



*Der AcceptConnectionsThread*


```
import java.net.InetSocketAddress;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Iterator;
import java.util.Set;



class AcceptConnectionsThread extends Thread {
	  private ServerSocketChannel ssc;
	  private Selector connectSelector;
	  private ConnectionList acceptedConnections;

	  public AcceptConnectionsThread(Selector connectSelector, ConnectionList list, int port) throws Exception {
	    super("AcceptConnections");

	    this.connectSelector = connectSelector;
	    this.acceptedConnections = list;

	    ssc = ServerSocketChannel.open();
	    ssc.configureBlocking(false);

	    InetSocketAddress address = new InetSocketAddress(port);
	    ssc.socket().bind(address);

      System.out.println("Bound to " + address);

	    ssc.register(this.connectSelector, SelectionKey.OP_ACCEPT);
	  }
	   
	  public void run() {
	    while(true) {
	      try {
	        //if(Server.verbose) 
	          System.out.println("AcceptThread: Selecting");

	        connectSelector.select();

	        acceptPendingConnections();
	      } catch(Exception ex) {
	        ex.printStackTrace();
	      }
	    }
	  }

	  protected void acceptPendingConnections() throws Exception {
	    Set readyKeys = connectSelector.selectedKeys();

	    for(Iterator i = readyKeys.iterator(); i.hasNext(); ) {
	      SelectionKey key = (SelectionKey)i.next();
	      i.remove();

	      ServerSocketChannel readyChannel = (ServerSocketChannel)key.channel();

	      SocketChannel incomingChannel = readyChannel.accept();

	        System.out.println("AcceptThread: Connection from " + incomingChannel.socket().getInetAddress() +":"+ incomingChannel.socket().getPort());

	      acceptedConnections.push(incomingChannel);
	    }
	  }
	}
```

*Der LoginManagerThread, hier wird der Channel ausgelesen*



```
import java.io.IOException;
import java.net.Socket;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.nio.charset.Charset;
import java.nio.charset.CharsetDecoder;
import java.util.Iterator;
import java.util.Set;



class LoginManagerThread extends Thread {
	private static final int READ_BUFFER_SIZE = 16;  
	
	private ServerSocketChannel ssc;
	private Selector readSelector;
	private ConnectionList acceptedConnections;
	private Charset asciiCharset;
	private CharsetDecoder asciiCharsetDecoder;
	private ByteBuffer readBuffer;
	  
	  public LoginManagerThread(Selector readSelector, ConnectionList acceptedConnections) throws Exception {
	    super("LoginManager");

	    this.readSelector = readSelector;
	    this.acceptedConnections = acceptedConnections;

	    // hier werden Teile des Requests reingelesen
	    this.readBuffer = ByteBuffer.allocateDirect(READ_BUFFER_SIZE);
	    
	    // Für die ByteBuffer <-> String Umwandlung
	    asciiCharset = Charset.forName("US-ASCII");
	    asciiCharsetDecoder = asciiCharset.newDecoder();
	    //responseBuffers[0] = initializeResponseHeader();


	  }
	   
	  public void run() {
	    while(true) {
	        try {
      
	          registerNewChannels();
	      
	          int keysReady = readSelector.select();
	          //System.out.println("ready keys: "+Integer.toString(keysReady));
	          if(keysReady > 0) {
	            acceptPendingRequests();
	          }
	        } catch(Exception ex) {
	          ex.printStackTrace();
	        }
	        
	      // slow down server  (zum debuggen)
	    try {
	        sleep(500); 
	    } catch (Exception e) {
	    	e.printStackTrace();
	    	
	    }
	      }
	  }

	  protected void registerNewChannels() throws Exception {
	    SocketChannel channel;
	    while(null != (channel = acceptedConnections.removeFirst())) {
	    	System.out.println("Register Channel to read from: "+channel.socket().getPort());
	    	channel.configureBlocking(false);
	      channel.register(readSelector, SelectionKey.OP_READ, new StringBuffer());
	    }  
	  }
	  
	  protected void acceptPendingRequests() throws Exception {
	    Set readyKeys = readSelector.selectedKeys();
	    
	    
	    for(Iterator i = readyKeys.iterator(); i.hasNext(); ) {
	    	//System.out.println("Channel ready for read");
	    SelectionKey key = (SelectionKey)i.next();
	      i.remove();
	      //System.out.println("isopen: "+key.channel().isOpen());
	      readRequest(key);
	    }
	  }
	  
	  protected void readRequest(SelectionKey key) throws Exception {
	    SocketChannel incomingChannel = (SocketChannel)key.channel();
	    Socket incomingSocket = incomingChannel.socket();
	    
	    try {
	      int bytesRead = incomingChannel.read(readBuffer);
	      readBuffer.flip();
	      String result = asciiCharsetDecoder.decode(readBuffer).toString();
	      readBuffer.clear();
	      System.out.println("Empfange: "+result);
	      
	      StringBuffer requestString = (StringBuffer)key.attachment();
	      
	      requestString.append(result);
	      
	      if(result.endsWith("\n\n") || result.endsWith("\r\n\r\n")) {
	          handleCompletedRequest(requestString.toString(), incomingChannel);
	      }
	    } 
	    // Brauch ich die RequestException aus dem Server Beispiel?
	    /*catch(RequestException re) {
	      sendError(incomingChannel, re);
	    } */catch(IOException ioe) {
	    	//ioe.printStackTrace();
	    	// close channel!
	    	incomingChannel.close();
	    	System.out.println("Achtung: IOException! Wahrscheinlich weil remote host die verbindung beendet hat. Channel wird geschlossen und damit keys deregistriert!");
	    	//sendError(incomingChannel, RequestException.INTERNAL_SERVER_ERROR);
	    }
	  }
	    
	    protected void handleCompletedRequest(String request, SocketChannel channel) throws 


/*RequestException,*/ IOException {
	        /*StringTokenizer tok = new StringTokenizer(request);
	        tok.nextToken();                       // skip the method
	        String path = tok.nextToken();         // grab the URI, ignore the rest

	        sendFile(path, channel);
	        
	        Server.statistics.request();
	        
	        // This behaves like HTTP 1.0, close connection
	        // after handling the request.
	        channel.close();*/
	    	// Gib mal komplette erhaltene Nachricht aus
	    	System.out.println("Komplette Nachricht von:");
	      }
	  }
```


----------



## semi (16. Jan 2006)

Schau Dir das hier an. Working wih Selectors
Insbesondere das mit "selectionKey.cancel();" bei Exceptions.


----------



## LarsbrauchtHilfe (17. Jan 2006)

Hm, die Server Beispiele schließen die Verbindung immer selbst nach dem RequestHAndling. Mein Server macht das aber nicht, weil die Verbindung bestehen bleiben soll. Vielleicht ist die Frage also: Wie bekommt der server den disconnect des clients mit? einfach ein timout für den channel oder gar auf applications ebene (kein input für user) setzen?


----------



## semi (17. Jan 2006)

Was sagt eigentlich channel.isConnected()?
Ansonsten kriegst Du auch eine ClosedChannelException, wenn Du versuchst auf eine 
von der Gegenstelle unterbrochene Verbindung zuzugreifen.


----------

