public List<OpResult> commit() throws InterruptedException, KeeperException { return zk.multi(ops); }
public void commit(MultiCallback cb, Object ctx) { zk.multi(ops, cb, ctx); } }
public List<OpResult> commit() throws InterruptedException, KeeperException { return zk.multi(ops); }
public void commit(MultiCallback cb, Object ctx) { zk.multi(ops, cb, ctx); } }
@Override public Future<Void> execute() { if (!done.compareAndSet(false, true)) { return result; } try { zkc.get().multi(zkOps, this, result); } catch (ZooKeeperClient.ZooKeeperConnectionException e) { result.setException(FutureUtils.zkException(e, "")); } catch (InterruptedException e) { result.setException(FutureUtils.zkException(e, "")); } return result; }
public void verifyMultiFailure_NoSideEffect() throws KeeperException, InterruptedException { List<Op> ops = Arrays.asList( Op.create("/multi", new byte[0], Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT), Op.delete("/nonexist1", -1)); zk.multi(ops, this, null); latch_await(); Assert.assertTrue(this.opResults.get(0) instanceof OpResult.ErrorResult); Assert.assertNull(zk.exists("/multi", false)); }
public void verifyMultiFailure_AllErrorResult() { List<Op> ops = Arrays.asList( Op.create("/multi", new byte[0], Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT), Op.delete("/nonexist1", -1), Op.setData("/multi", "test".getBytes(), -1)); zk.multi(ops, this, null); latch_await(); Assert.assertTrue(this.opResults.get(0) instanceof OpResult.ErrorResult); Assert.assertTrue(this.opResults.get(1) instanceof OpResult.ErrorResult); Assert.assertTrue(this.opResults.get(2) instanceof OpResult.ErrorResult); }
private List<OpResult> multi(ZooKeeper zk, Iterable<Op> ops) throws KeeperException, InterruptedException { if (useAsync) { final MultiResult res = new MultiResult(); zk.multi(ops, 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 zk.multi(ops); } }
public void verifyMulti() { List<Op> ops = Arrays.asList( Op.create("/multi", new byte[0], Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT), Op.delete("/multi", -1)); zk.multi(ops, this, null); latch_await(); Assert.assertEquals(this.rc, KeeperException.Code.OK.intValue()); Assert.assertTrue(this.opResults.get(0) instanceof OpResult.CreateResult); Assert.assertTrue(this.opResults.get(1) instanceof OpResult.DeleteResult); }
public void verifyMultiSequential_NoSideEffect() throws Exception{ StringCB scb = new StringCB(zk); scb.verifyCreate(); String path = scb.path + "-"; String seqPath = path + "0000000002"; zk.create(path, new byte[0], Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT_SEQUENTIAL); Assert.assertNotNull(zk.exists(path + "0000000001", false)); List<Op> ops = Arrays.asList( Op.create(path , new byte[0], Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT_SEQUENTIAL), Op.delete("/nonexist", -1)); zk.multi(ops, this, null); latch_await(); Assert.assertNull(zk.exists(seqPath, false)); zk.create(path, new byte[0], Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT_SEQUENTIAL); Assert.assertNotNull(zk.exists(seqPath, false)); } }
@Test(timeout = 30000) public void testMultiWithContainerSimple() throws KeeperException, InterruptedException { Op createContainer = Op.create("/foo", new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.CONTAINER); zk.multi(Collections.singletonList(createContainer)); DataTree dataTree = serverFactory.getZooKeeperServer().getZKDatabase().getDataTree(); Assert.assertEquals(dataTree.getContainers().size(), 1); }
zk[followerA].multi(Arrays.asList( Op.create(node1, node1.getBytes(), Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT),
watcher.waitForConnected(CONNECTION_TIMEOUT); zk.multi(Arrays.asList( Op.create("/multi0", new byte[0], Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT), Op.create("/multi1", new byte[0], Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT),
@Test public void ephemeralCreateMultiOpTest() throws KeeperException, InterruptedException, IOException { final ZooKeeper zk = createClient(); String data = "test"; String path = "/ephemeralcreatemultiop"; zk.create(path, new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT); QuorumZooKeeperServer server = getConnectedServer(zk.getSessionId()); Assert.assertNotNull("unable to find server interlocutor", server); UpgradeableSessionTracker sessionTracker = (UpgradeableSessionTracker)server.getSessionTracker(); Assert.assertFalse("session already global", sessionTracker.isGlobalSession(zk.getSessionId())); List<OpResult> multi = null; try { multi = zk.multi(Arrays.asList( Op.setData(path, data.getBytes(), 0), Op.create(path + "/e", data.getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL), Op.create(path + "/p", data.getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT), Op.create(path + "/q", data.getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL) )); } catch (KeeperException.SessionExpiredException e) { // the scenario that inspired this unit test Assert.fail("received session expired for a session promotion in a multi-op"); } Assert.assertNotNull(multi); Assert.assertEquals(4, multi.size()); Assert.assertEquals(data, new String(zk.getData(path + "/e", false, null))); Assert.assertEquals(data, new String(zk.getData(path + "/p", false, null))); Assert.assertEquals(data, new String(zk.getData(path + "/q", false, null))); Assert.assertTrue("session not promoted", sessionTracker.isGlobalSession(zk.getSessionId())); }
zk.getSessionId(), zk.getSessionPasswd()); zknew.multi(Arrays.asList( Op.create("/testSessionMovedWithMultiOp-1", new byte[0], Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL) ));
@Test(timeout = 30000) public void testMultiWithContainer() throws KeeperException, InterruptedException { Op createContainer = Op.create("/foo", new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.CONTAINER); Op createChild = Op.create("/foo/bar", new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT); zk.multi(Arrays.asList(createContainer, createChild)); DataTree dataTree = serverFactory.getZooKeeperServer().getZKDatabase().getDataTree(); Assert.assertEquals(dataTree.getContainers().size(), 1); zk.delete("/foo/bar", -1); // should cause "/foo" to get deleted when checkContainers() is called ContainerManager containerManager = new ContainerManager(serverFactory.getZooKeeperServer() .getZKDatabase(), serverFactory.getZooKeeperServer().firstProcessor, 1, 100); containerManager.checkContainers(); Thread.sleep(1000); Assert.assertNull("Container should have been deleted", zk.exists("/foo", false)); createContainer = Op.create("/foo", new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.CONTAINER); createChild = Op.create("/foo/bar", new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT); Op deleteChild = Op.delete("/foo/bar", -1); zk.multi(Arrays.asList(createContainer, createChild, deleteChild)); containerManager.checkContainers(); Thread.sleep(1000); Assert.assertNull("Container should have been deleted", zk.exists("/foo", false)); }
if (useAsync) { final MultiResult res = new MultiResult(); zk.multi(ops, new MultiCallback() { @Override public void processResult(int rc, String path, Object ctx, } else { try { zk.multi(ops); Assert.fail("/multi should have been deleted so setData should have failed"); } catch (KeeperException e) {
/** * Run multiple operations in a transactional manner. Retry before throwing exception */ public List<OpResult> multi(Iterable<Op> ops) throws KeeperException, InterruptedException { try (TraceScope scope = TraceUtil.createTrace("RecoverableZookeeper.multi")) { RetryCounter retryCounter = retryCounterFactory.create(); Iterable<Op> multiOps = prepareZKMulti(ops); while (true) { try { long startTime = EnvironmentEdgeManager.currentTime(); List<OpResult> opResults = checkZk().multi(multiOps); return opResults; } catch (KeeperException e) { switch (e.code()) { case CONNECTIONLOSS: retryOrThrow(retryCounter, e, "multi"); break; case OPERATIONTIMEOUT: retryOrThrow(retryCounter, e, "multi"); break; default: throw e; } } retryCounter.sleepUntilNextRetry(); } } }