Java TransactionConfig.setDurability方法代码示例

import com.sleepycat.je.TransactionConfig; //导入方法依赖的package包/类
/**
 * Mappings are flushed to disk at close, and at checkpoints.
 */
public void flushToDatabase(Durability useDurability) {
   
    TransactionConfig config = new TransactionConfig();
    config.setDurability(useDurability);
    Txn txn = Txn.createLocalTxn(envImpl, config);
    boolean success = false;
    try {
        flushToDatabase(txn);
        txn.commit();
        success = true;
    } finally {
        if (!success) {
            txn.abort();
        }
    }
}
 

import com.sleepycat.je.TransactionConfig; //导入方法依赖的package包/类
/**
 * Configures a TransactionConfig for auto-commit operations on a
 * non-replicated transactional database on a replicated node. We use:
 * - default SyncPolicy for the environment
 * - ReplicaAckPolicy.NONE to avoid consistency checks on the Master
 * - Consistency.NONE to avoid consistency checks on the Replica
 */
private static void configForNonRepDb(TransactionConfig config,
                                      Durability envDurability) {
    config.setDurability(new Durability
        (envDurability.getLocalSync(), envDurability.getReplicaSync(), 
         Durability.ReplicaAckPolicy.NONE));
    config.setConsistencyPolicy
        (NoConsistencyRequiredPolicy.NO_CONSISTENCY);
}
 

import com.sleepycat.je.TransactionConfig; //导入方法依赖的package包/类
/**
 * Remove all information from the VLSNIndex for VLSNs >= deleteStart
 * Used by replica side syncup, when the log is truncated. Assumes that the
 * vlsnIndex is quiescent.
 * @throws DatabaseException
 */
public synchronized void truncateFromTail(VLSN deleteStart, long lastLsn)
    throws DatabaseException {

    logItemCache.clear();
    VLSNRange currentRange = tracker.getRange();
    if (currentRange.getLast().getNext().equals(deleteStart)) {

        /*
         * deleteStart directly follows what's in this range, no need to
         * delete anything.
         */
        return;
    }

    tracker.truncateFromTail(deleteStart, lastLsn);

    TransactionConfig config = new TransactionConfig();
    
    /* 
     * Be sure to commit synchronously so that changes to the vlsn index
     * are persisted before the log is truncated. There are no feeders or
     * repstream write operations at this time, so the use of COMMIT_SYNC
     * does not introduce any lock contention. [#20702]
     */
    config.setDurability(Durability.COMMIT_SYNC);
    Txn txn = Txn.createLocalTxn(envImpl, config);
    boolean success = false;
    try {
        pruneDatabaseTail(deleteStart, lastLsn, txn);
        flushToDatabase(txn);
        txn.commit();
        success = true;
    } finally {
        if (!success) {
            txn.abort();
        }
    }
}
 

import com.sleepycat.je.TransactionConfig; //导入方法依赖的package包/类
/**
 * Returns all the members that are currently part of the replication
 * group. This method can read the database directly, and can be used when
 * the replicated environment is detached and the RepNode is null. It's for
 * the latter reason that the method reads uncommitted data. In detached
 * mode, there may be transactions on the database that were in progress
 * when the node was last shutdown. These transactions may have locks which
 * will not be released until after the node is re-attached and the
 * replication stream is resumed. Using uncommitted reads avoids use of
 * locks in this circumstance. It's safe to read these records, since the
 * database will eventually be updated with these changes.
 *
 * @param policy determines how current the information must be if it's
 * invoked on a Replica.
 *
 * @return the group object
 * @throws DatabaseException if the object could not be obtained
 */
public static RepGroupImpl getGroup(RepImpl rImpl,
                                    String groupName,
                                    ReplicaConsistencyPolicy policy)
    throws DatabaseException {

    DatabaseImpl dbImpl = null;
    try {
        dbImpl = rImpl.getGroupDb(policy);
    } catch (DatabaseNotFoundException e) {
        /* Creates a temporary placeholder group for use until the real
         * definition comes over the replication stream as part of the
         * replicated group database.
         */
        return new RepGroupImpl(groupName, true);
    }

    TransactionConfig txnConfig = new TransactionConfig();
    txnConfig.setDurability(READ_ONLY.getDurability());
    txnConfig.setConsistencyPolicy(policy);
    txnConfig.setReadUncommitted(true);

    Txn txn = null;
    try {
        txn = new ReadonlyTxn(rImpl, txnConfig);
        RepGroupImpl group = fetchGroup(groupName, dbImpl, txn);
        /* Correct summary info since we are reading uncommitted data */
        group.makeConsistent();
        txn.commit();
        txn = null;

        return group;
    } finally {
        if (txn != null) {
            txn.abort();
        }
    }
}
 

import com.sleepycat.je.TransactionConfig; //导入方法依赖的package包/类
/**
 * Ensures that information about this node, the current master is in the
 * member database. If it isn't, enter it into the database. If the
 * database does not exist, create it as well.
 *
 * Note that this overloading is only used by a node that is the master.
 *
 * @throws DatabaseException
 */
public void addFirstNode()
    throws DatabaseException {

    DbConfigManager configManager = repImpl.getConfigManager();
    String groupName = configManager.get(GROUP_NAME);
    String nodeName = configManager.get(NODE_NAME);

    DatabaseImpl groupDbImpl = repImpl.createGroupDb();

    /* setup the group information as data. */
    GroupBinding groupBinding = new GroupBinding();
    RepGroupImpl repGroup =  new RepGroupImpl(groupName);
    DatabaseEntry groupEntry = new DatabaseEntry();
    groupBinding.objectToEntry(repGroup, groupEntry);

    /* Create the common group entry. */
    TransactionConfig txnConfig = new TransactionConfig();
    txnConfig.setDurability(NO_ACK.getDurability());
    txnConfig.setConsistencyPolicy(NO_CONSISTENCY);
    Txn txn = null;
    Cursor cursor = null;
    try {
        txn = new MasterTxn(repImpl,
                            txnConfig,
                            repImpl.getNameIdPair());

        cursor = makeCursor(groupDbImpl, txn, CursorConfig.DEFAULT);
        OperationStatus status = cursor.put(groupKeyEntry, groupEntry);
        if (status != OperationStatus.SUCCESS) {
            throw EnvironmentFailureException.unexpectedState
                ("Couldn't write first group entry " + status);
        }
        cursor.close();
        cursor = null;
        txn.commit();
        txn = null;
    } finally {
        if (cursor != null) {
            cursor.close();
        }

        if (txn != null) {
            txn.abort();
        }
    }

    ensureMember(new RepNodeImpl(nodeName,
                                 repImpl.getHostName(),
                                 repImpl.getPort()));
}