From 58517266b1f3992dd64836c171324b3174147053 Mon Sep 17 00:00:00 2001 From: EndMove Date: Sat, 5 Mar 2022 14:33:56 +0100 Subject: [PATCH] =?UTF-8?q?R=C3=A9ception=20d'un=20fichier=20prototype,=20?= =?UTF-8?q?correction=20de=20bugs?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- app/src/main/java/lightcontainer/App.java | 5 +- .../domains/client/ClientHandler.java | 20 ++++--- .../protocol/ProtocolReader.java | 58 +----------------- .../protocol/rules/reader/FilelistRule.java | 26 ++++++++ .../protocol/rules/reader/HelloRule.java | 1 - .../protocol/rules/reader/SavefileRule.java | 59 +++++++++++++++++++ .../protocol/rules/reader/SigninRule.java | 28 ++++----- 7 files changed, 117 insertions(+), 80 deletions(-) create mode 100644 app/src/main/java/lightcontainer/protocol/rules/reader/FilelistRule.java create mode 100644 app/src/main/java/lightcontainer/protocol/rules/reader/SavefileRule.java diff --git a/app/src/main/java/lightcontainer/App.java b/app/src/main/java/lightcontainer/App.java index c3ee754..07b9ed6 100644 --- a/app/src/main/java/lightcontainer/App.java +++ b/app/src/main/java/lightcontainer/App.java @@ -8,7 +8,9 @@ import lightcontainer.domains.server.UnicastServerListener; import lightcontainer.interfaces.MulticastSPR; import lightcontainer.interfaces.ProtocolRepository; import lightcontainer.protocol.ProtocolReader; +import lightcontainer.protocol.rules.reader.FilelistRule; import lightcontainer.protocol.rules.reader.HelloRule; +import lightcontainer.protocol.rules.reader.SavefileRule; import lightcontainer.protocol.rules.reader.SigninRule; import lightcontainer.protocol.rules.writer.SignError; import lightcontainer.protocol.rules.writer.SignOk; @@ -33,11 +35,12 @@ public class App { protocolRep.addReader(new HelloRule()); protocolRep.addReader(new SigninRule()); + protocolRep.addReader(new FilelistRule()); + protocolRep.addReader(new SavefileRule()); protocolRep.addWriter(new SignOk()); protocolRep.addWriter(new SignError()); - new UnicastServerListener(clientRep, protocolRep, UNICAST_PORT); new MulticastServerListener(storeRep, protocolRep, MULTICAST_IP, MULTICAST_PORT); FileFrontEnd ffe = new FileFrontEnd(clientRep, storeRep, protocolRep); diff --git a/app/src/main/java/lightcontainer/domains/client/ClientHandler.java b/app/src/main/java/lightcontainer/domains/client/ClientHandler.java index 7d0b6ab..fa26a85 100644 --- a/app/src/main/java/lightcontainer/domains/client/ClientHandler.java +++ b/app/src/main/java/lightcontainer/domains/client/ClientHandler.java @@ -61,12 +61,12 @@ public class ClientHandler implements Runnable, AutoCloseable { private void initClient() { try { this.reader = new BufferedReader(new InputStreamReader( - this.client.getInputStream(), - StandardCharsets.UTF_8 + this.client.getInputStream(), + StandardCharsets.UTF_8 )); this.writer = new PrintWriter(new OutputStreamWriter( - this.client.getOutputStream(), - StandardCharsets.UTF_8 + this.client.getOutputStream(), + StandardCharsets.UTF_8 ), true); } catch (IOException e) { e.printStackTrace(); @@ -90,24 +90,26 @@ public class ClientHandler implements Runnable, AutoCloseable { ProtocolReader.ProtocolResult ruleResult = protocolRep.executeReader(command + "\r\n"); - if (isConnected()) { + ruleResult.read( + this.client.getInputStream() + ); if (ruleResult.getReceiver() == ProtocolReader.ResultCmdReceiver.STOREBACKEND) { fileFrontEnd.newCommand(command, ruleResult.getResultCommand()); // Envoie dans la file de tâche FileFrontEnd en attente d'un traitement d'un StorBackEnd } else { writer.write(ruleResult.getResultCommand()); // Renvoye au client + writer.flush(); } } else { - authentificate(ruleResult); + authentication(ruleResult); } - } catch (IOException ignore) { } } } - private void authentificate(ProtocolReader.ProtocolResult ruleResult) { + private void authentication(ProtocolReader.ProtocolResult ruleResult) { try { SigninRule.Result signinResult = (SigninRule.Result) ruleResult; if (signinResult.checkCredentials()) { @@ -116,7 +118,7 @@ public class ClientHandler implements Runnable, AutoCloseable { writer.flush(); return; } - } catch (ClassCastException castException) {} + } catch (ClassCastException ignored) {} writer.write(protocolRep.executeWriter(SignError.NAME)); // Envoie SignError car echec de la connection writer.flush(); diff --git a/app/src/main/java/lightcontainer/protocol/ProtocolReader.java b/app/src/main/java/lightcontainer/protocol/ProtocolReader.java index 55cadf5..3715d73 100644 --- a/app/src/main/java/lightcontainer/protocol/ProtocolReader.java +++ b/app/src/main/java/lightcontainer/protocol/ProtocolReader.java @@ -1,7 +1,6 @@ package lightcontainer.protocol; -import java.io.BufferedReader; -import java.io.BufferedWriter; +import java.io.InputStream; import java.util.regex.Matcher; import java.util.regex.Pattern; @@ -19,36 +18,12 @@ public abstract class ProtocolReader { STOREBACKEND } - public enum FileOptions { - - /** - * Ne lire/ecrire aucun fichier - */ - NONE, - - /** - * Lire un fichier : Implementer la méthode 'read' - */ - READ, - - /** - * Ecrire un fichier : Implementer la méthode 'write' - */ - WRITE - } - /** * Modèle utilisé par tout les résultats des règles de protocol. * Lorsqu'il retourne son résultat, on vérifie si il y a une demande de lecture/écriture de fichier depuis le réseau. Si oui on appel ces méthodes, sinon on ne fait rien. * Ensuite on regarde après l'exécution de ces méthode ou non si il y a une commande de retour ou non et l'envoyons au receiver spécifié par la commande. */ public abstract class ProtocolResult { - - /** - * Permet de déterminer si la class souhaite lire ou écrire un fichier. - */ - private final FileOptions option; - /** * Command qui sera renvoyée par exemple au client */ @@ -61,24 +36,13 @@ public abstract class ProtocolReader { */ private ResultCmdReceiver receiver; - - /** - * Spécifier une option correct afin de permettre au système de détecter ce qu'il doit exécuter. - * @param option Option - */ - public ProtocolResult(FileOptions option) { - this.option = option; - } - - public ResultCmdReceiver getReceiver() { return receiver; } - /** * Récupérer la commande à envoyer - * @return + * @return Commande */ public String getResultCommand() { return resultCommand; @@ -94,28 +58,12 @@ public abstract class ProtocolReader { this.receiver = receiver; } - /** - * Permet de récupérer l'option associée au protocol. - * @return L'option associée - */ - public FileOptions getOption() { - return option; - } - /** * Permet de lire un fichier. Cad reçevoir le contenu d'un fichier provenant du réseau. * Redéfinissez cette méthode pour l'utiliser * @param reader Buffer rempli du fichier */ - public void read(BufferedReader reader) {} - - - /** - * Permet d'écrire un fichier. Cad reçevoir le contenu d'un fichier provenant du réseau - * @param writer Buffer à remplir, et qui sera envoyer au destinataire - */ - public void write(BufferedWriter writer) {} - + public void read(InputStream reader) {} } /** diff --git a/app/src/main/java/lightcontainer/protocol/rules/reader/FilelistRule.java b/app/src/main/java/lightcontainer/protocol/rules/reader/FilelistRule.java new file mode 100644 index 0000000..c544d61 --- /dev/null +++ b/app/src/main/java/lightcontainer/protocol/rules/reader/FilelistRule.java @@ -0,0 +1,26 @@ +package lightcontainer.protocol.rules.reader; + +import lightcontainer.protocol.ProtocolReader; + +public class FilelistRule extends ProtocolReader { + // Constants + private static final String PATTERN = "^FILELIST\r\n$"; + + // Constructor + public FilelistRule() { + super(PATTERN); + } + + public class Result extends ProtocolResult { } + + /** + * Cette méthode est appelée lors de l'exécution de la règle + * @param data Paramètres pour créer la commande. + */ + @Override + protected FilelistRule.Result onExecuted(String... data) { + FilelistRule.Result result = new Result(); + result.setResultCommand("FILES endbenja.txt!500\r\n", ResultCmdReceiver.CLIENT); + return result; + } +} diff --git a/app/src/main/java/lightcontainer/protocol/rules/reader/HelloRule.java b/app/src/main/java/lightcontainer/protocol/rules/reader/HelloRule.java index 1b46e7a..407e2dc 100644 --- a/app/src/main/java/lightcontainer/protocol/rules/reader/HelloRule.java +++ b/app/src/main/java/lightcontainer/protocol/rules/reader/HelloRule.java @@ -27,7 +27,6 @@ public class HelloRule extends ProtocolReader { private final int port; public Result(String domain, int port) { - super(FileOptions.NONE); this.domain = domain; this.port = port; } diff --git a/app/src/main/java/lightcontainer/protocol/rules/reader/SavefileRule.java b/app/src/main/java/lightcontainer/protocol/rules/reader/SavefileRule.java new file mode 100644 index 0000000..1929480 --- /dev/null +++ b/app/src/main/java/lightcontainer/protocol/rules/reader/SavefileRule.java @@ -0,0 +1,59 @@ +package lightcontainer.protocol.rules.reader; + +import lightcontainer.protocol.ProtocolReader; +import lightcontainer.utils.FileReceiver; + +import java.io.IOException; +import java.io.InputStream; + +public class SavefileRule extends ProtocolReader { + // Constants + private static final String PATTERN = "^SAVEFILE ([^ !]{1,20}) ([0-9]{1,10})\r\n$"; + private static final int FILE_NAME = 0; // Index file name. + private static final int FILE_SIZE = 1; // Index file size. + + // Constructor + public SavefileRule() { + super(PATTERN); + } + + public class Result extends ProtocolResult { + // Variables + private final String filename; + private final int size; + + // Construct + public Result(String filename, int size) { + this.filename = filename; + this.size = size; + } + + @Override + public void read(InputStream reader) { + super.read(reader); + System.out.printf("Sauvegarde du fichier : %s %d\n", filename, size); + + try { + FileReceiver fileReceiver = new FileReceiver("D:\\"); + if (!fileReceiver.receiveFile(reader, this.filename, this.size)) + throw new IOException(); + + this.setResultCommand("SAVEFILE_OK\r\n", ResultCmdReceiver.CLIENT); + } catch (IOException e) { + this.setResultCommand("SAVEFILE_ERROR\r\n", ResultCmdReceiver.CLIENT); + e.printStackTrace(); + } + } + } + + /** + * Cette méthode est appelée lors de l'exécution de la règle + * @param data Paramètres pour créer la commande. + */ + @Override + protected SavefileRule.Result onExecuted(String... data) { + SavefileRule.Result result = new SavefileRule.Result(data[FILE_NAME], Integer.parseInt(data[FILE_SIZE])); + + return result; + } +} diff --git a/app/src/main/java/lightcontainer/protocol/rules/reader/SigninRule.java b/app/src/main/java/lightcontainer/protocol/rules/reader/SigninRule.java index dd097c6..ad8006b 100644 --- a/app/src/main/java/lightcontainer/protocol/rules/reader/SigninRule.java +++ b/app/src/main/java/lightcontainer/protocol/rules/reader/SigninRule.java @@ -2,29 +2,26 @@ package lightcontainer.protocol.rules.reader; import lightcontainer.protocol.ProtocolReader; +import java.io.InputStream; + public class SigninRule extends ProtocolReader { + // Constants + private static final String PATTERN = "^SIGNIN ([A-Za-z0-9]{2,20}) ([^ !]{5,50})\r\n$"; + private static final int LOGIN = 0; // Index du domain dans le tableau de données + private static final int PASSWORD = 1; // Index du port dans le tableau de données - private static final String PATTERN = "^SIGNIN ([A-Za-z0-9]{2,20}) ([^ !]{5,50})\r\n$"; - - // Index du domain dans le tableau de donnée - private static final int LOGIN = 0; - - //Index du port dans le tableau de donnée - private static final int PASSWORD = 1; - + // Constructor public SigninRule() { super(PATTERN); } - public class Result extends ProtocolResult { - + // Variables private final String login; - private final String password; + // Result constructor public Result(String login, String password) { - super(FileOptions.NONE); this.login = login; this.password = password; } @@ -40,8 +37,12 @@ public class SigninRule extends ProtocolReader { public boolean checkCredentials() { return getLogin().equals("aa") && getPassword().equals("aaaaa"); } - } + @Override + public void read(InputStream reader) { + + } + } @Override protected SigninRule.Result onExecuted(String... data) { @@ -53,7 +54,6 @@ public class SigninRule extends ProtocolReader { } else { result.setResultCommand("SIGN_ERROR\r\n", ResultCmdReceiver.CLIENT); } - return result; } }