flavien
/
Projet_JAVA_P2P_STRI2A
3
2
Fork 0
Code Issues 11 Pull Requests Releases 13 Activity

Labels Milestones

New Pull Request

clitracker #79

Merged
louis_royer merged 14 commits from clitracker into etape4 4 years ago
Conversation 0 Commits 14 Files Changed 11
11 changed files with 390 additions and 139 deletions
Show Stats Download Patch File Download Diff File

8
README.md
Unescape Escape View File

@ -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). **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. Les étapes suivantes sont conseillées.
# Usage
tracker : java tracker.Tracker (interactive) or java trackerP2P.trackerP2P -- <hostname> <PORT> (default port 6969 (range 6000 -> 6999))
server : java serveurP2P.ServeurP2P (interactive) or java serveurP2P.ServeurP2P -- <serveurHOSTNAME> <serveurPORT> <trackerHOSTNAME> <trackerPORT> (default server port: server 7070 (range 7000->7070) and tracker port 6969 (range 7000 -> 7999))
client/serveur : java clientP2P.ClientP2P or java clientP2P.ClientP2P -- <clientTransportProtocol> <integratedServerHOSTNAME> <integratedServerPORT> <trackerHOSTNAME> <trackerPORT> (default tracker port 6969 (range 7000 -> 7999) and server port: server 7070 (range 7000->7070))
## Étape 1 : Téléchargement à la FTP ## É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. 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. - 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). - 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.

219
src/clientP2P/ClientP2P.java
Unescape Escape View File

