baschno/k8s-operator-playground
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

new attempt

Browse Source
This commit is contained in:
Bastian Schnorbus
2025-05-06 23:03:51 +02:00
parent 7783d14826
commit cbefdfba7b
28 changed files with 80 additions and 446 deletions
Download Patch File Download Diff File Expand all files Collapse all files

218
internal/controller/deployment.go
View File

@@ -1,218 +0,0 @@
package controllers
import (
"context"
"fmt"
schedulev1 "github.com/baschno/tdset-operator/api/v1"
appsv1 "k8s.io/api/apps/v1"
corev1 "k8s.io/api/core/v1"
ctrl "sigs.k8s.io/controller-runtime"
"sigs.k8s.io/controller-runtime/pkg/log"
apierrors "k8s.io/apimachinery/pkg/api/errors"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/types"
)
func (r *TDSetReconciler) Deployment(
ctx context.Context, req ctrl.Request,
tdSet *schedulev1.TDSet,
) (*appsv1.Deployment, error) {
log := log.FromContext(ctx)
replicas, err := r.GetExpectedReplica(ctx, req, tdSet)
if err != nil {
log.Error(err, "failed to get expected replica")
return nil, err
}
labels := map[string]string{
"app.kubernetes.io/name": "TDSet",
"app.kubernetes.io/instance": tdSet.Name,
"app.kubernetes.io/version": "v1",
"app.kubernetes.io/part-of": "tdset-operator",
"app.kubernetes.io/created-by": "controller-manager",
}
dep := &appsv1.Deployment{
ObjectMeta: metav1.ObjectMeta{
Name: tdSet.Name,
Namespace: tdSet.Namespace,
},
Spec: appsv1.DeploymentSpec{
Replicas: &replicas,
Selector: &metav1.LabelSelector{
MatchLabels: labels,
},
Template: corev1.PodTemplateSpec{
ObjectMeta: metav1.ObjectMeta{
Labels: labels,
},
Spec: corev1.PodSpec{
Containers: []corev1.Container{{
Image: tdSet.Spec.Container.Image,
Name: tdSet.Name,
ImagePullPolicy: corev1.PullIfNotPresent,
Ports: []corev1.ContainerPort{{
ContainerPort: int32(tdSet.Spec.Container.Port),
Name: "tdset",
}},
}},
},
},
},
}
// Set the ownerRef for the Deployment
// More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/owners-dependents/
if err := ctrl.SetControllerReference(tdSet, dep, r.Scheme); err != nil {
log.Error(err, "failed to set controller owner reference")
return nil, err
}
return dep, nil
}
func (r *TDSetReconciler) DeploymentIfNotExist(
ctx context.Context, req ctrl.Request,
tdSet *schedulev1.TDSet,
) (bool, error) {
log := log.FromContext(ctx)
dep := &appsv1.Deployment{}
err := r.Get(ctx, types.NamespacedName{Name: tdSet.Name, Namespace: tdSet.Namespace}, dep)
if err != nil && apierrors.IsNotFound(err) {
dep, err := r.Deployment(ctx, req, tdSet)
if err != nil {
log.Error(err, "Failed to define new Deployment resource for TDSet")
err = r.SetCondition(
ctx, req, tdSet, TypeAvailable,
fmt.Sprintf("Failed to create Deployment for TDSet (%s): (%s)", tdSet.Name, err),
)
if err != nil {
return false, err
}
}
log.Info(
"Creating a new Deployment",
"Deployment.Namespace", dep.Namespace,
"Deployment.Name", dep.Name,
)
err = r.Create(ctx, dep)
if err != nil {
log.Error(
err, "Failed to create new Deployment",
"Deployment.Namespace", dep.Namespace,
"Deployment.Name", dep.Name,
)
return false, err
}
err = r.GetTDSet(ctx, req, tdSet)
if err != nil {
log.Error(err, "Failed to re-fetch TDSet")
return false, err
}
err = r.SetCondition(
ctx, req, tdSet, TypeProgressing,
fmt.Sprintf("Created Deployment for the TDSet: (%s)", tdSet.Name),
)
if err != nil {
return false, err
}
return true, nil
}
if err != nil {
log.Error(err, "Failed to get Deployment")
return false, err
}
return false, nil
}
func (r *TDSetReconciler) UpdateDeploymentReplica(
ctx context.Context, req ctrl.Request,
tdSet *schedulev1.TDSet,
) error {
log := log.FromContext(ctx)
dep := &appsv1.Deployment{}
err := r.Get(ctx, types.NamespacedName{Name: tdSet.Name, Namespace: tdSet.Namespace}, dep)
if err != nil {
log.Error(err, "Failed to get Deployment")
return err
}
replicas, err := r.GetExpectedReplica(ctx, req, tdSet)
if err != nil {
log.Error(err, "failed to get expected replica")
return err
}
if replicas == *dep.Spec.Replicas {
return nil
}
log.Info(
"Updating a Deployment replica",
"Deployment.Namespace", dep.Namespace,
"Deployment.Name", dep.Name,
)
dep.Spec.Replicas = &replicas
err = r.Update(ctx, dep)
if err != nil {
log.Error(
err, "Failed to update Deployment",
"Deployment.Namespace", dep.Namespace,
"Deployment.Name", dep.Name,
)
err = r.GetTDSet(ctx, req, tdSet)
if err != nil {
log.Error(err, "Failed to re-fetch TDSet")
return err
}
err = r.SetCondition(
ctx, req, tdSet, TypeProgressing,
fmt.Sprintf("Failed to update replica for the TDSet (%s): (%s)", tdSet.Name, err),
)
if err != nil {
return err
}
return nil
}
err = r.GetTDSet(ctx, req, tdSet)
if err != nil {
log.Error(err, "Failed to re-fetch TDSet")
return err
}
err = r.SetCondition(
ctx, req, tdSet, TypeProgressing,
fmt.Sprintf("Updated replica for the TDSet (%s)", tdSet.Name),
)
if err != nil {
return err
}
return nil
}

