* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

*

* Copyright (c) 1997-2013 Oracle and/or its affiliates. All rights reserved.

*

* The contents of this file are subject to the terms of either the GNU

* General Public License Version 2 only ("GPL") or the Common Development

* and Distribution License("CDDL") (collectively, the "License").  You

* may not use this file except in compliance with the License.  You can

* obtain a copy of the License at

* https://glassfish.dev.java.net/public/CDDL+GPL_1_1.html

* or packager/legal/LICENSE.txt.  See the License for the specific

* language governing permissions and limitations under the License.

*

* When distributing the software, include this License Header Notice in each

* file and include the License file at packager/legal/LICENSE.txt.

*

* GPL Classpath Exception:

* Oracle designates this particular file as subject to the "Classpath"

* exception as provided by Oracle in the GPL Version 2 section of the License

* file that accompanied this code.

*

* Modifications:

* If applicable, add the following below the License Header, with the fields

* enclosed by brackets [] replaced by your own identifying information:

* "Portions Copyright [year] [name of copyright owner]"

*

* Contributor(s):

* If you wish your version of this file to be governed by only the CDDL or

* only the GPL Version 2, indicate your decision by adding "[Contributor]

* elects to include this software in this distribution under the [CDDL or GPL

* Version 2] license."  If you don't indicate a single choice of license, a

* recipient has the option to distribute your version of this file under

* either the CDDL, the GPL Version 2 or to extend the choice of license to

* its licensees as provided above.  However, if you add GPL Version 2 code

* and therefore, elected the GPL Version 2 license, then the option applies

* only if the new code is made subject to such option by the copyright

* holder.

*/

* Represents an active JMS resource adapter. This does

* additional configuration to ManagedConnectionFactory

* and ResourceAdapter java beans.

*

* XXX: For code management reasons, think about splitting this

* to a preHawk and postHawk RA (with postHawk RA extending preHawk RA).

*

* @author Satish Kumar

*/

