public async Task testUpdateConflict()
{
var zk = await createClient();
Assert.assertNull(await zk.existsAsync("/multi", null));
try
{
await multiAsync(zk, Arrays.asList(
Op.create("/multi", new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT),
Op.setData("/multi", "X".UTF8getBytes(), 0),
Op.setData("/multi", "Y".UTF8getBytes(), 0)
));
Assert.fail("Should have thrown a KeeperException for invalid version");
}
catch (KeeperException e)
{
//PASS
LOG.error("STACKTRACE: " + e);
}
Assert.assertNull(await zk.existsAsync("/multi", null));
//Updating version solves conflict -- order matters
await multiAsync(zk, Arrays.asList(
Op.create("/multi", new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT),
Op.setData("/multi", "X".UTF8getBytes(), 0),
Op.setData("/multi", "Y".UTF8getBytes(), 1)
));
Assert.assertEquals((await zk.getDataAsync("/multi", false)).Data, "Y".UTF8getBytes());
}
public async Task testMultiRollback()
{
var zk = await createClient();
await zk.createAsync("/foo", new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
ZooKeeper epheZk = await createClient();
await epheZk.createAsync("/foo/bar", new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL);
List <Op> opList = Arrays.asList(Op.delete("/foo", -1));
try
{
await multiAsync(zk, opList);
Assert.fail("multi delete should failed for not empty directory");
}
catch (KeeperException.NotEmptyException)
{
}
var hasBeenDeleted = new HasBeenDeletedWatcher();
await zk.existsAsync("/foo/bar", hasBeenDeleted);
await epheZk.closeAsync();
await hasBeenDeleted.triggered.WaitAsync();
try
{
await zk.getDataAsync("/foo/bar", false);
Assert.fail("ephemeral node should have been deleted");
}
catch (KeeperException.NoNodeException)
{
}
await multiAsync(zk, opList);
try
{
await zk.getDataAsync("/foo", false);
Assert.fail("persistent node should have been deleted after multi");
}
catch (KeeperException.NoNodeException)
{
}
}
public async Task testInvalidVersion()
{
var zk = await createClient();
try
{
await multiAsync(zk, Arrays.asList(
Op.create("/multi", new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT),
Op.delete("/multi", 1)
));
Assert.fail("delete /multi should have failed");
}
catch (KeeperException)
{
/* PASS */
}
}
private async Task multiHavingErrors(ZooKeeper zk, List <Op> ops, List <KeeperException.Code> expectedResultCodes)
{
try
{
await multiAsync(zk, ops);
Assert.fail("Shouldn't have validated in ZooKeeper client!");
}
catch (KeeperException e)
{
var results = e.getResults();
for (int i = 0; i < results.Count; i++)
{
OpResult opResult = results[i];
Assert.assertTrue("Did't recieve proper error response", opResult is OpResult.ErrorResult);
OpResult.ErrorResult errRes = (OpResult.ErrorResult)opResult;
Assert.assertEquals("Did't recieve proper error code", expectedResultCodes[i], errRes.getErr());
}
}
}
public async Task TestDeleteUpdateConflict()
{
var zk = await createClient();
/* Delete of a node folowed by an update of the (now) deleted node */
try
{
await multiAsync(zk, Arrays.asList(
Op.create("/multi", new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT),
Op.delete("/multi", 0),
Op.setData("/multi", "Y".UTF8getBytes(), 0)
));
Assert.fail("/multi should have been deleted so setData should have failed");
}
catch (KeeperException)
{
/* PASS */
}
// '/multi' should never have been created as entire op should fail
Assert.assertNull(await zk.existsAsync("/multi", null));
}
public async Task TestGetResults()
{
var zk = await createClient();
/* Delete of a node folowed by an update of the (now) deleted node */
var ops = Arrays.asList(
Op.create("/multi", new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT),
Op.delete("/multi", 0),
Op.setData("/multi", "Y".UTF8getBytes(), 0),
Op.create("/foo", new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT)
);
List <OpResult> results = null;
try
{
await zk.multiAsync(ops);
Assert.fail("/multi should have been deleted so setData should have failed");
}
catch (KeeperException e)
{
// '/multi' should never have been created as entire op should fail
Assert.assertNull(await zk.existsAsync("/multi", null));
results = e.getResults();
}
Assert.assertNotNull(results);
foreach (OpResult r in results)
{
LOG.info("RESULT==> " + r);
if (r is OpResult.ErrorResult)
{
OpResult.ErrorResult er = (OpResult.ErrorResult)r;
LOG.info("ERROR RESULT: " + er + " ERR=>" + EnumUtil <KeeperException.Code> .DefinedCast(er.getErr()));
}
}
}
public async Task testNoWatchesTriggeredForFailedMultiRequest()
{
var zk = await createClient();
HasTriggeredWatcher watcher = new HasTriggeredWatcher();
await zk.getChildrenAsync("/", watcher);
try
{
await multiAsync(zk, Arrays.asList(
Op.create("/t", new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT),
Op.delete("/nonexisting", -1)
));
Assert.fail("expected previous multi op to fail!");
}
catch (KeeperException.NoNodeException)
{
// expected
}
// by waiting for the callback we're assured that the event queue is flushed
Assert.assertTrue(await zk.sync("/").WithTimeout(CONNECTION_TIMEOUT));
}
public async Task testTransactionBuilder()
{
var zk = await createClient();
List <OpResult> results = await commitAsync(zk.transaction()
.create("/t1", new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT)
.create("/t1/child", new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT)
.create("/t2", null, ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL));
Assert.assertEquals(3, results.Count);
foreach (OpResult r in results)
{
OpResult.CreateResult c = (OpResult.CreateResult)r;
Assert.assertTrue(c.getPath().StartsWith("/t"));
Assert.assertNotNull(c.ToString());
}
Assert.assertNotNull(await zk.existsAsync("/t1", false));
Assert.assertNotNull(await zk.existsAsync("/t1/child", false));
Assert.assertNotNull(await zk.existsAsync("/t2", false));
results = await commitAsync(zk.transaction()
.check("/t1", 0)
.check("/t1/child", 0)
.check("/t2", 0));
Assert.assertEquals(3, results.Count);
foreach (OpResult r in results)
{
OpResult.CheckResult c = (OpResult.CheckResult)r;
Assert.assertNotNull(c.ToString());
}
try
{
await commitAsync(zk.transaction()
.check("/t1", 0)
.check("/t1/child", 0)
.check("/t2", 1));
Assert.fail();
}
catch (KeeperException.BadVersionException)
{
// expected
}
results = await commitAsync(zk.transaction()
.check("/t1", 0)
.setData("/t1", new byte[0], 0));
Assert.assertEquals(2, results.Count);
foreach (OpResult r in results)
{
Assert.assertNotNull(r.ToString());
}
try
{
results = await commitAsync(zk.transaction()
.check("/t1", 1)
.setData("/t1", new byte[0], 2));
Assert.fail();
}
catch (KeeperException.BadVersionException)
{
// expected
}
results = await commitAsync(zk.transaction()
.check("/t1", 1)
.check("/t1/child", 0)
.check("/t2", 0));
Assert.assertEquals(3, results.Count);
results = await commitAsync(zk.transaction()
.delete("/t2", -1)
.delete("/t1/child", -1));
Assert.assertEquals(2, results.Count);
foreach (OpResult r in results)
{
OpResult.DeleteResult d = (OpResult.DeleteResult)r;
Assert.assertNotNull(d.ToString());
}
Assert.assertNotNull(await zk.existsAsync("/t1", false));
Assert.assertNull(await zk.existsAsync("/t1/child", false));
Assert.assertNull(await zk.existsAsync("/t2", false));
}
