k8sgpt/pkg/analyzer/pvc/pvcAnalyzer.go

package pvc

import (
	"fmt"
	"github.com/k8sgpt-ai/k8sgpt/pkg/analyzer/common"

	"github.com/k8sgpt-ai/k8sgpt/pkg/util"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
)

type PvcAnalyzer struct {
	common.Analyzer
}

func (a *PvcAnalyzer) Analyze() error {
	// search all namespaces for pods that are not running
	list, err := a.Client.GetClient().CoreV1().PersistentVolumeClaims(a.Namespace).List(a.Context, metav1.ListOptions{})
	if err != nil {
		return err
	}

	var preAnalysis = map[string]common.PreAnalysis{}

	for _, pvc := range list.Items {
		var failures []string

		// Check for empty rs
		if pvc.Status.Phase == "Pending" {

			// parse the event log and append details
			evt, err := common.FetchLatestPvcEvent(a.Context, a.Client, &pvc)
			if err != nil || evt == nil {
				continue
			}
			if evt.Reason == "ProvisioningFailed" && evt.Message != "" {
				failures = append(failures, evt.Message)
			}
		}
		if len(failures) > 0 {
			preAnalysis[fmt.Sprintf("%s/%s", pvc.Namespace, pvc.Name)] = common.PreAnalysis{
				PersistentVolumeClaim: pvc,
				FailureDetails:        failures,
			}
		}
	}

	for key, value := range preAnalysis {
		var currentAnalysis = common.Result{
			Kind:  "PersistentVolumeClaim",
			Name:  key,
			Error: value.FailureDetails,
		}

		parent, _ := util.GetParent(a.Client, value.PersistentVolumeClaim.ObjectMeta)
		currentAnalysis.ParentObject = parent
		a.Result = append(a.Result, currentAnalysis)
	}
	return nil
}

func (a *PvcAnalyzer) GetResult() []common.Result {
	return a.Result
}