深入浅出 Mnesia－schema 创建 (1)

-record(cstruct, {name,                    % Atom 表名字
          type = set,                      % set | bag
          ram_copies = [],                 % [Node]
          disc_copies = [],                % [Node]
          disc_only_copies = [],           % [Node]
          load_order = 0,                  % Integer
          access_mode = read_write,        % read_write | read_only
          majority = false,                % true | false
          index = [],                      % [Integer]
          snmp = [],                       % Snmp Ustruct
          local_content = false,           % true | false
          record_name = {bad_record_name}, % Atom (Default = Name) 表中存放的record的名字
          attributes = [key, val],         % [Atom] record中的属性名字
          user_properties = [],            % [Record]
          frag_properties = [],            % [{Key, Val]
          storage_properties = [],         % [{Key, Val]
                  cookie = ?unique_cookie,         % Term
                  version = {{2, 0}, []}}).        % {{Integer, Integer}, [Node]}

 %%尝试读取远程的schema 
ensure_no_schema([H|T]) when is_atom(H) -> 
    case rpc:call(H, ?MODULE, remote_read_schema, []) of 
        {badrpc, Reason} -> %% 返回建表失败 
            {H, {"All nodes not running", H, Reason}}; 
        {ok,Source, _} when Source /= default -> %% 返回的source是非default的时候，就代表已经存在了schema表 
            {H, {already_exists, H}};
        _ -> ensure_no_schema(T) 
    end; 
ensure_no_schema([H|_]) -> {error,{badarg, H}}; 
ensure_no_schema([]) -> ok.

make_initial_backup(Ns, Opaque, Mod) -> 
    %%获取最开始的元数据表 
    %%元数据是cstruct的[{key,value}]形式 
    Orig = mnesia_schema:get_initial_schema(disc_copies, Ns), 
    %% 删除掉storage_properties和majority这两个字段 
    Modded = proplists:delete(storage_properties, proplists:delete(majority, Orig)), 
    %% 向schema表中写入表名和cstruct Schema = [{schema, schema, Modded}], 
    O2 = do_apply(Mod, open_write, [Opaque], Opaque), 
    %写入日志头 %% 包括日志版本，日志类型，mnesia版本，节点名称，生成时间 
    %% 这里日志版本1.2 类型 backup_log 
    O3 = do_apply(Mod, write, [O2, [mnesia_log:backup_log_header()]], O2), 
    %写入schema数据 
    O4 = do_apply(Mod, write, [O3, Schema], O3), 
    %%生成Opaque所代表的文件 
    O5 = do_apply(Mod, commit_write, [O4], O4), 
    {ok, O5}. 

install_fallback_master(ClientPid, FA) ->
    %% 捕获退出异常，关联进程崩溃，但是并不真正捕获
    %% 而是防止崩溃后引起当前进程退出，打断元数据创建
    process_flag(trap_exit, true),
    %% 设置状态
    State = {start, FA},
    %% 拿出日志文件
    Opaque = FA#fallback_args.opaque,
    Mod = FA#fallback_args.module,
    Res = (catch iterate(Mod, fun restore_recs/4, Opaque, State)),
    unlink(ClientPid),
    ClientPid ! {self(), Res},
    exit(shutdown).

-spec fallback_receiver(pid(), fallback_args()) -> no_return().
%Master,在此处表示，整个mnesia集群在create_schema的时候的发起者
fallback_receiver(Master, FA) ->
    process_flag(trap_exit, true),
%将自己注册到本地名字库，防止创建出另一个fallback_receiver进程
    case catch register(mnesia_fallback, self()) of
        {'EXIT', _} ->
            Reason = {already_exists, node()},
            local_fallback_error(Master, Reason);
        true ->
            FA2 = check_fallback_dir(Master, FA),
            Bup = FA2#fallback_args.fallback_bup,
            %检查是否有backup
            case mnesia_lib:exists(Bup) of
                true ->
                    %如果有则报错
                    Reason2 = {already_exists, node()},
                    local_fallback_error(Master, Reason2);
                false ->
                    %如果没有，创建新的backup的临时文件
                    Mod = mnesia_backup,
                    %% 删除FALLBACK.TMP文件
                    Tmp = FA2#fallback_args.fallback_tmp,
                    R = #restore{mode = replace,
                                 bup_module = Mod,
                                 bup_data = Tmp},
                    file:delete(Tmp),
                    %开始接收fallback信息
                    case catch fallback_receiver_loop(Master, R, FA2, schema) of
                        {error, Reason} ->
                            local_fallback_error(Master, Reason);
                        Other ->
                            exit(Other)
                    end
            end
    end.

fallback_receiver_loop(Master, R, FA, State) ->
    receive
        {Master, {start, Header, Schema}} when State =:= schema ->
            Dir = FA#fallback_args.mnesia_dir,
            throw_bad_res(ok, mnesia_schema:opt_create_dir(true, Dir)),
            %% 创建FALLBACK.TMP文件
            R2 = safe_apply(R, open_write, [R#restore.bup_data]),
            R3 = safe_apply(R2, write, [R2#restore.bup_data, [Header]]),
            BupSchema = [schema2bup(S) || S <- Schema],
            R4 = safe_apply(R3, write, [R3#restore.bup_data, BupSchema]),
            Master ! {self(), ok},
            %% schema的日志已经写入文件了
            %% 状态切换到接收records
            fallback_receiver_loop(Master, R4, FA, records);

        {Master, {records, Recs}} when State =:= records ->
            R2 = safe_apply(R, write, [R#restore.bup_data, Recs]),
            Master ! {self(), ok},
            fallback_receiver_loop(Master, R2, FA, records);
        %收到swap，进行commit，并将临时文件重命名为backup文件
        {Master, swap} when State =/= schema ->
            ?eval_debug_fun({?MODULE, fallback_receiver_loop, pre_swap}, []),
            safe_apply(R, commit_write, [R#restore.bup_data]),
            Bup = FA#fallback_args.fallback_bup,
            Tmp = FA#fallback_args.fallback_tmp,
            %% 立刻重命名文件，将FALLBACK.TMP重命名为FALLBACK.BUP
            throw_bad_res(ok, file:rename(Tmp, Bup)),
            catch mnesia_lib:set(active_fallback, true),
            ?eval_debug_fun({?MODULE, fallback_receiver_loop, post_swap}, []),
            Master ! {self(), ok},
            fallback_receiver_loop(Master, R, FA, stop);

        {Master, stop} when State =:= stop ->
            stopped;

        Msg ->
            safe_apply(R, abort_write, [R#restore.bup_data]),
            Tmp = FA#fallback_args.fallback_tmp,
            file:delete(Tmp),
            throw({error, "Unexpected msg fallback_receiver_loop", Msg})
    end.