megaco_test_mgc.erl

OTP是开放电信平台的简称

	    server_reply(Parent, user_info_ack, Res),
	    loop(S);

	{{update_conn_info, Tag, Val}, Parent} when S#mgc.parent == Parent ->
	    i("loop -> got update_conn_info: ~w -> ~p", [Tag, Val]),
	    Conns = megaco:user_info(S#mgc.mid, connections), 
	    Fun = fun(CH) ->
			  (catch megaco:update_conn_info(CH, Tag, Val))
		  end,
	    Res = lists:map(Fun, Conns),
	    d("loop -> Res: ~p", [Res]),
	    server_reply(Parent, update_conn_info_ack, Res),
	    loop(S);

	{{conn_info, Tag}, Parent} when S#mgc.parent == Parent ->
	    i("loop -> got conn_info request for ~w", [Tag]),
	    Conns = megaco:user_info(S#mgc.mid, connections), 
	    Fun = fun(CH) ->
			  {CH, (catch megaco:conn_info(CH, Tag))}
		  end,
	    Res = lists:map(Fun, Conns),
	    d("loop -> Res: ~p", [Res]),
	    server_reply(Parent, conn_info_ack, Res),
	    loop(S);


	%% 
	{request_action, {Action, To}, Parent} when S#mgc.parent == Parent ->
	    i("loop -> got new request_action: ~p:~w", [Action,To]),
	    {Reply, S1} = 
		case lists:member(Action, ?valid_actions) of
		    true when To >= 0; To == infinity ->
			{{ok, S#mgc.req_action}, 
			 S#mgc{req_action = Action, req_timeout = To}};
		    true ->
			{{error, {invalid_action_timeout, To}}, S};
		    false ->
			{{error, {invalid_action, Action}}, S}
		end,
	    server_reply(Parent, request_action_ack, Reply),
	    loop(S1);


	%% Reset stats
	{reset_stats, Parent} when S#mgc.parent == Parent ->
	    i("loop -> got request to reset stats counters"),
	    do_reset_stats(S#mgc.mid),
	    server_reply(Parent, reset_stats_ack, ok),
	    loop(S);


	%% Give me statistics
	{{statistics, 1}, Parent} when S#mgc.parent == Parent ->
	    i("loop -> got request for statistics 1"),
	    {ok, Gen} = megaco:get_stats(),
	    GetTrans = 
		fun(CH) ->
			Reason = {statistics, CH}, 
			Pid = megaco:conn_info(CH, control_pid),
			SendMod = megaco:conn_info(CH, send_mod),
			SendHandle = megaco:conn_info(CH, send_handle),
			{ok, Stats} = 
			    case SendMod of
				megaco_tcp -> megaco_tcp:get_stats(SendHandle);
				megaco_udp -> megaco_udp:get_stats(SendHandle);
				SendMod    -> exit(Pid, Reason)
			    end,
			{SendHandle, Stats}
		end,
	    Mid = S#mgc.mid,
	    Trans = 
		lists:map(GetTrans, megaco:user_info(Mid, connections)),
	    Reply = {ok, [{gen, Gen}, {trans, Trans}]},
	    server_reply(Parent, {statistics_reply, 1}, Reply),
	    loop(S);


	{{statistics, 2}, Parent} when S#mgc.parent == Parent ->
	    i("loop -> got request for statistics 2"),
	    {ok, Gen} = megaco:get_stats(),
	    #mgc{tcp_sup = TcpSup, udp_sup = UdpSup} = S,
	    TcpStats = get_trans_stats(TcpSup, megaco_tcp),
	    UdpStats = get_trans_stats(UdpSup, megaco_udp),
	    Reply = {ok, [{gen, Gen}, {trans, [TcpStats, UdpStats]}]},
	    server_reply(Parent, {statistics_reply, 2}, Reply),
	    loop(S);


	%% Megaco callback messages
	{request, Request, From} ->
	    d("loop -> received megaco request from ~p:~n~p", 
	      [From, Request]),
	    {Reply, S1} = handle_megaco_request(Request, S),
	    d("loop -> send request reply: ~n~p", [Reply]),
	    reply(From, Reply),
	    loop(S1);


	{ack_info, To, Parent} when S#mgc.parent == Parent ->
	    i("loop -> received request to inform about received ack's ", []),
	    loop(S#mgc{ack_info = To});


	{abort_info, To, Parent} when S#mgc.parent == Parent ->
	    i("loop -> received request to inform about received aborts ", []),
	    loop(S#mgc{abort_info = To});


	{req_info, To, Parent} when S#mgc.parent == Parent ->
	    i("loop -> received request to inform about received req's ", []),
	    loop(S#mgc{req_info = To});


	{verbosity, V, Parent} when S#mgc.parent == Parent ->
	    i("loop -> received new verbosity: ~p", [V]),
	    put(verbosity,V),
	    loop(S);


	{'EXIT', Pid, Reason} ->
	    error_msg("MGC received unexpected exit signal from ~p:~n~p", 
		      [Pid, Reason]),
	    loop(S);


	Invalid ->
	    i("loop -> received invalid request: ~p", [Invalid]),
	    loop(S)
    end.


do_reset_stats(Mid) ->
    megaco:reset_stats(),
    do_reset_trans_stats(megaco:user_info(Mid, connections), []).

do_reset_trans_stats([], _Reset) ->
    ok;
do_reset_trans_stats([CH|CHs], Reset) ->
    SendMod = megaco:conn_info(CH, send_mod),
    case lists:member(SendMod, Reset) of
	true ->
	    do_reset_trans_stats(CHs, Reset);
	false ->
	    SendMod:reset_stats(),
	    do_reset_trans_stats(CHs, [SendMod|Reset])
    end.
	    

close_conns(Mid) ->
    Reason = {self(), ignore},
    Disco  = fun(CH) ->
		     (catch do_close_conn(CH, Reason))
	     end,
    lists:map(Disco, megaco:user_info(Mid, connections)).

do_close_conn(CH, Reason) ->
    d("close connection to ~p", [CH#megaco_conn_handle.remote_mid]),
    Pid        = megaco:conn_info(CH, control_pid),
    SendMod    = megaco:conn_info(CH, send_mod),
    SendHandle = megaco:conn_info(CH, send_handle),
    megaco:disconnect(CH, Reason),
    case SendMod of
	megaco_tcp -> megaco_tcp:close(SendHandle);
	megaco_udp -> megaco_udp:close(SendHandle);
	SendMod    -> exit(Pid, Reason)
    end.
    
get_trans_stats(P, SendMod) when pid(P) ->
    case (catch SendMod:get_stats()) of
	{ok, Stats} ->
	    {SendMod, Stats};
	Else ->
	    {SendMod, Else}
    end;
get_trans_stats(_P, SendMod) ->
    {SendMod, undefined}.

parse_receive_info([], _RH) ->
    throw({error, no_receive_info});
parse_receive_info(RI, RH) ->
    parse_receive_info(RI, RH, []).

parse_receive_info([], _RH, ListenTo) ->
    ListenTo;
parse_receive_info([RI|RIs], RH, ListenTo) ->
    d("parse_receive_info -> parse receive info"),
    case (catch parse_receive_info1(RI, RH)) of
	{error, Reason} ->
	    i("failed parsing receive info: ~p~n~p", [RI, Reason]),
	    exit({failed_parsing_recv_info, RI, Reason});
	RH1 ->
	    parse_receive_info(RIs, RH, [RH1|ListenTo])
    end.
    
parse_receive_info1(RI, RH) ->
    d("parse_receive_info1 -> get encoding module"),
    EM = get_encoding_module(RI),
    d("parse_receive_info1 -> get encoding config"),
    EC = get_encoding_config(RI, EM),
    d("parse_receive_info1 -> get transport module"),
    TM = get_transport_module(RI),
    d("parse_receive_info1 -> get transport port"),
    TP = get_transport_port(RI),
    RH1 = RH#megaco_receive_handle{send_mod        = TM,
				   encoding_mod    = EM,
				   encoding_config = EC},
    {TP, RH1}.


start_transports([]) ->
    throw({error, no_transport});
start_transports(ListenTo) ->
    start_transports(ListenTo, undefined, undefined).
    

start_transports([], TcpSup, UdpSup) ->
    {TcpSup, UdpSup};
start_transports([{Port, RH}|ListenTo], TcpSup, UdpSup) 
  when RH#megaco_receive_handle.send_mod == megaco_tcp ->
    TcpSup1 = start_tcp(RH, Port, TcpSup),
    start_transports(ListenTo, TcpSup1, UdpSup);
start_transports([{Port, RH}|ListenTo], TcpSup, UdpSup) 
  when RH#megaco_receive_handle.send_mod == megaco_udp ->
    UdpSup1 = start_udp(RH, Port, UdpSup),
    start_transports(ListenTo, TcpSup, UdpSup1);
start_transports([{_Port, RH}|_ListenTo], _TcpSup, _UdpSup) ->
    throw({error, {bad_send_mod, RH#megaco_receive_handle.send_mod}}).


start_tcp(RH, Port, undefined) ->
    d("start tcp transport"),
    case megaco_tcp:start_transport() of
	{ok, Sup} ->
	    start_tcp(RH, Port, Sup);
	Else ->
	    throw({error, {failed_starting_tcp_transport, Else}})
    end;
start_tcp(RH, Port, Sup) when pid(Sup) ->
    d("tcp listen on ~p", [Port]),
    Opts = [{port, Port}, {receive_handle, RH}],
    case megaco_tcp:listen(Sup, Opts) of
	ok ->
	    Sup;
	Else ->
	    throw({error, {failed_starting_tcp_listen, Else}})
    end.


start_udp(RH, Port, undefined) ->
    d("start udp transport"),
    case megaco_udp:start_transport() of
	{ok, Sup} ->
	    start_udp(RH, Port, Sup);
	Else ->
	    throw({error, {failed_starting_udp_transport, Else}})
    end;
start_udp(RH, Port, Sup) ->
    d("open udp ~p", [Port]),
    Opts = [{port, Port}, {receive_handle, RH}],
    case megaco_udp:open(Sup, Opts) of
	{ok, _SendHandle, _ControlPid} ->
	    Sup;
	Else ->
	    exit({error, {failed_starting_udp_listen, Else}})
    end.

%% -----------------------
%% Handle megaco callbacks
%%

handle_megaco_request({handle_connect, CH, _PV}, #mgc{mg = MGs} = S) ->
    case lists:member(CH, MGs) of
	true ->
	    i("MG already connected: ~n   ~p", [CH]),
	    {error, S};
	false ->
	    {ok, S#mgc{mg = [CH|MGs]}}
    end;

handle_megaco_request({handle_disconnect, CH, _PV, R}, S) ->
    d("handle_megaco_request(handle_disconnect) -> entry with"
      "~n   CH: ~p"
      "~n   R:  ~p", [CH, R]),
    CancelRes = (catch megaco:cancel(CH, R)), % Cancel the outstanding messages
    d("handle_megaco_request(handle_disconnect) -> megaco cancel result: ~p", [CancelRes]),
    MGs = lists:delete(CH, S#mgc.mg),
    d("handle_megaco_request(handle_disconnect) -> MGs: ~p", [MGs]),
    {ok, S#mgc{mg = MGs}};

handle_megaco_request({handle_syntax_error, _RH, _PV, _ED}, S) ->
    {reply, S};

handle_megaco_request({handle_message_error, _CH, _PV, _ED}, S) ->
    {no_reply, S};

handle_megaco_request({handle_trans_request, CH, PV, ARs}, 
		      #mgc{req_info = P} = S) when pid(P) ->
    d("handle_megaco_request(handle_trans_request,~p) -> entry", [P]),
    P ! {req_received, self(), ARs},
    do_handle_trans_request(CH, PV, ARs, S);
handle_megaco_request({handle_trans_request, CH, PV, ARs}, S) ->
    d("handle_megaco_request(handle_trans_request) -> entry"),
    do_handle_trans_request(CH, PV, ARs, S);

handle_megaco_request({handle_trans_long_request, CH, PV, RD}, S) ->
    d("handle_megaco_request(handle_long_trans_request) -> entry"),
    Reply0 = handle_act_requests(CH, PV, RD, discard_ack),
    Reply  = 
	case S of
	    #mgc{req_action = ignore, req_timeout = To} ->
		d("handle_megaco_request(handle_long_trans_request) -> "
		  "~n   To: ~p", [To]),
		{delay_reply, To, Reply0};
	    _ ->
		d("handle_megaco_request(handle_long_trans_request) -> "
		  "~n   S: ~p", [S]),
		Reply0
	end,
    {Reply, S};

handle_megaco_request({handle_trans_reply, _CH, _PV, _AR, _RD}, S) ->
    {ok, S};

handle_megaco_request({handle_trans_ack, CH, PV, AS, AD}, 
		      #mgc{ack_info = P} = S) when pid(P) ->
    d("handle_megaco_request(handle_trans_ack,~p) -> entry when"
      "~n   CH: ~p"
      "~n   PV: ~p"
      "~n   AS: ~p"
      "~n   AD: ~p", [P, CH, PV, AS, AD]),
    P ! {ack_received, self(), AS},
    {ok, S};

handle_megaco_request({handle_trans_ack, CH, PV, AS, AD}, S) ->
    d("handle_megaco_request(handle_trans_ack) -> entry with"
      "~n   CH: ~p"
      "~n   PV: ~p"
      "~n   AS: ~p"
      "~n   AD: ~p", [CH, PV, AS, AD]),
    {ok, S};

handle_megaco_request({handle_unexpected_trans, CH, PV, TR}, S) ->
    d("handle_megaco_request(handle_unexpected_trans) -> entry with"
      "~n   CH: ~p"
      "~n   PV: ~p"
      "~n   TR: ~p", [CH, PV, TR]),
    {ok, S};