[从源码学设计]蚂蚁金服SOFARegistry网络操作之连接管理

[从源码学设计]蚂蚁金服SOFARegistry网络操作之连接管理

0x00 摘要

SOFARegistry 是蚂蚁金服开源的一个生产级、高时效、高可用的服务注册中心。

本系列文章重点在于分析设计和架构,即利用多篇文章,从多个角度反推总结 DataServer 或者 SOFARegistry 的实现机制和架构思路,让大家借以学习阿里如何设计。

本文为第三篇,介绍SOFARegistry网络操作之连接管理。

0x01 业务领域

上文我们讲解了SOFARegistry的网络封装和操作,本文继续网络相关部分。

虽然SOFABolt底层已经做了连接管理,比如有Manager,pool,但是SOFARegistry在上层结合业务也做了连接管理,很有特色,所以我们专文讲解。

1.1 应用场景

这里我们集中从DataServer角度出发讲解,此处和业务紧密结合。

让我们大致想想DataServer需要管理哪些连接或者类似概念。

  • MetaServer Connection:本DataServer与Meta Server的连接,用来和Meta Server交互;
  • DataServer Connection:本DataServer与其他dataServer的连接,用来数据同步;
  • 扩展开来,其他Data Server节点也需要管理;
  • SessionServer Connection,本DataServer与Session server的连接,这个非常复杂,这里会重点讲解;
  • 在SessionServer方面,又需要区分具体每个Publisher;

这就让我们来思考几个问题:

  • 究竟什么可以唯一标示一个SessionServer?
  • 什么可以唯一标示一个Publisher?ip : port?或者其他?
  • 业务上有没有特殊考虑的需要?

具体我们在后文会详述阿里的思路。

0x02 管理内容

2.1 连接管理

首先讲讲普遍意义的连接管理。

连接管理是网络操作中的核心。我们知道,一次 tcp 请求大致分为三个步骤:建立连接、通信、关闭连接。每次建立新连接都会经历三次握手,中间包含三次网络传输,对于高并发的系统,这是一笔不小的负担;关闭连接同样如此。为了减少每次网络调用请求的开销,对连接进行管理、复用,可以极大的提高系统的性能。

为了提高通信效率,我们需要考虑复用连接,减少 TCP 三次握手的次数,因此需要有连接管理的机制。

关于连接管理,SOFARegistry有两维度层次的连接管理,分别是 Connection 和 Node

2.2 管理内容

普遍意义的连接管理,通常需要处理:

  • 连接创建与销毁
  • 心跳管理
  • 空闲连接管理
  • 断线重连
  • 慢连接处理
  • 作为一个框架,当然还需要把各种连接事件分派给用户进行定制

因为SOFABolt底层已经做了底层连接管理,所以SOFARegistry只要做顶层部分连接管理即可,就是从业务角度区分保存连接

0x03 Connection管理

3.1 Connection对象

这里说的Connection我们特指sofa-bolt的Connection对象

面向连接的TCP协议要求每次peer间通信前建立一条TCP连接,该连接可抽象为一个4元组(four-tuple,有时也称socket pair):socket(localIp, localPort, remoteIp, remotePort ),这4个元素唯一地代表一条TCP连接。

在Netty中用Channel来表示一条TCP连接,在sofa-bolt使用Connection对象来抽象一个连接,一个连接在client跟server端各用一个connection对象表示

有了Connection这个抽象之后,自然的需要提供接口来管理Connection, 这个接口就是ConnectionFactory。

那么Connection是如何跟Netty进行联动呢。我们知道在Netty中,client连接到server后,server会回调initChannel方法,在这个方法我们会初始化各种事件handler,sofa-bolt就在这里创建Connection,并在Netty的Channel对象上打上Connection标,后续通过Channel就可以直接找到这个Connection。

3.2 Connection类定义

Connection其删减版定义如下,可以看到其主要成员就是 Netty channel 实例

public class Connection {

    private Channel                                                               channel;

    private final ConcurrentHashMap<Integer, InvokeFuture>                        invokeFutureMap  = new ConcurrentHashMap<Integer, InvokeFuture>(4);

