Change ComMatrix struct Matrix field name to Ports as we will be adding dynamice ranges to the matrix, and we want to make it more clear that there are two parts of the matrix - ports and ranges, rather than the communication matrix and additional ranges.

Author: shirmoran

cmd/generate/generate_test.go

@@ -185,7 +185,7 @@ var (
 func TestCommatrixGeneration(t *testing.T) {
 	expectedComDetails := slices.Concat(testEpsComDetails, types.GeneralStaticEntriesMaster, types.GeneralStaticEntriesWorker, types.StandardStaticEntries)
 
-	expectedComMatrix := types.ComMatrix{Matrix: expectedComDetails}
+	expectedComMatrix := types.ComMatrix{Ports: expectedComDetails}
 	expectedComMatrix.SortAndRemoveDuplicates()
 
 	testCases := []struct {

pkg/commatrix-creator/commatrix.go

@@ -84,7 +84,7 @@ func (cm *CommunicationMatrixCreator) CreateEndpointMatrix() (*types.ComMatrix,
 		epSliceComDetails = append(epSliceComDetails, customComDetails...)
 	}
 
-	commMatrix := &types.ComMatrix{Matrix: epSliceComDetails}
+	commMatrix := &types.ComMatrix{Ports: epSliceComDetails}
 	log.Debug("Sorting ComMatrix and removing duplicates")
 	commMatrix.SortAndRemoveDuplicates()
 	return commMatrix, nil

pkg/commatrix-creator/commatrix_test.go

@@ -416,15 +416,15 @@ var _ = g.Describe("Commatrix creator pkg tests", func() {
 			g.By("Add to wanted comDetails the example static entries")
 			wantedComDetails = slices.Concat(wantedComDetails, exampleComDetailsList)
 
-			wantedComMatrix := types.ComMatrix{Matrix: wantedComDetails}
+			wantedComMatrix := types.ComMatrix{Ports: wantedComDetails}
 			wantedComMatrix.SortAndRemoveDuplicates()
 
 			g.By("Generate diff between created commatrix and eanted commatrix")
 			diff := matrixdiff.Generate(&wantedComMatrix, commatrix)
 
 			g.By("Checking whether diff is empty")
-			o.Expect(diff.GetUniquePrimary().Matrix).To(o.BeEmpty())
-			o.Expect(diff.GetUniqueSecondary().Matrix).To(o.BeEmpty())
+			o.Expect(diff.GetUniquePrimary().Ports).To(o.BeEmpty())
+			o.Expect(diff.GetUniqueSecondary().Ports).To(o.BeEmpty())
 		})
 
 		g.It("Should successfully create an endpoint matrix without custom entries", func() {
@@ -436,15 +436,15 @@ var _ = g.Describe("Commatrix creator pkg tests", func() {
 
 			g.By("Generating wanted comDetails")
 			wantedComDetails := slices.Concat(testEpsComDetails, types.GeneralStaticEntriesMaster)
-			wantedComMatrix := types.ComMatrix{Matrix: wantedComDetails}
+			wantedComMatrix := types.ComMatrix{Ports: wantedComDetails}
 			wantedComMatrix.SortAndRemoveDuplicates()
 
 			g.By("Generate diff between created commatrix and eanted commatrix")
 			diff := matrixdiff.Generate(&wantedComMatrix, commatrix)
 
 			g.By("Checking whether diff is empty")
-			o.Expect(diff.GetUniquePrimary().Matrix).To(o.BeEmpty())
-			o.Expect(diff.GetUniqueSecondary().Matrix).To(o.BeEmpty())
+			o.Expect(diff.GetUniquePrimary().Ports).To(o.BeEmpty())
+			o.Expect(diff.GetUniqueSecondary().Ports).To(o.BeEmpty())
 		})
 
 		g.It("Should include IPv6 static entries when ipv6Enabled is true on Standard", func() {
@@ -462,12 +462,12 @@ var _ = g.Describe("Commatrix creator pkg tests", func() {
 				types.GeneralIPv6StaticEntriesMaster,
 				types.GeneralIPv6StaticEntriesWorker,
 			)
-			wantedMatrix := types.ComMatrix{Matrix: wanted}
+			wantedMatrix := types.ComMatrix{Ports: wanted}
 			wantedMatrix.SortAndRemoveDuplicates()
 
 			diff := matrixdiff.Generate(&wantedMatrix, commatrix)
-			o.Expect(diff.GetUniquePrimary().Matrix).To(o.BeEmpty())
-			o.Expect(diff.GetUniqueSecondary().Matrix).To(o.BeEmpty())
+			o.Expect(diff.GetUniquePrimary().Ports).To(o.BeEmpty())
+			o.Expect(diff.GetUniqueSecondary().Ports).To(o.BeEmpty())
 		})
 
 		g.It("Should filter out localhost-bound ports from endpoint matrix", func() {
@@ -502,7 +502,7 @@ var _ = g.Describe("Commatrix creator pkg tests", func() {
 			o.Expect(err).ToNot(o.HaveOccurred())
 
 			g.By("Verifying that localhost-bound ports (8080 on 127.0.0.1, 3000 on ::1) are filtered out")
-			for _, entry := range commatrix.Matrix {
+			for _, entry := range commatrix.Ports {
 				if entry.Service == "localhost-service" {
 					o.Expect(entry.Port).ToNot(o.Equal(8080), "Port 8080 bound to 127.0.0.1 should be filtered out")
 					o.Expect(entry.Port).ToNot(o.Equal(3000), "Port 3000 bound to ::1 should be filtered out")
@@ -511,7 +511,7 @@ var _ = g.Describe("Commatrix creator pkg tests", func() {
 
 			g.By("Verifying that non-localhost port (9090 on 0.0.0.0) is present")
 			foundPort9090 := false
-			for _, entry := range commatrix.Matrix {
+			for _, entry := range commatrix.Ports {
 				if entry.Service == "localhost-service" && entry.Port == 9090 {
 					foundPort9090 = true
 					break
@@ -607,11 +607,11 @@ var _ = g.Describe("Commatrix creator pkg tests", func() {
 			}
 
 			// Compare ignoring order
-			gotMatrix := types.ComMatrix{Matrix: out}
+			gotMatrix := types.ComMatrix{Ports: out}
 			gotMatrix.SortAndRemoveDuplicates()
-			expectedMatrix := types.ComMatrix{Matrix: expected}
+			expectedMatrix := types.ComMatrix{Ports: expected}
 			expectedMatrix.SortAndRemoveDuplicates()
-			o.Expect(gotMatrix.Matrix).To(o.Equal(expectedMatrix.Matrix))
+			o.Expect(gotMatrix.Ports).To(o.Equal(expectedMatrix.Ports))
 		})
 	})
 })

pkg/listening-sockets/listening-sockets.go

@@ -107,7 +107,7 @@ func (cc *ConnectionCheck) GenerateSS(namespace string) (*types.ComMatrix, []byt
 		return nil, nil, nil, err
 	}
 
-	ssComMat := types.ComMatrix{Matrix: nodesComDetails}
+	ssComMat := types.ComMatrix{Ports: nodesComDetails}
 	ssComMat.SortAndRemoveDuplicates()
 
 	return &ssComMat, ssOutTCP, ssOutUDP, nil

pkg/listening-sockets/listening_sockets_test.go

@@ -192,7 +192,7 @@ var _ = Describe("GenerateSS", func() {
 
 		Expect(normalizeOutput(string(ssOutTCP))).To(Equal(normalizeOutput(expectedTCPOutput)))
 		Expect(normalizeOutput(string(ssOutUDP))).To(Equal(normalizeOutput(expectedUDPOutput)))
-		Expect(ssMat.Matrix).To(Equal(expectedSSMat))
+		Expect(ssMat.Ports).To(Equal(expectedSSMat))
 	})
 })
 

pkg/matrix-diff/matrix-diff.go

@@ -29,17 +29,17 @@ func Generate(primary *types.ComMatrix, secondary *types.ComMatrix) MatrixDiff {
 	matrix := types.ComMatrix{}
 	epsStatus := map[string]status{}
 
-	for _, cd := range primary.Matrix {
-		matrix.Matrix = append(matrix.Matrix, cd)
+	for _, cd := range primary.Ports {
+		matrix.Ports = append(matrix.Ports, cd)
 		epsStatus[cd.String()] = both
 
 		if !secondary.Contains(cd) {
 			epsStatus[cd.String()] = uniquePrimary
 		}
 	}
 
-	for _, cd := range secondary.Matrix {
-		matrix.Matrix = append(matrix.Matrix, cd)
+	for _, cd := range secondary.Ports {
+		matrix.Ports = append(matrix.Ports, cd)
 		epsStatus[cd.String()] = both
 
 		if !primary.Contains(cd) {
@@ -59,7 +59,7 @@ func (m *MatrixDiff) String() (string, error) {
 	}
 	diff := colNames + "\n"
 
-	for _, cd := range m.Matrix {
+	for _, cd := range m.Ports {
 		switch m.cdToStatus[cd.String()] {
 		case both:
 			diff += fmt.Sprintf("%s\n", cd)
@@ -79,9 +79,9 @@ func (m *MatrixDiff) String() (string, error) {
 func (m *MatrixDiff) GetUniquePrimary() *types.ComMatrix {
 	matrix := types.ComMatrix{}
 
-	for _, cd := range m.Matrix {
+	for _, cd := range m.Ports {
 		if m.cdToStatus[cd.String()] == uniquePrimary {
-			matrix.Matrix = append(matrix.Matrix, cd)
+			matrix.Ports = append(matrix.Ports, cd)
 		}
 	}
 
@@ -92,9 +92,9 @@ func (m *MatrixDiff) GetUniquePrimary() *types.ComMatrix {
 func (m *MatrixDiff) GetUniqueSecondary() *types.ComMatrix {
 	matrix := types.ComMatrix{}
 
-	for _, cd := range m.Matrix {
+	for _, cd := range m.Ports {
 		if m.cdToStatus[cd.String()] == uniqueSecondary {
-			matrix.Matrix = append(matrix.Matrix, cd)
+			matrix.Ports = append(matrix.Ports, cd)
 		}
 	}
 
@@ -105,9 +105,9 @@ func (m *MatrixDiff) GetUniqueSecondary() *types.ComMatrix {
 func (m *MatrixDiff) GetSharedEntries() *types.ComMatrix {
 	matrix := types.ComMatrix{}
 
-	for _, cd := range m.Matrix {
+	for _, cd := range m.Ports {
 		if m.cdToStatus[cd.String()] == both {
-			matrix.Matrix = append(matrix.Matrix, cd)
+			matrix.Ports = append(matrix.Ports, cd)
 		}
 	}
 

pkg/types/types.go

@@ -59,7 +59,7 @@ const (
 )
 
 type ComMatrix struct {
-	Matrix []ComDetails
+	Ports []ComDetails
 }
 
 type ComDetails struct {
@@ -89,7 +89,7 @@ func (m *ComMatrix) ToCSV() ([]byte, error) {
 	w := bytes.NewBuffer(out)
 	csvwriter := csv.NewWriter(w)
 
-	err := gocsv.MarshalCSV(&m.Matrix, csvwriter)
+	err := gocsv.MarshalCSV(&m.Ports, csvwriter)
 	if err != nil {
 		return nil, err
 	}
@@ -100,7 +100,7 @@ func (m *ComMatrix) ToCSV() ([]byte, error) {
 }
 
 func (m *ComMatrix) ToJSON() ([]byte, error) {
-	out, err := json.MarshalIndent(m.Matrix, "", "    ")
+	out, err := json.MarshalIndent(m.Ports, "", "    ")
 	if err != nil {
 		return nil, err
 	}
@@ -119,7 +119,7 @@ func (m *ComMatrix) ToYAML() ([]byte, error) {
 
 func (m *ComMatrix) String() string {
 	var result strings.Builder
-	for _, details := range m.Matrix {
+	for _, details := range m.Ports {
 		result.WriteString(details.String() + "\n")
 	}
 
@@ -130,7 +130,7 @@ func (m *ComMatrix) WriteMatrixToFileByType(utilsHelpers utils.UtilsInterface, f
 	if format == FormatNFT {
 		pools := m.SeparateMatrixByGroup()
 		for poolName, mat := range pools {
-			if len(mat.Matrix) == 0 {
+			if len(mat.Ports) == 0 {
 				continue
 			}
 			if err := mat.writeMatrixToFile(utilsHelpers, fileNamePrefix+"-"+poolName, format, destDir); err != nil {
@@ -165,13 +165,13 @@ func (m *ComMatrix) print(format string) ([]byte, error) {
 // SeparateMatrixByGroup groups matrix entries by their group name (stored in NodeGroup).
 func (m *ComMatrix) SeparateMatrixByGroup() map[string]ComMatrix {
 	res := make(map[string]ComMatrix)
-	for _, entry := range m.Matrix {
+	for _, entry := range m.Ports {
 		pool := entry.NodeGroup
 		if pool == "" {
 			continue
 		}
 		cm := res[pool]
-		cm.Matrix = append(cm.Matrix, entry)
+		cm.Ports = append(cm.Ports, entry)
 		res[pool] = cm
 	}
 	return res
@@ -188,7 +188,7 @@ func (m *ComMatrix) writeMatrixToFile(utilsHelpers utils.UtilsInterface, fileNam
 }
 
 func (m *ComMatrix) Contains(cd ComDetails) bool {
-	for _, cd1 := range m.Matrix {
+	for _, cd1 := range m.Ports {
 		if cd1.Equals(cd) {
 			return true
 		}
@@ -200,7 +200,7 @@ func (m *ComMatrix) Contains(cd ComDetails) bool {
 func (m *ComMatrix) ToNFTables() ([]byte, error) {
 	var tcpPorts []string
 	var udpPorts []string
-	for _, line := range m.Matrix {
+	for _, line := range m.Ports {
 		if line.Protocol == "TCP" {
 			tcpPorts = append(tcpPorts, fmt.Sprint(line.Port))
 		} else if line.Protocol == "UDP" {
@@ -243,16 +243,16 @@ func (m *ComMatrix) ToNFTables() ([]byte, error) {
 func (m *ComMatrix) SortAndRemoveDuplicates() {
 	allKeys := make(map[string]bool)
 	res := []ComDetails{}
-	for _, item := range m.Matrix {
+	for _, item := range m.Ports {
 		str := fmt.Sprintf("%s-%d-%s", item.NodeGroup, item.Port, item.Protocol)
 		if _, value := allKeys[str]; !value {
 			allKeys[str] = true
 			res = append(res, item)
 		}
 	}
-	m.Matrix = res
+	m.Ports = res
 
-	slices.SortFunc(m.Matrix, func(a, b ComDetails) int {
+	slices.SortFunc(m.Ports, func(a, b ComDetails) int {
 		res := cmp.Compare(a.NodeGroup, b.NodeGroup)
 		if res != 0 {
 			return res

test/e2e/validation_test.go

@@ -61,7 +61,7 @@ var _ = Describe("Validation", func() {
 
 		ComDetailsMatrix, err := types.ParseToComDetailsList(commatrixFileContent, types.FormatCSV)
 		Expect(err).ToNot(HaveOccurred(), "Failed to parse generated commatrix")
-		commatrix = &types.ComMatrix{Matrix: ComDetailsMatrix}
+		commatrix = &types.ComMatrix{Ports: ComDetailsMatrix}
 	})
 
 	It("generated communication matrix should be equal to documented communication matrix", func() {
@@ -93,7 +93,7 @@ var _ = Describe("Validation", func() {
 
 		docComDetailsList, err := types.ParseToComDetailsList(docCommatrixFileContent, types.FormatCSV)
 		Expect(err).ToNot(HaveOccurred(), "Failed to parse documented communication matrix")
-		docComMatrix := &types.ComMatrix{Matrix: docComDetailsList}
+		docComMatrix := &types.ComMatrix{Ports: docComDetailsList}
 
 		By("generating diff between matrices for testing purposes")
 		endpointslicesDiffWithDocMat := matrixdiff.Generate(commatrix, docComMatrix)
@@ -106,7 +106,7 @@ var _ = Describe("Validation", func() {
 		By("comparing new and documented commatrices")
 		// Get ports that are in the documented commatrix but not in the generated commatrix.
 		notUsedPortsMat := endpointslicesDiffWithDocMat.GetUniqueSecondary()
-		if len(notUsedPortsMat.Matrix) > 0 {
+		if len(notUsedPortsMat.Ports) > 0 {
 			logrus.Warningf("the following ports are documented but are not used:\n%s", notUsedPortsMat)
 		}
 
@@ -124,15 +124,15 @@ var _ = Describe("Validation", func() {
 
 			portsToIgnoreComDetails, err := types.ParseToComDetailsList(portsToIgnoreFileContent, openPortsToIgnoreFormat)
 			Expect(err).ToNot(HaveOccurred())
-			portsToIgnoreMat = &types.ComMatrix{Matrix: portsToIgnoreComDetails}
+			portsToIgnoreMat = &types.ComMatrix{Ports: portsToIgnoreComDetails}
 
 			// generate the diff matrix between the open ports to ignore matrix and the missing ports in the documented commatrix (based on the diff between the enpointslice and the doc matrix)
 			nonDocumentedEndpointslicesMat := endpointslicesDiffWithDocMat.GetUniquePrimary()
 			endpointslicesDiffWithIgnoredPorts := matrixdiff.Generate(nonDocumentedEndpointslicesMat, portsToIgnoreMat)
 			missingPortsMat = endpointslicesDiffWithIgnoredPorts.GetUniquePrimary()
 		}
 
-		if len(missingPortsMat.Matrix) > 0 {
+		if len(missingPortsMat.Ports) > 0 {
 			err := fmt.Errorf("the following ports are used but are not documented:\n%s", missingPortsMat)
 			Expect(err).ToNot(HaveOccurred())
 		}
@@ -150,13 +150,13 @@ var _ = Describe("Validation", func() {
 		missingEPSMat, err := extractEPSMatByStatus(matDiffSSFileContent, Missing)
 		Expect(err).ToNot(HaveOccurred(), "Failed to extract missing EPS Matrix")
 
-		if len(notUsedEPSMat.Matrix) > 0 {
+		if len(notUsedEPSMat.Ports) > 0 {
 			logrus.Warningf("the following ports are not used: \n %s", notUsedEPSMat)
 		}
 
 		missingEPSMat, err = filterKnownPorts(missingEPSMat)
 		Expect(err).ToNot(HaveOccurred(), "Failed to filter the known ports")
-		if len(missingEPSMat.Matrix) > 0 {
+		if len(missingEPSMat.Ports) > 0 {
 			err := fmt.Errorf("the following ports are used but don't have an endpointslice: \n %s", missingEPSMat)
 			Expect(err).ToNot(HaveOccurred())
 		}
@@ -190,7 +190,7 @@ func filterKnownPorts(mat *types.ComMatrix) (*types.ComMatrix, error) {
 	}
 
 	res := []types.ComDetails{}
-	for _, cd := range mat.Matrix {
+	for _, cd := range mat.Ports {
 		// Skip "ovnkube" ports in the nodePort range, these are dynamic open ports on the node,
 		// no need to mention them in the matrix diff
 		if cd.Service == "ovnkube" && cd.Port >= nodePortMin && cd.Port <= nodePortMax {
@@ -219,7 +219,7 @@ func filterKnownPorts(mat *types.ComMatrix) (*types.ComMatrix, error) {
 		res = append(res, cd)
 	}
 
-	return &types.ComMatrix{Matrix: res}, nil
+	return &types.ComMatrix{Ports: res}, nil
 }
 
 // extractEPSMatByStatus extracts and returns ComMatrix by filtering lines of a CSV content based on a EPS status.
@@ -231,7 +231,7 @@ func extractEPSMatByStatus(csvContent []byte, status EPSStatus) (*types.ComMatri
 		return nil, err
 	}
 
-	return &types.ComMatrix{Matrix: prefixEPSMat}, nil
+	return &types.ComMatrix{Ports: prefixEPSMat}, nil
 }
 
 // extractDiffByStatus filter the lines of the csv content based on the EPS status