anchor.diff:                           (_, Acc) ->
                                 Acc
                         end, null, Members),
  +
       Errors1 =
           case rpc:call(Node, leo_redundant_manager_api, synchronize,
                         [ObjectOfRings, Ring], ?DEF_TIMEOUT) of
  
positive.code: 
  %% @doc Notified "Synchronized" from cluster-nods.
  %%
  notify(synchronized, VNodeId, Node) ->
      ok = leo_redundant_manager_api:adjust(VNodeId),
      synchronize1(?SYNC_MODE_PREV_RING, Node);
  notify(_,_,_) ->
      {error, ?ERROR_INVALID_ARGS}.
  
negative.code:     end;
  
  rebalance_3(Type, ?STATE_DETACHED, [Node|_Rest], Members) ->
      {ok, RingCur} = leo_redundant_manager_api:get_ring(?SYNC_MODE_CUR_RING),
      ok = leo_redundant_manager_api:update_member_by_node(Node, leo_date:clock(), ?STATE_STOP),
  
      case leo_manager_mnesia:get_storage_node_by_name(Node) of
          {ok, [NodeInfo|_]} ->
              _ = leo_manager_mnesia:delete_storage_node(NodeInfo),
  
              case leo_redundant_manager_api:synchronize(?SYNC_MODE_PREV_RING, RingCur) of
                  {ok, _Checksum} ->
                      rebalance_4(Type, RingCur, Members, Members, []);
                  {error, Cause} ->
                      ?error("rebalance_3/4", "cause:~p", [Cause]),
                      {error, Cause}
              end;
          Error ->
              Error
      end.
  
  rebalance_4(_Type,_Ring,_Members, [], []) ->
      ok;
  rebalance_4(_Type,_Ring,_Members, [], Errors) ->
      {error, Errors};
  rebalance_4( Type, Ring, Members, [#member{node  = Node,
                                      state = ?STATE_RUNNING}|T], Errors0) ->
      ObjectOfRings = lists:foldl(
                        fun(#member{state = ?STATE_ATTACHED}, null)
                              when Type == ?TYPE_REBALANCE_REGULAR ->
  