/** Register a transaction synchronization callback with a context. */ protected void register(EntityEnterpriseContext ctx, Transaction tx) { boolean trace = log.isTraceEnabled(); if (trace) log.trace("register, ctx=" + ctx + ", tx=" + tx); EntityContainer ctxContainer = null; try { ctxContainer = (EntityContainer) ctx.getContainer(); if (!ctx.hasTxSynchronization()) { // Create a new synchronization Synchronization synch = createSynchronization(tx, ctx); // We want to be notified when the transaction commits tx.registerSynchronization(synch); ctx.hasTxSynchronization(true); } // mark it dirty in global tx entity map if it is not read only if (!ctxContainer.isReadOnly()) { ctx.getTxAssociation().scheduleSync(tx, ctx); } } catch (RollbackException e) { // The state in the instance is to be discarded, we force a reload of state synchronized (ctx) { ctx.setValid(false); ctx.hasTxSynchronization(false); ctx.setTransaction(null); ctx.setTxAssociation(GlobalTxEntityMap.NONE); } throw new EJBException(e); } catch (Throwable t) { // If anything goes wrong with the association remove the ctx-tx association ctx.hasTxSynchronization(false); ctx.setTxAssociation(GlobalTxEntityMap.NONE); if (t instanceof RuntimeException) throw (RuntimeException) t; else if (t instanceof Error) throw (Error) t; else if (t instanceof Exception) throw new EJBException((Exception) t); else throw new NestedRuntimeException(t); } }
public Object invoke(Invocation mi) throws Exception { // We are going to work with the context a lot EntityEnterpriseContext ctx = (EntityEnterpriseContext) mi.getEnterpriseContext(); // The Tx coming as part of the Method Invocation Transaction tx = mi.getTransaction(); if (log.isTraceEnabled()) log.trace("invoke called for ctx " + ctx + ", tx=" + tx); if (!ctx.isValid()) { container.getPersistenceManager().loadEntity(ctx); ctx.setValid(true); } // mark the context as read only if this is a readonly method and the context // was not already readonly boolean didSetReadOnly = false; if (!ctx.isReadOnly() && (container.isReadOnly() || container.getBeanMetaData().isMethodReadOnly(mi.getMethod()))) { ctx.setReadOnly(true); didSetReadOnly = true; } // So we can go on with the invocation // Invocation with a running Transaction try { if (tx != null && tx.getStatus() != Status.STATUS_NO_TRANSACTION) { // readonly does not synchronize, lock or belong with transaction. boolean isReadOnly = container.isReadOnly(); if (isReadOnly == false) { Method method = mi.getMethod(); if (method != null) isReadOnly = container.getBeanMetaData().isMethodReadOnly(method.getName()); } try { if (isReadOnly == false) { // register the wrapper with the transaction monitor (but only // register once). The transaction demarcation will trigger the // storage operations register(ctx, tx); } // Invoke down the chain Object retVal = getNext().invoke(mi); // Register again as a finder in the middle of a method // will de-register this entity, and then the rest of the method can // change fields which will never be stored if (isReadOnly == false) { // register the wrapper with the transaction monitor (but only // register once). The transaction demarcation will trigger the // storage operations register(ctx, tx); } // return the return value return retVal; } finally { // We were read-only and the context wasn't already synchronized, tidyup the cache if (isReadOnly && ctx.hasTxSynchronization() == false) { switch (commitOption) { // Keep instance active, but invalidate state case ConfigurationMetaData.B_COMMIT_OPTION: // Invalidate state (there might be other points of entry) ctx.setValid(false); break; // Invalidate everything AND Passivate instance case ConfigurationMetaData.C_COMMIT_OPTION: try { // FIXME: We cannot passivate here, because previous // interceptors work with the context, in particular // the re-entrance interceptor is doing lock counting // Just remove it from the cache if (ctx.getId() != null) container.getInstanceCache().remove(ctx.getId()); } catch (Exception e) { log.debug("Exception releasing context", e); } break; } } } } else { // No tx try { Object result = getNext().invoke(mi); // Store after each invocation -- not on exception though, or removal // And skip reads too ("get" methods) if (ctx.getId() != null && !container.isReadOnly()) { container.invokeEjbStore(ctx); container.storeEntity(ctx); } return result; } catch (Exception e) { // Exception - force reload on next call ctx.setValid(false); throw e; } finally { switch (commitOption) { // Keep instance active, but invalidate state case ConfigurationMetaData.B_COMMIT_OPTION: // Invalidate state (there might be other points of entry) ctx.setValid(false); break; // Invalidate everything AND Passivate instance case ConfigurationMetaData.C_COMMIT_OPTION: try { // Do not call release if getId() is null. This means that // the entity has been removed from cache. // release will schedule a passivation and this removed ctx // could be put back into the cache! // This is necessary because we have no lock, we // don't want to return an instance to the pool that is // being used if (ctx.getId() != null) container.getInstanceCache().remove(ctx.getId()); } catch (Exception e) { log.debug("Exception releasing context", e); } break; } } } } finally { // if we marked the context as read only we need to reset it if (didSetReadOnly) { ctx.setReadOnly(false); } } }