diff options
Diffstat (limited to 'lib/snmp/test/snmp_manager_user_test_lib.erl')
| -rw-r--r-- | lib/snmp/test/snmp_manager_user_test_lib.erl | 422 |
1 files changed, 422 insertions, 0 deletions
diff --git a/lib/snmp/test/snmp_manager_user_test_lib.erl b/lib/snmp/test/snmp_manager_user_test_lib.erl new file mode 100644 index 0000000000..a49fe93178 --- /dev/null +++ b/lib/snmp/test/snmp_manager_user_test_lib.erl @@ -0,0 +1,422 @@ +%% +%% %CopyrightBegin% +%% +%% Copyright Ericsson AB 2004-2009. All Rights Reserved. +%% +%% The contents of this file are subject to the Erlang Public License, +%% Version 1.1, (the "License"); you may not use this file except in +%% compliance with the License. You should have received a copy of the +%% Erlang Public License along with this software. If not, it can be +%% retrieved online at http://www.erlang.org/. +%% +%% Software distributed under the License is distributed on an "AS IS" +%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See +%% the License for the specific language governing rights and limitations +%% under the License. +%% +%% %CopyrightEnd% +%% + +%%---------------------------------------------------------------------- +%% Purpose: Utility functions for the (snmp manager) user test(s). +%%---------------------------------------------------------------------- + +-module(snmp_manager_user_test_lib). + +-behaviour(snmpm_user). + + +%%---------------------------------------------------------------------- +%% Include files +%%---------------------------------------------------------------------- +-include("test_server.hrl"). +-include("snmp_test_lib.hrl"). + + +%%---------------------------------------------------------------------- +%% External exports +%%---------------------------------------------------------------------- +-export([ + start_link/0, stop/1, + simulate_crash/2, + register/2, register/3, + register_monitor/2, register_monitor/3, + unregister/1, unregister/2, + register_agent/4 + ]). + +%%---------------------------------------------------------------------- +%% Internal exports +%%---------------------------------------------------------------------- +-export([ + user/1 + ]). + +-export([ + handle_error/3, + handle_agent/4, + handle_pdu/4, + handle_pdu/5, % For backwards compatibillity + handle_trap/3, + handle_trap/4, % For backwards compatibillity + handle_inform/3, + handle_inform/4, % For backwards compatibillity + handle_report/3, + handle_report/4 % For backwards compatibillity + ]). + + +-record(state, {parent, ids = []}). + + +%%---------------------------------------------------------------------- +%% The user simulation API +%%---------------------------------------------------------------------- + +start_link() -> + S = #state{parent = self()}, + proc_lib:start_link(?MODULE, user, [S]). + +stop(Pid) -> + cast(Pid, stop). + +simulate_crash(Pid, Reason) -> + call(Pid, {simulate_crash, Reason}). + +%% For backwards compatibillity +register(Pid, Id) -> + call(Pid, {register, Id}). + +register(Pid, Id, DefaultAgentConfig) -> + call(Pid, {register, Id, DefaultAgentConfig}). + +%% For backwards compatibillity +register_monitor(Pid, Id) -> + call(Pid, {register_monitor, Id}). + +register_monitor(Pid, Id, DefaultAgentConfig) -> + call(Pid, {register_monitor, Id, DefaultAgentConfig}). + +unregister(Pid) -> + call(Pid, unregister). + +unregister(Pid, Id) -> + call(Pid, {unregister, Id}). + +register_agent(Pid, Id, TargetName, AgentConfig) -> + call(Pid, {register_agent, Id, TargetName, AgentConfig}). + +user(#state{parent = Pid} = S) -> + proc_lib:init_ack(Pid, {ok, self()}), + user_loop(S). + +user_loop(#state{parent = Parent} = S) -> + receive + {stop, Parent} -> + exit(normal); + + {{simulate_crash, Reason}, Parent, Ref} -> + reply(Parent, ok, Ref), + exit(Reason); + + %% For backwards compatibillity + {{register, Id}, Parent, Ref} -> + IDs = S#state.ids, + case lists:member(Id, IDs) of + false -> + Res = snmpm:register_user(Id, ?MODULE, self()), + reply(Parent, Res, Ref), + user_loop(S#state{ids = [Id|IDs]}); + true -> + reply(Parent, {error, already_registered}, Ref), + user_loop(S) + end; + + {{register, Id, DefaultAgentConf}, Parent, Ref} -> + IDs = S#state.ids, + case lists:member(Id, IDs) of + false -> + Res = snmpm:register_user(Id, ?MODULE, self(), + DefaultAgentConf), + reply(Parent, Res, Ref), + user_loop(S#state{ids = [Id|IDs]}); + true -> + reply(Parent, {error, already_registered}, Ref), + user_loop(S) + end; + + %% For backwards compatibillity + {{register_monitor, Id}, Parent, Ref} -> + IDs = S#state.ids, + case lists:member(Id, IDs) of + false -> + Res = snmpm:register_user_monitor(Id, ?MODULE, self()), + reply(Parent, Res, Ref), + user_loop(S#state{ids = [Id|IDs]}); + true -> + reply(Parent, {error, already_registered}, Ref), + user_loop(S) + end; + + {{register_monitor, Id, DefaultAgentConf}, Parent, Ref} -> + IDs = S#state.ids, + case lists:member(Id, IDs) of + false -> + Res = snmpm:register_user_monitor(Id, ?MODULE, self(), + DefaultAgentConf), + reply(Parent, Res, Ref), + user_loop(S#state{ids = [Id|IDs]}); + true -> + reply(Parent, {error, already_registered}, Ref), + user_loop(S) + end; + + {unregister, Parent, Ref} -> + Res = [snmpm:unregister_user(Id) || Id <- S#state.ids], + reply(Parent, {ok, Res}, Ref), + user_loop(S); + + {{unregister, Id}, Parent, Ref} -> + IDs = S#state.ids, + IDs2 = + case lists:member(Id, IDs) of + true -> + Res = snmpm:unregister_user(Id), + reply(Parent, Res, Ref), + lists:delete(Id, IDs); + false -> + reply(Parent, {error, not_registered}, Ref), + IDs + end, + user_loop(S#state{ids = IDs2}); + + {{register_agent, Id, TargetName, Config}, Parent, Ref} -> + IDs = S#state.ids, + case lists:member(Id, IDs) of + true -> + Res = snmpm:register_agent(Id, TargetName, Config), + reply(Parent, Res, Ref), + user_loop(S); + false -> + reply(Parent, {error, {unknown_user, Id}}, Ref), + user_loop(S) + end; + + + + %% SNMP manager callback messages (from our callback API): + + {handle_error, Pid, ReqId, Reason} -> + do_handle_error(Pid, ReqId, Reason), + user_loop(S); + + {handle_agent, Pid, Addr, Port, SnmpInfo} -> + do_handle_agent(Pid, Addr, Port, SnmpInfo), + user_loop(S); + + {handle_pdu, Pid, TargetName, ReqId, SnmpResponse} -> + do_handle_pdu(Pid, TargetName, ReqId, SnmpResponse), + user_loop(S); + + {handle_pdu, Pid, Addr, Port, ReqId, SnmpResponse} -> + do_handle_pdu(Pid, Addr, Port, ReqId, SnmpResponse), + user_loop(S); + + {handle_trap, Pid, TargetName, SnmpTrap} -> + do_handle_trap(Pid, TargetName, SnmpTrap), + user_loop(S); + + {handle_trap, Pid, Addr, Port, SnmpTrap} -> + do_handle_trap(Pid, Addr, Port, SnmpTrap), + user_loop(S); + + {handle_inform, Pid, TargetName, SnmpInform} -> + do_handle_inform(Pid, TargetName, SnmpInform), + user_loop(S); + + {handle_inform, Pid, Addr, Port, SnmpInform} -> + do_handle_inform(Pid, Addr, Port, SnmpInform), + user_loop(S); + + {handle_report, Pid, TargetName, SnmpReport} -> + do_handle_report(Pid, TargetName, SnmpReport), + user_loop(S); + + {handle_report, Pid, Addr, Port, SnmpReport} -> + do_handle_report(Pid, Addr, Port, SnmpReport), + user_loop(S); + + Unknown -> + info("received unknown message: ~n~p", [Unknown]), + user_loop(S) + end. + + +%% ------------- + +do_handle_error(Pid, ReqId, Reason) -> + info("received error callback:" + "~n ReqId: ~p" + "~n Reason: ~p", [ReqId, Reason]), + Pid ! {ignore, self()}, + ok. + + +do_handle_agent(Pid, Addr, Port, SnmpInfo) -> + info("received agent callback:" + "~n Addr: ~p" + "~n Port: ~p" + "~n SnmpInfo: ~p", [Addr, Port, SnmpInfo]), + Pid ! {ignore, self()}, + ok. + + +do_handle_pdu(Pid, TargetName, ReqId, SnmpResponse) -> + info("received pdu callback:" + "~n TargetName: ~p" + "~n ReqId: ~p" + "~n SnmpResponse: ~p", [TargetName, ReqId, SnmpResponse]), + Pid ! {ignore, self()}, + ok. + +%% For backwards compatibillity +do_handle_pdu(Pid, Addr, Port, ReqId, SnmpResponse) -> + info("received pdu callback:" + "~n Addr: ~p" + "~n Port: ~p" + "~n ReqId: ~p" + "~n SnmpResponse: ~p", [Addr, Port, ReqId, SnmpResponse]), + Pid ! {ignore, self()}, + ok. + + +do_handle_trap(Pid, TargetName, SnmpTrap) -> + info("received trap callback:" + "~n TargetName: ~p" + "~n SnmpTrap: ~p", [TargetName, SnmpTrap]), + Pid ! {ignore, self()}, + ok. + +%% For backwards compatibillity +do_handle_trap(Pid, Addr, Port, SnmpTrap) -> + info("received trap callback:" + "~n Addr: ~p" + "~n Port: ~p" + "~n SnmpTrap: ~p", [Addr, Port, SnmpTrap]), + Pid ! {ignore, self()}, + ok. + + +do_handle_inform(Pid, TargetName, SnmpInform) -> + info("received inform callback:" + "~n TargetName: ~p" + "~n SnmpInform: ~p", [TargetName, SnmpInform]), + Pid ! {ignore, self()}, + ok. + +%% For backwards compatibillity +do_handle_inform(Pid, Addr, Port, SnmpInform) -> + info("received inform callback:" + "~n Addr: ~p" + "~n Port: ~p" + "~n SnmpInform: ~p", [Addr, Port, SnmpInform]), + Pid ! {ignore, self()}, + ok. + + +do_handle_report(Pid, TargetName, SnmpReport) -> + info("received report callback:" + "~n TargetName: ~p" + "~n SnmpReport: ~p", [TargetName, SnmpReport]), + Pid ! {ignore, self()}, + ok. + +%% For backwards compatibillity +do_handle_report(Pid, Addr, Port, SnmpReport) -> + info("received report callback:" + "~n Addr: ~p" + "~n Port: ~p" + "~n SnmpReport: ~p", [Addr, Port, SnmpReport]), + Pid ! {ignore, self()}, + ok. + + +info(F, A) -> + error_logger:info_msg("USER SIMULATOR " ++ F ++ "~n", A). + + +%% ------------- + +call(UserPid, Req) -> + call(UserPid, Req, 5000). + +call(UserPid, Req, To) -> + Ref = make_ref(), + UserPid ! {Req, self(), Ref}, + receive + {Reply, UserPid, Ref} -> + Reply + after To -> + {error, timeout} + end. + +reply(Pid, Reply, Ref) -> + Pid ! {Reply, self(), Ref}. + +cast(UserPid, Msg) -> + UserPid ! {Msg, self()}, + ok. + + +%%---------------------------------------------------------------------- +%% User callback functions: +%%---------------------------------------------------------------------- + +handle_error(ReqId, Reason, UserPid) -> + UserPid ! {handle_error, self(), ReqId, Reason}, + ignore. + + +handle_agent(Addr, Port, SnmpInfo, UserPid) -> + UserPid ! {handle_agent, self(), Addr, Port, SnmpInfo}, + ignore. + + +handle_pdu(TargetName, ReqId, SnmpResponse, UserPid) -> + UserPid ! {handle_pdu, self(), TargetName, ReqId, SnmpResponse}, + ignore. + +%% For backwards compatibillity +handle_pdu(Addr, Port, ReqId, SnmpResponse, UserPid) -> + UserPid ! {handle_pdu, self(), Addr, Port, ReqId, SnmpResponse}, + ignore. + + +handle_trap(TargetName, SnmpTrap, UserPid) -> + UserPid ! {handle_trap, self(), TargetName, SnmpTrap}, + ok. + +%% For backwards compatibillity +handle_trap(Addr, Port, SnmpTrap, UserPid) -> + UserPid ! {handle_trap, self(), Addr, Port, SnmpTrap}, + ok. + + +handle_inform(TargetName, SnmpInform, UserPid) -> + UserPid ! {handle_inform, self(), TargetName, SnmpInform}, + ok. + +%% For backwards compatibillity +handle_inform(Addr, Port, SnmpInform, UserPid) -> + UserPid ! {handle_inform, self(), Addr, Port, SnmpInform}, + ok. + + +handle_report(TargetName, SnmpReport, UserPid) -> + UserPid ! {handle_report, self(), TargetName, SnmpReport}, + ok. + +%% For backwards compatibillity +handle_report(Addr, Port, SnmpReport, UserPid) -> + UserPid ! {handle_report, self(), Addr, Port, SnmpReport}, + ok. |