anchor.diff:                      ok;
                   false ->
                       %% STATE_RUNNING | STATE_STOP
  -                    case leo_misc:node_existence(Node, (10 * 1000)) of
  +                    case leo_misc:node_existence(TargetNode, (10 * 1000)) of
                           true when State == ?STATE_RUNNING ->
                               ok;
                           true when State /= ?STATE_RUNNING ->
  -                            notify1(?STATE_RUNNING, Node);
  +                            notify2(?STATE_RUNNING, TargetNode);
                           false ->
  -                            notify1(?STATE_STOP, Node, NumOfErrors)
  +                            notify1(?STATE_STOP, TargetNode, NumOfErrors)
                       end;
                   _ ->
                       {error, ?ERROR_COULD_NOT_MODIFY_STORAGE_STATE}
               end;
           _Error ->
               {error, ?ERROR_COULD_NOT_MODIFY_STORAGE_STATE}
  -    end;
  -
  -notify(synchronized, VNodeId, Node) ->
  -    ok = leo_redundant_manager_api:adjust(VNodeId),
  -    Res = synchronize1(?SYNC_MODE_PREV_RING, Node),
  -    Res;
  -
  -notify(_,_,_) ->
  -    {error, ?ERROR_INVALID_ARGS}.
  -
  -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()});
  -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(?STATE_RUNNING = State, Node) ->
  -    Clock = leo_date:clock(),
  -    notify2(Node, Clock, State).
  +    end.
  +
   
   notify1(?STATE_STOP = State, Node, NumOfErrors) when NumOfErrors >= ?DEF_NUM_OF_ERROR_COUNT ->
  -    Cause = ?ERROR_COULD_NOT_MODIFY_STORAGE_STATE,
  -
  -    case leo_manager_mnesia:update_storage_node_status(update_state,
  -                                                       #node_state{node  = Node,
  -                                                                   state = State}) of
  -        ok ->
  -            Clock = leo_date:clock(),
  -            case leo_redundant_manager_api:update_member_by_node(Node, Clock, State) of
  -                ok ->
  -                    notify2(Node, Clock, State);
  -                _ ->
  -                    {error, Cause}
  -            end;
  -        _ ->
  -            {error, Cause}
  -    end;
  +    notify2(State, Node);
   
   notify1(?STATE_STOP, Node,_NumOfErrors) ->
  -    case leo_manager_mnesia:update_storage_node_status(increment_error,
  -                                                       #node_state{node = Node}) of
  +    case leo_manager_mnesia:update_storage_node_status(
  +           increment_error, #node_state{node = Node}) of
           ok ->
               ok;
           _Error ->
  
positive.code:     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
          {ok, [#node_state{state = State,
                            error = NumOfErrors}|_]} ->
              case (State == ?STATE_SUSPEND  orelse
  
negative.code:                      []
               end,
      {ok, Nodes0 ++ Nodes1}.
  
  
  %%----------------------------------------------------------------------
  