anchor.diff:              Ret
       end;
   
  -synchronize(?CHECKSUM_RING = Type, [{Node_0, {CurRingHash0, PrevRingHash0}},
  -                                    {Node_1, {CurRingHash1, PrevRingHash1}}]) ->
  +synchronize(?CHECKSUM_RING = Type, [{Node_1, {CurRingHash_1, PrevRingHash_1}},
  +                                    {Node_2, {CurRingHash_2, PrevRingHash_2}}]) ->
       case leo_redundant_manager_api:checksum(Type) of
           {ok, {LocalCurRingHash, LocalPrevRingHash}} ->
               %% copare manager-cur-ring-hash with remote cur-ring-hash
               _ = compare_local_chksum_with_remote_chksum(
  -                  ?SYNC_TARGET_RING_CUR,  Node_0, LocalCurRingHash,  CurRingHash0),
  +                  ?SYNC_TARGET_RING_CUR,  Node_1, LocalCurRingHash,  CurRingHash_1),
               _ = compare_local_chksum_with_remote_chksum(
  -                  ?SYNC_TARGET_RING_CUR,  Node_1, LocalCurRingHash,  CurRingHash1),
  +                  ?SYNC_TARGET_RING_CUR,  Node_2, LocalCurRingHash,  CurRingHash_2),
   
               %% copare manager-cur/prev-ring-hash/ with remote prev-ring-hash
               _ = compare_local_chksum_with_remote_chksum(
  -                  ?SYNC_TARGET_RING_PREV, Node_0, LocalCurRingHash, LocalPrevRingHash, PrevRingHash0),
  +                  ?SYNC_TARGET_RING_PREV, Node_1, LocalCurRingHash, LocalPrevRingHash, PrevRingHash_1),
               _ = compare_local_chksum_with_remote_chksum(
  -                  ?SYNC_TARGET_RING_PREV, Node_1, LocalCurRingHash, LocalPrevRingHash, PrevRingHash1);
  +                  ?SYNC_TARGET_RING_PREV, Node_2, LocalCurRingHash, LocalPrevRingHash, PrevRingHash_2);
           Error ->
               Error
       end.
  
positive.code: %% @private
  distribute_members([]) ->
      ok;
  distribute_members([Node|Rest]) ->
      _ = distribute_members(ok, Node),
      distribute_members(Rest);
  
  distribute_members(Node) when is_atom(Node) ->
      distribute_members(ok, Node).
  
  -spec(distribute_members(ok, atom()) ->
               ok | {error, any()}).
  distribute_members(ok, Node_0) ->
      case leo_redundant_manager_api:get_members() of
          {ok, Members} ->
              Fun = fun(#member{node  = Node_1,
                                state = ?STATE_RUNNING}, Acc) when Node_0 =/= Node_1 ->
                            [Node_1|Acc];
                       (_, Acc) ->
                            Acc
                    end,
              StorageNodes = lists:foldl(Fun, [], Members),
              DestNodes    = case leo_manager_mnesia:get_gateway_nodes_all() of
                                 {ok, GatewayNodes} ->
                                     lists:foldl(fun(#node_state{node = Node2}, Acc) ->
                                                         [Node2|Acc]
                                                 end, StorageNodes, GatewayNodes);
                                 _ ->
                                     StorageNodes
                             end,
  
              case rpc:multicall(DestNodes, leo_redundant_manager_api, update_members,
                                 [Members], ?DEF_TIMEOUT) of
                  {_, []} -> void;
                  {_, BadNodes} ->
                      ?error("start/0", "bad-nodes:~p", [BadNodes])
              end,
              ok;
          Error ->
              Error
      end;
  distribute_members(Error, _Node) ->
      Error.
  
  
negative.code: update_manager_nodes(Managers) ->
      Ret = case leo_manager_mnesia:get_storage_nodes_all() of
                {ok, Members} ->
                    StorageNodes = [_N || #node_state{node = _N} <- Members],
                    case rpc:multicall(StorageNodes, leo_storage_api, update_manager_nodes,
                                       [Managers], ?DEF_TIMEOUT) of
                        {_, []} -> ok;
  