@ -4,12 +4,16 @@ import java.util.Scanner;
import java.util.List; import java.util.List;
import clientP2P.ClientManagementUDP; import clientP2P.ClientManagementUDP;
import clientP2P.ClientManagementTCP; import clientP2P.ClientManagementTCP;
import serverP2P.ServerManagementUDP; import serverP2P.ServerManagementUDP;
import serverP2P.ServerManagementTCP; import serverP2P.ServerManagementTCP;
import tools.Logger; import tools.Logger;
import tools.LogLevel; import tools.LogLevel;
import tools.Directories; import tools.Directories;
import tools.HostItem; import tools.HostItem;
import tools.ServerPortRange;
import tools.TrackerPortRange;
/** Client + Server implementation. /** Client + Server implementation.
* @author Louis Royer * @author Louis Royer
@ -23,20 +27,17 @@ public class ClientP2P {
private String partsDir = ".parts/"; private String partsDir = ".parts/";
private Logger loggerServer; private Logger loggerServer;
private Logger loggerClient; private Logger loggerClient;
private String host;
private int port;
private Directories directories; private Directories directories;
private static final int defaultPort = 20000;
private HostItem tracker; private HostItem tracker;
private HostItem server;
private Scanner scanner; private Scanner scanner;
/** Initialize loggers if directories and logger are null, /** Initialize loggers if directories and logger are null,
* else fail silently. * else fail silently.
*/ */
public void initDirectoriesAndLoggers() { public void initDirectoriesAndLoggers() {
if (directories == null && loggerServer == null && loggerClient == null) { if (directories == null && loggerServer == null && loggerClient == null) {
directories = new Directories("P2P_JAVA_PROJECT_" + port); directories = new Directories("P2P_JAVA_PROJECT_" + server.getPort());
directories.createSubdir(logDir); directories.createSubdir(logDir);
loggerServer = new Logger(directories.getDataHomeDirectory() + logDir + "server.log"); loggerServer = new Logger(directories.getDataHomeDirectory() + logDir + "server.log");
loggerClient = new Logger(directories.getDataHomeDirectory() + logDir + "client.log"); loggerClient = new Logger(directories.getDataHomeDirectory() + logDir + "client.log");
@ -44,26 +45,34 @@ public class ClientP2P {
} }
} }
/** Constructor with portStr as parameter. /** Constructor.
* @param portStr String containing port for server listenning. * @param hostnameServer hostname to bind
* @param portServer port to bind
* @param hostnameTracker hostname of tracker
* @param portTracker port of tracker
*/ */
public ClientP2P(String portStr) { public ClientP2P(String hostnameServer, int portServer, String hostnameTracker, int portTracker) {
scanner = new Scanner(System.in); scanner = new Scanner(System.in);
tracker = new HostItem("localhost", 30000); // TODO : make it configurable server = new HostItem(hostnameServer, portServer);
try{ tracker = new HostItem(hostnameTracker, portTracker);
port = Integer.valueOf(Integer.parseInt(portStr));
} catch (NumberFormatException e){
int oldPort = port;
port = defaultPort;
initDirectoriesAndLoggers();
System.err.println("Error incorrect port " + oldPort + " using default port " + defaultPort);
loggerServer.write("incorrect port " + oldPort + " using default port " + defaultPort, LogLevel.Info);
}
initDirectoriesAndLoggers(); initDirectoriesAndLoggers();
host = "localhost"; System.out.println("Server will listen on port " + portServer + " and serve files from " + directories.getDataHomeDirectory());
System.out.println("Server will listen on port " + port + " and serve files from " + directories.getDataHomeDirectory());
directories.askOpenDataHomeDirectory(null, scanner); directories.askOpenDataHomeDirectory(null, scanner);
System.out.println("Please enter list of servers to use; first one will be used to ask list of files"); }
/** Print cli usage
* @param serverPortRange range of server ports
* @param trackerPortRange range of tracker ports
*/
private static void printUsage(ServerPortRange serverPortRange, TrackerPortRange trackerPortRange) {
System.out.println("usage :");
System.out.println("\tjava clientP2P.ClientP2P");
System.out.println("or");
System.out.println("java clientP2P.ClientP2P -- " +
"<clientTransportProtocol> " +
"<integratedServerHOSTNAME> <integratedServerPORT> " +
"<trackerHOSTNAME> <trackerPORT> ");
System.out.println("(" + trackerPortRange + " and " + serverPortRange +")");
} }
/** Main program entry point. /** Main program entry point.
@ -72,67 +81,121 @@ public class ClientP2P {
* @param args server listenning port * @param args server listenning port
*/ */
public static void main(String [] args) { public static void main(String [] args) {
if (args[1].equals("help") || args[1].equals("-h") || args[1].equals("h")){ final String defaultHostname = "localhost";
System.out.println("usage : java -ea clientP2P.ClientP2P -- <PORT> "); String hostnameServer = "";
int portServer = 0;
String hostnameTracker = "";
int portTracker = 0;
String protocolClient = "";
Scanner scanner = new Scanner(System.in);
final ServerPortRange serverPortRange = new ServerPortRange();
final TrackerPortRange trackerPortRange = new TrackerPortRange();
if ((args.length != 6) && (args.length != 0)){
ClientP2P.printUsage(serverPortRange, trackerPortRange);
System.exit(1);
} }
else{ else if(args.length == 6){
ClientP2P c; protocolClient = args[1];
try { hostnameServer = args[2];
c = new ClientP2P(args[1]); portServer = Integer.valueOf(Integer.parseInt(args[3]));
} catch (IndexOutOfBoundsException e){ hostnameTracker = args[4];
c = new ClientP2P("" + defaultPort); portTracker = Integer.valueOf(Integer.parseInt(args[5]));
} else{
System.out.println("Client, wich transport protocol do you want to use (default = TCP): ");
protocolClient = scanner.nextLine();
System.out.println("server side, 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 = " + serverPortRange.getDefaultPort() +"): ");
String portServerStr = scanner.nextLine();
if(portServerStr.equals("")){
portServer = serverPortRange.getDefaultPort();
System.out.println("using default port : " + portServer);
} else {
portServer = Integer.valueOf(Integer.parseInt(portServerStr));
}
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 = "+trackerPortRange.getDefaultPort() + "): ");
String portTrackerStr = scanner.nextLine();
if(portTrackerStr.equals("")){
portTracker = trackerPortRange.getDefaultPort();
System.out.println("using default port : " + portTracker);
} else {
portTracker = Integer.valueOf(Integer.parseInt(portTrackerStr));
}
}
// Server threads System.out.println("using hostname : " + hostnameServer);
ServerManagementUDP smudp = new ServerManagementUDP(c.directories.getDataHomeDirectory(), "localhost", c.port, c.loggerServer, c.tracker); if(serverPortRange.isPortInRange(portServer)){
ServerManagementTCP smtcp = new ServerManagementTCP(c.directories.getDataHomeDirectory(), "localhost", c.port, c.loggerServer, c.tracker); System.out.println("using port : " + portServer);
Thread tudp = new Thread(smudp); }
tudp.setName("server UDP P2P-JAVA-PROJECT (port: " + c.port + ")"); else {
tudp.start(); System.out.println("Port not in range. " + serverPortRange);
Thread ttcp = new Thread(smtcp); portServer = serverPortRange.getDefaultPort();
ttcp.setName("server TCP P2P-JAVA-PROJECT (port: " + c.port + ")"); }
ttcp.start(); System.out.println("tracker hostname : " + hostnameTracker);
// Wait a bit before printing client interface if(trackerPortRange.isPortInRange(portTracker)){
// This is not required, but allow to have a cleaner interface System.out.println("using port : " + portTracker);
try { }
Thread.sleep(200); else {
} catch(InterruptedException e) { System.out.println("Port not in range. " + trackerPortRange);
Thread.currentThread().interrupt(); portTracker = trackerPortRange.getDefaultPort();
} }
ClientP2P c = new ClientP2P(hostnameServer, portServer, hostnameTracker, portTracker);
ServerManagementUDP smudp = new ServerManagementUDP(c.directories.getDataHomeDirectory(), c.server, c.tracker, c.loggerServer);
ServerManagementTCP smtcp = new ServerManagementTCP(c.directories.getDataHomeDirectory(), c.server, c.tracker, c.loggerServer);
Thread tudp = new Thread(smudp);
tudp.setName("server UDP P2P-JAVA-PROJECT");
tudp.start();
Thread ttcp = new Thread(smtcp);
ttcp.setName("server TCP P2P-JAVA-PROJECT");
ttcp.start();
// Wait a bit before printing client interface
// This is not required, but allow to have a cleaner interface
try {
Thread.sleep(200);
} catch(InterruptedException e) {
Thread.currentThread().interrupt();
}
// initialize Host lists Thread tclient;
System.out.println("Client : Which transport protocol do you want to use? [TCP/udp]"); switch(protocolClient){
c.scanner.hasNextLine(); case "UDP":
String transportchoosen = c.scanner.nextLine(); case "udp":
Thread t; case "upd": // to avoid users typos
switch(transportchoosen){ case "2" :
case "UDP": System.out.println("Starting with UDP");
case "udp": ClientManagementUDP cmudp = new ClientManagementUDP(c.directories.getDataHomeDirectory(), c.tracker, c.directories.getDataHomeDirectory() + c.partsDir, c.loggerClient, c.scanner);
case "upd": // alias typo tclient = new Thread(cmudp);
case "2" : break;
System.out.println("Starting with UDP"); case "TCP":
ClientManagementUDP cmudp = new ClientManagementUDP(c.directories.getDataHomeDirectory(), c.tracker, c.directories.getDataHomeDirectory() + c.partsDir, c.loggerClient, c.scanner); case "tcp":
t = new Thread(cmudp); case "1":
break; default:
case "TCP": System.out.println("Starting with TCP");
case "tcp": ClientManagementTCP cmtcp = new ClientManagementTCP(c.directories.getDataHomeDirectory(), c.tracker, c.directories.getDataHomeDirectory() + c.partsDir, c.loggerClient, c.scanner);
case "1": tclient = new Thread(cmtcp);
default: break;
System.out.println("Starting with TCP");
ClientManagementTCP cmtcp = new ClientManagementTCP(c.directories.getDataHomeDirectory(), c.tracker, c.directories.getDataHomeDirectory() + c.partsDir, c.loggerClient, c.scanner);
t = new Thread(cmtcp);
break;
}
t.setName("client P2P-JAVA-PROJECT");
t.start();
try {
t.join();
} catch (InterruptedException e) {}
c.scanner.close();
smudp.setStop();
smtcp.setStop();
} }
tclient.setName("client P2P-JAVA-PROJECT");
tclient.start();
try {
tclient.join();
} catch (InterruptedException e) {}
smudp.setStop();
smtcp.setStop();
} }
} }

