Too many open file durant un test de charge [ServerSocketChannel]

Version imprimable

Bonjour,
J'ai fait un ServerSocketChannel qui traite des connexion client , et save les messages reçu dans un fichier.
J'attaque ce server avec une classe qui lance 20 Threads qui créent des sockets et envoient des messages.
Après environ 1 heure de traitement j'ai l'exception Too many open file .
Open file system : 32000.
Voila on thread Serveur :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
 
private class StartingServer extends Thread {
 
		public void run() {
 
			startServer(server, selector);
		}
 
		private void startServer(ServerSocketChannel server, final Selector selector) {
 
			while (isRunning) {
 
				try {
					selector.select();
					Iterator<SelectionKey> keys = selector.selectedKeys().iterator();
 
					while (keys.hasNext()) {
 
 
						SelectionKey key = keys.next();
						keys.remove();
 
						if (!key.isValid()) {
							continue;
						}
						try {
							//l'évenement correspond à une acceptation de connexion
							if(key.isAcceptable()) {
 
								SocketChannel channel = server.accept();
								channel.configureBlocking(false);
								channel.register(selector, SelectionKey.OP_READ);
 
							}
							//l'évenement correspond à une lecture
							else if(key.isReadable()) {
 
								SocketChannel client = (SocketChannel) key.channel();
 
								TrameManager manager = (TrameManager)key.attachment();
 
								if(manager == null) {
 
										SessionSocket ss = new SessionSocket(client.socket());
										manager = (TrameManager) Introspection.newInstance(managerClassName, new ByteArrayOutputStream(), ss , this.getClass().getClassLoader());
 
									key.attach(manager);
								}
 
								String msg = null;
 
								msg = manager.doRead(doRead(key , manager.getBuffer()));
 
								if(!StringUtils.isEmpty(msg)) {
									putMsgInQueue(msg);
									key.interestOps(SelectionKey.OP_WRITE) ;
								}
 
							}
							//l'évenement correspond à l'écriture
							else if(key.isWritable()) {
 
								TrameManager manager = (TrameManager)key.attachment();
								doWrite(key , manager.doWrite());
 
							}
						} catch (IOException e) {
							fireAlarm(e, "Exception in channel");
							key.channel().close();
							key.attach(null);
							key.cancel();
						}catch (IntrospectionException e) {
							throw new IFException(e, "IntrospectionException");
						}
					}
				} catch (ClosedChannelException e) {
					fireAlarm(e, "Exception in closing channel");
				} catch (IOException e) {
					fireAlarm(e, "Exception in channel");
				}catch (IFException e) {
					fireAlarm(e, "IntrospectionException");
 
				}
			}
		}
	}

