• Erlang节点重启导致的incarnation问题（转）

    转自霸爷的博客：

     转载自系统技术非业余研究

    本文链接地址: Erlang节点重启导致的incarnation问题

    遇到个问题，

    =ERROR REPORT==== 10-Mar-2016::09:44:07 ===
    Discarding message {'$gen_cast',close_be_covered} from <0.771.0> to <0.774.0> in an old incarnation (2) of this node (3)

     网上查阅了霸爷的博客，对该问题脑洞大开.

    今天晚上mingchaoyan同学在线上问以下这个问题：

    152489 =ERROR REPORT==== 2013-06-28 19:57:53 ===
    152490 Discarding message {send,<<19 bytes>>} from <0.86.1> to <0.6743.0> in an old incarnation (1 ) of this node (2)
    152491
    152492
    152493 =ERROR REPORT==== 2013-06-28 19:57:55 ===
    152494 Discarding message {send,<<22 bytes>>} from <0.1623.1> to <0.6743.0> in an old incarnation (1) of this node (2

    我们中午服务器更新后，日志上满屏的这些错误，请问您有遇到过类似的错误吗？或者提过些定位问题，解决问题的思路，谢谢

    这个问题有点意思，从日志提示来再结合源码来看，马上我们就可以找到打出这个提示的地方：

    /*bif.c*/
    Sint
    do_send(Process *p, Eterm to, Eterm msg, int suspend) {
        Eterm portid;
    ...
    } else if (is_external_pid(to)) {
            dep = external_pid_dist_entry(to);
            if(dep == erts_this_dist_entry) {
                erts_dsprintf_buf_t *dsbufp = erts_create_logger_dsbuf();
                erts_dsprintf(dsbufp,
                              "Discarding message %T from %T to %T in an old "
                              "incarnation (%d) of this node (%d) ",
                              msg,
                              p->id,
                              to,
                              external_pid_creation(to),
                              erts_this_node->creation);
                erts_send_error_to_logger(p->group_leader, dsbufp);
                return 0;
            }
    ..
    }

    触发这句警告提示必须满足以下条件：
    1. 目标Pid必须是external_pid。
    2. 该pid归宿的外部节点所对应的dist_entry和当前节点的dist_entry相同。

    通过google引擎，我找到了和这个描述很相近的问题：参见 这里 ，该作者很好的描述和重现了这个现象，但是他没有解释出具体的原因。

    好，那我们顺着他的路子来重新下这个问题.
    但演示之前，我们先巩固下基础，首先需要明白pid的格式：
    可以参见这篇文章：

    pid的核心内容摘抄如下：

    Printed process ids < A.B.C > are composed of [6]:
    A, the node number (0 is the local node, an arbitrary number for a remote node)
    B, the first 15 bits of the process number (an index into the process table) [7]
    C, bits 16-18 of the process number (the same process number as B) [7]

    再参见Erlang External Term Format 文档的章节9.10
    描述了PID_EXT的组成：

    1 N 4 4 1
    103 Node ID Serial Creation
    Table 9.16:
    Encode a process identifier object (obtained from spawn/3 or friends). The ID and Creation fields works just like in REFERENCE_EXT, while the Serial field is used to improve safety. In ID, only 15 bits are significant; the rest should be 0.


    我们可以看到一个字段 Creation， 这个东西我们之前怎么没见过呢？
    参考erlang的文档 我们可以知道：

    creation
    Returns the creation of the local node as an integer. The creation is changed when a node is restarted. The creation of a node is stored in process identifiers, port identifiers, and references. This makes it (to some extent) possible to distinguish between identifiers from different incarnations of a node. Currently valid creations are integers in the range 1..3, but this may (probably will) change in the future. If the node is not alive, 0 is returned.

    追踪这个creation的来源，我们知道这个变量来自epmd. 具体点的描述就是每次节点都会像epmd注册名字，epmd会给节点返回这个creation. net_kernel会把这个creation通过set_node这个bif登记到该节点的erts_this_dist_entry->creation中去:

    /* erl_node_tables.c */
    void
    erts_set_this_node(Eterm sysname, Uint creation)
    {
    ...
        erts_this_dist_entry->sysname = sysname;
        erts_this_dist_entry->creation = creation;
    ...
    }
     
    /*epmd_srv.c  */
    ...
            /* When reusing we change the "creation" number 1..3 */
     
            node->creation = node->creation % 3 + 1;
    ...

    从上面的代码可以看出creation取值是1-3，每次登记的时候+1. 未联网的节点creation为0.

    知道了createion的来龙去脉后，我们再看下DistEntry的数据结构，这个数据结构基本上代表了联网的节点和外面世界的交互。

    typedef struct dist_entry_ {
    …
    Eterm sysname; /* name@host atom for efficiency */
    Uint32 creation; /* creation of connected node */
    Eterm cid; /* connection handler (pid or port), NIL == free
    …
    } DistEntry;
    其中最重要的信息有上面3个，其中cid代表port(节点之间的TCP通道).

    我们知道外部pid是通过binary_to_term来构造的， 代码位于external.c:dec_pid函数。

    static byte*
    dec_pid(ErtsDistExternal *edep, Eterm** hpp, byte* ep, ErlOffHeap* off_heap, Eterm* objp)
    {
     ...
        /*                                                                                                                   
         * We are careful to create the node entry only after all                                                            
         * validity tests are done.                                                                                          
         */
        node = dec_get_node(sysname, cre);
     
        if(node == erts_this_node) {
            *objp = make_internal_pid(data);
        } else {
            ExternalThing *etp = (ExternalThing *) *hpp;
            *hpp += EXTERNAL_THING_HEAD_SIZE + 1;
     
            etp->header = make_external_pid_header(1);
            etp->next = off_heap->first;
            etp->node = node;
            etp->data.ui[0] = data;
     
            off_heap->first = (struct erl_off_heap_header*) etp;
            *objp = make_external_pid(etp);
        }
    ...
    }
    static ERTS_INLINE ErlNode* dec_get_node(Eterm sysname, Uint creation)
    {
        switch (creation) {
        case INTERNAL_CREATION:
            return erts_this_node;
        case ORIG_CREATION:
            if (sysname == erts_this_node->sysname) {
                creation = erts_this_node->creation;
            }
        }
        return erts_find_or_insert_node(sysname,creation);
    }

    如果creation等0的话，肯定是本地节点，否则根据sysname和creation来找到一个匹配的节点。
    继续上代码：

    typedef struct erl_node_ {
      HashBucket hash_bucket;       /* Hash bucket */
      erts_refc_t refc;             /* Reference count */
      Eterm sysname;                /* name@host atom for efficiency */
      Uint32 creation;              /* Creation */
      DistEntry *dist_entry;        /* Corresponding dist entry */
    } ErlNode;
     
    /* erl_node_tables.c */
    ErlNode *erts_find_or_insert_node(Eterm sysname, Uint creation)
    {   
        ErlNode *res;
        ErlNode ne;
        ne.sysname = sysname;
        ne.creation = creation;
     
        erts_smp_rwmtx_rlock(&erts_node_table_rwmtx);
        res = hash_get(&erts_node_table, (void *) &ne);
        if (res && res != erts_this_node) {
            erts_aint_t refc = erts_refc_inctest(&res->refc, 0);
            if (refc < 2) /* New or pending delete */
                erts_refc_inc(&res->refc, 1);
        }
        erts_smp_rwmtx_runlock(&erts_node_table_rwmtx);
        if (res)
            return res;
     
        erts_smp_rwmtx_rwlock(&erts_node_table_rwmtx);
        res = hash_put(&erts_node_table, (void *) &ne);
        ASSERT(res);
        if (res != erts_this_node) {
            erts_aint_t refc = erts_refc_inctest(&res->refc, 0);
            if (refc < 2) /* New or pending delete */
                erts_refc_inc(&res->refc, 1);
        }
        erts_smp_rwmtx_rwunlock(&erts_node_table_rwmtx);
        return res; 
    }
     
    static int
    node_table_cmp(void *venp1, void *venp2)
    {
        return ((((ErlNode *) venp1)->sysname == ((ErlNode *) venp2)->sysname
                 && ((ErlNode *) venp1)->creation == ((ErlNode *) venp2)->creation)
                ? 0
                : 1);
    }
     
    static void*
    node_table_alloc(void *venp_tmpl)
    {
        ErlNode *enp;
     
        if(((ErlNode *) venp_tmpl) == erts_this_node)
            return venp_tmpl;
     
        enp = (ErlNode *) erts_alloc(ERTS_ALC_T_NODE_ENTRY, sizeof(ErlNode));
     
        node_entries++;
     
        erts_refc_init(&enp->refc, -1);
        enp->creation = ((ErlNode *) venp_tmpl)->creation;
        enp->sysname = ((ErlNode *) venp_tmpl)->sysname;
        enp->dist_entry = erts_find_or_insert_dist_entry(((ErlNode *) venp_tmpl)->sysname);
     
        return (void *) enp;
    }

    这个erts_find_or_insert_node会根据sysname和creation的组合来查找节点，如果找不到的话，会新建一个节点放入ErlNode类型的erts_node_table表中。而ErlNode有3个关键信息 1. sysname 2. creation 3. dist_entry。 新建一个节点的时候，dist_entry填什么呢？

    核心代码是这行：
    enp->dist_entry = erts_find_or_insert_dist_entry(((ErlNode *) venp_tmpl)->sysname);
    这个dist_entry是根据sysname查找到的，而不是依据sysname和creation的组合。

    这时候问题就来了， 我们仔细看下 dec_pid的代码：

    node = dec_get_node(sysname, cre);
    if(node == erts_this_node) {
    *objp = make_internal_pid(data);
    } else {
    …
    etp->node = node;
    …
    *objp = make_external_pid(etp);
    }

    由于creation不同，所以相同的sysname， 无法找到目前的节点。在新建的节点里面，它的dist_entry却是当前节点对应的dist_entry.
    创建出来的外部pid对象包含新建的node。

    所以send的时候出警告的三句代码：

    } else if (is_external_pid(to)) {
    dep = external_pid_dist_entry(to);
    if(dep == erts_this_dist_entry) {

    external_pid_dist_entry宏会从外部pid中取出node,再从node中取出dist_entry. 这个dist_entry很不幸的和erts_this_dist_entry相同，于是就有了上面的悲剧。

    分析了半天总算有眉目了，喝口水先！
    现在有了这些背景知识我们就可以演示了：

    $ erl -sname a
    Erlang R15B03 (erts-5.9.3.1) 1 [64-bit] [smp:16:16] [async-threads:0] [hipe] [kernel-poll:false]
     
    Eshell V5.9.3.1  (abort with ^G)
    (a@rds064076)1> term_to_binary(self()).
    <<131,103,100,0,11,97,64,114,100,115,48,54,52,48,55,54,0,
      0,0,37,0,0,0,0,2>>
    (a@rds064076)2> binary_to_term(<<131,103,100,0,11,97,64,114,100,115,48,54,52,48,55,54,0,0,0,37,0,0,0,0,2>>).
    <0.37.0>
    (a@rds064076)3> binary_to_term(<<131,103,100,0,11,97,64,114,100,115,48,54,52,48,55,54,0,0,0,37,0,0,0,0,3>>).
    <0.37.0>
    (a@rds064076)4> binary_to_term(<<131,103,100,0,11,97,64,114,100,115,48,54,52,48,55,54,0,0,0,37,0,0,0,0,1>>).
    <0.37.0>
    (a@rds064076)5> binary_to_term(<<131,103,100,0,11,97,64,114,100,115,48,54,52,48,55,54,0,0,0,37,0,0,0,0,1>>)==self().
    false
    (a@rds064076)6> binary_to_term(<<131,103,100,0,11,97,64,114,100,115,48,54,52,48,55,54,0,0,0,37,0,0,0,0,2>>)==self().
    true
    (a@rds064076)7> binary_to_term(<<131,103,100,0,11,97,64,114,100,115,48,54,52,48,55,54,0,0,0,37,0,0,0,0,3>>)==self().
    false
    (a@rds064076)8> binary_to_term(<<131,103,100,0,11,97,64,114,100,115,48,54,52,48,55,54,0,0,0,37,0,0,0,0,3>>)!ok.    
    ok
    (a@rds064076)9> erlang:system_info(creation).
    2
    =ERROR REPORT==== 28-Jun-2013::23:10:58 ===
    Discarding message ok from <0.37.0> to <0.37.0> in an old incarnation (3) of this node (2)

    上面的演示我们可以看出，creation确实是每次+1循环，同时虽然pid打出来的是一样的，但是实际上由于creation的存在，看起来一样的还是不同的pid.
    到这里，我们大概明白了前应后果。但是并没有回到上面同学的疑问。
    他的集群，只是重新启动了个节点，然后收到一屏幕的警告。
    注意是一屏！！！

    我重新设计了一个案例，在深度剖析这个问题：
    在这之前，我们需要以下程序：

    $ cat test.erl
    -module(test).
    -export([start/0]).
     
    start()->
      register(test, self()),
      loop(undefined).
     
    loop(State)->
       loop(
      receive
       {set, Msg} -> Msg;
       {get, From} -> From!State
       end
       ).

    这段代码的目的是：
    test:start进程启动起来后，会在目标节点上把自己登记为test名字，同时可以接受2中消息get和set。set会保持用户设置的信息，而get会取回消息。

    我们的测试案例是这样的：
    启动a,b节点，然后在b节点上通过spawn在a节点上启动test:start这个进程负责保存我们的信息。这个信息就是b进程的shell的进程pid.
    然后模拟b节点挂掉重新启动，通过a节点上的test进程取回上次保持的进程pid, 这个pid和新启动的shell pid是相同的，但是他们应该是不完全相同的，因为creation不一样。
    好了，交代清楚了，我们就来秀下:

    $ erl -name a@127.0.0.1
    Erlang R15B03 (erts-5.9.3.1) 1 [64-bit] [smp:16:16] [async-threads:0] [hipe] [kernel-poll:false]
     
    Eshell V5.9.3.1  (abort with ^G)
    (a@127.0.0.1)1>

    好，A节点准备好了，接下来启动B节点保存shell的进程pid到节点a去。

    $ erl -name b@127.0.0.1
    Erlang R15B03 (erts-5.9.3.1) 1 [64-bit] [smp:16:16] [async-threads:0] [hipe] [kernel-poll:false]
     
    Eshell V5.9.3.1  (abort with ^G)
    (b@127.0.0.1)1> R=spawn('a@127.0.0.1', test, start,[]).
    <6002.42.0>
    (b@127.0.0.1)2> self().
    <0.37.0>
    (b@127.0.0.1)3> R!{set, self()}.  
    {set,<0.37.0>}
    (b@127.0.0.1)4> R!{get, self()}.
    {get,<0.37.0>}
    (b@127.0.0.1)5> flush().
    Shell got <0.37.0>
    ok
    (b@127.0.0.1)6>
    BREAK: (a)bort (c)ontinue (p)roc info (i)nfo (l)oaded
           (v)ersion (k)ill (D)b-tables (d)istribution
    ^C

    这时候把节点b退出，模拟b挂掉，再重新启动b,取回之前保存的pid,和现有的shell pid对比，发现不是完全一样。

    $ erl -name b@127.0.0.1
    Erlang R15B03 (erts-5.9.3.1) [64-bit] [smp:16:16] [async-threads:0] [hipe] [kernel-poll:false]

    Eshell V5.9.3.1 (abort with ^G)
    (b@127.0.0.1)1> {test, ‘a@127.0.0.1’}!{get, self()}.
    {get,<0.37.0>}
    (b@127.0.0.1)2> flush().
    Shell got <0.37.0>
    ok
    (b@127.0.0.1)3> {test, ‘a@127.0.0.1’}!{get, self()}, receive X->X end.
    <0.37.0>
    (b@127.0.0.1)4> T=v(-1).
    <0.37.0>
    (b@127.0.0.1)5> T==self().
    false
    (b@127.0.0.1)6> T!ok.
    ok
    (b@127.0.0.1)7>
    =ERROR REPORT==== 28-Jun-2013::23:24:00 ===
    Discarding message ok from <0.37.0> to <0.37.0> in an old incarnation (2) of this node (3)
    [/erlang]
    我们发消息给取回的上次保持的pid， 就触发了警告。

    这个场景在分布式环境里面非常普遍，参与协作的进程会保持在其他节点的系统里面，当其中的一些进程挂掉重新启动的时候，试图取回这些进程id的时候，却发现这些id已经失效了。

    到这里为止，应该能够很好的回答了上面同学的问题了。

    这个问题的解决方案是什么呢？
    我们的系统应该去monitor_node其他相关节点并且去捕获nodedown消息，当节点失效的时候，适时移除掉和该节点相关的进程。 因为这些进程本质上已经失去功效了。

    小结：看起来再无辜的警告，也是会隐藏着重大的问题。

    祝玩得开心。
  • 相关阅读:
    Python的注释
    Python的优缺点
    pymysql模块
    python(pymysql操作数据库)
    面向对象的测试用例设计有几种方法？如何实现？
    请试着比较一下黑盒测试、白盒测试、单元测试、集成测试、系统测试、验收测试的区别与联系。
    什么是兼容性测试？请举例说明如何利用兼容性测试列表进行测试。
    当开发人员说不是BUG时，你如何应付？
    性能测试的流程?
    您所熟悉的软件测试类型都有哪些？请试着分别比较这些不同的测试类型的区别与联系（如功能测试、性能测试……）
  • 原文地址：https://www.cnblogs.com/unqiang/p/5261033.html
Copyright © 2020-2023  润新知