1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
|
eval '(exit $?0)' && eval 'exec perl -S $0 ${1+"$@"}'
& eval 'exec perl -S $0 $argv:q'
if 0;
# $Id$
# -*- perl -*-
# Purpose:
# To test the FaultDetectorFactory and FaultDetectors
#
# Process being tested:
# Fault_Detector
# implements FaultDetectorFactory interface
# implements PullMonitorable interface
#
# Processes used in test:
# FT_Replica
# implements TestReplica interface.
# implements PullMonitorable.
# StubNotifier
# implements FaultNotifier interface (as a stub.)
# implements PullMonitorable.
# client for FaultDetectorFactory interface.
# FT_Client
# client for TestReplica interface.
# client for PullMonitorable.
#
# Test Scenario ( ***Test: marks behavior being tested):
# Phase 1:
# Start two FT_Replicas
# FT_Replicas write TestReplica IORs (FR#1 and FR#2) to files
# Start the Fault_Detector
# Fault_Detector writes its IOR (FDF) to a file
# Phase 2:
# Wait for IORs: FR#1, FR#2, and FDF
# Start the StubNotifier giving it IORS: FR#1, FR#2 and FDF
# StubNotifier calls FDF to create a FaultDetector
# for each Replica.
# StubNotifier writes FaultNotifier IOR (FN) to a file.
# Phase 3:
# Wait for IOR: FN
# Start FT_Client giving it IORS: FR#1 and FR#2. [1]
# FT_Client interacts with FR#1.
# FT_Client asks FR#1 to fault. It does so.
# FT_Client notices fault and switches to FR#2. [1]
# ***Test: FD#1 notices fault and notifies StubNotifier
# ***Test: FD#1 terminates
# FT_Client interacts with FR#2.
# FT_Client asks FR#2 to shut down.
# FT_Client shuts down.
# ***Test: FD#2 notices FR2 is gone, interprets this
# as a fault, and notifies StubNotifier.
# ***Test: FD#2 terminates.
# ***Test: FDF is idle, so it terminates.
# StubNotifier sees FDF terminate, so it terminates
# Phase 4:
# Wait for all processes to terminate.
# Check termination status.
# Delete temp files.
#
# [1] Client mediated fault tolerance. These points will
# change when IOGR support is available.
use lib '../../../../bin';
use PerlACE::Run_Test;
########################
#command line options
#set defaults:
my($verbose) = 0; # 1: report perl actions before executing them
my($debug_builds) = 0; # 0: use exes from Release directories
my($simulated) = 1; # 1: use "client simulated" fault tolerance
foreach $i (@ARGV) {
if ($i eq "--debug_build")
{
$debug_builds = 1;
}
elsif ($i eq "--no_simulate") # reverse this once we have FT ORB support
{
$simulated = 0;
}
elsif ($i eq "-v")
{
$verbose += 1;
}
}
my($build_directory) = "/Release";
if ( $debug_builds ) {
$build_directory = "";
}
if ( $verbose > 1) {
print "verbose: $verbose\n";
print "debug_builds: $debug_builds -> $build_directory\n";
print "simulated: $simulated\n";
}
#define temp files
my($factory1_ior) = PerlACE::LocalFile ("factory1.ior");
my($factory2_ior) = PerlACE::LocalFile ("factory2.ior");
my($replica1_ior) = PerlACE::LocalFile ("replica1.ior");
my($replica2_ior) = PerlACE::LocalFile ("replica2.ior");
my($detector_ior) = PerlACE::LocalFile ("detector.ior");
my($notifier_ior) = PerlACE::LocalFile ("notifier.ior");
my($client_data) = PerlACE::LocalFile ("persistent.dat");
#discard junk from previous tests
unlink $factory1_ior;
unlink $factory2_ior;
unlink $replica1_ior;
unlink $replica2_ior;
unlink $detector_ior;
unlink $notifier_ior;
unlink #client_data
my($status) = 0;
my($REP1) = new PerlACE::Process (".$build_directory/ft_replica", "-o $factory1_ior -t $replica1_ior -l loc1 -i type1 -q");
my($REP2) = new PerlACE::Process (".$build_directory/ft_replica", "-o $factory2_ior -t $replica2_ior -l loc2 -i type1 -q");
my($DET) = new PerlACE::Process ("$ENV{'TAO_ROOT'}/orbsvcs/Fault_Detector$build_directory/Fault_Detector", "-o $detector_ior -q");
my($NOT) = new PerlACE::Process (".$build_directory/ft_notifier", "-o $notifier_ior -q -d file://$detector_ior -r file://$replica1_ior -r file://$replica2_ior");
my($CL);
if ($simulated) {
print "\nTEST: Preparing Client Mediated Fault Tolerance test.\n" if ($verbose);
$CL = new PerlACE::Process (".$build_directory/ft_client", "-f file://$replica1_ior -f file://$replica2_ior -c testscript");
}else{
print "\nTEST: Preparing IOGR based test.\n" if ($verbose);
$CL = new PerlACE::Process (".$build_directory/ft_client", "-f file://$replica1_iogr -c testscript");
}
print "TEST: starting replica1 ". $REP1->CommandLine . "\n" if ($verbose);
$REP1->Spawn ();
print "TEST: waiting for replica 1's IOR\n" if ($verbose);
if (PerlACE::waitforfile_timed ($replica1_ior, 5) == -1) {
print STDERR "ERROR: cannot find file <$replica1_ior>\n";
$REP1->Kill (); $REP1->TimedWait (1);
exit 1;
}
print "\nTEST: starting replica2 " . $REP2->CommandLine . "\n" if ($verbose);
$REP2->Spawn ();
print "TEST: waiting for replica 2's IOR\n" if ($verbose);
if (PerlACE::waitforfile_timed ($replica2_ior, 5) == -1) {
print STDERR "ERROR: cannot find file <$replica2_ior>\n";
$REP1->Kill (); $REP1->TimedWait (1);
$REP2->Kill (); $REP2->TimedWait (1);
exit 1;
}
print "\nTEST: starting detector factory " . $DET->CommandLine . "\n" if ($verbose);
$DET->Spawn ();
print "TEST: waiting for detector's IOR\n" if ($verbose);
if (PerlACE::waitforfile_timed ($detector_ior, 5) == -1) {
print STDERR "ERROR: cannot find file <$detector_ior>\n";
$REP1->Kill (); $REP1->TimedWait (1);
$REP2->Kill (); $REP2->TimedWait (1);
$DET->Kill (); $DET2->TimedWait(1);
exit 1;
}
print "\nTEST: starting notifier " . $NOT->CommandLine . "\n" if ($verbose);
$NOT->Spawn ();
print "TEST: waiting for notifier's IOR\n" if ($verbose);
if (PerlACE::waitforfile_timed ($notifier_ior, 5) == -1) {
print STDERR "ERROR: cannot find file <$notifier_ior>\n";
$REP1->Kill (); $REP1->TimedWait (1);
$REP2->Kill (); $REP2->TimedWait (1);
$DET->Kill (); $DET2->TimedWait(1);
$NOT->Kill (); $NOT->TimedWait(1);
exit 1;
}
print "\nTEST: starting client." . $CL->CommandLine . "\n" if ($verbose);
$client = $CL->SpawnWaitKill (60);
if ($client != 0) {
print STDERR "ERROR: client returned $client\n";
$status = 1;
}
print "\nTEST: wait for replica 1.\n" if ($verbose);
$replica1 = $REP1->WaitKill (60);
if ($replica1 != 0) {
print STDERR "ERROR: replica returned $replica1\n";
$status = 1;
}
print "\nTEST: wait for replica 2.\n" if ($verbose);
$replica2 = $REP2->WaitKill (60);
if ($replica2 != 0) {
print STDERR "ERROR: replica returned $replica2\n";
$status = 1;
}
print "\nTEST: wait for detector factory to leave.\n" if ($verbose);
$detector = $DET->WaitKill (60);
if ($detector != 0) {
print STDERR "ERROR: detector returned $detector\n";
$status = 1;
}
print "\nTEST: wait for notifier to leave.\n" if ($verbose);
$notifier = $NOT->WaitKill (60);
if ($notifier != 0) {
print STDERR "ERROR: notifier returned $notifier\n";
$status = 1;
}
print "\nTEST: releasing scratch files.\n" if ($verbose);
unlink $factory1_ior;
unlink $factory2_ior;
unlink $replica1_ior;
unlink $replica2_ior;
unlink $detector_ior;
unlink $notifier_ior;
#client's work file
unlink #client_data;
exit $status;
|