Puis-je avoir votre aide pour résoudre ce problème :(

11/06/2014, 11h04
thelvin

Ben, 'faudrait songer à les fermer, les sockets.

Tant que tu y es, vérifier si tu fermes bien les fichiers, aussi.

Les sockets sont fermées côté client , voila la classe client :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
 
public class Client
{
    private static int    _port;
    private static String    _host;
    private  int _nbClients;
    private static String _path = "test/OE/TEST/";
 
    public Client(int port, String host, int nbClients) {
 
	   _nbClients = ( nbClients >= 1 ) ? nbClients : 1;
       _port   = (port >= 1) ? port : 10081;
       _host = (host != null && !host.equals("")) ? host : "localhost";
 
       for(int i=0; i<_nbClients; i++)
       {   		
          new Reader(i).start();
 
       }
 
	}
 
    /**
     * @param i
     * @return 
     * @throws IOException 
     */
    public static BufferedReader openFile(int i) throws IOException{
    	String filename = _path+"TEST_"+i+".csv";
		try {			
			return new BufferedReader(new FileReader(filename));
 
		} catch (IOException e) {
			throw new IOException(filename + " is not found.");
		} 
    }
 
    /**
     * @return current time
     */
    public static String getCurrentDate(){
    	DateFormat dateFormat = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
    	Calendar cal = Calendar.getInstance();
    	return dateFormat.format(cal.getTime());
    }
 
    private class Reader extends Thread {
    	int id;
 
 
	    public Reader(int i) {
	    	id=i;
		}
 
		public void run() {		
 
			System.out.println( getCurrentDate() + " : " + Reader.currentThread().getName() + " started ...");
			BufferedReader br = null;   
			try {
 
				while(true){
 
					br = openFile(id);
					int nbLine = 0;
					while(true){
 
						/*****************************************/
						/**    Send the message to the server   **/
						/*****************************************/
						String line = br.readLine();					
						if (line == null) break;
 
						nbLine++;
						Socket _socket = new Socket(_host, _port);
						PrintWriter output = new PrintWriter(new BufferedWriter(new OutputStreamWriter(_socket.getOutputStream())), true);
						output.println(line);					
						output.flush();
 
						/*****************************************/
						/**  Read the response from the server  **/
						/*****************************************/
						InputStream from_server = _socket.getInputStream();
						OutputStream out = new ByteArrayOutputStream();
 
						byte[] buffer = new byte[4096];
 
					   	out.write(buffer, 0, from_server.read(buffer));
					  // 	System.out.println(out.toString());
						from_server.close();   
 
				    	_socket.close();
 
				    	if (nbLine%100 == 0){
				    	//	sleep(5);
				    		System.out.println(Reader.currentThread().getName() + " : " + nbLine + " messages was sent to serverSocket.");
				    	}
					}
					br.close();
 
				}	
 
			} catch (UnknownHostException e) {
				e.printStackTrace();
			}catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} 
 
			System.out.println(getCurrentDate() + " : " + Reader.currentThread().getName() +" stopped ...");
	   	 	Reader.currentThread().interrupt();
	    }
    }
 
}

Est que je dois les fermer aussi côté serveur ?

11/06/2014, 11h33
thelvin

Bonne question. Que te dit ton test de charge ?

Oui, quand une machine lit de l'IO, elle le fait après avoir ouvert cette IO et doit donc la fermer. Peu importe qu'il y ait une autre machine en face qui doit faire exactement la même chose.
11/06/2014, 11h45
cyclopsnet

La classe Client qui est utilisée pour lancer le test de charge dit que les sockets se ferme après la reception de la réponse serveur, mais comment je peux être sur côté client que le socket est bien fermer et les ressources sont libérées ?

Dans mon cas mon serveur ne doit pas fermer le connexion car il sait pas si le client veut envoyer d'autres infos ou non , il reste en mode d'écoute.
11/06/2014, 12h13
thelvin

Je me moquais de toi. Ton test de charge te dit que tu as un gros problème dans la situation actuelle où le serveur ne ferme pas les sockets. Donc oui le serveur doit fermer les sockets !
Je reconnais que la science c'est quand même pas aussi simple que ça, mais en l'occurrence je t'enlève tes doutes : quand on connaît quoi que ce soit à la gestion des IOs, on sait que tout ce qu'on lit ou écrit on l'a ouvert et donc on doit le fermer. Que le client s'acquitte ou non de cette obligation qu'il a de le faire pour lui, ne concerne pas le serveur qui a lui aussi cette même obligation.

Citation:

mais comment je peux être sur côté client que le socket est bien fermer et les ressources sont libérées ?

L'emploi de try-with-resource est en général la bonne approche.
Après tu peux toujours regarder ce que dit netstat.

Citation:

Dans mon cas mon serveur ne doit pas fermer le connexion car il sait pas si le client veut envoyer d'autres infos ou non , il reste en mode d'écoute.

Ce qui signifie simplement qu'il ne doit la fermer qu'après que le client l'ait fermé, ce qui se voit du fait que read() renvoie un nombre négatif.
11/06/2014, 12h38
cyclopsnet

Mais si le read() renvoit un nombre négatif ça veut dire que le buffer est vide mais pas obligatoirement que le client à fermer ça connexion
11/06/2014, 13h15
thelvin

Où ça ? Moi je te parle de la Socket. Que dit la JavaDoc de read() ?
11/06/2014, 13h43
tchize_

Pour confirmer ce qui t'as été dit: oui, le serveur doit EXPLICITEMENT fermer la socket, personnes ne le fera pour lui. La question que te pose c'est "quand, comment puis-je savoir que c'est le moment?"

