From e947fc7c4601faa6c070435b0ab9e757bc65e76a Mon Sep 17 00:00:00 2001 From: Louis Date: Tue, 3 Mar 2020 19:30:04 +0100 Subject: [PATCH 1/2] fixes #18 --- src/clientP2P/ClientP2P.java | 2 +- src/protocolP2P/ProtocolP2PPacketTCP.java | 5 +- src/serverP2P/ServerManagementTCP.java | 84 +++++++++++++---------- src/serverP2P/ServerManagementUDP.java | 6 +- src/serverP2P/ServerP2P.java | 14 ++-- src/tools/Directories.java | 17 +++-- src/tools/Logger.java | 57 +++++++++++++++ 7 files changed, 132 insertions(+), 53 deletions(-) create mode 100644 src/tools/Logger.java diff --git a/src/clientP2P/ClientP2P.java b/src/clientP2P/ClientP2P.java index 43d88ee..c8ee8a9 100644 --- a/src/clientP2P/ClientP2P.java +++ b/src/clientP2P/ClientP2P.java @@ -13,7 +13,7 @@ public class ClientP2P { host = "localhost"; port = 40001; System.out.println("Client will try to contact server at " + host + " on port " + port + ". It will save files in " + directories.getDataHomeDirectory()); - directories.askOpenDataHomeDirectory(); + directories.askOpenDataHomeDirectory(null); } public static void main(String [] args) { diff --git a/src/protocolP2P/ProtocolP2PPacketTCP.java b/src/protocolP2P/ProtocolP2PPacketTCP.java index 3f2dfc5..59d7eb4 100644 --- a/src/protocolP2P/ProtocolP2PPacketTCP.java +++ b/src/protocolP2P/ProtocolP2PPacketTCP.java @@ -62,8 +62,7 @@ public class ProtocolP2PPacketTCP extends ProtocolP2PPacket { outputStream.write(packet); outputStream.flush(); } catch (IOException e) { - // closing socket - System.err.println("Error: cannot send response, closing socket"); + // Error: cannot send response, closing socket try { socket.close(); } catch (IOException e2) { @@ -112,7 +111,7 @@ public class ProtocolP2PPacketTCP extends ProtocolP2PPacket { try { System.err.println("Reading " + ss.getInputStream().read(packet) + " bytes"); } catch (IOException e) { - System.err.println("Error: cannot read request, closing socket"); + // Error: cannot read request, closing socket try { ss.close(); } catch (IOException e2) { diff --git a/src/serverP2P/ServerManagementTCP.java b/src/serverP2P/ServerManagementTCP.java index f62e2c0..5e4256d 100644 --- a/src/serverP2P/ServerManagementTCP.java +++ b/src/serverP2P/ServerManagementTCP.java @@ -28,6 +28,7 @@ import remoteException.ProtocolRemoteError; import remoteException.VersionRemoteError; import remoteException.EmptyFile; import java.util.Arrays; +import tools.Logger; /** Implementation of P2P-JAVA-PROJECT VERSION 1.0 protocol for TCP. @@ -42,12 +43,14 @@ public class ServerManagementTCP implements Runnable { private String baseDirectory; private int TCPPort; private ServerSocket socket; + private Logger logger; /** Constructor for TCP implementation, with baseDirectory and TCPPort parameters. * @param baseDirectory the root directory where files are stored * @param TCPPort the server will listen on this port */ - public ServerManagementTCP(String baseDirectory, int TCPPort) { + public ServerManagementTCP(String baseDirectory, int TCPPort, Logger logger) { + this.logger = logger; this.baseDirectory = baseDirectory; this.TCPPort = TCPPort; initFileList(); @@ -65,10 +68,10 @@ public class ServerManagementTCP implements Runnable { /** Implementation of runnable. This methods allows to run the server. */ public void run() { + logger.writeTCP("Server sucessfully started"); do { try { Socket s = socket.accept(); - System.err.println("Accepting new connection"); ClientHandler c = new ClientHandler(s); (new Thread(c)).start(); } catch (IOException e) { @@ -80,22 +83,60 @@ public class ServerManagementTCP implements Runnable { /** Private runnable class allowing to serve one client. */ private class ClientHandler implements Runnable { - Socket s; + private Socket s; + private String addr; /** Constructor with a socket. * @param s Socket of this client */ public ClientHandler(Socket s) { this.s = s; + this.addr = "[" +s.getInetAddress().getHostAddress() + "]:" + s.getPort() + " "; } /** Implementation of runnable. This method allow to serve one client. */ public void run() { + boolean end = false; + logger.writeTCP(addr + "New connection"); do { - end = handleRequest(s); + end = handleRequest(); } while(!end); - System.err.println("End of thread"); + logger.writeTCP(addr + "End of connection"); + } + + /** Respond to next request incomming on socket s. + * @param s Socket used to read request and send response + * @return true if cannot expect another request (ie, socket is closed) + */ + private boolean handleRequest() { + try { + ProtocolP2PPacketTCP pd = new ProtocolP2PPacketTCP((Object)s); + Payload p = pd.getPayload(); + switch (p.getRequestResponseCode()) { + case LOAD_REQUEST: + logger.writeTCP(addr + "LOAD_REQUEST"); + sendLoadResponse(pd); + break; + case LIST_REQUEST: + logger.writeTCP(addr + "LIST_REQUEST"); + sendListResponse(pd); + break; + default: + logger.writeTCP(addr + "Received grabbage"); + sendInternalError(pd); + } + } catch (IOException e) { + return true; + } catch (SocketClosed e) { + return true; + } + catch (TransmissionError e) {} + catch (ProtocolError e) {} + catch (VersionError e) {} + catch (InternalError e) {} + catch (SizeError e) {} + return false; } } @@ -197,37 +238,4 @@ public class ServerManagementTCP implements Runnable { } } - /** Respond to next request incomming on socket s. - * @param s Socket used to read request and send response - * @return true if cannot expect another request (ie, socket is closed) - */ - private boolean handleRequest(Socket s) { - try { - ProtocolP2PPacketTCP pd = new ProtocolP2PPacketTCP((Object)s); - Payload p = pd.getPayload(); - switch (p.getRequestResponseCode()) { - case LOAD_REQUEST: - System.out.println("Received LOAD_REQUEST"); - sendLoadResponse(pd); - break; - case LIST_REQUEST: - System.out.println("Received LIST_REQUEST"); - sendListResponse(pd); - break; - default: - sendInternalError(pd); - } - } catch (IOException e) { - return true; - } catch (SocketClosed e) { - return true; - } - catch (TransmissionError e) {} - catch (ProtocolError e) {} - catch (VersionError e) {} - catch (InternalError e) {} - catch (SizeError e) {} - return false; - } - } diff --git a/src/serverP2P/ServerManagementUDP.java b/src/serverP2P/ServerManagementUDP.java index a96138b..d7c785a 100644 --- a/src/serverP2P/ServerManagementUDP.java +++ b/src/serverP2P/ServerManagementUDP.java @@ -27,6 +27,7 @@ import remoteException.ProtocolRemoteError; import remoteException.VersionRemoteError; import remoteException.EmptyFile; import java.util.Arrays; +import tools.Logger; /** Implementation of P2P-JAVA-PROJECT VERSION 1.0 protocol for UDP. @@ -41,12 +42,14 @@ public class ServerManagementUDP implements Runnable { private String baseDirectory; private int UDPPort; private DatagramSocket socket; + private Logger logger; /** Constructor for UDP implementation, with baseDirectory and UDPPort parameters. * @param baseDirectory the root directory where files are stored * @param UDPPort the server will listen on this port */ - public ServerManagementUDP(String baseDirectory, int UDPPort) { + public ServerManagementUDP(String baseDirectory, int UDPPort, Logger logger) { + this.logger = logger; this.baseDirectory = baseDirectory; this.UDPPort = UDPPort; initFileList(); @@ -61,6 +64,7 @@ public class ServerManagementUDP implements Runnable { /** Implementation of runnable. This methods allows to run the server. */ public void run() { + logger.writeUDP("Server sucessfully started"); while(true) { try { ProtocolP2PPacketUDP pd = new ProtocolP2PPacketUDP((Object)socket); diff --git a/src/serverP2P/ServerP2P.java b/src/serverP2P/ServerP2P.java index 52ef26c..d4346c3 100644 --- a/src/serverP2P/ServerP2P.java +++ b/src/serverP2P/ServerP2P.java @@ -2,28 +2,32 @@ package serverP2P; import serverP2P.ServerManagementUDP; import serverP2P.ServerManagementTCP; import tools.Directories; +import tools.Logger; public class ServerP2P { private int port; private Directories directories; + static private final String subdir = "seeded/"; + private Logger logger; + public ServerP2P() { directories = new Directories("P2P_JAVA_PROJECT_SERVER"); + logger = new Logger(directories.getDataHomeDirectory() + "server.log"); port = 40001; - System.out.println("Server will listen on port " + port + " and serve files from " + directories.getDataHomeDirectory()); - directories.askOpenDataHomeDirectory(); + System.out.println("Server will listen on port " + port + " and serve files from " + directories.getDataHomeDirectory() + subdir); + directories.askOpenDataHomeDirectory(subdir); } public static void main(String [] args) { ServerP2P s = new ServerP2P(); - ServerManagementUDP smudp = new ServerManagementUDP(s.directories.getDataHomeDirectory(), s.port); - ServerManagementTCP smtcp = new ServerManagementTCP(s.directories.getDataHomeDirectory(), s.port); + ServerManagementUDP smudp = new ServerManagementUDP(s.directories.getDataHomeDirectory() + subdir, s.port, s.logger); + ServerManagementTCP smtcp = new ServerManagementTCP(s.directories.getDataHomeDirectory() + subdir, s.port, 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(); - System.out.println("Server started."); } } diff --git a/src/tools/Directories.java b/src/tools/Directories.java index da6363f..cb0326a 100644 --- a/src/tools/Directories.java +++ b/src/tools/Directories.java @@ -57,14 +57,21 @@ public class Directories { /** Opens dataHomeDirectory if supported. */ - private void openDataHomeDirectory() { + private void openDataHomeDirectory(String subdir) { + String d = dataHomeDirectory; + if (subdir != null) { + d += subdir; + if (!subdir.endsWith("/")) { + d += "/"; + } + } try { if (os.equals("Linux")) { Runtime runtime = Runtime.getRuntime(); - runtime.exec(new String[] { "xdg-open", dataHomeDirectory }); + runtime.exec(new String[] { "xdg-open", d }); } else if (os.equals("Mac")||os.equals("Mac OS X")) { Runtime runtime = Runtime.getRuntime(); - runtime.exec(new String[] { "open", dataHomeDirectory }); + runtime.exec(new String[] { "open", d }); } } catch (IOException e) { System.out.println("Error encountered while trying to open directory"); @@ -73,14 +80,14 @@ public class Directories { /** Asks the user to choose opening dataHomeDirectory or not. */ - public void askOpenDataHomeDirectory() { + public void askOpenDataHomeDirectory(String subdir) { if (os.equals("Linux") || os.equals("Mac") || os.equals("Mac OS X")) { System.out.println("Do you want to open this directory? (y/N)"); Scanner scanner = new Scanner(System.in); String resp = scanner.nextLine(); if (resp.equals("y") || resp.equals("Y")) { System.out.println("Openning"); - openDataHomeDirectory(); + openDataHomeDirectory(subdir); } } } diff --git a/src/tools/Logger.java b/src/tools/Logger.java new file mode 100644 index 0000000..dbbac24 --- /dev/null +++ b/src/tools/Logger.java @@ -0,0 +1,57 @@ +package tools; +import java.nio.file.Files; +import java.nio.file.Paths; +import java.nio.file.Path; +import java.nio.file.StandardOpenOption; +import java.io.IOException; +import java.sql.Timestamp; + + +/** Helper to log. + * @author Louis Royer + * @author Flavien Haas + * @author JS Auge + * @version 1.0 + */ +public class Logger { + private Path logFile; + + public Logger(String logFile) { + assert logFile != null : "Logfile name is null"; + this.logFile = Paths.get(logFile); + try { + this.logFile.toFile().createNewFile(); + } catch (IOException e) { + System.err.println("Error: cannot initialize logfile"); + } + } + + /** Appends log to filelog and print to stderr. + * @param text Text to log + */ + private void write(String text) { + System.err.println(text); + try { + Files.write(logFile, ("[" + new Timestamp(System.currentTimeMillis()) + "] " + text + "\n").getBytes(), StandardOpenOption.APPEND); + } catch (IOException e) { + System.err.println("Error: cannot write in logfile"); + } + } + + /** Appends log to filelog and print to stderr. + * Adds [TCP] in log line. + * @param text Text to log + */ + public void writeTCP(String text) { + write("[TCP] " + text); + } + + /** Appends log to filelog and print to stderr. + * Adds [UDP] in log line. + * @param text Text to log + */ + public void writeUDP(String text) { + write("[UDP] " + text); + } + +} From fd5eac9988c9f9bce5bc8fa06d7bdbfc8bdc98c0 Mon Sep 17 00:00:00 2001 From: Louis Date: Wed, 4 Mar 2020 15:03:23 +0100 Subject: [PATCH 2/2] Add logLevel --- src/serverP2P/ServerManagementTCP.java | 44 +++++++------- src/serverP2P/ServerManagementUDP.java | 34 ++++++----- src/tools/LogLevel.java | 8 +++ src/tools/Logger.java | 84 +++++++++++++++++++++++--- 4 files changed, 123 insertions(+), 47 deletions(-) create mode 100644 src/tools/LogLevel.java diff --git a/src/serverP2P/ServerManagementTCP.java b/src/serverP2P/ServerManagementTCP.java index 5e4256d..e84d975 100644 --- a/src/serverP2P/ServerManagementTCP.java +++ b/src/serverP2P/ServerManagementTCP.java @@ -29,6 +29,7 @@ import remoteException.VersionRemoteError; import remoteException.EmptyFile; import java.util.Arrays; import tools.Logger; +import tools.LogLevel; /** Implementation of P2P-JAVA-PROJECT VERSION 1.0 protocol for TCP. @@ -57,10 +58,10 @@ public class ServerManagementTCP implements Runnable { try { socket = new ServerSocket(TCPPort); } catch (SocketException e) { - System.err.println("Error: cannot listen on port " + TCPPort + " (TCP)"); + logger.writeTCP("Error: cannot listen on port " + TCPPort, LogLevel.Error); System.exit(-1); } catch (IOException e) { - System.err.println("Error: cannot openning TCP socket"); + logger.writeTCP("Error: cannot openning socket", LogLevel.Error); System.exit(-2); } } @@ -68,14 +69,14 @@ public class ServerManagementTCP implements Runnable { /** Implementation of runnable. This methods allows to run the server. */ public void run() { - logger.writeTCP("Server sucessfully started"); + logger.writeTCP("Server sucessfully started", LogLevel.Info); do { try { Socket s = socket.accept(); ClientHandler c = new ClientHandler(s); (new Thread(c)).start(); } catch (IOException e) { - System.err.println("Error while accepting new connection"); + logger.writeTCP("Error while accepting new connection", LogLevel.Warning); } } while(true); } @@ -98,11 +99,11 @@ public class ServerManagementTCP implements Runnable { public void run() { boolean end = false; - logger.writeTCP(addr + "New connection"); + logger.writeTCP(addr + "New connection", LogLevel.Action); do { end = handleRequest(); } while(!end); - logger.writeTCP(addr + "End of connection"); + logger.writeTCP(addr + "End of connection", LogLevel.Action); } /** Respond to next request incomming on socket s. @@ -115,15 +116,15 @@ public class ServerManagementTCP implements Runnable { Payload p = pd.getPayload(); switch (p.getRequestResponseCode()) { case LOAD_REQUEST: - logger.writeTCP(addr + "LOAD_REQUEST"); + logger.writeTCP(addr + "LOAD_REQUEST", LogLevel.Action); sendLoadResponse(pd); break; case LIST_REQUEST: - logger.writeTCP(addr + "LIST_REQUEST"); + logger.writeTCP(addr + "LIST_REQUEST", LogLevel.Action); sendListResponse(pd); break; default: - logger.writeTCP(addr + "Received grabbage"); + logger.writeTCP(addr + "Received grabbage", LogLevel.Action); sendInternalError(pd); } } catch (IOException e) { @@ -161,10 +162,11 @@ public class ServerManagementTCP implements Runnable { * @param pd ProtocolP2PPacketTCP to respond */ private void sendInternalError(ProtocolP2PPacketTCP pd) { + logger.writeTCP("Internal Error", LogLevel.Warning); try { pd.sendResponse((ProtocolP2PPacket)new ProtocolP2PPacketTCP(new Payload(RequestResponseCode.INTERNAL_ERROR))); } catch (Exception e) { - System.err.println(e); + logger.writeTCP(e, LogLevel.Error); } } @@ -174,14 +176,14 @@ public class ServerManagementTCP implements Runnable { private void sendListResponse(ProtocolP2PPacketTCP pd) { try { if (fileList.length == 0) { - System.err.println("Sending EMPTY_DIRECTORY"); + logger.writeTCP("Sending EMPTY_DIRECTORY", LogLevel.Action); pd.sendResponse((ProtocolP2PPacket)new ProtocolP2PPacketTCP(new Payload(RequestResponseCode.EMPTY_DIRECTORY))); } else { - System.out.println("Sending LIST_RESPONSE"); + logger.writeTCP("Sending LIST_RESPONSE", LogLevel.Action); pd.sendResponse((ProtocolP2PPacket)new ProtocolP2PPacketTCP((Payload)(new FileList(fileList)))); } } catch (Exception e2) { - System.err.println(e2); + logger.writeTCP(e2, LogLevel.Error); } } @@ -201,13 +203,13 @@ public class ServerManagementTCP implements Runnable { byte[] fullLoad = Files.readAllBytes(Paths.get(baseDirectory + filename)); long sizeToSend = 0; if (fullLoad.length - offset < maxSizePartialContent) { - System.out.println("Sending last partialContent"); + logger.writeTCP("Sending last partialContent", LogLevel.Debug); sizeToSend = fullLoad.length - offset; } else { sizeToSend = maxSizePartialContent; } - System.out.println("maxSizePartialContent: " + maxSizePartialContent); - System.out.println("Sending " + filename + " from " + offset + " to " + (offset + sizeToSend)); + logger.writeTCP("maxSizePartialContent: " + maxSizePartialContent, LogLevel.Debug); + logger.writeTCP("Sending " + filename + " from " + offset + " to " + (offset + sizeToSend), LogLevel.Debug); byte[] load = Arrays.copyOfRange(fullLoad, (int)offset, (int)(offset + sizeToSend)); if (Arrays.binarySearch(fileList, filename) >= 0) { try { @@ -217,13 +219,13 @@ public class ServerManagementTCP implements Runnable { pd.sendResponse((ProtocolP2PPacket)new ProtocolP2PPacketTCP((Payload)(new FilePart(filename, fullLoad.length, offset, load)))); } } catch (Exception e2) { - System.err.println(e2); + logger.writeTCP(e2, LogLevel.Error); } } else { - System.err.println("File requested not found: `" + filename + "` " + Arrays.binarySearch(fileList, filename)); - System.err.println("File list:"); + logger.writeTCP("File requested not found: `" + filename + "` " + Arrays.binarySearch(fileList, filename), LogLevel.Debug); + logger.writeTCP("File list:", LogLevel.Debug); for (String f: fileList) { - System.err.println("- " + f); + logger.writeTCP("- " + f, LogLevel.Debug); } throw new IOException(); // to send a NOT_FOUND in the catch block @@ -232,7 +234,7 @@ public class ServerManagementTCP implements Runnable { try { pd.sendResponse((ProtocolP2PPacket)new ProtocolP2PPacketTCP(new Payload(RequestResponseCode.NOT_FOUND))); } catch (Exception e2) { - System.err.println(e2); + logger.writeTCP(e2, LogLevel.Debug); } } } diff --git a/src/serverP2P/ServerManagementUDP.java b/src/serverP2P/ServerManagementUDP.java index d7c785a..1044ab0 100644 --- a/src/serverP2P/ServerManagementUDP.java +++ b/src/serverP2P/ServerManagementUDP.java @@ -28,6 +28,7 @@ import remoteException.VersionRemoteError; import remoteException.EmptyFile; import java.util.Arrays; import tools.Logger; +import tools.LogLevel; /** Implementation of P2P-JAVA-PROJECT VERSION 1.0 protocol for UDP. @@ -56,7 +57,7 @@ public class ServerManagementUDP implements Runnable { try { socket = new DatagramSocket(UDPPort); } catch (SocketException e) { - System.err.println("Error: cannot listen on port " + UDPPort + " (UDP)"); + logger.writeUDP("Error: cannot listen on port " + UDPPort, LogLevel.Error); System.exit(-1); } } @@ -64,14 +65,14 @@ public class ServerManagementUDP implements Runnable { /** Implementation of runnable. This methods allows to run the server. */ public void run() { - logger.writeUDP("Server sucessfully started"); + logger.writeUDP("Server sucessfully started", LogLevel.Info); while(true) { try { ProtocolP2PPacketUDP pd = new ProtocolP2PPacketUDP((Object)socket); Payload p = pd.getPayload(); switch (p.getRequestResponseCode()) { case LOAD_REQUEST: - System.out.println("Received LOAD_REQUEST"); + logger.writeUDP("Received LOAD_REQUEST", LogLevel.Action); assert p instanceof LoadRequest : "payload must be an instance of LoadRequest"; if (!(p instanceof LoadRequest)) { sendInternalError(pd); @@ -83,13 +84,13 @@ public class ServerManagementUDP implements Runnable { byte[] fullLoad = Files.readAllBytes(Paths.get(baseDirectory + filename)); long sizeToSend = 0; if (fullLoad.length - offset < maxSizePartialContent) { - System.out.println("Sending last partialContent"); + logger.writeUDP("Sending last partialContent", LogLevel.Debug); sizeToSend = fullLoad.length - offset; } else { sizeToSend = maxSizePartialContent; } - System.out.println("maxSizePartialContent: " + maxSizePartialContent); - System.out.println("Sending " + filename + " from " + offset + " to " + (offset + sizeToSend)); + logger.writeUDP("maxSizePartialContent: " + maxSizePartialContent, LogLevel.Debug); + logger.writeUDP("Sending " + filename + " from " + offset + " to " + (offset + sizeToSend), LogLevel.Debug); byte[] load = Arrays.copyOfRange(fullLoad, (int)offset, (int)(offset + sizeToSend)); if (Arrays.binarySearch(fileList, filename) >= 0) { try { @@ -99,13 +100,13 @@ public class ServerManagementUDP implements Runnable { pd.sendResponse((ProtocolP2PPacket)new ProtocolP2PPacketUDP((Payload)(new FilePart(filename, fullLoad.length, offset, load)))); } } catch (Exception e2) { - System.err.println(e2); + logger.writeUDP(e2, LogLevel.Error); } } else { - System.err.println("File requested not found: `" + filename + "` " + Arrays.binarySearch(fileList, filename)); - System.err.println("File list:"); + logger.writeUDP("File requested not found: `" + filename + "` " + Arrays.binarySearch(fileList, filename), LogLevel.Debug); + logger.writeUDP("File list:", LogLevel.Debug); for (String f: fileList) { - System.err.println("- " + f); + logger.writeUDP("- " + f, LogLevel.Debug); } throw new IOException(); // to send a NOT_FOUND in the catch block @@ -114,23 +115,23 @@ public class ServerManagementUDP implements Runnable { try { pd.sendResponse((ProtocolP2PPacket)new ProtocolP2PPacketUDP(new Payload(RequestResponseCode.NOT_FOUND))); } catch (Exception e2) { - System.err.println(e2); + logger.writeUDP(e2, LogLevel.Error); } } } break; case LIST_REQUEST: - System.out.println("Received LIST_REQUEST"); + logger.writeUDP("Received LIST_REQUEST", LogLevel.Action); try { if (fileList.length == 0) { - System.err.println("Sending EMPTY_DIRECTORY"); + logger.writeUDP("Sending EMPTY_DIRECTORY", LogLevel.Action); pd.sendResponse((ProtocolP2PPacket)new ProtocolP2PPacketUDP(new Payload(RequestResponseCode.EMPTY_DIRECTORY))); } else { - System.out.println("Sending LIST_RESPONSE"); + logger.writeUDP("Sending LIST_RESPONSE", LogLevel.Action); pd.sendResponse((ProtocolP2PPacket)new ProtocolP2PPacketUDP((Payload)(new FileList(fileList)))); } } catch (Exception e2) { - System.err.println(e2); + logger.writeUDP(e2, LogLevel.Error); } break; default: @@ -170,10 +171,11 @@ public class ServerManagementUDP implements Runnable { * @param pd ProtocolP2PPacketUDP to respond */ private void sendInternalError(ProtocolP2PPacketUDP pd) { + logger.writeUDP("Internal Error", LogLevel.Warning); try { pd.sendResponse((ProtocolP2PPacket)new ProtocolP2PPacketUDP(new Payload(RequestResponseCode.INTERNAL_ERROR))); } catch (Exception e) { - System.err.println(e); + logger.writeUDP(e, LogLevel.Error); } } diff --git a/src/tools/LogLevel.java b/src/tools/LogLevel.java new file mode 100644 index 0000000..5ff9900 --- /dev/null +++ b/src/tools/LogLevel.java @@ -0,0 +1,8 @@ +package tools; +public enum LogLevel { + Error, + Info, + Warning, + Action, + Debug +} diff --git a/src/tools/Logger.java b/src/tools/Logger.java index dbbac24..3ab3b5a 100644 --- a/src/tools/Logger.java +++ b/src/tools/Logger.java @@ -1,4 +1,5 @@ package tools; +import tools.LogLevel; import java.nio.file.Files; import java.nio.file.Paths; import java.nio.file.Path; @@ -29,29 +30,92 @@ public class Logger { /** Appends log to filelog and print to stderr. * @param text Text to log */ - private void write(String text) { - System.err.println(text); - try { - Files.write(logFile, ("[" + new Timestamp(System.currentTimeMillis()) + "] " + text + "\n").getBytes(), StandardOpenOption.APPEND); - } catch (IOException e) { - System.err.println("Error: cannot write in logfile"); + private void write(String text, LogLevel logLevel) { + String msg = "[" + new Timestamp(System.currentTimeMillis()) + "] " + text + "\n"; + String level = null; + switch (logLevel) { + case Error: + level = "[Error]"; + break; + case Info: + level = "[Info]"; + break; + case Warning: + level = "[Warning]"; + break; + case Action: + level = "[Action]"; + break; + case Debug: + level = "[Debug]"; + break; + default: + System.err.println("Error: incorrect logLevel"); + } + if (level != null) { + msg = level + " " + msg; + } + switch (logLevel) { + case Error: + case Info: + case Warning: + case Debug: + default: + System.err.println(text); + break; + case Action: + break; } + switch (logLevel) { + case Debug: + break; + case Error: + case Info: + case Warning: + default: + try { + Files.write(logFile, msg.getBytes(), StandardOpenOption.APPEND); + } catch (IOException e) { + System.err.println("Error: cannot write in logfile"); + } + break; + } + } + + /** Appends log to filelog and print to stderr. + * Adds [TCP] in log line. + * @param text Text to log + * @param logLevel Type of log + */ + public void writeTCP(String text, LogLevel logLevel) { + write("[TCP] " + text, logLevel); } /** Appends log to filelog and print to stderr. * Adds [TCP] in log line. * @param text Text to log + * @param logLevel Type of log */ - public void writeTCP(String text) { - write("[TCP] " + text); + public void writeTCP(Exception e, LogLevel logLevel) { + writeTCP(e.toString(), logLevel); } /** Appends log to filelog and print to stderr. * Adds [UDP] in log line. * @param text Text to log + * @param logLevel Type of log + */ + public void writeUDP(String text, LogLevel logLevel) { + write("[UDP] " + text, logLevel); + } + + /** Appends log to filelog and print to stderr. + * Adds [UDP] in log line. + * @param text Text to log + * @param logLevel Type of log */ - public void writeUDP(String text) { - write("[UDP] " + text); + public void writeUDP(Exception e, LogLevel logLevel) { + writeUDP(e.toString(), logLevel); } }