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
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
|
// **********************************************************************
//
// Copyright (c) 2003-2011 ZeroC, Inc. All rights reserved.
//
// This copy of Ice is licensed to you under the terms described in the
// ICE_LICENSE file included in this distribution.
//
// **********************************************************************
package test.Util;
import Ice.Communicator;
import Ice.InitializationData;
import Ice.LocalException;
import Ice.LoggerI;
import Ice.StringSeqHolder;
import Ice.Util;
public abstract class Application
{
public final int WAIT = 2;
public interface ServerReadyListener
{
void serverReady();
}
public interface CommunicatorListener
{
void communicatorInitialized(Communicator c);
}
public
Application()
{
}
//
// This main() must be called by the global main(). main()
// initializes the Communicator, calls run(), and destroys
// the Communicator upon return from run(). It thereby handles
// all exceptions properly, i.e., error messages are printed
// if exceptions propagate to main(), and the Communicator is
// always destroyed, regardless of exceptions.
//
public final int
main(String appName, String[] args)
{
Ice.StringSeqHolder argsH = new Ice.StringSeqHolder(args);
Ice.InitializationData initData = getInitData(argsH);
return main(appName, argsH.value, initData);
}
public final int
main(String appName, String[] args, InitializationData initializationData)
{
java.io.PrintWriter writer = getWriter();
if(_communicator != null)
{
writer.println(appName + ": only one instance of the Application class can be used");
return 1;
}
_testName = appName;
//
// We parse the properties here to extract Ice.ProgramName.
//
StringSeqHolder argHolder = new StringSeqHolder(args);
if(initializationData == null)
{
initializationData = getInitData(argHolder);
}
InitializationData initData;
if(initializationData != null)
{
initData = (InitializationData)initializationData.clone();
}
else
{
initData = new InitializationData();
}
initData.properties = Util.createProperties(argHolder, initData.properties);
//
// If the process logger is the default logger, we replace it with a
// a logger that uses the program name as the prefix.
//
if(Util.getProcessLogger() instanceof LoggerI)
{
Util.setProcessLogger(new LoggerI(initData.properties.getProperty("Ice.ProgramName"), ""));
}
int status = 0;
try
{
_communicator = Util.initialize(argHolder, initData);
if(_communicatorListener != null)
{
_communicatorListener.communicatorInitialized(_communicator);
}
status = run(argHolder.value);
if(status == WAIT)
{
if(_cb != null)
{
_cb.serverReady();
}
_communicator.waitForShutdown();
status = 0;
}
}
catch(LocalException ex)
{
writer.println(_testName + ": " + ex);
ex.printStackTrace();
status = 1;
}
catch(java.lang.Exception ex)
{
writer.println(_testName + ": unknown exception");
ex.printStackTrace(writer);
status = 1;
}
catch(java.lang.Error err)
{
//
// We catch Error to avoid hangs in some non-fatal situations
//
writer.println(_testName + ": Java error");
err.printStackTrace(writer);
status = 1;
}
if(_communicator != null)
{
try
{
_communicator.destroy();
}
catch(LocalException ex)
{
writer.println(_testName + ": " + ex);
ex.printStackTrace(writer);
status = 1;
}
catch(java.lang.Exception ex)
{
writer.println(_testName + ": unknown exception");
ex.printStackTrace(writer);
status = 1;
}
_communicator = null;
}
writer.flush();
return status;
}
public void stop()
{
if(_communicator != null)
{
_communicator.shutdown();
}
}
//
// Initialize a new communicator.
//
public Ice.Communicator initialize(InitializationData initData)
{
Ice.Communicator communicator = Util.initialize(initData);
if(_communicatorListener != null)
{
_communicatorListener.communicatorInitialized(communicator);
}
return communicator;
}
public abstract int run(String[] args);
//
// Hook to override the initialization data. This hook is
// necessary because some properties must be set prior to
// communicator initialization.
//
protected Ice.InitializationData getInitData(Ice.StringSeqHolder argsH)
{
return null;
}
public java.io.PrintWriter getWriter()
{
return _printWriter;
}
public void setWriter(java.io.Writer writer)
{
_printWriter = new java.io.PrintWriter(writer);
}
public void setServerReadyListener(ServerReadyListener cb)
{
_cb = cb;
}
public void setCommunicatorListener(CommunicatorListener listener)
{
_communicatorListener = listener;
}
public void serverReady()
{
if(_cb != null)
{
_cb.serverReady();
}
}
//
// Return the application name, i.e., argv[0].
//
public String
appName()
{
return _testName;
}
public Communicator
communicator()
{
return _communicator;
}
private String _testName;
private Communicator _communicator;
private java.io.PrintWriter _printWriter = new java.io.PrintWriter(new java.io.OutputStreamWriter(System.out));
private ServerReadyListener _cb = null;
private CommunicatorListener _communicatorListener = null;
}
|