La plupart des protocoles réseau s'acquittent de cette tâche en combinant deux méthodes:
1) établir un protocole qui permet de le savoir. Par exemple en ayant le client qui envoie un message style "au revoir" à la fin de la communication
2) établir un heartbeat, un keepalive ou quelque chose de similaire et en déconnectant les clients ne répondant pas au bout de X secondes. Ceci afin d'identifier les clients qui ne disent jamais au revoir et / ou les clients qui ont crashé
11/06/2014, 14h39
thelvin

Citation:

Envoyé par tchize_

1) établir un protocole qui permet de le savoir. Par exemple en ayant le client qui envoie un message style "au revoir" à la fin de la communication

À noter que TCP/IP inclut un message de ce genre et que Java le représente dans ses Socket, avec son mécanisme habituel de "fin de flux d'entrée" (end of stream.)

J'ai testé le cas d'un read() qui retourne -1 ; mais il indique seulement que le serveur à reçu tout le message envoyé
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 public ByteArrayOutputStream doRead(SelectionKey key , ByteArrayOutputStream reader) throws IOException { SocketChannel client = (SocketChannel) key.channel(); ByteBuffer readBuffer = ByteBuffer.allocate(2048); readBuffer.clear(); int numread = 0, capacity = 0; while (isRunning) { numread = client.read( readBuffer ); System.out.println("Bit : "+numread); if(numread > 0) capacity = numread; if (numread ==0) { break; } else if(numread == -1) throw new IOException(); } readBuffer.flip() ; reader.write(readBuffer.array(), 0, capacity); return reader; }
J'ai eu le -1 sans que je ferme ma socket client depuis la classe de test , alors si je ferme la socket quand read()==-1 , et le client veut envoyer un autre truc sur la meme connexion alors Boom java.net.SocketException: Socket is closed :?

11/06/2014, 17h44
thelvin

Désolé mais je te crois pas. Montre-nous.
"Reçu tout le message envoyé" ça existe pas. Mais si la socket a plus rien à lire sans bloquer, elle indique zéro, pas -1, pas autre chose.

Enfin, si c'est pendant tes tests de charge, le client peut très bien échouer à maintenir la socket, et passer dans le code de fermeture sans que ce soit ce que tu as cherché à faire. La surcharge, ça marche pas, c'est normal.

Voila ma classe de test :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
 
package com.geoloc.test;
 
import java.io.*;
import java.net.Socket;
import java.net.UnknownHostException;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Scanner;
 
public class Client
{
    private static int    _port;
    private static String    _host;
    private  int _nbClients;
    private static String _path = "test/geolocOE/TEST/";
 
    public Client(int port, String host, int nbClients) {
 
	   _nbClients = ( nbClients >= 1 ) ? nbClients : 1;
       _port   = (port >= 1) ? port : 10081;
       _host = (host != null && !host.equals("")) ? host : "localhost";
 
       for(int i=0; i<_nbClients; i++)
       {   		
          new Reader(i).start();
 
       }
 
	}
 
    /**
     * @param i
     * @return 
     * @throws IOException 
     */
    public static BufferedReader openFile(int i) throws IOException{
    	String filename = _path+"TEST_"+i+".csv";
		try {			
			return new BufferedReader(new FileReader(filename));
 
		} catch (IOException e) {
			throw new IOException(filename + " is not found.");
		} 
    }
 
    /**
     * @return current time
     */
    public static String getCurrentDate(){
    	DateFormat dateFormat = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
    	Calendar cal = Calendar.getInstance();
    	return dateFormat.format(cal.getTime());
    }
 
    private class Reader extends Thread {
    	int id;
 
 
	    public Reader(int i) {
	    	id=i;
		}
 