    /** Attribute key for connection */
    public static final AttributeKey<Connection>                                  CONNECTION       = AttributeKey.valueOf("connection");
  
    /** Attribute key for heartbeat count */
    public static final AttributeKey<Integer>                                     HEARTBEAT_COUNT  = AttributeKey.valueOf("heartbeatCount");

    /** Attribute key for heartbeat switch for each connection */
    public static final AttributeKey<Boolean>                                     HEARTBEAT_SWITCH = AttributeKey.valueOf("heartbeatSwitch");

    /** Attribute key for protocol */
    public static final AttributeKey<ProtocolCode>                                PROTOCOL         = AttributeKey.valueOf("protocol");

    /** Attribute key for version */
    public static final AttributeKey<Byte>                                        VERSION          = AttributeKey.valueOf("version");

    private Url                                                                   url;

    private final ConcurrentHashMap<Integer/* id */, String/* poolKey */>       id2PoolKey       = new ConcurrentHashMap<Integer, String>(256);

    private Set<String>                                                           poolKeys         = new ConcurrentHashSet<String>();

    private final ConcurrentHashMap<String/* attr key*/, Object /*attr value*/> attributes       = new ConcurrentHashMap<String, Object>();
}

省去 AtributeKey 类型定义以及 Log 配置,以上是Connection中主要的成员变量。包括几个方面:

  • 连接:Channel、Url
  • 版本:protocolCode、version
  • 调用:invokeFutureMap
  • 附着:attributes
  • 引用:referenceCount、id2PoolKey、poolKeys

这里提一下 protocolCode 和 version,版本信息会被携带至对端,用于连接的协商。总的来说,通过对于 Channel 的包装,Connection 提供了丰富的上下文及引用信息,是 SOFABolt 连接管理的直接对象

3.3 ConnectionFactory

SOFARegistry建立了ConnectionFactory 连接工厂,负责创建连接、检测连接等。

这里我对Connection进行了种类,分类是我从业务角度出发,强行分为三种Connection,只是为了讲解方便。

  • MetaServerConnectionFactory,是Meta Server的连接,用来和Meta Server交互。
  • DataServerConnectionFactory ,是其他dataServer的连接,用来数据同步;
  • SessionServerConnectionFactory,是Session server的连接,这个非常复杂,后续会重点讲解。

3.4 MetaServerConnectionFactory

MetaServerConnectionFactory 就是用来对com.alipay.remoting.Connection进行连接管理。

其核心变量是一个双层Map,可以理解为一个矩阵,其维度是 Map<dataCenter, Map<ip, Connection>>

其内部函数比较简单,望名生意。

public class MetaServerConnectionFactory {

    private final Map<String, Map<String, Connection>> MAP = new ConcurrentHashMap<>();

    /**
     * @param dataCenter
     * @param ip
     * @param connection
     */
    public void register(String dataCenter, String ip, Connection connection) {

        Map<String, Connection> connectionMap = MAP.get(dataCenter);
        if (connectionMap == null) {
            Map<String, Connection> newConnectionMap = new ConcurrentHashMap<>();
            connectionMap = MAP.putIfAbsent(dataCenter, newConnectionMap);
            if (connectionMap == null) {
                connectionMap = newConnectionMap;
            }
        }

        connectionMap.put(ip, connection);
    }

    /**
     * @param dataCenter
     * @param ip
     */
    public Connection getConnection(String dataCenter, String ip) {
        if (MAP.containsKey(dataCenter)) {
            Map<String, Connection> map = MAP.get(dataCenter);
            if (map.containsKey(ip)) {
                return map.get(ip);
            }
        }
        return null;
    }

    /**
     * @param dataCenter
     */
    public Map<String, Connection> getConnections(String dataCenter) {
        if (MAP.containsKey(dataCenter)) {
            return MAP.get(dataCenter);
        }
        return new HashMap<>();
    }

