Java Transaction.commit方法代码示例

import org.apache.zookeeper.Transaction; //导入方法依赖的package包/类
@Test
public void testInvalidTransactionOperation() throws Exception {
  zkClient.create("/transaction", "transaction".getBytes(), OPEN_ACL, CreateMode.PERSISTENT) ;
  Transaction transaction = zkClient.transaction();
  transaction.create("/transaction/good", new byte[0], OPEN_ACL, CreateMode.PERSISTENT);
  transaction.create("/transaction/bad/nested", new byte[0], OPEN_ACL, CreateMode.PERSISTENT);
  KeeperException expectError = null;
  try {
    transaction.commit();
  } catch(KeeperException ex) {
    expectError = ex ;
  }
  Assert.assertNotNull(expectError);
  Assert.assertTrue(expectError instanceof KeeperException.NoNodeException);
  Assert.assertNull(zkClient.exists("/transaction/good", false));
}
 

import org.apache.zookeeper.Transaction; //导入方法依赖的package包/类
/**
 * Test write operations using multi request.
 */
@Test(timeout = 90000)
public void testMultiTransaction() throws Exception {
    CountdownWatcher watcher = new CountdownWatcher();
    ZooKeeper zk = new ZooKeeper(qu.getConnString(), CONNECTION_TIMEOUT,
            watcher, true);
    watcher.waitForConnected(CONNECTION_TIMEOUT); // ensure zk got connected

    final String data = "Data to be read in RO mode";
    final String node1 = "/tnode1";
    final String node2 = "/tnode2";
    zk.create(node1, data.getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE,
            CreateMode.PERSISTENT);

    watcher.reset();
    qu.shutdown(2);
    watcher.waitForConnected(CONNECTION_TIMEOUT);
    Assert.assertEquals("Should be in r-o mode", States.CONNECTEDREADONLY,
            zk.getState());

    // read operation during r/o mode
    String remoteData = new String(zk.getData(node1, false, null));
    Assert.assertEquals("Failed to read data in r-o mode", data, remoteData);

    try {
        Transaction transaction = zk.transaction();
        transaction.setData(node1, "no way".getBytes(), -1);
        transaction.create(node2, data.getBytes(),
                ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
        transaction.commit();
        Assert.fail("Write operation using multi-transaction"
                + " api has succeeded during RO mode");
    } catch (NotReadOnlyException e) {
        // ok
    }

    Assert.assertNull("Should have created the znode:" + node2,
            zk.exists(node2, false));
}
 

import org.apache.zookeeper.Transaction; //导入方法依赖的package包/类
private List<OpResult> commit(Transaction txn)
throws KeeperException, InterruptedException {
    if (useAsync) {
        final MultiResult res = new MultiResult();
        txn.commit(new MultiCallback() {
            @Override
            public void processResult(int rc, String path, Object ctx,
                                      List<OpResult> opResults) {
                synchronized (res) {
                    res.rc = rc;
                    res.results = opResults;
                    res.finished = true;
                    res.notifyAll();
                }
            }
        }, null);
        synchronized (res) {
            while (!res.finished) {
                res.wait();
            }
        }
        if (KeeperException.Code.OK.intValue() != res.rc) {
            KeeperException ke = KeeperException.create(KeeperException.Code.get(res.rc));
            throw ke;
        }
        return res.results;
    } else {
        return txn.commit();
    }
}
 

import org.apache.zookeeper.Transaction; //导入方法依赖的package包/类
@Test
public void testChRootTransaction() throws Exception {
    // creating the subtree for chRoot clients.
    String chRoot = createNameSpace();
    // checking the child version using chRoot client.
    zk_chroot = createClient(this.hostPort + chRoot);
    String childPath = "/myid";
    Transaction transaction = zk_chroot.transaction();
    transaction.create(childPath, new byte[0], Ids.OPEN_ACL_UNSAFE,
            CreateMode.PERSISTENT);
    transaction.check(childPath, 0);
    transaction.setData(childPath, childPath.getBytes(), 0);
    transaction.commit();

    Assert.assertNotNull("zNode is not created under chroot:" + chRoot, zk
            .exists(chRoot + childPath, false));
    Assert.assertNotNull("zNode is not created under chroot:" + chRoot,
            zk_chroot.exists(childPath, false));
    Assert.assertNull("zNode is created directly under '/', ignored configured chroot",
                    zk.exists(childPath, false));
    Assert.assertArrayEquals("zNode data not matching", childPath
            .getBytes(), zk_chroot.getData(childPath, false, null));

    transaction = zk_chroot.transaction();
    // Deleting child using chRoot client.
    transaction.delete(childPath, 1);
    transaction.commit();

    Assert.assertNull("chroot:" + chRoot + " exists after delete", zk
            .exists(chRoot + "/myid", false));
    Assert.assertNull("chroot:" + chRoot + " exists after delete",
            zk_chroot.exists("/myid", false));
}
 

import org.apache.zookeeper.Transaction; //导入方法依赖的package包/类
private static void createLog(ZooKeeperClient zk, URI uri, String logName, String logIdentifier)
        throws Exception {
    final String logRootPath = getLogRootPath(uri, logName, logIdentifier);
    final String logSegmentsPath = logRootPath + LOGSEGMENTS_PATH;
    final String maxTxIdPath = logRootPath + MAX_TXID_PATH;
    final String lockPath = logRootPath + LOCK_PATH;
    final String readLockPath = logRootPath + READ_LOCK_PATH;
    final String versionPath = logRootPath + VERSION_PATH;
    final String allocationPath = logRootPath + ALLOCATION_PATH;

    Utils.zkCreateFullPathOptimistic(zk, logRootPath, new byte[0],
            zk.getDefaultACL(), CreateMode.PERSISTENT);
    Transaction txn = zk.get().transaction();
    txn.create(logSegmentsPath, DLUtils.serializeLogSegmentSequenceNumber(
                    DistributedLogConstants.UNASSIGNED_LOGSEGMENT_SEQNO),
            zk.getDefaultACL(), CreateMode.PERSISTENT);
    txn.create(maxTxIdPath, DLUtils.serializeTransactionId(0L),
            zk.getDefaultACL(), CreateMode.PERSISTENT);
    txn.create(lockPath, DistributedLogConstants.EMPTY_BYTES,
            zk.getDefaultACL(), CreateMode.PERSISTENT);
    txn.create(readLockPath, DistributedLogConstants.EMPTY_BYTES,
            zk.getDefaultACL(), CreateMode.PERSISTENT);
    txn.create(versionPath, ZKLogMetadataForWriter.intToBytes(LAYOUT_VERSION),
            zk.getDefaultACL(), CreateMode.PERSISTENT);
    txn.create(allocationPath, DistributedLogConstants.EMPTY_BYTES,
            zk.getDefaultACL(), CreateMode.PERSISTENT);
    txn.commit();
}
 

import org.apache.zookeeper.Transaction; //导入方法依赖的package包/类
@Test
public void testTransaction() throws Exception {
  zkClient.create("/transaction", "transaction".getBytes(), OPEN_ACL, CreateMode.PERSISTENT) ;
  Transaction transaction = zkClient.transaction();
  transaction.create("/transaction/test", new byte[0], OPEN_ACL, CreateMode.PERSISTENT);
  transaction.create("/transaction/test/nested", new byte[0], OPEN_ACL, CreateMode.PERSISTENT);
  transaction.create("/transaction/test/delete", new byte[0], OPEN_ACL, CreateMode.PERSISTENT);
  transaction.delete("/transaction/test/delete", 0);
  Assert.assertNull(zkClient.exists("/transaction/test", false));
  Assert.assertNull(zkClient.exists("/transaction/test/nested", false));
  transaction.commit();
  Assert.assertNotNull(zkClient.exists("/transaction/test", false));
  Assert.assertNotNull(zkClient.exists("/transaction/test/nested", false));
  Assert.assertNull(zkClient.exists("/transaction/test/delete", false));
}