		public void run() {		
 
			System.out.println( getCurrentDate() + " : " + Reader.currentThread().getName() + " started ...");
			BufferedReader br = null;   
			PrintWriter output = null;
			InputStream from_server = null;
			OutputStream out = null;
			try {
 
			//	while(true){
 
					br = openFile(id);
					int nbLine = 0;
					while(true){
 
						/*****************************************/
						/**    Send the message to the server   **/
						/*****************************************/
						String line = br.readLine();					
						if (line == null) break;
 
						nbLine++;
						Socket _socket = new Socket(_host, _port);
						output = new PrintWriter(new BufferedWriter(new OutputStreamWriter(_socket.getOutputStream())), true);
						output.println(line);					
						output.flush();
 
						/*****************************************/
						/**  Read the response from the server  **/
						/*****************************************/
						from_server = _socket.getInputStream();
						out = new ByteArrayOutputStream();
 
						byte[] buffer = new byte[4096];
 
					   	out.write(buffer, 0, from_server.read(buffer));
					   	System.out.println(out.toString());
						from_server.close();   
 
						output = new PrintWriter(new BufferedWriter(new OutputStreamWriter(_socket.getOutputStream())), true);
						output.println("TEST\n");					
						output.flush();
 
						from_server = _socket.getInputStream();
						out = new ByteArrayOutputStream();
 
						byte[] _buffer = new byte[4096];
 
					   	out.write(buffer, 0, from_server.read(_buffer));
					   	System.out.println(out.toString());
						from_server.close();  
 
						System.out.println(Reader.currentThread().getName() + " : " + nbLine + " messages was sent to serverSocket.");
 
				    	_socket.close();
 
				    	//if (nbLine%100 == 0){
				    	//	sleep(5);
				    	//	System.out.println(Reader.currentThread().getName() + " : " + nbLine + " messages was sent to serverSocket.");
				    	//}
					}
					br.close();
 
				//}	
 
			} catch (UnknownHostException e) {
				e.printStackTrace();
			}catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} 
 
			System.out.println(getCurrentDate() + " : " + Reader.currentThread().getName() +" stopped ...");
	   	 	Reader.currentThread().interrupt();
	    }
    }
 
}

Voila les logs :

Code:

1
2
3
4
5
6
7
 
2014/06/11 16:24:03 : Thread-0 started ...
ACK
java.net.SocketException: Socket is closed
	at java.net.Socket.getOutputStream(Socket.java:828)
	at com.geoloc.test.Client$Reader.run(Client.java:103)
2014/06/11 16:24:03 : Thread-0 stopped ...

Le client envoie une chaine et reçoit ACK puis il veut envoyer un autre message , Bom Socket is closed !

Dans le classe serveur (le dernier post) qui j'ai un read==-1 je throw un IOException qui ferme le channel....

11/06/2014, 18h04
thelvin

Citation:

J'ai eu le -1 sans que je ferme ma socket client depuis la classe de test

Code:

from_server.close();

Au cas où tu te demandes ce que veut dire le verbe close, c'est de l'anglais, ça veut dire fermer.

Jamais dire des trucs. Toujours les montrer.
11/06/2014, 18h11
cyclopsnet

Oki , alors le fait de fermer le InputStream ferme la socket :? , je pensais que le seul moyen pour fermer une socket c'est socket.close
Merci thelvin.
11/06/2014, 18h19
thelvin

Euuuuh, voui, mais, tu as sans doute remarqué que tu l'as obtenu en faisant getInputStream() sur la socket ? Tu te rappelles, c'est pour ça que ce qu'il lit, c'est ce qui vient du port connecté avec la socket ?
Concrètement, quand tu as fermé l'InputStream, tu pensais que tu demandais quoi, au juste ?
11/06/2014, 18h53
cyclopsnet

Que je ferme seulement le flux de lecture , mais la socket reste connecté au serveur :calim2:
11/06/2014, 19h31
tchize_

Citation:

Closing the returned InputStream will close the associated socket.

C'est un peu marqué clairement dans la doc quand même :weird:
12/06/2014, 10h19
thelvin

Citation:

Envoyé par cyclopsnet

Que je ferme seulement le flux de lecture , mais la socket reste connecté au serveur :calim2:

Je veux dire, "fermer le flux de lecture," ça veut dire quoi concrètement, sur une Socket ?
Si c'est pas la Socket elle-même il y a rien à fermer... Une connexion TCP/IP c'est une connexion TCP/IP.