ft: add gen_emm

src/gen_emm.erl

@@ -11,7 +11,7 @@
    , start_monitor/0, start_monitor/1, start_monitor/2
    , stop/1, stop/3
    , call/3, call/4
-   , epm_info/3
+   , send/3
    , send_request/3, wait_response/2, check_response/2
    , info_notify/2, call_notify/2
    , add_epm/3, add_sup_epm/3, del_epm/3
@@ -36,6 +36,8 @@
    , format_log/1, format_log/2
 ]).
 
+-define(STACKTRACE(), element(2, erlang:process_info(self(), current_stacktrace))).
+
 %% debug 调试相关宏定义
 -define(NOT_DEBUG, []).
 -define(SYS_DEBUG(Debug, Name, Msg),
@@ -107,7 +109,7 @@
    {'ok', {pid(), reference()}} |
    {'error', term()}.
 
--type request_id() :: term().
+-type requestId() :: term().
 
 -record(handler, {module :: atom(),
    id = false,
@@ -221,53 +223,54 @@ init_it(Starter, Parent, ServerRef, _, _, Options) ->
    proc_lib:init_ack(Starter, {ok, self()}),
    receiveIng(Parent, Name, [], HibernateAfterTimeout, Debug, false).
 
--spec add_epm(serverRef(), handler(), term()) -> term().
-add_epm(M, Handler, Args) ->
-   rpc(M, {add_handler, Handler, Args}).
+-spec add_epm(serverRef(), epmHandler(), term()) -> term().
+add_epm(EpmSrv, EpmHandler, Args) ->
+   epmRpc(EpmSrv, {'$addEpm', EpmHandler, Args}).
 
--spec add_sup_epm(serverRef(), handler(), term()) -> term().
-add_sup_epm(M, Handler, Args) ->
-   rpc(M, {add_sup_handler, Handler, Args, self()}).
+-spec add_sup_epm(serverRef(), epmHandler(), term()) -> term().
+add_sup_epm(EpmSrv, EpmHandler, Args) ->
+   epmRpc(EpmSrv, {'$addSupEpm', EpmHandler, Args}).
 
--spec del_epm(serverRef(), handler(), term()) -> term().
-del_epm(M, Handler, Args) -> rpc(M, {delete_handler, Handler, Args}).
+-spec del_epm(serverRef(), epmHandler(), term()) -> term().
+del_epm(EpmSrv, EpmHandler, Args) ->
+   epmRpc(EpmSrv, {'$deleteEpm', EpmHandler, Args}).
 
--spec swap_epm(serverRef(), {handler(), term()}, {handler(), term()}) ->
-   'ok' | {'error', term()}.
-swap_epm(M, {H1, A1}, {H2, A2}) -> rpc(M, {swap_handler, H1, A1, H2, A2}).
+-spec swap_epm(serverRef(), {epmHandler(), term()}, {epmHandler(), term()}) -> 'ok' | {'error', term()}.
+swap_epm(EpmSrv, {H1, A1}, {H2, A2}) ->
+   epmRpc(EpmSrv, {'$swapEpm', H1, A1, H2, A2}).
 
--spec swap_sup_epm(serverRef(), {handler(), term()}, {handler(), term()}) ->
-   'ok' | {'error', term()}.
-swap_sup_epm(M, {H1, A1}, {H2, A2}) ->
-   rpc(M, {swap_sup_handler, H1, A1, H2, A2, self()}).
+-spec swap_sup_epm(serverRef(), {epmHandler(), term()}, {epmHandler(), term()}) -> 'ok' | {'error', term()}.
+swap_sup_epm(EpmSrv, {H1, A1}, {H2, A2}) ->
+   epmRpc(EpmSrv, {'$swapSupEpm', H1, A1, H2, A2, self()}).
 
--spec which_epm(serverRef()) -> [handler()].
-which_epm(M) -> rpc(M, which_handlers).
+-spec which_epm(serverRef()) -> [epmHandler()].
+which_epm(EpmSrv) ->
+   epmRpc(EpmSrv, '$which_handlers').
 
 -spec info_notify(serverRef(), term()) -> 'ok'.
-info_notify(M, Event) ->
-   send(M, {notify, Event}).
+info_notify(EpmSrv, Event) ->
+   epmRequest(EpmSrv, {'$gen_info', '$infoNotify', Event}).
 
 -spec call_notify(serverRef(), term()) -> 'ok'.
-call_notify(M, Event) ->
-   rpc(M, {sync_notify, Event}).
+call_notify(EpmSrv, Event) ->
+   epmRpc(EpmSrv, {'$syncNotify', Event}).
 
 -spec call(serverRef(), handler(), term()) -> term().
-call(M, Handler, Query) ->
-   call1(M, Handler, Query).
+call(EpmSrv, EpmHandler, Query) ->
+   epmRpc(EpmSrv, {'$epmCall', EpmHandler, Query}).
 
--spec call(serverRef(), handler(), term(), timeout()) -> term().
-call(M, Handler, Query, Timeout) ->
-   call1(M, Handler, Query, Timeout).
+-spec call(serverRef(), epmHandler(), term(), timeout()) -> term().
+call(EpmSrv, EpmHandler, Query, Timeout) ->
+   epmRpc(EpmSrv, {'$epmCall', EpmHandler, Query}, Timeout).
 
-epm_info(M, Handler, Query) ->
-   call1(M, Handler, Query).
+send(EpmSrv, EpmHandler, Msg) ->
+   epmRequest(EpmSrv, {'$gen_info', EpmHandler, Msg}).
 
--spec send_request(serverRef(), handler(), term()) -> request_id().
-send_request(M, Handler, Query) ->
-   gen:send_request(M, self(), {call, Handler, Query}).
+-spec send_request(serverRef(), epmHandler(), term()) -> requestId().
+send_request(EpmSrv, EpmHandler, Query) ->
+   gen:send_request(EpmSrv, '$gen_call', {'$epmCall', EpmHandler, Query}).
 
--spec wait_response(RequestId :: request_id(), timeout()) ->
+-spec wait_response(RequestId :: requestId(), timeout()) ->
    {reply, Reply :: term()} | 'timeout' | {error, {Reason :: term(), serverRef()}}.
 wait_response(RequestId, Timeout) ->
    case gen:wait_response(RequestId, Timeout) of
@@ -275,7 +278,7 @@ wait_response(RequestId, Timeout) ->
       Return -> Return
    end.
 
--spec check_response(Msg :: term(), RequestId :: request_id()) ->
+-spec check_response(Msg :: term(), RequestId :: requestId()) ->
    {reply, Reply :: term()} | 'no_reply' | {error, {Reason :: term(), serverRef()}}.
 check_response(Msg, RequestId) ->
    case gen:check_response(Msg, RequestId) of
@@ -283,38 +286,34 @@ check_response(Msg, RequestId) ->
       Return -> Return
    end.
 
-rpc(M, Cmd) ->
-   {ok, Reply} = gen:call(M, self(), Cmd, infinity),
-   Reply.
-
-call1(M, Handler, Query) ->
-   Cmd = {call, Handler, Query},
-   try gen:call(M, self(), Cmd) of
-      {ok, Res} ->
-         Res
-   catch
-      exit:Reason ->
-         exit({Reason, {?MODULE, call, [M, Handler, Query]}})
+epmRpc(EpmSrv, Cmd) ->
+   try gen:call(EpmSrv, '$gen_call', Cmd, infinity) of
+      {ok, Reply} ->
+         Reply
+   catch Class:Reason ->
+      erlang:raise(Class, {Reason, {?MODULE, call, [EpmSrv, Cmd, infinity]}}, ?STACKTRACE())
    end.
 
-call1(M, Handler, Query, Timeout) ->
-   Cmd = {call, Handler, Query},
-   try gen:call(M, self(), Cmd, Timeout) of
-      {ok, Res} ->
-         Res
-   catch
-      exit:Reason ->
-         exit({Reason, {?MODULE, call, [M, Handler, Query, Timeout]}})
+epmRpc(EpmSrv, Cmd, Timeout) ->
+   try gen:call(EpmSrv, '$gen_call', Cmd, Timeout) of
+      {ok, Reply} ->
+         Reply
+   catch Class:Reason ->
+      erlang:raise(Class, {Reason, {?MODULE, call, [EpmSrv, Cmd, Timeout]}}, ?STACKTRACE())
    end.
 
-send({global, Name}, Cmd) ->
-   catch global:send(Name, Cmd),
-   ok;
-send({via, Mod, Name}, Cmd) ->
-   catch Mod:send(Name, Cmd),
-   ok;
-send(M, Cmd) ->
-   M ! Cmd,
+epmRequest({global, Name}, Msg) ->
+   try global:send(Name, Msg),
+   ok
+   catch _:_ -> ok
+   end;
+epmRequest({via, RegMod, Name}, Msg) ->
+   try RegMod:send(Name, Msg),
+   ok
+   catch _:_ -> ok
+   end;
+epmRequest(EpmSrv, Cmd) ->
+   EpmSrv ! Cmd,
    ok.
 
 loopEntry(Parent, ServerName, MSL, HibernateAfterTimeout, Debug, true) ->
@@ -331,11 +330,8 @@ receiveIng(Parent, ServerName, MSL, HibernateAfterTimeout, Debug, IsHib) ->
          sys:handle_system_msg(Req, From, Parent, ?MODULE, Debug, [ServerName, MSL, HibernateAfterTimeout, IsHib], IsHib);
       {'EXIT', Parent, Reason} ->
          terminate_server(Reason, Parent, MSL, ServerName);
-      Msg when Debug =:= [] ->
-         handle_msg(Msg, Parent, ServerName, MSL, HibernateAfterTimeout, []);
       Msg ->
-         Debug1 = sys:handle_debug(Debug, fun print_event/3, ServerName, {in, Msg}),
-         handle_msg(Msg, Parent, ServerName, MSL, HibernateAfterTimeout, Debug1)
+         handle_msg(Msg, Parent, ServerName, MSL, HibernateAfterTimeout, Debug)
    after HibernateAfterTimeout ->
       proc_lib:hibernate(?MODULE, wakeupFromHib, [Parent, ServerName, MSL, HibernateAfterTimeout, Debug])
    end.
@@ -400,8 +396,8 @@ terminate_server(Reason, Parent, MSL, ServerName) ->
    do_unlink(Parent, MSL),
    exit(Reason).
 
-reply({From, Ref}, Msg) ->
-   From ! {Ref, Msg},
+reply({To, Ref}, Msg) ->
+   To ! {Ref, Msg},
    ok.
 
 %% unlink the supervisor process of all supervised handlers.