Ajout récupération de fichier (fingerprint à check)

pkg/network/ClientMulticast.go

@@ -85,10 +85,10 @@ func (client ClientMulticast) ResolveAddr() (*net.UDPAddr, bool) {
 func ResolveInterfaceAddr(inter string) (*net.UDPAddr, bool) {
 	ip, err := utils.RetrieveIPv4FromInterface(inter)
 	if err != nil {
-		println("Error : " + err.Error())
+		println("Error while loading interface : " + err.Error())
 		return nil, true
 	}
-	println("Selected IP : " + ip.String())
+	println("Selected IP for multicast : " + ip.String())
 	return &net.UDPAddr{IP: ip}, false
 }
 

pkg/protocol/rules/readers/RetrieveFileRule.go

@@ -0,0 +1,60 @@
+package readers
+
+import (
+	"StoreBackEnd/pkg/protocol"
+	"StoreBackEnd/pkg/protocol/repository"
+	"StoreBackEnd/pkg/protocol/rules/writers"
+	"StoreBackEnd/pkg/utils"
+	"bufio"
+	"fmt"
+	"os"
+)
+
+// RetrieveFileRulePrefix Identifiant de cette règle
+const RetrieveFileRulePrefix = "RETRIEVEFILE"
+
+// RetrieveFileRule Demande de suppression d'un fichier
+type RetrieveFileRule struct {
+	// Cmd Nom de la règle
+	Cmd string
+	// matcher Permet de vérifier le matching
+	matcher *protocol.RegexMatcher
+	// protocolRepo Instance de ProtocolRepository
+	protocolRepo *repository.ProtocolRepository
+	// storagePath Chemin de stockage du fichier
+	storagePath string
+}
+
+// CreateRetrieveFileRule Création d'une instance de RetrieveFileRule
+func CreateRetrieveFileRule(pattern string, protocolRepo *repository.ProtocolRepository, storagePath string) protocol.IProtocolReader {
+	return &RetrieveFileRule{
+		Cmd:          RetrieveFileRulePrefix,
+		matcher:      protocol.CreateRegexMatcher(pattern),
+		protocolRepo: protocolRepo,
+		storagePath:  storagePath,
+	}
+}
+
+func (rule RetrieveFileRule) GetCmd() string {
+	return rule.Cmd
+}
+
+func (rule RetrieveFileRule) Execute(data string) (*protocol.ProtocolWriterResult, func(reader *bufio.Reader) *protocol.ProtocolWriterResult) {
+
+	if rule.Match(data) {
+		values := rule.matcher.Parse(data)
+		hashFileName := values[1]
+
+		path := fmt.Sprintf("%s/%s", rule.storagePath, hashFileName)
+		if fileinfo, err := os.Stat(path); err == nil {
+			println("OKOKOKOEKOEKE : ", hashFileName, fmt.Sprintf("%d", fileinfo.Size()), fmt.Sprintf("%x", utils.GenFingerPrint(path)))
+
+			return rule.protocolRepo.ExecuteWriter(writers.RetrieveOkRulePrefix, hashFileName, fmt.Sprintf("%d", fileinfo.Size()), fmt.Sprintf("%x", utils.GenFingerPrint(path))), nil
+		}
+	}
+	return rule.protocolRepo.ExecuteWriter(writers.RetrieveErrorRulePrefix), nil
+}
+
+func (rule RetrieveFileRule) Match(data string) bool {
+	return rule.matcher.Match(data)
+}

pkg/protocol/rules/writers/RetrieveErrorRule.go

@@ -0,0 +1,38 @@
+package writers
+
+import (
+	"StoreBackEnd/pkg/protocol"
+)
+
+// RetrieveErrorRulePrefix Rule command prefix
+const RetrieveErrorRulePrefix = "RETRIEVE_ERROR"
+
+// RetrieveErrorRule Storage structure for the RetrieveErrorRule
+type RetrieveErrorRule struct {
+	// cmd Rule name
+	cmd string
+	// matcher Allow to make a regex match
+	matcher *protocol.RegexMatcher
+}
+
+// CreateRetrieveErrorRule Creating an instance of RetrieveErrorRule
+func CreateRetrieveErrorRule(pattern string) protocol.IProtocolWriter {
+	return &RetrieveErrorRule{
+		cmd:     RetrieveErrorRulePrefix,
+		matcher: protocol.CreateRegexMatcher(pattern),
+	}
+}
+
+// GetCmd retrieve the command name.
+func (rule RetrieveErrorRule) GetCmd() string {
+	return rule.cmd
+}
+
+// Execute the Rule with a string command.
+func (rule RetrieveErrorRule) Execute(argsData ...string) *protocol.ProtocolWriterResult {
+	buildedCmd, _ := rule.matcher.Build(RetrieveErrorRulePrefix, argsData...)
+
+	return &protocol.ProtocolWriterResult{
+		Cmd: buildedCmd,
+	}
+}

pkg/protocol/rules/writers/RetrieveOkRule.go

@@ -0,0 +1,58 @@
+package writers
+
+import (
+	"StoreBackEnd/pkg/protocol"
+	"StoreBackEnd/pkg/utils"
+	"bufio"
+	"fmt"
+	"strconv"
+)
+
+// RetrieveOkRulePrefix Rule command prefix
+const RetrieveOkRulePrefix = "RETRIEVE_OK"
+
+// RetrieveOkRule Storage structure for the RetrieveOkRule
+type RetrieveOkRule struct {
+	// cmd Rule name
+	cmd string
+	// matcher Allow to make a regex match
+	matcher *protocol.RegexMatcher
+	// storagePath Chemin de stockage du fichier
+	storagePath string
+}
+
+// CreateRetrieveOkRule Creating an instance of RetrieveOkRule
+func CreateRetrieveOkRule(pattern string, storagePath string) protocol.IProtocolWriter {
+	return &RetrieveOkRule{
+		cmd:         RetrieveOkRulePrefix,
+		matcher:     protocol.CreateRegexMatcher(pattern),
+		storagePath: storagePath,
+	}
+}
+
+// GetCmd retrieve the command name.
+func (rule RetrieveOkRule) GetCmd() string {
+	return rule.cmd
+}
+
+// Execute the Rule with a string command.
+func (rule RetrieveOkRule) Execute(argsData ...string) *protocol.ProtocolWriterResult {
+	buildedCmd, _ := rule.matcher.Build(RetrieveOkRulePrefix, argsData...)
+
+	return &protocol.ProtocolWriterResult{
+		Cmd: buildedCmd,
+		Write: func(writer *bufio.Writer) {
+			fileSize, _ := strconv.Atoi(argsData[1])
+			rule.onWrite(writer, argsData[0], fileSize)
+		},
+	}
+}
+
+func (rule RetrieveOkRule) onWrite(writer *bufio.Writer, hashFileName string, fileSize int) {
+	path := fmt.Sprintf("%s/%s", rule.storagePath, hashFileName)
+	if utils.SendFile(path, fileSize, writer) {
+		println("Fichier envoyé au client")
+	} else {
+		println("Fichier non-envoyé au client")
+	}
+}

pkg/utils/FileSender.go

@@ -8,9 +8,9 @@ import (
 )
 
 // SendFile Envoie d'un fichier local sur le réseau
-func SendFile(fileName string, fileSize int, writer *bufio.Writer) bool {
+func SendFile(filePath string, fileSize int, writer *bufio.Writer) bool {
 	// Ouverture du fichier
-	file, fileErr := os.Open(fmt.Sprintf("/home/benjamin/sbe/%s", fileName))
+	file, fileErr := os.Open(fmt.Sprintf("%s", filePath))
 	if fileErr != nil {
 		return false
 	}
@@ -25,5 +25,5 @@ func SendFile(fileName string, fileSize int, writer *bufio.Writer) bool {
 		return false
 	}
 
-	return false
+	return true
 }

pkg/utils/Hasher.go

@@ -10,6 +10,12 @@ import (
 )
 
 func HashFileCompare(path string, fingerPrint string) bool {
+	sum := GenFingerPrint(path)
+
+	return fingerPrint == fmt.Sprintf("%x", sum)
+}
+
+func GenFingerPrint(path string) []byte {
 	f, err := os.Open(path)
 	if err != nil {
 		log.Fatal(err)
@@ -24,8 +30,5 @@ func HashFileCompare(path string, fingerPrint string) bool {
 	}
 	sum := hash.Sum(nil)
 
-	fmt.Printf("%x\n", sum)
-
-	println(fingerPrint, fmt.Sprintf("%x", sum))
-	return fingerPrint == fmt.Sprintf("%x", sum)
+	return sum
 }