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

Merge pull request 'clitracker' (#79) from clitracker into etape4

Browse Source 
Fix #80
pull/46/head
Louis Royer 5 years ago
parent 1355ef14b1 7253a34e49
commit e0bf3782c0
11 changed files with 390 additions and 139 deletions
Show Stats Download Patch File Download Diff File

6
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.

159
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(); initDirectoriesAndLoggers();
System.err.println("Error incorrect port " + oldPort + " using default port " + defaultPort); System.out.println("Server will listen on port " + portServer + " and serve files from " + directories.getDataHomeDirectory());
loggerServer.write("incorrect port " + oldPort + " using default port " + defaultPort, LogLevel.Info);
}
initDirectoriesAndLoggers();
host = "localhost";
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,25 +81,86 @@ 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 if(args.length == 6){
protocolClient = args[1];
hostnameServer = args[2];
portServer = Integer.valueOf(Integer.parseInt(args[3]));
hostnameTracker = args[4];
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));
}
}
System.out.println("using hostname : " + hostnameServer);
if(serverPortRange.isPortInRange(portServer)){
System.out.println("using port : " + portServer);
} }
else { else {
ClientP2P c; System.out.println("Port not in range. " + serverPortRange);
try { portServer = serverPortRange.getDefaultPort();
c = new ClientP2P(args[1]); }
} catch (IndexOutOfBoundsException e){ System.out.println("tracker hostname : " + hostnameTracker);
c = new ClientP2P("" + defaultPort);
if(trackerPortRange.isPortInRange(portTracker)){
System.out.println("using port : " + portTracker);
}
else {
System.out.println("Port not in range. " + trackerPortRange);
portTracker = trackerPortRange.getDefaultPort();
} }
// Server threads ClientP2P c = new ClientP2P(hostnameServer, portServer, hostnameTracker, portTracker);
ServerManagementUDP smudp = new ServerManagementUDP(c.directories.getDataHomeDirectory(), "localhost", c.port, c.loggerServer, c.tracker);
ServerManagementTCP smtcp = new ServerManagementTCP(c.directories.getDataHomeDirectory(), "localhost", c.port, c.loggerServer, c.tracker); 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); Thread tudp = new Thread(smudp);
tudp.setName("server UDP P2P-JAVA-PROJECT (port: " + c.port + ")"); tudp.setName("server UDP P2P-JAVA-PROJECT");
tudp.start(); tudp.start();
Thread ttcp = new Thread(smtcp); Thread ttcp = new Thread(smtcp);
ttcp.setName("server TCP P2P-JAVA-PROJECT (port: " + c.port + ")"); ttcp.setName("server TCP P2P-JAVA-PROJECT");
ttcp.start(); ttcp.start();
// Wait a bit before printing client interface // Wait a bit before printing client interface
@ -101,19 +171,15 @@ public class ClientP2P {
Thread.currentThread().interrupt(); 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();
String transportchoosen = c.scanner.nextLine();
Thread t;
switch(transportchoosen){
case "UDP": case "UDP":
case "udp": case "udp":
case "upd": // alias typo case "upd": // to avoid users typos
case "2" : case "2" :
System.out.println("Starting with UDP"); System.out.println("Starting with UDP");
ClientManagementUDP cmudp = new ClientManagementUDP(c.directories.getDataHomeDirectory(), c.tracker, c.directories.getDataHomeDirectory() + c.partsDir, c.loggerClient, c.scanner); ClientManagementUDP cmudp = new ClientManagementUDP(c.directories.getDataHomeDirectory(), c.tracker, c.directories.getDataHomeDirectory() + c.partsDir, c.loggerClient, c.scanner);
t = new Thread(cmudp); tclient = new Thread(cmudp);
break; break;
case "TCP": case "TCP":
case "tcp": case "tcp":
@ -121,18 +187,15 @@ public class ClientP2P {
default: default:
System.out.println("Starting with TCP"); System.out.println("Starting with TCP");
ClientManagementTCP cmtcp = new ClientManagementTCP(c.directories.getDataHomeDirectory(), c.tracker, c.directories.getDataHomeDirectory() + c.partsDir, c.loggerClient, c.scanner); ClientManagementTCP cmtcp = new ClientManagementTCP(c.directories.getDataHomeDirectory(), c.tracker, c.directories.getDataHomeDirectory() + c.partsDir, c.loggerClient, c.scanner);
t = new Thread(cmtcp); tclient = new Thread(cmtcp);
break; break;
} }
t.setName("client P2P-JAVA-PROJECT"); tclient.setName("client P2P-JAVA-PROJECT");
t.start(); tclient.start();
try { try {
t.join(); tclient.join();
} catch (InterruptedException e) {} } catch (InterruptedException e) {}
c.scanner.close();
smudp.setStop(); smudp.setStop();
smtcp.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";

103
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,40 +18,106 @@ 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 if(args.length == 5){
hostnameServer = args[1];
portServer = Integer.valueOf(Integer.parseInt(args[2]));
hostnameTracker = args[3];
portTracker = Integer.valueOf(Integer.parseInt(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 = " + 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 { else {
ServerP2P s = new ServerP2P(args[1], args[2], args[3]); System.out.println("Port not in range. " + serverPortRange);
ServerManagementUDP smudp = new ServerManagementUDP(s.directories.getDataHomeDirectory() + subdir, "localhost", s.port, s.logger, s.tracker); portServer = serverPortRange.getDefaultPort();
ServerManagementTCP smtcp = new ServerManagementTCP(s.directories.getDataHomeDirectory() + subdir, "localhost", s.port, s.logger, s.tracker); }
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); Thread tudp = new Thread(smudp);
tudp.setName("server UDP P2P-JAVA-PROJECT"); tudp.setName("server UDP P2P-JAVA-PROJECT");
tudp.start(); tudp.start();
@ -56,4 +126,3 @@ public class ServerP2P {
ttcp.start(); 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");
}
}

63
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();
} }
} }

33
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

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