first commit

raspberry-pi/internal/daemon/communication.go

@@ -10,6 +10,25 @@ import (
 	"time"
 )
 
+type ServerStatus int
+
+const (
+	ACK  = iota
+	FAIL = 1
+)
+
+func (s ServerStatus) String() string {
+	if int(s) < 0 || int(s) >= len([]string{"ACK", "FAIL"}) {
+		return "UNKNOWN"
+	}
+
+	return [...]string{"ACK", "FAIL"}[s]
+}
+
+func (s ServerStatus) EnumIndex() int {
+	return int(s)
+}
+
 /*
 Authenticator
 
@@ -45,7 +64,17 @@ func (c *Client) writeToServer(request entities.TCPCreateRaspberryPIRequest) (in
 		return 0, err
 	}
 
-	time.Sleep(200 * time.Millisecond) //TODO: this MUST be improved, as we should receive an ACK by the server and not sleep then sending
+	// accept ack from the server
+	read, err := c.readFromServer()
+
+	if err != nil {
+		return 0, err
+	}
+
+	if !c.isACKMessage(read) {
+		var status ServerStatus = FAIL
+		return 0, fmt.Errorf("error ACK from the server %s", status)
+	}
 
 	// Send the actual data
 	wrote, err := c.Conn.Write(marshaled)
@@ -57,6 +86,11 @@ func (c *Client) writeToServer(request entities.TCPCreateRaspberryPIRequest) (in
 	return wrote, nil
 }
 
+func (c *Client) isACKMessage(msg string) bool {
+	var ack ServerStatus = ACK
+	return msg == ack.String()
+}
+
 func (c *Client) readFromServer() (string, error) {
 	return bufio.NewReader(c.Conn).ReadString('\n')
 }

server/backend/internal/raspberrypi/components.go

@@ -34,19 +34,19 @@ func (wr *TCPServer) readMessageContent(reader *bufio.Reader, size int64) ([]byt
 	return buffer, err
 }
 
-// processMessage performs main tcp server actions
-func (wr *TCPServer) processMessage(buffer []byte, client net.Conn) error {
+// processHandshakeMessage performs main tcp server actions
+func (wr *TCPServer) processHandshakeMessage(buffer []byte, client net.Conn) error {
 	var createRequest TCPCreateRaspberryPIRequest
 
 	// Unmarshal the request
 	if err := json.Unmarshal(buffer, &createRequest); err != nil {
-		wr.writeError(client, "Invalid request format: "+err.Error())
+		wr.writeErrorToClient(client, fmt.Sprintf("Invalid request format: %s", err.Error()))
 		return err
 	}
 
 	// Validate the request
 	if err := utils.ValidateGenericStruct(createRequest); err != nil {
-		wr.writeError(client, "Invalid request data: "+err.Error())
+		wr.writeErrorToClient(client, fmt.Sprintf("Invalid request data: %s", err.Error()))
 		return err
 	}
 
@@ -55,14 +55,14 @@ func (wr *TCPServer) processMessage(buffer []byte, client net.Conn) error {
 	if err != nil {
 		errParsed := wr.handleCreationError(err, client)
 		if errParsed != nil {
-			wr.writeError(client, errParsed.Error())
+			wr.writeErrorToClient(client, errParsed.Error())
 		}
 	}
 
 	// Process Handshakes
 	handshakeSavedIDs, err := wr.processHandshakes(createRequest)
 	if err != nil {
-		wr.writeError(client, err.Error())
+		wr.writeErrorToClient(client, err.Error())
 		return err
 	}
 
@@ -103,14 +103,14 @@ func (wr *TCPServer) handleCreationError(err error, client net.Conn) error {
 		log.Errorf("[TCP/IP] Error creating RaspberryPI: %s", err.Error())
 		_, errWrite := client.Write([]byte(err.Error() + "\n"))
 		if errWrite != nil {
-			wr.writeError(client, errWrite.Error())
+			wr.writeErrorToClient(client, errWrite.Error())
 		}
 	}
 	return err
 }
 
-// writeError refactored function to send error whenever happens to the client
-func (wr *TCPServer) writeError(client net.Conn, message string) {
+// writeErrorToClient refactored function to send error whenever happens to the client
+func (wr *TCPServer) writeErrorToClient(client net.Conn, message string) {
 	_, err := client.Write([]byte(message + "\n"))
 	if err != nil {
 		log.Errorf("[TCP/IP] Error writing to client: %s", err.Error())

server/backend/internal/raspberrypi/tcp_server.go

@@ -3,6 +3,7 @@ package raspberrypi
 import (
 	"bufio"
 	"context"
+	"fmt"
 	"github.com/Virgula0/progetto-dp/server/entities"
 	log "github.com/sirupsen/logrus"
 	"net"
@@ -19,6 +20,21 @@ type TCPCreateRaspberryPIRequest struct {
 	EncryptionKey string `validate:"omitempty,len=64"`
 }
 
+type ServerStatus int
+
+const (
+	ACK  = iota
+	FAIL = 1
+)
+
+func (s ServerStatus) String() string {
+	return [...]string{"ACK\n", "FAIL\n"}[s-1]
+}
+
+func (s ServerStatus) EnumIndex() int {
+	return int(s)
+}
+
 // RunTCPServer Start TCP server
 func (wr *TCPServer) RunTCPServer() error {
 	log.Printf("[TCP/IP Server] TCP/IP server running on %s", wr.w.Addr())
@@ -61,24 +77,34 @@ func (wr *TCPServer) handleClientConnection(client net.Conn) {
 
 // processClientRequest parses the client request
 func (wr *TCPServer) processClientRequest(client net.Conn) error {
+	var status ServerStatus = FAIL
 	reader := bufio.NewReader(client)
 
 	// Step 1: Read message size
 	messageSize, err := wr.readMessageSize(reader)
 	if err != nil {
-		wr.writeError(client, "Invalid message size")
+		wr.writeErrorToClient(client, fmt.Sprintf("Invalid message size %s", status))
 		return err
 	}
 
 	// Step 2: Read message content
 	buffer, err := wr.readMessageContent(reader, messageSize)
 	if err != nil {
-		wr.writeError(client, "Error reading message content")
+		wr.writeErrorToClient(client, fmt.Sprintf("Error reading message content %s", status))
+		return err
+	}
+
+	// Step 3: Send ACK to the client
+	status = ACK
+	_, err = client.Write([]byte(status.String()))
+	if err != nil {
+		status = FAIL
+		wr.writeErrorToClient(client, fmt.Sprintf("Error reading ACK %s", status))
 		return err
 	}
 
 	log.Printf("[TCP/IP] Received message: %s", string(buffer))
 
-	// Step 3: Process the message
-	return wr.processMessage(buffer, client)
+	// Step 4: Process the message type
+	return wr.processHandshakeMessage(buffer, client)
 }