4
src/serverP2P/ServerManagementTCP.java
Unescape Escape View File

@ -56,8 +56,8 @@ public class ServerManagementTCP extends ServerManagement {
* @param logger Logger item * @param logger Logger item
* @param tracker Tracker * @param tracker Tracker
*/ */
public ServerManagementTCP(String baseDirectory, String hostName, int port, Logger logger, HostItem tracker) { public ServerManagementTCP(String baseDirectory, HostItem server, HostItem tracker, Logger logger) {
super(baseDirectory, new HostItem(hostName, port), tracker, logger); super(baseDirectory, server, tracker, logger);
assert baseDirectory != null : "baseDirectory is null"; assert baseDirectory != null : "baseDirectory is null";
assert server != null : "server is null"; assert server != null : "server is null";
assert tracker != null : "tracker is null"; assert tracker != null : "tracker is null";

4
src/serverP2P/ServerManagementUDP.java
Unescape Escape View File

@ -54,8 +54,8 @@ public class ServerManagementUDP extends ServerManagement {
* @param logger Logger item * @param logger Logger item
* @param tracker Tracker * @param tracker Tracker
*/ */
public ServerManagementUDP(String baseDirectory, String hostName, int port, Logger logger, HostItem tracker) { public ServerManagementUDP(String baseDirectory, HostItem server, HostItem tracker, Logger logger) {
super(baseDirectory, new HostItem(hostName, port), tracker, logger); super(baseDirectory, server, tracker, logger);
assert baseDirectory != null : "baseDirectory is null"; assert baseDirectory != null : "baseDirectory is null";
assert server != null : "server is null"; assert server != null : "server is null";
assert tracker != null : "tracker is null"; assert tracker != null : "tracker is null";

117
src/serverP2P/ServerP2P.java
Unescape Escape View File

@ -1,10 +1,14 @@
package serverP2P; package serverP2P;
import java.util.Scanner;
import serverP2P.ServerManagementUDP; import serverP2P.ServerManagementUDP;
import serverP2P.ServerManagementTCP; import serverP2P.ServerManagementTCP;
import tools.Directories; import tools.Directories;
import tools.Logger; import tools.Logger;
import tools.HostItem; import tools.HostItem;
import java.util.Scanner; import tools.ServerPortRange;
import tools.TrackerPortRange;
/** Server only implementation /** Server only implementation
* First argument of main method is port listened by the server, and is mandatory. * First argument of main method is port listened by the server, and is mandatory.
@ -14,46 +18,111 @@ import java.util.Scanner;
* @version 1.0 * @version 1.0
*/ */
public class ServerP2P { public class ServerP2P {
private int port;
private Directories directories; private Directories directories;
static private final String subdir = "seeded/"; static private final String subdir = "seeded/";
private Logger logger; private Logger logger;
private HostItem tracker; private HostItem tracker;
private HostItem server;
/** Constructor with portStr containing a port number. /** Constructor with portServerstr containing a port number.
* @param portStr String containing port number of listening. * @param hostnameServer binded hostname
* @param portServer binded port
* @param hostnameTracker tracker hostname
* @param portTracker tracker port
*/ */
public ServerP2P(String portStr, String trackerHostname, String trackerPortStr) { public ServerP2P(String hostnameServer, int portServer, String hostnameTracker, int portTracker) {
port = Integer.valueOf(Integer.parseInt(portStr)); Scanner scanner = new Scanner(System.in);
tracker = new HostItem(trackerHostname, Integer.valueOf(Integer.parseInt(trackerPortStr))); server = new HostItem(hostnameServer, portServer);
directories = new Directories("P2P_JAVA_PROJECT_SERVER_" + port); tracker = new HostItem(hostnameTracker, portTracker);
directories = new Directories("P2P_JAVA_PROJECT_SERVER_" + portServer);
directories.createSubdir(subdir); directories.createSubdir(subdir);
logger = new Logger(directories.getDataHomeDirectory() + "server.log"); logger = new Logger(directories.getDataHomeDirectory() + "server.log");
System.out.println("Server will listen on port " + port + " and serve files from " + directories.getDataHomeDirectory() + subdir); System.out.println("Server will listen on port " + portServer + " and serve files from " + directories.getDataHomeDirectory() + subdir);
Scanner scanner = new Scanner(System.in);
directories.askOpenDataHomeDirectory(subdir, scanner); directories.askOpenDataHomeDirectory(subdir, scanner);
scanner.close(); scanner.close();
} }
/** Main program entry point /** Main program entry point
* first parameter is port number and is mandatory * first parameter is port number and is mandatory
* to test, run with: java -ea serverP2P.ServerP2P -- <portNumber> <TrackerHostname> <TrackerPort> * to test, run with: java serverP2P.ServerP2P
* @param args parameters * @param args parameters
*/ */
public static void main(String [] args) { public static void main(String [] args) {
if (args[1].equals("help") || args[1].equals("-h") || args[1].equals("h")){ final String defaultHostname = "localhost";
System.out.println("usage : java -ea serveurP2P.ServeurP2P -- <serveurPORT> <trackerHOSTNAME> <trackerPORT>"); final ServerPortRange serverPortRange = new ServerPortRange();
final TrackerPortRange trackerPortRange = new TrackerPortRange();
String hostnameServer = "";
int portServer = 0;
String hostnameTracker = "";
int portTracker = 0;
Scanner scanner = new Scanner(System.in);
if ((args.length != 5) && (args.length != 0)){
System.out.println("usage : java serveurP2P.ServeurP2P (interactive) or java serveurP2P.ServeurP2P -- <serveurHOSTNAME> <serveurPORT> <trackerHOSTNAME> <trackerPORT> (" + serverPortRange + " and " + trackerPortRange +")");
System.exit(1);
} }
else{ else if(args.length == 5){
ServerP2P s = new ServerP2P(args[1], args[2], args[3]); hostnameServer = args[1];
ServerManagementUDP smudp = new ServerManagementUDP(s.directories.getDataHomeDirectory() + subdir, "localhost", s.port, s.logger, s.tracker); portServer = Integer.valueOf(Integer.parseInt(args[2]));
ServerManagementTCP smtcp = new ServerManagementTCP(s.directories.getDataHomeDirectory() + subdir, "localhost", s.port, s.logger, s.tracker); hostnameTracker = args[3];
Thread tudp = new Thread(smudp); portTracker = Integer.valueOf(Integer.parseInt(args[4]));
tudp.setName("server UDP P2P-JAVA-PROJECT"); } else {
tudp.start(); System.out.println("Server, enter hostname to bind (default = localhost): ");
Thread ttcp = new Thread(smtcp); hostnameServer = scanner.nextLine();
ttcp.setName("server TCP P2P-JAVA-PROJECT"); if(hostnameServer.equals("")){
ttcp.start(); hostnameServer = defaultHostname;
System.out.println("using default hostname : " + hostnameServer);
}
System.out.println("enter port (default = " + serverPortRange.getDefaultPort() + "): ");
String portServerStr = scanner.nextLine();
if(portServerStr.equals("")){
portServer = serverPortRange.getDefaultPort();
System.out.println("using default port : " + portServer);
} else {
portServer = Integer.valueOf(Integer.parseInt(portServerStr));
}
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 = " + trackerPortRange.getDefaultPort() + "): ");
String portTrackerStr = scanner.nextLine();
if(portTrackerStr.equals("")){
portTracker = serverPortRange.getDefaultPort();
System.out.println("using default port : " + portTracker);
} else {
portTracker = Integer.valueOf(Integer.parseInt(portTrackerStr));
}
} }
}
System.out.println("using hostname : " + hostnameServer);
if(serverPortRange.isPortInRange(portServer)) {
System.out.println("using port : " + portServer);
}
else {
System.out.println("Port not in range. " + serverPortRange);
portServer = serverPortRange.getDefaultPort();
}
System.out.println("tracker hostname : " + hostnameTracker);
if(trackerPortRange.isPortInRange(portTracker)) {
System.out.println("using port : " + portTracker);
}
else {
System.out.println("Port not in range. " + trackerPortRange);
portTracker = trackerPortRange.getDefaultPort();
}
ServerP2P s = new ServerP2P(hostnameServer, portServer, hostnameTracker, portTracker);
ServerManagementUDP smudp = new ServerManagementUDP(s.directories.getDataHomeDirectory() + subdir, s.server, s.tracker, s.logger);
ServerManagementTCP smtcp = new ServerManagementTCP(s.directories.getDataHomeDirectory() + subdir, s.server, s.tracker, s.logger);
Thread tudp = new Thread(smudp);
tudp.setName("server UDP P2P-JAVA-PROJECT");
tudp.start();
Thread ttcp = new Thread(smtcp);
ttcp.setName("server TCP P2P-JAVA-PROJECT");
ttcp.start();
}
} }

49
src/tools/PortRange.java
Unescape Escape View File

@ -0,0 +1,49 @@
package tools;
/** Test ports.
* @author Louis Royer
* @author Flavien Haas
* @author JS Auge
* @version 1.0
*/
public class PortRange {
protected int portMax;
protected int portMin;
protected int defaultPort;
protected String type;
/** Port range constructor
* @param portMin minimum port
* @param portMax maximum port
* @param defaultPort default port
* @param type type of range
*/
public PortRange(int portMin, int portMax, int defaultPort, String type) {
this.portMax = portMax;
this.portMin = portMin;
this.defaultPort = defaultPort;
this.type = type;
}
/** test if port given correspond a range : registered ports, can be used without superuser privileges
* @return true if port was valid
*/
public boolean isPortInRange(int port) {
return ((port >= portMin) && (port <= portMax));
}
/** To String
* @return String representation
*/
public String toString() {
return "default " + type + "port: " + defaultPort + "(range: " + portMin + " -> " + portMax + ")";
}
/** Default port getter
* @return default port
*/
public int getDefaultPort() {
return defaultPort;
}
}

10
src/tools/ServerPortRange.java
Unescape Escape View File

@ -0,0 +1,10 @@
package tools;
import tools.PortRange;
public class ServerPortRange extends PortRange {
/** Constructor */
public ServerPortRange() {
super(7000, 7999, 7070, "server");
}
}

10
src/tools/TrackerPortRange.java
Unescape Escape View File

@ -0,0 +1,10 @@
package tools;
import tools.PortRange;
public class TrackerPortRange extends PortRange {
/** Constructor */
public TrackerPortRange() {
super(6000, 6999, 6969, "tracker");
}
}

65
src/tracker/Tracker.java
Unescape Escape View File

@ -1,9 +1,13 @@
package tracker; package tracker;
import java.util.Scanner;
import tracker.TrackerManagementTCP; import tracker.TrackerManagementTCP;
import tracker.TrackerManagementUDP; import tracker.TrackerManagementUDP;
import tools.Directories; import tools.Directories;
import tools.Logger; import tools.Logger;
import java.util.Scanner; import tools.LogLevel;
import tools.TrackerPortRange;
import tools.HostItem;
/** Tracker implementation /** Tracker implementation
* First argument of main method is port listened by the tracker, and is mandatory. * First argument of main method is port listened by the tracker, and is mandatory.
@ -13,15 +17,16 @@ import java.util.Scanner;
* @version 1.0 * @version 1.0
*/ */
public class Tracker { public class Tracker {
private int port; private HostItem tracker;
private Directories directories; private Directories directories;
private Logger logger; private Logger logger;
/** Constructor with portStr containing a port number. /** Constructor with portStr containing a port number.
* @param portStr String containing port number of listening. * @param hostname hostname to bind
* @param port port to bind
*/ */
public Tracker(String portStr) { public Tracker(String hostname, int port) {
port = Integer.valueOf(Integer.parseInt(portStr)); tracker = new HostItem(hostname, port);
directories = new Directories("P2P_JAVA_PROJECT_TRACKER_" + port); directories = new Directories("P2P_JAVA_PROJECT_TRACKER_" + port);
logger = new Logger(directories.getDataHomeDirectory() + "tracker.log"); logger = new Logger(directories.getDataHomeDirectory() + "tracker.log");
System.out.println("Tracker will listen on port " + port + " and write logs into " + directories.getDataHomeDirectory()); System.out.println("Tracker will listen on port " + port + " and write logs into " + directories.getDataHomeDirectory());
@ -32,13 +37,52 @@ public class Tracker {
/** Main program entry point /** Main program entry point
* first parameter is port number and is mandatory * first parameter is port number and is mandatory
* to test, run with: java -ea serverP2P.ServerP2P -- <portNumber> * to test, run with: java serverP2P.ServerP2P
* @param args parameters * @param args parameters
*/ */
public static void main(String [] args) { public static void main(String [] args) {
Tracker t = new Tracker(args[1]); final TrackerPortRange trackerPortRange = new TrackerPortRange();
TrackerManagementUDP tmudp = new TrackerManagementUDP(t.port, t.logger); final String defaultHostname = "localhost";
TrackerManagementTCP tmtcp = new TrackerManagementTCP(t.port, t.logger); Scanner scanner = new Scanner(System.in);
String hostname = "";
int port = 0;
Tracker t;
if ((args.length != 3) && (args.length != 0)){
System.out.println("usage : java tracker.Tracker (interactive) or java trackerP2P.trackerP2P -- <hostname> <PORT> (" + trackerPortRange +")");
System.exit(1);
} else if (args.length == 3){
hostname = args[1];
port = Integer.valueOf(Integer.parseInt(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 = " + trackerPortRange.getDefaultPort() +"): ");
String portStr = scanner.nextLine();
if(portStr.equals("")){
port = trackerPortRange.getDefaultPort();
System.out.println("using default port : " + port);
} else {
port = Integer.valueOf(Integer.parseInt(portStr));
}
}
System.out.println("using hostname : " + hostname);
if(trackerPortRange.isPortInRange(port)) {
System.out.println("using port : " + port);
t = new Tracker(hostname, port);
}
else {
System.out.println("Port not in range. " + trackerPortRange);
t = new Tracker(hostname, trackerPortRange.getDefaultPort());
}
TrackerManagementUDP tmudp = new TrackerManagementUDP(t.tracker, t.logger);
TrackerManagementTCP tmtcp = new TrackerManagementTCP(t.tracker, t.logger);
Thread tudp = new Thread(tmudp); Thread tudp = new Thread(tmudp);
tudp.setName("Tracker UDP P2P-JAVA-PROJECT"); tudp.setName("Tracker UDP P2P-JAVA-PROJECT");
tudp.start(); tudp.start();
@ -46,5 +90,4 @@ public class Tracker {
ttcp.setName("Tracker TCP P2P-JAVA-PROJECT"); ttcp.setName("Tracker TCP P2P-JAVA-PROJECT");
ttcp.start(); ttcp.start();
} }
} }

35
src/tracker/TrackerManagementTCP.java
Unescape Escape View File

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

8
src/tracker/TrackerManagementUDP.java
Unescape Escape View File

@ -34,15 +34,15 @@ import tracker.TrackerManagement;
public class TrackerManagementUDP extends TrackerManagement { public class TrackerManagementUDP extends TrackerManagement {
private DatagramSocket socket; private DatagramSocket socket;
/** Constructor with port and logger. /** Constructor with port and logger.
* @param port Port used to listen. * @param tracker hostitem of the tracker.
* @param logger Logger object * @param logger Logger object
*/ */
public TrackerManagementUDP(int port, Logger logger) { public TrackerManagementUDP(HostItem tracker, Logger logger) {
super(new HostItem("localhost", port), logger); super(tracker, logger);
try { try {
socket = new DatagramSocket(tracker.getPort(), tracker.getInetAddress()); socket = new DatagramSocket(tracker.getPort(), tracker.getInetAddress());
} catch (SocketException e) { } catch (SocketException e) {
logger.writeUDP("Error: cannot listen on port " + port, LogLevel.Error); logger.writeUDP("Error: cannot listen on " + tracker, LogLevel.Error);
System.exit(-1); System.exit(-1);
} }
} }

Write Preview
Loading…
Cancel
Save