/*
* 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.
*/
package com.sun.enterprise.connectors.jms.system;
import java.util.logging.Logger;
import java.util.logging.Level;
import java.util.*;
import java.io.File;
import java.io.IOException;
import java.io.FileInputStream;
import java.beans.PropertyVetoException;
import com.sun.enterprise.connectors.jms.config.JmsHost;
import com.sun.enterprise.connectors.jms.config.JmsService;
import com.sun.enterprise.util.SystemPropertyConstants;
import com.sun.enterprise.config.serverbeans.*;
import com.sun.enterprise.connectors.jms.util.JmsRaUtil;
import com.sun.enterprise.admin.util.AdminConstants;
import com.sun.appserv.connectors.internal.api.ConnectorRuntimeException;
import org.glassfish.internal.api.ServerContext;
import org.glassfish.internal.api.Globals;
import org.glassfish.api.ActionReport;
import com.sun.enterprise.util.StringUtils;
import com.sun.enterprise.universal.glassfish.ASenvPropertyReader;
import org.jvnet.hk2.config.ConfigSupport;
import org.jvnet.hk2.config.SingleConfigCode;
import org.jvnet.hk2.config.TransactionFailure;
/**
* Defines an MQ addressList.
*
* @author Binod P.G
*/
public class MQAddressList {
private static final Logger logger = Logger.getLogger(ActiveJmsResourceAdapter.JMS_MAIN_LOGGER);
private String myName =
System.getProperty(SystemPropertyConstants.SERVER_NAME);
private List<MQUrl> urlList = new ArrayList<MQUrl>();
private JmsService jmsService = null;
//private AppserverClusterViewFromCacheRepository rep = null;
private static String nodeHost = null;
private String targetName = null;
/**
* Create an empty address list
*/
public MQAddressList() {
this(null);
}
/**
* Use the provided <code>JmsService</code> to create an addresslist
*/
public MQAddressList(JmsService service) {
//use the server instance this is being run in as the target
this(service, getServerName());
}
/**
* Creates an instance from jmsService and resolves
* values using the provided target name
* @param targetName Represents the target for which the addresslist
* needs to be created
* @param service <code>JmsService</code> instance.
*/
public MQAddressList(JmsService service, String targetName) {
if (logger.isLoggable(Level.FINE))
logFine(" init" + service + "target " + targetName);
this.jmsService = service;
this.targetName = targetName;
}
public void setJmsService (JmsService jmsService){
this.jmsService = jmsService;
}
public void setTargetName(String targetName){
this.targetName = targetName;
}
public void setInstanceName(String instanceName){
myName = instanceName;
}
public void setup()throws Exception
{
if (isClustered() && (!this.jmsService.getType().equals(ActiveJmsResourceAdapter.REMOTE)) )
setup(true);
else setup(false);
}
/**
* Sets up the addresslist.
*/
public void setup(boolean isClustered) throws Exception {
try {
if (isClustered) {
//setup for LOCAL/EMBEDDED clusters.
if (logger.isLoggable(Level.FINE))
logFine("setting up for cluster " + this.targetName);
setupClusterViewFromRepository();
setupForCluster();
} else {
if (logger.isLoggable(Level.FINE))
logFine("setting up for SI/DAS " + this.targetName);
if (isAConfig(targetName) || isDAS(targetName)) {
if (logger.isLoggable(Level.FINE))
logFine("performing default setup for DAS/remote clusters/PE instance" + targetName);
defaultSetup();
} else {
logFine("configuring for Standalone EE server instance");
//resolve and add.
setupClusterViewFromRepository();
setupForStandaloneServerInstance();
}
}
} catch (ConnectorRuntimeException ce) {
throw new Exception(ce);
}
}
private void setupClusterViewFromRepository() throws Exception {
ServerContext context = Globals.get(ServerContext.class);
Domain domain = Globals.get(Domain.class);
String serverName = context.getInstanceName();
Server server = domain.getServerNamed(serverName); //context.getConfigBean();
//String domainurl = context.getServerConfigURL();
//rep = new AppserverClusterViewFromCacheRepository(domainurl);
try {
nodeHost = getNodeHostName(server);
logFine("na host" + nodeHost);
} catch (Exception e) {
if (logger.isLoggable(Level.FINE))
logger.log(Level.FINE,"Exception while attempting to get nodeagentHost", e.getMessage());
if (logger.isLoggable(Level.FINER))
logger.log(Level.FINER, e.getMessage(), e);
}
}
public String getNodeHostName(final Server as) throws Exception{
String nodeRef = as.getNodeRef();
Nodes nodes = Globals.get(Nodes.class);
Node node = nodes.getNode(nodeRef);
if (node != null)
{
if (node.getNodeHost() != null) return node.getNodeHost();
//localhostNode
else if (node.isDefaultLocalNode())
{
String hostName = getHostNameFromDasProperties();
if ("localhost".equals(hostName))
//instance is co-located on same machine as DAS. Hence read host name from system property
return System.getProperty(SystemPropertyConstants.HOST_NAME_PROPERTY);
}
}
return null;
}
String dasPropertiesHostName= null;
public String getHostNameFromDasProperties()
{
if (dasPropertiesHostName != null) return dasPropertiesHostName;
String agentsDirPath = getSystemProperty(
SystemPropertyConstants.AGENT_ROOT_PROPERTY);
if(!StringUtils.ok(agentsDirPath))
//return agentsDirPath;
{
String installRootPath = getSystemProperty(
SystemPropertyConstants.INSTALL_ROOT_PROPERTY);
if(!StringUtils.ok(installRootPath))
installRootPath = System.getProperty(
SystemPropertyConstants.INSTALL_ROOT_PROPERTY);
agentsDirPath = installRootPath + File.separator + "nodes";
}
// if(!StringUtils.ok(installRootPath))
// throw new CommandException("Agent.noInstallDirPath");
String dasPropsFilePath = agentsDirPath + File.separator + "agent" + File.separator + "config";
File dasPropsFile = new File(dasPropsFilePath, "das.properties");
Properties dasprops = new Properties();
FileInputStream fis = null;
try {
fis = new FileInputStream(dasPropsFile);
dasprops.load(fis);
fis.close();
fis = null;
dasPropertiesHostName = dasprops.getProperty("agent.das.host");
return dasPropertiesHostName;
} catch (IOException ioex) {
;
} finally {
if (fis != null) {
try {
fis.close();
} catch (IOException cex) {
// ignore it
}
}
}
return null;
}
Map<String,String> systemProps = null;
protected String getSystemProperty(String propertyName)
{
if (systemProps == null)
systemProps = Collections.unmodifiableMap(new ASenvPropertyReader().getProps());
return systemProps.get(propertyName);
}
public String getMasterBroker(String clustername) {
String masterbrk = null;
//if (rep != null) {
try {
JmsHost mb = getMasterJmsHostInCluster(clustername);
JmsService js = getJmsServiceForMasterBroker
(clustername);
MQUrl url = createUrl(mb, js);
masterbrk = url.toString();
if (logger.isLoggable(Level.FINE))
logger.log(Level.FINE, "Master broker obtained is " + masterbrk);
}
catch (Exception e) {
logger.log(Level.SEVERE, "Cannot obtain master broker");
logger.log(Level.SEVERE, e.getMessage(), e);
}
//}
return masterbrk;
}
private JmsService getJmsServiceForMasterBroker(String clusterName) {
Domain domain = Globals.get(Domain.class);
Cluster cluster = domain.getClusterNamed(clusterName);
final Server[] buddies = getServersInCluster(cluster);
final Config cfg = getConfigForServer(buddies[0]);
return cfg.getExtensionByType(JmsService.class);
}
private Config getConfigForServer(Server server){
String cfgRef = server.getConfigRef();
return getConfigByName(cfgRef);
}
private Config getConfigByName(String cfgRef){
Domain domain = Globals.get(Domain.class);
Configs configs = domain.getConfigs();
List configList = configs.getConfig();
for(int i=0; i < configList.size(); i++){
Config config = (Config)configList.get(i);
if (config.getName().equals(cfgRef))
return config;
}
return null;
}
private JmsHost getMasterJmsHostInCluster(String clusterName) throws Exception {
Domain domain = Globals.get(Domain.class);
Cluster cluster = domain.getClusterNamed(clusterName);
/*
Since GF 3.1 - Added a new way to configure the master broker
Check if a master broker has been configured by looking at jmsService.getMasterBroker
If it is configured, return th
If not, use the first configured server in the cluster list as the master broker
*/
Config config = domain.getConfigNamed(cluster.getConfigRef());
JmsService jmsService = config.getExtensionByType(JmsService.class);
Server masterBrokerInstance = null;
String masterBrokerInstanceName = jmsService.getMasterBroker();
if (masterBrokerInstanceName != null){
masterBrokerInstance = domain.getServerNamed(masterBrokerInstanceName);
}
else{
Server[] buddies = getServersInCluster(cluster);
// return the first valid host
// there may be hosts attached to an NA that is down
if (buddies.length > 0){
masterBrokerInstance = buddies[0];
}
}
final JmsHost copy = getResolvedJmsHost(masterBrokerInstance);
if (copy != null)
return copy;
else
throw new RuntimeException("No JMS hosts available to select as Master");
}
public Cluster getClusterByName(String clusterName)
{
Domain domain = Globals.get(Domain.class);
Clusters clusters = domain.getClusters();
List clusterList = clusters.getCluster();
for (int i =0; i < clusterList.size(); i++){
Cluster cluster = (Cluster)clusterList.get(i);
if (cluster.getName().equals(clusterName))
return cluster;
}
return null;
}
public Server[] getServersInCluster(String clusterName){
Cluster cluster = getClusterByName(clusterName);
return getServersInCluster(cluster);
}
public Server[] getServersInCluster(Cluster cluster)
{
//first ensure that the cluster exists
//Cluster cluster = ClusterHelper.getClusterByName(configContext, clusterName);
//Now fetch the server instances in the cluster.
List servers = cluster.getInstances();
// List serverRefs = cluster.getServerRef();
Server[] result = new Server[servers.size()];
// Domain domain = Globals.get(Domain.class);
for (int i = 0; i < servers.size(); i++) {
result[i] = (Server) servers.get(i); //.getServerNamed(((ServerRef)serverRefs.get(i)).getRef());
// try {
//} catch (ConfigException ex) {
// throw new ConfigException(_strMgr.getString("noSuchClusterInstance",
// clusterName, serverRefs[i].getRef()));
//}
}
return result;
}
public boolean isDAS(String targetName) {
if (isAConfig(targetName)) {
return false;
}
return getServerByName(targetName).isDas();
}
public boolean isAConfig(String targetName) {
//return ServerHelper.isAConfig(getAdminConfigContext(), targetName);
final Config config = getConfigByName(targetName);
return (config != null ? true : false);
}
/**
* Gets the admin config context associated with this server instance
* Usage Notice: Use this only for operations that are performed in DAS
* and requires the admin config context
*/
/* private ConfigContext getAdminConfigContext() {
return com.sun.enterprise.admin.server.core.AdminService.
getAdminService().getAdminContext().getAdminConfigContext();
} */
/**
* Setup addresslist for Standalone server instance in EE
*/
private void setupForStandaloneServerInstance() throws Exception {
if (jmsService.getType().equals(ActiveJmsResourceAdapter.REMOTE)) {
logFine("REMOTE Standalone server instance and hence use default setup");
defaultSetup();
} else {
//For LOCAL or EMBEDDED standalone server instances, we need to resolve
//the JMSHost
logFine("LOCAL/EMBEDDED Standalone server instance");
JmsHost host = getResolvedJmsHostForStandaloneServerInstance(this.targetName);
MQUrl url = createUrl(host);
urlList.add(url);
}
}
/**
* Default setup concatanates all JMSHosts in a JMSService to create the address list
*/
private void defaultSetup() throws Exception {
logFine("performing defaultsetup");
JmsService jmsService = Globals.get(JmsService.class);
List hosts = jmsService.getJmsHost();
for (int i=0; i < hosts.size(); i++) {
MQUrl url = createUrl((JmsHost)hosts.get(i));
urlList.add(url);
}
}
/**
* Setup the address list after calculating the JMS hosts
* belonging to the local appserver cluster members.
* For LOCAL/EMBEDDED clusters the MQ broker corresponding
* to "this" server instance needs to be placed ahead
* of the other brokers of the other siblings in the AS
* cluter to enable sticky connection balancing by MQ.
*/
private void setupForCluster() throws Exception {
java.util.Map<String,JmsHost> hostMap =
getResolvedLocalJmsHostsInMyCluster(true);
//First add my jms host.
JmsHost jmsHost = hostMap.get(myName);
MQUrl myUrl = createUrl(jmsHost, nodeHost);
urlList.add(myUrl);
hostMap.remove(myName);
// Add all buddies to URL.
for (JmsHost host : hostMap.values() ) {
MQUrl url = createUrl(host);
urlList.add(url);
}
}
public Map<String, JmsHost> getResolvedLocalJmsHostsInMyCluster(final boolean includeMe) {
final Map<String, JmsHost> map = new HashMap<String, JmsHost> ();
Cluster cluster = getClusterForServer( myName);
if (cluster != null){
final Server[] buddies = getServersInCluster(cluster);
for (final Server as : buddies) {
if (!includeMe && myName.equals(as.getName()))
continue;
JmsHost copy = null;
try {
copy = getResolvedJmsHost(as);
} catch (Exception e) {
//e.printStackTrace();
}
map.put(as.getName(), copy);
}
}
return ( map );
}
public Cluster getClusterForServer(String instanceName){
Domain domain = Globals.get(Domain.class);
Clusters clusters = domain.getClusters();
List clusterList = clusters.getCluster();
for (int i =0; i < clusterList.size(); i++){
Cluster cluster = (Cluster)clusterList.get(i);
if (isServerInCluster(cluster, instanceName))
return cluster;
}
return null;
}
private boolean isServerInCluster (Cluster cluster, String instanceName){
List instances = cluster.getInstances();
for (int i=0; i < instances.size(); i++){
if(instanceName.equals(((Server)instances.get(i)).getName()))
return true;
}
return false;
}
/**
* Creates a String representation of address list from
* array list. In short, it is a comma separated list.
* Actual syntax of an MQ url is inside MQUrl class.
*
* @return AddressList String
* @see MQUrl
*/
public String toString() {
StringBuilder builder = new StringBuilder();
Iterator it = urlList.iterator();
if (it.hasNext()) {
builder.append(it.next().toString());
}
while (it.hasNext()) {
builder.append(",").append(it.next().toString());
}
String s = builder.toString();
if (logger.isLoggable(Level.FINE))
logFine("toString returns :: " + s);
return s;
}
/**
* Creates an instance of MQUrl from JmsHost element in
* the dtd and add it to the addresslist.
*
* @param host An instance of <code>JmsHost</code> object.
*/
public void addMQUrl(JmsHost host) {
MQUrl url = createUrl(host);
urlList.add(url);
}
/**
* Deletes the url represented by the JmsHost from the AddressList.
*
* @param host An instance of <code>JmsHost</code> object.
*/
public void removeMQUrl(JmsHost host) {
MQUrl url = createUrl(host);
urlList.remove(url);
}
/**
* Updates the information about the <code>JmsHost</code>
* in the address list.
*
* @param host An instance of <code>JmsHost</code> object.
*/
public void updateMQUrl(JmsHost host) {
MQUrl url = createUrl(host);
urlList.remove(url);
urlList.add(url);
}
private MQUrl createUrl(JmsHost host) {
return createUrl(host, this.jmsService);
}
private MQUrl createUrl(JmsHost host, String overridedHostName) {
return createUrl(host, this.jmsService, overridedHostName);
}
public static MQUrl createUrl(JmsHost host, JmsService js) {
return createUrl(host, js, null);
}
public static MQUrl createUrl(JmsHost host, JmsService js, String overridedHostName) {
try {
String name = host.getName();
String hostName = host.getHost();
// For LOCAL/EMBEDDED Clustered instances and
// standalone server instances, use
// their nodeagent's hostname as the jms host name.
if (overridedHostName != null && !overridedHostName.trim().equals("")) {
hostName = overridedHostName;
}
String port = host.getPort();
MQUrl url = new MQUrl(name);
url.setHost(hostName);
url.setPort(port);
if (js != null) {
String scheme = js.getMqScheme();
if (scheme != null && !scheme.trim().equals("")) {
url.setScheme(scheme);
}
String service = js.getMqService();
if (service != null && !service.trim().equals("")) {
url.setService(service);
}
}
return url;
} catch (Exception ce) {
ce.printStackTrace();
}
return null;
}
//Used to get resolved local JmsHost for a standalone server instance
private JmsHost getResolvedJmsHostForStandaloneServerInstance(
String serverName) throws Exception {
if (logger.isLoggable(Level.FINE))
logFine(" getresolved " + serverName);
//ConfigContext con = getAdminConfigContext();
Server serverInstance = getServerByName(serverName);
if (logger.isLoggable(Level.FINE))
logFine("serverinstace " + serverInstance);
JmsHost jmsHost = getResolvedJmsHost(serverInstance);
return jmsHost;
}
private Server getServerByName(String serverName){
Domain domain = Globals.get(Domain.class);
Servers servers = domain.getServers();
List serverList = servers.getServer();
for (int i=0; i < serverList.size(); i++){
Server server = (Server) serverList.get(i);
if(serverName.equals(server.getName()))
return server;
}
return null;
}
private JmsHost getResolvedJmsHost(Server as) throws Exception{
if (as == null) {
return null;
}
if (logger.isLoggable(Level.FINE))
logFine("getResolvedJmsHost " + as);
// final JmsService jmsService = Globals.get(JmsService.class);
// JmsHost jmsHost = null;
// if (JMSServiceType.LOCAL.toString().equals(jmsService.getType()) || JMSServiceType.EMBEDDED.toString().equals(jmsService.getType())) {
// jmsHost = getDefaultJmsHost(jmsService);
//}
// return ( jmsHost );
JmsHost jmsHost = getResolvedLocalJmsHostInServer(as);
JmsHost copy = createJmsHostCopy(jmsHost, as);
String hostName = getNodeHostName(as);
String port = JmsRaUtil.getJMSPropertyValue(as) ;//"JMS_PROVIDER_PORT", "7676");
copy.setHost(hostName);
copy.setPort(port);
return copy;
}
private JmsHost createJmsHostCopy(final JmsHost jmsHost, final Server server)
{
JmsHost jmsHostCopy = new JmsHostWrapper();
try {
jmsHostCopy.setAdminPassword(jmsHost.getAdminPassword());
jmsHostCopy.setAdminUserName(jmsHost.getAdminUserName());
jmsHostCopy.setName(jmsHost.getName());
jmsHostCopy.setHost(jmsHost.getHost());
jmsHostCopy.setPort(jmsHost.getPort());
} catch(Exception tfe) {
tfe.printStackTrace();//todo: handle this exception
}
return jmsHostCopy;
}
/*static JmsHost jmsHostcopy = null;
private JmsHost createJmsHostCopy(final JmsHost jmsHost, final Server server)
{
try {
//jmsHost.deepCopy();
ConfigSupport.apply(new SingleConfigCode<JmsService>() {
public Object run(JmsService param) throws PropertyVetoException, TransactionFailure {
final JmsHost jmsHost = param.createChild(JmsHost.class); //TODO: need a way to create a JmsHost instance
jmsHost.setAdminPassword(jmsHost.getAdminPassword());
jmsHost.setAdminUserName(jmsHost.getAdminUserName());
jmsHost.setName(jmsHost.getName());
jmsHost.setHost(jmsHost.getHost());
jmsHost.setPort(jmsHost.getPort());
MQAddressList.jmsHostcopy = jmsHost;
return jmsHost;
}
}, getConfigForServer(server).getJmsService());
} catch(TransactionFailure tfe) {
//tfe.printStackTrace();//todo: handle this exception
}
return jmsHostcopy;
}*/
private JmsHost getResolvedLocalJmsHostInServer(final Server server) {
Config config = getConfigForServer(server);
if (config != null)
{
JmsService jmsService = config.getExtensionByType(JmsService.class);
JmsHost jmsHost = null;
if (JMSServiceType.LOCAL.toString().equals(jmsService.getType()) || JMSServiceType.EMBEDDED.toString().equals(jmsService.getType())) {
jmsHost = getDefaultJmsHost(jmsService);
}
return ( jmsHost );
}
return null;
}
public JmsHost getDefaultJmsHost(JmsService jmsService){
String defaultJmsHost= jmsService.getDefaultJmsHost();
List <JmsHost> jmsHosts = jmsService.getJmsHost();
JmsHost jmsHost = null;
if (defaultJmsHost != null && ! defaultJmsHost.equals("") && jmsHosts != null && jmsHosts.size()> 0){
for (int i=0; i <jmsHosts.size(); i++)
if (defaultJmsHost.equals((jmsHosts.get(i)).getName()))
return (JmsHost)jmsHosts.get(i);
}
if(jmsHosts != null && jmsHosts.size() >0 )
jmsHost = jmsHosts.get(0);
else
jmsHost = Globals.get(JmsHost.class);
return jmsHost;
}
public boolean isClustered() {
Domain domain = Globals.get(Domain.class);
Clusters clusters = domain.getClusters();
if (clusters == null) return false;
List clusterList = clusters.getCluster();
return JmsRaUtil.isClustered(clusterList, myName);
}
private static String getServerName() {
String serverName=System.getProperty(SystemPropertyConstants.SERVER_NAME);
return serverName;
}
private void logFine(String s) {
if (logger.isLoggable(Level.FINE)) {
logger.log(Level.FINE, "MQAddressList :: " + s);
}
}
public int getSize() {
if (this.urlList != null) {
return this.urlList.size();
} else {
return 0;
}
}
enum JMSServiceType {
LOCAL,
REMOTE,
EMBEDDED
}
}