使用gen_server实现的更为复杂的。。。山寨kahoot!!!!!!
然鹅这次我们换名字了，现在它叫阿童木TA(robota)!
-module(robota).
-behaviour(gen_server).
%% Test helper function
-export([get_module_grader/1, get_concurrent_grader/1, valid/3,
get_mgrader/1, run_all_module_grader/1, troels_eval/2, check/2, eval/3]).
%% API
-export([get_the_show_started/0, new/2,
add_part/3, del_part/2, available/1, unavailable/1, status/1,
grade/4]).
%% gen_server callbacks
-export([init/1, handle_call/3, handle_cast/2, handle_info/2,
terminate/2, code_change/3]).
-define(SERVER, ?MODULE).
%%%===================================================================
%%% API
%%%===================================================================
get_the_show_started() ->
try
gen_server:start_link({local, ?SERVER}, ?MODULE, [], [])
catch
_ : _ -> {error,"Failed to crate a RoboTA!/n"}
end.
new(RoboTA, Name) ->
gen_server:call(RoboTA, {new, Name}).
add_part(AssHandler, Label, Grader) ->
gen_server:call(?MODULE, {add_part, AssHandler, Label, Grader}).
del_part(AssHandler, Label) ->
gen_server:cast(?MODULE, {del_part, AssHandler, Label}).
available(AssHandler) ->
gen_server:call(?MODULE, {available, AssHandler}).
unavailable(AssHandler) ->
gen_server:call(?MODULE, {unavailable, AssHandler}).
status(AssHandler) ->
gen_server:call(?MODULE, {status, AssHandler}).
grade(RoboTA, Name, Submission, Pid) ->
gen_server:call(RoboTA, {grade, Name, Submission, Pid}).
%%%===================================================================
%%% gen_server callbacks
%%%===================================================================
init([]) -> {ok, #{}}.
handle_call({new, Name}, _From, State) ->
case maps:find(Name, State) of
{ok, _} -> {reply, {error,the_name_has_been_token}, State};
_ -> Ref = make_ref(),
AssHandler = {Name, Ref},
NewState = maps:put(Name, {[], false, []}, State),
{reply, {ok, AssHandler}, NewState}
end;
handle_call({add_part, AssHandler, Label, Grader}, _From, State) ->
{Name, _Ref} = AssHandler,
case maps:find(Name, State) of
% check assignment not active
{ok, {AssignmentList,false, GraderList}} ->
% check label unique
case lists:keymember(Label, 1, AssignmentList) of
true -> {reply, {error, {Label, not_unique}}, State};
false ->
NewAssignmentList = lists:append(AssignmentList,[{Label,Grader}]),
NewState = maps:put(Name, {NewAssignmentList, false, GraderList}, State),
{reply, ok, NewState}
end;
{ok, {_AssignmentList,true, _}} ->
{reply, {error, {Name, is_available}}, State};
_ -> {reply, {error, fake_asshandler}, State}
end;
handle_call({available, AssHandler}, _From, State) ->
{Name, _Ref} = AssHandler,
case maps:find(Name, State) of
{ok, {AssignmentList,false, GraderList}} ->
ModuleGrader = get_mgrader(AssignmentList),
case ModuleGrader of
[] -> NewState = maps:put(Name, {AssignmentList, true}, State),
{reply, ok, NewState};
_ ->
try
NewAssignmentList = run_all_module_grader(AssignmentList),
NewState = maps:put(Name, {NewAssignmentList, true, GraderList}, State),
{reply, ok, NewState}
catch
Error -> Error
end
end;
{ok, {_AssignmentList,true, _}} ->
{reply, {error, already_available}, State};
_ -> {reply, {error, fake_asshandler}, State}
end;
handle_call({unavailable, AssHandler}, _From, State) ->
{Name, _Ref} = AssHandler,
case maps:find(Name, State) of
{ok, {AssignmentList, true, GraderList}} ->
% check no submission under grading and all graders have been upload
ModuleGrader = get_mgrader(AssignmentList),
try
unload_all(ModuleGrader),
check_no_grading(GraderList),
NewState = maps:put(Name, {AssignmentList, false, []}, State),
{reply, ok, NewState}
catch
Reason -> {reply, {error, Reason}, State}
end;
{ok, {_AssignmentList,false, _}} ->
{reply, {error, already_unavailable}, State};
_ -> {reply, {error, fake_asshandler}, State}
end;
handle_call({status, AssHandler}, _From, State) ->
{Name, _Ref} = AssHandler,
case maps:find(Name, State) of
{ok, {AssignmentList, false, _}} ->
{reply, {unavailable, AssignmentList}, State};
{ok, {AssignmentList, true, _}} ->
{reply, {available, AssignmentList}, State}
end;
handle_call({grade, Name, Submission, Pid}, _From, State) ->
case maps:find(Name, State) of
{ok, {_AssignmentList, false, _}} ->
{reply, {error, {Name, is_unavailable}}, State};
{ok, {AssignmentList, true, GraderList}} ->
GraderProcess = spawn(fun() -> graderloop([]) end),
NewState = maps:put(Name, {AssignmentList, true, [GraderProcess | GraderList]}, State),
case valid(Submission, [], AssignmentList) of
false -> Pid ! {error, invalid_submission};
ValidSub ->
try
Feedback = eval(ValidSub, AssignmentList, GraderProcess),
Pid ! {ok, Feedback}
catch
_:_ -> totally_grader_failed
end
end,
{reply, finished, NewState}
end.
handle_cast({del_part, AssHandler, Label}, State) ->
{Name, _Ref} = AssHandler,
case maps:find(Name, State) of
{ok, {AssignmentList, Active, GraderList}} ->
case lists:keyfind(Label, 1, AssignmentList) of
false -> {noreply, State};
Tuple -> NewAssignmentList = lists:delete(Tuple, AssignmentList),
NewState = maps:put(Name, {NewAssignmentList, Active, GraderList}, State),
{noreply, NewState}
end;
_ -> {noreply, State}
end.
handle_info(_Info, State) ->
{noreply, State}.
terminate(_Reason, _State) ->
ok.
code_change(_OldVsn, State, _Extra) ->
{ok, State}.
% helper functions
get_concurrent_grader([]) -> [];
get_concurrent_grader([X|Xs]) ->
case X of
{_Label, {troels, Gs}} ->
lists:append(Gs, get_concurrent_grader(Xs));
_ -> get_concurrent_grader(Xs)
end.
get_module_grader([]) -> [];
get_module_grader([X|Xs]) ->
case X of
{_Label, {andrzej, Callback, Init}} ->
lists:append([{andrzej, Callback, Init}], get_module_grader(Xs));
{andrzej, Callback, Init} ->
lists:append([{andrzej, Callback, Init}], get_module_grader(Xs));
_ -> get_module_grader(Xs)
end.
% combine get_concurrent_grader and get_module_grader
get_mgrader(AL) ->
CL = get_concurrent_grader(AL),
AAL = lists:append(CL,AL),
get_module_grader(AAL).
% run all module grader
run_all_module_grader([]) -> [];
run_all_module_grader([X|Xs]) ->
case X of
{Label, {andrzej, Callback, Init}} ->
case Callback:setup(Init) of
{ok, Salt} -> lists:append([{Label, {andrzej, Callback, Salt}}], run_all_module_grader(Xs));
% throw?
Error -> Error
end;
{Label, {troels, Gs}} ->
try
NGs = run_list_module_grader(Gs),
lists:append([{Label, {troels, NGs}}], run_all_module_grader(Xs))
catch
_ -> grader_failed
end;
Other -> lists:append([Other],run_all_module_grader(Xs))
end.
run_list_module_grader([]) -> [];
run_list_module_grader([X|Xs]) ->
case X of
{andrzej, Callback, Init} ->
case Callback:setup(Init) of
{ok, Salt} -> lists:append([{andrzej, Callback, Salt}], run_list_module_grader(Xs));
% throw?
Error -> Error
end;
Other -> lists:append([Other],run_list_module_grader(Xs))
end.
valid([],_,_) -> [];
valid([{Label, Answer} | Xs], Cont, AssignmentList) ->
case lists:keymember(Label, 1, AssignmentList) of
true ->
case lists:member(Label, Cont) of
true -> valid(Xs, Cont, AssignmentList);
false -> lists:append([{Label, Answer}], valid(Xs, [Label|Cont], AssignmentList))
end;
false -> false
end.
% check submissions with label and Answers with label
eval(_ValidSub,[],_) -> [];
eval(ValidSub,[{Label,Grader} | AL],GraderProcess) ->
case lists:keyfind(Label, 1, ValidSub) of
false -> lists:append([{Label, missing}], eval(ValidSub, AL, GraderProcess));
{Label,Answer} ->
try
Me = self(),
GraderProcess ! {Me,grading_start},
spawn(fun() ->
try
Result = check(Answer, Grader),
Me ! Result
catch
_:_ -> grader_failed
end
end),
receive
Result ->
GraderProcess ! {Me, grading_finish},
lists:append([{Label,Result}], eval(ValidSub,AL, GraderProcess))
after
3000 ->
GraderProcess ! {Me, grading_finish},
lists:append([{Label,grader_failed}], eval(ValidSub,AL, GraderProcess))
end
catch
_:_ -> lists:append([{Label,grader_failed}], eval(ValidSub,AL, GraderProcess))
end
end.
% check Gs result or total grader fail
troels_eval([],[]) -> [];
troels_eval([A|As],[G|Gs]) ->
Me = self(),
try
spawn(fun() ->
try
Res = check(A,G),
Me ! Res
catch
_:_ -> grader_failed
end
end),
Rs = troels_eval(As,Gs),
receive
Result -> lists:append(Rs, [Result])
end
catch
_:_ -> throw(grader_failed)
end;
troels_eval(_,_) -> throw(grader_failed).
% check single Answer in Gs is correct or not
check(A,G) ->
case G of
abraham -> looks_good;
niels -> failed;
{mikkel, Expect} ->
case (A =:= Expect) of
true -> looks_good;
_ -> failed
end;
{simon, Arg, Expect} ->
case (A(Arg) =:= Expect) of
true -> looks_good;
false -> failed
end;
{andrzej, Callback, Salt} ->
{ok, Result} = Callback:grade(Salt, {fakelabel, A}),
Result;
{troels, Gs} ->
try
troels_eval(A, Gs)
catch
_:_ -> grader_failed
end;
_ -> throw(grader_failed)
end.
unload_all([]) -> ok;
unload_all([{andrzej, Callback, Salt}|Xs]) ->
try
Callback:unload(Salt),
unload_all(Xs)
catch
Error -> Error
end.
graderloop(GraderList) ->
receive
{Pid, grading_start} ->
NewGraderList = [Pid | GraderList],
graderloop(NewGraderList);
{Pid, grading_finish} ->
graderloop(lists:delete(Pid, GraderList));
{From, check_finished} ->
case GraderList of
[] -> From ! all_finished;
_ -> graderloop(GraderList)
end
end.
check_no_grading([]) -> ok;
check_no_grading([G|Gs]) ->
From = self(),
G ! {From, check_finished},
receive
all_finished -> check_no_grading(Gs)
end.