应用场景

在实际开发使用过程当中，在Eureka Admin控制台上，我们想强制下线某个服务，就需要用到覆盖状态的

概念，其实说白了，就是在给实例存储另外一个状态，当续约，注册的时候，以这个覆盖状态为准。

覆盖状态

设置覆盖状态

程序入口： com.netflix.eureka.resources.InstanceResource

@PUT
@Path("status")
public Response statusUpdate(
        @QueryParam("value") String newStatus,
        @HeaderParam(PeerEurekaNode.HEADER_REPLICATION) String isReplication,
        @QueryParam("lastDirtyTimestamp") String lastDirtyTimestamp) {
    try {
        // 判断实例是否存在，不存在则更新失败
        if (registry.getInstanceByAppAndId(app.getName(), id) == null) {
            logger.warn("Instance not found: {}/{}", app.getName(), id);
            return Response.status(Status.NOT_FOUND).build();
        }
        // 更新状态
        boolean isSuccess = registry.statusUpdate(app.getName(), id,
                InstanceStatus.valueOf(newStatus), lastDirtyTimestamp,
                "true".equals(isReplication));

        if (isSuccess) {
            logger.info("Status updated: " + app.getName() + " - " + id
                    + " - " + newStatus);
            return Response.ok().build();
        } else {
            logger.warn("Unable to update status: " + app.getName() + " - "
                    + id + " - " + newStatus);
            return Response.serverError().build();
        }
    } catch (Throwable e) {
        logger.error("Error updating instance {} for status {}", id,
                newStatus);
        return Response.serverError().build();
    }
}

1.判断实例在服务端是否存在，不存在则返回更新失败

2.调用更新状态的接口


public boolean statusUpdate(final String appName, final String id,
                            final InstanceStatus newStatus, String lastDirtyTimestamp,
                            final boolean isReplication) {
    // 调用父类的状态更新
    if (super.statusUpdate(appName, id, newStatus, lastDirtyTimestamp, isReplication)) {
        // Eureka Server 集群同步
        replicateToPeers(Action.StatusUpdate, appName, id, null, newStatus, isReplication);
        return true;
    }
    return false;
}


public boolean statusUpdate(String appName, String id,
                            InstanceStatus newStatus, String lastDirtyTimestamp,
                            boolean isReplication) {
    try {
        //使用读锁
        read.lock();
        // 更新状态的次数 状态统计
        STATUS_UPDATE.increment(isReplication);
        // 从本地数据里面获取实例信息，
        Map<String, Lease<InstanceInfo>> gMap = registry.get(appName);
        Lease<InstanceInfo> lease = null;
        if (gMap != null) {
            lease = gMap.get(id);
        }
        // 实例不存在，则直接返回，更细你失败
        if (lease == null) {
            return false;
        } else {
            // 执行一下lease的renew方法，里面主要是更新了这个instance的最后更新时间。
            lease.renew();
            // 获取instance实例信息
            InstanceInfo info = lease.getHolder();
            // Lease is always created with its instance info object.
            // This log statement is provided as a safeguard, in case this invariant is violated.
            if (info == null) {
                logger.error("Found Lease without a holder for instance id {}", id);
            }
            // 当instance信息不为空时
            if ((info != null) && !(info.getStatus().equals(newStatus))) {
                // Mark service as UP if needed
                // 如果新状态是UP的状态，那么启动一下serviceUp() , 主要是更新服务的注册时间。 
                if (InstanceStatus.UP.equals(newStatus)) {
                    lease.serviceUp();
                }
                // 将instance Id 和这个状态的映射信息放入覆盖缓存MAP里面去
                overriddenInstanceStatusMap.put(id, newStatus);
                // Set it for transfer of overridden status to replica on
                // replica start up
                // 设置覆盖状态到实例信息里面去
                info.setOverriddenStatus(newStatus);
                long replicaDirtyTimestamp = 0;
                if (lastDirtyTimestamp != null) {
                    replicaDirtyTimestamp = Long.valueOf(lastDirtyTimestamp);
                }
                //
                // 如果replicaDirtyTimestamp 的时间大于instance的getLastDirtyTimestamp() ,则更新一下
                // 此处主要作用是为了设置instance的status 为新状态
                if (replicaDirtyTimestamp > info.getLastDirtyTimestamp()) {
                    info.setLastDirtyTimestamp(replicaDirtyTimestamp);
                    info.setStatusWithoutDirty(newStatus);
                } else {
                    info.setStatus(newStatus);
                }
                // 将instance的变化放入变化队列里面去，客户端增量获取注册信息时，会用到。
                info.setActionType(ActionType.MODIFIED);
                recentlyChangedQueue.add(new RecentlyChangedItem(lease));
                info.setLastUpdatedTimestamp();
                // 缓存过期
                invalidateCache(appName, info.getVIPAddress(), info.getSecureVipAddress());
            }
            return true;
        }
    } finally {
        read.unlock();
    }
}

