anchor.diff:      leo_manager_cluster_monitor:register(RequestedTimes, Pid, Node, Type).
   
   
  -%% @doc Notified "Server Error", "Server Launch" and "Rebalance Progress" from cluster-nods.
  -%%
  --spec(notify(error | launched | rebalance | synchronized, atom(), ?ERR_TYPE_NODE_DOWN) ->
  -             ok | {error, any()}).
  -notify(error, Node, ?ERR_TYPE_NODE_DOWN) ->
  -    case leo_manager_mnesia:get_storage_node_by_name(Node) of
  +%% @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}.
  +
  +%% @doc Notified "Server Error" from cluster-nods.
  +%%
  +notify(error, DownedNode, NotifyNode, ?ERR_TYPE_NODE_DOWN) ->
  +    Ret1 = notify1(DownedNode),
  +    Ret2 = notify1(NotifyNode),
  +    {ok, {Ret1, Ret2}};
  +
  +%% @doc Notified "Rebalance Progress" from cluster-nods.
  +%%
  +notify(rebalance, VNodeId, Node, TotalOfObjects) ->
  +    leo_manager_mnesia:update_rebalance_info(
  +      #rebalance_info{vnode_id = VNodeId,
  +                      node     = Node,
  +                      total_of_objects = TotalOfObjects,
  +                      when_is  = leo_date:now()});
  +
  +%% @doc Notified "Server Launch" from cluster-nods.
  +%%
  +notify(launched, gateway, Node, Checksums0) ->
  +    case get_routing_table_chksum() of
  +        {ok, Checksums1} when Checksums0 == Checksums1 ->
  +            {RingHash0, RingHash1} = Checksums1,
  +            leo_manager_mnesia:update_gateway_node(
  +              #node_state{node          = Node,
  +                          state         = ?STATE_RUNNING,
  +                          ring_hash_new = leo_hex:integer_to_hex(RingHash0),
  +                          ring_hash_old = leo_hex:integer_to_hex(RingHash1),
  +                          when_is       = leo_date:now()});
  +        {ok, _} ->
  +            {error, ?ERR_TYPE_INCONSISTENT_HASH};
  +        Error ->
  +            Error
  +    end;
  +notify(_,_,_,_) ->
  +    {error, ?ERROR_INVALID_ARGS}.
  +
  +
  +notify1(TargetNode) ->
  +    case leo_manager_mnesia:get_storage_node_by_name(TargetNode) of
           {ok, [#node_state{state = State,
                             error = NumOfErrors}|_]} ->
               case (State == ?STATE_SUSPEND  orelse
  
positive.code:                      []
               end,
      {ok, Nodes0 ++ Nodes1}.
  
  
  %% get_nodes(Node) ->
  %%     {ok, Nodes0} = get_nodes(),
  %%     Res = lists:foldl(fun({_, N, _}, Acc) when Node == N ->
  %%                               Acc;
  %%                          ({_, N, _}, Acc) ->
  %%                               [N|Acc]
  %%                       end, [], Nodes0),
  %%     {ok, Res}.
  
  
  %%----------------------------------------------------------------------
  
negative.code:                     ok;
                  false ->
                      %% STATE_RUNNING | STATE_STOP
                      case leo_misc:node_existence(TargetNode, (10 * 1000)) of
                          true when State == ?STATE_RUNNING ->
                              ok;
                          true when State /= ?STATE_RUNNING ->
                              notify2(?STATE_RUNNING, TargetNode);
                          false ->
                              notify1(?STATE_STOP, TargetNode, NumOfErrors)
                      end;
                  _ ->
                      {error, ?ERROR_COULD_NOT_MODIFY_STORAGE_STATE}
              end;
          _Error ->
              {error, ?ERROR_COULD_NOT_MODIFY_STORAGE_STATE}
      end.
  
  
  notify1(?STATE_STOP = State, Node, NumOfErrors) when NumOfErrors >= ?DEF_NUM_OF_ERROR_COUNT ->
      notify2(State, Node);
  
  notify1(?STATE_STOP, Node,_NumOfErrors) ->
      case leo_manager_mnesia:update_storage_node_status(
             increment_error, #node_state{node = Node}) of
          ok ->
              ok;
          _Error ->
  