Merge branch 'main' into backend/packet-sender

Author: JESUSJH18

.gitignore

@@ -1,13 +1,11 @@
 build
 profiles
-
-# GOOGLE API KEY
-secret.json
+backend/cmd/cmd
 
 # MacOS Files
 .DS_Store
 
 # Code Editor
 .idea/
 .vscode/
-.prettierrc
+.prettierrc

.gitmodules

@@ -0,0 +1,4 @@
+[submodule "backend/cmd/JSON_ADE"]
+	path = backend/cmd/JSON_ADE
+	url = https://github.com/HyperloopUPV-H8/JSON_ADE.git
+	branch = main

backend/cmd/JSON_ADE

@@ -256,16 +256,11 @@ func main() {
 		}
 	}
 
-	boardIps := make([]net.IP, 0)
-	for boardName, _ := range adj.Info.BoardIds {
+	boardIps := make([]net.IP, 0, len(adj.Info.BoardIds))
+	for boardName := range adj.Info.BoardIds {
 		boardIps = append(boardIps, net.ParseIP(adj.Info.Addresses[boardName]))
 	}
 
-	boardIpsStr := make([]string, 0)
-	for boardName, _ := range adj.Info.BoardIds {
-		boardIpsStr = append(boardIpsStr, adj.Info.Addresses[boardName])
-	}
-
 	filter := getFilter(boardIps, net.ParseIP(adj.Info.Addresses[BACKEND]), adj.Info.Ports[UDP])
 	trace.Warn().Str("filter", filter).Msg("filter")
 	err = source.SetBPFFilter(filter)
@@ -564,12 +559,16 @@ func getIPIPfilter() string {
 }
 
 func getUDPFilter(addrs []net.IP, backendAddr net.IP, port uint16) string {
-	udpPort := fmt.Sprintf("udp port %d", port)
-	udpAddrs := common.Map(addrs, func(addr net.IP) string {
+	udpPort := "udp" // TODO use proper ports for the filter
+	srcUdpAddrs := common.Map(addrs, func(addr net.IP) string {
 		return fmt.Sprintf("(src host %s)", addr)
 	})
+	dstUdpAddrs := common.Map(addrs, func(addr net.IP) string {
+		return fmt.Sprintf("(dst host %s)", addr)
+	})
 
-	udpAddrsStr := strings.Join(udpAddrs, " or ")
+	srcUdpAddrsStr := strings.Join(srcUdpAddrs, " or ")
+	dstUdpAddrsStr := strings.Join(dstUdpAddrs, " or ")
 
-	return fmt.Sprintf("(%s) and (%s) and (dst host %s)", udpPort, udpAddrsStr, backendAddr)
+	return fmt.Sprintf("(%s) and (%s) and (%s or (dst host %s))", udpPort, srcUdpAddrsStr, dstUdpAddrsStr, backendAddr)
 }

backend/cmd/main.go

@@ -2,44 +2,70 @@ package adj
 
 import (
 	"encoding/json"
-	"errors"
+	"os"
+	"path"
+
 	"github.com/HyperloopUPV-H8/h9-backend/internal/utils"
 	"github.com/go-git/go-git/v5"
-	"os"
 )
 
 const (
 	RepoUrl  = "https://github.com/HyperloopUPV-H8/JSON_ADE.git" // URL of the ADJ repository
 	RepoPath = "./JSON_ADE/"                                     // Path where the ADJ repository is cloned
 )
 
-func NewADJ() (*ADJ, error) {
+func NewADJ() (ADJ, error) {
 	infoRaw, boardsRaw, err := downloadADJ()
 	if err != nil {
-		return nil, err
+		return ADJ{}, err
 	}
 
-	var JsonInfo JsonInfo
-	var info Info
-	if err := json.Unmarshal(infoRaw, &JsonInfo); err != nil {
-		return nil, err
+	var infoJSON InfoJSON
+	if err := json.Unmarshal(infoRaw, &infoJSON); err != nil {
+		println("Info JSON unmarshal error")
+		return ADJ{}, err
+	}
+
+	var info Info = Info{
+		Ports:      infoJSON.Ports,
+		MessageIds: infoJSON.MessageIds,
+		Units:      make(map[string]utils.Operations),
+	}
+	for key, value := range infoJSON.Units {
+		info.Units[key], err = utils.NewOperations(value)
+		if err != nil {
+			return ADJ{}, err
+		}
 	}
 
-	info.Ports = utils.ConvertToMap_Str_Uint16(JsonInfo.Ports)
-	info.Addresses = utils.ConvertToMap_Str_Str(JsonInfo.Addresses)
-	info.Units = utils.ConvertToMap_Str_Op(JsonInfo.Units)
-	info.MessageIds = utils.ConvertToMap_Str_Uint16(JsonInfo.MessageIds)
+	type BoardList struct {
+		Boards map[string]string `json:"boards"`
+	}
 
-	var boardsList map[string]string
+	var boardsList BoardList
 	if err := json.Unmarshal(boardsRaw, &boardsList); err != nil {
-		return nil, err
+		return ADJ{}, err
 	}
 
-	boards, err := getBoards(info, boardsList)
+	boards, err := getBoards(boardsList.Boards)
+	if err != nil {
+		return ADJ{}, err
+	}
 
-	info.BoardIds, err = getBoardIds(boardsList)
+	info.BoardIds, err = getBoardIds(boardsList.Boards)
+	if err != nil {
+		return ADJ{}, err
+	}
+
+	info.Addresses, err = getAddresses(boards)
+	if err != nil {
+		return ADJ{}, err
+	}
+	for target, address := range infoJSON.Addresses {
+		info.Addresses[target] = address
+	}
 
-	adj := &ADJ{
+	adj := ADJ{
 		Info:   info,
 		Boards: boards,
 	}
@@ -79,14 +105,11 @@ func checkRepo() bool {
 	return true
 }
 
-func getBoards(info Info, boardsList map[string]string) (map[string]Board, error) {
-	var boards map[string]Board
+func getBoards(boardsList map[string]string) (map[string]Board, error) {
+	boards := make(map[string]Board, len(boardsList))
 	for boardName, boardPath := range boardsList {
-		if _, err := os.Stat(boardPath); os.IsNotExist(err) {
-			return nil, err
-		}
-
-		boardRaw, err := os.ReadFile(boardPath)
+		fullPath := path.Join(RepoPath, boardPath)
+		boardRaw, err := os.ReadFile(fullPath)
 		if err != nil {
 			return nil, err
 		}
@@ -96,15 +119,22 @@ func getBoards(info Info, boardsList map[string]string) (map[string]Board, error
 			return nil, err
 		}
 
-		if info.Addresses[boardName] != boardJSON.IP {
-			return nil, errors.New("the IP of the board does not match the one in the general info")
+		measPathsFr := make([]string, 0)
+		for _, measPath := range boardJSON.MeasurementsPaths {
+			measPathsFr = append(measPathsFr, path.Join(RepoPath, "boards", boardName, measPath))
 		}
+		boardJSON.MeasurementsPaths = measPathsFr
 
-		var board Board
-
-		board.Name = boardName
-		board.IP = boardJSON.IP
+		packetPathsFr := make([]string, 0)
+		for _, packetPath := range boardJSON.PacketsPaths {
+			packetPathsFr = append(packetPathsFr, path.Join(RepoPath, "boards", boardName, packetPath))
+		}
+		boardJSON.PacketsPaths = packetPathsFr
 
+		board := Board{
+			Name: boardName,
+			IP:   boardJSON.IP,
+		}
 		board.Packets, err = getBoardPackets(boardJSON.PacketsPaths)
 		if err != nil {
 			return nil, err
@@ -114,6 +144,12 @@ func getBoards(info Info, boardsList map[string]string) (map[string]Board, error
 		if err != nil {
 			return nil, err
 		}
+		board.LookUpMeasurements = make(map[string]Measurement, len(board.Measurements))
+
+		for _, measurement := range board.Measurements {
+			board.LookUpMeasurements[measurement.Id] = measurement
+		}
+		board.Structures = getBoardStructures(board)
 
 		boards[boardName] = board
 	}
@@ -122,7 +158,7 @@ func getBoards(info Info, boardsList map[string]string) (map[string]Board, error
 }
 
 func getBoardPackets(packetsPaths []string) ([]Packet, error) {
-	var packets []Packet
+	packets := make([]Packet, 0)
 	for _, packetPath := range packetsPaths {
 		if _, err := os.Stat(packetPath); os.IsNotExist(err) {
 			continue
@@ -133,19 +169,26 @@ func getBoardPackets(packetsPaths []string) ([]Packet, error) {
 			return nil, err
 		}
 
-		var packet Packet
-		if err = json.Unmarshal(packetRaw, &packet); err != nil {
-			return nil, err
+		// Magic happens here
+		type PacketJSON struct {
+			Packet []Packet `json:"packets"`
 		}
 
-		packets = append(packets, packet)
+		packetsJSON := PacketJSON{}
+		if err = json.Unmarshal(packetRaw, &packetsJSON); err != nil {
+			return nil, err
+		}
+		for _, packetTMP := range packetsJSON.Packet {
+			packets = append(packets, packetTMP)
+		}
 	}
 
 	return packets, nil
 }
 
 func getBoardMeasurements(measurementsPaths []string) ([]Measurement, error) {
-	var measurements []Measurement
+	measurements := make([]Measurement, 0)
+
 	for _, measurementPath := range measurementsPaths {
 		if _, err := os.Stat(measurementPath); os.IsNotExist(err) {
 			continue
@@ -156,25 +199,28 @@ func getBoardMeasurements(measurementsPaths []string) ([]Measurement, error) {
 			return nil, err
 		}
 
-		var measurement Measurement
-		if err = json.Unmarshal(measurementRaw, &measurement); err != nil {
-			return nil, err
+		// Absolutely doing tricks on it AGAIN - @msanlli
+		type MeasurementJSON struct {
+			Measurements []Measurement `json:"measurements"`
 		}
 
-		measurements = append(measurements, measurement)
+		measurementsJSON := MeasurementJSON{}
+		if err = json.Unmarshal(measurementRaw, &measurementsJSON); err != nil {
+			return nil, err
+		}
+		for _, measurementTMP := range measurementsJSON.Measurements {
+			measurements = append(measurements, measurementTMP)
+		}
 	}
 
 	return measurements, nil
 }
 
 func getBoardIds(boards map[string]string) (map[string]uint16, error) {
-	var boardIds map[string]uint16
+	boardIds := make(map[string]uint16, len(boards))
 	for boardName, boardPath := range boards {
-		if _, err := os.Stat(boardPath); os.IsNotExist(err) {
-			return nil, err
-		}
-
-		boardRaw, err := os.ReadFile(boardPath)
+		fullPath := path.Join(RepoPath, boardPath)
+		boardRaw, err := os.ReadFile(fullPath)
 		if err != nil {
 			return nil, err
 		}
@@ -189,3 +235,24 @@ func getBoardIds(boards map[string]string) (map[string]uint16, error) {
 
 	return boardIds, nil
 }
+
+func getBoardStructures(board Board) []Structure {
+	structures := make([]Structure, len(board.Packets))
+	for i, packet := range board.Packets {
+		structures[i] = Structure{
+			Packet:       packet,
+			Measurements: board.Measurements,
+		}
+	}
+
+	return structures
+}
+
+func getAddresses(boards map[string]Board) (map[string]string, error) {
+	addresses := make(map[string]string, len(boards))
+	for boardName, board := range boards {
+		addresses[boardName] = board.IP
+	}
+
+	return addresses, nil
+}

backend/internal/adj/adj.go

@@ -7,11 +7,12 @@ type ADJ struct {
 	Boards map[string]Board
 }
 
-type JsonInfo struct {
-	Ports      []map[string]uint16           `json:"ports"`
-	Addresses  []map[string]string           `json:"addresses"`
-	Units      []map[string]utils.Operations `json:"units"`
-	MessageIds []map[string]uint16           `json:"message_ids"`
+type InfoJSON struct {
+	Ports      map[string]uint16 `json:"ports"`
+	Addresses  map[string]string
+	Units      map[string]string `json:"units"`
+	MessageIds map[string]uint16 `json:"message_ids"`
+	BoardIds   map[string]uint16
 }
 
 type Info struct {
@@ -22,39 +23,41 @@ type Info struct {
 	BoardIds   map[string]uint16
 }
 
-type Board struct {
-	Name         string
-	IP           string
-	Packets      []Packet
-	Measurements []Measurement
-	Structures   []Structure
-}
-
 type BoardJSON struct {
 	ID                uint16   `json:"board_id"`
 	IP                string   `json:"board_ip"`
 	MeasurementsPaths []string `json:"measurements"`
 	PacketsPaths      []string `json:"packets"`
-	// StructuresPaths   []string `json:"structures"` // TODO: Issued in JSON_ADE #1
+}
+
+type Board struct {
+	Name               string
+	IP                 string
+	Packets            []Packet
+	Measurements       []Measurement
+	Structures         []Structure
+	LookUpMeasurements map[string]Measurement
 }
 
 type Packet struct {
-	Id   string
-	Name string
-	Type string
+	Id        string        `json:"id"`
+	Name      string        `json:"name"`
+	Type      string        `json:"type"`
+	Variables []Measurement `json:"variables"`
 }
 
 type Measurement struct {
-	Id           string
-	Name         string
-	Type         string
-	PodUnits     string
-	DisplayUnits string
-	SafeRange    string
-	WarningRange string
+	Id           string     `json:"id"`
+	Name         string     `json:"name"`
+	Type         string     `json:"type"`
+	PodUnits     string     `json:"podUnits"`
+	DisplayUnits string     `json:"displayUnits"`
+	SafeRange    []*float64 `json:"safeRange"`
+	WarningRange []*float64 `json:"warningRange"`
+	EnumValues   []string   `json:"enumValues"`
 }
 
 type Structure struct {
-	Packet       string
-	Measurements []string
+	Packet       Packet
+	Measurements []Measurement
 }