Nacos客户端续约

客户端续约

在阅读nacos实例注册时,我们看到,客户端会每隔5s执行一次 BeatTask 任务,请求naming服务端的 /nacos/v1/ns/instance/beat 接口,那么服务端是如何处理HTTP心跳请求的呢?

服务端续约

服务端处理客户端HTTP心跳请求由 com.alibaba.nacos.naming.controllers.InstanceController#beat 第386行的service.processClientBeat(clientBeat); 进入到该方法

/**
     * Process client beat.
     *
     * @param rsInfo metrics info of server
     */
    public void processClientBeat(final RsInfo rsInfo) {
        ClientBeatProcessor clientBeatProcessor = new ClientBeatProcessor();
        clientBeatProcessor.setService(this);
        clientBeatProcessor.setRsInfo(rsInfo);
        //创建一个0延迟的执行任务
        //GlobalExecutor.scheduleNamingHealth(task, 0, TimeUnit.MILLISECONDS);
        HealthCheckReactor.scheduleNow(clientBeatProcessor);//
    }

初始化一个 ClientBeatProcessor 对象,该类实现了 Runnable 接口,最终将该任务丢到了线程池中立即执行,我们看看该任务做了哪些事情

ClientBeatProcessor

@Override
    public void run() {
        Service service = this.service;
        if (Loggers.EVT_LOG.isDebugEnabled()) {
            Loggers.EVT_LOG.debug("[CLIENT-BEAT] processing beat: {}", rsInfo.toString());
        }
        
        String ip = rsInfo.getIp();
        String clusterName = rsInfo.getCluster();
        int port = rsInfo.getPort();
        Cluster cluster = service.getClusterMap().get(clusterName);
        List<Instance> instances = cluster.allIPs(true);
        //遍历客户端实例列表
        for (Instance instance : instances) {
        	//从实例列表中找出与发起当前心跳请求,ip和端口一致的客户端实例
            if (instance.getIp().equals(ip) && instance.getPort() == port) {
                if (Loggers.EVT_LOG.isDebugEnabled()) {
                    Loggers.EVT_LOG.debug("[CLIENT-BEAT] refresh beat: {}", rsInfo.toString());
                }
                //更新最后一次心跳时间为当前时间
                instance.setLastBeat(System.currentTimeMillis());
                if (!instance.isMarked()) {
                    if (!instance.isHealthy()) {
                        instance.setHealthy(true);
                        Loggers.EVT_LOG
                                .info("service: {} {POS} {IP-ENABLED} valid: {}:{}@{}, region: {}, msg: client beat ok",
                                        cluster.getService().getName(), ip, port, cluster.getName(),
                                        UtilsAndCommons.LOCALHOST_SITE);
                         //发布服务变更事件               
                        getPushService().serviceChanged(service);
                    }
                }
            }
        }
    }

/**
     * Service changed.
     *
     * @param service service
     */
    public void serviceChanged(Service service) {
        // merge some change events to reduce the push frequency:
        if (futureMap
                .containsKey(UtilsAndCommons.assembleFullServiceName(service.getNamespaceId(), service.getName()))) {
            return;
        }
        
        this.applicationContext.publishEvent(new ServiceChangeEvent(this, service));
    }

看到这里我们可知,客户端在进行服务注册时,会每隔5s向naming服务端发送心跳请求,服务端接收到心跳请求会更新该客户端实例最后一次的心跳时间。那这个心跳时间有什么用呢?
我们在看服务端处理客户端实例注册时,InstanceController#register ---->>> ServiceManager#createServiceIfAbsent---->>> ServiceManager#putServiceAndInit ---->>> Service#init 到这里会初始化一个定时器,进行客户端心跳续约的健康检查,具体代码我们看

/**
     * Init service.
     */
    public void init() {
    	//初始化一个延迟任务,延迟5s执行,间隔5s循环一次
        HealthCheckReactor.scheduleCheck(clientBeatCheckTask);
        for (Map.Entry<String, Cluster> entry : clusterMap.entrySet()) {
            entry.getValue().setService(this);
            entry.getValue().init();
        }
    }

/**
     * Schedule client beat check task with a delay.
     *
     * @param task client beat check task
     */
    public static void scheduleCheck(ClientBeatCheckTask task) {
        futureMap.putIfAbsent(task.taskKey(), GlobalExecutor.scheduleNamingHealth(task, 5000, 5000, TimeUnit.MILLISECONDS));
    }

那定时5s循环的心跳检查任务已经初始化好了,接下来我们看看着个 ClientBeatCheckTask 是如何做的
代码有点多,我们看关键的代码

			//获取所有实例
			List<Instance> instances = service.allIPs(true);
            
            // first set health status of instances:
            for (Instance instance : instances) {
            	//当前时间 - 最后一次续约时间 > 15s,也就是说客户端已经超过15s没有发送HTTP心跳请求了
                if (System.currentTimeMillis() - instance.getLastBeat() > instance.getInstanceHeartBeatTimeOut()) {
                    if (!instance.isMarked()) {
                    	//客户端的健康标志位,因为服务端在处理HTTP心跳请求时会set它为true
                        if (instance.isHealthy()) {
                        	//回置健康标志位
                            instance.setHealthy(false);
                            Loggers.EVT_LOG
                                    .info("{POS} {IP-DISABLED} valid: {}:{}@{}@{}, region: {}, msg: client timeout after {}, last beat: {}",
                                            instance.getIp(), instance.getPort(), instance.getClusterName(),
                                            service.getName(), UtilsAndCommons.LOCALHOST_SITE,
                                            instance.getInstanceHeartBeatTimeOut(), instance.getLastBeat());
                            //发布ServiceChangeEvent事件                
                            getPushService().serviceChanged(service);
                            //发布InstanceHeartbeatTimeoutEvent事件
                            ApplicationUtils.publishEvent(new InstanceHeartbeatTimeoutEvent(this, instance));
                        }
                    }
                }
            }
            
            if (!getGlobalConfig().isExpireInstance()) {
                return;
            }
            
            // then remove obsolete instances:
            for (Instance instance : instances) {
                
                if (instance.isMarked()) {
                    continue;
                }
                //当前时间 - 最后一次心跳时间 > 30s
                if (System.currentTimeMillis() - instance.getLastBeat() > instance.getIpDeleteTimeout()) {
                    // delete instance
                    Loggers.SRV_LOG.info("[AUTO-DELETE-IP] service: {}, ip: {}", service.getName(),
                            JacksonUtils.toJson(instance));
                    //删除客户实例,发送http请求调用自己的 `InstanceController#deregister`        
                    deleteIp(instance);
                }
            }

看到这里,服务端心跳检测有两部分
1.客户端超过15s没有发送HTTP心跳请求,服务端会发布 InstanceHeartbeatTimeoutEvent 事件
2.客户端超过30s没有发送HTTP心跳请求,服务端会移除客户端实例
问题来了,客户端15s没有续约并不会删除,那服务端要发布这个 InstanceHeartbeatTimeoutEvent 是用来做什么的。
很遗憾,nacos1.3.2版本,并没有找到该事件接收器!!!