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.ra;
  
  import jakarta.jms.JMSException;
  
  import org.apache.activemq.ActiveMQConnection;
  import org.apache.activemq.ActiveMQConnectionFactory;
  import org.apache.activemq.ActiveMQSslConnectionFactory;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  /**
   * Abstract base class providing support for creating physical connections to an
   * ActiveMQ instance.
   *
   *
   */
  public class ActiveMQConnectionSupport {
  
      private ActiveMQConnectionRequestInfo info = new ActiveMQConnectionRequestInfo();
      protected Logger log = LoggerFactory.getLogger(getClass());
  
      /**
       * Creates a factory for obtaining physical connections to an Active MQ
       * broker. The factory is configured with the given configuration
       * information.
       *
       * @param connectionRequestInfo
       *        the configuration request information
       * @param activationSpec
       * @return the connection factory
       * @throws java.lang.IllegalArgumentException
       *         if the server URL given in the configuration information is not a
       *         valid URL
       */
      protected ActiveMQConnectionFactory createConnectionFactory(ActiveMQConnectionRequestInfo connectionRequestInfo, MessageActivationSpec activationSpec) {
          // ActiveMQSslConnectionFactory defaults to TCP anyway
          ActiveMQConnectionFactory factory = new ActiveMQSslConnectionFactory();
          connectionRequestInfo.configure(factory, activationSpec);
          return factory;
      }
  
      /**
       * Creates a new physical connection to an Active MQ broker identified by
       * given connection request information.
       *
       * @param connectionRequestInfo
       *        the connection request information identifying the broker and any
       *        required connection parameters, e.g. username/password
       * @return the physical connection
       * @throws JMSException
       *         if the connection could not be established
       */
      public ActiveMQConnection makeConnection(ActiveMQConnectionRequestInfo connectionRequestInfo) throws JMSException {
          return makeConnection(connectionRequestInfo, createConnectionFactory(connectionRequestInfo, null));
      }
  
      /**
       * Creates a new physical connection to an Active MQ broker using a given
       * connection factory and credentials supplied in connection request
       * information.
       *
       * @param connectionRequestInfo
       *        the connection request information containing the credentials to
       *        use for the connection request
       * @return the physical connection
       * @throws JMSException
       *         if the connection could not be established
       */
      public ActiveMQConnection makeConnection(ActiveMQConnectionRequestInfo connectionRequestInfo, ActiveMQConnectionFactory connectionFactory)
          throws JMSException {
          String userName = connectionRequestInfo.getUserName();
          String password = connectionRequestInfo.getPassword();
          ActiveMQConnection physicalConnection = (ActiveMQConnection) connectionFactory.createConnection(userName, password);
  
          String clientId = connectionRequestInfo.getClientid();
          if (clientId != null && clientId.length() > 0) {
              physicalConnection.setClientID(clientId);
          }
          return physicalConnection;
      }
  
      /**
       * Gets the connection request information.
       *
       * @return the connection request information
       */
      public ActiveMQConnectionRequestInfo getInfo() {
          return info;
      }
  
      /**
       * Sets the connection request information as a whole.
       *
       * @param connectionRequestInfo
       *        the connection request information
       */
      protected void setInfo(ActiveMQConnectionRequestInfo connectionRequestInfo) {
          info = connectionRequestInfo;
          if (log.isDebugEnabled()) {
              log.debug(this + ", setting [info] to: " + info);
          }
      }
  
      protected boolean notEqual(Object o1, Object o2) {
          return (o1 == null ^ o2 == null) || (o1 != null && !o1.equals(o2));
      }
  
      protected String emptyToNull(String value) {
          if (value == null || value.length() == 0) {
              return null;
          } else {
              return value;
          }
      }
  
      protected String defaultValue(String value, String defaultValue) {
          if (value != null) {
              return value;
          }
          return defaultValue;
      }
  
      // ///////////////////////////////////////////////////////////////////////
      //
      // Java Bean getters and setters for this ResourceAdapter class.
      //
      // ///////////////////////////////////////////////////////////////////////
  
      /**
       * @return client id
       */
      public String getClientid() {
          return emptyToNull(info.getClientid());
      }
  
      /**
       * @param clientid
       */
      public void setClientid(String clientid) {
          if (log.isDebugEnabled()) {
              log.debug(this + ", setting [clientid] to: " + clientid);
          }
          info.setClientid(clientid);
      }
  
      /**
       * @return password
       */
      public String getPassword() {
          return emptyToNull(info.getPassword());
      }
  
      /**
       * @param password
       */
      public void setPassword(String password) {
          if (log.isDebugEnabled()) {
              log.debug(this + ", setting [password] property");
          }
          info.setPassword(password);
      }
  
      /**
       * @return server URL
       */
      public String getServerUrl() {
          return info.getServerUrl();
      }
  
      /**
       * @param url
       */
      public void setServerUrl(String url) {
          if (log.isDebugEnabled()) {
              log.debug(this + ", setting [serverUrl] to: " + url);
          }
          info.setServerUrl(url);
      }
  
      public String getTrustStore() {
          return info.getTrustStore();
      }
  
      public void setTrustStore(String trustStore) {
          if (log.isDebugEnabled()) {
              log.debug(this + ", setting [trustStore] to: " + trustStore);
          }
          info.setTrustStore(trustStore);
      }
  
      public String getTrustStorePassword() {
          return info.getTrustStorePassword();
      }
  
      public void setTrustStorePassword(String trustStorePassword) {
          if (log.isDebugEnabled()) {
              log.debug(this + ", setting [trustStorePassword] to: " + trustStorePassword);
          }
          info.setTrustStorePassword(trustStorePassword);
      }
  
      public String getKeyStore() {
          return info.getKeyStore();
      }
  
      public void setKeyStore(String keyStore) {
          if (log.isDebugEnabled()) {
              log.debug(this + ", setting [keyStore] to: " + keyStore);
          }
          info.setKeyStore(keyStore);
      }
  
      public String getKeyStorePassword() {
          return info.getKeyStorePassword();
      }
  
      public void setKeyStorePassword(String keyStorePassword) {
          if (log.isDebugEnabled()) {
              log.debug(this + ", setting [keyStorePassword] to: " + keyStorePassword);
          }
          info.setKeyStorePassword(keyStorePassword);
      }
  
      public String getKeyStoreKeyPassword() {
          return info.getKeyStoreKeyPassword();
      }
  
      public void setKeyStoreKeyPassword(String keyStoreKeyPassword) {
          if (log.isDebugEnabled()) {
              log.debug(this + ", setting [keyStoreKeyPassword] to: " + keyStoreKeyPassword);
          }
          info.setKeyStoreKeyPassword(keyStoreKeyPassword);
      }
  
      /**
       * @return user name
       */
      public String getUserName() {
          return emptyToNull(info.getUserName());
      }
  
      /**
       * @param userid
       */
      public void setUserName(String userid) {
          if (log.isDebugEnabled()) {
              log.debug("setting [userName] to: " + userid);
          }
          info.setUserName(userid);
      }
  
      /**
       * @return durable topic prefetch
       */
      public Integer getDurableTopicPrefetch() {
          return info.getDurableTopicPrefetch();
      }
  
      /**
       * @param optimizeDurableTopicPrefetch
       */
      public void setOptimizeDurableTopicPrefetch(Integer optimizeDurableTopicPrefetch) {
          if (log.isDebugEnabled()) {
              log.debug("setting [optimizeDurableTopicPrefetch] to: " + optimizeDurableTopicPrefetch);
          }
          info.setOptimizeDurableTopicPrefetch(optimizeDurableTopicPrefetch);
      }
  
      /**
       * @return durable topic prefetch
       */
      public Integer getOptimizeDurableTopicPrefetch() {
          return info.getOptimizeDurableTopicPrefetch();
      }
  
      /**
       * @param durableTopicPrefetch
       */
      public void setDurableTopicPrefetch(Integer durableTopicPrefetch) {
          if (log.isDebugEnabled()) {
              log.debug("setting [durableTopicPrefetch] to: " + durableTopicPrefetch);
          }
          info.setDurableTopicPrefetch(durableTopicPrefetch);
      }
  
      /**
       * @return initial redelivery delay
       */
      public Long getInitialRedeliveryDelay() {
          return info.getInitialRedeliveryDelay();
      }
  
      /**
       * @param value
       */
      public void setInitialRedeliveryDelay(Long value) {
          if (log.isDebugEnabled()) {
              log.debug("setting [initialRedeliveryDelay] to: " + value);
          }
          info.setInitialRedeliveryDelay(value);
      }
  
      /**
       * @return initial redelivery delay
       */
      public Long getMaximumRedeliveryDelay() {
          return info.getMaximumRedeliveryDelay();
      }
  
      /**
       * @param value
       */
      public void setMaximumRedeliveryDelay(Long value) {
          if (log.isDebugEnabled()) {
              log.debug("setting [maximumRedeliveryDelay] to: " + value);
          }
          info.setMaximumRedeliveryDelay(value);
      }
  
      /**
       * @return input stream prefetch
       */
      @Deprecated
      public Integer getInputStreamPrefetch() {
          return 0;
      }
  
      /**
       * @return maximum redeliveries
       */
      public Integer getMaximumRedeliveries() {
          return info.getMaximumRedeliveries();
      }
  
      /**
       * @param value
       */
      public void setMaximumRedeliveries(Integer value) {
          if (log.isDebugEnabled()) {
              log.debug("setting [maximumRedeliveries] to: " + value);
          }
          info.setMaximumRedeliveries(value);
      }
  
      /**
       * @return queue browser prefetch
       */
      public Integer getQueueBrowserPrefetch() {
          return info.getQueueBrowserPrefetch();
      }
  
      /**
       * @param queueBrowserPrefetch
       */
      public void setQueueBrowserPrefetch(Integer queueBrowserPrefetch) {
          if (log.isDebugEnabled()) {
              log.debug("setting [queueBrowserPrefetch] to: " + queueBrowserPrefetch);
          }
          info.setQueueBrowserPrefetch(queueBrowserPrefetch);
      }
  
      /**
       * @return queue prefetch
       */
      public Integer getQueuePrefetch() {
          return info.getQueuePrefetch();
      }
  
      /**
       * @param queuePrefetch
       */
      public void setQueuePrefetch(Integer queuePrefetch) {
          if (log.isDebugEnabled()) {
              log.debug("setting [queuePrefetch] to: " + queuePrefetch);
          }
          info.setQueuePrefetch(queuePrefetch);
      }
  
      /**
       * @return redelivery backoff multiplier
       */
      public Double getRedeliveryBackOffMultiplier() {
          return info.getRedeliveryBackOffMultiplier();
      }
  
      /**
       * @param value
       */
      public void setRedeliveryBackOffMultiplier(Double value) {
          if (log.isDebugEnabled()) {
              log.debug("setting [redeliveryBackOffMultiplier] to: " + value);
          }
          info.setRedeliveryBackOffMultiplier(value);
      }
  
      /**
       * @return redelivery use exponential backoff
       */
      public Boolean getRedeliveryUseExponentialBackOff() {
          return info.getRedeliveryUseExponentialBackOff();
      }
  
      /**
       * @param value
       */
      public void setRedeliveryUseExponentialBackOff(Boolean value) {
          if (log.isDebugEnabled()) {
              log.debug("setting [redeliveryUseExponentialBackOff] to: " + value);
          }
          info.setRedeliveryUseExponentialBackOff(value);
      }
  
      /**
       * @return topic prefetch
       */
      public Integer getTopicPrefetch() {
          return info.getTopicPrefetch();
      }
  
      /**
       * @param topicPrefetch
       */
      public void setTopicPrefetch(Integer topicPrefetch) {
          if (log.isDebugEnabled()) {
              log.debug("setting [topicPrefetch] to: " + topicPrefetch);
          }
          info.setTopicPrefetch(topicPrefetch);
      }
  
      /**
       * @param i
       */
      public void setAllPrefetchValues(Integer i) {
          info.setAllPrefetchValues(i);
      }
  
      /**
       * @return use inbound session enabled
       */
      public boolean isUseInboundSessionEnabled() {
          return info.isUseInboundSessionEnabled();
      }
  
      /**
       * @return use inbound session
       */
      public Boolean getUseInboundSession() {
          return info.getUseInboundSession();
      }
  
      /**
       * @param useInboundSession
       */
      public void setUseInboundSession(Boolean useInboundSession) {
          if (log.isDebugEnabled()) {
              log.debug("setting [useInboundSession] to: " + useInboundSession);
          }
          info.setUseInboundSession(useInboundSession);
      }
  
      public boolean isUseSessionArgs() {
          return info.isUseSessionArgs();
      }
  
      public Boolean getUseSessionArgs() {
          return info.getUseSessionArgs();
      }
  
      /**
       * if true, calls to managed connection factory.connection.createSession
       * will respect the passed in args. When false (default) the args are
       * ignored b/c the container will do transaction demarcation via xa or local
       * transaction rar contracts. This option is useful when a managed
       * connection is used in plain jms mode and a jms transacted session session
       * is required.
       *
       * @param useSessionArgs
       */
      public void setUseSessionArgs(Boolean useSessionArgs) {
          if (log.isDebugEnabled()) {
              log.debug(this + ", setting [useSessionArgs] to: " + useSessionArgs);
          }
          info.setUseSessionArgs(useSessionArgs);
      }
  }
  