@opensoha/contracts 0.1.26 → 0.1.29

package/resource/runtime/resource_graph_storage.go

@@ -0,0 +1,144 @@
+package runtime
+
+import (
+	cr "github.com/opensoha/soha-contracts/resource"
+	corev1 "k8s.io/api/core/v1"
+	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
+)
+
+const (
+	ResourceGraphRelationMounts           = "mounts"
+	ResourceGraphRelationBindsTo          = "binds-to"
+	ResourceGraphRelationUsesStorageClass = "uses-storage-class"
+)
+
+func graphStorageRootKind(kind string) bool {
+	switch kind {
+	case "PersistentVolumeClaim", "PersistentVolume", "StorageClass":
+		return true
+	}
+	return false
+}
+
+func graphStorageClassName(o *unstructured.Unstructured) string {
+	name, _, _ := unstructured.NestedString(o.Object, "spec", "storageClassName")
+	return name
+}
+
+func graphClaimVolumeName(claim *unstructured.Unstructured) string {
+	name, _, _ := unstructured.NestedString(claim.Object, "spec", "volumeName")
+	return name
+}
+
+func graphVolumeClaimName(volume map[string]interface{}) string {
+	return graphString(graphMap(volume, "persistentVolumeClaim"), "claimName")
+}
+
+func graphVolumeClaimRef(volume *unstructured.Unstructured) (graphNamespacedName, string) {
+	ref, _, _ := graphNestedMap(volume.Object, "spec", "claimRef")
+	if api := graphString(ref, "apiVersion"); api != "" && api != "v1" {
+		return graphNamespacedName{}, ""
+	}
+	if kind := graphString(ref, "kind"); kind != "" && kind != "PersistentVolumeClaim" {
+		return graphNamespacedName{}, ""
+	}
+	return graphNamespacedName{namespace: graphString(ref, "namespace"), name: graphString(ref, "name")}, graphString(ref, "uid")
+}
+
+func graphStorageBound(claim, volume *unstructured.Unstructured) bool {
+	if claim == nil || volume == nil || claim.GetDeletionTimestamp() != nil || volume.GetDeletionTimestamp() != nil {
+		return false
+	}
+	if graphStatus(claim) != string(corev1.ClaimBound) || graphStatus(volume) != string(corev1.VolumeBound) {
+		return false
+	}
+	ref, uid := graphVolumeClaimRef(volume)
+	return ref.namespace != "" && ref.name != "" && uid != "" && uid == string(claim.GetUID()) &&
+		ref.namespace == claim.GetNamespace() && ref.name == claim.GetName() && graphClaimVolumeName(claim) == volume.GetName()
+}
+
+func (b *graphRules) storageRelations(o *unstructured.Unstructured, id string) {
+	if !graphBuiltinSpec(o) {
+		return
+	}
+	switch o.GetKind() {
+	case "Pod":
+		for _, raw := range graphSlice(graphPodSpec(o), "volumes") {
+			if !b.active() {
+				return
+			}
+			volume, _ := raw.(map[string]interface{})
+			b.storageMountEdge(id, o.GetNamespace(), graphVolumeClaimName(volume))
+		}
+		return
+	case "PersistentVolumeClaim":
+		if o.GetNamespace() == "" {
+			return
+		}
+		if volumeName := graphClaimVolumeName(o); volumeName != "" {
+			volume := b.objects[graphIdentity("v1", "PersistentVolume", "", volumeName)]
+			edge := cr.ResourceGraphEdge{SourceID: id, Relation: ResourceGraphRelationBindsTo, FieldPath: "spec.volumeName"}
+			if graphStorageBound(o, volume) {
+				edge.TargetID = b.node(b.ref(volume), graphStatus(volume))
+				edge.ResolutionState = "resolved"
+				edge.Note = "PVC and PV report Bound with matching references"
+			} else {
+				edge.TargetID = b.unresolvedStorageNode("PersistentVolume", "", volumeName, "")
+				edge.ResolutionState = "unresolved"
+				edge.Note = "PVC volume reference requires binding confirmation"
+			}
+			b.addEdge(edge)
+		}
+	case "PersistentVolume":
+		if o.GetNamespace() != "" {
+			return
+		}
+		ref, uid := graphVolumeClaimRef(o)
+		if ref.namespace != "" && ref.name != "" {
+			claim := b.objects[graphIdentity("v1", "PersistentVolumeClaim", ref.namespace, ref.name)]
+			if !graphStorageBound(claim, o) {
+				declaration := b.ref(o)
+				b.addEdge(cr.ResourceGraphEdge{
+					SourceID: b.unresolvedStorageNode("PersistentVolumeClaim", ref.namespace, ref.name, uid),
+					TargetID: id, Relation: ResourceGraphRelationBindsTo, ResolutionState: "unresolved",
+					FieldPath: "spec.claimRef", Note: "PV claim reference requires binding confirmation", SourceRef: &declaration,
+				})
+			}
+		}
+	default:
+		return
+	}
+	b.storageReferenceEdge(id, "storage.k8s.io/v1", "StorageClass", "", graphStorageClassName(o),
+		ResourceGraphRelationUsesStorageClass, "spec.storageClassName", "StorageClass reference declared in spec")
+}
+
+func (b *graphRules) storageMountEdge(source, namespace, claim string) {
+	if namespace != "" {
+		b.storageReferenceEdge(source, "v1", "PersistentVolumeClaim", namespace, claim,
+			ResourceGraphRelationMounts, "spec.volumes", "PVC reference declared in Pod spec")
+	}
+}
+
+func (b *graphRules) unresolvedStorageNode(kind, namespace, name, uid string) string {
+	ref := cr.ResourceRef{ClusterID: b.cluster, APIVersion: "v1", Kind: kind, Namespace: namespace, Name: name, UID: uid, ScopeMode: topologyScope(namespace != "")}
+	id := graphNodeID(ref)
+	if observed := b.objects[graphIdentity(ref.APIVersion, kind, namespace, name)]; observed != nil && graphNodeID(b.ref(observed)) == id {
+		// A one-sided declaration can name an observed object without binding it.
+		id += ":unresolved"
+	}
+	return b.addNode(id, ref, "unresolved")
+}
+
+func (b *graphRules) storageReferenceEdge(source, api, kind, namespace, name, relation, fieldPath, note string) {
+	if name == "" {
+		return
+	}
+	state := "unresolved"
+	if b.objects[graphIdentity(api, kind, namespace, name)] != nil {
+		state = "resolved"
+	}
+	b.addEdge(cr.ResourceGraphEdge{
+		SourceID: source, TargetID: b.target(api, kind, namespace, name, ""), Relation: relation,
+		ResolutionState: state, FieldPath: fieldPath, Note: note,
+	})
+}

