Examples of org.exolab.castor.persist.LockEngine

org.exolab.castor.persist.LockEngine
LockEngine is a gateway for all the ClassMolders of a persistence storage. It mantains dirty checking cache state and lock, and provides a thread safe enviroment for ClassMolder. LockEngine garantees that no two conflicting operations will be let running concurrently for the same object.
For example, it ensures that exactly one transaction may read (load) exclusively on one object; transaction can not deleted an object while the other is reading it, etc...
It also provides caching for a persistence storage. Different {@link Cache} mechanismscan be specified.
User should not create more than one instance of LockEngine for each persistent storage. So that object can be properly locked and ObjectModifiedException can be avoided.
However, if more than one instance of LockEngine or some other external application run concurrently, if the {@link Persistence} supports dirty checking,like a fully complaint JDBC Relational Database, proper ObjectModifiedException will be thrown to ensure data consistency.
IMPLEMENTATION NOTES:
An object may be persistent in multiple caches at any given time. There is no way to load an object from multiple caches, but an object can be loaded in one engine and then made persistent in another. The engines are totally independent and no conflicts should occur.
Each class hierarchy gets its own cache, so caches can be controlled on a class-by-class basis. @author Assaf Arkin @author Thomas Yip @author Bruce Snyder @version $Revision: 8034 $ $Date: 2006-04-22 11:05:30 -0600 (Sat, 22 Apr 2006) $

                    "persist.objectNotPersistent", object.getClass().getName()
                            .getClass()));
        }


        ClassMolder molder = _tracker.getMolderForObject(object);
        LockEngine engine = molder.getLockEngine();
        OID oid = _tracker.getOIDForObject(object);


        if (_tracker.isDeleted(object)) {
            throw new ObjectDeletedException(Messages.format(
                    "persist.objectDeleted", object.getClass().getName(), oid
                            .getIdentity()));
        }


        // Release the lock, forget about the object in this transaction
        engine.releaseLock(this, oid);
        _tracker.untrackObject(object);


        if (_callback != null) {
            _callback.releasing(object, false);
        } else if (molder != null && molder.getCallback() != null) {

View Full Code Here

                    Object object = todoIterator.next();
                    // Anything not marked 'deleted' or 'creating' is ready to
                    // consider for store.
                    if ((!_tracker.isDeleted(object))
                            && (!_tracker.isCreating(object))) {
                        LockEngine engine =
                            _tracker.getMolderForObject(object).getLockEngine();
                        //_tracker.getMolderForObject(object);
                        OID oid = _tracker.getOIDForObject(object);


                        OID newoid = engine.preStore(this, oid, object, _lockTimeout);
                        if (newoid != null) {
                            _tracker.trackOIDChange(object, engine, oid, newoid);
                            _tracker.markUpdateCacheNeeded(object);
                        }
                    }

View Full Code Here

            boolean isDeleted = _tracker.isDeleted(toPrepare);
            boolean needsPersist = _tracker.isUpdatePersistNeeded(toPrepare);
            boolean needsCache = _tracker.isUpdateCacheNeeded(toPrepare);


            ClassMolder molder = _tracker.getMolderForObject(toPrepare);
            LockEngine engine = molder.getLockEngine();
            OID oid = _tracker.getOIDForObject(toPrepare);


            if (!isDeleted && !isCreating) {
                if (needsPersist) {
                    engine.store(this, oid, toPrepare);
                }
                if (needsCache) {
                    engine.softLock(this, oid, _lockTimeout);
                }
            }


            // do the callback
            if (!isDeleted && _callback != null) {

View Full Code Here

                .getObjectsWithDeletedStateSortedByHighestMolderPriority();
        Iterator it = objectsToDelete.iterator();


        while (it.hasNext()) {
            Object object = it.next();
            LockEngine engine = _tracker.getMolderForObject(object).getLockEngine();
            OID oid = _tracker.getOIDForObject(object);
            engine.delete(this, oid);
        }
    }

View Full Code Here

        Iterator it = readWriteObjects.iterator();
        while (it.hasNext()) {
            Object toCommit = it.next();


            ClassMolder molder = _tracker.getMolderForObject(toCommit);
            LockEngine engine = molder.getLockEngine();
            OID oid = _tracker.getOIDForObject(toCommit);


            if (_tracker.isDeleted(toCommit)) {
                // Object has been deleted inside transaction,
                // engine must forget about it.
                engine.forgetObject(this, oid);
            } else {
                // Object has been created/accessed inside the
                // transaction, release its lock.
                if (_tracker.isUpdateCacheNeeded(toCommit)) {
                    engine.updateCache(this, oid, toCommit);
                }


                engine.releaseLock(this, oid);
            }


            // Call our release callback on all processed objects.
            if (_callback != null) {
                _callback.releasing(toCommit, true);

View Full Code Here

        try {
            Iterator it = readWriteObjects.iterator();
            // First revert all objects
            while (it.hasNext()) {
                Object object = it.next();
                LockEngine engine = _tracker.getMolderForObject(object).getLockEngine();
                oid = _tracker.getOIDForObject(object);
                if (!_tracker.isCreating(object)) {
                    engine.revertObject(this, oid, object);
                }
            }


            // then forget object or release lock on them
            it = readWriteObjects.iterator();
            while (it.hasNext()) {
                Object object = it.next();
                ClassMolder molder = _tracker.getMolderForObject(object);
                LockEngine engine = molder.getLockEngine();
                oid = _tracker.getOIDForObject(object);


                if (!_tracker.isCreating(object)) {
                    if (_tracker.isCreated(object)) {
                        // Object has been created in this transaction,
                        // it no longer exists, forget about it in the engine.
                        engine.forgetObject(this, oid);
                    } else {
                        // Object has been queried (possibly) deleted in this
                        // transaction and release the lock.
                        engine.releaseLock(this, oid);
                    }
                }


                if (_callback != null) {
                    _callback.releasing(object, false);

View Full Code Here

    public final synchronized void expireCache(
            final ClassMolder molder, final Identity identity)
    throws PersistenceException {
        OID oid;
        
        LockEngine engine = molder.getLockEngine();


        if (identity == null) {
            throw new PersistenceException("Identities can't be null!");
        }


        oid = new OID(molder, identity);
        Object trackedObject = _tracker.getObjectForOID(engine, oid, false);
        if (trackedObject == null) {
            try {
                // the call to engine.expireCache may result in a
                // recursive call to this.expireCache, therefore,
                // an entry is added to the object list to prevent
                // infinite loops due to bi-directional references
                _tracker.trackObject(molder, oid, identity);


                if (engine.expireCache(this, oid, _lockTimeout)) {
                    engine.releaseLock(this, oid);
                }
            } catch (LockNotGrantedException except) {
                throw except;
            } finally {
                _tracker.untrackObject(identity);

View Full Code Here

        _operation++;
        Object aObject = supportCGLibObject(object);
        
        // Grab any lockengine/OID information for removal of the nested 
        // engine-oid-object maps.
        LockEngine engine = getMolderForObject(aObject).getLockEngine();
        OID oid = getOIDForObject(aObject);
        
        removeMolderForObject(aObject);
        removeOIDForObject(engine, oid);

View Full Code Here

            
            // TODO [WG] We still might have an option for some serious optimization
            // here if the instance has not been materialized yet.
            Identity identity = cgObject.interceptedIdentity();
            ClassMolder molder = cgObject.interceptedClassMolder();
            LockEngine engine = molder.getLockEngine();
            
            // Get the OID we're looking for.
            OID oid = new OID(molder, identity);
            
            // Retrieve the object for this OID; returns null if there ain't such object

View Full Code Here

0 1

TOP

Related Classes of org.exolab.castor.persist.LockEngine

org.castor.cache.Cache

org.castor.cache.CacheFactoryRegistry

org.castor.core.util.AbstractProperties

org.castor.persist.AbstractTransactionContext

org.castor.persist.cache.CacheEntry

org.castor.persist.ObjectTracker

org.exolab.castor.jdo.engine.OQLQueryImpl

org.exolab.castor.jdo.JDOManager

org.exolab.castor.mapping.AccessMode

org.exolab.castor.persist.spi.Identity

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.