Examples of com.sleepycat.je.txn.HandleLocker

com.sleepycat.je.txn.HandleLocker
Extends BasicLocker to share locks with another Locker that is being used to open a database. HandleLocker holds a read lock on the NameLN for the Database object, to prevent rename, removal or truncation of a database while it is open. The HandleLocker and the Locker used to open the database both hold a NameLN lock at the same time, so they must share locks to avoid conflicts. Accounts for the fact that the Txn may end before this locker ends by only keeping the Txn ID rather than a reference to the Txn object. A reference to a non-tnxl Locker is OK, OTOH, because it is short lived. Handle Locking Overview ------------------------ Environment.openDatabase calls Environment.setupDatabase, which calls Database.initHandleLocker to create the HandleLocker. setupDatabase ensures that the HandleLocker is passed to DbTree.getDb and createDb. These latter methods acquire a read lock on the NameLN for the HandleLocker, in addition to acquiring a read or write lock for the openDatabase locker. If setupDatabase is not successful, it ensures that locks are released via HandleLocker.endOperation. If setupDatabase is successful, the handle is returned by openDatabase, and Database.close must be called to release the lock. The handle lock is released by calling HandleLocker.endOperation. A special case is when a user txn is passed to openDatabase. If the txn aborts, the Database handle must be invalidated. When setupDatabase succeeds it passes the handle to Txn.addOpenedDatabase, which remembers the handle. Txn.abort invalidates the handle. NameLN Migration and LSN Changes [#20617] ----------------------------------------- When the log cleaner migrates a NameLN, its LSN changes and the new LSN is locked on behalf of all existing lockers by CursorImpl.lockAfterLsnChange. lockAfterLsnChange is also used when a dirty deferred-write LN is logged by BIN.logDirtyLN, as part of flushing a BIN during a checkpoint or eviction. Because handle lockers are legitimately very long lived, it is important that lockAfterLsnChange releases the locks on the old LSN, to avoid a steady accumulation of locks in a HandleLocker. Therefore, lockAfterLsnChange will release the lock on the old LSN, for HandleLockers only. Although it may be desirable to release the old LSN lock on other long lived lockers, it is too risky. In an experiment, this caused problems with demotion and upgrade, when a lock being demoted or upgraded was released. Because LSNs can change, it is also important that we don't rely on a single NameLN locker ID (LSN) as a data structure key for handle locks. This was acceptable when a stable Node ID was used as a lock ID, but is no longer appropriate now that mutable LSNs are used as lock IDs.

        /* Perform eviction before each operation that allocates memory. */
        envImpl.criticalEviction(false /*backgroundIO*/);


        DatabaseImpl database = null;
        boolean operationOk = false;
        HandleLocker handleLocker = null;
        final Locker locker = LockerFactory.getWritableLocker
            (this, txn, isInternalDb, dbConfig.getTransactional(),
             autoTxnIsReplicated, null);
        try {


            /*
             * Create the handle locker and lock the NameLN of an existing
             * database.  A read lock on the NameLN is acquired for both locker
             * and handleLocker.  Note: getDb may return a deleted database.
             */
            handleLocker = newDb.initHandleLocker(envImpl, locker);
            database = envImpl.getDbTree().getDb(locker, databaseName,
                                                 handleLocker);


            boolean dbCreated = false;
            final boolean databaseExists =
                (database != null) && !database.isDeleted();


            if (databaseExists) {
                if (dbConfig.getAllowCreate() &&
                    dbConfig.getExclusiveCreate()) {
                    throw new DatabaseExistsException
                        ("Database " + databaseName + " already exists");
                }


                newDb.initExisting(this, locker, database, dbConfig);
            } else {
                /* Release deleted DB. [#13415] */
                envImpl.getDbTree().releaseDb(database);
                database = null;


                if (!isInternalDb &&
                    DbTree.isReservedDbName(databaseName)) {
                    throw new IllegalArgumentException
                        (databaseName + " is a reserved database name.");
                }


                if (!dbConfig.getAllowCreate()) {
                    throw new DatabaseNotFoundException("Database " +
                                                        databaseName +
                                                        " not found.");
                }


                /*
                 * Init a new DB. This calls DbTree.createDb and the new
                 * database is returned.  A write lock on the NameLN is
                 * acquired by locker and a read lock by the handleLocker.
                 */
                database = newDb.initNew(this, locker, databaseName, dbConfig);
                dbCreated = true;
            }


            /*
             * The open is successful.  We add the opened database handle to
             * this environment to track open handles in general, and to the
             * locker so that it can be invalidated by a user txn abort.
             */
            operationOk = true;
            addReferringHandle(newDb);
            locker.addOpenedDatabase(newDb);


            /* Run triggers before any subsequent auto commits. */
            final boolean firstWriteHandle =
                newDb.isWritable() &&
                (newDb.getDatabaseImpl().noteWriteHandleOpen() == 1);


            if (dbCreated || firstWriteHandle) {
                TriggerManager.runOpenTriggers(locker, newDb, dbCreated);
            }
        } finally {


            /*
             * If the open fails, decrement the DB usage count and release
             * handle locks.  In other cases this is done by Database.close()
             * or invalidate(), the latter in the case of a user txn abort.
             */
            if (!operationOk) {
                envImpl.getDbTree().releaseDb(database);
                if (handleLocker != null) {
                    handleLocker.operationEnd(false);
                }
            }


            /*
             * Tell the locker that this operation is over. Some types of

View Full Code Here

TOP

Related Classes of com.sleepycat.je.txn.HandleLocker

com.sleepycat.je.Environment

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.