← Back to branch summary

~rdoering/ubuntu/karmic/erlang/fix-535090

« back to all changes in this revision

Viewing changes to lib/megaco/test/megaco_test_mg.erl

  • Committer: Bazaar Package Importer
  • Author(s): Sergei Golovan
  • Date: 2009-02-15 16:42:52 UTC
  • mfrom: (3.1.2 squeeze)
  • Revision ID: james.westby@ubuntu.com-20090215164252-q5x4rcf8a5pbesb1
Tags: 1:12.b.5-dfsg-2
Upload to unstable after lenny is released.

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/megaco/test/megaco_test_mg.erl
110
110
                        Else
111
111
                end
112
112
        end,
 
113
    true = erlang:monitor_node(Node, true),
113
114
    Pid = spawn_link(Node, Fun),
114
115
    %% Pid = spawn_link(Node, ?MODULE, mg, [self(), Verbosity, Config]),
115
116
    MonRef = (catch erlang:monitor(process, Pid)),
 
117
    NodePing = net_adm:ping(Node), 
 
118
    ProcInfo = (catch proc_info(Pid)), 
116
119
    i("start -> "
117
120
      "~n   self():           ~p"
118
121
      "~n   node():           ~p"
121
124
      "~n   Monitor ref:      ~p"
122
125
      "~n   Process info:     ~p", 
123
126
      [self(), node(), 
124
 
       Node, net_adm:ping(Node), 
 
127
       Node, NodePing, 
125
128
       Pid, 
126
 
       MonRef, (catch proc_info(Pid))]),
127
 
    await_started(MonRef, Pid).
 
129
       MonRef, ProcInfo]),
 
130
    await_started(Node, MonRef, Pid).
128
131
 
129
132
proc_info(Pid) ->
130
133
    rpc:call(node(Pid), erlang, process_info, [Pid]).
131
134
 
132
 
encoding_config({Encoding, EC}) when atom(Encoding), list(EC) ->
 
135
encoding_config({Encoding, EC}) when is_atom(Encoding) andalso is_list(EC) ->
133
136
    {Mod, Port} = select_encoding(Encoding),
134
137
    [{encoding_module, Mod},
135
138
     {encoding_config, EC},
136
139
     {port,            Port}];
137
 
encoding_config(Encoding) when atom(Encoding) ->
 
140
encoding_config(Encoding) when is_atom(Encoding) ->
138
141
    {Mod, Port} = select_encoding(Encoding),
