19075895534

Committed 04 Nov 2025 04:36PM UTC coverage: 76.775% (-0.5%) from 77.239%

Build # 19075895534

Build Type

Pull #3835

github

Committed by

web-flow

Commit Message

Merge 7ff4689c0 into f64d16a69

Pull Request Pull Request #3835: [WIP] Add Cluster Memory Load Perses dashboard

Run Details

0 of 62 new or added lines in 2 files covered. (0.0%)

7917 of 10312 relevant lines covered (76.77%)

1.84 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/controllers/observability/perses.go

package observability

import (
        "context"
        "encoding/json"
        "fmt"
        "io/fs"
        "os"
        "path/filepath"

        "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
        "k8s.io/apimachinery/pkg/runtime/schema"
        "sigs.k8s.io/controller-runtime/pkg/client"
        "sigs.k8s.io/yaml"
)

// persesAssetsDir is the directory (inside the repo image) containing Perses CR manifests (yaml).
// Each YAML should define a single resource: PersesDashboard or PersesDatasource.
const persesAssetsDir = "assets/dashboards/perses"

// ReconcilePersesResources applies all Perses resources shipped with the operator under assets/perses.
// It uses server-side apply to create/update resources idempotently without relying on cache reads.
func (r *Reconciler) ReconcilePersesResources(ctx context.Context) error {
        wd, err := os.Getwd()
        if err != nil {
                return fmt.Errorf("failed to get working dir: %w", err)
        }

        d := os.DirFS(wd)
        // If the directory does not exist, nothing to do.
        if _, err := fs.Stat(d, persesAssetsDir); err != nil {
                return nil
        }

        return fs.WalkDir(d, persesAssetsDir, func(path string, entry fs.DirEntry, err error) error {
                if err != nil {
                        return err
                }
                if entry.IsDir() {
                        return nil
                }
                if ext := filepath.Ext(entry.Name()); ext != ".yml" && ext != ".yaml" {
                        return nil
                }

                file, err := d.Open(path)
                if err != nil {
                        return fmt.Errorf("failed to open %s: %w", path, err)
                }
                defer file.Close()

                content, err := fs.ReadFile(d, path)
                if err != nil {
                        return fmt.Errorf("failed to read %s: %w", path, err)
                }

                // Decode YAML → JSON → map
                jsonBytes, err := yaml.YAMLToJSON(content)
                if err != nil {
                        return fmt.Errorf("failed to convert yaml to json for %s: %w", path, err)
                }

                var objMap map[string]any
                if err := json.Unmarshal(jsonBytes, &objMap); err != nil {
                        return fmt.Errorf("failed to unmarshal json for %s: %w", path, err)
                }

                // Enforce namespace to operator's namespace to ensure ownership & GC
                // If the manifest specifies a namespace, it will be overridden.
                // We only support namespaced resources here.
                metadata, _ := objMap["metadata"].(map[string]any)
                if metadata == nil {
                        metadata = map[string]any{}
                        objMap["metadata"] = metadata
                }
                metadata["namespace"] = r.namespace

                // Build Unstructured with GVK populated
                apiVersion, _ := objMap["apiVersion"].(string)
                kind, _ := objMap["kind"].(string)
                if apiVersion == "" || kind == "" {
                        return fmt.Errorf("missing apiVersion/kind in %s", path)
                }

                u := &unstructured.Unstructured{Object: objMap}
                u.SetGroupVersionKind(schema.FromAPIVersionAndKind(apiVersion, kind))

                // Apply with SSA so we don't need to read existing objects
                if err := r.Patch(ctx, u, client.Apply, client.FieldOwner("hyperconverged-operator"), client.ForceOwnership); err != nil {
                        return fmt.Errorf("failed to apply %s: %w", path, err)
                }

                return nil
        })
}