package/resource/runtime/resource_graph_storage_collect.go

@@ -0,0 +1,163 @@
+package runtime
+
+import (
+	"context"
+	"errors"
+
+	corev1 "k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
+	kruntime "k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/client-go/kubernetes"
+)
+
+func graphStorageProjection(obj kruntime.Object, projected *unstructured.Unstructured) error {
+	kind := projected.GetKind()
+	_, metadataOnly := obj.(*metav1.PartialObjectMetadata)
+	if gvk := obj.GetObjectKind().GroupVersionKind(); !metadataOnly && !gvk.Empty() && gvk != schema.FromAPIVersionAndKind(projected.GetAPIVersion(), kind) {
+		return errors.New("storage relationship observation GVK mismatch")
+	}
+	if projected.GetName() == "" || (kind == "PersistentVolumeClaim") != (projected.GetNamespace() != "") {
+		return errors.New("storage relationship observation scope mismatch")
+	}
+	switch item := obj.(type) {
+	case *corev1.PersistentVolumeClaim:
+		spec := map[string]interface{}{"volumeName": item.Spec.VolumeName}
+		if item.Spec.StorageClassName != nil {
+			spec["storageClassName"] = *item.Spec.StorageClassName
+		}
+		projected.Object["spec"] = spec
+		projected.Object["status"] = map[string]interface{}{"phase": string(item.Status.Phase)}
+		if item.DeletionTimestamp != nil {
+			projected.SetDeletionTimestamp(item.DeletionTimestamp)
+		}
+	case *corev1.PersistentVolume:
+		spec := map[string]interface{}{"storageClassName": item.Spec.StorageClassName}
+		if ref := item.Spec.ClaimRef; ref != nil {
+			spec["claimRef"] = map[string]interface{}{"apiVersion": ref.APIVersion, "kind": ref.Kind, "namespace": ref.Namespace, "name": ref.Name, "uid": string(ref.UID)}
+		}
+		projected.Object["spec"] = spec
+		projected.Object["status"] = map[string]interface{}{"phase": string(item.Status.Phase)}
+		if item.DeletionTimestamp != nil {
+			projected.SetDeletionTimestamp(item.DeletionTimestamp)
+		}
+	}
+	return nil
+}
+
+func collectGraphStorage(ctx context.Context, client kubernetes.Interface, sources map[string]graphSourceDefinition, root *unstructured.Unstructured, objects *[]*unstructured.Unstructured, warnings *[]string) error {
+	var claim, volume *unstructured.Unstructured
+	var err error
+	switch root.GetKind() {
+	case "PersistentVolumeClaim":
+		claim = root
+		volume, err = collectGraphStorageTarget(ctx, "PersistentVolume", "", graphClaimVolumeName(claim), client.CoreV1().PersistentVolumes().Get, objects, warnings)
+	case "PersistentVolume":
+		volume = root
+		ref, _ := graphVolumeClaimRef(volume)
+		if ref.namespace != "" {
+			claim, err = collectGraphStorageTarget(ctx, "PersistentVolumeClaim", ref.namespace, ref.name, client.CoreV1().PersistentVolumeClaims(ref.namespace).Get, objects, warnings)
+		}
+	case "StorageClass":
+		return collectGraphStorageClassSources(ctx, client, sources, root.GetName(), objects, warnings)
+	default:
+		return nil
+	}
+	if err != nil {
+		return err
+	}
+	class := graphStorageClassName(root)
+	getClass := client.StorageV1().StorageClasses().Get
+	if _, err = collectGraphStorageTarget(ctx, "StorageClass", "", class, getClass, objects, warnings); err != nil {
+		return err
+	}
+	bound := graphStorageBound(claim, volume)
+	if bound && root == claim && graphStorageClassName(volume) != class {
+		if _, err = collectGraphStorageTarget(ctx, "StorageClass", "", graphStorageClassName(volume), getClass, objects, warnings); err != nil {
+			return err
+		}
+	}
+	if root != claim && !bound {
+		return ctx.Err()
+	}
+	ref := graphNamespacedName{namespace: claim.GetNamespace(), name: claim.GetName()}
+	return collectGraphStoragePods(ctx, client, ref.namespace, map[graphNamespacedName]bool{ref: true}, objects, warnings)
+}
+
+func collectGraphStorageTarget[T kruntime.Object](ctx context.Context, kind, namespace, name string, get func(context.Context, string, metav1.GetOptions) (T, error), objects *[]*unstructured.Unstructured, warnings *[]string) (*unstructured.Unstructured, error) {
+	if err := ctx.Err(); err != nil || name == "" {
+		return nil, err
+	}
+	item, err := get(ctx, name, metav1.GetOptions{})
+	if err != nil {
+		if errors.Is(err, context.Canceled) || errors.Is(err, context.DeadlineExceeded) {
+			return nil, err
+		}
+		*warnings = append(*warnings, kind+" reference source "+graphSourceErrorClass(err))
+		return nil, ctx.Err()
+	}
+	projected, err := graphObjectProjection(item, graphBuiltinAPIs[kind], kind)
+	if err != nil || projected.GetName() != name || projected.GetNamespace() != namespace {
+		*warnings = append(*warnings, kind+" reference source projection unavailable")
+		return nil, ctx.Err()
+	}
+	*objects = append(*objects, projected)
+	return projected, ctx.Err()
+}
+
+func collectGraphStorageClassSources(ctx context.Context, client kubernetes.Interface, sources map[string]graphSourceDefinition, name string, objects *[]*unstructured.Unstructured, warnings *[]string) error {
+	volumesStart := len(*objects)
+	if err := sources["PersistentVolume"].collect(ctx, objects, warnings); err != nil {
+		return err
+	}
+	classVolumes := map[string]*unstructured.Unstructured{}
+	for _, volume := range (*objects)[volumesStart:] {
+		if graphStorageClassName(volume) == name && classVolumes[volume.GetName()] == nil {
+			classVolumes[volume.GetName()] = volume
+		}
+	}
+	claimsStart := len(*objects)
+	if err := sources["PersistentVolumeClaim"].collect(ctx, objects, warnings); err != nil {
+		return err
+	}
+	claims := map[graphNamespacedName]bool{}
+	for _, claim := range (*objects)[claimsStart:] {
+		if graphStorageClassName(claim) == name || graphStorageBound(claim, classVolumes[graphClaimVolumeName(claim)]) {
+			claims[graphNamespacedName{namespace: claim.GetNamespace(), name: claim.GetName()}] = true
+		}
+	}
+	if len(claims) == 0 {
+		return ctx.Err()
+	}
+	return collectGraphStoragePods(ctx, client, "", claims, objects, warnings)
+}
+
+func collectGraphStoragePods(ctx context.Context, client kubernetes.Interface, namespace string, claims map[graphNamespacedName]bool, objects *[]*unstructured.Unstructured, warnings *[]string) error {
+	project := func(obj kruntime.Object) (*unstructured.Unstructured, error) {
+		pod, ok := obj.(*corev1.Pod)
+		if !ok || pod.Namespace == "" || (namespace != "" && pod.Namespace != namespace) {
+			return nil, errors.New("storage relationship Pod scope mismatch")
+		}
+		volumes := []interface{}{}
+		for _, volume := range pod.Spec.Volumes {
+			if err := ctx.Err(); err != nil {
+				return nil, err
+			}
+			if claim := volume.PersistentVolumeClaim; claim != nil && claims[graphNamespacedName{namespace: pod.Namespace, name: claim.ClaimName}] {
+				volumes = append(volumes, map[string]interface{}{"persistentVolumeClaim": map[string]interface{}{"claimName": claim.ClaimName}})
+			}
+		}
+		if len(volumes) == 0 {
+			return nil, nil
+		}
+		projected, err := graphObjectMetadataProjection(pod, "v1", "Pod", false)
+		if err != nil {
+			return nil, err
+		}
+		projected.Object["spec"] = map[string]interface{}{"volumes": volumes}
+		projected.Object["status"] = map[string]interface{}{"phase": string(pod.Status.Phase)}
+		return projected, nil
+	}
+	return collectGraphSource(ctx, client.CoreV1().Pods(namespace).List, "Pod", project, objects, warnings)
+}