步骤如下：

1.获取实例信息，判断instance信息是否为空

2.将instanceId和覆盖状态，放入overriddenInstanceStatusMap 这个缓存MAP中进行了存储，过期时间默认为 1小时

3.更新instance的状态

4.添加instance Change 的记录进入队列

5.清除缓存。

删除覆盖状态

程序入口： com.netflix.eureka.resources.InstanceResource


@DELETE
@Path("status")
public Response deleteStatusUpdate(
        @HeaderParam(PeerEurekaNode.HEADER_REPLICATION) String isReplication,
        @QueryParam("value") String newStatusValue,
        @QueryParam("lastDirtyTimestamp") String lastDirtyTimestamp) {
    try {
        // 判断应用是否为空
        if (registry.getInstanceByAppAndId(app.getName(), id) == null) {
            logger.warn("Instance not found: {}/{}", app.getName(), id);
            return Response.status(Status.NOT_FOUND).build();
        }
        // 删除覆盖状态
        InstanceStatus newStatus = newStatusValue == null ? InstanceStatus.UNKNOWN : InstanceStatus.valueOf(newStatusValue);
        boolean isSuccess = registry.deleteStatusOverride(app.getName(), id,
                newStatus, lastDirtyTimestamp, "true".equals(isReplication));

        if (isSuccess) {
            logger.info("Status override removed: " + app.getName() + " - " + id);
            return Response.ok().build();
        } else {
            logger.warn("Unable to remove status override: " + app.getName() + " - " + id);
            return Response.serverError().build();
        }
    } catch (Throwable e) {
        logger.error("Error removing instance's {} status override", id);
        return Response.serverError().build();
    }
}

步骤说明：

1.判断应用信息是否为空

2.执行删除覆盖状态的接口


@Override
public boolean deleteStatusOverride(String appName, String id,
                                    InstanceStatus newStatus,
                                    String lastDirtyTimestamp,
                                    boolean isReplication) {
    // 删除覆盖状态
    if (super.deleteStatusOverride(appName, id, newStatus, lastDirtyTimestamp, isReplication)) {
        // Eureka Server 集群同步
        replicateToPeers(Action.DeleteStatusOverride, appName, id, null, null, isReplication);
        return true;
    }
    return false;
}


@Override
public boolean deleteStatusOverride(String appName, String id,
                                    InstanceStatus newStatus,
                                    String lastDirtyTimestamp,
                                    boolean isReplication) {
    try {
        // 上读锁
        read.lock();
        // 覆盖状态删除次数统计
        STATUS_OVERRIDE_DELETE.increment(isReplication);
        // 从本地获取appName对应的实例信息
        Map<String, Lease<InstanceInfo>> gMap = registry.get(appName);
        Lease<InstanceInfo> lease = null;
        if (gMap != null) {
            lease = gMap.get(id);
        }
        if (lease == null) {
            return false;
        } else {
            // 
            lease.renew();
            InstanceInfo info = lease.getHolder();

            // Lease is always created with its instance info object.
            // This log statement is provided as a safeguard, in case this invariant is violated.
            if (info == null) {
                logger.error("Found Lease without a holder for instance id {}", id);
            }
            // 将这个instanceID 对应的覆盖状态信息从MAP中移除
            InstanceStatus currentOverride = overriddenInstanceStatusMap.remove(id);
            if (currentOverride != null && info != null) {  
                // 设置instanceInfo的覆盖状态为UNKONW， 这是初始状态
                info.setOverriddenStatus(InstanceStatus.UNKNOWN);
                // 设置instance的status为最新的状态
                info.setStatus(newStatus);
                long replicaDirtyTimestamp = 0;
                if (lastDirtyTimestamp != null) {
                    replicaDirtyTimestamp = Long.valueOf(lastDirtyTimestamp);
                }
                // If the replication's dirty timestamp is more than the existing one, just update
                // it to the replica's.
                if (replicaDirtyTimestamp > info.getLastDirtyTimestamp()) {
                    info.setLastDirtyTimestamp(replicaDirtyTimestamp);
                }
                // 将instance的变化放入变化队列里面去，客户端增量获取注册信息时，会用到。
                info.setActionType(ActionType.MODIFIED);
                recentlyChangedQueue.add(new RecentlyChangedItem(lease));
                // 更新instance的最后更新时间
                info.setLastUpdatedTimestamp();
                // 缓存过期
                invalidateCache(appName, info.getVIPAddress(), info.getSecureVipAddress());
            }
            return true;
        }
    } finally {
        read.unlock();
    }
}

