Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.apache.openjpa.enhance;
import java.io.ByteArrayInputStream;
import java.lang.instrument.ClassFileTransformer;
import java.lang.instrument.IllegalClassFormatException;
import java.security.AccessController;
import java.security.ProtectionDomain;
import java.util.Set;
import org.apache.openjpa.conf.OpenJPAConfiguration;
import org.apache.openjpa.lib.log.Log;
import org.apache.openjpa.lib.util.J2DoPrivHelper;
import org.apache.openjpa.lib.util.Localizer;
import org.apache.openjpa.lib.util.Options;
import org.apache.openjpa.meta.MetaDataRepository;
import org.apache.openjpa.util.GeneralException;
import serp.bytecode.BCClass;
import serp.bytecode.Project;
/**
* Transformer that makes persistent classes implement the
* {@link PersistenceCapable} interface at runtime.
*
* @author Abe White
*/
public class PCClassFileTransformer
implements ClassFileTransformer {
private static final Localizer _loc = Localizer.forPackage
(PCClassFileTransformer.class);
private final MetaDataRepository _repos;
private final PCEnhancer.Flags _flags;
private final ClassLoader _tmpLoader;
private final Log _log;
private final Set _names;
/**
* Constructor.
*
* @param repos metadata repository to use internally
* @param opts enhancer configuration options
* @param loader temporary class loader for loading intermediate classes
*/
public PCClassFileTransformer(MetaDataRepository repos, Options opts, ClassLoader loader) {
this(repos, toFlags(opts), loader, opts.removeBooleanProperty
("scanDevPath", "ScanDevPath", false));
}
/**
* Create enhancer flags from the given options.
*/
private static PCEnhancer.Flags toFlags(Options opts) {
PCEnhancer.Flags flags = new PCEnhancer.Flags();
flags.addDefaultConstructor = opts.removeBooleanProperty
("addDefaultConstructor", "AddDefaultConstructor",
flags.addDefaultConstructor);
flags.enforcePropertyRestrictions = opts.removeBooleanProperty
("enforcePropertyRestrictions", "EnforcePropertyRestrictions",
flags.enforcePropertyRestrictions);
return flags;
}
/**
* Constructor.
*
* @param repos metadata repository to use internally
* @param flags enhancer configuration
* @param tmpLoader temporary class loader for loading intermediate classes
* @param devscan whether to scan the dev classpath for persistent types
* if none are configured
*/
public PCClassFileTransformer(MetaDataRepository repos, PCEnhancer.Flags flags, ClassLoader tmpLoader, boolean devscan) {
_repos = repos;
_tmpLoader = tmpLoader;
_log = repos.getConfiguration().
getLog(OpenJPAConfiguration.LOG_ENHANCE);
_flags = flags;
_names = repos.getPersistentTypeNames(devscan, tmpLoader);
if (_names == null && _log.isInfoEnabled())
_log.info(_loc.get("runtime-enhance-pcclasses"));
}
public static PCClassFileTransformer newInstance(final MetaDataRepository repos, final Options parseProperties,
final ClassLoader tmpLoader) {
return parseProperties != null && parseProperties.getBooleanProperty("Reentrant") ?
new PCClassFileTransformer.Reentrant(repos, parseProperties, tmpLoader) :
new PCClassFileTransformer(repos, parseProperties, tmpLoader);
}
@Override
public byte[] transform(ClassLoader loader, String className, Class redef, ProtectionDomain domain, byte[] bytes)
throws IllegalClassFormatException {
if (loader == _tmpLoader)
return null;
// JDK bug -- OPENJPA-1676
if (className == null) {
return null;
}
return transform0(className, redef, bytes);
}
/**
* We have to split the transform method into two methods to avoid
* ClassCircularityError when executing method using pure-JIT JVMs
* such as JRockit.
*/
protected byte[] transform0(String className, Class redef, byte[] bytes)
throws IllegalClassFormatException {
byte[] returnBytes = null;
try {
Boolean enhance = needsEnhance(className, redef, bytes);
if (enhance != null && _log.isTraceEnabled())
_log.trace(_loc.get("needs-runtime-enhance", className,
enhance));
if (enhance != Boolean.TRUE)
return null;
ClassLoader oldLoader = AccessController.doPrivileged(J2DoPrivHelper.getContextClassLoaderAction());
AccessController.doPrivileged(J2DoPrivHelper.setContextClassLoaderAction(_tmpLoader));
try {
PCEnhancer enhancer = new PCEnhancer(_repos.getConfiguration(),
new Project().loadClass(new ByteArrayInputStream(bytes),
_tmpLoader), _repos);
enhancer.setAddDefaultConstructor(_flags.addDefaultConstructor);
enhancer.setEnforcePropertyRestrictions
(_flags.enforcePropertyRestrictions);
if (enhancer.run() == PCEnhancer.ENHANCE_NONE)
return null;
BCClass pcb = enhancer.getPCBytecode();
returnBytes = AsmAdaptor.toByteArray(pcb, pcb.toByteArray());
return returnBytes;
} finally {
AccessController.doPrivileged(J2DoPrivHelper.setContextClassLoaderAction(oldLoader));
}
} catch (Throwable t) {
_log.warn(_loc.get("cft-exception-thrown", className), t);
if (t instanceof RuntimeException)
throw (RuntimeException) t;
if (t instanceof IllegalClassFormatException)
throw (IllegalClassFormatException) t;
throw new GeneralException(t);
} finally {
if (returnBytes != null && _log.isTraceEnabled())
_log.trace(_loc.get("runtime-enhance-complete", className,
bytes.length, returnBytes.length));
}
}
/**
* Return whether the given class needs enhancement.
*/
private Boolean needsEnhance(String clsName, Class redef, byte[] bytes) {
if (redef != null && PersistenceCapable.class.isAssignableFrom(redef)) {
// if the original class is already enhanced (implements PersistenceCapable)
// then we don't need to do any further processing.
return null;
}
if (_names != null) {
if (_names.contains(clsName.replace('/', '.')))
return !isEnhanced(bytes);
return null;
}
if (clsName.startsWith("java/") || clsName.startsWith("javax/") || clsName.startsWith("jakarta/")) {
return null;
}
if (isEnhanced(bytes)) {
return Boolean.FALSE;
}
try {
Class c = Class.forName(clsName.replace('/', '.'), false,
_tmpLoader);
if (_repos.getMetaData(c, null, false) != null)
return Boolean.TRUE;
return null;
} catch (ClassNotFoundException | LinkageError cnfe) {
// cannot load the class: this might mean that it is a proxy
// or otherwise inaccessible class which can't be an entity
return Boolean.FALSE;
} // this can happen if we are loading classes that this
// class depends on; these will never be enhanced anyway
catch (RuntimeException re) {
throw re;
} catch (Throwable t) {
throw new GeneralException(t);
}
}
/**
* Analyze the bytecode to see if the given class definition implements
* {@link PersistenceCapable}.
*/
private static boolean isEnhanced(byte[] b) {
return AsmAdaptor.isEnhanced(b);
}
public static class Reentrant extends PCClassFileTransformer {
private final ThreadLocal transforming = new ThreadLocal<>();
public Reentrant(final MetaDataRepository repos, final Options opts, final ClassLoader loader) {
super(repos, opts, loader);
}
public Reentrant(final MetaDataRepository repos, final PCEnhancer.Flags flags,
final ClassLoader tmpLoader, final boolean devscan) {
super(repos, flags, tmpLoader, devscan);
}
@Override
protected byte[] transform0(String className, Class redef, byte[] bytes) throws IllegalClassFormatException {
if (transforming.get() != null) {
return bytes;
}
transforming.set(true);
try {
return super.transform0(className, redef, bytes);
} finally {
transforming.remove();
}
}
}
}
