/*******************************************************************************
* Copyright (c) 2014, 2015 Oracle and/or its affiliates. All rights reserved.
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0
* which accompanies this distribution.
* The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
* and the Eclipse Distribution License is available at
* http://www.eclipse.org/org/documents/edl-v10.php.
*
* Contributors:
* Dmitry Kornilov - Initial implementation
******************************************************************************/
package org.eclipse.persistence.sdo.helper;
import org.eclipse.persistence.internal.security.PrivilegedAccessHelper;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Collections;
import java.util.Map;
import java.util.WeakHashMap;
import java.util.logging.Level;
import java.util.logging.Logger;
/**
* INTERNAL:
*
* This class using WLS classed to get unique application ID.
* WLS classes are accessed using reflection. It tries to use ComponentInvocationContext (CIC) first, if no success it
* tries to use ApplicationAccess.
*
* @author Dmitry Kornilov
* @since EclipseLink 2.6.0
*/
public class ApplicationAccessWLS {
private static final Logger LOGGER = Logger.getLogger(ApplicationAccessWLS.class.getName());
private static final String CIC_MANAGER_CLASS_NAME = "weblogic.invocation.ComponentInvocationContextManager";
private static final String CIC_CLASS_NAME = "weblogic.invocation.ComponentInvocationContext";
/** ApplicationID cache **/
private final Map<ClassLoader, String> appNames = Collections.synchronizedMap(new WeakHashMap<ClassLoader, String>());
/** Instance of ApplicationAccess or null if not initialized **/
private Object applicationAccessInstance;
private Method getApplicationNameMethod;
private Method getApplicationVersionMethod;
/** Instance of CIC (Component Invocation Context) or null if not initialized **/
private Object cicManagerInstance;
private Method getCurrentCicMethod;
private Method getApplicationIdMethod;
/**
* Create and initialize.
*/
public ApplicationAccessWLS() {
// Try initializing using CIC
if (initUsingCic()) {
LOGGER.fine("ApplicationAccessWLS initialized using ComponentInvocationContext.");
return;
}
// Init using CIC failed, try to init using ApplicationAccess
cicManagerInstance = null;
if (initUsingApplicationAccess()) {
LOGGER.fine("ApplicationAccessWLS initialized using ApplicationAccess.");
return;
}
applicationAccessInstance = null;
LOGGER.fine("Failed to initialize ApplicationAccessWLS.");
}
/**
* Gets a unique application name.
*
* @param classLoader the class loader
* @return unique application name.
*/
public String getApplicationName(ClassLoader classLoader) {
if (appNames.containsKey(classLoader)) {
return appNames.get(classLoader);
} else {
synchronized (appNames) {
if (appNames.containsKey(classLoader)) {
return appNames.get(classLoader);
} else {
final String appName = getApplicationNameInternal(classLoader);
appNames.put(classLoader, appName);
return appName;
}
}
}
}
/**
* Internal method to get a unique application name.
* Uses CIC if possible. If not using ApplicationAccess.
*
* @param classLoader the class loader
* @return unique application name.
*/
private String getApplicationNameInternal(ClassLoader classLoader) {
// If CIC initialization was successful use CIC
if (cicManagerInstance != null) {
try {
return getAppNameUsingCic();
} catch (Exception e) {
LOGGER.log(Level.WARNING, "ApplicationAccessWLS.getApplicationName error in getAppNameUsingCic.", e);
return null;
}
}
// If CIC initialization was not successful and ApplicationAccess initialization was successful
// use ApplicationAccess
if (applicationAccessInstance != null) {
try {
return getAppNameUsingApplicationAccess(classLoader);
} catch (Exception e) {
LOGGER.log(Level.WARNING, "ApplicationAccessWLS.getApplicationName error in getAppNameUsingApplicationAccess.", e);
return null;
}
}
// Both CIC and ApplicationAccess are failed to initialize
LOGGER.fine("ApplicationAccessWLS: null applicationName returned.");
return null;
}
/**
* Initializes CIC. Returns true on success.
*/
protected boolean initUsingCic() {
// Check that CIC implementation exists.
if (ApplicationAccessWLS.class.getClassLoader().getResource("META-INF/services/" + CIC_MANAGER_CLASS_NAME) == null) {
return false;
}
try {
// Get component invocation manager
final Class cicManagerClass = PrivilegedAccessHelper.getClassForName(CIC_MANAGER_CLASS_NAME);
final Method getInstance = PrivilegedAccessHelper.getDeclaredMethod(cicManagerClass, "getInstance", new Class[]{});
cicManagerInstance = PrivilegedAccessHelper.invokeMethod(getInstance, cicManagerClass);
// Get component invocation context
getCurrentCicMethod = PrivilegedAccessHelper.getMethod(cicManagerClass, "getCurrentComponentInvocationContext", new Class[]{}, true);
final Class cicClass = PrivilegedAccessHelper.getClassForName(CIC_CLASS_NAME);
getApplicationIdMethod = PrivilegedAccessHelper.getDeclaredMethod(cicClass, "getApplicationId", new Class[]{});
return true;
} catch (ClassNotFoundException|NoSuchMethodException|InvocationTargetException|IllegalAccessException e) {
LOGGER.log(Level.FINE, "Error initializing ApplicationAccessWLS using ComponentInvocationContext.", e);
return false;
}
}
/**
* Initializes ApplicationAccess.
*/
protected boolean initUsingApplicationAccess() {
try {
final Class applicationAccessClass = PrivilegedAccessHelper.getClassForName("weblogic.application.ApplicationAccess");
final Method getApplicationAccessMethod = PrivilegedAccessHelper.getDeclaredMethod(applicationAccessClass, "getApplicationAccess", new Class[]{});
applicationAccessInstance = PrivilegedAccessHelper.invokeMethod(getApplicationAccessMethod, applicationAccessClass);
final Class[] methodParameterTypes = new Class[]{ClassLoader.class};
getApplicationNameMethod = PrivilegedAccessHelper.getMethod(applicationAccessClass, "getApplicationName", methodParameterTypes, true);
getApplicationVersionMethod = PrivilegedAccessHelper.getMethod(applicationAccessClass, "getApplicationVersion", methodParameterTypes, true);
return true;
} catch (ClassNotFoundException|NoSuchMethodException|InvocationTargetException|IllegalAccessException ex) {
LOGGER.log(Level.FINE, "Error initializing ApplicationAccessWLS using ApplicationAccess.", ex);
return false;
}
}
/**
* Gets unique application name using CIC. Calls cicInstance.getApplicationIdMethod().
*/
private String getAppNameUsingCic() throws InvocationTargetException, IllegalAccessException {
final Object cicInstance = PrivilegedAccessHelper.invokeMethod(getCurrentCicMethod, cicManagerInstance);
return (String) PrivilegedAccessHelper.invokeMethod(getApplicationIdMethod, cicInstance);
}
/**
* Gets unique application name using ApplicationAccess. Calls its getApplicationName() and getApplicationVersion methods.
*/
private String getAppNameUsingApplicationAccess(ClassLoader classLoader) throws InvocationTargetException, IllegalAccessException {
final Object[] parameters = new Object[] {classLoader};
final String appName = (String) PrivilegedAccessHelper.invokeMethod(getApplicationNameMethod, applicationAccessInstance, parameters);
if (appName != null) {
final String appVersion = (String) PrivilegedAccessHelper.invokeMethod(getApplicationVersionMethod, applicationAccessInstance, parameters);
if (appVersion != null) {
return appName + "#" + appVersion;
}
}
return appName;
}
}