← Back to branch summary

~ubuntu-branches/debian/squeeze/erlang/squeeze

« back to all changes in this revision

Viewing changes to lib/snmp/test/snmp_manager_user_test_lib.erl

  • Committer: Bazaar Package Importer
  • Author(s): Erlang Packagers, Sergei Golovan
  • Date: 2006-12-03 17:07:44 UTC
  • mfrom: (2.1.11 feisty)
  • Revision ID: james.westby@ubuntu.com-20061203170744-rghjwupacqlzs6kv
Tags: 1:11.b.2-4
[ Sergei Golovan ]
Fixed erlang-base and erlang-base-hipe prerm scripts.

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/snmp/test/snmp_manager_user_test_lib.erl
 
1
%% ``The contents of this file are subject to the Erlang Public License,
 
2
%% Version 1.1, (the "License"); you may not use this file except in
 
3
%% compliance with the License. You should have received a copy of the
 
4
%% Erlang Public License along with this software. If not, it can be
 
5
%% retrieved via the world wide web at http://www.erlang.org/.
 
6
%%
 
7
%% Software distributed under the License is distributed on an "AS IS"
 
8
%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
 
9
%% the License for the specific language governing rights and limitations
 
10
%% under the License.
 
11
%%
 
12
%% The Initial Developer of the Original Code is Ericsson Utvecklings AB.
 
13
%% Portions created by Ericsson are Copyright 1999, Ericsson Utvecklings
 
14
%% AB. All Rights Reserved.''
 
15
%%
 
16
%%     $Id$
 
17
%%
 
18
%%----------------------------------------------------------------------
 
19
%% Purpose: Utility functions for the (snmp manager) user test(s).
 
20
%%----------------------------------------------------------------------
 
21
 
 
22
-module(snmp_manager_user_test_lib).
 
23
 
 
24
-behaviour(snmpm_user).
 
25
 
 
26
 
 
27
%%----------------------------------------------------------------------
 
28
%% Include files
 
29
%%----------------------------------------------------------------------
 
30
-include("test_server.hrl").
 
31
-include("snmp_test_lib.hrl").
 
32
 
 
33
 
 
34
%%----------------------------------------------------------------------
 
35
%% External exports
 
36
%%----------------------------------------------------------------------
 
37
-export([
 
38
         start_link/0, stop/1,
 
39
         simulate_crash/2,
 
40
         register/2, register_monitor/2, unregister/1, unregister/2
 
41
        ]).
 
42
 
 
43
%%----------------------------------------------------------------------
 
44
%% Internal exports
 
45
%%----------------------------------------------------------------------
 
46
-export([
 
47
         user/1
 
48
        ]).
 
49
 
 
50
-export([handle_error/3,
 
51
         handle_agent/4,
 
52
         handle_pdu/5,
 
53
         handle_trap/4,
 
54
         handle_inform/4,
 
55
         handle_report/4]).
 
56
 
 
57
 
 
58
-record(state, {parent, ids = []}).
 
59
 
 
60
 
 
61
%%----------------------------------------------------------------------
 
62
%% The user simulation API
 
63
%%----------------------------------------------------------------------
 
64
 
 
65
start_link() ->
 
66
    S = #state{parent = self()},
 
67
    proc_lib:start_link(?MODULE, user, [S]).
 
68
 
 
69
stop(Pid) ->
 
70
    cast(Pid, stop).
 
71
 
 
72
simulate_crash(Pid, Reason) ->
 
73
    call(Pid, {simulate_crash, Reason}).
 
74
 
 
75
register(Pid, Id) ->
 
76
    call(Pid, {register, Id}).
 
77
 
 
78
register_monitor(Pid, Id) ->
 
79
    call(Pid, {register_monitor, Id}).
 
80
 
 
81
unregister(Pid) ->
 
82
    call(Pid, unregister).
 
83
 
 
84
unregister(Pid, Id) ->
 
85
    call(Pid, {unregister, Id}).
 
