[从源码学设计]蚂蚁金服SOFARegistry之Data节点变更
[从源码学设计]蚂蚁金服SOFARegistry之Data节点变更
0x00 摘要
SOFARegistry 是蚂蚁金服开源的一个生产级、高时效、高可用的服务注册中心。
本系列文章重点在于分析设计和架构，即利用多篇文章，从多个角度反推总结 DataServer 或者 SOFARegistry 的实现机制和架构思路，让大家借以学习阿里如何设计。
本文为第十一篇，介绍SOFARegistry如何处理Data节点变化，即处理DataServerChangeEvent消息。
0x02 引子
上文中我们提到，MetaServerChangeEvent也会转化为 DataServerChangeEvent，投放到EventCenter。
这是因为Meta Server的这个推送，也许是在告诉data Server，"hi，目前data server也有变动"。所以本期我们介绍如何处理DataServerChangeEvent，此处需要结合上文。
0x03 业务范畴
我们在这里首先要讲讲几个业务范畴。
3.1 DataServer 数据一致性
为支持海量数据，SOFARegistry 采用了一致性 Hash 来分片存储 Publisher 数据，避免了单个服务器存储全量数据时产生的容量瓶颈问题。而在这个模型中，每个数据分片拥有多个副本，当存储注册数的 DataServer 进行扩容、缩容时，MetaServer 会把这个变更通知到 DataServer 和 SessionServer，数据分片会在集群内部进行数据迁移与同步，此时就出现了 DataServer 内部数据的一致性问题。
3.2 节点变更时的数据同步
MetaServer 会通过网络连接感知到新节点上线或者下线，所有的 DataServer 中运行着一个定时刷新连接的任务 ConnectionRefreshTask，该任务定时去轮询 MetaServer，获取数据节点的信息。需要注意的是，除了 DataServer 主动去 MetaServer 拉取节点信息外，MetaServer 也会主动发送 NodeChangeResult 请求到各个节点，通知节点信息发生变化，推拉获取信息的最终效果是一致的。
0x04 总体逻辑
这部分总体逻辑如下：
当轮询信息返回数据节点有变化时，会向 EventCenter 投递一个 DataServerChangeEvent 事件，在该事件的处理器中，如果判断出是当前机房节点信息有变化，则会投递新的事件 LocalDataServerChangeEvent。
该事件的处理器 LocalDataServerChangeEventHandler 中会判断当前节点是否为新加入的节点，如果是新节点则会向其它节点发送 NotifyOnlineRequest 请求，如图所示：
图 DataServer 节点上线时新节点的逻辑
本文就主要讲解从DataServerChangeEvent到LocalDataServerChangeEvent这部分的逻辑。
0x05 DataServerChangeEvent
5.1 消息来源
DataServerChangeEvent有三种来源：启动主动获取，定期，推送。这三种具体如下：
- 启动主动获取：这个主动查询并且拉取的过程，这个过程基本上类似一个同步过程，体现为客户端一次查询结果的同步返回。
- 版本变更推送：为了确定服务发布数据的变更，对于这个服务感兴趣的所有客户端订阅方都需要推送，进行推送。由于性能要求必须并发执行并且异步确定推送成功。
- 定期轮训：这样避免了某次变更通知没有通知到所有订阅方的情况。
因为有了上文的知识，我们应该知道，启动主动获取 和 推送 这两种方式是通过MetaServerChangeEvent完成的，结合上文逻辑图，现在简述如下：
+-------------------------------+
|[DataServerBootstrap] | MetaServerChangeEvent
| |
| +-------------------------+
| startRaftClient | a |
| | | +---------------+
| | | | |
+-------------------------------+ | | |
+-------------------------------+ | | |
| [Timer] | | v |
| | b | 1 +-------+-----+ |
| ConnectionRefreshMetaTask +------------------------------> | EventCenter +----+ |
| | MetaServerChangeEvent | +-------+-----+ | |
+-------------------------------+ | ^ | |
+-------------------------------+ | | | |
| | | | | |
| [Push<NodeChangeResult>] | | | | |
| | c | | | |
| +-------------------------+ | | |
| | MetaServerChangeEvent | | |
| ServerChangeHandler | 2 | | |
| +----------------------------------------+ | |
+-------------------------------+ DataServerChangeEvent | |
| |
| |
MetaServerChangeEvent | |
3 | |
+----------------------------------------------------+ |
| |
v |
+-----------------+--------------+ DataServerChangeEvent |
| | 4 |
| MetaServerChangeEventHandler +------------------------------------------+
| |
+--------------------------------+
5.1.1 启动
5.1.1.1 产生消息
当 DataServer 节点初始化成功后，会启动任务自动去连接 MetaServer。启动时，会从配置里面读取meta server配置，metaServerService.getMetaServerMap()；据此构建MetaServerChangeEvent，投放到EventCenter之中。
private void startRaftClient() {
metaServerService.startRaftClient();
eventCenter.post(new MetaServerChangeEvent(metaServerService.getMetaServerMap()));
}
5.1.1.2 MetaServerChangeEventHandler
MetaServerChangeEventHandler 用来响应 MetaServerChangeEvent 消息。因为其继承了AbstractEventHandler，所以 MetaServerChangeEventHandler 已经注册到了EventCenter之上。
在处理MetaServerChangeEvent之后，该任务会往事件中心 EventCenter 注册一个 DataServerChangeEvent 事件，该事件注册后会被触发，之后将对新增节点计算 Hash 值，同时进行纳管分片。
就是对应上图 a，1，3，4这条线，是DataServerChangeEvent的来源1。
5.1.2 推送
这个来源是其他消息的转换，即NodeChangeResult的转换。而且有两个转换过程。
5.1.2.1 推送
除了 DataServer 主动去 MetaServer 拉取节点信息外，MetaServer 也会主动发送 NodeChangeResult 请求到各个节点，通知节点信息发生变化，推拉获取信息的最终效果是一致的。
5.1.2.2 第一层转换
ServerChangeHandler 是 metaClientHandler 的一部分，是MetaNodeExchanger 的响应函数。
在ServerChangeHandler之中，拿到了NodeChangeResult之后，会判断变更节点类型，这里会根据 Note 类型不同，决定产生 DataServerChangeEvent 还是 MetaServerChangeEvent。
如果是NodeType.META，就发送消息给eventCenter，即eventCenter.post(new MetaServerChangeEvent(map));，
这就是MetaServerChangeEvent和DataServerChangeEvent来源之一。就是对应上图2这条线，是DataServerChangeEvent的来源2。
public class ServerChangeHandler extends AbstractClientHandler<NodeChangeResult> {
@Autowired
private EventCenter eventCenter;
@Autowired
private DataServerConfig dataServerConfig;
@Override
public Object doHandle(Channel channel, NodeChangeResult request) {
ExecutorFactory.getCommonExecutor().execute(() -> {
if (request.getNodeType() == NodeType.DATA) {
eventCenter.post(new DataServerChangeEvent(request.getNodes(),
request.getDataCenterListVersions(), FromType.META_NOTIFY));
} else if (request.getNodeType() == NodeType.META) {
Map<String, Map<String, MetaNode>> metaNodesMap = request.getNodes();
if (metaNodesMap != null && !metaNodesMap.isEmpty()) {
Map<String, MetaNode> metaNodeMap = metaNodesMap.get(dataServerConfig.getLocalDataCenter());
if (metaNodeMap != null && !metaNodeMap.isEmpty()) {
HashMap<String, Set<String>> map = new HashMap<>();
map.put(dataServerConfig.getLocalDataCenter(), metaNodeMap.keySet());
eventCenter.post(new MetaServerChangeEvent(map));
}
}
}
});
return CommonResponse.buildSuccessResponse();
}
@Override
public Class interest() {
return NodeChangeResult.class;
}
@Override
public HandlerType getType() {
return HandlerType.PROCESSER;
}
@Override
protected Node.NodeType getConnectNodeType() {
return Node.NodeType.DATA;
}
}
5.1.2.3 第二层转换
MetaServerChangeEventHandler 用来响应 MetaServerChangeEvent 消息。因为其继承了AbstractEventHandler，所以 MetaServerChangeEventHandler 已经注册到了EventCenter之上。
注意，这里有一个再次转换DataServerChangeEvent的过程，即MetaServerChangeEventHandler这里会再主动和MetaServer交互，这是因为Meta Server的这个推送，也许是在告诉data Server，"hi，目前data server也有变动"。
如果返回消息是NodeChangeResult，就转换为DataServerChangeEvent，投放DataServerChangeEvent到Event Center。
就是对应上图 b，1，3，4这条线，是DataServerChangeEvent的来源3。
public class MetaServerChangeEventHandler extends AbstractEventHandler<MetaServerChangeEvent> {
private void registerMetaServer(String dataCenter, String ip) {
......
if (obj instanceof NodeChangeResult) {
NodeChangeResult<DataNode> result = (NodeChangeResult<DataNode>) obj;
Map<String, Long> versionMap = result.getDataCenterListVersions();
//send renew after first register dataNode
Set<StartTaskTypeEnum> set = new HashSet<>();
set.add(StartTaskTypeEnum.RENEW);
eventCenter.post(new StartTaskEvent(set));
eventCenter.post(new DataServerChangeEvent(result.getNodes(), versionMap,
DataServerChangeEvent.FromType.REGISTER_META));
break;
}
}
}
0x06 轮训拉
我们这里要重点讲解DataServerChangeEvent的来源“轮训拉”。
MetaServer 会通过网络连接感知到新节点上线或者下线，所有的 DataServer 中运行着一个定时刷新连接的任务 ConnectionRefreshTask，该任务定时去轮询 MetaServer，获取数据节点的信息。
6.1 Bean
ConnectionRefreshTask 在 tasks 这个 Bean中启动。
@Bean(name = "tasks")
public List<AbstractTask> tasks() {
List<AbstractTask> list = new ArrayList<>();
list.add(connectionRefreshTask());
list.add(connectionRefreshMetaTask());
list.add(renewNodeTask());
return list;
}
6.2 启动
tasks是在startScheduler间接启动的。
eventCenter.post(new StartTaskEvent(
Arrays.stream(StartTaskTypeEnum.values()).filter(type -> type != StartTaskTypeEnum.RENEW).collect(Collectors.toSet())));
StartTaskEventHandler响应StartTaskEvent，其会逐一启动tasks。
public class StartTaskEventHandler extends AbstractEventHandler<StartTaskEvent> {
@Resource(name = "tasks")
private List<AbstractTask> tasks;
private ScheduledExecutorService executor = null;
@Override
public void doHandle(StartTaskEvent event) {
if (executor == null || executor.isShutdown()) {
getExecutor();
}
for (AbstractTask task : tasks) {
if (event.getSuitableTypes().contains(task.getStartTaskTypeEnum())) {
executor.scheduleWithFixedDelay(task, task.getInitialDelay(), task.getDelay(),
task.getTimeUnit());
}
}
}
private void getExecutor() {
executor = ExecutorFactory.newScheduledThreadPool(tasks.size(), this.getClass()
.getSimpleName());
}
}
这里有一个技巧。
ConnectionRefreshTask里面指定了支持CONNECT_DATA，StartTaskEventHandler在启动时判断支持类型，发现是CONNECT_DATA，就启动了ConnectionRefreshTask。
AbstractEventHandler 其中注册了eventCenter.register，这样它的继承类都默认注册到了EventCenter 之上。
public abstract class AbstractEventHandler<Event> implements InitializingBean {
@Autowired
private EventCenter eventCenter;
@Override
public void afterPropertiesSet() throws Exception {
eventCenter.register(this);
}
/**
* event handle func
* @param event
*/
public void handle(Event event) {
doHandle(event);
}
public abstract List<Class<? extends Event>> interest();
public abstract void doHandle(Event event);
}
于是，connectionRefreshTask就启动了。
6.3 ConnectionRefreshTask
ConnectionRefreshTask负责轮询与meta Server交互，可以看到，也发送了DataServerChangeEvent。
public class ConnectionRefreshTask extends AbstractTask {
@Autowired
private IMetaServerService metaServerService;
@Autowired
private EventCenter eventCenter;
@Override
public void handle() {
DataServerChangeItem dataServerChangeItem = metaServerService.getDateServers();
if (dataServerChangeItem != null) {
eventCenter
.post(new DataServerChangeEvent(dataServerChangeItem, FromType.CONNECT_TASK));
}
}
@Override
public int getDelay() {
return 30;
}
@Override
public int getInitialDelay() {
return 0;
}
@Override
public TimeUnit getTimeUnit() {
return TimeUnit.SECONDS;
}
@Override
public StartTaskTypeEnum getStartTaskTypeEnum() {
return StartTaskTypeEnum.CONNECT_DATA;
}
}
ConnectionRefreshTask 调用 metaServerService.getDateServers()；getDateServers 的作用是：
- 从 metaServerConnectionFactory 获取connectionMap；
- 通过raft来获取raft leader;
- 从 connectionMap 获取 leader 的connection，这是一个 bolt Connection；
- 利用 bolt Connection 进行请求，GetNodesRequest(NodeType.DATA)；
- 从请求结果构建 DataServerChangeItem；
- 在 EventCenter 中放一个消息 DataServerChangeEvent(dataServerChangeItem, FromType.CONNECT_TASK)；
具体如下：
@Override
public DataServerChangeItem getDateServers() {
Map<String, Connection> connectionMap = metaServerConnectionFactory
.getConnections(dataServerConfig.getLocalDataCenter());
String leader = getLeader().getIp();
if (connectionMap.containsKey(leader)) {
Connection connection = connectionMap.get(leader);
if (connection.isFine()) {
try {
GetNodesRequest request = new GetNodesRequest(NodeType.DATA);
Object obj = metaNodeExchanger.request(new Request() {
@Override
public Object getRequestBody() {
return request;
}
@Override
public URL getRequestUrl() {
return new URL(connection.getRemoteIP(), connection.getRemotePort());
}
}).getResult();
if (obj instanceof NodeChangeResult) {
NodeChangeResult<DataNode> result = (NodeChangeResult<DataNode>) obj;
Map<String, Long> versionMap = result.getDataCenterListVersions();
versionMap.put(result.getLocalDataCenter(), result.getVersion());
return new DataServerChangeItem(result.getNodes(), versionMap);
}
}
}
}
String newip = refreshLeader().getIp();
return null;
}
0x07 DataServerChangeEventHandler
7.1 总体逻辑
DataServerChangeEvent 事件被触发后，由 DataServerChangeEventHandler 来进行相应的处理，分别分为如下一些步骤：
- 初始化当前数据节点的一致性 Hash 值，把当前节点添加进一致性的 Hash 环中。
- 获取变更了的 DataServer 节点，这些节点在启动 DataServer 服务的时候从 MetaServer 中获取到的，并且通过 DataServerChangeEvent 事件中的 DataServerChangeItem 传入。
- 获取了当前的 DataServer 节点之后，若节点列表非空，则遍历每个节点，建立当前节点与其余数据节点之间的连接，同时删除本地维护的不在节点列表中的节点数据，更新dataServerCache。同时，若当前节点是 DataCenter 节点，则触发 LocalDataServerChangeEvent 事件。
SOFA这里主要是处理LocalDataServerChangeEvent，异地机房的部分没有开源。
7.2 LocalDataServerChangeEvent
关于上面第三点，详细说明如下：
从DataServerChangeEvent中提取DataServerChangeItem，如果发现有一个DataCenter就是本机，则使用如下语句获取新加入的DataServer。
Set<String> newjoined = new HashSet<>(ips);
newjoined.removeAll(localDataServers);
然后使用这些新加入的DataServer来构建 LocalDataServerChangeEvent。
参见如下片段：
//get changed dataservers
Map<String, Set<String>> changedMap = dataServerCache.compareAndSet(
dataServerChangeItem, event.getFromType());
if (!changedMap.isEmpty()) {
for (Entry<String, Set<String>> changeEntry : changedMap.entrySet()) {
String dataCenter = changeEntry.getKey();
Set<String> ips = changeEntry.getValue();
String dataCenter = changeEntry.getKey();
Set<String> ips = changeEntry.getValue();
//if the dataCenter is self, post LocalDataServerChangeEvent
if (dataServerConfig.isLocalDataCenter(dataCenter)) {
Set<String> newjoined = new HashSet<>(ips);
newjoined.removeAll(localDataServers);
eventCenter.post(new LocalDataServerChangeEvent(map, newjoined,
dataServerChangeItem.getVersionMap().get(dataCenter), newVersion));
} else {
dataServerCache.updateItem(newDataNodes, newVersion, dataCenter);
eventCenter.post(new RemoteDataServerChangeEvent(dataCenter, map,
dataServerChangeItem.getVersionMap().get(dataCenter), newVersion));
}
}
具体代码如下：
public class DataServerChangeEventHandler extends AbstractEventHandler<DataServerChangeEvent> {
private static final int TRY_COUNT = 5;
@Autowired
private DataServerConfig dataServerConfig;
@Autowired
private DataServerCache dataServerCache;
@Autowired
private DataNodeExchanger dataNodeExchanger;
@Autowired
private EventCenter eventCenter;
@Override
public List<Class<? extends DataServerChangeEvent>> interest() {
return Lists.newArrayList(DataServerChangeEvent.class);
}
@Override
public void doHandle(DataServerChangeEvent event) {
synchronized (this) {
//register self first,execute once
DataServerNodeFactory.initConsistent(dataServerConfig);
DataServerChangeItem dataServerChangeItem = event.getDataServerChangeItem();
Set<String> localDataServers = dataServerCache.getDataServers(
dataServerConfig.getLocalDataCenter()).keySet();
//get changed dataservers 得到变化了的dataServers
Map<String, Set<String>> changedMap = dataServerCache.compareAndSet(
dataServerChangeItem, event.getFromType());
if (!changedMap.isEmpty()) {
for (Entry<String, Set<String>> changeEntry : changedMap.entrySet()) {
String dataCenter = changeEntry.getKey();
Set<String> ips = changeEntry.getValue();
Long newVersion = dataServerCache.getDataCenterNewVersion(dataCenter);
if (!CollectionUtils.isEmpty(ips)) {
for (String ip : ips) {
if (!StringUtils.equals(ip, DataServerConfig.IP)) {
DataServerNode dataServerNode = DataServerNodeFactory
.getDataServerNode(dataCenter, ip);
if (dataServerNode == null
|| dataServerNode.getConnection() == null
|| !dataServerNode.getConnection().isFine()) {
connectDataServer(dataCenter, ip);
}
}
}
//remove all old DataServerNode not in change map
Set<String> ipSet = DataServerNodeFactory.getIps(dataCenter);
for (String ip : ipSet) {
if (!ips.contains(ip)) {
DataServerNodeFactory.remove(dataCenter, ip, dataServerConfig);
}
}
Map<String, DataNode> newDataNodes = dataServerCache
.getNewDataServerMap(dataCenter);
//avoid input map reference operation DataServerNodeFactory MAP
Map<String, DataNode> map = new ConcurrentHashMap<>(newDataNodes);
//if the dataCenter is self, post LocalDataServerChangeEvent
if (dataServerConfig.isLocalDataCenter(dataCenter)) {
//为什么 local 时候不做 updateItem
Set<String> newjoined = new HashSet<>(ips);
newjoined.removeAll(localDataServers);
eventCenter.post(new LocalDataServerChangeEvent(map, newjoined,
dataServerChangeItem.getVersionMap().get(dataCenter), newVersion));
} else {
dataServerCache.updateItem(newDataNodes, newVersion, dataCenter);
eventCenter.post(new RemoteDataServerChangeEvent(dataCenter, map,
dataServerChangeItem.getVersionMap().get(dataCenter), newVersion));
}
} else {
//if the dataCenter which has no dataServers is not self, remove it
if (!dataServerConfig.isLocalDataCenter(dataCenter)) {
removeDataCenter(dataCenter);
eventCenter.post(new RemoteDataServerChangeEvent(dataCenter,
Collections.EMPTY_MAP, dataServerChangeItem.getVersionMap().get(
dataCenter), newVersion));
}
Map<String, DataNode> newDataNodes = dataServerCache
.getNewDataServerMap(dataCenter);
dataServerCache.updateItem(newDataNodes, newVersion, dataCenter);
}
}
} else {
//refresh for keep connect other dataServers
//如果没有“有变化”的DataServer，则重新连接一下现有的DataServer
Set<String> allDataCenter = new HashSet<>(dataServerCache.getAllDataCenters());
for (String dataCenter : allDataCenter) {
Map<String, DataNode> dataNodes = dataServerCache
.getNewDataServerMap(dataCenter);
if (dataNodes != null) {
for (DataNode dataNode : dataNodes.values()) {
if (!StringUtils.equals(dataNode.getIp(), DataServerConfig.IP)) {
DataServerNode dataServerNode = DataServerNodeFactory
.getDataServerNode(dataCenter, dataNode.getIp());
Connection connection = dataServerNode != null ? dataServerNode
.getConnection() : null;
if (connection == null || !connection.isFine()) {
connectDataServer(dataCenter, dataNode.getIp());
}
}
}
}
}
}
}
}
/**
* connect specific dataserver
*
* @param dataCenter
* @param ip
*/
private void connectDataServer(String dataCenter, String ip) {
Connection conn = null;
for (int tryCount = 0; tryCount < TRY_COUNT; tryCount++) {
try {
conn = ((BoltChannel) dataNodeExchanger.connect(new URL(ip, dataServerConfig
.getSyncDataPort()))).getConnection();
break;
} catch (Exception e) {
TimeUtil.randomDelay(3000);
}
}
if (conn == null || !conn.isFine()) {
throw new RuntimeException(
String
.format(
"[DataServerChangeEventHandler] connect dataServer %s in %s failed five times,dataServer will not work,please check connect!",
ip, dataCenter));
}
//maybe get dataNode from metaServer,current has not start! register dataNode info to factory,wait for connect task next execute
DataServerNodeFactory.register(new DataServerNode(ip, dataCenter, conn), dataServerConfig);
}
/**
* remove dataCenter, and close connections of dataServers in this dataCenter
*
* @param dataCenter
*/
private void removeDataCenter(String dataCenter) {
DataServerNodeFactory.getDataServerNodes(dataCenter).values().stream().map(DataServerNode::getConnection)
.filter(connection -> connection != null && connection.isFine()).forEach(Connection::close);
DataServerNodeFactory.remove(dataCenter);
}
}
7.3 逻辑图
于是，我们的逻辑图拓展如下：
DataServerChangeEvent一共四个来源。
前三个来源是与MetaServerChangeEvent相关。
- 启动主动获取：MetaServerChangeEventHandler 用来响应 MetaServerChangeEvent 消息。在处理MetaServerChangeEvent之后，该任务会往事件中心 EventCenter 注册一个 DataServerChangeEvent 事件。就是对应下图 a，1，3，4这条线，是DataServerChangeEvent的来源1。
- 版本变更推送：ServerChangeHandler 是 MetaNodeExchanger 的响应函数。在ServerChangeHandler之中，拿到了NodeChangeResult之后，会判断变更节点类型，这里会根据 Note 类型不同，决定产生 DataServerChangeEvent 还是 MetaServerChangeEvent。
- 如果是NodeType.DATA，ServerChangeHandler 就发送消息给eventCenter，即
eventCenter.post(new MetaServerChangeEvent(map));；就是对应下图2这条线，是DataServerChangeEvent的来源2。 - 如果是NodeType.DATA，ServerChangeHandler 就发送消息给eventCenter，即
eventCenter.post(new MetaServerChangeEvent(map));；注意，这里有一个再次转换DataServerChangeEvent的过程，即MetaServerChangeEventHandler这里会再主动和MetaServer交互，如果返回消息是NodeChangeResult，就转换为DataServerChangeEvent，投放DataServerChangeEvent到Event Center。就是对应下图 b，1，3，4这条线，是DataServerChangeEvent的来源3。
- 如果是NodeType.DATA，ServerChangeHandler 就发送消息给eventCenter，即
第四来源是定期轮训。
所有的 DataServer 中运行着一个定时刷新连接的任务 ConnectionRefreshTask，该任务定时去轮询 MetaServer，获取数据节点的信息。
ConnectionRefreshTask 调用 metaServerService.getDateServers()；与MetaServer联系，从请求结果构建 DataServerChangeItem；在 EventCenter 中放一个消息 DataServerChangeEvent(dataServerChangeItem, FromType.CONNECT_TASK)；就是对应下图5这条线，是DataServerChangeEvent的来源3。
最后，DataServerChangeEvent 事件被触发后，由 DataServerChangeEventHandler 来进行相应的处理。就是对应下图6，7这条线。
若当前节点是 DataCenter 节点，则触发 LocalDataServerChangeEvent 事件。SOFA这里主要是处理LocalDataServerChangeEvent，异地机房的部分没有开源。
+---------------------------+
|[DataServerBootstrap] | MetaServerChangeEvent +------------------------+
| | | |
| +-------------------------+ | +------------------+ |
| startRaftClient | a | | | | |
| | | | | +-------------+ | |
| | | | | | | | |
+---------------------------+ | | | | | | |
+---------------------------+ | v | | | | |
| [Timer] | | | v | | |
| | b | 1 +----+--+-----+ | | |
| ConnectionRefreshMetaTask +------------------------------> | EventCenter +----+ | | |
| | MetaServerChangeEvent | +-------+---+-+ | | | |
+---------------------------+ | ^ ^ | | | |
+---------------------------+ | | | | | | |
| | | | | | | | |
| [Push<NodeChangeResult>] | | | | | | | |
| | c | | | | | | |
| +-------------------------+ | | 5 | | | |
| | MetaServerChangeEvent | | | | | |
| ServerChangeHandler | 2 | | | | | |
| +----------------------------------------+ | | | | |
+---------------------------+ DataServerChangeEvent | | | | |
| | | | |
+-------------------------+ | | | | |
| | | | | | |
| ConnectionRefreshTask +----------------------------------------------+ | | | |
| | | | | |
+-------------------------+ | | | |
| | | |
MetaServerChangeEvent | | | |
3 | | | |
+----------------------------------------------------+ | | |
| | | |
v | | |
+-----------------+--------------+ DataServerChangeEvent | | |
| | 4 | | |
| MetaServerChangeEventHandler +----------------------------------------+ | |
| | | |
+--------------------------------+ | |
| |
DataServerChangeEvent | |
+------------------------------+ | |
| DataServerChangeEventHandler | <----------------------------------------+ |
+---------------+--------------+ 6 |
| |
| 7 |
+------------------------------------------------------------+
LocalDataServerChangeEvent / RemoteDataServerChangeEvent
0x08 总结
本文讲解了SOFARegistry如何处理Data节点变化。
主要就是从DataServerChangeEvent到LocalDataServerChangeEvent这部分的逻辑。SOFA这里主要是处理LocalDataServerChangeEvent，异地机房的部分没有开源。所以下文我们介绍LocalDataServerChangeEvent。
[从源码学设计]蚂蚁金服SOFARegistry之Data节点变更的更多相关文章
- [从源码学设计]蚂蚁金服SOFARegistry之程序基本架构
[从源码学设计]蚂蚁金服SOFARegistry之程序基本架构 0x00 摘要 之前我们通过三篇文章初步分析了 MetaServer 的基本架构,MetaServer 这三篇文章为我们接下来的工作做了 ...
- [从源码学设计]蚂蚁金服SOFARegistry之网络封装和操作
[从源码学设计]蚂蚁金服SOFARegistry之网络封装和操作 目录 [从源码学设计]蚂蚁金服SOFARegistry之网络封装和操作 0x00 摘要 0x01 业务领域 1.1 SOFARegis ...
- [从源码学设计]蚂蚁金服SOFARegistry网络操作之连接管理
[从源码学设计]蚂蚁金服SOFARegistry网络操作之连接管理 目录 [从源码学设计]蚂蚁金服SOFARegistry网络操作之连接管理 0x00 摘要 0x01 业务领域 1.1 应用场景 0x ...
- [从源码学设计]蚂蚁金服SOFARegistry之消息总线
[从源码学设计]蚂蚁金服SOFARegistry之消息总线 目录 [从源码学设计]蚂蚁金服SOFARegistry之消息总线 0x00 摘要 0x01 相关概念 1.1 事件驱动模型 1.1.1 概念 ...
- [从源码学设计]蚂蚁金服SOFARegistry之消息总线异步处理
[从源码学设计]蚂蚁金服SOFARegistry之消息总线异步处理 目录 [从源码学设计]蚂蚁金服SOFARegistry之消息总线异步处理 0x00 摘要 0x01 为何分离 0x02 业务领域 2 ...
- [从源码学设计]蚂蚁金服SOFARegistry之存储结构
[从源码学设计]蚂蚁金服SOFARegistry之存储结构 目录 [从源码学设计]蚂蚁金服SOFARegistry之存储结构 0x00 摘要 0x01 业务范畴 1.1 缓存 1.2 DataServ ...
- [从源码学设计]蚂蚁金服SOFARegistry之推拉模型
[从源码学设计]蚂蚁金服SOFARegistry之推拉模型 目录 [从源码学设计]蚂蚁金服SOFARegistry之推拉模型 0x00 摘要 0x01 相关概念 1.1 推模型和拉模型 1.1.1 推 ...
- [从源码学设计]蚂蚁金服SOFARegistry之时间轮的使用
[从源码学设计]蚂蚁金服SOFARegistry之时间轮的使用 目录 [从源码学设计]蚂蚁金服SOFARegistry之时间轮的使用 0x00 摘要 0x01 业务领域 1.1 应用场景 0x02 定 ...
- [从源码学设计]蚂蚁金服SOFARegistry 之 自动调节间隔周期性任务
[从源码学设计]蚂蚁金服SOFARegistry 之 自动调节间隔周期性任务 目录 [从源码学设计]蚂蚁金服SOFARegistry 之 自动调节间隔周期性任务 0x00 摘要 0x01 业务领域 0 ...
随机推荐
- Java蓝桥杯——排序练习：选美大赛
选美大赛 在选美大奖赛的半决胜赛现场,有一批选手参加比赛,比赛的规则是最后得分越高,名次越低.当半决决赛结束时,要在现场按照选手的出场顺序宣布最后得分和最后名次,获得相同分数的选手具有相同的名次,名次 ...
- 记录一下超大list引起oom
1.2g的堆内存 比较大的对象20w个,oom
- C语言实现聊天室(windows版本)
来源:微信公众号「编程学习基地」 目录 C语言聊天室 运行效果 分析设计 多线程 线程的同步 服务端设计 遇到的问题 C语言聊天室 基于 tcp 实现群聊功能,本项目设计是在windows环境下基于套 ...
- 20200416_Centos 7.2 在安装系统之前把数据备份出来
第一种方法: 起因: 服务器强制断电, 然后就再也启动不起来了, 进入救援模式, 一直卡死在 charoot /mnt/sysimages; 然后想在救援模式下的shell中挂载我的2T的移动硬盘, ...
- 哀悼疫情，全站灰色如何实现，CSS滤镜一行代码实现
庚子清明,以国家之名哀悼,以国家之名哀悼在新冠肺炎疫情中牺牲的烈士和逝世的同胞! 向抗疫英雄致敬! 今日打开各样的app,各大电商,爱奇艺都是灰色的 这里我也一直很好奇该功能,前端如何实现,了解过后发 ...
- c++11-17 模板核心知识（十五）—— 解析模板之依赖型类型名称与typename Dependent Names of Types
模板名称的问题及解决 typename规则 C++20 typename 上篇文章c++11-17 模板核心知识(十四)-- 解析模板之依赖型模板名称 Dependent Names of Templ ...
- Scrum冲刺_Day03
一.团队展示: 1.项目:light_note备忘录 2.队名:删库跑路队 3.团队成员 队员(不分先后) 项目角色 黄敦鸿 后端工程师.测试 黄华 后端工程师.测试 黄骏鹏 后端工程师.测试 黄源钦 ...
- 2020中国.NET开发者峰会主题内容发布
2020年12月09日,组委会正式发布了China .NET Conf 2020中国 .NET 开发者峰会的主题内容. 今年的大会主题收到超预期的主题,无论是数量还是质量上都比2019年有所进步,这也 ...
- 【题解】「UVA11626」Convex Hull
凸包模板题. 之前写过拿 Graham 算法求凸包的,为了不重复/多学点知识,那这次拿 Andrew 算法求凸包吧qaq *此文章所有图片均为作者手画. Andrew 算法 假设我们有这些点: 首先把 ...
- 函数动态参数 *args **kwargs
def f1(*args,**kwargs): print(args,type(args)) print(kwargs,type(kwargs))li = [11,22,33]dic = {'k1': ...