步骤说明：

1.从本地的CurrentHashMap中获取appName对应的应用信息，然后通过instanceId获取该应用对应的机器

2.移除overriddenInstanceStatusMap中该instanceId对应的覆盖状态

3.设置instanceInfo的覆盖状态为UNKNOW，这个是他的初始状态。

设置instance的status为新状态

5.添加instance Change 的记录进入队列

6.清除缓存。

实际应用

客户端注册


public void register(InstanceInfo registrant, int leaseDuration, boolean isReplication) {
    try {
        
        // .....省略N多代码
        // 判断instance的的覆盖状态是否等于UNKONW （默认状态下就是等于UNKONW）
        if (!InstanceStatus.UNKNOWN.equals(registrant.getOverriddenStatus())) {
            // 如果不等于，则说明被修改过，放入overriddenInstanceStatusMap
            logger.debug("Found overridden status {} for instance {}. Checking to see if needs to be add to the "
                            + "overrides", registrant.getOverriddenStatus(), registrant.getId());
            if (!overriddenInstanceStatusMap.containsKey(registrant.getId())) {
                logger.info("Not found overridden id {} and hence adding it", registrant.getId());
                overriddenInstanceStatusMap.put(registrant.getId(), registrant.getOverriddenStatus());
            }
        }
        // overriddenInstanceStatusMap 里面是否存在这个instanceId的覆盖状态
        InstanceStatus overriddenStatusFromMap = overriddenInstanceStatusMap.get(registrant.getId());
        // 如果存在，则设置进去
        if (overriddenStatusFromMap != null) {
            logger.info("Storing overridden status {} from map", overriddenStatusFromMap);
            registrant.setOverriddenStatus(overriddenStatusFromMap);
        }

        // 获取instance的状态，并设置进去
        InstanceStatus overriddenInstanceStatus = getOverriddenInstanceStatus(registrant, existingLease, isReplication);
        registrant.setStatusWithoutDirty(overriddenInstanceStatus);

     
        // .....省略N多代码
    } finally {
        read.unlock();
    }
}

续约


public boolean renew(String appName, String id, boolean isReplication) {
    RENEW.increment(isReplication);
    Map<String, Lease<InstanceInfo>> gMap = registry.get(appName);
    Lease<InstanceInfo> leaseToRenew = null;
    if (gMap != null) {
        leaseToRenew = gMap.get(id);
    }
    if (leaseToRenew == null) {
        RENEW_NOT_FOUND.increment(isReplication);
        logger.warn("DS: Registry: lease doesn't exist, registering resource: {} - {}", appName, id);
        return false;
    } else {
        InstanceInfo instanceInfo = leaseToRenew.getHolder();
        if (instanceInfo != null) {
            // 获取应用实例的最终状态
            InstanceStatus overriddenInstanceStatus = this.getOverriddenInstanceStatus(
                    instanceInfo, leaseToRenew, isReplication);
            // 如果应用实例的最终状态为UNKONW，则无法续约。 
            if (overriddenInstanceStatus == InstanceStatus.UNKNOWN) {
                logger.info("Instance status UNKNOWN possibly due to deleted override for instance {}"
                        + "; re-register required", instanceInfo.getId());
                RENEW_NOT_FOUND.increment(isReplication);
                return false;
            }
            // 应用实例的状态和最终的状态不一致，则以最终状态为准
            if (!instanceInfo.getStatus().equals(overriddenInstanceStatus)) {
                Object[] args = {
                        instanceInfo.getStatus().name(),
                        instanceInfo.getOverriddenStatus().name(),
                        instanceInfo.getId()
                };
               
                instanceInfo.setStatus(overriddenInstanceStatus);
            }
        }
        renewsLastMin.increment();
        leaseToRenew.renew();
        return true;
    }
}

步骤说明：

1.获取应用实例的最终状态

2.如果最终状态为UNKONW，则无法续约，返回false ，存在UNKONW的可能性，在deleteStatusOverride()的时候

存在UNKONW的可能性

3.应用实例的状态和最终状态不一致，以最终状态为准。

下线


protected boolean internalCancel(String appName, String id, boolean isReplication) {
    try {
        // ..... 省略N多代码
        // 将覆盖状态移除
        InstanceStatus instanceStatus = overriddenInstanceStatusMap.remove(id);
        // ..... 省略N多代码
    } finally {
        read.unlock();
    }
}

步骤说明:

1.移除覆盖状态

过期

和下线一致

深入理解Eureka覆盖状态（九）

应用场景

覆盖状态

设置覆盖状态

删除覆盖状态

实际应用

客户端注册

续约

下线

过期

猜你喜欢