CorbaTransportManagerImpl.java revision 744:a98f572e2ceb 
1/*
2 * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
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
7 * published by the Free Software Foundation.  Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
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 *
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.
24 */
25
26package com.sun.corba.se.impl.transport;
27
28import java.net.ServerSocket;
29import java.util.ArrayList;
30import java.util.Collection;
31import java.util.HashMap;
32import java.util.Iterator;
33import java.util.List;
34import java.util.Map;
35
36import org.omg.CORBA.INITIALIZE;
37import org.omg.CORBA.INTERNAL;
38import org.omg.CORBA.CompletionStatus;
39
40import com.sun.corba.se.pept.transport.Acceptor;
41import com.sun.corba.se.pept.transport.ConnectionCache;
42import com.sun.corba.se.pept.transport.ByteBufferPool;
43import com.sun.corba.se.pept.transport.ContactInfo;
44import com.sun.corba.se.pept.transport.InboundConnectionCache;
45import com.sun.corba.se.pept.transport.OutboundConnectionCache;
46import com.sun.corba.se.pept.transport.Selector;
47
48import com.sun.corba.se.spi.ior.IORTemplate;
49import com.sun.corba.se.spi.ior.ObjectAdapterId;
50import com.sun.corba.se.spi.orb.ORB;
51import com.sun.corba.se.spi.transport.CorbaAcceptor;
52import com.sun.corba.se.spi.transport.CorbaTransportManager;
53import com.sun.corba.se.pept.transport.Connection;
54import com.sun.corba.se.pept.transport.ConnectionCache;
55
56// REVISIT - impl/poa specific:
57import com.sun.corba.se.impl.oa.poa.Policies;
58import com.sun.corba.se.impl.orbutil.ORBUtility;
59
60/**
61 * @author Harold Carr
62 */
63public class CorbaTransportManagerImpl
64    implements
65        CorbaTransportManager
66{
67    protected ORB orb;
68    protected List acceptors;
69    protected Map outboundConnectionCaches;
70    protected Map inboundConnectionCaches;
71    protected Selector selector;
72
73    public CorbaTransportManagerImpl(ORB orb)
74    {
75        this.orb = orb;
76        acceptors = new ArrayList();
77        outboundConnectionCaches = new HashMap();
78        inboundConnectionCaches = new HashMap();
79        selector = new SelectorImpl(orb);
80    }
81
82    ////////////////////////////////////////////////////
83    //
84    // pept TransportManager
85    //
86
87    public ByteBufferPool getByteBufferPool(int id)
88    {
89        throw new RuntimeException();
90    }
91
92    public OutboundConnectionCache getOutboundConnectionCache(
93        ContactInfo contactInfo)
94    {
95        synchronized (contactInfo) {
96            if (contactInfo.getConnectionCache() == null) {
97                OutboundConnectionCache connectionCache = null;
98                synchronized (outboundConnectionCaches) {
99                    connectionCache = (OutboundConnectionCache)
100                        outboundConnectionCaches.get(
101                            contactInfo.getConnectionCacheType());
102                    if (connectionCache == null) {
103                        // REVISIT: Would like to be able to configure
104                        // the connection cache type used.
105                        connectionCache =
106                            new CorbaOutboundConnectionCacheImpl(orb,
107                                                                 contactInfo);
108                        outboundConnectionCaches.put(
109                            contactInfo.getConnectionCacheType(),
110                            connectionCache);
111                    }
112                }
113                contactInfo.setConnectionCache(connectionCache);
114            }
115            return contactInfo.getConnectionCache();
116        }
117    }
118
119    public Collection getOutboundConnectionCaches()
120    {
121        return outboundConnectionCaches.values();
122    }
123
124    public InboundConnectionCache getInboundConnectionCache(
125        Acceptor acceptor)
126    {
127        synchronized (acceptor) {
128            if (acceptor.getConnectionCache() == null) {
129                InboundConnectionCache connectionCache = null;
130                synchronized (inboundConnectionCaches) {
131                    connectionCache = (InboundConnectionCache)
132                        inboundConnectionCaches.get(
133                            acceptor.getConnectionCacheType());
134                    if (connectionCache == null) {
135                        // REVISIT: Would like to be able to configure
136                        // the connection cache type used.
137                        connectionCache =
138                            new CorbaInboundConnectionCacheImpl(orb,
139                                                                acceptor);
140                        inboundConnectionCaches.put(
141                            acceptor.getConnectionCacheType(),
142                            connectionCache);
143                    }
144                }
145                acceptor.setConnectionCache(connectionCache);
146            }
147            return acceptor.getConnectionCache();
148        }
149    }
150
151    public Collection getInboundConnectionCaches()
152    {
153        return inboundConnectionCaches.values();
154    }
155
156    public Selector getSelector(int id)
157    {
158        return selector;
159    }
160
161    public synchronized void registerAcceptor(Acceptor acceptor)
162    {
163        if (orb.transportDebugFlag) {
164            dprint(".registerAcceptor->: " + acceptor);
165        }
166        acceptors.add(acceptor);
167        if (orb.transportDebugFlag) {
168            dprint(".registerAcceptor<-: " + acceptor);
169        }
170    }
171
172    public Collection getAcceptors()
173    {
174        return getAcceptors(null, null);
175    }
176
177    public synchronized void unregisterAcceptor(Acceptor acceptor)
178    {
179        acceptors.remove(acceptor);
180    }
181
182    public void close()
183    {
184        try {
185            if (orb.transportDebugFlag) {
186                dprint(".close->");
187            }
188            for (Object cc : outboundConnectionCaches.values()) {
189                ((ConnectionCache)cc).close() ;
190            }
191            for (Object icc : inboundConnectionCaches.values()) {
192                ((ConnectionCache)icc).close() ;
193                unregisterAcceptor(((InboundConnectionCache)icc).getAcceptor());
194            }
195            getSelector(0).close();
196        } finally {
197            if (orb.transportDebugFlag) {
198                dprint(".close<-");
199            }
200        }
201    }
202
203    ////////////////////////////////////////////////////
204    //
205    // CorbaTransportManager
206    //
207
208    public Collection getAcceptors(String objectAdapterManagerId,
209                                   ObjectAdapterId objectAdapterId)
210    {
211        // REVISIT - need to filter based on arguments.
212
213        // REVISIT - initialization will be moved to OA.
214        // Lazy initialization of acceptors.
215        Iterator iterator = acceptors.iterator();
216        while (iterator.hasNext()) {
217            Acceptor acceptor = (Acceptor) iterator.next();
218            if (acceptor.initialize()) {
219                if (acceptor.shouldRegisterAcceptEvent()) {
220                    orb.getTransportManager().getSelector(0)
221                        .registerForEvent(acceptor.getEventHandler());
222                }
223            }
224        }
225        return acceptors;
226    }
227
228    // REVISIT - POA specific policies
229    public void addToIORTemplate(IORTemplate iorTemplate,
230                                 Policies policies,
231                                 String codebase,
232                                 String objectAdapterManagerId,
233                                 ObjectAdapterId objectAdapterId)
234    {
235        Iterator iterator =
236            getAcceptors(objectAdapterManagerId, objectAdapterId).iterator();
237        while (iterator.hasNext()) {
238            CorbaAcceptor acceptor = (CorbaAcceptor) iterator.next();
239            acceptor.addToIORTemplate(iorTemplate, policies, codebase);
240        }
241    }
242
243
244    ////////////////////////////////////////////////////
245    //
246    // implemenation
247    //
248
249    protected void dprint(String msg)
250    {
251        ORBUtility.dprint("CorbaTransportManagerImpl", msg);
252    }
253}
254
255// End of file.
256