Erlang generic standard behaviours -- gen_server noblock call

 1 handle_call({block_call, Mod, Fun, Args, Gleader}, _To, S) ->
 2     MyGL = group_leader(),
 3     set_group_leader(Gleader),
 4     Reply = 
 5         case catch apply(Mod,Fun,Args) of
 6             {‘EXIT‘, _} = Exit ->
 7                 {badrpc, Exit};
 8             Other ->
 9                 Other
10         end,
11     group_leader(MyGL, self()), % restore
12     {reply, Reply, S};

1 handle_call({call, Mod, Fun, Args, Gleader}, To, S) ->
2     handle_call_call(Mod, Fun, Args, Gleader, To, S);

 1 handle_call_call(Mod, Fun, Args, Gleader, To, S) ->
 2     RpcServer = self(),
 3     %% Spawn not to block the rpc server.
 4     {Caller,_} =
 5         erlang:spawn_monitor(
 6           fun () ->
 7                   set_group_leader(Gleader),
 8                   Reply = 
 9                       %% in case some sucker rex‘es 
10                       %% something that throws
11                       case catch apply(Mod, Fun, Args) of
12                           {‘EXIT‘, _} = Exit ->
13                               {badrpc, Exit};
14                           Result ->
15                               Result
16                       end,
17                   RpcServer ! {self(), {reply, Reply}}
18           end),
19     {noreply, gb_trees:insert(Caller, To, S)}.

 1 handle_info({Caller, {reply, Reply}}, S) ->
 2     case gb_trees:lookup(Caller, S) of
 3         {value, To} ->
 4             receive
 5                 {‘DOWN‘, _, process, Caller, _} -> 
 6                     gen_server:reply(To, Reply),
 7                     {noreply, gb_trees:delete(Caller, S)}
 8             end;
 9         none ->
10             {noreply, S}
11     end;

 1 init({Name, LongOrShortNames, TickT}) ->
 2     process_flag(trap_exit,true),
 3     case init_node(Name, LongOrShortNames) of
 4     {ok, Node, Listeners} ->
 5         process_flag(priority, max),
 6         Ticktime = to_integer(TickT),
 7         Ticker = spawn_link(net_kernel, ticker, [self(), Ticktime]),
 8         {ok, #state{name = Name,
 9             node = Node,
10             type = LongOrShortNames,
11             tick = #tick{ticker = Ticker, time = Ticktime},
12             connecttime = connecttime(),
13             connections =
14             ets:new(sys_dist,[named_table,
15                       protected,
16                       {keypos, 2}]),
17             listen = Listeners,
18             allowed = [],
19             verbose = 0
20                }};
21     Error ->
22         {stop, Error}
23     end.

 1 %%
 2 %% The spawn/4 BIF ends up here.
 3 %%
 4 handle_call({spawn,M,F,A,Gleader},{From,Tag},State) when is_pid(From) ->
 5     do_spawn([no_link,{From,Tag},M,F,A,Gleader],[],State);
 6 
 7 %%
 8 %% The spawn_link/4 BIF ends up here.
 9 %%
10 handle_call({spawn_link,M,F,A,Gleader},{From,Tag},State) when is_pid(From) ->
11     do_spawn([link,{From,Tag},M,F,A,Gleader],[],State);
12 
13 %%
14 %% The spawn_opt/5 BIF ends up here.
15 %%
16 handle_call({spawn_opt,M,F,A,O,L,Gleader},{From,Tag},State) when is_pid(From) ->
17     do_spawn([L,{From,Tag},M,F,A,Gleader],O,State);

 1 do_spawn(SpawnFuncArgs, SpawnOpts, State) ->
 2     [_,From|_] = SpawnFuncArgs,
 3     case catch spawn_opt(?MODULE, spawn_func, SpawnFuncArgs, SpawnOpts) of
 4     　　{‘EXIT‘, {Reason,_}} ->
 5             async_reply({reply, {‘EXIT‘, {Reason,[]}}, State}, From);
 6     　　{‘EXIT‘, Reason} ->
 7         　　async_reply({reply, {‘EXIT‘, {Reason,[]}}, State}, From);
 8     　　_ ->
 9     　　    {noreply,State}
10     end.

 1 %% This code is really intricate. The link will go first and then comes
 2 %% the pid, This means that the client need not do a network link.
 3 %% If the link message would not arrive, the runtime system shall
 4 %% generate a nodedown message
 5 
 6 spawn_func(link,{From,Tag},M,F,A,Gleader) ->
 7     link(From),
 8     gen_server:reply({From,Tag},self()),  %% ahhh
 9     group_leader(Gleader,self()),
10     apply(M,F,A);
11 spawn_func(_,{From,Tag},M,F,A,Gleader) ->
12     gen_server:reply({From,Tag},self()),  %% ahhh
13     group_leader(Gleader,self()),
14     apply(M,F,A).