README.md

@@ -6,6 +6,12 @@ Lien vers le [document original](https://stri-online.net/FTLV/mod/resource/view.
 **But** : le but de ce projet est de créer une application répartie en Java de téléchargement de fichier en mode P2P (peer to peer ou poste à poste).
 Les étapes suivantes sont conseillées.
 
+# Usage
+
+tracker : java tracker.Tracker
+server : java serveurP2P.ServeurP2P
+client/serveur : java clientP2P.ClientP2P
+
 ## Étape 1 : Téléchargement à la FTP
 
 La première étape doit permettre de télécharger un fichier en intégralité d'une machine vers une autre machine de façon similaire aux applications suivant le protocole FTP.
@@ -47,4 +53,4 @@ Options :
 - Permettre la recherche de fichiers à partir de leur nom ou de toute autre caractéristique. À l'issu de la recherche on devra pouvoir connaître un ensemble d'application possédant le fichier et commencer le téléchargement.
 - Gérer le protocole d'une application de téléchargement P2P existante (bittorrent, emule ou autre).
 
-Note : toute fonctionnalité supplémentaire ne sera prise en compte dans la notation que si toutes les étapes ont été correctement traitées.
+Note : toute fonctionnalité supplémentaire ne sera prise en compte dans la notation que si toutes les étapes ont été correctement traitées.

src/clientP2P/ClientP2P.java

@@ -73,7 +73,7 @@ public class ClientP2P {
 	 */
 	public static void main(String [] args) {
 		if (args[1].equals("help") || args[1].equals("-h") || args[1].equals("h")){
-			System.out.println("usage : java -ea clientP2P.ClientP2P -- <PORT> ");
+			System.out.println("usage : java clientP2P.ClientP2P or java clientP2P.ClientP2P -- <integratedServerPORT> <trackerHOSTNAME> <trackerPORT> (default for integratedServer localhost:7070 and tracker localhost:6969, range 7000 -> 7999)");
 		}
 		else{
 			ClientP2P c;

src/serverP2P/ServerP2P.java

@@ -1,10 +1,14 @@
 package serverP2P;
+
+import java.util.Scanner;
+import javafx.util.Pair;
 import serverP2P.ServerManagementUDP;
 import serverP2P.ServerManagementTCP;
 import tools.Directories;
 import tools.Logger;
 import tools.HostItem;
-import java.util.Scanner;
+import tools.TestPort;
+
 
 /** Server only implementation
  * First argument of main method is port listened by the server, and is mandatory.
@@ -37,17 +41,80 @@ public class ServerP2P {
 
 	/** Main program entry point
 	 * first parameter is port number and is mandatory
-	 * to test, run with: java -ea serverP2P.ServerP2P -- <portNumber> <TrackerHostname> <TrackerPort>
+	 * to test, run with: java -ea serverP2P.ServerP2P
 	 * @param args	parameters
 	 */
 		public static void main(String [] args) {
-			if (args[1].equals("help") || args[1].equals("-h") || args[1].equals("h")){
-				System.out.println("usage : java -ea serveurP2P.ServeurP2P -- <serveurPORT> <trackerHOSTNAME> <trackerPORT>");
+			final String defaultHostname = "localhost";
+			final String defaultPortServer = "7070";
+			final String defaultPortTracker = "6969";
+			String hostnameServer = "";
+			String portServer = "";
+			String hostnameTracker = "";
+			String portTracker = "";
+			Scanner scanner = new Scanner(System.in);
+			TestPort testPort = new TestPort();
+
+			if ((args.length != 5) && (args.length != 0)){
+				System.out.println("usage : java serveurP2P.ServeurP2P (interactive) or java serveurP2P.ServeurP2P -- <serveurHOSTNAME> <serveurPORT> <trackerHOSTNAME> <trackerPORT>");
 			}
 			else{
-				ServerP2P s = new ServerP2P(args[1], args[2], args[3]);
-				ServerManagementUDP smudp = new ServerManagementUDP(s.directories.getDataHomeDirectory() + subdir, "localhost", s.port, s.logger, s.tracker);
-				ServerManagementTCP smtcp = new ServerManagementTCP(s.directories.getDataHomeDirectory() + subdir, "localhost", s.port, s.logger, s.tracker);
+				if(args.length == 5){
+					hostnameServer = args[1];
+					portServer = args[2];
+					hostnameTracker = args[3];
+					portTracker = args[4];
+				}
+				else{
+					System.out.println("Server, enter hostname to bind (default = localhost): ");
+					hostnameServer = scanner.nextLine();
+					if(hostnameServer.equals("")){
+						hostnameServer = defaultHostname;
+						System.out.println("using default hostname : " + hostnameServer);
+					}
+					System.out.println("enter port (default = 7070): ");
+					portServer = scanner.nextLine();
+					if(portServer.equals("")){
+						portServer = defaultPortServer;
+						System.out.println("using default port : " + portServer);
+					}
+					System.out.println("enter hostname of tracker (default = localhost): ");
+					hostnameTracker = scanner.nextLine();
+					if(hostnameTracker.equals("")){
+						hostnameTracker = defaultHostname;
+						System.out.println("tracker default hostname : " + hostnameTracker);
+					}
+					System.out.println("enter tracker's port (default = 6969): ");
+					portTracker = scanner.nextLine();
+					if(portTracker.equals("")){
+						portTracker = defaultPortTracker;
+						System.out.println("using default port : " + portTracker);
+					}
+				}
+
+				System.out.println("using hostname : " + hostnameServer);
+				Pair<Integer, String> PtestPortServer = testPort.testPortServer(Integer.parseInt(portServer));
+				if(PtestPortServer.getKey() == 0){
+					System.out.println("using port : " + portServer);
+				}
+				else {
+					System.out.println(PtestPortServer.getValue());
+					portServer = defaultPortServer;
+				}
+				System.out.println("tracker hostname : " + hostnameTracker);
+
+				Pair<Integer, String> PtestPortTracker = testPort.testPortTracker(Integer.parseInt(portTracker));
+				if(PtestPortTracker.getKey() == 0){
+					System.out.println("using port : " + portTracker);
+				}
+				else {
+					System.out.println(PtestPortTracker.getValue());
+					portTracker = defaultPortTracker;
+				}
+
+				ServerP2P s = new ServerP2P(portServer, hostnameTracker, portTracker);
+				ServerManagementUDP smudp = new ServerManagementUDP(s.directories.getDataHomeDirectory() + subdir, hostnameServer, s.port, s.logger, s.tracker);
+				ServerManagementTCP smtcp = new ServerManagementTCP(s.directories.getDataHomeDirectory() + subdir, hostnameServer, s.port, s.logger, s.tracker);
 				Thread tudp = new Thread(smudp);
 				tudp.setName("server UDP P2P-JAVA-PROJECT");
 				tudp.start();
@@ -55,5 +122,5 @@ public class ServerP2P {
 				ttcp.setName("server TCP P2P-JAVA-PROJECT");
 				ttcp.start();
 			}
-	}
+		}
 }

src/tools/TestPort.java

@@ -0,0 +1,29 @@
+package tools;
+
+import javafx.util.Pair;
+
+/** Test ports.
+ * @author	Louis Royer
+ * @author	Flavien Haas
+ * @author	JS Auge
+ * @version	1.0
+ */
+public class TestPort {
+
+	public Pair<Integer,String> testPortServer(int port) {
+		if((port > 7000) && (port < 7999)){
+			return new Pair<>(0,"");
+		}
+		return new Pair<>(1, "Wrong port (7000 -> 7999), using default port 7070");
+	}
+
+	public Pair<Integer,String> testPortTracker(int port) {
+		if((port > 6000) && (port < 6999)){
+			return new Pair<>(0,"");
+		}
+		return new Pair<>(1, "Wrong port (6000 -> 6999), using default port 6969");
+	}
+
+
+
+}

src/tracker/Tracker.java

@@ -1,9 +1,13 @@
 package tracker;
+
+import java.util.Scanner;
+import javafx.util.Pair;
 import tracker.TrackerManagementTCP;
 import tracker.TrackerManagementUDP;
 import tools.Directories;
 import tools.Logger;
-import java.util.Scanner;
+import tools.LogLevel;
+import tools.TestPort;
 
 /** Tracker implementation
  * First argument of main method is port listened by the tracker, and is mandatory.
@@ -32,19 +36,61 @@ public class Tracker {
 
 	/** Main program entry point
 	 * first parameter is port number and is mandatory
-	 * to test, run with: java -ea serverP2P.ServerP2P -- <portNumber>
+	 * to test, run with: java -ea serverP2P.ServerP2P
 	 * @param args	parameters
 	 */
 		public static void main(String [] args) {
-		Tracker t = new Tracker(args[1]);
-		TrackerManagementUDP tmudp = new TrackerManagementUDP(t.port, t.logger);
-		TrackerManagementTCP tmtcp = new TrackerManagementTCP(t.port, t.logger);
-		Thread tudp = new Thread(tmudp);
-		tudp.setName("Tracker UDP P2P-JAVA-PROJECT");
-		tudp.start();
-		Thread ttcp = new Thread(tmtcp);
-		ttcp.setName("Tracker TCP P2P-JAVA-PROJECT");
-		ttcp.start();
-	}
+			final String defaultPort = "6969";
+			final String defaultHostname = "localhost";
+			Scanner scanner = new Scanner(System.in);
+			TestPort testPort = new TestPort();
+			String hostname;
+			String port;
+			Tracker t;
 
+			if ((args.length != 3) && (args.length != 0)){
+				System.out.println("usage : java tracker.Tracker (interactive) or java trackerP2P.trackerP2P -- <hostname> <PORT> (default localhost:6969, range 6000 -> 6999)");
+			}
+			else{
+				if(args.length == 3){
+					hostname = args[1];
+					port = args[2];
+				}
+				else{
+					System.out.println("Tracker Server, enter hostname to bind (default = localhost): ");
+					hostname = scanner.nextLine();
+					if(hostname.equals("")){
+						hostname = defaultHostname;
+						System.out.println("using default hostname : " + hostname);
+					}
+					System.out.println("enter port (default = 6969): ");
+					port = scanner.nextLine();
+					if(port.equals("")){
+						port = defaultPort;
+						System.out.println("using default port : " + port);
+					}
+				}
+
+				System.out.println("using hostname : " + hostname);
+				Pair<Integer, String> PtestPortTracker = testPort.testPortTracker(Integer.parseInt(port));
+				if(PtestPortTracker.getKey() == 0){
+					System.out.println("using port : " + port);
+					t = new Tracker(port);
+				}
+				else {
+					System.out.println(PtestPortTracker.getValue());
+					t = new Tracker(defaultPort);
+					t.logger.write(PtestPortTracker.getValue(), LogLevel.Warning);
+				}
+
+				TrackerManagementUDP tmudp = new TrackerManagementUDP(hostname, t.port, t.logger);
+				TrackerManagementTCP tmtcp = new TrackerManagementTCP(hostname, t.port, t.logger);
+				Thread tudp = new Thread(tmudp);
+				tudp.setName("Tracker UDP P2P-JAVA-PROJECT");
+				tudp.start();
+				Thread ttcp = new Thread(tmtcp);
+				ttcp.setName("Tracker TCP P2P-JAVA-PROJECT");
+				ttcp.start();
+			}
+		}
 }

src/tracker/TrackerManagementTCP.java

@@ -1,32 +1,32 @@
 package tracker;
-import tools.Logger;
-import tools.LogLevel;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.HashMap;
+import java.io.IOException;
 import java.net.ServerSocket;
 import java.net.Socket;
 import java.net.SocketException;
+import java.net.UnknownHostException;
+import java.net.InetAddress;
 import protocolP2P.ProtocolP2PPacketTCP;
 import protocolP2P.ProtocolP2PPacket;
 import protocolP2P.RequestResponseCode;
 import protocolP2P.Payload;
 import protocolP2P.Register;
 import protocolP2P.Unregister;
-import tools.HostItem;
-import java.util.ArrayList;
-import java.util.List;
-import java.io.IOException;
-import exception.LocalException;
-import java.util.Map;
-import java.util.HashMap;
 import protocolP2P.DiscoverRequest;
 import protocolP2P.DiscoverResponse;
 import protocolP2P.FileList;
-import localException.InternalError;
+import exception.LocalException;
 import remoteException.EmptyDirectory;
-import java.net.UnknownHostException;
-import java.net.InetAddress;
+import localException.InternalError;
 import localException.SocketClosed;
 import tracker.TrackerManagement;
-
+import tools.HostItem;
+import tools.Logger;
+import tools.LogLevel;
 
 /** Tracker management implementation with tcp
  * @author	Louis Royer
@@ -41,8 +41,8 @@ public class TrackerManagementTCP extends TrackerManagement {
 	 * @param port	Port used to listen.
 	 * @param logger	Logger object
 	 */
-	public TrackerManagementTCP(int port, Logger logger) {
-		super(new HostItem("localhost", port), logger);
+	public TrackerManagementTCP(String hostname, int port, Logger logger) {
+		super(new HostItem(hostname, port), logger);
 		try {
 			socket = new ServerSocket(tracker.getPort(), 10, tracker.getInetAddress());
 		} catch (SocketException e) {
@@ -114,6 +114,7 @@ public class TrackerManagementTCP extends TrackerManagement {
 		}
 	}
 
+
 	/** Implementation of writeLog
 	 * @param text	Text to log
 	 * @param logLevel	level of logging
@@ -144,7 +145,7 @@ public class TrackerManagementTCP extends TrackerManagement {
 	protected Object getHostItemSocket(HostItem hostItem) {
 		return (Object)hostItem.getTCPSocket();
 	}
-
+	
 	/** Close HostItem socket
 	 * @param hostItem	HostItem
 	 */

src/tracker/TrackerManagementUDP.java

@@ -37,8 +37,8 @@ public class TrackerManagementUDP extends TrackerManagement {
 	 * @param port	Port used to listen.
 	 * @param logger	Logger object
 	 */
-	public TrackerManagementUDP(int port, Logger logger) {
-		super(new HostItem("localhost", port), logger);
+	public TrackerManagementUDP(String hostname, int port, Logger logger) {
+		super(new HostItem(hostname, port), logger);
 		try {
 			socket = new DatagramSocket(tracker.getPort(), tracker.getInetAddress());
 		} catch (SocketException e) {