reconcile-test/controllers/recon_controller.go

/*
Copyright 2022.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/

package controllers

import (
	"context"

	appsv1 "k8s.io/api/apps/v1"
	corev1 "k8s.io/api/core/v1"
	"k8s.io/apimachinery/pkg/api/errors"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	"k8s.io/apimachinery/pkg/runtime"
	ctrl "sigs.k8s.io/controller-runtime"
	"sigs.k8s.io/controller-runtime/pkg/client"
	"sigs.k8s.io/controller-runtime/pkg/controller/controllerutil"
	"sigs.k8s.io/controller-runtime/pkg/log"

	testv1 "git.mashibing.com/test/reconcile/api/v1"
)

// ReconReconciler reconciles a Recon object
type ReconReconciler struct {
	client.Client
	Scheme *runtime.Scheme
}

var (
	// 用于更新第三方资源
	replicas1 = int32(1)
	replicas2 = int32(2)
)

//+kubebuilder:rbac:groups=test.mashibing.com,resources=recons,verbs=get;list;watch;create;update;patch;delete
//+kubebuilder:rbac:groups=test.mashibing.com,resources=recons/status,verbs=get;update;patch
//+kubebuilder:rbac:groups=test.mashibing.com,resources=recons/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.
// TODO(user): Modify the Reconcile function to compare the state specified by
// the Recon object against the actual cluster state, and then
// perform operations to make the cluster state reflect the state specified by
// the user.
//
// For more details, check Reconcile and its Result here:
// - https://pkg.go.dev/sigs.k8s.io/controller-runtime@v0.13.0/pkg/reconcile
func (r *ReconReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) {
	logger := log.FromContext(ctx)

	logger.Info("Start reconcile")

	// 获取资源对象
	recon := new(testv1.Recon)
	if err := r.Client.Get(ctx, req.NamespacedName, recon); err != nil {
		return ctrl.Result{}, client.IgnoreNotFound(err)
	}

	// 获取第三方资源
	dd := new(appsv1.Deployment)
	if err := r.Client.Get(ctx, req.NamespacedName, dd); err != nil {
		if errors.IsNotFound(err) {
			// 不存在创建
			logger.Info("Not exist deployment, Create it.")
			// 创建要创建第三方资源对象
			d := &appsv1.Deployment{
				TypeMeta: metav1.TypeMeta{
					Kind:       "Deployment",
					APIVersion: "apps/v1",
				},
			}

			replicas := int32(1)
			d.ObjectMeta.Name = req.Name
			d.ObjectMeta.Namespace = req.Namespace
			nameMap := map[string]string{"app": req.Name}
			d.ObjectMeta.Labels = nameMap
			d.Spec.Selector = &metav1.LabelSelector{}
			d.Spec.Selector.MatchLabels = nameMap
			d.Spec.Template.ObjectMeta.Labels = nameMap
			d.Spec.Replicas = &replicas
			d.Spec.Template.Spec.Containers = []corev1.Container{corev1.Container{
				Name:  req.Name,
				Image: recon.Spec.Image,
				Ports: []corev1.ContainerPort{
					corev1.ContainerPort{
						ContainerPort: 80,
					},
				},
			}}
			controllerutil.SetControllerReference(recon, d, r.Scheme)
			if err := r.Client.Create(ctx, d); err != nil {
				return ctrl.Result{}, err
			}
			logger.Info("Create deployment done.")
		} else {
			return ctrl.Result{}, err
		}
	} else {
		// 存在更新

		// 测试三方对象的修改
		//logger.Info("Change deployment.")
		//if *dd.Spec.Replicas == replicas1 {
		//	dd.Spec.Replicas = &replicas2
		//} else {
		//	dd.Spec.Replicas = &replicas1
		//}
		//logger.Info("Change deployment done.")
		// 测试更新第三方
		//logger.Info("Update deployment.")
		//if err := r.Client.Update(ctx, dd); err != nil {
		//	return ctrl.Result{}, err
		//}
		//logger.Info("Update deployment done.")
	}

	reconCopy := recon.DeepCopy()

	// 测试资源对象的修改
	logger.Info("Change recon.")
	reconCopy.Spec.Tag = !reconCopy.Spec.Tag
	// 测试更新资源
	logger.Info("Update recon.")
	if err := r.Client.Update(ctx, reconCopy); err != nil {
		return ctrl.Result{}, err
	}
	logger.Info("Update recon done.")

	// 测试status对象的修改
	//logger.Info("Change status.")
	//reconCopy.Status.Count += 1
	// 测试更新status
	//logger.Info("Update status.")
	//if err := r.Client.Status().Update(ctx, reconCopy); err != nil {
	//	return ctrl.Result{}, err
	//}
	//logger.Info("Update status done.")
	//
	logger.Info("End reconcile")
	return ctrl.Result{}, nil
}

// SetupWithManager sets up the controller with the Manager.
func (r *ReconReconciler) SetupWithManager(mgr ctrl.Manager) error {
	return ctrl.NewControllerManagedBy(mgr).
		For(&testv1.Recon{}).
		Owns(&appsv1.Deployment{}).
		Complete(r)
}