1%% 2%% %CopyrightBegin% 3%% 4%% Copyright Ericsson AB 2003-2020. All Rights Reserved. 5%% 6%% Licensed under the Apache License, Version 2.0 (the "License"); 7%% you may not use this file except in compliance with the License. 8%% You may obtain a copy of the License at 9%% 10%% http://www.apache.org/licenses/LICENSE-2.0 11%% 12%% Unless required by applicable law or agreed to in writing, software 13%% distributed under the License is distributed on an "AS IS" BASIS, 14%% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 15%% See the License for the specific language governing permissions and 16%% limitations under the License. 17%% 18%% %CopyrightEnd% 19%% 20 21%% 22%%---------------------------------------------------------------------- 23%% Purpose: Verify that the transaction sender works with acks. 24%% 25%% Test: ts:run(megaco, megaco_trans_SUITE, [batch]). 26%% 27%%---------------------------------------------------------------------- 28-module(megaco_trans_SUITE). 29 30-export([ 31 suite/0, all/0, groups/0, 32 init_per_suite/1, end_per_suite/1, 33 init_per_group/2, end_per_group/2, 34 init_per_testcase/2, end_per_testcase/2, 35 36 single_ack/1, 37 multi_ack_timeout/1, 38 multi_ack_maxcount/1, 39 40 single_trans_req/1, 41 multi_trans_req_timeout/1, 42 multi_trans_req_maxcount1/1, 43 multi_trans_req_maxcount2/1, 44 multi_trans_req_maxsize1/1, 45 multi_trans_req_maxsize2/1, 46 47 single_trans_req_and_ack/1, 48 multi_trans_req_and_ack_timeout/1, 49 multi_trans_req_and_ack_ackmaxcount/1, 50 multi_trans_req_and_ack_reqmaxcount/1, 51 multi_trans_req_and_ack_maxsize1/1, 52 multi_trans_req_and_ack_maxsize2/1, 53 54 single_trans_req_and_pending/1, 55 multi_trans_req_and_pending/1, 56 multi_trans_req_and_ack_and_pending/1, 57 multi_ack_and_pending/1, 58 59 multi_trans_req_and_reply/1, 60 multi_trans_req_and_ack_and_reply/1, 61 multi_ack_and_reply/1, 62 63 otp_7192_1/1, 64 otp_7192_2/1, 65 otp_7192_3/1 66 67 ]). 68 69-include_lib("megaco/include/megaco.hrl"). 70-include_lib("megaco/include/megaco_message_v1.hrl"). 71-include("megaco_test_lib.hrl"). 72 73-define(VERSION, 1). 74-define(TEST_VERBOSITY, debug). 75-define(MGC_VERBOSITY, debug). 76-define(MG_VERBOSITY, debug). 77 78-define(LOAD_COUNTER_START, 10). 79-define(A4444, ["11111111", "00000000", "00000000"]). 80-define(A4445, ["11111111", "00000000", "11111111"]). 81-define(A5555, ["11111111", "11111111", "00000000"]). 82-define(A5556, ["11111111", "11111111", "11111111"]). 83 84-define(MG, megaco_test_mg). 85-define(MGC, megaco_test_mgc). 86 87-define(MGC_START(Pid, Mid, ET, Verb), 88 mgc_start(Pid, Mid, ET, Verb)). 89-define(MGC_STOP(Pid), ?MGC:stop(Pid)). 90-define(MGC_GET_STATS(Pid, No), ?MGC:get_stats(Pid, No)). 91-define(MGC_RESET_STATS(Pid), ?MGC:reset_stats(Pid)). 92-define(MGC_REQ_DISC(Pid,To), ?MGC:request_discard(Pid,To)). 93-define(MGC_REQ_PEND(Pid,To), ?MGC:request_pending(Pid,To)). 94-define(MGC_REQ_HAND(Pid), ?MGC:request_handle(Pid)). 95-define(MGC_REQ_HANDS(Pid), ?MGC:request_handle_sloppy(Pid)). 96-define(MGC_UPDATE_UI(Pid,Tag,Val), ?MGC:update_user_info(Pid,Tag,Val)). 97-define(MGC_UPDATE_CI(Pid,Tag,Val), ?MGC:update_conn_info(Pid,Tag,Val)). 98-define(MGC_USER_INFO(Pid,Tag), ?MGC:user_info(Pid,Tag)). 99-define(MGC_CONN_INFO(Pid,Tag), ?MGC:conn_info(Pid,Tag)). 100-define(MGC_ACK_INFO(Pid,To), ?MGC:ack_info(Pid,To)). 101-define(MGC_REQ_INFO(Pid,To), ?MGC:req_info(Pid,To)). 102 103-define(MG_START(Pid, Mid, Enc, Transp, Conf, Verb), 104 mg_start(Pid, Mid, Enc, Transp, Conf, Verb)). 105-define(MG_STOP(Pid), ?MG:stop(Pid)). 106-define(MG_GET_STATS(Pid), ?MG:get_stats(Pid)). 107-define(MG_RESET_STATS(Pid), ?MG:reset_stats(Pid)). 108-define(MG_SERV_CHANGE(Pid), ?MG:service_change(Pid)). 109-define(MG_NOTIF_RAR(Pid), ?MG:notify_request_and_reply(Pid)). 110-define(MG_NOTIF_REQ(Pid), ?MG:notify_request(Pid)). 111-define(MG_NOTIF_AR(Pid), ?MG:await_notify_reply(Pid)). 112-define(MG_CANCEL(Pid,R), ?MG:cancel_request(Pid,R)). 113-define(MG_APPLY_LOAD(Pid,CntStart), ?MG:apply_load(Pid,CntStart)). 114-define(MG_UPDATE_UI(Pid,Tag,Val), ?MG:update_user_info(Pid,Tag,Val)). 115-define(MG_UPDATE_CI(Pid,Tag,Val), ?MG:update_conn_info(Pid,Tag,Val)). 116-define(MG_USER_INFO(Pid,Tag), ?MG:user_info(Pid,Tag)). 117-define(MG_CONN_INFO(Pid,Tag), ?MG:conn_info(Pid,Tag)). 118-define(MG_GRP_REQ(Pid,N), ?MG:group_requests(Pid,N)). 119-define(MG_ACK_INFO(Pid,To), ?MG:ack_info(Pid,To)). 120-define(MG_REP_INFO(Pid,To), ?MG:rep_info(Pid,To)). 121 122 123%%====================================================================== 124%% Common Test interface functions 125%%====================================================================== 126 127suite() -> 128 [{ct_hooks, [ts_install_cth]}]. 129 130all() -> 131 [ 132 {group, ack}, 133 {group, trans_req}, 134 {group, trans_req_and_ack}, 135 {group, pending}, 136 {group, reply}, 137 {group, tickets} 138 ]. 139 140groups() -> 141 [ 142 {ack, [], ack_cases()}, 143 {trans_req, [], trans_req_cases()}, 144 {trans_req_and_ack, [], trans_req_and_ack_cases()}, 145 {pending, [], pending_cases()}, 146 {reply, [], reply_cases()}, 147 {tickets, [], tickets_cases()}, 148 {otp_7192, [], otp_7192_cases()} 149 ]. 150 151ack_cases() -> 152 [ 153 single_ack, 154 multi_ack_timeout, 155 multi_ack_maxcount 156 ]. 157 158trans_req_cases() -> 159 [ 160 single_trans_req, 161 multi_trans_req_timeout, 162 multi_trans_req_maxcount1, 163 multi_trans_req_maxcount2, 164 multi_trans_req_maxsize1, 165 multi_trans_req_maxsize2 166 ]. 167 168trans_req_and_ack_cases() -> 169 [ 170 single_trans_req_and_ack, 171 multi_trans_req_and_ack_timeout, 172 multi_trans_req_and_ack_ackmaxcount, 173 multi_trans_req_and_ack_reqmaxcount, 174 multi_trans_req_and_ack_maxsize1, 175 multi_trans_req_and_ack_maxsize2 176 ]. 177 178pending_cases() -> 179 [ 180 single_trans_req_and_pending, 181 multi_trans_req_and_pending, 182 multi_trans_req_and_ack_and_pending, 183 multi_ack_and_pending 184 ]. 185 186reply_cases() -> 187 [ 188 multi_trans_req_and_reply, 189 multi_trans_req_and_ack_and_reply, 190 multi_ack_and_reply 191 ]. 192 193tickets_cases() -> 194 [ 195 {group, otp_7192} 196 ]. 197 198otp_7192_cases() -> 199 [ 200 otp_7192_1, 201 otp_7192_2, 202 otp_7192_3 203 ]. 204 205 206 207 208%% 209%% ----- 210%% 211 212init_per_suite(suite) -> 213 []; 214init_per_suite(doc) -> 215 []; 216init_per_suite(Config0) when is_list(Config0) -> 217 218 ?ANNOUNCE_SUITE_INIT(), 219 220 p("init_per_suite -> entry with" 221 "~n Config: ~p" 222 "~n Nodes: ~p", [Config0, erlang:nodes()]), 223 224 case ?LIB:init_per_suite(Config0) of 225 {skip, _} = SKIP -> 226 SKIP; 227 228 Config1 when is_list(Config1) -> 229 230 %% We need a (local) monitor on this node also 231 megaco_test_sys_monitor:start(), 232 233 p("init_per_suite -> end when" 234 "~n Config: ~p" 235 "~n Nodes: ~p", [Config1, erlang:nodes()]), 236 237 Config1 238 end. 239 240end_per_suite(suite) -> []; 241end_per_suite(doc) -> []; 242end_per_suite(Config0) when is_list(Config0) -> 243 244 p("end_per_suite -> entry with" 245 "~n Config: ~p" 246 "~n Nodes: ~p", [Config0, erlang:nodes()]), 247 248 megaco_test_sys_monitor:stop(), 249 Config1 = ?LIB:end_per_suite(Config0), 250 251 p("end_per_suite -> end when" 252 "~n Nodes: ~p", [erlang:nodes()]), 253 254 Config1. 255 256 257%% 258%% ----- 259%% 260 261init_per_group(Group, Config) -> 262 ?ANNOUNCE_GROUP_INIT(Group), 263 Config. 264 265end_per_group(_GroupName, Config) -> 266 Config. 267 268 269 270%% 271%% ----- 272%% 273 274init_per_testcase(multi_ack_maxcount = Case, Config) -> 275 C = lists:keydelete(tc_timeout, 1, Config), 276 init_per_testcase2(Case, [{tc_timeout,timer:minutes(10)}|C]); 277init_per_testcase(Case, Config) -> 278 process_flag(trap_exit, true), 279 init_per_testcase2(Case, Config). 280 281init_per_testcase2(Case, Config) -> 282 process_flag(trap_exit, true), 283 284 p("init_per_suite -> entry with" 285 "~n Config: ~p" 286 "~n Nodes: ~p", [Config, erlang:nodes()]), 287 288 megaco_test_global_sys_monitor:reset_events(), 289 megaco_test_lib:init_per_testcase(Case, Config). 290 291end_per_testcase(Case, Config) -> 292 process_flag(trap_exit, false), 293 294 p("end_per_suite -> entry with" 295 "~n Config: ~p" 296 "~n Nodes: ~p", [Config, erlang:nodes()]), 297 298 p("system events during test: " 299 "~n ~p", [megaco_test_global_sys_monitor:events()]), 300 301 megaco_test_lib:end_per_testcase(Case, Config). 302 303 304 305%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 306 307single_ack(suite) -> 308 []; 309single_ack(doc) -> 310 []; 311single_ack(Config) when is_list(Config) -> 312 Pre = fun() -> 313 MgcNode = make_node_name(mgc), 314 MgNode = make_node_name(mg), 315 d("start nodes: " 316 "~n MGC Node: ~p" 317 "~n MG Node: ~p", 318 [MgcNode, MgNode]), 319 Nodes = [MgcNode, MgNode], 320 ok = ?START_NODES(Nodes), 321 Nodes 322 end, 323 Case = fun do_single_ack/1, 324 Post = fun(Nodes) -> 325 d("stop nodes"), 326 ?STOP_NODES(lists:reverse(Nodes)) 327 end, 328 try_tc(rsingle_ack, Pre, Case, Post). 329 330do_single_ack([MgcNode, MgNode]) -> 331 %% Start the MGC and MGs 332 i("[MGC] start"), 333 ET = [{text,tcp}, {text,udp}, {binary,tcp}, {binary,udp}], 334 Mgc = ?MGC_START(MgcNode, {deviceName, "ctrl"}, ET, ?MGC_VERBOSITY), 335 336 i("[MG] start"), 337 %% MgConf0 = [{MgNode, "mg", text, tcp, ?MG_VERBOSITY}], 338 MgMid = {deviceName, "mg"}, 339 MgConfig = [{auto_ack, true}, {trans_timer, 5000}, {trans_ack, true}], 340 Mg = ?MG_START(MgNode, MgMid, text, tcp, MgConfig, ?MG_VERBOSITY), 341 342 d("MG user info: ~p", [?MG_USER_INFO(Mg, all)]), 343 344 i("[MG] connect to the MGC (service change)"), 345 ServChRes = ?MG_SERV_CHANGE(Mg), 346 d("service change result: ~p", [ServChRes]), 347 348 d("MG conn info: ~p", [?MG_CONN_INFO(Mg, all)]), 349 350 d("ensure the megaco stack calls the handle_trans_ack callback"), 351 ?MGC_REQ_HANDS(Mgc), 352 353 d("tell the MGC to send the ack's to us"), 354 ?MGC_ACK_INFO(Mgc, self()), 355 356 d("send the notify"), 357 ?MG_GRP_REQ(Mg, 1), 358 359 d("send the notify"), 360 ?MG_NOTIF_REQ(Mg), 361 362 d("await the ack"), 363 await_ack(Mgc, 1, infinity, ok), 364 365 %% Tell MG to stop 366 i("[MG] stop"), 367 ?MG_STOP(Mg), 368 369 %% Tell Mgc to stop 370 i("[MGC] stop"), 371 ?MGC_STOP(Mgc), 372 373 i("done", []), 374 ok. 375 376 377%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 378 379multi_ack_timeout(suite) -> 380 []; 381multi_ack_timeout(doc) -> 382 []; 383multi_ack_timeout(Config) when is_list(Config) -> 384 Pre = fun() -> 385 %% <CONDITIONAL-SKIP> 386 Skippable = [win32, {unix, [darwin, linux, sunos]}], 387 Condition = fun() -> ?OS_BASED_SKIP(Skippable) end, 388 ?NON_PC_TC_MAYBE_SKIP(Config, Condition), 389 %% </CONDITIONAL-SKIP> 390 391 MgcNode = make_node_name(mgc), 392 MgNode = make_node_name(mg), 393 d("start nodes: " 394 "~n MGC Node: ~p" 395 "~n MG Node: ~p", 396 [MgcNode, MgNode]), 397 Nodes = [MgcNode, MgNode], 398 ok = ?START_NODES(Nodes), 399 Nodes 400 end, 401 Case = fun do_multi_ack_timeout/1, 402 Post = fun(Nodes) -> 403 d("stop nodes"), 404 ?STOP_NODES(lists:reverse(Nodes)) 405 end, 406 try_tc(multi_ack_timeout, Pre, Case, Post). 407 408do_multi_ack_timeout([MgcNode, MgNode]) -> 409 410 MaxCount = 20, 411 412 %% Start the MGC and MGs 413 i("[MGC] start"), 414 ET = [{text,tcp}, {text,udp}, {binary,tcp}, {binary,udp}], 415 Mgc = ?MGC_START(MgcNode, {deviceName, "ctrl"}, ET, ?MGC_VERBOSITY), 416 417 i("[MG] start"), 418 %% MgConf0 = [{MgNode, "mg", text, tcp, ?MG_VERBOSITY}], 419 MgMid = {deviceName, "mg"}, 420 MgConfig = [{auto_ack, true}, 421 {trans_ack, true}, 422 {trans_timer, 10000}, 423 {trans_ack_maxcount, MaxCount + 10}], 424 Mg = ?MG_START(MgNode, MgMid, text, tcp, MgConfig, ?MG_VERBOSITY), 425 426 d("MG user info: ~p", [?MG_USER_INFO(Mg, all)]), 427 428 i("[MG] connect the MGC (service change)"), 429 ServChRes = ?MG_SERV_CHANGE(Mg), 430 d("service change result: ~p", [ServChRes]), 431 432 i("wait some time"), 433 sleep(1000), 434 435 d("MG conn info: ~p", [?MG_CONN_INFO(Mg, all)]), 436 437 {ok, _OldAction} = ?MGC_REQ_HANDS(Mgc), 438 439 d("tell the MGC to send the ack's to us"), 440 ?MGC_ACK_INFO(Mgc, self()), 441 442 d("set group size to ~p", [MaxCount]), 443 ?MG_GRP_REQ(Mg, MaxCount), 444 445 d("[MG] send a group of requests (and await the replies)"), 446 ?MG_NOTIF_RAR(Mg), 447 448 d("await the ack(s)"), 449 await_ack(Mgc, MaxCount, 60000, ok), 450 451 i("wait some time before closing down"), 452 sleep(5000), 453 454 %% Tell MG to stop 455 i("[MG] stop"), 456 ?MG_STOP(Mg), 457 458 %% Tell Mgc to stop 459 i("[MGC] stop"), 460 ?MGC_STOP(Mgc), 461 462 i("done"), 463 ok. 464 465 466 467%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 468 469multi_ack_maxcount(suite) -> 470 []; 471multi_ack_maxcount(doc) -> 472 []; 473multi_ack_maxcount(Config) when is_list(Config) -> 474 Pre = fun() -> 475 MgcNode = make_node_name(mgc), 476 MgNode = make_node_name(mg), 477 d("start nodes: " 478 "~n MGC Node: ~p" 479 "~n MG Node: ~p", 480 [MgcNode, MgNode]), 481 Nodes = [MgcNode, MgNode], 482 ok = ?START_NODES(Nodes), 483 Nodes 484 end, 485 Case = fun do_multi_ack_maxcount/1, 486 Post = fun(Nodes) -> 487 d("stop nodes"), 488 ?STOP_NODES(lists:reverse(Nodes)) 489 end, 490 try_tc(multi_ack_maxcount, Pre, Case, Post). 491 492do_multi_ack_maxcount([MgcNode, MgNode]) -> 493 MaxCount = 10, 494 495 %% Start the MGC and MGs 496 i("[MGC] start"), 497 ET = [{text,tcp}, {text,udp}, {binary,tcp}, {binary,udp}], 498 Mgc = ?MGC_START(MgcNode, {deviceName, "ctrl"}, ET, ?MGC_VERBOSITY), 499 500 i("[MG] start"), 501 %% MgConf0 = [{MgNode, "mg", text, tcp, ?MG_VERBOSITY}], 502 MgMid = {deviceName, "mg"}, 503 MgConfig = [%% {auto_ack, true}, 504 %% {trans_timer, 120000}, 505 %% {trans_ack_maxcount, MaxCount} 506 ], 507 Mg = ?MG_START(MgNode, MgMid, text, tcp, MgConfig, ?MG_VERBOSITY), 508 509 d("MG user info: ~p", [?MG_USER_INFO(Mg, all)]), 510 511 i("[MG] connect the MGC (service change)"), 512 ServChRes = ?MG_SERV_CHANGE(Mg), 513 d("service change result: ~p", [ServChRes]), 514 515 i("wait some time"), 516 sleep(1000), 517 518 d("MG conn info: ~p", [?MG_CONN_INFO(Mg, all)]), 519 520 ?MG_UPDATE_CI(Mg,auto_ack,true), 521 ?MG_UPDATE_CI(Mg,trans_timer,120000), 522 ?MG_UPDATE_CI(Mg,trans_ack_maxcount,MaxCount), 523 ?MG_UPDATE_CI(Mg,trans_ack,true), 524 525 d("MG conn info: ~p", [?MG_CONN_INFO(Mg, all)]), 526 527 {ok, _OldAction} = ?MGC_REQ_HANDS(Mgc), 528 529 d("tell the MGC to send the ack's to us"), 530 ?MGC_ACK_INFO(Mgc, self()), 531 532 d("set group size to ~p", [MaxCount]), 533 ?MG_GRP_REQ(Mg, MaxCount), 534 535 d("[MG] send a group of requests (and await the replies)"), 536 ?MG_NOTIF_RAR(Mg), 537 538 d("await the ack"), 539 await_ack(Mgc, MaxCount, 60000, ok), 540 541 i("wait some time before closing down"), 542 sleep(5000), 543 544 %% Tell MG to stop 545 i("[MG] stop"), 546 ?MG_STOP(Mg), 547 548 %% Tell Mgc to stop 549 i("[MGC] stop"), 550 ?MGC_STOP(Mgc), 551 552 i("done"), 553 ok. 554 555 556 557%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 558 559single_trans_req(suite) -> 560 []; 561single_trans_req(doc) -> 562 []; 563single_trans_req(Config) when is_list(Config) -> 564 Pre = fun() -> 565 MgcNode = make_node_name(mgc), 566 MgNode = make_node_name(mg), 567 d("start nodes: " 568 "~n MGC Node: ~p" 569 "~n MG Node: ~p", 570 [MgcNode, MgNode]), 571 Nodes = [MgcNode, MgNode], 572 ok = ?START_NODES(Nodes), 573 Nodes 574 end, 575 Case = fun do_single_trans_req/1, 576 Post = fun(Nodes) -> 577 d("stop nodes"), 578 ?STOP_NODES(lists:reverse(Nodes)) 579 end, 580 try_tc(single_trans_req, Pre, Case, Post). 581 582do_single_trans_req([MgcNode, MgNode]) -> 583 584 d("[MGC] start the simulator "), 585 {ok, Mgc} = megaco_test_megaco_generator:start_link("MGC", MgcNode), 586 587 d("[MGC] create the event sequence"), 588 MgcEvSeq = str_mgc_event_sequence(text, tcp), 589 590 i("wait some time before starting the MGC simulation"), 591 sleep(1000), 592 593 d("[MGC] start the simulation"), 594 {ok, MgcId} = megaco_test_megaco_generator:exec(Mgc, MgcEvSeq), 595 596 %% i("wait some time before starting the MG simulator"), 597 %% sleep(1000), 598 599 i("await MGC ready announcement"), 600 receive 601 announce_mgc -> 602 i("received MGC ready announcement"), 603 ok 604 end, 605 606 d("[MG] start the simulator (generator)"), 607 {ok, Mg} = megaco_test_megaco_generator:start_link("MG", MgNode), 608 609 d("[MG] create the event sequence"), 610 MgEvSeq = str_mg_event_sequence(text, tcp), 611 612 i("wait some time before starting the MG simulation"), 613 sleep(1000), 614 615 d("[MG] start the simulation"), 616 {ok, MgId} = megaco_test_megaco_generator:exec(Mg, MgEvSeq), 617 618 d("await the generator reply(s)"), 619 await_completion([MgcId, MgId]), 620 621 %% Tell Mgc to stop 622 i("[MGC] stop generator"), 623 megaco_test_megaco_generator:stop(Mgc), 624 625 %% Tell Mg to stop 626 i("[MG] stop generator"), 627 megaco_test_megaco_generator:stop(Mg), 628 629 i("done", []), 630 ok. 631 632 633%% 634%% MGC generator stuff 635%% 636-ifdef(megaco_hipe_special). 637-define(str_mgc_connect_verify_fun(), 638 {?MODULE, str_mgc_verify_handle_connect, []}). 639-define(str_mgc_service_change_req_verify_fun(Mid), 640 {?MODULE, str_mgc_verify_service_change_req, [Mid]}). 641-define(str_mgc_notify_req_verify_fun(), 642 {?MODULE, str_mgc_verify_notify_request, []}). 643-define(str_mgc_disco_verify_fun(), 644 {?MODULE, str_mgc_verify_handle_disconnect, []}). 645-else. 646-define(str_mgc_connect_verify_fun(), 647 fun str_mgc_verify_handle_connect/1). 648-define(str_mgc_service_change_req_verify_fun(Mid), 649 str_mgc_verify_service_change_req_fun(Mid)). 650-define(str_mgc_notify_req_verify_fun(), 651 str_mgc_verify_notify_request_fun()). 652-define(str_mgc_disco_verify_fun(), 653 fun str_mgc_verify_handle_disconnect/1). 654-endif. 655 656str_mgc_event_sequence(text, tcp) -> 657 CTRL = self(), 658 Mid = {deviceName,"ctrl"}, 659 RI = [ 660 {port, 2944}, 661 {encoding_module, megaco_pretty_text_encoder}, 662 {encoding_config, []}, 663 {transport_module, megaco_tcp} 664 ], 665 ConnectVerify = ?str_mgc_connect_verify_fun(), 666 ServiceChangeReqVerify = ?str_mgc_service_change_req_verify_fun(Mid), 667 NotifyReqVerify = ?str_mgc_notify_req_verify_fun(), 668 DiscoVerify = ?str_mgc_disco_verify_fun(), 669 EvSeq = [ 670 {debug, false}, 671 {megaco_trace, disable}, 672 megaco_start, 673 {megaco_start_user, Mid, RI, []}, 674 start_transport, 675 listen, 676 677 %% ANNOUNCE READY 678 {trigger, fun() -> CTRL ! announce_mgc end}, 679 680 {megaco_callback, handle_connect, ConnectVerify}, 681 {megaco_callback, handle_trans_request, ServiceChangeReqVerify}, 682 {megaco_callback, handle_trans_request, NotifyReqVerify}, 683 {megaco_callback, handle_disconnect, DiscoVerify}, 684 {sleep, 1000}, 685 megaco_stop_user, 686 megaco_stop 687 ], 688 EvSeq. 689 690 691str_mgc_verify_handle_connect({handle_connect, CH, ?VERSION}) -> 692 io:format("str_mgc_verify_handle_connect -> ok" 693 "~n CH: ~p~n", [CH]), 694 {ok, CH, ok}; 695str_mgc_verify_handle_connect(Else) -> 696 io:format("str_mgc_verify_handle_connect -> unknown" 697 "~n Else: ~p~n", [Else]), 698 {error, Else, ok}. 699 700 701str_mgc_verify_service_change_req_fun(Mid) -> 702 fun(Ev) -> 703 str_mgc_verify_service_change_req(Ev, Mid) 704 end. 705 706str_mgc_verify_service_change_req( 707 {handle_trans_request, _, ?VERSION, [AR]}, Mid) -> 708 io:format("str_mgc_verify_service_change_req -> ok" 709 "~n AR: ~p~n", [AR]), 710 case AR of 711 #'ActionRequest'{commandRequests = [CR]} -> 712 case CR of 713 #'CommandRequest'{command = Cmd} -> 714 case Cmd of 715 {serviceChangeReq, 716 #'ServiceChangeRequest'{terminationID = [Tid], 717 serviceChangeParms = Parms}} -> 718 case Tid of 719 #megaco_term_id{contains_wildcards = false, 720 id = ["root"]} -> 721 case Parms of 722 #'ServiceChangeParm'{ 723 serviceChangeMethod = restart, 724 serviceChangeReason = [[$9,$0,$1|_]]} -> 725 Reply = 726 {discard_ack, 727 [str_mgc_service_change_reply_ar(Mid, 1)]}, 728 {ok, AR, Reply}; 729 _ -> 730 Err = {invalid_SCP, Parms}, 731 ED = str_err_desc(Parms), 732 ErrReply = {discard_ack, 733 ED}, 734 {error, Err, ErrReply} 735 end; 736 _ -> 737 Err = {invalid_termination_id, Tid}, 738 ED = str_err_desc(Tid), 739 ErrReply = {discard_ack, ED}, 740 {error, Err, ErrReply} 741 end; 742 _ -> 743 Err = {invalid_command, Cmd}, 744 ED = str_err_desc(Cmd), 745 ErrReply = {discard_ack, ED}, 746 {error, Err, ErrReply} 747 end; 748 _ -> 749 Err = {invalid_command_request, CR}, 750 ED = str_err_desc(CR), 751 ErrReply = {discard_ack, ED}, 752 {error, Err, ErrReply} 753 end; 754 _ -> 755 Err = {invalid_action_request, AR}, 756 ED = str_err_desc(AR), 757 ErrReply = {discard_ack, ED}, 758 {error, Err, ErrReply} 759 end; 760str_mgc_verify_service_change_req(Else, _Mid) -> 761 io:format("str_mgc_verify_service_change_req -> unknown" 762 "~n Else: ~p~n", [Else]), 763 ED = str_err_desc(Else), 764 ErrReply = {discard_ack, ED}, 765 {error, Else, ErrReply}. 766 767 768str_mgc_verify_notify_request_fun() -> 769 fun(Ev) -> 770 str_mgc_verify_notify_request(Ev) 771 end. 772 773str_mgc_verify_notify_request({handle_trans_request, _, ?VERSION, [AR]}) -> 774 io:format("str_mgc_verify_notify_request:fun -> ok" 775 "~n AR: ~p~n", [AR]), 776 case AR of 777 #'ActionRequest'{contextId = Cid, 778 commandRequests = [CR]} -> 779 #'CommandRequest'{command = Cmd} = CR, 780 {notifyReq, NR} = Cmd, 781 #'NotifyRequest'{terminationID = [Tid], 782 observedEventsDescriptor = OED, 783 errorDescriptor = asn1_NOVALUE} = NR, 784 #'ObservedEventsDescriptor'{observedEventLst = [OE]} = OED, 785 #'ObservedEvent'{eventName = "al/of"} = OE, 786 Reply = {discard_ack, [str_mgc_notify_reply_ar(Cid, Tid)]}, 787 {ok, AR, Reply}; 788 _ -> 789 ED = str_err_desc(AR), 790 ErrReply = {discard_ack, ED}, 791 {error, AR, ErrReply} 792 end; 793str_mgc_verify_notify_request(Else) -> 794 io:format("str_mgc_verify_notify_request:fun -> unknown" 795 "~n Else: ~p~n", [Else]), 796 ED = str_err_desc(Else), 797 ErrReply = {discard_ack, ED}, 798 {error, Else, ErrReply}. 799 800 801str_mgc_verify_handle_disconnect({handle_disconnect, CH, ?VERSION, R}) -> 802 io:format("str_mgc_verify_handle_disconnect -> ok" 803 "~n CH: ~p" 804 "~n R: ~p" 805 "~n", [CH, R]), 806 {ok, CH, ok}; 807str_mgc_verify_handle_disconnect(Else) -> 808 io:format("str_mgc_verify_handle_disconnect -> unknown" 809 "~n Else: ~p~n", [Else]), 810 {error, Else, ok}. 811 812 813str_mgc_service_change_reply_ar(Mid, Cid) -> 814 SCRP = cre_serviceChangeResParm(Mid), 815 SCRes = cre_serviceChangeResult(SCRP), 816 Root = #megaco_term_id{id = ["root"]}, 817 SCR = cre_serviceChangeReply([Root], SCRes), 818 CR = cre_cmdReply(SCR), 819 cre_actionReply(Cid, [CR]). 820 821%% str_mgc_service_change_reply_msg(Mid, TransId, Cid) -> 822%% AR = str_mgc_service_change_reply_ar(Mid, Cid), 823%% TRes = cre_transResult([AR]), 824%% TR = cre_transReply(TransId, TRes), 825%% Trans = cre_transaction(TR), 826%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 827%% cre_megacoMessage(Mess). 828 829str_mgc_notify_reply_ar(Cid, TermId) -> 830 NR = cre_notifyReply([TermId]), 831 CR = cre_cmdReply(NR), 832 cre_actionReply(Cid, [CR]). 833 834%% str_mgc_notify_reply(Mid, TransId, Cid, TermId) -> 835%% AR = str_mgc_notify_reply_ar(Cid, TermId), 836%% TRes = cre_transResult([AR]), 837%% TR = cre_transReply(TransId, TRes), 838%% Trans = cre_transaction(TR), 839%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 840%% cre_megacoMessage(Mess). 841 842 843%% 844%% MG generator stuff 845%% 846-ifdef(megaco_hipe_special). 847-define(str_mg_connect_verify_fun(), 848 {?MODULE, str_mg_verify_handle_connect, []}). 849-define(str_mg_service_change_reply_verify_fun(), 850 {?MODULE, str_mg_verify_service_change_reply, []}). 851-define(str_mg_notify_reply_verify_fun(), 852 {?MODULE, str_mg_verify_notify_reply, []}). 853-else. 854-define(str_mg_connect_verify_fun(), 855 fun str_mg_verify_handle_connect/1). 856-define(str_mg_service_change_reply_verify_fun(), 857 fun str_mg_verify_service_change_reply/1). 858-define(str_mg_notify_reply_verify_fun(), 859 fun str_mg_verify_notify_reply/1). 860-endif. 861 862str_mg_event_sequence(text, tcp) -> 863 Mid = {deviceName,"mg"}, 864 RI = [ 865 {port, 2944}, 866 {encoding_module, megaco_pretty_text_encoder}, 867 {encoding_config, []}, 868 {transport_module, megaco_tcp} 869 ], 870 ServiceChangeReq = [str_mg_service_change_request_ar(Mid, 1)], 871 Tid = #megaco_term_id{id = ["00000000","00000000","01101101"]}, 872 NotifyReq = [str_mg_notify_request_ar(1, Tid, 1)], 873 ConnectVerify = ?str_mg_connect_verify_fun(), 874 ServiceChangeReplyVerify = ?str_mg_service_change_reply_verify_fun(), 875 NotifyReplyVerify = ?str_mg_notify_reply_verify_fun(), 876 EvSeq = [ 877 {debug, true}, 878 megaco_start, 879 {megaco_start_user, Mid, RI, []}, 880 start_transport, 881 {megaco_trace, max}, 882 {megaco_system_info, users}, 883 {megaco_system_info, connections}, 884 connect, 885 {megaco_callback, handle_connect, ConnectVerify}, 886 megaco_connect, 887 {megaco_cast, ServiceChangeReq, []}, 888 {megaco_callback, handle_connect, ConnectVerify}, 889 {megaco_callback, handle_trans_reply, ServiceChangeReplyVerify}, 890 {sleep, 1000}, 891 {megaco_cast, NotifyReq, []}, 892 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 893 {sleep, 1000}, 894 megaco_stop_user, 895 megaco_stop, 896 {sleep, 1000} 897 ], 898 EvSeq. 899 900str_mg_verify_handle_connect({handle_connect, CH, ?VERSION}) -> 901 io:format("str_mg_verify_handle_connect -> ok" 902 "~n CH: ~p~n", [CH]), 903 {ok, CH, ok}; 904str_mg_verify_handle_connect(Else) -> 905 io:format("str_mg_verify_handle_connect -> unknown" 906 "~n Else: ~p~n", [Else]), 907 {error, Else, ok}. 908 909str_mg_verify_service_change_reply({handle_trans_reply, _CH, ?VERSION, 910 {ok, [AR]}, _}) -> 911 io:format("str_mg_verify_service_change_reply -> ok" 912 "~n AR: ~p~n", [AR]), 913 case AR of 914 #'ActionReply'{commandReply = [SCR]} -> 915 case SCR of 916 {serviceChangeReply, 917 #'ServiceChangeReply'{terminationID = [Tid], 918 serviceChangeResult = Res}} -> 919 case Tid of 920 #megaco_term_id{contains_wildcards = false, 921 id = ["root"]} -> 922 case Res of 923 {serviceChangeResParms, 924 #'ServiceChangeResParm'{ 925 serviceChangeMgcId = _RemoteMid}} -> 926 {ok, AR, ok}; 927 {Tag, Val} -> 928 Err = {invalid_service_change_result, 929 Tag, Val}, 930 {error, Err, ok} 931 end; 932 _ -> 933 Err = {invalid_termination_id, Tid}, 934 {error, Err, ok} 935 end; 936 {Tag, Val} -> 937 Err = {invalid_command_reply, Tag, Val}, 938 {error, Err, ok} 939 end; 940 _ -> 941 Err = {invalid_action_reply, AR}, 942 {error, Err, ok} 943 end; 944str_mg_verify_service_change_reply(Else) -> 945 io:format("str_mg_verify_service_change_reply -> unknown" 946 "~n Else: ~p~n", [Else]), 947 {error, Else, ok}. 948 949str_mg_verify_notify_reply({handle_trans_reply, _CH, ?VERSION, 950 {ok, [AR]}, _}) -> 951 io:format("str_mg_verify_notify_reply -> ok" 952 "~n AR: ~p~n", [AR]), 953 {ok, AR, ok}; 954str_mg_verify_notify_reply(Else) -> 955 io:format("str_mg_verify_notify_reply -> unknown" 956 "~n Else: ~p~n", [Else]), 957 {error, Else, ok}. 958 959str_mg_service_change_request_ar(_Mid, Cid) -> 960 Prof = cre_serviceChangeProf("resgw", 1), 961 SCP = cre_serviceChangeParm(restart, ["901 mg col boot"], Prof), 962 Root = #megaco_term_id{id = ["root"]}, 963 SCR = cre_serviceChangeReq([Root], SCP), 964 CMD = cre_command(SCR), 965 CR = cre_cmdReq(CMD), 966 cre_actionReq(Cid, [CR]). 967 968%% str_mg_service_change_request_msg(Mid, TransId, Cid) -> 969%% AR = str_mg_service_change_request_ar(Mid, Cid), 970%% TR = cre_transReq(TransId, [AR]), 971%% Trans = cre_transaction(TR), 972%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 973%% cre_megacoMessage(Mess). 974 975str_mg_notify_request_ar(Rid, Tid, Cid) -> 976 TT = cre_timeNotation("19990729", "22000000"), 977 Ev = cre_obsEvent("al/of", TT), 978 EvsDesc = cre_obsEvsDesc(Rid, [Ev]), 979 NR = cre_notifyReq([Tid], EvsDesc), 980 CMD = cre_command(NR), 981 CR = cre_cmdReq(CMD), 982 cre_actionReq(Cid, [CR]). 983 984%% str_notify_request_msg(Mid, TransId, Rid, TermId, Cid) -> 985%% AR = str_mg_notify_request_ar(Rid, TermId, Cid), 986%% TR = cre_transReq(TransId, [AR]), 987%% Trans = cre_transaction(TR), 988%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 989%% cre_megacoMessage(Mess). 990 991 992%% 993%% Common functions for the single_trans_req test case 994%% 995 996str_err_desc(T) -> 997 EC = ?megaco_internal_gateway_error, 998 ET = lists:flatten(io_lib:format("~w",[T])), 999 #'ErrorDescriptor'{errorCode = EC, errorText = ET}. 1000 1001 1002%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 1003 1004multi_trans_req_timeout(suite) -> 1005 []; 1006multi_trans_req_timeout(doc) -> 1007 []; 1008multi_trans_req_timeout(Config) when is_list(Config) -> 1009 Pre = fun() -> 1010 MgcNode = make_node_name(mgc), 1011 MgNode = make_node_name(mg), 1012 d("start nodes: " 1013 "~n MGC Node: ~p" 1014 "~n MG Node: ~p", 1015 [MgcNode, MgNode]), 1016 Nodes = [MgcNode, MgNode], 1017 ok = ?START_NODES(Nodes), 1018 Nodes 1019 end, 1020 Case = fun do_multi_trans_req_timeout/1, 1021 Post = fun(Nodes) -> 1022 d("stop nodes"), 1023 ?STOP_NODES(lists:reverse(Nodes)) 1024 end, 1025 try_tc(request_and_no_reply, Pre, Case, Post). 1026 1027do_multi_trans_req_timeout([MgcNode, MgNode]) -> 1028 1029 d("[MGC] start the simulator "), 1030 {ok, Mgc} = megaco_test_megaco_generator:start_link("MGC", MgcNode), 1031 1032 d("[MGC] create the event sequence"), 1033 MgcEvSeq = mtrt_mgc_event_sequence(text, tcp), 1034 1035 i("wait some time before starting the MGC simulation"), 1036 sleep(1000), 1037 1038 d("[MGC] start the simulation"), 1039 {ok, MgcId} = megaco_test_megaco_generator:exec(Mgc, MgcEvSeq), 1040 1041 %% i("wait some time before starting the MG simulator"), 1042 %% sleep(1000), 1043 1044 i("await MGC ready announcement"), 1045 receive 1046 announce_mgc -> 1047 i("received MGC ready announcement"), 1048 ok 1049 end, 1050 1051 d("[MG] start the simulator (generator)"), 1052 {ok, Mg} = megaco_test_megaco_generator:start_link("MG", MgNode), 1053 1054 d("[MG] create the event sequence"), 1055 MgEvSeq = mtrt_mg_event_sequence(text, tcp), 1056 1057 i("wait some time before starting the MG simulation"), 1058 sleep(1000), 1059 1060 d("[MG] start the simulation"), 1061 {ok, MgId} = megaco_test_megaco_generator:exec(Mg, MgEvSeq), 1062 1063 d("await the generator reply(s)"), 1064 await_completion([MgcId, MgId]), 1065 1066 %% Tell Mgc to stop 1067 i("[MGC] stop generator"), 1068 megaco_test_megaco_generator:stop(Mgc), 1069 1070 %% Tell Mg to stop 1071 i("[MG] stop generator"), 1072 megaco_test_megaco_generator:stop(Mg), 1073 1074 i("done", []), 1075 ok. 1076 1077 1078%% 1079%% MGC generator stuff 1080%% 1081-ifdef(megaco_hipe_special). 1082-define(mtrt_mgc_verify_handle_connect_fun(), 1083 {?MODULE, mtrt_mgc_verify_handle_connect, []}). 1084-define(mtrt_mgc_verify_service_change_req_fun(Mid), 1085 {?MODULE, mtrt_mgc_verify_service_change_req, [Mid]}). 1086-define(mtrt_mgc_verify_notify_req_fun(), 1087 {?MODULE, mtrt_mgc_verify_notify_request, []}). 1088-define(mtrt_mgc_verify_handle_disconnect_fun(), 1089 {?MODULE, mtrt_mgc_verify_handle_disconnect, []}). 1090-else. 1091-define(mtrt_mgc_verify_handle_connect_fun(), 1092 fun mtrt_mgc_verify_handle_connect/1). 1093-define(mtrt_mgc_verify_service_change_req_fun(Mid), 1094 mtrt_mgc_verify_service_change_req_fun(Mid)). 1095-define(mtrt_mgc_verify_notify_req_fun(), 1096 mtrt_mgc_verify_notify_request_fun()). 1097-define(mtrt_mgc_verify_handle_disconnect_fun(), 1098 fun mtrt_mgc_verify_handle_disconnect/1). 1099-endif. 1100 1101mtrt_mgc_event_sequence(text, tcp) -> 1102 CTRL = self(), 1103 Mid = {deviceName,"ctrl"}, 1104 RI = [ 1105 {port, 2944}, 1106 {encoding_module, megaco_pretty_text_encoder}, 1107 {encoding_config, []}, 1108 {transport_module, megaco_tcp} 1109 ], 1110 ConnectVerify = ?mtrt_mgc_verify_handle_connect_fun(), 1111 ServiceChangeReqVerify = ?mtrt_mgc_verify_service_change_req_fun(Mid), 1112 NotifyReqVerify = ?mtrt_mgc_verify_notify_req_fun(), 1113 DiscoVerify = ?mtrt_mgc_verify_handle_disconnect_fun(), 1114 EvSeq = [ 1115 {debug, true}, 1116 {megaco_trace, disable}, 1117 megaco_start, 1118 {megaco_start_user, Mid, RI, []}, 1119 start_transport, 1120 listen, 1121 1122 %% ANNOUNCE READY 1123 {trigger, fun() -> CTRL ! announce_mgc end}, 1124 1125 {megaco_callback, handle_connect, ConnectVerify}, 1126 {megaco_callback, handle_trans_request, ServiceChangeReqVerify}, 1127 {megaco_callback, handle_trans_request, NotifyReqVerify}, 1128 {megaco_callback, handle_trans_request, NotifyReqVerify}, 1129 {megaco_callback, handle_trans_request, NotifyReqVerify}, 1130 {megaco_callback, handle_trans_request, NotifyReqVerify}, 1131 {megaco_callback, handle_trans_request, NotifyReqVerify}, 1132 {megaco_callback, handle_disconnect, DiscoVerify}, 1133 {sleep, 1000}, 1134 megaco_stop_user, 1135 megaco_stop 1136 ], 1137 EvSeq. 1138 1139 1140mtrt_mgc_verify_handle_connect({handle_connect, CH, ?VERSION}) -> 1141 io:format("mtrt_mgc_verify_handle_connect -> ok" 1142 "~n CH: ~p~n", [CH]), 1143 {ok, CH, ok}; 1144mtrt_mgc_verify_handle_connect(Else) -> 1145 io:format("mtrt_mgc_verify_handle_connect -> unknown" 1146 "~n Else: ~p~n", [Else]), 1147 {error, Else, ok}. 1148 1149mtrt_mgc_verify_service_change_req_fun(Mid) -> 1150 fun(Ev) -> 1151 mtrt_mgc_verify_service_change_req(Ev, Mid) 1152 end. 1153 1154mtrt_mgc_verify_service_change_req( 1155 {handle_trans_request, _, ?VERSION, [AR]}, Mid) -> 1156 io:format("mtrt_mgc_verify_service_change_req -> ok" 1157 "~n AR: ~p~n", [AR]), 1158 case AR of 1159 #'ActionRequest'{commandRequests = [CR]} -> 1160 case CR of 1161 #'CommandRequest'{command = Cmd} -> 1162 case Cmd of 1163 {serviceChangeReq, 1164 #'ServiceChangeRequest'{terminationID = [Tid], 1165 serviceChangeParms = Parms}} -> 1166 case Tid of 1167 #megaco_term_id{contains_wildcards = false, 1168 id = ["root"]} -> 1169 case Parms of 1170 #'ServiceChangeParm'{ 1171 serviceChangeMethod = restart, 1172 serviceChangeReason = [[$9,$0,$1|_]]} -> 1173 Reply = 1174 {discard_ack, 1175 [mtrt_mgc_service_change_reply_ar(Mid, 1)]}, 1176 {ok, AR, Reply}; 1177 _ -> 1178 Err = {invalid_SCP, Parms}, 1179 ED = mtrt_err_desc(Parms), 1180 ErrReply = {discard_ack, 1181 ED}, 1182 {error, Err, ErrReply} 1183 end; 1184 _ -> 1185 Err = {invalid_termination_id, Tid}, 1186 ED = mtrt_err_desc(Tid), 1187 ErrReply = {discard_ack, ED}, 1188 {error, Err, ErrReply} 1189 end; 1190 _ -> 1191 Err = {invalid_command, Cmd}, 1192 ED = mtrt_err_desc(Cmd), 1193 ErrReply = {discard_ack, ED}, 1194 {error, Err, ErrReply} 1195 end; 1196 _ -> 1197 Err = {invalid_command_request, CR}, 1198 ED = mtrt_err_desc(CR), 1199 ErrReply = {discard_ack, ED}, 1200 {error, Err, ErrReply} 1201 end; 1202 _ -> 1203 Err = {invalid_action_request, AR}, 1204 ED = mtrt_err_desc(AR), 1205 ErrReply = {discard_ack, ED}, 1206 {error, Err, ErrReply} 1207 end; 1208mtrt_mgc_verify_service_change_req(Else, _Mid) -> 1209 io:format("mtrt_mgc_verify_service_change_req -> unknown" 1210 "~n Else: ~p~n", [Else]), 1211 ED = mtrt_err_desc(Else), 1212 ErrReply = {discard_ack, ED}, 1213 {error, Else, ErrReply}. 1214 1215mtrt_mgc_verify_notify_request_fun() -> 1216 fun(Ev) -> 1217 mtrt_mgc_verify_notify_request(Ev) 1218 end. 1219 1220mtrt_mgc_verify_notify_request({handle_trans_request, _, ?VERSION, [AR]}) -> 1221 io:format("mtrt_mgc_verify_notify_request:fun -> ok" 1222 "~n AR: ~p~n", [AR]), 1223 case AR of 1224 #'ActionRequest'{contextId = Cid, 1225 commandRequests = [CR]} -> 1226 #'CommandRequest'{command = Cmd} = CR, 1227 {notifyReq, NR} = Cmd, 1228 #'NotifyRequest'{terminationID = [Tid], 1229 observedEventsDescriptor = OED, 1230 errorDescriptor = asn1_NOVALUE} = NR, 1231 #'ObservedEventsDescriptor'{observedEventLst = [OE]} = OED, 1232 #'ObservedEvent'{eventName = "al/of"} = OE, 1233 Reply = {discard_ack, [mtrt_mgc_notify_reply_ar(Cid, Tid)]}, 1234 {ok, AR, Reply}; 1235 _ -> 1236 ED = mtrt_err_desc(AR), 1237 ErrReply = {discard_ack, ED}, 1238 {error, AR, ErrReply} 1239 end; 1240mtrt_mgc_verify_notify_request(Else) -> 1241 io:format("mtrt_mgc_verify_notify_request:fun -> unknown" 1242 "~n Else: ~p~n", [Else]), 1243 ED = mtrt_err_desc(Else), 1244 ErrReply = {discard_ack, ED}, 1245 {error, Else, ErrReply}. 1246 1247mtrt_mgc_verify_handle_disconnect({handle_disconnect, CH, ?VERSION, R}) -> 1248 io:format("mtrt_mgc_verify_handle_disconnect -> ok" 1249 "~n CH: ~p" 1250 "~n R: ~p" 1251 "~n", [CH, R]), 1252 {ok, CH, ok}; 1253mtrt_mgc_verify_handle_disconnect(Else) -> 1254 io:format("mtrt_mgc_verify_handle_disconnect -> unknown" 1255 "~n Else: ~p~n", [Else]), 1256 {error, Else, ok}. 1257 1258 1259mtrt_mgc_service_change_reply_ar(Mid, Cid) -> 1260 SCRP = cre_serviceChangeResParm(Mid), 1261 SCRes = cre_serviceChangeResult(SCRP), 1262 Root = #megaco_term_id{id = ["root"]}, 1263 SCR = cre_serviceChangeReply([Root], SCRes), 1264 CR = cre_cmdReply(SCR), 1265 cre_actionReply(Cid, [CR]). 1266 1267%% mtrt_mgc_service_change_reply_msg(Mid, TransId, Cid) -> 1268%% AR = mtrt_mgc_service_change_reply_ar(Mid, Cid), 1269%% TRes = cre_transResult([AR]), 1270%% TR = cre_transReply(TransId, TRes), 1271%% Trans = cre_transaction(TR), 1272%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 1273%% cre_megacoMessage(Mess). 1274 1275mtrt_mgc_notify_reply_ar(Cid, TermId) -> 1276 NR = cre_notifyReply([TermId]), 1277 CR = cre_cmdReply(NR), 1278 cre_actionReply(Cid, [CR]). 1279 1280%% mtrt_mgc_notify_reply(Mid, TransId, Cid, TermId) -> 1281%% AR = mtrt_mgc_notify_reply_ar(Cid, TermId), 1282%% TRes = cre_transResult([AR]), 1283%% TR = cre_transReply(TransId, TRes), 1284%% Trans = cre_transaction(TR), 1285%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 1286%% cre_megacoMessage(Mess). 1287 1288 1289%% 1290%% MG generator stuff 1291%% 1292-ifdef(megaco_hipe_special). 1293-define(mtrt_mg_verify_handle_connect_fun(), 1294 {?MODULE, mtrt_mg_verify_handle_connect, []}). 1295-define(mtrt_mg_verify_service_change_reply_fun(), 1296 {?MODULE, mtrt_mg_verify_service_change_reply, []}). 1297-define(mtrt_mg_verify_notify_reply_fun(), 1298 {?MODULE, mtrt_mg_verify_notify_reply, []}). 1299-else. 1300-define(mtrt_mg_verify_handle_connect_fun(), 1301 fun mtrt_mg_verify_handle_connect/1). 1302-define(mtrt_mg_verify_service_change_reply_fun(), 1303 fun mtrt_mg_verify_service_change_reply/1). 1304-define(mtrt_mg_verify_notify_reply_fun(), 1305 fun mtrt_mg_verify_notify_reply/1). 1306-endif. 1307 1308mtrt_mg_event_sequence(text, tcp) -> 1309 Mid = {deviceName,"mg"}, 1310 RI = [ 1311 {port, 2944}, 1312 {encoding_module, megaco_pretty_text_encoder}, 1313 {encoding_config, []}, 1314 {transport_module, megaco_tcp} 1315 ], 1316 ServiceChangeReq = [mtrt_mg_service_change_request_ar(Mid, 1)], 1317 Tid = #megaco_term_id{id = ["00000000","00000000","01101101"]}, 1318 NotifyReq = [mtrt_mg_notify_request_ar(1, Tid, 1)], 1319 ConnectVerify = ?mtrt_mg_verify_handle_connect_fun(), 1320 ServiceChangeReplyVerify = ?mtrt_mg_verify_service_change_reply_fun(), 1321 NotifyReplyVerify = ?mtrt_mg_verify_notify_reply_fun(), 1322 EvSeq = [ 1323 {debug, true}, 1324 megaco_start, 1325 {megaco_start_user, Mid, RI, []}, 1326 start_transport, 1327 {megaco_trace, disable}, 1328 {megaco_system_info, users}, 1329 {megaco_system_info, connections}, 1330 connect, 1331 {megaco_callback, handle_connect, ConnectVerify}, 1332 megaco_connect, 1333 {megaco_cast, ServiceChangeReq, []}, 1334 {megaco_callback, handle_connect, ConnectVerify}, 1335 {megaco_callback, handle_trans_reply, ServiceChangeReplyVerify}, 1336 {sleep, 1000}, 1337 {megaco_system_info, users}, 1338 {megaco_system_info, connections}, 1339 {sleep, 1000}, 1340 {megaco_update_conn_info, trans_timer, 5000}, 1341 {megaco_update_conn_info, trans_req, true}, 1342 {megaco_conn_info, all}, 1343 {megaco_cast, NotifyReq, []}, 1344 {megaco_cast, NotifyReq, []}, 1345 {megaco_cast, NotifyReq, []}, 1346 {megaco_cast, NotifyReq, []}, 1347 {megaco_cast, NotifyReq, []}, 1348 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 1349 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 1350 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 1351 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 1352 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 1353 {sleep, 1000}, 1354 megaco_stop_user, 1355 megaco_stop, 1356 {sleep, 1000} 1357 ], 1358 EvSeq. 1359 1360mtrt_mg_verify_handle_connect({handle_connect, CH, ?VERSION}) -> 1361 io:format("mtrt_mg_verify_handle_connect -> ok" 1362 "~n CH: ~p~n", [CH]), 1363 {ok, CH, ok}; 1364mtrt_mg_verify_handle_connect(Else) -> 1365 io:format("mtrt_mg_verify_handle_connect -> unknown" 1366 "~n Else: ~p~n", [Else]), 1367 {error, Else, ok}. 1368 1369mtrt_mg_verify_service_change_reply({handle_trans_reply, _CH, ?VERSION, 1370 {ok, [AR]}, _}) -> 1371 io:format("mtrt_mg_verify_service_change_reply -> ok" 1372 "~n AR: ~p~n", [AR]), 1373 case AR of 1374 #'ActionReply'{commandReply = [SCR]} -> 1375 case SCR of 1376 {serviceChangeReply, 1377 #'ServiceChangeReply'{terminationID = [Tid], 1378 serviceChangeResult = Res}} -> 1379 case Tid of 1380 #megaco_term_id{contains_wildcards = false, 1381 id = ["root"]} -> 1382 case Res of 1383 {serviceChangeResParms, 1384 #'ServiceChangeResParm'{ 1385 serviceChangeMgcId = _RemoteMid}} -> 1386 {ok, AR, ok}; 1387 {Tag, Val} -> 1388 Err = {invalid_service_change_result, 1389 Tag, Val}, 1390 {error, Err, ok} 1391 end; 1392 _ -> 1393 Err = {invalid_termination_id, Tid}, 1394 {error, Err, ok} 1395 end; 1396 {Tag, Val} -> 1397 Err = {invalid_command_reply, Tag, Val}, 1398 {error, Err, ok} 1399 end; 1400 _ -> 1401 Err = {invalid_action_reply, AR}, 1402 {error, Err, ok} 1403 end; 1404mtrt_mg_verify_service_change_reply(Else) -> 1405 io:format("mtrt_mg_verify_service_change_reply -> unknown" 1406 "~n Else: ~p~n", [Else]), 1407 {error, Else, ok}. 1408 1409mtrt_mg_verify_notify_reply({handle_trans_reply, _CH, ?VERSION, 1410 {ok, [AR]}, _}) -> 1411 io:format("mtrt_mg_verify_service_change_reply -> ok" 1412 "~n AR: ~p~n", [AR]), 1413 {ok, AR, ok}; 1414mtrt_mg_verify_notify_reply(Else) -> 1415 io:format("mtrt_mg_verify_service_change_reply -> unknown" 1416 "~n Else: ~p~n", [Else]), 1417 {error, Else, ok}. 1418 1419mtrt_mg_service_change_request_ar(_Mid, Cid) -> 1420 Prof = cre_serviceChangeProf("resgw", 1), 1421 SCP = cre_serviceChangeParm(restart, ["901 mg col boot"], Prof), 1422 Root = #megaco_term_id{id = ["root"]}, 1423 SCR = cre_serviceChangeReq([Root], SCP), 1424 CMD = cre_command(SCR), 1425 CR = cre_cmdReq(CMD), 1426 cre_actionReq(Cid, [CR]). 1427 1428%% mtrt_mg_service_change_request_msg(Mid, TransId, Cid) -> 1429%% AR = mtrt_mg_service_change_request_ar(Mid, Cid), 1430%% TR = cre_transReq(TransId, [AR]), 1431%% Trans = cre_transaction(TR), 1432%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 1433%% cre_megacoMessage(Mess). 1434 1435mtrt_mg_notify_request_ar(Rid, Tid, Cid) -> 1436 TT = cre_timeNotation("19990729", "22000000"), 1437 Ev = cre_obsEvent("al/of", TT), 1438 EvsDesc = cre_obsEvsDesc(Rid, [Ev]), 1439 NR = cre_notifyReq([Tid], EvsDesc), 1440 CMD = cre_command(NR), 1441 CR = cre_cmdReq(CMD), 1442 cre_actionReq(Cid, [CR]). 1443 1444%% mtrt_notify_request_msg(Mid, TransId, Rid, TermId, Cid) -> 1445%% AR = mtrt_mg_notify_request_ar(Rid, TermId, Cid), 1446%% TR = cre_transReq(TransId, [AR]), 1447%% Trans = cre_transaction(TR), 1448%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 1449%% cre_megacoMessage(Mess). 1450 1451 1452%% 1453%% Common functions for the multi_trans_req_timeout test case 1454%% 1455 1456mtrt_err_desc(T) -> 1457 EC = ?megaco_internal_gateway_error, 1458 ET = lists:flatten(io_lib:format("~w",[T])), 1459 #'ErrorDescriptor'{errorCode = EC, errorText = ET}. 1460 1461 1462%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 1463 1464multi_trans_req_maxcount1(suite) -> 1465 []; 1466multi_trans_req_maxcount1(doc) -> 1467 "Test that a message is sent when req_maxcount is reached"; 1468multi_trans_req_maxcount1(Config) when is_list(Config) -> 1469 Pre = fun() -> 1470 MgcNode = make_node_name(mgc), 1471 MgNode = make_node_name(mg), 1472 d("start nodes: " 1473 "~n MGC Node: ~p" 1474 "~n MG Node: ~p", 1475 [MgcNode, MgNode]), 1476 Nodes = [MgcNode, MgNode], 1477 ok = ?START_NODES(Nodes), 1478 Nodes 1479 end, 1480 Case = fun do_multi_trans_req_maxcount1/1, 1481 Post = fun(Nodes) -> 1482 d("stop nodes"), 1483 ?STOP_NODES(lists:reverse(Nodes)) 1484 end, 1485 try_tc(multi_trans_req_maxcount1, Pre, Case, Post). 1486 1487do_multi_trans_req_maxcount1([MgcNode, MgNode]) -> 1488 d("[MGC] start the simulator "), 1489 {ok, Mgc} = megaco_test_megaco_generator:start_link("MGC", MgcNode), 1490 1491 d("[MGC] create the event sequence"), 1492 MgcEvSeq = mtrmc1_mgc_event_sequence(text, tcp), 1493 1494 i("wait some time before starting the MGC simulation"), 1495 sleep(1000), 1496 1497 d("[MGC] start the simulation"), 1498 {ok, MgcId} = megaco_test_megaco_generator:exec(Mgc, MgcEvSeq), 1499 1500 %% i("wait some time before starting the MG simulator"), 1501 %% sleep(1000), 1502 1503 i("await MGC ready announcement"), 1504 receive 1505 announce_mgc -> 1506 i("received MGC ready announcement"), 1507 ok 1508 end, 1509 1510 d("[MG] start the simulator (generator)"), 1511 {ok, Mg} = megaco_test_megaco_generator:start_link("MG", MgNode), 1512 1513 d("[MG] create the event sequence"), 1514 MgEvSeq = mtrmc1_mg_event_sequence(text, tcp), 1515 1516 i("wait some time before starting the MG simulation"), 1517 sleep(1000), 1518 1519 d("[MG] start the simulation"), 1520 {ok, MgId} = megaco_test_megaco_generator:exec(Mg, MgEvSeq), 1521 1522 d("await the generator reply(s)"), 1523 await_completion([MgcId, MgId]), 1524 1525 %% Tell Mgc to stop 1526 i("[MGC] stop generator"), 1527 megaco_test_megaco_generator:stop(Mgc), 1528 1529 %% Tell Mg to stop 1530 i("[MG] stop generator"), 1531 megaco_test_megaco_generator:stop(Mg), 1532 1533 i("done", []), 1534 ok. 1535 1536 1537%% 1538%% MGC generator stuff 1539%% 1540-ifdef(megaco_hipe_special). 1541-define(mtrmc1_mgc_verify_handle_connect_fun(), 1542 {?MODULE, mtrmc1_mgc_verify_handle_connect, []}). 1543-define(mtrmc1_mgc_verify_service_change_req_fun(Mid), 1544 {?MODULE, mtrmc1_mgc_verify_service_change_req, [Mid]}). 1545-define(mtrmc1_mgc_verify_notify_req_fun(), 1546 {?MODULE, mtrmc1_mgc_verify_notify_request, []}). 1547-define(mtrmc1_mgc_verify_handle_disconnect_fun(), 1548 {?MODULE, mtrmc1_mgc_verify_handle_disconnect, []}). 1549-else. 1550-define(mtrmc1_mgc_verify_handle_connect_fun(), 1551 fun mtrmc1_mgc_verify_handle_connect/1). 1552-define(mtrmc1_mgc_verify_service_change_req_fun(Mid), 1553 mtrmc1_mgc_verify_service_change_req_fun(Mid)). 1554-define(mtrmc1_mgc_verify_notify_req_fun(), 1555 mtrmc1_mgc_verify_notify_request_fun()). 1556-define(mtrmc1_mgc_verify_handle_disconnect_fun(), 1557 fun mtrmc1_mgc_verify_handle_disconnect/1). 1558-endif. 1559 1560mtrmc1_mgc_event_sequence(text, tcp) -> 1561 CTRL = self(), 1562 Mid = {deviceName,"ctrl"}, 1563 RI = [ 1564 {port, 2944}, 1565 {encoding_module, megaco_pretty_text_encoder}, 1566 {encoding_config, []}, 1567 {transport_module, megaco_tcp} 1568 ], 1569 ConnectVerify = ?mtrmc1_mgc_verify_handle_connect_fun(), 1570 ServiceChangeReqVerify = ?mtrmc1_mgc_verify_service_change_req_fun(Mid), 1571 NotifyReqVerify = ?mtrmc1_mgc_verify_notify_req_fun(), 1572 DiscoVerify = ?mtrmc1_mgc_verify_handle_disconnect_fun(), 1573 EvSeq = [ 1574 {debug, true}, 1575 {megaco_trace, disable}, 1576 megaco_start, 1577 {megaco_start_user, Mid, RI, []}, 1578 start_transport, 1579 listen, 1580 1581 %% ANNOUNCE READY 1582 {trigger, fun() -> CTRL ! announce_mgc end}, 1583 1584 {megaco_callback, handle_connect, ConnectVerify}, 1585 {megaco_callback, handle_trans_request, ServiceChangeReqVerify}, 1586 {megaco_callback, handle_trans_request, NotifyReqVerify}, 1587 {megaco_callback, handle_trans_request, NotifyReqVerify}, 1588 {megaco_callback, handle_trans_request, NotifyReqVerify}, 1589 {megaco_callback, handle_trans_request, NotifyReqVerify}, 1590 {megaco_callback, handle_trans_request, NotifyReqVerify}, 1591 {megaco_callback, handle_disconnect, DiscoVerify}, 1592 {sleep, 1000}, 1593 megaco_stop_user, 1594 megaco_stop 1595 ], 1596 EvSeq. 1597 1598 1599mtrmc1_mgc_verify_handle_connect({handle_connect, CH, ?VERSION}) -> 1600 io:format("mtrmc1_mgc_verify_handle_connect -> ok" 1601 "~n CH: ~p~n", [CH]), 1602 {ok, CH, ok}; 1603mtrmc1_mgc_verify_handle_connect(Else) -> 1604 io:format("mtrmc1_mgc_verify_handle_connect -> unknown" 1605 "~n Else: ~p~n", [Else]), 1606 {error, Else, ok}. 1607 1608mtrmc1_mgc_verify_service_change_req_fun(Mid) -> 1609 fun(Ev) -> 1610 mtrmc1_mgc_verify_service_change_req(Ev, Mid) 1611 end. 1612 1613mtrmc1_mgc_verify_service_change_req( 1614 {handle_trans_request, _, ?VERSION, [AR]}, Mid) -> 1615 io:format("mtrmc1_mgc_verify_service_change_req -> ok" 1616 "~n AR: ~p~n", [AR]), 1617 case AR of 1618 #'ActionRequest'{commandRequests = [CR]} -> 1619 case CR of 1620 #'CommandRequest'{command = Cmd} -> 1621 case Cmd of 1622 {serviceChangeReq, 1623 #'ServiceChangeRequest'{terminationID = [Tid], 1624 serviceChangeParms = Parms}} -> 1625 case Tid of 1626 #megaco_term_id{contains_wildcards = false, 1627 id = ["root"]} -> 1628 case Parms of 1629 #'ServiceChangeParm'{ 1630 serviceChangeMethod = restart, 1631 serviceChangeReason = [[$9,$0,$1|_]]} -> 1632 Reply = 1633 {discard_ack, 1634 [mtrmc1_mgc_service_change_reply_ar(Mid, 1)]}, 1635 {ok, AR, Reply}; 1636 _ -> 1637 Err = {invalid_SCP, Parms}, 1638 ED = mtrmc1_err_desc(Parms), 1639 ErrReply = {discard_ack, 1640 ED}, 1641 {error, Err, ErrReply} 1642 end; 1643 _ -> 1644 Err = {invalid_termination_id, Tid}, 1645 ED = mtrmc1_err_desc(Tid), 1646 ErrReply = {discard_ack, ED}, 1647 {error, Err, ErrReply} 1648 end; 1649 _ -> 1650 Err = {invalid_command, Cmd}, 1651 ED = mtrmc1_err_desc(Cmd), 1652 ErrReply = {discard_ack, ED}, 1653 {error, Err, ErrReply} 1654 end; 1655 _ -> 1656 Err = {invalid_command_request, CR}, 1657 ED = mtrmc1_err_desc(CR), 1658 ErrReply = {discard_ack, ED}, 1659 {error, Err, ErrReply} 1660 end; 1661 _ -> 1662 Err = {invalid_action_request, AR}, 1663 ED = mtrmc1_err_desc(AR), 1664 ErrReply = {discard_ack, ED}, 1665 {error, Err, ErrReply} 1666 end; 1667mtrmc1_mgc_verify_service_change_req(Else, _Mid) -> 1668 io:format("mtrmc1_mgc_verify_service_change_req -> unknown" 1669 "~n Else: ~p~n", [Else]), 1670 ED = mtrmc1_err_desc(Else), 1671 ErrReply = {discard_ack, ED}, 1672 {error, Else, ErrReply}. 1673 1674mtrmc1_mgc_verify_notify_request_fun() -> 1675 fun(Ev) -> 1676 mtrmc1_mgc_verify_notify_request(Ev) 1677 end. 1678 1679mtrmc1_mgc_verify_notify_request({handle_trans_request, _, ?VERSION, [AR]}) -> 1680 io:format("mtrmc1_mgc_verify_notify_request:fun -> ok" 1681 "~n AR: ~p~n", [AR]), 1682 case AR of 1683 #'ActionRequest'{contextId = Cid, 1684 commandRequests = [CR]} -> 1685 #'CommandRequest'{command = Cmd} = CR, 1686 {notifyReq, NR} = Cmd, 1687 #'NotifyRequest'{terminationID = [Tid], 1688 observedEventsDescriptor = OED, 1689 errorDescriptor = asn1_NOVALUE} = NR, 1690 #'ObservedEventsDescriptor'{observedEventLst = [OE]} = OED, 1691 #'ObservedEvent'{eventName = "al/of"} = OE, 1692 Reply = {discard_ack, [mtrmc1_mgc_notify_reply_ar(Cid, Tid)]}, 1693 {ok, AR, Reply}; 1694 _ -> 1695 ED = mtrmc1_err_desc(AR), 1696 ErrReply = {discard_ack, ED}, 1697 {error, AR, ErrReply} 1698 end; 1699mtrmc1_mgc_verify_notify_request(Else) -> 1700 io:format("mtrmc1_mgc_verify_notify_request:fun -> unknown" 1701 "~n Else: ~p~n", [Else]), 1702 ED = mtrmc1_err_desc(Else), 1703 ErrReply = {discard_ack, ED}, 1704 {error, Else, ErrReply}. 1705 1706mtrmc1_mgc_verify_handle_disconnect({handle_disconnect, CH, ?VERSION, R}) -> 1707 io:format("mtrmc1_mgc_verify_handle_disconnect -> ok" 1708 "~n CH: ~p" 1709 "~n R: ~p" 1710 "~n", [CH, R]), 1711 {ok, CH, ok}; 1712mtrmc1_mgc_verify_handle_disconnect(Else) -> 1713 io:format("mtrmc1_mgc_verify_handle_disconnect -> unknown" 1714 "~n Else: ~p~n", [Else]), 1715 {error, Else, ok}. 1716 1717 1718mtrmc1_mgc_service_change_reply_ar(Mid, Cid) -> 1719 SCRP = cre_serviceChangeResParm(Mid), 1720 SCRes = cre_serviceChangeResult(SCRP), 1721 Root = #megaco_term_id{id = ["root"]}, 1722 SCR = cre_serviceChangeReply([Root], SCRes), 1723 CR = cre_cmdReply(SCR), 1724 cre_actionReply(Cid, [CR]). 1725 1726%% mtrmc1_mgc_service_change_reply_msg(Mid, TransId, Cid) -> 1727%% AR = mtrmc1_mgc_service_change_reply_ar(Mid, Cid), 1728%% TRes = cre_transResult([AR]), 1729%% TR = cre_transReply(TransId, TRes), 1730%% Trans = cre_transaction(TR), 1731%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 1732%% cre_megacoMessage(Mess). 1733 1734mtrmc1_mgc_notify_reply_ar(Cid, TermId) -> 1735 NR = cre_notifyReply([TermId]), 1736 CR = cre_cmdReply(NR), 1737 cre_actionReply(Cid, [CR]). 1738 1739%% mtrmc1_mgc_notify_reply(Mid, TransId, Cid, TermId) -> 1740%% AR = mtrmc1_mgc_notify_reply_ar(Cid, TermId), 1741%% TRes = cre_transResult([AR]), 1742%% TR = cre_transReply(TransId, TRes), 1743%% Trans = cre_transaction(TR), 1744%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 1745%% cre_megacoMessage(Mess). 1746 1747 1748%% 1749%% MG generator stuff 1750%% 1751-ifdef(megaco_hipe_special). 1752-define(mtrmc1_mg_verify_handle_connect_fun(), 1753 {?MODULE, mtrmc1_mg_verify_handle_connect, []}). 1754-define(mtrmc1_mg_verify_service_change_reply_fun(), 1755 {?MODULE, mtrmc1_mg_verify_service_change_reply, []}). 1756-define(mtrmc1_mg_verify_notify_reply_fun(), 1757 {?MODULE, mtrmc1_mg_verify_notify_reply, []}). 1758-else. 1759-define(mtrmc1_mg_verify_handle_connect_fun(), 1760 fun mtrmc1_mg_verify_handle_connect/1). 1761-define(mtrmc1_mg_verify_service_change_reply_fun(), 1762 fun mtrmc1_mg_verify_service_change_reply/1). 1763-define(mtrmc1_mg_verify_notify_reply_fun(), 1764 fun mtrmc1_mg_verify_notify_reply/1). 1765-endif. 1766 1767mtrmc1_mg_event_sequence(text, tcp) -> 1768 Mid = {deviceName,"mg"}, 1769 RI = [ 1770 {port, 2944}, 1771 {encoding_module, megaco_pretty_text_encoder}, 1772 {encoding_config, []}, 1773 {transport_module, megaco_tcp} 1774 ], 1775 ServiceChangeReq = [mtrmc1_mg_service_change_request_ar(Mid, 1)], 1776 Tid = #megaco_term_id{id = ["00000000","00000000","01101101"]}, 1777 NotifyReq = [mtrmc1_mg_notify_request_ar(1, Tid, 1)], 1778 ConnectVerify = ?mtrmc1_mg_verify_handle_connect_fun(), 1779 ServiceChangeReplyVerify = ?mtrmc1_mg_verify_service_change_reply_fun(), 1780 NotifyReplyVerify = ?mtrmc1_mg_verify_notify_reply_fun(), 1781 EvSeq = [ 1782 {debug, true}, 1783 megaco_start, 1784 {megaco_start_user, Mid, RI, []}, 1785 start_transport, 1786 {megaco_trace, disable}, 1787 {megaco_system_info, users}, 1788 {megaco_system_info, connections}, 1789 connect, 1790 {megaco_callback, handle_connect, ConnectVerify}, 1791 megaco_connect, 1792 {megaco_cast, ServiceChangeReq, []}, 1793 {megaco_callback, handle_connect, ConnectVerify}, 1794 {megaco_callback, handle_trans_reply, ServiceChangeReplyVerify}, 1795 {sleep, 1000}, 1796 {megaco_system_info, users}, 1797 {megaco_system_info, connections}, 1798 {sleep, 1000}, 1799 {megaco_update_conn_info, trans_req_maxcount, 5}, 1800 {megaco_update_conn_info, trans_req_maxsize, 4096}, 1801 {megaco_update_conn_info, trans_timer, 120000}, 1802 {megaco_update_conn_info, trans_req, true}, 1803 {megaco_conn_info, all}, 1804 {megaco_cast, NotifyReq, []}, 1805 {megaco_cast, NotifyReq, []}, 1806 {megaco_cast, NotifyReq, []}, 1807 {megaco_cast, NotifyReq, []}, 1808 {megaco_cast, NotifyReq, []}, 1809 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 1810 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 1811 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 1812 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 1813 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 1814 {sleep, 1000}, 1815 megaco_stop_user, 1816 megaco_stop, 1817 {sleep, 1000} 1818 ], 1819 EvSeq. 1820 1821mtrmc1_mg_verify_handle_connect({handle_connect, CH, ?VERSION}) -> 1822 io:format("mtrmc1_mg_verify_handle_connect -> ok" 1823 "~n CH: ~p~n", [CH]), 1824 {ok, CH, ok}; 1825mtrmc1_mg_verify_handle_connect(Else) -> 1826 io:format("mtrmc1_mg_verify_handle_connect -> unknown" 1827 "~n Else: ~p~n", [Else]), 1828 {error, Else, ok}. 1829 1830mtrmc1_mg_verify_service_change_reply({handle_trans_reply, _CH, ?VERSION, 1831 {ok, [AR]}, _}) -> 1832 io:format("mtrmc1_mg_verify_service_change_reply -> ok" 1833 "~n AR: ~p~n", [AR]), 1834 case AR of 1835 #'ActionReply'{commandReply = [SCR]} -> 1836 case SCR of 1837 {serviceChangeReply, 1838 #'ServiceChangeReply'{terminationID = [Tid], 1839 serviceChangeResult = Res}} -> 1840 case Tid of 1841 #megaco_term_id{contains_wildcards = false, 1842 id = ["root"]} -> 1843 case Res of 1844 {serviceChangeResParms, 1845 #'ServiceChangeResParm'{ 1846 serviceChangeMgcId = _RemoteMid}} -> 1847 {ok, AR, ok}; 1848 {Tag, Val} -> 1849 Err = {invalid_service_change_result, 1850 Tag, Val}, 1851 {error, Err, ok} 1852 end; 1853 _ -> 1854 Err = {invalid_termination_id, Tid}, 1855 {error, Err, ok} 1856 end; 1857 {Tag, Val} -> 1858 Err = {invalid_command_reply, Tag, Val}, 1859 {error, Err, ok} 1860 end; 1861 _ -> 1862 Err = {invalid_action_reply, AR}, 1863 {error, Err, ok} 1864 end; 1865mtrmc1_mg_verify_service_change_reply(Else) -> 1866 io:format("mtrmc1_mg_verify_service_change_reply -> unknown" 1867 "~n Else: ~p~n", [Else]), 1868 {error, Else, ok}. 1869 1870mtrmc1_mg_verify_notify_reply({handle_trans_reply, _CH, ?VERSION, 1871 {ok, [AR]}, _}) -> 1872 io:format("mtrmc1_mg_verify_service_change_reply -> ok" 1873 "~n AR: ~p~n", [AR]), 1874 {ok, AR, ok}; 1875mtrmc1_mg_verify_notify_reply(Else) -> 1876 io:format("mtrmc1_mg_verify_service_change_reply -> unknown" 1877 "~n Else: ~p~n", [Else]), 1878 {error, Else, ok}. 1879 1880mtrmc1_mg_service_change_request_ar(_Mid, Cid) -> 1881 Prof = cre_serviceChangeProf("resgw", 1), 1882 SCP = cre_serviceChangeParm(restart, ["901 mg col boot"], Prof), 1883 Root = #megaco_term_id{id = ["root"]}, 1884 SCR = cre_serviceChangeReq([Root], SCP), 1885 CMD = cre_command(SCR), 1886 CR = cre_cmdReq(CMD), 1887 cre_actionReq(Cid, [CR]). 1888 1889%% mtrmc1_mg_service_change_request_msg(Mid, TransId, Cid) -> 1890%% AR = mtrmc1_mg_service_change_request_ar(Mid, Cid), 1891%% TR = cre_transReq(TransId, [AR]), 1892%% Trans = cre_transaction(TR), 1893%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 1894%% cre_megacoMessage(Mess). 1895 1896mtrmc1_mg_notify_request_ar(Rid, Tid, Cid) -> 1897 TT = cre_timeNotation("19990729", "22000000"), 1898 Ev = cre_obsEvent("al/of", TT), 1899 EvsDesc = cre_obsEvsDesc(Rid, [Ev]), 1900 NR = cre_notifyReq([Tid], EvsDesc), 1901 CMD = cre_command(NR), 1902 CR = cre_cmdReq(CMD), 1903 cre_actionReq(Cid, [CR]). 1904 1905%% mtrmc1_notify_request_msg(Mid, TransId, Rid, TermId, Cid) -> 1906%% AR = mtrmc1_mg_notify_request_ar(Rid, TermId, Cid), 1907%% TR = cre_transReq(TransId, [AR]), 1908%% Trans = cre_transaction(TR), 1909%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 1910%% cre_megacoMessage(Mess). 1911 1912 1913%% 1914%% Common functions for the multi_trans_req_timeout test case 1915%% 1916 1917mtrmc1_err_desc(T) -> 1918 EC = ?megaco_internal_gateway_error, 1919 ET = lists:flatten(io_lib:format("~w",[T])), 1920 #'ErrorDescriptor'{errorCode = EC, errorText = ET}. 1921 1922 1923%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 1924 1925multi_trans_req_maxcount2(suite) -> 1926 []; 1927multi_trans_req_maxcount2(doc) -> 1928 "Test that the message is sent when req_maxcount is reached " 1929 "with a request bigger then maxsize limit"; 1930multi_trans_req_maxcount2(Config) when is_list(Config) -> 1931 Pre = fun() -> 1932 MgcNode = make_node_name(mgc), 1933 MgNode = make_node_name(mg), 1934 d("start nodes: " 1935 "~n MGC Node: ~p" 1936 "~n MG Node: ~p", 1937 [MgcNode, MgNode]), 1938 Nodes = [MgcNode, MgNode], 1939 ok = ?START_NODES(Nodes), 1940 Nodes 1941 end, 1942 Case = fun do_multi_trans_req_maxcount2/1, 1943 Post = fun(Nodes) -> 1944 d("stop nodes"), 1945 ?STOP_NODES(lists:reverse(Nodes)) 1946 end, 1947 try_tc(multi_trans_req_maxcount2, Pre, Case, Post). 1948 1949do_multi_trans_req_maxcount2([MgcNode, MgNode]) -> 1950 1951 d("[MGC] start the simulator "), 1952 {ok, Mgc} = megaco_test_megaco_generator:start_link("MGC", MgcNode), 1953 1954 d("[MGC] create the event sequence"), 1955 MgcEvSeq = mtrmc2_mgc_event_sequence(text, tcp), 1956 1957 i("wait some time before starting the MGC simulation"), 1958 sleep(1000), 1959 1960 d("[MGC] start the simulation"), 1961 {ok, MgcId} = megaco_test_megaco_generator:exec(Mgc, MgcEvSeq), 1962 1963 %% i("wait some time before starting the MG simulator"), 1964 %% sleep(1000), 1965 1966 i("await MGC ready announcement"), 1967 receive 1968 announce_mgc -> 1969 i("received MGC ready announcement"), 1970 ok 1971 end, 1972 1973 d("[MG] start the simulator (generator)"), 1974 {ok, Mg} = megaco_test_megaco_generator:start_link("MG", MgNode), 1975 1976 d("[MG] create the event sequence"), 1977 MgEvSeq = mtrmc2_mg_event_sequence(text, tcp), 1978 1979 i("wait some time before starting the MG simulation"), 1980 sleep(1000), 1981 1982 d("[MG] start the simulation"), 1983 {ok, MgId} = megaco_test_megaco_generator:exec(Mg, MgEvSeq), 1984 1985 d("await the generator reply(s)"), 1986 await_completion([MgcId, MgId]), 1987 1988 %% Tell Mgc to stop 1989 i("[MGC] stop generator"), 1990 megaco_test_megaco_generator:stop(Mgc), 1991 1992 %% Tell Mg to stop 1993 i("[MG] stop generator"), 1994 megaco_test_megaco_generator:stop(Mg), 1995 1996 i("done", []), 1997 ok. 1998 1999 2000%% 2001%% MGC generator stuff 2002%% 2003-ifdef(megaco_hipe_special). 2004-define(mtrmc2_mgc_verify_handle_connect_fun(), 2005 {?MODULE, mtrmc2_mgc_verify_handle_connect, []}). 2006-define(mtrmc2_mgc_verify_service_change_req_fun(Mid), 2007 {?MODULE, mtrmc2_mgc_verify_service_change_req, [Mid]}). 2008-define(mtrmc2_mgc_verify_notify_req_fun(), 2009 {?MODULE, mtrmc2_mgc_verify_notify_request, []}). 2010-define(mtrmc2_mgc_verify_handle_disconnect_fun(), 2011 {?MODULE, mtrmc2_mgc_verify_handle_disconnect, []}). 2012-else. 2013-define(mtrmc2_mgc_verify_handle_connect_fun(), 2014 fun mtrmc2_mgc_verify_handle_connect/1). 2015-define(mtrmc2_mgc_verify_service_change_req_fun(Mid), 2016 mtrmc2_mgc_verify_service_change_req_fun(Mid)). 2017-define(mtrmc2_mgc_verify_notify_req_fun(), 2018 mtrmc2_mgc_verify_notify_request_fun()). 2019-define(mtrmc2_mgc_verify_handle_disconnect_fun(), 2020 fun mtrmc2_mgc_verify_handle_disconnect/1). 2021-endif. 2022 2023mtrmc2_mgc_event_sequence(text, tcp) -> 2024 CTRL = self(), 2025 Mid = {deviceName,"ctrl"}, 2026 RI = [ 2027 {port, 2944}, 2028 {encoding_module, megaco_pretty_text_encoder}, 2029 {encoding_config, []}, 2030 {transport_module, megaco_tcp} 2031 ], 2032 ConnectVerify = ?mtrmc2_mgc_verify_handle_connect_fun(), 2033 ServiceChangeReqVerify = ?mtrmc2_mgc_verify_service_change_req_fun(Mid), 2034 NotifyReqVerify = ?mtrmc2_mgc_verify_notify_req_fun(), 2035 DiscoVerify = ?mtrmc2_mgc_verify_handle_disconnect_fun(), 2036 EvSeq = [ 2037 {debug, true}, 2038 {megaco_trace, disable}, 2039 megaco_start, 2040 {megaco_start_user, Mid, RI, []}, 2041 start_transport, 2042 listen, 2043 2044 %% ANNOUNCE READY 2045 {trigger, fun() -> CTRL ! announce_mgc end}, 2046 2047 {megaco_callback, handle_connect, ConnectVerify}, 2048 {megaco_callback, handle_trans_request, ServiceChangeReqVerify}, 2049 {megaco_callback, handle_trans_request, NotifyReqVerify}, 2050 {megaco_callback, handle_trans_request, NotifyReqVerify}, 2051 {megaco_callback, handle_trans_request, NotifyReqVerify}, 2052 {megaco_callback, handle_trans_request, NotifyReqVerify}, 2053 {megaco_callback, handle_trans_request, NotifyReqVerify}, 2054 {megaco_callback, handle_disconnect, DiscoVerify}, 2055 {sleep, 1000}, 2056 megaco_stop_user, 2057 megaco_stop 2058 ], 2059 EvSeq. 2060 2061 2062mtrmc2_mgc_verify_handle_connect({handle_connect, CH, ?VERSION}) -> 2063 io:format("mtrmc2_mgc_verify_handle_connect -> ok" 2064 "~n CH: ~p~n", [CH]), 2065 {ok, CH, ok}; 2066mtrmc2_mgc_verify_handle_connect(Else) -> 2067 io:format("mtrmc2_mgc_verify_handle_connect -> unknown" 2068 "~n Else: ~p~n", [Else]), 2069 {error, Else, ok}. 2070 2071mtrmc2_mgc_verify_service_change_req_fun(Mid) -> 2072 fun(Ev) -> 2073 mtrmc2_mgc_verify_service_change_req(Ev, Mid) 2074 end. 2075 2076mtrmc2_mgc_verify_service_change_req( 2077 {handle_trans_request, _, ?VERSION, [AR]}, Mid) -> 2078 io:format("mtrmc2_mgc_verify_service_change_req -> ok" 2079 "~n AR: ~p~n", [AR]), 2080 case AR of 2081 #'ActionRequest'{commandRequests = [CR]} -> 2082 case CR of 2083 #'CommandRequest'{command = Cmd} -> 2084 case Cmd of 2085 {serviceChangeReq, 2086 #'ServiceChangeRequest'{terminationID = [Tid], 2087 serviceChangeParms = Parms}} -> 2088 case Tid of 2089 #megaco_term_id{contains_wildcards = false, 2090 id = ["root"]} -> 2091 case Parms of 2092 #'ServiceChangeParm'{ 2093 serviceChangeMethod = restart, 2094 serviceChangeReason = [[$9,$0,$1|_]]} -> 2095 Reply = 2096 {discard_ack, 2097 [mtrmc2_mgc_service_change_reply_ar(Mid, 1)]}, 2098 {ok, AR, Reply}; 2099 _ -> 2100 Err = {invalid_SCP, Parms}, 2101 ED = mtrmc2_err_desc(Parms), 2102 ErrReply = {discard_ack, 2103 ED}, 2104 {error, Err, ErrReply} 2105 end; 2106 _ -> 2107 Err = {invalid_termination_id, Tid}, 2108 ED = mtrmc2_err_desc(Tid), 2109 ErrReply = {discard_ack, ED}, 2110 {error, Err, ErrReply} 2111 end; 2112 _ -> 2113 Err = {invalid_command, Cmd}, 2114 ED = mtrmc2_err_desc(Cmd), 2115 ErrReply = {discard_ack, ED}, 2116 {error, Err, ErrReply} 2117 end; 2118 _ -> 2119 Err = {invalid_command_request, CR}, 2120 ED = mtrmc2_err_desc(CR), 2121 ErrReply = {discard_ack, ED}, 2122 {error, Err, ErrReply} 2123 end; 2124 _ -> 2125 Err = {invalid_action_request, AR}, 2126 ED = mtrmc2_err_desc(AR), 2127 ErrReply = {discard_ack, ED}, 2128 {error, Err, ErrReply} 2129 end; 2130mtrmc2_mgc_verify_service_change_req(Else, _Mid) -> 2131 io:format("mtrmc2_mgc_verify_service_change_req -> unknown" 2132 "~n Else: ~p~n", [Else]), 2133 ED = mtrmc2_err_desc(Else), 2134 ErrReply = {discard_ack, ED}, 2135 {error, Else, ErrReply}. 2136 2137mtrmc2_mgc_verify_notify_request_fun() -> 2138 fun(Ev) -> 2139 mtrmc2_mgc_verify_notify_request(Ev) 2140 end. 2141 2142mtrmc2_mgc_verify_notify_request({handle_trans_request, _, ?VERSION, [AR]}) -> 2143 io:format("mtrmc2_mgc_verify_notify_request:fun -> ok" 2144 "~n AR: ~p~n", [AR]), 2145 case AR of 2146 #'ActionRequest'{contextId = Cid, 2147 commandRequests = [CR]} -> 2148 io:format("mtrmc2_mgc_verify_notify_request:fun -> " 2149 "single command",[]), 2150 #'CommandRequest'{command = Cmd} = CR, 2151 {notifyReq, NR} = Cmd, 2152 #'NotifyRequest'{terminationID = [Tid], 2153 observedEventsDescriptor = OED, 2154 errorDescriptor = asn1_NOVALUE} = NR, 2155 #'ObservedEventsDescriptor'{observedEventLst = [OE]} = OED, 2156 #'ObservedEvent'{eventName = "al/of"} = OE, 2157 Reply = {discard_ack, 2158 [mtrmc2_mgc_notify_reply_ar1(Cid, Tid)]}, 2159 {ok, AR, Reply}; 2160 #'ActionRequest'{contextId = Cid, 2161 commandRequests = CRs} -> 2162 io:format("mtrmc2_mgc_verify_notify_request:fun -> " 2163 "multi command (~w)",[length(CRs)]), 2164 Tids = [Tid || 2165 #'CommandRequest'{command = 2166 {notifyReq, 2167 #'NotifyRequest'{ 2168 terminationID = [Tid]}}} 2169 <- CRs], 2170 Reply = 2171 {discard_ack, 2172 [mtrmc2_mgc_notify_reply_ar2(Cid, Tids)]}, 2173 {ok, AR, Reply}; 2174 _ -> 2175 ED = mtrmc2_err_desc(AR), 2176 ErrReply = {discard_ack, ED}, 2177 {error, AR, ErrReply} 2178 end; 2179mtrmc2_mgc_verify_notify_request(Else) -> 2180 io:format("mtrmc2_mgc_verify_notify_request:fun -> unknown" 2181 "~n Else: ~p~n", [Else]), 2182 ED = mtrmc2_err_desc(Else), 2183 ErrReply = {discard_ack, ED}, 2184 {error, Else, ErrReply}. 2185 2186mtrmc2_mgc_verify_handle_disconnect({handle_disconnect, CH, ?VERSION, R}) -> 2187 io:format("mtrmc2_mgc_verify_handle_disconnect -> ok" 2188 "~n CH: ~p" 2189 "~n R: ~p" 2190 "~n", [CH, R]), 2191 {ok, CH, ok}; 2192mtrmc2_mgc_verify_handle_disconnect(Else) -> 2193 io:format("mtrmc2_mgc_verify_handle_disconnect -> unknown" 2194 "~n Else: ~p~n", [Else]), 2195 {error, Else, ok}. 2196 2197 2198mtrmc2_mgc_service_change_reply_ar(Mid, Cid) -> 2199 SCRP = cre_serviceChangeResParm(Mid), 2200 SCRes = cre_serviceChangeResult(SCRP), 2201 Root = #megaco_term_id{id = ["root"]}, 2202 SCR = cre_serviceChangeReply([Root], SCRes), 2203 CR = cre_cmdReply(SCR), 2204 cre_actionReply(Cid, [CR]). 2205 2206%% mtrmc2_mgc_service_change_reply_msg(Mid, TransId, Cid) -> 2207%% AR = mtrmc2_mgc_service_change_reply_ar(Mid, Cid), 2208%% TRes = cre_transResult([AR]), 2209%% TR = cre_transReply(TransId, TRes), 2210%% Trans = cre_transaction(TR), 2211%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 2212%% cre_megacoMessage(Mess). 2213 2214mtrmc2_mgc_notify_reply_ar1(Cid, Tid) -> 2215 NR = cre_notifyReply([Tid]), 2216 CR = cre_cmdReply(NR), 2217 cre_actionReply(Cid, [CR]). 2218 2219mtrmc2_mgc_notify_reply_ar2(Cid, Tids) -> 2220 CRs = [cre_cmdReply(cre_notifyReply([Tid])) || Tid <- Tids], 2221 cre_actionReply(Cid, CRs). 2222 2223%% mtrmc2_mgc_notify_reply(Mid, TransId, Cid, TermId) -> 2224%% AR = mtrmc2_mgc_notify_reply_ar1(Cid, TermId), 2225%% TRes = cre_transResult([AR]), 2226%% TR = cre_transReply(TransId, TRes), 2227%% Trans = cre_transaction(TR), 2228%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 2229%% cre_megacoMessage(Mess). 2230 2231 2232%% 2233%% MG generator stuff 2234%% 2235-ifdef(megaco_hipe_special). 2236-define(mtrmc2_mg_verify_handle_connect_fun(), 2237 {?MODULE, mtrmc2_mg_verify_handle_connect, []}). 2238-define(mtrmc2_mg_verify_service_change_reply_fun(), 2239 {?MODULE, mtrmc2_mg_verify_service_change_reply, []}). 2240-define(mtrmc2_mg_verify_notify_reply_fun(), 2241 {?MODULE, mtrmc2_mg_verify_notify_reply, []}). 2242-else. 2243-define(mtrmc2_mg_verify_handle_connect_fun(), 2244 fun mtrmc2_mg_verify_handle_connect/1). 2245-define(mtrmc2_mg_verify_service_change_reply_fun(), 2246 fun mtrmc2_mg_verify_service_change_reply/1). 2247-define(mtrmc2_mg_verify_notify_reply_fun(), 2248 fun mtrmc2_mg_verify_notify_reply/1). 2249-endif. 2250 2251mtrmc2_mg_event_sequence(text, tcp) -> 2252 Mid = {deviceName,"mg"}, 2253 RI = [ 2254 {port, 2944}, 2255 {encoding_module, megaco_pretty_text_encoder}, 2256 {encoding_config, []}, 2257 {transport_module, megaco_tcp} 2258 ], 2259 ServiceChangeReq = [mtrmc2_mg_service_change_request_ar(Mid, 1)], 2260 Tid = #megaco_term_id{id = ["00000000","00000000","01101101"]}, 2261 NR1 = fun(N) -> 2262 [mtrmc2_mg_notify_request_ar1(N, Tid, N)] 2263 end, 2264 NR2 = fun(N) -> 2265 [mtrmc2_mg_notify_request_ar2(N, Tid, N)] 2266 end, 2267 ConnectVerify = ?mtrmc2_mg_verify_handle_connect_fun(), 2268 ServiceChangeReplyVerify = ?mtrmc2_mg_verify_service_change_reply_fun(), 2269 NotifyReplyVerify = ?mtrmc2_mg_verify_notify_reply_fun(), 2270 EvSeq = [ 2271 {debug, true}, 2272 megaco_start, 2273 {megaco_start_user, Mid, RI, []}, 2274 start_transport, 2275 {megaco_trace, disable}, 2276 {megaco_system_info, users}, 2277 {megaco_system_info, connections}, 2278 connect, 2279 {megaco_callback, handle_connect, ConnectVerify}, 2280 megaco_connect, 2281 {megaco_cast, ServiceChangeReq, []}, 2282 {megaco_callback, handle_connect, ConnectVerify}, 2283 {megaco_callback, handle_trans_reply, ServiceChangeReplyVerify}, 2284 {sleep, 1000}, 2285 {megaco_system_info, users}, 2286 {megaco_system_info, connections}, 2287 {sleep, 1000}, 2288 {megaco_update_conn_info, trans_req_maxcount, 5}, 2289 {megaco_update_conn_info, trans_req_maxsize, 1024}, 2290 {megaco_update_conn_info, trans_timer, 120000}, 2291 {megaco_update_conn_info, trans_req, true}, 2292 {megaco_conn_info, all}, 2293 {megaco_cast, NR1(1), []}, 2294 {megaco_cast, [NR1(2), NR1(3)], []}, 2295 {megaco_cast, NR1(4), []}, 2296 {megaco_cast, NR2(5), []}, 2297 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 2298 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 2299 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 2300 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 2301 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 2302 {sleep, 1000}, 2303 megaco_stop_user, 2304 megaco_stop, 2305 {sleep, 1000} 2306 ], 2307 EvSeq. 2308 2309mtrmc2_mg_verify_handle_connect({handle_connect, CH, ?VERSION}) -> 2310 io:format("mtrmc2_mg_verify_handle_connect -> ok" 2311 "~n CH: ~p~n", [CH]), 2312 {ok, CH, ok}; 2313mtrmc2_mg_verify_handle_connect(Else) -> 2314 io:format("mtrmc2_mg_verify_handle_connect -> unknown" 2315 "~n Else: ~p~n", [Else]), 2316 {error, Else, ok}. 2317 2318mtrmc2_mg_verify_service_change_reply({handle_trans_reply, _CH, ?VERSION, 2319 {ok, [AR]}, _}) -> 2320 io:format("mtrmc2_mg_verify_service_change_reply -> ok" 2321 "~n AR: ~p~n", [AR]), 2322 case AR of 2323 #'ActionReply'{commandReply = [SCR]} -> 2324 case SCR of 2325 {serviceChangeReply, 2326 #'ServiceChangeReply'{terminationID = [Tid], 2327 serviceChangeResult = Res}} -> 2328 case Tid of 2329 #megaco_term_id{contains_wildcards = false, 2330 id = ["root"]} -> 2331 case Res of 2332 {serviceChangeResParms, 2333 #'ServiceChangeResParm'{ 2334 serviceChangeMgcId = _RemoteMid}} -> 2335 {ok, AR, ok}; 2336 {Tag, Val} -> 2337 Err = {invalid_service_change_result, 2338 Tag, Val}, 2339 {error, Err, ok} 2340 end; 2341 _ -> 2342 Err = {invalid_termination_id, Tid}, 2343 {error, Err, ok} 2344 end; 2345 {Tag, Val} -> 2346 Err = {invalid_command_reply, Tag, Val}, 2347 {error, Err, ok} 2348 end; 2349 _ -> 2350 Err = {invalid_action_reply, AR}, 2351 {error, Err, ok} 2352 end; 2353mtrmc2_mg_verify_service_change_reply(Else) -> 2354 io:format("mtrmc2_mg_verify_service_change_reply -> unknown" 2355 "~n Else: ~p~n", [Else]), 2356 {error, Else, ok}. 2357 2358mtrmc2_mg_verify_notify_reply({handle_trans_reply, _CH, ?VERSION, 2359 {ok, [AR]}, _}) -> 2360 io:format("mtrmc2_mg_verify_notify_reply -> ok" 2361 "~n AR: ~p~n", [AR]), 2362 case AR of 2363 #'ActionReply'{commandReply = [{notifyReply, _NR}]} -> 2364 io:format("mtrmc2_mg_verify_notify_reply -> " 2365 "single notify reply", []), 2366 {ok, AR, ok}; 2367 #'ActionReply'{commandReply = [{notifyReply, _NR}|_] = CR} -> 2368 io:format("mtrmc2_mg_verify_notify_reply -> " 2369 "multi notify reply: (~w)", [length(CR)]), 2370 {ok, AR, ok}; 2371 _ -> 2372 {error, {invalid_action_reply, AR}, ok} 2373 end; 2374mtrmc2_mg_verify_notify_reply(Else) -> 2375 io:format("mtrmc2_mg_verify_notify_reply -> unknown" 2376 "~n Else: ~p~n", [Else]), 2377 {error, Else, ok}. 2378 2379mtrmc2_mg_service_change_request_ar(_Mid, Cid) -> 2380 Prof = cre_serviceChangeProf("resgw", 1), 2381 SCP = cre_serviceChangeParm(restart, ["901 mg col boot"], Prof), 2382 Root = #megaco_term_id{id = ["root"]}, 2383 SCR = cre_serviceChangeReq([Root], SCP), 2384 CMD = cre_command(SCR), 2385 CR = cre_cmdReq(CMD), 2386 cre_actionReq(Cid, [CR]). 2387 2388%% mtrmc2_mg_service_change_request_msg(Mid, TransId, Cid) -> 2389%% AR = mtrmc2_mg_service_change_request_ar(Mid, Cid), 2390%% TR = cre_transReq(TransId, [AR]), 2391%% Trans = cre_transaction(TR), 2392%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 2393%% cre_megacoMessage(Mess). 2394 2395mtrmc2_mg_notify_request_ar1(Rid, Tid, Cid) -> 2396 TT = cre_timeNotation("19990729", "22000000"), 2397 Ev = cre_obsEvent("al/of", TT), 2398 EvsDesc = cre_obsEvsDesc(Rid, [Ev]), 2399 NR = cre_notifyReq([Tid], EvsDesc), 2400 CMD = cre_command(NR), 2401 CR = cre_cmdReq(CMD), 2402 cre_actionReq(Cid, [CR]). 2403 2404mtrmc2_mg_notify_request_ar2(Rid, Tid, Cid) -> 2405 F = fun(N) -> 2406 T = 22000000 + N, 2407 TS = integer_to_list(T), 2408 TT = cre_timeNotation("19990729", TS), 2409 Ev = cre_obsEvent("al/of", TT), 2410 EvsDesc = cre_obsEvsDesc(Rid+N, [Ev]), 2411 NR = cre_notifyReq([Tid], EvsDesc), 2412 CMD = cre_command(NR), 2413 cre_cmdReq(CMD) 2414 end, 2415 Ns = [0,1,2,3,4,5,6,7,8,9], 2416 CRs = [F(N) || N <- Ns], 2417 cre_actionReq(Cid, CRs). 2418 2419%% mtrmc2_notify_request_msg(Mid, TransId, Rid, TermId, Cid) -> 2420%% AR = mtrmc2_mg_notify_request_ar1(Rid, TermId, Cid), 2421%% TR = cre_transReq(TransId, [AR]), 2422%% Trans = cre_transaction(TR), 2423%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 2424%% cre_megacoMessage(Mess). 2425 2426 2427%% 2428%% Common functions for the multi_trans_req_timeout test case 2429%% 2430 2431mtrmc2_err_desc(T) -> 2432 EC = ?megaco_internal_gateway_error, 2433 ET = lists:flatten(io_lib:format("~w",[T])), 2434 #'ErrorDescriptor'{errorCode = EC, errorText = ET}. 2435 2436 2437 2438 2439%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 2440 2441multi_trans_req_maxsize1(suite) -> 2442 []; 2443multi_trans_req_maxsize1(doc) -> 2444 "Test that the message is sent when req_maxsize is reached"; 2445multi_trans_req_maxsize1(Config) when is_list(Config) -> 2446 Pre = fun() -> 2447 put(verbosity, ?TEST_VERBOSITY), 2448 put(sname, "TEST"), 2449 put(tc, multi_trans_req_maxsize1), 2450 i("starting"), 2451 2452 MgcNode = make_node_name(mgc), 2453 MgNode = make_node_name(mg), 2454 d("start nodes: " 2455 "~n MGC Node: ~p" 2456 "~n MG Node: ~p", 2457 [MgcNode, MgNode]), 2458 Nodes = [MgcNode, MgNode], 2459 ok = ?START_NODES(Nodes), 2460 Nodes 2461 end, 2462 Case = fun do_multi_trans_req_maxsize1/1, 2463 Post = fun(Nodes) -> 2464 d("stop nodes"), 2465 ?STOP_NODES(lists:reverse(Nodes)) 2466 end, 2467 try_tc(multi_trans_req_maxsize1, Pre, Case, Post). 2468 2469do_multi_trans_req_maxsize1([MgcNode, MgNode]) -> 2470 2471 d("[MGC] start the simulator "), 2472 {ok, Mgc} = megaco_test_megaco_generator:start_link("MGC", MgcNode), 2473 2474 d("[MGC] create the event sequence"), 2475 MgcEvSeq = mtrms1_mgc_event_sequence(text, tcp), 2476 2477 i("wait some time before starting the MGC simulation"), 2478 sleep(1000), 2479 2480 d("[MGC] start the simulation"), 2481 {ok, MgcId} = megaco_test_megaco_generator:exec(Mgc, MgcEvSeq), 2482 2483 %% i("wait some time before starting the MG simulator"), 2484 %% sleep(1000), 2485 2486 i("await MGC ready announcement"), 2487 receive 2488 announce_mgc -> 2489 i("received MGC ready announcement"), 2490 ok 2491 end, 2492 2493 d("[MG] start the simulator (generator)"), 2494 {ok, Mg} = megaco_test_megaco_generator:start_link("MG", MgNode), 2495 2496 d("[MG] create the event sequence"), 2497 MgEvSeq = mtrms1_mg_event_sequence(text, tcp), 2498 2499 i("wait some time before starting the MG simulation"), 2500 sleep(1000), 2501 2502 d("[MG] start the simulation"), 2503 {ok, MgId} = megaco_test_megaco_generator:exec(Mg, MgEvSeq), 2504 2505 d("await the generator reply(s)"), 2506 await_completion([MgcId, MgId]), 2507 2508 %% Tell Mgc to stop 2509 i("[MGC] stop generator"), 2510 megaco_test_megaco_generator:stop(Mgc), 2511 2512 %% Tell Mg to stop 2513 i("[MG] stop generator"), 2514 megaco_test_megaco_generator:stop(Mg), 2515 2516 i("done", []), 2517 ok. 2518 2519 2520%% 2521%% MGC generator stuff 2522%% 2523-ifdef(megaco_hipe_special). 2524-define(mtrms1_mgc_verify_handle_connect_fun(), 2525 {?MODULE, mtrms1_mgc_verify_handle_connect, []}). 2526-define(mtrms1_mgc_verify_service_change_req_fun(Mid), 2527 {?MODULE, mtrms1_mgc_verify_service_change_req, [Mid]}). 2528-define(mtrms1_mgc_verify_notify_req_fun(), 2529 {?MODULE, mtrms1_mgc_verify_notify_request, []}). 2530-define(mtrms1_mgc_verify_handle_disconnect_fun(), 2531 {?MODULE, mtrms1_mgc_verify_handle_disconnect, []}). 2532-else. 2533-define(mtrms1_mgc_verify_handle_connect_fun(), 2534 fun mtrms1_mgc_verify_handle_connect/1). 2535-define(mtrms1_mgc_verify_service_change_req_fun(Mid), 2536 mtrms1_mgc_verify_service_change_req_fun(Mid)). 2537-define(mtrms1_mgc_verify_notify_req_fun(), 2538 mtrms1_mgc_verify_notify_request_fun()). 2539-define(mtrms1_mgc_verify_handle_disconnect_fun(), 2540 fun mtrms1_mgc_verify_handle_disconnect/1). 2541-endif. 2542 2543mtrms1_mgc_event_sequence(text, tcp) -> 2544 CTRL = self(), 2545 Mid = {deviceName,"ctrl"}, 2546 RI = [ 2547 {port, 2944}, 2548 {encoding_module, megaco_pretty_text_encoder}, 2549 {encoding_config, []}, 2550 {transport_module, megaco_tcp} 2551 ], 2552 ConnectVerify = ?mtrms1_mgc_verify_handle_connect_fun(), 2553 ServiceChangeReqVerify = ?mtrms1_mgc_verify_service_change_req_fun(Mid), 2554 NotifyReqVerify = ?mtrms1_mgc_verify_notify_req_fun(), 2555 DiscoVerify = ?mtrms1_mgc_verify_handle_disconnect_fun(), 2556 EvSeq = [ 2557 {debug, true}, 2558 {megaco_trace, disable}, 2559 megaco_start, 2560 {megaco_start_user, Mid, RI, []}, 2561 start_transport, 2562 listen, 2563 2564 %% ANNOUNCE READY 2565 {trigger, fun() -> CTRL ! announce_mgc end}, 2566 2567 {megaco_callback, handle_connect, ConnectVerify}, 2568 {megaco_callback, handle_trans_request, ServiceChangeReqVerify}, 2569 {megaco_callback, handle_trans_request, NotifyReqVerify}, 2570 {megaco_callback, handle_trans_request, NotifyReqVerify}, 2571 {megaco_callback, handle_trans_request, NotifyReqVerify}, 2572 {megaco_callback, handle_trans_request, NotifyReqVerify}, 2573 {megaco_callback, handle_trans_request, NotifyReqVerify}, 2574 {megaco_callback, handle_disconnect, DiscoVerify}, 2575 {sleep, 1000}, 2576 megaco_stop_user, 2577 megaco_stop 2578 ], 2579 EvSeq. 2580 2581 2582mtrms1_mgc_verify_handle_connect({handle_connect, CH, ?VERSION}) -> 2583 io:format("mtrms1_mgc_verify_handle_connect -> ok" 2584 "~n CH: ~p~n", [CH]), 2585 {ok, CH, ok}; 2586mtrms1_mgc_verify_handle_connect(Else) -> 2587 io:format("mtrms1_mgc_verify_handle_connect -> unknown" 2588 "~n Else: ~p~n", [Else]), 2589 {error, Else, ok}. 2590 2591mtrms1_mgc_verify_service_change_req_fun(Mid) -> 2592 fun(Ev) -> 2593 mtrms1_mgc_verify_service_change_req(Ev, Mid) 2594 end. 2595 2596mtrms1_mgc_verify_service_change_req( 2597 {handle_trans_request, _, ?VERSION, [AR]}, Mid) -> 2598 io:format("mtrms1_mgc_verify_service_change_req -> ok" 2599 "~n AR: ~p~n", [AR]), 2600 case AR of 2601 #'ActionRequest'{commandRequests = [CR]} -> 2602 case CR of 2603 #'CommandRequest'{command = Cmd} -> 2604 case Cmd of 2605 {serviceChangeReq, 2606 #'ServiceChangeRequest'{terminationID = [Tid], 2607 serviceChangeParms = Parms}} -> 2608 case Tid of 2609 #megaco_term_id{contains_wildcards = false, 2610 id = ["root"]} -> 2611 case Parms of 2612 #'ServiceChangeParm'{ 2613 serviceChangeMethod = restart, 2614 serviceChangeReason = [[$9,$0,$1|_]]} -> 2615 Reply = 2616 {discard_ack, 2617 [mtrms1_mgc_service_change_reply_ar(Mid, 1)]}, 2618 {ok, AR, Reply}; 2619 _ -> 2620 Err = {invalid_SCP, Parms}, 2621 ED = mtrms1_err_desc(Parms), 2622 ErrReply = {discard_ack, 2623 ED}, 2624 {error, Err, ErrReply} 2625 end; 2626 _ -> 2627 Err = {invalid_termination_id, Tid}, 2628 ED = mtrms1_err_desc(Tid), 2629 ErrReply = {discard_ack, ED}, 2630 {error, Err, ErrReply} 2631 end; 2632 _ -> 2633 Err = {invalid_command, Cmd}, 2634 ED = mtrms1_err_desc(Cmd), 2635 ErrReply = {discard_ack, ED}, 2636 {error, Err, ErrReply} 2637 end; 2638 _ -> 2639 Err = {invalid_command_request, CR}, 2640 ED = mtrms1_err_desc(CR), 2641 ErrReply = {discard_ack, ED}, 2642 {error, Err, ErrReply} 2643 end; 2644 _ -> 2645 Err = {invalid_action_request, AR}, 2646 ED = mtrms1_err_desc(AR), 2647 ErrReply = {discard_ack, ED}, 2648 {error, Err, ErrReply} 2649 end; 2650mtrms1_mgc_verify_service_change_req(Else, _Mid) -> 2651 io:format("mtrms1_mgc_verify_service_change_req -> unknown" 2652 "~n Else: ~p~n", [Else]), 2653 ED = mtrms1_err_desc(Else), 2654 ErrReply = {discard_ack, ED}, 2655 {error, Else, ErrReply}. 2656 2657mtrms1_mgc_verify_notify_request_fun() -> 2658 fun(Ev) -> 2659 mtrms1_mgc_verify_notify_request(Ev) 2660 end. 2661 2662mtrms1_mgc_verify_notify_request({handle_trans_request, _, ?VERSION, [AR]}) -> 2663 io:format("mtrms1_mgc_verify_notify_request:fun1 -> ok" 2664 "~n AR: ~p~n", [AR]), 2665 case AR of 2666 #'ActionRequest'{contextId = Cid, 2667 commandRequests = [CR]} -> 2668 #'CommandRequest'{command = Cmd} = CR, 2669 {notifyReq, NR} = Cmd, 2670 #'NotifyRequest'{terminationID = [Tid], 2671 observedEventsDescriptor = OED, 2672 errorDescriptor = asn1_NOVALUE} = NR, 2673 #'ObservedEventsDescriptor'{observedEventLst = [OE]} = OED, 2674 #'ObservedEvent'{eventName = "al/of"} = OE, 2675 Reply = {discard_ack, 2676 [mtrms1_mgc_notify_reply_ar1(Cid, Tid)]}, 2677 {ok, AR, Reply}; 2678 _ -> 2679 ED = mtrms1_err_desc(AR), 2680 ErrReply = {discard_ack, ED}, 2681 {error, AR, ErrReply} 2682 end; 2683mtrms1_mgc_verify_notify_request(Else) -> 2684 io:format("mtrms1_mgc_verify_notify_request:fun1 -> unknown" 2685 "~n Else: ~p~n", [Else]), 2686 ED = mtrms1_err_desc(Else), 2687 ErrReply = {discard_ack, ED}, 2688 {error, Else, ErrReply}. 2689 2690mtrms1_mgc_verify_handle_disconnect({handle_disconnect, CH, ?VERSION, R}) -> 2691 io:format("mtrms1_mgc_verify_handle_disconnect -> ok" 2692 "~n CH: ~p" 2693 "~n R: ~p" 2694 "~n", [CH, R]), 2695 {ok, CH, ok}; 2696mtrms1_mgc_verify_handle_disconnect(Else) -> 2697 io:format("mtrms1_mgc_verify_handle_disconnect -> unknown" 2698 "~n Else: ~p~n", [Else]), 2699 {error, Else, ok}. 2700 2701 2702mtrms1_mgc_service_change_reply_ar(Mid, Cid) -> 2703 SCRP = cre_serviceChangeResParm(Mid), 2704 SCRes = cre_serviceChangeResult(SCRP), 2705 Root = #megaco_term_id{id = ["root"]}, 2706 SCR = cre_serviceChangeReply([Root], SCRes), 2707 CR = cre_cmdReply(SCR), 2708 cre_actionReply(Cid, [CR]). 2709 2710%% mtrms1_mgc_service_change_reply_msg(Mid, TransId, Cid) -> 2711%% AR = mtrms1_mgc_service_change_reply_ar(Mid, Cid), 2712%% TRes = cre_transResult([AR]), 2713%% TR = cre_transReply(TransId, TRes), 2714%% Trans = cre_transaction(TR), 2715%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 2716%% cre_megacoMessage(Mess). 2717 2718mtrms1_mgc_notify_reply_ar1(Cid, Tid) -> 2719 NR = cre_notifyReply([Tid]), 2720 CR = cre_cmdReply(NR), 2721 cre_actionReply(Cid, [CR]). 2722 2723%% mtrms1_mgc_notify_reply(Mid, TransId, Cid, TermId) -> 2724%% AR = mtrms1_mgc_notify_reply_ar1(Cid, TermId), 2725%% TRes = cre_transResult([AR]), 2726%% TR = cre_transReply(TransId, TRes), 2727%% Trans = cre_transaction(TR), 2728%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 2729%% cre_megacoMessage(Mess). 2730 2731 2732%% 2733%% MG generator stuff 2734%% 2735-ifdef(megaco_hipe_special). 2736-define(mtrms1_mg_verify_handle_connect_fun(), 2737 {?MODULE, mtrms1_mg_verify_handle_connect, []}). 2738-define(mtrms1_mg_verify_service_change_reply_fun(Mid), 2739 {?MODULE, mtrms1_mg_verify_service_change_reply, [Mid]}). 2740-define(mtrms1_mg_verify_notify_reply_fun(), 2741 {?MODULE, mtrms1_mg_verify_notify_reply, []}). 2742-else. 2743-define(mtrms1_mg_verify_handle_connect_fun(), 2744 fun mtrms1_mg_verify_handle_connect/1). 2745-define(mtrms1_mg_verify_service_change_reply_fun(), 2746 fun mtrms1_mg_verify_service_change_reply/1). 2747-define(mtrms1_mg_verify_notify_reply_fun(), 2748 fun mtrms1_mg_verify_notify_reply/1). 2749-endif. 2750 2751mtrms1_mg_event_sequence(text, tcp) -> 2752 Mid = {deviceName,"mg"}, 2753 RI = [ 2754 {port, 2944}, 2755 {encoding_module, megaco_pretty_text_encoder}, 2756 {encoding_config, []}, 2757 {transport_module, megaco_tcp} 2758 ], 2759 ServiceChangeReq = [mtrms1_mg_service_change_request_ar(Mid, 1)], 2760 Tid = #megaco_term_id{id = ["00000000","00000000","01101101"]}, 2761 NR = fun(N) -> 2762 [mtrms1_mg_notify_request_ar1(N, Tid, N)] 2763 end, 2764 ConnectVerify = ?mtrms1_mg_verify_handle_connect_fun(), 2765 ServiceChangeReplyVerify = ?mtrms1_mg_verify_service_change_reply_fun(), 2766 NotifyReplyVerify = ?mtrms1_mg_verify_notify_reply_fun(), 2767 EvSeq = [ 2768 {debug, true}, 2769 megaco_start, 2770 {megaco_start_user, Mid, RI, []}, 2771 start_transport, 2772 {megaco_trace, disable}, 2773 {megaco_system_info, users}, 2774 {megaco_system_info, connections}, 2775 connect, 2776 {megaco_callback, handle_connect, ConnectVerify}, 2777 megaco_connect, 2778 {megaco_cast, ServiceChangeReq, []}, 2779 {megaco_callback, handle_connect, ConnectVerify}, 2780 {megaco_callback, handle_trans_reply, ServiceChangeReplyVerify}, 2781 {sleep, 1000}, 2782 {megaco_system_info, users}, 2783 {megaco_system_info, connections}, 2784 {sleep, 1000}, 2785 {megaco_update_conn_info, trans_req_maxcount, 10}, 2786 {megaco_update_conn_info, trans_req_maxsize, 650}, 2787 {megaco_update_conn_info, trans_timer, 120000}, 2788 {megaco_update_conn_info, trans_req, true}, 2789 {megaco_conn_info, all}, 2790 {megaco_cast, NR(1), []}, 2791 {megaco_cast, [NR(2), NR(3)], []}, 2792 {megaco_cast, NR(4), []}, 2793 {megaco_cast, NR(5), []}, 2794 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 2795 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 2796 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 2797 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 2798 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 2799 {sleep, 1000}, 2800 megaco_stop_user, 2801 megaco_stop, 2802 {sleep, 1000} 2803 ], 2804 EvSeq. 2805 2806mtrms1_mg_verify_handle_connect({handle_connect, CH, ?VERSION}) -> 2807 io:format("mtrms1_mg_verify_handle_connect -> ok" 2808 "~n CH: ~p~n", [CH]), 2809 {ok, CH, ok}; 2810mtrms1_mg_verify_handle_connect(Else) -> 2811 io:format("mtrms1_mg_verify_handle_connect -> unknown" 2812 "~n Else: ~p~n", [Else]), 2813 {error, Else, ok}. 2814 2815mtrms1_mg_verify_service_change_reply({handle_trans_reply, _CH, ?VERSION, 2816 {ok, [AR]}, _}) -> 2817 io:format("mtrms1_mg_verify_service_change_reply -> ok" 2818 "~n AR: ~p~n", [AR]), 2819 case AR of 2820 #'ActionReply'{commandReply = [SCR]} -> 2821 case SCR of 2822 {serviceChangeReply, 2823 #'ServiceChangeReply'{terminationID = [Tid], 2824 serviceChangeResult = Res}} -> 2825 case Tid of 2826 #megaco_term_id{contains_wildcards = false, 2827 id = ["root"]} -> 2828 case Res of 2829 {serviceChangeResParms, 2830 #'ServiceChangeResParm'{ 2831 serviceChangeMgcId = _RemoteMid}} -> 2832 {ok, AR, ok}; 2833 {Tag, Val} -> 2834 Err = {invalid_service_change_result, 2835 Tag, Val}, 2836 {error, Err, ok} 2837 end; 2838 _ -> 2839 Err = {invalid_termination_id, Tid}, 2840 {error, Err, ok} 2841 end; 2842 {Tag, Val} -> 2843 Err = {invalid_command_reply, Tag, Val}, 2844 {error, Err, ok} 2845 end; 2846 _ -> 2847 Err = {invalid_action_reply, AR}, 2848 {error, Err, ok} 2849 end; 2850mtrms1_mg_verify_service_change_reply(Else) -> 2851 io:format("mtrms1_mg_verify_service_change_reply -> unknown" 2852 "~n Else: ~p~n", [Else]), 2853 {error, Else, ok}. 2854 2855mtrms1_mg_verify_notify_reply({handle_trans_reply, _CH, ?VERSION, 2856 {ok, [AR]}, _}) -> 2857 io:format("mtrms1_mg_verify_service_change_reply -> ok" 2858 "~n AR: ~p~n", [AR]), 2859 {ok, AR, ok}; 2860mtrms1_mg_verify_notify_reply(Else) -> 2861 io:format("mtrms1_mg_verify_service_change_reply -> unknown" 2862 "~n Else: ~p~n", [Else]), 2863 {error, Else, ok}. 2864 2865mtrms1_mg_service_change_request_ar(_Mid, Cid) -> 2866 Prof = cre_serviceChangeProf("resgw", 1), 2867 SCP = cre_serviceChangeParm(restart, ["901 mg col boot"], Prof), 2868 Root = #megaco_term_id{id = ["root"]}, 2869 SCR = cre_serviceChangeReq([Root], SCP), 2870 CMD = cre_command(SCR), 2871 CR = cre_cmdReq(CMD), 2872 cre_actionReq(Cid, [CR]). 2873 2874%% mtrms1_mg_service_change_request_msg(Mid, TransId, Cid) -> 2875%% AR = mtrms1_mg_service_change_request_ar(Mid, Cid), 2876%% TR = cre_transReq(TransId, [AR]), 2877%% Trans = cre_transaction(TR), 2878%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 2879%% cre_megacoMessage(Mess). 2880 2881mtrms1_mg_notify_request_ar1(Rid, Tid, Cid) -> 2882 TT = cre_timeNotation("19990729", "22000000"), 2883 Ev = cre_obsEvent("al/of", TT), 2884 EvsDesc = cre_obsEvsDesc(Rid, [Ev]), 2885 NR = cre_notifyReq([Tid], EvsDesc), 2886 CMD = cre_command(NR), 2887 CR = cre_cmdReq(CMD), 2888 cre_actionReq(Cid, [CR]). 2889 2890%% mtrms1_notify_request_msg(Mid, TransId, Rid, TermId, Cid) -> 2891%% AR = mtrms1_mg_notify_request_ar1(Rid, TermId, Cid), 2892%% TR = cre_transReq(TransId, [AR]), 2893%% Trans = cre_transaction(TR), 2894%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 2895%% cre_megacoMessage(Mess). 2896 2897 2898mtrms1_err_desc(T) -> 2899 cre_ErrDesc(T). 2900 2901 2902 2903 2904%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 2905 2906multi_trans_req_maxsize2(suite) -> 2907 []; 2908multi_trans_req_maxsize2(doc) -> 2909 "Test that the message is sent when req_maxsize is reached, " 2910 "when the 'last' message is bigger then req_maxsize itself"; 2911multi_trans_req_maxsize2(Config) when is_list(Config) -> 2912 Pre = fun() -> 2913 MgcNode = make_node_name(mgc), 2914 MgNode = make_node_name(mg), 2915 d("start nodes: " 2916 "~n MGC Node: ~p" 2917 "~n MG Node: ~p", 2918 [MgcNode, MgNode]), 2919 Nodes = [MgcNode, MgNode], 2920 ok = ?START_NODES(Nodes), 2921 Nodes 2922 end, 2923 Case = fun do_multi_trans_req_maxsize2/1, 2924 Post = fun(Nodes) -> 2925 d("stop nodes"), 2926 ?STOP_NODES(lists:reverse(Nodes)) 2927 end, 2928 try_tc(multi_trans_req_maxsize2, Pre, Case, Post). 2929 2930do_multi_trans_req_maxsize2([MgcNode, MgNode]) -> 2931 2932 d("[MGC] start the simulator "), 2933 {ok, Mgc} = megaco_test_megaco_generator:start_link("MGC", MgcNode), 2934 2935 d("[MGC] create the event sequence"), 2936 MgcEvSeq = mtrms2_mgc_event_sequence(text, tcp), 2937 2938 i("wait some time before starting the MGC simulation"), 2939 sleep(1000), 2940 2941 d("[MGC] start the simulation"), 2942 {ok, MgcId} = megaco_test_megaco_generator:exec(Mgc, MgcEvSeq), 2943 2944 %% i("wait some time before starting the MG simulator"), 2945 %% sleep(1000), 2946 2947 i("await MGC ready announcement"), 2948 receive 2949 announce_mgc -> 2950 i("received MGC ready announcement"), 2951 ok 2952 end, 2953 2954 d("[MG] start the simulator (generator)"), 2955 {ok, Mg} = megaco_test_megaco_generator:start_link("MG", MgNode), 2956 2957 d("[MG] create the event sequence"), 2958 MgEvSeq = mtrms2_mg_event_sequence(text, tcp), 2959 2960 i("wait some time before starting the MG simulation"), 2961 sleep(1000), 2962 2963 d("[MG] start the simulation"), 2964 {ok, MgId} = megaco_test_megaco_generator:exec(Mg, MgEvSeq), 2965 2966 d("await the generator reply(s)"), 2967 await_completion([MgcId, MgId]), 2968 2969 %% Tell Mgc to stop 2970 i("[MGC] stop generator"), 2971 megaco_test_megaco_generator:stop(Mgc), 2972 2973 %% Tell Mg to stop 2974 i("[MG] stop generator"), 2975 megaco_test_megaco_generator:stop(Mg), 2976 2977 i("done", []), 2978 ok. 2979 2980 2981%% 2982%% MGC generator stuff 2983%% 2984-ifdef(megaco_hipe_special). 2985-define(mtrms2_mgc_verify_handle_connect_fun(), 2986 {?MODULE, mtrms2_mgc_verify_handle_connect, []}). 2987-define(mtrms2_mgc_verify_service_change_req_fun(Mid), 2988 {?MODULE, mtrms2_mgc_verify_service_change_req, [Mid]}). 2989-define(mtrms2_mgc_verify_notify_req_fun(), 2990 {?MODULE, mtrms2_mgc_verify_notify_request, []}). 2991-define(mtrms2_mgc_verify_handle_disconnect_fun(), 2992 {?MODULE, mtrms2_mgc_verify_handle_disconnect, []}). 2993-else. 2994-define(mtrms2_mgc_verify_handle_connect_fun(), 2995 fun mtrms2_mgc_verify_handle_connect/1). 2996-define(mtrms2_mgc_verify_service_change_req_fun(Mid), 2997 mtrms2_mgc_verify_service_change_req_fun(Mid)). 2998-define(mtrms2_mgc_verify_notify_req_fun(), 2999 mtrms2_mgc_verify_notify_request_fun()). 3000-define(mtrms2_mgc_verify_handle_disconnect_fun(), 3001 fun mtrms2_mgc_verify_handle_disconnect/1). 3002-endif. 3003 3004mtrms2_mgc_event_sequence(text, tcp) -> 3005 CTRL = self(), 3006 Mid = {deviceName,"ctrl"}, 3007 RI = [ 3008 {port, 2944}, 3009 {encoding_module, megaco_pretty_text_encoder}, 3010 {encoding_config, []}, 3011 {transport_module, megaco_tcp} 3012 ], 3013 ConnectVerify = ?mtrms2_mgc_verify_handle_connect_fun(), 3014 ServiceChangeReqVerify = ?mtrms2_mgc_verify_service_change_req_fun(Mid), 3015 NotifyReqVerify = ?mtrms2_mgc_verify_notify_req_fun(), 3016 DiscoVerify = ?mtrms2_mgc_verify_handle_disconnect_fun(), 3017 EvSeq = [ 3018 {debug, true}, 3019 {megaco_trace, disable}, 3020 megaco_start, 3021 {megaco_start_user, Mid, RI, []}, 3022 start_transport, 3023 listen, 3024 3025 %% ANNOUNCE READY 3026 {trigger, fun() -> CTRL ! announce_mgc end}, 3027 3028 {megaco_callback, handle_connect, ConnectVerify}, 3029 {megaco_callback, handle_trans_request, ServiceChangeReqVerify}, 3030 {megaco_callback, handle_trans_request, NotifyReqVerify}, 3031 {megaco_callback, handle_trans_request, NotifyReqVerify}, 3032 {megaco_callback, handle_trans_request, NotifyReqVerify}, 3033 {megaco_callback, handle_trans_request, NotifyReqVerify}, 3034 {megaco_callback, handle_trans_request, NotifyReqVerify}, 3035 {megaco_callback, handle_disconnect, DiscoVerify}, 3036 {sleep, 1000}, 3037 megaco_stop_user, 3038 megaco_stop 3039 ], 3040 EvSeq. 3041 3042 3043mtrms2_mgc_verify_handle_connect({handle_connect, CH, ?VERSION}) -> 3044 io:format("mtrms2_mgc_verify_handle_connect -> ok" 3045 "~n CH: ~p~n", [CH]), 3046 {ok, CH, ok}; 3047mtrms2_mgc_verify_handle_connect(Else) -> 3048 io:format("mtrms2_mgc_verify_handle_connect -> unknown" 3049 "~n Else: ~p~n", [Else]), 3050 {error, Else, ok}. 3051 3052mtrms2_mgc_verify_service_change_req_fun(Mid) -> 3053 fun(Ev) -> 3054 mtrms2_mgc_verify_service_change_req(Ev, Mid) 3055 end. 3056 3057mtrms2_mgc_verify_service_change_req( 3058 {handle_trans_request, _, ?VERSION, [AR]}, Mid) -> 3059 io:format("mtrms2_mgc_verify_service_change_req -> ok" 3060 "~n AR: ~p~n", [AR]), 3061 case AR of 3062 #'ActionRequest'{commandRequests = [CR]} -> 3063 case CR of 3064 #'CommandRequest'{command = Cmd} -> 3065 case Cmd of 3066 {serviceChangeReq, 3067 #'ServiceChangeRequest'{terminationID = [Tid], 3068 serviceChangeParms = Parms}} -> 3069 case Tid of 3070 #megaco_term_id{contains_wildcards = false, 3071 id = ["root"]} -> 3072 case Parms of 3073 #'ServiceChangeParm'{ 3074 serviceChangeMethod = restart, 3075 serviceChangeReason = [[$9,$0,$1|_]]} -> 3076 Reply = 3077 {discard_ack, 3078 [mtrms2_mgc_service_change_reply_ar(Mid, 1)]}, 3079 {ok, AR, Reply}; 3080 _ -> 3081 Err = {invalid_SCP, Parms}, 3082 ED = mtrms2_err_desc(Parms), 3083 ErrReply = {discard_ack, 3084 ED}, 3085 {error, Err, ErrReply} 3086 end; 3087 _ -> 3088 Err = {invalid_termination_id, Tid}, 3089 ED = mtrms2_err_desc(Tid), 3090 ErrReply = {discard_ack, ED}, 3091 {error, Err, ErrReply} 3092 end; 3093 _ -> 3094 Err = {invalid_command, Cmd}, 3095 ED = mtrms2_err_desc(Cmd), 3096 ErrReply = {discard_ack, ED}, 3097 {error, Err, ErrReply} 3098 end; 3099 _ -> 3100 Err = {invalid_command_request, CR}, 3101 ED = mtrms2_err_desc(CR), 3102 ErrReply = {discard_ack, ED}, 3103 {error, Err, ErrReply} 3104 end; 3105 _ -> 3106 Err = {invalid_action_request, AR}, 3107 ED = mtrms2_err_desc(AR), 3108 ErrReply = {discard_ack, ED}, 3109 {error, Err, ErrReply} 3110 end; 3111mtrms2_mgc_verify_service_change_req(Else, _Mid) -> 3112 io:format("mtrms2_mgc_verify_service_change_req -> unknown" 3113 "~n Else: ~p~n", [Else]), 3114 ED = mtrms2_err_desc(Else), 3115 ErrReply = {discard_ack, ED}, 3116 {error, Else, ErrReply}. 3117 3118mtrms2_mgc_verify_notify_request_fun() -> 3119 fun(Ev) -> 3120 mtrms2_mgc_verify_notify_request(Ev) 3121 end. 3122 3123mtrms2_mgc_verify_notify_request({handle_trans_request, _, ?VERSION, [AR]}) -> 3124 io:format("mtrms2_mgc_verify_notify_request -> ok" 3125 "~n AR: ~p~n", [AR]), 3126 case AR of 3127 #'ActionRequest'{contextId = Cid, 3128 commandRequests = [CR]} -> 3129 io:format("mtrms2_mgc_verify_notify_request:fun -> " 3130 "single command", []), 3131 #'CommandRequest'{command = Cmd} = CR, 3132 {notifyReq, NR} = Cmd, 3133 #'NotifyRequest'{terminationID = [Tid], 3134 observedEventsDescriptor = OED, 3135 errorDescriptor = asn1_NOVALUE} = NR, 3136 #'ObservedEventsDescriptor'{observedEventLst = [OE]} = OED, 3137 #'ObservedEvent'{eventName = "al/of"} = OE, 3138 Reply = {discard_ack, 3139 [mtrms2_mgc_notify_reply_ar1(Cid, Tid)]}, 3140 {ok, AR, Reply}; 3141 #'ActionRequest'{contextId = Cid, 3142 commandRequests = CRs} -> 3143 io:format("mtrms2_mgc_verify_notify_request:fun -> " 3144 "multi command (~w)", [length(CRs)]), 3145 Tids = [Tid || 3146 #'CommandRequest'{command = 3147 {notifyReq, 3148 #'NotifyRequest'{ 3149 terminationID = [Tid]}}} 3150 <- CRs], 3151 Reply = 3152 {discard_ack, 3153 [mtrms2_mgc_notify_reply_ar2(Cid, Tids)]}, 3154 {ok, AR, Reply}; 3155 _ -> 3156 ED = mtrms2_err_desc(AR), 3157 ErrReply = {discard_ack, ED}, 3158 {error, AR, ErrReply} 3159 end; 3160mtrms2_mgc_verify_notify_request(Else) -> 3161 io:format("mtrms2_mgc_verify_notify_request -> unknown" 3162 "~n Else: ~p~n", [Else]), 3163 ED = mtrms2_err_desc(Else), 3164 ErrReply = {discard_ack, ED}, 3165 {error, Else, ErrReply}. 3166 3167mtrms2_mgc_verify_handle_disconnect({handle_disconnect, CH, ?VERSION, R}) -> 3168 io:format("mtrms2_mgc_verify_handle_disconnect -> ok" 3169 "~n CH: ~p" 3170 "~n R: ~p" 3171 "~n", [CH, R]), 3172 {ok, CH, ok}; 3173mtrms2_mgc_verify_handle_disconnect(Else) -> 3174 io:format("mtrms2_mgc_verify_handle_disconnect -> unknown" 3175 "~n Else: ~p~n", [Else]), 3176 {error, Else, ok}. 3177 3178 3179mtrms2_mgc_service_change_reply_ar(Mid, Cid) -> 3180 SCRP = cre_serviceChangeResParm(Mid), 3181 SCRes = cre_serviceChangeResult(SCRP), 3182 Root = #megaco_term_id{id = ["root"]}, 3183 SCR = cre_serviceChangeReply([Root], SCRes), 3184 CR = cre_cmdReply(SCR), 3185 cre_actionReply(Cid, [CR]). 3186 3187%% mtrms2_mgc_service_change_reply_msg(Mid, TransId, Cid) -> 3188%% AR = mtrms2_mgc_service_change_reply_ar(Mid, Cid), 3189%% TRes = cre_transResult([AR]), 3190%% TR = cre_transReply(TransId, TRes), 3191%% Trans = cre_transaction(TR), 3192%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 3193%% cre_megacoMessage(Mess). 3194 3195mtrms2_mgc_notify_reply_ar1(Cid, Tid) -> 3196 NR = cre_notifyReply([Tid]), 3197 CR = cre_cmdReply(NR), 3198 cre_actionReply(Cid, [CR]). 3199 3200mtrms2_mgc_notify_reply_ar2(Cid, Tids) -> 3201 CRs = [cre_cmdReply(cre_notifyReply([Tid])) || Tid <- Tids], 3202 cre_actionReply(Cid, CRs). 3203 3204%% mtrms2_mgc_notify_reply(Mid, TransId, Cid, TermId) -> 3205%% AR = mtrms2_mgc_notify_reply_ar1(Cid, TermId), 3206%% TRes = cre_transResult([AR]), 3207%% TR = cre_transReply(TransId, TRes), 3208%% Trans = cre_transaction(TR), 3209%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 3210%% cre_megacoMessage(Mess). 3211 3212 3213%% 3214%% MG generator stuff 3215%% 3216-ifdef(megaco_hipe_special). 3217-define(mtrms2_mg_verify_handle_connect_fun(), 3218 {?MODULE, mtrms2_mg_verify_handle_connect, []}). 3219-define(mtrms2_mg_verify_service_change_reply_fun(Mid), 3220 {?MODULE, mtrms2_mg_verify_service_change_reply, [Mid]}). 3221-define(mtrms2_mg_verify_notify_reply_fun(), 3222 {?MODULE, mtrms2_mg_verify_notify_reply, []}). 3223-else. 3224-define(mtrms2_mg_verify_handle_connect_fun(), 3225 fun mtrms2_mg_verify_handle_connect/1). 3226-define(mtrms2_mg_verify_service_change_reply_fun(), 3227 fun mtrms2_mg_verify_service_change_reply/1). 3228-define(mtrms2_mg_verify_notify_reply_fun(), 3229 fun mtrms2_mg_verify_notify_reply/1). 3230-endif. 3231 3232mtrms2_mg_event_sequence(text, tcp) -> 3233 Mid = {deviceName,"mg"}, 3234 RI = [ 3235 {port, 2944}, 3236 {encoding_module, megaco_pretty_text_encoder}, 3237 {encoding_config, []}, 3238 {transport_module, megaco_tcp} 3239 ], 3240 ServiceChangeReq = [mtrms2_mg_service_change_request_ar(Mid, 1)], 3241 Tid = #megaco_term_id{id = ["00000000","00000000","01101101"]}, 3242 NotifyReq1 = [mtrms2_mg_notify_request_ar1(1, Tid, 1)], 3243 NotifyReq2 = [mtrms2_mg_notify_request_ar2(2, Tid, 2)], 3244 ConnectVerify = ?mtrms2_mg_verify_handle_connect_fun(), 3245 ServiceChangeReplyVerify = ?mtrms2_mg_verify_service_change_reply_fun(), 3246 NotifyReplyVerify = ?mtrms2_mg_verify_notify_reply_fun(), 3247 EvSeq = [ 3248 {debug, true}, 3249 megaco_start, 3250 {megaco_start_user, Mid, RI, []}, 3251 start_transport, 3252 {megaco_trace, disable}, 3253 {megaco_system_info, users}, 3254 {megaco_system_info, connections}, 3255 connect, 3256 {megaco_callback, handle_connect, ConnectVerify}, 3257 megaco_connect, 3258 {megaco_cast, ServiceChangeReq, []}, 3259 {megaco_callback, handle_connect, ConnectVerify}, 3260 {megaco_callback, handle_trans_reply, ServiceChangeReplyVerify}, 3261 {sleep, 1000}, 3262 {megaco_system_info, users}, 3263 {megaco_system_info, connections}, 3264 {sleep, 1000}, 3265 {megaco_update_conn_info, trans_req_maxcount, 10}, 3266 {megaco_update_conn_info, trans_req_maxsize, 1024}, 3267 {megaco_update_conn_info, trans_timer, 120000}, 3268 {megaco_update_conn_info, trans_req, true}, 3269 {megaco_conn_info, all}, 3270 {megaco_cast, NotifyReq1, []}, 3271 {megaco_cast, [NotifyReq1, NotifyReq1], []}, 3272 {megaco_cast, NotifyReq1, []}, 3273 {megaco_cast, NotifyReq2, []}, 3274 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 3275 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 3276 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 3277 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 3278 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 3279 {sleep, 1000}, 3280 megaco_stop_user, 3281 megaco_stop, 3282 {sleep, 1000} 3283 ], 3284 EvSeq. 3285 3286mtrms2_mg_verify_handle_connect({handle_connect, CH, ?VERSION}) -> 3287 io:format("mtrms2_mg_verify_handle_connect -> ok" 3288 "~n CH: ~p~n", [CH]), 3289 {ok, CH, ok}; 3290mtrms2_mg_verify_handle_connect(Else) -> 3291 io:format("mtrms2_mg_verify_handle_connect -> unknown" 3292 "~n Else: ~p~n", [Else]), 3293 {error, Else, ok}. 3294 3295mtrms2_mg_verify_service_change_reply({handle_trans_reply, _CH, ?VERSION, 3296 {ok, [AR]}, _}) -> 3297 io:format("mtrms2_mg_verify_service_change_reply -> ok" 3298 "~n AR: ~p~n", [AR]), 3299 case AR of 3300 #'ActionReply'{commandReply = [SCR]} -> 3301 case SCR of 3302 {serviceChangeReply, 3303 #'ServiceChangeReply'{terminationID = [Tid], 3304 serviceChangeResult = Res}} -> 3305 case Tid of 3306 #megaco_term_id{contains_wildcards = false, 3307 id = ["root"]} -> 3308 case Res of 3309 {serviceChangeResParms, 3310 #'ServiceChangeResParm'{ 3311 serviceChangeMgcId = _RemoteMid}} -> 3312 {ok, AR, ok}; 3313 {Tag, Val} -> 3314 Err = {invalid_service_change_result, 3315 Tag, Val}, 3316 {error, Err, ok} 3317 end; 3318 _ -> 3319 Err = {invalid_termination_id, Tid}, 3320 {error, Err, ok} 3321 end; 3322 {Tag, Val} -> 3323 Err = {invalid_command_reply, Tag, Val}, 3324 {error, Err, ok} 3325 end; 3326 _ -> 3327 Err = {invalid_action_reply, AR}, 3328 {error, Err, ok} 3329 end; 3330mtrms2_mg_verify_service_change_reply(Else) -> 3331 io:format("mtrms2_mg_verify_service_change_reply -> unknown" 3332 "~n Else: ~p~n", [Else]), 3333 {error, Else, ok}. 3334 3335mtrms2_mg_verify_notify_reply({handle_trans_reply, _CH, ?VERSION, 3336 {ok, [AR]}, _}) -> 3337 io:format("mtrms2_mg_verify_notify_reply -> ok" 3338 "~n AR: ~p~n", [AR]), 3339 case AR of 3340 #'ActionReply'{commandReply = [{notifyReply, _NR}]} -> 3341 io:format("mtrms2_mg_verify_notify_reply -> " 3342 "single notify reply", []), 3343 {ok, AR, ok}; 3344 #'ActionReply'{commandReply = [{notifyReply, _NR}|_] = CR} -> 3345 io:format("mtrms2_mg_verify_notify_reply -> " 3346 "multi notify reply: (~w)", [length(CR)]), 3347 {ok, AR, ok}; 3348 _ -> 3349 {error, {invalid_action_reply, AR}, ok} 3350 end; 3351mtrms2_mg_verify_notify_reply(Else) -> 3352 io:format("mtrms2_mg_verify_notify_reply -> unknown" 3353 "~n Else: ~p~n", [Else]), 3354 {error, Else, ok}. 3355 3356mtrms2_mg_service_change_request_ar(_Mid, Cid) -> 3357 Prof = cre_serviceChangeProf("resgw", 1), 3358 SCP = cre_serviceChangeParm(restart, ["901 mg col boot"], Prof), 3359 Root = #megaco_term_id{id = ["root"]}, 3360 SCR = cre_serviceChangeReq([Root], SCP), 3361 CMD = cre_command(SCR), 3362 CR = cre_cmdReq(CMD), 3363 cre_actionReq(Cid, [CR]). 3364 3365%% mtrms2_mg_service_change_request_msg(Mid, TransId, Cid) -> 3366%% AR = mtrms2_mg_service_change_request_ar(Mid, Cid), 3367%% TR = cre_transReq(TransId, [AR]), 3368%% Trans = cre_transaction(TR), 3369%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 3370%% cre_megacoMessage(Mess). 3371 3372mtrms2_mg_notify_request_ar1(Rid, Tid, Cid) -> 3373 TT = cre_timeNotation("19990729", "22000000"), 3374 Ev = cre_obsEvent("al/of", TT), 3375 EvsDesc = cre_obsEvsDesc(Rid, [Ev]), 3376 NR = cre_notifyReq([Tid], EvsDesc), 3377 CMD = cre_command(NR), 3378 CR = cre_cmdReq(CMD), 3379 cre_actionReq(Cid, [CR]). 3380 3381mtrms2_mg_notify_request_ar2(Rid, Tid, Cid) -> 3382 F = fun(N) -> 3383 T = 22000000 + N, 3384 TS = integer_to_list(T), 3385 TT = cre_timeNotation("19990729", TS), 3386 Ev = cre_obsEvent("al/of", TT), 3387 EvsDesc = cre_obsEvsDesc(Rid+N, [Ev]), 3388 NR = cre_notifyReq([Tid], EvsDesc), 3389 CMD = cre_command(NR), 3390 cre_cmdReq(CMD) 3391 end, 3392 Ns = [0,1,2,3,4,5,6,7,8,9], 3393 CRs = [F(N) || N <- Ns], 3394 cre_actionReq(Cid, CRs). 3395 3396%% mtrms2_notify_request_msg(Mid, TransId, Rid, TermId, Cid) -> 3397%% AR = mtrms2_mg_notify_request_ar1(Rid, TermId, Cid), 3398%% TR = cre_transReq(TransId, [AR]), 3399%% Trans = cre_transaction(TR), 3400%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 3401%% cre_megacoMessage(Mess). 3402 3403 3404mtrms2_err_desc(T) -> 3405 cre_ErrDesc(T). 3406 3407 3408%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 3409 3410single_trans_req_and_ack(suite) -> 3411 []; 3412single_trans_req_and_ack(doc) -> 3413 []; 3414single_trans_req_and_ack(Config) when is_list(Config) -> 3415 Pre = fun() -> 3416 MgcNode = make_node_name(mgc), 3417 MgNode = make_node_name(mg), 3418 d("start nodes: " 3419 "~n MGC Node: ~p" 3420 "~n MG Node: ~p", 3421 [MgcNode, MgNode]), 3422 Nodes = [MgcNode, MgNode], 3423 ok = ?START_NODES(Nodes), 3424 Nodes 3425 end, 3426 Case = fun do_single_trans_req_and_ack/1, 3427 Post = fun(Nodes) -> 3428 d("stop nodes"), 3429 ?STOP_NODES(lists:reverse(Nodes)) 3430 end, 3431 try_tc(single_trans_req_and_ack, Pre, Case, Post). 3432 3433do_single_trans_req_and_ack([MgcNode, MgNode]) -> 3434 3435 d("[MGC] start the simulator "), 3436 {ok, Mgc} = megaco_test_megaco_generator:start_link("MGC", MgcNode), 3437 3438 d("[MGC] create the event sequence"), 3439 MgcEvSeq = straa_mgc_event_sequence(text, tcp), 3440 3441 i("wait some time before starting the MGC simulation"), 3442 sleep(1000), 3443 3444 d("[MGC] start the simulation"), 3445 {ok, MgcId} = megaco_test_megaco_generator:exec(Mgc, MgcEvSeq), 3446 3447 %% i("wait some time before starting the MG simulator"), 3448 %% sleep(1000), 3449 3450 i("await MGC ready announcement"), 3451 receive 3452 announce_mgc -> 3453 i("received MGC ready announcement"), 3454 ok 3455 end, 3456 3457 d("[MG] start the simulator (generator)"), 3458 {ok, Mg} = megaco_test_megaco_generator:start_link("MG", MgNode), 3459 3460 d("[MG] create the event sequence"), 3461 MgEvSeq = straa_mg_event_sequence(text, tcp), 3462 3463 i("wait some time before starting the MG simulation"), 3464 sleep(1000), 3465 3466 d("[MG] start the simulation"), 3467 {ok, MgId} = megaco_test_megaco_generator:exec(Mg, MgEvSeq), 3468 3469 d("await the generator reply(s)"), 3470 await_completion([MgcId, MgId]), 3471 3472 %% Tell Mgc to stop 3473 i("[MGC] stop generator"), 3474 megaco_test_megaco_generator:stop(Mgc), 3475 3476 %% Tell Mg to stop 3477 i("[MG] stop generator"), 3478 megaco_test_megaco_generator:stop(Mg), 3479 3480 i("done", []), 3481 ok. 3482 3483 3484%% 3485%% MGC generator stuff 3486%% 3487-ifdef(megaco_hipe_special). 3488-define(straa_mgc_verify_handle_connect_fun(), 3489 {?MODULE, straa_mgc_verify_handle_connect, []}). 3490-define(straa_mgc_verify_service_change_req_fun(Mid), 3491 {?MODULE, straa_mgc_verify_service_change_req, [Mid]}). 3492-define(straa_mgc_verify_notify_req_fun(), 3493 {?MODULE, straa_mgc_verify_notify_request, []}). 3494-define(straa_mgc_verify_ack_fun(), 3495 {?MODULE, straa_mgc_verify_ack, []}). 3496-define(straa_mgc_verify_handle_disconnect_fun(), 3497 {?MODULE, straa_mgc_verify_handle_disconnect, []}). 3498-else. 3499-define(straa_mgc_verify_handle_connect_fun(), 3500 fun straa_mgc_verify_handle_connect/1). 3501-define(straa_mgc_verify_service_change_req_fun(Mid), 3502 straa_mgc_verify_service_change_req_fun(Mid)). 3503-define(straa_mgc_verify_notify_req_fun(), 3504 straa_mgc_verify_notify_request_fun()). 3505-define(straa_mgc_verify_ack_fun(), 3506 fun straa_mgc_verify_ack/1). 3507-define(straa_mgc_verify_handle_disconnect_fun(), 3508 fun straa_mgc_verify_handle_disconnect/1). 3509-endif. 3510 3511straa_mgc_event_sequence(text, tcp) -> 3512 CTRL = self(), 3513 Mid = {deviceName,"ctrl"}, 3514 RI = [ 3515 {port, 2944}, 3516 {encoding_module, megaco_pretty_text_encoder}, 3517 {encoding_config, []}, 3518 {transport_module, megaco_tcp} 3519 ], 3520 ConnectVerify = ?straa_mgc_verify_handle_connect_fun(), 3521 ServiceChangeReqVerify = ?straa_mgc_verify_service_change_req_fun(Mid), 3522 NotifyReqVerify = ?straa_mgc_verify_notify_req_fun(), 3523 AckVerify = ?straa_mgc_verify_ack_fun(), 3524 DiscoVerify = ?straa_mgc_verify_handle_disconnect_fun(), 3525 EvSeq = [ 3526 {debug, true}, 3527 {megaco_trace, disable}, 3528 megaco_start, 3529 {megaco_start_user, Mid, RI, []}, 3530 start_transport, 3531 listen, 3532 3533 %% ANNOUNCE READY 3534 {trigger, fun() -> CTRL ! announce_mgc end}, 3535 3536 {megaco_callback, handle_connect, ConnectVerify}, 3537 {megaco_callback, handle_trans_request, ServiceChangeReqVerify}, 3538 {megaco_callback, handle_trans_request, NotifyReqVerify}, 3539 {megaco_callback, handle_trans_ack, AckVerify}, 3540 {megaco_callback, handle_trans_request, NotifyReqVerify}, 3541 {megaco_callback, handle_disconnect, DiscoVerify}, 3542 {sleep, 1000}, 3543 megaco_stop_user, 3544 megaco_stop 3545 ], 3546 EvSeq. 3547 3548 3549straa_mgc_verify_handle_connect({handle_connect, CH, ?VERSION}) -> 3550 io:format("straa_mgc_verify_handle_connect -> ok" 3551 "~n CH: ~p~n", [CH]), 3552 {ok, CH, ok}; 3553straa_mgc_verify_handle_connect(Else) -> 3554 io:format("straa_mgc_verify_handle_connect -> unknown" 3555 "~n Else: ~p~n", [Else]), 3556 {error, Else, ok}. 3557 3558straa_mgc_verify_service_change_req_fun(Mid) -> 3559 fun(Ev) -> 3560 straa_mgc_verify_service_change_req(Ev, Mid) 3561 end. 3562 3563straa_mgc_verify_service_change_req( 3564 {handle_trans_request, _, ?VERSION, [AR]}, Mid) -> 3565 io:format("straa_mgc_verify_service_change_req -> ok" 3566 "~n AR: ~p~n", [AR]), 3567 case AR of 3568 #'ActionRequest'{commandRequests = [CR]} -> 3569 case CR of 3570 #'CommandRequest'{command = Cmd} -> 3571 case Cmd of 3572 {serviceChangeReq, 3573 #'ServiceChangeRequest'{terminationID = [Tid], 3574 serviceChangeParms = Parms}} -> 3575 case Tid of 3576 #megaco_term_id{contains_wildcards = false, 3577 id = ["root"]} -> 3578 case Parms of 3579 #'ServiceChangeParm'{ 3580 serviceChangeMethod = restart, 3581 serviceChangeReason = [[$9,$0,$1|_]]} -> 3582 Reply = 3583 {discard_ack, 3584 [straa_mgc_service_change_reply_ar(Mid, 1)]}, 3585 {ok, AR, Reply}; 3586 _ -> 3587 Err = {invalid_SCP, Parms}, 3588 ED = straa_err_desc(Parms), 3589 ErrReply = {discard_ack, 3590 ED}, 3591 {error, Err, ErrReply} 3592 end; 3593 _ -> 3594 Err = {invalid_termination_id, Tid}, 3595 ED = straa_err_desc(Tid), 3596 ErrReply = {discard_ack, ED}, 3597 {error, Err, ErrReply} 3598 end; 3599 _ -> 3600 Err = {invalid_command, Cmd}, 3601 ED = straa_err_desc(Cmd), 3602 ErrReply = {discard_ack, ED}, 3603 {error, Err, ErrReply} 3604 end; 3605 _ -> 3606 Err = {invalid_command_request, CR}, 3607 ED = straa_err_desc(CR), 3608 ErrReply = {discard_ack, ED}, 3609 {error, Err, ErrReply} 3610 end; 3611 _ -> 3612 Err = {invalid_action_request, AR}, 3613 ED = straa_err_desc(AR), 3614 ErrReply = {discard_ack, ED}, 3615 {error, Err, ErrReply} 3616 end; 3617straa_mgc_verify_service_change_req(Else, _Mid) -> 3618 io:format("straa_mgc_verify_service_change_req -> unknown" 3619 "~n Else: ~p~n", [Else]), 3620 ED = straa_err_desc(Else), 3621 ErrReply = {discard_ack, ED}, 3622 {error, Else, ErrReply}. 3623 3624straa_mgc_verify_notify_request_fun() -> 3625 fun(Ev) -> 3626 straa_mgc_verify_notify_request(Ev) 3627 end. 3628 3629straa_mgc_verify_notify_request({handle_trans_request, _, ?VERSION, [AR]}) -> 3630 io:format("straa_mgc_verify_notify_request:fun -> ok" 3631 "~n AR: ~p~n", [AR]), 3632 case AR of 3633 #'ActionRequest'{contextId = 1 = Cid, 3634 commandRequests = [CR]} -> 3635 #'CommandRequest'{command = Cmd} = CR, 3636 {notifyReq, NR} = Cmd, 3637 #'NotifyRequest'{terminationID = [Tid], 3638 observedEventsDescriptor = OED, 3639 errorDescriptor = asn1_NOVALUE} = NR, 3640 #'ObservedEventsDescriptor'{observedEventLst = [OE]} = OED, 3641 #'ObservedEvent'{eventName = "al/of"} = OE, 3642 HandleAck = {handle_sloppy_ack, kalle}, 3643 Reply = {HandleAck, 3644 [straa_mgc_notify_reply_ar(Cid, Tid)]}, 3645 {ok, AR, Reply}; 3646 #'ActionRequest'{contextId = 2 = Cid, 3647 commandRequests = [CR]} -> 3648 #'CommandRequest'{command = Cmd} = CR, 3649 {notifyReq, NR} = Cmd, 3650 #'NotifyRequest'{terminationID = [Tid], 3651 observedEventsDescriptor = OED, 3652 errorDescriptor = asn1_NOVALUE} = NR, 3653 #'ObservedEventsDescriptor'{observedEventLst = [OE]} = OED, 3654 #'ObservedEvent'{eventName = "al/of"} = OE, 3655 Reply = {discard_ack, 3656 [straa_mgc_notify_reply_ar(Cid, Tid)]}, 3657 {ok, AR, Reply}; 3658 _ -> 3659 ED = straa_err_desc(AR), 3660 ErrReply = {discard_ack, ED}, 3661 {error, AR, ErrReply} 3662 end; 3663straa_mgc_verify_notify_request(Else) -> 3664 io:format("straa_mgc_verify_notify_request:fun -> unknown" 3665 "~n Else: ~p~n", [Else]), 3666 ED = straa_err_desc(Else), 3667 ErrReply = {discard_ack, ED}, 3668 {error, Else, ErrReply}. 3669 3670straa_mgc_verify_ack({handle_trans_ack, CH, ?VERSION, ok, kalle}) -> 3671 io:format("straa_mgc_verify_ack -> ok" 3672 "~n CH: ~p" 3673 "~n", [CH]), 3674 {ok, CH, ok}; 3675straa_mgc_verify_ack(Else) -> 3676 io:format("straa_mgc_verify_ack -> unknown" 3677 "~n Else: ~p~n", [Else]), 3678 {error, Else, ok}. 3679 3680straa_mgc_verify_handle_disconnect({handle_disconnect, CH, ?VERSION, R}) -> 3681 io:format("straa_mgc_verify_handle_disconnect -> ok" 3682 "~n CH: ~p" 3683 "~n R: ~p" 3684 "~n", [CH, R]), 3685 {ok, CH, ok}; 3686straa_mgc_verify_handle_disconnect(Else) -> 3687 io:format("straa_mgc_verify_handle_disconnect -> unknown" 3688 "~n Else: ~p~n", [Else]), 3689 {error, Else, ok}. 3690 3691 3692straa_mgc_service_change_reply_ar(Mid, Cid) -> 3693 SCRP = cre_serviceChangeResParm(Mid), 3694 SCRes = cre_serviceChangeResult(SCRP), 3695 Root = #megaco_term_id{id = ["root"]}, 3696 SCR = cre_serviceChangeReply([Root], SCRes), 3697 CR = cre_cmdReply(SCR), 3698 cre_actionReply(Cid, [CR]). 3699 3700%% straa_mgc_service_change_reply_msg(Mid, TransId, Cid) -> 3701%% AR = straa_mgc_service_change_reply_ar(Mid, Cid), 3702%% TRes = cre_transResult([AR]), 3703%% TR = cre_transReply(TransId, TRes), 3704%% Trans = cre_transaction(TR), 3705%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 3706%% cre_megacoMessage(Mess). 3707 3708straa_mgc_notify_reply_ar(Cid, TermId) -> 3709 NR = cre_notifyReply([TermId]), 3710 CR = cre_cmdReply(NR), 3711 cre_actionReply(Cid, [CR]). 3712 3713%% straa_mgc_notify_reply(Mid, TransId, Cid, TermId) -> 3714%% AR = straa_mgc_notify_reply_ar(Cid, TermId), 3715%% TRes = cre_transResult([AR]), 3716%% TR = cre_transReply(TransId, TRes), 3717%% Trans = cre_transaction(TR), 3718%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 3719%% cre_megacoMessage(Mess). 3720 3721 3722%% 3723%% MG generator stuff 3724%% 3725-ifdef(megaco_hipe_special). 3726-define(straa_mg_verify_handle_connect_fun(), 3727 {?MODULE, straa_mg_verify_handle_connect, []}). 3728-define(straa_mg_verify_service_change_reply_fun(), 3729 {?MODULE, straa_mg_verify_service_change_reply, []}). 3730-define(straa_mg_verify_notify_reply_fun(), 3731 {?MODULE, straa_mg_verify_notify_reply, []}). 3732-else. 3733-define(straa_mg_verify_handle_connect_fun(), 3734 fun straa_mg_verify_handle_connect/1). 3735-define(straa_mg_verify_service_change_reply_fun(), 3736 fun straa_mg_verify_service_change_reply/1). 3737-define(straa_mg_verify_notify_reply_fun(), 3738 fun straa_mg_verify_notify_reply/1). 3739-endif. 3740 3741straa_mg_event_sequence(text, tcp) -> 3742 Mid = {deviceName,"mg"}, 3743 RI = [ 3744 {port, 2944}, 3745 {encoding_module, megaco_pretty_text_encoder}, 3746 {encoding_config, []}, 3747 {transport_module, megaco_tcp} 3748 ], 3749 ServiceChangeReq = [straa_mg_service_change_request_ar(Mid, 1)], 3750 Tid = #megaco_term_id{id = ["00000000","00000000","01101101"]}, 3751 NR = fun(N) -> 3752 [straa_mg_notify_request_ar(N, Tid, N)] 3753 end, 3754 ConnectVerify = ?straa_mg_verify_handle_connect_fun(), 3755 ServiceChangeReplyVerify = ?straa_mg_verify_service_change_reply_fun(), 3756 NotifyReplyVerify = ?straa_mg_verify_notify_reply_fun(), 3757 EvSeq = [ 3758 {debug, true}, 3759 megaco_start, 3760 {megaco_start_user, Mid, RI, []}, 3761 start_transport, 3762 {megaco_trace, disable}, 3763 {megaco_system_info, users}, 3764 {megaco_system_info, connections}, 3765 connect, 3766 {megaco_callback, handle_connect, ConnectVerify}, 3767 megaco_connect, 3768 {megaco_cast, ServiceChangeReq, []}, 3769 {megaco_callback, handle_connect, ConnectVerify}, 3770 {megaco_callback, handle_trans_reply, ServiceChangeReplyVerify}, 3771 {sleep, 1000}, 3772 {megaco_update_conn_info, auto_ack, true}, 3773 {megaco_update_conn_info, trans_ack_maxcount, 10}, 3774 {megaco_update_conn_info, trans_timer, 1000}, 3775 {megaco_update_conn_info, trans_ack, true}, 3776 {megaco_update_conn_info, trans_req, true}, 3777 {megaco_conn_info, all}, 3778 {sleep, 1000}, 3779 {megaco_cast, NR(1), []}, 3780 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 3781 {megaco_cast, NR(2), []}, 3782 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 3783 {sleep, 3000}, 3784 megaco_stop_user, 3785 megaco_stop, 3786 {sleep, 1000} 3787 ], 3788 EvSeq. 3789 3790straa_mg_verify_handle_connect({handle_connect, CH, ?VERSION}) -> 3791 io:format("straa_mg_verify_handle_connect -> ok" 3792 "~n CH: ~p~n", [CH]), 3793 {ok, CH, ok}; 3794straa_mg_verify_handle_connect(Else) -> 3795 io:format("straa_mg_verify_handle_connect -> unknown" 3796 "~n Else: ~p~n", [Else]), 3797 {error, Else, ok}. 3798 3799straa_mg_verify_service_change_reply({handle_trans_reply, _CH, ?VERSION, 3800 {ok, [AR]}, _}) -> 3801 io:format("straa_mg_verify_service_change_reply -> ok" 3802 "~n AR: ~p~n", [AR]), 3803 case AR of 3804 #'ActionReply'{commandReply = [SCR]} -> 3805 case SCR of 3806 {serviceChangeReply, 3807 #'ServiceChangeReply'{terminationID = [Tid], 3808 serviceChangeResult = Res}} -> 3809 case Tid of 3810 #megaco_term_id{contains_wildcards = false, 3811 id = ["root"]} -> 3812 case Res of 3813 {serviceChangeResParms, 3814 #'ServiceChangeResParm'{ 3815 serviceChangeMgcId = _RemoteMid}} -> 3816 {ok, AR, ok}; 3817 {Tag, Val} -> 3818 Err = {invalid_service_change_result, 3819 Tag, Val}, 3820 {error, Err, ok} 3821 end; 3822 _ -> 3823 Err = {invalid_termination_id, Tid}, 3824 {error, Err, ok} 3825 end; 3826 {Tag, Val} -> 3827 Err = {invalid_command_reply, Tag, Val}, 3828 {error, Err, ok} 3829 end; 3830 _ -> 3831 Err = {invalid_action_reply, AR}, 3832 {error, Err, ok} 3833 end; 3834straa_mg_verify_service_change_reply(Else) -> 3835 io:format("straa_mg_verify_service_change_reply -> unknown" 3836 "~n Else: ~p~n", [Else]), 3837 {error, Else, ok}. 3838 3839straa_mg_verify_notify_reply({handle_trans_reply, _CH, ?VERSION, 3840 {ok, [AR]}, _}) -> 3841 io:format("straa_mg_verify_notify_reply -> ok" 3842 "~n AR: ~p~n", [AR]), 3843 {ok, AR, ok}; 3844straa_mg_verify_notify_reply({handle_trans_reply, _CH, ?VERSION, 3845 {error, Err}, _}) -> 3846 io:format("straa_mg_verify_notify_reply -> error" 3847 "~n Err: ~p~n", [Err]), 3848 {error, Err, ok}; 3849straa_mg_verify_notify_reply(Else) -> 3850 io:format("straa_mg_verify_notify_reply -> unknown" 3851 "~n Else: ~p~n", [Else]), 3852 {error, Else, ok}. 3853 3854straa_mg_service_change_request_ar(_Mid, Cid) -> 3855 Prof = cre_serviceChangeProf("resgw", 1), 3856 SCP = cre_serviceChangeParm(restart, ["901 mg col boot"], Prof), 3857 Root = #megaco_term_id{id = ["root"]}, 3858 SCR = cre_serviceChangeReq([Root], SCP), 3859 CMD = cre_command(SCR), 3860 CR = cre_cmdReq(CMD), 3861 cre_actionReq(Cid, [CR]). 3862 3863%% straa_mg_service_change_request_msg(Mid, TransId, Cid) -> 3864%% AR = straa_mg_service_change_request_ar(Mid, Cid), 3865%% TR = cre_transReq(TransId, [AR]), 3866%% Trans = cre_transaction(TR), 3867%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 3868%% cre_megacoMessage(Mess). 3869 3870straa_mg_notify_request_ar(Rid, Tid, Cid) -> 3871 TT = cre_timeNotation("19990729", "22000000"), 3872 Ev = cre_obsEvent("al/of", TT), 3873 EvsDesc = cre_obsEvsDesc(Rid, [Ev]), 3874 NR = cre_notifyReq([Tid], EvsDesc), 3875 CMD = cre_command(NR), 3876 CR = cre_cmdReq(CMD), 3877 cre_actionReq(Cid, [CR]). 3878 3879%% straa_notify_request_msg(Mid, TransId, Rid, TermId, Cid) -> 3880%% AR = straa_mg_notify_request_ar(Rid, TermId, Cid), 3881%% TR = cre_transReq(TransId, [AR]), 3882%% Trans = cre_transaction(TR), 3883%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 3884%% cre_megacoMessage(Mess). 3885 3886 3887%% 3888%% Common functions for the single_trans_req test case 3889%% 3890 3891straa_err_desc(T) -> 3892 cre_ErrDesc(T). 3893 3894 3895 3896 3897%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 3898 3899multi_trans_req_and_ack_timeout(suite) -> 3900 []; 3901multi_trans_req_and_ack_timeout(doc) -> 3902 []; 3903multi_trans_req_and_ack_timeout(Config) when is_list(Config) -> 3904 Pre = fun() -> 3905 MgcNode = make_node_name(mgc), 3906 MgNode = make_node_name(mg), 3907 d("start nodes: " 3908 "~n MGC Node: ~p" 3909 "~n MG Node: ~p", 3910 [MgcNode, MgNode]), 3911 Nodes = [MgcNode, MgNode], 3912 ok = ?START_NODES(Nodes), 3913 Nodes 3914 end, 3915 Case = fun do_multi_trans_req_and_ack_timeout/1, 3916 Post = fun(Nodes) -> 3917 d("stop nodes"), 3918 ?STOP_NODES(lists:reverse(Nodes)) 3919 end, 3920 try_tc(multi_trans_req_and_ack_timeout, Pre, Case, Post). 3921 3922do_multi_trans_req_and_ack_timeout([MgcNode, MgNode]) -> 3923 3924 d("[MGC] start the simulator "), 3925 {ok, Mgc} = megaco_test_megaco_generator:start_link("MGC", MgcNode), 3926 3927 d("[MGC] create the event sequence"), 3928 MgcEvSeq = mtrtaat_mgc_event_sequence(text, tcp), 3929 3930 i("wait some time before starting the MGC simulation"), 3931 sleep(1000), 3932 3933 d("[MGC] start the simulation"), 3934 {ok, MgcId} = megaco_test_megaco_generator:exec(Mgc, MgcEvSeq), 3935 3936 %% i("wait some time before starting the MG simulator"), 3937 %% sleep(1000), 3938 3939 i("await MGC ready announcement"), 3940 receive 3941 announce_mgc -> 3942 i("received MGC ready announcement"), 3943 ok 3944 end, 3945 3946 d("[MG] start the simulator (generator)"), 3947 {ok, Mg} = megaco_test_megaco_generator:start_link("MG", MgNode), 3948 3949 d("[MG] create the event sequence"), 3950 MgEvSeq = mtrtaat_mg_event_sequence(text, tcp), 3951 3952 i("wait some time before starting the MG simulation"), 3953 sleep(1000), 3954 3955 d("[MG] start the simulation"), 3956 {ok, MgId} = megaco_test_megaco_generator:exec(Mg, MgEvSeq), 3957 3958 d("await the generator reply(s)"), 3959 await_completion([MgcId, MgId]), 3960 3961 %% Tell Mgc to stop 3962 i("[MGC] stop generator"), 3963 megaco_test_megaco_generator:stop(Mgc), 3964 3965 %% Tell Mg to stop 3966 i("[MG] stop generator"), 3967 megaco_test_megaco_generator:stop(Mg), 3968 3969 i("done", []), 3970 ok. 3971 3972 3973%% 3974%% MGC generator stuff 3975%% 3976-ifdef(megaco_hipe_special). 3977-define(mtrtaat_mgc_verify_handle_connect_fun(), 3978 {?MODULE, mtrtaat_mgc_verify_handle_connect, []}). 3979-define(mtrtaat_mgc_verify_service_change_req_fun(Mid), 3980 {?MODULE, mtrtaat_mgc_verify_service_change_req, [Mid]}). 3981-define(mtrtaat_mgc_verify_notify_req_fun(), 3982 {?MODULE, mtrtaat_mgc_verify_notify_request, []}). 3983-define(mtrtaat_mgc_verify_ack_fun(), 3984 {?MODULE, mtrtaat_mgc_verify_ack, []}). 3985-define(mtrtaat_mgc_verify_handle_disconnect_fun(), 3986 {?MODULE, mtrtaat_mgc_verify_handle_disconnect, []}). 3987-else. 3988-define(mtrtaat_mgc_verify_handle_connect_fun(), 3989 fun mtrtaat_mgc_verify_handle_connect/1). 3990-define(mtrtaat_mgc_verify_service_change_req_fun(Mid), 3991 mtrtaat_mgc_verify_service_change_req_fun(Mid)). 3992-define(mtrtaat_mgc_verify_notify_req_fun(), 3993 mtrtaat_mgc_verify_notify_request_fun()). 3994-define(mtrtaat_mgc_verify_ack_fun(), 3995 fun mtrtaat_mgc_verify_ack/1). 3996-define(mtrtaat_mgc_verify_handle_disconnect_fun(), 3997 fun mtrtaat_mgc_verify_handle_disconnect/1). 3998-endif. 3999 4000mtrtaat_mgc_event_sequence(text, tcp) -> 4001 CTRL = self(), 4002 Mid = {deviceName,"ctrl"}, 4003 RI = [ 4004 {port, 2944}, 4005 {encoding_module, megaco_pretty_text_encoder}, 4006 {encoding_config, []}, 4007 {transport_module, megaco_tcp} 4008 ], 4009 ConnectVerify = ?mtrtaat_mgc_verify_handle_connect_fun(), 4010 ServiceChangeReqVerify = ?mtrtaat_mgc_verify_service_change_req_fun(Mid), 4011 NotifyReqVerify = ?mtrtaat_mgc_verify_notify_req_fun(), 4012 AckVerify = ?mtrtaat_mgc_verify_ack_fun(), 4013 DiscoVerify = ?mtrtaat_mgc_verify_handle_disconnect_fun(), 4014 EvSeq = [ 4015 {debug, true}, 4016 {megaco_trace, disable}, 4017 megaco_start, 4018 {megaco_start_user, Mid, RI, []}, 4019 start_transport, 4020 listen, 4021 4022 %% ANNOUNCE READY 4023 {trigger, fun() -> CTRL ! announce_mgc end}, 4024 4025 {megaco_callback, handle_connect, ConnectVerify}, 4026 {megaco_callback, handle_trans_request, ServiceChangeReqVerify}, 4027 {megaco_callback, handle_trans_request, NotifyReqVerify}, 4028 {megaco_callback, handle_trans_request, NotifyReqVerify}, 4029 {megaco_callback, handle_trans_request, NotifyReqVerify}, 4030 {megaco_callback, handle_trans_ack, AckVerify}, 4031 {megaco_callback, handle_trans_ack, AckVerify}, 4032 {megaco_callback, handle_trans_ack, AckVerify}, 4033 {megaco_callback, handle_trans_request, NotifyReqVerify}, 4034 {megaco_callback, handle_trans_request, NotifyReqVerify}, 4035 {megaco_callback, handle_trans_request, NotifyReqVerify}, 4036 {megaco_callback, handle_disconnect, DiscoVerify}, 4037 {sleep, 1000}, 4038 megaco_stop_user, 4039 megaco_stop 4040 ], 4041 EvSeq. 4042 4043 4044mtrtaat_mgc_verify_handle_connect({handle_connect, CH, ?VERSION}) -> 4045 io:format("mtrtaat_mgc_verify_handle_connect -> ok" 4046 "~n CH: ~p~n", [CH]), 4047 {ok, CH, ok}; 4048mtrtaat_mgc_verify_handle_connect(Else) -> 4049 io:format("mtrtaat_mgc_verify_handle_connect -> unknown" 4050 "~n Else: ~p~n", [Else]), 4051 {error, Else, ok}. 4052 4053mtrtaat_mgc_verify_service_change_req_fun(Mid) -> 4054 fun(Ev) -> 4055 mtrtaat_mgc_verify_service_change_req(Ev, Mid) 4056 end. 4057 4058mtrtaat_mgc_verify_service_change_req( 4059 {handle_trans_request, _, ?VERSION, [AR]}, Mid) -> 4060 io:format("mtrtaat_mgc_verify_service_change_req -> ok" 4061 "~n AR: ~p~n", [AR]), 4062 case AR of 4063 #'ActionRequest'{commandRequests = [CR]} -> 4064 case CR of 4065 #'CommandRequest'{command = Cmd} -> 4066 case Cmd of 4067 {serviceChangeReq, 4068 #'ServiceChangeRequest'{terminationID = [Tid], 4069 serviceChangeParms = Parms}} -> 4070 case Tid of 4071 #megaco_term_id{contains_wildcards = false, 4072 id = ["root"]} -> 4073 case Parms of 4074 #'ServiceChangeParm'{ 4075 serviceChangeMethod = restart, 4076 serviceChangeReason = [[$9,$0,$1|_]]} -> 4077 Reply = 4078 {discard_ack, 4079 [mtrtaat_mgc_service_change_reply_ar(Mid, 1)]}, 4080 {ok, AR, Reply}; 4081 _ -> 4082 Err = {invalid_SCP, Parms}, 4083 ED = mtrtaat_err_desc(Parms), 4084 ErrReply = {discard_ack, 4085 ED}, 4086 {error, Err, ErrReply} 4087 end; 4088 _ -> 4089 Err = {invalid_termination_id, Tid}, 4090 ED = mtrtaat_err_desc(Tid), 4091 ErrReply = {discard_ack, ED}, 4092 {error, Err, ErrReply} 4093 end; 4094 _ -> 4095 Err = {invalid_command, Cmd}, 4096 ED = mtrtaat_err_desc(Cmd), 4097 ErrReply = {discard_ack, ED}, 4098 {error, Err, ErrReply} 4099 end; 4100 _ -> 4101 Err = {invalid_command_request, CR}, 4102 ED = mtrtaat_err_desc(CR), 4103 ErrReply = {discard_ack, ED}, 4104 {error, Err, ErrReply} 4105 end; 4106 _ -> 4107 Err = {invalid_action_request, AR}, 4108 ED = mtrtaat_err_desc(AR), 4109 ErrReply = {discard_ack, ED}, 4110 {error, Err, ErrReply} 4111 end; 4112mtrtaat_mgc_verify_service_change_req(Else, _Mid) -> 4113 io:format("mtrtaat_mgc_verify_service_change_req -> unknown" 4114 "~n Else: ~p~n", [Else]), 4115 ED = mtrtaat_err_desc(Else), 4116 ErrReply = {discard_ack, ED}, 4117 {error, Else, ErrReply}. 4118 4119mtrtaat_mgc_verify_notify_request_fun() -> 4120 fun(Ev) -> 4121 mtrtaat_mgc_verify_notify_request(Ev) 4122 end. 4123 4124mtrtaat_mgc_verify_notify_request({handle_trans_request, _, ?VERSION, [AR]}) -> 4125 io:format("mtrtaat_mgc_verify_notify_request -> ok" 4126 "~n AR: ~p~n", [AR]), 4127 case AR of 4128 #'ActionRequest'{contextId = 1 = Cid, 4129 commandRequests = [CR]} -> 4130 #'CommandRequest'{command = Cmd} = CR, 4131 {notifyReq, NR} = Cmd, 4132 #'NotifyRequest'{terminationID = [Tid], 4133 observedEventsDescriptor = OED, 4134 errorDescriptor = asn1_NOVALUE} = NR, 4135 #'ObservedEventsDescriptor'{observedEventLst = [OE]} = OED, 4136 #'ObservedEvent'{eventName = "al/of"} = OE, 4137 HandleAck = {handle_sloppy_ack, kalle}, 4138 Reply = {HandleAck, 4139 [mtrtaat_mgc_notify_reply_ar(Cid, Tid)]}, 4140 {ok, AR, Reply}; 4141 #'ActionRequest'{contextId = 2 = Cid, 4142 commandRequests = [CR]} -> 4143 #'CommandRequest'{command = Cmd} = CR, 4144 {notifyReq, NR} = Cmd, 4145 #'NotifyRequest'{terminationID = [Tid], 4146 observedEventsDescriptor = OED, 4147 errorDescriptor = asn1_NOVALUE} = NR, 4148 #'ObservedEventsDescriptor'{observedEventLst = [OE]} = OED, 4149 #'ObservedEvent'{eventName = "al/of"} = OE, 4150 Reply = {discard_ack, [mtrtaat_mgc_notify_reply_ar(Cid, Tid)]}, 4151 {ok, AR, Reply}; 4152 _ -> 4153 ED = mtrtaat_err_desc(AR), 4154 ErrReply = {discard_ack, ED}, 4155 {error, AR, ErrReply} 4156 end; 4157mtrtaat_mgc_verify_notify_request(Else) -> 4158 io:format("mtrtaat_mgc_verify_notify_request -> unknown" 4159 "~n Else: ~p~n", [Else]), 4160 ED = mtrtaat_err_desc(Else), 4161 ErrReply = {discard_ack, ED}, 4162 {error, Else, ErrReply}. 4163 4164 4165mtrtaat_mgc_verify_ack({handle_trans_ack, CH, ?VERSION, ok, kalle}) -> 4166 io:format("mtrtaat_mgc_verify_ack -> ok" 4167 "~n CH: ~p" 4168 "~n", [CH]), 4169 {ok, CH, ok}; 4170mtrtaat_mgc_verify_ack(Else) -> 4171 io:format("mtrtaat_mgc_verify_ack -> unknown" 4172 "~n Else: ~p~n", [Else]), 4173 {error, Else, ok}. 4174 4175mtrtaat_mgc_verify_handle_disconnect({handle_disconnect, CH, ?VERSION, R}) -> 4176 io:format("mtrtaat_mgc_verify_handle_disconnect -> ok" 4177 "~n CH: ~p" 4178 "~n R: ~p" 4179 "~n", [CH, R]), 4180 {ok, CH, ok}; 4181mtrtaat_mgc_verify_handle_disconnect(Else) -> 4182 io:format("mtrtaat_mgc_verify_handle_disconnect -> unknown" 4183 "~n Else: ~p~n", [Else]), 4184 {error, Else, ok}. 4185 4186 4187mtrtaat_mgc_service_change_reply_ar(Mid, Cid) -> 4188 SCRP = cre_serviceChangeResParm(Mid), 4189 SCRes = cre_serviceChangeResult(SCRP), 4190 Root = #megaco_term_id{id = ["root"]}, 4191 SCR = cre_serviceChangeReply([Root], SCRes), 4192 CR = cre_cmdReply(SCR), 4193 cre_actionReply(Cid, [CR]). 4194 4195%% mtrtaat_mgc_service_change_reply_msg(Mid, TransId, Cid) -> 4196%% AR = mtrtaat_mgc_service_change_reply_ar(Mid, Cid), 4197%% TRes = cre_transResult([AR]), 4198%% TR = cre_transReply(TransId, TRes), 4199%% Trans = cre_transaction(TR), 4200%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 4201%% cre_megacoMessage(Mess). 4202 4203mtrtaat_mgc_notify_reply_ar(Cid, TermId) -> 4204 NR = cre_notifyReply([TermId]), 4205 CR = cre_cmdReply(NR), 4206 cre_actionReply(Cid, [CR]). 4207 4208%% mtrtaat_mgc_notify_reply(Mid, TransId, Cid, TermId) -> 4209%% AR = mtrtaat_mgc_notify_reply_ar(Cid, TermId), 4210%% TRes = cre_transResult([AR]), 4211%% TR = cre_transReply(TransId, TRes), 4212%% Trans = cre_transaction(TR), 4213%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 4214%% cre_megacoMessage(Mess). 4215 4216 4217%% 4218%% MG generator stuff 4219%% 4220-ifdef(megaco_hipe_special). 4221-define(mtrtaat_mg_verify_handle_connect_fun(), 4222 {?MODULE, mtrtaat_mg_verify_handle_connect, []}). 4223-define(mtrtaat_mg_verify_service_change_reply_fun(), 4224 {?MODULE, mtrtaat_mg_verify_service_change_reply, []}). 4225-define(mtrtaat_mg_verify_notify_reply_fun(), 4226 {?MODULE, mtrtaat_mg_verify_notify_reply, []}). 4227-else. 4228-define(mtrtaat_mg_verify_handle_connect_fun(), 4229 fun mtrtaat_mg_verify_handle_connect/1). 4230-define(mtrtaat_mg_verify_service_change_reply_fun(), 4231 fun mtrtaat_mg_verify_service_change_reply/1). 4232-define(mtrtaat_mg_verify_notify_reply_fun(), 4233 fun mtrtaat_mg_verify_notify_reply/1). 4234-endif. 4235 4236mtrtaat_mg_event_sequence(text, tcp) -> 4237 Mid = {deviceName,"mg"}, 4238 RI = [ 4239 {port, 2944}, 4240 {encoding_module, megaco_pretty_text_encoder}, 4241 {encoding_config, []}, 4242 {transport_module, megaco_tcp} 4243 ], 4244 ServiceChangeReq = [mtrtaat_mg_service_change_request_ar(Mid, 1)], 4245 Tid = #megaco_term_id{id = ["00000000","00000000","01101101"]}, 4246 NR = fun(Cid, Rid) -> 4247 [mtrtaat_mg_notify_request_ar(Rid, Tid, Cid)] 4248 end, 4249 ConnectVerify = ?mtrtaat_mg_verify_handle_connect_fun(), 4250 ServiceChangeReplyVerify = ?mtrtaat_mg_verify_service_change_reply_fun(), 4251 NotifyReplyVerify = ?mtrtaat_mg_verify_notify_reply_fun(), 4252 EvSeq = [ 4253 {debug, true}, 4254 megaco_start, 4255 {megaco_start_user, Mid, RI, []}, 4256 start_transport, 4257 {megaco_trace, disable}, 4258 {megaco_system_info, users}, 4259 {megaco_system_info, connections}, 4260 connect, 4261 {megaco_callback, handle_connect, ConnectVerify}, 4262 megaco_connect, 4263 {megaco_cast, ServiceChangeReq, []}, 4264 {megaco_callback, handle_connect, ConnectVerify}, 4265 {megaco_callback, handle_trans_reply, ServiceChangeReplyVerify}, 4266 {sleep, 1000}, 4267 {megaco_system_info, users}, 4268 {megaco_system_info, connections}, 4269 {sleep, 1000}, 4270 {megaco_update_conn_info, auto_ack, true}, 4271 {megaco_update_conn_info, trans_ack_maxcount, 10}, 4272 {megaco_update_conn_info, trans_req_maxcount, 10}, 4273 {megaco_update_conn_info, trans_timer, 1000}, 4274 {megaco_update_conn_info, trans_ack, true}, 4275 {megaco_update_conn_info, trans_req, true}, 4276 {megaco_conn_info, all}, 4277 {megaco_cast, NR(1,1), []}, 4278 {megaco_cast, NR(1,2), []}, 4279 {megaco_cast, NR(1,3), []}, 4280 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 4281 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 4282 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 4283 {megaco_cast, NR(2,1), []}, 4284 {megaco_cast, NR(2,2), []}, 4285 {megaco_cast, NR(2,3), []}, 4286 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 4287 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 4288 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 4289 {sleep, 3000}, 4290 megaco_stop_user, 4291 megaco_stop, 4292 {sleep, 1000} 4293 ], 4294 EvSeq. 4295 4296mtrtaat_mg_verify_handle_connect({handle_connect, CH, ?VERSION}) -> 4297 io:format("mtrtaat_mg_verify_handle_connect -> ok" 4298 "~n CH: ~p~n", [CH]), 4299 {ok, CH, ok}; 4300mtrtaat_mg_verify_handle_connect(Else) -> 4301 io:format("mtrtaat_mg_verify_handle_connect -> unknown" 4302 "~n Else: ~p~n", [Else]), 4303 {error, Else, ok}. 4304 4305mtrtaat_mg_verify_service_change_reply({handle_trans_reply, _CH, ?VERSION, 4306 {ok, [AR]}, _}) -> 4307 io:format("mtrtaat_mg_verify_service_change_reply -> ok" 4308 "~n AR: ~p~n", [AR]), 4309 case AR of 4310 #'ActionReply'{commandReply = [SCR]} -> 4311 case SCR of 4312 {serviceChangeReply, 4313 #'ServiceChangeReply'{terminationID = [Tid], 4314 serviceChangeResult = Res}} -> 4315 case Tid of 4316 #megaco_term_id{contains_wildcards = false, 4317 id = ["root"]} -> 4318 case Res of 4319 {serviceChangeResParms, 4320 #'ServiceChangeResParm'{ 4321 serviceChangeMgcId = _RemoteMid}} -> 4322 {ok, AR, ok}; 4323 {Tag, Val} -> 4324 Err = {invalid_service_change_result, 4325 Tag, Val}, 4326 {error, Err, ok} 4327 end; 4328 _ -> 4329 Err = {invalid_termination_id, Tid}, 4330 {error, Err, ok} 4331 end; 4332 {Tag, Val} -> 4333 Err = {invalid_command_reply, Tag, Val}, 4334 {error, Err, ok} 4335 end; 4336 _ -> 4337 Err = {invalid_action_reply, AR}, 4338 {error, Err, ok} 4339 end; 4340mtrtaat_mg_verify_service_change_reply(Else) -> 4341 io:format("mtrtaat_mg_verify_service_change_reply -> unknown" 4342 "~n Else: ~p~n", [Else]), 4343 {error, Else, ok}. 4344 4345mtrtaat_mg_verify_notify_reply({handle_trans_reply, _CH, ?VERSION, 4346 {ok, [AR]}, _}) -> 4347 io:format("mtrtaat_mg_verify_notify_reply -> ok" 4348 "~n AR: ~p~n", [AR]), 4349 {ok, AR, ok}; 4350mtrtaat_mg_verify_notify_reply(Else) -> 4351 io:format("mtrtaat_mg_verify_notify_reply -> unknown" 4352 "~n Else: ~p~n", [Else]), 4353 {error, Else, ok}. 4354 4355mtrtaat_mg_service_change_request_ar(_Mid, Cid) -> 4356 Prof = cre_serviceChangeProf("resgw", 1), 4357 SCP = cre_serviceChangeParm(restart, ["901 mg col boot"], Prof), 4358 Root = #megaco_term_id{id = ["root"]}, 4359 SCR = cre_serviceChangeReq([Root], SCP), 4360 CMD = cre_command(SCR), 4361 CR = cre_cmdReq(CMD), 4362 cre_actionReq(Cid, [CR]). 4363 4364%% mtrtaat_mg_service_change_request_msg(Mid, TransId, Cid) -> 4365%% AR = mtrtaat_mg_service_change_request_ar(Mid, Cid), 4366%% TR = cre_transReq(TransId, [AR]), 4367%% Trans = cre_transaction(TR), 4368%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 4369%% cre_megacoMessage(Mess). 4370 4371mtrtaat_mg_notify_request_ar(Rid, Tid, Cid) -> 4372 TT = cre_timeNotation("19990729", "22000000"), 4373 Ev = cre_obsEvent("al/of", TT), 4374 EvsDesc = cre_obsEvsDesc(Rid, [Ev]), 4375 NR = cre_notifyReq([Tid], EvsDesc), 4376 CMD = cre_command(NR), 4377 CR = cre_cmdReq(CMD), 4378 cre_actionReq(Cid, [CR]). 4379 4380%% mtrtaat_notify_request_msg(Mid, TransId, Rid, TermId, Cid) -> 4381%% AR = mtrtaat_mg_notify_request_ar(Rid, TermId, Cid), 4382%% TR = cre_transReq(TransId, [AR]), 4383%% Trans = cre_transaction(TR), 4384%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 4385%% cre_megacoMessage(Mess). 4386 4387 4388%% 4389%% Common functions for the multi_trans_req_timeout test case 4390%% 4391 4392mtrtaat_err_desc(T) -> 4393 cre_ErrDesc(T). 4394 4395 4396%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 4397 4398%% Transaction Sender 4399%% 4400%% 4401 4402multi_trans_req_and_ack_ackmaxcount(suite) -> 4403 []; 4404multi_trans_req_and_ack_ackmaxcount(doc) -> 4405 []; 4406multi_trans_req_and_ack_ackmaxcount(Config) when is_list(Config) -> 4407 Pre = fun() -> 4408 MgcNode = make_node_name(mgc), 4409 MgNode = make_node_name(mg), 4410 d("start nodes: " 4411 "~n MGC Node: ~p" 4412 "~n MG Node: ~p", 4413 [MgcNode, MgNode]), 4414 Nodes = [MgcNode, MgNode], 4415 ok = ?START_NODES(Nodes), 4416 Nodes 4417 end, 4418 Case = fun do_multi_trans_req_and_ack_ackmaxcount/1, 4419 Post = fun(Nodes) -> 4420 d("stop nodes"), 4421 ?STOP_NODES(lists:reverse(Nodes)) 4422 end, 4423 try_tc(multi_trans_req_and_ack_ackmaxcount, Pre, Case, Post). 4424 4425do_multi_trans_req_and_ack_ackmaxcount([MgcNode, MgNode]) -> 4426 4427 d("[MGC] start the simulator "), 4428 {ok, Mgc} = megaco_test_megaco_generator:start_link("MGC", MgcNode), 4429 4430 d("[MGC] create the event sequence"), 4431 MgcEvSeq = mtrtaaamc_mgc_event_sequence(text, tcp), 4432 4433 i("wait some time before starting the MGC simulation"), 4434 sleep(1000), 4435 4436 d("[MGC] start the simulation"), 4437 {ok, MgcId} = megaco_test_megaco_generator:exec(Mgc, MgcEvSeq), 4438 4439 %% i("wait some time before starting the MG simulator"), 4440 %% sleep(1000), 4441 4442 i("await MGC ready announcement"), 4443 receive 4444 announce_mgc -> 4445 i("received MGC ready announcement"), 4446 ok 4447 end, 4448 4449 d("[MG] start the simulator (generator)"), 4450 {ok, Mg} = megaco_test_megaco_generator:start_link("MG", MgNode), 4451 4452 d("[MG] create the event sequence"), 4453 MgEvSeq = mtrtaaamc_mg_event_sequence(text, tcp), 4454 4455 i("wait some time before starting the MG simulation"), 4456 sleep(1000), 4457 4458 d("[MG] start the simulation"), 4459 {ok, MgId} = megaco_test_megaco_generator:exec(Mg, MgEvSeq), 4460 4461 d("await the generator reply(s)"), 4462 await_completion([MgcId, MgId]), 4463 4464 %% Tell Mgc to stop 4465 i("[MGC] stop generator"), 4466 megaco_test_megaco_generator:stop(Mgc), 4467 4468 %% Tell Mg to stop 4469 i("[MG] stop generator"), 4470 megaco_test_megaco_generator:stop(Mg), 4471 4472 i("done", []), 4473 ok. 4474 4475 4476%% 4477%% MGC generator stuff 4478%% 4479-ifdef(megaco_hipe_special). 4480-define(mtrtaaamc_mgc_verify_handle_connect_fun(), 4481 {?MODULE, mtrtaaamc_mgc_verify_handle_connect, []}). 4482-define(mtrtaaamc_mgc_verify_service_change_req_fun(Mid), 4483 {?MODULE, mtrtaaamc_mgc_verify_service_change_req, [Mid]}). 4484-define(mtrtaaamc_mgc_verify_notify_req_fun(), 4485 {?MODULE, mtrtaaamc_mgc_verify_notify_request, []}). 4486-define(mtrtaaamc_mgc_verify_ack_fun(), 4487 {?MODULE, mtrtaaamc_mgc_verify_ack, []}). 4488-define(mtrtaaamc_mgc_verify_handle_disconnect_fun(), 4489 {?MODULE, mtrtaaamc_mgc_verify_handle_disconnect, []}). 4490-else. 4491-define(mtrtaaamc_mgc_verify_handle_connect_fun(), 4492 fun mtrtaaamc_mgc_verify_handle_connect/1). 4493-define(mtrtaaamc_mgc_verify_service_change_req_fun(Mid), 4494 mtrtaaamc_mgc_verify_service_change_req_fun(Mid)). 4495-define(mtrtaaamc_mgc_verify_notify_req_fun(), 4496 mtrtaaamc_mgc_verify_notify_request_fun()). 4497-define(mtrtaaamc_mgc_verify_ack_fun(), 4498 fun mtrtaaamc_mgc_verify_ack/1). 4499-define(mtrtaaamc_mgc_verify_handle_disconnect_fun(), 4500 fun mtrtaaamc_mgc_verify_handle_disconnect/1). 4501-endif. 4502 4503mtrtaaamc_mgc_event_sequence(text, tcp) -> 4504 CTRL = self(), 4505 Mid = {deviceName,"ctrl"}, 4506 RI = [ 4507 {port, 2944}, 4508 {encoding_module, megaco_pretty_text_encoder}, 4509 {encoding_config, []}, 4510 {transport_module, megaco_tcp} 4511 ], 4512 ConnectVerify = ?mtrtaaamc_mgc_verify_handle_connect_fun(), 4513 ServiceChangeReqVerify = ?mtrtaaamc_mgc_verify_service_change_req_fun(Mid), 4514 NotifyReqVerify = ?mtrtaaamc_mgc_verify_notify_req_fun(), 4515 AckVerify = ?mtrtaaamc_mgc_verify_ack_fun(), 4516 DiscoVerify = ?mtrtaaamc_mgc_verify_handle_disconnect_fun(), 4517 EvSeq = [ 4518 {debug, true}, 4519 {trigger, fun() -> 4520 put(verbosity, ?TEST_VERBOSITY) 4521 end}, 4522 {megaco_trace, disable}, 4523 megaco_start, 4524 {megaco_start_user, Mid, RI, []}, 4525 start_transport, 4526 listen, 4527 4528 %% ANNOUNCE READY 4529 {trigger, fun() -> CTRL ! announce_mgc end}, 4530 4531 {megaco_callback, handle_connect, ConnectVerify}, 4532 {megaco_callback, handle_trans_request, ServiceChangeReqVerify}, 4533 {megaco_callback, handle_trans_request, NotifyReqVerify}, 4534 {megaco_callback, handle_trans_request, NotifyReqVerify}, 4535 {megaco_callback, handle_trans_request, NotifyReqVerify}, 4536 {megaco_callback, handle_trans_request, NotifyReqVerify}, 4537 {megaco_callback, handle_trans_ack, AckVerify}, 4538 {megaco_callback, handle_trans_ack, AckVerify}, 4539 {megaco_callback, handle_trans_ack, AckVerify}, 4540 {megaco_callback, handle_trans_ack, AckVerify}, 4541 {megaco_callback, handle_trans_request, NotifyReqVerify}, 4542 {megaco_callback, handle_trans_request, NotifyReqVerify}, 4543 {megaco_callback, handle_trans_request, NotifyReqVerify}, 4544 {megaco_callback, handle_disconnect, DiscoVerify}, 4545 {sleep, 1000}, 4546 megaco_stop_user, 4547 megaco_stop 4548 ], 4549 EvSeq. 4550 4551 4552mtrtaaamc_mgc_verify_handle_connect({handle_connect, CH, ?VERSION}) -> 4553 i("MGC Connect verification ok" 4554 "~n ~p~n", [CH]), 4555 {ok, CH, ok}; 4556mtrtaaamc_mgc_verify_handle_connect(Else) -> 4557 e("MGC Connect verification failed: unknown" 4558 "~n ~p~n", [Else]), 4559 {error, Else, ok}. 4560 4561mtrtaaamc_mgc_verify_service_change_req_fun(Mid) -> 4562 fun(Ev) -> 4563 mtrtaaamc_mgc_verify_service_change_req(Ev, Mid) 4564 end. 4565 4566mtrtaaamc_mgc_verify_service_change_req( 4567 {handle_trans_request, _, ?VERSION, [AR]}, Mid) -> 4568 i("MGC Service Change Request verification: begin" 4569 "~n AR: ~p" 4570 "~n", [AR]), 4571 case AR of 4572 #'ActionRequest'{commandRequests = [CR]} -> 4573 case CR of 4574 #'CommandRequest'{command = Cmd} -> 4575 case Cmd of 4576 {serviceChangeReq, 4577 #'ServiceChangeRequest'{terminationID = [Tid], 4578 serviceChangeParms = Parms}} -> 4579 case Tid of 4580 #megaco_term_id{contains_wildcards = false, 4581 id = ["root"]} -> 4582 case Parms of 4583 #'ServiceChangeParm'{ 4584 serviceChangeMethod = restart, 4585 serviceChangeReason = [[$9,$0,$1|_]]} -> 4586 i("MGC Service Change Request " 4587 "verification ok"), 4588 Reply = 4589 {discard_ack, 4590 [mtrtaaamc_mgc_service_change_reply_ar(Mid, 1)]}, 4591 {ok, AR, Reply}; 4592 _ -> 4593 e("MGC Service Change Request " 4594 "verification failed: invalid SCP" 4595 "~n ~p" 4596 "~n", [Parms]), 4597 Err = {invalid_SCP, Parms}, 4598 ED = mtrtaaamc_err_desc(Parms), 4599 ErrReply = {discard_ack, 4600 ED}, 4601 {error, Err, ErrReply} 4602 end; 4603 _ -> 4604 e("MGC Service Change Request " 4605 "verification failed: " 4606 "invalid termination id" 4607 "~n ~p" 4608 "~n", [Tid]), 4609 Err = {invalid_termination_id, Tid}, 4610 ED = mtrtaaamc_err_desc(Tid), 4611 ErrReply = {discard_ack, ED}, 4612 {error, Err, ErrReply} 4613 end; 4614 _ -> 4615 e("MGC Service Change Request verification failed: " 4616 "invalid command" 4617 "~n ~p" 4618 "~n", [Cmd]), 4619 Err = {invalid_command, Cmd}, 4620 ED = mtrtaaamc_err_desc(Cmd), 4621 ErrReply = {discard_ack, ED}, 4622 {error, Err, ErrReply} 4623 end; 4624 _ -> 4625 e("MGC Service Change Request verification failed: " 4626 "invalid command request" 4627 "~n ~p" 4628 "~n", [CR]), 4629 Err = {invalid_command_request, CR}, 4630 ED = mtrtaaamc_err_desc(CR), 4631 ErrReply = {discard_ack, ED}, 4632 {error, Err, ErrReply} 4633 end; 4634 _ -> 4635 e("MGC Service Change Request verification failed: " 4636 "invalid action request" 4637 "~n ~p" 4638 "~n", [AR]), 4639 Err = {invalid_action_request, AR}, 4640 ED = mtrtaaamc_err_desc(AR), 4641 ErrReply = {discard_ack, ED}, 4642 {error, Err, ErrReply} 4643 end; 4644mtrtaaamc_mgc_verify_service_change_req(Else, _Mid) -> 4645 e("MGC Service Change Request verification failed: unknown" 4646 "~n ~p" 4647 "~n", [Else]), 4648 ED = mtrtaaamc_err_desc(Else), 4649 ErrReply = {discard_ack, ED}, 4650 {error, Else, ErrReply}. 4651 4652mtrtaaamc_mgc_verify_notify_request_fun() -> 4653 fun(Ev) -> 4654 mtrtaaamc_mgc_verify_notify_request(Ev) 4655 end. 4656 4657mtrtaaamc_mgc_verify_notify_request( 4658 {handle_trans_request, _, ?VERSION, [AR]}) -> 4659 i("MGC Notify Request verification: begin" 4660 "~n AR: ~p" 4661 "~n", [AR]), 4662 case AR of 4663 %% *** SLOPPY ACK *** 4664 #'ActionRequest'{contextId = 1 = Cid, 4665 commandRequests = [CR]} -> 4666 #'CommandRequest'{command = Cmd} = CR, 4667 {notifyReq, NR} = Cmd, 4668 #'NotifyRequest'{terminationID = [Tid], 4669 observedEventsDescriptor = OED, 4670 errorDescriptor = asn1_NOVALUE} = NR, 4671 #'ObservedEventsDescriptor'{requestId = Rid, 4672 observedEventLst = [OE]} = OED, 4673 #'ObservedEvent'{eventName = "al/of"} = OE, 4674 HandleAck = {handle_sloppy_ack, {kalle, Rid}}, 4675 i("MGC Notify Request verification ok: sloppy ack" 4676 "~n Cid: ~p" 4677 "~n Tid: ~p" 4678 "~n Rid: ~p", [Cid, Tid, Rid]), 4679 Reply = {HandleAck, 4680 [mtrtaaamc_mgc_notify_reply_ar(Cid, Tid)]}, 4681 {ok, AR, Reply}; 4682 4683 %% *** PROPER ACK *** 4684 #'ActionRequest'{contextId = 2 = Cid, 4685 commandRequests = [CR]} -> 4686 #'CommandRequest'{command = Cmd} = CR, 4687 {notifyReq, NR} = Cmd, 4688 #'NotifyRequest'{terminationID = [Tid], 4689 observedEventsDescriptor = OED, 4690 errorDescriptor = asn1_NOVALUE} = NR, 4691 #'ObservedEventsDescriptor'{requestId = _Rid, 4692 observedEventLst = [OE]} = OED, 4693 #'ObservedEvent'{eventName = "al/of"} = OE, 4694 i("MGC Notify Request verification ok: discard ack" 4695 "~n Cid: ~p" 4696 "~n Tid: ~p" 4697 "~n Rid: ~p", [Cid, Tid, _Rid]), 4698 Reply = {discard_ack, [mtrtaaamc_mgc_notify_reply_ar(Cid, Tid)]}, 4699 {ok, AR, Reply}; 4700 4701 _ -> 4702 e("MGC Notify Request verification failed: unexpected AR" 4703 "~n ~p" 4704 "~n", [AR]), 4705 ED = mtrtaaamc_err_desc(AR), 4706 ErrReply = {discard_ack, ED}, 4707 {error, AR, ErrReply} 4708 end; 4709mtrtaaamc_mgc_verify_notify_request(Else) -> 4710 e("MGC Notify Request verification failed: unexpected callback" 4711 "~n ~p" 4712 "~n", [Else]), 4713 ED = mtrtaaamc_err_desc(Else), 4714 ErrReply = {discard_ack, ED}, 4715 {error, Else, ErrReply}. 4716 4717mtrtaaamc_mgc_verify_ack({handle_trans_ack, CH, ?VERSION, ok, 4718 {kalle, Rid}}) -> 4719 i("MGC Ack verification: ok (kalle)" 4720 "~n CH: ~p" 4721 "~n Rid: ~p" 4722 "~n", [CH, Rid]), 4723 {ok, CH, ok}; 4724mtrtaaamc_mgc_verify_ack(Else) -> 4725 e("MGC Ack verification failed: unknown" 4726 "~n ~p~n", [Else]), 4727 {error, Else, ok}. 4728 4729mtrtaaamc_mgc_verify_handle_disconnect({handle_disconnect, CH, ?VERSION, R}) -> 4730 i("MGC Disconnect verification: ok" 4731 "~n CH: ~p" 4732 "~n R: ~p" 4733 "~n", [CH, R]), 4734 {ok, CH, ok}; 4735mtrtaaamc_mgc_verify_handle_disconnect(Else) -> 4736 e("MGC Disconnect verification failed: unknown" 4737 "~n ~p" 4738 "~n", [Else]), 4739 {error, Else, ok}. 4740 4741 4742mtrtaaamc_mgc_service_change_reply_ar(Mid, Cid) -> 4743 SCRP = cre_serviceChangeResParm(Mid), 4744 SCRes = cre_serviceChangeResult(SCRP), 4745 Root = #megaco_term_id{id = ["root"]}, 4746 SCR = cre_serviceChangeReply([Root], SCRes), 4747 CR = cre_cmdReply(SCR), 4748 cre_actionReply(Cid, [CR]). 4749 4750mtrtaaamc_mgc_notify_reply_ar(Cid, TermId) -> 4751 NR = cre_notifyReply([TermId]), 4752 CR = cre_cmdReply(NR), 4753 cre_actionReply(Cid, [CR]). 4754 4755 4756 4757%% 4758%% MG generator stuff 4759%% 4760-ifdef(megaco_hipe_special). 4761-define(mtrtaaamc_mg_verify_handle_connect_fun(), 4762 {?MODULE, mtrtaaamc_mg_verify_handle_connect, []}). 4763-define(mtrtaaamc_mg_verify_service_change_reply_fun(), 4764 {?MODULE, mtrtaaamc_mg_verify_service_change_reply, []}). 4765-define(mtrtaaamc_mg_verify_notify_reply_fun(), 4766 {?MODULE, mtrtaaamc_mg_verify_notify_reply, []}). 4767-else. 4768-define(mtrtaaamc_mg_verify_handle_connect_fun(), 4769 fun mtrtaaamc_mg_verify_handle_connect/1). 4770-define(mtrtaaamc_mg_verify_service_change_reply_fun(), 4771 fun mtrtaaamc_mg_verify_service_change_reply/1). 4772-define(mtrtaaamc_mg_verify_notify_reply_fun(), 4773 fun mtrtaaamc_mg_verify_notify_reply/1). 4774-endif. 4775 4776mtrtaaamc_mg_event_sequence(text, tcp) -> 4777 Mid = {deviceName,"mg"}, 4778 RI = [ 4779 {port, 2944}, 4780 {encoding_module, megaco_pretty_text_encoder}, 4781 {encoding_config, []}, 4782 {transport_module, megaco_tcp} 4783 ], 4784 ServiceChangeReq = [mtrtaaamc_mg_service_change_request_ar(Mid, 1)], 4785 Tid = #megaco_term_id{id = ["00000000","00000000","01101101"]}, 4786 NR = fun(Cid, Rid) -> 4787 [mtrtaaamc_mg_notify_request_ar(Rid, Tid, Cid)] 4788 end, 4789 ConnectVerify = ?mtrtaaamc_mg_verify_handle_connect_fun(), 4790 ServiceChangeReplyVerify = ?mtrtaaamc_mg_verify_service_change_reply_fun(), 4791 NotifyReplyVerify = ?mtrtaaamc_mg_verify_notify_reply_fun(), 4792 EvSeq = [ 4793 {debug, true}, 4794 {trigger, fun() -> 4795 put(verbosity, ?TEST_VERBOSITY) 4796 end}, 4797 megaco_start, 4798 {megaco_start_user, Mid, RI, []}, 4799 start_transport, 4800 {megaco_trace, disable}, 4801 {megaco_system_info, users}, 4802 {megaco_system_info, connections}, 4803 connect, 4804 {megaco_callback, handle_connect, ConnectVerify}, 4805 megaco_connect, 4806 {megaco_cast, ServiceChangeReq, []}, 4807 {megaco_callback, handle_connect, ConnectVerify}, 4808 {megaco_callback, handle_trans_reply, ServiceChangeReplyVerify}, 4809 {sleep, 1000}, 4810 {megaco_system_info, users}, 4811 {megaco_system_info, connections}, 4812 {sleep, 1000}, 4813 {megaco_update_conn_info, auto_ack, true}, 4814 {megaco_update_conn_info, trans_ack_maxcount, 4}, 4815 {megaco_update_conn_info, trans_req_maxcount, 10}, 4816 {megaco_update_conn_info, trans_timer, 5000}, 4817 {megaco_update_conn_info, trans_ack, true}, 4818 {megaco_update_conn_info, trans_req, true}, 4819 {megaco_conn_info, all}, 4820 {megaco_conn_info, requests}, 4821 {megaco_cast, NR(1,1), []}, 4822 {megaco_conn_info, requests}, 4823 {megaco_cast, NR(1,2), []}, 4824 {megaco_conn_info, requests}, 4825 {megaco_cast, NR(1,3), []}, 4826 {megaco_conn_info, requests}, 4827 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 4828 {megaco_conn_info, requests}, 4829 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 4830 {megaco_conn_info, requests}, 4831 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 4832 {megaco_conn_info, requests}, 4833 {megaco_cast, NR(2,1), []}, 4834 {megaco_conn_info, requests}, 4835 {megaco_cast, NR(2,2), []}, 4836 {megaco_conn_info, requests}, 4837 {megaco_cast, NR(2,3), []}, 4838 {megaco_conn_info, requests}, 4839 {megaco_cast, NR(1,4), [{trans_req,false}]}, 4840 {megaco_conn_info, requests}, 4841 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 4842 {megaco_conn_info, requests}, 4843 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 4844 {megaco_conn_info, requests}, 4845 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 4846 {megaco_conn_info, requests}, 4847 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 4848 {megaco_conn_info, requests}, 4849 {sleep, 3000}, 4850 megaco_stop_user, 4851 megaco_stop, 4852 {sleep, 1000} 4853 ], 4854 EvSeq. 4855 4856mtrtaaamc_mg_verify_handle_connect({handle_connect, CH, ?VERSION}) -> 4857 i("MG Connect verification: ok" 4858 "~n CH: ~p" 4859 "~n", [CH]), 4860 {ok, CH, ok}; 4861mtrtaaamc_mg_verify_handle_connect(Else) -> 4862 e("MG Connect verification failed: unknown" 4863 "~n ~p" 4864 "~n", [Else]), 4865 {error, Else, ok}. 4866 4867mtrtaaamc_mg_verify_service_change_reply({handle_trans_reply, _CH, ?VERSION, 4868 {ok, [AR]}, _}) -> 4869 i("MG Service Change Reply verification: begin" 4870 "~n AR: ~p" 4871 "~n", [AR]), 4872 case AR of 4873 #'ActionReply'{commandReply = [SCR]} -> 4874 case SCR of 4875 {serviceChangeReply, 4876 #'ServiceChangeReply'{terminationID = [Tid], 4877 serviceChangeResult = Res}} -> 4878 case Tid of 4879 #megaco_term_id{contains_wildcards = false, 4880 id = ["root"]} -> 4881 case Res of 4882 {serviceChangeResParms, 4883 #'ServiceChangeResParm'{ 4884 serviceChangeMgcId = _RemoteMid}} -> 4885 i("MG Service Change Reply verification ok"), 4886 {ok, AR, ok}; 4887 {Tag, Val} -> 4888 e("MG Service Change Reply " 4889 "verification failed: " 4890 "invalid service change result" 4891 "~n Tag: ~p" 4892 "~n Val: ~p" 4893 "~n", [Tag, Val]), 4894 Err = {invalid_service_change_result, 4895 Tag, Val}, 4896 {error, Err, ok} 4897 end; 4898 _ -> 4899 e("MG Service Change Reply verification failed: " 4900 "invalid termination id" 4901 "~n ~p" 4902 "~n", [Tid]), 4903 Err = {invalid_termination_id, Tid}, 4904 {error, Err, ok} 4905 end; 4906 {Tag, Val} -> 4907 e("MG Service Change Reply verification failed: " 4908 "invalid command reply" 4909 "~n Tag: ~p" 4910 "~n Val: ~p" 4911 "~n", [Tag, Val]), 4912 Err = {invalid_command_reply, Tag, Val}, 4913 {error, Err, ok} 4914 end; 4915 _ -> 4916 e("MG Service Change Reply verification failed: invalid action reply" 4917 "~n ~p" 4918 "~n", [AR]), 4919 Err = {invalid_action_reply, AR}, 4920 {error, Err, ok} 4921 end; 4922mtrtaaamc_mg_verify_service_change_reply(Else) -> 4923 e("MG Service Change Reply verification failed -> unknown" 4924 "~n ~p" 4925 "~n", [Else]), 4926 {error, Else, ok}. 4927 4928mtrtaaamc_mg_verify_notify_reply({handle_trans_reply, _CH, ?VERSION, 4929 {ok, [AR]}, _}) -> 4930 i("MG Notify Reply verification ok:" 4931 "~n ~p~n", [AR]), 4932 {ok, AR, ok}; 4933mtrtaaamc_mg_verify_notify_reply({handle_unexpected_trans, CH, PV, T} = Else) -> 4934 e("MG Notify Reply verification failed: unexpected transaction" 4935 "~n CH: ~p" 4936 "~n PV: ~p" 4937 "~n T: ~p" 4938 "~n", [CH, PV, T]), 4939 {error, Else, ok}; 4940mtrtaaamc_mg_verify_notify_reply({handle_unexpected_trans, CH, PV, E, T} = Else) -> 4941 e("MG Notify Reply failed: unexpected transaction" 4942 "~n CH: ~p" 4943 "~n PV: ~p" 4944 "~n E: ~p" 4945 "~n T: ~p" 4946 "~n", [CH, PV, E, T]), 4947 {error, Else, ok}; 4948mtrtaaamc_mg_verify_notify_reply(Else) -> 4949 e("MG Notify Reply failed -> unknown" 4950 "~n ~p" 4951 "~n", [Else]), 4952 {error, Else, ok}. 4953 4954mtrtaaamc_mg_service_change_request_ar(_Mid, Cid) -> 4955 Prof = cre_serviceChangeProf("resgw", 1), 4956 SCP = cre_serviceChangeParm(restart, ["901 mg col boot"], Prof), 4957 Root = #megaco_term_id{id = ["root"]}, 4958 SCR = cre_serviceChangeReq([Root], SCP), 4959 CMD = cre_command(SCR), 4960 CR = cre_cmdReq(CMD), 4961 cre_actionReq(Cid, [CR]). 4962 4963mtrtaaamc_mg_notify_request_ar(Rid, Tid, Cid) -> 4964 TT = cre_timeNotation("19990729", "22000000"), 4965 Ev = cre_obsEvent("al/of", TT), 4966 EvsDesc = cre_obsEvsDesc(Rid, [Ev]), 4967 NR = cre_notifyReq([Tid], EvsDesc), 4968 CMD = cre_command(NR), 4969 CR = cre_cmdReq(CMD), 4970 cre_actionReq(Cid, [CR]). 4971 4972 4973%% 4974%% Common functions for the multi_trans_req_timeout test case 4975%% 4976 4977mtrtaaamc_err_desc(T) -> 4978 cre_ErrDesc(T). 4979 4980 4981%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 4982 4983multi_trans_req_and_ack_reqmaxcount(suite) -> 4984 []; 4985multi_trans_req_and_ack_reqmaxcount(doc) -> 4986 []; 4987multi_trans_req_and_ack_reqmaxcount(Config) when is_list(Config) -> 4988 Pre = fun() -> 4989 MgcNode = make_node_name(mgc), 4990 MgNode = make_node_name(mg), 4991 d("start nodes: " 4992 "~n MGC Node: ~p" 4993 "~n MG Node: ~p", 4994 [MgcNode, MgNode]), 4995 Nodes = [MgcNode, MgNode], 4996 ok = ?START_NODES(Nodes), 4997 Nodes 4998 end, 4999 Case = fun do_multi_trans_req_and_ack_reqmaxcount/1, 5000 Post = fun(Nodes) -> 5001 d("stop nodes"), 5002 ?STOP_NODES(lists:reverse(Nodes)) 5003 end, 5004 try_tc(multi_trans_req_and_ack_reqmaxcount, Pre, Case, Post). 5005 5006do_multi_trans_req_and_ack_reqmaxcount([MgcNode, MgNode]) -> 5007 5008 d("[MGC] start the simulator "), 5009 {ok, Mgc} = megaco_test_megaco_generator:start_link("MGC", MgcNode), 5010 5011 d("[MGC] create the event sequence"), 5012 MgcEvSeq = mtrtaarac_mgc_event_sequence(text, tcp), 5013 5014 i("wait some time before starting the MGC simulation"), 5015 sleep(1000), 5016 5017 d("[MGC] start the simulation"), 5018 {ok, MgcId} = megaco_test_megaco_generator:exec(Mgc, MgcEvSeq), 5019 5020 %% i("wait some time before starting the MG simulator"), 5021 %% sleep(1000), 5022 5023 i("await MGC ready announcement"), 5024 receive 5025 announce_mgc -> 5026 i("received MGC ready announcement"), 5027 ok 5028 end, 5029 5030 d("[MG] start the simulator (generator)"), 5031 {ok, Mg} = megaco_test_megaco_generator:start_link("MG", MgNode), 5032 5033 d("[MG] create the event sequence"), 5034 MgEvSeq = mtrtaarac_mg_event_sequence(text, tcp), 5035 5036 i("wait some time before starting the MG simulation"), 5037 sleep(1000), 5038 5039 d("[MG] start the simulation"), 5040 {ok, MgId} = megaco_test_megaco_generator:exec(Mg, MgEvSeq), 5041 5042 d("await the generator reply(s)"), 5043 await_completion([MgcId, MgId]), 5044 5045 %% Tell Mgc to stop 5046 i("[MGC] stop generator"), 5047 megaco_test_megaco_generator:stop(Mgc), 5048 5049 %% Tell Mg to stop 5050 i("[MG] stop generator"), 5051 megaco_test_megaco_generator:stop(Mg), 5052 5053 i("done", []), 5054 ok. 5055 5056 5057%% 5058%% MGC generator stuff 5059%% 5060-ifdef(megaco_hipe_special). 5061-define(mtrtaarac_mgc_verify_handle_connect_fun(), 5062 {?MODULE, mtrtaarac_mgc_verify_handle_connect, []}). 5063-define(mtrtaarac_mgc_verify_service_change_req_fun(Mid), 5064 {?MODULE, mtrtaarac_mgc_verify_service_change_req, [Mid]}). 5065-define(mtrtaarac_mgc_verify_notify_req_fun(), 5066 {?MODULE, mtrtaarac_mgc_verify_notify_request, []}). 5067-define(mtrtaarac_mgc_verify_ack_fun(), 5068 {?MODULE, mtrtaarac_mgc_verify_ack, []}). 5069-define(mtrtaarac_mgc_verify_handle_disconnect_fun(), 5070 {?MODULE, mtrtaarac_mgc_verify_handle_disconnect, []}). 5071-else. 5072-define(mtrtaarac_mgc_verify_handle_connect_fun(), 5073 fun mtrtaarac_mgc_verify_handle_connect/1). 5074-define(mtrtaarac_mgc_verify_service_change_req_fun(Mid), 5075 mtrtaarac_mgc_verify_service_change_req_fun(Mid)). 5076-define(mtrtaarac_mgc_verify_notify_req_fun(), 5077 mtrtaarac_mgc_verify_notify_request_fun()). 5078-define(mtrtaarac_mgc_verify_ack_fun(), 5079 fun mtrtaarac_mgc_verify_ack/1). 5080-define(mtrtaarac_mgc_verify_handle_disconnect_fun(), 5081 fun mtrtaarac_mgc_verify_handle_disconnect/1). 5082-endif. 5083 5084mtrtaarac_mgc_event_sequence(text, tcp) -> 5085 CTRL = self(), 5086 Mid = {deviceName,"ctrl"}, 5087 RI = [ 5088 {port, 2944}, 5089 {encoding_module, megaco_pretty_text_encoder}, 5090 {encoding_config, []}, 5091 {transport_module, megaco_tcp} 5092 ], 5093 ConnectVerify = ?mtrtaarac_mgc_verify_handle_connect_fun(), 5094 ServiceChangeReqVerify = ?mtrtaarac_mgc_verify_service_change_req_fun(Mid), 5095 NotifyReqVerify = ?mtrtaarac_mgc_verify_notify_req_fun(), 5096 AckVerify = ?mtrtaarac_mgc_verify_ack_fun(), 5097 DiscoVerify = ?mtrtaarac_mgc_verify_handle_disconnect_fun(), 5098 EvSeq = [ 5099 {debug, true}, 5100 {megaco_trace, disable}, 5101 megaco_start, 5102 {megaco_start_user, Mid, RI, []}, 5103 start_transport, 5104 listen, 5105 5106 %% ANNOUNCE READY 5107 {trigger, fun() -> CTRL ! announce_mgc end}, 5108 5109 {megaco_callback, handle_connect, ConnectVerify}, 5110 {megaco_callback, handle_trans_request, ServiceChangeReqVerify}, 5111 {megaco_callback, handle_trans_request, NotifyReqVerify}, 5112 {megaco_callback, handle_trans_request, NotifyReqVerify}, 5113 {megaco_callback, handle_trans_request, NotifyReqVerify}, 5114 {megaco_callback, handle_trans_ack, AckVerify}, 5115 {megaco_callback, handle_trans_ack, AckVerify}, 5116 {megaco_callback, handle_trans_ack, AckVerify}, 5117 {megaco_callback, handle_trans_request, NotifyReqVerify}, 5118 {megaco_callback, handle_trans_request, NotifyReqVerify}, 5119 {megaco_callback, handle_trans_request, NotifyReqVerify}, 5120 {megaco_callback, handle_trans_request, NotifyReqVerify}, 5121 {megaco_callback, handle_disconnect, DiscoVerify}, 5122 {sleep, 1000}, 5123 megaco_stop_user, 5124 megaco_stop 5125 ], 5126 EvSeq. 5127 5128 5129mtrtaarac_mgc_verify_handle_connect({handle_connect, CH, ?VERSION}) -> 5130 io:format("mtrtaarac_mgc_verify_handle_connect -> ok" 5131 "~n CH: ~p~n", [CH]), 5132 {ok, CH, ok}; 5133mtrtaarac_mgc_verify_handle_connect(Else) -> 5134 io:format("mtrtaarac_mgc_verify_handle_connect -> unknown" 5135 "~n Else: ~p~n", [Else]), 5136 {error, Else, ok}. 5137 5138mtrtaarac_mgc_verify_service_change_req_fun(Mid) -> 5139 fun(Ev) -> 5140 mtrtaarac_mgc_verify_service_change_req(Ev, Mid) 5141 end. 5142 5143mtrtaarac_mgc_verify_service_change_req( 5144 {handle_trans_request, _, ?VERSION, [AR]}, Mid) -> 5145 io:format("mtrtaarac_mgc_verify_service_change_req -> ok" 5146 "~n AR: ~p~n", [AR]), 5147 case AR of 5148 #'ActionRequest'{commandRequests = [CR]} -> 5149 case CR of 5150 #'CommandRequest'{command = Cmd} -> 5151 case Cmd of 5152 {serviceChangeReq, 5153 #'ServiceChangeRequest'{terminationID = [Tid], 5154 serviceChangeParms = Parms}} -> 5155 case Tid of 5156 #megaco_term_id{contains_wildcards = false, 5157 id = ["root"]} -> 5158 case Parms of 5159 #'ServiceChangeParm'{ 5160 serviceChangeMethod = restart, 5161 serviceChangeReason = [[$9,$0,$1|_]]} -> 5162 Reply = 5163 {discard_ack, 5164 [mtrtaarac_mgc_service_change_reply_ar(Mid, 1)]}, 5165 {ok, AR, Reply}; 5166 _ -> 5167 Err = {invalid_SCP, Parms}, 5168 ED = mtrtaarac_err_desc(Parms), 5169 ErrReply = {discard_ack, 5170 ED}, 5171 {error, Err, ErrReply} 5172 end; 5173 _ -> 5174 Err = {invalid_termination_id, Tid}, 5175 ED = mtrtaarac_err_desc(Tid), 5176 ErrReply = {discard_ack, ED}, 5177 {error, Err, ErrReply} 5178 end; 5179 _ -> 5180 Err = {invalid_command, Cmd}, 5181 ED = mtrtaarac_err_desc(Cmd), 5182 ErrReply = {discard_ack, ED}, 5183 {error, Err, ErrReply} 5184 end; 5185 _ -> 5186 Err = {invalid_command_request, CR}, 5187 ED = mtrtaarac_err_desc(CR), 5188 ErrReply = {discard_ack, ED}, 5189 {error, Err, ErrReply} 5190 end; 5191 _ -> 5192 Err = {invalid_action_request, AR}, 5193 ED = mtrtaarac_err_desc(AR), 5194 ErrReply = {discard_ack, ED}, 5195 {error, Err, ErrReply} 5196 end; 5197mtrtaarac_mgc_verify_service_change_req(Else, _Mid) -> 5198 io:format("mtrtaarac_mgc_verify_service_change_req -> unknown" 5199 "~n Else: ~p~n", [Else]), 5200 ED = mtrtaarac_err_desc(Else), 5201 ErrReply = {discard_ack, ED}, 5202 {error, Else, ErrReply}. 5203 5204mtrtaarac_mgc_verify_notify_request_fun() -> 5205 fun(Ev) -> 5206 mtrtaarac_mgc_verify_notify_request(Ev) 5207 end. 5208 5209mtrtaarac_mgc_verify_notify_request( 5210 {handle_trans_request, _, ?VERSION, [AR]}) -> 5211 io:format("mtrtaarac_mgc_verify_notify_request:fun -> ok" 5212 "~n AR: ~p~n", [AR]), 5213 case AR of 5214 #'ActionRequest'{contextId = 1 = Cid, 5215 commandRequests = [CR]} -> 5216 #'CommandRequest'{command = Cmd} = CR, 5217 {notifyReq, NR} = Cmd, 5218 #'NotifyRequest'{terminationID = [Tid], 5219 observedEventsDescriptor = OED, 5220 errorDescriptor = asn1_NOVALUE} = NR, 5221 #'ObservedEventsDescriptor'{requestId = Rid, 5222 observedEventLst = [OE]} = OED, 5223 #'ObservedEvent'{eventName = "al/of"} = OE, 5224 HandleAck = {handle_sloppy_ack, {kalle, Rid}}, 5225 Reply = {HandleAck, 5226 [mtrtaarac_mgc_notify_reply_ar(Cid, Tid)]}, 5227 {ok, AR, Reply}; 5228 #'ActionRequest'{contextId = 2 = Cid, 5229 commandRequests = [CR]} -> 5230 #'CommandRequest'{command = Cmd} = CR, 5231 {notifyReq, NR} = Cmd, 5232 #'NotifyRequest'{terminationID = [Tid], 5233 observedEventsDescriptor = OED, 5234 errorDescriptor = asn1_NOVALUE} = NR, 5235 #'ObservedEventsDescriptor'{observedEventLst = [OE]} = OED, 5236 #'ObservedEvent'{eventName = "al/of"} = OE, 5237 Reply = {discard_ack, [mtrtaarac_mgc_notify_reply_ar(Cid, Tid)]}, 5238 {ok, AR, Reply}; 5239 _ -> 5240 ED = mtrtaarac_err_desc(AR), 5241 ErrReply = {discard_ack, ED}, 5242 {error, AR, ErrReply} 5243 end; 5244mtrtaarac_mgc_verify_notify_request(Else) -> 5245 io:format("mtrtaarac_mgc_verify_notify_request:fun -> unknown" 5246 "~n Else: ~p~n", [Else]), 5247 ED = mtrtaarac_err_desc(Else), 5248 ErrReply = {discard_ack, ED}, 5249 {error, Else, ErrReply}. 5250 5251mtrtaarac_mgc_verify_ack({handle_trans_ack, CH, ?VERSION, ok, 5252 {kalle, Rid}}) -> 5253 io:format("mtrtaarac_mgc_verify_ack -> ok" 5254 "~n CH: ~p" 5255 "~n Rid: ~p" 5256 "~n", [CH, Rid]), 5257 {ok, CH, ok}; 5258mtrtaarac_mgc_verify_ack(Else) -> 5259 io:format("mtrtaarac_mgc_verify_ack -> unknown" 5260 "~n Else: ~p~n", [Else]), 5261 {error, Else, ok}. 5262 5263mtrtaarac_mgc_verify_handle_disconnect({handle_disconnect, CH, ?VERSION, R}) -> 5264 io:format("mtrtaarac_mgc_verify_handle_disconnect -> ok" 5265 "~n CH: ~p" 5266 "~n R: ~p" 5267 "~n", [CH, R]), 5268 {ok, CH, ok}; 5269mtrtaarac_mgc_verify_handle_disconnect(Else) -> 5270 io:format("mtrtaarac_mgc_verify_handle_disconnect -> unknown" 5271 "~n Else: ~p~n", [Else]), 5272 {error, Else, ok}. 5273 5274 5275mtrtaarac_mgc_service_change_reply_ar(Mid, Cid) -> 5276 SCRP = cre_serviceChangeResParm(Mid), 5277 SCRes = cre_serviceChangeResult(SCRP), 5278 Root = #megaco_term_id{id = ["root"]}, 5279 SCR = cre_serviceChangeReply([Root], SCRes), 5280 CR = cre_cmdReply(SCR), 5281 cre_actionReply(Cid, [CR]). 5282 5283%% mtrtaarac_mgc_service_change_reply_msg(Mid, TransId, Cid) -> 5284%% AR = mtrtaarac_mgc_service_change_reply_ar(Mid, Cid), 5285%% TRes = cre_transResult([AR]), 5286%% TR = cre_transReply(TransId, TRes), 5287%% Trans = cre_transaction(TR), 5288%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 5289%% cre_megacoMessage(Mess). 5290 5291mtrtaarac_mgc_notify_reply_ar(Cid, TermId) -> 5292 NR = cre_notifyReply([TermId]), 5293 CR = cre_cmdReply(NR), 5294 cre_actionReply(Cid, [CR]). 5295 5296%% mtrtaarac_mgc_notify_reply(Mid, TransId, Cid, TermId) -> 5297%% AR = mtrtaarac_mgc_notify_reply_ar(Cid, TermId), 5298%% TRes = cre_transResult([AR]), 5299%% TR = cre_transReply(TransId, TRes), 5300%% Trans = cre_transaction(TR), 5301%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 5302%% cre_megacoMessage(Mess). 5303 5304 5305%% 5306%% MG generator stuff 5307%% 5308-ifdef(megaco_hipe_special). 5309-define(mtrtaarac_mg_verify_handle_connect_fun(), 5310 {?MODULE, mtrtaarac_mg_verify_handle_connect, []}). 5311-define(mtrtaarac_mg_verify_service_change_reply_fun(), 5312 {?MODULE, mtrtaarac_mg_verify_service_change_reply, []}). 5313-define(mtrtaarac_mg_verify_notify_reply_fun(), 5314 {?MODULE, mtrtaarac_mg_verify_notify_reply, []}). 5315-else. 5316-define(mtrtaarac_mg_verify_handle_connect_fun(), 5317 fun mtrtaarac_mg_verify_handle_connect/1). 5318-define(mtrtaarac_mg_verify_service_change_reply_fun(), 5319 fun mtrtaarac_mg_verify_service_change_reply/1). 5320-define(mtrtaarac_mg_verify_notify_reply_fun(), 5321 fun mtrtaarac_mg_verify_notify_reply/1). 5322-endif. 5323 5324mtrtaarac_mg_event_sequence(text, tcp) -> 5325 Mid = {deviceName,"mg"}, 5326 RI = [ 5327 {port, 2944}, 5328 {encoding_module, megaco_pretty_text_encoder}, 5329 {encoding_config, []}, 5330 {transport_module, megaco_tcp} 5331 ], 5332 ServiceChangeReq = [mtrtaarac_mg_service_change_request_ar(Mid, 1)], 5333 Tid = #megaco_term_id{id = ["00000000","00000000","01101101"]}, 5334 NR = fun(Cid, Rid) -> 5335 [mtrtaarac_mg_notify_request_ar(Rid, Tid, Cid)] 5336 end, 5337 ConnectVerify = ?mtrtaarac_mg_verify_handle_connect_fun(), 5338 ServiceChangeReplyVerify = ?mtrtaarac_mg_verify_service_change_reply_fun(), 5339 NotifyReplyVerify = ?mtrtaarac_mg_verify_notify_reply_fun(), 5340 EvSeq = [ 5341 {debug, true}, 5342 megaco_start, 5343 {megaco_start_user, Mid, RI, []}, 5344 start_transport, 5345 {megaco_trace, disable}, 5346 {megaco_system_info, users}, 5347 {megaco_system_info, connections}, 5348 connect, 5349 {megaco_callback, handle_connect, ConnectVerify}, 5350 megaco_connect, 5351 {megaco_cast, ServiceChangeReq, []}, 5352 {megaco_callback, handle_connect, ConnectVerify}, 5353 {megaco_callback, handle_trans_reply, ServiceChangeReplyVerify}, 5354 {sleep, 1000}, 5355 {megaco_system_info, users}, 5356 {megaco_system_info, connections}, 5357 {sleep, 1000}, 5358 {megaco_update_conn_info, auto_ack, true}, 5359 {megaco_update_conn_info, trans_ack_maxcount, 10}, 5360 {megaco_update_conn_info, trans_req_maxcount, 4}, 5361 {megaco_update_conn_info, trans_timer, 5000}, 5362 {megaco_update_conn_info, trans_ack, true}, 5363 {megaco_update_conn_info, trans_req, true}, 5364 {megaco_conn_info, all}, 5365 {megaco_cast, NR(1,1), []}, 5366 {megaco_cast, NR(1,2), []}, 5367 {megaco_cast, NR(1,3), []}, 5368 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 5369 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 5370 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 5371 {megaco_cast, NR(2,1), []}, 5372 {megaco_cast, NR(2,2), []}, 5373 {megaco_cast, NR(2,3), []}, 5374 {megaco_cast, NR(2,4), []}, 5375 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 5376 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 5377 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 5378 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 5379 {sleep, 3000}, 5380 megaco_stop_user, 5381 megaco_stop, 5382 {sleep, 1000} 5383 ], 5384 EvSeq. 5385 5386mtrtaarac_mg_verify_handle_connect({handle_connect, CH, ?VERSION}) -> 5387 io:format("mtrtaarac_mg_verify_handle_connect -> ok" 5388 "~n CH: ~p~n", [CH]), 5389 {ok, CH, ok}; 5390mtrtaarac_mg_verify_handle_connect(Else) -> 5391 io:format("mtrtaarac_mg_verify_handle_connect -> unknown" 5392 "~n Else: ~p~n", [Else]), 5393 {error, Else, ok}. 5394 5395mtrtaarac_mg_verify_service_change_reply({handle_trans_reply, _CH, ?VERSION, 5396 {ok, [AR]}, _}) -> 5397 case AR of 5398 #'ActionReply'{commandReply = [SCR]} -> 5399 case SCR of 5400 {serviceChangeReply, 5401 #'ServiceChangeReply'{terminationID = [Tid], 5402 serviceChangeResult = Res}} -> 5403 case Tid of 5404 #megaco_term_id{contains_wildcards = false, 5405 id = ["root"]} -> 5406 case Res of 5407 {serviceChangeResParms, 5408 #'ServiceChangeResParm'{ 5409 serviceChangeMgcId = _RemoteMid}} -> 5410 i("received expected handle_trans_reply " 5411 "(service change) with ok" 5412 "~n AR: ~p", [AR]), 5413 {ok, AR, ok}; 5414 {Tag, Val} -> 5415 e("received expected handle_trans_reply " 5416 "(service change) with error" 5417 "~n Tag: ~p" 5418 "~n Val: ~p", [Tag, Val]), 5419 Err = {invalid_service_change_result, 5420 Tag, Val}, 5421 {error, Err, ok} 5422 end; 5423 _ -> 5424 e("received expected handle_trans_reply " 5425 "(service change) with error" 5426 "~n Tid: ~p", [Tid]), 5427 Err = {invalid_termination_id, Tid}, 5428 {error, Err, ok} 5429 end; 5430 {Tag, Val} -> 5431 e("received expected handle_trans_reply " 5432 "(action reply) with error" 5433 "~n Tag: ~p" 5434 "~n Val: ~p", [Tag, Val]), 5435 Err = {invalid_command_reply, Tag, Val}, 5436 {error, Err, ok} 5437 end; 5438 _ -> 5439 e("received expected handle_trans_reply with error" 5440 "~n AR: ~p", [AR]), 5441 Err = {invalid_action_reply, AR}, 5442 {error, Err, ok} 5443 end; 5444mtrtaarac_mg_verify_service_change_reply(Else) -> 5445 e("mtrtaarac_mg_verify_service_change_reply -> invalid service change reply" 5446 "~n Expected: handle_trans_reply (service change) with ok" 5447 "~n Received; ~p", [Else]), 5448 {error, Else, ok}. 5449 5450mtrtaarac_mg_verify_notify_reply({handle_trans_reply, _CH, ?VERSION, 5451 {ok, [AR]}, _}) -> 5452 i("received expected handle_notify_reply with ok" 5453 "~n AR: ~p~n", [AR]), 5454 {ok, AR, ok}; 5455mtrtaarac_mg_verify_notify_reply(Else) -> 5456 e("MG Notify Reply verification failed: invalid notify reply" 5457 "~n Expected: handle_trans_reply with ok" 5458 "~n Received: ~p", [Else]), 5459 {error, Else, ok}. 5460 5461mtrtaarac_mg_service_change_request_ar(_Mid, Cid) -> 5462 Prof = cre_serviceChangeProf("resgw", 1), 5463 SCP = cre_serviceChangeParm(restart, ["901 mg col boot"], Prof), 5464 Root = #megaco_term_id{id = ["root"]}, 5465 SCR = cre_serviceChangeReq([Root], SCP), 5466 CMD = cre_command(SCR), 5467 CR = cre_cmdReq(CMD), 5468 cre_actionReq(Cid, [CR]). 5469 5470mtrtaarac_mg_notify_request_ar(Rid, Tid, Cid) -> 5471 TT = cre_timeNotation("19990729", "22000000"), 5472 Ev = cre_obsEvent("al/of", TT), 5473 EvsDesc = cre_obsEvsDesc(Rid, [Ev]), 5474 NR = cre_notifyReq([Tid], EvsDesc), 5475 CMD = cre_command(NR), 5476 CR = cre_cmdReq(CMD), 5477 cre_actionReq(Cid, [CR]). 5478 5479 5480%% 5481%% Common functions for the multi_trans_req_timeout test case 5482%% 5483 5484mtrtaarac_err_desc(T) -> 5485 EC = ?megaco_internal_gateway_error, 5486 ET = lists:flatten(io_lib:format("~w",[T])), 5487 #'ErrorDescriptor'{errorCode = EC, errorText = ET}. 5488 5489 5490%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 5491 5492multi_trans_req_and_ack_maxsize1(suite) -> 5493 []; 5494multi_trans_req_and_ack_maxsize1(doc) -> 5495 []; 5496multi_trans_req_and_ack_maxsize1(Config) when is_list(Config) -> 5497 Pre = fun() -> 5498 MgcNode = make_node_name(mgc), 5499 MgNode = make_node_name(mg), 5500 d("start nodes: " 5501 "~n MGC Node: ~p" 5502 "~n MG Node: ~p", 5503 [MgcNode, MgNode]), 5504 Nodes = [MgcNode, MgNode], 5505 ok = ?START_NODES(Nodes), 5506 Nodes 5507 end, 5508 Case = fun do_multi_trans_req_and_ack_maxsize1/1, 5509 Post = fun(Nodes) -> 5510 d("stop nodes"), 5511 ?STOP_NODES(lists:reverse(Nodes)) 5512 end, 5513 try_tc(multi_trans_req_and_ack_maxsize1, Pre, Case, Post). 5514 5515do_multi_trans_req_and_ack_maxsize1([MgcNode, MgNode]) -> 5516 5517 d("[MGC] start the simulator "), 5518 {ok, Mgc} = megaco_test_megaco_generator:start_link("MGC", MgcNode), 5519 5520 d("[MGC] create the event sequence"), 5521 MgcEvSeq = mtrtaams1_mgc_event_sequence(text, tcp), 5522 5523 i("wait some time before starting the MGC simulation"), 5524 sleep(1000), 5525 5526 d("[MGC] start the simulation"), 5527 {ok, MgcId} = megaco_test_megaco_generator:exec(Mgc, MgcEvSeq), 5528 5529 %% i("wait some time before starting the MG simulator"), 5530 %% sleep(1000), 5531 5532 i("await MGC ready announcement"), 5533 receive 5534 announce_mgc -> 5535 i("received MGC ready announcement"), 5536 ok 5537 end, 5538 5539 d("[MG] start the simulator (generator)"), 5540 {ok, Mg} = megaco_test_megaco_generator:start_link("MG", MgNode), 5541 5542 d("[MG] create the event sequence"), 5543 MgEvSeq = mtrtaams1_mg_event_sequence(text, tcp), 5544 5545 i("wait some time before starting the MG simulation"), 5546 sleep(1000), 5547 5548 d("[MG] start the simulation"), 5549 {ok, MgId} = megaco_test_megaco_generator:exec(Mg, MgEvSeq), 5550 5551 d("await the generator reply(s)"), 5552 await_completion([MgcId, MgId]), 5553 5554 %% Tell Mgc to stop 5555 i("[MGC] stop generator"), 5556 megaco_test_megaco_generator:stop(Mgc), 5557 5558 %% Tell Mg to stop 5559 i("[MG] stop generator"), 5560 megaco_test_megaco_generator:stop(Mg), 5561 5562 i("done", []), 5563 ok. 5564 5565 5566%% 5567%% MGC generator stuff 5568%% 5569-ifdef(megaco_hipe_special). 5570-define(mtrtaams1_mgc_verify_handle_connect_fun(), 5571 {?MODULE, mtrtaams1_mgc_verify_handle_connect, []}). 5572-define(mtrtaams1_mgc_verify_service_change_req_fun(Mid), 5573 {?MODULE, mtrtaams1_mgc_verify_service_change_req, [Mid]}). 5574-define(mtrtaams1_mgc_verify_notify_req_fun(), 5575 {?MODULE, mtrtaams1_mgc_verify_notify_request, []}). 5576-define(mtrtaams1_mgc_verify_ack_fun(), 5577 {?MODULE, mtrtaams1_mgc_verify_ack, []}). 5578-define(mtrtaams1_mgc_verify_handle_disconnect_fun(), 5579 {?MODULE, mtrtaams1_mgc_verify_handle_disconnect, []}). 5580-else. 5581-define(mtrtaams1_mgc_verify_handle_connect_fun(), 5582 fun mtrtaams1_mgc_verify_handle_connect/1). 5583-define(mtrtaams1_mgc_verify_service_change_req_fun(Mid), 5584 mtrtaams1_mgc_verify_service_change_req_fun(Mid)). 5585-define(mtrtaams1_mgc_verify_notify_req_fun(), 5586 mtrtaams1_mgc_verify_notify_request_fun()). 5587-define(mtrtaams1_mgc_verify_ack_fun(), 5588 fun mtrtaams1_mgc_verify_ack/1). 5589-define(mtrtaams1_mgc_verify_handle_disconnect_fun(), 5590 fun mtrtaams1_mgc_verify_handle_disconnect/1). 5591-endif. 5592 5593mtrtaams1_mgc_event_sequence(text, tcp) -> 5594 CTRL = self(), 5595 Mid = {deviceName,"ctrl"}, 5596 RI = [ 5597 {port, 2944}, 5598 {encoding_module, megaco_pretty_text_encoder}, 5599 {encoding_config, []}, 5600 {transport_module, megaco_tcp} 5601 ], 5602 ConnectVerify = ?mtrtaams1_mgc_verify_handle_connect_fun(), 5603 ServiceChangeReqVerify = ?mtrtaams1_mgc_verify_service_change_req_fun(Mid), 5604 NotifyReqVerify = ?mtrtaams1_mgc_verify_notify_req_fun(), 5605 AckVerify = ?mtrtaams1_mgc_verify_ack_fun(), 5606 DiscoVerify = ?mtrtaams1_mgc_verify_handle_disconnect_fun(), 5607 EvSeq = [ 5608 {debug, true}, 5609 {megaco_trace, disable}, 5610 megaco_start, 5611 {megaco_start_user, Mid, RI, []}, 5612 start_transport, 5613 listen, 5614 5615 %% ANNOUNCE READY 5616 {trigger, fun() -> CTRL ! announce_mgc end}, 5617 5618 {megaco_callback, handle_connect, ConnectVerify}, 5619 {megaco_callback, handle_trans_request, ServiceChangeReqVerify}, 5620 {megaco_callback, handle_trans_request, NotifyReqVerify}, 5621 {megaco_callback, handle_trans_request, NotifyReqVerify}, 5622 {megaco_callback, handle_trans_request, NotifyReqVerify}, 5623 {megaco_callback, handle_trans_ack, AckVerify}, 5624 {megaco_callback, handle_trans_ack, AckVerify}, 5625 {megaco_callback, handle_trans_ack, AckVerify}, 5626 {megaco_callback, handle_trans_request, NotifyReqVerify}, 5627 {megaco_callback, handle_trans_request, NotifyReqVerify}, 5628 {megaco_callback, handle_trans_request, NotifyReqVerify}, 5629 {megaco_callback, handle_trans_request, NotifyReqVerify}, 5630 {megaco_callback, handle_disconnect, DiscoVerify}, 5631 {sleep, 1000}, 5632 megaco_stop_user, 5633 megaco_stop 5634 ], 5635 EvSeq. 5636 5637 5638mtrtaams1_mgc_verify_handle_connect({handle_connect, CH, ?VERSION}) -> 5639 io:format("mtrtaams1_mgc_verify_handle_connect -> ok" 5640 "~n CH: ~p~n", [CH]), 5641 {ok, CH, ok}; 5642mtrtaams1_mgc_verify_handle_connect(Else) -> 5643 io:format("mtrtaams1_mgc_verify_handle_connect -> unknown" 5644 "~n Else: ~p~n", [Else]), 5645 {error, Else, ok}. 5646 5647mtrtaams1_mgc_verify_service_change_req_fun(Mid) -> 5648 fun(Ev) -> 5649 mtrtaams1_mgc_verify_service_change_req(Ev, Mid) 5650 end. 5651 5652mtrtaams1_mgc_verify_service_change_req( 5653 {handle_trans_request, _, ?VERSION, [AR]}, Mid) -> 5654 io:format("mtrtaams1_mgc_verify_service_change_req -> ok" 5655 "~n AR: ~p~n", [AR]), 5656 case AR of 5657 #'ActionRequest'{commandRequests = [CR]} -> 5658 case CR of 5659 #'CommandRequest'{command = Cmd} -> 5660 case Cmd of 5661 {serviceChangeReq, 5662 #'ServiceChangeRequest'{terminationID = [Tid], 5663 serviceChangeParms = Parms}} -> 5664 case Tid of 5665 #megaco_term_id{contains_wildcards = false, 5666 id = ["root"]} -> 5667 case Parms of 5668 #'ServiceChangeParm'{ 5669 serviceChangeMethod = restart, 5670 serviceChangeReason = [[$9,$0,$1|_]]} -> 5671 Reply = 5672 {discard_ack, 5673 [mtrtaams1_mgc_service_change_reply_ar(Mid, 1)]}, 5674 {ok, AR, Reply}; 5675 _ -> 5676 Err = {invalid_SCP, Parms}, 5677 ED = mtrtaams1_err_desc(Parms), 5678 ErrReply = {discard_ack, 5679 ED}, 5680 {error, Err, ErrReply} 5681 end; 5682 _ -> 5683 Err = {invalid_termination_id, Tid}, 5684 ED = mtrtaams1_err_desc(Tid), 5685 ErrReply = {discard_ack, ED}, 5686 {error, Err, ErrReply} 5687 end; 5688 _ -> 5689 Err = {invalid_command, Cmd}, 5690 ED = mtrtaams1_err_desc(Cmd), 5691 ErrReply = {discard_ack, ED}, 5692 {error, Err, ErrReply} 5693 end; 5694 _ -> 5695 Err = {invalid_command_request, CR}, 5696 ED = mtrtaams1_err_desc(CR), 5697 ErrReply = {discard_ack, ED}, 5698 {error, Err, ErrReply} 5699 end; 5700 _ -> 5701 Err = {invalid_action_request, AR}, 5702 ED = mtrtaams1_err_desc(AR), 5703 ErrReply = {discard_ack, ED}, 5704 {error, Err, ErrReply} 5705 end; 5706mtrtaams1_mgc_verify_service_change_req(Else, _Mid) -> 5707 io:format("mtrtaams1_mgc_verify_service_change_req -> unknown" 5708 "~n Else: ~p~n", [Else]), 5709 ED = mtrtaams1_err_desc(Else), 5710 ErrReply = {discard_ack, ED}, 5711 {error, Else, ErrReply}. 5712 5713mtrtaams1_mgc_verify_notify_request_fun() -> 5714 fun(Ev) -> 5715 mtrtaams1_mgc_verify_notify_request(Ev) 5716 end. 5717 5718mtrtaams1_mgc_verify_notify_request( 5719 {handle_trans_request, _, ?VERSION, [AR]}) -> 5720 io:format("mtrtaams1_mgc_verify_notify_request -> ok" 5721 "~n AR: ~p~n", [AR]), 5722 case AR of 5723 #'ActionRequest'{contextId = 1 = Cid, 5724 commandRequests = [CR]} -> 5725 #'CommandRequest'{command = Cmd} = CR, 5726 {notifyReq, NR} = Cmd, 5727 #'NotifyRequest'{terminationID = [Tid], 5728 observedEventsDescriptor = OED, 5729 errorDescriptor = asn1_NOVALUE} = NR, 5730 #'ObservedEventsDescriptor'{requestId = Rid, 5731 observedEventLst = [OE]} = OED, 5732 #'ObservedEvent'{eventName = "al/of"} = OE, 5733 HandleAck = {handle_sloppy_ack, {kalle, Rid}}, 5734 Reply = {HandleAck, 5735 [mtrtaams1_mgc_notify_reply_ar(Cid, Tid)]}, 5736 {ok, AR, Reply}; 5737 #'ActionRequest'{contextId = 2 = Cid, 5738 commandRequests = [CR]} -> 5739 #'CommandRequest'{command = Cmd} = CR, 5740 {notifyReq, NR} = Cmd, 5741 #'NotifyRequest'{terminationID = [Tid], 5742 observedEventsDescriptor = OED, 5743 errorDescriptor = asn1_NOVALUE} = NR, 5744 #'ObservedEventsDescriptor'{observedEventLst = [OE]} = OED, 5745 #'ObservedEvent'{eventName = "al/of"} = OE, 5746 Reply = {discard_ack, [mtrtaams1_mgc_notify_reply_ar(Cid, Tid)]}, 5747 {ok, AR, Reply}; 5748 _ -> 5749 ED = mtrtaams1_err_desc(AR), 5750 ErrReply = {discard_ack, ED}, 5751 {error, AR, ErrReply} 5752 end; 5753mtrtaams1_mgc_verify_notify_request(Else) -> 5754 io:format("mtrtaams1_mgc_verify_notify_request -> unknown" 5755 "~n Else: ~p~n", [Else]), 5756 ED = mtrtaams1_err_desc(Else), 5757 ErrReply = {discard_ack, ED}, 5758 {error, Else, ErrReply}. 5759 5760mtrtaams1_mgc_verify_ack({handle_trans_ack, CH, ?VERSION, ok, 5761 {kalle, Rid}}) -> 5762 io:format("mtrtaams1_mgc_verify_ack -> ok" 5763 "~n CH: ~p" 5764 "~n Rid: ~p" 5765 "~n", [CH, Rid]), 5766 {ok, CH, ok}; 5767mtrtaams1_mgc_verify_ack(Else) -> 5768 io:format("mtrtaams1_mgc_verify_ack -> unknown" 5769 "~n Else: ~p~n", [Else]), 5770 {error, Else, ok}. 5771 5772mtrtaams1_mgc_verify_handle_disconnect({handle_disconnect, CH, ?VERSION, R}) -> 5773 io:format("mtrtaams1_mgc_verify_handle_disconnect -> ok" 5774 "~n CH: ~p" 5775 "~n R: ~p" 5776 "~n", [CH, R]), 5777 {ok, CH, ok}; 5778mtrtaams1_mgc_verify_handle_disconnect(Else) -> 5779 io:format("mtrtaams1_mgc_verify_handle_disconnect -> unknown" 5780 "~n Else: ~p~n", [Else]), 5781 {error, Else, ok}. 5782 5783 5784mtrtaams1_mgc_service_change_reply_ar(Mid, Cid) -> 5785 SCRP = cre_serviceChangeResParm(Mid), 5786 SCRes = cre_serviceChangeResult(SCRP), 5787 Root = #megaco_term_id{id = ["root"]}, 5788 SCR = cre_serviceChangeReply([Root], SCRes), 5789 CR = cre_cmdReply(SCR), 5790 cre_actionReply(Cid, [CR]). 5791 5792%% mtrtaams1_mgc_service_change_reply_msg(Mid, TransId, Cid) -> 5793%% AR = mtrtaams1_mgc_service_change_reply_ar(Mid, Cid), 5794%% TRes = cre_transResult([AR]), 5795%% TR = cre_transReply(TransId, TRes), 5796%% Trans = cre_transaction(TR), 5797%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 5798%% cre_megacoMessage(Mess). 5799 5800mtrtaams1_mgc_notify_reply_ar(Cid, TermId) -> 5801 NR = cre_notifyReply([TermId]), 5802 CR = cre_cmdReply(NR), 5803 cre_actionReply(Cid, [CR]). 5804 5805%% mtrtaams1_mgc_notify_reply(Mid, TransId, Cid, TermId) -> 5806%% AR = mtrtaams1_mgc_notify_reply_ar(Cid, TermId), 5807%% TRes = cre_transResult([AR]), 5808%% TR = cre_transReply(TransId, TRes), 5809%% Trans = cre_transaction(TR), 5810%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 5811%% cre_megacoMessage(Mess). 5812 5813 5814%% 5815%% MG generator stuff 5816%% 5817-ifdef(megaco_hipe_special). 5818-define(mtrtaams1_mg_verify_handle_connect_fun(), 5819 {?MODULE, mtrtaams1_mg_verify_handle_connect, []}). 5820-define(mtrtaams1_mg_verify_service_change_reply_fun(), 5821 {?MODULE, mtrtaams1_mg_verify_service_change_reply, []}). 5822-define(mtrtaams1_mg_verify_notify_reply_fun(), 5823 {?MODULE, mtrtaams1_mg_verify_notify_reply, []}). 5824-else. 5825-define(mtrtaams1_mg_verify_handle_connect_fun(), 5826 fun mtrtaams1_mg_verify_handle_connect/1). 5827-define(mtrtaams1_mg_verify_service_change_reply_fun(), 5828 fun mtrtaams1_mg_verify_service_change_reply/1). 5829-define(mtrtaams1_mg_verify_notify_reply_fun(), 5830 fun mtrtaams1_mg_verify_notify_reply/1). 5831-endif. 5832 5833mtrtaams1_mg_event_sequence(text, tcp) -> 5834 Mid = {deviceName,"mg"}, 5835 RI = [ 5836 {port, 2944}, 5837 {encoding_module, megaco_pretty_text_encoder}, 5838 {encoding_config, []}, 5839 {transport_module, megaco_tcp} 5840 ], 5841 ServiceChangeReq = [mtrtaams1_mg_service_change_request_ar(Mid, 1)], 5842 Tid = #megaco_term_id{id = ["00000000","00000000","01101101"]}, 5843 NR = fun(Cid, Rid) -> 5844 [mtrtaams1_mg_notify_request_ar(Rid, Tid, Cid)] 5845 end, 5846 ConnectVerify = ?mtrtaams1_mg_verify_handle_connect_fun(), 5847 ServiceChangeReplyVerify = ?mtrtaams1_mg_verify_service_change_reply_fun(), 5848 NotifyReplyVerify = ?mtrtaams1_mg_verify_notify_reply_fun(), 5849 EvSeq = [ 5850 {debug, true}, 5851 megaco_start, 5852 {megaco_start_user, Mid, RI, []}, 5853 start_transport, 5854 {megaco_trace, disable}, 5855 {megaco_system_info, users}, 5856 {megaco_system_info, connections}, 5857 connect, 5858 {megaco_callback, handle_connect, ConnectVerify}, 5859 megaco_connect, 5860 {megaco_cast, ServiceChangeReq, []}, 5861 {megaco_callback, handle_connect, ConnectVerify}, 5862 {megaco_callback, handle_trans_reply, ServiceChangeReplyVerify}, 5863 {sleep, 1000}, 5864 {megaco_system_info, users}, 5865 {megaco_system_info, connections}, 5866 {sleep, 1000}, 5867 {megaco_update_conn_info, auto_ack, true}, 5868 {megaco_update_conn_info, trans_ack_maxcount, 10}, 5869 {megaco_update_conn_info, trans_req_maxcount, 10}, 5870 {megaco_update_conn_info, trans_req_maxsize, 650}, 5871 {megaco_update_conn_info, trans_timer, 5000}, 5872 {megaco_update_conn_info, trans_ack, true}, 5873 {megaco_update_conn_info, trans_req, true}, 5874 {megaco_conn_info, all}, 5875 {megaco_cast, [NR(1,2), NR(1,3), NR(1,4)], []}, 5876 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 5877 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 5878 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 5879 {megaco_cast, NR(2,1), []}, 5880 {megaco_cast, NR(2,2), []}, 5881 {megaco_cast, NR(2,3), []}, 5882 {megaco_cast, NR(2,4), []}, 5883 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 5884 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 5885 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 5886 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 5887 {sleep, 3000}, 5888 megaco_stop_user, 5889 megaco_stop, 5890 {sleep, 1000} 5891 ], 5892 EvSeq. 5893 5894mtrtaams1_mg_verify_handle_connect({handle_connect, CH, ?VERSION}) -> 5895 io:format("mtrtaams1_mg_verify_handle_connect -> ok" 5896 "~n CH: ~p~n", [CH]), 5897 {ok, CH, ok}; 5898mtrtaams1_mg_verify_handle_connect(Else) -> 5899 io:format("mtrtaams1_mg_verify_handle_connect -> unknown" 5900 "~n Else: ~p~n", [Else]), 5901 {error, Else, ok}. 5902 5903mtrtaams1_mg_verify_service_change_reply({handle_trans_reply, _CH, ?VERSION, 5904 {ok, [AR]}, _}) -> 5905 io:format("mtrtaams1_mg_verify_service_change_reply -> ok" 5906 "~n AR: ~p~n", [AR]), 5907 case AR of 5908 #'ActionReply'{commandReply = [SCR]} -> 5909 case SCR of 5910 {serviceChangeReply, 5911 #'ServiceChangeReply'{terminationID = [Tid], 5912 serviceChangeResult = Res}} -> 5913 case Tid of 5914 #megaco_term_id{contains_wildcards = false, 5915 id = ["root"]} -> 5916 case Res of 5917 {serviceChangeResParms, 5918 #'ServiceChangeResParm'{ 5919 serviceChangeMgcId = _RemoteMid}} -> 5920 {ok, AR, ok}; 5921 {Tag, Val} -> 5922 Err = {invalid_service_change_result, 5923 Tag, Val}, 5924 {error, Err, ok} 5925 end; 5926 _ -> 5927 Err = {invalid_termination_id, Tid}, 5928 {error, Err, ok} 5929 end; 5930 {Tag, Val} -> 5931 Err = {invalid_command_reply, Tag, Val}, 5932 {error, Err, ok} 5933 end; 5934 _ -> 5935 Err = {invalid_action_reply, AR}, 5936 {error, Err, ok} 5937 end; 5938mtrtaams1_mg_verify_service_change_reply(Else) -> 5939 io:format("mtrtaams1_mg_verify_service_change_reply -> unknown" 5940 "~n Else: ~p~n", [Else]), 5941 {error, Else, ok}. 5942 5943mtrtaams1_mg_verify_notify_reply({handle_trans_reply, _CH, ?VERSION, 5944 {ok, [AR]}, _}) -> 5945 io:format("mtrtaams1_mg_verify_notify_reply -> ok" 5946 "~n AR: ~p~n", [AR]), 5947 {ok, AR, ok}; 5948mtrtaams1_mg_verify_notify_reply(Else) -> 5949 io:format("mtrtaams1_mg_verify_notify_reply -> unknown" 5950 "~n Else: ~p~n", [Else]), 5951 {error, Else, ok}. 5952 5953mtrtaams1_mg_service_change_request_ar(_Mid, Cid) -> 5954 Prof = cre_serviceChangeProf("resgw", 1), 5955 SCP = cre_serviceChangeParm(restart, ["901 mg col boot"], Prof), 5956 Root = #megaco_term_id{id = ["root"]}, 5957 SCR = cre_serviceChangeReq([Root], SCP), 5958 CMD = cre_command(SCR), 5959 CR = cre_cmdReq(CMD), 5960 cre_actionReq(Cid, [CR]). 5961 5962%% mtrtaams1_mg_service_change_request_msg(Mid, TransId, Cid) -> 5963%% AR = mtrtaams1_mg_service_change_request_ar(Mid, Cid), 5964%% TR = cre_transReq(TransId, [AR]), 5965%% Trans = cre_transaction(TR), 5966%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 5967%% cre_megacoMessage(Mess). 5968 5969mtrtaams1_mg_notify_request_ar(Rid, Tid, Cid) -> 5970 TT = cre_timeNotation("19990729", "22000000"), 5971 Ev = cre_obsEvent("al/of", TT), 5972 EvsDesc = cre_obsEvsDesc(Rid, [Ev]), 5973 NR = cre_notifyReq([Tid], EvsDesc), 5974 CMD = cre_command(NR), 5975 CR = cre_cmdReq(CMD), 5976 cre_actionReq(Cid, [CR]). 5977 5978%% mtrtaams1_notify_request_msg(Mid, TransId, Rid, TermId, Cid) -> 5979%% AR = mtrtaams1_mg_notify_request_ar(Rid, TermId, Cid), 5980%% TR = cre_transReq(TransId, [AR]), 5981%% Trans = cre_transaction(TR), 5982%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 5983%% cre_megacoMessage(Mess). 5984 5985 5986%% 5987%% Common functions for the multi_trans_req_timeout test case 5988%% 5989 5990mtrtaams1_err_desc(T) -> 5991 cre_ErrDesc(T). 5992 5993 5994%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 5995 5996multi_trans_req_and_ack_maxsize2(suite) -> 5997 []; 5998multi_trans_req_and_ack_maxsize2(doc) -> 5999 []; 6000multi_trans_req_and_ack_maxsize2(Config) when is_list(Config) -> 6001 Pre = fun() -> 6002 MgcNode = make_node_name(mgc), 6003 MgNode = make_node_name(mg), 6004 d("start nodes: " 6005 "~n MGC Node: ~p" 6006 "~n MG Node: ~p", 6007 [MgcNode, MgNode]), 6008 Nodes = [MgcNode, MgNode], 6009 ok = ?START_NODES(Nodes), 6010 Nodes 6011 end, 6012 Case = fun do_multi_trans_req_and_ack_maxsize2/1, 6013 Post = fun(Nodes) -> 6014 d("stop nodes"), 6015 ?STOP_NODES(lists:reverse(Nodes)) 6016 end, 6017 try_tc(multi_trans_req_and_ack_maxsize2, Pre, Case, Post). 6018 6019do_multi_trans_req_and_ack_maxsize2([MgcNode, MgNode]) -> 6020 6021 d("[MGC] start the simulator "), 6022 {ok, Mgc} = megaco_test_megaco_generator:start_link("MGC", MgcNode), 6023 6024 d("[MGC] create the event sequence"), 6025 MgcEvSeq = mtrtaams2_mgc_event_sequence(text, tcp), 6026 6027 i("wait some time before starting the MGC simulation"), 6028 sleep(1000), 6029 6030 d("[MGC] start the simulation"), 6031 {ok, MgcId} = megaco_test_megaco_generator:exec(Mgc, MgcEvSeq), 6032 6033 %% i("wait some time before starting the MG simulator"), 6034 %% sleep(1000), 6035 6036 i("await MGC ready announcement"), 6037 receive 6038 announce_mgc -> 6039 i("received MGC ready announcement"), 6040 ok 6041 end, 6042 6043 d("[MG] start the simulator (generator)"), 6044 {ok, Mg} = megaco_test_megaco_generator:start_link("MG", MgNode), 6045 6046 d("[MG] create the event sequence"), 6047 MgEvSeq = mtrtaams2_mg_event_sequence(text, tcp), 6048 6049 i("wait some time before starting the MG simulation"), 6050 sleep(1000), 6051 6052 d("[MG] start the simulation"), 6053 {ok, MgId} = megaco_test_megaco_generator:exec(Mg, MgEvSeq), 6054 6055 d("await the generator reply(s)"), 6056 await_completion([MgcId, MgId]), 6057 6058 %% Tell Mgc to stop 6059 i("[MGC] stop generator"), 6060 megaco_test_megaco_generator:stop(Mgc), 6061 6062 %% Tell Mg to stop 6063 i("[MG] stop generator"), 6064 megaco_test_megaco_generator:stop(Mg), 6065 6066 i("done", []), 6067 ok. 6068 6069 6070%% 6071%% MGC generator stuff 6072%% 6073-ifdef(megaco_hipe_special). 6074-define(mtrtaams2_mgc_verify_handle_connect_fun(), 6075 {?MODULE, mtrtaams2_mgc_verify_handle_connect, []}). 6076-define(mtrtaams2_mgc_verify_service_change_req_fun(Mid), 6077 {?MODULE, mtrtaams2_mgc_verify_service_change_req, [Mid]}). 6078-define(mtrtaams2_mgc_verify_notify_req_fun(), 6079 {?MODULE, mtrtaams2_mgc_verify_notify_request, []}). 6080-define(mtrtaams2_mgc_verify_ack_fun(), 6081 {?MODULE, mtrtaams2_mgc_verify_ack, []}). 6082-define(mtrtaams2_mgc_verify_handle_disconnect_fun(), 6083 {?MODULE, mtrtaams2_mgc_verify_handle_disconnect, []}). 6084-else. 6085-define(mtrtaams2_mgc_verify_handle_connect_fun(), 6086 fun mtrtaams2_mgc_verify_handle_connect/1). 6087-define(mtrtaams2_mgc_verify_service_change_req_fun(Mid), 6088 mtrtaams2_mgc_verify_service_change_req_fun(Mid)). 6089-define(mtrtaams2_mgc_verify_notify_req_fun(), 6090 mtrtaams2_mgc_verify_notify_request_fun()). 6091-define(mtrtaams2_mgc_verify_ack_fun(), 6092 fun mtrtaams2_mgc_verify_ack/1). 6093-define(mtrtaams2_mgc_verify_handle_disconnect_fun(), 6094 fun mtrtaams2_mgc_verify_handle_disconnect/1). 6095-endif. 6096 6097mtrtaams2_mgc_event_sequence(text, tcp) -> 6098 CTRL = self(), 6099 Mid = {deviceName,"ctrl"}, 6100 RI = [ 6101 {port, 2944}, 6102 {encoding_module, megaco_pretty_text_encoder}, 6103 {encoding_config, []}, 6104 {transport_module, megaco_tcp} 6105 ], 6106 ConnectVerify = ?mtrtaams2_mgc_verify_handle_connect_fun(), 6107 ServiceChangeReqVerify = ?mtrtaams2_mgc_verify_service_change_req_fun(Mid), 6108 NotifyReqVerify = ?mtrtaams2_mgc_verify_notify_req_fun(), 6109 AckVerify = ?mtrtaams2_mgc_verify_ack_fun(), 6110 DiscoVerify = ?mtrtaams2_mgc_verify_handle_disconnect_fun(), 6111 EvSeq = [ 6112 {debug, true}, 6113 {megaco_trace, disable}, 6114 megaco_start, 6115 {megaco_start_user, Mid, RI, []}, 6116 start_transport, 6117 {listen, [{serialize, true}]}, 6118 6119 %% ANNOUNCE READY 6120 {trigger, fun() -> CTRL ! announce_mgc end}, 6121 6122 {megaco_callback, handle_connect, ConnectVerify}, 6123 {megaco_callback, handle_trans_request, ServiceChangeReqVerify}, 6124 {megaco_callback, handle_trans_request, NotifyReqVerify}, 6125 {megaco_callback, handle_trans_request, NotifyReqVerify}, 6126 {megaco_callback, handle_trans_request, NotifyReqVerify}, 6127 {megaco_callback, handle_trans_ack, AckVerify}, 6128 {megaco_callback, handle_trans_ack, AckVerify}, 6129 {megaco_callback, handle_trans_ack, AckVerify}, 6130 {megaco_callback, handle_trans_request, NotifyReqVerify}, 6131 {megaco_callback, handle_trans_request, NotifyReqVerify}, 6132 {megaco_callback, handle_trans_request, NotifyReqVerify}, 6133 {megaco_callback, handle_trans_request, NotifyReqVerify}, 6134 {megaco_callback, handle_disconnect, DiscoVerify}, 6135 {sleep, 1000}, 6136 megaco_stop_user, 6137 megaco_stop 6138 ], 6139 EvSeq. 6140 6141 6142mtrtaams2_mgc_verify_handle_connect({handle_connect, CH, ?VERSION}) -> 6143 p("mtrtaams2_mgc_verify_handle_connect -> ok" 6144 "~n CH: ~p", [CH]), 6145 {ok, CH, ok}; 6146mtrtaams2_mgc_verify_handle_connect(Else) -> 6147 p("mtrtaams2_mgc_verify_handle_connect -> unknown" 6148 "~n Else: ~p", [Else]), 6149 {error, Else, ok}. 6150 6151mtrtaams2_mgc_verify_service_change_req_fun(Mid) -> 6152 fun(Ev) -> 6153 mtrtaams2_mgc_verify_service_change_req(Ev, Mid) 6154 end. 6155 6156mtrtaams2_mgc_verify_service_change_req( 6157 {handle_trans_request, _, ?VERSION, [AR]}, Mid) -> 6158 p("mtrtaams2_mgc_verify_service_change_req -> ok" 6159 "~n AR: ~p", [AR]), 6160 case AR of 6161 #'ActionRequest'{commandRequests = [CR]} -> 6162 case CR of 6163 #'CommandRequest'{command = Cmd} -> 6164 case Cmd of 6165 {serviceChangeReq, 6166 #'ServiceChangeRequest'{terminationID = [Tid], 6167 serviceChangeParms = Parms}} -> 6168 case Tid of 6169 #megaco_term_id{contains_wildcards = false, 6170 id = ["root"]} -> 6171 case Parms of 6172 #'ServiceChangeParm'{ 6173 serviceChangeMethod = restart, 6174 serviceChangeReason = [[$9,$0,$1|_]]} -> 6175 Reply = 6176 {discard_ack, 6177 [mtrtaams2_mgc_service_change_reply_ar(Mid, 1)]}, 6178 {ok, AR, Reply}; 6179 _ -> 6180 Err = {invalid_SCP, Parms}, 6181 ED = mtrtaams2_err_desc(Parms), 6182 ErrReply = {discard_ack, 6183 ED}, 6184 {error, Err, ErrReply} 6185 end; 6186 _ -> 6187 Err = {invalid_termination_id, Tid}, 6188 ED = mtrtaams2_err_desc(Tid), 6189 ErrReply = {discard_ack, ED}, 6190 {error, Err, ErrReply} 6191 end; 6192 _ -> 6193 Err = {invalid_command, Cmd}, 6194 ED = mtrtaams2_err_desc(Cmd), 6195 ErrReply = {discard_ack, ED}, 6196 {error, Err, ErrReply} 6197 end; 6198 _ -> 6199 Err = {invalid_command_request, CR}, 6200 ED = mtrtaams2_err_desc(CR), 6201 ErrReply = {discard_ack, ED}, 6202 {error, Err, ErrReply} 6203 end; 6204 _ -> 6205 Err = {invalid_action_request, AR}, 6206 ED = mtrtaams2_err_desc(AR), 6207 ErrReply = {discard_ack, ED}, 6208 {error, Err, ErrReply} 6209 end; 6210mtrtaams2_mgc_verify_service_change_req(Else, _Min) -> 6211 p("mtrtaams2_mgc_verify_service_change_req -> unknown" 6212 "~n Else: ~p", [Else]), 6213 ED = mtrtaams2_err_desc(Else), 6214 ErrReply = {discard_ack, ED}, 6215 {error, Else, ErrReply}. 6216 6217mtrtaams2_mgc_verify_notify_request_fun() -> 6218 fun(Ev) -> 6219 mtrtaams2_mgc_verify_notify_request(Ev) 6220 end. 6221 6222mtrtaams2_mgc_verify_notify_request( 6223 {handle_trans_request, _, ?VERSION, [AR]}) -> 6224 p("mtrtaams2_mgc_verify_notify_request:fun -> ok" 6225 "~n AR: ~p", [AR]), 6226 case AR of 6227 #'ActionRequest'{contextId = 1 = Cid, 6228 commandRequests = [CR]} -> 6229 p("mtrtaams2_mgc_verify_notify_request:fun -> " 6230 "single command", []), 6231 #'CommandRequest'{command = Cmd} = CR, 6232 {notifyReq, NR} = Cmd, 6233 #'NotifyRequest'{terminationID = [Tid], 6234 observedEventsDescriptor = OED, 6235 errorDescriptor = asn1_NOVALUE} = NR, 6236 #'ObservedEventsDescriptor'{requestId = Rid, 6237 observedEventLst = [OE]} = OED, 6238 #'ObservedEvent'{eventName = "al/of"} = OE, 6239 HandleAck = {handle_sloppy_ack, {kalle, Rid}}, 6240 Reply = {HandleAck, 6241 [mtrtaams2_mgc_notify_reply_ar1(Cid, Tid)]}, 6242 {ok, AR, Reply}; 6243 #'ActionRequest'{contextId = 2 = Cid, 6244 commandRequests = CRs} -> 6245 p("mtrtaams2_mgc_verify_notify_request:fun -> " 6246 "multi command (~w)", [length(CRs)]), 6247 Tids = [Tid || 6248 #'CommandRequest'{command = 6249 {notifyReq, 6250 #'NotifyRequest'{ 6251 terminationID = [Tid]}}} 6252 <- CRs], 6253 Reply = 6254 {discard_ack, 6255 [mtrtaams2_mgc_notify_reply_ar2(Cid, Tids)]}, 6256 {ok, AR, Reply}; 6257 _ -> 6258 ED = mtrtaams2_err_desc(AR), 6259 ErrReply = {discard_ack, ED}, 6260 {error, AR, ErrReply} 6261 end; 6262mtrtaams2_mgc_verify_notify_request(Else) -> 6263 p("mtrtaams2_mgc_verify_notify_request:fun -> unknown" 6264 "~n Else: ~p", [Else]), 6265 ED = mtrtaams2_err_desc(Else), 6266 ErrReply = {discard_ack, ED}, 6267 {error, Else, ErrReply}. 6268 6269mtrtaams2_mgc_verify_ack({handle_trans_ack, CH, ?VERSION, ok, 6270 {kalle, Rid}}) -> 6271 p("mtrtaams2_mgc_verify_ack -> ok" 6272 "~n CH: ~p" 6273 "~n Rid: ~p", [CH, Rid]), 6274 {ok, CH, ok}; 6275mtrtaams2_mgc_verify_ack(Else) -> 6276 p("mtrtaams2_mgc_verify_ack -> Else: " 6277 "~n~p", [Else]), 6278 {error, Else, ok}. 6279 6280mtrtaams2_mgc_verify_handle_disconnect({handle_disconnect, CH, ?VERSION, R}) -> 6281 p("mtrtaams2_mgc_verify_handle_disconnect -> ok" 6282 "~n CH: ~p" 6283 "~n R: ~p", [CH, R]), 6284 {ok, CH, ok}; 6285mtrtaams2_mgc_verify_handle_disconnect(Else) -> 6286 p("mtrtaams2_mgc_verify_handle_disconnect -> unknown" 6287 "~n Else: ~p", [Else]), 6288 {error, Else, ok}. 6289 6290 6291mtrtaams2_mgc_service_change_reply_ar(Mid, Cid) -> 6292 SCRP = cre_serviceChangeResParm(Mid), 6293 SCRes = cre_serviceChangeResult(SCRP), 6294 Root = #megaco_term_id{id = ["root"]}, 6295 SCR = cre_serviceChangeReply([Root], SCRes), 6296 CR = cre_cmdReply(SCR), 6297 cre_actionReply(Cid, [CR]). 6298 6299%% mtrtaams2_mgc_service_change_reply_msg(Mid, TransId, Cid) -> 6300%% AR = mtrtaams2_mgc_service_change_reply_ar(Mid, Cid), 6301%% TRes = cre_transResult([AR]), 6302%% TR = cre_transReply(TransId, TRes), 6303%% Trans = cre_transaction(TR), 6304%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 6305%% cre_megacoMessage(Mess). 6306 6307mtrtaams2_mgc_notify_reply_ar1(Cid, TermId) -> 6308 NR = cre_notifyReply([TermId]), 6309 CR = cre_cmdReply(NR), 6310 cre_actionReply(Cid, [CR]). 6311 6312mtrtaams2_mgc_notify_reply_ar2(Cid, Tids) -> 6313 CRs = [cre_cmdReply(cre_notifyReply([Tid])) || Tid <- Tids], 6314 cre_actionReply(Cid, CRs). 6315 6316%% mtrtaams2_mgc_notify_reply(Mid, TransId, Cid, TermId) -> 6317%% AR = mtrtaams2_mgc_notify_reply_ar1(Cid, TermId), 6318%% TRes = cre_transResult([AR]), 6319%% TR = cre_transReply(TransId, TRes), 6320%% Trans = cre_transaction(TR), 6321%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 6322%% cre_megacoMessage(Mess). 6323 6324 6325%% 6326%% MG generator stuff 6327%% 6328-ifdef(megaco_hipe_special). 6329-define(mtrtaams2_mg_verify_handle_connect_fun(), 6330 {?MODULE, mtrtaams2_mg_verify_handle_connect, []}). 6331-define(mtrtaams2_mg_verify_service_change_reply_fun(), 6332 {?MODULE, mtrtaams2_mg_verify_service_change_reply, []}). 6333-define(mtrtaams2_mg_verify_notify_reply_fun(), 6334 {?MODULE, mtrtaams2_mg_verify_notify_reply, []}). 6335-else. 6336-define(mtrtaams2_mg_verify_handle_connect_fun(), 6337 fun mtrtaams2_mg_verify_handle_connect/1). 6338-define(mtrtaams2_mg_verify_service_change_reply_fun(), 6339 fun mtrtaams2_mg_verify_service_change_reply/1). 6340-define(mtrtaams2_mg_verify_notify_reply_fun(), 6341 fun mtrtaams2_mg_verify_notify_reply/1). 6342-endif. 6343 6344mtrtaams2_mg_event_sequence(text, tcp) -> 6345 Mid = {deviceName,"mg"}, 6346 RI = [ 6347 {port, 2944}, 6348 {encoding_module, megaco_pretty_text_encoder}, 6349 {encoding_config, []}, 6350 {transport_module, megaco_tcp} 6351 ], 6352 ServiceChangeReq = [mtrtaams2_mg_service_change_request_ar(Mid, 1)], 6353 Tid = #megaco_term_id{id = ["00000000","00000000","01101101"]}, 6354 NR1 = fun(Cid, Rid) -> 6355 [mtrtaams2_mg_notify_request_ar1(10 + Rid, Tid, Cid)] 6356 end, 6357 NR2 = fun(Cid, Rid) -> 6358 [mtrtaams2_mg_notify_request_ar2(20 + Rid, Tid, Cid)] 6359 end, 6360 ConnectVerify = ?mtrtaams2_mg_verify_handle_connect_fun(), 6361 ServiceChangeReplyVerify = ?mtrtaams2_mg_verify_service_change_reply_fun(), 6362 NotifyReplyVerify = ?mtrtaams2_mg_verify_notify_reply_fun(), 6363 EvSeq = [ 6364 {debug, true}, 6365 megaco_start, 6366 {megaco_start_user, Mid, RI, []}, 6367 start_transport, 6368 {megaco_trace, disable}, 6369 {megaco_system_info, users}, 6370 {megaco_system_info, connections}, 6371 {connect, [{serialize, true}]}, 6372 {megaco_callback, handle_connect, ConnectVerify}, 6373 megaco_connect, 6374 {megaco_cast, ServiceChangeReq, []}, 6375 {megaco_callback, handle_connect, ConnectVerify}, 6376 {megaco_callback, handle_trans_reply, ServiceChangeReplyVerify}, 6377 {sleep, 1000}, 6378 {megaco_system_info, users}, 6379 {megaco_system_info, connections}, 6380 {sleep, 1000}, 6381 {megaco_update_conn_info, auto_ack, true}, 6382 {megaco_update_conn_info, trans_ack_maxcount, 10}, 6383 {megaco_update_conn_info, trans_req_maxcount, 10}, 6384 {megaco_update_conn_info, trans_req_maxsize, 1024}, 6385 {megaco_update_conn_info, trans_timer, 5000}, 6386 {megaco_update_conn_info, trans_ack, true}, 6387 {megaco_update_conn_info, trans_req, true}, 6388 {megaco_conn_info, all}, 6389 {megaco_cast, [NR1(1,2), NR1(1,3), NR1(1,4)], []}, 6390 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 6391 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 6392 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 6393 {megaco_cast, [NR1(2,5), NR1(2,6), NR1(2,7)], []}, 6394 {megaco_cast, NR2(2,1), []}, 6395 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 6396 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 6397 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 6398 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 6399 {sleep, 3000}, 6400 megaco_stop_user, 6401 megaco_stop, 6402 {sleep, 1000} 6403 ], 6404 EvSeq. 6405 6406mtrtaams2_mg_verify_handle_connect({handle_connect, CH, ?VERSION}) -> 6407 p("mtrtaams2_mg_verify_handle_connect -> ok" 6408 "~n CH: ~p", [CH]), 6409 {ok, CH, ok}; 6410mtrtaams2_mg_verify_handle_connect(Else) -> 6411 p("mtrtaams2_mg_verify_handle_connect -> unknown" 6412 "~n Else: ~p", [Else]), 6413 {error, Else, ok}. 6414 6415mtrtaams2_mg_verify_service_change_reply({handle_trans_reply, _CH, ?VERSION, 6416 {ok, [AR]}, _}) -> 6417 p("mtrtaams2_mg_verify_service_change_reply -> ok" 6418 "~n AR: ~p", [AR]), 6419 case AR of 6420 #'ActionReply'{commandReply = [SCR]} -> 6421 case SCR of 6422 {serviceChangeReply, 6423 #'ServiceChangeReply'{terminationID = [Tid], 6424 serviceChangeResult = Res}} -> 6425 case Tid of 6426 #megaco_term_id{contains_wildcards = false, 6427 id = ["root"]} -> 6428 case Res of 6429 {serviceChangeResParms, 6430 #'ServiceChangeResParm'{ 6431 serviceChangeMgcId = _RemoteMid}} -> 6432 {ok, AR, ok}; 6433 {Tag, Val} -> 6434 Err = {invalid_service_change_result, 6435 Tag, Val}, 6436 {error, Err, ok} 6437 end; 6438 _ -> 6439 Err = {invalid_termination_id, Tid}, 6440 {error, Err, ok} 6441 end; 6442 {Tag, Val} -> 6443 Err = {invalid_command_reply, Tag, Val}, 6444 {error, Err, ok} 6445 end; 6446 _ -> 6447 Err = {invalid_action_reply, AR}, 6448 {error, Err, ok} 6449 end; 6450mtrtaams2_mg_verify_service_change_reply(Else) -> 6451 p("mtrtaams2_mg_verify_service_change_reply -> unknown" 6452 "~n Else: ~p", [Else]), 6453 {error, Else, ok}. 6454 6455mtrtaams2_mg_verify_notify_reply({handle_trans_reply, _CH, ?VERSION, 6456 {ok, [AR]}, _}) -> 6457 p("mtrtaams2_mg_verify_notify_reply -> ok" 6458 "~n AR: ~p", [AR]), 6459 {ok, AR, ok}; 6460mtrtaams2_mg_verify_notify_reply(Else) -> 6461 p("mtrtaams2_mg_verify_notify_reply -> unknown" 6462 "~n Else: ~p", [Else]), 6463 {error, Else, ok}. 6464 6465mtrtaams2_mg_service_change_request_ar(_Mid, Cid) -> 6466 Prof = cre_serviceChangeProf("resgw", 1), 6467 SCP = cre_serviceChangeParm(restart, ["901 mg col boot"], Prof), 6468 Root = #megaco_term_id{id = ["root"]}, 6469 SCR = cre_serviceChangeReq([Root], SCP), 6470 CMD = cre_command(SCR), 6471 CR = cre_cmdReq(CMD), 6472 cre_actionReq(Cid, [CR]). 6473 6474%% mtrtaams2_mg_service_change_request_msg(Mid, TransId, Cid) -> 6475%% AR = mtrtaams2_mg_service_change_request_ar(Mid, Cid), 6476%% TR = cre_transReq(TransId, [AR]), 6477%% Trans = cre_transaction(TR), 6478%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 6479%% cre_megacoMessage(Mess). 6480 6481mtrtaams2_mg_notify_request_ar1(Rid, Tid, Cid) -> 6482 TT = cre_timeNotation("19990729", "22000000"), 6483 Ev = cre_obsEvent("al/of", TT), 6484 EvsDesc = cre_obsEvsDesc(Rid, [Ev]), 6485 NR = cre_notifyReq([Tid], EvsDesc), 6486 CMD = cre_command(NR), 6487 CR = cre_cmdReq(CMD), 6488 cre_actionReq(Cid, [CR]). 6489 6490mtrtaams2_mg_notify_request_ar2(Rid, Tid, Cid) -> 6491 F = fun(N) -> 6492 T = 22000000 + N, 6493 TS = integer_to_list(T), 6494 TT = cre_timeNotation("19990729", TS), 6495 Ev = cre_obsEvent("al/of", TT), 6496 EvsDesc = cre_obsEvsDesc(Rid+N, [Ev]), 6497 NR = cre_notifyReq([Tid], EvsDesc), 6498 CMD = cre_command(NR), 6499 cre_cmdReq(CMD) 6500 end, 6501 Ns = [0,1,2,3,4,5,6,7,8,9], 6502 CRs = [F(N) || N <- Ns], 6503 cre_actionReq(Cid, CRs). 6504 6505%% mtrtaams2_notify_request_msg(Mid, TransId, Rid, TermId, Cid) -> 6506%% AR = mtrtaams2_mg_notify_request_ar1(Rid, TermId, Cid), 6507%% TR = cre_transReq(TransId, [AR]), 6508%% Trans = cre_transaction(TR), 6509%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 6510%% cre_megacoMessage(Mess). 6511 6512 6513%% 6514%% Common functions for the multi_trans_req_timeout test case 6515%% 6516 6517mtrtaams2_err_desc(T) -> 6518 cre_ErrDesc(T). 6519 6520 6521%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 6522 6523single_trans_req_and_pending(suite) -> 6524 []; 6525single_trans_req_and_pending(doc) -> 6526 []; 6527single_trans_req_and_pending(Config) when is_list(Config) -> 6528 ?SKIP(not_yet_implemented). 6529 6530 6531%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 6532 6533multi_trans_req_and_pending(suite) -> 6534 []; 6535multi_trans_req_and_pending(doc) -> 6536 []; 6537multi_trans_req_and_pending(Config) when is_list(Config) -> 6538 ?SKIP(not_yet_implemented). 6539 6540 6541%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 6542 6543multi_trans_req_and_ack_and_pending(suite) -> 6544 []; 6545multi_trans_req_and_ack_and_pending(doc) -> 6546 []; 6547multi_trans_req_and_ack_and_pending(Config) when is_list(Config) -> 6548 Pre = fun() -> 6549 MgcNode = make_node_name(mgc), 6550 MgNode = make_node_name(mg), 6551 d("start nodes: " 6552 "~n MGC Node: ~p" 6553 "~n MG Node: ~p", 6554 [MgcNode, MgNode]), 6555 Nodes = [MgcNode, MgNode], 6556 ok = ?START_NODES(Nodes), 6557 Nodes 6558 end, 6559 Case = fun do_multi_trans_req_and_ack_and_pending/1, 6560 Post = fun(Nodes) -> 6561 d("stop nodes"), 6562 ?STOP_NODES(lists:reverse(Nodes)) 6563 end, 6564 try_tc(mtraaap, Pre, Case, Post). 6565 6566do_multi_trans_req_and_ack_and_pending([MgcNode, MgNode]) -> 6567 6568 d("[MGC] start the simulator "), 6569 {ok, Mgc} = megaco_test_megaco_generator:start_link("MGC", MgcNode), 6570 6571 d("[MGC] create the event sequence"), 6572 MgcEvSeq = mtraaap_mgc_event_sequence(text, tcp), 6573 6574 i("wait some time before starting the MGC simulation"), 6575 sleep(1000), 6576 6577 d("[MGC] start the simulation"), 6578 {ok, MgcId} = megaco_test_megaco_generator:exec(Mgc, MgcEvSeq), 6579 6580 %% i("wait some time before starting the MG simulator"), 6581 %% sleep(1000), 6582 6583 i("await MGC ready announcement"), 6584 receive 6585 announce_mgc -> 6586 i("received MGC ready announcement"), 6587 ok 6588 end, 6589 6590 d("[MG] start the simulator (generator)"), 6591 {ok, Mg} = megaco_test_megaco_generator:start_link("MG", MgNode), 6592 6593 d("[MG] create the event sequence"), 6594 MgEvSeq = mtraaap_mg_event_sequence(text, tcp), 6595 6596 i("wait some time before starting the MG simulation"), 6597 sleep(1000), 6598 6599 d("[MG] start the simulation"), 6600 {ok, MgId} = megaco_test_megaco_generator:exec(Mg, MgEvSeq), 6601 6602 d("await the generator reply(s)"), 6603 await_completion([MgcId, MgId]), 6604 6605 %% Tell Mgc to stop 6606 i("[MGC] stop generator"), 6607 megaco_test_megaco_generator:stop(Mgc), 6608 6609 %% Tell Mg to stop 6610 i("[MG] stop generator"), 6611 megaco_test_megaco_generator:stop(Mg), 6612 6613 i("done", []), 6614 ok. 6615 6616 6617%% 6618%% MGC generator stuff 6619%% 6620-ifdef(megaco_hipe_special). 6621-define(mtraaap_mgc_verify_handle_connect_fun(), 6622 {?MODULE, mtraaap_mgc_verify_handle_connect, []}). 6623-define(mtraaap_mgc_verify_service_change_req_fun(Mid), 6624 {?MODULE, mtraaap_mgc_verify_service_change_req, [Mid]}). 6625-define(mtraaap_mgc_verify_notify_req_fun(), 6626 {?MODULE, mtraaap_mgc_verify_notify_request, []}). 6627-define(mtraaap_mgc_verify_notify_reply_fun(), 6628 {?MODULE, mtraaap_mgc_verify_notify_reply, []}). 6629-define(mtraaap_mgc_verify_ack_fun(), 6630 {?MODULE, mtraaap_mgc_verify_ack, []}). 6631-define(mtraaap_mgc_verify_handle_disconnect_fun(), 6632 {?MODULE, mtraaap_mgc_verify_handle_disconnect, []}). 6633-else. 6634-define(mtraaap_mgc_verify_handle_connect_fun(), 6635 fun mtraaap_mgc_verify_handle_connect/1). 6636-define(mtraaap_mgc_verify_service_change_req_fun(Mid), 6637 mtraaap_mgc_verify_service_change_req_fun(Mid)). 6638-define(mtraaap_mgc_verify_notify_req_fun(), 6639 mtraaap_mgc_verify_notify_request_fun()). 6640-define(mtraaap_mgc_verify_notify_reply_fun(), 6641 fun mtraaap_mgc_verify_notify_reply/1). 6642-define(mtraaap_mgc_verify_ack_fun(), 6643 fun mtraaap_mgc_verify_ack/1). 6644-define(mtraaap_mgc_verify_handle_disconnect_fun(), 6645 fun mtraaap_mgc_verify_handle_disconnect/1). 6646-endif. 6647 6648mtraaap_mgc_event_sequence(text, tcp) -> 6649 CTRL = self(), 6650 Mid = {deviceName,"ctrl"}, 6651 RI = [ 6652 {port, 2944}, 6653 {encoding_module, megaco_pretty_text_encoder}, 6654 {encoding_config, []}, 6655 {transport_module, megaco_tcp} 6656 ], 6657 Tid = #megaco_term_id{id = ["00000000","00000000","01101101"]}, 6658 NR = fun(Cid, Rid) -> 6659 [mtraaap_mgc_notify_request_ar(Rid, Tid, Cid)] 6660 end, 6661 ReqTmr = #megaco_incr_timer{wait_for = 500, 6662 factor = 1, 6663 max_retries = 1}, 6664 ConnectVerify = ?mtraaap_mgc_verify_handle_connect_fun(), 6665 ServiceChangeReqVerify = ?mtraaap_mgc_verify_service_change_req_fun(Mid), 6666 NotifyReqVerify = ?mtraaap_mgc_verify_notify_req_fun(), 6667 NotifyReplyVerify = ?mtraaap_mgc_verify_notify_reply_fun(), 6668 AckVerify = ?mtraaap_mgc_verify_ack_fun(), 6669 DiscoVerify = ?mtraaap_mgc_verify_handle_disconnect_fun(), 6670 EvSeq = [ 6671 {debug, true}, 6672 {megaco_trace, disable}, 6673 megaco_start, 6674 {megaco_start_user, Mid, RI, []}, 6675 start_transport, 6676 listen, 6677 6678 %% ANNOUNCE READY 6679 {trigger, fun() -> CTRL ! announce_mgc end}, 6680 6681 {megaco_callback, handle_connect, ConnectVerify}, 6682 {megaco_callback, handle_trans_request, ServiceChangeReqVerify}, 6683 {megaco_callback, handle_trans_request, NotifyReqVerify}, 6684 {megaco_callback, handle_trans_request, NotifyReqVerify}, 6685 {megaco_callback, handle_trans_request, NotifyReqVerify}, 6686 {megaco_update_conn_info, request_timer, ReqTmr}, 6687 {megaco_cast, NR(1,1), []}, 6688 {megaco_callback, [{handle_trans_ack, 3, AckVerify}, 6689 {handle_trans_request, 3, NotifyReqVerify}, 6690 {handle_trans_reply, 1, NotifyReplyVerify}]}, 6691 {megaco_callback, handle_disconnect, DiscoVerify}, 6692 {sleep, 1000}, 6693 megaco_stop_user, 6694 megaco_stop 6695 ], 6696 EvSeq. 6697 6698 6699mtraaap_mgc_verify_handle_connect({handle_connect, CH, ?VERSION}) -> 6700 io:format("mtraaap_mgc_verify_handle_connect -> ok" 6701 "~n CH: ~p~n", [CH]), 6702 {ok, CH, ok}; 6703mtraaap_mgc_verify_handle_connect(Else) -> 6704 io:format("mtraaap_mgc_verify_handle_connect -> unknown" 6705 "~n Else: ~p~n", [Else]), 6706 {error, Else, ok}. 6707 6708mtraaap_mgc_verify_service_change_req_fun(Mid) -> 6709 fun(Ev) -> 6710 mtraaap_mgc_verify_service_change_req(Ev, Mid) 6711 end. 6712 6713mtraaap_mgc_verify_service_change_req( 6714 {handle_trans_request, _, ?VERSION, [AR]}, Mid) -> 6715 io:format("mtraaap_mgc_verify_service_change_req -> ok" 6716 "~n AR: ~p~n", [AR]), 6717 case AR of 6718 #'ActionRequest'{commandRequests = [CR]} -> 6719 case CR of 6720 #'CommandRequest'{command = Cmd} -> 6721 case Cmd of 6722 {serviceChangeReq, 6723 #'ServiceChangeRequest'{terminationID = [Tid], 6724 serviceChangeParms = Parms}} -> 6725 case Tid of 6726 #megaco_term_id{contains_wildcards = false, 6727 id = ["root"]} -> 6728 case Parms of 6729 #'ServiceChangeParm'{ 6730 serviceChangeMethod = restart, 6731 serviceChangeReason = [[$9,$0,$1|_]]} -> 6732 Reply = 6733 {discard_ack, 6734 [mtraaap_mgc_service_change_reply_ar(Mid, 1)]}, 6735 {ok, AR, Reply}; 6736 _ -> 6737 Err = {invalid_SCP, Parms}, 6738 ED = mtraaap_err_desc(Parms), 6739 ErrReply = {discard_ack, 6740 ED}, 6741 {error, Err, ErrReply} 6742 end; 6743 _ -> 6744 Err = {invalid_termination_id, Tid}, 6745 ED = mtraaap_err_desc(Tid), 6746 ErrReply = {discard_ack, ED}, 6747 {error, Err, ErrReply} 6748 end; 6749 _ -> 6750 Err = {invalid_command, Cmd}, 6751 ED = mtraaap_err_desc(Cmd), 6752 ErrReply = {discard_ack, ED}, 6753 {error, Err, ErrReply} 6754 end; 6755 _ -> 6756 Err = {invalid_command_request, CR}, 6757 ED = mtraaap_err_desc(CR), 6758 ErrReply = {discard_ack, ED}, 6759 {error, Err, ErrReply} 6760 end; 6761 _ -> 6762 Err = {invalid_action_request, AR}, 6763 ED = mtraaap_err_desc(AR), 6764 ErrReply = {discard_ack, ED}, 6765 {error, Err, ErrReply} 6766 end; 6767mtraaap_mgc_verify_service_change_req(Else, _Mid) -> 6768 io:format("mtraaap_mgc_verify_service_change_req -> unknown" 6769 "~n Else: ~p~n", [Else]), 6770 ED = mtraaap_err_desc(Else), 6771 ErrReply = {discard_ack, ED}, 6772 {error, Else, ErrReply}. 6773 6774mtraaap_mgc_verify_notify_request_fun() -> 6775 fun(Ev) -> 6776 mtraaap_mgc_verify_notify_request(Ev) 6777 end. 6778 6779mtraaap_mgc_verify_notify_request( 6780 {handle_trans_request, _, ?VERSION, [AR]}) -> 6781 io:format("mtraaap_mgc_verify_notify_request -> ok" 6782 "~n AR: ~p~n", [AR]), 6783 case AR of 6784 #'ActionRequest'{contextId = 1 = Cid, 6785 commandRequests = [CR]} -> 6786 #'CommandRequest'{command = Cmd} = CR, 6787 {notifyReq, NR} = Cmd, 6788 #'NotifyRequest'{terminationID = [Tid], 6789 observedEventsDescriptor = OED, 6790 errorDescriptor = asn1_NOVALUE} = NR, 6791 #'ObservedEventsDescriptor'{observedEventLst = [OE]} = OED, 6792 #'ObservedEvent'{eventName = "al/of"} = OE, 6793 HandleAck = {handle_sloppy_ack, kalle}, 6794 Reply = {HandleAck, 6795 [mtraaap_mgc_notify_reply_ar(Cid, Tid)]}, 6796 {ok, AR, Reply}; 6797 #'ActionRequest'{contextId = 2 = Cid, 6798 commandRequests = [CR]} -> 6799 #'CommandRequest'{command = Cmd} = CR, 6800 {notifyReq, NR} = Cmd, 6801 #'NotifyRequest'{terminationID = [Tid], 6802 observedEventsDescriptor = OED, 6803 errorDescriptor = asn1_NOVALUE} = NR, 6804 #'ObservedEventsDescriptor'{observedEventLst = [OE]} = OED, 6805 #'ObservedEvent'{eventName = "al/of"} = OE, 6806 Reply = {discard_ack, [mtraaap_mgc_notify_reply_ar(Cid, Tid)]}, 6807 {ok, AR, Reply}; 6808 _ -> 6809 ED = mtraaap_err_desc(AR), 6810 ErrReply = {discard_ack, ED}, 6811 {error, AR, ErrReply} 6812 end; 6813mtraaap_mgc_verify_notify_request(Else) -> 6814 io:format("mtraaap_mgc_verify_notify_request -> unknown" 6815 "~n Else: ~p~n", [Else]), 6816 ED = mtraaap_err_desc(Else), 6817 ErrReply = {discard_ack, ED}, 6818 {error, Else, ErrReply}. 6819 6820mtraaap_mgc_verify_notify_reply({handle_trans_reply, _CH, ?VERSION, 6821 {ok, [AR]}, _}) -> 6822 io:format("mtraaap_mgc_verify_notify_reply -> ok" 6823 "~n AR: ~p~n", [AR]), 6824 {ok, AR, ok}; 6825mtraaap_mgc_verify_notify_reply(Else) -> 6826 io:format("mtraaap_mgc_verify_notify_reply -> unknown" 6827 "~n Else: ~p~n", [Else]), 6828 {error, Else, ok}. 6829 6830mtraaap_mgc_verify_ack({handle_trans_ack, CH, ?VERSION, ok, kalle}) -> 6831 io:format("mtraaap_mgc_verify_ack -> ok" 6832 "~n CH: ~p" 6833 "~n", [CH]), 6834 {ok, CH, ok}; 6835mtraaap_mgc_verify_ack(Else) -> 6836 io:format("mtraaap_mgc_verify_ack -> unknown" 6837 "~n Else: ~p~n", [Else]), 6838 {error, Else, ok}. 6839 6840mtraaap_mgc_verify_handle_disconnect({handle_disconnect, CH, ?VERSION, R}) -> 6841 io:format("mtraaap_mgc_verify_handle_disconnect -> ok" 6842 "~n CH: ~p" 6843 "~n R: ~p" 6844 "~n", [CH, R]), 6845 {ok, CH, ok}; 6846mtraaap_mgc_verify_handle_disconnect(Else) -> 6847 io:format("mtraaap_mgc_verify_handle_disconnect -> unknown" 6848 "~n Else: ~p~n", [Else]), 6849 {error, Else, ok}. 6850 6851 6852mtraaap_mgc_service_change_reply_ar(Mid, Cid) -> 6853 SCRP = cre_serviceChangeResParm(Mid), 6854 SCRes = cre_serviceChangeResult(SCRP), 6855 Root = #megaco_term_id{id = ["root"]}, 6856 SCR = cre_serviceChangeReply([Root], SCRes), 6857 CR = cre_cmdReply(SCR), 6858 cre_actionReply(Cid, [CR]). 6859 6860%% mtraaap_mgc_service_change_reply_msg(Mid, TransId, Cid) -> 6861%% AR = mtraaap_mgc_service_change_reply_ar(Mid, Cid), 6862%% TRes = cre_transResult([AR]), 6863%% TR = cre_transReply(TransId, TRes), 6864%% Trans = cre_transaction(TR), 6865%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 6866%% cre_megacoMessage(Mess). 6867 6868mtraaap_mgc_notify_request_ar(Rid, Tid, Cid) -> 6869 TT = cre_timeNotation("19990729", "44000000"), 6870 Ev = cre_obsEvent("al/of", TT), 6871 EvsDesc = cre_obsEvsDesc(Rid, [Ev]), 6872 NR = cre_notifyReq([Tid], EvsDesc), 6873 CMD = cre_command(NR), 6874 CR = cre_cmdReq(CMD), 6875 cre_actionReq(Cid, [CR]). 6876 6877mtraaap_mgc_notify_reply_ar(Cid, TermId) -> 6878 NR = cre_notifyReply([TermId]), 6879 CR = cre_cmdReply(NR), 6880 cre_actionReply(Cid, [CR]). 6881 6882%% mtraaap_mgc_notify_reply(Mid, TransId, Cid, TermId) -> 6883%% AR = mtraaap_mgc_notify_reply_ar(Cid, TermId), 6884%% TRes = cre_transResult([AR]), 6885%% TR = cre_transReply(TransId, TRes), 6886%% Trans = cre_transaction(TR), 6887%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 6888%% cre_megacoMessage(Mess). 6889 6890 6891%% 6892%% MG generator stuff 6893%% 6894-ifdef(megaco_hipe_special). 6895-define(mtraaap_mg_verify_handle_connect_fun(), 6896 {?MODULE, mtraaap_mg_verify_handle_connect, []}). 6897-define(mtraaap_mg_verify_service_change_reply_fun(), 6898 {?MODULE, mtraaap_mg_verify_service_change_reply, []}). 6899-define(mtraaap_mg_verify_notify_req_fun(), 6900 {?MODULE, mtraaap_mgc_verify_notify_request, []}). 6901-define(mtraaap_mg_verify_notify_reply_fun(), 6902 {?MODULE, mtraaap_mg_verify_notify_reply, []}). 6903-else. 6904-define(mtraaap_mg_verify_handle_connect_fun(), 6905 fun mtraaap_mg_verify_handle_connect/1). 6906-define(mtraaap_mg_verify_service_change_reply_fun(), 6907 fun mtraaap_mg_verify_service_change_reply/1). 6908-define(mtraaap_mg_verify_notify_req_fun(), 6909 mtraaap_mgc_verify_notify_request_fun()). 6910-define(mtraaap_mg_verify_notify_reply_fun(), 6911 fun mtraaap_mg_verify_notify_reply/1). 6912-endif. 6913 6914mtraaap_mg_event_sequence(text, tcp) -> 6915 Mid = {deviceName,"mg"}, 6916 RI = [ 6917 {port, 2944}, 6918 {encoding_module, megaco_pretty_text_encoder}, 6919 {encoding_config, []}, 6920 {transport_module, megaco_tcp} 6921 ], 6922 ServiceChangeReq = [mtraaap_mg_service_change_request_ar(Mid, 1)], 6923 Tid = #megaco_term_id{id = ["00000000","00000000","01101101"]}, 6924 NR = fun(Cid, Rid) -> 6925 [mtraaap_mg_notify_request_ar(Rid, Tid, Cid)] 6926 end, 6927 ConnectVerify = ?mtraaap_mg_verify_handle_connect_fun(), 6928 ServiceChangeReplyVerify = ?mtraaap_mg_verify_service_change_reply_fun(), 6929 NotifyReqVerify = ?mtraaap_mg_verify_notify_req_fun(), 6930 NotifyReplyVerify = ?mtraaap_mg_verify_notify_reply_fun(), 6931 EvSeq = [ 6932 {debug, true}, 6933 megaco_start, 6934 {megaco_start_user, Mid, RI, []}, 6935 start_transport, 6936 {megaco_trace, disable}, 6937 {megaco_system_info, users}, 6938 {megaco_system_info, connections}, 6939 connect, 6940 {megaco_callback, handle_connect, ConnectVerify}, 6941 megaco_connect, 6942 {megaco_cast, ServiceChangeReq, []}, 6943 {megaco_callback, handle_connect, ConnectVerify}, 6944 {megaco_callback, handle_trans_reply, ServiceChangeReplyVerify}, 6945 {sleep, 1000}, 6946 {megaco_system_info, users}, 6947 {megaco_system_info, connections}, 6948 {sleep, 1000}, 6949 {megaco_update_conn_info, auto_ack, true}, 6950 {megaco_update_conn_info, trans_ack_maxcount, 10}, 6951 {megaco_update_conn_info, trans_req_maxcount, 10}, 6952 {megaco_update_conn_info, trans_timer, 1000}, 6953 {megaco_update_conn_info, trans_ack, true}, 6954 {megaco_update_conn_info, trans_req, true}, 6955 {megaco_conn_info, all}, 6956 {megaco_cast, NR(1,1), []}, 6957 {megaco_cast, NR(1,2), []}, 6958 {megaco_cast, NR(1,3), []}, 6959 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 6960 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 6961 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 6962 {megaco_update_conn_info, trans_timer, 120000}, 6963 {megaco_cast, NR(2,1), []}, 6964 {megaco_cast, NR(2,2), []}, 6965 {megaco_cast, NR(2,3), []}, 6966 {megaco_callback, handle_trans_request, NotifyReqVerify}, 6967 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 6968 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 6969 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 6970 {sleep, 3000}, 6971 megaco_stop_user, 6972 megaco_stop, 6973 {sleep, 1000} 6974 ], 6975 EvSeq. 6976 6977mtraaap_mg_verify_handle_connect({handle_connect, CH, ?VERSION}) -> 6978 io:format("mtraaap_mg_verify_handle_connect -> ok" 6979 "~n CH: ~p~n", [CH]), 6980 {ok, CH, ok}; 6981mtraaap_mg_verify_handle_connect(Else) -> 6982 io:format("mtraaap_mg_verify_handle_connect -> unknown" 6983 "~n Else: ~p~n", [Else]), 6984 {error, Else, ok}. 6985 6986mtraaap_mg_verify_service_change_reply({handle_trans_reply, _CH, ?VERSION, 6987 {ok, [AR]}, _}) -> 6988 io:format("mtraaap_mg_verify_service_change_reply -> ok" 6989 "~n AR: ~p~n", [AR]), 6990 case AR of 6991 #'ActionReply'{commandReply = [SCR]} -> 6992 case SCR of 6993 {serviceChangeReply, 6994 #'ServiceChangeReply'{terminationID = [Tid], 6995 serviceChangeResult = Res}} -> 6996 case Tid of 6997 #megaco_term_id{contains_wildcards = false, 6998 id = ["root"]} -> 6999 case Res of 7000 {serviceChangeResParms, 7001 #'ServiceChangeResParm'{ 7002 serviceChangeMgcId = _RemoteMid}} -> 7003 {ok, AR, ok}; 7004 {Tag, Val} -> 7005 Err = {invalid_service_change_result, 7006 Tag, Val}, 7007 {error, Err, ok} 7008 end; 7009 _ -> 7010 Err = {invalid_termination_id, Tid}, 7011 {error, Err, ok} 7012 end; 7013 {Tag, Val} -> 7014 Err = {invalid_command_reply, Tag, Val}, 7015 {error, Err, ok} 7016 end; 7017 _ -> 7018 Err = {invalid_action_reply, AR}, 7019 {error, Err, ok} 7020 end; 7021mtraaap_mg_verify_service_change_reply(Else) -> 7022 io:format("mtraaap_mg_verify_service_change_reply -> unknown" 7023 "~n Else: ~p~n", [Else]), 7024 {error, Else, ok}. 7025 7026 7027mtraaap_mg_verify_notify_reply({handle_trans_reply, _CH, ?VERSION, 7028 {ok, [AR]}, _}) -> 7029 io:format("mtraaap_mg_verify_notify_reply -> ok" 7030 "~n AR: ~p~n", [AR]), 7031 {ok, AR, ok}; 7032mtraaap_mg_verify_notify_reply(Else) -> 7033 io:format("mtraaap_mg_verify_notify_reply -> unknown" 7034 "~n Else: ~p~n", [Else]), 7035 {error, Else, ok}. 7036 7037mtraaap_mg_service_change_request_ar(_Mid, Cid) -> 7038 Prof = cre_serviceChangeProf("resgw", 1), 7039 SCP = cre_serviceChangeParm(restart, ["901 mg col boot"], Prof), 7040 Root = #megaco_term_id{id = ["root"]}, 7041 SCR = cre_serviceChangeReq([Root], SCP), 7042 CMD = cre_command(SCR), 7043 CR = cre_cmdReq(CMD), 7044 cre_actionReq(Cid, [CR]). 7045 7046%% mtraaap_mg_service_change_request_msg(Mid, TransId, Cid) -> 7047%% AR = mtraaap_mg_service_change_request_ar(Mid, Cid), 7048%% TR = cre_transReq(TransId, [AR]), 7049%% Trans = cre_transaction(TR), 7050%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 7051%% cre_megacoMessage(Mess). 7052 7053%% mtraaap_mg_notify_reply_ar(Cid, TermId) -> 7054%% NR = cre_notifyReply([TermId]), 7055%% CR = cre_cmdReply(NR), 7056%% cre_actionReply(Cid, [CR]). 7057 7058mtraaap_mg_notify_request_ar(Rid, Tid, Cid) -> 7059 TT = cre_timeNotation("19990729", "22000000"), 7060 Ev = cre_obsEvent("al/of", TT), 7061 EvsDesc = cre_obsEvsDesc(Rid, [Ev]), 7062 NR = cre_notifyReq([Tid], EvsDesc), 7063 CMD = cre_command(NR), 7064 CR = cre_cmdReq(CMD), 7065 cre_actionReq(Cid, [CR]). 7066 7067%% mtraaap_notify_request_msg(Mid, TransId, Rid, TermId, Cid) -> 7068%% AR = mtraaap_mg_notify_request_ar(Rid, TermId, Cid), 7069%% TR = cre_transReq(TransId, [AR]), 7070%% Trans = cre_transaction(TR), 7071%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 7072%% cre_megacoMessage(Mess). 7073 7074 7075%% 7076%% Common functions for this test case 7077%% 7078 7079mtraaap_err_desc(T) -> 7080 cre_ErrDesc(T). 7081 7082 7083%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 7084 7085multi_ack_and_pending(suite) -> 7086 []; 7087multi_ack_and_pending(doc) -> 7088 []; 7089multi_ack_and_pending(Config) when is_list(Config) -> 7090 ?SKIP(not_yet_implemented). 7091 7092 7093%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 7094 7095multi_trans_req_and_reply(suite) -> 7096 []; 7097multi_trans_req_and_reply(doc) -> 7098 []; 7099multi_trans_req_and_reply(Config) when is_list(Config) -> 7100 ?SKIP(not_yet_implemented). 7101 7102 7103%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 7104 7105multi_trans_req_and_ack_and_reply(suite) -> 7106 []; 7107multi_trans_req_and_ack_and_reply(doc) -> 7108 []; 7109multi_trans_req_and_ack_and_reply(Config) when is_list(Config) -> 7110 Pre = fun() -> 7111 MgcNode = make_node_name(mgc), 7112 MgNode = make_node_name(mg), 7113 d("start nodes: " 7114 "~n MGC Node: ~p" 7115 "~n MG Node: ~p", 7116 [MgcNode, MgNode]), 7117 Nodes = [MgcNode, MgNode], 7118 ok = ?START_NODES(Nodes), 7119 Nodes 7120 end, 7121 Case = fun do_multi_trans_req_and_ack_and_reply/1, 7122 Post = fun(Nodes) -> 7123 d("stop nodes"), 7124 ?STOP_NODES(lists:reverse(Nodes)) 7125 end, 7126 try_tc(multi_trans_req_and_ack_and_reply, Pre, Case, Post). 7127 7128do_multi_trans_req_and_ack_and_reply([MgcNode, MgNode]) -> 7129 7130 d("[MGC] start the simulator "), 7131 {ok, Mgc} = megaco_test_megaco_generator:start_link("MGC", MgcNode), 7132 7133 d("[MGC] create the event sequence"), 7134 MgcEvSeq = mtraaar_mgc_event_sequence(text, tcp), 7135 7136 i("wait some time before starting the MGC simulation"), 7137 sleep(1000), 7138 7139 d("[MGC] start the simulation"), 7140 {ok, MgcId} = megaco_test_megaco_generator:exec(Mgc, MgcEvSeq), 7141 7142 %% i("wait some time before starting the MG simulator"), 7143 %% sleep(1000), 7144 7145 i("await MGC ready announcement"), 7146 receive 7147 announce_mgc -> 7148 i("received MGC ready announcement"), 7149 ok 7150 end, 7151 7152 d("[MG] start the simulator (generator)"), 7153 {ok, Mg} = megaco_test_megaco_generator:start_link("MG", MgNode), 7154 7155 d("[MG] create the event sequence"), 7156 MgEvSeq = mtraaar_mg_event_sequence(text, tcp), 7157 7158 i("wait some time before starting the MG simulation"), 7159 sleep(1000), 7160 7161 d("[MG] start the simulation"), 7162 {ok, MgId} = megaco_test_megaco_generator:exec(Mg, MgEvSeq), 7163 7164 d("await the generator reply(s)"), 7165 await_completion([MgcId, MgId]), 7166 7167 %% Tell Mgc to stop 7168 i("[MGC] stop generator"), 7169 megaco_test_megaco_generator:stop(Mgc), 7170 7171 %% Tell Mg to stop 7172 i("[MG] stop generator"), 7173 megaco_test_megaco_generator:stop(Mg), 7174 7175 i("done", []), 7176 ok. 7177 7178 7179%% 7180%% MGC generator stuff 7181%% 7182-ifdef(megaco_hipe_special). 7183-define(mtraaar_mgc_verify_handle_connect_fun(), 7184 {?MODULE, mtraaar_mgc_verify_handle_connect, []}). 7185-define(mtraaar_mgc_verify_service_change_req_fun(Mid), 7186 {?MODULE, mtraaar_mgc_verify_service_change_req, [Mid]}). 7187-define(mtraaar_mgc_verify_notify_req_fun(N), 7188 {?MODULE, mtraaar_mgc_verify_notify_request, [N]}). 7189-define(mtraaar_mgc_verify_notify_reply_fun(N), 7190 {?MODULE, mtraaar_mgc_verify_notify_reply, [N]}). 7191-define(mtraaar_mgc_verify_ack_fun(), 7192 {?MODULE, mtraaar_mgc_verify_ack, []}). 7193-define(mtraaar_mgc_verify_handle_disconnect_fun(), 7194 {?MODULE, mtraaar_mgc_verify_handle_disconnect, []}). 7195-else. 7196-define(mtraaar_mgc_verify_handle_connect_fun(), 7197 fun mtraaar_mgc_verify_handle_connect/1). 7198-define(mtraaar_mgc_verify_service_change_req_fun(Mid), 7199 mtraaar_mgc_verify_service_change_req_fun(Mid)). 7200-define(mtraaar_mgc_verify_notify_req_fun(N), 7201 fun(Request) -> 7202 mtraaar_mgc_verify_notify_request(N, Request) 7203 end). 7204-define(mtraaar_mgc_verify_notify_reply_fun(N), 7205 fun(Reply) -> 7206 mtraaar_mgc_verify_notify_reply(N, Reply) 7207 end). 7208-define(mtraaar_mgc_verify_ack_fun(), 7209 fun mtraaar_mgc_verify_ack/1). 7210-define(mtraaar_mgc_verify_handle_disconnect_fun(), 7211 fun mtraaar_mgc_verify_handle_disconnect/1). 7212-endif. 7213 7214mtraaar_mgc_event_sequence(text, tcp) -> 7215 CTRL = self(), 7216 Mid = {deviceName,"ctrl"}, 7217 RI = [ 7218 {port, 2944}, 7219 {encoding_module, megaco_pretty_text_encoder}, 7220 {encoding_config, []}, 7221 {transport_module, megaco_tcp} 7222 ], 7223 Tid = #megaco_term_id{id = ["00000000","00000000","01101101"]}, 7224 SNR = fun(Cid, Rid) -> 7225 [mtraaar_mgc_notify_request_ar(Rid, Tid, Cid)] 7226 end, 7227 ConnectVerify = ?mtraaar_mgc_verify_handle_connect_fun(), 7228 ServiceChangeReqVerify = ?mtraaar_mgc_verify_service_change_req_fun(Mid), 7229 %% NotifyReqVerify = ?mtraaar_mgc_verify_notify_req_fun(), 7230 NReqV = 7231 fun(N) -> 7232 ?mtraaar_mgc_verify_notify_req_fun(N) 7233 end, 7234 %% NotifyReplyVerify = ?mtraaar_mgc_verify_notify_reply_fun(), 7235 NRepV = fun(N) -> 7236 ?mtraaar_mgc_verify_notify_reply_fun(N) 7237 end, 7238 AckVerify = ?mtraaar_mgc_verify_ack_fun(), 7239 DiscoVerify = ?mtraaar_mgc_verify_handle_disconnect_fun(), 7240 EvSeq = [ 7241 {debug, true}, 7242 %% {megaco_trace, max}, 7243 {megaco_trace, disable}, 7244 megaco_start, 7245 {megaco_start_user, Mid, RI, []}, 7246 start_transport, 7247 listen, 7248 7249 %% ANNOUNCE READY 7250 {trigger, fun() -> CTRL ! announce_mgc end}, 7251 7252 {megaco_callback, handle_connect, ConnectVerify}, 7253 {megaco_callback, handle_trans_request, ServiceChangeReqVerify}, 7254 {megaco_callback, handle_trans_request, NReqV(1)}, 7255 {megaco_callback, handle_trans_request, NReqV(2)}, 7256 {megaco_callback, handle_trans_request, NReqV(3)}, 7257 {megaco_update_conn_info, request_timer, 1000}, 7258 {sleep, 1000}, 7259 {megaco_cast, SNR(1,1), []}, 7260 7261 {megaco_callback, [{handle_trans_ack, 3, AckVerify}, 7262 {handle_trans_request, 3, NReqV(4)}, 7263 {handle_trans_reply, 1, NRepV(1)}]}, 7264 {megaco_callback, handle_disconnect, DiscoVerify}, 7265 {sleep, 1000}, 7266 megaco_stop_user, 7267 megaco_stop 7268 ], 7269 EvSeq. 7270 7271 7272mtraaar_mgc_verify_handle_connect({handle_connect, CH, ?VERSION}) -> 7273 io:format("mtraaar_mgc_verify_handle_connect -> ok" 7274 "~n CH: ~p~n", [CH]), 7275 {ok, CH, ok}; 7276mtraaar_mgc_verify_handle_connect(Else) -> 7277 io:format("mtraaar_mgc_verify_handle_connect -> unknown" 7278 "~n Else: ~p~n", [Else]), 7279 {error, Else, ok}. 7280 7281mtraaar_mgc_verify_service_change_req_fun(Mid) -> 7282 fun(Ev) -> 7283 mtraaar_mgc_verify_service_change_req(Ev, Mid) 7284 end. 7285 7286mtraaar_mgc_verify_service_change_req( 7287 {handle_trans_request, _, ?VERSION, [AR]}, Mid) -> 7288 io:format("mtraaar_mgc_verify_service_change_req -> ok" 7289 "~n AR: ~p~n", [AR]), 7290 case AR of 7291 #'ActionRequest'{commandRequests = [CR]} -> 7292 case CR of 7293 #'CommandRequest'{command = Cmd} -> 7294 case Cmd of 7295 {serviceChangeReq, 7296 #'ServiceChangeRequest'{terminationID = [Tid], 7297 serviceChangeParms = Parms}} -> 7298 case Tid of 7299 #megaco_term_id{contains_wildcards = false, 7300 id = ["root"]} -> 7301 case Parms of 7302 #'ServiceChangeParm'{ 7303 serviceChangeMethod = restart, 7304 serviceChangeReason = [[$9,$0,$1|_]]} -> 7305 Reply = 7306 {discard_ack, 7307 [mtraaar_mgc_service_change_reply_ar(Mid, 1)]}, 7308 {ok, AR, Reply}; 7309 _ -> 7310 Err = {invalid_SCP, Parms}, 7311 ED = mtraaar_err_desc(Parms), 7312 ErrReply = {discard_ack, 7313 ED}, 7314 {error, Err, ErrReply} 7315 end; 7316 _ -> 7317 Err = {invalid_termination_id, Tid}, 7318 ED = mtraaar_err_desc(Tid), 7319 ErrReply = {discard_ack, ED}, 7320 {error, Err, ErrReply} 7321 end; 7322 _ -> 7323 Err = {invalid_command, Cmd}, 7324 ED = mtraaar_err_desc(Cmd), 7325 ErrReply = {discard_ack, ED}, 7326 {error, Err, ErrReply} 7327 end; 7328 _ -> 7329 Err = {invalid_command_request, CR}, 7330 ED = mtraaar_err_desc(CR), 7331 ErrReply = {discard_ack, ED}, 7332 {error, Err, ErrReply} 7333 end; 7334 _ -> 7335 Err = {invalid_action_request, AR}, 7336 ED = mtraaar_err_desc(AR), 7337 ErrReply = {discard_ack, ED}, 7338 {error, Err, ErrReply} 7339 end; 7340mtraaar_mgc_verify_service_change_req(Else, _Mid) -> 7341 io:format("mtraaar_mgc_verify_service_change_req -> unknown" 7342 "~n Else: ~p~n", [Else]), 7343 ED = mtraaar_err_desc(Else), 7344 ErrReply = {discard_ack, ED}, 7345 {error, Else, ErrReply}. 7346 7347mtraaar_mgc_verify_notify_request( 7348 N, 7349 {handle_trans_request, _, ?VERSION, [AR]}) -> 7350 io:format("mtraaar_mgc_verify_notify_request -> [~w] ok" 7351 "~n AR: ~p~n", [N, AR]), 7352 case AR of 7353 #'ActionRequest'{contextId = 1 = Cid, 7354 commandRequests = [CR]} -> 7355 #'CommandRequest'{command = Cmd} = CR, 7356 {notifyReq, NR} = Cmd, 7357 #'NotifyRequest'{terminationID = [Tid], 7358 observedEventsDescriptor = OED, 7359 errorDescriptor = asn1_NOVALUE} = NR, 7360 #'ObservedEventsDescriptor'{observedEventLst = [OE]} = OED, 7361 #'ObservedEvent'{eventName = "al/of"} = OE, 7362 HandleAck = {handle_sloppy_ack, kalle}, 7363 Reply = {HandleAck, 7364 [mtraaar_mgc_notify_reply_ar(Cid, Tid)]}, 7365 {ok, AR, Reply}; 7366 #'ActionRequest'{contextId = 2 = Cid, 7367 commandRequests = [CR]} -> 7368 #'CommandRequest'{command = Cmd} = CR, 7369 {notifyReq, NR} = Cmd, 7370 #'NotifyRequest'{terminationID = [Tid], 7371 observedEventsDescriptor = OED, 7372 errorDescriptor = asn1_NOVALUE} = NR, 7373 #'ObservedEventsDescriptor'{observedEventLst = [OE]} = OED, 7374 #'ObservedEvent'{eventName = "al/of"} = OE, 7375 Reply = {discard_ack, [mtraaar_mgc_notify_reply_ar(Cid, Tid)]}, 7376 {ok, AR, Reply}; 7377 _ -> 7378 ED = mtraaar_err_desc(AR), 7379 ErrReply = {discard_ack, ED}, 7380 {error, AR, ErrReply} 7381 end; 7382mtraaar_mgc_verify_notify_request(N, Else) -> 7383 io:format("mtraaar_mgc_verify_notify_request -> [~w] unknown" 7384 "~n Else: ~p~n", [N, Else]), 7385 ED = mtraaar_err_desc(Else), 7386 ErrReply = {discard_ack, ED}, 7387 {error, Else, ErrReply}. 7388 7389mtraaar_mgc_verify_notify_reply(N, 7390 {handle_trans_reply, _CH, ?VERSION, 7391 {ok, [AR]}, _}) -> 7392 io:format("mtraaar_mgc_verify_notify_reply -> [~w] ok" 7393 "~n AR: ~p~n", [N, AR]), 7394 {ok, AR, ok}; 7395mtraaar_mgc_verify_notify_reply(N, 7396 {handle_trans_reply, CH, ?VERSION, 7397 UnknownResult, _}) -> 7398 io:format("mtraaar_mgc_verify_notify_reply -> [~w] unknown result" 7399 "~n UnknownResult: ~p~n", [N, UnknownResult]), 7400 {error, {unknown_reply_result, UnknownResult, CH}, ok}; 7401mtraaar_mgc_verify_notify_reply(N, Else) -> 7402 io:format("mtraaar_mgc_verify_notify_reply -> [~w] unknown" 7403 "~n Else: ~p~n", [N, Else]), 7404 {error, {unknown_reply, Else}, ok}. 7405 7406mtraaar_mgc_verify_ack({handle_trans_ack, CH, ?VERSION, ok, kalle}) -> 7407 io:format("mtraaar_mgc_verify_ack -> ok" 7408 "~n CH: ~p" 7409 "~n", [CH]), 7410 {ok, CH, ok}; 7411mtraaar_mgc_verify_ack(Else) -> 7412 io:format("mtraaar_mgc_verify_ack -> unknown" 7413 "~n Else: ~p~n", [Else]), 7414 {error, Else, ok}. 7415 7416mtraaar_mgc_verify_handle_disconnect({handle_disconnect, CH, ?VERSION, R}) -> 7417 io:format("mtraaar_mgc_verify_handle_disconnect -> ok" 7418 "~n CH: ~p" 7419 "~n R: ~p" 7420 "~n", [CH, R]), 7421 {ok, CH, ok}; 7422mtraaar_mgc_verify_handle_disconnect(Else) -> 7423 io:format("mtraaar_mgc_verify_handle_disconnect -> unknown" 7424 "~n Else: ~p~n", [Else]), 7425 {error, Else, ok}. 7426 7427 7428mtraaar_mgc_service_change_reply_ar(Mid, Cid) -> 7429 SCRP = cre_serviceChangeResParm(Mid), 7430 SCRes = cre_serviceChangeResult(SCRP), 7431 Root = #megaco_term_id{id = ["root"]}, 7432 SCR = cre_serviceChangeReply([Root], SCRes), 7433 CR = cre_cmdReply(SCR), 7434 cre_actionReply(Cid, [CR]). 7435 7436%% mtraaar_mgc_service_change_reply_msg(Mid, TransId, Cid) -> 7437%% AR = mtraaar_mgc_service_change_reply_ar(Mid, Cid), 7438%% TRes = cre_transResult([AR]), 7439%% TR = cre_transReply(TransId, TRes), 7440%% Trans = cre_transaction(TR), 7441%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 7442%% cre_megacoMessage(Mess). 7443 7444mtraaar_mgc_notify_request_ar(Rid, Tid, Cid) -> 7445 TT = cre_timeNotation("19990729", "44000000"), 7446 Ev = cre_obsEvent("al/of", TT), 7447 EvsDesc = cre_obsEvsDesc(Rid, [Ev]), 7448 NR = cre_notifyReq([Tid], EvsDesc), 7449 CMD = cre_command(NR), 7450 CR = cre_cmdReq(CMD), 7451 cre_actionReq(Cid, [CR]). 7452 7453mtraaar_mgc_notify_reply_ar(Cid, TermId) -> 7454 NR = cre_notifyReply([TermId]), 7455 CR = cre_cmdReply(NR), 7456 cre_actionReply(Cid, [CR]). 7457 7458%% mtraaar_mgc_notify_reply(Mid, TransId, Cid, TermId) -> 7459%% AR = mtraaar_mgc_notify_reply_ar(Cid, TermId), 7460%% TRes = cre_transResult([AR]), 7461%% TR = cre_transReply(TransId, TRes), 7462%% Trans = cre_transaction(TR), 7463%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 7464%% cre_megacoMessage(Mess). 7465 7466 7467%% 7468%% MG generator stuff 7469%% 7470-ifdef(megaco_hipe_special). 7471-define(mtraaar_mg_verify_handle_connect_fun(), 7472 {?MODULE, mtraaar_mg_verify_handle_connect, []}). 7473-define(mtraaar_mg_verify_service_change_reply_fun(), 7474 {?MODULE, mtraaar_mg_verify_service_change_reply, []}). 7475-define(mtraaar_mg_verify_notify_req_fun(), 7476 {?MODULE, mtraaar_mgc_verify_notify_request, []}). 7477-define(mtraaar_mg_verify_notify_reply_fun(), 7478 {?MODULE, mtraaar_mg_verify_notify_reply, []}). 7479-else. 7480-define(mtraaar_mg_verify_handle_connect_fun(), 7481 fun mtraaar_mg_verify_handle_connect/1). 7482-define(mtraaar_mg_verify_service_change_reply_fun(), 7483 fun mtraaar_mg_verify_service_change_reply/1). 7484-define(mtraaar_mg_verify_notify_req_fun(N), 7485 %% We reuse the mgc code... 7486 fun(Request) -> 7487 mtraaar_mgc_verify_notify_request(N, Request) 7488 end). 7489-define(mtraaar_mg_verify_notify_reply_fun(N), 7490 fun(Reply) -> 7491 mtraaar_mg_verify_notify_reply(N, Reply) 7492 end). 7493-endif. 7494 7495mtraaar_mg_event_sequence(text, tcp) -> 7496 Mid = {deviceName,"mg"}, 7497 RI = [ 7498 {port, 2944}, 7499 {encoding_module, megaco_pretty_text_encoder}, 7500 {encoding_config, []}, 7501 {transport_module, megaco_tcp} 7502 ], 7503 ServiceChangeReq = [mtraaar_mg_service_change_request_ar(Mid, 1)], 7504 Tid = #megaco_term_id{id = ["00000000","00000000","01101101"]}, 7505 SNR = fun(Cid, Rid) -> 7506 [mtraaar_mg_notify_request_ar(Rid, Tid, Cid)] 7507 end, 7508 ConnectVerify = ?mtraaar_mg_verify_handle_connect_fun(), 7509 ServiceChangeReplyVerify = ?mtraaar_mg_verify_service_change_reply_fun(), 7510 %% NotifyReqVerify = ?mtraaar_mg_verify_notify_req_fun(), 7511 NReqV = 7512 fun(N) -> 7513 ?mtraaar_mg_verify_notify_req_fun(N) 7514 end, 7515 %% NotifyReplyVerify = ?mtraaar_mg_verify_notify_reply_fun(), 7516 NRepV = 7517 fun(N) -> 7518 ?mtraaar_mg_verify_notify_reply_fun(N) 7519 end, 7520 EvSeq = [ 7521 {debug, true}, 7522 megaco_start, 7523 {megaco_start_user, Mid, RI, []}, 7524 start_transport, 7525 %% {megaco_trace, max}, 7526 {megaco_trace, disable}, 7527 {megaco_system_info, users}, 7528 {megaco_system_info, connections}, 7529 connect, 7530 {megaco_callback, handle_connect, ConnectVerify}, 7531 megaco_connect, 7532 {megaco_cast, ServiceChangeReq, []}, 7533 {megaco_callback, handle_connect, ConnectVerify}, 7534 {megaco_callback, handle_trans_reply, ServiceChangeReplyVerify}, 7535 {sleep, 1000}, 7536 {megaco_system_info, users}, 7537 {megaco_system_info, connections}, 7538 {sleep, 1000}, 7539 {megaco_update_conn_info, auto_ack, true}, 7540 {megaco_update_conn_info, trans_ack_maxcount, 10}, 7541 {megaco_update_conn_info, trans_req_maxcount, 10}, 7542 {megaco_update_conn_info, trans_timer, 1000}, 7543 {megaco_update_conn_info, trans_ack, true}, 7544 {megaco_update_conn_info, trans_req, true}, 7545 {megaco_conn_info, all}, 7546 {megaco_cast, SNR(1,1), []}, 7547 {sleep, 100}, 7548 {megaco_cast, SNR(1,2), []}, 7549 {sleep, 100}, 7550 {megaco_cast, SNR(1,3), []}, 7551 {megaco_callback, handle_trans_reply, NRepV(1)}, 7552 {megaco_callback, handle_trans_reply, NRepV(2)}, 7553 {megaco_callback, handle_trans_reply, NRepV(3)}, 7554 {megaco_update_conn_info, trans_timer, 120000}, 7555 {megaco_cast, SNR(2,1), []}, 7556 {sleep, 100}, 7557 {megaco_cast, SNR(2,2), []}, 7558 {sleep, 100}, 7559 {megaco_cast, SNR(2,3), []}, 7560 {megaco_callback, handle_trans_request, NReqV(1)}, 7561 {megaco_callback, handle_trans_reply, NRepV(4)}, 7562 {megaco_callback, handle_trans_reply, NRepV(5)}, 7563 {megaco_callback, handle_trans_reply, NRepV(6)}, 7564 {sleep, 3000}, 7565 megaco_stop_user, 7566 megaco_stop, 7567 {sleep, 1000} 7568 ], 7569 EvSeq. 7570 7571mtraaar_mg_verify_handle_connect({handle_connect, CH, ?VERSION}) -> 7572 io:format("mtraaar_mg_verify_handle_connect -> ok" 7573 "~n CH: ~p~n", [CH]), 7574 {ok, CH, ok}; 7575mtraaar_mg_verify_handle_connect(Else) -> 7576 io:format("mtraaar_mg_verify_handle_connect -> unknown" 7577 "~n Else: ~p~n", [Else]), 7578 {error, Else, ok}. 7579 7580mtraaar_mg_verify_service_change_reply({handle_trans_reply, _CH, ?VERSION, 7581 {ok, [AR]}, _}) -> 7582 io:format("mtraaar_mg_verify_service_change_reply -> ok" 7583 "~n AR: ~p~n", [AR]), 7584 case AR of 7585 #'ActionReply'{commandReply = [SCR]} -> 7586 case SCR of 7587 {serviceChangeReply, 7588 #'ServiceChangeReply'{terminationID = [Tid], 7589 serviceChangeResult = Res}} -> 7590 case Tid of 7591 #megaco_term_id{contains_wildcards = false, 7592 id = ["root"]} -> 7593 case Res of 7594 {serviceChangeResParms, 7595 #'ServiceChangeResParm'{ 7596 serviceChangeMgcId = _RemoteMid}} -> 7597 {ok, AR, ok}; 7598 {Tag, Val} -> 7599 Err = {invalid_service_change_result, 7600 Tag, Val}, 7601 {error, Err, ok} 7602 end; 7603 _ -> 7604 Err = {invalid_termination_id, Tid}, 7605 {error, Err, ok} 7606 end; 7607 {Tag, Val} -> 7608 Err = {invalid_command_reply, Tag, Val}, 7609 {error, Err, ok} 7610 end; 7611 _ -> 7612 Err = {invalid_action_reply, AR}, 7613 {error, Err, ok} 7614 end; 7615mtraaar_mg_verify_service_change_reply(Else) -> 7616 io:format("mtraaar_mg_verify_service_change_reply -> unknown" 7617 "~n Else: ~p~n", [Else]), 7618 {error, Else, ok}. 7619 7620mtraaar_mg_verify_notify_reply(N, 7621 {handle_trans_reply, 7622 _CH, 7623 ?VERSION, 7624 {ok, [AR]}, 7625 _}) -> 7626 io:format("mtraaar_mg_verify_notify_reply -> [~w] ok" 7627 "~n AR: ~p~n", [N, AR]), 7628 {ok, AR, ok}; 7629mtraaar_mg_verify_notify_reply(N, 7630 {handle_trans_reply, 7631 _CH, 7632 ?VERSION, 7633 ERROR, 7634 _}) -> 7635 io:format("mtraaar_mg_verify_notify_reply -> [~w] reply error" 7636 "~n ERROR: ~p~n", [N, ERROR]), 7637 {error, ERROR, ok}; 7638mtraaar_mg_verify_notify_reply(N, 7639 Else) when is_tuple(Else) -> 7640 io:format("mtraaar_mg_verify_notify_reply -> [~w] ~w instead of ~w" 7641 "~n Else: ~p" 7642 "~n", [N, element(1, Else), handle_trans_reply, Else]), 7643 {error, Else, ok}; 7644mtraaar_mg_verify_notify_reply(N, 7645 Else) -> 7646 io:format("mtraaar_mg_verify_notify_reply -> [~w] unknown" 7647 "~n Else: ~p~n", [N, Else]), 7648 {error, Else, ok}. 7649 7650mtraaar_mg_service_change_request_ar(_Mid, Cid) -> 7651 Prof = cre_serviceChangeProf("resgw", 1), 7652 SCP = cre_serviceChangeParm(restart, ["901 mg col boot"], Prof), 7653 Root = #megaco_term_id{id = ["root"]}, 7654 SCR = cre_serviceChangeReq([Root], SCP), 7655 CMD = cre_command(SCR), 7656 CR = cre_cmdReq(CMD), 7657 cre_actionReq(Cid, [CR]). 7658 7659mtraaar_mg_notify_request_ar(Rid, Tid, Cid) -> 7660 TT = cre_timeNotation("19990729", "22000000"), 7661 Ev = cre_obsEvent("al/of", TT), 7662 EvsDesc = cre_obsEvsDesc(Rid, [Ev]), 7663 NR = cre_notifyReq([Tid], EvsDesc), 7664 CMD = cre_command(NR), 7665 CR = cre_cmdReq(CMD), 7666 cre_actionReq(Cid, [CR]). 7667 7668%% 7669%% Common functions for the multi_trans_req_timeout test case 7670%% 7671 7672mtraaar_err_desc(T) -> 7673 cre_ErrDesc(T). 7674 7675 7676%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 7677 7678multi_ack_and_reply(suite) -> 7679 []; 7680multi_ack_and_reply(doc) -> 7681 []; 7682multi_ack_and_reply(Config) when is_list(Config) -> 7683 ?SKIP(not_yet_implemented). 7684 7685 7686%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 7687 7688otp_7192_1(suite) -> 7689 []; 7690otp_7192_1(doc) -> 7691 [""]; 7692otp_7192_1(Config) when is_list(Config) -> 7693 Pre = fun() -> 7694 MgcNode = make_node_name(mgc), 7695 MgNode = make_node_name(mg), 7696 d("start nodes: " 7697 "~n MGC Node: ~p" 7698 "~n MG Node: ~p", 7699 [MgcNode, MgNode]), 7700 Nodes = [MgcNode, MgNode], 7701 ok = ?START_NODES(Nodes), 7702 Nodes 7703 end, 7704 Case = fun do_otp_7192_1/1, 7705 Post = fun(Nodes) -> 7706 d("stop nodes"), 7707 ?STOP_NODES(lists:reverse(Nodes)) 7708 end, 7709 try_tc(otp_7192_1, Pre, Case, Post). 7710 7711do_otp_7192_1([MgcNode, MgNode]) -> 7712 MgMid = {deviceName,"mg"}, 7713 7714 d("[MGC] start the simulator "), 7715 {ok, Mgc} = megaco_test_megaco_generator:start_link("MGC", MgcNode), 7716 7717 d("[MGC] create the event sequence"), 7718 MgcEvSeq = otp71921_mgc_event_sequence(text, tcp, MgMid), 7719 7720 i("wait some time before starting the MGC simulation"), 7721 sleep(1000), 7722 7723 d("[MGC] start the simulation"), 7724 {ok, MgcId} = megaco_test_megaco_generator:exec(Mgc, MgcEvSeq), 7725 7726 i("wait some time before starting the MG simulator"), 7727 sleep(1000), 7728 7729 d("[MG] start the simulator (generator)"), 7730 {ok, Mg} = megaco_test_megaco_generator:start_link("MG", MgNode), 7731 7732 d("[MG] create the event sequence"), 7733 MgEvSeq = otp71921_mg_event_sequence(text, tcp, MgMid), 7734 7735 i("wait some time before starting the MG simulation"), 7736 sleep(1000), 7737 7738 d("[MG] start the simulation"), 7739 {ok, MgId} = megaco_test_megaco_generator:exec(Mg, MgEvSeq), 7740 7741 d("await the generator(s) completion"), 7742 await_completion([MgcId, MgId], 30000), 7743 7744 %% Tell Mgc to stop 7745 i("[MGC] stop generator"), 7746 megaco_test_megaco_generator:stop(Mgc), 7747 7748 %% Tell Mg to stop 7749 i("[MG] stop generator"), 7750 megaco_test_megaco_generator:stop(Mg), 7751 7752 i("done", []), 7753 ok. 7754 7755 7756%% 7757%% MGC generator stuff 7758%% 7759-ifdef(megaco_hipe_special). 7760-define(otp71921_mgc_verify_handle_connect_fun(), 7761 {?MODULE, otp71921_mgc_verify_handle_connect, []}). 7762-define(otp71921_mgc_verify_service_change_req_fun(Mid), 7763 {?MODULE, otp71921_mgc_verify_service_change_req, [Mid]}). 7764-define(otp71921_mgc_verify_notify_req_fun(), 7765 {?MODULE, otp71921_mgc_verify_notify_request, []}). 7766-define(otp71921_mgc_verify_notify_reply_fun(), 7767 {?MODULE, otp71921_mgc_verify_notify_reply, []}). 7768-define(otp71921_mgc_verify_ack_fun(), 7769 {?MODULE, otp71921_mgc_verify_ack, []}). 7770-define(otp71921_mgc_verify_handle_disconnect_fun(), 7771 {?MODULE, otp71921_mgc_verify_handle_disconnect, []}). 7772-else. 7773-define(otp71921_mgc_verify_handle_connect_fun(), 7774 fun otp71921_mgc_verify_handle_connect/1). 7775-define(otp71921_mgc_verify_service_change_req_fun(Mid), 7776 otp71921_mgc_verify_service_change_req_fun(Mid)). 7777-define(otp71921_mgc_verify_notify_req_fun(), 7778 otp71921_mgc_verify_notify_request_fun()). 7779-define(otp71921_mgc_verify_notify_reply_fun(), 7780 fun otp71921_mgc_verify_notify_reply/1). 7781-define(otp71921_mgc_verify_ack_fun(), 7782 fun otp71921_mgc_verify_ack/1). 7783-define(otp71921_mgc_verify_handle_disconnect_fun(), 7784 fun otp71921_mgc_verify_handle_disconnect/1). 7785-endif. 7786 7787otp71921_mgc_event_sequence(text, tcp, MgMid) -> 7788 CTRL = self(), 7789 Mid = {deviceName, "ctrl"}, 7790 RI = [ 7791 {port, 2944}, 7792 {encoding_module, megaco_pretty_text_encoder}, 7793 {encoding_config, []}, 7794 {transport_module, megaco_tcp} 7795 ], 7796 Tid = #megaco_term_id{id = ["00000000","00000000","01101101"]}, 7797 NR = fun(Cid, Rid) -> 7798 [otp71921_mgc_notify_request_ar(Rid, Tid, Cid)] 7799 end, 7800 LocalConnectVerify = ?otp71921_mgc_verify_handle_connect_fun(), 7801 ServiceChangeReqVerify = ?otp71921_mgc_verify_service_change_req_fun(Mid), 7802 NotifyReqVerify = ?otp71921_mgc_verify_notify_req_fun(), 7803 NotifyReplyVerify = ?otp71921_mgc_verify_notify_reply_fun(), 7804 AckVerify = ?otp71921_mgc_verify_ack_fun(), 7805 DiscoVerify = ?otp71921_mgc_verify_handle_disconnect_fun(), 7806 EvSeq = [ 7807 {debug, true}, 7808 %% {megaco_trace, max}, 7809 {megaco_trace, disable}, 7810 megaco_start, 7811 {megaco_start_user, Mid, RI, []}, 7812 start_transport, 7813 listen, 7814 7815 %% ANNOUNCE READY 7816 {trigger, fun() -> CTRL ! announce_mgc end}, 7817 7818 {megaco_connect, MgMid}, 7819 {megaco_callback, handle_connect, LocalConnectVerify}, 7820 %% {megaco_callback, handle_connect, RemoteConnectVerify}, 7821 {megaco_callback, handle_trans_request, ServiceChangeReqVerify}, 7822 {megaco_callback, handle_trans_request, NotifyReqVerify}, 7823 {megaco_callback, handle_trans_request, NotifyReqVerify}, 7824 {megaco_callback, handle_trans_request, NotifyReqVerify}, 7825 {megaco_update_conn_info, request_timer, 1000}, 7826 {megaco_cast, NR(1,1), []}, 7827 7828 {megaco_callback, [{handle_trans_ack, 3, AckVerify}, 7829 {handle_trans_request, 3, NotifyReqVerify}, 7830 {handle_trans_reply, 1, NotifyReplyVerify}]}, 7831 {megaco_callback, handle_disconnect, DiscoVerify}, 7832 {sleep, 1000}, 7833 megaco_stop_user, 7834 megaco_stop 7835 ], 7836 EvSeq. 7837 7838 7839otp71921_mgc_verify_handle_connect({handle_connect, CH, ?VERSION}) -> 7840 io:format("otp71921_mgc_verify_handle_connect -> ok" 7841 "~n CH: ~p~n", [CH]), 7842 {ok, CH, ok}; 7843otp71921_mgc_verify_handle_connect(Else) -> 7844 io:format("otp71921_mgc_verify_handle_connect -> unknown" 7845 "~n Else: ~p~n", [Else]), 7846 {error, Else, ok}. 7847 7848otp71921_mgc_verify_service_change_req_fun(Mid) -> 7849 fun(Ev) -> 7850 otp71921_mgc_verify_service_change_req(Ev, Mid) 7851 end. 7852 7853otp71921_mgc_verify_service_change_req( 7854 {handle_trans_request, _, ?VERSION, [AR]}, Mid) -> 7855 io:format("otp71921_mgc_verify_service_change_req -> ok" 7856 "~n AR: ~p~n", [AR]), 7857 case AR of 7858 #'ActionRequest'{commandRequests = [CR]} -> 7859 case CR of 7860 #'CommandRequest'{command = Cmd} -> 7861 case Cmd of 7862 {serviceChangeReq, 7863 #'ServiceChangeRequest'{terminationID = [Tid], 7864 serviceChangeParms = Parms}} -> 7865 case Tid of 7866 #megaco_term_id{contains_wildcards = false, 7867 id = ["root"]} -> 7868 case Parms of 7869 #'ServiceChangeParm'{ 7870 serviceChangeMethod = restart, 7871 serviceChangeReason = [[$9,$0,$1|_]]} -> 7872 Reply = 7873 {discard_ack, 7874 [otp71921_mgc_service_change_reply_ar(Mid, 1)]}, 7875 {ok, AR, Reply}; 7876 _ -> 7877 Err = {invalid_SCP, Parms}, 7878 ED = otp71921_err_desc(Parms), 7879 ErrReply = {discard_ack, 7880 ED}, 7881 {error, Err, ErrReply} 7882 end; 7883 _ -> 7884 Err = {invalid_termination_id, Tid}, 7885 ED = otp71921_err_desc(Tid), 7886 ErrReply = {discard_ack, ED}, 7887 {error, Err, ErrReply} 7888 end; 7889 _ -> 7890 Err = {invalid_command, Cmd}, 7891 ED = otp71921_err_desc(Cmd), 7892 ErrReply = {discard_ack, ED}, 7893 {error, Err, ErrReply} 7894 end; 7895 _ -> 7896 Err = {invalid_command_request, CR}, 7897 ED = otp71921_err_desc(CR), 7898 ErrReply = {discard_ack, ED}, 7899 {error, Err, ErrReply} 7900 end; 7901 _ -> 7902 Err = {invalid_action_request, AR}, 7903 ED = otp71921_err_desc(AR), 7904 ErrReply = {discard_ack, ED}, 7905 {error, Err, ErrReply} 7906 end; 7907otp71921_mgc_verify_service_change_req(Else, _Mid) -> 7908 io:format("otp71921_mgc_verify_service_change_req -> unknown" 7909 "~n Else: ~p~n", [Else]), 7910 ED = otp71921_err_desc(Else), 7911 ErrReply = {discard_ack, ED}, 7912 {error, Else, ErrReply}. 7913 7914otp71921_mgc_verify_notify_request_fun() -> 7915 fun(Ev) -> 7916 otp71921_mgc_verify_notify_request(Ev) 7917 end. 7918 7919otp71921_mgc_verify_notify_request( 7920 {handle_trans_request, _, ?VERSION, [AR]}) -> 7921 io:format("otp71921_mgc_verify_notify_request -> ok" 7922 "~n AR: ~p~n", [AR]), 7923 case AR of 7924 #'ActionRequest'{contextId = 1 = Cid, 7925 commandRequests = [CR]} -> 7926 #'CommandRequest'{command = Cmd} = CR, 7927 {notifyReq, NR} = Cmd, 7928 #'NotifyRequest'{terminationID = [Tid], 7929 observedEventsDescriptor = OED, 7930 errorDescriptor = asn1_NOVALUE} = NR, 7931 #'ObservedEventsDescriptor'{observedEventLst = [OE]} = OED, 7932 #'ObservedEvent'{eventName = "al/of"} = OE, 7933 HandleAck = {handle_sloppy_ack, kalle}, 7934 Reply = {HandleAck, 7935 [otp71921_mgc_notify_reply_ar(Cid, Tid)]}, 7936 {ok, AR, Reply}; 7937 #'ActionRequest'{contextId = 2 = Cid, 7938 commandRequests = [CR]} -> 7939 #'CommandRequest'{command = Cmd} = CR, 7940 {notifyReq, NR} = Cmd, 7941 #'NotifyRequest'{terminationID = [Tid], 7942 observedEventsDescriptor = OED, 7943 errorDescriptor = asn1_NOVALUE} = NR, 7944 #'ObservedEventsDescriptor'{observedEventLst = [OE]} = OED, 7945 #'ObservedEvent'{eventName = "al/of"} = OE, 7946 Reply = {discard_ack, [otp71921_mgc_notify_reply_ar(Cid, Tid)]}, 7947 {ok, AR, Reply}; 7948 _ -> 7949 ED = otp71921_err_desc(AR), 7950 ErrReply = {discard_ack, ED}, 7951 {error, AR, ErrReply} 7952 end; 7953otp71921_mgc_verify_notify_request(Else) -> 7954 io:format("otp71921_mgc_verify_notify_request -> unknown" 7955 "~n Else: ~p~n", [Else]), 7956 ED = otp71921_err_desc(Else), 7957 ErrReply = {discard_ack, ED}, 7958 {error, Else, ErrReply}. 7959 7960otp71921_mgc_verify_notify_reply({handle_trans_reply, _CH, ?VERSION, 7961 {ok, [AR]}, _}) -> 7962 io:format("otp71921_mgc_verify_notify_reply -> ok" 7963 "~n AR: ~p~n", [AR]), 7964 {ok, AR, ok}; 7965otp71921_mgc_verify_notify_reply({handle_trans_reply, CH, ?VERSION, 7966 UnknownResult, _}) -> 7967 io:format("otp71921_mgc_verify_notify_reply -> unknown result" 7968 "~n UnknownResult: ~p~n", [UnknownResult]), 7969 {error, {unknown_reply_result, UnknownResult, CH}, ok}; 7970otp71921_mgc_verify_notify_reply(Else) -> 7971 io:format("otp71921_mgc_verify_notify_reply -> unknown" 7972 "~n Else: ~p~n", [Else]), 7973 {error, {unknown_reply, Else}, ok}. 7974 7975otp71921_mgc_verify_ack({handle_trans_ack, CH, ?VERSION, ok, kalle}) -> 7976 io:format("otp71921_mgc_verify_ack -> ok" 7977 "~n CH: ~p" 7978 "~n", [CH]), 7979 {ok, CH, ok}; 7980otp71921_mgc_verify_ack(Else) -> 7981 io:format("otp71921_mgc_verify_ack -> unknown" 7982 "~n Else: ~p~n", [Else]), 7983 {error, Else, ok}. 7984 7985otp71921_mgc_verify_handle_disconnect({handle_disconnect, CH, ?VERSION, R}) -> 7986 io:format("otp71921_mgc_verify_handle_disconnect -> ok" 7987 "~n CH: ~p" 7988 "~n R: ~p" 7989 "~n", [CH, R]), 7990 {ok, CH, ok}; 7991otp71921_mgc_verify_handle_disconnect(Else) -> 7992 io:format("otp71921_mgc_verify_handle_disconnect -> unknown" 7993 "~n Else: ~p~n", [Else]), 7994 {error, Else, ok}. 7995 7996 7997otp71921_mgc_service_change_reply_ar(Mid, Cid) -> 7998 SCRP = cre_serviceChangeResParm(Mid), 7999 SCRes = cre_serviceChangeResult(SCRP), 8000 Root = #megaco_term_id{id = ["root"]}, 8001 SCR = cre_serviceChangeReply([Root], SCRes), 8002 CR = cre_cmdReply(SCR), 8003 cre_actionReply(Cid, [CR]). 8004 8005%% otp71921_mgc_service_change_reply_msg(Mid, TransId, Cid) -> 8006%% AR = otp71921_mgc_service_change_reply_ar(Mid, Cid), 8007%% TRes = cre_transResult([AR]), 8008%% TR = cre_transReply(TransId, TRes), 8009%% Trans = cre_transaction(TR), 8010%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 8011%% cre_megacoMessage(Mess). 8012 8013otp71921_mgc_notify_request_ar(Rid, Tid, Cid) -> 8014 TT = cre_timeNotation("19990729", "44000000"), 8015 Ev = cre_obsEvent("al/of", TT), 8016 EvsDesc = cre_obsEvsDesc(Rid, [Ev]), 8017 NR = cre_notifyReq([Tid], EvsDesc), 8018 CMD = cre_command(NR), 8019 CR = cre_cmdReq(CMD), 8020 cre_actionReq(Cid, [CR]). 8021 8022otp71921_mgc_notify_reply_ar(Cid, TermId) -> 8023 NR = cre_notifyReply([TermId]), 8024 CR = cre_cmdReply(NR), 8025 cre_actionReply(Cid, [CR]). 8026 8027%% otp71921_mgc_notify_reply(Mid, TransId, Cid, TermId) -> 8028%% AR = otp71921_mgc_notify_reply_ar(Cid, TermId), 8029%% TRes = cre_transResult([AR]), 8030%% TR = cre_transReply(TransId, TRes), 8031%% Trans = cre_transaction(TR), 8032%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 8033%% cre_megacoMessage(Mess). 8034 8035 8036%% 8037%% MG generator stuff 8038%% 8039-ifdef(megaco_hipe_special). 8040-define(otp71921_mg_verify_handle_connect_fun(), 8041 {?MODULE, otp71921_mg_verify_handle_connect, []}). 8042-define(otp71921_mg_verify_service_change_reply_fun(), 8043 {?MODULE, otp71921_mg_verify_service_change_reply, []}). 8044-define(otp71921_mg_verify_notify_req_fun(), 8045 {?MODULE, otp71921_mgc_verify_notify_request, []}). 8046-define(otp71921_mg_verify_notify_reply_fun(), 8047 {?MODULE, otp71921_mg_verify_notify_reply, []}). 8048-else. 8049-define(otp71921_mg_verify_handle_connect_fun(), 8050 fun otp71921_mg_verify_handle_connect/1). 8051-define(otp71921_mg_verify_service_change_reply_fun(), 8052 fun otp71921_mg_verify_service_change_reply/1). 8053-define(otp71921_mg_verify_notify_req_fun(), 8054 otp71921_mgc_verify_notify_request_fun()). 8055-define(otp71921_mg_verify_notify_reply_fun(), 8056 fun otp71921_mg_verify_notify_reply/1). 8057-endif. 8058 8059otp71921_mg_event_sequence(text, tcp, Mid) -> 8060 RI = [ 8061 {port, 2944}, 8062 {encoding_module, megaco_pretty_text_encoder}, 8063 {encoding_config, []}, 8064 {transport_module, megaco_tcp} 8065 ], 8066 ServiceChangeReq = [otp71921_mg_service_change_request_ar(Mid, 1)], 8067 Tid = #megaco_term_id{id = ["00000000","00000000","01101101"]}, 8068 NR = fun(Cid, Rid) -> 8069 [otp71921_mg_notify_request_ar(Rid, Tid, Cid)] 8070 end, 8071 ConnectVerify = ?otp71921_mg_verify_handle_connect_fun(), 8072 ServiceChangeReplyVerify = ?otp71921_mg_verify_service_change_reply_fun(), 8073 NotifyReqVerify = ?otp71921_mg_verify_notify_req_fun(), 8074 NotifyReplyVerify = ?otp71921_mg_verify_notify_reply_fun(), 8075 EvSeq = [ 8076 {debug, true}, 8077 megaco_start, 8078 {megaco_start_user, Mid, RI, []}, 8079 start_transport, 8080 %% {megaco_trace, max}, 8081 {megaco_trace, disable}, 8082 {megaco_system_info, users}, 8083 {megaco_system_info, connections}, 8084 connect, 8085 {megaco_callback, handle_connect, ConnectVerify}, 8086 megaco_connect, 8087 {megaco_cast, ServiceChangeReq, []}, 8088 {megaco_callback, handle_connect, ConnectVerify}, 8089 {megaco_callback, handle_trans_reply, ServiceChangeReplyVerify}, 8090 {sleep, 1000}, 8091 {megaco_system_info, users}, 8092 {megaco_system_info, connections}, 8093 {sleep, 1000}, 8094 {megaco_update_conn_info, auto_ack, true}, 8095 {megaco_update_conn_info, trans_ack_maxcount, 10}, 8096 {megaco_update_conn_info, trans_req_maxcount, 10}, 8097 {megaco_update_conn_info, trans_timer, 1000}, 8098 {megaco_update_conn_info, trans_ack, true}, 8099 {megaco_update_conn_info, trans_req, true}, 8100 {megaco_conn_info, all}, 8101 {megaco_cast, NR(1,1), []}, 8102 {megaco_cast, NR(1,2), []}, 8103 {megaco_cast, NR(1,3), []}, 8104 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 8105 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 8106 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 8107 {megaco_update_conn_info, trans_timer, 120000}, 8108 {megaco_cast, NR(2,1), []}, 8109 {megaco_cast, NR(2,2), []}, 8110 {megaco_cast, NR(2,3), []}, 8111 {megaco_callback, handle_trans_request, NotifyReqVerify}, 8112 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 8113 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 8114 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 8115 {sleep, 3000}, 8116 megaco_stop_user, 8117 megaco_stop, 8118 {sleep, 1000} 8119 ], 8120 EvSeq. 8121 8122otp71921_mg_verify_handle_connect({handle_connect, CH, ?VERSION}) -> 8123 io:format("otp71921_mg_verify_handle_connect -> ok" 8124 "~n CH: ~p~n", [CH]), 8125 {ok, CH, ok}; 8126otp71921_mg_verify_handle_connect(Else) -> 8127 io:format("otp71921_mg_verify_handle_connect -> unknown" 8128 "~n Else: ~p~n", [Else]), 8129 {error, Else, ok}. 8130 8131otp71921_mg_verify_service_change_reply({handle_trans_reply, _CH, ?VERSION, 8132 {ok, [AR]}, _}) -> 8133 io:format("otp71921_mg_verify_service_change_reply -> ok" 8134 "~n AR: ~p~n", [AR]), 8135 case AR of 8136 #'ActionReply'{commandReply = [SCR]} -> 8137 case SCR of 8138 {serviceChangeReply, 8139 #'ServiceChangeReply'{terminationID = [Tid], 8140 serviceChangeResult = Res}} -> 8141 case Tid of 8142 #megaco_term_id{contains_wildcards = false, 8143 id = ["root"]} -> 8144 case Res of 8145 {serviceChangeResParms, 8146 #'ServiceChangeResParm'{ 8147 serviceChangeMgcId = _RemoteMid}} -> 8148 {ok, AR, ok}; 8149 {Tag, Val} -> 8150 Err = {invalid_service_change_result, 8151 Tag, Val}, 8152 {error, Err, ok} 8153 end; 8154 _ -> 8155 Err = {invalid_termination_id, Tid}, 8156 {error, Err, ok} 8157 end; 8158 {Tag, Val} -> 8159 Err = {invalid_command_reply, Tag, Val}, 8160 {error, Err, ok} 8161 end; 8162 _ -> 8163 Err = {invalid_action_reply, AR}, 8164 {error, Err, ok} 8165 end; 8166otp71921_mg_verify_service_change_reply(Else) -> 8167 io:format("otp71921_mg_verify_service_change_reply -> unknown" 8168 "~n Else: ~p~n", [Else]), 8169 {error, Else, ok}. 8170 8171%% otp71921_mg_verify_notify_request_fun() -> 8172%% fun(Ev) -> 8173%% otp71921_mg_verify_notify_request(Ev) 8174%% end. 8175 8176%% otp71921_mg_verify_notify_request( 8177%% {handle_trans_request, _, ?VERSION, [AR]}) -> 8178%% io:format("otp71921_mg_verify_notify_request -> ok" 8179%% "~n AR: ~p~n", [AR]), 8180%% case AR of 8181%% #'ActionRequest'{contextId = 1 = Cid, 8182%% commandRequests = [CR]} -> 8183%% #'CommandRequest'{command = Cmd} = CR, 8184%% {notifyReq, NR} = Cmd, 8185%% #'NotifyRequest'{terminationID = [Tid], 8186%% observedEventsDescriptor = OED, 8187%% errorDescriptor = asn1_NOVALUE} = NR, 8188%% #'ObservedEventsDescriptor'{observedEventLst = [OE]} = OED, 8189%% #'ObservedEvent'{eventName = "al/of"} = OE, 8190%% Reply = {discard_ack, [otp71921_mg_notify_reply_ar(Cid, Tid)]}, 8191%% {ok, AR, Reply}; 8192%% _ -> 8193%% ED = otp71921_err_desc(AR), 8194%% ErrReply = {discard_ack, ED}, 8195%% {error, AR, ErrReply} 8196%% end; 8197%% otp71921_mg_verify_notify_request(Else) -> 8198%% io:format("otp71921_mg_verify_notify_request -> unknown" 8199%% "~n Else: ~p~n", [Else]), 8200%% ED = otp71921_err_desc(Else), 8201%% ErrReply = {discard_ack, ED}, 8202%% {error, Else, ErrReply}. 8203 8204otp71921_mg_verify_notify_reply({handle_trans_reply, _CH, ?VERSION, 8205 {ok, [AR]}, _}) -> 8206 io:format("otp71921_mg_verify_notify_reply -> ok" 8207 "~n AR: ~p~n", [AR]), 8208 {ok, AR, ok}; 8209otp71921_mg_verify_notify_reply(Else) -> 8210 io:format("otp71921_mg_verify_notify_reply -> unknown" 8211 "~n Else: ~p~n", [Else]), 8212 {error, Else, ok}. 8213 8214otp71921_mg_service_change_request_ar(_Mid, Cid) -> 8215 Prof = cre_serviceChangeProf("resgw", 1), 8216 SCP = cre_serviceChangeParm(restart, ["901 mg col boot"], Prof), 8217 Root = #megaco_term_id{id = ["root"]}, 8218 SCR = cre_serviceChangeReq([Root], SCP), 8219 CMD = cre_command(SCR), 8220 CR = cre_cmdReq(CMD), 8221 cre_actionReq(Cid, [CR]). 8222 8223%% otp71921_mg_service_change_request_msg(Mid, TransId, Cid) -> 8224%% AR = otp71921_mg_service_change_request_ar(Mid, Cid), 8225%% TR = cre_transReq(TransId, [AR]), 8226%% Trans = cre_transaction(TR), 8227%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 8228%% cre_megacoMessage(Mess). 8229 8230%% otp71921_mg_notify_reply_ar(Cid, TermId) -> 8231%% NR = cre_notifyReply([TermId]), 8232%% CR = cre_cmdReply(NR), 8233%% cre_actionReply(Cid, [CR]). 8234 8235otp71921_mg_notify_request_ar(Rid, Tid, Cid) -> 8236 TT = cre_timeNotation("19990729", "22000000"), 8237 Ev = cre_obsEvent("al/of", TT), 8238 EvsDesc = cre_obsEvsDesc(Rid, [Ev]), 8239 NR = cre_notifyReq([Tid], EvsDesc), 8240 CMD = cre_command(NR), 8241 CR = cre_cmdReq(CMD), 8242 cre_actionReq(Cid, [CR]). 8243 8244%% otp71921_notify_request_msg(Mid, TransId, Rid, TermId, Cid) -> 8245%% AR = otp71921_mg_notify_request_ar(Rid, TermId, Cid), 8246%% TR = cre_transReq(TransId, [AR]), 8247%% Trans = cre_transaction(TR), 8248%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 8249%% cre_megacoMessage(Mess). 8250 8251 8252%% 8253%% Common functions for the multi_trans_req_timeout test case 8254%% 8255 8256otp71921_err_desc(T) -> 8257 EC = ?megaco_internal_gateway_error, 8258 ET = lists:flatten(io_lib:format("~w",[T])), 8259 #'ErrorDescriptor'{errorCode = EC, errorText = ET}. 8260 8261 8262%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 8263 8264otp_7192_2(suite) -> 8265 []; 8266otp_7192_2(doc) -> 8267 []; 8268otp_7192_2(Config) when is_list(Config) -> 8269 Pre = fun() -> 8270 MgcNode = make_node_name(mgc), 8271 MgNode = make_node_name(mg), 8272 d("start nodes: " 8273 "~n MGC Node: ~p" 8274 "~n MG Node: ~p", 8275 [MgcNode, MgNode]), 8276 Nodes = [MgcNode, MgNode], 8277 ok = ?START_NODES(Nodes), 8278 Nodes 8279 end, 8280 Case = fun do_otp_7192_2/1, 8281 Post = fun(Nodes) -> 8282 d("stop nodes"), 8283 ?STOP_NODES(lists:reverse(Nodes)) 8284 end, 8285 try_tc(otp_7192_2, Pre, Case, Post). 8286 8287do_otp_7192_2([MgcNode, MgNode]) -> 8288 8289 MgMid = {deviceName,"mg"}, 8290 8291 d("[MGC] start the simulator "), 8292 {ok, Mgc} = megaco_test_megaco_generator:start_link("MGC", MgcNode), 8293 8294 d("[MGC] create the event sequence"), 8295 MgcEvSeq = otp71922_mgc_event_sequence(text, tcp, MgMid), 8296 8297 i("wait some time before starting the MGC simulation"), 8298 sleep(1000), 8299 8300 d("[MGC] start the simulation"), 8301 {ok, MgcId} = megaco_test_megaco_generator:exec(Mgc, MgcEvSeq), 8302 8303 i("wait some time before starting the MG simulator"), 8304 sleep(1000), 8305 8306 d("[MG] start the simulator (generator)"), 8307 {ok, Mg} = megaco_test_megaco_generator:start_link("MG", MgNode), 8308 8309 d("[MG] create the event sequence"), 8310 MgEvSeq = otp71922_mg_event_sequence(text, tcp, MgMid), 8311 8312 i("wait some time before starting the MG simulation"), 8313 sleep(1000), 8314 8315 d("[MG] start the simulation"), 8316 {ok, MgId} = megaco_test_megaco_generator:exec(Mg, MgEvSeq), 8317 8318 d("await the generator(s) completion"), 8319 await_completion([MgcId, MgId], 30000), 8320 8321 %% Tell Mgc to stop 8322 i("[MGC] stop generator"), 8323 megaco_test_megaco_generator:stop(Mgc), 8324 8325 %% Tell Mg to stop 8326 i("[MG] stop generator"), 8327 megaco_test_megaco_generator:stop(Mg), 8328 8329 i("done", []), 8330 ok. 8331 8332 8333%% 8334%% MGC generator stuff 8335%% 8336-ifdef(megaco_hipe_special). 8337-define(otp71922_mgc_verify_handle_connect_fun(), 8338 {?MODULE, otp71922_mgc_verify_handle_connect, []}). 8339-define(otp71922_mgc_verify_service_change_req_fun(Mid), 8340 {?MODULE, otp71922_mgc_verify_service_change_req, [Mid]}). 8341-define(otp71922_mgc_verify_notify_req_fun(), 8342 {?MODULE, otp71922_mgc_verify_notify_request, []}). 8343-define(otp71922_mgc_verify_notify_reply_fun(), 8344 {?MODULE, otp71922_mgc_verify_notify_reply, []}). 8345-define(otp71922_mgc_verify_ack_fun(), 8346 {?MODULE, otp71922_mgc_verify_ack, []}). 8347-define(otp71922_mgc_verify_handle_disconnect_fun(), 8348 {?MODULE, otp71922_mgc_verify_handle_disconnect, []}). 8349-else. 8350-define(otp71922_mgc_verify_handle_connect_fun(), 8351 fun otp71922_mgc_verify_handle_connect/1). 8352-define(otp71922_mgc_verify_service_change_req_fun(Mid), 8353 otp71922_mgc_verify_service_change_req_fun(Mid)). 8354-define(otp71922_mgc_verify_notify_req_fun(), 8355 otp71922_mgc_verify_notify_request_fun()). 8356-define(otp71922_mgc_verify_notify_reply_fun(), 8357 fun otp71922_mgc_verify_notify_reply/1). 8358-define(otp71922_mgc_verify_ack_fun(), 8359 fun otp71922_mgc_verify_ack/1). 8360-define(otp71922_mgc_verify_handle_disconnect_fun(), 8361 fun otp71922_mgc_verify_handle_disconnect/1). 8362-endif. 8363 8364otp71922_mgc_event_sequence(text, tcp, MgMid) -> 8365 CTRL = self(), 8366 Mid = {deviceName, "ctrl"}, 8367 RI = [ 8368 {port, 2944}, 8369 {encoding_module, megaco_pretty_text_encoder}, 8370 {encoding_config, []}, 8371 {transport_module, megaco_tcp} 8372 ], 8373 Tid = #megaco_term_id{id = ["00000000","00000100","01101101"]}, 8374 NR = fun(Cid, Rid) -> 8375 [otp71922_mgc_notify_request_ar(Rid, Tid, Cid)] 8376 end, 8377 LocalConnectVerify = ?otp71922_mgc_verify_handle_connect_fun(), 8378 ServiceChangeReqVerify = ?otp71922_mgc_verify_service_change_req_fun(Mid), 8379 NotifyReqVerify = ?otp71922_mgc_verify_notify_req_fun(), 8380 NotifyReplyVerify = ?otp71922_mgc_verify_notify_reply_fun(), 8381 AckVerify = ?otp71922_mgc_verify_ack_fun(), 8382 DiscoVerify = ?otp71922_mgc_verify_handle_disconnect_fun(), 8383 EvSeq = [ 8384 {debug, true}, 8385 %% {megaco_trace, max}, 8386 {megaco_trace, disable}, 8387 megaco_start, 8388 {megaco_start_user, Mid, RI, []}, 8389 start_transport, 8390 listen, 8391 8392 %% ANNOUNCE READY 8393 {trigger, fun() -> CTRL ! announce_mgc end}, 8394 8395 {megaco_connect, MgMid}, 8396 {megaco_callback, handle_connect, LocalConnectVerify}, 8397 {megaco_callback, handle_trans_request, ServiceChangeReqVerify}, 8398 {megaco_callback, handle_trans_request, NotifyReqVerify}, 8399 {megaco_callback, handle_trans_request, NotifyReqVerify}, 8400 {megaco_callback, handle_trans_request, NotifyReqVerify}, 8401 {megaco_update_conn_info, request_timer, 1000}, 8402 {megaco_cast, NR(1,1), []}, 8403 8404 {megaco_callback, [{handle_trans_ack, 3, AckVerify}, 8405 {handle_trans_request, 3, NotifyReqVerify}, 8406 {handle_trans_reply, 1, NotifyReplyVerify}]}, 8407 {megaco_callback, handle_disconnect, DiscoVerify}, 8408 {sleep, 1000}, 8409 megaco_stop_user, 8410 megaco_stop 8411 ], 8412 EvSeq. 8413 8414 8415otp71922_mgc_verify_handle_connect({handle_connect, CH, ?VERSION}) -> 8416 i("received expected handle_connect with" 8417 "~n CH: ~p" 8418 "~n => force a 2 second sleep before return", [CH]), 8419 {ok, timer:seconds(2), CH, ok}; 8420otp71922_mgc_verify_handle_connect(Else) -> 8421 e("otp71922_mgc_verify_handle_connect -> invalid handle-connect: " 8422 "~n Extected: handle_connect" 8423 "~n Received: ~p", [Else]), 8424 {error, Else, ok}. 8425 8426otp71922_mgc_verify_service_change_req_fun(Mid) -> 8427 fun(Ev) -> 8428 otp71922_mgc_verify_service_change_req(Ev, Mid) 8429 end. 8430 8431otp71922_mgc_verify_service_change_req( 8432 {handle_trans_request, _, ?VERSION, [AR]}, Mid) -> 8433 i("otp71922_mgc_verify_service_change_req -> ok" 8434 "~n AR: ~p", [AR]), 8435 case AR of 8436 #'ActionRequest'{commandRequests = [CR]} -> 8437 case CR of 8438 #'CommandRequest'{command = Cmd} -> 8439 case Cmd of 8440 {serviceChangeReq, 8441 #'ServiceChangeRequest'{terminationID = [Tid], 8442 serviceChangeParms = Parms}} -> 8443 case Tid of 8444 #megaco_term_id{contains_wildcards = false, 8445 id = ["root"]} -> 8446 case Parms of 8447 #'ServiceChangeParm'{ 8448 serviceChangeMethod = restart, 8449 serviceChangeReason = [[$9,$0,$1|_]]} -> 8450 Reply = 8451 {discard_ack, 8452 [otp71922_mgc_service_change_reply_ar(Mid, 1)]}, 8453 {ok, AR, Reply}; 8454 _ -> 8455 Err = {invalid_SCP, Parms}, 8456 ED = otp71922_err_desc(Parms), 8457 ErrReply = {discard_ack, 8458 ED}, 8459 {error, Err, ErrReply} 8460 end; 8461 _ -> 8462 Err = {invalid_termination_id, Tid}, 8463 ED = otp71922_err_desc(Tid), 8464 ErrReply = {discard_ack, ED}, 8465 {error, Err, ErrReply} 8466 end; 8467 _ -> 8468 Err = {invalid_command, Cmd}, 8469 ED = otp71922_err_desc(Cmd), 8470 ErrReply = {discard_ack, ED}, 8471 {error, Err, ErrReply} 8472 end; 8473 _ -> 8474 Err = {invalid_command_request, CR}, 8475 ED = otp71922_err_desc(CR), 8476 ErrReply = {discard_ack, ED}, 8477 {error, Err, ErrReply} 8478 end; 8479 _ -> 8480 Err = {invalid_action_request, AR}, 8481 ED = otp71922_err_desc(AR), 8482 ErrReply = {discard_ack, ED}, 8483 {error, Err, ErrReply} 8484 end; 8485otp71922_mgc_verify_service_change_req(Else, _Mid) -> 8486 io:format("otp71922_mgc_verify_service_change_req -> unknown" 8487 "~n Else: ~p~n", [Else]), 8488 ED = otp71922_err_desc(Else), 8489 ErrReply = {discard_ack, ED}, 8490 {error, Else, ErrReply}. 8491 8492otp71922_mgc_verify_notify_request_fun() -> 8493 fun(Ev) -> 8494 otp71922_mgc_verify_notify_request(Ev) 8495 end. 8496 8497otp71922_mgc_verify_notify_request( 8498 {handle_trans_request, _, ?VERSION, [AR]}) -> 8499 io:format("otp71922_mgc_verify_notify_request -> ok" 8500 "~n AR: ~p~n", [AR]), 8501 case AR of 8502 #'ActionRequest'{contextId = 1 = Cid, 8503 commandRequests = [CR]} -> 8504 #'CommandRequest'{command = Cmd} = CR, 8505 {notifyReq, NR} = Cmd, 8506 #'NotifyRequest'{terminationID = [Tid], 8507 observedEventsDescriptor = OED, 8508 errorDescriptor = asn1_NOVALUE} = NR, 8509 #'ObservedEventsDescriptor'{observedEventLst = [OE]} = OED, 8510 #'ObservedEvent'{eventName = "al/of"} = OE, 8511 HandleAck = {handle_sloppy_ack, kalle}, 8512 Reply = {HandleAck, 8513 [otp71922_mgc_notify_reply_ar(Cid, Tid)]}, 8514 {ok, AR, Reply}; 8515 #'ActionRequest'{contextId = 2 = Cid, 8516 commandRequests = [CR]} -> 8517 #'CommandRequest'{command = Cmd} = CR, 8518 {notifyReq, NR} = Cmd, 8519 #'NotifyRequest'{terminationID = [Tid], 8520 observedEventsDescriptor = OED, 8521 errorDescriptor = asn1_NOVALUE} = NR, 8522 #'ObservedEventsDescriptor'{observedEventLst = [OE]} = OED, 8523 #'ObservedEvent'{eventName = "al/of"} = OE, 8524 Reply = {discard_ack, [otp71922_mgc_notify_reply_ar(Cid, Tid)]}, 8525 {ok, AR, Reply}; 8526 _ -> 8527 ED = otp71922_err_desc(AR), 8528 ErrReply = {discard_ack, ED}, 8529 {error, AR, ErrReply} 8530 end; 8531otp71922_mgc_verify_notify_request(Else) -> 8532 io:format("otp71922_mgc_verify_notify_request -> unknown" 8533 "~n Else: ~p~n", [Else]), 8534 ED = otp71922_err_desc(Else), 8535 ErrReply = {discard_ack, ED}, 8536 {error, Else, ErrReply}. 8537 8538otp71922_mgc_verify_notify_reply({handle_trans_reply, _CH, ?VERSION, 8539 {ok, [AR]}, _}) -> 8540 io:format("otp71922_mgc_verify_notify_reply -> ok" 8541 "~n AR: ~p~n", [AR]), 8542 {ok, AR, ok}; 8543otp71922_mgc_verify_notify_reply({handle_trans_reply, CH, ?VERSION, 8544 UnknownResult, _}) -> 8545 io:format("otp71922_mgc_verify_notify_reply -> unknown result" 8546 "~n UnknownResult: ~p~n", [UnknownResult]), 8547 {error, {unknown_reply_result, UnknownResult, CH}, ok}; 8548otp71922_mgc_verify_notify_reply(Else) -> 8549 io:format("otp71922_mgc_verify_notify_reply -> unknown" 8550 "~n Else: ~p~n", [Else]), 8551 {error, {unknown_reply, Else}, ok}. 8552 8553otp71922_mgc_verify_ack({handle_trans_ack, CH, ?VERSION, ok, kalle}) -> 8554 io:format("otp71922_mgc_verify_ack -> ok" 8555 "~n CH: ~p" 8556 "~n", [CH]), 8557 {ok, CH, ok}; 8558otp71922_mgc_verify_ack(Else) -> 8559 io:format("otp71922_mgc_verify_ack -> unknown" 8560 "~n Else: ~p~n", [Else]), 8561 {error, Else, ok}. 8562 8563otp71922_mgc_verify_handle_disconnect({handle_disconnect, CH, ?VERSION, R}) -> 8564 io:format("otp71922_mgc_verify_handle_disconnect -> ok" 8565 "~n CH: ~p" 8566 "~n R: ~p" 8567 "~n", [CH, R]), 8568 {ok, CH, ok}; 8569otp71922_mgc_verify_handle_disconnect(Else) -> 8570 io:format("otp71922_mgc_verify_handle_disconnect -> unknown" 8571 "~n Else: ~p~n", [Else]), 8572 {error, Else, ok}. 8573 8574 8575otp71922_mgc_service_change_reply_ar(Mid, Cid) -> 8576 SCRP = cre_serviceChangeResParm(Mid), 8577 SCRes = cre_serviceChangeResult(SCRP), 8578 Root = #megaco_term_id{id = ["root"]}, 8579 SCR = cre_serviceChangeReply([Root], SCRes), 8580 CR = cre_cmdReply(SCR), 8581 cre_actionReply(Cid, [CR]). 8582 8583%% otp71922_mgc_service_change_reply_msg(Mid, TransId, Cid) -> 8584%% AR = otp71922_mgc_service_change_reply_ar(Mid, Cid), 8585%% TRes = cre_transResult([AR]), 8586%% TR = cre_transReply(TransId, TRes), 8587%% Trans = cre_transaction(TR), 8588%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 8589%% cre_megacoMessage(Mess). 8590 8591otp71922_mgc_notify_request_ar(Rid, Tid, Cid) -> 8592 TT = cre_timeNotation("19990729", "44000000"), 8593 Ev = cre_obsEvent("al/of", TT), 8594 EvsDesc = cre_obsEvsDesc(Rid, [Ev]), 8595 NR = cre_notifyReq([Tid], EvsDesc), 8596 CMD = cre_command(NR), 8597 CR = cre_cmdReq(CMD), 8598 cre_actionReq(Cid, [CR]). 8599 8600otp71922_mgc_notify_reply_ar(Cid, TermId) -> 8601 NR = cre_notifyReply([TermId]), 8602 CR = cre_cmdReply(NR), 8603 cre_actionReply(Cid, [CR]). 8604 8605%% otp71922_mgc_notify_reply(Mid, TransId, Cid, TermId) -> 8606%% AR = otp71922_mgc_notify_reply_ar(Cid, TermId), 8607%% TRes = cre_transResult([AR]), 8608%% TR = cre_transReply(TransId, TRes), 8609%% Trans = cre_transaction(TR), 8610%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 8611%% cre_megacoMessage(Mess). 8612 8613 8614%% 8615%% MG generator stuff 8616%% 8617-ifdef(megaco_hipe_special). 8618-define(otp71922_mg_verify_handle_connect_fun(), 8619 {?MODULE, otp71922_mg_verify_handle_connect, []}). 8620-define(otp71922_mg_verify_service_change_reply_fun(), 8621 {?MODULE, otp71922_mg_verify_service_change_reply, []}). 8622-define(otp71922_mg_verify_notify_req_fun(), 8623 {?MODULE, otp71922_mgc_verify_notify_request, []}). 8624-define(otp71922_mg_verify_notify_reply_fun(), 8625 {?MODULE, otp71922_mg_verify_notify_reply, []}). 8626-else. 8627-define(otp71922_mg_verify_handle_connect_fun(), 8628 fun otp71922_mg_verify_handle_connect/1). 8629-define(otp71922_mg_verify_service_change_reply_fun(), 8630 fun otp71922_mg_verify_service_change_reply/1). 8631-define(otp71922_mg_verify_notify_req_fun(), 8632 otp71922_mgc_verify_notify_request_fun()). 8633-define(otp71922_mg_verify_notify_reply_fun(), 8634 fun otp71922_mg_verify_notify_reply/1). 8635-endif. 8636 8637otp71922_mg_event_sequence(text, tcp, Mid) -> 8638 RI = [ 8639 {port, 2944}, 8640 {encoding_module, megaco_pretty_text_encoder}, 8641 {encoding_config, []}, 8642 {transport_module, megaco_tcp} 8643 ], 8644 ServiceChangeReq = [otp71922_mg_service_change_request_ar(Mid, 1)], 8645 %% This is so that we can match notify request and reply 8646 Tid1 = #megaco_term_id{id = ["00000000","00000001","01101101"]}, 8647 Tid2 = #megaco_term_id{id = ["00000000","00000010","01101101"]}, 8648 Tid3 = #megaco_term_id{id = ["00000000","00000011","01101101"]}, 8649 NR = fun(Cid, Rid, Tid) -> 8650 [otp71922_mg_notify_request_ar(Rid, Tid, Cid)] 8651 end, 8652 ConnectVerify = ?otp71922_mg_verify_handle_connect_fun(), 8653 ServiceChangeReplyVerify = ?otp71922_mg_verify_service_change_reply_fun(), 8654 NotifyReqVerify = ?otp71922_mg_verify_notify_req_fun(), 8655 NotifyReplyVerify = ?otp71922_mg_verify_notify_reply_fun(), 8656 EvSeq = [ 8657 {debug, true}, 8658 megaco_start, 8659 {megaco_start_user, Mid, RI, []}, 8660 start_transport, 8661 %% {megaco_trace, max}, 8662 {megaco_trace, disable}, 8663 {megaco_system_info, users}, 8664 {megaco_system_info, connections}, 8665 connect, 8666 {megaco_callback, handle_connect, ConnectVerify}, 8667 megaco_connect, 8668 {megaco_cast, ServiceChangeReq, []}, 8669 {megaco_callback, handle_connect, ConnectVerify}, 8670 {megaco_callback, handle_trans_reply, ServiceChangeReplyVerify}, 8671 {sleep, 1000}, 8672 {megaco_system_info, users}, 8673 {megaco_system_info, connections}, 8674 {sleep, 1000}, 8675 {megaco_update_conn_info, auto_ack, true}, 8676 {megaco_update_conn_info, trans_ack_maxcount, 10}, 8677 {megaco_update_conn_info, trans_req_maxcount, 10}, 8678 {megaco_update_conn_info, trans_timer, 1000}, 8679 {megaco_update_conn_info, trans_ack, true}, 8680 {megaco_update_conn_info, trans_req, true}, 8681 {megaco_conn_info, all}, 8682 {megaco_cast, NR(1,1,Tid1), []}, 8683 {megaco_cast, NR(1,2,Tid2), []}, 8684 {megaco_cast, NR(1,3,Tid3), []}, 8685 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 8686 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 8687 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 8688 {megaco_update_conn_info, trans_timer, 120000}, 8689 {megaco_cast, NR(2,1,Tid1), []}, 8690 {megaco_cast, NR(2,2,Tid2), []}, 8691 {megaco_cast, NR(2,3,Tid3), []}, 8692 {megaco_callback, handle_trans_request, NotifyReqVerify}, 8693 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 8694 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 8695 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 8696 {sleep, 3000}, 8697 megaco_stop_user, 8698 megaco_stop, 8699 {sleep, 1000} 8700 ], 8701 EvSeq. 8702 8703otp71922_mg_verify_handle_connect({handle_connect, CH, ?VERSION}) -> 8704 i("received expected handle_connect:" 8705 "~n CH: ~p", [CH]), 8706 {ok, CH, ok}; 8707otp71922_mg_verify_handle_connect(Else) -> 8708 e("otp71922_mg_verify_handle_connect -> received unexpected:" 8709 "~n Expected: handle_connect" 8710 "~n Received: ~p", [Else]), 8711 {error, Else, ok}. 8712 8713otp71922_mg_verify_service_change_reply({handle_trans_reply, _CH, ?VERSION, 8714 {ok, [AR]}, _}) -> 8715 case AR of 8716 #'ActionReply'{commandReply = [SCR]} -> 8717 case SCR of 8718 {serviceChangeReply, 8719 #'ServiceChangeReply'{terminationID = [Tid], 8720 serviceChangeResult = Res}} -> 8721 case Tid of 8722 #megaco_term_id{contains_wildcards = false, 8723 id = ["root"]} -> 8724 case Res of 8725 {serviceChangeResParms, 8726 #'ServiceChangeResParm'{ 8727 serviceChangeMgcId = _RemoteMid}} -> 8728 i("received expected handle_trans_reply " 8729 "(service change) with ok" 8730 "~n AR: ~p", [AR]), 8731 {ok, AR, ok}; 8732 {Tag, Val} -> 8733 e("received expected handle_trans_reply " 8734 "(service change) with error" 8735 "~n Tag: ~p" 8736 "~n Val: ~p", [Tag, Val]), 8737 Err = {invalid_service_change_result, 8738 Tag, Val}, 8739 {error, Err, ok} 8740 end; 8741 _ -> 8742 e("received expected handle_trans_reply " 8743 "(service change) with error" 8744 "~n Tid: ~p", [Tid]), 8745 Err = {invalid_termination_id, Tid}, 8746 {error, Err, ok} 8747 end; 8748 {Tag, Val} -> 8749 e("received expected handle_trans_reply " 8750 "(action reply) with error" 8751 "~n Tag: ~p" 8752 "~n Val: ~p", [Tag, Val]), 8753 Err = {invalid_command_reply, Tag, Val}, 8754 {error, Err, ok} 8755 end; 8756 _ -> 8757 e("received expected handle_trans_reply with error" 8758 "~n AR: ~p", [AR]), 8759 Err = {invalid_action_reply, AR}, 8760 {error, Err, ok} 8761 end; 8762otp71922_mg_verify_service_change_reply(Else) -> 8763 e("invalid service change reply:" 8764 "~n Expected: handle_trans_reply" 8765 "~n Received: ~p", [Else]), 8766 {error, Else, ok}. 8767 8768otp71922_mg_verify_notify_reply({handle_trans_reply, _CH, ?VERSION, 8769 {ok, [AR]}, _}) -> 8770 i("received expected handle_notify_reply -> ok" 8771 "~n AR: ~p", [AR]), 8772 {ok, AR, ok}; 8773otp71922_mg_verify_notify_reply(Else) -> 8774 e("otp71922_mg_verify_notify_reply -> invalid notify reply" 8775 "~n Expected: handle_trans_reply with ok" 8776 "~n Received: ~p", [Else]), 8777 {error, Else, ok}. 8778 8779otp71922_mg_service_change_request_ar(_Mid, Cid) -> 8780 Prof = cre_serviceChangeProf("resgw", 1), 8781 SCP = cre_serviceChangeParm(restart, ["901 mg col boot"], Prof), 8782 Root = #megaco_term_id{id = ["root"]}, 8783 SCR = cre_serviceChangeReq([Root], SCP), 8784 CMD = cre_command(SCR), 8785 CR = cre_cmdReq(CMD), 8786 cre_actionReq(Cid, [CR]). 8787 8788otp71922_mg_notify_request_ar(Rid, Tid, Cid) -> 8789 TT = cre_timeNotation("19990729", "22000000"), 8790 Ev = cre_obsEvent("al/of", TT), 8791 EvsDesc = cre_obsEvsDesc(Rid, [Ev]), 8792 NR = cre_notifyReq([Tid], EvsDesc), 8793 CMD = cre_command(NR), 8794 CR = cre_cmdReq(CMD), 8795 cre_actionReq(Cid, [CR]). 8796 8797 8798%% 8799%% Common functions for the multi_trans_req_timeout test case 8800%% 8801 8802otp71922_err_desc(T) -> 8803 cre_ErrDesc(T). 8804 8805 8806%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 8807 8808otp_7192_3(suite) -> 8809 []; 8810otp_7192_3(doc) -> 8811 ["Same as otp_7192_2 but transport is UDP instead of TCP"]; 8812otp_7192_3(Config) when is_list(Config) -> 8813 Pre = fun() -> 8814 MgcNode = make_node_name(mgc), 8815 MgNode = make_node_name(mg), 8816 d("start nodes: " 8817 "~n MGC Node: ~p" 8818 "~n MG Node: ~p", 8819 [MgcNode, MgNode]), 8820 Nodes = [MgcNode, MgNode], 8821 ok = ?START_NODES(Nodes), 8822 Nodes 8823 end, 8824 Case = fun do_otp_7192_3/1, 8825 Post = fun(Nodes) -> 8826 d("stop nodes"), 8827 ?STOP_NODES(lists:reverse(Nodes)) 8828 end, 8829 try_tc(otp_7192_3, Pre, Case, Post). 8830 8831do_otp_7192_3([MgcNode, MgNode]) -> 8832 8833 MgMid = {deviceName,"mg"}, 8834 8835 d("[MGC] start the simulator "), 8836 {ok, Mgc} = megaco_test_megaco_generator:start_link("MGC", MgcNode), 8837 8838 d("[MGC] create the event sequence"), 8839 MgcEvSeq = otp72923_mgc_event_sequence(text, udp, MgMid), 8840 8841 i("wait some time before starting the MGC simulation"), 8842 sleep(1000), 8843 8844 d("[MGC] start the simulation"), 8845 {ok, MgcId} = megaco_test_megaco_generator:exec(Mgc, MgcEvSeq), 8846 8847 i("wait some time before starting the MG simulator"), 8848 sleep(1000), 8849 8850 d("[MG] start the simulator (generator)"), 8851 {ok, Mg} = megaco_test_megaco_generator:start_link("MG", MgNode), 8852 8853 d("[MG] create the event sequence"), 8854 MgEvSeq = otp72923_mg_event_sequence(text, udp, MgMid), 8855 8856 i("wait some time before starting the MG simulation"), 8857 sleep(1000), 8858 8859 d("[MG] start the simulation"), 8860 {ok, MgId} = megaco_test_megaco_generator:exec(Mg, MgEvSeq), 8861 8862 d("await the generator(s) completion"), 8863 await_completion([MgcId, MgId], 60000), 8864 8865 %% Tell Mgc to stop 8866 i("[MGC] stop generator"), 8867 megaco_test_megaco_generator:stop(Mgc), 8868 8869 %% Tell Mg to stop 8870 i("[MG] stop generator"), 8871 megaco_test_megaco_generator:stop(Mg), 8872 8873 i("done", []), 8874 ok. 8875 8876 8877%% 8878%% MGC generator stuff 8879%% 8880-ifdef(megaco_hipe_special). 8881-define(otp72923_mgc_verify_handle_connect_fun(), 8882 {?MODULE, otp72923_mgc_verify_handle_connect, []}). 8883-define(otp72923_mgc_verify_service_change_req_fun(Mid), 8884 {?MODULE, otp72923_mgc_verify_service_change_req, [Mid]}). 8885-define(otp72923_mgc_verify_notify_req_fun(), 8886 {?MODULE, otp72923_mgc_verify_notify_request, []}). 8887-define(otp72923_mgc_verify_notify_reply_fun(), 8888 {?MODULE, otp72923_mgc_verify_notify_reply, []}). 8889-define(otp72923_mgc_verify_ack_fun(), 8890 {?MODULE, otp72923_mgc_verify_ack, []}). 8891-define(otp72923_mgc_verify_handle_disconnect_fun(), 8892 {?MODULE, otp72923_mgc_verify_handle_disconnect, []}). 8893-else. 8894-define(otp72923_mgc_verify_handle_connect_fun(), 8895 fun otp72923_mgc_verify_handle_connect/1). 8896-define(otp72923_mgc_verify_service_change_req_fun(Mid), 8897 otp72923_mgc_verify_service_change_req_fun(Mid)). 8898-define(otp72923_mgc_verify_notify_req_fun(), 8899 otp72923_mgc_verify_notify_request_fun()). 8900-define(otp72923_mgc_verify_notify_reply_fun(), 8901 fun otp72923_mgc_verify_notify_reply/1). 8902-define(otp72923_mgc_verify_ack_fun(), 8903 fun otp72923_mgc_verify_ack/1). 8904-define(otp72923_mgc_verify_handle_disconnect_fun(), 8905 fun otp72923_mgc_verify_handle_disconnect/1). 8906-endif. 8907 8908otp72923_mgc_event_sequence(text, udp, MgMid) -> 8909 CTRL = self(), 8910 Mid = {deviceName, "ctrl"}, 8911 RI = [ 8912 {port, 2944}, 8913 {encoding_module, megaco_pretty_text_encoder}, 8914 {encoding_config, []}, 8915 {transport_module, megaco_udp} 8916 ], 8917 Tid = #megaco_term_id{id = ["00000000","00000000","01101101"]}, 8918 NR = fun(Cid, Rid) -> 8919 [otp72923_mgc_notify_request_ar(Rid, Tid, Cid)] 8920 end, 8921 LocalConnectVerify = ?otp72923_mgc_verify_handle_connect_fun(), 8922 ServiceChangeReqVerify = ?otp72923_mgc_verify_service_change_req_fun(Mid), 8923 NotifyReqVerify = ?otp72923_mgc_verify_notify_req_fun(), 8924 NotifyReplyVerify = ?otp72923_mgc_verify_notify_reply_fun(), 8925 AckVerify = ?otp72923_mgc_verify_ack_fun(), 8926 %% DiscoVerify = ?otp72923_mgc_verify_handle_disconnect_fun(), 8927 EvSeq = [ 8928 {debug, true}, 8929 {megaco_trace, max}, 8930 %% {megaco_trace, disable}, 8931 megaco_start, 8932 {megaco_start_user, Mid, RI, []}, 8933 start_transport, 8934 listen, 8935 8936 %% ANNOUNCE READY 8937 {trigger, fun() -> CTRL ! announce_mgc end}, 8938 8939 {megaco_connect, MgMid}, 8940 {megaco_callback, handle_connect, LocalConnectVerify}, 8941 {megaco_callback, handle_trans_request, ServiceChangeReqVerify}, 8942 {megaco_callback, handle_trans_request, NotifyReqVerify}, 8943 {megaco_callback, handle_trans_request, NotifyReqVerify}, 8944 {megaco_callback, handle_trans_request, NotifyReqVerify}, 8945 {megaco_update_conn_info, request_timer, 1000}, 8946 {megaco_cast, NR(1,1), []}, 8947 8948 {megaco_callback, [{handle_trans_ack, 3, AckVerify}, 8949 {handle_trans_request, 3, NotifyReqVerify}, 8950 {handle_trans_reply, 1, NotifyReplyVerify}]}, 8951 %% {megaco_callback, handle_disconnect, DiscoVerify}, 8952 {sleep, 1000}, 8953 megaco_stop_user, 8954 megaco_stop 8955 ], 8956 EvSeq. 8957 8958 8959otp72923_mgc_verify_handle_connect({handle_connect, CH, ?VERSION}) -> 8960 io:format("otp72923_mgc_verify_handle_connect -> ok" 8961 "~n CH: ~p~n", [CH]), 8962 {ok, timer:seconds(2), CH, ok}; 8963otp72923_mgc_verify_handle_connect(Else) -> 8964 io:format("otp72923_mgc_verify_handle_connect -> unknown" 8965 "~n Else: ~p~n", [Else]), 8966 {error, Else, ok}. 8967 8968otp72923_mgc_verify_service_change_req_fun(Mid) -> 8969 fun(Ev) -> 8970 otp72923_mgc_verify_service_change_req(Ev, Mid) 8971 end. 8972 8973otp72923_mgc_verify_service_change_req( 8974 {handle_trans_request, _, ?VERSION, [AR]}, Mid) -> 8975 io:format("otp72923_mgc_verify_service_change_req -> ok" 8976 "~n AR: ~p~n", [AR]), 8977 case AR of 8978 #'ActionRequest'{commandRequests = [CR]} -> 8979 case CR of 8980 #'CommandRequest'{command = Cmd} -> 8981 case Cmd of 8982 {serviceChangeReq, 8983 #'ServiceChangeRequest'{terminationID = [Tid], 8984 serviceChangeParms = Parms}} -> 8985 case Tid of 8986 #megaco_term_id{contains_wildcards = false, 8987 id = ["root"]} -> 8988 case Parms of 8989 #'ServiceChangeParm'{ 8990 serviceChangeMethod = restart, 8991 serviceChangeReason = [[$9,$0,$1|_]]} -> 8992 Reply = 8993 {discard_ack, 8994 [otp72923_mgc_service_change_reply_ar(Mid, 1)]}, 8995 {ok, AR, Reply}; 8996 _ -> 8997 Err = {invalid_SCP, Parms}, 8998 ED = otp72923_err_desc(Parms), 8999 ErrReply = {discard_ack, 9000 ED}, 9001 {error, Err, ErrReply} 9002 end; 9003 _ -> 9004 Err = {invalid_termination_id, Tid}, 9005 ED = otp72923_err_desc(Tid), 9006 ErrReply = {discard_ack, ED}, 9007 {error, Err, ErrReply} 9008 end; 9009 _ -> 9010 Err = {invalid_command, Cmd}, 9011 ED = otp72923_err_desc(Cmd), 9012 ErrReply = {discard_ack, ED}, 9013 {error, Err, ErrReply} 9014 end; 9015 _ -> 9016 Err = {invalid_command_request, CR}, 9017 ED = otp72923_err_desc(CR), 9018 ErrReply = {discard_ack, ED}, 9019 {error, Err, ErrReply} 9020 end; 9021 _ -> 9022 Err = {invalid_action_request, AR}, 9023 ED = otp72923_err_desc(AR), 9024 ErrReply = {discard_ack, ED}, 9025 {error, Err, ErrReply} 9026 end; 9027otp72923_mgc_verify_service_change_req(Else, _Mid) -> 9028 io:format("otp72923_mgc_verify_service_change_req -> unknown" 9029 "~n Else: ~p~n", [Else]), 9030 ED = otp72923_err_desc(Else), 9031 ErrReply = {discard_ack, ED}, 9032 {error, Else, ErrReply}. 9033 9034otp72923_mgc_verify_notify_request_fun() -> 9035 fun(Ev) -> 9036 otp72923_mgc_verify_notify_request(Ev) 9037 end. 9038 9039otp72923_mgc_verify_notify_request( 9040 {handle_trans_request, _, ?VERSION, [AR]}) -> 9041 io:format("otp72923_mgc_verify_notify_request -> ok" 9042 "~n AR: ~p~n", [AR]), 9043 case AR of 9044 #'ActionRequest'{contextId = 1 = Cid, 9045 commandRequests = [CR]} -> 9046 #'CommandRequest'{command = Cmd} = CR, 9047 {notifyReq, NR} = Cmd, 9048 #'NotifyRequest'{terminationID = [Tid], 9049 observedEventsDescriptor = OED, 9050 errorDescriptor = asn1_NOVALUE} = NR, 9051 #'ObservedEventsDescriptor'{observedEventLst = [OE]} = OED, 9052 #'ObservedEvent'{eventName = "al/of"} = OE, 9053 HandleAck = {handle_sloppy_ack, kalle}, 9054 Reply = {HandleAck, 9055 [otp72923_mgc_notify_reply_ar(Cid, Tid)]}, 9056 {ok, AR, Reply}; 9057 #'ActionRequest'{contextId = 2 = Cid, 9058 commandRequests = [CR]} -> 9059 #'CommandRequest'{command = Cmd} = CR, 9060 {notifyReq, NR} = Cmd, 9061 #'NotifyRequest'{terminationID = [Tid], 9062 observedEventsDescriptor = OED, 9063 errorDescriptor = asn1_NOVALUE} = NR, 9064 #'ObservedEventsDescriptor'{observedEventLst = [OE]} = OED, 9065 #'ObservedEvent'{eventName = "al/of"} = OE, 9066 Reply = {discard_ack, [otp72923_mgc_notify_reply_ar(Cid, Tid)]}, 9067 {ok, AR, Reply}; 9068 _ -> 9069 ED = otp72923_err_desc(AR), 9070 ErrReply = {discard_ack, ED}, 9071 {error, AR, ErrReply} 9072 end; 9073otp72923_mgc_verify_notify_request(Else) -> 9074 io:format("otp72923_mgc_verify_notify_request -> unknown" 9075 "~n Else: ~p~n", [Else]), 9076 ED = otp72923_err_desc(Else), 9077 ErrReply = {discard_ack, ED}, 9078 {error, Else, ErrReply}. 9079 9080otp72923_mgc_verify_notify_reply({handle_trans_reply, _CH, ?VERSION, 9081 {ok, [AR]}, _}) -> 9082 io:format("otp72923_mgc_verify_notify_reply -> ok" 9083 "~n AR: ~p~n", [AR]), 9084 {ok, AR, ok}; 9085otp72923_mgc_verify_notify_reply({handle_trans_reply, CH, ?VERSION, 9086 UnknownResult, _}) -> 9087 io:format("otp72923_mgc_verify_notify_reply -> unknown result" 9088 "~n UnknownResult: ~p~n", [UnknownResult]), 9089 {error, {unknown_reply_result, UnknownResult, CH}, ok}; 9090otp72923_mgc_verify_notify_reply(Else) -> 9091 io:format("otp72923_mgc_verify_notify_reply -> unknown" 9092 "~n Else: ~p~n", [Else]), 9093 {error, {unknown_reply, Else}, ok}. 9094 9095otp72923_mgc_verify_ack({handle_trans_ack, CH, ?VERSION, ok, kalle}) -> 9096 io:format("otp72923_mgc_verify_ack -> ok" 9097 "~n CH: ~p" 9098 "~n", [CH]), 9099 {ok, CH, ok}; 9100otp72923_mgc_verify_ack(Else) -> 9101 io:format("otp72923_mgc_verify_ack -> unknown" 9102 "~n Else: ~p~n", [Else]), 9103 {error, Else, ok}. 9104 9105%% otp72923_mgc_verify_handle_disconnect({handle_disconnect, CH, ?VERSION, R}) -> 9106%% io:format("otp72923_mgc_verify_handle_disconnect -> ok" 9107%% "~n CH: ~p" 9108%% "~n R: ~p" 9109%% "~n", [CH, R]), 9110%% {ok, CH, ok}; 9111%% otp72923_mgc_verify_handle_disconnect(Else) -> 9112%% io:format("otp72923_mgc_verify_handle_disconnect -> unknown" 9113%% "~n Else: ~p~n", [Else]), 9114%% {error, Else, ok}. 9115 9116 9117otp72923_mgc_service_change_reply_ar(Mid, Cid) -> 9118 SCRP = cre_serviceChangeResParm(Mid), 9119 SCRes = cre_serviceChangeResult(SCRP), 9120 Root = #megaco_term_id{id = ["root"]}, 9121 SCR = cre_serviceChangeReply([Root], SCRes), 9122 CR = cre_cmdReply(SCR), 9123 cre_actionReply(Cid, [CR]). 9124 9125%% otp72923_mgc_service_change_reply_msg(Mid, TransId, Cid) -> 9126%% AR = otp72923_mgc_service_change_reply_ar(Mid, Cid), 9127%% TRes = cre_transResult([AR]), 9128%% TR = cre_transReply(TransId, TRes), 9129%% Trans = cre_transaction(TR), 9130%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 9131%% cre_megacoMessage(Mess). 9132 9133otp72923_mgc_notify_request_ar(Rid, Tid, Cid) -> 9134 TT = cre_timeNotation("19990729", "44000000"), 9135 Ev = cre_obsEvent("al/of", TT), 9136 EvsDesc = cre_obsEvsDesc(Rid, [Ev]), 9137 NR = cre_notifyReq([Tid], EvsDesc), 9138 CMD = cre_command(NR), 9139 CR = cre_cmdReq(CMD), 9140 cre_actionReq(Cid, [CR]). 9141 9142otp72923_mgc_notify_reply_ar(Cid, TermId) -> 9143 NR = cre_notifyReply([TermId]), 9144 CR = cre_cmdReply(NR), 9145 cre_actionReply(Cid, [CR]). 9146 9147%% otp72923_mgc_notify_reply(Mid, TransId, Cid, TermId) -> 9148%% AR = otp72923_mgc_notify_reply_ar(Cid, TermId), 9149%% TRes = cre_transResult([AR]), 9150%% TR = cre_transReply(TransId, TRes), 9151%% Trans = cre_transaction(TR), 9152%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 9153%% cre_megacoMessage(Mess). 9154 9155 9156%% 9157%% MG generator stuff 9158%% 9159-ifdef(megaco_hipe_special). 9160-define(otp72923_mg_verify_handle_connect_fun(), 9161 {?MODULE, otp72923_mg_verify_handle_connect, []}). 9162-define(otp72923_mg_verify_service_change_reply_fun(), 9163 {?MODULE, otp72923_mg_verify_service_change_reply, []}). 9164-define(otp72923_mg_verify_notify_req_fun(), 9165 {?MODULE, otp72923_mgc_verify_notify_request, []}). 9166-define(otp72923_mg_verify_notify_reply_fun(), 9167 {?MODULE, otp72923_mg_verify_notify_reply, []}). 9168-else. 9169-define(otp72923_mg_verify_handle_connect_fun(), 9170 fun otp72923_mg_verify_handle_connect/1). 9171-define(otp72923_mg_verify_service_change_reply_fun(), 9172 fun otp72923_mg_verify_service_change_reply/1). 9173-define(otp72923_mg_verify_notify_req_fun(), 9174 otp72923_mgc_verify_notify_request_fun()). 9175-define(otp72923_mg_verify_notify_reply_fun(), 9176 fun otp72923_mg_verify_notify_reply/1). 9177-endif. 9178 9179otp72923_mg_event_sequence(text, udp, Mid) -> 9180 RI = [ 9181 {port, 2944}, 9182 {encoding_module, megaco_pretty_text_encoder}, 9183 {encoding_config, []}, 9184 {transport_module, megaco_udp} 9185 ], 9186 ServiceChangeReq = [otp72923_mg_service_change_request_ar(Mid, 1)], 9187 Tid = #megaco_term_id{id = ["00000000","00000000","01101101"]}, 9188 NR = fun(Cid, Rid) -> 9189 [otp72923_mg_notify_request_ar(Rid, Tid, Cid)] 9190 end, 9191 ConnectVerify = ?otp72923_mg_verify_handle_connect_fun(), 9192 ServiceChangeReplyVerify = ?otp72923_mg_verify_service_change_reply_fun(), 9193 NotifyReqVerify = ?otp72923_mg_verify_notify_req_fun(), 9194 NotifyReplyVerify = ?otp72923_mg_verify_notify_reply_fun(), 9195 EvSeq = [ 9196 %% {debug, true}, 9197 {debug, false}, 9198 megaco_start, 9199 {megaco_start_user, Mid, RI, []}, 9200 start_transport, 9201 %% {megaco_trace, max}, 9202 {megaco_trace, disable}, 9203 {megaco_system_info, users}, 9204 {megaco_system_info, connections}, 9205 connect, 9206 {megaco_callback, handle_connect, ConnectVerify}, 9207 megaco_connect, 9208 {megaco_cast, ServiceChangeReq, []}, 9209 {megaco_callback, handle_connect, ConnectVerify}, 9210 {megaco_callback, handle_trans_reply, ServiceChangeReplyVerify}, 9211 {sleep, 1000}, 9212 {megaco_system_info, users}, 9213 {megaco_system_info, connections}, 9214 {sleep, 1000}, 9215 {megaco_update_conn_info, auto_ack, true}, 9216 {megaco_update_conn_info, trans_ack_maxcount, 10}, 9217 {megaco_update_conn_info, trans_req_maxcount, 10}, 9218 {megaco_update_conn_info, trans_timer, 1000}, 9219 {megaco_update_conn_info, trans_ack, true}, 9220 {megaco_update_conn_info, trans_req, true}, 9221 {megaco_conn_info, all}, 9222 {megaco_cast, NR(1,1), []}, 9223 {megaco_cast, NR(1,2), []}, 9224 {megaco_cast, NR(1,3), []}, 9225 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 9226 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 9227 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 9228 {megaco_update_conn_info, trans_timer, 120000}, 9229 {megaco_cast, NR(2,1), []}, 9230 {megaco_cast, NR(2,2), []}, 9231 {megaco_cast, NR(2,3), []}, 9232 {megaco_callback, handle_trans_request, NotifyReqVerify}, 9233 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 9234 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 9235 {megaco_callback, handle_trans_reply, NotifyReplyVerify}, 9236 {sleep, 3000}, 9237 megaco_stop_user, 9238 megaco_stop, 9239 {sleep, 1000} 9240 ], 9241 EvSeq. 9242 9243otp72923_mg_verify_handle_connect({handle_connect, CH, ?VERSION}) -> 9244 io:format("otp72923_mg_verify_handle_connect -> ok" 9245 "~n CH: ~p~n", [CH]), 9246 {ok, CH, ok}; 9247otp72923_mg_verify_handle_connect(Else) -> 9248 io:format("otp72923_mg_verify_handle_connect -> unknown" 9249 "~n Else: ~p~n", [Else]), 9250 {error, Else, ok}. 9251 9252otp72923_mg_verify_service_change_reply({handle_trans_reply, _CH, ?VERSION, 9253 {ok, [AR]}, _}) -> 9254 io:format("otp72923_mg_verify_service_change_reply -> ok" 9255 "~n AR: ~p~n", [AR]), 9256 case AR of 9257 #'ActionReply'{commandReply = [SCR]} -> 9258 case SCR of 9259 {serviceChangeReply, 9260 #'ServiceChangeReply'{terminationID = [Tid], 9261 serviceChangeResult = Res}} -> 9262 case Tid of 9263 #megaco_term_id{contains_wildcards = false, 9264 id = ["root"]} -> 9265 case Res of 9266 {serviceChangeResParms, 9267 #'ServiceChangeResParm'{ 9268 serviceChangeMgcId = _RemoteMid}} -> 9269 {ok, AR, ok}; 9270 {Tag, Val} -> 9271 Err = {invalid_service_change_result, 9272 Tag, Val}, 9273 {error, Err, ok} 9274 end; 9275 _ -> 9276 Err = {invalid_termination_id, Tid}, 9277 {error, Err, ok} 9278 end; 9279 {Tag, Val} -> 9280 Err = {invalid_command_reply, Tag, Val}, 9281 {error, Err, ok} 9282 end; 9283 _ -> 9284 Err = {invalid_action_reply, AR}, 9285 {error, Err, ok} 9286 end; 9287otp72923_mg_verify_service_change_reply(Else) -> 9288 io:format("otp72923_mg_verify_service_change_reply -> unknown" 9289 "~n Else: ~p~n", [Else]), 9290 {error, Else, ok}. 9291 9292%% otp72923_mg_verify_notify_request_fun() -> 9293%% fun(Ev) -> 9294%% otp72923_mg_verify_notify_request(Ev) 9295%% end. 9296 9297%% otp72923_mg_verify_notify_request( 9298%% {handle_trans_request, _, ?VERSION, [AR]}) -> 9299%% io:format("otp72923_mg_verify_notify_request -> ok" 9300%% "~n AR: ~p~n", [AR]), 9301%% case AR of 9302%% #'ActionRequest'{contextId = 1 = Cid, 9303%% commandRequests = [CR]} -> 9304%% #'CommandRequest'{command = Cmd} = CR, 9305%% {notifyReq, NR} = Cmd, 9306%% #'NotifyRequest'{terminationID = [Tid], 9307%% observedEventsDescriptor = OED, 9308%% errorDescriptor = asn1_NOVALUE} = NR, 9309%% #'ObservedEventsDescriptor'{observedEventLst = [OE]} = OED, 9310%% #'ObservedEvent'{eventName = "al/of"} = OE, 9311%% Reply = {discard_ack, [otp72923_mg_notify_reply_ar(Cid, Tid)]}, 9312%% {ok, AR, Reply}; 9313%% _ -> 9314%% ED = otp72923_err_desc(AR), 9315%% ErrReply = {discard_ack, ED}, 9316%% {error, AR, ErrReply} 9317%% end; 9318%% otp72923_mg_verify_notify_request(Else) -> 9319%% io:format("otp72923_mg_verify_notify_request -> unknown" 9320%% "~n Else: ~p~n", [Else]), 9321%% ED = otp72923_err_desc(Else), 9322%% ErrReply = {discard_ack, ED}, 9323%% {error, Else, ErrReply}. 9324 9325otp72923_mg_verify_notify_reply({handle_trans_reply, _CH, ?VERSION, 9326 {ok, [AR]}, _}) -> 9327 io:format("otp72923_mg_verify_notify_reply -> ok" 9328 "~n AR: ~p~n", [AR]), 9329 {ok, AR, ok}; 9330otp72923_mg_verify_notify_reply(Else) -> 9331 io:format("otp72923_mg_verify_notify_reply -> unknown" 9332 "~n Else: ~p~n", [Else]), 9333 {error, Else, ok}. 9334 9335otp72923_mg_service_change_request_ar(_Mid, Cid) -> 9336 Prof = cre_serviceChangeProf("resgw", 1), 9337 SCP = cre_serviceChangeParm(restart, ["901 mg col boot"], Prof), 9338 Root = #megaco_term_id{id = ["root"]}, 9339 SCR = cre_serviceChangeReq([Root], SCP), 9340 CMD = cre_command(SCR), 9341 CR = cre_cmdReq(CMD), 9342 cre_actionReq(Cid, [CR]). 9343 9344%% otp72923_mg_service_change_request_msg(Mid, TransId, Cid) -> 9345%% AR = otp72923_mg_service_change_request_ar(Mid, Cid), 9346%% TR = cre_transReq(TransId, [AR]), 9347%% Trans = cre_transaction(TR), 9348%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 9349%% cre_megacoMessage(Mess). 9350 9351%% otp72923_mg_notify_reply_ar(Cid, TermId) -> 9352%% NR = cre_notifyReply([TermId]), 9353%% CR = cre_cmdReply(NR), 9354%% cre_actionReply(Cid, [CR]). 9355 9356otp72923_mg_notify_request_ar(Rid, Tid, Cid) -> 9357 TT = cre_timeNotation("19990729", "22000000"), 9358 Ev = cre_obsEvent("al/of", TT), 9359 EvsDesc = cre_obsEvsDesc(Rid, [Ev]), 9360 NR = cre_notifyReq([Tid], EvsDesc), 9361 CMD = cre_command(NR), 9362 CR = cre_cmdReq(CMD), 9363 cre_actionReq(Cid, [CR]). 9364 9365%% otp72923_notify_request_msg(Mid, TransId, Rid, TermId, Cid) -> 9366%% AR = otp72923_mg_notify_request_ar(Rid, TermId, Cid), 9367%% TR = cre_transReq(TransId, [AR]), 9368%% Trans = cre_transaction(TR), 9369%% Mess = cre_message(?VERSION, Mid, cre_transactions([Trans])), 9370%% cre_megacoMessage(Mess). 9371 9372 9373%% 9374%% Common functions for the multi_trans_req_timeout test case 9375%% 9376 9377otp72923_err_desc(T) -> 9378 cre_ErrDesc(T). 9379 9380 9381%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 9382 9383%% 9384%% Common message creation functions 9385%% 9386 9387cre_ErrDesc(T) -> 9388 cre_ErrDesc(?megaco_internal_gateway_error, T). 9389 9390cre_ErrDesc(EC, T) -> 9391 ET = lists:flatten(io_lib:format("~w",[T])), 9392 #'ErrorDescriptor'{errorCode = EC, errorText = ET}. 9393 9394cre_serviceChangeParm(M,R,P) -> 9395 #'ServiceChangeParm'{serviceChangeMethod = M, 9396 serviceChangeReason = R, 9397 serviceChangeProfile = P}. 9398 9399cre_serviceChangeReq(Tid, Parms) -> 9400 #'ServiceChangeRequest'{terminationID = Tid, 9401 serviceChangeParms = Parms}. 9402 9403cre_timeNotation(D,T) -> 9404 #'TimeNotation'{date = D, time = T}. 9405 9406cre_obsEvent(Name, Not) -> 9407 #'ObservedEvent'{eventName = Name, 9408 timeNotation = Not}. 9409%% cre_obsEvent(Name, Not, Par) -> 9410%% #'ObservedEvent'{eventName = Name, 9411%% timeNotation = Not, 9412%% eventParList = Par}. 9413 9414cre_obsEvsDesc(Id, EvList) -> 9415 #'ObservedEventsDescriptor'{requestId = Id, 9416 observedEventLst = EvList}. 9417 9418cre_notifyReq(Tid, EvsDesc) -> 9419 #'NotifyRequest'{terminationID = Tid, 9420 observedEventsDescriptor = EvsDesc}. 9421 9422cre_command(R) when is_record(R, 'NotifyRequest') -> 9423 {notifyReq, R}; 9424cre_command(R) when is_record(R, 'ServiceChangeRequest') -> 9425 {serviceChangeReq, R}. 9426 9427cre_cmdReq(Cmd) -> 9428 #'CommandRequest'{command = Cmd}. 9429 9430cre_actionReq(CtxId, CmdReqs) when is_list(CmdReqs) -> 9431 #'ActionRequest'{contextId = CtxId, 9432 commandRequests = CmdReqs}. 9433 9434%% cre_transReq(TransId, ARs) when is_list(ARs) -> 9435%% #'TransactionRequest'{transactionId = TransId, 9436%% actions = ARs}. 9437 9438%% -- 9439 9440cre_serviceChangeResParm(Mid) -> 9441 #'ServiceChangeResParm'{serviceChangeMgcId = Mid}. 9442 9443cre_serviceChangeResult(SCRP) when is_record(SCRP, 'ServiceChangeResParm') -> 9444 {serviceChangeResParms, SCRP}; 9445cre_serviceChangeResult(ED) when is_record(ED, 'ErrorDescriptor') -> 9446 {errorDescriptor, ED}. 9447 9448cre_serviceChangeReply(Tid, Res) -> 9449 #'ServiceChangeReply'{terminationID = Tid, 9450 serviceChangeResult = Res}. 9451 9452cre_cmdReply(R) when is_record(R, 'NotifyReply') -> 9453 {notifyReply, R}; 9454cre_cmdReply(R) when is_record(R, 'ServiceChangeReply') -> 9455 {serviceChangeReply, R}. 9456 9457cre_notifyReply(Tid) -> 9458 #'NotifyReply'{terminationID = Tid}. 9459 9460cre_actionReply(CtxId, CmdRep) -> 9461 #'ActionReply'{contextId = CtxId, 9462 commandReply = CmdRep}. 9463 9464%% cre_transResult(ED) when is_record(ED, 'ErrorDescriptor') -> 9465%% {transactionError, ED}; 9466%% cre_transResult([AR|_] = ARs) when is_record(AR, 'ActionReply') -> 9467%% {actionReplies, ARs}. 9468 9469%% cre_transReply(TransId, Res) -> 9470%% #'TransactionReply'{transactionId = TransId, 9471%% transactionResult = Res}. 9472 9473 9474%% -- 9475 9476cre_serviceChangeProf(Name, Ver) when is_list(Name) andalso is_integer(Ver) -> 9477 #'ServiceChangeProfile'{profileName = Name, 9478 version = Ver}. 9479 9480%% cre_transaction(Trans) when is_record(Trans, 'TransactionRequest') -> 9481%% {transactionRequest, Trans}; 9482%% cre_transaction(Trans) when is_record(Trans, 'TransactionPending') -> 9483%% {transactionPending, Trans}; 9484%% cre_transaction(Trans) when is_record(Trans, 'TransactionReply') -> 9485%% {transactionReply, Trans}; 9486%% cre_transaction(Trans) when is_record(Trans, 'TransactionAck') -> 9487%% {transactionResponseAck, Trans}. 9488 9489%% cre_transactions(Trans) when is_list(Trans) -> 9490%% {transactions, Trans}. 9491 9492%% cre_message(Version, Mid, Body) -> 9493%% #'Message'{version = Version, 9494%% mId = Mid, 9495%% messageBody = Body}. 9496 9497%% cre_megacoMessage(Mess) -> 9498%% #'MegacoMessage'{mess = Mess}. 9499 9500 9501%% 9502%% Common functions 9503%% 9504 9505%% encode_msg_fun(Mod, Conf) -> 9506%% fun(M) -> 9507%% Mod:encode_message(Conf, M) 9508%% end. 9509%% encode_msg_fun(Mod, Conf, Ver) -> 9510%% fun(M) -> 9511%% Mod:encode_message(Conf, Ver, M) 9512%% end. 9513 9514%% decode_msg_fun(Mod, Conf) -> 9515%% fun(M) -> 9516%% Mod:decode_message(Conf, M) 9517%% end. 9518%% decode_msg_fun(Mod, Conf, Ver) -> 9519%% fun(M) -> 9520%% Mod:decode_message(Conf, Ver, M) 9521%% end. 9522 9523 9524%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 9525 9526await_ack(_User, 0, Timeout, _Expected) -> 9527 d("await_ack -> done when Timeout = ~p", [Timeout]), 9528 ok; 9529await_ack(User, N, Timeout, Expected) when (N > 0) andalso is_integer(Timeout) -> 9530 d("await_ack -> entry with N: ~p, Timeout: ~p", [N,Timeout]), 9531 T = tim(), 9532 receive 9533 {ack_received, User, Expected} -> 9534 d("await_ack -> received another expected ack"), 9535 await_ack(User, N-1, Timeout - (tim() - T), Expected); 9536 {ack_received, User, UnExpected} -> 9537 e("await_ack -> received unexpected ack result: ~p", [UnExpected]), 9538 exit({unexpected_ack_result, UnExpected, Expected}) 9539 after Timeout -> 9540 exit({await_ack_timeout, N}) 9541 end; 9542await_ack(User, N, infinity, Expected) when N > 0 -> 9543 d("await_ack -> entry with N: ~p", [N]), 9544 receive 9545 {ack_received, User, Expected} -> 9546 d("await_ack -> received another ack"), 9547 await_ack(User, N-1, infinity, Expected); 9548 {ack_received, User, UnExpected} -> 9549 e("await_ack -> unexpected ack result: ~p", [UnExpected]), 9550 exit({unexpected_ack_result, UnExpected, Expected}) 9551 end. 9552 9553 9554tim() -> 9555 {A,B,C} = erlang:timestamp(), 9556 A*1000000000+B*1000+(C div 1000). 9557 9558 9559make_node_name(Name) -> 9560 case string:tokens(atom_to_list(node()), [$@]) of 9561 [_,Host] -> 9562 list_to_atom(lists:concat([atom_to_list(Name) ++ "@" ++ Host])); 9563 _ -> 9564 exit("Test node must be started with '-sname'") 9565 end. 9566 9567 9568%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 9569 9570await_completion(Ids) -> 9571 case megaco_test_generator_lib:await_completion(Ids) of 9572 {ok, Reply} -> 9573 d("OK => Reply: ~n~p", [Reply]), 9574 ok; 9575 {error, Reply} -> 9576 e("await completion failed: " 9577 "~n ~p", [Reply]), 9578 ?ERROR({failed, Reply}) 9579 end. 9580 9581await_completion(Ids, Timeout) -> 9582 case megaco_test_generator_lib:await_completion(Ids, Timeout) of 9583 {ok, Reply} -> 9584 d("OK => Reply: ~n~p", [Reply]), 9585 ok; 9586 {error, Reply} -> 9587 e("await completion failed: " 9588 "~n ~p" 9589 "~n ~p", [Timeout, Reply]), 9590 ?ERROR({failed, Reply}) 9591 end. 9592 9593 9594%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 9595 9596mgc_start(Pid, Mid, ET, Verb) -> 9597 try ?MGC:start(Pid, Mid, ET, Verb) of 9598 {ok, MGC} -> 9599 MGC; 9600 {error, StartReason} -> 9601 e("failed starting mgc (error): " 9602 "~n ~p", [StartReason]), 9603 ?SKIP({failed_starting, mgc, StartReason}) 9604 catch 9605 exit:{error, timeout} -> 9606 e("failed starting mgc (exit): timeout"), 9607 ?SKIP({failed_starting, mgc, timeout}); 9608 exit:{failed_starting, _, StartExitReason} -> 9609 e("failed starting mgc (exit): " 9610 "~n ~p", [StartExitReason]), 9611 ?SKIP({failed_starting, mgc, StartExitReason}) 9612 end. 9613 9614 9615mg_start(Pid, Mid, Enc, Transp, Conf, Verb) -> 9616 try ?MG:start(Pid, Mid, Enc, Transp, Conf, Verb) of 9617 {ok, MG} -> 9618 MG; 9619 {error, Reason} -> 9620 e("failed starting mg (error): " 9621 "~n ~p", [Reason]), 9622 ?SKIP({failed_starting, mgc, Reason}) 9623 catch 9624 exit:{error, timeout} -> 9625 e("failed starting mg (exit): timeout"), 9626 ?SKIP({failed_starting, mg, timeout}); 9627 exit:{failed_starting, _, ExitReason} -> 9628 e("failed starting mg (exit): " 9629 "~n ~p", [ExitReason]), 9630 ?SKIP({failed_starting, mg, ExitReason}) 9631 end. 9632 9633 9634%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 9635 9636try_tc(TCName, Pre, Case, Post) -> 9637 try_tc(TCName, "TEST", ?TEST_VERBOSITY, Pre, Case, Post). 9638 9639try_tc(TCName, Name, Verbosity, Pre, Case, Post) -> 9640 ?TRY_TC(TCName, Name, Verbosity, Pre, Case, Post). 9641 9642 9643 9644%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 9645 9646sleep(X) -> receive after X -> ok end. 9647 9648%% error_msg(F,A) -> error_logger:error_msg(F ++ "~n",A). 9649 9650 9651%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 9652 9653p(F, A) -> 9654 io:format("*** [~s] ~p ***" 9655 "~n " ++ F ++ "~n", 9656 [?FTS(), self() | A]). 9657 9658e(F) -> 9659 e(F, []). 9660 9661e(F, A) -> 9662 print(error, "ERROR", F, A). 9663 9664 9665i(F) -> 9666 i(F, []). 9667 9668i(F, A) -> 9669 print(info, "INFO", F, A). 9670 9671 9672d(F) -> 9673 d(F, []). 9674 9675d(F, A) -> 9676 print(debug, "DBG", F, A). 9677 9678 9679print(Severity, P, F, A) -> 9680 print2(printable(Severity), P, F, A). 9681 9682printable(Sev) -> 9683 printable(Sev, get(verbosity)). 9684 9685printable(_, debug) -> true; 9686printable(info, info) -> true; 9687printable(error, _) -> true; 9688printable(_,_) -> false. 9689 9690print2(true, P, F, A) -> 9691 S = ?F("*** [~s] ~s ~p~s ***" 9692 "~n " ++ F ++ "~n" 9693 "~n", [?FTS(), P, self(), case get(tc) of 9694 undefined -> ""; 9695 TC -> " " ++ atom_to_list(TC) 9696 end | A]), 9697 io:format("~s", [S]); 9698print2(_, _, _, _) -> 9699 ok. 9700 9701 9702