    /**
     * @param dataCenter
     */
    public Set<String> getIps(String dataCenter) {
        if (MAP.containsKey(dataCenter)) {
            Map<String, Connection> map = MAP.get(dataCenter);
            if (map != null) {
                return map.keySet();
            }
        }
        return new HashSet<>();
    }

    /**
     * @param dataCenter
     */
    public void remove(String dataCenter) {
        Map<String, Connection> map = getConnections(dataCenter);
        if (!map.isEmpty()) {
            for (Connection connection : map.values()) {
                if (connection.isFine()) {
                    connection.close();
                }
            }
        }
        MAP.remove(dataCenter);
    }

    /**
     * @param dataCenter
     * @param ip
     */
    public void remove(String dataCenter, String ip) {
        if (MAP.containsKey(dataCenter)) {
            Map<String, Connection> map = MAP.get(dataCenter);
            if (map != null) {
                map.remove(ip);
            }
        }
    }

    public Set<String> getAllDataCenters() {
        return MAP.keySet();
    }
}

3.5 DataServerConnectionFactory

DataServerConnectionFactory 就是用来对com.alipay.remoting.Connection进行连接管理。

其核心变量是以ip:port作为key,Connection作为value的一个Map

其内部函数比较简单,望名生意。

import com.alipay.remoting.Connection;

/**
 * the factory to hold connections that other dataservers connected to local server
 */
public class DataServerConnectionFactory {

    /**
     * collection of connections
     * key:connectId ip:port
     */
    private final Map<String, Connection> MAP = new ConcurrentHashMap<>();

    /**
     * register connection
     *
     * @param connection
     */
    public void register(Connection connection) {
        MAP.put(getConnectId(connection), connection);
    }

    /**
     * remove connection by specific ip+port
     *
     * @param connection
     */
    public void remove(Connection connection) {
        MAP.remove(getConnectId(connection));
    }

    /**
     * get connection by ip
     *
     * @param ip
     * @return
     */
    public Connection getConnection(String ip) {
        return MAP.values().stream().filter(connection -> ip.equals(connection.getRemoteIP()) && connection.isFine()).findFirst().orElse(null);
    }

    private String getConnectId(Connection connection) {
        return connection.getRemoteIP() + ":" + connection.getRemotePort();
    }
}

3.5.1 注册

当需要管理连接时候,可以通过如下来进行注册。

public void connected(Channel channel) throws RemotingException {
    super.connected(channel);
    dataServerConnectionFactory.register(((BoltChannel) channel).getConnection());
}

这样往ConcurrentHashMap client放入,是根据IP和port构建了url,然后url作为key。

3.5.2 获取

com.alipay.remoting.Connection 可以通过Channel进行获取。

DataNodeExchanger就采用如下方式获取Client。

conn = ((BoltChannel) dataNodeExchanger.connect(new URL(ip, dataServerConfig
    .getSyncDataPort()))).getConnection();

3.5.3 DataSyncServerConnectionHandler

有了注册与获取,接下来我们看看连接事件响应。

DataSyncServerConnectionHandler 是 server 的handler。

前文提到了,DataSyncServerConnectionHandler是连接事件处理器 (ConnectionEventProcessor),用来监听建连事件(ConnectionEventType.CONNECT)与断连事件(ConnectionEventType.CLOSE)。

这里就是针对各种事件,简单的对Connection做相应维护。

public class DataSyncServerConnectionHandler extends AbstractServerHandler {
    @Autowired
    private DataServerConnectionFactory dataServerConnectionFactory;

    @Override
    public ChannelHandler.HandlerType getType() {
        return ChannelHandler.HandlerType.LISENTER;
    }

    @Override
    public void connected(Channel channel) throws RemotingException {
        super.connected(channel);
        dataServerConnectionFactory.register(((BoltChannel) channel).getConnection());
    }

    @Override
    public void disconnected(Channel channel) throws RemotingException {
        super.disconnected(channel);
        dataServerConnectionFactory.remove(((BoltChannel) channel).getConnection());
    }

    @Override
    protected Node.NodeType getConnectNodeType() {
        return Node.NodeType.DATA;
    }
}

