%%
%% %CopyrightBegin%
%%
%% Copyright Ericsson AB 2000-2009. All Rights Reserved.
%%
%% The contents of this file are subject to the Erlang Public License,
%% Version 1.1, (the "License"); you may not use this file except in
%% compliance with the License. You should have received a copy of the
%% Erlang Public License along with this software. If not, it can be
%% retrieved online at http://www.erlang.org/.
%%
%% Software distributed under the License is distributed on an "AS IS"
%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
%% the License for the specific language governing rights and limitations
%% under the License.
%%
%% %CopyrightEnd%
%%
%%
%%----------------------------------------------------------------------
%% Purpose: A fun implementation of user callbacks
%%----------------------------------------------------------------------
-module(megaco_mess_user_test).
-behaviour(megaco_user).
-export([
handle_connect/2, handle_connect/3,
handle_disconnect/3,
handle_syntax_error/3, handle_syntax_error/4,
handle_message_error/3, handle_message_error/4,
handle_trans_request/3, handle_trans_request/4,
handle_trans_long_request/3, handle_trans_long_request/4,
handle_trans_reply/4, handle_trans_reply/5,
handle_trans_ack/4, handle_trans_ack/5,
handle_unexpected_trans/3, handle_unexpected_trans/4,
handle_trans_request_abort/4, handle_trans_request_abort/5,
handle_segment_reply/5, handle_segment_reply/6
]).
-export([
start_proxy/0,
stop_proxy/0,
apply_proxy/1,
reply/3,
start_transport/2,
loop_transport/1, % Internal only
send_message/2,
resend_message/2
]).
-include("megaco_test_lib.hrl").
-define(SERVER, ?MODULE).
start_proxy() ->
yes = global:register_name(?SERVER, self()),
Pid = megaco_test_lib:proxy_start(?MODULE),
put(?MODULE, Pid),
Pid.
stop_proxy() ->
global:unregister_name(?SERVER),
Pid = erase(?MODULE),
unlink(Pid),
exit(Pid, shutdown).
whereis_proxy() ->
case get(?MODULE) of
undefined ->
exit(no_server, ?MODULE);
Pid when is_pid(Pid) ->
Pid
end.
apply_proxy(Fun) ->
Pid = whereis_proxy(),
?APPLY(Pid, Fun),
ok.
reply(Mod, Line, Fun) when is_function(Fun) ->
receive
{?MODULE, Pid, UserCallback} ->
UserReply = Fun(UserCallback),
Pid ! {?MODULE, self(), UserReply},
UserReply;
Other ->
megaco_test_lib:error(Other, Mod, Line),
{error, Other}
%% after 1000 ->
%% megaco_test_lib:error(timeout, Mod, Line),
%% {error, timeout}
end.
call(UserCallback) ->
Request = {?MODULE, self(), UserCallback},
case global:whereis_name(?SERVER) of
undefined ->
exit({no_server, ?SERVER, Request});
Pid when is_pid(Pid) ->
?LOG("call[~p] -> bang request: "
"~n ~p"
"~n", [Pid, Request]),
Pid ! Request,
call_await_reply(Pid)
end.
call_await_reply(Pid) ->
receive
{?MODULE, Pid, UserReply} = _Reply ->
case UserReply of
{ok, Good} -> Good;
{error, Bad} -> exit(Bad)
end;
{'EXIT', Pid, Reason} = Bad ->
?LOG("receive test case exit: ~p~n", [Bad]),
exit(Reason);
{'EXIT', _, _Reason} = Bad ->
?LOG("receive unknown exit: ~p~n", [Bad]),
call_await_reply(Pid);
Bad ->
?LOG("receive other: ~p~n", [Bad]),
exit(Bad)
end.
%%----------------------------------------------------------------------
%% Megaco user callback
%%----------------------------------------------------------------------
%% -- handle_connect/2 --
handle_connect(ConnHandle, ProtocolVersion) ->
%% io:format("~p~p[~p]: handle_connect -> entry with"
%% "~n ConnHandle: ~p"
%% "~n ProtocolVersion: ~p"
%% "~n",
%% [self(), ?MODULE, ?LINE, ConnHandle, ProtocolVersion]),
call({connect, ConnHandle, ProtocolVersion, []}).
handle_connect(ConnHandle, ProtocolVersion, Extra) ->
%% io:format(user,"~p~p[~p]: handle_connect -> entry with"
%% "~n ConnHandle: ~p"
%% "~n ProtocolVersion: ~p"
%% "~n Extra: ~p"
%% "~n",
%% [self(), ?MODULE, ?LINE, ConnHandle, ProtocolVersion, Extra]),
call({connect, ConnHandle, ProtocolVersion, [Extra]}).
%% -- handle_disconnect/3 --
handle_disconnect(ConnHandle, ProtocolVersion, Reason) ->
%% io:format("~w:~w:~p:handle_disconnect -> entry with"
%% "~n ConnHandle: ~p"
%% "~n ProtocolVersion: ~p"
%% "~n Reason: ~p"
%% "~n",
%% [?MODULE, ?LINE, self(), ConnHandle, ProtocolVersion, Reason]),
call({disconnect, ConnHandle, ProtocolVersion, [Reason]}).
%% -- handle_syntax_error/3,4 --
handle_syntax_error(ReceiveHandle, ProtocolVersion, ErrorDescriptor) ->
call({syntax_error, ReceiveHandle, ProtocolVersion, [ErrorDescriptor]}).
handle_syntax_error(ReceiveHandle, ProtocolVersion, ErrorDescriptor, Extra) ->
call({syntax_error, ReceiveHandle, ProtocolVersion, [ErrorDescriptor, Extra]}).
%% -- handle_message_error/3,4 --
handle_message_error(ConnHandle, ProtocolVersion, ErrorDescriptor) ->
call({message_error, ConnHandle, ProtocolVersion, [ErrorDescriptor]}).
handle_message_error(ConnHandle, ProtocolVersion, ErrorDescriptor, Extra) ->
call({message_error, ConnHandle, ProtocolVersion, [ErrorDescriptor, Extra]}).
%% -- handle_trans_request/3,4 --
handle_trans_request(ConnHandle, ProtocolVersion, ActionRequests) ->
call({request, ConnHandle, ProtocolVersion, [ActionRequests]}).
handle_trans_request(ConnHandle, ProtocolVersion, ActionRequests, Extra) ->
call({request, ConnHandle, ProtocolVersion, [ActionRequests, Extra]}).
%% -- handle_trans_long_request/3,4 --
handle_trans_long_request(ConnHandle, ProtocolVersion, RequestData) ->
call({long_request, ConnHandle, ProtocolVersion, [RequestData]}).
handle_trans_long_request(ConnHandle, ProtocolVersion, RequestData, Extra) ->
call({long_request, ConnHandle, ProtocolVersion, [RequestData, Extra]}).
%% -- handle_trans_relpy/4,5 --
handle_trans_reply(ConnHandle, ProtocolVersion, UserReply, UserData) ->
call({reply, ConnHandle, ProtocolVersion, [UserReply, UserData]}).
handle_trans_reply(ConnHandle, ProtocolVersion, UserReply, UserData, Extra) ->
call({reply, ConnHandle, ProtocolVersion, [UserReply, UserData, Extra]}).
%% -- handle_trans_relpy/4,5 --
handle_trans_ack(ConnHandle, ProtocolVersion, AckStatus, AckData) ->
call({ack, ConnHandle, ProtocolVersion, [AckStatus, AckData]}).
handle_trans_ack(ConnHandle, ProtocolVersion, AckStatus, AckData, Extra) ->
call({ack, ConnHandle, ProtocolVersion, [AckStatus, AckData, Extra]}).
%% -- handle_unexpected_trans/3,4 --
handle_unexpected_trans(ConnHandle, ProtocolVersion, Trans) ->
call({unepected_trans, ConnHandle, ProtocolVersion, [Trans]}).
handle_unexpected_trans(ConnHandle, ProtocolVersion, Trans, Extra) ->
call({unepected_trans, ConnHandle, ProtocolVersion, [Trans, Extra]}).
%% -- handle_trans_request_abort/4,5 --
handle_trans_request_abort(ConnHandle, ProtocolVersion, TransId, Pid) ->
call({request_abort, ConnHandle, ProtocolVersion, [TransId, Pid]}).
handle_trans_request_abort(ConnHandle, ProtocolVersion, TransId, Pid, Extra) ->
call({request_abort, ConnHandle, ProtocolVersion, [TransId, Pid, Extra]}).
%% -- handle_segment_reply/5,6 --
handle_segment_reply(ConnHandle, ProtocolVersion, TransId, SN, SC) ->
call({segment_reply, ConnHandle, ProtocolVersion, [TransId, SN, SC]}).
handle_segment_reply(ConnHandle, ProtocolVersion, TransId, SN, SC, Extra) ->
call({segment_reply, ConnHandle, ProtocolVersion, [TransId, SN, SC, Extra]}).
%%----------------------------------------------------------------------
%% The ultimate Megaco transport callback
%%----------------------------------------------------------------------
start_transport(MgReceiveHandle, MgcReceiveHandle) ->
MgControlPid = spawn_link(?MODULE, loop_transport, [self()]),
MgSendHandle = {MgcReceiveHandle, MgControlPid},
MgcControlPid = spawn_link(?MODULE, loop_transport, [self()]),
MgcSendHandle = {MgReceiveHandle, MgcControlPid},
SendHandle = {MgSendHandle, MgcSendHandle},
{ok, MgControlPid, SendHandle}.
loop_transport(Parent) ->
receive
{'EXIT', _Pid, Reason} = Error ->
ok = io:format("transport stopped: ~p~n", [{Parent, Error}]),
exit(Reason)
end.
send_message(Handles, Bin) ->
?LOG("send_message -> entry with"
"~n Handles: ~p"
"~n", [Handles]),
case megaco_tc_controller:lookup(allow_send_message) of
{value, ok} ->
do_send_message(Handles, Bin);
{value, {fail, Reason}} ->
{error, Reason};
{value, {cancel, Reason}} ->
{cancel, Reason};
{value, {skip, Result}} ->
Result;
false ->
do_send_message(Handles, Bin)
end.
resend_message(Handles, Bin) ->
?LOG("resend_message -> entry with"
"~n Handles: ~p"
"~n", [Handles]),
case megaco_tc_controller:lookup(allow_resend_message) of
{value, ok} ->
do_send_message(Handles, Bin);
{value, {fail, Reason}} ->
{error, Reason};
{value, {cancel, Reason}} ->
{cancel, Reason};
{value, {skip, Result}} ->
Result;
false ->
do_send_message(Handles, Bin)
end.
do_send_message({{RH, Pid} = LocalSendHandle, RemoteSendHandle}, Bin) ->
?LOG("do_send_message -> entry with"
"~n RH: ~p"
"~n Pid: ~p"
"~n RemoteSendHandle: ~p"
"~n", [RH, Pid, RemoteSendHandle]),
SwappedSendHandle = {RemoteSendHandle, LocalSendHandle},
case megaco_tc_controller:lookup(extra_transport_info) of
{value, Extra} ->
megaco:receive_message(RH, Pid, SwappedSendHandle, Bin, Extra);
_ ->
megaco:receive_message(RH, Pid, SwappedSendHandle, Bin)
end.
