%%
%% %CopyrightBegin%
%%
%% Copyright Ericsson AB 2002-2019. All Rights Reserved.
%%
%% Licensed under the Apache License, Version 2.0 (the "License");
%% you may not use this file except in compliance with the License.
%% You may obtain a copy of the License at
%%
%% http://www.apache.org/licenses/LICENSE-2.0
%%
%% Unless required by applicable law or agreed to in writing, software
%% distributed under the License is distributed on an "AS IS" BASIS,
%% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
%% See the License for the specific language governing permissions and
%% limitations under the License.
%%
%% %CopyrightEnd%
%%
%%
%%----------------------------------------------------------------------
%% Purpose: Verify the application specifics of the Megaco application
%%----------------------------------------------------------------------
-module(megaco_mib_test).
-export([
t/0, t/1,
all/0,
groups/0,
init_per_testcase/2,
end_per_testcase/2,
init_per_group/2,
end_per_group/2,
plain/1,
connect/1,
traffic/1,
mg/3,
mgc/3,
handle_connect/3,
handle_disconnect/4,
handle_syntax_error/4,
handle_message_error/4,
handle_trans_request/4,
handle_trans_long_request/4,
handle_trans_reply/5,
handle_trans_ack/5
]).
-include("megaco_test_lib.hrl").
-include_lib("megaco/include/megaco.hrl").
-include_lib("megaco/include/megaco_message_v1.hrl").
-define(TEST_VERBOSITY, info). % silence | info | debug
-define(MGC_VERBOSITY, info).
-define(MG_VERBOSITY, info).
-define(LOAD_COUNTER_START, 100).
-define(A4444, ["11111111", "00000000", "00000000"]).
-record(mgc, {parent = undefined,
tcp_sup = undefined,
udp_sup = undefined,
mid = undefined,
mg = []}).
-record(mg, {parent = undefined,
mid = undefined,
conn_handle = undefined,
state = initiated,
load_counter = 0}).
t() -> megaco_test_lib:t(?MODULE).
t(Case) -> megaco_test_lib:t({?MODULE, Case}).
%% Test server callbacks
init_per_testcase(Case, Config) ->
progress("init_per_testcase -> ~w", [Case]),
process_flag(trap_exit, true),
case Case of
traffic ->
Conf0 = lists:keydelete(tc_timeout, 1, Config),
Conf = [{tc_timeout, timer:minutes(5)}|Conf0],
megaco_test_lib:init_per_testcase(Case, Conf);
_ ->
megaco_test_lib:init_per_testcase(Case, Config)
end.
end_per_testcase(Case, Config) ->
progress("end_per_testcase -> ~w", [Case]),
process_flag(trap_exit, false),
megaco_test_lib:end_per_testcase(Case, Config).
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
all() ->
[plain, connect, traffic].
groups() ->
[].
init_per_group(_GroupName, Config) ->
Config.
end_per_group(_GroupName, Config) ->
Config.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
plain(suite) ->
[];
plain(doc) ->
["Test case for the basic statistics counter handling. "];
plain(Config) when is_list(Config) ->
io:format("create test table 1~n", []),
Tab1 = megaco_test_cnt1,
megaco_stats:init(Tab1),
io:format("~ncreate test table 2~n", []),
Tab2 = megaco_test_cnt2,
megaco_stats:init(Tab2, [kalle, hobbe]),
io:format("~ntable 1 increments~n", []),
H1 = #megaco_conn_handle{local_mid = {deviceName, "a"},
remote_mid = {deviceName, "b"}},
H2 = #megaco_conn_handle{local_mid = {deviceName, "a"},
remote_mid = {deviceName, "c"}},
1 = megaco_stats:inc(Tab1, H1, sune),
2 = megaco_stats:inc(Tab1, H2, sune, 2),
3 = megaco_stats:inc(Tab1, H1, gurka, 3),
4 = megaco_stats:inc(Tab1, H2, sune, 2),
4 = megaco_stats:inc(Tab1, H1, gurka),
io:format("~ntable 2 increments~n", []),
H3 = #megaco_conn_handle{local_mid = {deviceName, "e"},
remote_mid = {deviceName, "c"}},
H4 = #megaco_conn_handle{local_mid = {deviceName, "e"},
remote_mid = {deviceName, "d"}},
1 = megaco_stats:inc(Tab2, H3, tomat),
4 = megaco_stats:inc(Tab2, H3, tomat, 3),
5 = megaco_stats:inc(Tab2, H4, paprika, 5),
io:format("~ntable 2 global increments~n", []),
1 = megaco_stats:inc(Tab2, kalle),
1 = megaco_stats:inc(Tab2, hobbe),
2 = megaco_stats:inc(Tab2, hobbe),
2 = megaco_stats:inc(Tab2, kalle),
3 = megaco_stats:inc(Tab2, kalle),
4 = megaco_stats:inc(Tab2, hobbe, 2),
io:format("~ntable 1 stats~n", []),
{ok, Stats1} = megaco_stats:get_stats(Tab1),
io:format("Stats1 = ~p~n", [Stats1]),
{value, {H1, H1Stats}} = lists:keysearch(H1, 1, Stats1),
Stats1_2 = lists:keydelete(H1, 1, Stats1),
{value, {H2, H2Stats}} = lists:keysearch(H2, 1, Stats1_2),
Stats1_3 = lists:keydelete(H2, 1, Stats1_2),
[] = Stats1_3,
io:format("H1Stats = ~p~n", [H1Stats]),
io:format("H2Stats = ~p~n", [H2Stats]),
{value, {sune, 1}} = lists:keysearch(sune, 1, H1Stats),
H1Stats_2 = lists:keydelete(sune, 1, H1Stats),
{value, {gurka, 4}} = lists:keysearch(gurka, 1, H1Stats_2),
H1Stats_3 = lists:keydelete(gurka, 1, H1Stats_2),
[] = H1Stats_3,
{value, {sune, 4}} = lists:keysearch(sune, 1, H2Stats),
H2Stats_2 = lists:keydelete(sune, 1, H2Stats),
[] = H2Stats_2,
%% --
io:format("~ntable 2 stats~n", []),
{ok, Stats2} = megaco_stats:get_stats(Tab2),
io:format("Stats2 = ~p~n", [Stats2]),
{ok, 3} = megaco_stats:get_stats(Tab2, kalle),
{ok, 4} = megaco_stats:get_stats(Tab2, hobbe),
%% --
io:format("~ntable 1 reset stats for ~p~n", [H1]),
megaco_stats:reset_stats(Tab1, H1),
{ok, Stats1_4} = megaco_stats:get_stats(Tab1),
io:format("Stats1_4 = ~p~n", [Stats1_4]),
{ok, 0} = megaco_stats:get_stats(Tab1, H1, sune),
{ok, 0} = megaco_stats:get_stats(Tab1, H1, gurka),
%% --
io:format("~ntable 2 reset stats for kalle and ~p~n", [H4]),
megaco_stats:reset_stats(Tab2, kalle),
megaco_stats:reset_stats(Tab2, H4),
{ok, Stats2_2} = megaco_stats:get_stats(Tab2),
io:format("Stats2_2 = ~p~n", [Stats2_2]),
{ok, 0} = megaco_stats:get_stats(Tab2, kalle),
{ok, 4} = megaco_stats:get_stats(Tab2, hobbe),
{ok, 4} = megaco_stats:get_stats(Tab2, H3, tomat),
{ok, 0} = megaco_stats:get_stats(Tab2, H4, paprika),
{ok, Stats4_4} = megaco_stats:get_stats(Tab2, H4),
io:format("Stats4_4 = ~p~n", [Stats4_4]),
%% --
io:format("~ntable 2 stats for nonexisting counters~n", []),
{error, _} = megaco_stats:get_stats(Tab2, kalla),
{error, _} = megaco_stats:get_stats(Tab2, H3, paprika),
ok.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
connect(suite) ->
[];
connect(doc) ->
[];
connect(Config) when is_list(Config) ->
put(verbosity, ?TEST_VERBOSITY),
put(sname, "TEST"),
i("connect -> starting"),
progress("start nodes"),
MgcNode = make_node_name(mgc),
Mg1Node = make_node_name(mg1),
Mg2Node = make_node_name(mg2),
d("connect -> Nodes: "
"~n MgcNode: ~p"
"~n Mg1Node: ~p"
"~n Mg2Node: ~p", [MgcNode, Mg1Node, Mg2Node]),
ok = megaco_test_lib:start_nodes([MgcNode, Mg1Node, Mg2Node],
?FILE, ?LINE),
%% Start the MGC and MGs
ET = [{text,tcp}, {text,udp}, {binary,tcp}, {binary,udp}],
progress("start MGC"),
{ok, Mgc} =
start_mgc(MgcNode, {deviceName, "ctrl"}, ET, ?MGC_VERBOSITY),
progress("start MG1"),
{ok, Mg1} =
start_mg(Mg1Node, {deviceName, "mg1"}, text, tcp, ?MG_VERBOSITY),
progress("start MG2"),
{ok, Mg2} =
start_mg(Mg2Node, {deviceName, "mg2"}, binary, udp, ?MG_VERBOSITY),
%% Collect the initial statistics (should be zero if anything)
progress("collect initial MG1 stats"),
{ok, Mg1Stats0} = get_stats(Mg1, 1),
d("connect -> stats for Mg1: ~n~p", [Mg1Stats0]),
progress("collect initial MG2 stats"),
{ok, Mg2Stats0} = get_stats(Mg2, 1),
d("connect -> stats for Mg2: ~n~p", [Mg2Stats0]),
progress("collect initial MGC stats"),
{ok, MgcStats0} = get_stats(Mgc, 1),
d("connect -> stats for Mgc: ~n~p", [MgcStats0]),
%% Ask Mg1 to do a service change
progress("perform MG1 service change"),
{ok, Res1} = service_change(Mg1),
d("connect -> (Mg1) service change result: ~p", [Res1]),
%% Collect the statistics
progress("collect MG1 statistics (after service change)"),
{ok, Mg1Stats1} = get_stats(Mg1, 1),
d("connect -> stats for Mg1: ~n~p", [Mg1Stats1]),
progress("collect MGC statistics (after MG1 service change)"),
{ok, MgcStats1} = get_stats(Mgc, 1),
d("connect -> stats (1) for Mgc: ~n~p", [MgcStats1]),
{ok, MgcStats2} = get_stats(Mgc, 2),
d("connect -> stats (2) for Mgc: ~n~p", [MgcStats2]),
%% Ask Mg2 to do a service change
progress("perform MG2 service change"),
{ok, Res2} = service_change(Mg2),
d("connect -> (Mg2) service change result: ~p", [Res2]),
%% Collect the statistics
progress("collect MG2 statistics (after service change)"),
{ok, Mg2Stats1} = get_stats(Mg2, 1),
d("connect -> stats for Mg1: ~n~p", [Mg2Stats1]),
progress("collect MGC statistics (after MG2 service change)"),
{ok, MgcStats3} = get_stats(Mgc, 1),
d("connect -> stats (1) for Mgc: ~n~p", [MgcStats3]),
{ok, MgcStats4} = get_stats(Mgc, 2),
d("connect -> stats (2) for Mgc: ~n~p", [MgcStats4]),
%% Tell Mg1 to stop
progress("stop MG1"),
stop(Mg1),
%% Collect the statistics
progress("collect MGC statistics (after MG1 stop)"),
{ok, MgcStats5} = get_stats(Mgc, 1),
d("connect -> stats (1) for Mgc: ~n~p", [MgcStats5]),
{ok, MgcStats6} = get_stats(Mgc, 2),
d("connect -> stats (2) for Mgc: ~n~p", [MgcStats6]),
%% Tell Mg2 to stop
progress("stop MG2"),
stop(Mg2),
%% Collect the statistics
progress("collect MGC statistics (after MG2 stop)"),
{ok, MgcStats7} = get_stats(Mgc, 1),
d("connect -> stats (1) for Mgc: ~n~p", [MgcStats7]),
{ok, MgcStats8} = get_stats(Mgc, 2),
d("connect -> stats (2) for Mgc: ~n~p", [MgcStats8]),
%% Tell Mgc to stop
progress("stop MGC"),
stop(Mgc),
i("connect -> done", []),
progress("done"),
ok.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
traffic(suite) ->
[];
traffic(doc) ->
[];
traffic(Config) when is_list(Config) ->
put(verbosity, ?TEST_VERBOSITY),
put(sname, "TEST"),
i("traffic -> starting"),
progress("start nodes"),
MgcNode = make_node_name(mgc),
Mg1Node = make_node_name(mg1),
Mg2Node = make_node_name(mg2),
Mg3Node = make_node_name(mg3),
Mg4Node = make_node_name(mg4),
d("traffic -> Nodes: "
"~n MgcNode: ~p"
"~n Mg1Node: ~p"
"~n Mg2Node: ~p"
"~n Mg3Node: ~p"
"~n Mg4Node: ~p",
[MgcNode, Mg1Node, Mg2Node, Mg3Node, Mg4Node]),
ok = megaco_test_lib:start_nodes([MgcNode,
Mg1Node, Mg2Node, Mg3Node, Mg4Node],
?FILE, ?LINE),
%% Start the MGC and MGs
i("traffic -> start the MGC"),
progress("start MGC"),
ET = [{text,tcp}, {text,udp}, {binary,tcp}, {binary,udp}],
{ok, Mgc} =
start_mgc(MgcNode, {deviceName, "ctrl"}, ET, ?MGC_VERBOSITY),
i("traffic -> start and connect the MGs"),
progress("start and connect MGs"),
MgConf0 = [{Mg1Node, "mg1", text, tcp},
{Mg2Node, "mg2", text, udp},
{Mg3Node, "mg3", binary, tcp},
{Mg4Node, "mg4", binary, udp}],
MgConf = traffic_connect_mg(MgConf0, []),
%% Collect and check the MGs statistics
i("traffic -> collect and check the MGs stats"),
progress("collect and verify MGs (initial) stats"),
traffic_verify_mg_stats(MgConf, 1, 1),
%% Collect and check the MGC statistics
i("traffic -> collect and check the MGC (initial) stats"),
progress("collect and verify MGC stats"),
{ok, MgcStats1} = get_stats(Mgc, 1),
d("traffic -> stats (1) for Mgc: ~n~p~n", [MgcStats1]),
traffic_verify_mgc_stats(Mgc, 1, 1),
?SLEEP(1000),
%% And apply some load
i("traffic -> apply traffic load (1)"),
progress("apply some load (1)"),
ok = traffic_apply_load(MgConf),
%% Await completion of load part and the collect traffic
i("traffic -> await load (1) competion"),
progress("await load (1) completion"),
ok = traffic_await_load_complete(MgConf),
?SLEEP(1000),
i("traffic -> collect and check the MGs statistics"),
progress("collect and verify MGs (after load 1) stats"),
traffic_verify_mg_stats(MgConf,
1 + ?LOAD_COUNTER_START,
1 + ?LOAD_COUNTER_START),
i("traffic -> collect and check the MGC statistics"),
progress("collect and verify MGC (after load 1) stats"),
{ok, MgcStats3} = get_stats(Mgc, 1),
d("traffic -> stats (1) for Mgc: ~n~p~n", [MgcStats3]),
traffic_verify_mgc_stats(Mgc,
1 + ?LOAD_COUNTER_START,
1 + ?LOAD_COUNTER_START),
?SLEEP(1000),
%% Reset counters
i("traffic -> reset the MGs statistics"),
progress("reset MGs stats"),
traffic_reset_mg_stats(MgConf),
i("traffic -> collect and check the MGs statistics"),
progress("collect and verify MGs (after reset) stats"),
traffic_verify_mg_stats(MgConf, 0, 0),
i("traffic -> reset the MGC statistics"),
progress("reset MGC stats"),
traffic_reset_mgc_stats(Mgc),
i("traffic -> collect and check the MGC statistics"),
progress("collect and verify MGC (after reset) stats"),
traffic_verify_mgc_stats(Mgc, 0, 0),
?SLEEP(1000),
%% And apply some load
i("traffic -> apply traffic load (2)"),
progress("apply some load (2)"),
ok = traffic_apply_load(MgConf),
%% Await completion of load part and the collect traffic
i("traffic -> await load (2) competion"),
progress("await load (2) completion"),
ok = traffic_await_load_complete(MgConf),
?SLEEP(1000),
i("traffic -> collect and check the MGs statistics"),
progress("collect and verify MGs (after load 2) stats"),
traffic_verify_mg_stats(MgConf,
?LOAD_COUNTER_START,
?LOAD_COUNTER_START),
i("traffic -> collect and check the MGC statistics"),
progress("collect and verify MGC (after load 2) stats"),
traffic_verify_mgc_stats(Mgc,
?LOAD_COUNTER_START,
?LOAD_COUNTER_START),
?SLEEP(1000),
%% Tell MGs to stop
i("traffic -> stop the MGs"),
progress("stop MGs"),
traffic_stop_mg(MgConf),
?SLEEP(1000),
%% Collect the statistics
i("traffic -> collect the MGC statistics"),
progress("collect and verify MGC (after MGs stop) stats"),
{ok, MgcStats7} = get_stats(Mgc, 1),
d("traffic -> stats (1) for Mgc: ~n~p~n", [MgcStats7]),
{ok, MgcStats8} = get_stats(Mgc, 2),
d("traffic -> stats (2) for Mgc: ~n~p~n", [MgcStats8]),
%% Tell Mgc to stop
i("traffic -> stop the MGC"),
progress("stop MGC"),
stop(Mgc),
i("traffic -> done", []),
progress("done"),
ok.
traffic_verify_mgc_stats(Pid, Out, In)
when is_pid(Pid) andalso is_integer(Out) andalso is_integer(In) ->
d("traffic_verify_mgc_stats -> entry with"
"~n Out: ~p"
"~n In: ~p", [Out, In]),
{ok, Stats} = get_stats(Pid, 2),
d("traffic_verify_mgc_stats -> stats (2) for Mgc: ~n~p~n", [Stats]),
traffic_verify_mgc_stats(Stats, Out, In);
traffic_verify_mgc_stats(Stats, Out, In) when is_list(Stats) ->
d("traffic_verify_mgc_stats -> checking stats"),
Gen = traffic_verify_get_stats(gen, Stats),
Trans = traffic_verify_get_stats(trans, Stats),
traffic_verify_mgc_stats_gen(Gen),
traffic_verify_mgc_stats_trans(Trans, Out, In).
traffic_verify_mgc_stats_gen([]) ->
d("traffic_verify_mgc_stats_gen -> done"),
ok;
traffic_verify_mgc_stats_gen([{medGwyGatewayNumErrors, 0}|Stats]) ->
traffic_verify_mgc_stats_gen(Stats);
traffic_verify_mgc_stats_gen([{medGwyGatewayNumErrors, Val}|_]) ->
exit({global_error_counter, Val, mgc});
traffic_verify_mgc_stats_gen([{Handle, Counters}|Stats]) ->
N = {mgc, Handle, Handle},
traffic_verify_counter(N, medGwyGatewayNumErrors, Counters, 0),
traffic_verify_mgc_stats_gen(Stats).
traffic_verify_mgc_stats_trans([], _Out, _In) ->
ok;
traffic_verify_mgc_stats_trans([{Mod, Stats}|MgcStats], Out, In) ->
d("traffic_verify_mgc_stats_trans -> entry with"
"~n Mod: ~p"
"~n Stats: ~p", [Mod, Stats]),
traffic_verify_mgc_stats_trans(Mod, Stats, Out, In),
traffic_verify_mgc_stats_trans(MgcStats, Out, In).
traffic_verify_mgc_stats_trans(_Mod, [], _Out, _In) ->
ok;
traffic_verify_mgc_stats_trans(Mod, [{Handle,Counters}|Stats], Out, In) ->
N = {mgc, Mod, Handle},
traffic_verify_counter(N, medGwyGatewayNumErrors, Counters, 0),
traffic_verify_counter(N, medGwyGatewayNumOutMessages, Counters, Out),
traffic_verify_counter(N, medGwyGatewayNumInMessages, Counters, In),
traffic_verify_mgc_stats_trans(Mod, Stats, Out, In).
traffic_verify_mg_stats(MgConf, Out, In)
when is_integer(Out) andalso is_integer(In) ->
d("traffic_verify_mg_stats -> entry with"
"~n Out: ~p"
"~n In: ~p", [Out, In]),
Stats = traffic_get_mg_stats(MgConf, []),
d("traffic_verify_mg_stats -> stats for MGs: ~n~p", [Stats]),
traffic_verify_mg_stats1(Stats, Out, In).
traffic_verify_mg_stats1([], _, _) ->
ok;
traffic_verify_mg_stats1([{Name, Stats}|MgStats], Out, In) ->
d("traffic_verify_mg_stats1 -> entry with"
"~n Name: ~s"
"~n Stats: ~p", [Name, Stats]),
Gen = traffic_verify_get_stats(gen, Stats),
Trans = traffic_verify_get_stats(trans, Stats),
traffic_verify_mg_stats_gen(Name, Gen),
traffic_verify_mg_stats_trans(Name, Trans, Out, In),
traffic_verify_mg_stats1(MgStats, Out, In).
traffic_verify_mg_stats_gen(Mg, []) ->
d("traffic_verify_mg_stats_gen -> ~s checked out OK",[Mg]),
ok;
traffic_verify_mg_stats_gen(Mg, [{medGwyGatewayNumErrors, 0}|Stats]) ->
traffic_verify_mg_stats_gen(Mg, Stats);
traffic_verify_mg_stats_gen(Mg, [{medGwyGatewayNumErrors, Val}|_]) ->
exit({global_error_counter, Val, Mg});
traffic_verify_mg_stats_gen(Mg, [{_Handle, Counters}|Stats]) ->
traffic_verify_counter(Mg, medGwyGatewayNumErrors, Counters, 0),
traffic_verify_mg_stats_gen(Mg, Stats).
traffic_verify_mg_stats_trans(Mg, Counters, Out, In) ->
traffic_verify_counter(Mg, medGwyGatewayNumErrors, Counters, 0),
traffic_verify_counter(Mg, medGwyGatewayNumOutMessages, Counters, Out),
traffic_verify_counter(Mg, medGwyGatewayNumInMessages, Counters, In).
traffic_verify_get_stats(S, Stats) ->
case lists:keysearch(S, 1, Stats) of
{value, {S, Val}} ->
Val;
false ->
exit({not_found, S, Stats})
end.
traffic_verify_counter(Name, Counter, Counters, Expected) ->
case lists:keysearch(Counter, 1, Counters) of
{value, {Counter, Expected}} ->
i("counter ~w verified for ~p", [Counter, Name]),
ok;
{value, {Counter, Val}} ->
i("counter ~w *not* verified for ~p: "
"~n Expected: ~w"
"~n Actual: ~w", [Counter, Name, Expected, Val]),
exit({illegal_counter_value, Counter, Val, Expected, Name});
false ->
i("counter ~w *not* found for ~p", [Counter, Name]),
exit({not_found, Counter, Counters, Name, Expected})
end.
traffic_connect_mg([], Acc) ->
lists:reverse(Acc);
traffic_connect_mg([{Node, Name, Coding, Trans}|Mg], Acc) ->
Pid = traffic_connect_mg(Node, Name, Coding, Trans),
traffic_connect_mg(Mg, [{Name, Pid}|Acc]).
traffic_connect_mg(Node, Name, Coding, Trans) ->
Mid = {deviceName, Name},
{ok, Pid} = start_mg(Node, Mid, Coding, Trans, ?MG_VERBOSITY),
%% Ask the MGs to do a service change
{ok, Res} = service_change(Pid),
d("traffic_connect_mg -> (~s) service change result: ~p", [Name, Res]),
Pid.
traffic_stop_mg(MGs) ->
[stop(Pid) || {_Name, Pid} <- MGs].
traffic_get_mg_stats([], Acc) ->
lists:reverse(Acc);
traffic_get_mg_stats([{Name, Pid}|Mgs], Acc) ->
{ok, Stats} = get_stats(Pid, 1),
d("traffic_get_mg_stats -> stats for ~s: "
"~n ~p"
"~n", [Name, Stats]),
traffic_get_mg_stats(Mgs, [{Name, Stats}|Acc]).
traffic_apply_load([]) ->
ok;
traffic_apply_load([{_,MG}|MGs]) ->
MG ! {apply_load, self(), ?LOAD_COUNTER_START},
receive
{apply_load_ack, MG} ->
traffic_apply_load(MGs);
{'EXIT', MG, Reason} ->
exit({mg_exit, MG, Reason})
after 10000 ->
exit({apply_load_ack_timeout, MG})
end.
traffic_reset_mg_stats([]) ->
ok;
traffic_reset_mg_stats([{Name, Pid}|MGs]) ->
d("traffic_reset_mg_stats -> resetting ~s", [Name]),
traffic_reset_stats(Pid),
traffic_reset_mg_stats(MGs).
traffic_reset_mgc_stats(Mgc) ->
d("traffic_reset_mgc_stats -> resetting ~p", [Mgc]),
traffic_reset_stats(Mgc).
traffic_reset_stats(Pid) ->
Pid ! {reset_stats, self()},
receive
{reset_stats_ack, Pid} ->
ok;
{'EXIT', Pid, Reason} ->
exit({client_exit, Pid, Reason})
after 10000 ->
exit({reset_stats_ack_timeout, Pid})
end.
traffic_await_load_complete([]) ->
ok;
traffic_await_load_complete(MGs0) ->
receive
{load_complete, Pid} ->
d("received load_complete from ~p", [Pid]),
MGs1 = lists:keydelete(Pid, 2, MGs0),
traffic_await_load_complete(lists:delete(Pid, MGs1));
{'EXIT', Pid, Reason} ->
i("exit signal from ~p: ~p", [Pid, Reason]),
case lists:keymember(Pid, 2, MGs0) of
true ->
exit({mg_exit, Pid, Reason});
false ->
MGs1 = lists:keydelete(Pid, 2, MGs0),
traffic_await_load_complete(lists:delete(Pid, MGs1))
end
end.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
make_node_name(Name) ->
case string:tokens(atom_to_list(node()), [$@]) of
[_,Host] ->
list_to_atom(lists:concat([atom_to_list(Name) ++ "@" ++ Host]));
_ ->
exit("Test node must be started with '-sname'")
end.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
start_mgc(Node, Mid, ET, Verbosity) ->
d("start mgc[~p]: ~p", [Node, Mid]),
RI = {receive_info, mk_recv_info(ET)},
Config = [{local_mid, Mid}, RI],
Pid = spawn_link(Node, ?MODULE, mgc, [self(), Verbosity, Config]),
await_started(Pid).
mk_recv_info(ET) ->
mk_recv_info(ET, []).
mk_recv_info([], Acc) ->
Acc;
mk_recv_info([{text,tcp}|ET], Acc) ->
RI = [{encoding_module, megaco_pretty_text_encoder},
{encoding_config, []},
{transport_module, megaco_tcp},
{port, 2944}],
mk_recv_info(ET, [RI|Acc]);
mk_recv_info([{text,udp}|ET], Acc) ->
RI = [{encoding_module, megaco_pretty_text_encoder},
{encoding_config, []},
{transport_module, megaco_udp},
{port, 2944}],
mk_recv_info(ET, [RI|Acc]);
mk_recv_info([{binary,tcp}|ET], Acc) ->
RI = [{encoding_module, megaco_ber_encoder},
{encoding_config, []},
{transport_module, megaco_tcp},
{port, 2945}],
mk_recv_info(ET, [RI|Acc]);
mk_recv_info([{binary,udp}|ET], Acc) ->
RI = [{encoding_module, megaco_ber_encoder},
{encoding_config, []},
{transport_module, megaco_udp},
{port, 2945}],
mk_recv_info(ET, [RI|Acc]);
mk_recv_info([ET|_], _) ->
throw({error, {invaalid_encoding_transport, ET}}).
mgc(Parent, Verbosity, Config) ->
process_flag(trap_exit, true),
put(verbosity, Verbosity),
put(sname, "MGC"),
i("mgc -> starting"),
{Mid, TcpSup, UdpSup} = mgc_init(Config),
notify_started(Parent),
S = #mgc{parent = Parent,
tcp_sup = TcpSup, udp_sup = UdpSup, mid = Mid},
i("mgc -> started"),
mgc_loop(S).
mgc_init(Config) ->
d("mgc_init -> entry"),
Mid = get_conf(local_mid, Config),
RI = get_conf(receive_info, Config),
i("mgc_init -> start megaco"),
application:start(megaco),
d("mgc_init -> start megaco user"),
megaco:start_user(Mid, []),
d("mgc_init -> update user info (user_mod)"),
megaco:update_user_info(Mid, user_mod, ?MODULE),
d("mgc_init -> update user info (user_args)"),
megaco:update_user_info(Mid, user_args, [self()]),
d("mgc_init -> get user info (receive_handle)"),
RH = megaco:user_info(Mid,receive_handle),
d("mgc_init -> parse receive info"),
ListenTo = mgc_parse_receive_info(RI, RH),
i("mgc_init -> start transport(s)"),
{Tcp, Udp} = mgc_start_transports(ListenTo),
{Mid, Tcp, Udp}.
mgc_loop(S) ->
d("mgc_loop -> await request"),
receive
{stop, Parent} when S#mgc.parent == Parent ->
i("mgc_loop -> stopping", []),
Mid = S#mgc.mid,
(catch mgc_close_conns(Mid)),
megaco:stop_user(Mid),
application:stop(megaco),
i("mgc_loop -> stopped", []),
Parent ! {stopped, self()},
exit(normal);
%% Reset stats
{reset_stats, Parent} when S#mgc.parent == Parent ->
i("mgc_loop -> got request to reset stats counters"),
mgc_reset_stats(S#mgc.mid),
Parent ! {reset_stats_ack, self()},
mgc_loop(S);
%% Give me statistics
{statistics, 1, Parent} when S#mgc.parent == Parent ->
i("mgc_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)),
Parent ! {statistics, 1, [{gen, Gen}, {trans, Trans}], self()},
mgc_loop(S);
{statistics, 2, Parent} when S#mgc.parent == Parent ->
i("mgc_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),
Parent ! {statistics, 2, [{gen, Gen}, {trans, [TcpStats, UdpStats]}], self()},
mgc_loop(S);
%% Megaco callback messages
{request, Request, From} ->
d("mgc_loop -> received megaco request: ~n~p~n From: ~p",
[Request, From]),
Reply = mgc_handle_request(Request),
d("mgc_loop -> send request reply: ~n~p", [Reply]),
From ! {reply, Reply, self()},
mgc_loop(S);
{'EXIT', Pid, Reason} ->
error_msg("MGC received unexpected exit signal from ~p:~n~p",
[Pid, Reason]),
mgc_loop(S);
Invalid ->
i("mgc_loop -> received invalid request: ~p", [Invalid]),
mgc_loop(S)
end.
mgc_reset_stats(Mid) ->
megaco:reset_stats(),
mgc_reset_trans_stats(megaco:user_info(Mid, connections), []).
mgc_reset_trans_stats([], _Reset) ->
ok;
mgc_reset_trans_stats([CH|CHs], Reset) ->
SendMod = megaco:conn_info(CH, send_mod),
case lists:member(SendMod, Reset) of
true ->
mgc_reset_trans_stats(CHs, Reset);
false ->
SendMod:reset_stats(),
mgc_reset_trans_stats(CHs, [SendMod|Reset])
end.
mgc_close_conns(Mid) ->
Reason = {self(), ignore},
Disco = fun(CH) ->
(catch mgc_close_conn(CH, Reason))
end,
lists:map(Disco, megaco:user_info(Mid, connections)).
mgc_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 is_pid(P) ->
case (catch SendMod:get_stats()) of
{ok, Stats} ->
{SendMod, Stats};
Else ->
{SendMod, Else}
end;
get_trans_stats(_P, SendMod) ->
{SendMod, undefined}.
mgc_parse_receive_info([], _RH) ->
throw({error, no_receive_info});
mgc_parse_receive_info(RI, RH) ->
mgc_parse_receive_info(RI, RH, []).
mgc_parse_receive_info([], _RH, ListenTo) ->
ListenTo;
mgc_parse_receive_info([RI|RIs], RH, ListenTo) ->
d("mgc_parse_receive_info -> parse receive info"),
RH1 = mgc_parse_receive_info1(RI, RH),
case (catch mgc_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 ->
mgc_parse_receive_info(RIs, RH, [RH1|ListenTo])
end.
mgc_parse_receive_info1(RI, RH) ->
d("mgc_parse_receive_info1 -> get encoding module"),
EM = get_encoding_module(RI),
d("mgc_parse_receive_info1 -> get encoding config"),
EC = get_encoding_config(RI, EM),
d("mgc_parse_receive_info1 -> get transport module"),
TM = get_transport_module(RI),
d("mgc_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}.
mgc_start_transports([]) ->
throw({error, no_transport});
mgc_start_transports(ListenTo) ->
mgc_start_transports(ListenTo, undefined, undefined).
mgc_start_transports([], TcpSup, UdpSup) ->
{TcpSup, UdpSup};
mgc_start_transports([{Port, RH}|ListenTo], TcpSup, UdpSup)
when RH#megaco_receive_handle.send_mod == megaco_tcp ->
TcpSup1 = mgc_start_tcp(RH, Port, TcpSup),
mgc_start_transports(ListenTo, TcpSup1, UdpSup);
mgc_start_transports([{Port, RH}|ListenTo], TcpSup, UdpSup)
when RH#megaco_receive_handle.send_mod == megaco_udp ->
UdpSup1 = mgc_start_udp(RH, Port, UdpSup),
mgc_start_transports(ListenTo, TcpSup, UdpSup1);
mgc_start_transports([{_Port, RH}|_ListenTo], _TcpSup, _UdpSup) ->
throw({error, {bad_send_mod, RH#megaco_receive_handle.send_mod}}).
mgc_start_tcp(RH, Port, undefined) ->
i("start tcp transport"),
case megaco_tcp:start_transport() of
{ok, Sup} ->
mgc_start_tcp(RH, Port, Sup);
Else ->
throw({error, {failed_starting_tcp_transport, Else}})
end;
mgc_start_tcp(RH, Port, Sup) when is_pid(Sup) ->
i("tcp listen on ~p", [Port]),
Opts = [{port, Port},
{receive_handle, RH},
{tcp_options, [{nodelay, true}]}],
mgc_tcp_create_listen(Sup, Opts, 3).
mgc_tcp_create_listen(Sup, Opts, N) ->
mgc_tcp_create_listen(Sup, Opts, N, 1, undefined).
mgc_tcp_create_listen(_Sup, _Opts, N, N, InitialReason) ->
d("failed creating mgc tcp listen socket after ~p tries: ~p",
[N, InitialReason]),
throw({error, {failed_starting_tcp_listen, InitialReason}});
mgc_tcp_create_listen(Sup, Opts, MaxN, N, _InitialReason)
when is_integer(N) andalso is_integer(MaxN) andalso (MaxN > N) ->
d("try create mgc tcp listen socket [~w]", [N]),
case megaco_tcp:listen(Sup, Opts) of
ok ->
Sup;
{error, {could_not_start_listener, {gen_tcp_listen, eaddrinuse} = Reason}} ->
?SLEEP(N * 200),
mgc_tcp_create_listen(Sup, Opts, MaxN, N + 1, Reason);
{error, Reason} ->
throw({error, {failed_starting_tcp_listen, Reason}});
Else ->
throw({error, {failed_starting_tcp_listen, Else}})
end.
mgc_start_udp(RH, Port, undefined) ->
i("start udp transport"),
case megaco_udp:start_transport() of
{ok, Sup} ->
mgc_start_udp(RH, Port, Sup);
Else ->
throw({error, {failed_starting_udp_transport, Else}})
end;
mgc_start_udp(RH, Port, Sup) ->
i("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
%%
mgc_handle_request({handle_connect, _CH, _PV}) ->
ok;
mgc_handle_request({handle_disconnect, CH, _PV, R}) ->
megaco:cancel(CH, R), % Cancel the outstanding messages
ok;
mgc_handle_request({handle_syntax_error, _RH, _PV, _ED}) ->
reply;
mgc_handle_request({handle_message_error, _CH, _PV, _ED}) ->
no_reply;
mgc_handle_request({handle_trans_request, CH, PV, ARs}) ->
ED = #'ErrorDescriptor'{errorCode = ?megaco_not_implemented,
errorText = "Only single service change on null context handled"},
case ARs of
[AR] ->
ContextId = AR#'ActionRequest'.contextId,
case AR#'ActionRequest'.commandRequests of
[CR] when ContextId == ?megaco_null_context_id ->
case CR#'CommandRequest'.command of
{serviceChangeReq, Req} ->
Rep = mgc_service_change(CH, PV, Req),
CmdRep = [{serviceChangeReply, Rep}],
{discard_ack,
[#'ActionReply'{contextId = ContextId,
commandReply = CmdRep}]};
_ ->
{discard_ack, ED}
end;
_ ->
{discard_ack, ED}
end;
_ ->
{discard_ack, ED}
end;
mgc_handle_request({handle_trans_long_request, _CH, _PV, _RD}) ->
ED = #'ErrorDescriptor'{errorCode = ?megaco_not_implemented,
errorText = "Long transaction requests not handled"},
{discard_ack, ED};
mgc_handle_request({handle_trans_reply, _CH, _PV, _AR, _RD}) ->
ok;
mgc_handle_request({handle_trans_ack, _CH, _PV, _AS, _AD}) ->
ok.
mgc_service_change(CH, _PV, SCR) ->
SCP = SCR#'ServiceChangeRequest'.serviceChangeParms,
#'ServiceChangeParm'{serviceChangeAddress = Address,
serviceChangeProfile = Profile,
serviceChangeReason = [_Reason]} = SCP,
TermId = SCR#'ServiceChangeRequest'.terminationID,
if
TermId == [?megaco_root_termination_id] ->
MyMid = CH#megaco_conn_handle.local_mid,
Res = {serviceChangeResParms,
#'ServiceChangeResParm'{serviceChangeMgcId = MyMid,
serviceChangeAddress = Address,
serviceChangeProfile = Profile}},
#'ServiceChangeReply'{terminationID = TermId,
serviceChangeResult = Res};
true ->
Res = {errorDescriptor,
#'ErrorDescriptor'{errorCode = ?megaco_not_implemented,
errorText = "Only handled for root"}},
#'ServiceChangeReply'{terminationID = TermId,
serviceChangeResult = Res}
end.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
start_mg(Node, Mid, Encoding, Transport, Verbosity) ->
d("start mg[~p]: ~p", [Node, Mid]),
RI1 =
case Encoding of
text ->
[{encoding_module, megaco_pretty_text_encoder},
{encoding_config, []},
{port,2944}];
binary ->
[{encoding_module, megaco_ber_encoder},
{encoding_config, []},
{port,2945}]
end,
RI2 =
case Transport of
tcp ->
[{transport_module, megaco_tcp}];
udp ->
[{transport_module, megaco_udp}]
end,
RI = {receive_info, RI1 ++ RI2},
Config = [{local_mid, Mid}, RI],
Pid = spawn_link(Node, ?MODULE, mg, [self(), Verbosity, Config]),
await_started(Pid).
mg(Parent, Verbosity, Config) ->
process_flag(trap_exit, true),
put(verbosity, Verbosity),
put(sname, "MG"),
i("mg -> starting"),
{Mid, ConnHandle} = mg_init(Config),
notify_started(Parent),
S = #mg{parent = Parent, mid = Mid, conn_handle = ConnHandle},
i("mg -> started"),
mg_loop(S).
mg_init(Config) ->
d("mg_init -> entry"),
Mid = get_conf(local_mid, Config),
RI = get_conf(receive_info, Config),
i("mg_init -> start megaco"),
application:start(megaco),
d("mg_init -> start megaco user"),
megaco:start_user(Mid, []),
d("mg_init -> update user info (user_mod)"),
megaco:update_user_info(Mid, user_mod, ?MODULE),
d("mg_init -> update user info (user_args)"),
megaco:update_user_info(Mid, user_args, [self()]),
d("mg_init -> get user info (receive_handle)"),
RH = megaco:user_info(Mid,receive_handle),
d("mg_init -> parse receive info"),
{MgcPort,RH1} = mg_parse_receive_info(RI, RH),
i("mg_init -> start transport(s)"),
ConnHandle = mg_start_transport(MgcPort, RH1),
{Mid, ConnHandle}.
mg_loop(#mg{state = State} = S) ->
d("mg_loop(~p) -> await request", [State]),
receive
{stop, Parent} when S#mg.parent == Parent ->
i("mg_loop(~p) -> stopping", [State]),
mg_close_conn(S#mg.conn_handle),
megaco:stop_user(S#mg.mid),
application:stop(megaco),
i("mg_loop(~p) -> stopped", [State]),
Parent ! {stopped, self()},
exit(normal);
{reset_stats, Parent} when S#mg.parent == Parent ->
i("mg_loop(~p) -> got request to reset stats counters", [State]),
%% mg_reset_stats(S#mgc.conn_handle),
mg_reset_stats(S#mg.conn_handle),
Parent ! {reset_stats_ack, self()},
mg_loop(S);
%% Give me statistics
{statistics, 1, Parent} when S#mg.parent == Parent ->
i("mg_loop(~p) -> got request for statistics 1", [State]),
{ok, Gen} = megaco:get_stats(),
CH = S#mg.conn_handle,
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, Trans} =
case SendMod of
megaco_tcp -> megaco_tcp:get_stats(SendHandle);
megaco_udp -> megaco_udp:get_stats(SendHandle);
SendMod -> exit(Pid, Reason)
end,
Parent ! {statistics, 1, [{gen, Gen}, {trans, Trans}], self()},
mg_loop(S);
%% Do a service change
{service_change, Parent} when S#mg.parent == Parent,
State == initiated ->
i("mg_loop(~p) -> received request to perform service change",
[State]),
Res = mg_service_change(S#mg.conn_handle),
d("mg_loop(~p) -> result: ~p", [State, Res]),
mg_loop(S#mg{state = connecting});
%% Apply some load
{apply_load, Parent, Times} when S#mg.parent == Parent ->
i("mg_loop(~p) -> received apply_load request", [State]),
apply_load_timer(),
Parent ! {apply_load_ack, self()},
mg_loop(S#mg{load_counter = Times - 1});
apply_load_timeout ->
d("mg_loop(~p) -> received apply_load timeout [~p]",
[State, S#mg.load_counter]),
mg_apply_load(S),
mg_loop(S);
%% Megaco callback messages
{request, Request, From} ->
d("mg_loop(~p) -> received megaco request: ~n~p~n From: ~p",
[State, Request, From]),
{Reply, NewS} = mg_handle_request(Request, S),
d("mg_loop(~p) -> send request reply: ~n~p",
[NewS#mg.state, Reply]),
From ! {reply, Reply, self()},
mg_loop(NewS);
{'EXIT', Pid, Reason} ->
error_msg("MG ~p received unexpected exit signal from ~p:~n~p",
[S#mg.mid, Pid, Reason]),
mg_loop(S);
Invalid ->
i("mg_loop(~p) -> received invalid request: ~p", [State, Invalid]),
mg_loop(S)
end.
mg_reset_stats(CH) ->
megaco:reset_stats(),
case (catch megaco:conn_info(CH, send_mod)) of
{error, Reason} ->
error_msg("unexpected result when retrieving send module for "
"own connection ~p: ~p. "
"~nexiting...", [CH, Reason]),
exit({invalid_connection, CH, Reason});
{'EXIT', Reason} ->
error_msg("exit signal when retrieving send module for "
"own connection ~p: ~p. "
"~nexiting...", [CH, Reason]),
exit({invalid_connection, CH, Reason});
SendMod when is_atom(SendMod) ->
SendMod:reset_stats()
end.
mg_close_conn(CH) ->
Reason = {self(), ignore},
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.
mg_parse_receive_info(RI, RH) ->
d("mg_parse_receive_info -> get encoding module"),
EM = get_encoding_module(RI),
d("mg_parse_receive_info -> get encoding config"),
EC = get_encoding_config(RI, EM),
d("mg_parse_receive_info -> get transport module"),
TM = get_transport_module(RI),
d("mg_parse_receive_info -> get transport port"),
TP = get_transport_port(RI),
RH1 = RH#megaco_receive_handle{send_mod = TM,
encoding_mod = EM,
encoding_config = EC},
{TP, RH1}.
mg_start_transport(MgcPort,
#megaco_receive_handle{send_mod = megaco_tcp} = RH) ->
mg_start_tcp(MgcPort,RH);
mg_start_transport(MgcPort,
#megaco_receive_handle{send_mod = megaco_udp} = RH) ->
mg_start_udp(MgcPort,RH);
mg_start_transport(_, #megaco_receive_handle{send_mod = Mod}) ->
throw({error, {bad_send_mod, Mod}}).
mg_start_tcp(MgcPort, RH) ->
i("start tcp transport"),
case megaco_tcp:start_transport() of
{ok, Sup} ->
{ok, LocalHost} = inet:gethostname(),
Opts = [{host, LocalHost},
{port, MgcPort},
{receive_handle, RH},
{tcp_options, [{nodelay, true}]}],
case megaco_tcp:connect(Sup, Opts) of
{ok, SendHandle, ControlPid} ->
PrelMgcMid = preliminary_mid,
{ok, ConnHandle} =
megaco:connect(RH, PrelMgcMid,
SendHandle, ControlPid),
ConnHandle;
{error, Reason} ->
{error, {megaco_tcp_connect, Reason}}
end;
{error, Reason} ->
{error, {megaco_tcp_start_transport, Reason}}
end.
mg_start_udp(MgcPort, RH) ->
i("start udp transport"),
case megaco_udp:start_transport() of
{ok, Sup} ->
%% Some linux (Ubuntu) has "crap" in their /etc/hosts, that
%% causes problem for us in this case (UDP). So we can't use
%% local host. Try instead to "figure out" tha actual address...
LocalAddr = which_local_addr(),
Opts = [{port, 0}, {receive_handle, RH}],
case megaco_udp:open(Sup, Opts) of
{ok, Handle, ControlPid} ->
MgcMid = preliminary_mid,
SendHandle = megaco_udp:create_send_handle(Handle,
LocalAddr,
MgcPort),
{ok, ConnHandle} =
megaco:connect(RH, MgcMid,
SendHandle, ControlPid),
ConnHandle;
{error, Reason} ->
{error, {megaco_udp_open, Reason}}
end;
{error, Reason} ->
{error, {megaco_udp_start_transport, Reason}}
end.
mg_service_change(ConnHandle) ->
mg_service_change(ConnHandle, restart, ?megaco_cold_boot).
mg_service_change(ConnHandle, Method, Reason) ->
SCP = #'ServiceChangeParm'{serviceChangeMethod = Method,
serviceChangeReason = [Reason]},
TermId = [?megaco_root_termination_id],
SCR = #'ServiceChangeRequest'{terminationID = TermId,
serviceChangeParms = SCP},
CR = #'CommandRequest'{command = {serviceChangeReq, SCR}},
AR = #'ActionRequest'{contextId = ?megaco_null_context_id,
commandRequests = [CR]},
megaco:cast(ConnHandle, [AR], []).
mg_notify_request(CH) ->
TimeStamp = cre_timeNotation("19990729", "22000000"),
Event = cre_observedEvent("al/of",TimeStamp),
Desc = cre_observedEventsDesc(2222,[Event]),
NotifyReq = cre_notifyReq([#megaco_term_id{id = ?A4444}],Desc),
CmdReq = cre_commandReq({notifyReq, NotifyReq}),
ActReq = cre_actionReq(?megaco_null_context_id, [CmdReq]),
megaco:cast(CH, [ActReq], [{reply_data, Desc}]).
mg_apply_load(#mg{conn_handle = CH}) ->
mg_notify_request(CH).
cre_actionReq(Cid, Cmds) ->
#'ActionRequest'{contextId = Cid,
commandRequests = Cmds}.
cre_commandReq(Cmd) ->
#'CommandRequest'{command = Cmd}.
cre_notifyReq(Tid, EvsDesc) ->
#'NotifyRequest'{terminationID = Tid, observedEventsDescriptor = EvsDesc}.
cre_observedEventsDesc(Id, EvList) ->
#'ObservedEventsDescriptor'{requestId = Id, observedEventLst = EvList}.
cre_observedEvent(Name, Not) ->
#'ObservedEvent'{eventName = Name, timeNotation = Not}.
cre_timeNotation(D,T) ->
#'TimeNotation'{date = D, time = T}.
%% -----------------------
%% Handle megaco callbacks
%%
mg_handle_request({handle_connect, CH, _PV},
#mg{state = connecting} = S) ->
{ok, S#mg{conn_handle = CH}};
mg_handle_request({handle_disconnect, CH, _PV, _R}, S) ->
{ok, S#mg{conn_handle = CH}};
mg_handle_request({handle_syntax_error, _RH, _PV, _ED}, S) ->
{reply, S};
mg_handle_request({handle_message_error, CH, _PV, _ED}, S) ->
{no_reply, S#mg{conn_handle = CH}};
mg_handle_request({handle_trans_request, CH, _PV, _AR}, S) ->
ED = #'ErrorDescriptor'{errorCode = ?megaco_not_implemented,
errorText = "Transaction requests not handled"},
{{discard_ack, ED}, S#mg{conn_handle = CH}};
mg_handle_request({handle_trans_long_request, CH, _PV, _RD}, S) ->
ED = #'ErrorDescriptor'{errorCode = ?megaco_not_implemented,
errorText = "Long transaction requests not handled"},
{{discard_ack, ED}, S#mg{conn_handle = CH}};
mg_handle_request({handle_trans_reply, CH, _PV, _AR, _RD},
#mg{parent = Pid, state = connecting} = S) ->
%% Should really check this...
Pid ! {service_change_reply, ok, self()},
{ok, S#mg{conn_handle = CH, state = connected}};
mg_handle_request({handle_trans_reply, _CH, _PV, {error, ED}, RD},
#mg{parent = Pid, load_counter = 0} = S)
when is_record(ED, 'ErrorDescriptor') andalso
is_record(RD, 'ObservedEventsDescriptor') ->
Pid ! {load_complete, self()},
{ok, S};
mg_handle_request({handle_trans_reply, _CH, _PV, {error, ED}, RD},
#mg{load_counter = N} = S)
when is_record(ED, 'ErrorDescriptor') andalso
is_record(RD, 'ObservedEventsDescriptor') ->
apply_load_timer(),
{ok, S#mg{load_counter = N-1}};
mg_handle_request({handle_trans_ack, _CH, _PV, _AS, _AD}, S) ->
{ok, S}.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
await_started(Pid) ->
receive
{started, Pid} ->
d("await_started ~p: ok", [Pid]),
{ok, Pid};
{'EXIT', Pid, Reason} ->
i("await_started ~p: received exit signal: ~p", [Pid, Reason]),
exit({failed_starting, Pid, Reason})
after 10000 ->
i("await_started ~p: timeout", [Pid]),
exit({error, timeout})
end.
stop(Pid) ->
d("stop ~p", [Pid]),
Pid ! {stop, self()},
receive
{stopped, Pid} ->
d("stop -> received stopped from ~p", [Pid]),
ok;
{'EXIT', Pid, Reason} ->
i("stop ~p: received exit signal: ~p", [Pid, Reason]),
exit({failed_stopping, Pid, Reason})
after 10000 ->
exit({error, timeout})
end.
get_stats(Pid, No) ->
d("get_stats ~p", [Pid]),
Pid ! {statistics, No, self()},
receive
{statistics, No, Stats, Pid} ->
{ok, Stats};
{'EXIT', Pid, Reason} ->
i("get_stats ~p: received exit signal: ~p", [Pid, Reason]),
exit({failed_getting_stats, Pid, Reason})
after 10000 ->
exit({error, timeout})
end.
service_change(Pid) ->
d("service_change ~p", [Pid]),
Pid ! {service_change, self()},
receive
{service_change_reply, Res, Pid} ->
{ok, Res};
{'EXIT', Pid, Reason} ->
i("service_change ~p: received exit signal: ~p", [Pid, Reason]),
exit({failed_service_change, Pid, Reason})
after 10000 ->
exit({error, timeout})
end.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
notify_started(Parent) ->
Parent ! {started, self()}.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% The megaco user callback interface
handle_connect(CH, PV, Pid) ->
% i("handle_connect -> entry with"
% "~n CH: ~p"
% "~n PV: ~p"
% "~n Pid: ~p", [CH, PV, Pid]),
case CH#megaco_conn_handle.remote_mid of
preliminary_mid ->
%% Avoids deadlock
ok;
_ ->
Reply = request(Pid, {handle_connect, CH, PV}),
% d("handle_connect -> Reply:~n~p", [Reply]),
Reply
end.
handle_disconnect(_CH, _PV,
{user_disconnect, {Pid, ignore}},
Pid) ->
% i("handle_disconnect(ignore) -> entry with"
% "~n CH: ~p"
% "~n PV: ~p", [CH, PV]),
%% Avoids deadlock
ok;
handle_disconnect(CH, PV, R, Pid) ->
% i("handle_disconnect -> entry with"
% "~n CH: ~p"
% "~n PV: ~p"
% "~n R: ~p", [CH, PV, R]),
request(Pid, {handle_disconnect, CH, PV, R}).
handle_syntax_error(ReceiveHandle, ProtocolVersion, ErrorDescriptor, Pid) ->
% i("handle_syntax_error -> entry with"
% "~n ReceiveHandle: ~p"
% "~n ProtocolVersion: ~p"
% "~n ErrorDescriptor: ~p",
% [ReceiveHandle, ProtocolVersion, ErrorDescriptor]),
Req = {handle_syntax_error, ReceiveHandle, ProtocolVersion,
ErrorDescriptor},
request(Pid, Req).
handle_message_error(ConnHandle, ProtocolVersion, ErrorDescriptor, Pid) ->
% i("handle_message_error -> entry with"
% "~n ConnHandle: ~p"
% "~n ProtocolVersion: ~p"
% "~n ErrorDescriptor: ~p",
% [ConnHandle, ProtocolVersion, ErrorDescriptor]),
Req = {handle_message_error, ConnHandle, ProtocolVersion, ErrorDescriptor},
request(Pid, Req).
handle_trans_request(CH, PV, AR, Pid) ->
% i("handle_trans_request -> entry with"
% "~n CH: ~p"
% "~n PV: ~p"
% "~n AR: ~p"
% "~n Pid: ~p", [CH, PV, AR, Pid]),
Reply = request(Pid, {handle_trans_request, CH, PV, AR}),
% i("handle_trans_request -> Reply:~n~p", [Reply]),
Reply.
handle_trans_long_request(ConnHandle, ProtocolVersion, ReqData, Pid) ->
% i("handle_trans_long_request -> entry with"
% "~n ConnHandle: ~p"
% "~n ProtocolVersion: ~p"
% "~n ReqData: ~p", [ConnHandle, ProtocolVersion, ReqData]),
Req = {handle_trans_long_request, ConnHandle, ProtocolVersion, ReqData},
request(Pid, Req).
handle_trans_reply(ConnHandle, ProtocolVersion, ActualReply, ReplyData, Pid) ->
% i("handle_trans_reply -> entry with"
% "~n ConnHandle: ~p"
% "~n ProtocolVersion: ~p"
% "~n ActualReply: ~p"
% "~n ReplyData: ~p",
% [ConnHandle, ProtocolVersion, ActualReply, ReplyData]),
Req = {handle_trans_reply, ConnHandle, ProtocolVersion,
ActualReply, ReplyData},
request(Pid, Req).
handle_trans_ack(ConnHandle, ProtocolVersion, AckStatus, AckData, Pid) ->
% i("handle_trans_ack -> entry with"
% "~n ConnHandle: ~p"
% "~n ProtocolVersion: ~p"
% "~n AckStatus: ~p"
% "~n AckData: ~p",
% [ConnHandle, ProtocolVersion, AckStatus, AckData]),
Req = {handle_trans_ack, ConnHandle, ProtocolVersion, AckStatus, AckData},
request(Pid, Req).
request(Pid, Request) ->
Pid ! {request, Request, self()},
receive
{reply, Reply, Pid} ->
Reply
end.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
error_msg(F,A) -> error_logger:error_msg(F ++ "~n",A).
get_encoding_module(RI) ->
case (catch get_conf(encoding_module, RI)) of
{error, _} ->
undefined;
Val ->
Val
end.
get_encoding_config(RI, EM) ->
case text_codec(EM) of
true ->
case megaco:system_info(text_config) of
[Conf] when is_list(Conf) ->
Conf;
_ ->
[]
end;
false ->
get_conf(encoding_config, RI)
end.
text_codec(megaco_compact_text_encoder) ->
true;
text_codec(megaco_pretty_text_encoder) ->
true;
text_codec(_) ->
false.
get_transport_module(RI) ->
get_conf(transport_module, RI).
get_transport_port(RI) ->
get_conf(port, RI).
get_conf(Key, Config) ->
case lists:keysearch(Key, 1, Config) of
{value, {Key, Val}} ->
Val;
_ ->
exit({error, {not_found, Key, Config}})
end.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
which_local_addr() ->
case inet:getifaddrs() of
{ok, IFs} ->
which_local_addr(IFs);
{error, Reason} ->
i("Failed get local address: "
"~n ~p", [Reason]),
?SKIP({failed_get_local_addr, Reason})
end.
which_local_addr([]) ->
?SKIP(failed_get_local_addr);
which_local_addr([{"lo" = _IfName, _IfOpts}|IFs]) ->
which_local_addr(IFs);
which_local_addr([{"br-" ++ _ = _IfName, _IfOpts}|IFs]) ->
which_local_addr(IFs);
which_local_addr([{"docker" ++ _ = _IfName, _IfOpts}|IFs]) ->
which_local_addr(IFs);
which_local_addr([{_IfName, IfOpts}|IFs]) ->
case which_local_addr2(IfOpts) of
{ok, Addr} ->
Addr;
error ->
which_local_addr(IFs)
end.
which_local_addr2([]) ->
error;
which_local_addr2([{addr, Addr}|_])
when (size(Addr) =:= 4) andalso (element(1, Addr) =/= 127) ->
{ok, Addr};
which_local_addr2([_|T]) ->
which_local_addr2(T).
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
i(F) ->
i(F, []).
i(F, A) ->
print(info, get(verbosity), "", F, A).
d(F) ->
d(F, []).
d(F, A) ->
print(debug, get(verbosity), "DBG: ", F, A).
printable(_, debug) -> true;
printable(info, info) -> true;
printable(_,_) -> false.
print(Severity, Verbosity, P, F, A) ->
print(printable(Severity,Verbosity), P, F, A).
print(true, P, F, A) ->
io:format("~s~p:~s:~s: " ++ F ++ "~n", [P, self(), get(sname), ?FTS() | A]);
print(_, _, _, _) ->
ok.
progress(F) ->
progress(F, []).
progress(F, A) ->
io:format("~s " ++ F ++ "~n", [?FTS()|A]),
io:format(user, "~s " ++ F ++ "~n", [?FTS()|A]).
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
random() ->
10 * rand:uniform(50).
apply_load_timer() ->
erlang:send_after(random(), self(), apply_load_timeout).
