@Test void deleteNonExistingML() throws Exception { MetaStore store = new MetaStoreImplZookeeper(zkc, executor); AtomicReference<MetaStoreException> exception = new AtomicReference<>(); CountDownLatch counter = new CountDownLatch(1); store.removeManagedLedger("non-existing", new MetaStoreCallback<Void>() { @Override public void operationComplete(Void result, Stat version) { counter.countDown(); } @Override public void operationFailed(MetaStoreException e) { exception.set(e); counter.countDown(); } }); counter.await(); assertNotNull(exception.get()); }
(rc, path, ignoreCtx1, name) -> { Runnable retry = () -> { asyncCreateFullPathOptimistic(zk, basePath, nodePath, data, acl, createMode, callback); }; } else { nodeParent = nodeParent.replace("\\", "/"); asyncCreateFullPathOptimistic( zk, basePath, nodeParent, new byte[0], acl, CreateMode.PERSISTENT, (parentRc, parentPath, ignoreCtx3, parentName) -> {
@Override public void asyncGetCursorInfo(String ledgerName, String consumerName, final MetaStoreCallback<ManagedCursorInfo> callback) { String path = prefix + ledgerName + "/" + consumerName; if (log.isDebugEnabled()) { log.debug("Reading from {}", path); } zk.getData(path, false, (rc, path1, ctx, data, stat) -> executor.executeOrdered(ledgerName, safeRun(() -> { if (rc != Code.OK.intValue()) { callback.operationFailed(new MetaStoreException(KeeperException.create(Code.get(rc)))); } else { try { ManagedCursorInfo info = parseManagedCursorInfo(data); callback.operationComplete(info, new ZKStat(stat)); } catch (ParseException | InvalidProtocolBufferException e) { callback.operationFailed(new MetaStoreException(e)); } } })), null); if (log.isDebugEnabled()) { log.debug("Reading from {} ok", path); } }
if (rc == Code.OK.intValue()) { try { ManagedLedgerInfo info = parseManagedLedgerInfo(readData); info = updateMLInfoTimestamp(info); callback.operationComplete(info, new ZKStat(stat)); } catch (ParseException | InvalidProtocolBufferException e) { asyncCreateFullPathOptimistic(zk, prefixName, ledgerName, new byte[0], Acl, CreateMode.PERSISTENT, createcb); } else {
@Override public void getManagedLedgerInfo(final String ledgerName, final MetaStoreCallback<ManagedLedgerInfo> callback) { // Try to get the content or create an empty node zk.getData(prefix + ledgerName, false, (rc, path, ctx, readData, stat) -> executor.submit(safeRun(() -> { if (rc == Code.OK.intValue()) { try { ManagedLedgerInfo info = parseManagedLedgerInfo(readData); info = updateMLInfoTimestamp(info); callback.operationComplete(info, new ZKStat(stat)); } catch (ParseException | InvalidProtocolBufferException e) { callback.operationFailed(new MetaStoreException(e)); } } else if (rc == Code.NONODE.intValue()) { log.info("Creating '{}{}'", prefix, ledgerName); StringCallback createcb = (rc1, path1, ctx1, name) -> { if (rc1 == Code.OK.intValue()) { ManagedLedgerInfo info = ManagedLedgerInfo.getDefaultInstance(); callback.operationComplete(info, new ZKStat()); } else { callback.operationFailed(new MetaStoreException(KeeperException.create(Code.get(rc1)))); } }; ZkUtils.asyncCreateFullPathOptimistic(zk, prefix + ledgerName, new byte[0], Acl, CreateMode.PERSISTENT, createcb, null); } else { callback.operationFailed(new MetaStoreException(KeeperException.create(Code.get(rc)))); } })), null); }
private ManagedCursorInfo parseManagedCursorInfo(byte[] data) throws ParseException, InvalidProtocolBufferException { if (protobufFormat == ZNodeProtobufFormat.Text) { // First try text format, then fallback to binary try { return parseManagedCursorInfoFromText(data); } catch (ParseException e) { return parseManagedCursorInfoFromBinary(data); } } else { // First try binary format, then fallback to text try { return parseManagedCursorInfoFromBinary(data); } catch (InvalidProtocolBufferException e) { return parseManagedCursorInfoFromText(data); } } }
private ManagedLedgerInfo parseManagedLedgerInfo(byte[] data) throws ParseException, InvalidProtocolBufferException { if (protobufFormat == ZNodeProtobufFormat.Text) { // First try text format, then fallback to binary try { return parseManagedLedgerInfoFromText(data); } catch (ParseException e) { return parseManagedLedgerInfoFromBinary(data); } } else { // First try binary format, then fallback to text try { return parseManagedLedgerInfoFromBinary(data); } catch (InvalidProtocolBufferException e) { return parseManagedLedgerInfoFromText(data); } } }
return null; }).when(mockMetaStore).asyncGetCursorInfo(eq(mlName), eq(cursorName), any(MetaStoreCallback.class));
if (rc == Code.OK.intValue()) { try { ManagedLedgerInfo info = parseManagedLedgerInfo(readData); info = updateMLInfoTimestamp(info); callback.operationComplete(info, new ZKStat(stat)); } catch (ParseException | InvalidProtocolBufferException e) { asyncCreateFullPathOptimistic(zk, prefixName, ledgerName, new byte[0], Acl, CreateMode.PERSISTENT, createcb); } else {
@Test void getMLList() throws Exception { MetaStore store = new MetaStoreImplZookeeper(zkc, executor); zkc.failNow(Code.CONNECTIONLOSS); try { store.getManagedLedgers(); fail("should fail in getting the list"); } catch (MetaStoreException e) { // ok } }
@Test(timeOut = 20000) public void createOptimisticBaseNotExist() throws Exception { CompletableFuture<Void> promise = new CompletableFuture<>(); MetaStoreImplZookeeper.asyncCreateFullPathOptimistic( zkc, "/foo", "bar/zar/gar", new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT, (rc, path, ctx, name) -> { if (rc != KeeperException.Code.OK.intValue()) { promise.completeExceptionally(KeeperException.create(rc)); } else { promise.complete(null); } }); try { promise.get(); fail("should have failed"); } catch (ExecutionException ee) { assertEquals(ee.getCause().getClass(), KeeperException.NoNodeException.class); } }
@Override public void asyncGetCursorInfo(String ledgerName, String consumerName, final MetaStoreCallback<ManagedCursorInfo> callback) { String path = prefix + ledgerName + "/" + consumerName; if (log.isDebugEnabled()) { log.debug("Reading from {}", path); } zk.getData(path, false, (rc, path1, ctx, data, stat) -> executor.executeOrdered(ledgerName, safeRun(() -> { if (rc != Code.OK.intValue()) { callback.operationFailed(new MetaStoreException(KeeperException.create(Code.get(rc)))); } else { try { ManagedCursorInfo info = parseManagedCursorInfo(data); callback.operationComplete(info, new ZKStat(stat)); } catch (ParseException | InvalidProtocolBufferException e) { callback.operationFailed(new MetaStoreException(e)); } } })), null); if (log.isDebugEnabled()) { log.debug("Reading from {} ok", path); } }
@Test(timeOut = 20000) void failInCreatingMLnode() throws Exception { MetaStore store = new MetaStoreImplZookeeper(zkc, executor); final CountDownLatch latch = new CountDownLatch(1); zkc.failAfter(1, Code.CONNECTIONLOSS); store.getManagedLedgerInfo("my_test", false, new MetaStoreCallback<MLDataFormats.ManagedLedgerInfo>() { public void operationFailed(MetaStoreException e) { // Ok latch.countDown(); } public void operationComplete(ManagedLedgerInfo result, Stat version) { fail("Operation should have failed"); } }); latch.await(); }
@Test(timeOut = 20000) public void createOptimisticBaseExists() throws Exception { zkc.create("/foo", new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT); CompletableFuture<Void> promise = new CompletableFuture<>(); MetaStoreImplZookeeper.asyncCreateFullPathOptimistic( zkc, "/foo", "bar/zar/gar", new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT, (rc, path, ctx, name) -> { if (rc != KeeperException.Code.OK.intValue()) { promise.completeExceptionally(KeeperException.create(rc)); } else { promise.complete(null); } }); promise.get(); CompletableFuture<Void> promise2 = new CompletableFuture<>(); MetaStoreImplZookeeper.asyncCreateFullPathOptimistic( zkc, "/foo", "blah", new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT, (rc, path, ctx, name) -> { if (rc != KeeperException.Code.OK.intValue()) { promise2.completeExceptionally(KeeperException.create(rc)); } else { promise2.complete(null); } }); promise2.get(); } }
@Override public void asyncGetCursorInfo(String ledgerName, String consumerName, final MetaStoreCallback<ManagedCursorInfo> callback) { String path = prefix + ledgerName + "/" + consumerName; if (log.isDebugEnabled()) { log.debug("Reading from {}", path); } zk.getData(path, false, (rc, path1, ctx, data, stat) -> executor.submit(safeRun(() -> { if (rc != Code.OK.intValue()) { callback.operationFailed(new MetaStoreException(KeeperException.create(Code.get(rc)))); } else { try { ManagedCursorInfo info = parseManagedCursorInfo(data); callback.operationComplete(info, new ZKStat(stat)); } catch (ParseException | InvalidProtocolBufferException e) { callback.operationFailed(new MetaStoreException(e)); } } })), null); if (log.isDebugEnabled()) { log.debug("Reading from {} ok", path); } }
@Test(timeOut = 20000) void readMalformedML() throws Exception { MetaStore store = new MetaStoreImplZookeeper(zkc, executor); zkc.create("/managed-ledgers/my_test", "non-valid".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT); final CountDownLatch latch = new CountDownLatch(1); store.getManagedLedgerInfo("my_test", false, new MetaStoreCallback<MLDataFormats.ManagedLedgerInfo>() { public void operationFailed(MetaStoreException e) { // Ok latch.countDown(); } public void operationComplete(ManagedLedgerInfo result, Stat version) { fail("Operation should have failed"); } }); latch.await(); }
(rc, path, ignoreCtx1, name) -> { Runnable retry = () -> { asyncCreateFullPathOptimistic(zk, basePath, nodePath, data, acl, createMode, callback); }; } else { nodeParent = nodeParent.replace("\\", "/"); asyncCreateFullPathOptimistic( zk, basePath, nodeParent, new byte[0], acl, CreateMode.PERSISTENT, (parentRc, parentPath, ignoreCtx3, parentName) -> {
@Test(timeOut = 20000) void readMalformedCursorNode() throws Exception { MetaStore store = new MetaStoreImplZookeeper(zkc, executor); zkc.create("/managed-ledgers/my_test", "".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT); zkc.create("/managed-ledgers/my_test/c1", "non-valid".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT); final CountDownLatch latch = new CountDownLatch(1); store.asyncGetCursorInfo("my_test", "c1", new MetaStoreCallback<MLDataFormats.ManagedCursorInfo>() { public void operationFailed(MetaStoreException e) { // Ok latch.countDown(); } public void operationComplete(ManagedCursorInfo result, Stat version) { fail("Operation should have failed"); } }); latch.await(); }
@Test(timeOut = 20000) void updatingMLNode() throws Exception { final MetaStore store = new MetaStoreImplZookeeper(zkc, executor); zkc.create("/managed-ledgers/my_test", "".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT); final CountDownLatch latch = new CountDownLatch(1); store.getManagedLedgerInfo("my_test", false, new MetaStoreCallback<ManagedLedgerInfo>() { public void operationFailed(MetaStoreException e) { fail("should have succeeded"); } public void operationComplete(ManagedLedgerInfo mlInfo, Stat version) { // Update again using the version zkc.failNow(Code.BADVERSION); store.asyncUpdateLedgerIds("my_test", mlInfo, version, new MetaStoreCallback<Void>() { public void operationFailed(MetaStoreException e) { // ok latch.countDown(); } @Override public void operationComplete(Void result, Stat version) { fail("should have failed"); } }); } }); latch.await(); }
@Test(timeOut = 20000) void updatingCursorNode() throws Exception { final MetaStore store = new MetaStoreImplZookeeper(zkc, executor); zkc.create("/managed-ledgers/my_test", "".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT); final CountDownLatch latch = new CountDownLatch(1); ManagedCursorInfo info = ManagedCursorInfo.newBuilder().setCursorsLedgerId(1).build(); store.asyncUpdateCursorInfo("my_test", "c1", info, null, new MetaStoreCallback<Void>() { public void operationFailed(MetaStoreException e) { fail("should have succeeded"); } public void operationComplete(Void result, Stat version) { // Update again using the version zkc.failNow(Code.CONNECTIONLOSS); ManagedCursorInfo info = ManagedCursorInfo.newBuilder().setCursorsLedgerId(2).build(); store.asyncUpdateCursorInfo("my_test", "c1", info, version, new MetaStoreCallback<Void>() { public void operationFailed(MetaStoreException e) { // ok latch.countDown(); } @Override public void operationComplete(Void result, Stat version) { fail("should have failed"); } }); } }); latch.await(); }