switch (reason) {
        case TopologyCoordinator::StartElectionReason::kElectionTimeout:
            log() << "Starting an election, since we've seen no PRIMARY in the past "
                  << _rsConfig.getElectionTimeoutPeriod();
            break;
        case TopologyCoordinator::StartElectionReason::kPriorityTakeover:
            log() << "Starting an election for a priority takeover";
            break;
        case TopologyCoordinator::StartElectionReason::kStepUpRequest:
        case TopologyCoordinator::StartElectionReason::kStepUpRequestSkipDryRun:
            log() << "Starting an election due to step up request";
            break;
        case TopologyCoordinator::StartElectionReason::kCatchupTakeover:
            log() << "Starting an election for a catchup takeover";
            break;
        case TopologyCoordinator::StartElectionReason::kSingleNodePromptElection:
            log() << "Starting an election due to single node replica set prompt election";
            break;
    }

// 获取当前term
long long term = _topCoord->getTerm();
// 如果需要跳过预选举，则term自增，并且开始真正的选举
if (reason == TopologyCoordinator::StartElectionReason::kStepUpRequestSkipDryRun) {
        long long newTerm = term + 1;
        log() << "skipping dry run and running for election in term " << newTerm;
        _startRealElection_inlock(newTerm);
        lossGuard.dismiss();
        return;
    }

// 否则都需要进行预选举（dry run）
log() << "conducting a dry run election to see if we could be elected. current term: " << term;
// 选举准备（通过心跳heartbeat实现）
_voteRequester.reset(new VoteRequester);
// 预选举
_processDryRunResult(term);

long long newTerm = originalTerm + 1;
log() << "dry election run succeeded, running for election in term " << newTerm;

_startRealElection_inlock(newTerm);

// 先投自己一票
_topCoord->voteForMyselfV1();
...
// 给其他人节点发送请求投票结果的RPC
_startVoteRequester_inlock(lastVote.getTerm());
...
// 得到投票结果并处理
_onVoteRequestComplete(newTerm)
...
// 状态机变更，传递的是选举胜利状态
_performPostMemberStateUpdateAction(kActionWinElection);

	switch (action) {
        case kActionWinElection: {
            _electionId = OID::fromTerm(_topCoord->getTerm());
			...
            auto ts = LogicalClock::get(getServiceContext())->reserveTicks(1).asTimestamp();
			// 处理选举获胜的结果
            _topCoord->processWinElection(_electionId, ts);
			// 获取下一个阶段，正常的话会从kActionWinElection变更到kActionCloseAllConnections
            const PostMemberStateUpdateAction nextAction =
                _updateMemberStateFromTopologyCoordinator_inlock(nullptr);
            lk.unlock();
			// 再次更新状态机，往下一阶段前进
            _performPostMemberStateUpdateAction(nextAction);
            lk.lock();
            // 通过心跳通知副本集内所有的从节点选举胜利的好消息
            _restartHeartbeats_inlock();
			...
			//进入追赶模式
			_catchupState = stdx::make_unique<CatchupState>(this);
            _catchupState->start_inlock();

            break;
        }
	}

PostMemberStateUpdateAction result;
    if (_memberState.primary() || newState.removed() || newState.rollback()) {
        // Wake up any threads blocked in awaitReplication, close connections, etc.
        _replicationWaiterList.signalAll_inlock();
        // Wake up the optime waiter that is waiting for primary catch-up to finish.
        _opTimeWaiterList.signalAll_inlock();
        // _canAcceptNonLocalWrites 为false，表示无法接受非local的写入
        invariant(!_canAcceptNonLocalWrites);

        serverGlobalParams.validateFeaturesAsMaster.store(false);
		// 主节点会返回这个
        result = kActionCloseAllConnections;
    } else {
		//从节点会返回这个
        result = kActionFollowerModeStateChange;
    }

{
        // We have to do this check even if our current and target state are the same as we might
        // have just failed a stepdown attempt and thus are staying in PRIMARY state but restoring
        // our ability to accept writes.
        bool canAcceptWrites = _topCoord->canAcceptWrites();
        if (canAcceptWrites != _canAcceptNonLocalWrites) {
            // We must be holding the global X lock to change _canAcceptNonLocalWrites.
            invariant(opCtx);
            invariant(opCtx->lockState()->isW());
        }
        _canAcceptNonLocalWrites = canAcceptWrites;
    }

// 开始catchup，如果catchup的超时设置为0（后面会提到这一设置参数）就跳过catchup阶段直接返回了
_catchupState->start_inlock();
// 调度
ReplicationExecutor::scheduleWorkAt() 
// 通过心跳和oplog来追赶，此函数用于处理心跳返回结果
_handleHeartbeatResponse()
// 判断是否追上了
CatchupState::signalHeartbeatUpdate_inlock()
//结束追赶模式
CatchupState::abort_inlock() 结束catchup模式

// We've caught up.
    if (*targetOpTime <= _repl->_getMyLastAppliedOpTime_inlock()) {
        log() << "Caught up to the latest optime known via heartbeats after becoming primary.";
        abort_inlock();
        return;
    }

//进入drain阶段
_enterDrainMode_inlock()
// 结束后台同步
BackgroundSync::stop()
//退出drain阶段
signalDrainComplete()
// 销毁追赶状态
_catchupState.reset()

//获取全局写锁
Lock::GlobalWrite globalWriteLock(opCtx);

// 断言当前的节点状态和 接受写入状态
invariant(_getMemberState_inlock().primary());
invariant(!_canAcceptNonLocalWrites);

{
    lk.unlock();
    AllowNonLocalWritesBlock writesAllowed(opCtx);
    OpTime firstOpTime = _externalState->onTransitionToPrimary(opCtx, isV1ElectionProtocol());
    lk.lock();
    auto status = _topCoord->completeTransitionToPrimary(firstOpTime);
    if (status.code() == ErrorCodes::PrimarySteppedDown) {
        log() << "Transition to primary failed" << causedBy(status);
        return;
    }
    invariant(status);
}
// Must calculate the commit level again because firstOpTimeOfMyTerm wasn't set when we logged
// our election in onTransitionToPrimary(), above.
_updateLastCommittedOpTime_inlock();
// 再次调用这个函数，此时由于节点已经是primary状态，会将`_canAcceptNonLocalWrites`更新为true，即此时主节点已经可以接受非local的写入了 _updateMemberStateFromTopologyCoordinator_inlock(opCtx);
log() << "transition to primary complete; database writes are now permitted" << rsLog;