Discussion :

[guizmaii]

Bonjour à tous

Voila, pour la fac j'ai dû faire un serveur FTP en Java. J'y suis parvenu, il fonctionne plutôt pas mal avec Filezilla comme client par exemple.

Maintenant on doit faire une passerelle REST sous glassfish pour utiliser ce serveur FTP.
Pour que la passerelle REST puisse parler avec mon serveur il faut donc que je code un bout de client FTP et pour cela j'utilise la librairie Apache Commons Net (https://commons.apache.org/proper/commons-net//).

Mais voila, quand je dis à mon client FTP "connect" (ligne 37 du deuxième bout de code que je fournis), il envoie bien la requête, mon serveur FTP crée bien son thread pour ce client et lui renvoie bien "220 Service ready" mais tout s'arrête là.
Mon client ne bouge plus (alors qu'il le devrait. Il devrait passer à la ligne "reply = ftp.getReplyCode();") et mon serveur après avoir répondu ça attends une commande de la part du client (comportement normal d'un serveur FTP).

Je pense qu'ils, même si la Socket est correctement créée, n'arrivent pas à se parler. Peut être un problème d'encoding ?

Voici quelques bout de code qui pourront vous être utile pour essayer de m'aider :

Tout d'abord un bout de mon serveur FTP. C'est un bout de la classe qui gère le canal de commandes.
Pour chaque client qui se connecte un thread de cette classe est lancé.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
// runner du thread qui est lancé pour chaque client. 
// Il se charge de créer les reader et writer pour lire et écrire dans la Socket puis appel la méthode "processRequest" qui va traiter les requêtes du client (boucle infini).
 
@Override
	public void run() {
		try {
			readerCmd = new BufferedReader(new InputStreamReader(
					socketCmd.getInputStream()));
			writerCmd = new PrintWriter(new OutputStreamWriter(
					socketCmd.getOutputStream()), true);
 
			processRequest();
		} catch (final Exception e) {
			e.printStackTrace();
		} finally {
			try {
				socketCmd.close();
			} catch (final IOException e) {
				e.printStackTrace();
			}
		}
	}
 