30
internal/controller/schedule.go
View File

@@ -1,30 +0,0 @@
package controllers
import (
"context"
"time"
ctrl "sigs.k8s.io/controller-runtime"
"sigs.k8s.io/controller-runtime/pkg/log"
schedulev1 "github.com/baschno/tdset-operator/api/v1"
)
func (r *TDSetReconciler) GetExpectedReplica(ctx context.Context, req ctrl.Request, tdSet *schedulev1.TDSet) (int32, error) {
log := log.FromContext(ctx)
if tdSet.Spec.SchedulingConfig != nil && len(tdSet.Spec.SchedulingConfig) != 0 {
now := time.Now()
hour := now.Hour()
log.Info("current server", "hour", hour, "time", now)
for _, config := range tdSet.Spec.SchedulingConfig {
if hour >= config.StartTime && hour < config.EndTime {
return int32(config.Replica), nil
}
}
}
return tdSet.Spec.DefaultReplica, nil
}

76
internal/controller/tdset.go
View File

@@ -1,76 +0,0 @@
package controllers
import (
"context"
"sigs.k8s.io/controller-runtime/pkg/log"
schedulev1 "github.com/baschno/tdset-operator/api/v1"
"k8s.io/apimachinery/pkg/api/meta"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
ctrl "sigs.k8s.io/controller-runtime"
)
// ConditionStatus defines TDSet condition status.
type ConditionStatus string
// Defines TDSet condition status.
const (
TypeAvailable ConditionStatus = "Available"
TypeProgressing ConditionStatus = "Progressing"
TypeDegraded ConditionStatus = "Degraded"
)
// GetTDSet gets the TDSet from api server.
func (r *TDSetReconciler) GetTDSet(ctx context.Context, req ctrl.Request, tdSet *schedulev1.TDSet) error {
err := r.Get(ctx, req.NamespacedName, tdSet)
if err != nil {
return err
}
return nil
}
// SetInitialCondition sets the status condition of the TDSet to available initially
// when no condition exists yet.
func (r *TDSetReconciler) SetInitialCondition(ctx context.Context, req ctrl.Request, tdSet *schedulev1.TDSet) error {
if tdSet.Status.Conditions != nil || len(tdSet.Status.Conditions) != 0 {
return nil
}
err := r.SetCondition(ctx, req, tdSet, TypeAvailable, "Starting reconciliation")
return err
}
// SetCondition sets the status condition of the TDSet.
func (r *TDSetReconciler) SetCondition(
ctx context.Context, req ctrl.Request,
tdSet *schedulev1.TDSet, condition ConditionStatus,
message string,
) error {
log := log.FromContext(ctx)
meta.SetStatusCondition(
&tdSet.Status.Conditions,
metav1.Condition{
Type: string(condition),
Status: metav1.ConditionUnknown, Reason: "Reconciling",
Message: message,
},
)
if err := r.Status().Update(ctx, tdSet); err != nil {
log.Error(err, "Failed to update TDSet status")
return err
}
if err := r.Get(ctx, req.NamespacedName, tdSet); err != nil {
log.Error(err, "Failed to re-fetch TDSet")
return err
}
return nil
}

