towk/magellan
1
0
Fork 0
mirror of https://github.com/davidallendj/magellan.git synced 2025-12-20 03:27:03 -07:00
Code Issues Projects Releases Packages Wiki Activity Actions

More minor changes

Browse source
This commit is contained in:
David J. Allen 2024-05-08 13:29:07 -06:00
parent 2289209604
commit c041acafee
No known key found for this signature in database
GPG key ID: 717C593FF60A2ACC
2 changed files with 55 additions and 72 deletions
Download patch file Download diff file Expand all files Collapse all files

4
internal/api/smd/smd.go
View file

@ -117,7 +117,7 @@ func (c *Client) AddRedfishEndpoint(data []byte, headers map[string]string) erro
func (c *Client) UpdateRedfishEndpoint(xname string, data []byte, headers map[string]string) error {
if data == nil {
return fmt.Errorf("could not add redfish endpoint: no data found")
return fmt.Errorf("failed to add redfish endpoint: no data found")
}
// Update redfish endpoint via PUT `/hsm/v2/Inventory/RedfishEndpoints` endpoint
url := makeEndpointUrl("/Inventory/RedfishEndpoints/" + xname)
@ -126,7 +126,7 @@ func (c *Client) UpdateRedfishEndpoint(xname string, data []byte, headers map[st
if res != nil {
statusOk := res.StatusCode >= 200 && res.StatusCode < 300
if !statusOk {
return fmt.Errorf("could not update redfish endpoint")
return fmt.Errorf("failed to update redfish endpoint (returned %s)", res.Status)
}
}
return err

121
internal/collect.go
View file

@ -2,8 +2,10 @@ package magellan
import (
"context"
"crypto/tls"
"encoding/json"
"fmt"
"net"
"net/http"
"os"
"path"
@ -62,7 +64,7 @@ func CollectAll(probeStates *[]ScannedResult, l *log.Logger, q *QueryParams) err
outputPath := path.Clean(q.OutputPath)
outputPath, err := util.MakeOutputDirectory(outputPath)
if err != nil {
l.Log.Errorf("could not make output directory: %v", err)
l.Log.Errorf("failed to make output directory: %v", err)
}
// collect bmc information asynchronously
@ -97,14 +99,9 @@ func CollectAll(probeStates *[]ScannedResult, l *log.Logger, q *QueryParams) err
}
offset += 1
// bmclibClient, err := NewClient(l, q)
// if err != nil {
// l.Log.Errorf("could not make client: %v", err)
// }
gofishClient, err := connectGofish(q)
if err != nil {
l.Log.Errorf("could not connect to bmc (%v:%v): %v", q.Host, q.Port, err)
l.Log.Errorf("failed to connect to bmc (%v:%v): %v", q.Host, q.Port, err)
}
// data to be sent to smd
@ -122,21 +119,11 @@ func CollectAll(probeStates *[]ScannedResult, l *log.Logger, q *QueryParams) err
// unmarshal json to send in correct format
var rm map[string]json.RawMessage
// inventories
// if bmclibClient != nil {
// inventory, err := CollectInventory(bmclibClient, q)
// if err != nil {
// l.Log.Errorf("could not query inventory (%v:%v): %v", q.Host, q.Port, err)
// }
// json.Unmarshal(inventory, &rm)
// data["Inventory"] = rm["Inventory"]
// }
// chassis
if gofishClient != nil {
chassis, err := CollectChassis(gofishClient, q)
if err != nil {
l.Log.Errorf("could not query chassis: %v", err)
l.Log.Errorf("failed to query chassis: %v", err)
continue
}
json.Unmarshal(chassis, &rm)
@ -145,7 +132,7 @@ func CollectAll(probeStates *[]ScannedResult, l *log.Logger, q *QueryParams) err
// systems
systems, err := CollectSystems(gofishClient, q)
if err != nil {
l.Log.Errorf("could not query systems: %v", err)
l.Log.Errorf("failed to query systems: %v", err)
}
json.Unmarshal(systems, &rm)
data["Systems"] = rm["Systems"]
@ -168,7 +155,7 @@ func CollectAll(probeStates *[]ScannedResult, l *log.Logger, q *QueryParams) err
body, err := json.MarshalIndent(data, "", " ")
if err != nil {
l.Log.Errorf("could not marshal JSON: %v", err)
l.Log.Errorf("failed to marshal JSON: %v", err)
}
if q.Verbose {
@ -179,7 +166,7 @@ func CollectAll(probeStates *[]ScannedResult, l *log.Logger, q *QueryParams) err
if outputPath != "" {
err = os.WriteFile(path.Clean(outputPath+"/"+q.Host+".json"), body, os.ModePerm)
if err != nil {
l.Log.Errorf("could not write data to file: %v", err)
l.Log.Errorf("failed to write data to file: %v", err)
}
}
@ -232,15 +219,13 @@ func CollectAll(probeStates *[]ScannedResult, l *log.Logger, q *QueryParams) err
}
func CollectMetadata(client *bmclib.Client, q *QueryParams) ([]byte, error) {
// client, err := NewClient(l, q)
// open BMC session and update driver registry
ctx, ctxCancel := context.WithTimeout(context.Background(), time.Second*time.Duration(q.Timeout))
client.Registry.FilterForCompatible(ctx)
err := client.Open(ctx)
if err != nil {
ctxCancel()
return nil, fmt.Errorf("could not connect to bmc: %v", err)
return nil, fmt.Errorf("failed to connect to bmc: %v", err)
}
defer client.Close(ctx)
@ -248,14 +233,14 @@ func CollectMetadata(client *bmclib.Client, q *QueryParams) ([]byte, error) {
metadata := client.GetMetadata()
if err != nil {
ctxCancel()
return nil, fmt.Errorf("could not get metadata: %v", err)
return nil, fmt.Errorf("failed to get metadata: %v", err)
}
// retrieve inventory data
b, err := json.MarshalIndent(metadata, "", " ")
if err != nil {
ctxCancel()
return nil, fmt.Errorf("could not marshal JSON: %v", err)
return nil, fmt.Errorf("failed to marshal JSON: %v", err)
}
ctxCancel()
@ -269,13 +254,13 @@ func CollectInventory(client *bmclib.Client, q *QueryParams) ([]byte, error) {
err := client.PreferProvider(q.Preferred).Open(ctx)
if err != nil {
ctxCancel()
return nil, fmt.Errorf("could not open client: %v", err)
return nil, fmt.Errorf("failed to open client: %v", err)
}
inventory, err := client.Inventory(ctx)
if err != nil {
ctxCancel()
return nil, fmt.Errorf("could not get inventory: %v", err)
return nil, fmt.Errorf("failed to get inventory: %v", err)
}
// retrieve inventory data
@ -283,7 +268,7 @@ func CollectInventory(client *bmclib.Client, q *QueryParams) ([]byte, error) {
b, err := json.MarshalIndent(data, "", " ")
if err != nil {
ctxCancel()
return nil, fmt.Errorf("could not marshal JSON: %v", err)
return nil, fmt.Errorf("failed to marshal JSON: %v", err)
}
ctxCancel()
@ -296,13 +281,13 @@ func CollectPowerState(client *bmclib.Client, q *QueryParams) ([]byte, error) {
err := client.PreferProvider(q.Preferred).Open(ctx)
if err != nil {
ctxCancel()
return nil, fmt.Errorf("could not open client: %v", err)
return nil, fmt.Errorf("failed to open client: %v", err)
}
powerState, err := client.GetPowerState(ctx)
if err != nil {
ctxCancel()
return nil, fmt.Errorf("could not get inventory: %v", err)
return nil, fmt.Errorf("failed to get inventory: %v", err)
}
// retrieve inventory data
@ -310,7 +295,7 @@ func CollectPowerState(client *bmclib.Client, q *QueryParams) ([]byte, error) {
b, err := json.MarshalIndent(data, "", " ")
if err != nil {
ctxCancel()
return nil, fmt.Errorf("could not marshal JSON: %v", err)
return nil, fmt.Errorf("failed to marshal JSON: %v", err)
}
ctxCancel()
@ -325,7 +310,7 @@ func CollectUsers(client *bmclib.Client, q *QueryParams) ([]byte, error) {
err := client.Open(ctx)
if err != nil {
ctxCancel()
return nil, fmt.Errorf("could not connect to bmc: %v", err)
return nil, fmt.Errorf("failed to connect to bmc: %v", err)
}
defer client.Close(ctx)
@ -333,7 +318,7 @@ func CollectUsers(client *bmclib.Client, q *QueryParams) ([]byte, error) {
users, err := client.ReadUsers(ctx)
if err != nil {
ctxCancel()
return nil, fmt.Errorf("could not get users: %v", err)
return nil, fmt.Errorf("failed to get users: %v", err)
}
// retrieve inventory data
@ -341,7 +326,7 @@ func CollectUsers(client *bmclib.Client, q *QueryParams) ([]byte, error) {
b, err := json.MarshalIndent(data, "", " ")
if err != nil {
ctxCancel()
return nil, fmt.Errorf("could not marshal JSON: %v", err)
return nil, fmt.Errorf("failed to marshal JSON: %v", err)
}
ctxCancel()
@ -351,7 +336,7 @@ func CollectUsers(client *bmclib.Client, q *QueryParams) ([]byte, error) {
func CollectBios(client *bmclib.Client, q *QueryParams) ([]byte, error) {
// client, err := NewClient(l, q)
// if err != nil {
// return nil, fmt.Errorf("could not make query: %v", err)
// return nil, fmt.Errorf("failed to make query: %v", err)
// }
b, err := makeRequest(client, client.GetBiosConfiguration, q.Timeout)
return b, err
@ -360,7 +345,7 @@ func CollectBios(client *bmclib.Client, q *QueryParams) ([]byte, error) {
func CollectEthernetInterfaces(c *gofish.APIClient, q *QueryParams, systemID string) ([]byte, error) {
systems, err := c.Service.Systems()
if err != nil {
return nil, fmt.Errorf("could not query storage systems (%v:%v): %v", q.Host, q.Port, err)
return nil, fmt.Errorf("failed to query storage systems (%v:%v): %v", q.Host, q.Port, err)
}
var interfaces []*redfish.EthernetInterface
@ -373,13 +358,13 @@ func CollectEthernetInterfaces(c *gofish.APIClient, q *QueryParams, systemID str
}
if len(interfaces) <= 0 {
return nil, fmt.Errorf("could not get ethernet interfaces: %v", err)
return nil, fmt.Errorf("failed to get ethernet interfaces: %v", err)
}
data := map[string]any{"EthernetInterfaces": interfaces}
b, err := json.MarshalIndent(data, "", " ")
if err != nil {
return nil, fmt.Errorf("could not marshal JSON: %v", err)
return nil, fmt.Errorf("failed to marshal JSON: %v", err)
}
return b, nil
@ -388,13 +373,13 @@ func CollectEthernetInterfaces(c *gofish.APIClient, q *QueryParams, systemID str
func CollectChassis(c *gofish.APIClient, q *QueryParams) ([]byte, error) {
chassis, err := c.Service.Chassis()
if err != nil {
return nil, fmt.Errorf("could not query chassis (%v:%v): %v", q.Host, q.Port, err)
return nil, fmt.Errorf("failed to query chassis (%v:%v): %v", q.Host, q.Port, err)
}
data := map[string]any{"Chassis": chassis}
b, err := json.MarshalIndent(data, "", " ")
if err != nil {
return nil, fmt.Errorf("could not marshal JSON: %v", err)
return nil, fmt.Errorf("failed to marshal JSON: %v", err)
}
return b, nil
@ -403,12 +388,12 @@ func CollectChassis(c *gofish.APIClient, q *QueryParams) ([]byte, error) {
func CollectStorage(c *gofish.APIClient, q *QueryParams) ([]byte, error) {
systems, err := c.Service.StorageSystems()
if err != nil {
return nil, fmt.Errorf("could not query storage systems (%v:%v): %v", q.Host, q.Port, err)
return nil, fmt.Errorf("failed to query storage systems (%v:%v): %v", q.Host, q.Port, err)
}
services, err := c.Service.StorageServices()
if err != nil {
return nil, fmt.Errorf("could not query storage services (%v:%v): %v", q.Host, q.Port, err)
return nil, fmt.Errorf("failed to query storage services (%v:%v): %v", q.Host, q.Port, err)
}
data := map[string]any{
@ -419,7 +404,7 @@ func CollectStorage(c *gofish.APIClient, q *QueryParams) ([]byte, error) {
}
b, err := json.MarshalIndent(data, "", " ")
if err != nil {
return nil, fmt.Errorf("could not marshal JSON: %v", err)
return nil, fmt.Errorf("failed to marshal JSON: %v", err)
}
return b, nil
@ -428,7 +413,7 @@ func CollectStorage(c *gofish.APIClient, q *QueryParams) ([]byte, error) {
func CollectSystems(c *gofish.APIClient, q *QueryParams) ([]byte, error) {
systems, err := c.Service.Systems()
if err != nil {
return nil, fmt.Errorf("could not query systems (%v:%v): %v", q.Host, q.Port, err)
return nil, fmt.Errorf("failed to query systems (%v:%v): %v", q.Host, q.Port, err)
}
// query the system's ethernet interfaces
@ -449,7 +434,7 @@ func CollectSystems(c *gofish.APIClient, q *QueryParams) ([]byte, error) {
data := map[string]any{"Systems": temp}
b, err := json.MarshalIndent(data, "", " ")
if err != nil {
return nil, fmt.Errorf("could not marshal JSON: %v", err)
return nil, fmt.Errorf("failed to marshal JSON: %v", err)
}
return b, nil
@ -458,13 +443,13 @@ func CollectSystems(c *gofish.APIClient, q *QueryParams) ([]byte, error) {
func CollectRegisteries(c *gofish.APIClient, q *QueryParams) ([]byte, error) {
registries, err := c.Service.Registries()
if err != nil {
return nil, fmt.Errorf("could not query storage systems (%v:%v): %v", q.Host, q.Port, err)
return nil, fmt.Errorf("failed to query storage systems (%v:%v): %v", q.Host, q.Port, err)
}
data := map[string]any{"Registries": registries}
b, err := json.MarshalIndent(data, "", " ")
if err != nil {
return nil, fmt.Errorf("could not marshal JSON: %v", err)
return nil, fmt.Errorf("failed to marshal JSON: %v", err)
}
return b, nil
@ -504,7 +489,7 @@ func CollectProcessors(q *QueryParams) ([]byte, error) {
data := map[string]any{"Processors": procs}
b, err := json.MarshalIndent(data, "", " ")
if err != nil {
return nil, fmt.Errorf("could not marshal JSON: %v", err)
return nil, fmt.Errorf("failed to marshal JSON: %v", err)
}
return b, nil
@ -517,7 +502,7 @@ func connectGofish(q *QueryParams) (*gofish.APIClient, error) {
}
c, err := gofish.Connect(config)
if err != nil {
return nil, fmt.Errorf("could not connect to redfish endpoint: %v", err)
return nil, fmt.Errorf("failed to connect to redfish endpoint: %v", err)
}
if c != nil {
c.Service.ProtocolFeaturesSupported = gofish.ProtocolFeaturesSupported{
@ -532,24 +517,22 @@ func connectGofish(q *QueryParams) (*gofish.APIClient, error) {
func makeGofishConfig(q *QueryParams) (gofish.ClientConfig, error) {
var (
client = &http.Client{}
client = &http.Client{
Transport: &http.Transport{
TLSClientConfig: &tls.Config{
InsecureSkipVerify: true,
},
DisableKeepAlives: true,
Dial: (&net.Dialer{
Timeout: 120 * time.Second,
KeepAlive: 120 * time.Second,
}).Dial,
TLSHandshakeTimeout: 120 * time.Second,
ResponseHeaderTimeout: 120 * time.Second,
},
}
url = baseRedfishUrl(q)
)
// NOTE: CA certs are not used for BMCs as far as I know
// if q.CaCertPath != "" {
// cacert, err := os.ReadFile(q.CaCertPath)
// if err != nil {
// return config, fmt.Errorf("failed to read CA cert file: %v", err)
// }
// certPool := x509.NewCertPool()
// certPool.AppendCertsFromPEM(cacert)
// client.Transport = &http.Transport{
// TLSClientConfig: &tls.Config{
// RootCAs: certPool,
// InsecureSkipVerify: false,
// },
// }
// }
return gofish.ClientConfig{
Endpoint: url,
Username: q.User,
@ -567,7 +550,7 @@ func makeRequest[T any](client *bmclib.Client, fn func(context.Context) (T, erro
err := client.Open(ctx)
if err != nil {
ctxCancel()
return nil, fmt.Errorf("could not open client: %v", err)
return nil, fmt.Errorf("failed to open client: %v", err)
}
defer client.Close(ctx)
@ -575,7 +558,7 @@ func makeRequest[T any](client *bmclib.Client, fn func(context.Context) (T, erro
response, err := fn(ctx)
if err != nil {
ctxCancel()
return nil, fmt.Errorf("could not get response: %v", err)
return nil, fmt.Errorf("failed to get response: %v", err)
}
ctxCancel()
@ -585,7 +568,7 @@ func makeRequest[T any](client *bmclib.Client, fn func(context.Context) (T, erro
func makeJson(object any) ([]byte, error) {
b, err := json.MarshalIndent(object, "", " ")
if err != nil {
return nil, fmt.Errorf("could not marshal JSON: %v", err)
return nil, fmt.Errorf("failed to marshal JSON: %v", err)
}
return []byte(b), nil
}