不这样做，同名互踢容易踩坑！-优快云博客

本文链接：https://blog.youkuaiyun.com/csdnnews/article/details/103775712

作者 | 张超

责编 | 伍杏玲

出品 | 优快云（ID：优快云news）

最近我在做连接服务的结构调整，梳理到其中的一个功能点：同账号连续登录，旧的连接会被新的连接踢掉的功能。

第一个感觉这是个简单的需求点，不就是新的建立好了，然后把旧的连接踢掉？

可仔细想想就会发现一个问题：是在新的连接建立好了再踢掉旧的连接还是先踢掉旧的连接，然后再建立新的连接呢？如果存在多个同时进行的新连接呢，是不是就有数据竞争了？如果集群要是有多个机房，多个集群该如何高效的实现这个功能点？

如何既要考虑功能的实现，又要考虑工程实现的复杂程度以及后续的维护成本，是否满足对服务的整体服务质量的要求？在本文中，我和大家一起探讨下。

功能需求的描述

同一个账号（这里的同一个账号，指的是系统的唯一识别码，如果系统支持同一个账号的多端登录，则指的式特定的某一个端）登录系统时，后登录的连接保留，而之前建立的连接将默认被踢掉（断开连接，只是断开的原因是踢掉）。踢掉旧的连接之后主要达到下面的两个效果：

1、新连接能够正常的进行操作。

一般的操作是新连接会覆盖旧连接，在这种情况下，不会影响新连接的所有工作。在通常的实现下，确实是这样的，覆盖之后肯定旧连接没法正常找到，所以发送给连接的数据能够正常到达新的连接上。

但有些系统为了保证连接的活跃性，采用的连接是定时进行刷新自己的连接信息。在这种情况下，就会出现新连接被覆盖的情况，具体关于连接的维护的后续的文章中在详细的介绍。

2、旧连接不能再发送或者接收任何的数据。

如果不踢掉的话，旧的连接至少能够进行数据上传，该数据在特定的场景下就会带来业务上的不一致性，甚至是错误；当然这种情况下收到数据也是有可能的，1中描述的实现策略是一种情况，我接触的发布订阅的模型就是新的订阅默认是不会覆盖旧的订阅，所以是两者共存。

实现方案

下面介绍几种解决方案，并进行优缺点比较。该文章中的数据均是基于Erlang版本，其他的编程语言除去第一种之外都是一样的。

一、利用可比较的程序标识实现：

%% 新创建连接的逻辑
open_session(SID, User, Server, Resource, Priority, Info) ->
    set_session(SID, User, Server, Resource, Priority, Info),
    check_for_sessions_to_replace(User, Server, Resource),
    JID = jid:make(User, Server, Resource),
    ejabberd_hooks:run(sm_register_connection_hook,
                       JID#jid.lserver, [SID, JID, Info]).

%% 设置新的连接信息,新的连接信息是可以存储在不同的数据库中,目前在ejabberd的实现中就
%% 已经支持了mnesia,redis,mysql,postgresql等数据库的实现
set_session(SID, User, Server, Resource, Priority, Info) ->
    LUser = jid:nodeprep(User),
    LServer = jid:nameprep(Server),
    LResource = jid:resourceprep(Resource),
    US = {LUser, LServer},
    USR = {LUser, LServer, LResource},
    set_session(#session{sid = SID, usr = USR, us = US,
                         priority = Priority, info = Info}).

