No puede seleccionar más de 25 temas
Los temas deben comenzar con una letra o número, pueden incluir guiones ('-') y pueden tener hasta 35 caracteres de largo.
2156 líneas
92 KiB
2156 líneas
92 KiB
-module(gen_ipc).
|
|
|
|
-include_lib("kernel/include/logger.hrl").
|
|
|
|
-export([
|
|
%% API for gen_server or gen_statem behaviour
|
|
start/3, start/4, start_link/3, start_link/4
|
|
, stop/1, stop/3
|
|
, cast/2
|
|
, abcast/2, abcast/3
|
|
, call/2, call/3
|
|
, multi_call/2, multi_call/3, multi_call/4
|
|
, enter_loop/4, enter_loop/5, enter_loop/6
|
|
, reply/1, reply/2
|
|
|
|
%% API for gen_event behaviour
|
|
, infoNotify/2, callNotify/2
|
|
, epmCall/3, epmCall/4, epmInfo/3
|
|
, addEpm/3, addSupEpm/3, whichEpm/1
|
|
, deleteEpm/3, swapEpm/3, swapSupEpm/3
|
|
|
|
%% gen callbacks
|
|
, init_it/6
|
|
|
|
%% sys callbacks
|
|
, system_continue/3
|
|
, system_terminate/4
|
|
, system_code_change/4
|
|
, system_get_state/1
|
|
, system_replace_state/2
|
|
, format_status/2
|
|
|
|
%% Internal callbacks
|
|
, wakeup_from_hibernate/5
|
|
%% logger callback
|
|
, format_log/1
|
|
, epm_log/1
|
|
]).
|
|
|
|
%% 进程字典的宏定义
|
|
-define(PD_PARENT, '$pd_parent').
|
|
-define(PD_PRO_NAME, '$pd_proname').
|
|
-define(PD_EPM_FLAG, '$pd_epmFlag').
|
|
-define(PD_EPM_LIST, '$pd_epmList').
|
|
|
|
%% timeout相关宏定义
|
|
-define(REL_TIMEOUT(T), ((is_integer(T) andalso (T) >= 0) orelse (T) =:= infinity)).
|
|
-define(ABS_TIMEOUT(T), (is_integer(T) orelse (T) =:= infinity)).
|
|
|
|
-define(STACKTRACE(), element(2, erlang:process_info(self(), current_stacktrace))).
|
|
|
|
-define(CB_FORM_ENTER, 1). %% 从enter 回调返回
|
|
-define(CB_FORM_AFTER, 2). %% 从after 回调返回
|
|
-define(CB_FORM_EVENT, 3). %% 从event 回调返回
|
|
|
|
%% debug 调试相关宏定义
|
|
-define(NOT_DEBUG, []).
|
|
-define(SYS_DEBUG(Debug, SystemEvent),
|
|
case Debug of
|
|
?NOT_DEBUG ->
|
|
Debug;
|
|
_ ->
|
|
sys:handle_debug(Debug, fun print_event/3, getProName(), SystemEvent)
|
|
end).
|
|
|
|
%%%==========================================================================
|
|
%%% Interface functions.
|
|
%%%==========================================================================
|
|
%% gen:call 发送消息来源进程格式类型
|
|
-type from() :: {To :: pid(), Tag :: term()}.
|
|
|
|
%% 事件类型
|
|
-type eventType() :: externalEventType() | timeoutEventType() | {'onevent', Subtype :: term()}.
|
|
-type externalEventType() :: {'call', From :: from()} | 'cast' | 'info'.
|
|
-type timeoutEventType() :: 'eTimeout' | 'sTimeout' | {'gTimeout', Name :: term()}.
|
|
|
|
%% 是否改进程捕捉信号 gen_event管理进程需要设置该参数为true
|
|
-type isTrapExit() :: boolean().
|
|
%% 是否允许进入enter 回调
|
|
-type isEnter() :: boolean().
|
|
%% 如果为 "true" 则推迟当前事件，并在状态更改时重试(=/=)
|
|
-type isPostpone() :: boolean().
|
|
%% 如果为 "true" 则使服务器休眠而不是进入接收状态
|
|
-type isHibernate() :: boolean().
|
|
|
|
%% 定时器相关
|
|
-type timeouts() :: Time :: timeout() | integer().
|
|
-type timeoutOption() :: {abs, Abs :: boolean()}.
|
|
|
|
% gen_event模式下回调模块的Key
|
|
-type epmHandler() :: atom() | {atom(), term()}.
|
|
|
|
%% 在状态更改期间:
|
|
%% NextStatus and NewData are set.
|
|
%% 按照出现的顺序处理 actions()列表
|
|
%% 这些action() 按包含列表中的出现顺序执行。设置选项的选项将覆盖任何以前的选项，因此每种类型的最后一种将获胜。
|
|
%% 如果设置了enter 则进入enter回调
|
|
%% 如果设置了doAfter 则进入after回调
|
|
%% 如果 "postpone" 为 "true"，则推迟当前事件。
|
|
%% 如果设置了“超时”，则开始状态超时。 零超时事件将会插入到待处理事件的前面 先执行
|
|
%% 如果有postponed 事件则 事件执行顺序为 超时添加和更新 + 零超时 + 当前事件 + 反序的Postpone事件 + LeftEvent
|
|
%% 处理待处理的事件，或者如果没有待处理的事件，则服务器进入接收或休眠状态（当“hibernate”为“ true”时）
|
|
-type initAction() ::
|
|
{trap_exit, Bool :: isTrapExit()} | % 设置是否捕捉信息 主要用于gen_event模式下
|
|
eventAction().
|
|
|
|
-type eventAction() ::
|
|
{'doAfter', Args :: term()} | % 设置执行某事件后是否回调 handleAfter
|
|
{'isPostpone', Bool :: isPostpone()} | % 设置推迟选项
|
|
{'nextEvent', EventType :: eventType(), EventContent :: term()} | % 插入事件作为下一个处理
|
|
commonAction().
|
|
|
|
-type afterAction() ::
|
|
{'nextEvent', EventType :: eventType(), EventContent :: term()} | % 插入事件作为下一个处理
|
|
commonAction().
|
|
|
|
-type enterAction() ::
|
|
{'isPostpone', false} | % 虽然enter action 不能设置postpone 但是可以取消之前event的设置
|
|
commonAction().
|
|
|
|
-type commonAction() ::
|
|
{'isEnter', Bool :: isEnter()} |
|
|
{'isHibernate', Bool :: isHibernate()} |
|
|
timeoutAction() |
|
|
replyAction().
|
|
|
|
-type timeoutAction() ::
|
|
timeoutNewAction() |
|
|
timeoutCancelAction() |
|
|
timeoutUpdateAction().
|
|
|
|
-type timeoutNewAction() ::
|
|
{'eTimeout', Time :: timeouts(), EventContent :: term()} | % Set the event_timeout option
|
|
{'eTimeout', Time :: timeouts(), EventContent :: term(), Options :: ([timeoutOption()])} | % Set the generic_timeout option
|
|
{{'gTimeout', Name :: term()}, Time :: timeouts(), EventContent :: term()} | % Set the generic_timeout option
|
|
{{'gTimeout', Name :: term()}, Time :: timeouts(), EventContent :: term(), Options :: ([timeoutOption()])} | % Set the status_timeout option
|
|
{'sTimeout', Time :: timeouts(), EventContent :: term()} | % Set the status_timeout option
|
|
{'sTimeout', Time :: timeouts(), EventContent :: term(), Options :: ([timeoutOption()])}.
|
|
|
|
-type timeoutCancelAction() ::
|
|
'c_eTimeout' |
|
|
{'c_gTimeout', Name :: term()} |
|
|
'c_sTimeout'.
|
|
|
|
-type timeoutUpdateAction() ::
|
|
{'u_eTimeout', EventContent :: term()} |
|
|
{{'u_gTimeout', Name :: term()}, EventContent :: term()} |
|
|
{'u_sTimeout', EventContent :: term()}.
|
|
|
|
-type replyAction() ::
|
|
{'reply', From :: from(), Reply :: term()}.
|
|
|
|
-type eventCallbackResult() ::
|
|
{'reply', Reply :: term(), NewState :: term()} | % 用作gen_server模式时快速响应进入消息接收
|
|
{'noreply', NewState :: term()} | % 用作gen_server模式时快速响应进入消息接收
|
|
{'reply', Reply :: term(), NewState :: term(), Options :: hibernate | {doAfter, Args}} | % 用作gen_server模式时快速响应进入消息接收
|
|
{'noreply', NewState :: term(), Options :: hibernate | {doAfter, Args}} | % 用作gen_server模式时快速响应进入循环
|
|
{'nextStatus', NextStatus :: term(), NewState :: term()} | % {next_status,NextStatus,NewData,[]}
|
|
{'nextStatus', NextStatus :: term(), NewState :: term(), Actions :: [eventAction(), ...]} | % Status transition, maybe to the same status
|
|
commonCallbackResult(eventAction()).
|
|
|
|
-type afterCallbackResult() ::
|
|
{'nextStatus', NextStatus :: term(), NewState :: term()} | % {next_status,NextStatus,NewData,[]}
|
|
{'nextStatus', NextStatus :: term(), NewState :: term(), Actions :: [afterAction(), ...]} | % Status transition, maybe to the same status
|
|
{'noreply', NewState :: term()} | % 用作gen_server模式时快速响应进入消息接收
|
|
{'noreply', NewState :: term(), Options :: hibernate} | % 用作gen_server模式时快速响应进入消息接收
|
|
commonCallbackResult(afterAction()).
|
|
|
|
-type enterCallbackResult() ::
|
|
commonCallbackResult(enterAction()).
|
|
|
|
-type commonCallbackResult(ActionType) ::
|
|
{'keepStatus', NewState :: term()} | % {keep_status,NewData,[]}
|
|
{'keepStatus', NewState :: term(), Actions :: [ActionType]} | % Keep status, change data
|
|
'keepStatusState' | % {keep_status_and_data,[]}
|
|
{'keepStatusState', Actions :: [ActionType]} | % Keep status and data -> only actions
|
|
{'repeatStatus', NewState :: term()} | % {repeat_status,NewData,[]}
|
|
{'repeatStatus', NewState :: term(), Actions :: [ActionType]} | % Repeat status, change data
|
|
'repeatStatusState' | % {repeat_status_and_data,[]}
|
|
{'repeatStatusState', Actions :: [ActionType]} | % Repeat status and data -> only actions
|
|
'stop' | % {stop,normal}
|
|
{'stop', Reason :: term()} | % Stop the server
|
|
{'stop', Reason :: term(), NewState :: term()} | % Stop the server
|
|
{'stopReply', Reason :: term(), Replies :: [replyAction(), ...]} | % Reply then stop the server
|
|
{'stopReply', Reason :: term(), Replies :: [replyAction(), ...], NewState :: term()}. % Reply then stop the server
|
|
|
|
%% 状态机的初始化功能函数
|
|
%% 如果要模拟gen_server init返回定时时间 可以在Actions返回定时动作
|
|
%% 如果要把改进程当做gen_event管理进程需要在actions列表包含 {trap_exit, true} 设置该进程捕捉异常
|
|
-callback init(Args :: term()) ->
|
|
'ignore' |
|
|
{'stop', Reason :: term()} |
|
|
{'ok', State :: term()} |
|
|
{'ok', Status :: term(), State :: term()} |
|
|
{'ok', Status :: term(), State :: term(), Actions :: [initAction(), ...]}.
|
|
|
|
%% 当 enter call 回调函数
|
|
-callback handleEnter(OldStatus :: term(), CurStatus :: term(), State :: term()) ->
|
|
enterCallbackResult().
|
|
|
|
%% 当 init返回actions包含 doAfter 的时候会在 enter调用后 调用该函数 或者
|
|
%% 在事件回调函数返回后 enter调用后调用该函数
|
|
%% 该回调函数相当于 gen_server 的 handle_continue回调 但是在综合模式时 也可以生效
|
|
-callback handleAfter(AfterArgs :: term(), Status :: term(), State :: term()) ->
|
|
afterCallbackResult().
|
|
|
|
%% call 所以状态的回调函数
|
|
-callback handleCall(EventContent :: term(), From :: {pid(), Tag :: term()}, Status :: term(), State :: term()) ->
|
|
eventCallbackResult().
|
|
|
|
%% cast 回调函数
|
|
-callback handleCast(EventContent :: term(), Status :: term(), State :: term()) ->
|
|
eventCallbackResult().
|
|
|
|
%% info 回调函数
|
|
-callback handleInfo(EventContent :: term(), Status :: term(), State :: term()) ->
|
|
eventCallbackResult().
|
|
|
|
%% 内部事件 Onevent 包括actions 设置的定时器超时产生的事件 和 nextEvent产生的超时事件 但是不是 call cast info 回调函数 以及其他自定义定时事件 的回调函数
|
|
%% 并且这里需要注意 其他erlang:start_timer生成超时事件发送的消息 不能和gen_ipc定时器关键字重合 有可能会导致一些问题
|
|
-callback handleOnevent(EventType :: term(), EventContent :: term(), Status :: term(), State :: term()) ->
|
|
eventCallbackResult().
|
|
|
|
%% 在gen_event模式下 扩展了下面三个回调函数 考虑场景是：
|
|
%% 比如游戏里的公会 有时候一个公会一个进程来管理可能开销比较高 只用一个进程来管理所以公会有可能一个进程处理不过来
|
|
%% 这个时候可以考虑用gen_ipc来分组管理 一个gen_ipc进程管理 N 个公会 但是管理进程需要做一些数据保存什么 或者定时 就可能会用到下面的这些函数
|
|
%% gen_event模式时 notify 有可能需要回调该管理进程的该函数
|
|
-callback handleEpmEvent(EventContent :: term(), Status :: term(), State :: term()) ->
|
|
eventCallbackResult().
|
|
|
|
%% gen_event模式时 call请求 有可能需要回调该管理进程的该函数
|
|
-callback handleEpmCall(EventContent :: term(), Status :: term(), State :: term()) ->
|
|
eventCallbackResult().
|
|
|
|
%% gen_event模式时 info消息 有可能需要回调该管理进程的该函数
|
|
-callback handleEpmInfo(EventContent :: term(), Status :: term(), State :: term()) ->
|
|
eventCallbackResult().
|
|
|
|
%% 在服务器终止之前进行清理。
|
|
-callback terminate(Reason :: 'normal' | 'shutdown' | {'shutdown', term()} | term(), Status :: term(), State :: term()) ->
|
|
any().
|
|
|
|
%% 代码更新回调函数
|
|
-callback code_change(OldVsn :: term() | {'down', term()}, OldStatus :: term(), OldState :: term(), Extra :: term()) ->
|
|
{ok, NewStatus :: term(), NewData :: term()} |
|
|
(Reason :: term()).
|
|
|
|
%% 以一种通常被精简的方式来格式化回调模块状态。
|
|
%% 对于StatusOption =:= 'normal'，首选返回 term 是[{data,[{"Status",FormattedStatus}]}]
|
|
%% 对于StatusOption =:= 'terminate'，它只是FormattedStatus
|
|
-callback formatStatus(StatusOption, [PDict | term()]) ->
|
|
Status :: term() when
|
|
StatusOption :: 'normal' | 'terminate',
|
|
PDict :: [{Key :: term(), Value :: term()}].
|
|
|
|
-optional_callbacks([
|
|
formatStatus/2
|
|
, terminate/3
|
|
, code_change/4
|
|
, handleEnter/3
|
|
, handleAfter/3
|
|
, handleOnevent/4
|
|
, handleEpmEvent/3
|
|
, handleEpmCall/3
|
|
, handleEpmInfo/3
|
|
]).
|
|
|
|
-record(cycleData, {
|
|
module :: atom()
|
|
, isEnter = false :: boolean()
|
|
, hibernateAfter = infinity :: timeout()
|
|
, postponed = [] :: [{eventType(), term()}]
|
|
, timers = #{} :: #{TimeoutType :: timeoutEventType() => {TimerRef :: reference(), TimeoutMsg :: term()}}
|
|
}).
|
|
|
|
-record(epmHer, {
|
|
epmM :: atom(),
|
|
epmId = false,
|
|
epmS :: term(),
|
|
epmSup = false :: 'false' | pid()}).
|
|
|
|
-compile({inline, [isEventType/1]}).
|
|
|
|
isEventType(Type) ->
|
|
case Type of
|
|
{'call', {_Pid, _Ref}} -> true;
|
|
'cast' -> true;
|
|
'info' -> true;
|
|
{'onevent', _SubType} -> true;
|
|
'eTimeout' -> true;
|
|
'sTimeout' -> true;
|
|
{'gTimeout', _Name} -> true;
|
|
_ ->
|
|
false
|
|
end.
|
|
|
|
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% start stop API start %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
|
|
-type serverName() ::
|
|
{'local', atom()} |
|
|
{'global', GlobalName :: term()} |
|
|
{'via', RegMod :: module(), Name :: term()}.
|
|
|
|
-type serverRef() ::
|
|
pid() |
|
|
(LocalName :: atom()) |
|
|
{Name :: atom(), Node :: atom()} |
|
|
{'global', GlobalName :: term()} |
|
|
{'via', RegMod :: module(), ViaName :: term()}.
|
|
|
|
-type startOpt() ::
|
|
{'timeout', Time :: timeout()} |
|
|
{'spawn_opt', [proc_lib:spawn_option()]} |
|
|
enterLoopOpt().
|
|
|
|
-type enterLoopOpt() ::
|
|
{'debug', Debugs :: [sys:debug_option()]} |
|
|
{'hibernate_after', HibernateAfterTimeout :: timeout()}.
|
|
|
|
-type startRet() ::
|
|
'ignore' |
|
|
{'ok', pid()} |
|
|
{'error', term()}.
|
|
|
|
-spec start(Module :: module(), Args :: term(), Opts :: [startOpt()]) -> startRet().
|
|
start(Module, Args, Opts) ->
|
|
gen:start(?MODULE, nolink, Module, Args, Opts).
|
|
|
|
-spec start(ServerName :: serverName(), Module :: module(), Args :: term(), Opts :: [startOpt()]) -> startRet().
|
|
start(ServerName, Module, Args, Opts) ->
|
|
gen:start(?MODULE, nolink, ServerName, Module, Args, Opts).
|
|
|
|
-spec start_link(Module :: module(), Args :: term(), Opts :: [startOpt()]) -> startRet().
|
|
start_link(Module, Args, Opts) ->
|
|
gen:start(?MODULE, link, Module, Args, Opts).
|
|
|
|
-spec start_link(ServerName :: serverName(), Module :: module(), Args :: term(), Opts :: [startOpt()]) -> startRet().
|
|
start_link(ServerName, Module, Args, Opts) ->
|
|
gen:start(?MODULE, link, ServerName, Module, Args, Opts).
|
|
|
|
|
|
-spec stop(ServerRef :: serverRef()) -> ok.
|
|
stop(ServerRef) ->
|
|
gen:stop(ServerRef).
|
|
|
|
-spec stop(ServerRef :: serverRef(), Reason :: term(), Timeout :: timeout()) -> ok.
|
|
stop(ServerRef, Reason, Timeout) ->
|
|
gen:stop(ServerRef, Reason, Timeout).
|
|
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% start stop API end %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
|
|
|
|
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% gen callbacks start %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
|
|
doModuleInit(Module, Args) ->
|
|
try
|
|
Module:init(Args)
|
|
catch
|
|
throw:Ret -> Ret;
|
|
Class:Reason:Stacktrace -> {'EXIT', Class, Reason, Stacktrace}
|
|
end.
|
|
|
|
init_it(Starter, self, ServerRef, Module, Args, Opts) ->
|
|
init_it(Starter, self(), ServerRef, Module, Args, Opts);
|
|
init_it(Starter, Parent, ServerRef, Module, Args, Opts) ->
|
|
Name = gen:name(ServerRef),
|
|
Debug = gen:debug_options(Name, Opts),
|
|
HibernateAfterTimeout = gen:hibernate_after(Opts),
|
|
case doModuleInit(Module, Args) of
|
|
{ok, State} ->
|
|
proc_lib:init_ack(Starter, {ok, self()}),
|
|
loopEntry(Parent, Debug, Module, Name, HibernateAfterTimeout, undefined, State, []);
|
|
{ok, Status, State} ->
|
|
proc_lib:init_ack(Starter, {ok, self()}),
|
|
loopEntry(Parent, Debug, Module, Name, HibernateAfterTimeout, Status, State, []);
|
|
{ok, Status, State, Actions} ->
|
|
proc_lib:init_ack(Starter, {ok, self()}),
|
|
loopEntry(Parent, Debug, Module, Name, HibernateAfterTimeout, Status, State, Actions);
|
|
{stop, Reason} ->
|
|
gen:unregister_name(ServerRef),
|
|
proc_lib:init_ack(Starter, {error, Reason}),
|
|
exit(Reason);
|
|
ignore ->
|
|
gen:unregister_name(ServerRef),
|
|
proc_lib:init_ack(Starter, ignore),
|
|
exit(normal);
|
|
{'EXIT', Class, Reason, Stacktrace} ->
|
|
gen:unregister_name(ServerRef),
|
|
proc_lib:init_ack(Starter, {error, Reason}),
|
|
error_info(Class, Reason, Stacktrace, #cycleData{module = Module}, 'Sun_init', '$un_init', Debug, []),
|
|
erlang:raise(Class, Reason, Stacktrace);
|
|
_Ret ->
|
|
gen:unregister_name(ServerRef),
|
|
Error = {badReturnFrom_doModuleInit, _Ret},
|
|
proc_lib:init_ack(Starter, {error, Error}),
|
|
error_info(error, Error, ?STACKTRACE(), #cycleData{module = Module}, '$un_init', '$un_init', Debug, []),
|
|
exit(Error)
|
|
end.
|
|
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% gen callbacks end %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
|
|
%% 进入循环 调用该进程必须使用proc_lib启动 且已经初始化状态和数据 包括注册名称
|
|
-spec enter_loop(Module :: module(), Status :: term(), State :: term(), Opts :: [enterLoopOpt()]) -> no_return().
|
|
enter_loop(Module, Status, State, Opts) ->
|
|
enter_loop(Module, Status, State, Opts, self(), []).
|
|
|
|
-spec enter_loop(Module :: module(), Status :: term(), State :: term(), Opts :: [enterLoopOpt()], ServerOrActions :: serverName() | pid() | [eventAction()]) -> no_return().
|
|
enter_loop(Module, Status, State, Opts, ServerOrActions) ->
|
|
if
|
|
is_list(ServerOrActions) ->
|
|
enter_loop(Module, Opts, Status, State, self(), ServerOrActions);
|
|
true ->
|
|
enter_loop(Module, Opts, Status, State, ServerOrActions, [])
|
|
end.
|
|
|
|
-spec enter_loop(Module :: module(), Status :: term(), State :: term(), Opts :: [enterLoopOpt()], Server :: serverName() | pid(), Actions :: [eventAction()]) -> no_return().
|
|
enter_loop(Module, Status, State, Opts, ServerName, Actions) ->
|
|
is_atom(Module) orelse error({atom, Module}),
|
|
Parent = gen:get_parent(),
|
|
Name = gen:get_proc_name(ServerName),
|
|
Debug = gen:debug_options(Name, Opts),
|
|
HibernateAfterTimeout = gen:hibernate_after(Opts),
|
|
loopEntry(Parent, Debug, Module, Name, HibernateAfterTimeout, Status, State, Actions).
|
|
|
|
%% 这里的 init_it/6 和 enter_loop/5,6,7 函数汇聚
|
|
loopEntry(Parent, Debug, Module, Name, HibernateAfterTimeout, CurStatus, CurState, Actions) ->
|
|
setParent(Parent),
|
|
setProName(Name),
|
|
%% 如果该进程用于 gen_event 则需要设置 process_flag(trap_exit, true) 需要在Actions返回 {trap_exit, true}
|
|
MewActions =
|
|
case lists:keyfind(trap_exit, 1, Actions) of
|
|
false ->
|
|
Actions;
|
|
{trap_exit, true} ->
|
|
process_flag(trap_exit, true),
|
|
lists:keydelete(trap_exit, 1, Actions);
|
|
_ ->
|
|
lists:keydelete(trap_exit, 1, Actions)
|
|
end,
|
|
|
|
CycleData = #cycleData{module = Module, hibernateAfter = HibernateAfterTimeout},
|
|
NewDebug = ?SYS_DEBUG(Debug, {enter, CurStatus}),
|
|
%% 强制执行{postpone，false}以确保我们的假事件被丢弃
|
|
LastActions = MewActions ++ [{isPostpone, false}],
|
|
parseEventActionsList(CycleData, CurStatus, CurState, CurStatus, NewDebug, [{onevent, init_status}], true, LastActions, ?CB_FORM_EVENT).
|
|
|
|
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% sys callbacks start %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
|
|
system_continue(Parent, Debug, {CycleData, CurStatus, CurState, IsHibernate}) ->
|
|
updateParent(Parent),
|
|
if
|
|
IsHibernate ->
|
|
proc_lib:hibernate(?MODULE, wakeup_from_hibernate, [CycleData, CurStatus, CurState, Debug, IsHibernate]);
|
|
true ->
|
|
receiveMsgWait(CycleData, CurStatus, CurState, Debug, IsHibernate)
|
|
end.
|
|
|
|
system_terminate(Reason, Parent, Debug, {CycleData, CurStatus, CurState, _IsHibernate}) ->
|
|
updateParent(Parent),
|
|
terminate(exit, Reason, ?STACKTRACE(), CycleData, CurStatus, CurState, Debug, []).
|
|
|
|
system_code_change({#cycleData{module = Module} = CycleData, CurStatus, CurState, IsHibernate}, _Mod, OldVsn, Extra) ->
|
|
case
|
|
try Module:code_change(OldVsn, CurStatus, CurState, Extra)
|
|
catch
|
|
throw:Result -> Result
|
|
end
|
|
of
|
|
{ok, NewStatus, NewState} ->
|
|
{ok, {CycleData, NewStatus, NewState, IsHibernate}};
|
|
Error ->
|
|
Error
|
|
end.
|
|
|
|
system_get_state({_CycleData, CurStatus, CurState, _IsHibernate}) ->
|
|
{ok, {CurStatus, CurState}}.
|
|
|
|
system_replace_state(StatusFun, {CycleData, CurStatus, CurState, IsHibernate}) ->
|
|
{NewStatus, NewState} = StatusFun(CurStatus, CurState),
|
|
{ok, {NewStatus, NewState}, {CycleData, NewStatus, NewState, IsHibernate}}.
|
|
|
|
format_status(Opt, [PDict, SysStatus, Parent, Debug, {#cycleData{timers = Timers, postponed = Postponed} = CycleData, CurStatus, CurState, _IsHibernate}]) ->
|
|
Header = gen:format_status_header("Status for status machine", getProName()),
|
|
updateParent(Parent),
|
|
Log = sys:get_log(Debug),
|
|
[
|
|
{header, Header},
|
|
{data,
|
|
[
|
|
{"Status", SysStatus},
|
|
{"Parent", Parent},
|
|
{"Time-outs", list_timeouts(Timers)},
|
|
{"Logged Events", Log},
|
|
{"Postponed", Postponed}
|
|
]
|
|
} |
|
|
case format_status(Opt, PDict, CycleData, CurStatus, CurState) of
|
|
L when is_list(L) -> L;
|
|
T -> [T]
|
|
end
|
|
].
|
|
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% sys callbacks end %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
|
|
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% API helpers start %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
|
|
-spec call(ServerRef :: serverRef(), Request :: term()) -> Reply :: term().
|
|
call(ServerRef, Request) ->
|
|
try gen:call(ServerRef, '$gen_call', Request) of
|
|
{ok, Reply} ->
|
|
Reply
|
|
catch
|
|
Class:Reason:Stacktrace ->
|
|
erlang:raise(Class, {Reason, {?MODULE, call, [ServerRef, Request]}}, Stacktrace)
|
|
end.
|
|
|
|
-spec call(ServerRef :: serverRef(), Request :: term(), Timeout :: timeout() |{'cleanTimeout', T :: timeout()} | {'dirtyTimeout', T :: timeout()}) -> Reply :: term().
|
|
call(ServerRef, Request, infinity) ->
|
|
try gen:call(ServerRef, '$gen_call', Request, infinity) of
|
|
{ok, Reply} ->
|
|
Reply
|
|
catch
|
|
Class:Reason:Stacktrace ->
|
|
erlang:raise(Class, {Reason, {?MODULE, call, [ServerRef, Request, infinity]}}, Stacktrace)
|
|
end;
|
|
call(ServerRef, Request, {dirtyTimeout, T} = Timeout) ->
|
|
try gen:call(ServerRef, '$gen_call', Request, T) of
|
|
{ok, Reply} ->
|
|
Reply
|
|
catch
|
|
Class:Reason:Stacktrace ->
|
|
erlang:raise(Class, {Reason, {?MODULE, call, [ServerRef, Request, Timeout]}}, Stacktrace)
|
|
end;
|
|
call(ServerRef, Request, {cleanTimeout, T} = Timeout) ->
|
|
callClean(ServerRef, Request, Timeout, T);
|
|
call(ServerRef, Request, {_, _} = Timeout) ->
|
|
erlang:error(badarg, [ServerRef, Request, Timeout]);
|
|
call(ServerRef, Request, Timeout) ->
|
|
callClean(ServerRef, Request, Timeout, Timeout).
|
|
|
|
callClean(ServerRef, Request, Timeout, T) ->
|
|
%% 通过代理过程呼叫服务器以躲避任何较晚的答复
|
|
Ref = make_ref(),
|
|
Self = self(),
|
|
Pid = spawn(
|
|
fun() ->
|
|
Self !
|
|
try gen:call(ServerRef, '$gen_call', Request, T) of
|
|
Result ->
|
|
{Ref, Result}
|
|
catch Class:Reason:Stacktrace ->
|
|
{Ref, Class, Reason, Stacktrace}
|
|
end
|
|
end),
|
|
Mref = monitor(process, Pid),
|
|
receive
|
|
{Ref, Result} ->
|
|
demonitor(Mref, [flush]),
|
|
case Result of
|
|
{ok, Reply} ->
|
|
Reply
|
|
end;
|
|
{Ref, Class, Reason, Stacktrace} ->
|
|
demonitor(Mref, [flush]),
|
|
erlang:raise(Class, {Reason, {?MODULE, call, [ServerRef, Request, Timeout]}}, Stacktrace);
|
|
{'DOWN', Mref, _, _, Reason} ->
|
|
%% 从理论上讲，有可能在try-of和！之间杀死代理进程。因此，在这种情况下
|
|
exit(Reason)
|
|
end.
|
|
|
|
multi_call(Name, Request) when is_atom(Name) ->
|
|
do_multi_call([node() | nodes()], Name, Request, infinity).
|
|
|
|
multi_call(Nodes, Name, Request) when is_list(Nodes), is_atom(Name) ->
|
|
do_multi_call(Nodes, Name, Request, infinity).
|
|
|
|
multi_call(Nodes, Name, Request, infinity) ->
|
|
do_multi_call(Nodes, Name, Request, infinity);
|
|
multi_call(Nodes, Name, Request, Timeout) when is_list(Nodes), is_atom(Name), is_integer(Timeout), Timeout >= 0 ->
|
|
do_multi_call(Nodes, Name, Request, Timeout).
|
|
|
|
do_multi_call(Nodes, Name, Request, infinity) ->
|
|
Tag = make_ref(),
|
|
Monitors = send_nodes(Nodes, Name, Tag, Request, []),
|
|
rec_nodes(Tag, Monitors, Name, undefined);
|
|
do_multi_call(Nodes, Name, Request, Timeout) ->
|
|
Tag = make_ref(),
|
|
Caller = self(),
|
|
Receiver = spawn(
|
|
fun() ->
|
|
process_flag(trap_exit, true),
|
|
Mref = erlang:monitor(process, Caller),
|
|
receive
|
|
{Caller, Tag} ->
|
|
Monitors = send_nodes(Nodes, Name, Tag, Request, []),
|
|
TimerId = erlang:start_timer(Timeout, self(), ok),
|
|
Result = rec_nodes(Tag, Monitors, Name, TimerId),
|
|
exit({self(), Tag, Result});
|
|
{'DOWN', Mref, _, _, _} ->
|
|
exit(normal)
|
|
end
|
|
end
|
|
),
|
|
Mref = erlang:monitor(process, Receiver),
|
|
Receiver ! {self(), Tag},
|
|
receive
|
|
{'DOWN', Mref, _, _, {Receiver, Tag, Result}} ->
|
|
Result;
|
|
{'DOWN', Mref, _, _, Reason} ->
|
|
exit(Reason)
|
|
end.
|
|
|
|
send_nodes([Node | Tail], Name, Tag, Request, Monitors) when is_atom(Node) ->
|
|
Monitor = start_monitor(Node, Name),
|
|
catch {Name, Node} ! {'$gen_call', {self(), {Tag, Node}}, Request},
|
|
send_nodes(Tail, Name, Tag, Request, [Monitor | Monitors]);
|
|
send_nodes([_Node | Tail], Name, Tag, Request, Monitors) ->
|
|
send_nodes(Tail, Name, Tag, Request, Monitors);
|
|
send_nodes([], _Name, _Tag, _Req, Monitors) ->
|
|
Monitors.
|
|
|
|
rec_nodes(Tag, Nodes, Name, TimerId) ->
|
|
rec_nodes(Tag, Nodes, Name, [], [], 2000, TimerId).
|
|
|
|
rec_nodes(Tag, [{N, R} | Tail], Name, BadNodes, Replies, Time, TimerId) ->
|
|
receive
|
|
{'DOWN', R, _, _, _} ->
|
|
rec_nodes(Tag, Tail, Name, [N | BadNodes], Replies, Time, TimerId);
|
|
{{Tag, N}, Reply} ->
|
|
erlang:demonitor(R, [flush]),
|
|
rec_nodes(Tag, Tail, Name, BadNodes,
|
|
[{N, Reply} | Replies], Time, TimerId);
|
|
{timeout, TimerId, _} ->
|
|
erlang:demonitor(R, [flush]),
|
|
rec_nodes_rest(Tag, Tail, Name, [N | BadNodes], Replies)
|
|
end;
|
|
rec_nodes(Tag, [N | Tail], Name, BadNodes, Replies, Time, TimerId) ->
|
|
receive
|
|
{nodedown, N} ->
|
|
monitor_node(N, false),
|
|
rec_nodes(Tag, Tail, Name, [N | BadNodes], Replies, 2000, TimerId);
|
|
{{Tag, N}, Reply} ->
|
|
receive {nodedown, N} -> ok after 0 -> ok end,
|
|
monitor_node(N, false),
|
|
rec_nodes(Tag, Tail, Name, BadNodes,
|
|
[{N, Reply} | Replies], 2000, TimerId);
|
|
{timeout, TimerId, _} ->
|
|
receive {nodedown, N} -> ok after 0 -> ok end,
|
|
monitor_node(N, false),
|
|
rec_nodes_rest(Tag, Tail, Name, [N | BadNodes], Replies)
|
|
after Time ->
|
|
case rpc:call(N, erlang, whereis, [Name]) of
|
|
Pid when is_pid(Pid) ->
|
|
rec_nodes(Tag, [N | Tail], Name, BadNodes,
|
|
Replies, infinity, TimerId);
|
|
_ ->
|
|
receive {nodedown, N} -> ok after 0 -> ok end,
|
|
monitor_node(N, false),
|
|
rec_nodes(Tag, Tail, Name, [N | BadNodes],
|
|
Replies, 2000, TimerId)
|
|
end
|
|
end;
|
|
rec_nodes(_, [], _, BadNodes, Replies, _, TimerId) ->
|
|
case catch erlang:cancel_timer(TimerId) of
|
|
false ->
|
|
receive
|
|
{timeout, TimerId, _} -> ok
|
|
after 0 ->
|
|
ok
|
|
end;
|
|
_ ->
|
|
ok
|
|
end,
|
|
{Replies, BadNodes}.
|
|
|
|
rec_nodes_rest(Tag, [{N, R} | Tail], Name, BadNodes, Replies) ->
|
|
receive
|
|
{'DOWN', R, _, _, _} ->
|
|
rec_nodes_rest(Tag, Tail, Name, [N | BadNodes], Replies);
|
|
{{Tag, N}, Reply} ->
|
|
erlang:demonitor(R, [flush]),
|
|
rec_nodes_rest(Tag, Tail, Name, BadNodes, [{N, Reply} | Replies])
|
|
after 0 ->
|
|
erlang:demonitor(R, [flush]),
|
|
rec_nodes_rest(Tag, Tail, Name, [N | BadNodes], Replies)
|
|
end;
|
|
rec_nodes_rest(Tag, [N | Tail], Name, BadNodes, Replies) ->
|
|
receive
|
|
{nodedown, N} ->
|
|
monitor_node(N, false),
|
|
rec_nodes_rest(Tag, Tail, Name, [N | BadNodes], Replies);
|
|
{{Tag, N}, Reply} ->
|
|
receive {nodedown, N} -> ok after 0 -> ok end,
|
|
monitor_node(N, false),
|
|
rec_nodes_rest(Tag, Tail, Name, BadNodes, [{N, Reply} | Replies])
|
|
after 0 ->
|
|
receive {nodedown, N} -> ok after 0 -> ok end,
|
|
monitor_node(N, false),
|
|
rec_nodes_rest(Tag, Tail, Name, [N | BadNodes], Replies)
|
|
end;
|
|
rec_nodes_rest(_Tag, [], _Name, BadNodes, Replies) ->
|
|
{Replies, BadNodes}.
|
|
|
|
start_monitor(Node, Name) when is_atom(Node), is_atom(Name) ->
|
|
if node() =:= nonode@nohost, Node =/= nonode@nohost ->
|
|
Ref = make_ref(),
|
|
self() ! {'DOWN', Ref, process, {Name, Node}, noconnection},
|
|
{Node, Ref};
|
|
true ->
|
|
case catch erlang:monitor(process, {Name, Node}) of
|
|
{'EXIT', _} ->
|
|
monitor_node(Node, true),
|
|
Node;
|
|
Ref when is_reference(Ref) ->
|
|
{Node, Ref}
|
|
end
|
|
end.
|
|
|
|
-spec cast(ServerRef :: serverRef(), Msg :: term()) -> ok.
|
|
cast({global, Name}, Msg) ->
|
|
try global:send(Name, {'$gen_cast', Msg}) of
|
|
_ -> ok
|
|
catch
|
|
_:_ -> ok
|
|
end;
|
|
cast({via, RegMod, Name}, Msg) ->
|
|
try RegMod:send(Name, {'$gen_cast', Msg}) of
|
|
_ -> ok
|
|
catch
|
|
_:_ -> ok
|
|
end;
|
|
cast({Name, Node} = Dest, Msg) when is_atom(Name), is_atom(Node) ->
|
|
try erlang:send(Dest, {'$gen_cast', Msg})
|
|
catch
|
|
error:_ -> ok
|
|
end;
|
|
cast(Dest, Msg) ->
|
|
try erlang:send(Dest, {'$gen_cast', Msg})
|
|
catch
|
|
error:_ -> ok
|
|
end.
|
|
|
|
%% 异步广播，不返回任何内容，只是发送“ n”祈祷
|
|
abcast(Name, Msg) when is_atom(Name) ->
|
|
doAbcast([node() | nodes()], Name, Msg).
|
|
|
|
abcast(Nodes, Name, Msg) when is_list(Nodes), is_atom(Name) ->
|
|
doAbcast(Nodes, Name, Msg).
|
|
|
|
doAbcast([Node | Nodes], Name, Msg) when is_atom(Node) ->
|
|
try erlang:send({Name, Node}, {'$gen_cast', Msg})
|
|
catch
|
|
error:_ -> ok
|
|
end,
|
|
doAbcast(Nodes, Name, Msg);
|
|
doAbcast([], _, _) -> abcast.
|
|
|
|
%% Reply from a status machine callback to whom awaits in call/2
|
|
-spec reply([replyAction()] | replyAction()) -> ok.
|
|
reply({reply, From, Reply}) ->
|
|
reply(From, Reply);
|
|
reply(Replies) when is_list(Replies) ->
|
|
replies(Replies).
|
|
|
|
replies([{reply, From, Reply} | Replies]) ->
|
|
reply(From, Reply),
|
|
replies(Replies);
|
|
replies([]) ->
|
|
ok.
|
|
|
|
-compile({inline, [reply/2]}).
|
|
-spec reply(From :: from(), Reply :: term()) -> ok.
|
|
reply({To, Tag}, Reply) ->
|
|
Msg = {Tag, Reply},
|
|
try To ! Msg of
|
|
_ ->
|
|
ok
|
|
catch
|
|
_:_ -> ok
|
|
end.
|
|
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% API helpers end %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
|
|
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% gen_event start %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
|
|
epmRequest({global, Name}, Msg) ->
|
|
try global:send(Name, Msg) of
|
|
_ -> ok
|
|
catch
|
|
_:_ -> ok
|
|
end;
|
|
epmRequest({via, RegMod, Name}, Msg) ->
|
|
try RegMod:send(Name, Msg) of
|
|
_ -> ok
|
|
catch
|
|
_:_ -> ok
|
|
end;
|
|
epmRequest(EpmSrv, Cmd) ->
|
|
EpmSrv ! Cmd,
|
|
ok.
|
|
|
|
-spec epmInfo(serverRef(), epmHandler(), term()) -> term().
|
|
epmInfo(EpmSrv, EpmHandler, Msg) ->
|
|
epmRequest(EpmSrv, {'$epm_info', EpmHandler, Msg}).
|
|
|
|
-spec infoNotify(serverRef(), term()) -> 'ok'.
|
|
infoNotify(EpmSrv, Event) ->
|
|
epmRequest(EpmSrv, {'$epm_info', '$infoNotify', Event}).
|
|
|
|
epmRpc(EpmSrv, Cmd) ->
|
|
try gen:call(EpmSrv, '$epm_call', Cmd, infinity) of
|
|
{ok, Reply} ->
|
|
Reply
|
|
catch
|
|
Class:Reason:Stacktrace ->
|
|
erlang:raise(Class, {Reason, {?MODULE, call, [EpmSrv, Cmd, infinity]}}, Stacktrace)
|
|
end.
|
|
|
|
epmRpc(EpmSrv, Cmd, Timeout) ->
|
|
try gen:call(EpmSrv, '$epm_call', Cmd, Timeout) of
|
|
{ok, Reply} ->
|
|
Reply
|
|
catch
|
|
Class:Reason:Stacktrace ->
|
|
erlang:raise(Class, {Reason, {?MODULE, call, [EpmSrv, Cmd, Timeout]}}, Stacktrace)
|
|
end.
|
|
|
|
-spec callNotify(serverRef(), term()) -> 'ok'.
|
|
callNotify(EpmSrv, Event) ->
|
|
epmRpc(EpmSrv, {'$syncNotify', Event}).
|
|
|
|
-spec epmCall(serverRef(), epmHandler(), term()) -> term().
|
|
epmCall(EpmSrv, EpmHandler, Query) ->
|
|
epmRpc(EpmSrv, {'$epmCall', EpmHandler, Query}).
|
|
|
|
-spec epmCall(serverRef(), epmHandler(), term(), timeout()) -> term().
|
|
epmCall(EpmSrv, EpmHandler, Query, Timeout) ->
|
|
epmRpc(EpmSrv, {'$epmCall', EpmHandler, Query}, Timeout).
|
|
|
|
-spec addEpm(serverRef(), epmHandler(), term()) -> term().
|
|
addEpm(EpmSrv, EpmHandler, Args) ->
|
|
epmRpc(EpmSrv, {'$addEpm', EpmHandler, Args}).
|
|
|
|
-spec addSupEpm(serverRef(), epmHandler(), term()) -> term().
|
|
addSupEpm(EpmSrv, EpmHandler, Args) ->
|
|
epmRpc(EpmSrv, {'$addSupEpm', EpmHandler, Args}).
|
|
|
|
-spec deleteEpm(serverRef(), epmHandler(), term()) -> term().
|
|
deleteEpm(EpmSrv, EpmHandler, Args) ->
|
|
epmRpc(EpmSrv, {'$deleteEpm', EpmHandler, Args}).
|
|
|
|
-spec swapEpm(serverRef(), {epmHandler(), term()}, {epmHandler(), term()}) -> 'ok' | {'error', term()}.
|
|
swapEpm(EpmSrv, {H1, A1}, {H2, A2}) ->
|
|
epmRpc(EpmSrv, {'$swapEpm', H1, A1, H2, A2}).
|
|
|
|
-spec swapSupEpm(serverRef(), {epmHandler(), term()}, {epmHandler(), term()}) -> 'ok' | {'error', term()}.
|
|
swapSupEpm(EpmSrv, {H1, A1}, {H2, A2}) ->
|
|
epmRpc(EpmSrv, {'$swapSupEpm', H1, A1, H2, A2, self()}).
|
|
|
|
-spec whichEpm(serverRef()) -> [epmHandler()].
|
|
whichEpm(EpmSrv) ->
|
|
epmRpc(EpmSrv, '$which_handlers').
|
|
|
|
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
|
|
%% EPM inner fun
|
|
addNewEpm(InitRet, Module, EpmId, EpmSup) ->
|
|
case InitRet of
|
|
{ok, State} ->
|
|
EpmHer = #epmHer{epmM = Module, epmId = EpmId, epmS = State},
|
|
OldList = getEpmList(),
|
|
setEpmHer(EpmHer),
|
|
setEpmList([{EpmId, Module, EpmSup} | OldList]),
|
|
{ok, false};
|
|
{ok, State, hibernate} ->
|
|
EpmHer = #epmHer{epmM = Module, epmId = EpmId, epmS = State},
|
|
OldList = getEpmList(),
|
|
setEpmHer(EpmHer),
|
|
setEpmList([{EpmId, Module, EpmSup} | OldList]),
|
|
{ok, true};
|
|
Other ->
|
|
{Other, false}
|
|
end.
|
|
|
|
doAddEpm({Module, EpmId}, Args, EpmSup) ->
|
|
case getEpmHer(EpmId) of
|
|
undefined ->
|
|
try Module:init(Args) of
|
|
Result ->
|
|
addNewEpm(Result, Module, EpmId, EpmSup)
|
|
catch
|
|
throw:Ret ->
|
|
addNewEpm(Ret, Module, EpmId, EpmSup);
|
|
C:R:T ->
|
|
{{C, R, T}, false}
|
|
end;
|
|
_ ->
|
|
{existed, false}
|
|
end;
|
|
doAddEpm(Module, Args, EpmSup) ->
|
|
case getEpmHer(Module) of
|
|
undefined ->
|
|
try Module:init(Args) of
|
|
Result ->
|
|
addNewEpm(Result, Module, Module, EpmSup)
|
|
catch
|
|
throw:Ret ->
|
|
addNewEpm(Ret, Module, Module, EpmSup);
|
|
C:R:T ->
|
|
{{C, R, T}, false}
|
|
end;
|
|
_ ->
|
|
{existed, false}
|
|
end.
|
|
|
|
doAddSupEpm(Module, Args, EpmSup) ->
|
|
case doAddEpm(Module, Args, EpmSup) of
|
|
{ok, _} = Result ->
|
|
link(EpmSup),
|
|
Result;
|
|
Ret ->
|
|
Ret
|
|
end.
|
|
|
|
doSwapEpm(EpmId1, Args1, EpmMId, Args2) ->
|
|
case getEpmHer(EpmId1) of
|
|
undefined ->
|
|
doAddEpm(EpmMId, {Args2, undefined}, false);
|
|
#epmHer{epmSup = EpmSup} = EpmHer ->
|
|
State2 = epmTerminate(EpmHer, Args1, swapped, {swapped, EpmMId, EpmSup}),
|
|
case EpmSup of
|
|
false ->
|
|
doAddEpm(EpmMId, {Args2, State2}, false);
|
|
_ ->
|
|
doAddSupEpm(EpmMId, {Args2, State2}, EpmSup)
|
|
end
|
|
end.
|
|
|
|
doSwapSupEpm(EpmId1, Args1, EpmMId, Args2, EpmSup) ->
|
|
case getEpmHer(EpmId1) of
|
|
undefined ->
|
|
doAddSupEpm(EpmMId, {Args2, undefined}, EpmSup);
|
|
EpmHer ->
|
|
State2 = epmTerminate(EpmHer, Args1, swapped, {swapped, EpmMId, EpmSup}),
|
|
doAddSupEpm(EpmMId, {Args2, State2}, EpmSup)
|
|
end.
|
|
|
|
doNotify([{EpmId, _EmpM} | T], Event, Func, IsHib) ->
|
|
case doEpmHandle(getEpmHer(EpmId), Func, Event, false) of
|
|
ok ->
|
|
doNotify(T, Event, Func, IsHib);
|
|
hibernate ->
|
|
doNotify(T, Event, Func, true);
|
|
_Other ->
|
|
doNotify(T, Event, Func, IsHib)
|
|
end;
|
|
doNotify([], _Event, _Func, IsHib) ->
|
|
IsHib.
|
|
|
|
doEpmHandle(#epmHer{epmM = EpmM, epmS = EpmS} = EpmHer, Func, Event, From) ->
|
|
try EpmM:Func(Event, EpmS) of
|
|
Result ->
|
|
handleEpmCallbackRet(Result, EpmHer, Event, From)
|
|
catch
|
|
throw:Ret ->
|
|
handleEpmCallbackRet(Ret, EpmHer, Event, From);
|
|
C:R:S ->
|
|
epmTerminate(EpmHer, {error, {C, R, S}}, Event, crash)
|
|
end;
|
|
doEpmHandle(undefined, _Func, _Event, _From) ->
|
|
no_epm.
|
|
|
|
doDeleteEpm(EpmId, Args) ->
|
|
case getEpmHer(EpmId) of
|
|
undefined ->
|
|
{error, module_not_found};
|
|
EpmHer ->
|
|
epmTerminate(EpmHer, Args, delete, normal)
|
|
end.
|
|
|
|
proTerminate(#epmHer{epmM = EpmM, epmS = State} = EpmHer, Args, LastIn, Reason) ->
|
|
case erlang:function_exported(EpmM, terminate, 2) of
|
|
true ->
|
|
Res = (catch EpmM:terminate(Args, State)),
|
|
reportTerminate(EpmHer, Reason, Args, LastIn, Res),
|
|
Res;
|
|
false ->
|
|
reportTerminate(EpmHer, Reason, Args, LastIn, ok),
|
|
ok
|
|
end.
|
|
|
|
epmTerminate(#epmHer{epmM = EpmM, epmId = EpmId, epmS = State} = EpmHer, Args, LastIn, Reason) ->
|
|
%% 删除列表的数据
|
|
OldList = getEpmList(),
|
|
NewList = lists:keydelete(EpmId, 1, OldList),
|
|
setEpmList(NewList),
|
|
%% 删除进程字典中的数据
|
|
delEpmHer(EpmId),
|
|
|
|
case erlang:function_exported(EpmM, terminate, 2) of
|
|
true ->
|
|
Res = (catch EpmM:terminate(Args, State)),
|
|
reportTerminate(EpmHer, Reason, Args, LastIn, Res),
|
|
Res;
|
|
false ->
|
|
reportTerminate(EpmHer, Reason, Args, LastIn, ok),
|
|
ok
|
|
end.
|
|
|
|
reportTerminate(EpmHer, crash, {error, Why}, LastIn, _) ->
|
|
reportTerminate2(EpmHer, Why, LastIn);
|
|
%% How == normal | shutdown | {swapped, NewHandler, NewSupervisor}
|
|
reportTerminate(EpmHer, How, _, LastIn, _) ->
|
|
reportTerminate2(EpmHer, How, LastIn).
|
|
|
|
reportTerminate2(#epmHer{epmSup = EpmSup, epmId = EpmId, epmS = State} = EpmHer, Reason, LastIn) ->
|
|
report_error(EpmHer, Reason, State, LastIn),
|
|
case EpmSup of
|
|
false ->
|
|
ok;
|
|
_ ->
|
|
EpmSup ! {gen_event_EXIT, EpmId, Reason},
|
|
ok
|
|
end.
|
|
|
|
report_error(_EpmHer, normal, _, _) -> ok;
|
|
report_error(_EpmHer, shutdown, _, _) -> ok;
|
|
report_error(_EpmHer, {swapped, _, _}, _, _) -> ok;
|
|
report_error(#epmHer{epmM = EpmM, epmId = EpmId}, Reason, State, LastIn) ->
|
|
?LOG_ERROR(
|
|
#{
|
|
label=>{gen_ipc, epm_terminate},
|
|
handler => {EpmId, EpmM},
|
|
name => getProName(),
|
|
last_message => LastIn,
|
|
state=> format_status(terminate, [EpmM, get(), State]),
|
|
reason => Reason
|
|
},
|
|
#{
|
|
domain => [otp],
|
|
report_cb => fun gen_ipc:epm_log/1,
|
|
error_logger => #{tag => error}
|
|
}).
|
|
|
|
epm_log(#{label := {gen_ipc, epm_terminate}, handler := Handler, name := SName, last_message := LastIn, state := State, reason := Reason}) ->
|
|
Reason1 =
|
|
case Reason of
|
|
{'EXIT', {undef, [{M, F, A, L} | MFAs]}} ->
|
|
case code:is_loaded(M) of
|
|
false ->
|
|
{'module could not be loaded', [{M, F, A, L} | MFAs]};
|
|
_ ->
|
|
case erlang:function_exported(M, F, length(A)) of
|
|
true ->
|
|
{undef, [{M, F, A, L} | MFAs]};
|
|
false ->
|
|
{'function not exported', [{M, F, A, L} | MFAs]}
|
|
end
|
|
end;
|
|
{'EXIT', Why} ->
|
|
Why;
|
|
_ ->
|
|
Reason
|
|
end,
|
|
{"** gen_ipc emp handler ~p crashed.~n"
|
|
"** Was installed in ~tp~n"
|
|
"** Last event was: ~tp~n"
|
|
"** When handler state == ~tp~n"
|
|
"** Reason == ~tp~n", [Handler, SName, LastIn, State, Reason1]};
|
|
epm_log(#{label := {gen_ipc, no_handle_info}, module := Mod, message := Msg}) ->
|
|
{"** Undefined handle_info in ~tp~n"
|
|
"** Unhandled message: ~tp~n", [Mod, Msg]}.
|
|
|
|
epmStopAll() ->
|
|
EpmList = getEpmList(),
|
|
[
|
|
begin
|
|
proTerminate(getEpmHer(EpmId), stop, 'receive', shutdown),
|
|
case EpmSup =/= false of
|
|
true ->
|
|
unlink(EpmSup);
|
|
_ ->
|
|
ignore
|
|
end
|
|
end || {EpmId, _EpmM, EpmSup} <- EpmList
|
|
].
|
|
|
|
epmStopOne(ExitEmpSup) ->
|
|
EpmList = getEpmList(),
|
|
[epmTerminate(getEpmHer(EpmId), stop, 'receive', shutdown) || {EpmId, _EpmM, EpmSup} <- EpmList, ExitEmpSup =:= EpmSup].
|
|
|
|
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% gen_event end %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
|
|
%% 仅在＃params.parent不同时更新。今天，这应该是不可能的（OTP-22.0），但是，例如，如果有人在新的sys调用中实现了更改服务器父服务器，则可能发生这种情况。
|
|
-compile({inline, updateParent/1}).
|
|
updateParent(Parent) ->
|
|
setProName(Parent).
|
|
%%%==========================================================================
|
|
%%% Internal callbacks
|
|
wakeup_from_hibernate(CycleData, CurStatus, CurState, Debug, IsHibernate) ->
|
|
%% 这是一条新消息，唤醒了我们，因此我们必须立即收到它
|
|
receiveMsgWait(CycleData, CurStatus, CurState, Debug, IsHibernate).
|
|
|
|
%%%==========================================================================
|
|
%% Entry point for system_continue/3
|
|
reLoopEntry(CycleData, CurStatus, CurState, Debug, IsHibernate) ->
|
|
if
|
|
IsHibernate ->
|
|
proc_lib:hibernate(?MODULE, wakeup_from_hibernate, [CycleData, CurStatus, CurState, Debug, IsHibernate]);
|
|
true ->
|
|
receiveMsgWait(CycleData, CurStatus, CurState, Debug, IsHibernate)
|
|
end.
|
|
|
|
%% 接收新的消息
|
|
receiveMsgWait(#cycleData{hibernateAfter = HibernateAfterTimeout} = CycleData, CurStatus, CurState, Debug, IsHibernate) ->
|
|
receive
|
|
Msg ->
|
|
case Msg of
|
|
{'$gen_call', From, Request} ->
|
|
matchCallMsg(CycleData, CurStatus, CurState, Debug, {{call, From}, Request});
|
|
{'$gen_cast', Cast} ->
|
|
matchCastMsg(CycleData, CurStatus, CurState, Debug, {cast, Cast});
|
|
{timeout, TimerRef, TimeoutType} ->
|
|
case element(#cycleData.timers, CycleData) of
|
|
#{TimeoutType := {TimerRef, TimeoutMsg}} = Timers ->
|
|
NewTimer = maps:remove(TimeoutType, Timers),
|
|
NewCycleData = setelement(#cycleData.timers, CycleData, NewTimer),
|
|
matchTimeoutMsg(NewCycleData, CurStatus, CurState, Debug, {TimeoutType, TimeoutMsg});
|
|
#{} ->
|
|
matchInfoMsg(CycleData, CurStatus, CurState, Debug, {info, Msg})
|
|
end;
|
|
{system, PidFrom, Request} ->
|
|
%% 不返回但尾递归调用 system_continue/3
|
|
sys:handle_system_msg(Request, PidFrom, getParent(), ?MODULE, Debug, {CycleData, CurStatus, CurState, IsHibernate});
|
|
{'EXIT', PidFrom, Reason} ->
|
|
case getParent() of
|
|
PidFrom ->
|
|
terminate(exit, Reason, ?STACKTRACE(), CycleData, CurStatus, CurState, Debug, []);
|
|
_ ->
|
|
epmStopOne(PidFrom),
|
|
matchInfoMsg(CycleData, CurStatus, CurState, Debug, {info, Msg})
|
|
end;
|
|
{'$epm_call', From, Request} ->
|
|
matchEpmCallMsg(CycleData, CurStatus, CurState, Debug, From, Request);
|
|
{'$epm_info', CmdOrEmpHandler, Event} ->
|
|
matchEpmInfoMsg(CycleData, CurStatus, CurState, Debug, CmdOrEmpHandler, Event);
|
|
_ ->
|
|
matchInfoMsg(CycleData, CurStatus, CurState, Debug, {info, Msg})
|
|
end
|
|
after
|
|
HibernateAfterTimeout ->
|
|
proc_lib:hibernate(?MODULE, wakeup_from_hibernate, [CycleData, CurStatus, CurState, Debug, IsHibernate])
|
|
end.
|
|
|
|
matchCallMsg(#cycleData{module = Module} = CycleData, CurStatus, CurState, Debug, {{call, From}, Request} = Event) ->
|
|
NewDebug = ?SYS_DEBUG(Debug, {in, Event, CurStatus}),
|
|
try Module:handleCall(Request, From, CurStatus, CurState) of
|
|
Result ->
|
|
handleEventCallbackRet(CycleData, CurStatus, CurState, NewDebug, [Event], Result, ?CB_FORM_EVENT, From)
|
|
catch
|
|
throw:Result ->
|
|
handleEventCallbackRet(CycleData, CurStatus, CurState, NewDebug, [Event], Result, ?CB_FORM_EVENT, From);
|
|
Class:Reason:Stacktrace ->
|
|
terminate(Class, Reason, Stacktrace, CycleData, CurStatus, CurState, NewDebug, [Event])
|
|
end.
|
|
|
|
matchCastMsg(#cycleData{module = Module} = CycleData, CurStatus, CurState, Debug, {cast, Cast} = Event) ->
|
|
NewDebug = ?SYS_DEBUG(Debug, {in, Event, CurStatus}),
|
|
try Module:handleCast(Cast, CurStatus, CurState) of
|
|
Result ->
|
|
handleEventCallbackRet(CycleData, CurStatus, CurState, NewDebug, [Event], Result, ?CB_FORM_EVENT, false)
|
|
catch
|
|
throw:Result ->
|
|
handleEventCallbackRet(CycleData, CurStatus, CurState, NewDebug, [Event], Result, ?CB_FORM_EVENT, false);
|
|
Class:Reason:Stacktrace ->
|
|
terminate(Class, Reason, Stacktrace, CycleData, CurStatus, CurState, NewDebug, [Event])
|
|
end.
|
|
|
|
matchInfoMsg(#cycleData{module = Module} = CycleData, CurStatus, CurState, Debug, {info, Msg} = Event) ->
|
|
NewDebug = ?SYS_DEBUG(Debug, {in, Event, CurStatus}),
|
|
try Module:handleInfo(Msg, CurStatus, CurState) of
|
|
Result ->
|
|
handleEventCallbackRet(CycleData, CurStatus, CurState, NewDebug, [Event], Result, ?CB_FORM_EVENT, false)
|
|
catch
|
|
throw:Result ->
|
|
handleEventCallbackRet(CycleData, CurStatus, CurState, NewDebug, [Event], Result, ?CB_FORM_EVENT, false);
|
|
Class:Reason:Stacktrace ->
|
|
terminate(Class, Reason, Stacktrace, CycleData, CurStatus, CurState, NewDebug, [Event])
|
|
end.
|
|
|
|
matchTimeoutMsg(#cycleData{module = Module} = CycleData, CurStatus, CurState, Debug, {TimeoutType, TimeoutMsg} = Event) ->
|
|
NewDebug = ?SYS_DEBUG(Debug, {in, Event, CurStatus}),
|
|
try Module:handleOnevent(TimeoutType, TimeoutMsg, CurStatus, CurState) of
|
|
Result ->
|
|
handleEventCallbackRet(CycleData, CurStatus, CurState, NewDebug, [Event], Result, ?CB_FORM_EVENT, false)
|
|
catch
|
|
throw:Result ->
|
|
handleEventCallbackRet(CycleData, CurStatus, CurState, NewDebug, [Event], Result, ?CB_FORM_EVENT, false);
|
|
Class:Reason:Stacktrace ->
|
|
terminate(Class, Reason, Stacktrace, CycleData, CurStatus, CurState, NewDebug, [Event])
|
|
end.
|
|
|
|
matchEpmCallMsg(CycleData, CurStatus, CurState, Debug, From, Request) ->
|
|
NewDebug = ?SYS_DEBUG(Debug, {in, Request, CurStatus}),
|
|
case Request of
|
|
'$which_handlers' ->
|
|
reply(From, getEpmList());
|
|
{'$addEpm', EpmHandler, Args} ->
|
|
{Reply, IsHib} = doAddEpm(EpmHandler, Args, false),
|
|
reply(From, Reply),
|
|
reLoopEntry(CycleData, CurStatus, CurState, NewDebug, IsHib);
|
|
{'$addSupEpm', EpmHandler, Args, EpmSup} ->
|
|
{Reply, IsHib} = doAddSupEpm(EpmHandler, Args, EpmSup),
|
|
reply(From, Reply),
|
|
reLoopEntry(CycleData, CurStatus, CurState, NewDebug, IsHib);
|
|
{'$deleteEpm', EpmHandler, Args} ->
|
|
Reply = doDeleteEpm(EpmHandler, Args),
|
|
reply(From, Reply),
|
|
receiveMsgWait(CycleData, CurStatus, CurState, NewDebug, false);
|
|
{'$swapEpm', EpmId1, Args1, EpmId2, Args2} ->
|
|
{Reply, IsHib} = doSwapEpm(EpmId1, Args1, EpmId2, Args2),
|
|
reply(From, Reply),
|
|
reLoopEntry(CycleData, CurStatus, CurState, NewDebug, IsHib);
|
|
{'$swapSupEpm', EpmId1, Args1, EpmId2, Args2, SupPid} ->
|
|
{Reply, IsHib} = doSwapSupEpm(EpmId1, Args1, EpmId2, Args2, SupPid),
|
|
reply(From, Reply),
|
|
reLoopEntry(CycleData, CurStatus, CurState, NewDebug, IsHib);
|
|
{'$syncNotify', Event} ->
|
|
IsHib = doNotify(getEpmList(), Event, handleEvent, false),
|
|
reply(From, ok),
|
|
startEpmCall(CycleData, CurStatus, CurState, NewDebug, handleEpmEvent, Request, IsHib);
|
|
{'$epmCall', EpmHandler, Query} ->
|
|
IsHib = doEpmHandle(getEpmHer(EpmHandler), handleCall, Query, From),
|
|
startEpmCall(CycleData, CurStatus, CurState, Debug, handleEpmCall, Request, IsHib)
|
|
end.
|
|
|
|
matchEpmInfoMsg(CycleData, CurStatus, CurState, Debug, CmdOrEmpHandler, Event) ->
|
|
case CmdOrEmpHandler of
|
|
'$infoNotify' ->
|
|
IsHib = doNotify(getEpmList(), Event, handleEvent, false),
|
|
startEpmCall(CycleData, CurStatus, CurState, Debug, handleEpmEvent, Event, IsHib);
|
|
EpmHandler ->
|
|
IsHib = doEpmHandle(getEpmHer(EpmHandler), Event, handleInfo, false),
|
|
startEpmCall(CycleData, CurStatus, CurState, Debug, handleEpmInfo, Event, IsHib)
|
|
end.
|
|
|
|
startEpmCall(#cycleData{module = Module} = CycleData, CurStatus, CurState, Debug, CallbackFun, Event, IsHib) ->
|
|
case erlang:function_exported(Module, CallbackFun, 3) of
|
|
true ->
|
|
NewDebug = ?SYS_DEBUG(Debug, {in, Event, CurStatus}),
|
|
try Module:CallbackFun(Event, CurStatus, CurState) of
|
|
Result ->
|
|
handleEventCallbackRet(CycleData, CurStatus, CurState, NewDebug, [Event], Result, ?CB_FORM_EVENT, false)
|
|
catch
|
|
throw:Ret ->
|
|
handleEventCallbackRet(CycleData, CurStatus, CurState, NewDebug, [Event], Ret, ?CB_FORM_EVENT, false);
|
|
Class:Reason:Stacktrace ->
|
|
terminate(Class, Reason, Stacktrace, CycleData, CurStatus, CurState, NewDebug, [Event])
|
|
end;
|
|
_ ->
|
|
receiveMsgWait(CycleData, CurStatus, CurState, Debug, IsHib)
|
|
end.
|
|
|
|
startEnterCall(#cycleData{module = Module} = CycleData, PrevStatus, CurState, CurStatus, Debug, LeftEvents, Timeouts, NextEvents, IsPostpone, IsHibernate, DoAfter) ->
|
|
try Module:handleEnter(PrevStatus, CurStatus, CurState) of
|
|
Result ->
|
|
handleEnterCallbackRet(CycleData, PrevStatus, CurState, CurStatus, Debug, LeftEvents, Timeouts, NextEvents, IsPostpone, IsHibernate, DoAfter, Result)
|
|
catch
|
|
throw:Result ->
|
|
handleEnterCallbackRet(CycleData, PrevStatus, CurState, CurStatus, Debug, LeftEvents, Timeouts, NextEvents, IsPostpone, IsHibernate, DoAfter, Result);
|
|
Class:Reason:Stacktrace ->
|
|
terminate(Class, Reason, Stacktrace, CycleData, Debug, CurStatus, CurState, LeftEvents)
|
|
end.
|
|
|
|
startAfterCall(#cycleData{module = Module} = CycleData, CurStatus, CurState, Debug, LeftEvents, Args) ->
|
|
try Module:handleAfter(Args, CurStatus, CurState) of
|
|
Result ->
|
|
handleEventCallbackRet(CycleData, CurStatus, CurState, Debug, LeftEvents, Result, ?CB_FORM_AFTER, false)
|
|
catch
|
|
throw:Result ->
|
|
handleEventCallbackRet(CycleData, CurStatus, CurState, Debug, LeftEvents, Result, ?CB_FORM_AFTER, false);
|
|
Class:Reason:Stacktrace ->
|
|
terminate(Class, Reason, Stacktrace, CycleData, CurStatus, CurState, Debug, LeftEvents)
|
|
end.
|
|
|
|
startEventCall(#cycleData{module = Module} = CycleData, CurStatus, CurState, Debug, LeftEvents, {Type, Content}) ->
|
|
case Type of
|
|
'cast' ->
|
|
try Module:handleCast(Content, CurStatus, CurState) of
|
|
Result ->
|
|
handleEventCallbackRet(CycleData, CurStatus, CurState, Debug, LeftEvents, Result, ?CB_FORM_EVENT, false)
|
|
catch
|
|
throw:Ret ->
|
|
handleEventCallbackRet(CycleData, CurStatus, CurState, Debug, LeftEvents, Ret, ?CB_FORM_EVENT, false);
|
|
Class:Reason:Stacktrace ->
|
|
terminate(Class, Reason, Stacktrace, CycleData, CurStatus, CurState, Debug, LeftEvents)
|
|
end;
|
|
'info' ->
|
|
try Module:handleInfo(Content, CurStatus, CurState) of
|
|
Result ->
|
|
handleEventCallbackRet(CycleData, CurStatus, CurState, Debug, LeftEvents, Result, ?CB_FORM_EVENT, false)
|
|
catch
|
|
throw:Ret ->
|
|
handleEventCallbackRet(CycleData, CurStatus, CurState, Debug, LeftEvents, Ret, ?CB_FORM_EVENT, false);
|
|
Class:Reason:Stacktrace ->
|
|
terminate(Class, Reason, Stacktrace, CycleData, CurStatus, CurState, Debug, LeftEvents)
|
|
end;
|
|
{'call', From} ->
|
|
try Module:handleCall(Content, CurStatus, CurState) of
|
|
Result ->
|
|
handleEventCallbackRet(CycleData, CurStatus, CurState, Debug, LeftEvents, Result, ?CB_FORM_EVENT, From)
|
|
catch
|
|
throw:Ret ->
|
|
handleEventCallbackRet(CycleData, CurStatus, CurState, Debug, LeftEvents, Ret, ?CB_FORM_EVENT, From);
|
|
Class:Reason:Stacktrace ->
|
|
terminate(Class, Reason, Stacktrace, CycleData, CurStatus, CurState, Debug, LeftEvents)
|
|
end;
|
|
_ ->
|
|
try Module:handleOnevent(Content, CurStatus, CurState) of
|
|
Result ->
|
|
handleEventCallbackRet(CycleData, CurStatus, CurState, Debug, LeftEvents, Result, ?CB_FORM_EVENT, false)
|
|
catch
|
|
throw:Ret ->
|
|
handleEventCallbackRet(CycleData, CurStatus, CurState, Debug, LeftEvents, Ret, ?CB_FORM_EVENT, false);
|
|
Class:Reason:Stacktrace ->
|
|
terminate(Class, Reason, Stacktrace, CycleData, CurStatus, CurState, Debug, LeftEvents)
|
|
end
|
|
end.
|
|
|
|
handleEpmCallbackRet(Result, EpmHer, Event, From) ->
|
|
case Result of
|
|
ok ->
|
|
ok;
|
|
{ok, NewEpmS} ->
|
|
MewEpmHer = setelement(#epmHer.epmS, EpmHer, NewEpmS),
|
|
setEpmHer(MewEpmHer),
|
|
ok;
|
|
{ok, NewEpmS, hibernate} ->
|
|
MewEpmHer = setelement(#epmHer.epmS, EpmHer, NewEpmS),
|
|
setEpmHer(MewEpmHer),
|
|
hibernate;
|
|
{swapEpm, NewEpmS, Args1, EpmMId, Args2} ->
|
|
#epmHer{epmId = OldEpmMId, epmSup = EpmSup} = MewEpmHer = setelement(#epmHer.epmS, EpmHer, NewEpmS),
|
|
State = epmTerminate(MewEpmHer, Args1, swapped, {swapped, OldEpmMId, EpmSup}),
|
|
case EpmSup of
|
|
false ->
|
|
doAddEpm(EpmMId, {Args2, State}, false);
|
|
_ ->
|
|
doAddSupEpm(EpmMId, {Args2, State}, EpmSup)
|
|
end,
|
|
ok;
|
|
{swapEpm, Reply, NewEpmS, Args1, EpmMId, Args2} ->
|
|
reply(From, Reply),
|
|
#epmHer{epmId = OldEpmMId, epmSup = EpmSup} = MewEpmHer = setelement(#epmHer.epmS, EpmHer, NewEpmS),
|
|
State = epmTerminate(MewEpmHer, Args1, swapped, {swapped, OldEpmMId, EpmSup}),
|
|
case EpmSup of
|
|
false ->
|
|
doAddEpm(EpmMId, {Args2, State}, false);
|
|
_ ->
|
|
doAddSupEpm(EpmMId, {Args2, State}, EpmSup)
|
|
end,
|
|
ok;
|
|
removeEpm ->
|
|
epmTerminate(EpmHer, removeEpm, remove, normal),
|
|
ok;
|
|
{removeEpm, Reply} ->
|
|
reply(From, Reply),
|
|
epmTerminate(EpmHer, removeEpm, remove, normal),
|
|
ok;
|
|
{reply, Reply} ->
|
|
reply(From, Reply),
|
|
ok;
|
|
{reply, Reply, NewEpmS} ->
|
|
reply(From, Reply),
|
|
MewEpmHer = setelement(#epmHer.epmS, EpmHer, NewEpmS),
|
|
setEpmHer(MewEpmHer),
|
|
ok;
|
|
{reply, Reply, NewEpmS, hibernate} ->
|
|
reply(From, Reply),
|
|
MewEpmHer = setelement(#epmHer.epmS, EpmHer, NewEpmS),
|
|
setEpmHer(MewEpmHer),
|
|
hibernate;
|
|
Other ->
|
|
epmTerminate(EpmHer, {error, Other}, Event, crash),
|
|
ok
|
|
end.
|
|
|
|
handleEnterCallbackRet(CycleData, PrevStatus, CurState, CurStatus, Debug, LeftEvents, Timeouts, NextEvents, IsPostpone, IsHibernate, DoAfter, Result) ->
|
|
case Result of
|
|
{keepStatus, NewState} ->
|
|
dealEnterCallbackRet(CycleData, PrevStatus, NewState, CurStatus, Debug, LeftEvents, Timeouts, NextEvents, IsPostpone, IsHibernate, DoAfter, false);
|
|
{keepStatus, NewState, Actions} ->
|
|
parseEnterActionsList(CycleData, PrevStatus, NewState, CurStatus, Debug, LeftEvents, Timeouts, NextEvents, IsPostpone, IsHibernate, DoAfter, false, Actions);
|
|
keepStatusData ->
|
|
dealEnterCallbackRet(CycleData, PrevStatus, CurState, CurStatus, Debug, LeftEvents, Timeouts, NextEvents, IsPostpone, IsHibernate, DoAfter, false);
|
|
{keepStatusData, Actions} ->
|
|
parseEnterActionsList(CycleData, PrevStatus, CurState, CurStatus, Debug, LeftEvents, Timeouts, NextEvents, IsPostpone, IsHibernate, DoAfter, false, Actions);
|
|
{repeatStatus, NewState} ->
|
|
dealEnterCallbackRet(CycleData, PrevStatus, NewState, CurStatus, Debug, LeftEvents, Timeouts, NextEvents, IsPostpone, IsHibernate, DoAfter, true);
|
|
{repeatStatus, NewState, Actions} ->
|
|
parseEnterActionsList(CycleData, PrevStatus, NewState, CurStatus, Debug, LeftEvents, Timeouts, NextEvents, IsPostpone, IsHibernate, DoAfter, true, Actions);
|
|
repeatStatusData ->
|
|
dealEnterCallbackRet(CycleData, PrevStatus, CurState, CurStatus, Debug, LeftEvents, Timeouts, NextEvents, IsPostpone, IsHibernate, DoAfter, true);
|
|
{repeatStatusData, Actions} ->
|
|
parseEnterActionsList(CycleData, PrevStatus, CurState, CurStatus, Debug, LeftEvents, Timeouts, NextEvents, IsPostpone, IsHibernate, DoAfter, true, Actions);
|
|
stop ->
|
|
terminate(exit, normal, ?STACKTRACE(), CycleData, CurStatus, CurState, Debug, LeftEvents);
|
|
{stop, Reason} ->
|
|
terminate(exit, Reason, ?STACKTRACE(), CycleData, CurStatus, CurState, Debug, LeftEvents);
|
|
{stop, Reason, NewState} ->
|
|
terminate(exit, Reason, ?STACKTRACE(), CycleData, CurStatus, NewState, Debug, LeftEvents);
|
|
{stopReply, Reason, Replies} ->
|
|
replyThenTerminate(exit, Reason, ?STACKTRACE(), CycleData, CurStatus, CurState, Debug, LeftEvents, Replies);
|
|
{stopReply, Reason, Replies, NewState} ->
|
|
replyThenTerminate(exit, Reason, ?STACKTRACE(), CycleData, CurStatus, NewState, Debug, LeftEvents, Replies);
|
|
_ ->
|
|
terminate(error, {badReturnFrom_EnterFunction, Result}, ?STACKTRACE(), CycleData, CurStatus, CurState, Debug, LeftEvents)
|
|
end.
|
|
|
|
handleEventCallbackRet(CycleData, CurStatus, CurState, Debug, LeftEvents, Result, CallbackForm, From) ->
|
|
case Result of
|
|
{noreply, NewState} ->
|
|
receiveMsgWait(CycleData, CurStatus, NewState, Debug, false);
|
|
{noreply, NewState, Option} ->
|
|
case Option of
|
|
hibernate ->
|
|
reLoopEntry(CycleData, CurStatus, NewState, Debug, true);
|
|
{doAfter, Args} ->
|
|
startAfterCall(CycleData, CurStatus, NewState, Debug, [], Args);
|
|
_Ret ->
|
|
terminate(error, {bad_reply_option, _Ret}, ?STACKTRACE(), CycleData, CurStatus, NewState, Debug, [])
|
|
end;
|
|
{nextStatus, NewStatus, NewState} ->
|
|
dealEventCallbackRet(CycleData, CurStatus, NewState, NewStatus, Debug, LeftEvents, NewStatus =/= CurStatus);
|
|
{nextStatus, NewStatus, NewState, Actions} ->
|
|
parseEventActionsList(CycleData, CurStatus, NewState, NewStatus, Debug, LeftEvents, NewStatus =/= CurStatus, Actions, CallbackForm);
|
|
{keepStatus, NewState} ->
|
|
dealEventCallbackRet(CycleData, CurStatus, NewState, CurStatus, Debug, LeftEvents, false);
|
|
{keepStatus, NewState, Actions} ->
|
|
parseEventActionsList(CycleData, CurStatus, NewState, CurStatus, Debug, LeftEvents, false, Actions, CallbackForm);
|
|
keepStatusData ->
|
|
dealEventCallbackRet(CycleData, CurStatus, CurState, CurStatus, Debug, LeftEvents, false);
|
|
{keepStatusData, Actions} ->
|
|
parseEventActionsList(CycleData, CurStatus, CurState, CurStatus, Debug, LeftEvents, false, Actions, CallbackForm);
|
|
{repeatStatus, NewState} ->
|
|
dealEventCallbackRet(CycleData, CurStatus, NewState, CurStatus, Debug, LeftEvents, true);
|
|
{repeatStatus, NewState, Actions} ->
|
|
parseEventActionsList(CycleData, CurStatus, NewState, CurStatus, Debug, LeftEvents, true, Actions, CallbackForm);
|
|
repeatStatusData ->
|
|
dealEventCallbackRet(CycleData, CurStatus, CurState, CurStatus, Debug, LeftEvents, true);
|
|
{repeatStatusData, Actions} ->
|
|
parseEventActionsList(CycleData, CurStatus, CurState, CurStatus, Debug, LeftEvents, true, Actions, CallbackForm);
|
|
stop ->
|
|
terminate(exit, normal, ?STACKTRACE(), CycleData, CurStatus, CurState, Debug, LeftEvents);
|
|
{stop, Reason} ->
|
|
terminate(exit, Reason, ?STACKTRACE(), CycleData, CurStatus, CurState, Debug, LeftEvents);
|
|
{stop, Reason, NewState} ->
|
|
terminate(exit, Reason, ?STACKTRACE(), CycleData, CurStatus, NewState, Debug, LeftEvents);
|
|
{stopReply, Reason, Replies} ->
|
|
replyThenTerminate(exit, Reason, ?STACKTRACE(), CycleData, CurStatus, CurState, Debug, LeftEvents, Replies);
|
|
{stopReply, Reason, Replies, NewState} ->
|
|
replyThenTerminate(exit, Reason, ?STACKTRACE(), CycleData, CurStatus, NewState, Debug, LeftEvents, Replies);
|
|
{reply, Reply, NewState} when CallbackForm == ?CB_FORM_EVENT ->
|
|
reply(From, Reply),
|
|
NewDebug = ?SYS_DEBUG(Debug, {out, Reply, From}),
|
|
receiveMsgWait(CycleData, CurStatus, NewState, NewDebug, false);
|
|
{reply, Reply, NewState, Option} when CallbackForm == ?CB_FORM_EVENT ->
|
|
reply(From, Reply),
|
|
NewDebug = ?SYS_DEBUG(Debug, {out, Reply, From}),
|
|
case Option of
|
|
hibernate ->
|
|
reLoopEntry(CycleData, CurStatus, NewState, NewDebug, true);
|
|
{doAfter, Args} ->
|
|
startAfterCall(CycleData, CurStatus, NewState, NewDebug, [], Args);
|
|
_Ret ->
|
|
terminate(error, {bad_reply_option, _Ret}, ?STACKTRACE(), CycleData, CurStatus, NewState, Debug, [])
|
|
end;
|
|
_ ->
|
|
terminate(error, {bad_return_from_status_function, Result}, ?STACKTRACE(), CycleData, CurStatus, CurState, Debug, LeftEvents)
|
|
end.
|
|
|
|
-compile({inline, [dealEnterCallbackRet/12]}).
|
|
dealEnterCallbackRet(#cycleData{isEnter = IsEnter} = CycleData, CurStatus, CurState, NewStatus, Debug, LeftEvents, Timeouts, NextEvents, IsPostpone, IsHibernate, DoAfter, IsCallEnter) ->
|
|
case IsEnter andalso IsCallEnter of
|
|
true ->
|
|
startEnterCall(CycleData, CurStatus, CurState, NewStatus, Debug, LeftEvents, Timeouts, NextEvents, IsPostpone, IsHibernate, DoAfter);
|
|
false ->
|
|
performTransitions(CycleData, CurStatus, CurState, NewStatus, Debug, LeftEvents, Timeouts, NextEvents, IsPostpone, IsHibernate, DoAfter)
|
|
end.
|
|
|
|
-compile({inline, [dealEventCallbackRet/7]}).
|
|
dealEventCallbackRet(#cycleData{isEnter = IsEnter} = CycleData, CurStatus, CurState, NewStatus, Debug, LeftEvents, IsCallEnter) ->
|
|
case IsEnter andalso IsCallEnter of
|
|
true ->
|
|
startEnterCall(CycleData, CurStatus, CurState, NewStatus, Debug, LeftEvents, [], [], false, false, false);
|
|
false ->
|
|
performTransitions(CycleData, CurStatus, CurState, NewStatus, Debug, LeftEvents, [], [], false, false, false)
|
|
end.
|
|
|
|
%% 处理enter callback 动作列表
|
|
parseEnterActionsList(CycleData, CurStatus, CurState, NewStatus, Debug, LeftEvents, Timeouts, NextEvents, IsPostpone, IsCallEnter, IsHibernate, DoAfter, Actions) ->
|
|
%% enter 调用不能改成状态 actions 不能返回 IsPostpone = true 但是可以取消之前的推迟 设置IsPostpone = false 不能设置 doafter 不能插入事件
|
|
case loopParseActionsList(Actions, ?CB_FORM_ENTER, CycleData, Debug, IsPostpone, IsHibernate, DoAfter, Timeouts, NextEvents) of
|
|
{error, ErrorContent} ->
|
|
terminate(error, ErrorContent, ?STACKTRACE(), CycleData, CurStatus, CurState, Debug, []);
|
|
{NewCycleData, NewDebug, NewIsPostpone, NewIsHibernate, DoAfter, NewTimeouts, NextEvents} ->
|
|
case IsCallEnter andalso element(#cycleData.isEnter, NewCycleData) of
|
|
true ->
|
|
startEnterCall(NewCycleData, CurStatus, CurState, NewStatus, NewDebug, LeftEvents, NewTimeouts, NextEvents, NewIsPostpone, NewIsHibernate, DoAfter);
|
|
_ ->
|
|
performTransitions(NewCycleData, CurStatus, CurState, NewStatus, NewDebug, LeftEvents, NewTimeouts, NextEvents, NewIsPostpone, NewIsHibernate, DoAfter)
|
|
end
|
|
end.
|
|
|
|
%% 处理非 enter 或者after callback 返回的动作列表
|
|
parseEventActionsList(CycleData, CurStatus, CurState, NewStatus, Debug, LeftEvents, IsCallEnter, Actions, CallbackForm) ->
|
|
case loopParseActionsList(Actions, CallbackForm, CycleData, Debug, false, false, false, [], []) of
|
|
{error, ErrorContent} ->
|
|
terminate(error, ErrorContent, ?STACKTRACE(), CycleData, CurStatus, CurState, Debug, []);
|
|
{NewCycleData, NewDebug, NewIsPostpone, NewIsHibernate, MewDoAfter, NewTimeouts, NewNextEvents} ->
|
|
case IsCallEnter andalso element(#cycleData.isEnter, NewCycleData) of
|
|
true ->
|
|
startEnterCall(NewCycleData, CurStatus, CurState, NewStatus, NewDebug, LeftEvents, NewTimeouts, NewNextEvents, NewIsPostpone, NewIsHibernate, MewDoAfter);
|
|
_ ->
|
|
performTransitions(NewCycleData, CurStatus, CurState, NewStatus, NewDebug, LeftEvents, NewTimeouts, NewNextEvents, NewIsPostpone, NewIsHibernate, MewDoAfter)
|
|
end
|
|
end.
|
|
|
|
loopParseActionsList([], _CallbackForm, CycleData, Debug, IsPostpone, IsHibernate, DoAfter, Timeouts, NextEvents) ->
|
|
{CycleData, Debug, IsPostpone, IsHibernate, DoAfter, Timeouts, NextEvents};
|
|
loopParseActionsList([OneAction | LeftActions], CallbackForm, CycleData, Debug, IsPostpone, IsHibernate, DoAfter, Timeouts, NextEvents) ->
|
|
case OneAction of
|
|
{reply, From, Reply} ->
|
|
reply(From, Reply),
|
|
NewDebug = ?SYS_DEBUG(Debug, {out, Reply, From}),
|
|
loopParseActionsList(LeftActions, CallbackForm, CycleData, NewDebug, IsPostpone, IsHibernate, DoAfter, Timeouts, NextEvents);
|
|
{eTimeout, _Time, _TimeoutMsg, _Options} = ENewTVOpt ->
|
|
case checkTimeOptions(ENewTVOpt) of
|
|
error_timeout_opt ->
|
|
{error, {bad_eTimeout_action, ENewTVOpt}};
|
|
RetTV ->
|
|
loopParseActionsList(LeftActions, CallbackForm, CycleData, Debug, IsPostpone, IsHibernate, DoAfter, [RetTV | Timeouts], NextEvents)
|
|
end;
|
|
{sTimeout, _Time, _TimeoutMsg, _Options} = SNewTVOpt ->
|
|
case checkTimeOptions(SNewTVOpt) of
|
|
error_timeout_opt ->
|
|
{error, {bad_sTimeout_action, SNewTVOpt}};
|
|
RetTV ->
|
|
loopParseActionsList(LeftActions, CallbackForm, CycleData, Debug, IsPostpone, IsHibernate, DoAfter, [RetTV | Timeouts], NextEvents)
|
|
end;
|
|
{{gTimeout, _Name}, _Time, _TimeoutMsg, _Options} = GNewTVOpt ->
|
|
case checkTimeOptions(GNewTVOpt) of
|
|
error_timeout_opt ->
|
|
{error, {bad_gTimeout_action, GNewTVOpt}};
|
|
RetTV ->
|
|
loopParseActionsList(LeftActions, CallbackForm, CycleData, Debug, IsPostpone, IsHibernate, DoAfter, [RetTV | Timeouts], NextEvents)
|
|
end;
|
|
{u_eTimeout, _TimeoutMsg} = UENewTV ->
|
|
loopParseActionsList(LeftActions, CallbackForm, CycleData, Debug, IsPostpone, IsHibernate, DoAfter, [UENewTV | Timeouts], NextEvents);
|
|
{u_sTimeout, _TimeoutMsg} = USNewTV ->
|
|
loopParseActionsList(LeftActions, CallbackForm, CycleData, Debug, IsPostpone, IsHibernate, DoAfter, [USNewTV | Timeouts], NextEvents);
|
|
{{u_gTimeout, _Name}, _TimeoutMsg} = UGNewTV ->
|
|
loopParseActionsList(LeftActions, CallbackForm, CycleData, Debug, IsPostpone, IsHibernate, DoAfter, [UGNewTV | Timeouts], NextEvents);
|
|
c_eTimeout ->
|
|
loopParseActionsList(LeftActions, CallbackForm, CycleData, Debug, IsPostpone, IsHibernate, DoAfter, [c_eTimeout | Timeouts], NextEvents);
|
|
c_sTimeout ->
|
|
loopParseActionsList(LeftActions, CallbackForm, CycleData, Debug, IsPostpone, IsHibernate, DoAfter, [c_sTimeout | Timeouts], NextEvents);
|
|
{c_gTimeout, _Name} = CGNewTV ->
|
|
loopParseActionsList(LeftActions, CallbackForm, CycleData, Debug, IsPostpone, IsHibernate, DoAfter, [CGNewTV | Timeouts], NextEvents);
|
|
{isEnter, IsEnter} when is_boolean(IsEnter) ->
|
|
NewCycleData =
|
|
case element(#cycleData.isEnter, CycleData) of
|
|
IsEnter ->
|
|
CycleData;
|
|
_ ->
|
|
setelement(#cycleData.isEnter, CycleData, IsEnter)
|
|
end,
|
|
loopParseActionsList(LeftActions, CallbackForm, NewCycleData, Debug, IsPostpone, IsHibernate, DoAfter, Timeouts, NextEvents);
|
|
{isHibernate, NewIsHibernate} when is_boolean(NewIsHibernate) ->
|
|
loopParseActionsList(LeftActions, CallbackForm, CycleData, Debug, IsPostpone, NewIsHibernate, DoAfter, Timeouts, NextEvents);
|
|
{isPostpone, NewIsPostpone} when is_boolean(NewIsPostpone) andalso (not NewIsPostpone orelse CallbackForm == ?CB_FORM_EVENT) ->
|
|
loopParseActionsList(LeftActions, CallbackForm, CycleData, Debug, NewIsPostpone, IsHibernate, DoAfter, Timeouts, NextEvents);
|
|
{doAfter, Args} when CallbackForm == ?CB_FORM_EVENT ->
|
|
loopParseActionsList(LeftActions, CallbackForm, CycleData, Debug, IsPostpone, IsHibernate, {true, Args}, Timeouts, NextEvents);
|
|
{eTimeout, Time, _TimeoutMsg} = ENewTV when ?REL_TIMEOUT(Time) ->
|
|
loopParseActionsList(LeftActions, CallbackForm, CycleData, Debug, IsPostpone, IsHibernate, DoAfter, [ENewTV | Timeouts], NextEvents);
|
|
{sTimeout, Time, _TimeoutMsg} = SNewTV when ?REL_TIMEOUT(Time) ->
|
|
loopParseActionsList(LeftActions, CallbackForm, CycleData, Debug, IsPostpone, IsHibernate, DoAfter, [SNewTV | Timeouts], NextEvents);
|
|
{{gTimeout, _Name}, Time, _TimeoutMsg} = GNewTV when ?REL_TIMEOUT(Time) ->
|
|
loopParseActionsList(LeftActions, CallbackForm, CycleData, Debug, IsPostpone, IsHibernate, DoAfter, [GNewTV | Timeouts], NextEvents);
|
|
{nextEvent, Type, Content} when CallbackForm == ?CB_FORM_EVENT orelse CallbackForm == ?CB_FORM_AFTER ->
|
|
%% 处理next_event动作
|
|
case isEventType(Type) of
|
|
true ->
|
|
loopParseActionsList(LeftActions, CallbackForm, CycleData, Debug, IsPostpone, IsHibernate, DoAfter, Timeouts, [{Type, Content} | NextEvents]);
|
|
_ ->
|
|
{error, {bad_next_event, Type, Content}}
|
|
end;
|
|
_ActRet ->
|
|
{error, {bad_action_type, _ActRet}}
|
|
end.
|
|
|
|
checkTimeOptions({TimeoutType, Time, TimeoutMsg, Options} = NewTV) ->
|
|
case Options of
|
|
[{abs, true}] when ?ABS_TIMEOUT(Time) ->
|
|
NewTV;
|
|
[{abs, false}] when ?REL_TIMEOUT(Time) ->
|
|
{TimeoutType, Time, TimeoutMsg};
|
|
[] when ?REL_TIMEOUT(Time) ->
|
|
{TimeoutType, Time, TimeoutMsg};
|
|
_ ->
|
|
%% 如果将来 start_timer opt扩展了 这里的代码也要修改
|
|
error_timeout_opt
|
|
end.
|
|
|
|
%% 进行状态转换
|
|
performTransitions(#cycleData{postponed = Postponed, timers = Timers} = CycleData, CurStatus, CurState, NewStatus, Debug, [Event | LeftEvents], Timeouts, NextEvents, IsPostpone, IsHibernate, DoAfter) ->
|
|
%% 已收集所有选项，并缓冲next_events。执行实际状态转换。如果推迟则将当前事件移至推迟
|
|
%% 此时 Timeouts, NextEvents的顺序与最开始出现的顺序相反. 后面执行的顺序 超时添加和更新 + 零超时 + 当前事件 + 反序的Postpone事件 + LeftEvent %% TODO 测试验证
|
|
NewDebug = ?SYS_DEBUG(Debug, case IsPostpone of true -> {postpone, Event, CurStatus, NewStatus}; _ -> {consume, Event, NewStatus, NewStatus} end),
|
|
if
|
|
CurStatus =:= NewStatus ->
|
|
%% Cancel event timeout
|
|
LastTimers =
|
|
case Timers of
|
|
#{eTimeout := {TimerRef, _TimeoutMsg}} ->
|
|
cancelTimer(eTimeout, TimerRef, Timers);
|
|
_ ->
|
|
Timers
|
|
end,
|
|
if
|
|
IsPostpone ->
|
|
NewCycleData = setelement(#cycleData.postponed, CycleData, [Event | Postponed]),
|
|
performTimeouts(NewCycleData, NewStatus, CurState, NewDebug, LeftEvents, Timeouts, NextEvents, LastTimers, IsHibernate, DoAfter);
|
|
true ->
|
|
performTimeouts(CycleData, NewStatus, CurState, NewDebug, LeftEvents, Timeouts, NextEvents, LastTimers, IsHibernate, DoAfter)
|
|
end;
|
|
true ->
|
|
%% 取消 status and event timeout
|
|
LastTimers =
|
|
case Timers of
|
|
#{sTimeout := {STimerRef, _STimeoutMsg}} ->
|
|
TemTimer = cancelTimer(sTimeout, STimerRef, Timers),
|
|
case TemTimer of
|
|
#{eTimeout := {ETimerRef, _ETimeoutMsg}} ->
|
|
cancelTimer(eTimeout, ETimerRef, TemTimer);
|
|
_ ->
|
|
TemTimer
|
|
end;
|
|
_ ->
|
|
case Timers of
|
|
#{eTimeout := {ETimerRef, _ETimeoutMsg}} ->
|
|
cancelTimer(eTimeout, ETimerRef, Timers);
|
|
_ ->
|
|
Timers
|
|
end
|
|
end,
|
|
NewCycleData = setelement(#cycleData.postponed, CycleData, []),
|
|
|
|
%% 状态发生改变 重试推迟的事件
|
|
if
|
|
IsPostpone ->
|
|
NewLeftEvents =
|
|
case Postponed of
|
|
[] ->
|
|
[Event | LeftEvents];
|
|
[E1] ->
|
|
[E1, Event | LeftEvents];
|
|
[E2, E1] ->
|
|
[E1, E2, Event | LeftEvents];
|
|
_ ->
|
|
lists:reverse(Postponed, [Event | LeftEvents])
|
|
end,
|
|
performTimeouts(NewCycleData, NewStatus, CurState, NewDebug, NewLeftEvents, Timeouts, NextEvents, LastTimers, IsHibernate, DoAfter);
|
|
true ->
|
|
NewLeftEvents =
|
|
case Postponed of
|
|
[] ->
|
|
LeftEvents;
|
|
[E1] ->
|
|
[E1 | LeftEvents];
|
|
[E2, E1] ->
|
|
[E1, E2 | LeftEvents];
|
|
_ ->
|
|
lists:reverse(Postponed, LeftEvents)
|
|
end,
|
|
performTimeouts(NewCycleData, NewStatus, CurState, NewDebug, NewLeftEvents, Timeouts, NextEvents, LastTimers, IsHibernate, DoAfter)
|
|
end
|
|
end.
|
|
|
|
%% 通过超时和插入事件的处理继续状态转换
|
|
performTimeouts(#cycleData{timers = OldTimer} = CycleData, CurStatus, CurState, Debug, LeftEvents, Timeouts, NextEvents, CurTimers, IsHibernate, DoAfter) ->
|
|
TemLastEvents =
|
|
case NextEvents of
|
|
[] ->
|
|
LeftEvents;
|
|
[E1] ->
|
|
[E1 | LeftEvents];
|
|
[E2, E1] ->
|
|
[E1, E2 | LeftEvents];
|
|
_ ->
|
|
lists:reverse(NextEvents, LeftEvents)
|
|
end,
|
|
case Timeouts of
|
|
[] ->
|
|
case OldTimer =:= CurTimers of
|
|
true ->
|
|
performEvents(CycleData, CurStatus, CurState, Debug, TemLastEvents, IsHibernate, DoAfter);
|
|
_ ->
|
|
NewCycleData = setelement(#cycleData.timers, CycleData, CurTimers),
|
|
performEvents(NewCycleData, CurStatus, CurState, Debug, TemLastEvents, IsHibernate, DoAfter)
|
|
end;
|
|
_ ->
|
|
%% 下面执行 loopTimeoutList 时 列表顺序跟最开始的是发的
|
|
{NewTimers, TimeoutEvents, NewDebug} = loopTimeoutsList(lists:reverse(Timeouts), CurTimers, [], Debug),
|
|
case TimeoutEvents of
|
|
[] ->
|
|
case OldTimer =:= NewTimers of
|
|
true ->
|
|
performEvents(CycleData, CurStatus, CurState, NewDebug, TemLastEvents, IsHibernate, DoAfter);
|
|
_ ->
|
|
NewCycleData = setelement(#cycleData.timers, CycleData, NewTimers),
|
|
performEvents(NewCycleData, CurStatus, CurState, NewDebug, TemLastEvents, IsHibernate, DoAfter)
|
|
end;
|
|
_ ->
|
|
{LastEvents, LastDebug} = mergeTimeoutEvents(TimeoutEvents, CurStatus, NewDebug, TemLastEvents),
|
|
case OldTimer =:= NewTimers of
|
|
true ->
|
|
performEvents(CycleData, CurStatus, CurState, LastDebug, LastEvents, IsHibernate, DoAfter);
|
|
_ ->
|
|
NewCycleData = setelement(#cycleData.timers, CycleData, NewTimers),
|
|
performEvents(NewCycleData, CurStatus, CurState, LastDebug, LastEvents, IsHibernate, DoAfter)
|
|
end
|
|
end
|
|
end.
|
|
|
|
loopTimeoutsList([], Timers, TimeoutEvents, Debug) ->
|
|
{Timers, TimeoutEvents, Debug};
|
|
loopTimeoutsList([OneTimeout | LeftTimeouts], Timers, TimeoutEvents, Debug) ->
|
|
case OneTimeout of
|
|
{TimeoutType, Time, TimeoutMsg, Options} ->
|
|
case Time of
|
|
infinity ->
|
|
NewTimers = doCancelTimer(TimeoutType, Timers),
|
|
loopTimeoutsList(LeftTimeouts, NewTimers, TimeoutEvents, Debug);
|
|
0 when Options =:= [] ->
|
|
NewTimers = doCancelTimer(TimeoutType, Timers),
|
|
loopTimeoutsList(LeftTimeouts, NewTimers, [{TimeoutType, TimeoutMsg} | TimeoutEvents], Debug);
|
|
_ ->
|
|
TimerRef = erlang:start_timer(Time, self(), TimeoutType, Options),
|
|
NewDebug = ?SYS_DEBUG(Debug, {start_timer, {TimeoutType, Time, TimeoutMsg, Options}}),
|
|
NewTimers = doRegisterTimer(TimeoutType, TimerRef, TimeoutMsg, Timers),
|
|
loopTimeoutsList(LeftTimeouts, NewTimers, TimeoutEvents, NewDebug)
|
|
end;
|
|
{TimeoutType, Time, TimeoutMsg} ->
|
|
case Time of
|
|
infinity ->
|
|
NewTimers = doCancelTimer(TimeoutType, Timers),
|
|
loopTimeoutsList(LeftTimeouts, NewTimers, TimeoutEvents, Debug);
|
|
0 ->
|
|
NewTimers = doCancelTimer(TimeoutType, Timers),
|
|
loopTimeoutsList(LeftTimeouts, NewTimers, [{TimeoutType, TimeoutMsg} | TimeoutEvents], Debug);
|
|
_ ->
|
|
TimerRef = erlang:start_timer(Time, self(), TimeoutType),
|
|
NewDebug = ?SYS_DEBUG(Debug, {start_timer, {TimeoutType, Time, TimeoutMsg, []}}),
|
|
NewTimers = doRegisterTimer(TimeoutType, TimerRef, TimeoutMsg, Timers),
|
|
loopTimeoutsList(LeftTimeouts, NewTimers, TimeoutEvents, NewDebug)
|
|
end;
|
|
{UpdateTimeoutType, NewTimeoutMsg} ->
|
|
NewTimers = doUpdateTimer(UpdateTimeoutType, NewTimeoutMsg, Timers),
|
|
loopTimeoutsList(LeftTimeouts, NewTimers, TimeoutEvents, Debug);
|
|
CancelTimeoutType ->
|
|
NewTimers = doCancelTimer(CancelTimeoutType, Timers),
|
|
loopTimeoutsList(LeftTimeouts, NewTimers, TimeoutEvents, Debug)
|
|
end.
|
|
|
|
doRegisterTimer(TimeoutType, NewTimerRef, TimeoutMsg, Timers) ->
|
|
case Timers of
|
|
#{TimeoutType := {OldTimerRef, _OldTimeMsg}} ->
|
|
TemTimers = cancelTimer(TimeoutType, OldTimerRef, Timers),
|
|
TemTimers#{TimeoutType => {NewTimerRef, TimeoutMsg}};
|
|
_ ->
|
|
Timers#{TimeoutType => {NewTimerRef, TimeoutMsg}}
|
|
end.
|
|
|
|
doCancelTimer(TimeoutType, Timers) ->
|
|
case Timers of
|
|
#{TimeoutType := {TimerRef, _TimeoutMsg}} ->
|
|
cancelTimer(TimeoutType, TimerRef, Timers);
|
|
_ ->
|
|
Timers
|
|
end.
|
|
|
|
doUpdateTimer(TimeoutType, Timers, TimeoutMsg) ->
|
|
case Timers of
|
|
#{TimeoutType := {TimerRef, _OldTimeoutMsg}} ->
|
|
Timers#{TimeoutType := {TimerRef, TimeoutMsg}};
|
|
_ ->
|
|
Timers
|
|
end.
|
|
|
|
-compile({inline, [cancelTimer/3]}).
|
|
cancelTimer(TimeoutType, TimerRef, Timers) ->
|
|
case erlang:cancel_timer(TimerRef) of
|
|
false ->
|
|
%% 找不到计时器，我们还没有看到超时消息
|
|
receive
|
|
{TimeoutType, TimerRef, _Msg} ->
|
|
%% 丢弃该超时消息
|
|
ok
|
|
end;
|
|
_ ->
|
|
%% Timer 已经运行了
|
|
ok
|
|
end,
|
|
maps:remove(TimeoutType, Timers).
|
|
|
|
%% 排队立即超时事件（超时0事件）
|
|
%% 自事件超时0起，事件得到特殊处理
|
|
%% 任何收到的事件都会取消事件超时，
|
|
%% 因此，如果在事件超时0事件之前存在入队事件-事件超时被取消，因此没有事件。
|
|
%% 其他（status_timeout和{timeout，Name}）超时0个事件
|
|
%% 在事件计时器超时0事件之后发生的事件被认为是
|
|
%% 属于在事件计时器之后启动的计时器
|
|
%% 已触发超时0事件，因此它们不会取消事件计时器。
|
|
mergeTimeoutEvents([], _Status, Debug, Events) ->
|
|
{Events, Debug};
|
|
mergeTimeoutEvents([{eTimeout, _} = TimeoutEvent | TimeoutEvents], Status, Debug, []) ->
|
|
%% 由于队列中没有其他事件，因此添加该事件零超时事件
|
|
NewDebug = ?SYS_DEBUG(Debug, {insert_timeout, TimeoutEvent, Status}),
|
|
mergeTimeoutEvents(TimeoutEvents, Status, NewDebug, [TimeoutEvent]);
|
|
mergeTimeoutEvents([{eTimeout, _} | TimeoutEvents], Status, Debug, Events) ->
|
|
%% 忽略，因为队列中还有其他事件，因此它们取消了事件超时0。
|
|
mergeTimeoutEvents(TimeoutEvents, Status, Debug, Events);
|
|
mergeTimeoutEvents([TimeoutEvent | TimeoutEvents], Status, Debug, Events) ->
|
|
%% Just prepend all others
|
|
NewDebug = ?SYS_DEBUG(Debug, {insert_timeout, TimeoutEvent, Status}),
|
|
mergeTimeoutEvents(TimeoutEvents, Status, NewDebug, [TimeoutEvent | Events]).
|
|
|
|
%% Return a list of all pending timeouts
|
|
list_timeouts(Timers) ->
|
|
{maps:size(Timers),
|
|
maps:fold(
|
|
fun(TimeoutType, {_TimerRef, TimeoutMsg}, Acc) ->
|
|
[{TimeoutType, TimeoutMsg} | Acc]
|
|
end, [], Timers)}.
|
|
%%---------------------------------------------------------------------------
|
|
|
|
%% 状态转换已完成，如果有排队事件，则继续循环，否则获取新事件
|
|
performEvents(CycleData, CurStatus, CurState, Debug, LeftEvents, IsHibernate, DoAfter) ->
|
|
% io:format("loop_done: status_data = ~p ~n postponed = ~p LeftEvents = ~p ~n timers = ~p.~n", [S#status.status_data,,S#status.postponed,LeftEvents,S#status.timers]),
|
|
case DoAfter of
|
|
{true, Args} ->
|
|
%% 这里 IsHibernate设置会被丢弃 按照gen_server中的设计 continue 和 hiernate是互斥的
|
|
startAfterCall(CycleData, CurStatus, CurState, Debug, LeftEvents, Args);
|
|
_ ->
|
|
case LeftEvents of
|
|
[] ->
|
|
reLoopEntry(CycleData, CurStatus, CurState, Debug, IsHibernate);
|
|
[Event | _Events] ->
|
|
%% 循环直到没有排队事件
|
|
if
|
|
IsHibernate ->
|
|
%% _ = garbage_collect(),
|
|
erts_internal:garbage_collect(major);
|
|
true ->
|
|
ignore
|
|
end,
|
|
startEventCall(CycleData, CurStatus, CurState, Debug, LeftEvents, Event)
|
|
end
|
|
end.
|
|
|
|
doReplies([], Debug) ->
|
|
Debug;
|
|
doReplies([{reply, From, Reply} | Replies], Debug) ->
|
|
reply(From, Reply),
|
|
NewDebug = ?SYS_DEBUG(Debug, {out, Reply, From}),
|
|
doReplies(Replies, NewDebug);
|
|
doReplies([OneReply | _Replies], Debug) ->
|
|
{bad_reply_action, OneReply, Debug}.
|
|
|
|
replyThenTerminate(Class, Reason, Stacktrace, CycleData, CurStatus, CurState, Debug, LeftEvents, Replies) ->
|
|
case doReplies(Replies, Debug) of
|
|
{bad_reply_action, OneReply, Debug} ->
|
|
terminate(error, {bad_reply_action, OneReply}, ?STACKTRACE(), CycleData, CurStatus, CurState, Debug, LeftEvents);
|
|
NewDebug ->
|
|
terminate(Class, Reason, Stacktrace, CycleData, CurStatus, CurState, NewDebug, LeftEvents)
|
|
end.
|
|
|
|
terminate(Class, Reason, Stacktrace, #cycleData{module = Module} = CycleData, CurStatus, CurState, Debug, LeftEvents) ->
|
|
epmStopAll(),
|
|
case erlang:function_exported(Module, terminate, 3) of
|
|
true ->
|
|
try Module:terminate(Reason, CurStatus, CurState) of
|
|
_ -> ok
|
|
catch
|
|
throw:_ -> ok;
|
|
C:R:ST ->
|
|
error_info(C, R, ST, CycleData, CurStatus, CurState, Debug, LeftEvents),
|
|
erlang:raise(C, R, ST)
|
|
end;
|
|
false ->
|
|
ok
|
|
end,
|
|
case Reason of
|
|
normal ->
|
|
?SYS_DEBUG(Debug, {terminate, Reason, CurStatus});
|
|
shutdown ->
|
|
?SYS_DEBUG(Debug, {terminate, Reason, CurStatus});
|
|
{shutdown, _} ->
|
|
?SYS_DEBUG(Debug, {terminate, Reason, CurStatus});
|
|
_ ->
|
|
error_info(Class, Reason, Stacktrace, CycleData, CurStatus, CurState, Debug, LeftEvents)
|
|
end,
|
|
case Stacktrace of
|
|
[] ->
|
|
erlang:Class(Reason);
|
|
_ ->
|
|
erlang:raise(Class, Reason, Stacktrace)
|
|
end.
|
|
|
|
error_info(Class, Reason, Stacktrace, #cycleData{isEnter = IsEnter, postponed = Postponed, timers = Timers} = CycleData, CurStatus, CurState, Debug, LeftEvents) ->
|
|
Log = sys:get_log(Debug),
|
|
?LOG_ERROR(
|
|
#{
|
|
label => {gen_ipc, terminate},
|
|
name => getProName(),
|
|
queue => LeftEvents,
|
|
postponed => Postponed,
|
|
isEnter => IsEnter,
|
|
status => format_status(terminate, get(), CycleData, CurStatus, CurState),
|
|
timeouts => list_timeouts(Timers),
|
|
log => Log,
|
|
reason => {Class, Reason, Stacktrace},
|
|
client_info => clientStacktrace(LeftEvents)
|
|
},
|
|
#{
|
|
domain => [otp],
|
|
report_cb => fun gen_ipc:format_log/1,
|
|
error_logger => #{tag => error}}
|
|
).
|
|
|
|
clientStacktrace([]) ->
|
|
undefined;
|
|
clientStacktrace([{{call, {Pid, _Tag}}, _Req} | _]) when is_pid(Pid) ->
|
|
if
|
|
node(Pid) =:= node() ->
|
|
case process_info(Pid, [current_stacktrace, registered_name]) of
|
|
undefined ->
|
|
{Pid, dead};
|
|
[{current_stacktrace, Stacktrace}, {registered_name, []}] ->
|
|
{Pid, {Pid, Stacktrace}};
|
|
[{current_stacktrace, Stacktrace}, {registered_name, Name}] ->
|
|
{Pid, {Name, Stacktrace}}
|
|
end;
|
|
true ->
|
|
{Pid, remote}
|
|
end;
|
|
clientStacktrace([_ | _]) ->
|
|
undefined.
|
|
|
|
|
|
format_log(#{label:={gen_statusm, terminate},
|
|
name:=Name,
|
|
queue:=LeftEvents,
|
|
postponed:=Postponed,
|
|
callback_mode:=CallbackMode,
|
|
status_enter:=StatusEnter,
|
|
status:=FmtData,
|
|
timeouts:=Timeouts,
|
|
log:=Log,
|
|
reason:={Class, Reason, Stacktrace},
|
|
client_info:=ClientInfo}) ->
|
|
{FixedReason, FixedStacktrace} =
|
|
case Stacktrace of
|
|
[{M, F, Args, _} | ST]
|
|
when Class =:= error, Reason =:= undef ->
|
|
case code:is_loaded(M) of
|
|
false ->
|
|
{{'module could not be loaded', M}, ST};
|
|
_ ->
|
|
Arity =
|
|
if
|
|
is_list(Args) ->
|
|
length(Args);
|
|
is_integer(Args) ->
|
|
Args
|
|
end,
|
|
case erlang:function_exported(M, F, Arity) of
|
|
true ->
|
|
{Reason, Stacktrace};
|
|
false ->
|
|
{{'function not exported', {M, F, Arity}}, ST}
|
|
end
|
|
end;
|
|
_ -> {Reason, Stacktrace}
|
|
end,
|
|
{ClientFmt, ClientArgs} = format_client_log(ClientInfo),
|
|
CBMode =
|
|
case StatusEnter of
|
|
true ->
|
|
[CallbackMode, status_enter];
|
|
false ->
|
|
CallbackMode
|
|
end,
|
|
{"** Status machine ~tp terminating~n" ++
|
|
case LeftEvents of
|
|
[] -> "";
|
|
_ -> "** Last event = ~tp~n"
|
|
end ++
|
|
"** When server status = ~tp~n" ++
|
|
"** Reason for termination = ~w:~tp~n" ++
|
|
"** Callback mode = ~p~n" ++
|
|
case LeftEvents of
|
|
[_, _ | _] -> "** Queued = ~tp~n";
|
|
_ -> ""
|
|
end ++
|
|
case Postponed of
|
|
[] -> "";
|
|
_ -> "** Postponed = ~tp~n"
|
|
end ++
|
|
case FixedStacktrace of
|
|
[] -> "";
|
|
_ -> "** Stacktrace =~n** ~tp~n"
|
|
end ++
|
|
case Timeouts of
|
|
{0, _} -> "";
|
|
_ -> "** Time-outs: ~p~n"
|
|
end ++
|
|
case Log of
|
|
[] -> "";
|
|
_ -> "** Log =~n** ~tp~n"
|
|
end ++ ClientFmt,
|
|
[Name |
|
|
case LeftEvents of
|
|
[] -> [];
|
|
[Event | _] -> [error_logger:limit_term(Event)]
|
|
end] ++
|
|
[error_logger:limit_term(FmtData),
|
|
Class, error_logger:limit_term(FixedReason),
|
|
CBMode] ++
|
|
case LeftEvents of
|
|
[_ | [_ | _] = Events] -> [error_logger:limit_term(Events)];
|
|
_ -> []
|
|
end ++
|
|
case Postponed of
|
|
[] -> [];
|
|
_ -> [error_logger:limit_term(Postponed)]
|
|
end ++
|
|
case FixedStacktrace of
|
|
[] -> [];
|
|
_ -> [error_logger:limit_term(FixedStacktrace)]
|
|
end ++
|
|
case Timeouts of
|
|
{0, _} -> [];
|
|
_ -> [error_logger:limit_term(Timeouts)]
|
|
end ++
|
|
case Log of
|
|
[] -> [];
|
|
_ -> [[error_logger:limit_term(T) || T <- Log]]
|
|
end ++ ClientArgs}.
|
|
|
|
format_client_log(undefined) ->
|
|
{"", []};
|
|
format_client_log({Pid, dead}) ->
|
|
{"** Client ~p is dead~n", [Pid]};
|
|
format_client_log({Pid, remote}) ->
|
|
{"** Client ~p is remote on node ~p~n", [Pid, node(Pid)]};
|
|
format_client_log({_Pid, {Name, Stacktrace}}) ->
|
|
{"** Client ~tp stacktrace~n"
|
|
"** ~tp~n",
|
|
[Name, error_logger:limit_term(Stacktrace)]}.
|
|
|
|
|
|
%% Call Module:format_status/2 or return a default value
|
|
format_status(Opt, PDict, #cycleData{module = Module}, CurStatus, CurState) ->
|
|
case erlang:function_exported(Module, format_status, 2) of
|
|
true ->
|
|
try Module:formatStatus(Opt, [PDict, CurStatus, CurState])
|
|
catch
|
|
throw:Result ->
|
|
Result;
|
|
_:_ ->
|
|
format_status_default(Opt, {CurStatus, atom_to_list(Module) ++ ":format_status/2 crashed"})
|
|
end;
|
|
false ->
|
|
format_status_default(Opt, {CurStatus, CurState})
|
|
end.
|
|
|
|
%% The default Module:format_status/3
|
|
format_status_default(Opt, Status_State) ->
|
|
case Opt of
|
|
terminate ->
|
|
Status_State;
|
|
_ ->
|
|
[{data, [{"Status", Status_State}]}]
|
|
end.
|
|
|
|
%%---------------------------------------------------------------------------
|
|
%% Format debug messages. Print them as the call-back module sees
|
|
%% them, not as the real erlang messages. Use trace for that.
|
|
%%--------------------------------------------------------------------------
|
|
|
|
print_event(Dev, SystemEvent, Name) ->
|
|
case SystemEvent of
|
|
{in, Event, Status} ->
|
|
io:format(Dev, "*DBG* ~tp receive ~ts in status ~tp~n", [Name, event_string(Event), Status]);
|
|
{code_change, Event, Status} ->
|
|
io:format(Dev, "*DBG* ~tp receive ~ts after code change in status ~tp~n", [Name, event_string(Event), Status]);
|
|
{out, Reply, {To, _Tag}} ->
|
|
io:format(Dev, "*DBG* ~tp send ~tp to ~tw~n", [Name, Reply, To]);
|
|
{enter, Status} ->
|
|
io:format(Dev, "*DBG* ~tp enter in status ~tp~n", [Name, Status]);
|
|
{start_timer, Action, Status} ->
|
|
io:format(Dev, "*DBG* ~tp start_timer ~tp in status ~tp~n", [Name, Action, Status]);
|
|
{insert_timeout, Event, Status} ->
|
|
io:format(Dev, "*DBG* ~tp insert_timeout ~tp in status ~tp~n", [Name, Event, Status]);
|
|
{terminate, Reason, Status} ->
|
|
io:format(Dev, "*DBG* ~tp terminate ~tp in status ~tp~n", [Name, Reason, Status]);
|
|
{Tag, Event, Status, NextStatus}
|
|
when Tag =:= postpone; Tag =:= consume ->
|
|
StatusString =
|
|
case NextStatus of
|
|
Status ->
|
|
io_lib:format("~tp", [Status]);
|
|
_ ->
|
|
io_lib:format("~tp => ~tp", [Status, NextStatus])
|
|
end,
|
|
io:format(Dev, "*DBG* ~tp ~tw ~ts in status ~ts~n", [Name, Tag, event_string(Event), StatusString])
|
|
end.
|
|
|
|
event_string(Event) ->
|
|
case Event of
|
|
{{call, {Pid, _Tag}}, Request} ->
|
|
io_lib:format("call ~tp from ~tw", [Request, Pid]);
|
|
{EventType, EventContent} ->
|
|
io_lib:format("~tw ~tp", [EventType, EventContent])
|
|
end.
|
|
|
|
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 进程字典操作函数 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
|
|
setParent(Parent) ->
|
|
erlang:put(?PD_PARENT, Parent).
|
|
|
|
getParent() ->
|
|
erlang:get(?PD_PARENT).
|
|
|
|
setProName(Name) ->
|
|
erlang:put(?PD_PRO_NAME, Name).
|
|
|
|
getProName() ->
|
|
erlang:get(?PD_PRO_NAME).
|
|
|
|
setEpmList(EpmList) ->
|
|
erlang:put(?PD_EPM_LIST, EpmList).
|
|
|
|
getEpmList() ->
|
|
case erlang:get(?PD_EPM_LIST) of
|
|
undefined ->
|
|
[];
|
|
RetList ->
|
|
RetList
|
|
end.
|
|
|
|
delEpmHer(#epmHer{epmId = EpmId}) ->
|
|
erlang:erase({?PD_EPM_FLAG, EpmId}).
|
|
|
|
setEpmHer(#epmHer{epmId = EpmId} = EpmHer) ->
|
|
erlang:put({?PD_EPM_FLAG, EpmId}, EpmHer).
|
|
getEpmHer(EpmId) ->
|
|
erlang:get({?PD_EPM_FLAG, EpmId}).
|
|
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
|