func()

in pkg/controllers/member/internalmembercluster/v1alpha1/controller.go [55:123]

• 66 lines of code
• 10 McCabe index (conditional complexity)

func (r *Reconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) {
	imcKRef := klog.KRef(req.Namespace, req.Name)
	startTime := time.Now()
	klog.V(2).InfoS("Reconciliation starts", "internalMemberCluster", imcKRef)
	defer func() {
		latency := time.Since(startTime).Milliseconds()
		klog.V(2).InfoS("Reconciliation ends", "internalMemberCluster", imcKRef, "latency", latency)
	}()

	var imc fleetv1alpha1.InternalMemberCluster
	if err := r.HubClient.Get(ctx, req.NamespacedName, &imc); err != nil {
		if apierrors.IsNotFound(err) {
			klog.V(4).InfoS("Ignoring NotFound internalMemberCluster", "internalMemberCluster", imcKRef)
			return ctrl.Result{}, nil
		}
		klog.ErrorS(err, "Failed to get internal member cluster", "internalMemberCluster", imcKRef)
		return ctrl.Result{}, err
	}

	switch imc.Spec.State {
	case fleetv1alpha1.ClusterStateJoin:
		agentStatus := fleetv1alpha1.AgentStatus{
			Type: r.AgentType,
			Conditions: []metav1.Condition{
				{
					Type:               string(fleetv1alpha1.AgentJoined),
					Status:             metav1.ConditionTrue,
					Reason:             conditionReasonJoined,
					ObservedGeneration: imc.GetGeneration(),
				},
			},
			LastReceivedHeartbeat: metav1.NewTime(time.Now()),
		}
		if err := r.updateAgentStatus(ctx, &imc, agentStatus); err != nil {
			return ctrl.Result{}, err
		}
		// add jitter to the heart beat to mitigate the herding of multiple agents
		hbInterval := 1000 * imc.Spec.HeartbeatPeriodSeconds
		jitterRange := int64(hbInterval*jitterPercent) / 100
		requeueAfter := time.Millisecond * (time.Duration(hbInterval) + time.Duration(rand.Int63nRange(0, jitterRange)-jitterRange/2))
		return ctrl.Result{RequeueAfter: requeueAfter}, nil
	case fleetv1alpha1.ClusterStateLeave:
		if r.AgentType == fleetv1alpha1.MultiClusterServiceAgent {
			if err := r.cleanupMCSRelatedResources(ctx); err != nil {
				return ctrl.Result{}, err
			}
		}
		if r.AgentType == fleetv1alpha1.ServiceExportImportAgent {
			if err := r.cleanupServiceExportRelatedResources(ctx); err != nil {
				return ctrl.Result{}, err
			}
		}
		agentStatus := fleetv1alpha1.AgentStatus{
			Type: r.AgentType,
			Conditions: []metav1.Condition{
				{
					Type:               string(fleetv1alpha1.AgentJoined),
					Status:             metav1.ConditionFalse,
					Reason:             conditionReasonLeft,
					ObservedGeneration: imc.GetGeneration(),
				},
			},
		}
		return ctrl.Result{}, r.updateAgentStatus(ctx, &imc, agentStatus)
	default:
		klog.ErrorS(errors.New("unknown state"), "internalMemberCluster", imcKRef, "state", imc.Spec.State)
	}
	return ctrl.Result{}, nil
}