ngi

Signed-off-by: Jacob Salmela <[email protected]>

cmd/session/session_init.go

@@ -56,10 +56,10 @@ func initSessionWithProviderCmd(cmd *cobra.Command, args []string) (err error) {
 	switch root.D.Provider {
 	case taxonomy.CSM:
 		root.D.DatastorePath = filepath.Join(config.ConfigDir, taxonomy.DsFileCSM)
-	case taxonomy.Hpengi:
-		root.D.DatastorePath = filepath.Join(config.ConfigDir, taxonomy.DsFile)
 	case taxonomy.HPCM:
 		root.D.DatastorePath = filepath.Join(config.ConfigDir, taxonomy.DsFile)
+	case taxonomy.Hpengi:
+		root.D.DatastorePath = filepath.Join(config.ConfigDir, taxonomy.DsFile)
 	default:
 		err = fmt.Errorf("not a valid provider: %s", root.D.Provider)
 	}

cmd/taxonomy/taxonomy.go

@@ -36,6 +36,7 @@ const (
 	App              = "cani"
 	CSM              = "csm"
 	HPCM             = "hpcm"
+	Hpengi           = "hpengi"
 	DsFile           = App + "db.json"
 	DsFileCSM        = App + "db.json"
 	LogFile          = App + "db.log"
@@ -50,7 +51,7 @@ const (
 var (
 	DsPath             = filepath.Join(CfgDir, DsFile)
 	CfgPath            = filepath.Join(CfgDir, CfgFile)
-	SupportedProviders = []string{CSM, HPCM}
+	SupportedProviders = []string{CSM, Hpengi, HPCM}
 )
 
 func Init() {

internal/domain/domain.go

@@ -35,6 +35,7 @@ import (
 	"github.com/Cray-HPE/cani/internal/provider"
 	"github.com/Cray-HPE/cani/internal/provider/csm"
 	"github.com/Cray-HPE/cani/internal/provider/hpcm"
+	"github.com/Cray-HPE/cani/internal/provider/hpengi"
 	"github.com/Cray-HPE/cani/pkg/hardwaretypes"
 	"github.com/google/uuid"
 	"github.com/rs/zerolog/log"
@@ -93,6 +94,8 @@ func (d *Domain) SetupDomain(cmd *cobra.Command, args []string, configDomains ma
 		d.datastore, err = inventory.NewDatastoreJSONCSM(d.DatastorePath, d.LogFilePath, inventory.Provider(d.Provider))
 	case taxonomy.HPCM:
 		d.datastore, err = inventory.NewDatastoreJSON(d.DatastorePath, d.LogFilePath, inventory.Provider(d.Provider))
+	case taxonomy.Hpengi:
+		d.datastore, err = inventory.NewDatastoreJSON(d.DatastorePath, d.LogFilePath, inventory.Provider(d.Provider))
 	default:
 		return fmt.Errorf("invalid provider: %s", d.Provider)
 	}
@@ -121,6 +124,8 @@ func (d *Domain) SetupDomain(cmd *cobra.Command, args []string, configDomains ma
 		d.externalInventoryProvider, err = csm.New(cmd, args, d.hardwareTypeLibrary, d.Options)
 	case taxonomy.HPCM:
 		d.externalInventoryProvider, err = hpcm.New(cmd, args, d.hardwareTypeLibrary, d.Options)
+	case taxonomy.Hpengi:
+		d.externalInventoryProvider, err = hpengi.New(cmd, args, d.hardwareTypeLibrary, d.Options)
 	default:
 		return fmt.Errorf("unknown external inventory provider provided (%s)", d.Provider)
 	}
@@ -173,6 +178,7 @@ func GetProviders() []provider.InventoryProvider {
 	supportedProviders := []provider.InventoryProvider{
 		&csm.CSM{},
 		&hpcm.Hpcm{},
+		&hpengi.Hpengi{},
 	}
 	return supportedProviders
 }

internal/provider/hpcm/import.go

@@ -39,11 +39,18 @@ func (hpcm *Hpcm) ImportInit(cmd *cobra.Command, args []string, datastore invent
 	}
 
 	// translate external inventory data to cani hardware entries
-	err = hpcm.Translate(cmd, args, ds)
+	translated, err := hpcm.Translate(cmd, args)
 	if err != nil {
 		return err
 	}
 
+	for _, hw := range translated {
+		err = ds.Add(hw)
+		if err != nil {
+			return err
+		}
+	}
+
 	// merge the temp datastore with the existing one
 	err = datastore.Merge(ds)
 	if err != nil {

internal/provider/hpcm/translate.go

@@ -39,32 +39,24 @@ import (
 	"github.com/spf13/cobra"
 )
 
-func (hpcm *Hpcm) Translate(cmd *cobra.Command, args []string, ds inventory.Datastore) (err error) {
-	var translated = map[uuid.UUID]*inventory.Hardware{}
+func (hpcm *Hpcm) Translate(cmd *cobra.Command, args []string) (translated map[uuid.UUID]*inventory.Hardware, err error) {
+	// translated = make(map[uuid.UUID]*inventory.Hardware, 0)
 
 	// check if input is coming from a cm config file
 	if cmd.Flags().Changed("cm-config") {
-		translated, err = hpcm.TranslateCmConfig()
+		translated, err = hpcm.CmConfig.TranslateCmConfig()
 		if err != nil {
-			return err
+			return translated, err
 		}
 		// by default, translate information from the cmdb
 	} else {
 		translated, err = hpcm.TranslateCmdb()
 		if err != nil {
-			return err
+			return translated, err
 		}
 	}
 
-	// add the translated hardware to the datastore
-	for _, hw := range translated {
-		err = ds.Add(hw)
-		if err != nil {
-			return err
-		}
-	}
-
-	return nil
+	return translated, nil
 }
 
 // extractProviderMetadata is a catchall function for HPCM data that doesn't fit elsewhere
@@ -206,6 +198,33 @@ func setupTempDatastore(datastore inventory.Datastore) (temp inventory.Datastore
 	return temp, nil
 }
 
+func hpcmLocToCaniType(cmloc hpcm_client.LocationSettings) (string, error) {
+	if &cmloc.Rack == nil {
+		log.Info().Msgf("%+v", "rack nil")
+	}
+	if &cmloc.Chassis == nil {
+		log.Info().Msgf("%+v", "chassis nil")
+	}
+	if &cmloc.Tray == nil {
+		log.Info().Msgf("%+v", "tray nil")
+	}
+	if &cmloc.Controller == nil {
+		log.Info().Msgf("%+v", "controller nil")
+	}
+	if &cmloc.Node == nil {
+		log.Info().Msgf("%+v", "node nil")
+	}
+	system := inventory.LocationToken{HardwareType: hardwaretypes.System, Ordinal: 0}
+	cabinet := inventory.LocationToken{HardwareType: hardwaretypes.Cabinet, Ordinal: int(cmloc.Rack)}
+	chassis := inventory.LocationToken{HardwareType: hardwaretypes.Chassis, Ordinal: int(cmloc.Chassis)}
+	blade := inventory.LocationToken{HardwareType: hardwaretypes.NodeBlade, Ordinal: int(cmloc.Tray)}
+	bmc := inventory.LocationToken{HardwareType: hardwaretypes.NodeController, Ordinal: int(cmloc.Controller)}
+	node := inventory.LocationToken{HardwareType: hardwaretypes.Node, Ordinal: int(cmloc.Node)}
+	lp := inventory.LocationPath{system, cabinet, chassis, blade, bmc, node}
+
+	return lp.GetHardwareTypePath().Key(), nil
+}
+
 // hpcmLocToCaniLoc translates hpcm location keys to a cani location path
 func hpcmLocToCaniLoc(caniHwType hardwaretypes.HardwareType, hpcmLoc *hpcm_client.LocationSettings) (caniLoc inventory.LocationPath, err error) {
 	// HPCM        --->   CANI
@@ -215,7 +234,7 @@ func hpcmLocToCaniLoc(caniHwType hardwaretypes.HardwareType, hpcmLoc *hpcm_clien
 	// Tray        --->   NodeBlade/SwitchBlade
 	// Controller  --->   NodeController
 	// Node        --->   Node
-	var system, cabinet, chassis, blade, node inventory.LocationToken
+	var system, cabinet, chassis, blade, controller, node inventory.LocationToken
 	// rack and chassis map to cabinet and chassis
 	system = inventory.LocationToken{HardwareType: hardwaretypes.System, Ordinal: 0}
 	cabinet = inventory.LocationToken{HardwareType: hardwaretypes.Cabinet, Ordinal: int(hpcmLoc.Rack)}
@@ -241,10 +260,16 @@ func hpcmLocToCaniLoc(caniHwType hardwaretypes.HardwareType, hpcmLoc *hpcm_clien
 		caniLoc = inventory.LocationPath{system, cabinet, chassis, blade}
 	case hardwaretypes.Node:
 		blade = inventory.LocationToken{HardwareType: hardwaretypes.NodeBlade, Ordinal: int(hpcmLoc.Tray)}
+		controller = inventory.LocationToken{HardwareType: hardwaretypes.NodeController, Ordinal: int(hpcmLoc.Controller)}
 		node = inventory.LocationToken{HardwareType: hardwaretypes.Node, Ordinal: int(hpcmLoc.Node)}
-		caniLoc = inventory.LocationPath{system, cabinet, chassis, blade, node}
+		caniLoc = inventory.LocationPath{system, cabinet, chassis, blade, controller, node}
 	default:
-		log.Warn().Msgf("Unable to get LocationPath from hardware type: %v", caniHwType)
+		// assume a node
+		blade = inventory.LocationToken{HardwareType: hardwaretypes.NodeBlade, Ordinal: int(hpcmLoc.Tray)}
+		controller = inventory.LocationToken{HardwareType: hardwaretypes.NodeController, Ordinal: int(hpcmLoc.Controller)}
+		node = inventory.LocationToken{HardwareType: hardwaretypes.Node, Ordinal: int(hpcmLoc.Node)}
+		caniLoc = inventory.LocationPath{system, cabinet, chassis, blade, controller, node}
+		// log.Warn().Msgf("Unable to get LocationPath from hardware type: %v", caniHwType)
 	}
 
 	log.Debug().Msgf("Set LocationPath via HPCM geo location values: %+v -> %v", hpcmLoc, caniLoc)
@@ -273,8 +298,11 @@ func hpcmTypeToCaniHardwareType(hpcmType string) (t hardwaretypes.HardwareType,
 		t = hardwaretypes.CabinetPDU
 	case "switch_blade":
 		t = hardwaretypes.ManagementSwitchEnclosure
+	case "":
+		// assume anything else is a node.  this may be a mistake
+		t = hardwaretypes.Node
 	default:
-		err = fmt.Errorf("unabled to map HPCM type to CANI hardwaretype: %v", hpcmType)
+		err = fmt.Errorf("unable to map HPCM type to CANI hardwaretype: %v", hpcmType)
 	}
 	if err != nil {
 		return t, err

internal/provider/hpcm/translate_hpcm_config.go

@@ -26,8 +26,6 @@
 package hpcm
 
 import (
-	"fmt"
-
 	"github.com/Cray-HPE/cani/cmd/taxonomy"
 	"github.com/Cray-HPE/cani/internal/inventory"
 	hpcm_client "github.com/Cray-HPE/cani/pkg/hpcm-client"
@@ -36,108 +34,87 @@ import (
 )
 
 // TranslateCmConfigToCaniHw translates data from Hpcm.CmConfig to CANI format
-func (hpcm *Hpcm) TranslateCmConfig() (translated map[uuid.UUID]*inventory.Hardware, err error) {
+func (cm HpcmConfig) TranslateCmConfig() (translated map[uuid.UUID]*inventory.Hardware, err error) {
 	translated = make(map[uuid.UUID]*inventory.Hardware, 0)
-	for _, d := range hpcm.CmConfig.Discover {
+	for _, d := range cm.Discover {
 		log.Debug().Msgf("Translating %s hardware to %s format (%+v)", "HPCM", taxonomy.App, d.Hostname1)
-		hw := &inventory.Hardware{}
-
-		// translate the hpcm fields to cani fields
-		err = TranslateCmHardwareToCaniHw(d, hpcm.CmConfig, hw)
-		if err != nil {
-			return translated, err
-		}
 
-		// add the hardware to the map if it does not exist
-		_, exists := translated[hw.ID]
-		if exists {
-			return translated, fmt.Errorf("Hardware already exists: %s", hw.ID)
-		}
-		translated[hw.ID] = hw
+		_ = d.getModel()
+		// 	// translate the hpcm fields to cani fields
+		// 	t, err := TranslateCmHardwareToCaniHw(d, cm)
+		// 	if err != nil {
+		// 		return translated, err
+		// 	}
+
+		// 	// add the hardware to the map if it does not exist
+		// 	_, exists := translated[t.ID]
+		// 	if exists {
+		// 		return translated, fmt.Errorf("Hardware already exists: %s", hw.ID)
+		// 	}
+		// 	translated[hw.ID] = hw
 	}
 
 	// return the map of translated hpcm --> cani hardware
 	return translated, nil
 }
 
-func TranslateCmHardwareToCaniHw(d Discover, cm HpcmConfig, hw *inventory.Hardware) (err error) {
-	// create a uuid for the new hardware
-	u := uuid.New()
-	log.Debug().Msgf("  Unique Identifier:  --> %s: %+v", "ID", u)
-	hw.ID = u
-
-	// Convert HPCM type to cani hardwaretypes
-	t, err := hpcmTypeToCaniHardwareType(d.Type)
-	if err != nil {
-		return err
-	}
-	hw.Type = t
-	log.Debug().Msgf("  type: %s --> %s: %s", d.Type, "Type", t)
-
-	// Convert HPCM template name to cani device type slug
-	s := hpcmCmTemplateNameToCaniSlug(d, cm)
-	if err != nil {
-		return err
-	}
-	hw.DeviceTypeSlug = s
-	log.Debug().Msgf("  template_name: %s --> %s: %s", d.TemplateName, "DeviceTypeSlug", s)
+func (cm HpcmConfig) TranslateCmHardwareToCaniHw() (translated map[uuid.UUID]*inventory.Hardware, err error) {
+	translated = make(map[uuid.UUID]*inventory.Hardware, 0)
 
-	// Convert HPCM card type to cani vendor
-	v := hpcmCmCardTypeToCaniVendor(d, cm)
-	if err != nil {
-		return err
-	}
-	hw.Vendor = v
-	log.Debug().Msgf("  card_type: %s --> %s: %s", d.CardType, "Vendor", v)
+	for _, d := range cm.Discover {
+		hw := &inventory.Hardware{}
+		hw.ID = uuid.New()
 
-	// Convert HPCM card type to cani vendor
-	cmloc := &hpcm_client.LocationSettings{
-		Rack:       int32(d.RackNr),
-		Chassis:    int32(d.Chassis),
-		Tray:       int32(d.Tray),
-		Node:       int32(d.NodeNr),
-		Controller: int32(d.ControllerNr),
-	}
-	lp, err := hpcmLocToCaniLoc(hw.Type, cmloc)
-	if err != nil {
-		return err
-	}
-	hw.LocationPath = lp
-	log.Debug().Msgf("  *_nr: %d->%d->%d->%d --> %s: %s",
-		d.RackNr,
-		d.Chassis,
-		d.Tray,
-		d.NodeNr,
-		"LocationPath", lp.String())
+		// Convert HPCM type to cani hardwaretypes
+		t, err := hpcmTypeToCaniHardwareType(d.Type)
+		if err != nil {
+			return translated, err
+		}
+		hw.Type = t
+
+		// Convert HPCM location to cani location
+		cmloc := &hpcm_client.LocationSettings{
+			Rack:       int32(d.RackNr),
+			Chassis:    int32(d.Chassis),
+			Tray:       int32(d.Tray),
+			Controller: int32(d.ControllerNr),
+			Node:       int32(d.NodeNr),
+		}
 
-	// these fields map 1:1 and are not necessarily required, so just fill them
-	hw.LocationOrdinal = &d.NodeNr
-	log.Debug().Msgf("  node_nr: %d --> %s: %d", d.NodeNr, "LocationOrdinal", *hw.LocationOrdinal)
-	hw.Architecture = d.Architecture
-	log.Debug().Msgf("  %s: %s %s %s: %s", "architecture", d.Architecture, "-->", "Architecture", hw.Architecture)
-	hw.Model = d.TemplateName
-	// log.Debug().Msgf("  %s: %s %s %s: %s", "template_name", d.TemplateName, "-->", "Model", hw.Model)
-	hw.Name = d.Hostname1
-	log.Debug().Msgf("  %s: %s %s %s: %s", "hostname1", d.Hostname1, "-->", "Name", hw.Name)
-	log.Debug().Msgf("")
+		lp, err := hpcmLocToCaniLoc(hw.Type, cmloc)
+		if err != nil {
+			return translated, err
+		}
 
-	return nil
-}
+		hw.LocationPath = lp
+		hw.Architecture = d.Architecture
+		hw.Model = d.TemplateName
+		hw.Name = d.Hostname1
 
-// hpcmCmCardTypeToCaniVendor
-func hpcmCmCardTypeToCaniVendor(d Discover, cm HpcmConfig) (v string) {
-	switch d.CardType {
-	case "iLo":
-		v = "HPE"
-	case "Intel":
-		v = "Intel"
-	case "IPMI":
-		v = "IPMI"
-	default:
-		v = "Unknown"
+		_, exists := translated[hw.ID]
+		if !exists {
+			translated[hw.ID] = hw
+		}
 	}
+	return translated, nil
+}
 
-	return v
+// getModel messily gets the model from a Discover object
+func (d Discover) getModel() (model string) {
+	log.Info().Msgf("%+v", d)
+	// md := make(map[string]interface{}, 0)
+	// md["Inventory"] = make(map[string]interface{}, 0)
+	// mdInv := md["Inventory"].(map[string]interface{})
+	// if node.Inventory != nil {
+	// 	inv := *node.Inventory
+	// 	for k, v := range inv.(map[string]interface{}) {
+	// 		if k == "fru.Model" {
+	// 			vendor = v.(string)
+	// 		}
+	// 		mdInv[k] = v
+	// 	}
+	// }
+	return model
 }
 
 // hpcmCmTemplateNameToCaniSlug

internal/provider/hpcm/validate_external.go

@@ -52,7 +52,7 @@ func (hpcm *Hpcm) siteSurvey(cmd *cobra.Command, args []string) error {
 		hpcm.CmConfig = cm
 		// by default, import from the CMDB if no flags were passed
 	} else {
-		err := hpcm.dumpCmdb(cmd, args)
+		err := hpcm.LoadCmdb(cmd, args)
 		if err != nil {
 			return err
 		}