3.6 SessionServerConnectionFactory

SessionServerConnectionFactory 包括复杂的逻辑。

3.6.1 问题

回顾前面问题:

  • 究竟什么可以唯一标示一个SessionServer?
  • 什么可以唯一标示一个Publisher?
  • ip : port?或者其他?
  • 业务上有没有特殊考虑的需要?

下面我们就一一看看阿里如何处理。

3.6.2 逻辑概念和关系

首先要讲讲阿里的几个逻辑概念:

  • process Id 代表了Session Server,格式是类似uid的构建,每个Session Server有一个唯一的process Id,Session Server与process Id是一对一的关系;
  • Connection 就是一个 Session Server 和 Data Server 之间的 Connection;
  • connect Id 代表了Publisher,格式是 ip : port。connect Id与Publisher是一对一的关系;
  • 一个Session Server包括许多Publiser,即许多connection id;
  • Session Server address 是一个 ip : port 的组合,代表一个 Connection 的 session server 那一端;
  • 一个 Session Server 可能对于一个data Server有多个连接;这个目前原因不知,没有发现业务原因,可能推测如下:因为连接敏感性,网络不稳定性,所以SOFABolt重连时候会选择一个新端口,所以会有多个Connection存在。所以一个processID对应多个sessionConnAddress;

具体就是,SOFARegistry 将服务数据 (PublisherRegister) 和 服务发布者 (Publisher) 的连接的生命周期绑定在一起:每个 PublisherRegister 定义属性 connId,connId 由注册本次服务的 Publisher 的连接标识 (IP 和 Port)构成,也就是只要该 Publisher 和 SessionServer 断连,服务信息数据即失效。客户端重新建连成功后重新注册服务数据,重新注册的服务数据会被当成新的数据,考虑更换长连接后 Publisher 的 connId 是 Renew 新生成的。

3.6.3 示例图

我们假设一个Session server内部有两个 Publisher,都连接到一个Data Server上。

这些 address 格式都是 ip : port,举例如下:

  • SessionServer address 1 是 :1.1.2.3 : 1

  • SessionServer address 2 是 :1.1.2.3 : 2

  • SessionServer address 3 是 :1.1.2.3 : 3

  • SessionServer address 4 是 :1.1.2.3 : 4

  • DataServer address 1 是 :2.2.2.3 : 1

  • DataServer address 2 是 :2.2.2.3 : 2

具体逻辑如图:

    +----------+                        +----------+
    |  Client  |                        |  Client  |
    +----+-----+                        +----+-----+
         |                                   |
         |                                   |
         |                                   |
         |                                   |
         |  SessionServer address 1          |   SessionServer address 2
         v                                   v
+--------+-----------------------------------+----------------+
|                Session Server(process Id)                   |
|                                                             |
| +------------------------+        +-----------------------+ |
| |  Publisher(connect Id) |  ...   | Publisher(connect Id) | |
| +------------------------+        +-----------------------+ |
+-------------------------------------------------------------+
         | SessionServer address 3                  |  SessionServer address 4
         |                                          |
         |                                          |
         |                                          |
         |                                          |
         +---------->  +---------------+  <---------+
DataServer address 1   |  Data Server  |    DataServer address 2
                       +---------------+

3.6.4 主要变量

所以,SessionServerConnectionFactory的几个变量就对应了上述这些逻辑关系,具体如下:

  • SESSION_CONN_PROCESS_ID_MAP : Map<SessionServer address, SessionServer processId>,这个代表了怎么从 SessionServer address 找到 SessionServer processId,是一对一的关系;
  • PROCESS_ID_CONNECT_ID_MAP : Map<SessionServer processId, Set<ip:port of clients> >,这个代表了一个Session Server 包括了哪些Publiser
  • PROCESS_ID_SESSION_CONN_MAP : Map<SessionServer processId, pair(SessionServer address, SessionServer connection)>,这代表了一个 Session Server 包括哪些 Connection,每个Connection 被其Session Server 端的address 唯一确定;

这些都代表了本 Data Server 和 其 Session Server 之间的关系

+-----------------------------------------------------------------------------------------+     +--------------------------------+
|  SessionServerConnectionFactory                                                         |     |        SessionServer           |
|                                                                                         |     |                                |
|                                                                                         |     |   +-------------------------+  |
|  +---------------------------------------------------------+                            |     |   |   SessionServer address |  |
|  | SESSION_CONN_PROCESS_ID_MAP                             |                            |     |   |                         |  |
|  |                                                         |                            |     |   |  +----------------+     |  |
|  |                                                         | +----------------------------------->+  |   process Id   |     |  |
|  |    Map<SessionServer address, SessionServer processId>  |                            |     |   +-------------------------+  |
|  |                                                         |                            |     |      |                |        |
|  +---------------------------------------------------------+                            |     |      |   Publisher    |        |
|                                                                                         |     |      +--+-------------+        |
|                                                                                         |     |         ^                      |
|   +---------------------------------------------------------+                           |     |         |                      |
|   | PROCESS_ID_CONNECT_ID_MAP                               |                           |     +------------------------+-------+
|   |                                                         |                           |               |              ^
|   | Map<SessionServer processId, Set<ip:port of clients> >  +-------------------------------------------+              |
|   |                                                         |                           |                              |
|   +---------------------------------------------------------+                           |                              |
|                                                                                         |                              |
|                                                                                         |                              |
|  +------------------------------------------------------------------------------------+ |       +------------+         |
|  |PROCESS_ID_SESSION_CONN_MAP                                                         +-------> | Connection +---------+
|  |                                                                                    | |       +------------+
|  |                                                                                    | |
|  |Map<SessionServer processId, pair(SessionServer address, SessionServer connection)> | |
|  |                                                                                    | |
|  +------------------------------------------------------------------------------------+ |
+-----------------------------------------------------------------------------------------+

手机上如下图:

在这里插入图片描述

具体类定义如下:

public class SessionServerConnectionFactory {

    private static final int               DELAY                       = 30 * 1000;
    private static final Map               EMPTY_MAP                   = new HashMap(0);

    /**
     * key  :   SessionServer address
     * value:   SessionServer processId
     */
    private final Map<String, String>      SESSION_CONN_PROCESS_ID_MAP = new ConcurrentHashMap<>();

    /**
     * key  :   SessionServer processId
     * value:   ip:port of clients
     */
    private final Map<String, Set<String>> PROCESS_ID_CONNECT_ID_MAP   = new ConcurrentHashMap<>();

    /**
     * key  :   SessionServer processId
     * value:   pair(SessionServer address, SessionServer connection)
     */
    private final Map<String, Pair>        PROCESS_ID_SESSION_CONN_MAP = new ConcurrentHashMap<>();

    @Autowired
    private DisconnectEventHandler         disconnectEventHandler;
}

3.6.5 Pair

这是SessionServerConnectionFactory的内部类。

PROCESS_ID_SESSION_CONN_MAP是 Map<SessionServer processId, pair(SessionServer address, SessionServer connection)>,代表了一个 Session Server 包括哪些Connection,每个Connection 被其Session Server 端的address 唯一确定。

Pair就是SessionServer address, SessionServer connection的组合,定义如下:

private static class Pair {
    private AtomicInteger           roundRobin = new AtomicInteger(-1);
    private Map<String, Connection> connections;
    private String                  lastDisconnectedSession;

    private Pair(Map<String, Connection> connections) {
        this.connections = connections;
    }

    @Override
    public boolean equals(Object o) {
        return connections.equals(((Pair) o).getConnections())
               && (((Pair) o).lastDisconnectedSession.equals(lastDisconnectedSession));
    }

    /**
     * Getter method for property <tt>connections</tt>.
     * @return property value of connections
     */
    private Map<String, Connection> getConnections() {
        return connections;
    }
}

当生成时,Session Server 端的address,这是由InetSocketAddress转换而来。此类用于实现 IP 套接字地址 (IP 地址+端口号),用于socket 通信;

public void registerSession(String processId, Set<String> connectIds, Connection connection) {
    String sessionConnAddress = NetUtil.toAddressString(connection.getRemoteAddress());

    SESSION_CONN_PROCESS_ID_MAP.put(sessionConnAddress, processId);

    Set<String> connectIdSet = PROCESS_ID_CONNECT_ID_MAP
            .computeIfAbsent(processId, k -> ConcurrentHashMap.newKeySet());
    connectIdSet.addAll(connectIds);

    Pair pair = PROCESS_ID_SESSION_CONN_MAP.computeIfAbsent(processId, k -> new Pair(new ConcurrentHashMap<>()));
    pair.getConnections().put(sessionConnAddress, connection);
}

3.6.6 processId

processId是在Session Server之中生成,可以看出,是IP,时间戳,循环递增整数构建。这样就可以唯一确定一个SessionServer。

public class SessionProcessIdGenerator {
    /**
     * Generate session processId.
     */
    public static String generate() {
        String localIp = NetUtil.getLocalSocketAddress().getAddress().getHostAddress();
        if (localIp != null && !localIp.isEmpty()) {
            return getId(getIPHex(localIp), System.currentTimeMillis(), getNextId());
        }
        return EMPTY_STRING;
    }
}

3.7 SessionServerConnectionFactory业务流程

因为高层连接管理与业务密切耦合,所以我们接下来分析业务。看看调用 SessionServerConnectionFactory的业务流程。

具体registerSession从何处调用,这就涉及到两个消息:SessionServerRegisterRequest 和PublishDataRequest。即有两个途径会调用。而且业务涉及到Session Server与DataServer

3.7.1 SessionServerRegisterRequest

当重新连接的时候,会统一注册 Session Server 本身包含的所有Publisher。对应在Session Server之中,如下可以看到:

  • 从sessionServer获取connectIds。
  • 建立SessionServerRegisterRequest,然后发送。

代码如下:

public class SessionRegisterDataTask extends AbstractSessionTask {
    @Override
    public void setTaskEvent(TaskEvent taskEvent) {

        //taskId create from event
        if (taskEvent.getTaskId() != null) {
            setTaskId(taskEvent.getTaskId());
        }

        Object obj = taskEvent.getEventObj();

        if (obj instanceof BoltChannel) {
            this.channel = (BoltChannel) obj;
        } 
        Server sessionServer = boltExchange.getServer(sessionServerConfig.getServerPort());

        if (sessionServer != null) {

            Collection<Channel> chs = sessionServer.getChannels();
            Set<String> connectIds = new HashSet<>();
            chs.forEach(channel -> connectIds.add(NetUtil.toAddressString(channel.getRemoteAddress())));

            sessionServerRegisterRequest = new SessionServerRegisterRequest(
                    SessionProcessIdGenerator.getSessionProcessId(), connectIds);
        } 
    }
}

来到DataServer,SessionServerRegisterHandler会进行处理调用,用到了sessionServerConnectionFactory。

public class SessionServerRegisterHandler extends
                                         AbstractServerHandler<SessionServerRegisterRequest> {
    @Override
    public Object doHandle(Channel channel, SessionServerRegisterRequest request) {
        Set<String> connectIds = request.getConnectIds();
        if (connectIds == null) {
            connectIds = new HashSet<>();
        }
        sessionServerConnectionFactory.registerSession(request.getProcessId(), connectIds,
            ((BoltChannel) channel).getConnection());
        return CommonResponse.buildSuccessResponse();
    }
}

3.7.2 PublishDataRequest

当注册Publisher时候。在Session Server之中,可以看到建立了请求。

private Request<PublishDataRequest> buildPublishDataRequest(Publisher publisher) {
    return new Request<PublishDataRequest>() {
        private AtomicInteger retryTimes = new AtomicInteger();

        @Override
        public PublishDataRequest getRequestBody() {
            PublishDataRequest publishDataRequest = new PublishDataRequest();
            publishDataRequest.setPublisher(publisher);
            publishDataRequest.setSessionServerProcessId(SessionProcessIdGenerator
                .getSessionProcessId());
            return publishDataRequest;
        }

        @Override
        public URL getRequestUrl() {
            return getUrl(publisher.getDataInfoId());
        }

        @Override
        public AtomicInteger getRetryTimes() {
            return retryTimes;
        }
    };
}

在data server之中,会调用处理,用到了sessionServerConnectionFactory。

public class PublishDataHandler extends AbstractServerHandler<PublishDataRequest> {
    @Override
    public Object doHandle(Channel channel, PublishDataRequest request) {
        Publisher publisher = Publisher.internPublisher(request.getPublisher());
        if (forwardService.needForward()) {
            CommonResponse response = new CommonResponse();
            response.setSuccess(false);
            response.setMessage("Request refused, Server status is not working");
            return response;
        }

        dataChangeEventCenter.onChange(publisher, dataServerConfig.getLocalDataCenter());

        if (publisher.getPublishType() != PublishType.TEMPORARY) {
            String connectId = WordCache.getInstance().getWordCache(
                publisher.getSourceAddress().getAddressString());
            sessionServerConnectionFactory.registerConnectId(request.getSessionServerProcessId(),
                connectId);
            // record the renew timestamp
            datumLeaseManager.renew(connectId);
        }

        return CommonResponse.buildSuccessResponse();
    }  
}

3.7.3 DatumLeaseManager

上述代码提到了DatumLeaseManager,这里可以看到就是对connectId,即Publisher进行续约

  • connectIdRenewTimestampMap : 记录了renew时间;

  • locksForConnectId :只有一个task能够更新;

renew 函数记录本次renew时间戳,启动evict task,如果到期没有renew,就去除。

public class DatumLeaseManager implements AfterWorkingProcess {
    /** record the latest heartbeat time for each connectId, format: connectId -> lastRenewTimestamp */
    private final Map<String, Long>            connectIdRenewTimestampMap = new ConcurrentHashMap<>();

    /** lock for connectId , format: connectId -> true */
    private ConcurrentHashMap<String, Boolean> locksForConnectId          = new ConcurrentHashMap();
  
    /**
     * record the renew timestamp
     */
    public void renew(String connectId) {

        // record the renew timestamp
        connectIdRenewTimestampMap.put(connectId, System.currentTimeMillis());
        // try to trigger evict task
        scheduleEvictTask(connectId, 0);
    }

}

0x04 节点管理

除了具体连接之外,SOFARegistry也对Data 节点进行另一个维度的连接管理。具体在DataServerNodeFactory完成。

4.1 DataServerNodeFactory

4.1.1 DataServerNode

就是简单的数据结构,没有建立Bean。

public class DataServerNode implements HashNode {

    private String     ip;

    private String     dataCenter;

    private Connection connection;
}

4.1.2 DataServerNodeFactory

对应Node的连接管理 则是 DataServerNodeFactory。

在具体模块控制上,DataServerNodeFactory拥有自己的Bean。DataServerConnectionFactory 则全部是Static类型,直接static使用

DataServerNodeFactory的关键变量有两个:

  • MAP是以dataCenter和ip作为维度的一个Node矩阵,是数据节点相关数据;
  • CONSISTENT_HASH_MAP则是用dataCenter作为key,ConsistentHash作为value的Map;

具体定义如下:

public class DataServerNodeFactory {
    /**
     * row:     dataCenter
     * column:  ip
     * value    dataServerNode
     */
    private static final Map<String, Map<String, DataServerNode>>    MAP                 = new ConcurrentHashMap<>();

    /**
     * key:     dataCenter
     * value:   consistentHash
     */
    private static final Map<String, ConsistentHash<DataServerNode>> CONSISTENT_HASH_MAP = new ConcurrentHashMap<>();
}

4.2 业务流程

4.2.1 注册

具体在LocalDataServerChangeEventHandler 和 DataServerChangeEventHandler 全都有涉及。

public class LocalDataServerChangeEventHandler extends
                                            AbstractEventHandler<LocalDataServerChangeEvent> {
       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;
                } 
            }

            //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);
        }
    }
}

以及

public class DataServerChangeEventHandler extends AbstractEventHandler<DataServerChangeEvent> {
   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);
            }
        }
        //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);
    }
}

4.2.2 使用

使用就是从MAP与CONSISTENT_HASH_MAP中提取Node,这里把从CONSISTENT_HASH_MAP提取的代码摘录如下:

/**
 * get dataserver by specific datacenter and dataInfoId
 *
 * @param dataCenter
 * @param dataInfoId
 * @return
 */
public static DataServerNode computeDataServerNode(String dataCenter, String dataInfoId) {
    ConsistentHash<DataServerNode> consistentHash = CONSISTENT_HASH_MAP.get(dataCenter);
    if (consistentHash != null) {
        return consistentHash.getNodeFor(dataInfoId);
    }
    return null;
}

public static List<DataServerNode> computeDataServerNodes(String dataCenter, String dataInfoId,
                                                          int backupNodes) {
    ConsistentHash<DataServerNode> consistentHash = CONSISTENT_HASH_MAP.get(dataCenter);
    if (consistentHash != null) {
        return consistentHash.getNUniqueNodesFor(dataInfoId, backupNodes);
    }
    return null;
}

0x05 总结

因为SOFABolt底层已经做了底层连接管理,所以SOFARegistry只要做顶层部分连接管理即可,就是从业务角度区分注册,保存,获取连接。具体就是:

  • Connection 就是一个 Session Server 和 Data Server 之间的 Connection;
  • 一个 Session Server 可能对于一个data Server有多个连接;
  • 一个Session Server包括许多Publiser;
  • Connection与Publiser一一对应;

SOFARegistry 将服务数据 (PublisherRegister) 和 服务发布者 (Publisher) 的连接的生命周期绑定在一起:每个 PublisherRegister 定义属性 connId,connId 由注册本次服务的 Publisher 的连接标识 (IP 和 Port)构成。

只要该 Publisher 和 SessionServer 断连,服务信息数据即失效。客户端重新建连成功后重新注册服务数据,重新注册的服务数据会被当成新的数据,考虑更换长连接后 Publisher 的 connId 是 Renew 新生成的。

如下图所示:

                 +----------+                        +----------+
                 |  Client  |                        |  Client  |
                 +----+-----+                        +----+-----+
                      |                                   |
                      |                                   |
                      |                                   |
                      |                                   |
                      |                                   |
                      |                                   |
             +-------------------------------------------------------------+
             |        |       Session Server(process Id)  |                |
             |        v                                   v                |
             | +------+-----------------+        +--------+--------------+ |
             | |  Publisher(connect Id) |  ...   | Publisher(connect Id) | |
             | +------------------------+        +-----------------------+ |
             +-------------------------------------------------------------+
                      |                                          |
                      |                                          |
                      | Connection                    Connection |
                      |                                          |
                      |                                          |
                      |                                          |
                      v                                          v
+---------------------+------------------------------------------+--------------------+
|  Data Server                                                                        |
|                                                                                     |
|                  Map<SessionServer address, SessionServer processId>                |
|                                                                                     |
|                  Map<SessionServer processId, Set<ip:port of clients> >             |
|                                                                                     |
| Map<SessionServer processId, pair(SessionServer address, SessionServer connection)> |
|                                                                                     |
+-------------------------------------------------------------------------------------+

0xFF 参考

https://timyang.net/architecture/cell-distributed-system/

SOFABolt 源码分析12 - Connection 连接管理设计

SOFABolt 源码分析2 - RpcServer 服务端启动的设计

SOFABolt 源码分析3 - RpcClient 客户端启动的设计

★★★★★★关于生活和技术的思考★★★★★★

微信公众账号:罗西的思考

如果您想及时得到个人撰写文章的消息推送,或者想看看个人推荐的技术资料,可以扫描下面二维码(或者长按识别二维码)关注个人公众号)。

在这里插入图片描述

已标记关键词 清除标记
©️2020 CSDN 皮肤主题: 游动-白 设计师:上身试试 返回首页