-spec set_session(#session{}) -> ok | {error, any()}.
set_session(#session{us = {LUser, LServer}} = Session) ->
    Mod = get_sm_backend(LServer),
    case Mod:set_session(Session) of
        ok ->
            case use_cache(Mod, LServer) of
                true ->
                    ets_cache:delete(?SM_CACHE, {LUser, LServer},
                                     cache_nodes(Mod, LServer));
                false ->
                    ok
            end;
        {error, _} = Err ->
            Err
    end.

%% 检查已经存在的连接,如果检测到连接已经是离线的状态,就直接进行删除相应的连接信息
%% 连接是在线的状态的话,则保留最大的连接,其他的连接则踢掉(这里通过下面的replaced消息处理)
check_for_sessions_to_replace(User, Server, Resource) ->
    LUser = jid:nodeprep(User),
    LServer = jid:nameprep(Server),
    LResource = jid:resourceprep(Resource),
    check_existing_resources(LUser, LServer, LResource),
    check_max_sessions(LUser, LServer).

-spec check_existing_resources(binary(), binary(), binary()) -> ok.
check_existing_resources(LUser, LServer, LResource) ->
    Mod = get_sm_backend(LServer),
    Ss = get_sessions(Mod, LUser, LServer, LResource),
    if Ss == [] -> ok;
       true ->
            SIDs = [SID || #session{sid = SID} <- Ss],
            MaxSID = lists:max(SIDs),
            lists:foreach(fun ({_, Pid} = S) when S /= MaxSID ->
                                  ejabberd_c2s:route(Pid, replaced);
                              (_) -> ok
                          end,
                          SIDs)
    end.

%% 生成连接的唯一ID,这里加入了时间戳,而且是单调递增的数据
%% self()加入到sid中,能够保证sid的唯一性,pid在erlang中是能够保证唯一性的,具体的
%% 实现原理有兴趣可以自行查找
make_sid() ->
    {misc:unique_timestamp(), self()}.

%% misc.erl
unique_timestamp() ->
    {MS, S, _} = erlang:timestamp(),
    {MS, S, erlgang:unique_integer([positive, monotonic]) rem 1000000}.

原理说明：

1. 设置新的连接信息是这段代码中的set_session()方法；

2. 查找已经存在的连接是代码中的get_sessions()，并没有列出完整的实现；

3. 踢掉旧的连接，通过上一步查到的所有连接，根据连接的大小关系，除了最大的连接保留之外，其他的所有连接都执行踢掉的逻辑。

关键点的说明：

1. 连接的唯一识别从单一的账号信息，添加了一个唯一识别码（即代码中的sid），有了这个识别标志之后，在写入新的连接数据同时，不会覆盖原有的旧连接，进而保证了后续的连接清理工作。

2. 在连接信息中添加了一个可进行比较的字段sid，有了这规则之后，无论怎样的踢掉操作都能够保证竞争的双方保留的结果是一致的。即使在竞争的情况下，也不会出现删除错误的情况。

3. 下面列举了一些可能的时序场景：

（1）正常的登录场景

（2）登录过程在setSession之后之后被其他的登录过程打断：

（3）新的登录过程插入到另一个登录过程中：

（4）虽然业务是A是先执行setSession但是,但是写入的sid却比后写入的sid要大，比如A在写入时网络延时很大等情况都有可能出现如下的情况：

二、利用独立的锁结构实现

%% 1. 获取新键连接的锁,获取到相应的锁之后
%% 2. 踢掉之前已经存在的旧连接
%% 3. 初始化新的连接
open_session(true, ClientInfo = #{clientid := ClientId}, ConnInfo) ->
    CleanStart = fun(_) ->
                         ok = discard_session(ClientId),
                         %% 具体的初始化新连接的具体逻辑
                         Session = emqx_session:init(ClientInfo, ConnInfo),
                         {ok, #{session => Session, present => false}}
                 end,
    %% 这里没有列举获取锁的相关过程,处理完所有的逻辑之后,释放获取的锁
    emqx_cm_locker:trans(ClientId, CleanStart);

%% 根据连接的ClientID找到具体的ChanPid,然后循环执行discard_session
discard_session(ClientId) when is_binary(ClientId) ->
    case lookup_channels(ClientId) of
        [] -> ok;
        ChanPids ->
            lists:foreach(
              fun(ChanPid) ->
                      try
                          discard_session(ClientId, ChanPid)
                      catch
                          _:Error:_Stk ->
                              ?LOG(error, "Failed to discard ~p: ~p", [ChanPid, Error])
                      end
              end, ChanPids)
    end.

%% 具体的操作踢掉的逻辑
discard_session(ClientId, ChanPid) when node(ChanPid) == node() ->
    case get_chan_attrs(ClientId, ChanPid) of
        #{conninfo := #{conn_mod := ConnMod}} ->
            ConnMod:call(ChanPid, discard);
        undefined -> ok
    end;

原理说明如下：

1. 根据连接的标识（ClientID）来获取对应的锁，该锁是排他的，emqx的代码中的锁是程序实现通过集群中广播的方式。

在集群中维护着对应锁，对应的锁可以借助其他的数据库，比如Redis等方式实现同样的锁的功能。不过要注意锁的释放，否则将会影响正常的用户登录。

2. 查找已经存在的连接，踢掉相应的连接。

3. 初始化新创建的连接。