61
internal/controller/tdset_controller.go
View File

@@ -18,9 +18,7 @@ package controller
import (
"context"
"time"
apierrors "k8s.io/apimachinery/pkg/api/errors"
"k8s.io/apimachinery/pkg/runtime"
ctrl "sigs.k8s.io/controller-runtime"
"sigs.k8s.io/controller-runtime/pkg/client"
@@ -29,10 +27,6 @@ import (
schedulev1 "github.com/baschno/tdset-operator/api/v1"
)
const (
DefaultReconciliationInterval = 5
)
// TDSetReconciler reconciles a TDSet object
type TDSetReconciler struct {
client.Client
@@ -42,7 +36,6 @@ type TDSetReconciler struct {
// +kubebuilder:rbac:groups=schedule.rs,resources=tdsets,verbs=get;list;watch;create;update;patch;delete
// +kubebuilder:rbac:groups=schedule.rs,resources=tdsets/status,verbs=get;update;patch
// +kubebuilder:rbac:groups=schedule.rs,resources=tdsets/finalizers,verbs=update
// +kubebuilder:rbac:groups=apps,resources=deployments,verbs=get;list;watch;create;update;patch;delete
// Reconcile is part of the main kubernetes reconciliation loop which aims to
// move the current state of the cluster closer to the desired state.
@@ -54,59 +47,11 @@ type TDSetReconciler struct {
// For more details, check Reconcile and its Result here:
// - https://pkg.go.dev/sigs.k8s.io/controller-runtime@v0.19.0/pkg/reconcile
func (r *TDSetReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) {
log := log.FromContext(ctx)
_ = log.FromContext(ctx)
log.Info("Starting reconciliation")
tdSet := &schedulev1.TDSet{}
// Get TDSet
err := r.GetTDSet(ctx, req, tdSet)
if err != nil {
if apierrors.IsNotFound(err) {
log.Info("TDSet not found - ignoring since object must be deleted")
return ctrl.Result{}, nil
}
log.Error(err, "Failed to get TDSet")
return ctrl.Result{}, err
}
// Try to set initial status
err = r.SetInitialCondition(ctx, req, tdSet)
if err != nil {
log.Error(err, "Failed to set initial condition")
return ctrl.Result{}, err
}
// TODO Delete finalizer
// Deployment if not exist
ok, err := r.DeploymentIfNotExist(ctx, req, tdSet)
if err != nil {
log.Error(err, "Failed to check deployment for TDSet")
return ctrl.Result{}, err
}
if ok {
return ctrl.Result{RequeueAfter: time.Minute}, nil
}
// Update deployment replica if mismatched
err = r.UpdateDeploymentReplica(ctx, req, tdSet)
if err != nil {
log.Log.Error(err, "Failed to update deployment replica for TDSet")
return ctrl.Result{}, err
}
interval := DefaultReconciliationInterval
if tdSet.Spec.IntervalMint != 0 {
interval = int(tdSet.Spec.IntervalMint)
}
log.Info("Reconciliation done", "RequeueAfter", interval)
return ctrl.Result{RequeueAfter: time.Duration(time.Minute * time.Duration(interval))}, nil
// TODO(user): your logic here
return ctrl.Result{}, nil
}
// SetupWithManager sets up the controller with the Manager.