1	package observability
2
3	import (
4	"context"
5	"encoding/json"
6	"fmt"
7	"io/fs"
8	"os"
9	"path/filepath"
10
11	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
12	"k8s.io/apimachinery/pkg/runtime/schema"
13	"sigs.k8s.io/controller-runtime/pkg/client"
14	"sigs.k8s.io/yaml"
15	)
16
17	// persesAssetsDir is the directory (inside the repo image) containing Perses CR manifests (yaml).
18	// Each YAML should define a single resource: PersesDashboard or PersesDatasource.
19	const persesAssetsDir = "assets/dashboards/perses"
20
21	// ReconcilePersesResources applies all Perses resources shipped with the operator under assets/perses.
22	// It uses server-side apply to create/update resources idempotently without relying on cache reads.
NEW 23	func (r *Reconciler) ReconcilePersesResources(ctx context.Context) error {	×
NEW 24	wd, err := os.Getwd()	×
NEW 25	if err != nil {	×
NEW 26	return fmt.Errorf("failed to get working dir: %w", err)	×
NEW 27	}	×
28
NEW 29	d := os.DirFS(wd)	×
NEW 30	// If the directory does not exist, nothing to do.	×
NEW 31	if _, err := fs.Stat(d, persesAssetsDir); err != nil {	×
NEW 32	return nil	×
NEW 33	}	×
34
NEW 35	return fs.WalkDir(d, persesAssetsDir, func(path string, entry fs.DirEntry, err error) error {	×
NEW 36	if err != nil {	×
NEW 37	return err	×
NEW 38	}	×
NEW 39	if entry.IsDir() {	×
NEW 40	return nil	×
NEW 41	}	×
NEW 42	if ext := filepath.Ext(entry.Name()); ext != ".yml" && ext != ".yaml" {	×
NEW 43	return nil	×
NEW 44	}	×
45
NEW 46	file, err := d.Open(path)	×
NEW 47	if err != nil {	×
NEW 48	return fmt.Errorf("failed to open %s: %w", path, err)	×
NEW 49	}	×
NEW 50	defer file.Close()	×
NEW 51		×
NEW 52	content, err := fs.ReadFile(d, path)	×
NEW 53	if err != nil {	×
NEW 54	return fmt.Errorf("failed to read %s: %w", path, err)	×
NEW 55	}	×
56
57	// Decode YAML → JSON → map
NEW 58	jsonBytes, err := yaml.YAMLToJSON(content)	×
NEW 59	if err != nil {	×
NEW 60	return fmt.Errorf("failed to convert yaml to json for %s: %w", path, err)	×
NEW 61	}	×
62
NEW 63	var objMap map[string]any	×
NEW 64	if err := json.Unmarshal(jsonBytes, &objMap); err != nil {	×
NEW 65	return fmt.Errorf("failed to unmarshal json for %s: %w", path, err)	×
NEW 66	}	×
67
68	// Enforce namespace to operator's namespace to ensure ownership & GC
69	// If the manifest specifies a namespace, it will be overridden.
70	// We only support namespaced resources here.
NEW 71	metadata, _ := objMap["metadata"].(map[string]any)	×
NEW 72	if metadata == nil {	×
NEW 73	metadata = map[string]any{}	×
NEW 74	objMap["metadata"] = metadata	×
NEW 75	}	×
NEW 76	metadata["namespace"] = r.namespace	×
NEW 77		×
NEW 78	// Build Unstructured with GVK populated	×
NEW 79	apiVersion, _ := objMap["apiVersion"].(string)	×
NEW 80	kind, _ := objMap["kind"].(string)	×
NEW 81	if apiVersion == "" \|\| kind == "" {	×
NEW 82	return fmt.Errorf("missing apiVersion/kind in %s", path)	×
NEW 83	}	×
84
NEW 85	u := &unstructured.Unstructured{Object: objMap}	×
NEW 86	u.SetGroupVersionKind(schema.FromAPIVersionAndKind(apiVersion, kind))	×
NEW 87		×
NEW 88	// Apply with SSA so we don't need to read existing objects	×
NEW 89	if err := r.Patch(ctx, u, client.Apply, client.FieldOwner("hyperconverged-operator"), client.ForceOwnership); err != nil {	×
NEW 90	return fmt.Errorf("failed to apply %s: %w", path, err)	×
NEW 91	}	×
92
NEW 93	return nil	×
94	})
95	}

kubevirt / hyperconverged-cluster-operator / 19075895534

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous