fix: have most of the structs

Author: Arta Asadi

discovery/describers/kubernetes.go

@@ -0,0 +1,71 @@
+package helpers
+
+import (
+	rbacv1 "k8s.io/api/rbac/v1"
+)
+
+// --- ClusterRole ---
+type ClusterRole struct {
+	TypeMeta
+	ObjectMeta
+	Rules           []PolicyRule
+	AggregationRule *AggregationRule
+}
+
+// ConvertClusterRole creates a helper ClusterRole from a rbacv1 ClusterRole
+func ConvertClusterRole(cr *rbacv1.ClusterRole) ClusterRole {
+	return ClusterRole{
+		TypeMeta:        ConvertTypeMeta(cr.TypeMeta),
+		ObjectMeta:      ConvertObjectMeta(&cr.ObjectMeta),
+		Rules:           ConvertPolicyRules(cr.Rules),
+		AggregationRule: ConvertAggregationRule(cr.AggregationRule),
+	}
+}
+
+// --- PolicyRule ---
+type PolicyRule struct {
+	Verbs           []string
+	APIGroups       []string
+	Resources       []string
+	ResourceNames   []string
+	NonResourceURLs []string
+}
+
+func ConvertPolicyRules(policyRules []rbacv1.PolicyRule) []PolicyRule {
+	if policyRules == nil {
+		return nil
+	}
+	rules := make([]PolicyRule, len(policyRules))
+	for i, policyRule := range policyRules {
+		rules[i] = PolicyRule{
+			Verbs:           policyRule.Verbs,
+			APIGroups:       policyRule.APIGroups,
+			Resources:       policyRule.Resources,
+			ResourceNames:   policyRule.ResourceNames,
+			NonResourceURLs: policyRule.NonResourceURLs,
+		}
+	}
+	return rules
+}
+
+// --- AggregationRule ---
+type AggregationRule struct {
+	ClusterRoleSelectors []LabelSelector // Assumes LabelSelector in model_helpers.go
+}
+
+func ConvertAggregationRule(aggregationRule *rbacv1.AggregationRule) *AggregationRule {
+	if aggregationRule == nil {
+		return nil
+	}
+	selectors := make([]LabelSelector, 0, len(aggregationRule.ClusterRoleSelectors))
+	for _, sel := range aggregationRule.ClusterRoleSelectors {
+		// Assuming ConvertLabelSelector exists in model_helpers.go
+		convertedSel := ConvertLabelSelector(&sel)
+		if convertedSel != nil {
+			selectors = append(selectors, *convertedSel)
+		}
+	}
+	return &AggregationRule{
+		ClusterRoleSelectors: selectors,
+	}
+}

discovery/provider/helpers/cluster_role.go

@@ -0,0 +1,69 @@
+package helpers
+
+import (
+	rbacv1 "k8s.io/api/rbac/v1"
+)
+
+// --- ClusterRoleBinding ---
+type ClusterRoleBinding struct {
+	TypeMeta
+	ObjectMeta
+	Subjects []Subject // Uses Subject from this file
+	RoleRef  RoleRef   // Uses RoleRef from this file
+}
+
+// ConvertClusterRoleBinding creates a helper ClusterRoleBinding from a rbacv1 ClusterRoleBinding
+func ConvertClusterRoleBinding(crb *rbacv1.ClusterRoleBinding) ClusterRoleBinding {
+	return ClusterRoleBinding{
+		TypeMeta:   ConvertTypeMeta(crb.TypeMeta),      // Assumes ConvertTypeMeta in model_helpers.go
+		ObjectMeta: ConvertObjectMeta(&crb.ObjectMeta), // Assumes ConvertObjectMeta in model_helpers.go
+		Subjects:   ConvertSubjects(crb.Subjects),      // Uses ConvertSubjects from this file
+		RoleRef:    ConvertRoleRef(crb.RoleRef),        // Uses ConvertRoleRef from this file
+	}
+}
+
+// --- Subject ---
+type Subject struct {
+	Kind      string
+	APIGroup  string
+	Name      string
+	Namespace string
+}
+
+// ConvertSubject converts a single rbacv1.Subject to a helper Subject
+func ConvertSubject(srcSubject rbacv1.Subject) Subject {
+	return Subject{
+		Kind:      srcSubject.Kind,
+		APIGroup:  srcSubject.APIGroup,
+		Name:      srcSubject.Name,
+		Namespace: srcSubject.Namespace,
+	}
+}
+
+// ConvertSubjects converts a slice of rbacv1.Subject to a slice of helper Subject
+func ConvertSubjects(srcSubjects []rbacv1.Subject) []Subject {
+	if srcSubjects == nil {
+		return nil
+	}
+	subjects := make([]Subject, len(srcSubjects))
+	for i, srcSubject := range srcSubjects {
+		subjects[i] = ConvertSubject(srcSubject)
+	}
+	return subjects
+}
+
+// --- RoleRef ---
+type RoleRef struct {
+	APIGroup string
+	Kind     string
+	Name     string
+}
+
+// ConvertRoleRef converts a rbacv1.RoleRef to a helper RoleRef
+func ConvertRoleRef(roleRef rbacv1.RoleRef) RoleRef {
+	return RoleRef{
+		APIGroup: roleRef.APIGroup,
+		Kind:     roleRef.Kind,
+		Name:     roleRef.Name,
+	}
+}

