anchor.diff:  
       %% Check during-rebalance
       case leo_redundant_manager_api:checksum(?CHECKSUM_RING) of
  -        {ok, {CurRingHash, PrevRingHash}} when CurRingHash == PrevRingHash ->
  +        {ok, {RingHashCur, RingHashPrev}} when RingHashCur == RingHashPrev ->
               %% Check preconditions
               case is_allow_to_distribute_command() of
                   {true, _}->
  
positive.code:             Ret
      end;
  
  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_1, LocalCurRingHash,  CurRingHash_1),
              _ = compare_local_chksum_with_remote_chksum(
                    ?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_1, LocalCurRingHash, LocalPrevRingHash, PrevRingHash_1),
              _ = compare_local_chksum_with_remote_chksum(
                    ?SYNC_TARGET_RING_PREV, Node_2, LocalCurRingHash, LocalPrevRingHash, PrevRingHash_2);
          Error ->
              Error
      end.
  
negative.code:             case BadNodes0 of
                  [] ->
                      lists:foreach(
                        fun({Node, {RingHashCur, RingHashPrev}}) ->
                                leo_manager_mnesia:update_storage_node_status(
                                  update,
                                  #node_state{node          = Node,
                                              state         = ?STATE_RUNNING,
                                              ring_hash_new = leo_hex:integer_to_hex(RingHashCur,  8),
                                              ring_hash_old = leo_hex:integer_to_hex(RingHashPrev, 8),
                                              when_is       = leo_date:now()})
                        end, ResL1),
                      {ResL1, []};
  