86
 
 
87
user(#state{parent = Pid} = S) ->
 
88
    proc_lib:init_ack(Pid, {ok, self()}),
 
89
    user_loop(S).
 
90
 
 
91
user_loop(#state{parent = Parent} = S) ->
 
92
    receive
 
93
        {stop, Parent} ->
 
94
            exit(normal);
 
95
 
 
96
        {{simulate_crash, Reason}, Parent, Ref} ->
 
97
            reply(Parent, ok, Ref),
 
98
            exit(Reason);
 
99
        
 
100
        {{register, Id}, Parent, Ref} ->
 
101
            IDs = S#state.ids,
 
102
            case lists:member(Id, IDs) of
 
103
                false ->
 
104
                    Res = snmpm:register_user(Id, ?MODULE, self()),
 
105
                    reply(Parent, Res, Ref),
 
106
                    user_loop(S#state{ids = [Id|IDs]});
 
107
                true ->
 
108
                    reply(Parent, {error, already_registered}, Ref),
 
109
                    user_loop(S)
 
110
            end;
 
111
        
 
112
        {{register_monitor, Id}, Parent, Ref} ->
 
113
            IDs = S#state.ids,
 
114
            case lists:member(Id, IDs) of
 
115
                false ->
 
116
                    Res = snmpm:register_user_monitor(Id, ?MODULE, self()),
 
117
                    reply(Parent, Res, Ref),
 
118
                    user_loop(S#state{ids = [Id|IDs]});
 
119
                true ->
 
120
                    reply(Parent, {error, already_registered}, Ref),
 
121
                    user_loop(S)
 
122
            end;
 
123
        
 
124
        {unregister, Parent, Ref} ->
 
125
            Res = [snmpm:unregister_user(Id) || Id <- S#state.ids],
 
126
            reply(Parent, {ok, Res}, Ref),
 
127
            user_loop(S);
 
128
        
 
129
        {{unregister, Id}, Parent, Ref} ->
 
130
            IDs = S#state.ids,
 
131
            IDs2 = 
 
132
                case lists:member(Id, IDs) of
 
133
                    true ->
 
134
                        Res = snmpm:unregister_user(Id),
 
135
                        reply(Parent, Res, Ref),
 
136
                        lists:delete(Id, IDs);
 
137
                    false ->
 
138
                        reply(Parent, {error, not_registered}, Ref),
 
139
                        IDs
 
140
                end,
 
141
            user_loop(S#state{ids = IDs2});
 
142
        
 
143
 
 
144
        %% SNMP manager callback messages (from our callback API):
 
145
 
 
146
        {handle_error, Pid, ReqId, Reason} ->
 
147
            do_handle_error(Pid, ReqId, Reason),
 
148
            user_loop(S);
 
149
 
 
150
        {handle_agent, Pid, Addr, Port, SnmpInfo} ->
 
151
            do_handle_agent(Pid, Addr, Port, SnmpInfo),
 
152
            user_loop(S);
 
153
 
 
154
        {handle_pdu, Pid, Addr, Port, ReqId, SnmpResponse} ->
 
155
            do_handle_pdu(Pid, Addr, Port, ReqId, SnmpResponse),
 
156
            user_loop(S);
 
157
 
 
158
        {handle_trap, Pid, Addr, Port, SnmpTrap} ->
 
159
            do_handle_trap(Pid, Addr, Port, SnmpTrap),
 
160
            user_loop(S);
 
161
 
 
162
        {handle_inform, Pid, Addr, Port, SnmpInform} ->
 
163
            do_handle_inform(Pid, Addr, Port, SnmpInform),
 
164
            user_loop(S);
 
165
 
 
166
        {handle_report, Pid, Addr, Port, SnmpReport} ->
 
167
            do_handle_report(Pid, Addr, Port, SnmpReport),
 
168
            user_loop(S);
 
169
 
 
170
        Unknown ->
 
171
            info("received unknown message: ~n~p", [Unknown]),
 
172
            user_loop(S)
 
173
    end.
 
174
            
 
175
 
 
176
%% -------------
 
177
 
 
178
do_handle_error(Pid, ReqId, Reason) ->
 
179
    info("received error callback:"
 
180
         "~n   ReqId:    ~p"
 
181
         "~n   Reason:   ~p", [ReqId, Reason]),
 
182
    Pid ! {ignore, self()},
 
183
    ok.
 
184
 
 
185
 
 
186
do_handle_agent(Pid, Addr, Port, SnmpInfo) ->
 
187
    info("received agent callback:"
 
188
         "~n   Addr:     ~p"
 
189
         "~n   Port:     ~p"
 
190
         "~n   SnmpInfo: ~p", [Addr, Port, SnmpInfo]),
 
191
    Pid ! {ignore, self()},
 
192
    ok.
 
193
 
 
194
 
 
195
do_handle_pdu(Pid, Addr, Port, ReqId, SnmpResponse) ->
 
196
    info("received pdu callback:"
 
197
         "~n   Addr:         ~p"
 
198
         "~n   Port:         ~p"
 
199
         "~n   ReqId:        ~p"
 
200
         "~n   SnmpResponse: ~p", [Addr, Port, ReqId, SnmpResponse]),
 
201
    Pid ! {ignore, self()},
 
202
    ok.
 
203
 
 
204
 
 
205
do_handle_trap(Pid, Addr, Port, SnmpTrap) ->
 
206
    info("received trap callback:"
 
207
         "~n   Addr:     ~p"
 
208
         "~n   Port:     ~p"
 
209
         "~n   SnmpTrap: ~p", [Addr, Port, SnmpTrap]),
 
210
    Pid ! {ignore, self()},
 
211
    ok.
 
212
 
 
213
 
 
214
do_handle_inform(Pid, Addr, Port, SnmpInform) ->
 
215
    info("received inform callback:"
 
216
         "~n   Addr:       ~p"
 
217
         "~n   Port:       ~p"
 
218
         "~n   SnmpInform: ~p", [Addr, Port, SnmpInform]),
 
219
    Pid ! {ignore, self()},
 
220
    ok.
 
221
 
 
222
 
 
223
do_handle_report(Pid, Addr, Port, SnmpReport) ->
 
224
    info("received report callback:"
 
225
         "~n   Addr:       ~p"
 
226
         "~n   Port:       ~p"
 
227
         "~n   SnmpReport: ~p", [Addr, Port, SnmpReport]),
 
228
    Pid ! {ignore, self()},
 
229
    ok.
 
230
 
 
231
 
 
232
info(F, A) ->
 
233
    error_logger:info_msg("USER SIMULATOR " ++ F ++ "~n", A).
 
234
 
 
235
 
 
236
%% -------------
 
237
 
 
238
call(UserPid, Req) ->
 
239
    call(UserPid, Req, 5000).
 
240
 
 
241
call(UserPid, Req, To) ->
 
242
    Ref = make_ref(),
 
243
    UserPid ! {Req, self(), Ref},
 
244
    receive
 
245
        {Reply, UserPid, Ref} ->
 
246
            Reply
 
247
    after To ->
 
248
            {error, timeout}
 
249
    end.
 
250
 
 
251
reply(Pid, Reply, Ref) ->    
 
252
    Pid ! {Reply, self(), Ref}.
 
253
 
 
254
cast(UserPid, Msg) ->
 
255
    UserPid ! {Msg, self()},
 
256
    ok.
 
257
 
 
258
 
 
259
%%----------------------------------------------------------------------
 
260
%% User callback functions:
 
261
%%----------------------------------------------------------------------
 
262
 
 
263
handle_error(ReqId, Reason, UserPid) ->
 
264
    UserPid ! {handle_error, self(), ReqId, Reason},
 
265
    ignore.
 
266
 
 
267
 
 
268
handle_agent(Addr, Port, SnmpInfo, UserPid) ->
 
269
    UserPid ! {handle_agent, self(), Addr, Port, SnmpInfo},
 
270
    ignore.
 
271
 
 
272
 
 
273
handle_pdu(Addr, Port, ReqId, SnmpResponse, UserPid) ->
 
274
    UserPid ! {handle_pdu, self(), Addr, Port, ReqId, SnmpResponse},
 
275
    ignore.
 
276
 
 
277
 
 
278
handle_trap(Addr, Port, SnmpTrap, UserPid) ->
 
279
    UserPid ! {handle_trap, self(), Addr, Port, SnmpTrap},
 
280
    ok.
 
281
 
 
282
 
 
283
handle_inform(Addr, Port, SnmpInform, UserPid) ->
 
284
    UserPid ! {handle_inform, self(), Addr, Port, SnmpInform},
 
285
    ok.
 
286
 
 
287
 
 
288
handle_report(Addr, Port, SnmpReport, UserPid) ->
 
289
    UserPid ! {handle_report, self(), Addr, Port, SnmpReport},
 
290
    ok.