author | msheppar |
Tue, 16 Feb 2016 12:37:44 +0000 | |
changeset 36019 | f5596d6af0de |
parent 25862 | a5e25d68f971 |
permissions | -rw-r--r-- |
4 | 1 |
/* |
18307
8bf60b58675b
8000642: Better handling of objects for transportation
coffeys
parents:
7059
diff
changeset
|
2 |
* Copyright (c) 2001, 2013, Oracle and/or its affiliates. All rights reserved. |
4 | 3 |
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
4 |
* |
|
5 |
* This code is free software; you can redistribute it and/or modify it |
|
6 |
* under the terms of the GNU General Public License version 2 only, as |
|
5555 | 7 |
* published by the Free Software Foundation. Oracle designates this |
4 | 8 |
* particular file as subject to the "Classpath" exception as provided |
5555 | 9 |
* by Oracle in the LICENSE file that accompanied this code. |
4 | 10 |
* |
11 |
* This code is distributed in the hope that it will be useful, but WITHOUT |
|
12 |
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
|
13 |
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
|
14 |
* version 2 for more details (a copy is included in the LICENSE file that |
|
15 |
* accompanied this code). |
|
16 |
* |
|
17 |
* You should have received a copy of the GNU General Public License version |
|
18 |
* 2 along with this work; if not, write to the Free Software Foundation, |
|
19 |
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
|
20 |
* |
|
5555 | 21 |
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
22 |
* or visit www.oracle.com if you need additional information or have any |
|
23 |
* questions. |
|
4 | 24 |
*/ |
25 |
||
26 |
package com.sun.corba.se.impl.transport; |
|
27 |
||
28 |
import java.io.IOException; |
|
29 |
import java.net.InetSocketAddress; |
|
30 |
import java.net.ServerSocket; |
|
31 |
import java.net.Socket; |
|
32 |
import java.nio.channels.SelectableChannel; |
|
33 |
import java.nio.channels.SelectionKey; |
|
34 |
import java.nio.channels.ServerSocketChannel; |
|
35 |
import java.nio.channels.SocketChannel; |
|
36 |
import java.util.Iterator; |
|
37 |
||
38 |
import com.sun.corba.se.pept.broker.Broker; |
|
39 |
import com.sun.corba.se.pept.encoding.InputObject; |
|
40 |
import com.sun.corba.se.pept.encoding.OutputObject; |
|
41 |
import com.sun.corba.se.pept.protocol.MessageMediator; |
|
42 |
import com.sun.corba.se.pept.transport.Acceptor; |
|
43 |
import com.sun.corba.se.pept.transport.Connection; |
|
44 |
import com.sun.corba.se.pept.transport.ContactInfo; |
|
45 |
import com.sun.corba.se.pept.transport.EventHandler; |
|
46 |
import com.sun.corba.se.pept.transport.InboundConnectionCache; |
|
47 |
import com.sun.corba.se.pept.transport.Selector; |
|
48 |
||
49 |
import com.sun.corba.se.spi.extension.RequestPartitioningPolicy; |
|
50 |
import com.sun.corba.se.spi.ior.IORTemplate; |
|
51 |
import com.sun.corba.se.spi.ior.TaggedProfileTemplate; |
|
52 |
import com.sun.corba.se.spi.ior.iiop.IIOPAddress ; |
|
53 |
import com.sun.corba.se.spi.ior.iiop.IIOPFactories; |
|
54 |
import com.sun.corba.se.spi.ior.iiop.IIOPProfileTemplate ; |
|
55 |
import com.sun.corba.se.spi.ior.iiop.GIOPVersion ; |
|
56 |
import com.sun.corba.se.spi.ior.iiop.AlternateIIOPAddressComponent; |
|
57 |
import com.sun.corba.se.spi.logging.CORBALogDomains; |
|
58 |
import com.sun.corba.se.spi.orb.ORB; |
|
59 |
import com.sun.corba.se.spi.orbutil.threadpool.Work; |
|
60 |
import com.sun.corba.se.spi.protocol.CorbaMessageMediator; |
|
61 |
import com.sun.corba.se.spi.transport.CorbaAcceptor; |
|
62 |
import com.sun.corba.se.spi.transport.CorbaConnection; |
|
63 |
import com.sun.corba.se.spi.transport.SocketInfo; |
|
64 |
import com.sun.corba.se.spi.transport.SocketOrChannelAcceptor; |
|
65 |
||
66 |
import com.sun.corba.se.impl.encoding.CDRInputObject; |
|
67 |
import com.sun.corba.se.impl.encoding.CDROutputObject; |
|
68 |
import com.sun.corba.se.impl.logging.ORBUtilSystemException; |
|
69 |
import com.sun.corba.se.impl.oa.poa.Policies; // REVISIT impl/poa specific |
|
70 |
import com.sun.corba.se.impl.orbutil.ORBConstants; |
|
71 |
import com.sun.corba.se.impl.orbutil.ORBUtility; |
|
72 |
||
73 |
// BEGIN Legacy support. |
|
74 |
import com.sun.corba.se.spi.legacy.connection.LegacyServerSocketEndPointInfo; |
|
75 |
// END Legacy support. |
|
76 |
||
77 |
/** |
|
78 |
* @author Harold Carr |
|
79 |
*/ |
|
80 |
public class SocketOrChannelAcceptorImpl |
|
81 |
extends |
|
82 |
EventHandlerBase |
|
83 |
implements |
|
84 |
CorbaAcceptor, |
|
85 |
SocketOrChannelAcceptor, |
|
86 |
Work, |
|
87 |
// BEGIN Legacy |
|
88 |
SocketInfo, |
|
89 |
LegacyServerSocketEndPointInfo |
|
90 |
// END Legacy |
|
91 |
{ |
|
92 |
protected ServerSocketChannel serverSocketChannel; |
|
93 |
protected ServerSocket serverSocket; |
|
94 |
protected int port; |
|
95 |
protected long enqueueTime; |
|
96 |
protected boolean initialized; |
|
97 |
protected ORBUtilSystemException wrapper ; |
|
98 |
protected InboundConnectionCache connectionCache; |
|
99 |
||
100 |
// BEGIN Legacy |
|
101 |
protected String type = ""; |
|
102 |
protected String name = ""; |
|
103 |
protected String hostname; |
|
104 |
protected int locatorPort; |
|
105 |
// END Legacy |
|
106 |
||
107 |
public SocketOrChannelAcceptorImpl(ORB orb) |
|
108 |
{ |
|
109 |
this.orb = orb; |
|
110 |
wrapper = ORBUtilSystemException.get( orb, |
|
111 |
CORBALogDomains.RPC_TRANSPORT ) ; |
|
112 |
||
113 |
setWork(this); |
|
114 |
initialized = false; |
|
115 |
||
116 |
// BEGIN Legacy support. |
|
117 |
this.hostname = orb.getORBData().getORBServerHost(); |
|
118 |
this.name = LegacyServerSocketEndPointInfo.NO_NAME; |
|
119 |
this.locatorPort = -1; |
|
120 |
// END Legacy support. |
|
121 |
} |
|
122 |
||
123 |
public SocketOrChannelAcceptorImpl(ORB orb, int port) |
|
124 |
{ |
|
125 |
this(orb); |
|
126 |
this.port = port; |
|
127 |
} |
|
128 |
||
129 |
// BEGIN Legacy support. |
|
130 |
public SocketOrChannelAcceptorImpl(ORB orb, int port, |
|
131 |
String name, String type) |
|
132 |
{ |
|
133 |
this(orb, port); |
|
134 |
this.name = name; |
|
135 |
this.type = type; |
|
136 |
} |
|
137 |
// END Legacy support. |
|
138 |
||
139 |
//////////////////////////////////////////////////// |
|
140 |
// |
|
141 |
// pept.transport.Acceptor |
|
142 |
// |
|
143 |
||
144 |
public boolean initialize() |
|
145 |
{ |
|
146 |
if (initialized) { |
|
147 |
return false; |
|
148 |
} |
|
149 |
if (orb.transportDebugFlag) { |
|
150 |
dprint(".initialize: " + this); |
|
151 |
} |
|
152 |
InetSocketAddress inetSocketAddress = null; |
|
153 |
try { |
|
154 |
if (orb.getORBData().getListenOnAllInterfaces().equals(ORBConstants.LISTEN_ON_ALL_INTERFACES)) { |
|
155 |
inetSocketAddress = new InetSocketAddress(port); |
|
156 |
} else { |
|
157 |
String host = orb.getORBData().getORBServerHost(); |
|
158 |
inetSocketAddress = new InetSocketAddress(host, port); |
|
159 |
} |
|
160 |
serverSocket = orb.getORBData().getSocketFactory() |
|
161 |
.createServerSocket(type, inetSocketAddress); |
|
162 |
internalInitialize(); |
|
163 |
} catch (Throwable t) { |
|
164 |
throw wrapper.createListenerFailed( t, Integer.toString(port) ) ; |
|
165 |
} |
|
166 |
initialized = true; |
|
167 |
return true; |
|
168 |
} |
|
169 |
||
170 |
protected void internalInitialize() |
|
171 |
throws Exception |
|
172 |
{ |
|
173 |
// Determine the listening port (for the IOR). |
|
174 |
// This is important when using emphemeral ports (i.e., |
|
175 |
// when the port value to the constructor is 0). |
|
176 |
||
177 |
port = serverSocket.getLocalPort(); |
|
178 |
||
179 |
// Register with transport (also sets up monitoring). |
|
180 |
||
181 |
orb.getCorbaTransportManager().getInboundConnectionCache(this); |
|
182 |
||
183 |
// Finish configuation. |
|
184 |
||
185 |
serverSocketChannel = serverSocket.getChannel(); |
|
186 |
||
187 |
if (serverSocketChannel != null) { |
|
188 |
setUseSelectThreadToWait( |
|
189 |
orb.getORBData().acceptorSocketUseSelectThreadToWait()); |
|
190 |
serverSocketChannel.configureBlocking( |
|
191 |
! orb.getORBData().acceptorSocketUseSelectThreadToWait()); |
|
192 |
} else { |
|
193 |
// Configure to use listener and reader threads. |
|
194 |
setUseSelectThreadToWait(false); |
|
195 |
} |
|
196 |
setUseWorkerThreadForEvent( |
|
197 |
orb.getORBData().acceptorSocketUseWorkerThreadForEvent()); |
|
198 |
||
199 |
} |
|
200 |
||
201 |
public boolean initialized() |
|
202 |
{ |
|
203 |
return initialized; |
|
204 |
} |
|
205 |
||
206 |
public String getConnectionCacheType() |
|
207 |
{ |
|
208 |
return this.getClass().toString(); |
|
209 |
} |
|
210 |
||
211 |
public void setConnectionCache(InboundConnectionCache connectionCache) |
|
212 |
{ |
|
213 |
this.connectionCache = connectionCache; |
|
214 |
} |
|
215 |
||
216 |
public InboundConnectionCache getConnectionCache() |
|
217 |
{ |
|
218 |
return connectionCache; |
|
219 |
} |
|
220 |
||
221 |
public boolean shouldRegisterAcceptEvent() |
|
222 |
{ |
|
223 |
return true; |
|
224 |
} |
|
225 |
||
226 |
public void accept() |
|
227 |
{ |
|
228 |
try { |
|
229 |
SocketChannel socketChannel = null; |
|
230 |
Socket socket = null; |
|
231 |
if (serverSocketChannel == null) { |
|
232 |
socket = serverSocket.accept(); |
|
233 |
} else { |
|
234 |
socketChannel = serverSocketChannel.accept(); |
|
235 |
socket = socketChannel.socket(); |
|
236 |
} |
|
237 |
orb.getORBData().getSocketFactory() |
|
238 |
.setAcceptedSocketOptions(this, serverSocket, socket); |
|
239 |
if (orb.transportDebugFlag) { |
|
240 |
dprint(".accept: " + |
|
241 |
(serverSocketChannel == null |
|
242 |
? serverSocket.toString() |
|
243 |
: serverSocketChannel.toString())); |
|
244 |
} |
|
245 |
||
246 |
CorbaConnection connection = |
|
247 |
new SocketOrChannelConnectionImpl(orb, this, socket); |
|
248 |
if (orb.transportDebugFlag) { |
|
249 |
dprint(".accept: new: " + connection); |
|
250 |
} |
|
251 |
||
252 |
// NOTE: The connection MUST be put in the cache BEFORE being |
|
253 |
// registered with the selector. Otherwise if the bytes |
|
254 |
// are read on the connection it will attempt a time stamp |
|
255 |
// but the cache will be null, resulting in NPE. |
|
23756
ce3ae619aa25
8029073: (corba) New connection reclaimed when number of connection is greater than highwatermark
aefimov
parents:
18307
diff
changeset
|
256 |
|
ce3ae619aa25
8029073: (corba) New connection reclaimed when number of connection is greater than highwatermark
aefimov
parents:
18307
diff
changeset
|
257 |
// A connection needs to be timestamped before putting to the cache. |
ce3ae619aa25
8029073: (corba) New connection reclaimed when number of connection is greater than highwatermark
aefimov
parents:
18307
diff
changeset
|
258 |
// Otherwise the newly created connection (with 0 timestamp) could be |
ce3ae619aa25
8029073: (corba) New connection reclaimed when number of connection is greater than highwatermark
aefimov
parents:
18307
diff
changeset
|
259 |
// incorrectly reclaimed by concurrent reclaim() call OR if there |
ce3ae619aa25
8029073: (corba) New connection reclaimed when number of connection is greater than highwatermark
aefimov
parents:
18307
diff
changeset
|
260 |
// will be no events on this connection then it could be reclaimed |
ce3ae619aa25
8029073: (corba) New connection reclaimed when number of connection is greater than highwatermark
aefimov
parents:
18307
diff
changeset
|
261 |
// by upcoming reclaim() call. |
ce3ae619aa25
8029073: (corba) New connection reclaimed when number of connection is greater than highwatermark
aefimov
parents:
18307
diff
changeset
|
262 |
getConnectionCache().stampTime(connection); |
4 | 263 |
getConnectionCache().put(this, connection); |
264 |
||
265 |
if (connection.shouldRegisterServerReadEvent()) { |
|
266 |
Selector selector = orb.getTransportManager().getSelector(0); |
|
36019
f5596d6af0de
8144144: ORB destroy() leaks filedescriptors after unsuccessful connection
msheppar
parents:
25862
diff
changeset
|
267 |
if (selector != null) { |
f5596d6af0de
8144144: ORB destroy() leaks filedescriptors after unsuccessful connection
msheppar
parents:
25862
diff
changeset
|
268 |
if (orb.transportDebugFlag) { |
f5596d6af0de
8144144: ORB destroy() leaks filedescriptors after unsuccessful connection
msheppar
parents:
25862
diff
changeset
|
269 |
dprint(".accept: registerForEvent: " + connection); |
f5596d6af0de
8144144: ORB destroy() leaks filedescriptors after unsuccessful connection
msheppar
parents:
25862
diff
changeset
|
270 |
} |
f5596d6af0de
8144144: ORB destroy() leaks filedescriptors after unsuccessful connection
msheppar
parents:
25862
diff
changeset
|
271 |
selector.registerForEvent(connection.getEventHandler()); |
f5596d6af0de
8144144: ORB destroy() leaks filedescriptors after unsuccessful connection
msheppar
parents:
25862
diff
changeset
|
272 |
} |
4 | 273 |
} |
274 |
||
275 |
getConnectionCache().reclaim(); |
|
276 |
||
277 |
} catch (IOException e) { |
|
278 |
if (orb.transportDebugFlag) { |
|
279 |
dprint(".accept:", e); |
|
280 |
} |
|
36019
f5596d6af0de
8144144: ORB destroy() leaks filedescriptors after unsuccessful connection
msheppar
parents:
25862
diff
changeset
|
281 |
Selector selector = orb.getTransportManager().getSelector(0); |
f5596d6af0de
8144144: ORB destroy() leaks filedescriptors after unsuccessful connection
msheppar
parents:
25862
diff
changeset
|
282 |
if (selector != null) { |
f5596d6af0de
8144144: ORB destroy() leaks filedescriptors after unsuccessful connection
msheppar
parents:
25862
diff
changeset
|
283 |
selector.unregisterForEvent(this); |
f5596d6af0de
8144144: ORB destroy() leaks filedescriptors after unsuccessful connection
msheppar
parents:
25862
diff
changeset
|
284 |
// REVISIT - need to close - recreate - then register new one. |
f5596d6af0de
8144144: ORB destroy() leaks filedescriptors after unsuccessful connection
msheppar
parents:
25862
diff
changeset
|
285 |
selector.registerForEvent(this); |
f5596d6af0de
8144144: ORB destroy() leaks filedescriptors after unsuccessful connection
msheppar
parents:
25862
diff
changeset
|
286 |
// NOTE: if register cycling we do not want to shut down ORB |
f5596d6af0de
8144144: ORB destroy() leaks filedescriptors after unsuccessful connection
msheppar
parents:
25862
diff
changeset
|
287 |
// since local beans will still work. Instead one will see |
f5596d6af0de
8144144: ORB destroy() leaks filedescriptors after unsuccessful connection
msheppar
parents:
25862
diff
changeset
|
288 |
// a growing log file to alert admin of problem. |
f5596d6af0de
8144144: ORB destroy() leaks filedescriptors after unsuccessful connection
msheppar
parents:
25862
diff
changeset
|
289 |
} |
4 | 290 |
} |
291 |
} |
|
292 |
||
293 |
public void close () |
|
294 |
{ |
|
295 |
try { |
|
296 |
if (orb.transportDebugFlag) { |
|
297 |
dprint(".close->:"); |
|
298 |
} |
|
299 |
Selector selector = orb.getTransportManager().getSelector(0); |
|
36019
f5596d6af0de
8144144: ORB destroy() leaks filedescriptors after unsuccessful connection
msheppar
parents:
25862
diff
changeset
|
300 |
if (selector != null) { |
f5596d6af0de
8144144: ORB destroy() leaks filedescriptors after unsuccessful connection
msheppar
parents:
25862
diff
changeset
|
301 |
selector.unregisterForEvent(this); |
f5596d6af0de
8144144: ORB destroy() leaks filedescriptors after unsuccessful connection
msheppar
parents:
25862
diff
changeset
|
302 |
} |
4 | 303 |
if (serverSocketChannel != null) { |
304 |
serverSocketChannel.close(); |
|
305 |
} |
|
306 |
if (serverSocket != null) { |
|
307 |
serverSocket.close(); |
|
308 |
} |
|
309 |
} catch (IOException e) { |
|
310 |
if (orb.transportDebugFlag) { |
|
311 |
dprint(".close:", e); |
|
312 |
} |
|
313 |
} finally { |
|
314 |
if (orb.transportDebugFlag) { |
|
315 |
dprint(".close<-:"); |
|
316 |
} |
|
317 |
} |
|
318 |
} |
|
319 |
||
320 |
public EventHandler getEventHandler() |
|
321 |
{ |
|
322 |
return this; |
|
323 |
} |
|
324 |
||
325 |
//////////////////////////////////////////////////// |
|
326 |
// |
|
327 |
// CorbaAcceptor |
|
328 |
// |
|
329 |
||
330 |
public String getObjectAdapterId() |
|
331 |
{ |
|
332 |
return null; |
|
333 |
} |
|
334 |
||
335 |
public String getObjectAdapterManagerId() |
|
336 |
{ |
|
337 |
return null; |
|
338 |
} |
|
339 |
||
340 |
public void addToIORTemplate(IORTemplate iorTemplate, |
|
341 |
Policies policies, |
|
342 |
String codebase) |
|
343 |
{ |
|
344 |
Iterator iterator = iorTemplate.iteratorById( |
|
345 |
org.omg.IOP.TAG_INTERNET_IOP.value); |
|
346 |
||
347 |
String hostname = orb.getORBData().getORBServerHost(); |
|
348 |
||
349 |
if (iterator.hasNext()) { |
|
350 |
// REVISIT - how does this play with legacy ORBD port exchange? |
|
351 |
IIOPAddress iiopAddress = |
|
352 |
IIOPFactories.makeIIOPAddress(orb, hostname, port); |
|
353 |
AlternateIIOPAddressComponent iiopAddressComponent = |
|
354 |
IIOPFactories.makeAlternateIIOPAddressComponent(iiopAddress); |
|
355 |
||
356 |
while (iterator.hasNext()) { |
|
357 |
TaggedProfileTemplate taggedProfileTemplate = |
|
358 |
(TaggedProfileTemplate) iterator.next(); |
|
359 |
taggedProfileTemplate.add(iiopAddressComponent); |
|
360 |
} |
|
361 |
} else { |
|
362 |
GIOPVersion version = orb.getORBData().getGIOPVersion(); |
|
363 |
int templatePort; |
|
364 |
if (policies.forceZeroPort()) { |
|
365 |
templatePort = 0; |
|
366 |
} else if (policies.isTransient()) { |
|
367 |
templatePort = port; |
|
368 |
} else { |
|
369 |
templatePort = orb.getLegacyServerSocketManager() |
|
370 |
.legacyGetPersistentServerPort(SocketInfo.IIOP_CLEAR_TEXT); |
|
371 |
} |
|
372 |
IIOPAddress addr = |
|
373 |
IIOPFactories.makeIIOPAddress(orb, hostname, templatePort); |
|
374 |
IIOPProfileTemplate iiopProfile = |
|
375 |
IIOPFactories.makeIIOPProfileTemplate(orb, version, addr); |
|
376 |
if (version.supportsIORIIOPProfileComponents()) { |
|
377 |
iiopProfile.add(IIOPFactories.makeCodeSetsComponent(orb)); |
|
378 |
iiopProfile.add(IIOPFactories.makeMaxStreamFormatVersionComponent()); |
|
379 |
RequestPartitioningPolicy rpPolicy = (RequestPartitioningPolicy) |
|
380 |
policies.get_effective_policy( |
|
381 |
ORBConstants.REQUEST_PARTITIONING_POLICY); |
|
382 |
if (rpPolicy != null) { |
|
383 |
iiopProfile.add( |
|
384 |
IIOPFactories.makeRequestPartitioningComponent( |
|
385 |
rpPolicy.getValue())); |
|
386 |
} |
|
387 |
if (codebase != null && codebase != "") { |
|
388 |
iiopProfile.add(IIOPFactories. makeJavaCodebaseComponent(codebase)); |
|
389 |
} |
|
390 |
if (orb.getORBData().isJavaSerializationEnabled()) { |
|
391 |
iiopProfile.add( |
|
392 |
IIOPFactories.makeJavaSerializationComponent()); |
|
393 |
} |
|
394 |
} |
|
395 |
iorTemplate.add(iiopProfile); |
|
396 |
} |
|
397 |
} |
|
398 |
||
399 |
public String getMonitoringName() |
|
400 |
{ |
|
401 |
return "AcceptedConnections"; |
|
402 |
} |
|
403 |
||
404 |
//////////////////////////////////////////////////// |
|
405 |
// |
|
406 |
// EventHandler methods |
|
407 |
// |
|
408 |
||
409 |
public SelectableChannel getChannel() |
|
410 |
{ |
|
411 |
return serverSocketChannel; |
|
412 |
} |
|
413 |
||
414 |
public int getInterestOps() |
|
415 |
{ |
|
416 |
return SelectionKey.OP_ACCEPT; |
|
417 |
} |
|
418 |
||
419 |
public Acceptor getAcceptor() |
|
420 |
{ |
|
421 |
return this; |
|
422 |
} |
|
423 |
||
424 |
public Connection getConnection() |
|
425 |
{ |
|
426 |
throw new RuntimeException("Should not happen."); |
|
427 |
} |
|
428 |
||
429 |
//////////////////////////////////////////////////// |
|
430 |
// |
|
431 |
// Work methods. |
|
432 |
// |
|
433 |
||
434 |
/* CONFLICT: with legacy below. |
|
435 |
public String getName() |
|
436 |
{ |
|
437 |
return this.toString(); |
|
438 |
} |
|
439 |
*/ |
|
440 |
||
441 |
public void doWork() |
|
442 |
{ |
|
443 |
try { |
|
444 |
if (orb.transportDebugFlag) { |
|
445 |
dprint(".doWork->: " + this); |
|
446 |
} |
|
447 |
if (selectionKey.isAcceptable()) { |
|
448 |
accept(); |
|
449 |
} else { |
|
450 |
if (orb.transportDebugFlag) { |
|
451 |
dprint(".doWork: ! selectionKey.isAcceptable: " + this); |
|
452 |
} |
|
453 |
} |
|
454 |
} catch (SecurityException se) { |
|
455 |
if (orb.transportDebugFlag) { |
|
456 |
dprint(".doWork: ignoring SecurityException: " |
|
457 |
+ se |
|
458 |
+ " " + this); |
|
459 |
} |
|
460 |
String permissionStr = ORBUtility.getClassSecurityInfo(getClass()); |
|
461 |
wrapper.securityExceptionInAccept(se, permissionStr); |
|
462 |
} catch (Exception ex) { |
|
463 |
if (orb.transportDebugFlag) { |
|
464 |
dprint(".doWork: ignoring Exception: " |
|
465 |
+ ex |
|
466 |
+ " " + this); |
|
467 |
} |
|
468 |
wrapper.exceptionInAccept(ex); |
|
469 |
} catch (Throwable t) { |
|
470 |
if (orb.transportDebugFlag) { |
|
471 |
dprint(".doWork: ignoring Throwable: " |
|
472 |
+ t |
|
473 |
+ " " + this); |
|
474 |
} |
|
475 |
} finally { |
|
476 |
||
477 |
// IMPORTANT: To avoid bug (4953599), we force the |
|
478 |
// Thread that does the NIO select to also do the |
|
479 |
// enable/disable of Ops using SelectionKey.interestOps(). |
|
480 |
// Otherwise, the SelectionKey.interestOps() may block |
|
481 |
// indefinitely. |
|
482 |
// NOTE: If "acceptorSocketUseWorkerThreadForEvent" is |
|
483 |
// set to to false in ParserTable.java, then this method, |
|
484 |
// doWork(), will get executed by the same thread |
|
485 |
// (SelectorThread) that does the NIO select. |
|
486 |
// If "acceptorSocketUseWorkerThreadForEvent" is set |
|
487 |
// to true, a WorkerThread will execute this method, |
|
488 |
// doWork(). Hence, the registering of the enabling of |
|
489 |
// the SelectionKey's interestOps is done here instead |
|
490 |
// of calling SelectionKey.interestOps(<interest op>). |
|
491 |
||
492 |
Selector selector = orb.getTransportManager().getSelector(0); |
|
36019
f5596d6af0de
8144144: ORB destroy() leaks filedescriptors after unsuccessful connection
msheppar
parents:
25862
diff
changeset
|
493 |
if (selector != null) { |
f5596d6af0de
8144144: ORB destroy() leaks filedescriptors after unsuccessful connection
msheppar
parents:
25862
diff
changeset
|
494 |
selector.registerInterestOps(this); |
f5596d6af0de
8144144: ORB destroy() leaks filedescriptors after unsuccessful connection
msheppar
parents:
25862
diff
changeset
|
495 |
} |
4 | 496 |
|
497 |
if (orb.transportDebugFlag) { |
|
498 |
dprint(".doWork<-:" + this); |
|
499 |
} |
|
500 |
} |
|
501 |
} |
|
502 |
||
503 |
public void setEnqueueTime(long timeInMillis) |
|
504 |
{ |
|
505 |
enqueueTime = timeInMillis; |
|
506 |
} |
|
507 |
||
508 |
public long getEnqueueTime() |
|
509 |
{ |
|
510 |
return enqueueTime; |
|
511 |
} |
|
512 |
||
513 |
||
514 |
// |
|
515 |
// Factory methods. |
|
516 |
// |
|
517 |
||
518 |
// REVISIT: refactor into common base or delegate. |
|
519 |
public MessageMediator createMessageMediator(Broker broker, |
|
520 |
Connection connection) |
|
521 |
{ |
|
522 |
// REVISIT - no factoring so cheat to avoid code dup right now. |
|
523 |
// REVISIT **** COUPLING !!!! |
|
524 |
ContactInfo contactInfo = new SocketOrChannelContactInfoImpl(); |
|
525 |
return contactInfo.createMessageMediator(broker, connection); |
|
526 |
} |
|
527 |
||
528 |
// REVISIT: refactor into common base or delegate. |
|
529 |
public MessageMediator finishCreatingMessageMediator(Broker broker, |
|
530 |
Connection connection, |
|
531 |
MessageMediator messageMediator) |
|
532 |
{ |
|
533 |
// REVISIT - no factoring so cheat to avoid code dup right now. |
|
534 |
// REVISIT **** COUPLING !!!! |
|
535 |
ContactInfo contactInfo = new SocketOrChannelContactInfoImpl(); |
|
536 |
return contactInfo.finishCreatingMessageMediator(broker, |
|
537 |
connection, messageMediator); |
|
538 |
} |
|
539 |
||
540 |
public InputObject createInputObject(Broker broker, |
|
541 |
MessageMediator messageMediator) |
|
542 |
{ |
|
543 |
CorbaMessageMediator corbaMessageMediator = (CorbaMessageMediator) |
|
544 |
messageMediator; |
|
545 |
return new CDRInputObject((ORB)broker, |
|
546 |
(CorbaConnection)messageMediator.getConnection(), |
|
547 |
corbaMessageMediator.getDispatchBuffer(), |
|
548 |
corbaMessageMediator.getDispatchHeader()); |
|
549 |
} |
|
550 |
||
551 |
public OutputObject createOutputObject(Broker broker, |
|
552 |
MessageMediator messageMediator) |
|
553 |
{ |
|
554 |
CorbaMessageMediator corbaMessageMediator = (CorbaMessageMediator) |
|
555 |
messageMediator; |
|
18307
8bf60b58675b
8000642: Better handling of objects for transportation
coffeys
parents:
7059
diff
changeset
|
556 |
return sun.corba.OutputStreamFactory.newCDROutputObject((ORB) broker, |
8bf60b58675b
8000642: Better handling of objects for transportation
coffeys
parents:
7059
diff
changeset
|
557 |
corbaMessageMediator, corbaMessageMediator.getReplyHeader(), |
8bf60b58675b
8000642: Better handling of objects for transportation
coffeys
parents:
7059
diff
changeset
|
558 |
corbaMessageMediator.getStreamFormatVersion()); |
4 | 559 |
} |
560 |
||
561 |
//////////////////////////////////////////////////// |
|
562 |
// |
|
563 |
// SocketOrChannelAcceptor |
|
564 |
// |
|
565 |
||
566 |
public ServerSocket getServerSocket() |
|
567 |
{ |
|
568 |
return serverSocket; |
|
569 |
} |
|
570 |
||
571 |
//////////////////////////////////////////////////// |
|
572 |
// |
|
573 |
// Implementation. |
|
574 |
// |
|
575 |
||
576 |
public String toString() |
|
577 |
{ |
|
578 |
String sock; |
|
579 |
if (serverSocketChannel == null) { |
|
580 |
if (serverSocket == null) { |
|
581 |
sock = "(not initialized)"; |
|
582 |
} else { |
|
583 |
sock = serverSocket.toString(); |
|
584 |
} |
|
585 |
} else { |
|
586 |
sock = serverSocketChannel.toString(); |
|
587 |
} |
|
588 |
||
589 |
return |
|
590 |
toStringName() + |
|
591 |
"[" |
|
592 |
+ sock + " " |
|
593 |
+ type + " " |
|
594 |
+ shouldUseSelectThreadToWait() + " " |
|
595 |
+ shouldUseWorkerThreadForEvent() |
|
596 |
+ "]" ; |
|
597 |
} |
|
598 |
||
599 |
protected String toStringName() |
|
600 |
{ |
|
601 |
return "SocketOrChannelAcceptorImpl"; |
|
602 |
} |
|
603 |
||
604 |
protected void dprint(String msg) |
|
605 |
{ |
|
606 |
ORBUtility.dprint(toStringName(), msg); |
|
607 |
} |
|
608 |
||
609 |
protected void dprint(String msg, Throwable t) |
|
610 |
{ |
|
611 |
dprint(msg); |
|
612 |
t.printStackTrace(System.out); |
|
613 |
} |
|
614 |
||
615 |
// BEGIN Legacy support |
|
616 |
//////////////////////////////////////////////////// |
|
617 |
// |
|
618 |
// LegacyServerSocketEndPointInfo and EndPointInfo |
|
619 |
// |
|
620 |
||
621 |
public String getType() |
|
622 |
{ |
|
623 |
return type; |
|
624 |
} |
|
625 |
||
626 |
public String getHostName() |
|
627 |
{ |
|
628 |
return hostname; |
|
629 |
} |
|
630 |
||
631 |
public String getHost() |
|
632 |
{ |
|
633 |
return hostname; |
|
634 |
} |
|
635 |
||
636 |
public int getPort() |
|
637 |
{ |
|
638 |
return port; |
|
639 |
} |
|
640 |
||
641 |
public int getLocatorPort() |
|
642 |
{ |
|
643 |
return locatorPort; |
|
644 |
} |
|
645 |
||
646 |
public void setLocatorPort (int port) |
|
647 |
{ |
|
648 |
locatorPort = port; |
|
649 |
} |
|
650 |
||
651 |
public String getName() |
|
652 |
{ |
|
653 |
// Kluge alert: |
|
654 |
// Work and Legacy both define getName. |
|
655 |
// Try to make this behave best for most cases. |
|
656 |
String result = |
|
657 |
name.equals(LegacyServerSocketEndPointInfo.NO_NAME) ? |
|
658 |
this.toString() : name; |
|
659 |
return result; |
|
660 |
} |
|
661 |
// END Legacy support |
|
662 |
} |
|
663 |
||
664 |
// End of file. |