1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

	mgr, err := ctrl.NewManager(ctrl.GetConfigOrDie(), ctrl.Options{
		Scheme:                 scheme,
		Metrics:                metricsServerOptions,
		WebhookServer:          webhookServer,
		HealthProbeBindAddress: probeAddr,
		LeaderElection:         enableLeaderElection,
		LeaderElectionID:       "958dbbf6.hexactf.io",
		// LeaderElectionReleaseOnCancel defines if the leader should step down voluntarily
		// when the Manager ends. This requires the binary to immediately end when the
		// Manager is stopped, otherwise, this setting is unsafe. Setting this significantly
		// speeds up voluntary leader transitions as the new leader don't have to wait
		// LeaseDuration time first.
		//
		// In the default scaffold provided, the program ends immediately after
		// the manager stops, so would be fine to enable this option. However,
		// if you are doing or is intended to do any operation such as perform cleanups
		// after the manager stops then its usage might be unsafe.
		// LeaderElectionReleaseOnCancel: true,
	})
	if err != nil {
		setupLog.Error(err, "unable to start manager")
		os.Exit(1)
	}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

// SetupWithManager sets up the controller with the Manager.
func (r *ChallengeReconciler) SetupWithManager(mgr ctrl.Manager) error {
	// Builder 초기화
	return ctrl.NewControllerManagedBy(mgr)
		// Challenge라는 대상 리소스
		For(&hexactfproj.Challenge{}).
		Owns(&appsv1.Deployment{}).
		Owns(&corev1.Service{})./
		Named("challenge").
		// Controller에 ChallengeReconciler를 삽입
		Complete(r)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

// 처음 생성 시 StartedAt 등 Status 초기화
	if challenge.Status.StartedAt == nil {

		if err := r.Get(ctx, req.NamespacedName, &challenge); err != nil {
			return r.handleError(ctx, req, &challenge, err)
		}
		now := metav1.Now()
		challenge.Status.StartedAt = &now
		challenge.Status.CurrentStatus = *hexactfproj.NewCurrentStatus()
		if err := r.Status().Update(ctx, &challenge); err != nil {
			log.Error(err, "Failed to initialize status")
			return r.handleError(ctx, req, &challenge, err)
		}
	}

	// 최신 상태로 갱신
	if err := r.Get(ctx, req.NamespacedName, &challenge); err != nil {
		// NotFound 에러 등은 무시
		return r.handleError(ctx, req, &challenge, err)
	}

	// 현재 상태에 따라 분기
	switch {
	case challenge.Status.CurrentStatus.IsNone():
		// ...

		if err := r.Get(ctx, req.NamespacedName, &challenge); err != nil {
			return r.handleError(ctx, req, &challenge, err)
		}
		// 실제 Challenge에 필요한 리소스들(Deployment, Service 등) 생성 로직
		err := r.loadChallengeDefinition(ctx, req, &challenge)
		if err != nil {
			return r.handleError(ctx, req, &challenge, err)
		}

		// 한 번 더 재큐(Requeue)하여 바로 다음 단계 확인
		return ctrl.Result{Requeue: true}, nil

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

	// Deployment가 존재하는지 확인
	err := r.Get(ctx, client.ObjectKey{
		Namespace: challenge.Namespace,
		Name:      deploy.Name,
	}, deploy)

	if err != nil {
		if errors.IsNotFound(err) {
			log.Info("Creating Deployment", "Deployment.Namespace", deploy.Namespace, "Deployment.Name", deploy.Name)

			// Owner Reference 설정
			if err := ctrl.SetControllerReference(challenge, deploy, r.Scheme); err != nil {
				log.Error(err, "failed to set controller reference")
				return err
			}
			// Deployment 생성
			err = r.Client.Create(ctx, deploy)
			if err != nil {
				log.Error(err, "failed to create Deployment")
				return err
			}
		} else {
			log.Error(err, "failed to get Deployment")
			return err
		}
	}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

// SetupWithManager sets up the controller with the Manager.
func (r *ChallengeReconciler) SetupWithManager(mgr ctrl.Manager) error {
	// Builder를 초기화
	return ctrl.NewControllerManagedBy(mgr)
		// Challenge(부모 리소스)
		For(&hexactfproj.Challenge{}).
		// Deployment(자식 리소스)
		Owns(&appsv1.Deployment{}).
		// Service(자식 리소스)
		Owns(&corev1.Service{})./
		Named("challenge").
		// Controller에 ChallengeReconciler를 삽입
		Complete(r)
}

1
2
3
4
5
6

		challenge.Status.CurrentStatus.SetRunning()
		now := metav1.Now()
		challenge.Status.StartedAt = &now
		if err := r.Status().Update(ctx, &challenge); err != nil {
			return r.handleError(ctx, req, &challenge, err)
		}

1
2
3

if err := r.Get(ctx, req.NamespacedName, &challenge); err != nil {
	return r.handleError(ctx, req, &challenge, err)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

{
  "controller": "challenge",
  "controllerGroup": "apps.hexactf.io",
  "controllerKind": "Challenge",
  "Challenge": {
    "name": "challenge-59-sample",
    "namespace": "default"
  },
  "namespace": "default",
  "name": "challenge-59-sample",
  "reconcileID": "bf0eee44-a54d-417d-8322-7dc81e52152e",
  "error": "Operation cannot be fulfilled on challenges.apps.hexactf.io \"challenge-59-sample\": the object has been modified; please apply your changes to the latest version and try again"
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

const (
	challengeFinalizer = "challenge.hexactf.io/finalizer"
)

func (r *ChallengeReconciler) addFinalizer(ctx context.Context, challenge *hexactfproj.Challenge) (ctrl.Result, error) {
	challenge.Finalizers = append(challenge.Finalizers, challengeFinalizer)
	if err := r.Update(ctx, challenge); err != nil {
		return ctrl.Result{}, fmt.Errorf("failed to add finalizer: %w", err)
	}
	return ctrl.Result{}, nil
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

func (r *ChallengeReconciler) handleDeletion(ctx context.Context, challenge *hexactfproj.Challenge) (ctrl.Result, error) {
	log.Info("Processing deletion", "challenge", challenge.Name)
	crStatusMetric.WithLabelValues(challenge.Labels["apps.hexactf.io/challengeId"], challenge.Name, challenge.Labels["apps.hexactf.io/user"], challenge.Namespace).Set(2)

	// Finalizer가 남아있는지 확인
	if controllerutil.ContainsFinalizer(challenge, "challenge.hexactf.io/finalizer") {

		// 파이널라이저 제거
		controllerutil.RemoveFinalizer(challenge, "challenge.hexactf.io/finalizer")

		// 메타데이터 업데이트
		if err := r.Update(ctx, challenge); err != nil {
			log.Error(err, "Failed to remove finalizer")
			// 재시도 위해 Requeue
			return ctrl.Result{RequeueAfter: time.Second * 5}, err
		}

		// 필요하다면 Deleted 이벤트 전송
		err := r.KafkaClient.SendStatusChange(
			challenge.Labels["apps.hexactf.io/user"],
			challenge.Labels["apps.hexactf.io/challengeId"],
			"Deleted",
		)
		if err != nil {
			log.Error(err, "Failed to send status change message")
			// 여기서도 에러 시 재시도
			return ctrl.Result{}, err
		}
	}

	go func() {
		time.Sleep(1 * time.Minute) // scrape_interval이 30초라면 1분 정도 기다리면 안전
		crStatusMetric.DeleteLabelValues(challenge.Labels["apps.hexactf.io/challengeId"], challenge.Name, challenge.Labels["apps.hexactf.io/user"], challenge.Namespace)
	}()
	log.Info("Successfully completed deletion process")
	// 이 시점에서 finalizers가 비어 있으므로, K8s가 오브젝트를 실제 삭제함
	return ctrl.Result{}, nil
}

1
2
3

 if !challenge.DeletionTimestamp.IsZero() {
	return r.handleDeletion(ctx, &challenge)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

		if time.Since(challenge.Status.StartedAt.Time) > challengeDuration {
			// 아직 DeletionTimestamp가 없다면 Delete 요청
			if challenge.DeletionTimestamp.IsZero() {

				log.Info("Time exceeded; issuing a Delete request", "challenge", challenge.Name)
				if err := r.Delete(ctx, &challenge); err != nil {
					log.Error(err, "Failed to delete challenge")
					return r.handleError(ctx, req, &challenge, err)
				}
				// Delete 요청 후에는 Kubernetes가 DeletionTimestamp를 설정하고
				// 다시 Reconcile이 호출되면 handleDeletion()이 수행됨
				return ctrl.Result{}, nil
			} else {
				// 이미 Delete 진행중이면 handleDeletion으로
				return r.handleDeletion(ctx, &challenge)
			}
		}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

	case challenge.Status.CurrentStatus.IsRunning():
		if err := r.Get(ctx, req.NamespacedName, &challenge); err != nil {
			return r.handleError(ctx, &challenge, err)
		}

		// isOne이 false이면 일정 시간 내에만 작동
		if !challenge.Status.IsOne && time.Since(challenge.Status.StartedAt.Time) > challengeDuration {

			return r.handleDeletion(ctx, &challenge)
		}

		if !challenge.DeletionTimestamp.IsZero() {
			return r.handleDeletion(ctx, &challenge)
		}

		// Running 메세지 전송
		err := r.KafkaClient.SendStatusChange(challenge.Labels["apps.hexactf.io/user"], challenge.Labels["apps.hexactf.io/challengeId"], "Running")
		if err != nil {
			log.Error(err, "Failed to send status change message")
			return r.handleError(ctx, &challenge, err)
		}
	}
	return ctrl.Result{RequeueAfter: requeueInterval}, nil