discovery/provider/helpers/cluster_role_binding.go

@@ -0,0 +1,25 @@
+package helpers
+
+import (
+	corev1 "k8s.io/api/core/v1"
+)
+
+// --- ConfigMap ---
+type ConfigMap struct {
+	TypeMeta   // Assumes TypeMeta in model_helpers.go
+	ObjectMeta // Assumes ObjectMeta in model_helpers.go
+	Immutable  *bool
+	Data       map[string]string
+	BinaryData map[string][]byte
+}
+
+// ConvertConfigMap creates a helper ConfigMap from a corev1 ConfigMap
+func ConvertConfigMap(cm *corev1.ConfigMap) ConfigMap {
+	return ConfigMap{
+		TypeMeta:   ConvertTypeMeta(cm.TypeMeta),      // Assumes ConvertTypeMeta in model_helpers.go
+		ObjectMeta: ConvertObjectMeta(&cm.ObjectMeta), // Assumes ConvertObjectMeta in model_helpers.go
+		Immutable:  cm.Immutable,
+		Data:       cm.Data,
+		BinaryData: cm.BinaryData,
+	}
+}

discovery/provider/helpers/config_map.go

@@ -0,0 +1,94 @@
+package helpers
+
+import (
+	"time"
+
+	batchv1 "k8s.io/api/batch/v1"
+	corev1 "k8s.io/api/core/v1"
+)
+
+type JobTemplateSpec struct {
+	ObjectMeta
+	Spec JobSpec
+}
+
+func ConvertJobTemplateSpec(spec batchv1.JobTemplateSpec) JobTemplateSpec {
+	return JobTemplateSpec{
+		ObjectMeta: ConvertObjectMeta(&spec.ObjectMeta),
+		Spec:       ConvertJobSpec(spec.Spec),
+	}
+}
+
+type CronJobSpec struct {
+	Schedule                   string
+	TimeZone                   *string
+	StartingDeadlineSeconds    *int64
+	ConcurrencyPolicy          string // batchv1.ConcurrencyPolicy
+	Suspend                    *bool
+	JobTemplate                JobTemplateSpec
+	SuccessfulJobsHistoryLimit *int32
+	FailedJobsHistoryLimit     *int32
+}
+
+func ConvertConcurrencyPolicy(cp batchv1.ConcurrencyPolicy) string {
+	return string(cp)
+}
+
+func ConvertCronJobSpec(spec batchv1.CronJobSpec) CronJobSpec {
+	return CronJobSpec{
+		Schedule:                   spec.Schedule,
+		TimeZone:                   spec.TimeZone,
+		StartingDeadlineSeconds:    spec.StartingDeadlineSeconds,
+		ConcurrencyPolicy:          ConvertConcurrencyPolicy(spec.ConcurrencyPolicy),
+		Suspend:                    spec.Suspend,
+		JobTemplate:                ConvertJobTemplateSpec(spec.JobTemplate),
+		SuccessfulJobsHistoryLimit: spec.SuccessfulJobsHistoryLimit,
+		FailedJobsHistoryLimit:     spec.FailedJobsHistoryLimit,
+	}
+}
+
+func ConvertObjectReferences(objReferences []corev1.ObjectReference) []ObjectReference {
+	references := make([]ObjectReference, len(objReferences))
+	for i, objReference := range objReferences {
+		references[i] = ObjectReference{
+			Kind:            objReference.Kind,
+			Namespace:       objReference.Namespace,
+			Name:            objReference.Name,
+			UID:             objReference.UID,
+			APIVersion:      objReference.APIVersion,
+			ResourceVersion: objReference.ResourceVersion,
+			FieldPath:       objReference.FieldPath,
+		}
+	}
+	return references
+}
+
+type CronJobStatus struct {
+	Active             []ObjectReference
+	LastScheduleTime   *time.Time
+	LastSuccessfulTime *time.Time
+}
+
+func ConvertCronJobStatus(status batchv1.CronJobStatus) CronJobStatus {
+	return CronJobStatus{
+		Active:             ConvertObjectReferences(status.Active),
+		LastScheduleTime:   ConvertTimePtr(status.LastScheduleTime),
+		LastSuccessfulTime: ConvertTimePtr(status.LastSuccessfulTime),
+	}
+}
+
+type CronJob struct {
+	TypeMeta
+	ObjectMeta
+	Spec   CronJobSpec
+	Status CronJobStatus
+}
+
+func ConvertCronJob(cj *batchv1.CronJob) CronJob {
+	return CronJob{
+		TypeMeta:   ConvertTypeMeta(cj.TypeMeta),
+		ObjectMeta: ConvertObjectMeta(&cj.ObjectMeta),
+		Spec:       ConvertCronJobSpec(cj.Spec),
+		Status:     ConvertCronJobStatus(cj.Status),
+	}
+}