@Singleton

    static Logger _logger = LogDomains.getLogger(ActiveJmsResourceAdapter.class,  LogDomains.JMS_LOGGER);

    private final String SETTER = "setProperty";

    private static final String SEPARATOR = "#";

    private static final String MQ_PASS_FILE_PREFIX = "asmq";

    private static final String MQ_PASS_FILE_KEY = "imq.imqcmd.password=";

    //RA Javabean properties.

    public static final String CONNECTION_URL = "ConnectionURL";

    private final String RECONNECTENABLED = "ReconnectEnabled";

    private final String RECONNECTINTERVAL = "ReconnectInterval";

    private final String RECONNECTATTEMPTS = "ReconnectAttempts";

    private static final String GROUPNAME = "GroupName";

    private static final String CLUSTERCONTAINER = "InClusteredContainer";

    //Lifecycle RA JavaBean properties

    public static final String BROKERTYPE="BrokerType";

    private static final String BROKERINSTANCENAME="BrokerInstanceName";

    private static final String BROKERBINDADDRESS="BrokerBindAddress";

    private static final String BROKERPORT="BrokerPort";

    private static final String BROKERARGS="BrokerArgs";

    private static final String BROKERHOMEDIR="BrokerHomeDir";

    private static final String BROKERLIBDIR ="BrokerLibDir";

    private static final String BROKERVARDIR="BrokerVarDir";

    private static final String BROKERJAVADIR="BrokerJavaDir";

    private static final String BROKERSTARTTIMEOUT="BrokerStartTimeOut";

    public static final String ADMINUSERNAME="AdminUsername";

    public static final String ADMINPASSWORD="AdminPassword";

    private static final String ADMINPASSFILE="AdminPassFile";

    private static final String USERNAME="UserName";

    private static final String PASSWORD="Password";

    private static final String MQ_PORTMAPPER_BIND = "doBind";//"imq.portmapper.bind";

    private static final String MASTERBROKER="MasterBroker";

    //JMX properties

    private static final String JMXSERVICEURL="JMXServiceURL";

    private static final String JMXSERVICEURLLIST="JMXServiceURLList";

    private static final String JMXCONNECTORENV="JMXConnectorEnv";

    private static final String USEJNDIRMISERVICEURL="useJNDIRMIServiceURL";

    private static final String RMIREGISTRYPORT="RmiRegistryPort";

    private static final String USEEXTERNALRMIREGISTRY="startRMIRegistry";

    private static final int DEFAULTRMIREGISTRYPORT =7776;

    private static final int BROKERRMIPORTOFFSET=100;

    private static final String SSLJMXCONNECTOR="SslJMXConnector";

    //Availability properties

    private static final String CONVENTIONAL_CLUSTER__OF_PEER_BROKERS_DB_PREFIX= "imq.cluster.sharecc.persist.jdbc.";

    private static final String ENHANCED_CLUSTER_DB_PREFIX= "imq.persist.jdbc.";

    private static final String HAREQUIRED = "HARequired";

    private static final String CLUSTERID = "ClusterId";

    private static final String BROKERID = "BrokerId";

    private static final String PINGINTERVAL = "PingInterval";

    private static final String DBTYPE = "DBType";

    private static final String DBTYPE_HADB="hadb";

    private static final String BROKERENABLEHA = "BrokerEnableHA";

    private static final String DB_HADB_PROPS = "DBProps";

    //properties within DB_PROPS

    private static final String DB_HADB_USER = "hadb.user";

    private static final String DB_HADB_PASSWORD = "hadb.password";

    private static final String DB_HADB_DRIVERCLASS = "hadb.driverClass";

    private static final String DS_HADB_PROPS = "DSProps";

    //properties within DS_PROPS

    private static final String DS_HADB_SERVERLIST = "hadb.serverList";

    //Not used now.

    private final String CONTAINER = "InAppClientContainer";

    //Activation config properties of MQ resource adapter.

    public static final String DESTINATION        = "Destination";

    public static final String DESTINATION_TYPE   = "DestinationType";

    private static String SUBSCRIPTION_NAME  = "SubscriptionName";

    private static String CLIENT_ID          = "ClientID";

    public static final String PHYSICAL_DESTINATION  = "Name";

    private static String MAXPOOLSIZE  = "EndpointPoolMaxSize";

    private static String MINPOOLSIZE  = "EndpointPoolSteadySize";

    private static String RESIZECOUNT  = "EndpointPoolResizeCount";

    private static String RESIZETIMEOUT  = "EndpointPoolResizeTimeout";

    private static String REDELIVERYCOUNT  = "EndpointExceptionRedeliveryAttempts";

    private static String LOWERCASE_REDELIVERYCOUNT  = "endpointExceptionRedeliveryAttempts";

    public static final String ADDRESSLIST  = "AddressList";

    private static String ADRLIST_BEHAVIOUR  = "AddressListBehavior";

    private static String ADRLIST_ITERATIONS  = "AddressListIterations";

    private static final String MDBIDENTIFIER = "MdbName";

    private static final String JMS_SERVICE = "mq-service";

    //MCF properties

    private static final String MCFADDRESSLIST = "MessageServiceAddressList";

    //private static final String XA_JOIN_ALLOWED= "imq.jmsra.isXAJoinAllowed";

    private StringManager sm =

        StringManager.getManager(ActiveJmsResourceAdapter.class);

    private MQAddressList urlList = null;

    private String addressList;

    private String brkrPort;

    //Properties in domain.xml for HADB JDBC connection pool (for HA)

    private static final String DUSERNAME = "User";

    private static final String DPASSWORD = "Password";

    private static final String DSERVERLIST = "ServerList";

    private static final String HADB_CONNECTION_URL_PREFIX = "jdbc:sun:hadb:";

    //Lifecycle properties

    public static final String EMBEDDED="EMBEDDED";

    public static final String LOCAL="LOCAL";

    public static final String REMOTE="REMOTE";

    public static final String DIRECT="DIRECT";

    private final String DEFAULT_STORE_POOL_JNDI_NAME = "jdbc/hastore";

    // Both the properties below are hacks. These will be changed later on.

    private static String MQRmiPort =

        System.getProperty("com.sun.enterprise.connectors.system.MQRmiPort");

    private static final String DASRMIPORT = "31099";

    private static final String REVERT_TO_EMBEDDED_PROPERTY =

        "com.sun.enterprise.connectors.system.RevertToEmbedded";

    private static final String BROKER_RMI_PORT =

        "com.sun.enterprise.connectors.system.mq.rmiport";

    private static final String DEFAULT_SERVER = "server";

    private static final String DEFAULT_MQ_INSTANCE = "imqbroker";

    public static final String MQ_DIR_NAME = "imq";

    private static enum ClusterMode {

      ENHANCED, CONVENTIONAL_WITH_MASTER_BROKER, CONVENTIONAL_OF_PEER_BROKERS;

    }

    private Properties dbProps = null;

    private Properties dsProps = null;

    private String brokerInstanceName = null;

    private File mqPassFile = null;

    private boolean grizzlyListenerInit;

    @Inject

    private ConnectorRuntime connectorRuntime;

    @Inject

    private GlassfishNamingManager nm;

    @Inject

    private Provider<JMSConfigListener> jmsConfigListenerProvider;

   

    @Inject

    private Provider<ServerEnvironmentImpl> serverEnvironmentImplProvider;

   

    @Inject @Named(ServerEnvironment.DEFAULT_INSTANCE_NAME)

    private Provider<AdminService> adminServiceProvider;

   

    @Inject

    private Provider<Servers> serversProvider;

   

    private Provider<JmsService> jmsServiceProvider;

   

    @Inject

    private Provider<ServerContext> serverContextProvider;

   

    @Inject

    private Provider<ConnectorRuntime> connectorRuntimeProvider;

    @Inject

     private ServiceLocator habitat;

   

    @Inject

    private ApplicationRegistry appRegistry;

    /**

     * Constructor for an active Jms Adapter.

     *

     */

    public ActiveJmsResourceAdapter() {

        super();

        //if(getJmsService() == null)return;

        //Now that the RA has been started, delete the temp passfile

        if (mqPassFile != null) {

            mqPassFile.delete();

        }

    }

    public void postConstruct()

    {

            /*

                * If any special handling is required for the system resource

                * adapter, then ActiveResourceAdapter implementation for that

                * RA should implement additional functionality by extending

                * ActiveInboundResourceAdapter or ActiveOutboundResourceAdapter.

                *

                * For example ActiveJmsResourceAdapter extends

                * ActiveInboundResourceAdapter.

                */

               //if (moduleName.equals(ConnectorConstants.DEFAULT_JMS_ADAPTER)) {

                   // Upgrade jms resource adapter, if necessary before starting

                   // the RA.

           try {

               JMSConfigListener jmsConfigListener=jmsConfigListenerProvider.get();

                   jmsConfigListener.setActiveResourceAdapter(this);

                   JmsRaUtil raUtil = new JmsRaUtil();

                   raUtil.upgradeIfNecessary();

           }

           catch (Throwable t) {

               //t.printStackTrace();

                   _logger.log(Level.FINE,"Cannot upgrade jmsra"+ t.getMessage());

           }

    }

    /**

     * Loads RA configuration for MQ Resource adapter.

     *

     * @throws ConnectorRuntimeException in case of an exception.

     */

    protected void loadRAConfiguration() throws ConnectorRuntimeException{

        if (connectorRuntime.isServer()) {

            // Check whether MQ has started up or not.

            try {

               // if (!JmsProviderLifecycle.shouldUseMQRAForLifecycleControl()) {

                 //   JmsProviderLifecycle.checkProviderStartup();

                //} else {

                    setLifecycleProperties();

                //}

            } catch (Exception e) {

                ConnectorRuntimeException cre = new ConnectorRuntimeException

                                                        (e.getMessage());

                throw (ConnectorRuntimeException) cre.initCause(e);

            }

            setMdbContainerProperties();

            setJmsServiceProperties(null);

            setClusterRABeanProperties();

            setAvailabilityProperties();

        } else {

            setAppClientRABeanProperties();

        }

        super.loadRAConfiguration();

        postRAConfiguration();

    }

    @Override

    public void destroy() {

        JmsService jmsService = getJmsService();

        if (connectorRuntime.isServer() && grizzlyListenerInit && jmsService != null

                && EMBEDDED.equalsIgnoreCase(jmsService.getType())) {

            GrizzlyService grizzlyService = null;

            try {

                grizzlyService = Globals.get(GrizzlyService.class);

            } catch (RunLevelException rle) {

                // if GrizzlyService was shut down already, skip removing the proxy.

            }

            if (grizzlyService != null)

                grizzlyService.removeNetworkProxy(JMS_SERVICE);

            grizzlyListenerInit = false;

        }

        super.destroy();

    }

    /**

     * Start Grizzly based JMS lazy listener, which is going to initialize

     * JMS container on first request.

     */ 

    public void initializeLazyListener(JmsService jmsService) {

        if (jmsService != null) {

            if (EMBEDDED.equalsIgnoreCase(jmsService.getType()) && !grizzlyListenerInit) {

                GrizzlyService grizzlyService = Globals.get(GrizzlyService.class);

                if (grizzlyService != null) {

                List<JmsHost> jmsHosts = jmsService.getJmsHost();

                    for (JmsHost oneHost : jmsHosts) {

                        if (Boolean.valueOf(oneHost.getLazyInit())) {

                            String jmsHost = null;

                            if (oneHost.getHost() != null && "localhost".equals(oneHost.getHost())) {

                                jmsHost = "0.0.0.0";

                            } else {

                                jmsHost = oneHost.getHost();

                            }

                            NetworkListener dummy = new DummyNetworkListener();

                            dummy.setPort(oneHost.getPort());

                            dummy.setAddress(jmsHost);

                            dummy.setProtocol("light-weight-listener");

                            dummy.setTransport("tcp");

                            dummy.setName(JMS_SERVICE);

                            grizzlyService.createNetworkProxy(dummy);

                            grizzlyListenerInit = true;

                        }

                    }

                }

            }

        }

    }

    protected void startResourceAdapter(BootstrapContext bootstrapContext) throws ResourceAdapterInternalException {

        try{

        if (this.moduleName_.equals(ConnectorRuntime.DEFAULT_JMS_ADAPTER)) {

            if (connectorRuntime.isServer()) {

                Domain domain = Globals.get(Domain.class);

                ServerContext serverContext = Globals.get(ServerContext.class);

                Server server = domain.getServerNamed(serverContext.getInstanceName());

                JmsService jmsService = server.getConfig().getExtensionByType(JmsService.class);

                initializeLazyListener(jmsService);

            }

    //System.setProperty("imq.jmsra.direct.clustered", "true");

                AccessController.doPrivileged

                        (new java.security.PrivilegedExceptionAction() {

                            public Object run() throws

                                    ResourceAdapterInternalException {

                                //set the JMSRA system property to enable XA JOINS

                                //disabling this due to issue - 8727

                                //System.setProperty(XA_JOIN_ALLOWED, "true");

                                resourceadapter_.start(bootStrapContextImpl);

                                return null;

                            }

                        });

                //setResourceAdapter(resourceadapter_);

            } else {

                resourceadapter_.start(bootStrapContextImpl);

            }

        }catch (PrivilegedActionException ex){

            throw new ResourceAdapterInternalException(ex);

        }

    }

    /**

     * This is a HACK to remove the connection URL

     * in the case of PE LOCAL/EMBEDDED before setting the properties

     * to the RA. If this was not done, MQ RA incorrectly assumed

     * that the passed in connection URL is one additional

     * URL, apart from the default URL derived from brokerhost:brokerport

     * and reported a PE connection url limitation.

     *

     */

     protected Set mergeRAConfiguration(ResourceAdapterConfig raConfig, List<Property> raConfigProps) {

   //private void hackMergedProps(Set mergedProps) {

        if (!(connectorRuntime.isServer())) {

            return super.mergeRAConfiguration(raConfig, raConfigProps);

        }

        Set mergedProps = super.mergeRAConfiguration(raConfig, raConfigProps);

        String brokerType = null;

        for (Iterator iter = mergedProps.iterator(); iter.hasNext();) {

            ConnectorConfigProperty  element = (ConnectorConfigProperty) iter.next();

            if (element.getName().equals(ActiveJmsResourceAdapter.BROKERTYPE)) {

                     brokerType = element.getValue();

            }

        }

  boolean cluster = false;

  try {

    cluster = isClustered();

  } catch (Exception e) {

    e.printStackTrace();

  }

  // hack is required only for nonclustered nonremote brokers.

  if (!cluster) {

        if (brokerType.equals(ActiveJmsResourceAdapter.LOCAL)

                || brokerType.equals(ActiveJmsResourceAdapter.EMBEDDED)

    || brokerType.equals(ActiveJmsResourceAdapter.DIRECT))

        {

    for (Iterator iter = mergedProps.iterator(); iter.hasNext();) {

                ConnectorConfigProperty  element = (ConnectorConfigProperty ) iter.next();

                if (element.getName().equals(ActiveJmsResourceAdapter.CONNECTION_URL)) {

                    iter.remove();

                }

          }

      }

  }

        return mergedProps;

    }

    //Overriding ActiveResourceAdapterImpl.setup() as a work around for

    //this condition - connectionDefs_.length != 1

    //Need to remove this once the original problem is fixed

     public void setup() throws ConnectorRuntimeException {

        //TODO NEED TO REMOVE ONCE THE ActiveResourceAdapterImpl.setup() is fixed

        if (connectionDefs_ == null) {

            throw new ConnectorRuntimeException("No Connection Defs defined in the RA.xml");

        }

        if (isServer() && !isSystemRar(moduleName_)) {

            createAllConnectorResources();

        }

        _logger.log(Level.FINE, "Completed Active Resource adapter setup", moduleName_);

    }

    /*

     * Set Availability related properties

     * If JMS availability true set availability properties

     * read configured pool information and set.

     */

    private void setAvailabilityProperties() throws ConnectorRuntimeException {

      if(!isClustered()) return;

        try {

          Domain domain = Globals.get(Domain.class);

          ServerContext serverContext = Globals.get(ServerContext.class);

          Server server = domain.getServerNamed(serverContext.getInstanceName());

          JmsService jmsService = server.getConfig().getExtensionByType(JmsService.class);

          if (jmsService.getType().equals(REMOTE)) {

            //If REMOTE, the broker cluster instances already have

            //been configured with the right properties.

            return;

          }

          AvailabilityService as = server.getConfig().getAvailabilityService();

          if (as == null) {

            logFine("Availability Service is null. Not setting AvailabilityProperties.");

            return;

          }

          boolean useMasterBroker = true;

          if(as.getExtensionByType(JmsAvailability.class) != null && ! MASTERBROKER.equalsIgnoreCase(as.getExtensionByType(JmsAvailability.class).getConfigStoreType()))

            useMasterBroker = false;

          //jmsService.getUseMasterBroker() != null ? Boolean.valueOf(jmsService.getUseMasterBroker()) :true;

          boolean isJmsAvailabilityEnabled = this.isJMSAvailabilityOn(as);

          logFine("Setting AvailabilityProperties .. ");

          if (!useMasterBroker || isJmsAvailabilityEnabled) {

            // For conventional cluster of peer brokers and Enhanced Broker Cluster.

            ConnectorDescriptor cd = getDescriptor();

            String clusterName = getMQClusterName();

            ConnectorConfigProperty  envProp1 = new ConnectorConfigProperty (

                        CLUSTERID , clusterName,"Cluster Id",

                        "java.lang.String");

            setProperty(cd, envProp1);

            if(brokerInstanceName == null) {

                brokerInstanceName = getBrokerInstanceName(jmsService);

            }

            ConnectorConfigProperty  envProp2 = new ConnectorConfigProperty (

                        BROKERID , brokerInstanceName,"Broker Id",

                        "java.lang.String");

            setProperty(cd, envProp2);

            //Only if JMS availability is true - Enhanced Broker Cluster only.

            if (isJmsAvailabilityEnabled) {

              //Set HARequired as true - irrespective of whether it is REMOTE or

              //LOCAL

              ConnectorConfigProperty  envProp3 = new ConnectorConfigProperty (

                          HAREQUIRED , "true","HA Required",

                          "java.lang.String");

              setProperty(cd, envProp3);

               /* The broker has a property to control whether

               * it starts in HA mode or not and that's represented on

               * the RA by BrokerEnableHA.

               * On the MQ Client connection side it is HARequired -

               * this does not control the broker, it just is a client

               * side requirement.

               * So for AS EE, if BrokerType is LOCAL or EMBEDDED,

               * and AS HA is enabled for JMS then both these must be

               * set to true. */

              ConnectorConfigProperty  envProp4 = new ConnectorConfigProperty (

                          BROKERENABLEHA , "true",

                          "BrokerEnableHA flag","java.lang.Boolean");

              setProperty(cd, envProp4);

              String nodeHostName = domain.getNodeNamed(server.getNodeRef()).getNodeHost();

              if (nodeHostName != null) {

                ConnectorConfigProperty  envProp5 = new ConnectorConfigProperty (

                            BROKERBINDADDRESS , nodeHostName,

                            "Broker Bind Address","java.lang.String");

                setProperty(cd, envProp5);

              }

              loadDBProperties(as.getExtensionByType(JmsAvailability.class), ClusterMode.ENHANCED);

            } else {

              //  Conventional cluster of peer brokers

              JmsAvailability jmsAvailability = as.getExtensionByType(JmsAvailability.class);

              if ("jdbc".equals(jmsAvailability.getMessageStoreType()))

                loadDBProperties(jmsAvailability, ClusterMode.ENHANCED);

              loadDBProperties(jmsAvailability, ClusterMode.CONVENTIONAL_OF_PEER_BROKERS);

            }

            /*

            ConnectorConfigProperty  envProp4 = new ConnectorConfigProperty  (

                            DBTYPE , DBTYPE_HADB,"DBType",

                            "java.lang.String");

            setProperty(cd, envProp4);

            * The broker has a property to control whether

            * it starts in HA mode or not and that's represented on

            * the RA by BrokerEnableHA.

            * On the MQ Client connection side it is HARequired -

            * this does not control the broker, it just is a client

            * side requirement.

            * So for AS EE, if BrokerType is LOCAL or EMBEDDED,

            * and AS HA is enabled for JMS then both these must be

            * set to true.

            ConnectorConfigProperty  envProp5 = new ConnectorConfigProperty  (

                        BROKERENABLEHA , "true",

                        "BrokerEnableHA flag","java.lang.Boolean");

            setProperty(cd, envProp5);

            String nodeHostName = domain.getNodeNamed(server.getNode()).getNodeHost();

            if (nodeHostName != null)  {

              ConnectorConfigProperty  envProp6 = new ConnectorConfigProperty  (

                          BROKERBINDADDRESS , nodeHostName,

                          "Broker Bind Address","java.lang.String");

              setProperty(cd, envProp6);

            }

            //get pool name

            String poolJNDIName = as.getJmsAvailability().getMqStorePoolName();

            //If no MQ store pool name is specified, use default poolname

            //XXX: default pool name is jdbc/hastore but asadmin

            //configure-ha-cluster creates a resource called

            //"jdbc/<asclustername>-hastore" which needs to be used.

            if (poolJNDIName == null || poolJNDIName =="" ) {

              //get Web container's HA store's pool name

              poolJNDIName = as.getWebContainerAvailability().

                                getHttpSessionStorePoolName();

              logFine("HTTP Session store pool jndi name " +

                         "is " + poolJNDIName);

            }

            //XXX: request HADB team mq-store-pool name to be

            //populated as part of configure-ha-cluster

            JdbcConnectionPool jdbcConPool = getJDBCConnectionPoolInfo(

                                                poolJNDIName);

            //DBProps: compute values from pool object

            String userName = getPropertyFromPool(jdbcConPool, DUSERNAME);

            logFine("HA username is " + userName);

            String password = getPropertyFromPool(jdbcConPool, DPASSWORD);

            logFine("HA Password is " + password);

            String driverClass = jdbcConPool.getDatasourceClassname();

            logFine("HA driverclass" + driverClass);

            dbProps = new Properties();

            dbProps.setProperty(DB_HADB_USER, userName);

            dbProps.setProperty(DB_HADB_PASSWORD, password);

            dbProps.setProperty(DB_HADB_DRIVERCLASS, driverClass);

            //DSProps: compute values from pool object

            String serverList = getPropertyFromPool(jdbcConPool, DSERVERLIST);

            logFine("HADB server list is " + serverList);

            dsProps = new Properties();

            if (serverList != null) {

                dsProps.setProperty(DS_HADB_SERVERLIST, serverList);

            } else {

                _logger.warning("ajra.incorrect_hadb_server_list");

            }

            //set all other properties in dsProps as well.

            Properties p = getDSPropertiesFromThePool(jdbcConPool);

            Iterator iterator = p.keySet().iterator();

            while (iterator.hasNext()) {

                String key = (String) iterator.next();

                String val = (String)p.get(key);

                dsProps.setProperty(key, val);

            }*/

          } else {

            // Conventional cluster with master broker.

            if ("jdbc".equals(as.getExtensionByType(JmsAvailability.class).getMessageStoreType()))

              loadDBProperties(as.getExtensionByType(JmsAvailability.class), ClusterMode.CONVENTIONAL_WITH_MASTER_BROKER);

          }

        } catch (Exception e) {

            ConnectorRuntimeException crex = new ConnectorRuntimeException(e.getMessage());

            throw (ConnectorRuntimeException)crex.initCause(e);

        }

    }

    private void loadDBProperties(JmsAvailability jmsAvailability, ClusterMode clusterMode) {

        /*imq.cluster.nomasterbroker=[true|false] default false

                imq.cluster.sharecc.persist.jdbc.dbVendor

                imq.cluster.sharecc.persist.jdbc.<dbVendor>.user

                imq.cluster.sharecc.persist.jdbc.<dbVendor>.property.<propname>=<propval>

                imq.cluster.sharecc.persist.jdbc.<dbVendor>.table.MQSHARECC45=<table-schema>

                These broker properties, including imq.cluster.clusterid, must be set to

                same values in all broker instances in the conventional cluster

                */

    String prefix = null;       

    if (ClusterMode.CONVENTIONAL_WITH_MASTER_BROKER == clusterMode) {

      prefix = ENHANCED_CLUSTER_DB_PREFIX;

    } else if (ClusterMode.CONVENTIONAL_OF_PEER_BROKERS == clusterMode) {

      prefix = CONVENTIONAL_CLUSTER__OF_PEER_BROKERS_DB_PREFIX;

    } else if (ClusterMode.ENHANCED == clusterMode) {

      prefix = ENHANCED_CLUSTER_DB_PREFIX;

    } else {

      logFine("Unknown cluster mode: " + clusterMode.name() + ", imq DB properties are not set.");

      return;

    }

    if(dbProps == null) dbProps = new Properties();

  dbProps.setProperty("imq.cluster.clusterid", getMQClusterName());

    dbProps.setProperty("imq.persist.store", jmsAvailability.getMessageStoreType());

    if(ClusterMode.CONVENTIONAL_WITH_MASTER_BROKER == clusterMode)

      dbProps.setProperty("imq.cluster.nomasterbroker", "false");

    else

      dbProps.setProperty("imq.cluster.nomasterbroker", "true");

    if(Boolean.valueOf(jmsAvailability.getAvailabilityEnabled()) == true || "jdbc".equals(jmsAvailability.getMessageStoreType()))

      dbProps.setProperty("imq.brokerid", getBrokerInstanceName(getJmsService()));

        String dbVendor = jmsAvailability.getDbVendor();

        String dbuser = jmsAvailability.getDbUsername();

        String dbPassword = jmsAvailability.getDbPassword();

        String dbJdbcUrl = jmsAvailability.getDbUrl();

        dbProps.setProperty(prefix + "dbVendor", dbVendor);

        String fullprefix = prefix + dbVendor + ".";

        if (dbuser != null) dbProps.setProperty(fullprefix + "user", dbuser);

        if (dbPassword != null) dbProps.setProperty(fullprefix + "password", dbPassword);

        List dbprops = jmsAvailability.getProperty();

        String propertyPrefix = fullprefix + "property.";

        if(dbJdbcUrl != null) {

    if ("derby".equals(dbVendor)) 

      dbProps.setProperty(fullprefix + "opendburl", dbJdbcUrl);

    else

      dbProps.setProperty(propertyPrefix + "url", dbJdbcUrl);

  }

        for (Object obj : dbprops){

      Property prop = (Property) obj; 

            String key = prop.getName();

            String value = prop.getValue();

            //don't set a prefix if the property name is already prefixed with "imq."

            if(key.startsWith("imq."))

                dbProps.setProperty(key, value);

            else

                dbProps.setProperty(propertyPrefix + key, value);

        }

    }

    /*

     * Gets all the other [apart from serverlist] DataSource properties from

     * the HADB JDBC connection pool.

     *

    private Properties getDSPropertiesFromThePool(JdbcConnectionPool jdbcConPool) {

        Properties p = new Properties();

        List elemProp = jdbcConPool.getProperty();

        Set<String> excludeList = new HashSet<String>();

        excludeList.add(DUSERNAME);

        excludeList.add(DPASSWORD);

        excludeList.add(DSERVERLIST);

        for(Property e: elemProp) {

            String propName = e.getAttributeValue("name");

            if (!excludeList.contains(propName)) {

                p.setProperty(propName, e.getAttributeValue("value"));

            }

        }

        logFine("Additional DataSource properties from pool "

                        + jdbcConPool.getName() + " are " + p);

        return p;

    }*/

    /**

     * Method to perform any post RA configuration action by derivative subclasses.

     * For example, this method is used by <code>ActiveJMSResourceAdapter</code>

     * to set unsupported javabean property types on its RA JavaBean runtime

     * instance.

     * @throws ConnectorRuntimeException

     */

    protected void postRAConfiguration() throws ConnectorRuntimeException {

        //Set all non-supported javabean property types in the JavaBean

        try {

    //if(isClustered()){

    if(dbProps == null)

      dbProps = new Properties();

     dbProps.setProperty("imq.cluster.dynamicChangeMasterBrokerEnabled", "true");     

  //}

            if (dbProps != null) {

                Method mthds = this.resourceadapter_.getClass().getMethod("setBrokerProps", Properties.class);

              if(mthds != null){       

          logFine("Setting property:" + DB_HADB_PROPS

                                        + "=" + dbProps.toString());

                        mthds.invoke(this.resourceadapter_,

                                        new Object[]{dbProps});

                    }

            }

        } catch (Exception e) {

            ConnectorRuntimeException crex = new ConnectorRuntimeException(

                            e.getMessage());

            throw (ConnectorRuntimeException)crex.initCause(e);

        }

    }

    //todo: enable this method

   /* private String getPropertyFromPool(JdbcConnectionPool jdbcConPool,

                                       String poolPropertyName) {

        String poolPropertyValue = null;

        if(jdbcConPool == null) {

            return null;

        }

        ElementProperty[] props = jdbcConPool.getElementProperty();

        for (int i = 0; i < props.length; i++) {

            String name = props[i].getAttributeValue("name");

            String value = props[i].getAttributeValue("value");

            if (name.equalsIgnoreCase(poolPropertyName)) {

            //if (name.equalsIgnoreCase("username")) {

                poolPropertyValue = value;

            }

        }

        logFine("ActiveJMSResourceAdapter :: got property " + poolPropertyName

                        + "="+ poolPropertyValue);

        return poolPropertyValue;

    }      */

    private boolean isJMSAvailabilityOn(AvailabilityService as) {

        if (as == null) {

            return false;

      }

      JmsAvailability ja = as.getExtensionByType(JmsAvailability.class);

      boolean jmsAvailability = false;

     /* JMS Availability  should be false if its not present in

        * domain.xml,

       */

     if (ja != null) {

        jmsAvailability = Boolean.parseBoolean(ja.getAvailabilityEnabled());

    }

        _logger.log(Level.FINE, "JMS availability :: " + jmsAvailability);

        return jmsAvailability;

    }

    /**

     * Set MQ4.0 RA lifecycle properties

     */

    private void setLifecycleProperties() throws

                                      Exception, ConnectorRuntimeException {

        //ConfigContext ctx = ApplicationServer.getServerContext().getConfigContext();

        //If PE:

        //EMBEDDED/LOCAL goto jms-service, get defaultjmshost info and set

        //accordingly

        //if EE:

        //EMBEDDED/LOCAL get this instance and cluster name, search for a

        //jms-host wth this this name in jms-service gets its proeprties

        //and set

        //@siva As of now use default JMS host. As soon as changes for modifying EE

        //cluster to LOCAL is brought in, change this to use system properties

        //for EE to get port, host, adminusername, adminpassword.

        //JmsService jmsService = ServerBeansFactory.getJmsServiceBean(ctx);

        String defaultJmsHost = getJmsService().getDefaultJmsHost();

        logFine("Default JMS Host :: " + defaultJmsHost);

        JmsHost jmsHost = getJmsHost();

        if (jmsHost != null) {//todo: && jmsHost.isEnabled()) {

            JavaConfig javaConfig = (JavaConfig) Globals.get(JavaConfig.class); ;

            String java_home = javaConfig.getJavaHome();

            //Get broker type from JMS Service.

            // String brokerType = jmsService.getType();

            /*

             * XXX: adjust the brokertype for the new DIRECT mode in 4.1

             * uncomment the line below once we have an MQ integration

             * that has DIRECT mode support

             */

            String brokerType = adjustForDirectMode(getJmsService().getType());

            String brokerPort = jmsHost.getPort();

            brkrPort = brokerPort;

            String adminUserName = jmsHost.getAdminUserName();

            String adminPassword = JmsRaUtil.getUnAliasedPwd(jmsHost.getAdminPassword());

            List jmsHostProps= getJmsService().getProperty();

            String username = null;

            String password = null;

            if (jmsHostProps != null) {

            for (int i =0;i <jmsHostProps.size(); i++) {

                Property jmsProp =(Property)jmsHostProps.get(i);

                String propName = jmsProp.getName();

                String propValue = jmsProp.getValue();

                if ("user-name".equals(propName)) {

                    username = propValue;

                } else if ("password".equals(propName)) {

                    password = propValue;

                }

                // Add more properties as and when you want.

            }

           }

        logFine("Broker UserName = " + username);

            createMQVarDirectoryIfNecessary();