eureka源码解析——服务主动下线

---

前言

服务主动下线流程其实包含了几个步骤：

1. eurekaServer收到请求后从注册表剔除实例信息
2. 清除本地缓存
3. 同步给集群中的其他节点

一、 服务主动下线源码解析

1.1、 InstanceResource#cancelLease

服务主动下线，客户端请求下线接口会调用到服务端的InstanceResource#cancelLease处理下线,这里直接调用注册表的cancel方法进行服务下线

    @DELETE
    public Response cancelLease(
            @HeaderParam(PeerEurekaNode.HEADER_REPLICATION) String isReplication) {
        try {
            // 服务下线
            boolean isSuccess = registry.cancel(app.getName(), id,
                "true".equals(isReplication));

            if (isSuccess) {
                logger.debug("Found (Cancel): {} - {}", app.getName(), id);
                return Response.ok().build();
            } else {
                logger.info("Not Found (Cancel): {} - {}", app.getName(), id);
                return Response.status(Status.NOT_FOUND).build();
            }
        } catch (Throwable e) {
            logger.error("Error (cancel): {} - {}", app.getName(), id, e);
            return Response.serverError().build();
        }

    }

1.2、 PeerAwareInstanceRegistryImpl#cancel

1. 调用父类AbstractInstanceRegistry的cancel方法进行本地注册表更新
2. 同步给集群的其他节点

    @Override
    public boolean cancel(final String appName, final String id,
                          final boolean isReplication) {
        if (super.cancel(appName, id, isReplication)) {
            replicateToPeers(Action.Cancel, appName, id, null, null, isReplication);

            return true;
        }
        return false;
    }

1.2.1、 AbstractInstanceRegistry#cancel

1. 首先获取读锁
2. 从注册表剔除实例信息
3. 将变更信息放到最近删除队列中
4. 删除本地缓存数据
5. 更新需要发送心跳的客户端数量(自我保护机制)

 protected boolean internalCancel(String appName, String id, boolean isReplication) {
        // 获取读锁
        read.lock();
        try {
            CANCEL.increment(isReplication);
            // 获取 appName 对应的所有实例集合
            Map<String, Lease<InstanceInfo>> gMap = registry.get(appName);
            Lease<InstanceInfo> leaseToCancel = null;
            if (gMap != null) {
                // 根据实例id 移除对应的实例租约信息
                leaseToCancel = gMap.remove(id);
            }
            // 将变更信息 扔到最近删除队列中
            recentCanceledQueue.add(new Pair<Long, String>(System.currentTimeMillis(), appName + "(" + id + ")"));
            InstanceStatus instanceStatus = overriddenInstanceStatusMap.remove(id);
            if (instanceStatus != null) {
                logger.debug("Removed instance id {} from the overridden map which has value {}", id, instanceStatus.name());
            }
            if (leaseToCancel == null) {
                CANCEL_NOT_FOUND.increment(isReplication);
                logger.warn("DS: Registry: cancel failed because Lease is not registered for: {}/{}", appName, id);
                return false;
            } else {
                // 变更实例剔除时间
                leaseToCancel.cancel();
                InstanceInfo instanceInfo = leaseToCancel.getHolder();
                String vip = null;
                String svip = null;
                if (instanceInfo != null) {
                    instanceInfo.setActionType(ActionType.DELETED);
                    // 放入最近变更队列中
                    recentlyChangedQueue.add(new RecentlyChangedItem(leaseToCancel));
                    instanceInfo.setLastUpdatedTimestamp();
                    vip = instanceInfo.getVIPAddress();
                    svip = instanceInfo.getSecureVipAddress();
                }
                // 删除实例对应的缓存数据
                invalidateCache(appName, vip, svip);
                logger.info("Cancelled instance {}/{} (replication={})", appName, id, isReplication);
            }
        } finally {
            read.unlock();
        }

        // 更新 需要发送心跳的客户端数量
        synchronized (lock) {
            if (this.expectedNumberOfClientsSendingRenews > 0) {
                // Since the client wants to cancel it, reduce the number of clients to send renews.
                this.expectedNumberOfClientsSendingRenews = this.expectedNumberOfClientsSendingRenews - 1;
                updateRenewsPerMinThreshold();
            }
        }

        return true;
    }

1.2.2、 AbstractInstanceRegistry#replicateToPeers

将实例删除信息同步到集群中其他节点，这里可以发现Eureka是一个p2p的架构，客户端可以连接任何一台eurekaServer，然后做服务注册，上下线等，eurekaServer再把实例信息同步到其他节点，p2p如何解决复制冲突问题？
eureka复制冲突
eureka复制冲突2

     */
    private void replicateToPeers(Action action, String appName, String id,
                                  InstanceInfo info /* optional */,
                                  InstanceStatus newStatus /* optional */, boolean isReplication) {
        Stopwatch tracer = action.getTimer().start();
        try {
            if (isReplication) {
                numberOfReplicationsLastMin.increment();
            }
            // If it is a replication already, do not replicate again as this will create a poison replication
            if (peerEurekaNodes == Collections.EMPTY_LIST || isReplication) {
                return;
            }

            for (final PeerEurekaNode node : peerEurekaNodes.getPeerEurekaNodes()) {
                // If the url represents this host, do not replicate to yourself.
                if (peerEurekaNodes.isThisMyUrl(node.getServiceUrl())) {
                    continue;
                }
                //复制实例信息到其他节点
                replicateInstanceActionsToPeers(action, appName, id, info, newStatus, node);
            }
        } finally {
            tracer.stop();
        }
    }

好文章

eureka解析