From fd5eac9988c9f9bce5bc8fa06d7bdbfc8bdc98c0 Mon Sep 17 00:00:00 2001 From: Louis Date: Wed, 4 Mar 2020 15:03:23 +0100 Subject: [PATCH] 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); } }