139
142
    [{encoding_module, Mod},
140
143
     {encoding_config, []},
160
163
transport_config(udp) ->
161
164
    [{transport_module, megaco_udp}].
162
165
 
163
 
await_started(MonRef, Pid) ->
 
166
await_started(Node, MonRef, Pid) ->
164
167
    i("await_started -> entry with"
165
168
      "~n   MonRef: ~p"
166
169
      "~n   Pid:    ~p", [MonRef, Pid]),
167
170
    receive
168
171
        {started, Pid} ->
169
 
            d("await_started ~p: "
 
172
            d("await_started ~p - started"
170
173
              "~n   Process info: ~p", [Pid, (catch proc_info(Pid))]),
 
174
            true = erlang:monitor_node(Node, false),        
171
175
            erlang:demonitor(MonRef),
172
176
            {ok, Pid};
173
177
 
 
178
        {nodedown, Node} ->
 
179
            i("await_started ~p - received node down", [Pid]),
 
180
            exit({node_down, Node}); 
 
181
 
174
182
        {'DOWN', MonRef, process, Pid, Info} ->
175
 
            i("await_started ~p: received down signal: ~p", 
 
183
            i("await_started ~p - received down signal: ~p", 
176
184
              [Pid, Info]),
 
185
            true = erlang:monitor_node(Node, false),        
177
186
            exit({failed_starting, Pid, Info});
178
187
 
179
188
        {'EXIT', Pid, Reason} ->
180
 
            i("await_started ~p: received exit signal: ~p", [Pid, Reason]),
 
189
            i("await_started ~p - received exit signal: ~p", [Pid, Reason]),
 
190
            true = erlang:monitor_node(Node, false),        
181
191
            exit({failed_starting, Pid, Reason})
182
192
 
183
 
    after 10000 ->
184
 
            i("await_started ~p: timeout: "
185
 
              "~n~p", [Pid, (catch process_info(Pid))]),
 
193
    %% This timeout was originally 10 secs, but on some debug compiled
 
194
    %% platforms, it was simply not long enough
 
195
    after 20000 ->
 
196
            NodePing = net_adm:ping(Node), 
 
197
            ProcInfo = (catch proc_info(Pid)),
 
198
            FlushQ = megaco_test_lib:flush(), 
 
199
            i("await_started ~p - timeout: "
 
200
              "~n   net_adm:ping(~p):     ~p" 
 
201
              "~n   Process info:         ~p"
 
202
              "~n   Messages in my queue: ~p", 
 
203
              [Pid, Node, NodePing, ProcInfo, FlushQ]),
 
204
            true = erlang:monitor_node(Node, false),        
186
205
            exit({error, timeout})
187
206
    end.
188
207
 
205
224
user_info(Pid) ->
206
225
    server_request(Pid, {user_info, all}, user_info_ack).
207
226
 
208
 
user_info(Pid, Tag) when atom(Tag) ->
 
227
user_info(Pid, Tag) when is_atom(Tag) ->
209
228
    server_request(Pid, {user_info, Tag}, user_info_ack).
210
229
 
211
230
 
216
235
conn_info(Pid) ->
217
236
    server_request(Pid, {conn_info, all}, conn_info_ack).
218
237
 
219
 
conn_info(Pid, Tag) when atom(Tag) ->
 
238
conn_info(Pid, Tag) when is_atom(Tag) ->
220
239
    server_request(Pid, {conn_info, Tag}, conn_info_ack).
221
240
 
222
241
 
225
244
 
226
245
 
227
246
enable_test_code(Pid, Module, Where, Fun) 
228
 
  when atom(Module), atom(Where), function(Fun) ->
 
247
  when is_atom(Module) andalso is_atom(Where) andalso is_function(Fun) ->
229
248
    Tag = {Module, Where},
230
249
    server_request(Pid, {enable_test_code, Tag, Fun}, enable_test_code_reply).
231
250
 
232
 
encode_ar_first(Pid, New) when atom(New) ->
 
251
encode_ar_first(Pid, New) when is_atom(New) ->
233
252
    server_request(Pid, {encode_ar_first, New}, encode_ar_first_reply).
234
253
 
235
254
service_change(Pid) ->
303
322
 
304
323
mg(Parent, Verbosity, Config) ->
305
324
    process_flag(trap_exit, true),
306
 
    put(verbosity, Verbosity),
307
 
    %% put(verbosity, debug),
308
 
    put(sname,   "MG"),
 
325
    put(sname, "MG"),
 
326
    %% put(verbosity, Verbosity),
 
327
    put(verbosity, debug),  % Enable debug printouts during init
309
328
    i("mg -> starting"),
310
329
    %% megaco:enable_trace(max, io),
311
330
    case (catch init(Config)) of
317
336
            notify_started(Parent),
318
337
            MG = #mg{parent = Parent, mid = Mid},
319
338
            i("mg -> started"),
 
339
            put(verbosity, Verbosity),
320
340
            case (catch loop(MG)) of
321
341
                {'EXIT', normal} ->
322
342
                    exit(normal);
333
353
    d("init -> entry with"
334
354
      "~n   Config: ~p", [Config]),
335
355
    random_init(),
 
356
    d("init -> random initiated", []),
336
357
    Mid = get_conf(local_mid, Config),
 
358
    d("init -> Mid: ~p", [Mid]),
337
359
    RI  = get_conf(receive_info, Config),
338
360
    d("init -> start megaco"),
339
361
    application:start(megaco),
345
367
            megaco:enable_trace(max, io);
346
368
        {value, {megaco_trace, io}} ->
347
369
            megaco:enable_trace(max, io);
348
 
        {value, {megaco_trace, File}} when list(File) ->
 
370
        {value, {megaco_trace, File}} when is_list(File) ->
349
371
            megaco:enable_trace(max, File);
350
372
        _ ->
351
373
            ok
361
383
    d("init -> update user info (user_args)"),
362
384
    ok = megaco:update_user_info(Mid, user_args, [self(), Mid]),
363
385
 
364
 
%     d("init -> start megaco user"),
365
 
%     megaco:start_user(Mid, []),
366
 
%     d("init -> update user info (user_mod)"),
367
 
%     megaco:update_user_info(Mid, user_mod,  ?MODULE),
368
 
%     d("init -> update user info (user_args)"),
369
 
%     megaco:update_user_info(Mid, user_args, [self()]),
370
 
 
371
386
    d("init -> get user info (receive_handle)"),
372
387
    RH = megaco:user_info(Mid,receive_handle),
373
388
    d("init -> parse receive info"),
374
 
    {MgcPort,RH1} = parse_receive_info(RI, RH),
 
389
    {MgcPort, RH1} = parse_receive_info(RI, RH),
375
390
    d("init -> start transport"),
376
391
    {ok, _CH} = start_transport(MgcPort, RH1),
377
392
    Mid.
559
574
 
560
575
 
561
576
handle_encode_ar_first(#mg{encode_ar_first = Old} = MG, New) 
562
 
  when New == true; New == false ->
 
577
  when (New =:= true) orelse (New =:= false) ->
563
578
    {{ok, Old}, MG#mg{encode_ar_first = New}};
564
579
handle_encode_ar_first(MG, New) ->
565
580
    {{error, {invalid_value, New}}, MG}.
635
650
                      "own connection ~p: ~p. "
636
651
                      "~nexiting...", [CH, Reason]),
637
652
            exit({invalid_connection, CH, Reason});
638
 
        SendMod when atom(SendMod) ->
 
653
        SendMod when is_atom(SendMod) ->
639
654
            SendMod:reset_stats()
640
655
    end.
641
656
 
664
679
%%
665
680
%% Get conn info 
666
681
%%
667
 
do_get_conn_info(CH, all = Tag) when record(CH, megaco_conn_handle) ->
 
682
do_get_conn_info(CH, all = Tag) when is_record(CH, megaco_conn_handle) ->
668
683
    case (catch megaco:conn_info(CH, Tag)) of
669
684
        L when is_list(L) ->
670
685
            lists:sort(L);
671
686
        Else ->
672
687
            Else
673
688
    end;
674
 
do_get_conn_info(CH, Tag) when record(CH, megaco_conn_handle) ->
 
689
do_get_conn_info(CH, Tag) when is_record(CH, megaco_conn_handle) ->
675
690
    (catch megaco:conn_info(CH, Tag));
676
691
do_get_conn_info(Mid, Tag) ->
677
692
    case megaco:user_info(Mid, connections) of
866
881
 
867
882
 
868
883
start_tcp(MgcPort, RH) ->
869
 
    d("start tcp transport (~p)", [MgcPort]),
 
884
    d("start tcp transport: "
 
885
      "~n   MGC Port:       ~p"
 
886
      "~n   Receive handle: ~p", [MgcPort, RH]),
870
887
    case megaco_tcp:start_transport() of
871
888
        {ok, Sup} ->
872
889
            d("tcp transport started: ~p", [Sup]),
873
 
            {ok, LocalHost} = inet:gethostname(),
874
 
            Opts = [{host, LocalHost},{port, MgcPort}, {receive_handle, RH}],
875
 
            d("tcp connect", []),
876
 
            case megaco_tcp:connect(Sup, Opts) of
877
 
                {ok, SendHandle, ControlPid} ->
878
 
                    d("tcp connected: ~p, ~p", [SendHandle, ControlPid]),
879
 
                    megaco_tcp_connect(RH, LocalHost, SendHandle, ControlPid);
880
 
                {error, Reason} ->
881
 
                    throw({error, {megaco_tcp_connect, Reason}})
882
 
            end;
 
890
            start_tcp_connect(RH, MgcPort, Sup);
883
891
        {error, Reason} ->
884
892
            throw({error, {megaco_tcp_start_transport, Reason}})
885
893
    end.
886
894
 
887
 
megaco_tcp_connect(RH, _LocalHost, SendHandle, ControlPid) ->
 
895
start_tcp_connect(RH, Port, Sup) ->
 
896
    {ok, LocalHost} = inet:gethostname(),
 
897
    Opts = [{host,           LocalHost},
 
898
            {port,           Port}, 
 
899
            {receive_handle, RH},
 
900
            {tcp_options,    [{nodelay, true}]}],
 
901
    try_start_tcp_connect(RH, Sup, Opts, 250, noError).
 
902
 
 
903
try_start_tcp_connect(RH, Sup, Opts, Timeout, Error0) when (Timeout < 5000) ->
 
904
    Sleep = random(Timeout) + 100,
 
905
    d("try tcp connect (~p,~p)", [Timeout, Sleep]),
 
906
    case megaco_tcp:connect(Sup, Opts) of
 
907
        {ok, SendHandle, ControlPid} ->
 
908
            d("tcp connected: ~p, ~p", [SendHandle, ControlPid]),
 
909
            megaco_tcp_connect(RH, SendHandle, ControlPid);
 
910
        Error1 when Error0 =:= noError -> % Keep the first error
 
911
            d("failed connecting [1]: ~p", [Error1]),
 
912
            sleep(Sleep),
 
913
            try_start_tcp_connect(RH, Sup, Opts, Timeout*2, Error1);
 
914
        Error2 ->       
 
915
            d("failed connecting [2]: ~p", [Error2]),
 
916
            sleep(Sleep),
 
917
            try_start_tcp_connect(RH, Sup, Opts, Timeout*2, Error0)
 
918
    end;
 
919
try_start_tcp_connect(_RH, Sup, _Opts, _Timeout, Error) ->
 
920
    megaco_tcp:stop_transport(Sup),
 
921
    throw({error, {megaco_tcp_connect, Error}}).
 
922
    
 
923
megaco_tcp_connect(RH, SendHandle, ControlPid) ->
888
924
    PrelMgcMid = preliminary_mid,
889
925
    d("megaco connect", []),    
890
926
    {ok, CH} = megaco:connect(RH, PrelMgcMid, SendHandle, ControlPid),
1013
1049
    {N, Actions, _} = make_notify_request(N,N),
1014
1050
    send_sync(EAF, CH, Actions, []).
1015
1051
 
1016
 
make_notify_request(N, Sz) when N >= Sz, Sz > 0 ->
 
1052
make_notify_request(N, Sz) when (N >= Sz) andalso (Sz > 0) ->
1017
1053
    {Req, ReplyData} = make_notify_request(N, Sz, [], []),
1018
1054
    {Sz, Req, ReplyData};
1019
1055
make_notify_request(N, _Sz) when N > 0 ->
1028
1064
    TimeStamp = cre_timeNotation(),
1029
1065
    Event     = cre_observedEvent("al/of", TimeStamp),
1030
1066
    Desc      = cre_observedEventsDesc(2000 + N, [Event]),
1031
 
    NotifyReq = cre_notifyReq([#megaco_term_id{id = tid(100+Offset-N)}],Desc),
 
1067
    TidNum    = 2#10000000 + Offset - N,
 
1068
    NotifyReq = cre_notifyReq([#megaco_term_id{id = tid(TidNum)}],Desc),
1032
1069
    CmdReq    = cre_commandReq({notifyReq, NotifyReq}),
1033
1070
    ActReq    = cre_actionReq(?megaco_null_context_id, [CmdReq]),
1034
1071
    make_notify_request(Offset, N-1, [[ActReq]|Actions], [Desc|ReplyDatas]).
1113
1150
 
1114
1151
handle_megaco_request(#mg{req_handler = Pid} = MG,
1115
1152
                      {handle_disconnect, _CH, _PV, R}) 
1116
 
  when pid(Pid) ->
 
1153
  when is_pid(Pid) ->
1117
1154
    d("handle_megaco_request(handle_disconnect) -> entry with"
1118
1155
      "~n   Pid: ~p", [Pid]),
1119
1156
    Error = {error, {disconnected, R}},
1131
1168
 
1132
1169
handle_megaco_request(#mg{req_handler = Pid} = MG,
1133
1170
                      {handle_message_error, CH, PV, ED}) 
1134
 
  when pid(Pid) ->
 
1171
  when is_pid(Pid) ->
1135
1172
    d("handle_megaco_request(handle_message_error) -> entry with"
1136
1173
      "~n   Pid:    ~p"
1137
1174
      "~n   CH:     ~p"
1160
1197
    {{discard_ack, ED}, MG};
1161
1198
 
1162
1199
handle_megaco_request(#mg{rep_info = P} = MG, 
1163
 
                      {handle_trans_reply, CH, PV, AR, RD}) when pid(P) ->
 
1200
                      {handle_trans_reply, CH, PV, AR, RD}) when is_pid(P) ->
1164
1201
    P ! {rep_received, self(), AR},
1165
1202
    do_handle_trans_reply(MG, CH, PV, AR, RD);
1166
1203
handle_megaco_request(MG, {handle_trans_reply, CH, PV, AR, RD}) ->
1167
1204
    do_handle_trans_reply(MG, CH, PV, AR, RD);
1168
1205
 
1169
1206
handle_megaco_request(#mg{ack_info = P} = MG, 
1170
 
                      {handle_trans_ack, _CH, _PV, AS, _AD}) when pid(P) ->
 
1207
                      {handle_trans_ack, _CH, _PV, AS, _AD}) when is_pid(P) ->
1171
1208
    d("handle_megaco_request(handle_trans_ack,~p) -> entry",[P]),
1172
1209
    P ! {ack_received, self(), AS},
1173
1210
    {ok, MG};
1349
1386
    case text_codec(EM) of
1350
1387
        true ->
1351
1388
            case megaco:system_info(text_config) of
1352
 
                [Conf] when list(Conf) ->
 
1389
                [Conf] when is_list(Conf) ->
1353
1390
                    Conf;
1354
1391
                _ ->
1355
1392
                    []
1453
1490
    random:seed(A,B,C).
1454
1491
 
1455
1492
random() ->
1456
 
    10 * random:uniform(50).
 
1493
    random(50).
 
1494
random(N) ->
 
1495
    random:uniform(N).
1457
1496
 
1458
1497
 
1459
1498
apply_load_timer() ->