JPA/EclipseLink - Error using multiple JpaEntityManagers - jpa

Question

We are trying to set up an application running on a Glassfish 4 Server. For data retrieval, we are using JPA 2.0 (EclipseLink Kepler). For several reasons, additionally to the normal user management, we also want users to authorize via the DMBS user management.
In order to accomplish that, we create a user-specific JpaEntityManager when the user logs in (In order to check the login itself, we also have a general server-side JpaEntityManager, whose DBMS credentials are located in the persistence.xml). Some code here:
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Hashtable;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import org.eclipse.persistence.jpa.JpaEntityManager;
import org.eclipse.persistence.jpa.JpaHelper;
import application.auth.general.Credentials;
import application.config.Config;
import application.data.model.JpaSession;
import application.logger.Logger;
/**
*/
public class EntityManagerBase {
/**
* Singleton instance
*/
private static EntityManagerBase instance = new EntityManagerBase();
/**
* Hashtable for storage of user specific EntityManagers
*
* #param String userName
* #param EntityManager corresponding EntityManager
*/
private Hashtable<Integer, JpaEntityManager> jpaEms = new Hashtable<>();
/**
* Default constructor for singleton, creates single jpaEm instance for
* user ID -1, rights are defined in server-side persistence.xml
*/
private EntityManagerBase() {
String persistenceUnitName = Config.get("pvapp.data.persistence.unitName");
EntityManagerFactory emf = Persistence.createEntityManagerFactory(persistenceUnitName);
EntityManager em = emf.createEntityManager();
JpaEntityManager jpaEm = JpaHelper.getEntityManager(em);
jpaEms.put(-1, jpaEm);
}
public static EntityManagerBase getInstance() {
return instance;
}
/**
* Prevent cloning of singleton instance
*/
#Override
protected Object clone() throws CloneNotSupportedException {
String name = this.getClass().getCanonicalName();
throw new CloneNotSupportedException(name
+ " does not support clone(). Use " + name
+ ".getInstance() instead.");
}
public void createJpaEntityManager(JpaSession session, Credentials credentials) {
String persistenceUnitName = Config.get("pvapp.data.persistence.unitName");
EntityManagerFactory emf = Persistence.createEntityManagerFactory(persistenceUnitName);
HashMap<String, String> properties = new HashMap<>();
properties.put("javax.persistence.jdbc.user", credentials.getUserName());
properties.put("javax.persistence.jdbc.password", credentials.getPassword());
EntityManager em = emf.createEntityManager(properties);
JpaEntityManager jpaEm = JpaHelper.getEntityManager(em);
jpaEms.put(session.getUser().getId(), jpaEm);
}
public JpaEntityManager getJpaEntityManager(JpaSession session) {
return this.jpaEms.get(session.getUser().getId());
}
/**
* Get a JPA entity manager for a numeric user id
*
* #param id
* #return
*/
public JpaEntityManager getJpaEntityManager(int id) {
return this.jpaEms.get(id);
}
}
So, when a user logs in, createJpaEntityManager is being called, the newly created JpaEntityManager is being stored in a Hashtable with his userId. This works fine for retrieving default POJOs, but if we have relations to other objects, like that:
import java.io.Serializable;
import java.util.List;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.NamedQueries;
import javax.persistence.NamedQuery;
import javax.persistence.OneToMany;
import javax.persistence.Table;
import javax.xml.bind.annotation.XmlRootElement;
import application.auth.general.Authorizable;
import static javax.persistence.FetchType.EAGER;
/**
* The persistent class for the modulesignature database table.
*
*/
#Entity(name="JpaModuleSignature")
#Table(name="modulesignature")
#XmlRootElement
#NamedQueries({
#NamedQuery(name="JpaModuleSignature.findAll", query="SELECT m FROM JpaModuleSignature m"),
#NamedQuery(name="JpaModuleSignature.findById", query="SELECT m FROM JpaModuleSignature m WHERE m.id = :id")
})
public class JpaModuleSignature implements Serializable, Authorizable, JpaRecord {
private static final long serialVersionUID = 1L;
#Id
#GeneratedValue(strategy=GenerationType.IDENTITY)
#Column(name="id")
private int id;
#Column(name="authObjId")
private int authObjId;
#Column(name="className")
private String className;
#Column(name="version")
private int version;
//bi-directional many-to-one association to JpaMenuItem
#OneToMany(mappedBy="moduleSignature", fetch = EAGER)
private List<JpaMenuItem> menuItems;
public JpaModuleSignature() {
}
public int getId() {
return this.id;
}
public void setId(int id) {
this.id = id;
}
public int getAuthObjId() {
return this.authObjId;
}
public void setAuthObjId(int authObjId) {
this.authObjId = authObjId;
}
public String getClassName() {
return this.className;
}
public void setClassName(String className) {
this.className = className;
}
public int getVersion() {
return this.version;
}
public void setVersion(int version) {
this.version = version;
}
public List<JpaMenuItem> getMenuItems() {
return this.menuItems;
}
public void setMenuItems(List<JpaMenuItem> menuItems) {
this.menuItems = menuItems;
}
public JpaMenuItem addMenuItem(JpaMenuItem menuItem) {
getMenuItems().add(menuItem);
menuItem.setModuleSignature(this);
return menuItem;
}
public JpaMenuItem removeMenuItem(JpaMenuItem menuItem) {
getMenuItems().remove(menuItem);
menuItem.setModuleSignature(null);
return menuItem;
}
}
Let's say we proceed as follows - determine the user's id and fetch the correct JpaEntityManager (unfortunately, some more code is necessary for that):
First the Jersey 2.0-Webservice, which is rather unspectacular:
import java.util.List;
import javax.ws.rs.GET;
import javax.ws.rs.POST;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;
import javax.ws.rs.QueryParam;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.ext.Provider;
import application.data.model.JpaMenuItem;
import application.data.model.JpaModuleSignature;
import application.data.model.JpaSession;
import application.logger.Logger;
import application.server.storage.GenericStorage;
/**
*/
#Provider
#Path("JpaModuleSignature")
public class ModuleSignatureService extends AbstractService {
/**
* Storage unit dealing with storage of the JPA entities
*/
//private ModuleSignatureStorage storage = ModuleSignatureStorage.getInstance();
private GenericStorage<JpaModuleSignature> storage =
GenericStorage.createInstance(JpaModuleSignature.class);
/**
* Include application.data.model classes
*/
public ModuleSignatureService() {
super();
}
/**
* Get a list of all ModuleSignatures in the database
*
* #return list of ModuleSignatures
*/
#Produces(MediaType.APPLICATION_XML)
#Path("list")
#GET
public JpaModuleSignature[] getModuleSignatures(#QueryParam("sessionId") String sessionId) {
Logger.getInstance().setVerbosity((byte) 3);
JpaSession session = this.getSession(sessionId);
List<JpaModuleSignature> ms = storage.getList(session);
Logger.getInstance().log("-----3-----");
for (int i = 0; i < ms.size(); i++) {
Logger.getInstance().log("signature #" + i + ": " + ms.get(i).getTitle());
List<JpaMenuItem> menuItems = ms.get(i).getMenuItems();
for (int j = 0; j < menuItems.size(); j++) {
Logger.getInstance().log("menu item #" + i + "-" + j + ": " + menuItems.get(j));
}
}
Logger.getInstance().log("-----4-----");
JpaModuleSignature ret[] = new JpaModuleSignature[0];
return ms.toArray(ret);
}
}
There's a callback to our generic storage, which contains the call to the user-specific JpaEntityManager (just look at the one line in getList where StorageBase is called statically:
import java.util.Hashtable;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import javax.persistence.Entity;
import javax.persistence.Query;
import org.eclipse.persistence.jpa.JpaEntityManager;
import application.auth.general.Authorizable;
import application.data.model.JpaRecord;
import application.data.model.JpaSession;
import application.logger.Logger;
import application.server.auth.AuthorizationManager;
public class GenericStorage<T> extends StorageBase {
/**
* This is an internal variable in order to store the class
* of the generic object. It is used as a helper later in the code
*/
private final Class<T> storageClass;
/**
* The constructor has only "protected" visibility so the formal type
* parameter has to be specified via createClient
*
* #param clientClass
*/
protected GenericStorage(Class<T> storageClass) {
this.storageClass = storageClass;
}
/**
* Static method for creating instances of GenericStorage.
*
* #param className
* #return
*/
public static <U> GenericStorage<U> createInstance(Class<U> className) {
return new GenericStorage<U>(className);
}
/**
* Get a list of all items
*
* #return
*/
public List<T> getList(JpaSession session) {
return this.getList(session, null);
}
public List<T> getList(JpaSession session, Hashtable<String,Object> parameters) {
Entity e = (Entity) this.storageClass.getAnnotation(Entity.class);
String entityName = e.name();
String queryString = "SELECT r FROM " + entityName + " r";
if (parameters != null && parameters.size() > 0) {
String where = " WHERE ";
Set<String> paramKeys = parameters.keySet();
Iterator<String> i = paramKeys.iterator();
while (i.hasNext()) {
String key = i.next();
where += key + " = :" + key;
}
queryString += where;
}
// GET USER-SPECIFIC JpaEntityManager HERE:
JpaEntityManager jpaEm = StorageBase.getJpaEM(session);
Query query = jpaEm.createQuery(queryString);
Logger.getInstance().log("-----1-----");
if (parameters != null && parameters.size() > 0) {
Set<String> paramKeys = parameters.keySet();
Iterator<String> i = paramKeys.iterator();
while (i.hasNext()) {
String key = i.next();
query.setParameter(key, parameters.get(key));
}
}
List<T> L = (List<T>) query.getResultList();
Logger.getInstance().log("-----2----- (" + entityName + ")");
return L;
}
}
Code for StorageBase:
import org.eclipse.persistence.jpa.JpaEntityManager;
import application.data.model.JpaSession;
/**
* Implements general functionality for retrieval of
* user specific JpaEntityManager instances using the
* EntityManagerBase
*/
abstract class StorageBase {
public static JpaEntityManager getJpaEM(JpaSession session) {
return EntityManagerBase.getInstance().getJpaEntityManager(session);
}
public static JpaEntityManager getJpaEM(int id) {
return EntityManagerBase.getInstance().getJpaEntityManager(id);
}
}
If there are any questions what "AbstractService" does - not really necessary to read, it just calls Jersey's 'this.packages(..)' and provides a method to get a JPA Session object by the user's provided session id.
The problem is, that, if we run getModuleSignatures of the ModuleSignatureService, something odd happens: The JpaModuleSignature can basically be retrieved via the correct JpaEntityManager, but when trying to access the linked attribute "menuItems", we get the following error:
INFO: [EL Severe]: 2013-10-09 16:50:24.34--ServerSession(1625769026)--Exception [EclispseLink-4002] (Eclipse Persistence Services - 2.5.0.v20130507-3faac2b): org.eclipe.persistence.exceptions.DatabaseException
Internal Exception: java.sql.SQLException: Access denied for user 'PERSISTENCE.XML-USER'#'localhost' (using password: YES)
Error Code: 1045
Of course the real username is not PERSISTENCE.XML-USER - but it is the one that has been defined in the persistence.xml. We double-checked that the original records are being fetched by the correct user that authorized against the datebase system. However, JPA apparently tries to fetch the linked records via the wrong JpaEntityManager.
Can anyone explain if there is some error on our side, if that is a known problem, or something else that might help?
Thanks in advance.

Answer 1

EMFs wrap shared resources, so as long as the EMF context exists for this persistence unit, the base EMF is used with the base login properties. You will need to setup EclipseLink so that it uses exclusive connections rather than shared connections as described here http://wiki.eclipse.org/EclipseLink/Examples/JPA/Auditing