mnesia_cluster_console.erl

-module(mnesia_cluster_console).

-export([ join_cluster/2
        , join_cluster/1
        , reverse_join_cluster/1
        , reverse_join_cluster/2
        , join_cluster_do/2
        , forget_node_from_cluster/1
        , cluster_status/0
        , get_all_nodes/0
        , get_disc_nodes/0
        , get_ram_nodes/0
        , get_running_nodes/0]).

reverse_join_cluster(Node) ->
    reverse_join_cluster(Node, disc).

reverse_join_cluster(Node, Type) ->
    LocalNode = erlang:node(),
    rpc:call(Node, mnesia_cluster_console,
             join_cluster_do, [LocalNode, Type]).

join_cluster(Node) ->
    join_cluster(Node, disc).

join_cluster(Node, Type) ->
    case catch ensure_node(Node) of
        {error, "clustered, plz reverse join"} ->
            reverse_join_cluster(Node, Type);
        {error, Error} ->
            {error, Error};
        ok ->
            join_cluster_do(Node, Type)
    end.

join_cluster_do(Node, Type) ->
    case mnesia_cluster_utils:is_clustered() of
        true ->
            ingore;
        _ ->
            stopped = mnesia:stop(),
            mnesia_cluster_utils:join_cluster(Node, Type),
            ok = mnesia:start(),
            ok = tentative_keeper_utils:add_local_copy_from_remote(),
            ok
    end.

forget_node_from_cluster(Node) ->
    case catch mnesia_cluster_utils:forget_cluster_node(Node, false) of
        {error, {failed_to_remove_node, Node,
                 {active,"Mnesia is running", Node}}} ->
            {error, "This node's mnesia is running"};
        {error, {not_a_cluster_node,
                 "The node selected is not in the cluster."}} ->
            ok;
        ok ->
            ok
    end.

cluster_status() ->
    [A, B | _ ] = mnesia_cluster_utils:status(),
    [A, B].

get_all_nodes() ->
    mnesia_cluster_utils:cluster_nodes(all).

get_disc_nodes() ->
    mnesia_cluster_utils:cluster_nodes(disc).

get_ram_nodes() ->
    mnesia_cluster_utils:cluster_nodes(ram).

get_running_nodes() ->
    mnesia_cluster_utils:cluster_nodes(running).

ensure_node(Node) ->
    case Node =:= erlang:node() of
        true ->
            erlang:throw({error, "can not join self"});
        _ ->
            ok
    end,
    case net_adm:ping(Node) of
        pong ->
            ok;
        _ ->
            erlang:throw({error, "not ping"})
    end,
    case mnesia_cluster_utils:is_running(Node) of
        false ->
            erlang:throw({error, "mnesia from target node is not running"});
        _ ->
            ok
    end,
    case mnesia_cluster_utils:is_clustered() of
        true ->
            erlang:throw({error, "clustered, plz reverse join"});
        false ->
            ok
    end.

tentative_keeper_utils:add_local_copy_from_remote/0

add_local_copy_from_remote() ->
    [begin
        NodeList = mnesia:table_info(X, all_nodes),
        case lists:member(erlang:node(), NodeList) of
            true -> ingore;
            _ -> mnesia:add_table_copy(X, node(), disc_copies)
        end
     end || X <- mnesia_lib:active_tables()],
    ok.