anchor.diff:      {reply, ok, State};
   
   handle_call(subscribe,_From, State) ->
  -    mnesia:subscribe({table, ?MEMBER_TBL_CUR,  simple}),
  -    mnesia:subscribe({table, ?MEMBER_TBL_PREV, simple}),
       {reply, ok, State};
   
   handle_call(_Handle, _From, State) ->
  
positive.code: %% <p>
  %% gen_server callback - Module:handle_info(Info, State) -> Result.
  %% </p>
  handle_info(Info, #state{cur  = #ring_info{ring_group_list = CurRing },
                           prev = #ring_info{ring_group_list = PrevRing}} = State) ->
      case Info of
          {mnesia_table_event, {write, El,_}} ->
              NodeStatus = erlang:element(8, El),
              case NodeStatus of
                  ?STATE_RUNNING when CurRing  == [];
                                      CurRing  == undefined;
                                      PrevRing == [];
                                      PrevRing == undefined ->
                      ok;
                  ?STATE_RUNNING ->
                      %% exists an attached node in ring?
                      Table = erlang:element(1, El),
                      Node  = erlang:element(2, El),
                      VNodeList = get_vnode_list(Table, CurRing, PrevRing),
                      case find_node_from_ring(VNodeList, Node) of
                          ok ->
                              void;
                          not_found ->
                              timer:apply_after(100, leo_redundant_manager_api, create, [])
                      end;
                  _ ->
                      ok
              end;
          {mnesia_table_event, {delete, El,_}} ->
              case (CurRing  == [] orelse
                    PrevRing == [] orelse
                    CurRing  == undefined orelse
                    PrevRing == undefined) of
                  true ->
                      timer:apply_after(100, leo_redundant_manager_api, create, []),
                      ok;
                  false ->
                      %% exists a detached node in ring?
                      Table = erlang:element(1, El),
                      Node  = erlang:element(2, El),
                      VNodeList = get_vnode_list(Table, CurRing, PrevRing),
                      case find_node_from_ring(VNodeList, Node) of
                          ok ->
                              timer:apply_after(100, leo_redundant_manager_api, create, []);
                          not_found ->
                              ok
                      end
              end;
          _ ->
              ok
      end,
      {noreply, State}.
  
  %% @doc This function is called by a gen_server when it is about to
  
negative.code:     State#state.prev;
  ring_info(_,_) ->
      {error, invalid_table}.
  