Add public/private split in projection store of machi_flu0.erl

This commit is contained in:
Scott Lystig Fritchie 2014-10-27 16:09:14 +09:00
parent fd7dad0714
commit ddce145bfb
4 changed files with 722 additions and 45 deletions

View file

@ -0,0 +1,191 @@
%% -------------------------------------------------------------------
%%
%% Machi: a small village of replicated files
%%
%% Copyright (c) 2014 Basho Technologies, Inc. All Rights Reserved.
%%
%% This file is provided to you under the Apache License,
%% Version 2.0 (the "License"); you may not use this file
%% except in compliance with the License. You may obtain
%% a copy of the License at
%%
%% http://www.apache.org/licenses/LICENSE-2.0
%%
%% Unless required by applicable law or agreed to in writing,
%% software distributed under the License is distributed on an
%% "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
%% KIND, either express or implied. See the License for the
%% specific language governing permissions and limitations
%% under the License.
%%
%% -------------------------------------------------------------------
-module(machi_chain_manager0).
-include("machi.hrl").
-export([make_initial_state/3, calc_projection/3, make_projection_summary/1]).
-ifdef(TEST).
-compile(export_all).
-ifdef(EQC).
-include_lib("eqc/include/eqc.hrl").
-endif.
-ifdef(PULSE).
-compile({parse_transform, pulse_instrument}).
-endif.
-endif. %TEST
make_initial_state(MyName, All_list, Seed) ->
RunEnv = [{seed, Seed},
{network_partitions, []}],
#ch_mgr{name=MyName,
proj=make_initial_projection(MyName, All_list, All_list, [], []),
runenv=RunEnv}.
make_initial_projection(MyName, All_list, UPI_list, Repairing_list, Ps) ->
make_projection(1, 0, <<>>,
MyName, All_list, [], UPI_list, Repairing_list, Ps).
make_projection(EpochNum, PrevEpochNum, PrevEpochCSum,
MyName, All_list, Down_list, UPI_list, Repairing_list, Ps) ->
P = #projection{epoch_number=EpochNum,
epoch_csum= <<>>,
prev_epoch_num=PrevEpochNum,
prev_epoch_csum=PrevEpochCSum,
creation_time=now(),
author_server=MyName,
all_members=All_list,
down=Down_list,
upi=UPI_list,
repairing=Repairing_list,
dbg=Ps},
CSum = crypto:hash(sha, term_to_binary(P)),
P#projection{epoch_csum=CSum}.
%% OldThreshold: Percent chance of using the old/previous network partition list
%% NoPartitionThreshold: If the network partition changes, what are the odds
%% that there are no partitions at all?
calc_projection(OldThreshold, NoPartitionThreshold,
#ch_mgr{name=MyName, proj=LastProj, runenv=RunEnv1} = S) ->
#projection{epoch_number=OldEpochNum,
epoch_csum=OldEpochCsum,
all_members=All_list,
upi=OldUPI_list,
repairing=OldRepairing_list
} = LastProj,
LastUp = lists:usort(OldUPI_list ++ OldRepairing_list),
AllMembers = (S#ch_mgr.proj)#projection.all_members,
{Up, RunEnv2} = calc_up_nodes(MyName, OldThreshold, NoPartitionThreshold,
AllMembers, RunEnv1),
NewUp = Up -- LastUp,
Down = AllMembers -- Up,
NewUPI_list = [X || X <- OldUPI_list, lists:member(X, Up)],
Repairing_list2 = [X || X <- OldRepairing_list, lists:member(X, Up)],
{NewUPI_list3, Repairing_list3, RunEnv3} =
case {NewUp, Repairing_list2} of
{[], []} ->
{NewUPI_list, [], RunEnv2};
{[], [H|T]} ->
{Prob, RunEnvX} = roll_dice(100, RunEnv2),
if Prob =< 50 ->
{NewUPI_list ++ [H], T, RunEnvX};
true ->
{NewUPI_list, OldRepairing_list, RunEnvX}
end;
{_, _} ->
{NewUPI_list, OldRepairing_list, RunEnv2}
end,
Repairing_list4 = case NewUp of
[] -> Repairing_list3;
NewUp -> Repairing_list3 ++ NewUp
end,
Repairing_list5 = Repairing_list4 -- Down,
P = make_projection(OldEpochNum + 1, OldEpochNum, OldEpochCsum,
MyName, All_list, Down, NewUPI_list3, Repairing_list5,
[goo]),
{P, S#ch_mgr{runenv=RunEnv3}}.
calc_up_nodes(MyName, OldThreshold, NoPartitionThreshold,
AllMembers, RunEnv1) ->
Seed1 = proplists:get_value(seed, RunEnv1),
Partitions1 = proplists:get_value(network_partitions, RunEnv1),
{Seed2, Partitions2} =
calc_network_partitions(AllMembers, Seed1, Partitions1,
OldThreshold, NoPartitionThreshold),
UpNodes = lists:sort(
[Node || Node <- AllMembers,
not lists:member({MyName, Node}, Partitions2),
not lists:member({Node, MyName}, Partitions2)]),
RunEnv2 = replace(RunEnv1,
[{seed, Seed2}, {network_partitions, Partitions2}]),
{UpNodes, RunEnv2}.
calc_network_partitions(Nodes, Seed1, OldPartition,
OldThreshold, NoPartitionThreshold) ->
{Cutoff2, Seed2} = random:uniform_s(100, Seed1),
if Cutoff2 < OldThreshold ->
{Seed2, OldPartition};
true ->
{Cutoff3, Seed3} = random:uniform_s(100, Seed1),
if Cutoff3 < NoPartitionThreshold ->
{Seed3, []};
%% Cutoff3 rem 10 < 5 ->
%% %% case get(goofus) of undefined -> put(goofus, true), io:format(user, "~w", [Cutoff3 rem 10]); _ -> ok end,
%% OldSeed = case random:seed(Seed3) of undefined -> now();
%% Else -> Else
%% end,
%% {Down, _} = lists:partition(fun(X) -> X /= 'a' andalso random:uniform() < 0.5 end, Nodes),
%% %% case get(goofus) of undefined -> put(goofus, true), io:format(user, "~w", [Down]); _ -> ok end,
%% Partitions = [{X, Y} || X <- Nodes, Y <- Down],
%% random:seed(OldSeed),
%% {Seed3, Partitions};
true ->
make_network_partition_locations(Nodes, Seed3)
end
end.
replace(PropList, Items) ->
lists:foldl(fun({Key, Val}, Ps) ->
lists:keyreplace(Key, 1, Ps, {Key,Val})
end, PropList, Items).
make_projection_summary(#projection{epoch_number=EpochNum,
all_members=_All_list,
down=Down_list,
upi=UPI_list,
repairing=Repairing_list}) ->
[{epoch,EpochNum},
{upi,UPI_list},{repair,Repairing_list},{down,Down_list}].
roll_dice(N, RunEnv) ->
Seed1 = proplists:get_value(seed, RunEnv),
{Val, Seed2} = random:uniform_s(N, Seed1),
{Val, replace(RunEnv, [{seed, Seed2}])}.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
make_network_partition_locations(Nodes, Seed1) ->
Pairs = make_all_pairs(Nodes),
Num = length(Pairs),
{Seed2, Weights} = lists:foldl(
fun(_, {Seeda, Acc}) ->
{Cutoff, Seedb} = random:uniform_s(100, Seeda),
{Seedb, [Cutoff|Acc]}
end, {Seed1, []}, lists:seq(1, Num)),
{Cutoff3, Seed3} = random:uniform_s(100, Seed2),
{Seed3, [X || {Weight, X} <- lists:zip(Weights, Pairs),
Weight < Cutoff3]}.
make_all_pairs(L) ->
lists:flatten(make_all_pairs2(lists:usort(L))).
make_all_pairs2([]) ->
[];
make_all_pairs2([_]) ->
[];
make_all_pairs2([H1|T]) ->
[[{H1, X}, {X, H1}] || X <- T] ++ make_all_pairs(T).

View file

@ -27,7 +27,7 @@
-export([start_link/1, stop/1, -export([start_link/1, stop/1,
write/3, read/2, trim/2, write/3, read/2, trim/2,
proj_write/3, proj_read/2, proj_get_latest_num/1, proj_read_latest/1]). proj_write/4, proj_read/3, proj_get_latest_num/2, proj_read_latest/2]).
-export([set_fake_repairing_status/2, get_fake_repairing_status/1]). -export([set_fake_repairing_status/2, get_fake_repairing_status/1]).
-export([make_proj/1, make_proj/2]). -export([make_proj/1, make_proj/2]).
@ -54,15 +54,16 @@
-type register() :: 'unwritten' | binary() | 'trimmed'. -type register() :: 'unwritten' | binary() | 'trimmed'.
-record(state, { -record(state, {
name :: list(), name :: atom(),
wedged = false :: boolean(), wedged = false :: boolean(),
register = 'unwritten' :: register(), register = 'unwritten' :: register(),
fake_repairing = false :: boolean(), fake_repairing = false :: boolean(),
proj_epoch :: non_neg_integer(), proj_epoch :: non_neg_integer(),
proj_store :: dict() proj_store_pub :: dict(),
proj_store_priv :: dict()
}). }).
start_link(Name) when is_list(Name) -> start_link(Name) when is_atom(Name) ->
gen_server:start_link(?MODULE, [Name], []). gen_server:start_link(?MODULE, [Name], []).
stop(Pid) -> stop(Pid) ->
@ -77,17 +78,21 @@ write(Pid, Epoch, Bin) ->
trim(Pid, Epoch) -> trim(Pid, Epoch) ->
g_call(Pid, {reg_op, Epoch, trim}, ?LONG_TIME). g_call(Pid, {reg_op, Epoch, trim}, ?LONG_TIME).
proj_write(Pid, Epoch, Proj) -> proj_write(Pid, Epoch, StoreType, Proj)
g_call(Pid, {proj_write, Epoch, Proj}, ?LONG_TIME). when StoreType == public; StoreType == private ->
g_call(Pid, {proj_write, Epoch, StoreType, Proj}, ?LONG_TIME).
proj_read(Pid, Epoch) -> proj_read(Pid, Epoch, StoreType)
g_call(Pid, {proj_read, Epoch}, ?LONG_TIME). when StoreType == public; StoreType == private ->
g_call(Pid, {proj_read, Epoch, StoreType}, ?LONG_TIME).
proj_get_latest_num(Pid) -> proj_get_latest_num(Pid, StoreType)
g_call(Pid, {proj_get_latest_num}, ?LONG_TIME). when StoreType == public; StoreType == private ->
g_call(Pid, {proj_get_latest_num, StoreType}, ?LONG_TIME).
proj_read_latest(Pid) -> proj_read_latest(Pid, StoreType)
g_call(Pid, {proj_read_latest}, ?LONG_TIME). when StoreType == public; StoreType == private ->
g_call(Pid, {proj_read_latest, StoreType}, ?LONG_TIME).
set_fake_repairing_status(Pid, Status) -> set_fake_repairing_status(Pid, Status) ->
gen_server:call(Pid, {set_fake_repairing_status, Status}, ?LONG_TIME). gen_server:call(Pid, {set_fake_repairing_status, Status}, ?LONG_TIME).
@ -115,7 +120,8 @@ init([Name]) ->
lclock_init(), lclock_init(),
{ok, #state{name=Name, {ok, #state{name=Name,
proj_epoch=-42, proj_epoch=-42,
proj_store=orddict:new()}}. proj_store_pub=orddict:new(),
proj_store_priv=orddict:new()}}.
handle_call({{reg_op, _Epoch, _}, LC1}, _From, #state{wedged=true} = S) -> handle_call({{reg_op, _Epoch, _}, LC1}, _From, #state{wedged=true} = S) ->
LC2 = lclock_update(LC1), LC2 = lclock_update(LC1),
@ -160,25 +166,25 @@ handle_call({{reg_op, _Epoch, trim}, LC1}, _From, #state{register=trimmed} = S)
LC2 = lclock_update(LC1), LC2 = lclock_update(LC1),
{reply, {error_trimmed, LC2}, S}; {reply, {error_trimmed, LC2}, S};
handle_call({{proj_write, Epoch, Proj}, LC1}, _From, S) -> handle_call({{proj_write, Epoch, StoreType, Proj}, LC1}, _From, S) ->
LC2 = lclock_update(LC1), LC2 = lclock_update(LC1),
{Reply, NewS} = do_proj_write(Epoch, Proj, S), {Reply, NewS} = do_proj_write(Epoch, StoreType, Proj, S),
{reply, {Reply, LC2}, NewS}; {reply, {Reply, LC2}, NewS};
handle_call({{proj_read, Epoch}, LC1}, _From, S) -> handle_call({{proj_read, Epoch, StoreType}, LC1}, _From, S) ->
LC2 = lclock_update(LC1), LC2 = lclock_update(LC1),
{Reply, NewS} = do_proj_read(Epoch, S), {Reply, NewS} = do_proj_read(Epoch, StoreType, S),
{reply, {Reply, LC2}, NewS}; {reply, {Reply, LC2}, NewS};
handle_call({{proj_get_latest_num}, LC1}, _From, S) -> handle_call({{proj_get_latest_num, StoreType}, LC1}, _From, S) ->
LC2 = lclock_update(LC1), LC2 = lclock_update(LC1),
{Reply, NewS} = do_proj_get_latest_num(S), {Reply, NewS} = do_proj_get_latest_num(StoreType, S),
{reply, {Reply, LC2}, NewS}; {reply, {Reply, LC2}, NewS};
handle_call({{proj_read_latest}, LC1}, _From, S) -> handle_call({{proj_read_latest, StoreType}, LC1}, _From, S) ->
LC2 = lclock_update(LC1), LC2 = lclock_update(LC1),
case do_proj_get_latest_num(S) of case do_proj_get_latest_num(StoreType, S) of
{error_unwritten, _S} -> {error_unwritten, _S} ->
{reply, {error_unwritten, LC2}, S}; {reply, {error_unwritten, LC2}, S};
{{ok, Epoch}, _S} -> {{ok, Epoch}, _S} ->
Proj = orddict:fetch(Epoch, S#state.proj_store), Proj = orddict:fetch(Epoch, get_store_dict(StoreType, S)),
{reply, {{ok, Proj}, LC2}, S} {reply, {{ok, Proj}, LC2}, S}
end; end;
handle_call({stop, LC1}, _From, MLP) -> handle_call({stop, LC1}, _From, MLP) ->
@ -206,24 +212,25 @@ code_change(_OldVsn, MLP, _Extra) ->
%%%% %%%% %%%% %%%% %%%% %%%% %%%% %%%% %%%% %%%% %%%% %%%% %%%% %%%% %%%% %%%% %%%% %%%% %%%% %%%% %%%% %%%% %%%% %%%%
do_proj_write(Epoch, Proj, #state{proj_epoch=MyEpoch, proj_store=D, do_proj_write(Epoch, StoreType, Proj, #state{proj_epoch=MyEpoch,
wedged=MyWedged} = S) -> wedged=MyWedged} = S) ->
D = get_store_dict(StoreType, S),
case orddict:find(Epoch, D) of case orddict:find(Epoch, D) of
error -> error ->
D2 = orddict:store(Epoch, Proj, D), D2 = orddict:store(Epoch, Proj, D),
{NewEpoch, NewWedged} = if Epoch > MyEpoch -> {NewEpoch, NewWedged} = if Epoch > MyEpoch ->
{Epoch, false}; {Epoch, false};
true -> true ->
{MyEpoch, MyWedged} {MyEpoch, MyWedged}
end, end,
{ok, S#state{wedged=NewWedged, {ok, set_store_dict(StoreType, D2, S#state{wedged=NewWedged,
proj_epoch=NewEpoch, proj_epoch=NewEpoch})};
proj_store=D2}};
{ok, _} -> {ok, _} ->
{error_written, S} {error_written, S}
end. end.
do_proj_read(Epoch, #state{proj_store=D} = S) -> do_proj_read(Epoch, StoreType, S) ->
D = get_store_dict(StoreType, S),
case orddict:find(Epoch, D) of case orddict:find(Epoch, D) of
error -> error ->
{error_unwritten, S}; {error_unwritten, S};
@ -231,7 +238,8 @@ do_proj_read(Epoch, #state{proj_store=D} = S) ->
{{ok, Proj}, S} {{ok, Proj}, S}
end. end.
do_proj_get_latest_num(#state{proj_store=D} = S) -> do_proj_get_latest_num(StoreType, S) ->
D = get_store_dict(StoreType, S),
case lists:sort(orddict:to_list(D)) of case lists:sort(orddict:to_list(D)) of
[] -> [] ->
{error_unwritten, S}; {error_unwritten, S};
@ -240,6 +248,16 @@ do_proj_get_latest_num(#state{proj_store=D} = S) ->
{{ok, Epoch}, S} {{ok, Epoch}, S}
end. end.
get_store_dict(public, #state{proj_store_pub=D}) ->
D;
get_store_dict(private, #state{proj_store_priv=D}) ->
D.
set_store_dict(public, D, S) ->
S#state{proj_store_pub=D};
set_store_dict(private, D, S) ->
S#state{proj_store_priv=D}.
-ifdef(TEST). -ifdef(TEST).
lclock_init() -> lclock_init() ->

View file

@ -0,0 +1,468 @@
%% -------------------------------------------------------------------
%%
%% Machi: a small village of replicated files
%%
%% Copyright (c) 2014 Basho Technologies, Inc. All Rights Reserved.
%%
%% This file is provided to you under the Apache License,
%% Version 2.0 (the "License"); you may not use this file
%% except in compliance with the License. You may obtain
%% a copy of the License at
%%
%% http://www.apache.org/licenses/LICENSE-2.0
%%
%% Unless required by applicable law or agreed to in writing,
%% software distributed under the License is distributed on an
%% "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
%% KIND, either express or implied. See the License for the
%% specific language governing permissions and limitations
%% under the License.
%%
%% -------------------------------------------------------------------
-module(machi_chain_manager_test0).
-include("machi.hrl").
-define(MGR, machi_chain_manager0).
-define(D(X), io:format(user, "~s ~p\n", [??X, X])).
-export([]).
-ifdef(TEST).
-ifdef(EQC).
-include_lib("eqc/include/eqc.hrl").
%% -include_lib("eqc/include/eqc_statem.hrl").
-define(QC_OUT(P),
eqc:on_output(fun(Str, Args) -> io:format(user, Str, Args) end, P)).
-endif.
-include_lib("eunit/include/eunit.hrl").
-compile(export_all).
smoke0_test() ->
S0 = ?MGR:make_initial_state(a, [a,b,c,d], {4,5,6}),
lists:foldl(fun(_, S) ->
{P1, S1} = ?MGR:calc_projection(20, 1, S),
%% io:format(user, "~p\n", [?MGR:make_projection_summary(P1)]),
S1#ch_mgr{proj=P1}
end, S0, lists:seq(1,10)).
-ifdef(CRUFT_DELETE_ME_MAYBE).
-record(s, {
step = 0 :: non_neg_integer(),
seed :: {integer(), integer(), integer()}
}).
gen_all_nodes() ->
[a, b, c].
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
initial_state() ->
#s{}.
command(#s{step=0}) ->
L = gen_all_nodes(),
{call, ?MODULE, init_run, [gen_rand_seed(), L]};
command(_S) ->
foo.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
prop_m() ->
?FORALL({_Cmds, _PulseSeed}, {commands(?MODULE), pulse:seed()},
begin
true
end).
-endif. % CRUFT_DELETE_ME_MAYBE
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
gen_rand_seed() ->
noshrink({gen_num(), gen_num(), gen_num()}).
gen_num() ->
choose(1, 50000).
prop_calc_projection() ->
prop_calc_projection([a,b,c], false).
prop_calc_projection(Nodes, TrackUseTab) ->
?FORALL(
{Seed, OldThreshold, NoPartitionThreshold, Steps, HeadNode},
{gen_rand_seed(),
oneof([0,15,35,55,75,85,100]),
oneof([0,15,35,55,75,85,100]),
5000,
oneof(Nodes)},
begin
erase(goofus),
{RandN, _} = random:uniform_s(length(Nodes), Seed),
NodesShuffle = lists:nth(RandN, perms(Nodes)),
S0 = ?MGR:make_initial_state(HeadNode, NodesShuffle, Seed),
F = fun(_, {S, Acc}) ->
{P1, S1} = ?MGR:calc_projection(
OldThreshold, NoPartitionThreshold, S),
%%io:format(user, "~p\n", [make_projection_summary(P1)]),
{S1#ch_mgr{proj=P1}, [P1|Acc]}
end,
{_, Projs0} = lists:foldl(F, {S0, []}, lists:seq(1,Steps)),
Projs = lists:reverse(Projs0),
if TrackUseTab == false ->
ok;
true ->
Transitions = extract_upi_transitions(Projs),
%% io:format(user, "\n~P\n", [lists:usort(Transitions), 10]),
[ets:update_counter(TrackUseTab, Trans, 1) ||
Trans <- Transitions]
end,
true = projection_transitions_are_sane(Projs)
end).
extract_upi_transitions([]) ->
[];
extract_upi_transitions([_]) ->
[];
extract_upi_transitions([P1, P2|T]) ->
Trans = {P1#projection.upi, P2#projection.upi},
[Trans|extract_upi_transitions([P2|T])].
find_common_prefix([], _) ->
[];
find_common_prefix(_, []) ->
[];
find_common_prefix([H|L1], [H|L2]) ->
[H|find_common_prefix(L1, L2)];
find_common_prefix(_, _) ->
[].
calc_projection_test_() ->
Runtime = 15, %% Runtime = 60*60,
{timeout, Runtime * 500,
fun() ->
Nodes = [a,b,c],
Cs = combinations(Nodes),
Combos = lists:sort([{UPI1, UPI2} || UPI1 <- Cs, UPI2 <- Cs]),
put(hack, 0),
timer:sleep(500),
io:format(user, "\n", []),
Rs = [begin
Hack = get(hack),if Hack rem 10000 == 0 -> ?D({time(), Hack}); true -> ok end,put(hack, Hack + 1),
P1 = ?MGR:make_projection(2, 1, <<>>, HdNd, Nodes,
[], PsUPI1, Nodes -- PsUPI1, []),
P2 = ?MGR:make_projection(3, 2, <<>>, HdNd, Nodes,
[], PsUPI2, Nodes -- PsUPI2, []),
Res = case projection_transition_is_sane(P1, P2) of
true -> true;
_ -> false
end,
{Res, PsUPI1, PsUPI2}
end || HdNd <- Nodes,
{PsUPI1,PsUPI2} <- Combos,
%% We assume that the author appears in any UPI list
PsUPI1 /= [],
PsUPI2 /= [],
%% HdNd is the author for all of these
%% tests, so it must be present in UPI1 & UPI2
lists:member(HdNd, PsUPI1),
lists:member(HdNd, PsUPI2)],
OKs = [begin
{UPI1,UPI2}
end || {true, UPI1, UPI2} <- Rs],
%% io:format(user, "OKs = ~p\n", [lists:usort(OKs)]),
Tab = ets:new(count, [public, set, {keypos, 1}]),
[ets:insert(Tab, {Transition, 0}) || Transition <- OKs],
true = eqc:quickcheck(
eqc:testing_time(Runtime,
?QC_OUT(prop_calc_projection(Nodes, Tab)))),
NotCounted = lists:sort([Transition || {Transition, 0} <- ets:tab2list(Tab)]),
Counted = [X || {_, N}=X <- ets:tab2list(Tab),
N > 0],
CountedX = lists:sort(fun(X, Y) ->
element(2, X) < element(2, Y)
end, Counted),
timer:sleep(100),
File = io_lib:format("/tmp/manager-test.~w.~w.~w",
tuple_to_list(time())),
{ok, FH} = file:open(File, [write]),
io:format(FH, "% NotCounted =\n~p.\n", [NotCounted]),
file:close(FH),
%% io:format(user, "\tNotCounted = ~p\n", [NotCounted]),
io:format(user, "\n\tNotCounted list was written to ~s\n", [File]),
io:format(user, "\tOKs length = ~p\n", [length(OKs)]),
io:format(user, "\tTransitions hit = ~p\n",
[length(OKs) - length(NotCounted)]),
%% io:format(user, "\tTransitions = ~p\n", [lists:sort(_Counted)]),
io:format(user, "\tNotCounted length = ~p\n",
[length(NotCounted)]),
io:format(user, "\tLeast-counted transition = ~p\n",
[hd(CountedX)]),
io:format(user, "\tMost-counted transition = ~p\n",
[lists:last(CountedX)]),
ok
end}.
projection_transitions_are_sane([]) ->
true;
projection_transitions_are_sane([_]) ->
true;
projection_transitions_are_sane([P1, P2|T]) ->
case projection_transition_is_sane(P1, P2) of
true ->
projection_transitions_are_sane([P2|T]);
Else ->
Else
end.
projection_transition_is_sane(
#projection{epoch_number=Epoch1,
epoch_csum=CSum1,
prev_epoch_num=PrevEpoch1,
prev_epoch_csum=PrevCSum1,
creation_time=CreationTime1,
author_server=AuthorServer1,
all_members=All_list1,
down=Down_list1,
upi=UPI_list1,
repairing=Repairing_list1,
dbg=Dbg1} = P1,
#projection{epoch_number=Epoch2,
epoch_csum=CSum2,
prev_epoch_num=PrevEpoch2,
prev_epoch_csum=PrevCSum2,
creation_time=CreationTime2,
author_server=AuthorServer2,
all_members=All_list2,
down=Down_list2,
upi=UPI_list2,
repairing=Repairing_list2,
dbg=Dbg2} = P2) ->
try
true = is_integer(Epoch1) andalso is_integer(Epoch2),
true = is_binary(CSum1) andalso is_binary(CSum2),
true = is_integer(PrevEpoch1) andalso is_integer(PrevEpoch2),
true = is_binary(PrevCSum1) andalso is_binary(PrevCSum2),
{_,_,_} = CreationTime1,
{_,_,_} = CreationTime2,
true = is_atom(AuthorServer1) andalso is_atom(AuthorServer2), % todo will probably change
true = is_list(All_list1) andalso is_list(All_list2),
true = is_list(Down_list1) andalso is_list(Down_list2),
true = is_list(UPI_list1) andalso is_list(UPI_list2),
true = is_list(Repairing_list1) andalso is_list(Repairing_list2),
true = is_list(Dbg1) andalso is_list(Dbg2),
true = Epoch2 > Epoch1,
true = PrevEpoch2 > PrevEpoch1,
All_list1 = All_list2, % todo will probably change
%% No duplicates
true = lists:sort(Down_list2) == lists:usort(Down_list2),
true = lists:sort(UPI_list2) == lists:usort(UPI_list2),
true = lists:sort(Repairing_list2) == lists:usort(Repairing_list2),
%% Disjoint-ness
true = lists:sort(All_list2) == lists:sort(Down_list2 ++ UPI_list2 ++
Repairing_list2),
[] = [X || X <- Down_list2, not lists:member(X, All_list2)],
[] = [X || X <- UPI_list2, not lists:member(X, All_list2)],
[] = [X || X <- Repairing_list2, not lists:member(X, All_list2)],
DownS2 = sets:from_list(Down_list2),
UPIS2 = sets:from_list(UPI_list2),
RepairingS2 = sets:from_list(Repairing_list2),
true = sets:is_disjoint(DownS2, UPIS2),
true = sets:is_disjoint(DownS2, RepairingS2),
true = sets:is_disjoint(UPIS2, RepairingS2),
%% The author must not be down.
false = lists:member(AuthorServer1, Down_list1),
false = lists:member(AuthorServer2, Down_list2),
%% The author must be in either the UPI or repairing list.
true = lists:member(AuthorServer1, UPI_list1 ++ Repairing_list1),
true = lists:member(AuthorServer2, UPI_list2 ++ Repairing_list2),
%% Additions to the UPI chain may only be at the tail
UPI_common_prefix = find_common_prefix(UPI_list1, UPI_list2),
if UPI_common_prefix == [] ->
if UPI_list1 == [] orelse UPI_list2 == [] ->
%% If the common prefix is empty, then one of the
%% inputs must be empty.
true;
true ->
%% Otherwise, we have a case of UPI changing from
%% one of these two situations:
%%
%% UPI_list1 -> UPI_list2
%% [d,c,b,a] -> [c,a]
%% [d,c,b,a] -> [c,a,repair_finished_added_to_tail].
NotUPI2 = (Down_list2 ++ Repairing_list2),
true = lists:prefix(UPI_list1 -- NotUPI2,
UPI_list2)
end;
true ->
true
end,
true = lists:prefix(UPI_common_prefix, UPI_list1),
true = lists:prefix(UPI_common_prefix, UPI_list2),
UPI_1_suffix = UPI_list1 -- UPI_common_prefix,
UPI_2_suffix = UPI_list2 -- UPI_common_prefix,
%% Where did elements in UPI_2_suffix come from?
%% Only two sources are permitted.
[true = lists:member(X, Repairing_list1) % X added after repair done
orelse
lists:member(X, UPI_list1) % X in UPI_list1 after common pref
|| X <- UPI_2_suffix],
%% The UPI_2_suffix must exactly be equal to: ordered items from
%% UPI_list1 concat'ed with ordered items from Repairing_list1.
%% Both temp vars below preserve relative order!
UPI_2_suffix_from_UPI1 = [X || X <- UPI_1_suffix,
lists:member(X, UPI_list2)],
UPI_2_suffix_from_Repairing1 = [X || X <- UPI_2_suffix,
lists:member(X, Repairing_list1)],
%% true?
UPI_2_suffix = UPI_2_suffix_from_UPI1 ++ UPI_2_suffix_from_Repairing1,
true
catch
_Type:_Err ->
S1 = ?MGR:make_projection_summary(P1),
S2 = ?MGR:make_projection_summary(P2),
Trace = erlang:get_stacktrace(),
{err, from, S1, to, S2, stack, Trace}
end.
pass1_smoke_test() ->
P2 = ?MGR:make_projection(2, 1, <<>>, a, [a,b,c,d],
[], [d,c,b,a], [], []),
P3 = ?MGR:make_projection(3, 2, <<>>, a, [a,b,c,d],
[b,c,d], [a], [], []),
true = projection_transition_is_sane(P2, P3),
P2b= ?MGR:make_projection(2, 1, <<>>, a, [a,b,c,d],
[], [d,c,b,a], [], []),
P3b= ?MGR:make_projection(3, 2, <<>>, a, [a,b,c,d],
[b,d], [c,a], [], []),
true = projection_transition_is_sane(P2b, P3b),
P2c= ?MGR:make_projection(2, 1, <<>>, a, [a,b,c,d,e],
[], [e,d,c,b], [a], []),
P3c= ?MGR:make_projection(3, 2, <<>>, a, [a,b,c,d,e],
[e,c], [d,b,a], [], []),
true = projection_transition_is_sane(P2c, P3c),
true.
fail1_smoke_test() ->
P15 = ?MGR:make_projection(15, 14, <<>>, a, [a,b,c,d],
[b,d], [a], [c], []),
P16 = ?MGR:make_projection(16, 15, <<>>, a, [a,b,c,d],
[b,d], [c,a], [], []),
true = projection_transition_is_sane(P15, P16) /= true,
P2d= ?MGR:make_projection(2, 1, <<>>, a, [a,b,c,d,e],
[], [e,d,c,b], [a], []),
P3d= ?MGR:make_projection(3, 2, <<>>, a, [a,b,c,d,e],
[e,c], [d,a,b], [], []),
true = projection_transition_is_sane(P2d, P3d) /= true,
P2e= ?MGR:make_projection(2, 1, <<>>, a, [a,b,c,d,e],
[], [e,d,c,b], [a], []),
P3e= ?MGR:make_projection(3, 2, <<>>, a, [a,b,c,d,e],
[e,c], [a,d,b], [], []),
true = projection_transition_is_sane(P2e, P3e) /= true,
true.
fail2_smoke_test() ->
AB = [a,b],
BadSets = [{1, [b,a],[a,b]},
{2, [b],[a,b]},
%% {3, [a],[b]}, % weird but valid: [a] means b is repairing;
% so if a fails and b finishes repairing,
% swapping both at the same time is "ok".
{4, [a,b],[b,a]},
%% {5, [b],[a]}, % weird but valid: see above
{6, [a],[b,a]}
],
[begin
P2f= ?MGR:make_projection(2, 1, <<>>, a, AB,
[], Two, AB -- Two, []),
P3f= ?MGR:make_projection(3, 2, <<>>, a, AB,
[], Three, AB -- Three, []),
{Label, true} =
{Label, (projection_transition_is_sane(P2f, P3f) /= true)}
end || {Label, Two, Three} <- BadSets],
true.
fail3_smoke_test() ->
Nodes = [a,b],
UPI1 = [a,b],
UPI2 = [b,a],
[begin
PsUPI1 = UPI1,
PsUPI2 = UPI2,
P1 = ?MGR:make_projection(2, 1, <<>>, HdNd, Nodes,
[], PsUPI1, Nodes -- PsUPI1, []),
P2 = ?MGR:make_projection(3, 2, <<>>, HdNd, Nodes,
[], PsUPI2, Nodes -- PsUPI2, []),
Res = case projection_transition_is_sane(P1, P2) of
true -> true;
_ -> false
end,
{Res, HdNd, PsUPI1, PsUPI2} = {false, HdNd, PsUPI1, PsUPI2}
end || HdNd <- Nodes],
true.
fail4_smoke_test() ->
Nodes = [a,b,c],
Two = [c,b,a],
Three = [c,a,b],
P2a= ?MGR:make_projection(2, 1, <<>>, a, Nodes,
[], Two, Nodes -- Two, []),
P3a= ?MGR:make_projection(3, 2, <<>>, a, Nodes,
[], Three, Nodes -- Three, []),
true = (projection_transition_is_sane(P2a, P3a) /= true),
true.
%% aaa_smoke_test() ->
%% L = [a,b,c,d],
%% Cs = combinations(L),
%% Combos = lists:sort([{X, Y} || X <- Cs, Y <- Cs]),
%% timer:sleep(500),
%% io:format(user, "\n", []),
%% Rs = [begin
%% P1 = ?MGR:make_projection(2, 1, <<>>, a, L,
%% [], X, L -- X, []),
%% P2 = ?MGR:make_projection(3, 2, <<>>, a, L,
%% [], Y, L -- Y, []),
%% Res = case projection_transition_is_sane(P1, P2) of
%% true -> true;
%% _ -> false
%% end,
%% {Res, P1, P2}
%% end || {X,Y} <- Combos],
%% OKs = [{X,Y} || {true, X, Y} <- Rs],
%% io:format(user, "Cs are ~p\n", [length(Cs)]),
%% io:format(user, "OKs are ~p\n", [length(OKs)]),
%% Bads = [{X,Y} || {false, X, Y} <- Rs],
%% io:format(user, "Bads are ~p\n", [length(Bads)]),
%% %% [io:format(user, "~p -> ~p: ~p\n", [X, Y, Res]);
%% ok.
combinations(L) ->
lists:usort(perms(L) ++ lists:append([ combinations(L -- [X]) || X <- L])).
perms([]) -> [[]];
perms(L) -> [[H|T] || H <- L, T <- perms(L--[H])].
-endif.

View file

@ -31,7 +31,7 @@
-ifdef(TEST). -ifdef(TEST).
repair_status_test() -> repair_status_test() ->
{ok, F} = machi_flu0:start_link("one"), {ok, F} = machi_flu0:start_link(one),
try try
ok = machi_flu0:set_fake_repairing_status(F, true), ok = machi_flu0:set_fake_repairing_status(F, true),
true = machi_flu0:get_fake_repairing_status(F), true = machi_flu0:get_fake_repairing_status(F),
@ -47,13 +47,13 @@ concuerror1_test() ->
ok. ok.
concuerror2_test() -> concuerror2_test() ->
{ok, F} = machi_flu0:start_link("one"), {ok, F} = machi_flu0:start_link(one),
ok = machi_flu0:stop(F), ok = machi_flu0:stop(F),
ok. ok.
concuerror3_test() -> concuerror3_test() ->
Me = self(), Me = self(),
Fun = fun() -> {ok, F1} = machi_flu0:start_link("one"), Fun = fun() -> {ok, F1} = machi_flu0:start_link(one),
ok = machi_flu0:stop(F1), ok = machi_flu0:stop(F1),
Me ! done Me ! done
end, end,
@ -65,7 +65,7 @@ concuerror3_test() ->
concuerror4_test() -> concuerror4_test() ->
event_setup(), event_setup(),
{ok, F1} = machi_flu0:start_link("one"), {ok, F1} = machi_flu0:start_link(one),
Epoch = 1, Epoch = 1,
ok = m_proj_write(F1, Epoch, dontcare), ok = m_proj_write(F1, Epoch, dontcare),
@ -103,7 +103,7 @@ concuerror4_test() ->
proj_store_test() -> proj_store_test() ->
event_setup(), event_setup(),
{ok, F1} = machi_flu0:start_link("one"), {ok, F1} = machi_flu0:start_link(one),
error_unwritten = m_proj_get_latest_num(F1), error_unwritten = m_proj_get_latest_num(F1),
error_unwritten = m_proj_read_latest(F1), error_unwritten = m_proj_read_latest(F1),
@ -120,7 +120,7 @@ proj_store_test() ->
wedge_test() -> wedge_test() ->
event_setup(), event_setup(),
{ok, F1} = machi_flu0:start_link("one"), {ok, F1} = machi_flu0:start_link(one),
Epoch1 = 1, Epoch1 = 1,
ok = m_proj_write(F1, Epoch1, dontcare), ok = m_proj_write(F1, Epoch1, dontcare),
@ -148,8 +148,8 @@ wedge_test() ->
proj0_test() -> proj0_test() ->
Me = self(), Me = self(),
event_setup(), event_setup(),
{ok, F1} = machi_flu0:start_link("one"), {ok, F1} = machi_flu0:start_link(one),
{ok, F2} = machi_flu0:start_link("two"), {ok, F2} = machi_flu0:start_link(two),
FLUs = [F1, F2], FLUs = [F1, F2],
FirstProj = machi_flu0:make_proj(1, FLUs), FirstProj = machi_flu0:make_proj(1, FLUs),
Epoch1 = FirstProj#proj.epoch, Epoch1 = FirstProj#proj.epoch,
@ -207,7 +207,7 @@ m_stop(Pid) ->
Res. Res.
m_proj_write(Pid, Epoch, Proj) -> m_proj_write(Pid, Epoch, Proj) ->
Res = machi_flu0:proj_write(Pid, Epoch, Proj), Res = machi_flu0:proj_write(Pid, Epoch, public, Proj),
event_add(proj_write, Pid, Res), event_add(proj_write, Pid, Res),
Res. Res.
@ -227,17 +227,17 @@ m_proj_write_with_check(Pid, Epoch, Proj) ->
end. end.
m_proj_read(Pid, Epoch) -> m_proj_read(Pid, Epoch) ->
Res = machi_flu0:proj_read(Pid, Epoch), Res = machi_flu0:proj_read(Pid, Epoch, public),
event_add(proj_read, Pid, Res), event_add(proj_read, Pid, Res),
Res. Res.
m_proj_get_latest_num(Pid) -> m_proj_get_latest_num(Pid) ->
Res = machi_flu0:proj_get_latest_num(Pid), Res = machi_flu0:proj_get_latest_num(Pid, public),
event_add(proj_get_latest_num, Pid, Res), event_add(proj_get_latest_num, Pid, Res),
Res. Res.
m_proj_read_latest(Pid) -> m_proj_read_latest(Pid) ->
Res = machi_flu0:proj_read_latest(Pid), Res = machi_flu0:proj_read_latest(Pid, public),
event_add(proj_read_latest, Pid, Res), event_add(proj_read_latest, Pid, Res),
Res. Res.