identify bad component

Author: Alva8756

internal/inventoryconverter/inventoryconverter.go

@@ -26,6 +26,11 @@ func (ic *InventoryConverter) ToRivetsServer(serverID, facility string, device *
 		return nil, err
 	}
 
+	deviceState := ""
+	if device.Status != nil {
+		deviceState = device.Status.State
+	}
+
 	return &rivets.Server{
 		BIOSCfg:    biosCfg,
 		ID:         serverID,
@@ -34,7 +39,7 @@ func (ic *InventoryConverter) ToRivetsServer(serverID, facility string, device *
 		Vendor:     device.Vendor,
 		Model:      device.Model,
 		Serial:     device.Serial,
-		Status:     device.Status.State,
+		Status:     deviceState,
 		Components: components,
 	}, nil
 }

pkg/api/routes/components.go

@@ -15,13 +15,13 @@ import (
 
 var fleetDBTimeout = 3 * time.Minute
 
-type cmpResult int
+type componentCompareResult int
 
 const (
-	NOT_FOUND cmpResult = iota
+	NOT_FOUND componentCompareResult = iota
 	ERROR_FETCH
-	GAP
-	SAME
+	DIFFERENT
+	EQUAL
 )
 
 // this is a map of "component_type_name" to the actual inventory data for each component
@@ -58,7 +58,7 @@ func fetchServerComponents(client internalfleetdb.Client, srvid uuid.UUID, l *za
 	return comps, nil
 }
 
-func verifyComponent(c internalfleetdb.Client, server *fleetdb.Server, dev *rivets.Server, log *zap.Logger) cmpResult {
+func verifyComponent(c internalfleetdb.Client, server *fleetdb.Server, dev *rivets.Server, log *zap.Logger) componentCompareResult {
 	fleetComponentsMap, err := fetchServerComponents(c, server.UUID, log)
 	if err != nil {
 		if strings.Contains(err.Error(), "404") {
@@ -68,6 +68,10 @@ func verifyComponent(c internalfleetdb.Client, server *fleetdb.Server, dev *rive
 		return ERROR_FETCH
 	}
 
+	if len(fleetComponentsMap) == 0 {
+		return NOT_FOUND
+	}
+
 	alloyComponentsMap := make(map[string][]*rivets.Component)
 	for _, component := range dev.Components {
 		slug := component.Name
@@ -77,24 +81,83 @@ func verifyComponent(c internalfleetdb.Client, server *fleetdb.Server, dev *rive
 		alloyComponentsMap[slug] = append(alloyComponentsMap[slug], component)
 	}
 
-	var diff strings.Builder
-	for slug, fleetComponents := range fleetComponentsMap {
-		if alloyComponents, ok := alloyComponentsMap[slug]; ok {
-			compareComponents(fleetComponents, alloyComponents, &diff)
-			continue
+	serverID := server.UUID.String()
+	var cmpResult componentCompareResult
+
+	for slug, alloyComponents := range alloyComponentsMap {
+		fleetComponents, _ := fleetComponentsMap[slug]
+		// if fleetComponents is nil, we will print logs for
+		// each component in alloyComponents.
+		if changed := compareComponents(alloyComponents, fleetComponents, slug, serverID, log); changed {
+			cmpResult = DIFFERENT
 		}
-		// diff.WriteString("-", fleetComponents)
 	}
 
-	for slug, alloyComponents := range alloyComponentsMap {
+	for slug, fleetComponents := range fleetComponentsMap {
 		if _, ok := alloyComponentsMap[slug]; ok {
+			// We have already compared this slug in the previous for loog.
 			continue
 		}
-		// diff.WriteString("+", fleetComponents)
+		cmpResult = DIFFERENT
+		compareComponents(nil, fleetComponents, slug, serverID, log)
 	}
 
-	return SAME
+	return cmpResult
 }
 
-func compareComponents(src []*rivets.Component, tgt []*rivets.Component, diff *strings.Builder) {
+func compareComponents(expected []*rivets.Component, current []*rivets.Component, slug string, serverID string, log *zap.Logger) bool {
+	var hasGap bool
+	expectedMap := make(map[string]string)
+	currentMap := make(map[string]string)
+	for _, component := range expected {
+		expectedMap[component.Vendor+component.Model] = component.Firmware.Installed
+	}
+	for _, component := range current {
+		currentMap[component.Vendor+component.Model] = component.Firmware.Installed
+	}
+
+	for key, expectedFirmwareVersion := range expectedMap {
+		currentFirmwareVersion, exist := currentMap[key]
+		if !exist {
+			hasGap = true
+			fields := []zap.Field{
+				zap.String("device.id", serverID),
+				zap.String("component", slug),
+				zap.String("expected(alloy)", expectedFirmwareVersion),
+				zap.String("current(fleetdb)", "fleetdb firmware does not exist"),
+			}
+			log.Warn("alloy has component but not in fleetdb", fields...)
+			continue
+		}
+
+		if expectedFirmwareVersion != currentFirmwareVersion {
+			hasGap = true
+			fields := []zap.Field{
+				zap.String("device.id", serverID),
+				zap.String("component", slug),
+				zap.String("expected(alloy)", currentFirmwareVersion),
+				zap.String("current(fleetdb)", expectedFirmwareVersion),
+			}
+			log.Warn("component firmware needs update", fields...)
+		}
+	}
+
+	for key, currentFirmwareVersion := range currentMap {
+		_, exist := expectedMap[key]
+		if exist {
+			// Already been compared in the previous for loop.
+			continue
+		}
+
+		hasGap = true
+		fields := []zap.Field{
+			zap.String("device.id", serverID),
+			zap.String("component", slug),
+			zap.String("expected(alloy)", "alloy firmware does not exist"),
+			zap.String("current(fleetdb)", currentFirmwareVersion),
+		}
+		log.Warn("fleetdb component has component but not in alloy", fields...)
+	}
+
+	return hasGap
 }

pkg/api/routes/components_test.go

@@ -12,8 +12,11 @@ import (
 	"github.com/metal-toolbox/component-inventory/internal/app"
 	"github.com/stretchr/testify/require"
 
+	common "github.com/bmc-toolbox/common"
 	internalfleetdb "github.com/metal-toolbox/component-inventory/internal/fleetdb"
 	fleetdb "github.com/metal-toolbox/fleetdb/pkg/api/v1"
+	rivets "github.com/metal-toolbox/rivets/types"
+	"go.uber.org/zap"
 )
 
 var serverUUID = uuid.New()
@@ -174,3 +177,37 @@ func TestFetchServerComponents(t *testing.T) {
 		require.Equal(t, 500, srvErr.StatusCode)
 	})
 }
+
+func TestCompareComponents(t *testing.T) {
+	testCases := []struct {
+		desc       string
+		installed  []*rivets.Component
+		current    []*rivets.Component
+		expectDiff bool
+	}{
+		{
+			"2 nil slice",
+			nil,
+			nil,
+			false,
+		},
+		{
+			"installed nil slice",
+			nil,
+			[]*rivets.Component{
+				{
+					Firmware: &common.Firmware{Installed: "2.6.6"},
+					Status:   &common.Status{State: "Enabled"},
+				},
+			},
+			true,
+		},
+	}
+
+	for _, tc := range testCases {
+		if got := compareComponents(tc.installed, tc.current, "fakeSlug", "fakeID", zap.NewNop()); got != tc.expectDiff {
+			t.Errorf("test %v got compare result %v, expect %v", tc.desc, got, tc.expectDiff)
+		}
+	}
+
+}

pkg/api/routes/inventory.go

@@ -3,6 +3,7 @@ package routes
 import (
 	"context"
 	"fmt"
+	"strconv"
 
 	"github.com/metal-toolbox/alloy/types"
 	internalfleetdb "github.com/metal-toolbox/component-inventory/internal/fleetdb"
@@ -18,8 +19,8 @@ func processInband(ctx context.Context, c internalfleetdb.Client, server *fleetd
 		return err
 	}
 
-	if cmp := verifyComponent(c, server, rivetsServer, log); cmp == SAME || cmp == ERROR_FETCH {
-		log.Error("verify component", zap.String("server", server.Name), zap.String("err", cmp))
+	if cmp := verifyComponent(c, server, rivetsServer, log); cmp == EQUAL || cmp == ERROR_FETCH {
+		log.Error("verify component", zap.String("server", server.Name), zap.String("err", strconv.Itoa(int(cmp))))
 		return fmt.Errorf("failed to verify components %v", cmp)
 	}
 	return c.UpdateServerInventory(ctx, server, rivetsServer, log, true)
@@ -32,8 +33,8 @@ func processOutofband(ctx context.Context, c internalfleetdb.Client, server *fle
 		log.Error("convert inventory fail", zap.String("server", server.Name), zap.String("err", err.Error()))
 		return err
 	}
-	if cmp := verifyComponent(c, server, rivetsServer, log); cmp == SAME || cmp == ERROR_FETCH {
-		log.Error("verify component", zap.String("server", server.Name), zap.String("err", cmp))
+	if cmp := verifyComponent(c, server, rivetsServer, log); cmp == EQUAL || cmp == ERROR_FETCH {
+		log.Error("verify component", zap.String("server", server.Name), zap.String("err", strconv.Itoa(int(cmp))))
 		return err
 	}
 	return c.UpdateServerInventory(ctx, server, rivetsServer, log, false)