public class ASJMXAuthenticator implements JMXAuthenticator {
private static final boolean _debug = false;
private static Logger _logger = Logger.getLogger(AdminConstants.kLoggerName);
private static StringManager _strings = StringManager.getManager(ASLoginDriverImpl.class);
private String realmName;
private LoginDriver loginDriver;
public ASJMXAuthenticator() {}
public ASJMXAuthenticator(String realmName) {
setRealmName(realmName);
}
public void setRealmName(String realm) {
// TODO: Add permission check.
realmName = realm;
}
public String getRealmName() {
return realmName;
}
public LoginDriver getLoginDriver() {
return loginDriver;
}
public void setLoginDriver(LoginDriver driver) {
// TODO: Add permission check.
loginDriver = driver;
}
public Subject authenticate(Object credentials) {
if (credentials == null) {
if (_debug) {
System.out.println("JMXAuthenticator: Null credentials sent from the client");
}
throwInvalidCredentialsException();
}
if (!(credentials instanceof String[])) {
if (_debug) {
System.out.println(
"JMXAuthenticator: Invalid credentials sent from the client "
+ credentials.getClass().getName());
}
throwInvalidCredentialsException();
}
String[] userpass = (String[]) credentials;
if (userpass.length != 2) {
if (_debug) {
System.out.println(
"JMXAuthenticator: Invalid credentials sent from client, string array of length "
+ userpass.length);
}
throwInvalidCredentialsException();
}
if (_debug) {
System.out.println(
"JMX authentication request for user " + userpass[0] + " and password " + userpass[1]);
System.out.println("Authentication realm is " + realmName);
}
Subject subject = null;
if (loginDriver != null) {
subject = loginDriver.login(userpass[0], userpass[1], realmName);
} else {
// TODO: WARNING message, JMX connector not protected
}
return subject;
}
private void throwInvalidCredentialsException() {
throw new SecurityException(_strings.getString("admin.auth.invalid.credentials"));
}
}
public class BaseElement {
protected StringManager stringManager =
StringManager.getManager(
com.sun.enterprise.tools.upgrade.logging.LogService.UPGRADE_TRANSFORM_LOGGER);
protected Logger logger =
com.sun.enterprise.tools.upgrade.common.CommonInfoModel.getDefaultLogger();
protected static CommonInfoModel commonInfoModel;
/** Creates a new instance of Element */
public BaseElement() {}
public void transform(Element element, Element parentSource, Element parentResult) {
NodeList childNodes = element.getChildNodes();
logger.log(
Level.FINE,
stringManager.getString(
"upgrade.transform.baseelemnt.transformingMSG", element.getTagName()));
for (int index = 0; index < childNodes.getLength(); index++) {
Node aNode = childNodes.item(index);
try {
if (aNode.getNodeType() == Node.ELEMENT_NODE) {
BaseElement baseElement =
ElementToObjectMapper.getMapper().getElementObject(aNode.getNodeName());
baseElement.transform((Element) aNode, element, parentResult);
}
} catch (Exception ex) {
// ****** LOG MESSAGE *************
ex.printStackTrace();
logger.log(
Level.WARNING,
stringManager.getString(
"upgrade.transform.baseelement.transformexception",
new String[] {element.getTagName(), ex.getMessage()}));
// -logger.log(Level.WARNING,
// stringManager.getString("upgrade.transform.baseelement.transformexception"), ex);
}
}
}
protected void transferAttributes(
Element source, Element result, java.util.List nonTransferList) {
boolean debug = false;
NamedNodeMap sourceAttrNodeMap = source.getAttributes();
if (sourceAttrNodeMap == null) return;
NamedNodeMap resultAttrNodeMap = result.getAttributes();
for (int index = 0; index < sourceAttrNodeMap.getLength(); index++) {
Node sourceAttrNode = sourceAttrNodeMap.item(index);
if (!this.canTransferAttribute(sourceAttrNode.getNodeName(), nonTransferList)) continue;
if (!isValidAttributeToTransfer(
sourceAttrNode.getNodeName(), getAttributeListForElement(result.getTagName()))) continue;
if (resultAttrNodeMap == null) {
Attr addAttr = result.getOwnerDocument().createAttribute(sourceAttrNode.getNodeName());
addAttr.setValue(sourceAttrNode.getNodeValue());
result.setAttributeNode(addAttr);
} else {
Node resultAttrNode = resultAttrNodeMap.getNamedItem(sourceAttrNode.getNodeName());
if (resultAttrNode != null) {
resultAttrNode.setNodeValue(sourceAttrNode.getNodeValue());
// result.setAttributeNode((Attr)resultAttrNode);
} else {
Attr addAttr = result.getOwnerDocument().createAttribute(sourceAttrNode.getNodeName());
addAttr.setValue(sourceAttrNode.getNodeValue());
result.setAttributeNode(addAttr);
}
}
}
}
private boolean canTransferAttribute(String attr, java.util.List attrList) {
if (attrList == null || attrList.isEmpty()) return true;
for (java.util.Iterator it = attrList.iterator(); it.hasNext(); ) {
if (it.next().equals(attr)) return false;
}
return true;
}
public static void setCommonInfoModel(CommonInfoModel cim) {
commonInfoModel = cim;
}
/*
* Returns the key mapped in mapper for the element
* This key is used for comparing source and target elements
* Returns NULL if no key is mapped. This is quite common for elements that have only child elements but no attributes to transfer
*/
protected String getKeyToCompare(String elementTagName) {
return ElementToObjectMapper.getMapper().getKeyForElement(elementTagName);
}
protected java.util.List getInsertElementStructure(Element element, Element parentEle) {
// Sub classes can override this method to return a different list if needed.
// parentEle is not used in this method. But sub classes can use it to make certain decision on
// structure
return ElementToObjectMapper.getMapper().getInsertElementStructure(element.getTagName());
}
public void appendElementToParent(Element parentEle, Element element) {
java.util.List eleStructureList = this.getInsertElementStructure(element, parentEle);
if (eleStructureList == null) {
// insert the element at the end
parentEle.appendChild(element);
return;
}
if (eleStructureList.isEmpty()) {
// insert the element in the beginning.
parentEle.insertBefore(element, parentEle.getFirstChild());
return;
}
String insertBeforeElementName = null;
Node insertBeforeNode = null;
for (int eleIndex = 0; eleIndex < eleStructureList.size(); eleIndex++) {
insertBeforeElementName = (String) eleStructureList.get(eleIndex);
Node lNode = parentEle.getFirstChild();
while (lNode != null) {
if (lNode instanceof Element) {
Element lElement = (Element) lNode;
if (lElement.getNodeName().equals(insertBeforeElementName)) {
// if match is found, break and insert
insertBeforeNode = lNode;
break;
}
}
// go to next sibling in order
lNode = lNode.getNextSibling();
}
if (insertBeforeNode != null) {
break;
}
}
// if match is not found, node will be place at the end
parentEle.insertBefore(element, insertBeforeNode);
}
protected boolean isValidAttributeToTransfer(String attrName, java.util.List attrList) {
for (java.util.Iterator it = attrList.iterator(); it.hasNext(); ) {
if (((String) it.next()).equals(attrName)) {
return true;
}
}
return false;
}
protected java.util.List getAttributeListForElement(String elementName) {
// String dtdFileName =
// this.commonInfoModel.getTargetInstallDir()+File.separator+"lib"+File.separator+"dtds"+File.separator+"sun-domain_1_1.dtd";
// Domain dtd changed for AS9.0
String dtdName = null;
if (UpgradeConstants.VERSION_91.equals(commonInfoModel.getTargetVersion())) {
dtdName = "sun-domain_1_3.dtd";
} else {
dtdName = "sun-domain_1_2.dtd";
}
String dtdFileName =
this.commonInfoModel.getTargetInstallDir()
+ File.separator
+ "lib"
+ File.separator
+ "dtds"
+ File.separator
+ dtdName;
return AttributeExtracter.getExtracter(dtdFileName).getAttributeList(elementName);
}
}
/** * Provides the implementation for an MBean that represents a node to give statistical data in the * form of its attributes. * * @author <a href="mailto:[email protected]">Kedar Mhaswade</a> * @since S1AS8.0 * @version $Revision: 1.6 $ */ class StatsHolderMBeanImpl implements DynamicMBean, StatsHolderMBean, MBeanRegistration { private static Logger logger = Logger.getLogger(AdminConstants.kLoggerName); private static StringManager sm = StringManager.getManager(StatsHolderMBeanImpl.class); private final StatsHolder delegate; private final StatsMediator mediator; private DottedNameRegistrar registrar; private MBeanInfo mi; private int state; private Object lock = new Object(); public static final int INITIALIZED = 0; public static final int REGISTERED = 1; public static final int MBEANINFO_DONE = 2; public static final String JTA_FREEZE = "freeze"; public static final String JTA_UNFREEZE = "unfreeze"; public static final String JTA_ROLLBACK = "rollback"; public static final String JTA_ACTIVE_TRANSACTIONS = "listActiveTransactions"; public static final String JTA_RUNTIME_RECOVERY_REQUIRED = "isRecoveryRequired"; public static final String DOTTED_NAME = "dotted-name"; StatsHolderMBeanImpl(StatsHolder delegate) { assert (delegate != null); this.delegate = delegate; this.mediator = new StatsMediatorImpl(delegate.getStats(), delegate.getStatsClass()); changeState(INITIALIZED); } public Object getAttribute(String name) throws AttributeNotFoundException, MBeanException, ReflectionException { if (name.equals(DOTTED_NAME)) return delegate.getDottedName(); else return (mediator.getAttribute(name)); } public AttributeList getAttributes(String[] names) { final AttributeList list = new AttributeList(); for (int i = 0; i < names.length; i++) { try { final Attribute a = new Attribute(names[i], this.getAttribute(names[i])); list.add(a); } catch (Exception e) { if (logger.isLoggable(Level.FINEST)) { logger.finest("Error while accessing an attribute named: " + names[i]); } // The exception SHOULD BE squelched per the contract of this method } } return (list); } public MBeanInfo getMBeanInfo() { synchronized (lock) { if (state == MBEANINFO_DONE) { return mi; } } build(); changeState(MBEANINFO_DONE); return (mi); } private void build() { final String name = StatsHolderMBeanImpl.class.getName(); final String desc = getDescription(); final MBeanAttributeInfo[] mais = mediator.getAttributeInfos(); final MBeanConstructorInfo[] mcis = this.getConstructorInfos(); final MBeanOperationInfo[] mois = this.getOperationInfos(); final MBeanNotificationInfo[] mnis = this.getNotificationInfos(); mi = new MBeanInfo(name, desc, mais, mcis, mois, mnis); } private String getDescription() { return "StatsHolder MBean for: " + StatsHolderMBeanImpl.class.getName(); } private MBeanConstructorInfo[] getConstructorInfos() { final MBeanConstructorInfo[] cis = new MBeanConstructorInfo[0]; return (cis); // we don't want management applications to create instances of this MBean } private MBeanOperationInfo[] getOperationInfos() { final ArrayList opInfo = new ArrayList(); opInfo.add(getChildrenInfo()); opInfo.add(getNameInfo()); opInfo.add(getTypeInfo()); // Add the additional ops only for StatsHolders that have an actual Stats object // associated with them if (delegate.getStats() != null) { opInfo.add(getStatisticNameInfo()); opInfo.add(getStatsInfo()); } MBeanOperationInfo[] mos = new MBeanOperationInfo[opInfo.size()]; mos = (MBeanOperationInfo[]) opInfo.toArray(mos); // if we are dealing with JTAStats, we need to add the additional // operations freeze, unfreeze & rollback to the MBeanOerationInfo if (isJta()) return (getJTAOperationInfo(mos)); return (mos); } public Object invoke(String method, Object[] params, String[] sign) throws MBeanException, ReflectionException { if ("getChildren".equals(method)) { return (this.getChildren()); } else if ("getName".equals(method)) { return (this.getName()); } else if ("getType".equals(method)) { return (this.getType()); } else if ("getStatisticNames".equals(method)) { return (this.getStatisticNames()); } else if ("getStatistics".equals(method)) { return (this.getStatistics()); } else if (isJTAMethod(method)) { return (mediator.invoke(method, params, sign)); } else { final String msg = sm.getString("smi.no_such_method", method); final Exception ae = new UnsupportedOperationException(msg); throw new MBeanException(ae); } } public void setAttribute(Attribute attribute) throws AttributeNotFoundException, InvalidAttributeValueException, MBeanException, ReflectionException { throw new UnsupportedOperationException("NYI"); } public AttributeList setAttributes(AttributeList attributes) { throw new UnsupportedOperationException("NYI"); } public ObjectName[] getChildren() { final Collection c = delegate.getAllChildren(); final ObjectName[] names = new ObjectName[c.size()]; final Iterator it = c.iterator(); int i = 0; while (it.hasNext()) { final StatsHolder s = (StatsHolder) it.next(); names[i++] = s.getObjectName(); } assert (names.length == i) : "Sizes don't match"; return (names); } private MBeanOperationInfo getChildrenInfo() { final MBeanOperationInfo info = new MBeanOperationInfo( "getChildren", "Gets the children of this StatsHolder", null, ObjectName[].class.getName(), MBeanOperationInfo.INFO); return (info); } private MBeanNotificationInfo[] getNotificationInfos() { final MBeanNotificationInfo[] mns = new MBeanNotificationInfo[0]; return (mns); } private boolean isJta() { boolean isJta = false; final Class cl = delegate.getStatsClass(); if (cl != null) { if (com.sun.enterprise.admin.monitor.stats.JTAStats.class.getName().equals(cl.getName())) { isJta = true; } } return (isJta); } private boolean isJTAMethod(String methodName) { return ((JTA_FREEZE.equals(methodName)) || (JTA_UNFREEZE.equals(methodName)) || (JTA_ACTIVE_TRANSACTIONS.equals(methodName)) || (JTA_RUNTIME_RECOVERY_REQUIRED.equals(methodName)) || (JTA_ROLLBACK.equals(methodName))); } // Implementation of MBeanRegistration - start public void postDeregister() {} public void postRegister(Boolean registered) { if (registered.equals(Boolean.TRUE)) { registrar.registerDottedName(delegate.getDottedName(), delegate.getObjectName()); changeState(REGISTERED); } } public void preDeregister() throws Exception { registrar.unregisterDottedName(delegate.getDottedName()); } public ObjectName preRegister(MBeanServer mBeanServer, ObjectName objectName) throws Exception { this.registrar = new DottedNameRegistrar(mBeanServer); return objectName; } // Implementation of MBeanRegistration - end private void changeState(int to) { synchronized (lock) { state = to; } } private MBeanOperationInfo[] getJTAOperationInfo(MBeanOperationInfo[] mos) { ArrayList opInfo = new ArrayList(); for (int i = 0; i < mos.length; i++) opInfo.add(mos[i]); // not performing any reflection for now, as it is assumed that // only 3 methods will be added to the MBeanOperationInfo and // their names and signatures are fixed. MBeanOperationInfo mInfo = new MBeanOperationInfo( JTA_FREEZE, "Freezes the transaction service", null, void.class.getName(), MBeanOperationInfo.ACTION); opInfo.add(mInfo); mInfo = new MBeanOperationInfo( JTA_UNFREEZE, "Unfreezes the transaction service", null, void.class.getName(), MBeanOperationInfo.ACTION); opInfo.add(mInfo); mInfo = new MBeanOperationInfo( JTA_ROLLBACK, "Rollsback a given transaction", new MBeanParameterInfo[] { new MBeanParameterInfo( "txnId", String.class.getName(), "Id of the transaction to be rolled back") }, void.class.getName(), MBeanOperationInfo.ACTION); opInfo.add(mInfo); mInfo = new MBeanOperationInfo( JTA_ACTIVE_TRANSACTIONS, "Gets Active Transactions in a Map", null, List.class.getName(), MBeanOperationInfo.ACTION_INFO); opInfo.add(mInfo); mInfo = new MBeanOperationInfo( JTA_RUNTIME_RECOVERY_REQUIRED, "Returns if the recovery is required", null, Boolean.class.getName(), MBeanOperationInfo.ACTION_INFO); opInfo.add(mInfo); MBeanOperationInfo[] jtaOpInfo = new MBeanOperationInfo[opInfo.size()]; return (MBeanOperationInfo[]) opInfo.toArray(jtaOpInfo); } public String getName() { return delegate.getName(); } public String getType() { return delegate.getType().getTypeName(); } private MBeanOperationInfo getNameInfo() { MBeanOperationInfo mInfo = new MBeanOperationInfo( "getName", "Gets the name of this StatsHolder", null, String.class.getName(), MBeanOperationInfo.INFO); return mInfo; } private MBeanOperationInfo getTypeInfo() { MBeanOperationInfo mInfo = new MBeanOperationInfo( "getType", "Gets the type of this StatsHolder", null, String.class.getName(), MBeanOperationInfo.INFO); return mInfo; } public String[] getStatisticNames() { Stats stats = delegate.getStats(); if (stats != null) { return stats.getStatisticNames(); } else { return null; } } public Statistic[] getStatistics() { Stats stats = delegate.getStats(); if (stats == null) { return null; } Statistic[] statArray = stats.getStatistics(); boolean isSerializable = checkSerializability(statArray); if (isSerializable) { final Statistic[] hackedArray = StatisticWorkaround.populateDescriptions(statArray); return hackedArray; } else return null; } private MBeanOperationInfo getStatisticNameInfo() { MBeanOperationInfo mInfo = new MBeanOperationInfo( "getStatisticNames", "Gets the names of all the statistics in the given Stats Object", null, String[].class.getName(), MBeanOperationInfo.INFO); return mInfo; } private MBeanOperationInfo getStatsInfo() { MBeanOperationInfo mInfo = new MBeanOperationInfo( "getStatistics", "returns the results of all the getXXX methods, in the given Stats object", null, Statistic[].class.getName(), MBeanOperationInfo.INFO); return mInfo; } private boolean checkSerializability(Object[] objArray) { boolean isSerializable = true; for (int i = 0; i < objArray.length; i++) { isSerializable = (isSerializable) && (objArray[i] instanceof java.io.Serializable); } return isSerializable; } }
/** @author mvatkina */
public class TransactionServiceProperties {
private static Logger _logger =
LogDomains.getLogger(TransactionServiceProperties.class, LogDomains.TRANSACTION_LOGGER);
private static StringManager localStrings =
StringManager.getManager(TransactionServiceProperties.class);
private static final String JTS_XA_SERVER_NAME = "com.sun.jts.xa-servername";
private static final String J2EE_SERVER_ID_PROP = "com.sun.enterprise.J2EEServerId";
private static final String JTS_SERVER_ID = "com.sun.jts.persistentServerId";
private static final String HABITAT = "HABITAT";
private static final int DEFAULT_SERVER_ID = 100;
private static Properties properties = null;
private static volatile boolean orbAvailable = false;
private static volatile boolean recoveryInitialized = false;
public static synchronized Properties getJTSProperties(
ServiceLocator serviceLocator, boolean isORBAvailable) {
if (orbAvailable == isORBAvailable && properties != null) {
// We will need to update the properties if ORB availability changed
return properties;
}
Properties jtsProperties = new Properties();
if (serviceLocator != null) {
jtsProperties.put(HABITAT, serviceLocator);
ProcessEnvironment processEnv = serviceLocator.getService(ProcessEnvironment.class);
if (processEnv.getProcessType().isServer()) {
TransactionService txnService =
serviceLocator.getService(
TransactionService.class, ServerEnvironment.DEFAULT_INSTANCE_NAME);
if (txnService != null) {
jtsProperties.put(Configuration.HEURISTIC_DIRECTION, txnService.getHeuristicDecision());
jtsProperties.put(Configuration.KEYPOINT_COUNT, txnService.getKeypointInterval());
String automaticRecovery = txnService.getAutomaticRecovery();
boolean isAutomaticRecovery =
(isValueSet(automaticRecovery) && "true".equals(automaticRecovery));
if (isAutomaticRecovery) {
_logger.log(Level.FINE, "Recoverable J2EE Server");
jtsProperties.put(Configuration.MANUAL_RECOVERY, "true");
}
boolean disable_distributed_transaction_logging = false;
String dbLoggingResource = null;
for (Property prop : txnService.getProperty()) {
String name = prop.getName();
String value = prop.getValue();
if (name.equals("disable-distributed-transaction-logging")) {
if (isValueSet(value) && "true".equals(value)) {
disable_distributed_transaction_logging = true;
}
} else if (name.equals("xaresource-txn-timeout")) {
if (isValueSet(value)) {
_logger.log(Level.FINE, "XAResource transaction timeout is" + value);
TransactionManagerImpl.setXAResourceTimeOut(Integer.parseInt(value));
}
} else if (name.equals("db-logging-resource")) {
dbLoggingResource = value;
_logger.log(Level.FINE, "Transaction DB Logging Resource Name" + dbLoggingResource);
if (dbLoggingResource != null
&& (" ".equals(dbLoggingResource) || "".equals(dbLoggingResource))) {
dbLoggingResource = "jdbc/TxnDS";
}
} else if (name.equals("xa-servername")) {
if (isValueSet(value)) {
jtsProperties.put(JTS_XA_SERVER_NAME, value);
}
} else if (name.equals("pending-txn-cleanup-interval")) {
if (isValueSet(value)) {
jtsProperties.put("pending-txn-cleanup-interval", value);
}
} else if (name.equals(Configuration.COMMIT_ONE_PHASE_DURING_RECOVERY)) {
if (isValueSet(value)) {
jtsProperties.put(Configuration.COMMIT_ONE_PHASE_DURING_RECOVERY, value);
}
} else if (name.equals("add-wait-point-during-recovery")) {
if (isValueSet(value)) {
try {
FailureInducer.setWaitPointRecovery(Integer.parseInt(value));
} catch (Exception e) {
_logger.log(Level.WARNING, e.getMessage());
}
}
}
}
if (dbLoggingResource != null) {
disable_distributed_transaction_logging = true;
jtsProperties.put(Configuration.DB_LOG_RESOURCE, dbLoggingResource);
}
/**
* JTS_SERVER_ID needs to be unique for each for server instance. This will be used as
* recovery identifier along with the hostname for example: if the hostname is 'tulsa' and
* iiop-listener-port is 3700 recovery identifier will be tulsa,P3700
*/
int jtsServerId = DEFAULT_SERVER_ID; // default value
if (isORBAvailable) {
jtsServerId =
serviceLocator
.<GlassFishORBHelper>getService(GlassFishORBHelper.class)
.getORBInitialPort();
if (jtsServerId == 0) {
// XXX Can this ever happen?
jtsServerId = DEFAULT_SERVER_ID; // default value
}
}
jtsProperties.put(JTS_SERVER_ID, String.valueOf(jtsServerId));
/* ServerId is an J2SE persistent server activation
API. ServerId is scoped at the ORBD. Since
There is no ORBD present in J2EE the value of
ServerId is meaningless - except it must have
SOME value if persistent POAs are created.
*/
// For clusters - all servers in the cluster MUST
// have the same ServerId so when failover happens
// and requests are delivered to a new server, the
// ServerId in the request will match the new server.
String serverId = String.valueOf(DEFAULT_SERVER_ID);
System.setProperty(J2EE_SERVER_ID_PROP, serverId);
ServerContext ctx = serviceLocator.getService(ServerContext.class);
String instanceName = ctx.getInstanceName();
/**
* if the auto recovery is true, always transaction logs will be written irrespective of
* disable_distributed_transaction_logging. if the auto recovery is false, then
* disable_distributed_transaction_logging will be used to write transaction logs are
* not.If disable_distributed_transaction_logging is set to false(by default false) logs
* will be written, set to true logs won't be written.
*/
if (!isAutomaticRecovery && disable_distributed_transaction_logging) {
Configuration.disableFileLogging();
} else {
// if (dbLoggingResource == null) {
Domain domain = serviceLocator.getService(Domain.class);
Server server = domain.getServerNamed(instanceName);
// Check if the server system property is set
String logdir = getTXLogDir(server);
// if not, check if the cluster system property is set
if (logdir == null) {
Cluster cluster = server.getCluster();
if (cluster != null) {
logdir = getTXLogDir(cluster);
}
}
// No system properties are set - get tx log dir from transaction service
if (logdir == null) {
logdir = txnService.getTxLogDir();
}
if (logdir == null) {
logdir = domain.getLogRoot();
if (logdir == null) {
// logdir = FileUtil.getAbsolutePath(".." + File.separator + "logs");
logdir = ".." + File.separator + "logs";
}
} else if (!(new File(logdir)).isAbsolute()) {
if (_logger.isLoggable(Level.FINE)) {
_logger.log(
Level.FINE,
"Relative pathname specified for transaction log directory : " + logdir);
}
String logroot = domain.getLogRoot();
if (logroot != null) {
logdir = logroot + File.separator + logdir;
} else {
// logdir = FileUtil.getAbsolutePath(".." + File.separator + "logs"
// + File.separator + logdir);
logdir = ".." + File.separator + "logs" + File.separator + logdir;
}
}
logdir += File.separator + instanceName + File.separator + "tx";
if (_logger.isLoggable(Level.FINE)) {
_logger.log(Level.FINE, "JTS log directory: " + logdir);
_logger.log(Level.FINE, "JTS Server id " + jtsServerId);
}
jtsProperties.put(Configuration.LOG_DIRECTORY, logdir);
}
jtsProperties.put(Configuration.COMMIT_RETRY, txnService.getRetryTimeoutInSeconds());
jtsProperties.put(Configuration.INSTANCE_NAME, instanceName);
}
}
}
properties = jtsProperties;
orbAvailable = isORBAvailable;
return properties;
}
public static void initRecovery(boolean force) {
if (_logger.isLoggable(Level.FINE)) {
_logger.log(Level.FINE, "initRecovery:recoveryInitialized: " + recoveryInitialized);
}
if (recoveryInitialized) {
// Only start initial recovery if it wasn't started before
return;
}
if (_logger.isLoggable(Level.FINE)) {
_logger.log(Level.FINE, "initRecovery:properties: " + properties);
}
if (properties == null) {
if (force) {
_logger.log(Level.WARNING, "", new IllegalStateException());
}
return;
}
// Start if force is true or automatic-recovery is set
String value = properties.getProperty(Configuration.MANUAL_RECOVERY);
if (_logger.isLoggable(Level.FINE)) {
_logger.log(Level.FINE, "initRecovery:Configuration.MANUAL_RECOVERY: " + value);
}
if (force || (isValueSet(value) && "true".equals(value))) {
recoveryInitialized = true;
ServiceLocator serviceLocator = (ServiceLocator) properties.get(HABITAT);
if (serviceLocator != null) {
ProcessEnvironment processEnv = serviceLocator.getService(ProcessEnvironment.class);
if (processEnv.getProcessType().isServer()) {
// Start ResourceManager if it hadn't started yet
serviceLocator.getAllServices(BuilderHelper.createNameFilter("ResourceManager"));
value = properties.getProperty("pending-txn-cleanup-interval");
int interval = -1;
if (isValueSet(value)) {
interval = Integer.parseInt(value);
}
new RecoveryHelperThread(serviceLocator, interval).start();
}
// Release all locks
RecoveryManager.startResyncThread();
if (_logger.isLoggable(Level.FINE)) _logger.log(Level.FINE, "[JTS] Started ResyncThread");
}
}
}
private static boolean isValueSet(String value) {
return (value != null && !value.equals("") && !value.equals(" "));
}
private static String getTXLogDir(SystemPropertyBag bag) {
for (SystemProperty prop : bag.getSystemProperty()) {
String name = prop.getName();
if (name.equals("TX-LOG-DIR")) {
return prop.getValue();
}
}
return null;
}
private static class RecoveryHelperThread extends Thread {
private int interval;
private ServiceLocator serviceLocator;
RecoveryHelperThread(ServiceLocator serviceLocator, int interval) {
setName("Recovery Helper Thread");
setDaemon(true);
this.serviceLocator = serviceLocator;
this.interval = interval;
}
public void run() {
ResourceRecoveryManager recoveryManager =
serviceLocator.getService(ResourceRecoveryManager.class);
if (interval <= 0) {
// Only start the recovery thread if the interval value is set, and set to a positive value
return;
}
if (_logger.isLoggable(Level.INFO)) {
_logger.log(
Level.INFO,
"Asynchronous thread for incomplete " + "tx is enabled with interval " + interval);
}
int prevSize = 0;
try {
while (true) {
Thread.sleep(interval * 1000L);
if (!RecoveryManager.isIncompleteTxRecoveryRequired()) {
if (_logger.isLoggable(Level.FINE))
_logger.log(
Level.FINE,
"Incomplete transaction recovery is "
+ "not requeired, waiting for the next interval");
continue;
}
if (RecoveryManager.sizeOfInCompleteTx() <= prevSize) {
if (_logger.isLoggable(Level.FINE))
_logger.log(
Level.FINE,
"Incomplete transaction recovery is "
+ "not required, waiting for the next interval SIZE");
continue;
}
prevSize = RecoveryManager.sizeOfInCompleteTx();
recoveryManager.recoverIncompleteTx(false, null);
}
} catch (Exception ex) {
if (_logger.isLoggable(Level.FINE))
_logger.log(Level.FINE, " Exception occurred in recoverInCompleteTx ");
}
}
}
}
/**
* @author bnevins
* @version
*/
public class DeployableObjectType {
public boolean isEJB() {
return this == EJB;
}
///////////////////////////////////////////////////////////////////////////
public boolean isWEB() {
return this == WEB;
}
///////////////////////////////////////////////////////////////////////////
public boolean isAPP() {
return this == APP;
}
///////////////////////////////////////////////////////////////////////////
public boolean isCONN() {
return this == CONN;
}
///////////////////////////////////////////////////////////////////////////
public boolean isCAR() {
return this == CAR;
}
public boolean isLCM() {
return this == LCM;
}
public boolean isCMB() {
return this == CMB;
}
///////////////////////////////////////////////////////////////////////////
public String toString() {
return name;
}
///////////////////////////////////////////////////////////////////////////
public ModuleType getModuleType() {
return jsr88Type;
}
///////////////////////////////////////////////////////////////////////////
private DeployableObjectType(
String theName, String theDDName, String theRuntimeDD, String ext, ModuleType type) {
name = theName;
ddName = theDDName;
runtimeDD = theRuntimeDD;
extension = ext;
jsr88Type = type;
allTypes.add(this);
}
///////////////////////////////////////////////////////////////////////////
public static final DeployableObjectType APP;
public static final DeployableObjectType EJB;
public static final DeployableObjectType WEB;
public static final DeployableObjectType CONN;
public static final DeployableObjectType CAR;
public static final DeployableObjectType LCM;
public static final DeployableObjectType CMB;
private final String name;
private final String ddName;
private final String runtimeDD;
private final String extension;
private final ModuleType jsr88Type;
private static StringManager localStrings = StringManager.getManager(DeployableObjectType.class);
private static List allTypes;
static {
allTypes = new ArrayList(7);
APP =
new DeployableObjectType(
"Application",
"META-INF/application.xml",
"META-INF/sun-application.xml",
".ear",
ModuleType.EAR);
WEB =
new DeployableObjectType(
"Web Module", "WEB-INF/web.xml", "WEB-INF/sun-web.xml", ".war", ModuleType.WAR);
CONN =
new DeployableObjectType(
"Connector Module", "META-INF/ra.xml", "META-INF/sun-ra.xml", ".rar", ModuleType.RAR);
CAR =
new DeployableObjectType(
"AppClient Module",
"META-INF/application-client.xml",
"META-INF/sun-application-client.xml",
".jar",
ModuleType.CAR);
EJB =
new DeployableObjectType(
"EJB Module",
"META-INF/ejb-jar.xml",
"META-INF/sun-ejb-jar.xml",
".jar",
ModuleType.EJB);
LCM = new DeployableObjectType("Lifecycle Module", null, null, ".jar", XModuleType.LCM);
CMB = new DeployableObjectType("Custom MBean Module", null, null, ".jar", XModuleType.CMB);
}
///////////////////////////////////////////////////////////////////////////
public static void main(String[] args) {
String[] files =
new String[] {
"pkgingEApp.ear",
"foof.rar",
"hello.war",
"foo.jar",
"nothere",
"junk.ear",
"ear",
"ejb",
"rar",
"war"
};
for (int i = 0; i < files.length; i++) {
File f = new File("C:/ias8samples/" + files[i]);
try {
// used to display (f.getName() + " is a: " + valueOf(f));
} catch (Exception ex) {
ex.printStackTrace();
}
}
}
}
/**
* This interface implements basic deployment related facilities such as deploying any j2ee modules
* on a Domain Admin Server or target servers as well as retrieving non portable artifacts for
* successful runs in a client mode configuration.
*/
public class DeploymentFacilityImpl implements DeploymentFacility {
protected ConnectionSource dasConnection = null;
protected ServerConnectionIdentifier serverId = null;
protected SunTarget domain = null;
protected Boolean localConnection = Boolean.FALSE;
private static final String DAS = "server";
private static StringManager localStrings =
StringManager.getManager(DeploymentFacilityImpl.class);
public DeploymentFacilityImpl() {}
/**
* Connects to a particular instance of the domain adminstration server using the provided
* connection information
*/
public boolean connect(ServerConnectionIdentifier targetDAS) {
try {
TLSParams tlsParams = null;
if (targetDAS.isSecure()) {
X509TrustManager trustManager =
(X509TrustManager)
targetDAS
.getConnectionEnvironment()
.get(DefaultConfiguration.TRUST_MANAGER_PROPERTY_NAME);
tlsParams = new TLSParams(trustManager, null);
}
dasConnection =
new AppserverConnectionSource(
AppserverConnectionSource.PROTOCOL_HTTP,
targetDAS.getHostName(),
targetDAS.getHostPort(),
targetDAS.getUserName(),
targetDAS.getPassword(),
tlsParams,
null);
} catch (IllegalArgumentException illEx) {
return false;
}
serverId = targetDAS;
domain = new SunTarget(targetDAS);
domain.setConnectionSource(dasConnection);
domain.setTargetType(TargetType.DOMAIN);
return true;
}
/** @return true if we are connected to a domain adminstration server */
public boolean isConnected() {
if (dasConnection == null) {
return false;
}
return true;
}
/** Disconnects from a domain administration server and releases all associated resouces. */
public boolean disconnect() {
dasConnection = null;
return true;
}
/**
* Initiates a deployment operation on the server, using a source archive abstraction and an
* optional deployment plan if the server specific information is not embedded in the source
* archive. The deploymentOptions is a key-value pair map of deployment options for this
* operations. Once the deployment is successful, the targets server instances
*
* @param source is the j2ee module abstraction (with or without the server specific artifacts).
* @param deploymenPlan is the optional deployment plan is the source archive is portable.
* @param the deployment options
* @return a JESProgressObject to receive deployment events.
*/
public JESProgressObject deploy(
Target[] targets, Archive source, Archive deploymentPlan, Map deploymentOptions) {
if (!isConnected()) {
throw new IllegalStateException(
localStrings.getString("enterprise.deployment.client.disconnected_state"));
}
SunTarget[] targetList = getSunTargets(targets);
ProgressObjectImpl progressObject = new DeployAction(targetList);
Object args[] = new Object[8];
args[0] = dasConnection;
args[1] = source;
args[2] = deploymentPlan;
args[3] =
(deploymentOptions == null)
? new HashMap()
: DeploymentProperties.propsToMap((Properties) deploymentOptions);
args[4] = targetList;
args[5] = domain;
args[6] = localConnection;
args[7] = serverId;
progressObject.setCommand(CommandType.DISTRIBUTE, args);
Thread newThread = new Thread(progressObject);
newThread.start();
return progressObject;
}
/**
* Initiates a undeployment operation on the server
*
* @param module ID for the component to undeploy
* @return a JESProgress to receive undeployment events
*/
// FIXME - this should go once admin-cli changes it code
public JESProgressObject undeploy(Target[] targets, String moduleID) {
return (undeploy(targets, moduleID, null));
}
public JESProgressObject undeploy(Target[] targets, String moduleID, Map options) {
if (!isConnected()) {
throw new IllegalStateException(
localStrings.getString("enterprise.deployment.client.disconnected_state"));
}
SunTarget[] targetList = getSunTargets(targets);
ProgressObjectImpl progressObject = new UndeployAction(targetList);
Object args[] = new Object[6];
args[0] = dasConnection;
args[1] = moduleID;
args[2] =
(options == null) ? new HashMap() : DeploymentProperties.propsToMap((Properties) options);
args[3] = targetList;
args[4] = domain;
args[5] = localConnection;
progressObject.setCommand(CommandType.UNDEPLOY, args);
Thread newThread = new Thread(progressObject);
newThread.start();
return progressObject;
}
/** Enables a deployed component on the provided list of targets. */
public JESProgressObject enable(Target[] targets, String moduleID) {
return (changeState(targets, moduleID, CommandType.START));
}
/** Disables a deployed component on the provided list of targets */
public JESProgressObject disable(Target[] targets, String moduleID) {
return (changeState(targets, moduleID, CommandType.STOP));
}
private JESProgressObject changeState(Target[] targets, String moduleID, CommandType cmd) {
if (!isConnected()) {
throw new IllegalStateException(
localStrings.getString("enterprise.deployment.client.disconnected_state"));
}
SunTarget[] targetList = getSunTargets(targets);
ProgressObjectImpl progressObject = new ChangeStateAction(targetList);
Object args[] = new Object[5];
args[0] = dasConnection;
args[1] = targetList;
args[2] = moduleID;
args[3] = cmd;
args[4] = domain;
progressObject.setCommand(cmd, args);
Thread newThread = new Thread(progressObject);
newThread.start();
return progressObject;
}
/** Add an application ref on the selected targets */
public JESProgressObject createAppRef(Target[] targets, String moduleID, Map options) {
return (doApplicationReferenceAction(targets, moduleID, options, CommandType.DISTRIBUTE));
}
/** remove the application ref for the provided list of targets. */
public JESProgressObject deleteAppRef(Target[] targets, String moduleID, Map options) {
return (doApplicationReferenceAction(targets, moduleID, options, CommandType.UNDEPLOY));
}
private JESProgressObject doApplicationReferenceAction(
Target[] targets, String moduleID, Map options, CommandType cmd) {
if (!isConnected()) {
throw new IllegalStateException(
localStrings.getString("enterprise.deployment.client.disconnected_state"));
}
SunTarget[] targetList = getSunTargets(targets);
ProgressObjectImpl progressObject = new ApplicationReferenceAction(targetList);
Object args[] = new Object[5];
args[0] = dasConnection;
args[1] = targetList;
args[2] = moduleID;
args[3] = cmd;
args[4] =
(options == null) ? new HashMap() : DeploymentProperties.propsToMap((Properties) options);
progressObject.setCommand(cmd, args);
Thread newThread = new Thread(progressObject);
newThread.start();
return progressObject;
}
/** list all application refs that are present in the provided list of targets */
public TargetModuleID[] listAppRefs(String[] targets) throws IOException {
if (!isConnected()) {
throw new IllegalStateException(
localStrings.getString("enterprise.deployment.client.disconnected_state"));
}
Vector tmpVector = new Vector();
DomainConfig domainCfg =
ProxyFactory.getInstance(dasConnection).getDomainRoot().getDomainConfig();
Map serverProxies = domainCfg.getStandaloneServerConfigMap();
Map clusterProxies = domainCfg.getClusterConfigMap();
Map clusteredServerProxies = domainCfg.getClusteredServerConfigMap();
for (int i = 0; i < targets.length; i++) {
Set proxySet = null;
if (serverProxies.get(targets[i]) != null) {
StandaloneServerConfig tgtProxy =
(StandaloneServerConfig)
domainCfg.getContainee(XTypes.STANDALONE_SERVER_CONFIG, targets[i]);
proxySet = tgtProxy.getContaineeSet(XTypes.DEPLOYED_ITEM_REF_CONFIG);
} else if (clusterProxies.get(targets[i]) != null) {
ClusterConfig tgtProxy =
(ClusterConfig) domainCfg.getContainee(XTypes.CLUSTER_CONFIG, targets[i]);
proxySet = tgtProxy.getContaineeSet(XTypes.DEPLOYED_ITEM_REF_CONFIG);
} else if (clusteredServerProxies.get(targets[i]) != null) {
ClusteredServerConfig tgtProxy =
(ClusteredServerConfig)
domainCfg.getContainee(XTypes.CLUSTERED_SERVER_CONFIG, targets[i]);
proxySet = tgtProxy.getContaineeSet(XTypes.DEPLOYED_ITEM_REF_CONFIG);
} else if (TargetType.DOMAIN.equals(targets[i])) {
StandaloneServerConfig tgtProxy =
(StandaloneServerConfig) domainCfg.getContainee(XTypes.STANDALONE_SERVER_CONFIG, DAS);
proxySet = tgtProxy.getContaineeSet(XTypes.DEPLOYED_ITEM_REF_CONFIG);
} else {
return null;
}
Object[] appRefs = proxySet.toArray();
for (int k = 0; k < appRefs.length; k++) {
SunTarget aTarget = new SunTarget(serverId);
aTarget.setAppServerInstance(targets[i]);
aTarget.setConnectionSource(dasConnection);
DeployedItemRefConfig item = (DeployedItemRefConfig) appRefs[k];
SunTargetModuleID tgtId = new SunTargetModuleID(item.getRef(), aTarget);
tmpVector.add(tgtId);
}
}
SunTargetModuleID[] result = new SunTargetModuleID[tmpVector.size()];
return (TargetModuleID[]) tmpVector.toArray(result);
}
/** Create SunTarget[] from given Target[] */
private SunTarget[] getSunTargets(Target[] givenTargets) throws IllegalArgumentException {
SunTarget[] result = new SunTarget[givenTargets.length];
for (int i = 0; i < givenTargets.length; i++) {
if (givenTargets[i] instanceof SunTarget) {
result[i] = new SunTarget((SunTarget) givenTargets[i]);
} else {
throw new IllegalArgumentException(
localStrings.getString(
"enterprise.deployment.client.notASunTarget",
givenTargets[i].getClass().getName()));
}
}
return result;
}
/**
* Downloads a particular file from the server repository. The filePath is a relative path from
* the root directory of the deployed component identified with the moduleID parameter. The
* resulting downloaded file should be placed in the location directory keeping the relative path
* constraint. Note that the current implementation only supports the download of the appclient
* jar file.
*
* @param location is the root directory where to place the downloaded file
* @param moduleID is the moduleID of the deployed component to download the file from
* @param moduleURI is the relative path to the file in the repository
* @return the downloaded local file absolute path.
*/
public String downloadFile(File location, String moduleID, String moduleURI) throws IOException {
if (!isConnected()) {
throw new IllegalStateException(
localStrings.getString("enterprise.deployment.client.disconnected_state"));
}
return DeploymentClientUtils.downloadClientStubs(
moduleID, location.getAbsolutePath(), dasConnection);
}
/**
* Wait for a Progress object to be in a completed state (sucessful or failed) and return the
* DeploymentStatus for this progress object.
*
* @param the progress object to wait for completion
* @return the deployment status
*/
public DeploymentStatus waitFor(JESProgressObject po) {
DeploymentStatus status = null;
do {
try {
Thread.currentThread().sleep(100);
} catch (InterruptedException ie) {
// Exception swallowed deliberately
}
status = po.getCompletedStatus();
} while (status == null);
return status;
}
public Target[] createTargets(String[] targets) {
if (!isConnected()) {
throw new IllegalStateException(
localStrings.getString("enterprise.deployment.client.disconnected_state"));
}
Target[] targetsArray = new Target[targets.length];
Map serverProxies = null;
Map clusterProxies = null;
try {
// parse through given targets
for (int i = 0; i < targets.length; i++) {
// if this is "domain" add a domain target
if (TargetType.DOMAIN.equals(targets[i])) {
// Add a domain target
SunTarget dom = new SunTarget(serverId);
dom.setAppServerInstance(TargetType.DOMAIN);
dom.setConnectionSource(dasConnection);
dom.setTargetType(TargetType.DOMAIN);
targetsArray[i] = dom;
continue;
}
// if this is "server" add a server target
if (DAS.equals(targets[i])) {
// Add a target for default server
SunTarget serv = new SunTarget(serverId);
serv.setAppServerInstance(DAS);
serv.setConnectionSource(dasConnection);
serv.setTargetType(TargetType.STAND_ALONE_SERVER);
targetsArray[i] = serv;
continue;
}
// for PE, it will not come here at all; go ahead and get proxies and server/cluster keysets
// from the proxies
if (serverProxies == null || clusterProxies == null) {
DomainConfig domainCfg =
ProxyFactory.getInstance(dasConnection).getDomainRoot().getDomainConfig();
serverProxies = domainCfg.getStandaloneServerConfigMap();
clusterProxies = domainCfg.getClusterConfigMap();
}
// check if ctarget is a stand alone server
if (serverProxies.get(targets[i]) != null) {
SunTarget aTarget = new SunTarget(serverId);
aTarget.setAppServerInstance(targets[i]);
aTarget.setConnectionSource(dasConnection);
aTarget.setTargetType(TargetType.STAND_ALONE_SERVER);
targetsArray[i] = aTarget;
continue;
}
// check if ctarget is a cluster
if (clusterProxies.get(targets[i]) != null) {
SunTarget aTarget = new SunTarget(serverId);
aTarget.setAppServerInstance(targets[i]);
aTarget.setConnectionSource(dasConnection);
aTarget.setTargetType(TargetType.CLUSTER);
targetsArray[i] = aTarget;
continue;
}
// if we are here, it means given target does not exist at all - return null
return null;
}
} catch (Throwable ex) {
// it's too late to change the DeploymentFacility.createTargets
// interface to throw approriate exceptions as this point,
// but let's at least re-throw the RuntimeException so
// connection failure (for example, due to wrong user/password)
// could be reported back to user.
if (ex instanceof RuntimeException) {
throw (RuntimeException) ex;
}
return null;
}
return targetsArray;
}
}
public class DomainXmlTransformer {
private File in;
private File out;
private final XMLEventFactory xmlEventFactory = XMLEventFactory.newInstance();
private final XMLOutputFactory xof = XMLOutputFactory.newInstance();
private Logger _logger =
Logger.getAnonymousLogger("com.sun.logging.enterprise.system.container.ejb.LogStrings");
private static final String VIRTUAL_SERVER = "virtual-server";
private static final String NETWORK_LISTENERS = "network-listeners";
private static final String IIOP_LISTENER = "iiop-listener";
private static final String PROTOCOLS = "protocols";
private static final String APPLICATIONS = "applications";
private static final String CLUSTERS = "clusters";
private static final String JMS_HOST = "jms-host";
private static final String JMX_CONNECTOR = "jmx-connector";
private static final String LAZY_INIT_ATTR = "lazy-init";
private static final String ADMIN_SERVICE = "admin-service";
private static final String DAS_CONFIG = "das-config";
private static final String DYNAMIC_RELOAD_ENABLED = "dynamic-reload-enabled";
private static final String JAVA_CONFIG = "java-config";
private static final String JVM_OPTIONS = "jvm-options";
private static final String INITIALIZE_ON_DEMAND = "-Dorg.glassfish.jms.InitializeOnDemand=true";
private static final String ENABLED = "enabled";
private static final String FALSE = "false";
private static final String TRUE = "true";
private static final Set<String> SKIP_ELEMENTS = new HashSet(Arrays.asList(VIRTUAL_SERVER));
private static final Set<String> SKIP_ELEMENTS_KEEP_PORTS = new HashSet();
private static final Set<String> EMPTY_ELEMENTS =
new HashSet(Arrays.asList(NETWORK_LISTENERS, PROTOCOLS, APPLICATIONS, CLUSTERS));
private static final Set<String> EMPTY_ELEMENTS_KEEP_PORTS =
new HashSet(Arrays.asList(APPLICATIONS));
private static final Set<String> SKIP_SETTINGS_ELEMENTS =
new HashSet(Arrays.asList(IIOP_LISTENER));
private static final Set<String> DISABLE_ELEMENTS = new HashSet(Arrays.asList(JMX_CONNECTOR));
private static final Set<String> DISABLE_SUB_ELEMENTS =
new HashSet(Arrays.asList(LAZY_INIT_ATTR));
private static final StringManager localStrings =
StringManager.getManager(DomainXmlTransformer.class);
public DomainXmlTransformer(File domainXml) {
in = domainXml;
}
public DomainXmlTransformer(File domainXml, Logger logger) {
in = domainXml;
_logger = logger;
}
public File transform(boolean keepPorts) {
FileInputStream fis = null;
FileOutputStream fos = null;
XMLEventReader parser = null;
XMLEventWriter writer = null;
XMLInputFactory xif =
(XMLInputFactory.class.getClassLoader() == null)
? XMLInputFactory.newInstance()
: XMLInputFactory.newInstance(
XMLInputFactory.class.getName(), XMLInputFactory.class.getClassLoader());
Set<String> empty_elements = (keepPorts) ? EMPTY_ELEMENTS_KEEP_PORTS : EMPTY_ELEMENTS;
Set<String> skip_elements = (keepPorts) ? SKIP_ELEMENTS_KEEP_PORTS : SKIP_ELEMENTS;
try {
fis = new FileInputStream(in);
out = File.createTempFile("domain", "xml");
if (_logger.isLoggable(Level.FINE)) {
_logger.fine("[DomainXmlTransformer] Creating temp domain file: " + out);
}
if (System.getProperty(EJBContainerProviderImpl.KEEP_TEMPORARY_FILES) == null) {
out.deleteOnExit();
}
fos = new FileOutputStream(out);
parser = xif.createXMLEventReader(fis);
writer = xof.createXMLEventWriter(fos);
boolean fixedDasConfig = false;
while (parser.hasNext()) {
XMLEvent event = parser.nextEvent();
if (event.isStartElement()) {
String name = event.asStartElement().getName().getLocalPart();
if (skip_elements.contains(name)) {
if (_logger.isLoggable(Level.FINE)) {
_logger.fine("[DomainXmlTransformer] Skipping all of: " + name);
}
getEndEventFor(parser, name);
continue;
}
boolean skip_to_end = false;
if (empty_elements.contains(name)) {
if (_logger.isLoggable(Level.FINE)) {
_logger.fine("[DomainXmlTransformer] Skipping details of: " + name);
}
skip_to_end = true;
} else if (SKIP_SETTINGS_ELEMENTS.contains(name)) {
// Make sure lazy init is not enabled by creating a new start element
// based on the original but that never includes the lazy init attribute
event = getSkippedElementStartEvent(event);
skip_to_end = true;
} else if (DISABLE_ELEMENTS.contains(name)) {
// Disable this element
event = getReplaceAttributeInStartEvent(event, ENABLED, FALSE);
skip_to_end = true;
} else if (JMS_HOST.equals(name)) {
// Set lazy-init to false
event = getReplaceAttributeInStartEvent(event, LAZY_INIT_ATTR, FALSE);
skip_to_end = true;
} else if (DAS_CONFIG.equals(name)) {
// Set dynamic-reload-enabled to false
event = getReplaceAttributeInStartEvent(event, DYNAMIC_RELOAD_ENABLED, FALSE);
fixedDasConfig = true;
skip_to_end = true;
} else if (JAVA_CONFIG.equals(name)) {
// Add jvm-options
writer.add(event);
event = getAddedEvent(event, writer, JVM_OPTIONS, INITIALIZE_ON_DEMAND);
}
if (skip_to_end) {
writer.add(event);
event = getEndEventFor(parser, name);
}
} else if (event.isEndElement()) {
String name = event.asEndElement().getName().getLocalPart();
if (ADMIN_SERVICE.equals(name)) {
if (!fixedDasConfig) {
writer.add(
getAddedEventBeforeEndElement(
event, writer, DAS_CONFIG, DYNAMIC_RELOAD_ENABLED, FALSE));
}
fixedDasConfig = false; // for the next config
}
}
if (_logger.isLoggable(Level.FINEST)) {
_logger.finest("[DomainXmlTransformer] Processing: " + event);
}
writer.add(event);
}
writer.flush();
writer.close();
} catch (Exception e) {
_logger.log(Level.SEVERE, "ejb.embedded.tmp_file_create_error", e.getMessage());
_logger.log(Level.FINE, e.getMessage(), e);
return null;
} finally {
try {
if (parser != null) {
parser.close();
}
} catch (Exception e) {
}
try {
if (fis != null) {
fis.close();
}
} catch (Exception e) {
}
try {
if (writer != null) {
writer.close();
}
} catch (Exception e) {
}
try {
if (fos != null) {
fos.close();
}
} catch (Exception e) {
}
}
if (_logger.isLoggable(Level.FINE)) {
_logger.fine("[DomainXmlTransformer] Created temp domain file: " + out);
}
return out;
}
private XMLEvent getEndEventFor(XMLEventReader parser, String name)
throws XMLStreamException, EOFException {
while (parser.hasNext()) {
XMLEvent event = parser.nextEvent();
if (event.isEndElement() && event.asEndElement().getName().getLocalPart().equals(name)) {
if (_logger.isLoggable(Level.FINEST)) {
_logger.finest("[DomainXmlTransformer] END: " + name);
}
return event;
}
}
throw new EOFException(localStrings.getString("ejb.embedded.no_matching_end_element", name));
}
/** Create a new start element based on the original but that does not include any attributes. */
private StartElement getEmptyStartEvent(XMLEvent event) {
StartElement oldStartEvent = event.asStartElement();
return xmlEventFactory.createStartElement(
oldStartEvent.getName(), null, oldStartEvent.getNamespaces());
}
/**
* Create a new start element based on the original but that does not include the specified
* attribute.
*/
private StartElement getSkippedElementStartEvent(XMLEvent event) {
Set attributes = new HashSet();
for (java.util.Iterator i = event.asStartElement().getAttributes(); i.hasNext(); ) {
Attribute a = (Attribute) i.next();
if (!DISABLE_SUB_ELEMENTS.contains(a.getName().getLocalPart())) {
attributes.add(a);
}
}
StartElement oldStartEvent = event.asStartElement();
return xmlEventFactory.createStartElement(
oldStartEvent.getName(), attributes.iterator(), oldStartEvent.getNamespaces());
}
/**
* Write a new element with the specified name and text
*
* @return the end element
*/
private XMLEvent getAddedEvent(
XMLEvent event, XMLEventWriter writer, String elementName, String text)
throws XMLStreamException {
StartElement oldStartEvent = event.asStartElement();
StartElement newStartEvent =
xmlEventFactory.createStartElement(
new QName(elementName), null, oldStartEvent.getNamespaces());
writer.add(newStartEvent);
writer.add(xmlEventFactory.createCharacters(text));
return xmlEventFactory.createEndElement(newStartEvent.getName(), newStartEvent.getNamespaces());
}
/**
* Write a new element with the specified name and attribute before the end element is written out
*
* @return the end element
*/
private XMLEvent getAddedEventBeforeEndElement(
XMLEvent event,
XMLEventWriter writer,
String elementName,
String attributeName,
String attributeValue)
throws XMLStreamException {
Attribute newAttribute = xmlEventFactory.createAttribute(attributeName, attributeValue);
Set attributes = new HashSet();
attributes.add(newAttribute);
EndElement oldEvent = event.asEndElement();
StartElement newStartEvent =
xmlEventFactory.createStartElement(
new QName(elementName), attributes.iterator(), oldEvent.getNamespaces());
writer.add(newStartEvent);
return xmlEventFactory.createEndElement(newStartEvent.getName(), newStartEvent.getNamespaces());
}
/** Create a new start element based on the original but that replaces attribute value */
private StartElement getReplaceAttributeInStartEvent(
XMLEvent event, String attr_name, String attr_value) {
Set attributes = new HashSet();
for (java.util.Iterator i = event.asStartElement().getAttributes(); i.hasNext(); ) {
Attribute a = (Attribute) i.next();
if (!a.getName().getLocalPart().equals(attr_name)) {
attributes.add(a);
}
}
Attribute newAttribute = xmlEventFactory.createAttribute(attr_name, attr_value);
attributes.add(newAttribute);
StartElement oldStartEvent = event.asStartElement();
return xmlEventFactory.createStartElement(
oldStartEvent.getName(), attributes.iterator(), oldStartEvent.getNamespaces());
}
}
/**
* Represents a concrete implementation of a command that processes the synchronization response.
*
* @author Nazrul Islam
* @since JDK1.4
*/
class ResponseProcessCommand implements Command {
private static Logger _logger = Logger.getLogger(EELogDomains.SYNCHRONIZATION_LOGGER);
private static final StringManager _localStrMgr =
StringManager.getManager(ResponseProcessCommand.class);
/**
* Initializes the arguments.
*
* @param req synchronization request
* @param res synchronization response
*/
ResponseProcessCommand(SynchronizationRequest req, SynchronizationResponse res) {
_request = req;
_response = res;
}
/**
* Renders the response zip into the local file system.
*
* @throws SynchronizationException if an error while processing the zip
*/
public void execute() throws SynchronizationException {
try {
_logger.log(Level.FINE, "synchronization.process_command", _request.getMetaFileName());
String baseDir = _request.getBaseDirectory();
Unzipper z = new Unzipper(baseDir);
byte[] zipBytes = _response.getZipBytes();
long checksum = 0;
// if byte exists in response
if (zipBytes != null) {
// render the zip bytes
checksum = z.writeZipBytes(zipBytes);
} else { // handle a re-direct
File tempZip = null;
// DAS and server instance are running on the same machine
// skips download and uses the zip directly
if (isSameHost()) {
String dasZipLoc = _response.getZipLocation();
tempZip = new File(dasZipLoc);
} else {
// download the zip file
tempZip = downloadZip();
}
// render the zip file
if (tempZip != null && tempZip.exists()) {
// ignore response entry for http based impl
z.ignoreEntry(ServletProcessor.RESPONSE_ENTRY_NAME);
checksum = z.writeZipFile(tempZip.getCanonicalPath());
}
}
// assert(_response.getChecksum() == checksum);
_logger.log(Level.FINE, "synchronization.check_sum", new Long(checksum).toString());
} catch (Exception e) {
String msg = _localStrMgr.getString("syncResponseError", _request.getMetaFileName());
throw new SynchronizationException(msg, e);
}
}
/**
* Returns true if DAS and remote server is running in the same machine. This allows to perform
* same host optimization during zip download.
*
* @return true if DAS and remote server runs on the same machine
*/
private boolean isSameHost() {
boolean tf = false;
String dasZipLoc = _response.getZipLocation();
File zip = new File(dasZipLoc);
// the zip file name after the time stamp exists in the remote
// server instance
if (zip.exists()) {
long dasLastModified = _response.getLastModifiedOfZip();
long localLastModified = zip.lastModified();
// last modified of zip is the same
if (dasLastModified == localLastModified) {
// host name of DAS
String dasHostName = _response.getDasHostName();
try {
InetAddress host = InetAddress.getLocalHost();
// host name of DAS is same is this server instance
if ((dasHostName != null) && (dasHostName.equals(host.getHostName()))) {
tf = true;
}
} catch (UnknownHostException uhe) {
// ignore
}
}
}
return tf;
}
/**
* Downloads the zip file from DAS.
*
* @return temporary location of the local zip file where zip is being down loaded
* @throws SynchronizationException if an error during zip download
* @throws IOException if an i/o error during zip download
*/
private File downloadZip() throws SynchronizationException, IOException {
File zipfile = null;
String dasZipLoc = _response.getZipLocation();
// zip size is too big to stream in byte array
// download the zip using chunking
if (dasZipLoc != null) {
// synchronization client to DAS
SynchronizationClientImpl sClient =
new SynchronizationClientImpl(SystemPropertyConstants.DEFAULT_SERVER_INSTANCE_NAME);
// temp file in the remote sever
zipfile = Utils.getTempZipFile();
// connects to DAS
sClient.connect();
// down loads the zip file
sClient.getAbsolute(dasZipLoc, zipfile);
// closes the connection to DAS
sClient.disconnect();
}
return zipfile;
}
/**
* Returns the name of this command.
*
* @return the name of this command
*/
public String getName() {
return NAME;
}
/** No-op. */
public Object getResult() {
return null;
}
// ---- VARIABLE(S) - PRIVATE -------------------------------
private SynchronizationRequest _request = null;
private SynchronizationResponse _response = null;
private static final String ZIP_SUFFIX = ".zip";
private static final String NAME = "Synchronization-Response-Process-Command";
}
public class PEFileLayout {
private static final StringManager _strMgr = StringManager.getManager(PEFileLayout.class);
public static final String DEFAULT_INSTANCE_NAME =
SystemPropertyConstants.DEFAULT_SERVER_INSTANCE_NAME;
/* above field is taken from a central place */
protected final RepositoryConfig _config;
public PEFileLayout(RepositoryConfig config) {
_config = config;
}
public void createRepositoryDirectories() throws RepositoryException {
createDirectory(getRepositoryRootDir());
createDirectory(getRepositoryDir());
createDirectory(getConfigRoot());
createDirectory(getBinDir());
createDirectory(getLogsDir());
createDirectory(getDocRoot());
createDirectory(getApplicationsRootDir());
createDirectory(getAutoDeployDir());
createDirectory(getAutoDeployStatusDir());
createDirectory(getAutoDeployOSGiBundlesDir());
createDirectory(getLibDir());
createDirectory(getClassesDir());
createDirectory(getExtLibDir());
createDirectory(getAppLibsDir());
createDirectory(getTimerDatabaseDir());
/*
createDirectory(getAddonRoot());
createDirectory(getJavaWebStartRoot());
createDirectory(getGeneratedDir());
createDirectory(getJspRootDir());
createDirectory(getEjbRootDir());
createDirectory(getXmlRootDir());
createDirectory(getJ2EEAppsDir());
createDirectory(getJ2EEModulesDir());
createDirectory(getLifecycleModulesDir());
createDirectory(getMbeansDir());
createDirectory(getSessionStore());
*/
}
protected RepositoryConfig getConfig() {
return _config;
}
public void createRepositoryRoot() throws RepositoryException {
createDirectory(getRepositoryRootDir());
}
public void createJBIDirectories() throws RepositoryException {
createDirectory(getJbiInstanceDir());
}
public void createJBIDomainDirectories() throws RepositoryException {
createJBIDirectories();
createDirectory(getJbiAuotoInstallDir());
createDirectory(getJbiConfigDir());
createDirectory(getJbiConfigPrivateDir());
createJbiSystemComponentsLayout();
}
protected void createDirectory(File dir) throws RepositoryException {
if (!dir.exists()) {
try {
if (!dir.mkdirs()) {
throw new RepositoryException(_strMgr.getString("directoryCreationError", dir));
}
} catch (Exception e) {
throw new RepositoryException(_strMgr.getString("directoryCreationError", dir), e);
}
}
}
public static final String ADDON_DIR = "addons";
public File getAddonRoot() {
return new File(getRepositoryDir(), ADDON_DIR);
}
public static final String CONFIG_DIR = "config";
public File getConfigRoot() {
return new File(getRepositoryDir(), CONFIG_DIR);
}
public static final String CONFIG_BACKUP_DIR = "backup";
public File getRepositoryBackupRoot() {
return new File(getConfigRoot(), CONFIG_BACKUP_DIR);
}
public static final String DOC_ROOT_DIR = "docroot";
public File getDocRoot() {
return new File(getRepositoryDir(), DOC_ROOT_DIR);
}
public static final String JAVA_WEB_START_DIR = "java-web-start";
public File getJavaWebStartRoot() {
return new File(getRepositoryDir(), JAVA_WEB_START_DIR);
}
public static final String LIB_DIR = "lib";
public File getLibDir() {
return new File(getRepositoryDir(), LIB_DIR);
}
public File getBinDir() {
return new File(getRepositoryDir(), BIN_DIR);
}
public static final String CLASSES_DIR = "classes";
public File getClassesDir() {
return new File(getLibDir(), CLASSES_DIR);
}
public static final String APPLIBS_DIR = "applibs";
public File getAppLibsDir() {
return new File(getLibDir(), APPLIBS_DIR);
}
public static final String EXTLIB_DIR = "ext";
public File getExtLibDir() {
return new File(getLibDir(), EXTLIB_DIR);
}
public static final String TIMERDB_DIR = "databases";
public File getTimerDatabaseDir() {
return new File(getLibDir(), TIMERDB_DIR);
}
public static final String LOGS_DIR = "logs";
public File getLogsDir() {
return new File(getRepositoryDir(), LOGS_DIR);
}
public static final String APPS_ROOT_DIR = "applications";
public File getApplicationsRootDir() {
return new File(getRepositoryDir(), APPS_ROOT_DIR);
}
public static final String J2EE_APPS_DIR = "j2ee-apps";
public File getJ2EEAppsDir() {
return new File(getApplicationsRootDir(), J2EE_APPS_DIR);
}
public static final String J2EE_MODULES_DIR = "j2ee-modules";
public File getJ2EEModulesDir() {
return new File(getApplicationsRootDir(), J2EE_MODULES_DIR);
}
public static final String LIFECYCLE_MODULES_DIR = "lifecycle-modules";
public File getLifecycleModulesDir() {
return new File(getApplicationsRootDir(), LIFECYCLE_MODULES_DIR);
}
public static final String MBEAN_FOLDER_NAME = "mbeans";
public File getMbeansDir() {
return new File(getApplicationsRootDir(), MBEAN_FOLDER_NAME);
}
public static final String GENERATED_DIR = "generated";
public File getGeneratedDir() {
return new File(getRepositoryDir(), GENERATED_DIR);
}
// Begin EE: 4946914 - cluster deployment support
public static final String POLICY_DIR = "policy";
public static final String POLICY_FILE_EXT = "granted.policy";
public File getPolicyDir() {
return new File(getGeneratedDir(), POLICY_DIR);
}
// End EE: 4946914 - cluster deployment support
public static final String JSP_DIR = "jsp";
public File getJspRootDir() {
return new File(getGeneratedDir(), JSP_DIR);
}
public static final String EJB_DIR = "ejb";
public File getEjbRootDir() {
return new File(getGeneratedDir(), EJB_DIR);
}
public static final String XML_DIR = "xml";
public File getXmlRootDir() {
return new File(getGeneratedDir(), XML_DIR);
}
public File getRepositoryDir() {
return new File(getRepositoryRootDir(), getConfig().getRepositoryName());
}
public static final String DOMAIN_XML_FILE = "domain.xml";
public File getDomainConfigFile() {
return new File(getConfigRoot(), DOMAIN_XML_FILE);
}
public File getDomainConfigBackupFile() {
return new File(getRepositoryBackupRoot(), DOMAIN_XML_FILE);
}
public static final String IMQ = "imq";
public File getImqDir() {
return new File(getInstallRootDir(), IMQ);
}
public static final String JBI_DIR = "jbi";
public File getJbiDir() {
return new File(getInstallRootDir(), JBI_DIR);
}
public static final String JBI_LIB_DIR = "lib";
public File getJbiLibDir() {
return new File(getJbiDir(), JBI_LIB_DIR);
}
public static final String JBI_LIB_INSTALL_DIR = "install";
public File getJbiLibInstallDir() {
return new File(getJbiLibDir(), JBI_LIB_INSTALL_DIR);
}
public static final String JBI_TEMPLATE_DIR = "templates";
public File getJbiTemplateDir() {
return new File(getJbiLibInstallDir(), JBI_TEMPLATE_DIR);
}
public static final String JBI_TEMPLATE_FILE = "jbi-registry.xml.template";
public File getJbiTemplateFile() {
return new File(getJbiTemplateDir(), JBI_TEMPLATE_FILE);
}
public static final String JBI_INSTANCE_DIR = "jbi";
public File getJbiInstanceDir() {
return new File(getRepositoryDir(), JBI_INSTANCE_DIR);
}
public static final String JBI_COMPONENTS_DIR = "components";
public File getJbiComponentsDir() {
return new File(getJbiInstanceDir(), JBI_COMPONENTS_DIR);
}
public static final String JAVAEE_SE_DIR = "sun-javaee-engine";
public File getJavaEESEDir() {
return new File(getJbiComponentsDir(), JAVAEE_SE_DIR);
}
public static final String HTTP_BC_DIR = "sun-http-binding";
public File getHttpBcDir() {
return new File(getJbiComponentsDir(), HTTP_BC_DIR);
}
public static final String JBI_COMPONENT_WS = "install_root" + File.separator + "workspace";
public File getJavaEESEWorkSpace() {
return new File(getJavaEESEDir(), JBI_COMPONENT_WS);
}
public File getHttpBcWorkSpace() {
return new File(getHttpBcDir(), JBI_COMPONENT_WS);
}
public static final String JBI_SHAREDLIB_DIR = "shared-libraries";
public File getJbiSharedLibDir() {
return new File(getJbiInstanceDir(), JBI_SHAREDLIB_DIR);
}
public static final String JBI_CONFIG_DIR = "config";
public File getJbiConfigDir() {
return new File(getJbiInstanceDir(), JBI_CONFIG_DIR);
}
public static final String JBI_AUTOINSTALL_DIR = "autoinstall";
public File getJbiAuotoInstallDir() {
return new File(getJbiInstanceDir(), JBI_AUTOINSTALL_DIR);
}
public static final String JBI_CONFIG_PRIVATE_DIR = "private";
public File getJbiConfigPrivateDir() {
return new File(getJbiConfigDir(), JBI_CONFIG_PRIVATE_DIR);
}
public static final String JBI_REGISTRY_FILE = "jbi-registry.xml";
public File getJbiRegistryFile() {
return new File(getJbiConfigDir(), JBI_REGISTRY_FILE);
}
public static final String HTTP_BC_CONFIG = "config.properties";
public File getHttpBcConfigTemplate() {
return new File(getJbiTemplateDir(), HTTP_BC_CONFIG);
}
public File getHttpBcConfigFile() {
return new File(getHttpBcWorkSpace(), HTTP_BC_CONFIG);
}
public static final String IMQ_VAR_DIR = "imq";
public File getImqVarHome() {
return new File(getRepositoryDir(), IMQ_VAR_DIR);
}
public static final String BIN_DIR = "bin";
public File getImqBinDir() {
return new File(getImqDir(), BIN_DIR);
}
public File getImqLibDir() {
return new File(getImqDir(), LIB_DIR);
}
public File getInstallRootDir() {
return getCanonicalFile(new File(getConfig().getInstallRoot()));
}
public File getRepositoryRootDir() {
return getCanonicalFile(new File(getConfig().getRepositoryRoot()));
}
public static final String SHARE = "share";
public File getShareDir() {
return new File(getInstallRootDir(), SHARE);
}
public File getWebServicesLibDir() {
return new File(getShareDir(), LIB_DIR);
}
// $INSTALL_ROOT/lib/install/templates
public static final String INSTALL_DIR = "install";
public static final String TEMPLATES_DIR = "templates";
public static final String COMMON_DIR = "common";
public static final String PROFILE_PROPERTIES = "profile.properties";
private static final String TEMPLATE_CONFIG_XML = "default-config.xml";
public File getTemplatesDir() {
final File lib = new File(getInstallRootDir(), LIB_DIR);
// final File install = new File(lib, INSTALL_DIR);
final File templates = new File(lib, TEMPLATES_DIR);
return templates;
}
public File getProfileFolder(final String profileName) {
/* Commented out for V3, till things can be more finalized. For
* now there is only one profile and the template is in the
* common template directory */
assert profileName != null : "Name of the profile can't be null";
final File pf = new File(getTemplatesDir(), profileName);
return pf;
}
public File getProfilePropertiesFile(final String profileName) {
return (new File(getProfileFolder(profileName), PROFILE_PROPERTIES));
}
public File getPreExistingDomainXmlTemplateForProfile(final String profileName) {
return (new File(getProfileFolder(profileName), DOMAIN_XML_FILE));
}
public File getTemplateConfigXml() {
return (new File(getTemplatesDir(), TEMPLATE_CONFIG_XML));
}
// $INSTALL_ROOT/lib/install/applications
public static final String APPLICATIONS_DIR = "applications";
public File getInstallApplicationsDir() {
final File lib = new File(getInstallRootDir(), LIB_DIR);
final File install = new File(lib, INSTALL_DIR);
return new File(install, APPLICATIONS_DIR);
}
// $INSTALL_ROOT/lib/install/databases
public static final String DATABASES_DIR = "databases";
public File getInstallDatabasesDir() {
final File lib = new File(getInstallRootDir(), LIB_DIR);
final File install = new File(lib, INSTALL_DIR);
return new File(install, DATABASES_DIR);
}
// $INSTALL_ROOT/lib/dtds
public static final String DTDS_DIR = "dtds";
public File getDtdsDir() {
final File lib = new File(getInstallRootDir(), LIB_DIR);
return new File(lib, DTDS_DIR);
}
// $INSTALL_ROOT/lib/dtds
public static final String DOMAIN_DTD = "sun-domain_1_3.dtd";
public File getDtdFile() {
return new File(getDtdsDir(), DOMAIN_DTD);
}
public static final String DOMAIN_XML_TEMPLATE = "default-domain.xml.template";
public File getDomainXmlTemplate() {
return new File(getTemplatesDir(), DOMAIN_XML_TEMPLATE);
}
public File getDomainXmlTemplate(String templateName) {
// check to see if the user has specified a template file to be used for
// domain creation. Assumed that the user specified template file
// exists in the INSTALL_ROOT/lib/install/templates if path is not absolute.
if (new File(templateName).isAbsolute()) return new File(templateName);
else return new File(getTemplatesDir(), templateName);
}
public static final String IMQBROKERD_UNIX = "imqbrokerd";
public static final String IMQBROKERD_WIN = "imqbrokerd.exe";
public static final String IMQBROKERD = isWindows() ? IMQBROKERD_WIN : IMQBROKERD_UNIX;
public File getImqBrokerExecutable() {
return new File(getImqBinDir(), IMQBROKERD);
}
public static final String START_SERV_UNIX = "startserv";
public static final String START_SERV_WIN = "startserv.bat";
public static final String START_SERV_OS = isWindows() ? START_SERV_WIN : START_SERV_UNIX;
public File getStartServ() {
return new File(getBinDir(), START_SERV_OS);
}
public static final String START_SERV_TEMPLATE_UNIX = "startserv.tomcat.template";
public static final String START_SERV_TEMPLATE_WIN = "startserv.tomcat.bat.template";
public static final String START_SERV_TEMPLATE_OS =
isWindows() ? START_SERV_TEMPLATE_WIN : START_SERV_TEMPLATE_UNIX;
public File getStartServTemplate() {
return new File(getTemplatesDir(), START_SERV_TEMPLATE_OS);
}
public static final String STOP_SERV_UNIX = "stopserv";
public static final String STOP_SERV_WIN = "stopserv.bat";
public static final String STOP_SERV_OS = isWindows() ? STOP_SERV_WIN : STOP_SERV_UNIX;
public File getStopServ() {
return new File(getBinDir(), STOP_SERV_OS);
}
public static final String KILL_SERV_UNIX = "killserv";
public static final String KILL_SERV_WIN = "killserv.bat";
public static final String KILL_SERV_OS = isWindows() ? KILL_SERV_WIN : KILL_SERV_UNIX;
public File getKillServ() {
return new File(getBinDir(), KILL_SERV_OS);
}
public File getKillServTemplate() {
return new File(getTemplatesDir(), KILL_SERV_OS);
}
public static final String STOP_SERV_TEMPLATE_UNIX = "stopserv.tomcat.template";
public static final String STOP_SERV_TEMPLATE_WIN = "stopserv.tomcat.bat.template";
public static final String STOP_SERV_TEMPLATE_OS =
isWindows() ? STOP_SERV_TEMPLATE_WIN : STOP_SERV_TEMPLATE_UNIX;
public File getStopServTemplate() {
return new File(getTemplatesDir(), STOP_SERV_TEMPLATE_OS);
}
public static final String POLICY_FILE = "server.policy";
public File getPolicyFileTemplate() {
return new File(getTemplatesDir(), POLICY_FILE);
}
public File getPolicyFile() {
return new File(getConfigRoot(), POLICY_FILE);
}
public static final String STUB_FILE = "admch";
public File getStubFile() {
return new File(getConfigRoot(), STUB_FILE);
}
public static final String SEED_FILE = "admsn";
public File getSeedFile() {
return new File(getConfigRoot(), SEED_FILE);
}
public File getInstallConfigRoot() {
return new File(getInstallRootDir(), CONFIG_DIR);
}
public static final String ACC_XML_TEMPLATE = "sun-acc.xml";
public File getAppClientContainerXmlTemplate() {
return new File(getTemplatesDir(), ACC_XML_TEMPLATE);
}
public static final String ACC_XML = "sun-acc.xml";
public File getAppClientContainerXml() {
return new File(getConfigRoot(), ACC_XML);
}
public static final String SESSION_STORE = "session-store";
public File getSessionStore() {
return new File(getRepositoryDir(), SESSION_STORE);
}
public static final String AUTO_DEPLOY = "autodeploy";
public File getAutoDeployDir() {
return new File(getRepositoryDir(), AUTO_DEPLOY);
}
public static final String AUTO_DEPLOY_STATUS = ".autodeploystatus";
public File getAutoDeployStatusDir() {
return new File(getAutoDeployDir(), AUTO_DEPLOY_STATUS);
}
private static final String AUTO_DEPLOY_OSGI_BUNDLES_DIR = "bundles";
private File getAutoDeployOSGiBundlesDir() {
return new File(getAutoDeployDir(), AUTO_DEPLOY_OSGI_BUNDLES_DIR);
}
public static final String KEY_FILE_TEMPLATE = "keyfile";
public File getKeyFileTemplate() {
return new File(getTemplatesDir(), KEY_FILE_TEMPLATE);
}
public static final String KEY_FILE = "keyfile";
public File getKeyFile() {
return new File(getConfigRoot(), KEY_FILE);
}
public static final String ADMIN_KEY_FILE = "admin-keyfile";
public File getAdminKeyFile() {
return new File(getConfigRoot(), ADMIN_KEY_FILE);
}
public File getBackupKeyFile() {
return new File(getRepositoryBackupRoot(), KEY_FILE);
}
public static final String INDEX_FILE = "index.html";
public static final String DOC_ROOT = "docroot";
public File getIndexFileTemplate() {
final File docRoot = new File(getTemplatesDir(), DOC_ROOT);
return new File(docRoot, INDEX_FILE);
}
private static final String LOCALES = "locales";
public File getNonEnglishIndexFileTemplate(Locale locale) {
File locales = new File(getTemplatesDir(), LOCALES);
File givenLocale = new File(locales, locale.toString());
return new File(givenLocale, INDEX_FILE);
}
public File getIndexFile() {
return new File(getDocRoot(), INDEX_FILE);
}
private static final String ENGLISH_INDEX_FILE = "index_en.html";
public File getEnglishIndexFile() {
return new File(getDocRoot(), ENGLISH_INDEX_FILE);
}
public static final String DEFAULT_WEB_XML = "default-web.xml";
public File getDefaultWebXmlTemplate() {
return new File(getTemplatesDir(), DEFAULT_WEB_XML);
}
public File getDefaultWebXml() {
return new File(getConfigRoot(), DEFAULT_WEB_XML);
}
public static final String LOGGING_PROPERTIES_FILE = "logging.properties";
public File getLoggingPropertiesTemplate() {
return new File(getTemplatesDir(), LOGGING_PROPERTIES_FILE);
}
public File getLoggingProperties() {
return new File(getConfigRoot(), LOGGING_PROPERTIES_FILE);
}
public static final String LOGIN_CONF = "login.conf";
public File getLoginConfTemplate() {
return new File(getTemplatesDir(), LOGIN_CONF);
}
public File getLoginConf() {
return new File(getConfigRoot(), LOGIN_CONF);
}
public static final String WSSSERVERCONFIGOLD = "wss-server-config-1.0.xml";
public File getWssServerConfigOldTemplate() {
return new File(getTemplatesDir(), WSSSERVERCONFIGOLD);
}
public File getWssServerConfigOld() {
return new File(getConfigRoot(), WSSSERVERCONFIGOLD);
}
public static final String WSSSERVERCONFIG = "wss-server-config-2.0.xml";
public File getWssServerConfigTemplate() {
return new File(getTemplatesDir(), WSSSERVERCONFIG);
}
public File getWssServerConfig() {
return new File(getConfigRoot(), WSSSERVERCONFIG);
}
public static final String KEYSTORE = "keystore.jks";
public File getKeyStore() {
return new File(getConfigRoot(), KEYSTORE);
}
public static final String TRUSTSTORE_TEMPLATE = "cacerts.jks";
public File getTrustStoreTemplate() {
return new File(getTemplatesDir(), TRUSTSTORE_TEMPLATE);
}
/**
* Should be used only in the cases where the actual keystore creation fails. The idea is when we
* are unable to create the JKS-keystore, we should copy the keystore in templates folder into the
* domain's config folder. This keystore is by no means a keystore for public use. It's just a
* keystore with a primary key "changeit" and associated certificate with signature:
* -------------------------------------------------------------- Keystore type: jks Keystore
* provider: SUN
*
* <p>Your keystore contains 1 entry
*
* <p>Alias name: s1as Creation date: Sep 11, 2008 Entry type: keyEntry Certificate chain length:
* 1 Certificate[1]: Owner: CN=localhost, OU=GlassFish, O=Sun Microsystems, L=Santa Clara,
* ST=California, C=US Issuer: CN=localhost, OU=GlassFish, O=Sun Microsystems, L=Santa Clara,
* ST=California, C=US Serial number: 48c9e075 Valid from: Thu Sep 11 20:22:29 PDT 2008 until: Sun
* Sep 09 20:22:29 PDT 2018 Certificate fingerprints: MD5:
* 00:E5:5D:1F:07:CC:99:9F:CF:68:0E:AD:29:43:E0:48 SHA1:
* 1B:62:3E:B2:3D:D7:0B:63:80:92:EE:9A:59:F7:D5:9F:97:A3:FD:98
* --------------------------------------------------------------
*
* @return File representing the keystore path. Does not check if the path actually exists.
*/
public File getKeyStoreTemplate() {
return new File(getTemplatesDir(), KEYSTORE);
}
public static final String TRUSTSTORE = "cacerts.jks";
public File getTrustStore() {
return new File(getConfigRoot(), TRUSTSTORE);
}
public static final String MASTERPASSWORD_FILE = "master-password";
public File getMasterPasswordFile() {
return new File(getRepositoryDir(), MASTERPASSWORD_FILE);
}
public static final String PASSWORD_ALIAS_KEYSTORE = PasswordAdapter.PASSWORD_ALIAS_KEYSTORE;
public File getPasswordAliasKeystore() {
return new File(getConfigRoot(), PASSWORD_ALIAS_KEYSTORE);
}
public static final String TIMERDB_WAL_TEMPLATE = "ejbtimer$1.wal";
public File getTimerWalTemplate() {
return new File(getInstallDatabasesDir(), TIMERDB_WAL_TEMPLATE);
}
public static final String TIMERDB_WAL = "ejbtimer$1.wal";
public File getTimerWal() {
return new File(getTimerDatabaseDir(), TIMERDB_WAL);
}
public static final String TIMERDB_DBN_TEMPLATE = "ejbtimer.dbn";
public File getTimerDbnTemplate() {
return new File(getInstallDatabasesDir(), TIMERDB_DBN_TEMPLATE);
}
public static final String TIMERDB_DBN = "ejbtimer.dbn";
public File getTimerDbn() {
return new File(getTimerDatabaseDir(), TIMERDB_DBN);
}
public static final String DERBY_SQL_FILE = "ejbtimer_derby.sql";
public static final String EJB_TIMER_TABLE_NAME = "EJB__TIMER__TBL"; // comes from sql file
public File getDerbyEjbTimerSqlFile() {
return new File(getInstallDatabasesDir(), DERBY_SQL_FILE);
}
public static final String DERBY_DATABASE_DIRECTORY = "ejbtimer";
public File getDerbyEjbTimerDatabaseDirectory() {
return new File(getTimerDatabaseDir(), DERBY_DATABASE_DIRECTORY);
// this directory must not exist before creating the derby database
}
protected static boolean isWindows() {
return OS.isWindows();
}
File getCanonicalFile(File f) {
return FileUtils.safeGetCanonicalFile(f);
}
/**
* This method is used to create the file layout for JBI system components, HttpSoapBC, JavaEESE,
* WSDLSL
*/
public void createJbiSystemComponentsLayout() throws RepositoryException {
try {
createDirectory(getHttpBcDir());
createDirectory(getHttpBcInstallRoot());
createDirectory(getJavaEESEDir());
createDirectory(getJavaEESEInstallRoot());
createDirectory(getWSDLSLDir());
createDirectory(getWSDLSLInstallRoot());
createDirectory(getHttpBcWorkSpace());
createDirectory(getJavaEESEWorkSpace());
} catch (Exception e) {
throw new RepositoryException(e);
}
}
/** This method is used to create WSDLSL install root */
public void createWSDLSLInstallRoot() throws Exception {
createDirectory(getWSDLSLDir());
createDirectory(getWSDLSLInstallRoot());
}
public static final String JBI_COMPONENTS = "components";
public File getJbiComponents() {
return new File(getJbiDir(), JBI_COMPONENTS);
}
public static final String HTTP_BC_ARCHIVE = "httpbc.jar";
public File getHttpBcArchiveSource() {
File bcDir = new File(getJbiComponents(), HTTP_BC_DIR);
return new File(bcDir, HTTP_BC_ARCHIVE);
}
public File getHttpBcArchiveDestination() {
return new File(getHttpBcDir(), HTTP_BC_ARCHIVE);
}
public static final String JBI_COMPONENTS_INSTALL_ROOT = "install_root";
public File getHttpBcInstallRoot() {
return new File(getHttpBcDir(), JBI_COMPONENTS_INSTALL_ROOT);
}
public static final String JAVAEE_SE_ARCHIVE = "appserv-jbise.jar";
public File getJavaEESEArchiveSource() {
File seDir = new File(getJbiComponents(), JAVAEE_SE_DIR);
return new File(seDir, JAVAEE_SE_ARCHIVE);
}
public File getJavaEESEArchiveDestination() {
return new File(getJavaEESEDir(), JAVAEE_SE_ARCHIVE);
}
public File getJavaEESEInstallRoot() {
return new File(getJavaEESEDir(), JBI_COMPONENTS_INSTALL_ROOT);
}
public static final String JBI_SHARED_LIBRARIES = "shared-libraries";
public File getJbiSharedLibraries() {
return new File(getJbiDir(), JBI_SHARED_LIBRARIES);
}
public static final String WSDLSL_DIR = "sun-wsdl-library";
public File getWSDLSLDir() {
return new File(getJbiSharedLibDir(), WSDLSL_DIR);
}
public static final String WSDLSL_ARCHIVE = "wsdlsl.jar";
public File getWSDLSLArchiveSource() {
File slDir = new File(getJbiSharedLibraries(), WSDLSL_DIR);
return new File(slDir, WSDLSL_ARCHIVE);
}
public File getWSDLSLArchiveDestination() {
return new File(getWSDLSLDir(), WSDLSL_ARCHIVE);
}
public File getWSDLSLInstallRoot() {
return new File(getWSDLSLDir(), JBI_COMPONENTS_INSTALL_ROOT);
}
}
@Service
@ResourceDeployerInfo(JdbcConnectionPool.class)
@Singleton
public class JdbcConnectionPoolDeployer implements ResourceDeployer {
@Inject private ConnectorRuntime runtime;
@Inject @Optional // we need it only in server mode
private Domain domain;
private static StringManager sm = StringManager.getManager(JdbcConnectionPoolDeployer.class);
private static String msg = sm.getString("resource.restart_needed");
private static Logger _logger = LoggerFactory.getLogger(JdbcConnectionPoolDeployer.class);
private static final Locale locale = Locale.getDefault();
private ExecutorService execService =
Executors.newSingleThreadExecutor(
new ThreadFactory() {
@Override
public Thread newThread(Runnable r) {
return new Thread(r);
}
});
/** {@inheritDoc} */
@Override
public void deployResource(Object resource, String applicationName, String moduleName)
throws Exception {
// deployResource is not synchronized as there is only one caller
// ResourceProxy which is synchronized
// intentional no-op
// From 8.1 PE/SE/EE, JDBC connection pools are no more resources and
// they would be available only to server instances that have a resoruce-ref
// that maps to a pool. So deploy resource would not be called during
// JDBC connection pool creation. The actualDeployResource method
// below is invoked by JdbcResourceDeployer when a resource-ref for a
// resource that is pointed to this pool is added to a server instance
JdbcConnectionPool jcp = (JdbcConnectionPool) resource;
PoolInfo poolInfo = new PoolInfo(jcp.getName(), applicationName, moduleName);
if (_logger.isLoggable(Level.FINE)) {
_logger.fine(
" JdbcConnectionPoolDeployer - deployResource : " + poolInfo + " calling actualDeploy");
}
actualDeployResource(resource, poolInfo);
}
/** {@inheritDoc} */
@Override
public void deployResource(Object resource) throws Exception {
JdbcConnectionPool jcp = (JdbcConnectionPool) resource;
PoolInfo poolInfo = ConnectorsUtil.getPoolInfo(jcp);
actualDeployResource(resource, poolInfo);
}
/** {@inheritDoc} */
@Override
public boolean canDeploy(
boolean postApplicationDeployment, Collection<Resource> allResources, Resource resource) {
if (handles(resource)) {
if (!postApplicationDeployment) {
return true;
}
}
return false;
}
/**
* Deploy the resource into the server's runtime naming context
*
* @param resource a resource object
* @throws Exception thrown if fail
*/
public void actualDeployResource(Object resource, PoolInfo poolInfo) {
if (_logger.isLoggable(Level.FINE)) {
_logger.fine(" JdbcConnectionPoolDeployer - actualDeployResource : " + poolInfo);
}
JdbcConnectionPool adminPool = (JdbcConnectionPool) resource;
try {
ConnectorConnectionPool connConnPool = createConnectorConnectionPool(adminPool, poolInfo);
registerTransparentDynamicReconfigPool(poolInfo, adminPool);
// now do internal book keeping
runtime.createConnectorConnectionPool(connConnPool);
} catch (Exception e) {
Object params[] = new Object[] {poolInfo, e};
_logger.log(Level.WARNING, "error.creating.jdbc.pool", params);
}
}
// performance issue related fix : IT 15784
private void registerTransparentDynamicReconfigPool(
PoolInfo poolInfo, JdbcConnectionPool resourcePool) {
ConnectorRegistry registry = ConnectorRegistry.getInstance();
if (ConnectorsUtil.isDynamicReconfigurationEnabled(resourcePool)) {
registry.addTransparentDynamicReconfigPool(poolInfo);
} else {
registry.removeTransparentDynamicReconfigPool(poolInfo);
}
}
/** {@inheritDoc} */
@Override
public void undeployResource(Object resource, String applicationName, String moduleName)
throws Exception {
JdbcConnectionPool jdbcConnPool = (JdbcConnectionPool) resource;
PoolInfo poolInfo = new PoolInfo(jdbcConnPool.getName(), applicationName, moduleName);
if (_logger.isLoggable(Level.FINE)) {
_logger.fine(
" JdbcConnectionPoolDeployer - unDeployResource : "
+ "calling actualUndeploy of "
+ poolInfo);
}
actualUndeployResource(poolInfo);
}
/** {@inheritDoc} */
@Override
public synchronized void undeployResource(Object resource) throws Exception {
JdbcConnectionPool jdbcConnPool = (JdbcConnectionPool) resource;
PoolInfo poolInfo = ConnectorsUtil.getPoolInfo(jdbcConnPool);
if (_logger.isLoggable(Level.FINE)) {
_logger.fine(
" JdbcConnectionPoolDeployer - unDeployResource : "
+ "calling actualUndeploy of "
+ poolInfo);
}
actualUndeployResource(poolInfo);
}
/** {@inheritDoc} */
@Override
public boolean handles(Object resource) {
return resource instanceof JdbcConnectionPool;
}
/** @inheritDoc */
@Override
public boolean supportsDynamicReconfiguration() {
return true;
}
/** @inheritDoc */
@Override
public Class[] getProxyClassesForDynamicReconfiguration() {
return new Class[] {com.sun.appserv.jdbc.DataSource.class};
}
/**
* Undeploy the resource from the server's runtime naming context
*
* @param poolInfo a resource object
* @throws UnsupportedOperationException Currently we are not supporting this method.
*/
private synchronized void actualUndeployResource(PoolInfo poolInfo) throws Exception {
runtime.deleteConnectorConnectionPool(poolInfo);
// performance issue related fix : IT 15784
ConnectorRegistry.getInstance().removeTransparentDynamicReconfigPool(poolInfo);
if (_logger.isLoggable(Level.FINEST)) {
_logger.finest("Pool Undeployed");
}
}
/**
* Pull out the MCF configuration properties and return them as an array of
* ConnectorConfigProperty
*
* @param adminPool - The JdbcConnectionPool to pull out properties from
* @param conConnPool - ConnectorConnectionPool which will be used by Resource Pool
* @param connDesc - The ConnectorDescriptor for this JDBC RA
* @return ConnectorConfigProperty [] array of MCF Config properties specified in this JDBC RA
*/
private ConnectorConfigProperty[] getMCFConfigProperties(
JdbcConnectionPool adminPool,
ConnectorConnectionPool conConnPool,
ConnectorDescriptor connDesc) {
ArrayList propList = new ArrayList();
if (adminPool.getResType() != null) {
if (ConnectorConstants.JAVA_SQL_DRIVER.equals(adminPool.getResType())) {
propList.add(
new ConnectorConfigProperty(
"ClassName",
adminPool.getDriverClassname() == null ? "" : adminPool.getDriverClassname(),
"The driver class name",
"java.lang.String"));
} else {
propList.add(
new ConnectorConfigProperty(
"ClassName",
adminPool.getDatasourceClassname() == null
? ""
: adminPool.getDatasourceClassname(),
"The datasource class name",
"java.lang.String"));
}
} else {
// When resType is null, one of these classnames would be specified
if (adminPool.getDriverClassname() != null) {
propList.add(
new ConnectorConfigProperty(
"ClassName",
adminPool.getDriverClassname() == null ? "" : adminPool.getDriverClassname(),
"The driver class name",
"java.lang.String"));
} else if (adminPool.getDatasourceClassname() != null) {
propList.add(
new ConnectorConfigProperty(
"ClassName",
adminPool.getDatasourceClassname() == null
? ""
: adminPool.getDatasourceClassname(),
"The datasource class name",
"java.lang.String"));
}
}
propList.add(
new ConnectorConfigProperty(
"ConnectionValidationRequired",
adminPool.getIsConnectionValidationRequired() + "",
"Is connection validation required",
"java.lang.String"));
propList.add(
new ConnectorConfigProperty(
"ValidationMethod",
adminPool.getConnectionValidationMethod() == null
? ""
: adminPool.getConnectionValidationMethod(),
"How the connection is validated",
"java.lang.String"));
propList.add(
new ConnectorConfigProperty(
"ValidationTableName",
adminPool.getValidationTableName() == null ? "" : adminPool.getValidationTableName(),
"Validation Table name",
"java.lang.String"));
propList.add(
new ConnectorConfigProperty(
"ValidationClassName",
adminPool.getValidationClassname() == null ? "" : adminPool.getValidationClassname(),
"Validation Class name",
"java.lang.String"));
propList.add(
new ConnectorConfigProperty(
"TransactionIsolation",
adminPool.getTransactionIsolationLevel() == null
? ""
: adminPool.getTransactionIsolationLevel(),
"Transaction Isolatin Level",
"java.lang.String"));
propList.add(
new ConnectorConfigProperty(
"GuaranteeIsolationLevel",
adminPool.getIsIsolationLevelGuaranteed() + "",
"Transaction Isolation Guarantee",
"java.lang.String"));
propList.add(
new ConnectorConfigProperty(
"StatementWrapping",
adminPool.getWrapJdbcObjects() + "",
"Statement Wrapping",
"java.lang.String"));
propList.add(
new ConnectorConfigProperty(
"LogJdbcCalls",
adminPool.getLogJdbcCalls() + "",
"Log JDBC Calls",
"java.lang.String"));
propList.add(
new ConnectorConfigProperty(
"SlowQueryThresholdInSeconds",
adminPool.getSlowQueryThresholdInSeconds() + "",
"Slow Query Threshold In Seconds",
"java.lang.String"));
propList.add(
new ConnectorConfigProperty(
"StatementTimeout",
adminPool.getStatementTimeoutInSeconds() + "",
"Statement Timeout",
"java.lang.String"));
PoolInfo poolInfo = conConnPool.getPoolInfo();
propList.add(
new ConnectorConfigProperty(
"PoolMonitoringSubTreeRoot",
ConnectorsUtil.getPoolMonitoringSubTreeRoot(poolInfo, true) + "",
"Pool Monitoring Sub Tree Root",
"java.lang.String"));
propList.add(
new ConnectorConfigProperty(
"PoolName", poolInfo.getName() + "", "Pool Name", "java.lang.String"));
if (poolInfo.getApplicationName() != null) {
propList.add(
new ConnectorConfigProperty(
"ApplicationName",
poolInfo.getApplicationName() + "",
"Application Name",
"java.lang.String"));
}
if (poolInfo.getModuleName() != null) {
propList.add(
new ConnectorConfigProperty(
"ModuleName", poolInfo.getModuleName() + "", "Module name", "java.lang.String"));
}
propList.add(
new ConnectorConfigProperty(
"StatementCacheSize",
adminPool.getStatementCacheSize() + "",
"Statement Cache Size",
"java.lang.String"));
propList.add(
new ConnectorConfigProperty(
"StatementCacheType",
adminPool.getStatementCacheType() + "",
"Statement Cache Type",
"java.lang.String"));
propList.add(
new ConnectorConfigProperty(
"InitSql", adminPool.getInitSql() + "", "InitSql", "java.lang.String"));
propList.add(
new ConnectorConfigProperty(
"SqlTraceListeners",
adminPool.getSqlTraceListeners() + "",
"Sql Trace Listeners",
"java.lang.String"));
propList.add(
new ConnectorConfigProperty(
"StatementLeakTimeoutInSeconds",
adminPool.getStatementLeakTimeoutInSeconds() + "",
"Statement Leak Timeout in seconds",
"java.lang.String"));
propList.add(
new ConnectorConfigProperty(
"StatementLeakReclaim",
adminPool.getStatementLeakReclaim() + "",
"Statement Leak Reclaim",
"java.lang.String"));
// dump user defined poperties into the list
Set connDefDescSet = connDesc.getOutboundResourceAdapter().getConnectionDefs();
// since this a 1.0 RAR, we will have only 1 connDefDesc
if (connDefDescSet.size() != 1) {
throw new MissingResourceException("Only one connDefDesc present", null, null);
}
Iterator iter = connDefDescSet.iterator();
// Now get the set of MCF config properties associated with each
// connection-definition . Each element here is an EnviromnentProperty
Set mcfConfigProps = null;
while (iter.hasNext()) {
mcfConfigProps = ((ConnectionDefDescriptor) iter.next()).getConfigProperties();
}
if (mcfConfigProps != null) {
Map mcfConPropKeys = new HashMap();
Iterator mcfConfigPropsIter = mcfConfigProps.iterator();
while (mcfConfigPropsIter.hasNext()) {
String key = ((ConnectorConfigProperty) mcfConfigPropsIter.next()).getName();
mcfConPropKeys.put(key.toUpperCase(locale), key);
}
String driverProperties = "";
for (Property rp : adminPool.getProperty()) {
if (rp == null) {
continue;
}
String name = rp.getName();
// The idea here is to convert the Environment Properties coming from
// the admin connection pool to standard pool properties thereby
// making it easy to compare in the event of a reconfig
if ("MATCHCONNECTIONS".equals(name.toUpperCase(locale))) {
// JDBC - matchConnections if not set is decided by the ConnectionManager
// so default is false
conConnPool.setMatchConnections(toBoolean(rp.getValue(), false));
logFine("MATCHCONNECTIONS");
} else if ("ASSOCIATEWITHTHREAD".equals(name.toUpperCase(locale))) {
conConnPool.setAssociateWithThread(toBoolean(rp.getValue(), false));
logFine("ASSOCIATEWITHTHREAD");
} else if ("LAZYCONNECTIONASSOCIATION".equals(name.toUpperCase(locale))) {
ConnectionPoolObjectsUtils.setLazyEnlistAndLazyAssocProperties(
rp.getValue(), adminPool.getProperty(), conConnPool);
logFine("LAZYCONNECTIONASSOCIATION");
} else if ("LAZYCONNECTIONENLISTMENT".equals(name.toUpperCase(Locale.getDefault()))) {
conConnPool.setLazyConnectionEnlist(toBoolean(rp.getValue(), false));
logFine("LAZYCONNECTIONENLISTMENT");
} else if ("POOLDATASTRUCTURE".equals(name.toUpperCase(Locale.getDefault()))) {
conConnPool.setPoolDataStructureType(rp.getValue());
logFine("POOLDATASTRUCTURE");
} else if (ConnectorConstants.DYNAMIC_RECONFIGURATION_FLAG.equals(
name.toLowerCase(locale))) {
String value = rp.getValue();
try {
conConnPool.setDynamicReconfigWaitTimeout(Long.parseLong(rp.getValue()) * 1000L);
logFine(ConnectorConstants.DYNAMIC_RECONFIGURATION_FLAG);
} catch (NumberFormatException nfe) {
_logger.log(
Level.WARNING,
"Invalid value for "
+ "'"
+ ConnectorConstants.DYNAMIC_RECONFIGURATION_FLAG
+ "' : "
+ value);
}
} else if ("POOLWAITQUEUE".equals(name.toUpperCase(locale))) {
conConnPool.setPoolWaitQueue(rp.getValue());
logFine("POOLWAITQUEUE");
} else if ("DATASTRUCTUREPARAMETERS".equals(name.toUpperCase(locale))) {
conConnPool.setDataStructureParameters(rp.getValue());
logFine("DATASTRUCTUREPARAMETERS");
} else if ("USERNAME".equals(name.toUpperCase(Locale.getDefault()))
|| "USER".equals(name.toUpperCase(locale))) {
propList.add(
new ConnectorConfigProperty("User", rp.getValue(), "user name", "java.lang.String"));
} else if ("PASSWORD".equals(name.toUpperCase(locale))) {
propList.add(
new ConnectorConfigProperty(
"Password", rp.getValue(), "Password", "java.lang.String"));
} else if ("JDBC30DATASOURCE".equals(name.toUpperCase(locale))) {
propList.add(
new ConnectorConfigProperty(
"JDBC30DataSource", rp.getValue(), "JDBC30DataSource", "java.lang.String"));
} else if ("PREFER-VALIDATE-OVER-RECREATE".equals(name.toUpperCase(Locale.getDefault()))) {
String value = rp.getValue();
conConnPool.setPreferValidateOverRecreate(toBoolean(value, false));
logFine("PREFER-VALIDATE-OVER-RECREATE : " + value);
} else if ("STATEMENT-CACHE-TYPE".equals(name.toUpperCase(Locale.getDefault()))) {
if (adminPool.getStatementCacheType() != null) {
propList.add(
new ConnectorConfigProperty(
"StatementCacheType", rp.getValue(), "StatementCacheType", "java.lang.String"));
}
} else if ("NUMBER-OF-TOP-QUERIES-TO-REPORT"
.equals(name.toUpperCase(Locale.getDefault()))) {
propList.add(
new ConnectorConfigProperty(
"NumberOfTopQueriesToReport",
rp.getValue(),
"NumberOfTopQueriesToReport",
"java.lang.String"));
} else if ("TIME-TO-KEEP-QUERIES-IN-MINUTES"
.equals(name.toUpperCase(Locale.getDefault()))) {
propList.add(
new ConnectorConfigProperty(
"TimeToKeepQueriesInMinutes",
rp.getValue(),
"TimeToKeepQueriesInMinutes",
"java.lang.String"));
} else if (mcfConPropKeys.containsKey(name.toUpperCase(Locale.getDefault()))) {
propList.add(
new ConnectorConfigProperty(
(String) mcfConPropKeys.get(name.toUpperCase(Locale.getDefault())),
rp.getValue() == null ? "" : rp.getValue(),
"Some property",
"java.lang.String"));
} else {
driverProperties =
driverProperties + "set" + escape(name) + "#" + escape(rp.getValue()) + "##";
}
}
if (!driverProperties.equals("")) {
propList.add(
new ConnectorConfigProperty(
"DriverProperties",
driverProperties,
"some proprietarty properties",
"java.lang.String"));
}
}
propList.add(new ConnectorConfigProperty("Delimiter", "#", "delim", "java.lang.String"));
propList.add(
new ConnectorConfigProperty(
"EscapeCharacter", "\\", "escapeCharacter", "java.lang.String"));
// create an array of EnvironmentProperties from above list
ConnectorConfigProperty[] eProps = new ConnectorConfigProperty[propList.size()];
ListIterator propListIter = propList.listIterator();
for (int i = 0; propListIter.hasNext(); i++) {
eProps[i] = (ConnectorConfigProperty) propListIter.next();
}
return eProps;
}
/**
* To escape the "delimiter" characters that are internally used by Connector & JDBCRA.
*
* @param value String that need to be escaped
* @return Escaped value
*/
private String escape(String value) {
CharSequence seq = "\\";
CharSequence replacement = "\\\\";
value = value.replace(seq, replacement);
seq = "#";
replacement = "\\#";
value = value.replace(seq, replacement);
return value;
}
private boolean toBoolean(Object prop, boolean defaultVal) {
if (prop == null) {
return defaultVal;
}
return Boolean.valueOf(((String) prop).toLowerCase(locale));
}
/**
* Use this method if the string being passed does not <br>
* involve multiple concatenations<br>
* Avoid using this method in exception-catch blocks as they are not frequently executed <br>
*
* @param msg
*/
private void logFine(String msg) {
if (_logger.isLoggable(Level.FINE) && msg != null) {
_logger.fine(msg);
}
}
public ConnectorConnectionPool createConnectorConnectionPool(
JdbcConnectionPool adminPool, PoolInfo poolInfo) throws ConnectorRuntimeException {
String moduleName = JdbcResourcesUtil.createInstance().getRANameofJdbcConnectionPool(adminPool);
int txSupport = getTxSupport(moduleName);
ConnectorDescriptor connDesc = runtime.getConnectorDescriptor(moduleName);
// Create the connector Connection Pool object from the configbean object
ConnectorConnectionPool conConnPool = new ConnectorConnectionPool(poolInfo);
conConnPool.setTransactionSupport(txSupport);
setConnectorConnectionPoolAttributes(conConnPool, adminPool);
// Initially create the ConnectorDescriptor
ConnectorDescriptorInfo connDescInfo = createConnectorDescriptorInfo(connDesc, moduleName);
connDescInfo.setMCFConfigProperties(getMCFConfigProperties(adminPool, conConnPool, connDesc));
// since we are deploying a 1.0 RAR, this is null
connDescInfo.setResourceAdapterConfigProperties((Set) null);
conConnPool.setConnectorDescriptorInfo(connDescInfo);
return conConnPool;
}
private int getTxSupport(String moduleName) {
if (ConnectorConstants.JDBCXA_RA_NAME.equals(moduleName)) {
return ConnectionPoolObjectsUtils.parseTransactionSupportString(
ConnectorConstants.XA_TRANSACTION_TX_SUPPORT_STRING);
}
return ConnectionPoolObjectsUtils.parseTransactionSupportString(
ConnectorConstants.LOCAL_TRANSACTION_TX_SUPPORT_STRING);
}
private ConnectorDescriptorInfo createConnectorDescriptorInfo(
ConnectorDescriptor connDesc, String moduleName) {
ConnectorDescriptorInfo connDescInfo = new ConnectorDescriptorInfo();
connDescInfo.setManagedConnectionFactoryClass(
connDesc.getOutboundResourceAdapter().getManagedConnectionFactoryImpl());
connDescInfo.setRarName(moduleName);
connDescInfo.setResourceAdapterClassName(connDesc.getResourceAdapterClass());
connDescInfo.setConnectionDefinitionName(
connDesc.getOutboundResourceAdapter().getConnectionFactoryIntf());
connDescInfo.setConnectionFactoryClass(
connDesc.getOutboundResourceAdapter().getConnectionFactoryImpl());
connDescInfo.setConnectionFactoryInterface(
connDesc.getOutboundResourceAdapter().getConnectionFactoryIntf());
connDescInfo.setConnectionClass(connDesc.getOutboundResourceAdapter().getConnectionImpl());
connDescInfo.setConnectionInterface(connDesc.getOutboundResourceAdapter().getConnectionIntf());
return connDescInfo;
}
private void setConnectorConnectionPoolAttributes(
ConnectorConnectionPool ccp, JdbcConnectionPool adminPool) {
String poolName = ccp.getName();
ccp.setMaxPoolSize(adminPool.getMaxPoolSize());
ccp.setSteadyPoolSize(adminPool.getSteadyPoolSize());
ccp.setMaxWaitTimeInMillis(adminPool.getMaxWaitTimeInMillis());
ccp.setPoolResizeQuantity(adminPool.getPoolResizeQuantity());
ccp.setIdleTimeoutInSeconds(adminPool.getIdleTimeoutInSeconds());
ccp.setFailAllConnections(Boolean.valueOf(adminPool.getFailAllConnections()));
ccp.setConnectionValidationRequired(
Boolean.valueOf(adminPool.getIsConnectionValidationRequired()));
ccp.setNonTransactional(Boolean.valueOf(adminPool.getNonTransactionalConnections()));
ccp.setNonComponent(Boolean.valueOf(adminPool.getAllowNonComponentCallers()));
ccp.setPingDuringPoolCreation(Boolean.valueOf(adminPool.getPing()));
// These are default properties of all Jdbc pools
// So set them here first and then figure out from the parsing routine
// if they need to be reset
ccp.setMatchConnections(Boolean.valueOf(adminPool.getMatchConnections()));
ccp.setAssociateWithThread(Boolean.valueOf(adminPool.getAssociateWithThread()));
ccp.setConnectionLeakTracingTimeout(adminPool.getConnectionLeakTimeoutInSeconds());
ccp.setConnectionReclaim(Boolean.valueOf(adminPool.getConnectionLeakReclaim()));
boolean lazyConnectionEnlistment = Boolean.valueOf(adminPool.getLazyConnectionEnlistment());
boolean lazyConnectionAssociation = Boolean.valueOf(adminPool.getLazyConnectionAssociation());
// lazy-connection-enlistment need to be ON for lazy-connection-association to work.
if (lazyConnectionAssociation) {
if (lazyConnectionEnlistment) {
ccp.setLazyConnectionAssoc(true);
ccp.setLazyConnectionEnlist(true);
} else {
_logger.log(
Level.SEVERE,
"conn_pool_obj_utils.lazy_enlist-lazy_assoc-invalid-combination",
poolName);
String i18nMsg = sm.getString("cpou.lazy_enlist-lazy_assoc-invalid-combination", poolName);
throw new RuntimeException(i18nMsg);
}
} else {
ccp.setLazyConnectionAssoc(lazyConnectionAssociation);
ccp.setLazyConnectionEnlist(lazyConnectionEnlistment);
}
boolean pooling = Boolean.valueOf(adminPool.getPooling());
if (!pooling) {
// Throw exception if assoc with thread is set to true.
if (Boolean.valueOf(adminPool.getAssociateWithThread())) {
_logger.log(
Level.SEVERE,
"conn_pool_obj_utils.pooling_disabled_assocwiththread_invalid_combination",
poolName);
String i18nMsg =
sm.getString("cpou.pooling_disabled_assocwiththread_invalid_combination", poolName);
throw new RuntimeException(i18nMsg);
}
// Below are useful in pooled environment only.
// Throw warning for connection validation/validate-atmost-once/
// match-connections/max-connection-usage-count/idele-timeout
if (Boolean.valueOf(adminPool.getIsConnectionValidationRequired())) {
_logger.log(
Level.WARNING,
"conn_pool_obj_utils.pooling_disabled_conn_validation_invalid_combination",
poolName);
}
if (Integer.parseInt(adminPool.getValidateAtmostOncePeriodInSeconds()) > 0) {
_logger.log(
Level.WARNING,
"conn_pool_obj_utils.pooling_disabled_validate_atmost_once_invalid_combination",
poolName);
}
if (Boolean.valueOf(adminPool.getMatchConnections())) {
_logger.log(
Level.WARNING,
"conn_pool_obj_utils.pooling_disabled_match_connections_invalid_combination",
poolName);
}
if (Integer.parseInt(adminPool.getMaxConnectionUsageCount()) > 0) {
_logger.log(
Level.WARNING,
"conn_pool_obj_utils.pooling_disabled_max_conn_usage_invalid_combination",
poolName);
}
if (Integer.parseInt(adminPool.getIdleTimeoutInSeconds()) > 0) {
_logger.log(
Level.WARNING,
"conn_pool_obj_utils.pooling_disabled_idle_timeout_invalid_combination",
poolName);
}
}
ccp.setPooling(pooling);
ccp.setMaxConnectionUsage(adminPool.getMaxConnectionUsageCount());
ccp.setConCreationRetryAttempts(adminPool.getConnectionCreationRetryAttempts());
ccp.setConCreationRetryInterval(adminPool.getConnectionCreationRetryIntervalInSeconds());
ccp.setValidateAtmostOncePeriod(adminPool.getValidateAtmostOncePeriodInSeconds());
}
/** {@inheritDoc} */
@Override
public synchronized void redeployResource(Object resource) throws Exception {
final JdbcConnectionPool adminPool = (JdbcConnectionPool) resource;
PoolInfo poolInfo = ConnectorsUtil.getPoolInfo(adminPool);
// Only if pool has already been deployed in this server-instance
// reconfig this pool
if (!runtime.isConnectorConnectionPoolDeployed(poolInfo)) {
if (_logger.isLoggable(Level.FINE)) {
_logger.fine(
"The JDBC connection pool "
+ poolInfo
+ " is not referred or not yet created in this server "
+ "instance and hence pool redeployment is ignored");
}
return;
}
final ConnectorConnectionPool connConnPool = createConnectorConnectionPool(adminPool, poolInfo);
if (connConnPool == null) {
throw new ConnectorRuntimeException(
"Unable to create ConnectorConnectionPool" + "from JDBC connection pool");
}
// now do internal book keeping
HashSet excludes = new HashSet();
// add MCF config props to the set that need to be excluded
// in checking for the equality of the props with old pool
excludes.add("TransactionIsolation");
excludes.add("GuaranteeIsolationLevel");
excludes.add("ValidationTableName");
excludes.add("ConnectionValidationRequired");
excludes.add("ValidationMethod");
excludes.add("StatementWrapping");
excludes.add("StatementTimeout");
excludes.add("ValidationClassName");
excludes.add("StatementCacheSize");
excludes.add("StatementCacheType");
excludes.add("StatementLeakTimeoutInSeconds");
excludes.add("StatementLeakReclaim");
try {
if (_logger.isLoggable(Level.FINEST)) {
_logger.finest("Calling reconfigure pool");
}
boolean requirePoolRecreation =
runtime.reconfigureConnectorConnectionPool(connConnPool, excludes);
if (requirePoolRecreation) {
if (runtime.isServer() || runtime.isEmbedded()) {
handlePoolRecreation(connConnPool);
} else {
recreatePool(connConnPool);
}
}
} catch (ConnectorRuntimeException cre) {
Object params[] = new Object[] {poolInfo, cre};
_logger.log(Level.WARNING, "error.redeploying.jdbc.pool", params);
throw cre;
}
}
private void handlePoolRecreation(final ConnectorConnectionPool connConnPool)
throws ConnectorRuntimeException {
debug("[DRC] Pool recreation required");
final long reconfigWaitTimeout = connConnPool.getDynamicReconfigWaitTimeout();
PoolInfo poolInfo =
new PoolInfo(
connConnPool.getName(),
connConnPool.getApplicationName(),
connConnPool.getModuleName());
final ResourcePool oldPool = runtime.getPoolManager().getPool(poolInfo);
if (reconfigWaitTimeout > 0) {
oldPool.blockRequests(reconfigWaitTimeout);
if (oldPool.getPoolWaitQueue().getQueueLength() > 0
|| oldPool.getPoolStatus().getNumConnUsed() > 0) {
Runnable thread =
new Runnable() {
@Override
public void run() {
try {
long numSeconds = 5000L; // poll every 5 seconds
long steps = reconfigWaitTimeout / numSeconds;
if (steps == 0) {
waitForCompletion(steps, oldPool, reconfigWaitTimeout);
} else {
for (long i = 0; i < steps; i++) {
waitForCompletion(steps, oldPool, reconfigWaitTimeout);
if (oldPool.getPoolWaitQueue().getQueueLength() == 0
&& oldPool.getPoolStatus().getNumConnUsed() == 0) {
debug("wait-queue is empty and num-con-used is 0");
break;
}
}
}
handlePoolRecreationForExistingProxies(connConnPool);
PoolWaitQueue reconfigWaitQueue = oldPool.getReconfigWaitQueue();
debug("checking reconfig-wait-queue for notification");
if (reconfigWaitQueue.getQueueContents().size() > 0) {
for (Object o : reconfigWaitQueue.getQueueContents()) {
debug("notifying reconfig-wait-queue object [ " + o + " ]");
synchronized (o) {
o.notify();
}
}
}
} catch (InterruptedException ie) {
if (_logger.isLoggable(Level.FINEST)) {
_logger.log(
Level.FINEST,
"Interrupted while waiting for all existing clients to return connections to pool",
ie);
}
}
if (_logger.isLoggable(Level.FINEST)) {
_logger.finest(
"woke-up after giving time for in-use connections to return, "
+ "WaitQueue-Length : ["
+ oldPool.getPoolWaitQueue().getQueueContents()
+ "], "
+ "Num-Conn-Used : ["
+ oldPool.getPoolStatus().getNumConnUsed()
+ "]");
}
}
};
Callable c = Executors.callable(thread);
ArrayList list = new ArrayList();
list.add(c);
try {
execService.invokeAll(list);
} catch (Exception e) {
Object[] params = new Object[] {connConnPool.getName(), e};
_logger.log(Level.WARNING, "exception.redeploying.pool.transparently", params);
}
} else {
handlePoolRecreationForExistingProxies(connConnPool);
}
} else if (oldPool.getReconfigWaitTime() > 0) {
// reconfig is being switched off, invalidate proxies
Collection<BindableResource> resources =
JdbcResourcesUtil.getResourcesOfPool(
runtime.getResources(oldPool.getPoolInfo()), oldPool.getPoolInfo().getName());
ConnectorRegistry registry = ConnectorRegistry.getInstance();
for (BindableResource resource : resources) {
ResourceInfo resourceInfo = ConnectorsUtil.getResourceInfo(resource);
registry.removeResourceFactories(resourceInfo);
}
// recreate the pool now.
recreatePool(connConnPool);
} else {
recreatePool(connConnPool);
}
}
private void waitForCompletion(long steps, ResourcePool oldPool, long totalWaitTime)
throws InterruptedException {
debug("waiting for in-use connections to return to pool or waiting requests to complete");
try {
Object poolWaitQueue = oldPool.getPoolWaitQueue();
synchronized (poolWaitQueue) {
long waitTime = totalWaitTime / steps;
if (waitTime > 0) {
poolWaitQueue.wait(waitTime);
}
}
} catch (InterruptedException ie) {
// ignore
}
debug("woke-up to verify in-use / waiting requests list");
}
private void handlePoolRecreationForExistingProxies(ConnectorConnectionPool connConnPool) {
recreatePool(connConnPool);
Collection<BindableResource> resourcesList;
if (!connConnPool.isApplicationScopedResource()) {
resourcesList =
JdbcResourcesUtil.getResourcesOfPool(domain.getResources(), connConnPool.getName());
} else {
PoolInfo poolInfo = connConnPool.getPoolInfo();
Resources resources = ResourcesUtil.createInstance().getResources(poolInfo);
resourcesList = JdbcResourcesUtil.getResourcesOfPool(resources, connConnPool.getName());
}
for (BindableResource bindableResource : resourcesList) {
ResourceInfo resourceInfo = ConnectorsUtil.getResourceInfo(bindableResource);
ConnectorRegistry.getInstance().updateResourceInfoVersion(resourceInfo);
}
}
private void recreatePool(ConnectorConnectionPool connConnPool) {
try {
runtime.recreateConnectorConnectionPool(connConnPool);
debug("Pool [" + connConnPool.getName() + "] recreation done");
} catch (ConnectorRuntimeException cre) {
Object params[] = new Object[] {connConnPool.getName(), cre};
_logger.log(Level.WARNING, "error.redeploying.jdbc.pool", params);
}
}
/**
* Enable the resource in the server's runtime naming context
*
* @param resource a resource object
* @exception UnsupportedOperationException Currently we are not supporting this method.
*/
@Override
public synchronized void enableResource(Object resource) throws Exception {
throw new UnsupportedOperationException(msg);
}
/**
* Disable the resource in the server's runtime naming context
*
* @param resource a resource object
* @exception UnsupportedOperationException Currently we are not supporting this method.
*/
@Override
public synchronized void disableResource(Object resource) throws Exception {
throw new UnsupportedOperationException(msg);
}
/** {@inheritDoc} */
@Override
public void validatePreservedResource(
Application oldApp, Application newApp, Resource resource, Resources allResources)
throws ResourceConflictException {
// do nothing.
}
private void debug(String message) {
if (_logger.isLoggable(Level.FINEST)) {
_logger.finest("[DRC] : " + message);
}
}
}
public class JTSConfigChangeEventListener implements JTSEventListener {
// Sting Manager for Localization
private static StringManager sm = StringManager.getManager(JTSConfigChangeEventListener.class);
// Logger to log transaction messages
static Logger _logger = LogDomains.getLogger(LogDomains.JTA_LOGGER);
public String xPath = ServerXPathHelper.XPATH_TRANSACTION_SERVICE;
private static ConfigChangeCategory category =
new ConfigChangeCategory(
"jts",
ServerXPathHelper.REGEX_XPATH_CONFIG
+ ServerXPathHelper.XPATH_SEPARATOR
+ ServerXPathHelper.REGEX_ONE_PLUS
+ ServerTags.TRANSACTION_SERVICE
+ ".*");
public static ConfigChangeCategory getCategory() {
return category;
}
public void handleCreate(JTSEvent event) throws AdminEventListenerException {
throw new AdminEventListenerException("handleCreate is not valid for JTSEvent");
}
public void handleDelete(JTSEvent event) throws AdminEventListenerException {
throw new AdminEventListenerException("handleDelete is not valid for JTSEvent");
}
public void handleUpdate(JTSEvent event) throws AdminEventListenerException {
// Bug Id: 4666390 Handle no event in event list case
if (event == null) {
// do nothing
return;
}
ArrayList configChangeList = event.getConfigChangeList();
if (configChangeList == null) {
// do nothing
return;
}
// Bug Id: 4666390 End
ConfigUpdate configUpdate = null;
boolean match = false;
for (int i = 0; i < configChangeList.size(); i++) {
configUpdate = (ConfigUpdate) configChangeList.get(i);
if (configUpdate.getXPath() != null
&& configUpdate.getXPath().endsWith(ServerTags.TRANSACTION_SERVICE)) {
if (xPath.equals(configUpdate.getXPath())) {
match = true;
break;
}
}
}
if (match) { // TransactionService has been changed
Set attributeSet = configUpdate.getAttributeSet();
String next = null;
for (Iterator iter = attributeSet.iterator(); iter.hasNext(); ) {
next = (String) iter.next();
if (next.equals(ServerTags.TIMEOUT_IN_SECONDS)) {
_logger.log(Level.FINE, " Transaction Timeout interval event occurred");
String oldTimeout = configUpdate.getOldValue(ServerTags.TIMEOUT_IN_SECONDS);
String newTimeout = configUpdate.getNewValue(ServerTags.TIMEOUT_IN_SECONDS);
if (oldTimeout.equals(newTimeout)) {
} else {
try {
Switch.getSwitch()
.getTransactionManager()
.setDefaultTransactionTimeout(Integer.parseInt(newTimeout, 10));
} catch (Exception ex) {
_logger.log(Level.WARNING, "transaction.reconfig_txn_timeout_failed", ex);
}
} // timeout-in-seconds
} else if (next.equals(ServerTags.KEYPOINT_INTERVAL)) {
_logger.log(Level.FINE, "Keypoint interval event occurred");
String oldKeyPoint = configUpdate.getOldValue(ServerTags.KEYPOINT_INTERVAL);
String newKeyPoint = configUpdate.getNewValue(ServerTags.KEYPOINT_INTERVAL);
if (oldKeyPoint.equals(newKeyPoint)) {
} else {
Configuration.setKeypointTrigger(Integer.parseInt(newKeyPoint, 10));
}
} else if (next.equals(ServerTags.RETRY_TIMEOUT_IN_SECONDS)) {
String oldRetryTiemout = configUpdate.getOldValue(ServerTags.RETRY_TIMEOUT_IN_SECONDS);
String newRetryTiemout = configUpdate.getNewValue(ServerTags.RETRY_TIMEOUT_IN_SECONDS);
_logger.log(
Level.FINE, "retry_timeout_in_seconds reconfig event occurred " + newRetryTiemout);
if (oldRetryTiemout.equals(newRetryTiemout)) {
} else {
Configuration.setCommitRetryVar(newRetryTiemout);
}
} else {
// Not handled dynamically. Restart is required.
AdminEventMulticaster.notifyFailure(event, AdminEventResult.RESTART_NEEDED);
}
/*
//This feature is currently dropped as it's not implemented totally
else if (next.equals("commit-retries")) {
String oldCommitRetries = configUpdate.getOldValue("commit-retries");
String newCommitRetries = configUpdate.getNewValue("commit-retries");
if (oldCommitRetries.equals(newCommitRetries)) {
}
else {
Configuration.setCommitRetryVar(newCommitRetries);
}
} // commit-retries
*/
}
}
}
}
/**
* Implements the reload callbacks for standalone web modules.
*
* <p>When dynamic reloading is enabled, this object adds the list of enabled standalone web modules
* to the reload monitor thread, so that web module reload via 'touch .reload' works.
*
* <p>This class lives in the com.sun.enterprise.server package and not the com.sun.enterprise.web
* package because of the scope of the interface/methods in - ReloadMonitor, MonitorableEntry and
* MonitorListener.
*/
public final class StandaloneWebModulesManager implements MonitorListener {
ReloadMonitor reloadMonitor;
// ------------------------------------------------------------ Constructor
/**
* Standard constructor.
*
* @param id The web container object identifier
* @param modulesRoot The top level directory under which all standalone modules are deployed at.
* @param pollInterval The interval at which dynamic reloading is performed
*/
public StandaloneWebModulesManager(String id, String modulesRoot, long pollInterval) {
_id = id;
_modulesRoot = modulesRoot;
start(pollInterval);
}
// ----------------------------------------------------- Instance Variables
/**
* The id of this object (this is the same as that of the id of the associated web container
* object).
*/
private String _id = null;
/**
* Absolute path for location where all the deployed standalone modules are stored for this Server
* Instance.
*/
private String _modulesRoot = null;
/** List of web module ids registered with the reload monitor thread. */
private ArrayList _reloadables = new ArrayList();
// --------------------------------------------------------- Public Methods
/**
* Enable dynamic reloading (via the .reload file) for all the standalone web-modules that are
* marked as enabled
*
* <p>This method is invoked be WebContainer.start() only when dynamic reloading has been enabled
* in server.xml.
*/
public void start(long pollInterval) {
reloadMonitor = ReloadMonitor.getInstance(pollInterval * 1000);
}
/**
* Remove the modules (that were previously registered by start()) from the reload monitor thread.
*
* <p>This method is invoked be WebContainer.stop() only when dynamic reloading has been enabled
* in server.xml.
*/
public void stop() {
ReloadMonitor reloadMonitor = ReloadMonitor.getInstance(1);
for (int i = 0; i < _reloadables.size(); i++) {
String id = (String) _reloadables.get(i);
reloadMonitor.removeMonitoredEntry(id);
}
_reloadables.clear();
_reloadables = null;
}
// ------------------------------------------------ MonitorListener Methods
/**
* Callback from the reload monitor thread for a web module.
*
* <p>This is done when the user updates the $MODULE_ROOT/$MODULE/.reload file indicating the
* server runtime for a dynamic reload.
*
* @param entry entry thats being monitored
* @return true if application was reloaded successfully
*/
public boolean reload(MonitorableEntry entry) {
// The actual reload is done by the NSAPI reconfiguration logic which
// the reload monitor thread invokes (at the end), so simply return
// true here.
InstanceEnvironment ienv = ApplicationServer.getServerContext().getInstanceEnvironment();
// 4926513 work-around --- use displayname
// for "foo", the id will be "foo[0]"
// String moduleName = entry.getId();
String moduleName = entry.getDisplayName();
boolean status = false;
try {
DeploymentRequest req =
new DeploymentRequest(ienv, DeployableObjectType.WEB, DeploymentCommand.DEPLOY);
// monitored file points to $APP_ROOT/.reload
req.setFileSource(entry.getMonitoredFile().getParentFile());
// application registration name
req.setName(moduleName);
// we are always trying a redeployment
req.setForced(true);
AutoDirReDeployer deployer = new AutoDirReDeployer(req);
status = deployer.redeploy();
} catch (IASDeploymentException de) {
_logger.log(Level.WARNING, "core.error_in_reload_war_module", de);
return false;
}
return status;
}
/**
* Callback from the auto deploy monitor when a new archive is detected.
*
* @param entry entry thats being monitored
* @param archive newly detected archive under the auto deploy directory
* @return true if archive was deployed successfully
*/
public boolean deploy(MonitorableEntry entry, File archive) {
// auto-deploy has not been implemented in S1AS7
return false;
}
/**
* Adds the given WebModule to the list of monitorable entries for dynamic reloading.
*
* @param wm The WebModule to add to the list of monitorable entries for dynamic reloading
*/
public void addWebModule(WebModule wm) {
if (wm != null && isEnabled(wm.getConfigContext(), wm.getName())) {
String name = wm.getName();
String id = name + "[" + _id + "]";
String fileName = getReloadFilename(wm);
MonitorableEntry entry = new MonitorableEntry(id, name, new File(fileName), this);
_reloadables.add(id);
reloadMonitor.addMonitorableEntry(entry);
}
}
/**
* Whether or not a component (either an application or a module) should be enabled is defined by
* the "enable" attribute on both the application/module element and the application-ref element.
*
* @param config The dynamic ConfigContext
* @param moduleName The name of the component
* @return boolean
*/
protected boolean isEnabled(ConfigContext config, String moduleName) {
try {
if (config == null) {
config = AdminService.getAdminService().getAdminContext().getAdminConfigContext();
}
ConfigBean app = ApplicationHelper.findApplication(config, moduleName);
Server server = ServerBeansFactory.getServerBean(config);
ApplicationRef appRef = server.getApplicationRefByRef(moduleName);
return ((app != null && app.isEnabled()) && (appRef != null && appRef.isEnabled()));
} catch (ConfigException e) {
_logger.log(Level.FINE, "Error in finding " + moduleName, e);
// If there is anything wrong, do not enable the module
return false;
}
}
/**
* Adds the given WebModule instances to the list of monitorable entries for dynamic reloading.
*
* @param modules The array of WebModule instances to add to the list of monitorable entries for
* dynamic reloading
*/
public void addWebModules(WebModule[] modules) {
if (modules != null && modules.length > 0) {
for (int i = 0; i < modules.length; i++) {
addWebModule(modules[i]);
}
}
}
/** Returns the absolute pathname to the .reload file in the specified web module's directory. */
private String getReloadFilename(WebModule wm) {
String path = wm.getLocation();
File dir = new File(path);
if (!dir.isAbsolute()) path = _modulesRoot + "/" + path;
return path + "/" + ReloadMonitor.RELOAD_FILE;
}
/** logger to log core messages */
static Logger _logger = LogDomains.getLogger(LogDomains.CORE_LOGGER);
/** local string manager */
private static StringManager localStrings =
StringManager.getManager(StandAloneEJBModulesManager.class);
}
