feat: add election leader

executor.go

@@ -54,8 +54,8 @@ type executor struct {
 	limitModeRunningJobs    *atomic.Int64    // tracks the count of running jobs to check against the max
 	stopped                 *atomic.Bool     // allow workers to drain the buffered limitModeQueue
 
-	distributedLocker   Locker   // support running jobs across multiple instances
-	distributedElection Election // support running jobs across multiple instances
+	distributedLocker  Locker  // support running jobs across multiple instances
+	distributedElector Elector // support running jobs across multiple instances
 }
 
 func newExecutor() executor {
@@ -161,8 +161,8 @@ func (e *executor) runJob(f jobFunction) {
 		if lockKey == "" {
 			lockKey = f.funcName
 		}
-		if e.distributedElection != nil {
-			err := e.distributedElection.IsLeader(e.ctx)
+		if e.distributedElector != nil {
+			err := e.distributedElector.IsLeader(e.ctx)
 			if err != nil {
 				return
 			}

scheduler.go

@@ -1495,14 +1495,14 @@ func (s *Scheduler) WithDistributedLocker(l Locker) {
 
 // WithDistributedElector prevents the same job from being run more than once
 // when multiple schedulers are trying to schedule the same job, by allowing only
-// the leader to run jobs. Non-leaders wait until the leader instance goes down 
+// the leader to run jobs. Non-leaders wait until the leader instance goes down
 // and then a new leader is elected.
 //
 // Compared with the distributed lock, the election is the same as leader/follower framework.
 // All jobs are only scheduled and execute on the leader scheduler instance. Only when the leader scheduler goes down
 // and one of the scheduler instances is successfully elected, then the new leader scheduler instance can schedule jobs.
 func (s *Scheduler) WithDistributedElector(e Elector) {
-	s.executor.distributedElection = el
+	s.executor.distributedElector = e
 }
 
 // RegisterEventListeners accepts EventListeners and registers them for all jobs

scheduler_test.go

@@ -2853,32 +2853,32 @@ func TestDataRace(t *testing.T) {
 	sut.Stop()
 }
 
-var _ Election = (*election)(nil)
+var _ Elector = (*elector)(nil)
 
-type election struct {
+type elector struct {
 	isLeader bool
 }
 
-func (e *election) IsLeader(_ context.Context) error {
+func (e *elector) IsLeader(_ context.Context) error {
 	if e.isLeader {
 		return nil
 	}
 	return errors.New("is not leader")
 }
 
-func (e *election) setLeader() {
+func (e *elector) setLeader() {
 	e.isLeader = true
 }
 
-func TestScheduler_EnableDistributedElection(t *testing.T) {
-	runTestWithDistributedElection(t, 0)
+func TestScheduler_EnableDistributedElector(t *testing.T) {
+	runTestWithDistributedElector(t, 0)
 }
 
-func TestScheduler_EnableDistributedElectionWithMaxConcurrent(t *testing.T) {
-	runTestWithDistributedElection(t, 1)
+func TestScheduler_EnableDistributedElectorWithMaxConcurrent(t *testing.T) {
+	runTestWithDistributedElector(t, 1)
 }
 
-func runTestWithDistributedElection(t *testing.T, maxConcurrentJobs int) {
+func runTestWithDistributedElector(t *testing.T, maxConcurrentJobs int) {
 	resultChan := make(chan int, 20)
 	f := func(schedulerInstance int) {
 		resultChan <- schedulerInstance
@@ -2887,13 +2887,13 @@ func runTestWithDistributedElection(t *testing.T, maxConcurrentJobs int) {
 	leaderIndex := 0
 	schedulers := make([]*Scheduler, 0)
 	for i := 0; i < 3; i++ {
-		el := &election{}
+		el := &elector{}
 		if i == leaderIndex {
 			el.setLeader()
 		}
 
 		s := NewScheduler(time.UTC)
-		s.WithDistributedElection(el)
+		s.WithDistributedElector(el)
 		if maxConcurrentJobs > 0 {
 			s.SetMaxConcurrentJobs(maxConcurrentJobs, WaitMode)
 		}