content: /*
   * Licensed to the Apache Software Foundation (ASF) under one or more
   * contributor license agreements.  See the NOTICE file distributed with
   * this work for additional information regarding copyright ownership.
   * The ASF licenses this file to You under the Apache License, Version 2.0
   * (the "License"); you may not use this file except in compliance with
   * the License.  You may obtain a copy of the License at
   *
   *      http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  package org.apache.activemq.pool;
  
  import jakarta.annotation.PostConstruct;
  import jakarta.annotation.PreDestroy;
  import jakarta.jms.ConnectionFactory;
  import jakarta.transaction.TransactionManager;
  import org.apache.activemq.jms.pool.PooledConnectionFactory;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  import org.springframework.beans.factory.FactoryBean;
  
  /**
   * Simple factory bean used to create a jencks connection pool.
   * Depending on the properties set, it will create a simple pool,
   * a transaction aware connection pool, or a jca aware connection pool.
   *
   * <pre class="code">
   * <bean id="pooledConnectionFactory" class="javax.script.ScriptEngineFactory.PooledConnectionFactoryFactoryBean">
   *   <property name="connectionFactory" ref="connectionFactory" />
   *   <property name="transactionManager" ref="transactionManager" />
   *   <property name="resourceName" value="ResourceName" />
   * </bean>
   * </pre>
   *
   * The <code>resourceName</code> property should be used along with the {@link org.apache.activemq.jms.pool.GenericResourceManager} and have
   * the same value than its <code>resourceName</code> property. This will make sure the transaction manager
   * maps correctly the connection factory to the recovery process.
   *
   * @org.apache.xbean.XBean
   */
  public class PooledConnectionFactoryBean implements FactoryBean {
  
      private static final Logger LOGGER = LoggerFactory.getLogger(PooledConnectionFactoryBean.class);
  
      private PooledConnectionFactory pooledConnectionFactory;
      private ConnectionFactory connectionFactory;
      private int maxConnections = 1;
      private int maximumActive = 500;
      private Object transactionManager;
      private String resourceName;
  
      public int getMaxConnections() {
          return maxConnections;
      }
  
      public void setMaxConnections(int maxConnections) {
          this.maxConnections = maxConnections;
      }
  
      public int getMaximumActive() {
          return maximumActive;
      }
  
      public void setMaximumActive(int maximumActive) {
          this.maximumActive = maximumActive;
      }
  
      public Object getTransactionManager() {
          return transactionManager;
      }
  
      public void setTransactionManager(Object transactionManager) {
          this.transactionManager = transactionManager;
      }
  
      public String getResourceName() {
          return resourceName;
      }
  
      public void setResourceName(String resourceName) {
          this.resourceName = resourceName;
      }
  
      public ConnectionFactory getConnectionFactory() {
          return connectionFactory;
      }
  
      public void setConnectionFactory(ConnectionFactory connectionFactory) {
          this.connectionFactory = connectionFactory;
      }
  
      /**
       * JSR-250 callback wrapper; converts checked exceptions to runtime exceptions
       *
       * delegates to afterPropertiesSet, done to prevent backwards incompatible signature change.
       */
      @PostConstruct
      private void postConstruct() {
          try {
              afterPropertiesSet();
          } catch (Exception ex) {
              throw new RuntimeException(ex);
          }
      }
  
      /**
       *
       * @throws Exception
       * @org.apache.xbean.InitMethod
       */
      public void afterPropertiesSet() throws Exception {
          if (pooledConnectionFactory == null && transactionManager != null && resourceName != null) {
              try {
                  LOGGER.debug("Trying to build a JcaPooledConnectionFactory");
                  JcaPooledConnectionFactory f = new JcaPooledConnectionFactory();
                  f.setName(resourceName);
                  f.setTransactionManager((TransactionManager) transactionManager);
                  f.setMaxConnections(maxConnections);
                  f.setMaximumActiveSessionPerConnection(maximumActive);
                  f.setConnectionFactory(connectionFactory);
                  this.pooledConnectionFactory = f;
              } catch (Throwable t) {
                  LOGGER.debug("Could not create JCA enabled connection factory: " + t, t);
              }
          }
          if (pooledConnectionFactory == null && transactionManager != null) {
              try {
                  LOGGER.debug("Trying to build a XaPooledConnectionFactory");
                  XaPooledConnectionFactory f = new XaPooledConnectionFactory();
                  f.setTransactionManager((TransactionManager) transactionManager);
                  f.setMaxConnections(maxConnections);
                  f.setMaximumActiveSessionPerConnection(maximumActive);
                  f.setConnectionFactory(connectionFactory);
                  this.pooledConnectionFactory = f;
              } catch (Throwable t) {
                  LOGGER.debug("Could not create XA enabled connection factory: " + t, t);
              }
          }
          if (pooledConnectionFactory == null) {
              try {
                  LOGGER.debug("Trying to build a PooledConnectionFactory");
                  PooledConnectionFactory f = new PooledConnectionFactory();
                  f.setMaxConnections(maxConnections);
                  f.setMaximumActiveSessionPerConnection(maximumActive);
                  f.setConnectionFactory(connectionFactory);
                  this.pooledConnectionFactory = f;
              } catch (Throwable t) {
                  LOGGER.debug("Could not create pooled connection factory: " + t, t);
              }
          }
          if (pooledConnectionFactory == null) {
              throw new IllegalStateException("Unable to create pooled connection factory.  Enable DEBUG log level for more informations");
          }
      }
  
      /**
       * JSR-250 callback wrapper; converts checked exceptions to runtime exceptions
       *
       * delegates to destroy, done to prevent backwards incompatible signature change.
       */
      @PreDestroy
      private void preDestroy() {
          try {
              destroy();
          } catch (Exception ex) {
              throw new RuntimeException(ex);
          }
      }
  
      /**
       *
       * @throws Exception
       * @org.apache.xbean.DestroyMethod
       */
      public void destroy() throws Exception {
          if (pooledConnectionFactory != null) {
              pooledConnectionFactory.stop();
              pooledConnectionFactory = null;
          }
      }
  
      @Override
      public Object getObject() throws Exception {
          // in case spring-dm calls getObject before this bean has been initialized
          if (pooledConnectionFactory == null) {
              afterPropertiesSet();
          }
          return pooledConnectionFactory;
      }
  
      @Override
      public Class getObjectType() {
          return ConnectionFactory.class;
      }
  
      @Override
      public boolean isSingleton() {
          return true;
      }
  }
  