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
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
|
/*******************************************************************************
* Copyright (c) 2004, 2005 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* IBM Corporation - initial API and implementation
*******************************************************************************/
/*
* $RCSfile: ExpressionCommands.java,v $
* $Revision: 1.8 $ $Date: 2005/08/24 20:39:08 $
*/
package org.eclipse.jem.internal.proxy.common.remote;
import java.io.*;
import org.eclipse.jem.internal.proxy.common.CommandException;
/**
*
* @since 1.0.0
*/
public class ExpressionCommands {
// These are the sub-commands under EXPRESSION_TREE_COMMANDS that can be send.
public static final byte
START_EXPRESSION_TREE_PROCESSING = 0,
PUSH_EXPRESSION = 1,
END_EXPRESSION_TREE_PROCESSING = 2,
SYNC_REQUEST = 3,
PULL_VALUE_REQUEST = 4,
TRANSFER_EXPRESSION_REQUEST = 5,
RESUME_EXPRESSION_REQUEST = 6;
// These are the expression specific error codes (it can also send back general ones. See SYNC_REQUEST docs lower down).
public static final int
EXPRESSION_NOEXPRESSIONVALUE_EXCEPTION = Commands.MAX_ERROR_CODE+1; // No expression value occurred.
// These are the flag values sent in proxy resolution when doesn't resolve to proxy.
public static final int
EXPRESSIONPROXY_VOIDTYPE = 0, // Expression proxy resolves to void type.
EXPRESSIONPROXY_NOTRESOLVED = 1; // Expression proxy not resolved.
// These are the trace values sent in START_EXPRESSION_TREE_PROCESSING
public static final byte
TRACE_DEFAULT = -1,
TRACE_OFF = 0,
TRACE_ON = 1;
public static final String EXPRESSIONTRACE = "proxyvm.expressionTrace"; // The system property for turning on expression tracing. //$NON-NLS-1$
public static final String EXPRESSIONTRACE_TIMER_THRESHOLD = "proxyvm.expressionTraceTimerThreshold"; // The system property for timer threshold. //$NON-NLS-1$
/*
* The format of the commands are:
* Note: Most of the commands will not being doing a os.flush() at the end. We are just going to
* be streaming the data over the line. At the end we will flush and then catch up. That way
* we aren't waiting for the other side as we send the data.
*
* START_EXPRESSION_TREE_PROCESSING: 0b, trace
* Start processing.
* byte(trace): -1 : do default
* 0 : no trace
* 1 : do trace
*
* PUSH_EXPRESSION: 1b, b
* Push an expression. Where "b" is the expression type from IInternalExpressionConstants.
* The actual data that follows is expression type dependent and will be
* sent in a following call to ExpressionCommands as it builds up the actual command.
* See REMExpression and each type of push call method within it to see the actual
* sent data.
*
* END_EXPRESSION_TREE_PROCESSING: 2b
* End the processing and clean up.
*
* SYNC_REQUEST: 3b
* This will return the current status. The reason it is called sync is because the
* IDE will wait for it to complete and read back the value. It will send back:
* 1: VALUE command with boolean true as the value.
* 2: ERROR command with code of ExpressionClassNotFound, with value of String with message from exception.
* 3: ERROR command with code of EXPRESSION_NOEXPRESSIONVALUE_EXCEPTION, with value of String with message from exception.
* 4: THROWABLE command with the actual exception that occurred.
*
*
* PULL_VALUE_REQUEST: 4b
* This will do a sync up and return the value from the expression.
* IDE will wait for it to compleate and read back the value. It will send back:
* 1: VALUE command with the result as the value.
* 2: ERROR or EXCEPTION if there were errors, see SYNC_REQUEST with the format they are sent back.
*
* TRANSFER_EXPRESSION_REQUEST: 5b
* This will do a sync up, and return the ExpressionProcessorController that the request is for. And remove
* the controller from its list of active expression controllers.
*
* RESUME_EXPRESSION_REQUEST: 6b, anExpressionProcessorController
* This will take the given controller and add it to the list of controllers this connection is handling. It returns nothing.
*
* @see org.eclipse.jem.internal.proxy.initParser.tree.IInternalExpressionConstants
* @see org.eclipse.jem.internal.proxy.remote.REMExpression
*
*/
/**
* Send the start expression processing command.
* @param expressionID
* @param trace
* @param os
*
* @throws IOException
*
* @since 1.0.0
*/
public static void sendStartExpressionProcessingCommand(int expressionID, byte trace, DataOutputStream os) throws IOException {
os.writeByte(Commands.EXPRESSION_TREE_COMMAND);
os.writeInt(expressionID);
os.writeByte(START_EXPRESSION_TREE_PROCESSING);
os.writeByte(trace);
}
/**
* Send the end expression processing command.
* @param expressionID
* @param os
*
* @throws IOException
*
* @since 1.0.0
*/
public static void sendEndExpressionProcessingCommand(int expressionID, DataOutputStream os) throws IOException {
os.writeByte(Commands.EXPRESSION_TREE_COMMAND);
os.writeInt(expressionID);
os.writeByte(END_EXPRESSION_TREE_PROCESSING);
os.flush(); // Flushing because we are done and want to make sure everything goes out.
}
/**
* Send an expression subcommand.
* @param expressionID
* @param os
* @param subcommand
*
* @throws IOException
*
* @since 1.0.0
*/
public static void sendExpressionCommand(int expressionID, DataOutputStream os, byte subcommand) throws IOException {
os.writeByte(Commands.EXPRESSION_TREE_COMMAND);
os.writeInt(expressionID);
os.writeByte(PUSH_EXPRESSION);
os.writeByte(subcommand);
}
/**
* Send just a byte.
*
* @param os
* @param aByte
* @throws IOException
*
* @since 1.0.0
*/
public static void sendByte(DataOutputStream os, byte aByte) throws IOException {
os.writeByte(aByte);
}
/**
* Send just an int.
*
* @param os
* @param anInt
* @throws IOException
*
* @since 1.0.0
*/
public static void sendInt(DataOutputStream os, int anInt) throws IOException {
os.writeInt(anInt);
}
/**
* Send just a string.
*
* @param os
* @param aString
* @throws IOException
*
* @since 1.0.0
*/
public static void sendString(DataOutputStream os, String aString) throws IOException {
Commands.sendStringData(os, aString);
}
/**
* Send just a boolean.
*
* @param os
* @param aBool
* @throws IOException
*
* @since 1.0.0
*/
public static void sendBoolean(DataOutputStream os, boolean aBool) throws IOException {
os.writeBoolean(aBool);
}
/**
* Send the pull value command. After processing the proxies, caller should call getFinalValue() to get the value.
* @param expressionID
* @param os
* @param is
* @param proxyids if not <code>null</code>, then this is the list of expression proxy ids that need to be returned as rendered.
* @param sender sender used to process the resolved proxy ids, or <code>null</code> if no proxy ids.
* @throws CommandException
*
* @since 1.0.0
*/
public static void sendPullValueCommand(int expressionID, DataOutputStream os, DataInputStream is, Commands.ValueObject proxyids, Commands.ValueSender sender) throws CommandException {
try {
os.writeByte(Commands.EXPRESSION_TREE_COMMAND);
os.writeInt(expressionID);
os.writeByte(PULL_VALUE_REQUEST);
sendProxyIDs(os, proxyids);
os.flush();
if (proxyids != null) {
Commands.readBackValue(is, proxyids, Commands.ARRAY_IDS); // Read the array header.
sender.initialize(proxyids);
Commands.readArray(is, proxyids.anInt, sender, proxyids, true); // Read the array.
}
} catch (CommandException e) {
// rethrow this exception since we want these to go on out.
throw e;
} catch (IOException e) {
// Wrapper this one.
throw new UnexpectedExceptionCommandException(false, e);
}
}
/**
* Send a sync command. This does a synchronize with the remote expression processor. It makes sure that the
* stream is caught and doesn't return until everything on the stream has been processed. Should then call
* getFinalValue() to verify the expression is valid.
* @param expressionID
* @param os
* @param is
* @param proxyids if not <code>null</code>, then this is the list of expression proxy ids that need to be returned as rendered.
* @param sender the sender used for reading back the proxyid resolutions, or <code>null</code> if no proxy ids.
*
* @throws CommandException
*
* @since 1.0.0
*/
public static void sendSyncCommand(int expressionID, DataOutputStream os, DataInputStream is, Commands.ValueObject proxyids, Commands.ValueSender sender) throws CommandException {
try {
os.writeByte(Commands.EXPRESSION_TREE_COMMAND);
os.writeInt(expressionID);
os.writeByte(SYNC_REQUEST);
sendProxyIDs(os, proxyids);
os.flush();
if (proxyids != null) {
Commands.readBackValue(is, proxyids, Commands.ARRAY_IDS); // Read the array header.
sender.initialize(proxyids);
Commands.readArray(is, proxyids.anInt, sender, proxyids, true); // Read the array.
}
} catch (CommandException e) {
// rethrow this exception since we want these to go on out.
throw e;
} catch (Exception e) {
// Wrapper this one.
throw new UnexpectedExceptionCommandException(false, e);
}
}
/**
* Send the proxyids (if not null) as part of a command. Used by sync and pullValue.
* @param os
* @param proxyids <code>null</code> if not requesting proxy ids.
* @throws IOException
* @throws CommandException
*
* @since 1.1.0
*/
private static void sendProxyIDs(DataOutputStream os, Commands.ValueObject proxyids) throws IOException, CommandException {
if (proxyids != null) {
os.writeBoolean(true); // Indicates proxy ids being sent.
Commands.writeValue(os, proxyids, false, false);
} else
os.writeBoolean(false); // No proxyids being sent.
}
/**
* Send the transfer expression command and receive back the expression processor controller.
*
* @param expressionID
* @param os
* @param is
* @param expressionProcesserController
* @throws CommandException
*
* @since 1.1.0
*/
public static void sendTransferExpressionCommand(int expressionID, DataOutputStream os, DataInputStream is, Commands.ValueObject expressionProcesserController) throws CommandException {
try {
os.writeByte(Commands.EXPRESSION_TREE_COMMAND);
os.writeInt(expressionID);
os.writeByte(TRANSFER_EXPRESSION_REQUEST);
os.flush();
Commands.readBackValue(is, expressionProcesserController, Commands.NO_TYPE_CHECK); // Read the expression processor controller
} catch (CommandException e) {
throw e;
} catch (Exception e) {
// Wrapper this one.
throw new UnexpectedExceptionCommandException(false, e);
}
}
/**
* Send the resume expression command with given expression processor controller.
*
* @param expressionID
* @param os
* @param expressionProcessorController
* @throws CommandException
*
* @since 1.1.0
*/
public static void sendResumeExpressionCommand(int expressionID, DataOutputStream os, Commands.ValueObject expressionProcessorController) throws CommandException {
try {
os.writeByte(Commands.EXPRESSION_TREE_COMMAND);
os.writeInt(expressionID);
os.writeByte(RESUME_EXPRESSION_REQUEST);
Commands.writeValue(os, expressionProcessorController, false, false);
} catch (CommandException e) {
throw e;
} catch (Exception e) {
// Wrapper this one.
throw new UnexpectedExceptionCommandException(false, e);
}
}
private ExpressionCommands() {
// Never intended to be instantiated.
}
}
|