001    /*
002     * Copyright 2002-2005 the original author or authors.
003     *
004     * Licensed under the Apache License, Version 2.0 (the "License");
005     * you may not use this file except in compliance with the License.
006     * You may obtain a copy of the License at
007     *
008     *      http://www.apache.org/licenses/LICENSE-2.0
009     *
010     * Unless required by applicable law or agreed to in writing, software
011     * distributed under the License is distributed on an "AS IS" BASIS,
012     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
013     * See the License for the specific language governing permissions and
014     * limitations under the License.
015     */
016    
017    package org.jencks.factory;
018    
019    import java.util.Map;
020    
021    import javax.resource.spi.ConnectionManager;
022    
023    import org.apache.geronimo.connector.outbound.GenericConnectionManager;
024    import org.apache.geronimo.connector.outbound.connectionmanagerconfig.NoPool;
025    import org.apache.geronimo.connector.outbound.connectionmanagerconfig.NoTransactions;
026    import org.apache.geronimo.connector.outbound.connectionmanagerconfig.PoolingSupport;
027    import org.apache.geronimo.connector.outbound.connectionmanagerconfig.TransactionSupport;
028    import org.apache.geronimo.connector.outbound.connectiontracking.ConnectionTracker;
029    import org.apache.geronimo.transaction.context.TransactionContextManager;
030    import org.springframework.beans.factory.FactoryBean;
031    import org.springframework.beans.factory.InitializingBean;
032    import org.springframework.context.ApplicationContext;
033    import org.springframework.context.ApplicationContextAware;
034    
035    /**
036     * This FactoryBean creates a local JCA connection factory outside
037     * a J2EE application server.
038     * <p/>
039     * The connection manager will be then injected in the
040     * LocalConnectionFactoryBean, class of the JCA support of Spring.
041     *
042     * @author Thierry Templier
043     * @see org.springframework.jca.support.LocalConnectionFactoryBean#setConnectionManager(ConnectionManager)
044     * @see NoTransactionFactoryBean
045     * @see LocalTransactionFactoryBean
046     * @see XATransactionFactoryBean
047     * @see PartitionedPoolFactoryBean
048     * @see SinglePoolFactoryBean
049     */
050    public class ConnectionManagerFactoryBean implements FactoryBean, InitializingBean, ApplicationContextAware {
051    
052            private ApplicationContext applicationContext;
053        private TransactionSupport transactionSupport;
054        private PoolingSupport poolingSupport;
055        private boolean containerManagedSecurity;
056        private TransactionContextManager transactionContextManager;
057        private ConnectionTracker connectionTracker;
058        private ConnectionManager connectionManager;
059    
060        public Object getObject() throws Exception {
061            return connectionManager;
062        }
063    
064        public Class getObjectType() {
065            return ConnectionManager.class;
066        }
067    
068        public boolean isSingleton() {
069            return true;
070        }
071    
072            public void setApplicationContext(ApplicationContext applicationContext) {
073                    this.applicationContext = applicationContext;
074            }
075    
076        /**
077         * Set the pooling support for the Geronimo Connection Manager.
078         * Geronimo provides two kinds of pool: single and partitioned.
079         *
080         * @see org.apache.geronimo.connector.outbound.connectionmanagerconfig.SinglePool
081         * @see org.apache.geronimo.connector.outbound.connectionmanagerconfig.PartitionedPool
082         */
083        public void setPoolingSupport(PoolingSupport support) {
084            poolingSupport = support;
085        }
086    
087        /**
088         * Set the transaction context manager for the Geronimo Connection Manager.
089         */
090        public void setTransactionContextManager(TransactionContextManager manager) {
091            transactionContextManager = manager;
092        }
093    
094        /**
095         * Set the transaction support for the Geronimo Connection Manager.
096         * Geronimo provides in this case three kinds of support like the
097         * JCA specification: no transaction, local transactions, XA transactions.
098         *
099         * @see NoTransactions
100         * @see org.apache.geronimo.connector.outbound.connectionmanagerconfig.LocalTransactions
101         * @see org.apache.geronimo.connector.outbound.connectionmanagerconfig.XATransactions
102         */
103        public void setTransactionSupport(TransactionSupport support) {
104            transactionSupport = support;
105        }
106    
107        /**
108         * Set the connection tracker for the Geronimo Connection Manager.
109         */
110        public void setConnectionTracker(ConnectionTracker tracker) {
111            connectionTracker = tracker;
112        }
113    
114        /**
115         * Enables/disables container managed security
116         */
117        public void setContainerManagedSecurity(boolean containerManagedSecurity) {
118            this.containerManagedSecurity = containerManagedSecurity;
119        }
120    
121        /**
122         * This method checks all the needed parameters to construct
123         * the Geronimo connection manager which is implemented by the
124         * GenericConnectionManager class.
125         * If the transaction support property is not set, the method
126         * configures the connection manager with the no transaction value.
127         * If the pooling support property is not set, the method
128         * configures the connection manager with the no pool value.
129         * If the realm bridge is not set, the method configure
130         * the connection manager with an identity realm bridge.
131         *
132         * @see GenericConnectionManager
133         */
134        public void afterPropertiesSet() throws Exception {
135            // Apply the default value for property if necessary
136            if (this.transactionSupport == null) {
137                // No transaction
138                this.transactionSupport = NoTransactions.INSTANCE;
139            }
140            if (this.poolingSupport == null) {
141                // No pool
142                this.poolingSupport = new NoPool();
143            }
144            // Instanciate the Geronimo Connection Manager
145            this.connectionManager = new GenericConnectionManager(
146                            this.transactionSupport, 
147                            this.poolingSupport,
148                    this.containerManagedSecurity, 
149                    getConnectionTracker(), 
150                    getTransactionContextManager(),
151                    getClass().getName(), 
152                    getClass().getClassLoader());
153        }
154    
155            public ConnectionTracker getConnectionTracker() {
156                    if (connectionTracker == null) {
157                            Map map = applicationContext.getBeansOfType(ConnectionTracker.class);
158                            if (map.size() == 1) {
159                                    connectionTracker = (ConnectionTracker) map.values().iterator().next();
160                            }
161                    }
162                    return connectionTracker;
163            }
164    
165            public TransactionContextManager getTransactionContextManager() {
166                    if (transactionContextManager == null) {
167                            Map map = applicationContext.getBeansOfType(TransactionContextManager.class);
168                            if (map.size() == 1) {
169                                    transactionContextManager = (TransactionContextManager) map.values().iterator().next();
170                            } else {
171                                    throw new IllegalStateException("no TransactionContextManager is registered");
172                            }
173                    }
174                    return transactionContextManager;
175            }
176    
177    }