/** * INTERNAL: Convert all the class-name-based settings in this mapping to actual class-based * settings. This method is used when converting a project that has been built with class names to * a project with classes. */ @Override public void convertClassNamesToClasses(ClassLoader classLoader) { super.convertClassNamesToClasses(classLoader); Iterator iterator = getTypeIndicatorNameTranslation().entrySet().iterator(); this.typeIndicatorTranslation = new HashMap(); while (iterator.hasNext()) { Map.Entry entry = (Map.Entry) iterator.next(); String referenceClassName = (String) entry.getKey(); Object indicator = entry.getValue(); Class referenceClass = null; try { if (PrivilegedAccessHelper.shouldUsePrivilegedAccess()) { try { referenceClass = (Class) AccessController.doPrivileged( new PrivilegedClassForName(referenceClassName, true, classLoader)); } catch (PrivilegedActionException exception) { throw ValidationException.classNotFoundWhileConvertingClassNames( referenceClassName, exception.getException()); } } else { referenceClass = PrivilegedAccessHelper.getClassForName(referenceClassName, true, classLoader); } } catch (ClassNotFoundException exception) { throw ValidationException.classNotFoundWhileConvertingClassNames( referenceClassName, exception); } addClassIndicator(referenceClass, indicator); } }
/** * INTERNAL: Convert all the class-name-based settings in this InheritancePolicy to actual * class-based settings. This method is used when converting a project that has been built with * class names to a project with classes. It will also convert referenced classes to the versions * of the classes from the classLoader. */ public void convertClassNamesToClasses(ClassLoader classLoader) { Vector newParentInterfaces = new Vector(); for (Iterator iterator = getParentInterfaceNames().iterator(); iterator.hasNext(); ) { String interfaceName = (String) iterator.next(); Class interfaceClass = null; try { if (PrivilegedAccessHelper.shouldUsePrivilegedAccess()) { try { interfaceClass = (Class) AccessController.doPrivileged( new PrivilegedClassForName(interfaceName, true, classLoader)); } catch (PrivilegedActionException exception) { throw ValidationException.classNotFoundWhileConvertingClassNames( interfaceName, exception.getException()); } } else { interfaceClass = org.eclipse.persistence.internal.security.PrivilegedAccessHelper.getClassForName( interfaceName, true, classLoader); } } catch (ClassNotFoundException exc) { throw ValidationException.classNotFoundWhileConvertingClassNames(interfaceName, exc); } newParentInterfaces.add(interfaceClass); } this.parentInterfaces = newParentInterfaces; }
/** * Parse constraints file (referenced in validation.xml). Add all classes declared under <bean * class="clazz"> to {@link * org.eclipse.persistence.jaxb.BeanValidationHelper#constraintsOnClasses} with value {@link * Boolean#TRUE}. */ private void parseConstraintFile(String constraintsFile, DefaultHandler referencedFileHandler) { InputStream constraintsXml = null; if (PrivilegedAccessHelper.shouldUsePrivilegedAccess()) { try { constraintsXml = AccessController.doPrivileged( new PrivilegedGetContextClassLoader(Thread.currentThread())) .getResourceAsStream(constraintsFile); } catch (PrivilegedActionException e) { String msg = "Loading of custom constraints file: " + constraintsFile + " failed. Exception: " + e.getMessage(); LOGGER.warning(msg); } } else { constraintsXml = Thread.currentThread().getContextClassLoader().getResourceAsStream(constraintsFile); } try { //noinspection ConstantConditions saxParser.parse(constraintsXml, referencedFileHandler); } catch (SAXException | IOException | NullPointerException e) { String msg = "Loading of custom constraints file: " + constraintsFile + " failed. Exception: " + e.getMessage(); LOGGER.warning(msg); } }
/** * INTERNAL: Convert all the class-name-based settings to actual class-based settings. This method * is used when converting a project that has been built with class names to a project with * classes. */ public void convertClassNamesToClasses(ClassLoader classLoader) { if (getPartitioningClasName() == null) { setPartitioningClasName(""); } try { if (PrivilegedAccessHelper.shouldUsePrivilegedAccess()) { Class partitioningClass = (Class) AccessController.doPrivileged( new PrivilegedClassForName(getPartitioningClasName(), true, classLoader)); this.policy = (PartitioningPolicy) AccessController.doPrivileged( new PrivilegedNewInstanceFromClass(partitioningClass)); } else { Class partitioningClass = PrivilegedAccessHelper.getClassForName(getPartitioningClasName(), true, classLoader); this.policy = (PartitioningPolicy) PrivilegedAccessHelper.newInstanceFromClass(partitioningClass); } } catch (PrivilegedActionException exception) { throw ValidationException.classNotFoundWhileConvertingClassNames( getPartitioningClasName(), exception.getException()); } catch (ClassNotFoundException exception) { throw ValidationException.classNotFoundWhileConvertingClassNames( getPartitioningClasName(), exception); } catch (IllegalAccessException exception) { throw ValidationException.reflectiveExceptionWhileCreatingClassInstance( getPartitioningClasName(), exception); } catch (InstantiationException exception) { throw ValidationException.reflectiveExceptionWhileCreatingClassInstance( getPartitioningClasName(), exception); } }
/** INTERNAL: Load a class from a given class name. (XMLEntityMappings calls this one) */ public static Class getClassForName(String classname, ClassLoader loader) { try { if (PrivilegedAccessHelper.shouldUsePrivilegedAccess()) { try { return (Class) AccessController.doPrivileged(new PrivilegedClassForName(classname, true, loader)); } catch (PrivilegedActionException exception) { throw ValidationException.unableToLoadClass(classname, exception.getException()); } } else { return PrivilegedAccessHelper.getClassForName(classname, true, loader); } } catch (ClassNotFoundException exception) { if (classname.indexOf('$') != -1) { String outer = classname.substring(0, classname.indexOf('$')); Class outerClass = getClassForName(outer, loader); for (int index = 0; index < outerClass.getClasses().length; index++) { if (outerClass.getClasses()[index].getName().equals(classname)) { return outerClass.getClasses()[index]; } } } throw ValidationException.unableToLoadClass(classname, exception); } }
/** * Internal: Helper to load class. Please do not make this method protected or public else it * would expose a security hole that would allow malicious code to use this method to load any * class without security permission * * @param className Fully qualified class name * @param classLoader ClassLoader to be used for loading the class * @return Loaded Class * @throws java.security.PrivilegedActionException * @throws ClassNotFoundException */ private Class loadClass(String className, ClassLoader classLoader) throws PrivilegedActionException, ClassNotFoundException { Class loadedClass = null; if (PrivilegedAccessHelper.shouldUsePrivilegedAccess()) { loadedClass = AccessController.doPrivileged(new PrivilegedClassForName(className, true, classLoader)); } else { loadedClass = PrivilegedAccessHelper.getClassForName(className, true, classLoader); } return loadedClass; }
/** * @return true if someone is just not letting the async thread do anything or if we possibly * failed due to using jdk executor and not having access to resources managed by container. */ static boolean asyncAttemptFailed() { try { return !didSomething || (possibleResourceVisibilityFail && (PrivilegedAccessHelper.shouldUsePrivilegedAccess() ? AccessController.doPrivileged( new PrivilegedGetContextClassLoader(Thread.currentThread())) .getResource(VALIDATION_XML) : Thread.currentThread().getContextClassLoader().getResource(VALIDATION_XML)) != null); } catch (PrivilegedActionException exception) { return true; } }
/** INTERNAL: Return a new instance of the class provided. */ public Object getClassInstance(Class cls) { if (cls != null) { try { if (PrivilegedAccessHelper.shouldUsePrivilegedAccess()) { return AccessController.doPrivileged(new PrivilegedNewInstanceFromClass(cls)); } else { return org.eclipse.persistence.internal.security.PrivilegedAccessHelper .newInstanceFromClass(cls); } } catch (Exception e) { throw ValidationException.reflectiveExceptionWhileCreatingClassInstance(cls.getName(), e); } } return null; }
/** INTERNAL: Create a new instance of the class given. */ static Object getClassInstance(Class cls) { try { if (PrivilegedAccessHelper.shouldUsePrivilegedAccess()) { try { return AccessController.doPrivileged(new PrivilegedNewInstanceFromClass(cls)); } catch (PrivilegedActionException exception) { throw ValidationException.errorInstantiatingClass(cls, exception.getException()); } } else { return PrivilegedAccessHelper.newInstanceFromClass(cls); } } catch (IllegalAccessException exception) { throw ValidationException.errorInstantiatingClass(cls, exception); } catch (InstantiationException exception) { throw ValidationException.errorInstantiatingClass(cls, exception); } }
/** * INTERNAL: Convert all the class-name-based settings in this Descriptor to actual class-based * settings. This method is used when converting a project that has been built with class names to * a project with classes. * * @param classLoader */ public void convertClassNamesToClasses(ClassLoader classLoader) { if (this.type == null) { try { if (PrivilegedAccessHelper.shouldUsePrivilegedAccess()) { try { this.type = AccessController.doPrivileged( new PrivilegedClassForName(this.typeName, true, classLoader)); } catch (PrivilegedActionException exception) { throw ValidationException.classNotFoundWhileConvertingClassNames( this.typeName, exception.getException()); } } else { this.type = org.eclipse.persistence.internal.security.PrivilegedAccessHelper.getClassForName( this.typeName, true, classLoader); } } catch (ClassNotFoundException exc) { throw ValidationException.classNotFoundWhileConvertingClassNames(this.typeName, exc); } if (this.items != null) { for (ATTRIBUTE_ITEM item : this.items.values()) { item.convertClassNamesToClasses(classLoader); } } if (this.allsubclasses != null) { Map<Object, CoreAttributeGroup> allGroups = new HashMap<Object, CoreAttributeGroup>(); this.subClasses = new HashSet<CoreAttributeGroup>(); for (CoreAttributeGroup subClass : allsubclasses.values()) { subClass.convertClassNamesToClasses(classLoader); allGroups.put(subClass.getType(), subClass); } this.allsubclasses = allGroups; for (CoreAttributeGroup subClass : allsubclasses.values()) { if (CoreAttributeItem.orderInheritance(subClass, allGroups)) { this.insertSubClass(subClass); } } } } }
public static ArchiveFactory getArchiveFactory(ClassLoader loader) { if (ARCHIVE_FACTORY != null) { return ARCHIVE_FACTORY; } ArchiveFactory factory = null; String factoryClassName = System.getProperty(SystemProperties.ARCHIVE_FACTORY, null); if (factoryClassName == null) { return new ArchiveFactoryImpl(); } else { try { if (loader != null) { Class archiveClass = loader.loadClass(factoryClassName); if (PrivilegedAccessHelper.shouldUsePrivilegedAccess()) { try { factory = (ArchiveFactory) AccessController.doPrivileged( new PrivilegedNewInstanceFromClass(archiveClass)); } catch (PrivilegedActionException exception) { throw PersistenceUnitLoadingException.exceptionCreatingArchiveFactory( factoryClassName, exception); } } else { factory = (ArchiveFactory) PrivilegedAccessHelper.newInstanceFromClass(archiveClass); } } } catch (ClassNotFoundException cnfe) { throw PersistenceUnitLoadingException.exceptionCreatingArchiveFactory( factoryClassName, cnfe); } catch (IllegalAccessException iae) { throw PersistenceUnitLoadingException.exceptionCreatingArchiveFactory( factoryClassName, iae); } catch (InstantiationException ie) { throw PersistenceUnitLoadingException.exceptionCreatingArchiveFactory(factoryClassName, ie); } } return factory; }
private void parseValidationXML() throws SAXException, IOException { InputStream validationXml = null; if (PrivilegedAccessHelper.shouldUsePrivilegedAccess()) { try { validationXml = AccessController.doPrivileged( new PrivilegedGetContextClassLoader(Thread.currentThread())) .getResourceAsStream(VALIDATION_XML); } catch (PrivilegedActionException e) { String msg = "Loading of " + VALIDATION_XML + " file failed. Exception: " + e.getMessage(); LOGGER.warning(msg); } } else { validationXml = Thread.currentThread().getContextClassLoader().getResourceAsStream(VALIDATION_XML); } if (validationXml != null) { saxParser.parse(validationXml, validationHandler); } else if (jdkExecutor) { possibleResourceVisibilityFail = true; } }
/** * INTERNAL: Lazy initialization of xmlTypeFactory allows to avoid loading xdb-dependent class * XMLTypeFactoryImpl unless xdb is used. * * @return XMLTypeFactory */ protected XMLTypeFactory getXMLTypeFactory() { if (xmlTypeFactory == null) { String className = "org.eclipse.persistence.internal.platform.database.oracle.xdb.XMLTypeFactoryImpl"; try { if (PrivilegedAccessHelper.shouldUsePrivilegedAccess()) { Class xmlTypeFactoryClass = (Class) AccessController.doPrivileged( new PrivilegedClassForName( className, true, this.getClass().getClassLoader())); Constructor xmlTypeFactoryConstructor = (Constructor) AccessController.doPrivileged( new PrivilegedGetConstructorFor(xmlTypeFactoryClass, new Class[0], true)); xmlTypeFactory = (XMLTypeFactory) AccessController.doPrivileged( new PrivilegedInvokeConstructor(xmlTypeFactoryConstructor, new Object[0])); } else { Class xmlTypeFactoryClass = PrivilegedAccessHelper.getClassForName( className, true, this.getClass().getClassLoader()); Constructor xmlTypeFactoryConstructor = PrivilegedAccessHelper.getConstructorFor(xmlTypeFactoryClass, new Class[0], true); xmlTypeFactory = (XMLTypeFactory) PrivilegedAccessHelper.invokeConstructor( xmlTypeFactoryConstructor, new Object[0]); } } catch (Exception e) { throw QueryException.reflectiveCallOnTopLinkClassFailed(className, e); } } return xmlTypeFactory; }
/** * This method will be used to set a new type of identity map for a particular class type. If * objects of that class type are in use loss of object identity will result. For prevention * client may wish to initialize all identity maps first. * * @param className the fully qualified className to set the identity map for. * @param identityMapClassType the fully qualified class name of the new identity map type. * @param maxSize the maximum size to be specified for the new identity map. * @exception ClassNotFoundException thrown then the IdenityMap for that class name could not be * found */ public void setIdentityMapForClass(String className, String identityMapClassType, int maxSize) throws ClassNotFoundException { Class classToChange = (Class) getSession() .getDatasourcePlatform() .getConversionManager() .convertObject(className, ClassConstants.CLASS); Class identityMapClass = null; if (PrivilegedAccessHelper.shouldUsePrivilegedAccess()) { try { identityMapClass = (Class) AccessController.doPrivileged(new PrivilegedClassForName(identityMapClassType)); } catch (PrivilegedActionException ex) { throw (RuntimeException) ex.getCause(); } } else { identityMapClass = PrivilegedAccessHelper.getClassForName(identityMapClassType); } ClassDescriptor descriptor = getSession().getDescriptor(classToChange); descriptor.setIdentityMapClass(identityMapClass); descriptor.setIdentityMapSize(maxSize); getSession().getIdentityMapAccessorInstance().initializeIdentityMap(classToChange); }
/** * Return the java.lang.reflect.Member for the represented attribute. In the case of property * access the get method will be returned * * @return corresponding java.lang.reflect.Member */ @Override public Member getJavaMember() { AttributeAccessor accessor = getMapping().getAttributeAccessor(); if (accessor.isMethodAttributeAccessor()) { // Method level access here Method aMethod = ((MethodAttributeAccessor) accessor).getGetMethod(); if (null == aMethod) { // 316991: If the getMethod is not set - use a reflective call via the getMethodName String getMethodName = null; try { getMethodName = ((MethodAttributeAccessor) mapping.getAttributeAccessor()).getGetMethodName(); if (PrivilegedAccessHelper.shouldUsePrivilegedAccess()) { aMethod = AccessController.doPrivileged( new PrivilegedGetDeclaredMethod( this.getManagedTypeImpl().getJavaType(), getMethodName, null)); } else { aMethod = PrivilegedAccessHelper.getDeclaredMethod( this.getManagedTypeImpl().getJavaType(), getMethodName, null); } // Exceptions are to be ignored for reflective calls - if the methodName is also null - it // will catch here } catch (PrivilegedActionException pae) { // pae.printStackTrace(); } catch (NoSuchMethodException nsfe) { // nsfe.printStackTrace(); } } return aMethod; } // Field level access here Member aMember = ((InstanceVariableAttributeAccessor) accessor).getAttributeField(); // For primitive and basic types - we should not return null - the attributeAccessor on the // MappedSuperclass is not initialized - see // http://wiki.eclipse.org/EclipseLink/Development/JPA_2.0/metamodel_api#DI_95:_20091017:_Attribute.getJavaMember.28.29_returns_null_for_a_BasicType_on_a_MappedSuperclass_because_of_an_uninitialized_accessor // MappedSuperclasses need special handling to get their type from an inheriting subclass // Note: This code does not handle attribute overrides on any entity subclass tree - use // descriptor initialization instead if (null == aMember) { if (this.getManagedTypeImpl().isMappedSuperclass()) { // get inheriting subtype member (without handling @override annotations) AttributeImpl inheritingTypeMember = ((MappedSuperclassTypeImpl) this.getManagedTypeImpl()) .getMemberFromInheritingType(mapping.getAttributeName()); // 322166: If attribute is defined on this current ManagedType (and not on a superclass) - // do not attempt a reflective call on a superclass if (null != inheritingTypeMember) { // Verify we have an attributeAccessor aMember = ((InstanceVariableAttributeAccessor) inheritingTypeMember.getMapping().getAttributeAccessor()) .getAttributeField(); } } if (null == aMember) { // 316991: Handle Embeddable types // If field level access - perform a getDeclaredField call // Field level access // Check declaredFields in the case where we have no getMethod or getMethodName try { if (PrivilegedAccessHelper.shouldUsePrivilegedAccess()) { aMember = AccessController.doPrivileged( new PrivilegedGetDeclaredField( this.getManagedTypeImpl().getJavaType(), mapping.getAttributeName(), false)); } else { aMember = PrivilegedAccessHelper.getDeclaredField( this.getManagedTypeImpl().getJavaType(), mapping.getAttributeName(), false); } // Exceptions are to be ignored for reflective calls - if the methodName is also null - it // will catch here } catch (PrivilegedActionException pae) { // pae.printStackTrace(); } catch (NoSuchFieldException nsfe) { // nsfe.printStackTrace(); } } } // 303063: secondary check for attribute override case - this will show on code coverage if (null == aMember) { AbstractSessionLog.getLog() .log( SessionLog.FINEST, AbstractSessionLog.METAMODEL, "metamodel_attribute_getmember_is_null", this, this.getManagedTypeImpl(), this.getDescriptor()); } return aMember; }