001    /**
002     * Licensed to the Apache Software Foundation (ASF) under one or more
003     * contributor license agreements.  See the NOTICE file distributed with
004     * this work for additional information regarding copyright ownership.
005     * The ASF licenses this file to You under the Apache License, Version 2.0
006     * (the "License"); you may not use this file except in compliance with
007     * the License.  You may obtain a copy of the License at
008     *
009     *     http://www.apache.org/licenses/LICENSE-2.0
010     *
011     * Unless required by applicable law or agreed to in writing, software
012     * distributed under the License is distributed on an "AS IS" BASIS,
013     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014     * See the License for the specific language governing permissions and
015     * limitations under the License.
016     */
017    package org.apache.geronimo.corba;
018    
019    import java.net.InetAddress;
020    import java.net.InetSocketAddress;
021    import java.net.UnknownHostException;
022    
023    import javax.ejb.spi.HandleDelegate;
024    
025    import org.apache.commons.logging.Log;
026    import org.apache.commons.logging.LogFactory;
027    import org.apache.geronimo.gbean.AbstractName;
028    import org.apache.geronimo.gbean.GBeanLifecycle;
029    import org.apache.geronimo.gbean.InvalidConfigurationException; 
030    import org.apache.geronimo.corba.security.ServerPolicy;
031    import org.apache.geronimo.corba.security.ServerPolicyFactory;
032    import org.apache.geronimo.corba.security.config.ConfigAdapter;
033    import org.apache.geronimo.corba.security.config.ssl.SSLConfig;
034    import org.apache.geronimo.corba.security.config.tss.TSSConfig;
035    import org.apache.geronimo.corba.security.config.tss.TSSSSLTransportConfig;
036    import org.apache.geronimo.corba.security.config.tss.TSSTransportMechConfig;
037    import org.apache.geronimo.corba.util.Util;
038    import org.apache.geronimo.openejb.OpenEjbSystem; 
039    import org.omg.CORBA.Any;
040    import org.omg.CORBA.ORB;
041    import org.omg.CORBA.Policy;
042    import org.omg.PortableServer.POA;
043    import org.omg.PortableServer.POAHelper;
044    
045    
046    /**
047     * A CORBABean is a main CORBA server configuration.  The
048     * CORBABean is the hosting ORB to which additional TSSBeans
049     * attach to export EJBs.  The CORBABean may be configured
050     * to use either plain socket listeners or SSL listeners, based
051     * on the bean specification.  All TSSBean objects attached
052     * to this Bean instance will share the same listener
053     * endpoint and transport-level security.
054     * @version $Revision: 497125 $ $Date: 2007-01-17 10:51:30 -0800 (Wed, 17 Jan 2007) $
055     */
056    public class CORBABean implements GBeanLifecycle, ORBRef, ORBConfiguration {
057        private final Log log = LogFactory.getLog(CORBABean.class);
058    
059        private final ClassLoader classLoader;
060        private final ConfigAdapter configAdapter;
061        // the initial listener port
062        private int listenerPort;
063        // the host name we expose in IORs
064        private String host;
065        private TSSConfig tssConfig;
066        private SSLConfig sslConfig;
067        private ORB orb;
068        private POA rootPOA;
069        private NameService nameService;
070        private AbstractName abstractName;
071        private OpenEjbSystem ejbSystem; 
072        // ORB-specific policy overrides we need to add to POA policies created by 
073        // child TSSBeans.  
074        private Policy[] policyOverrides = null; 
075    
076        public CORBABean() {
077            this.classLoader = null;
078            this.configAdapter = null;
079            this.sslConfig = null;
080            this.listenerPort = -1;
081            this.host = null;
082            this.abstractName = null;
083            this.policyOverrides = null; 
084            this.ejbSystem = null;
085        }
086    
087        /**
088         * Instantiate a CORBABean instance.
089         *
090         * @param abstractName
091         *               The server-created abstract name for this bean instance.
092         * @param configAdapter
093         *               The ORB ConfigAdapter used to interface with the
094         *               JVM-configured ORB instance.
095         * @param host   The hostname we publish ourselves under.
096         * @param listenerPort
097         *               The initial listener port to use.
098         * @param classLoader
099         *               The ClassLoader used for ORB context class loading.
100         * @param nameService
101         *               The initial name service the created ORB will use
102         *               for object resolution.
103         * @param ssl    The SSL configuration, including the KeystoreManager.
104         *
105         */
106        public CORBABean(AbstractName abstractName, ConfigAdapter configAdapter, String host, int listenerPort, ClassLoader classLoader, NameService nameService, OpenEjbSystem ejbSystem, SSLConfig ssl) {
107            this.abstractName = abstractName;
108            this.classLoader = classLoader;
109            this.configAdapter = configAdapter;
110            sslConfig = ssl;
111            this.nameService = nameService;
112            this.host = host;
113            this.listenerPort = listenerPort;
114            this.policyOverrides = null; 
115            this.ejbSystem = ejbSystem; 
116        }
117    
118        /**
119         * Retrieve the NameService this CORBA server depends upon.
120         *
121         * @return The configured NameService instance.
122         */
123        public NameService getNameService() {
124            return nameService;
125        }
126    
127        /**
128         * Setter attribute for the NameService.
129         *
130         * @param s      The new target name service.
131         */
132        public void setNameService(NameService s) {
133            nameService = s;
134        }
135    
136        /**
137         * Get the optional TSSConfig object specified for this
138         * CORBABean server.
139         *
140         * @return The TSSConfig object (if any).
141         */
142        public TSSConfig getTssConfig() {
143            // if nothing has been explicitly set, ensure we return
144            // a default one.
145            if (tssConfig == null) {
146                tssConfig = new TSSConfig();
147            }
148            return tssConfig;
149        }
150    
151        /**
152         * Set a TSSConfig value for this CORBA instance.
153         *
154         * @param config The required TSSConfig information.
155         */
156        public void setTssConfig(TSSConfig config) {
157            this.tssConfig = config;
158        }
159    
160        /**
161         * Return the SSLConfig used for this ORB instance.
162         * if one has not been configured, this returns
163         * a default configuration.
164         *
165         * @return The SSLConfig object use to manage transport-level
166         *         security.
167         */
168        public SSLConfig getSslConfig() {
169            if (sslConfig == null) {
170                sslConfig = new SSLConfig();
171            }
172            return sslConfig;
173        }
174    
175        /**
176         * Attribute setter for the SSL configuration.
177         *
178         * @param c      The new SSLConfig object used for secure communications.
179         */
180        public void setSslConfing(SSLConfig c) {
181            sslConfig = c;
182        }
183    
184    
185        /**
186         * Return the ORB instance created for this CORBABean.
187         *
188         * @return The ORB instance backing this bean.
189         */
190        public ORB getORB() {
191            return orb;
192        }
193    
194        public HandleDelegate getHandleDelegate() {
195            return new CORBAHandleDelegate();
196        }
197    
198        /**
199         * Get the root POA() instance associated with the ORB.
200         *
201         * @return The rootPOA instance obtained from the ORB.
202         */
203        public POA getRootPOA() {
204            return rootPOA;
205        }
206    
207        /**
208         * Retrieve the listener address (host/port combo) used
209         * by the ORB.
210         *
211         * @return An InetSocketAddress item identifying the end point
212         *         for the ORB.
213         */
214        public InetSocketAddress getListenAddress() {
215            return new InetSocketAddress(host, listenerPort);
216        }
217    
218        /**
219         * Start the ORB associated with this bean instance.
220         *
221         * @exception Exception
222         */
223        public void doStart() throws Exception {
224    
225            ClassLoader savedLoader = Thread.currentThread().getContextClassLoader();
226            try {
227                Thread.currentThread().setContextClassLoader(classLoader);
228    
229                // make sure we've decided how the listener should be configured.
230                resolveListenerAddress();
231                // register this so we can retrieve this in the interceptors 
232                Util.registerORB(getURI(), this); 
233    
234                log.debug("CORBABean " + getURI() + " creating listener on port " + listenerPort);
235                // the config adapter creates the actual ORB instance for us.
236                orb = configAdapter.createServerORB(this);
237    
238                // we set this ORB value into the Util.  The Util ORB is used for a lot of utility things, so
239                // we'll cache the first instance created.
240                Util.setORB(orb);
241                
242                // TSSBeans are going to need our rootPOA instance, so resolve this now.
243                org.omg.CORBA.Object obj = orb.resolve_initial_references("RootPOA");
244                rootPOA = POAHelper.narrow(obj);
245                // if we have an OpenEjbSystem reference, inform the ejb subsystem 
246                // there's now an ORB available for the JNDI context. 
247                if (ejbSystem != null) {
248                    ejbSystem.setORBContext(orb, getHandleDelegate()); 
249                }
250            } catch (NoSuchMethodError e) {
251                log.error("Incorrect level of org.omg.CORBA classes found.\nLikely cause is an incorrect java.endorsed.dirs configuration"); 
252                throw new InvalidConfigurationException("CORBA usage requires Yoko CORBA spec classes in java.endorsed.dirs classpath", e); 
253            } finally {
254                Thread.currentThread().setContextClassLoader(savedLoader);
255            }
256    
257        }
258    
259        public void doStop() throws Exception {
260            orb.destroy();
261            // remove this from the registry 
262            Util.unregisterORB(getURI()); 
263            log.debug("Stopped CORBABean");
264        }
265    
266        public void doFail() {
267            log.warn("Failed CORBABean");
268        }
269    
270        /**
271         * Process the specified host/port information on
272         * both the bean and the TSSConfig to arrive at a
273         * target port.  This must be called prior to creating
274         * the ORB.
275         */
276        private void resolveListenerAddress() {
277            // now provide defaults for anything still needing resolving
278            if (host == null) {
279                try {
280                    host = InetAddress.getLocalHost().getHostName();
281                } catch (UnknownHostException e) {
282                    // just punt an use localhost as an absolute fallback.
283                    host = "localhost";
284                }
285            }
286            
287            // if nothing has been explicitly specified, we use a port value of -1, which
288            // allows the ORB to allocate the address.
289            
290            // if we have a config with a TSSSSLTransportConfig defined, the
291            // host and port from the config override bean-configured values.
292            if (tssConfig != null) {
293                TSSTransportMechConfig transportMech = tssConfig.getTransport_mech();
294                if (transportMech != null) {
295                    if (transportMech instanceof TSSSSLTransportConfig) {
296                        TSSSSLTransportConfig transportConfig = (TSSSSLTransportConfig) transportMech;
297                        transportConfig.setHostname(host); 
298                        transportConfig.setPort((short)listenerPort); 
299                    }
300                }
301            }
302    
303        }
304    
305        /**
306         * Return the retrieval URI for this bean.
307         *
308         * @return The URI for the bean AbstractName;
309         */
310        public String getURI() {
311            return abstractName.toString();
312        }
313    
314        /**
315         * Get the configured listener port.
316         *
317         * @return The configeration port value.
318         */
319        public int getPort() {
320            return listenerPort;
321        }
322    
323        /**
324         * Get the configuration host name.
325         *
326         * @return The configuration host name.  The default is "localhost".
327         */
328        public String getHost() {
329            return host;
330        }
331        
332        /**
333         * Set a set of policy overrides to be used with 
334         * this ORB instance.  These are normally set by 
335         * the ORBConfigAdapter instance when the ORB 
336         * is created. 
337         * 
338         * @param overrides The new override list.
339         */
340        public void setPolicyOverrides(Policy[] overrides) {
341            policyOverrides = overrides; 
342        }
343        
344        /**
345         * Add the policy overrides (if any) to the list 
346         * of policies used to create a POA instance.
347         * 
348         * @param policies The base set of policies.
349         * 
350         * @return A new Policy array with the overrides added.  Returns
351         *         the same array if no overrides are required.
352         */
353        public Policy[] addPolicyOverrides(Policy[] policies) {
354            // just return the same list of no overrides exist 
355            if (policyOverrides == null) {
356                return policies; 
357            }
358            
359            Policy[] newPolicies = new Policy[policies.length + policyOverrides.length]; 
360            
361            System.arraycopy(policies, 0, newPolicies, 0, policies.length); 
362            System.arraycopy(policyOverrides, 0, newPolicies, policies.length, policyOverrides.length); 
363            
364            return newPolicies; 
365        }
366    }