// Le début de ma méthode processRequest. Elle répond au client qu'elle est prête ("220 Service Ready") 
//puis avec son readerCmd.readLine() attend les commandes du client.
 
	/**
         * Main controler
         * 
         * @throws Exception
         */
	private void processRequest() throws Exception {
		reply(220, "Service ready");
 
		String line;
		while ((line = readerCmd.readLine()) != null) {
 
// ....
 
}
 
// Ma méthode qui est chargé d'envoyé les réponses au client sur le canal  de commandes.
 
int reply(final int code, final String text) {
		writerCmd.println(code + " " + text);
		return code;
	}

Et voici le code de mon client ftp :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
 
public class DAOOverFTP {
 
	private final FTPClient ftp;
 
	private final String currentDir;
 
	private final String username = "test";
 
	private final String password = "test";
 
	public DAOOverFTP() throws IOException {
		final FTPClientConfig config = new FTPClientConfig();
		config.setDefaultDateFormatStr("MMM dd HH:mm");
 
		ftp = new FTPClient();
		ftp.configure(config);
		ftp.addProtocolCommandListener(new PrintCommandListener(
				new PrintWriter(System.out), true));
		// ftp.setAutodetectUTF8(true);
		// ftp.setBufferSize(1024);
		// ftp.setReceiveBufferSize(1024);
		// ftp.setSendBufferSize(1024);
		// ftp.setConnectTimeout(120 * 120);
		ftp.setControlEncoding("UTF-8");
		// no keep alive control
		ftp.setControlKeepAliveReplyTimeout(0);
		ftp.setControlKeepAliveTimeout(0);
		// ftp.setCopyStreamListener(createListener());
		// ftp.setFileStructure(FTP.FILE_STRUCTURE);
		// ftp.setServerSocketFactory(ne)
		// ftp.setSocketFactory(factory)
 
		int reply;
		try {
			ftp.connect(InetAddress.getLocalHost().getHostName(), 5555);
 
			reply = ftp.getReplyCode();
 
			System.out.println("Connected to "
					+ InetAddress.getLocalHost().getHostName() + " on " + 5555);
 
			if (!FTPReply.isPositiveCompletion(reply)) {
				ftp.disconnect();
				System.err.println("FTP server refused connection.");
				System.exit(1);
			}
		} catch (final IOException e) {
			if (ftp.isConnected()) {
				try {
					ftp.disconnect();
				} catch (final IOException f) {
					// do nothing
				}
			}
			System.err.println("Could not connect to server.");
			e.printStackTrace();
			System.exit(1);
		}
 
		if (!ftp.login(username, password)) {
			ftp.logout();
		}
 
		System.out.println("Remote system is " + ftp.getSystemType());
 
		ftp.setFileType(FTP.BINARY_FILE_TYPE);
 
		// ftp.user();
		// ftp.pass("jules");
		ftp.pasv();
		currentDir = ftp.printWorkingDirectory();
		System.out.println("currentDir : " + currentDir);
	}
 
	public List<String> getlistNames() throws IOException {
		return Arrays.asList(ftp.listNames());
	}
 
	public List<String> getlistNames(final String pathname) throws IOException {
		return Arrays.asList(ftp.listNames(pathname));
	}
 
	private static CopyStreamListener createListener() {
		return new CopyStreamListener() {
			private long megsTotal = 0;
 
			@Override
			public void bytesTransferred(final CopyStreamEvent event) {
				bytesTransferred(event.getTotalBytesTransferred(),
						event.getBytesTransferred(), event.getStreamSize());
			}
 
			@Override
			public void bytesTransferred(final long totalBytesTransferred,
					final int bytesTransferred, final long streamSize) {
				final long megs = totalBytesTransferred / 1000000;
				for (long l = megsTotal; l < megs; l++) {
					System.err.print("#");
				}
				megsTotal = megs;
			}
		};
	}
}

Pour tester mon client FTP, j'utilise une petite classe JUnit que voici :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
 
@RunWith(JUnit4.class)
public class DAOOverFTPTest {
 
	private DAOOverFTP daoOverFTP;
 
	@Before
	public void setUp() throws SocketException, IOException {
		daoOverFTP = new DAOOverFTP();
	}
 
	@Test
	public void test() throws IOException {
		Assert.assertTrue(!daoOverFTP.getlistNames().isEmpty());
	}
 
}

Qu'en pensez vous ? Avez-vous une idée ?

Merci d'avane pour votre aide.
Jules.

[max224]

Tu serais pas en master à Lille toi
Je suis preneur pour une réponse !!! surtout que moi mon code ne marche que sous windows ??? alors que je l'ai codé sous linux

[guizmaii]

Effectivement je suis en master à Lille

Sinon j'ai découvert quelque chose d'étrange.
Lorsque mon client et mon serveur sont mutuellement bloqués comme décrit dans le premier post, si je kill mon serveur (tue le processus lancé en débug sous eclipse en appuyant sur le carré rouge), alors le client se débloque et reçoit correctement la réponse. Étrange !!!!

Avez-vous une idée d'où cela peut venir ?

Cordialement,
Jules

[guizmaii]

up !

[guizmaii]

Re,

J'ai trouvé la solution

En farfouillant dans les classes qu'utilise FTPClient j'ai remarqué qu'ils utilisaient un CRLFLineReader comme reader, je me suis donc dit qu'il fallait surement finir nos lignes de commandes non pas par "\n" comme le fait naturellement mon writer (un PrintWriter) avec sa méthode println() mais par l'équivalent ASCII : "\r\n" en utilisant la méthode print() de mon writer. ET SA MARCHE !!

Voici ma méthode reply() de ma classe FtpRequest de mon serveur FTP maintenant :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
int reply(final int code, final String text) {
	writerCmd.print(code + " " + text + "\r\n");
	return code;
}

Bien à vous