+ AllocateIdInput allocateIdInput = buildAllocateId(globalPoolName, idKey);
+ Optional<IdPool> expected = Optional.of(globalIdPool);
+ List<IdEntries> idEntries = new ArrayList<IdEntries>();
+ idEntries.add(buildIdEntry(idKey2, idValue));
+ Optional<IdPool> expectedLocalPool = Optional.of(buildLocalIdPool(blockSize, localPoolName, globalPoolName).setIdEntries(idEntries).build());
+ doReturn(Futures.immediateCheckedFuture(expected)).when(mockReadTx).read(
+ LogicalDatastoreType.CONFIGURATION, identifier);
+ doReturn(Futures.immediateCheckedFuture(expectedLocalPool)).when(mockReadTx).read(
+ LogicalDatastoreType.CONFIGURATION, childIdentifier);
+ InstanceIdentifier<IdEntries> idEntriesIdentifier = buildIdEntriesIdentifier(idKey);
+ doReturn(Futures.immediateCheckedFuture(Optional.absent())).when(mockReadTx).read(
+ LogicalDatastoreType.CONFIGURATION, idEntriesIdentifier);
+ InstanceIdentifier<AvailableIdsHolder> availableIdsIdentifier = buildAvailbaleIdsIdentifier(globalPoolName);
+
+ Future<RpcResult<AllocateIdOutput>> result = idManager.allocateId(allocateIdInput);
+ assertTrue(result.get().isSuccessful());
+ assertEquals(0,configDataStore.size());
+ DataObject dataObject = configDataStore.get(childIdentifier);
+ if (dataObject instanceof IdPool) {
+ IdPool pool = (IdPool) dataObject;
+ assertEquals(localPoolName, pool.getPoolName());
+ assertEquals(idStart, pool.getAvailableIdsHolder().getStart().intValue());
+ assertEquals(idStart + blockSize - 1 , pool.getAvailableIdsHolder().getEnd().intValue());
+ assertEquals(idStart, pool.getAvailableIdsHolder().getCursor().intValue());
+ assertEquals(2, pool.getIdEntries().size());
+ }
+ dataObject = configDataStore.get(availableIdsIdentifier);
+ if (dataObject instanceof AvailableIdsHolder) {
+ AvailableIdsHolder availableIds = (AvailableIdsHolder) dataObject;
+ assertEquals(idEnd, availableIds.getEnd().intValue());
+ assertEquals(idStart, availableIds.getStart().intValue());
+ assertEquals(idStart + blockSize - 1, availableIds.getCursor().intValue());
+ }
+ }
+
+ @Test
+ public void testReleaseId() throws Exception {
+ ReleaseIdInput releaseIdInput = createReleaseIdInput(globalPoolName, idKey);
+ List<IdEntries> idEntries = new ArrayList<IdEntries>();
+ idEntries.add(buildIdEntry(idKey, idValue));
+ Optional<IdPool> expectedLocalPool = Optional.of(buildLocalIdPool(blockSize, localPoolName, globalPoolName).setIdEntries(idEntries).build());
+ doReturn(Futures.immediateCheckedFuture(expectedLocalPool)).when(mockReadTx).read(
+ LogicalDatastoreType.CONFIGURATION, childIdentifier);
+ InstanceIdentifier<IdEntries> idEntriesIdentifier = buildIdEntriesIdentifier(idKey);
+ Optional<IdEntries> expectedIdEntry = Optional.of(buildIdEntry(idKey, idValue));
+ doReturn(Futures.immediateCheckedFuture(expectedIdEntry)).when(mockReadTx).read(
+ LogicalDatastoreType.CONFIGURATION, idEntriesIdentifier);
+ Future<RpcResult<Void>> result = idManager.releaseId(releaseIdInput);
+ assertTrue(result.get().isSuccessful());
+ assertEquals(0, configDataStore.size());
+ DataObject idPoolVal = configDataStore.get(childIdentifier);
+ if (idPoolVal instanceof IdPool) {
+ IdPool pool = (IdPool) idPoolVal;
+ assertEquals(0, pool.getIdEntries().size());
+ assertEquals(0, pool.getReleasedIdsHolder().getAvailableIdCount().intValue());
+ assertEquals(idValue, pool.getReleasedIdsHolder().getDelayedIdEntries().get(0).getId().intValue());
+ }
+ }
+
+ @Test
+ public void testCleanupReleasedIds() throws Exception {
+ AllocateIdInput allocateIdInput = buildAllocateId(globalPoolName, idKey2);
+ Optional<ReleasedIdsHolder> expected = Optional.of(createReleasedIdsHolder(0, null, 0));
+ long[] excessIds = new long[] { 1, 2, 3, 4, 5 };
+ List<IdEntries> idEntries = new ArrayList<IdEntries>();
+ idEntries.add(buildIdEntry(idKey2, idValue));
+ ReleasedIdsHolder excessReleasedIds = createReleasedIdsHolder(0, buildDelayedIdEntries(excessIds), (long) 30);
+ Optional<IdPool> expectedLocalPool = Optional.of(buildLocalIdPool(blockSize, localPoolName, globalPoolName)
+ .setIdEntries(idEntries).setReleasedIdsHolder(excessReleasedIds)
+ .build());
+ InstanceIdentifier<ReleasedIdsHolder> releaseIdsIdentifier = buildReleaseIdsIdentifier(globalPoolName);
+ doReturn(Futures.immediateCheckedFuture(expected)).when(mockReadTx)
+ .read(LogicalDatastoreType.CONFIGURATION, releaseIdsIdentifier);
+ doReturn(Futures.immediateCheckedFuture(expectedLocalPool)).when(
+ mockReadTx).read(LogicalDatastoreType.CONFIGURATION,
+ childIdentifier);
+ InstanceIdentifier<IdEntries> idEntriesIdentifier = buildIdEntriesIdentifier(idKey2);
+ doReturn(Futures.immediateCheckedFuture(Optional.absent())).when(
+ mockReadTx).read(LogicalDatastoreType.CONFIGURATION,
+ idEntriesIdentifier);
+
+ Future<RpcResult<AllocateIdOutput>> result = idManager.allocateId(allocateIdInput);
+ assertTrue(result.get().isSuccessful());
+ assertEquals(0, configDataStore.size());
+ DataObject dataObject = configDataStore.get(childIdentifier);
+ if (dataObject instanceof IdPool) {
+ IdPool pool = (IdPool) dataObject;
+ assertEquals(localPoolName, pool.getPoolName());
+ assertEquals(excessIds.length - 3, pool.getReleasedIdsHolder().getAvailableIdCount().intValue());
+ assertEquals(2, pool.getIdEntries().size());
+ }
+ dataObject = configDataStore.get(releaseIdsIdentifier);
+ if (dataObject instanceof ReleasedIdsHolder) {
+ ReleasedIdsHolder releasedIds = (ReleasedIdsHolder) dataObject;
+ assertEquals(2, releasedIds.getAvailableIdCount().intValue());
+ assertEquals(2, releasedIds.getDelayedIdEntries().size());
+ }
+ }
+
+ @Test
+ public void testAllocateIdBlockFromReleasedIds() throws Exception {
+ AllocateIdInput allocateIdInput = buildAllocateId(globalPoolName, globalPoolName);
+ List<DelayedIdEntries> delayedIdEntries = buildDelayedIdEntries(new long[] {1, 2, 3});
+ ReleasedIdsHolder expectedReleasedIds = createReleasedIdsHolder(3, delayedIdEntries , 0);
+ IdPool globalIdPool = buildGlobalIdPool(globalPoolName, idStart, idEnd, blockSize, buildChildPool(localPoolName)).setReleasedIdsHolder(expectedReleasedIds).build();
+ Optional<IdPool> expected = Optional.of(globalIdPool);
+ Optional<IdPool> expectedLocalPool = Optional.of(buildLocalIdPool(blockSize, localPoolName, globalPoolName).build());
+ doReturn(Futures.immediateCheckedFuture(expected)).when(mockReadTx).read(
+ LogicalDatastoreType.CONFIGURATION, identifier);
+ doReturn(Futures.immediateCheckedFuture(expectedLocalPool)).when(mockReadTx).read(
+ LogicalDatastoreType.CONFIGURATION, childIdentifier);
+ InstanceIdentifier<IdEntries> idEntriesIdentifier = buildIdEntriesIdentifier(globalPoolName);
+ doReturn(Futures.immediateCheckedFuture(Optional.absent())).when(mockReadTx).read(
+ LogicalDatastoreType.CONFIGURATION, idEntriesIdentifier);
+ InstanceIdentifier<ReleasedIdsHolder> releaseIdsIdentifier = buildReleaseIdsIdentifier(globalPoolName);
+
+ Future<RpcResult<AllocateIdOutput>> result = idManager.allocateId(allocateIdInput);
+ assertTrue(result.get().isSuccessful());
+ assertEquals(0,configDataStore.size());
+ DataObject dataObject = configDataStore.get(childIdentifier);
+ if (dataObject instanceof IdPool) {
+ IdPool pool = (IdPool) dataObject;
+ assertEquals(localPoolName, pool.getPoolName());
+ assertEquals(1, pool.getReleasedIdsHolder().getDelayedIdEntries().size());
+ assertEquals(1, pool.getIdEntries().size());
+ assertEquals(1, pool.getReleasedIdsHolder().getAvailableIdCount().intValue());
+ }
+ dataObject = configDataStore.get(releaseIdsIdentifier);
+ if (dataObject instanceof ReleasedIdsHolder) {
+ ReleasedIdsHolder releasedIds = (ReleasedIdsHolder) dataObject;
+ assertEquals(1, releasedIds.getAvailableIdCount().intValue());
+ assertEquals(1, releasedIds.getDelayedIdEntries().size());
+ }
+ }
+
+ @Test
+ public void testDeletePool() throws Exception {
+ IdPool globalIdPool = buildGlobalIdPool(globalPoolName, idStart, idEnd, blockSize, buildChildPool(localPoolName)).build();
+ Optional<IdPool> expected = Optional.of(globalIdPool);
+ Optional<IdPool> expectedLocalPool = Optional.of(buildLocalIdPool(blockSize, localPoolName, globalPoolName).build());