idmanager/idmanager-impl/src/test/java/org/opendaylight/genius/idmanager/test/IdManagerTest.java

   1 /*
   2  * Copyright (c) 2016 Ericsson India Global Services Pvt Ltd. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8 package org.opendaylight.genius.idmanager.test;
   9
  10 import static org.junit.Assert.assertEquals;
  11 import static org.junit.Assert.assertTrue;
  12 import static org.mockito.Matchers.any;
  13 import static org.mockito.Matchers.eq;
  14 import static org.mockito.Mockito.doReturn;
  15 import static org.mockito.Mockito.when;
  16
  17 import java.net.InetAddress;
  18 import java.util.ArrayList;
  19 import java.util.HashMap;
  20 import java.util.List;
  21 import java.util.Map;
  22 import java.util.concurrent.Future;
  23
  24 import org.junit.Before;
  25 import org.junit.Test;
  26 import org.junit.runner.RunWith;
  27 import org.mockito.Mock;
  28 import org.mockito.runners.MockitoJUnitRunner;
  29 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  30 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
  31 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
  32 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  33 import org.opendaylight.genius.idmanager.IdManager;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.AllocateIdInput;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.AllocateIdInputBuilder;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.AllocateIdOutput;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.CreateIdPoolInput;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.CreateIdPoolInputBuilder;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.DeleteIdPoolInput;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.DeleteIdPoolInputBuilder;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.IdPools;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.ReleaseIdInput;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.ReleaseIdInputBuilder;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.id.pools.IdPool;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.id.pools.IdPoolBuilder;
  46 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.id.pools.IdPoolKey;
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.id.pools.id.pool.AvailableIdsHolder;
  48 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.id.pools.id.pool.AvailableIdsHolderBuilder;
  49 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.id.pools.id.pool.ChildPools;
  50 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.id.pools.id.pool.ChildPoolsBuilder;
  51 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.id.pools.id.pool.ChildPoolsKey;
  52 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.id.pools.id.pool.IdEntries;
  53 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.id.pools.id.pool.IdEntriesBuilder;
  54 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.id.pools.id.pool.IdEntriesKey;
  55 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.id.pools.id.pool.ReleasedIdsHolder;
  56 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.id.pools.id.pool.ReleasedIdsHolderBuilder;
  57 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.released.ids.DelayedIdEntries;
  58 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.released.ids.DelayedIdEntriesBuilder;
  59 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.lockmanager.rev160413.LockInput;
  60 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.lockmanager.rev160413.LockManagerService;
  61 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.lockmanager.rev160413.UnlockInput;
  62 import org.opendaylight.yangtools.yang.binding.DataObject;
  63 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  64 import org.opendaylight.yangtools.yang.common.RpcResult;
  65 import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
  66 import org.slf4j.Logger;
  67 import org.slf4j.LoggerFactory;
  68
  69 import com.google.common.base.Optional;
  70 import com.google.common.net.InetAddresses;
  71 import com.google.common.util.concurrent.Futures;
  72
  73
  74 @RunWith(MockitoJUnitRunner.class)
  75 public class IdManagerTest {
  76     private static final Logger LOG = LoggerFactory.getLogger(IdManagerTest.class);
  77     private static int BLADE_ID;
  78     static {
  79         try {
  80             BLADE_ID = InetAddresses.coerceToInteger(InetAddress.getLocalHost());
  81         } catch (Exception e) {
  82             LOG.error("IdManager - Exception - {}", e.getMessage());
  83         }
  84     }
  85
  86     Map<InstanceIdentifier<?>,DataObject> configDataStore = new HashMap<>();
  87     @Mock DataBroker dataBroker;
  88     @Mock ReadOnlyTransaction mockReadTx;
  89     @Mock WriteTransaction mockWriteTx;
  90     @Mock LockManagerService lockManager;
  91     Future<RpcResult<Void>> rpcResult;
  92     IdManager idManager;
  93     IdPool globalIdPool;
  94     InstanceIdentifier<IdPool> identifier;
  95     InstanceIdentifier<IdPool> childIdentifier;
  96     InstanceIdentifier<ChildPools> childPoolIdentifier;
  97     String globalPoolName = "test-pool";
  98     String localPoolName = new StringBuilder(globalPoolName).append(".").append(BLADE_ID).toString();
  99     String idKey = "test-key1";
 100     int idStart = 100;
 101     int idEnd = 200;
 102     int blockSize = 2;
 103     String idKey2 = "test-key2";
 104     long idValue = 25;
 105
 106     @Before
 107     public void setUp() throws Exception {
 108
 109         idManager = new IdManager(dataBroker);
 110         idManager.setLockManager(lockManager);
 111         setupMocks();
 112     }
 113
 114     private void setupMocks() {
 115         globalIdPool = buildGlobalIdPool(globalPoolName, idStart, idEnd, blockSize, buildChildPool(localPoolName)).build();
 116         identifier = buildInstanceIdentifier(globalPoolName);
 117         childIdentifier = buildInstanceIdentifier(localPoolName);
 118         childPoolIdentifier = buildChildPoolInstanceIdentifier(globalPoolName, localPoolName);
 119         when(dataBroker.newReadOnlyTransaction()).thenReturn(mockReadTx);
 120         when(dataBroker.newWriteOnlyTransaction()).thenReturn(mockWriteTx);
 121         when(lockManager.lock(any(LockInput.class))).thenReturn(Futures.immediateFuture(RpcResultBuilder.<Void>success().build()));
 122         when(lockManager.unlock(any(UnlockInput.class))).thenReturn(Futures.immediateFuture(RpcResultBuilder.<Void>success().build()));
 123         doReturn(Futures.immediateCheckedFuture(null)).when(mockWriteTx).submit();
 124         doReturn(Futures.immediateCheckedFuture(null)).when(mockReadTx).read(eq(LogicalDatastoreType.OPERATIONAL), any(InstanceIdentifier.class));
 125     }
 126
 127     @Test
 128     public void testCreateIdPool() throws Exception
 129     {
 130         CreateIdPoolInput createPoolTest = buildCreateIdPool(globalPoolName, idStart, idEnd);
 131         doReturn(Futures.immediateCheckedFuture(Optional.absent())).when(mockReadTx).read(
 132                 LogicalDatastoreType.CONFIGURATION, identifier);
 133         doReturn(Futures.immediateCheckedFuture(Optional.absent())).when(mockReadTx).read(
 134                 LogicalDatastoreType.CONFIGURATION, childIdentifier);
 135         Future<RpcResult<Void>> result = idManager.createIdPool(createPoolTest);
 136         DataObject dataObject;
 137         IdPool pool;
 138         assertTrue(result.get().isSuccessful());
 139         assertEquals(0,configDataStore.size());
 140         dataObject = configDataStore.get(childIdentifier);
 141         if (dataObject instanceof IdPool) {
 142             pool = (IdPool) dataObject;
 143             assertEquals(localPoolName, pool.getPoolName());
 144             assertEquals(createPoolTest.getPoolName(), pool.getParentPoolName());
 145             assertEquals(null, pool.getAvailableIdsHolder());
 146             assertEquals(30, pool.getReleasedIdsHolder().getDelayedTimeSec().longValue());
 147             assertEquals(0, pool.getReleasedIdsHolder().getAvailableIdCount().longValue());
 148             assertEquals(blockSize, pool.getBlockSize().longValue());
 149         }
 150         dataObject = configDataStore.get(identifier);
 151         if (dataObject instanceof IdPool) {
 152             pool = (IdPool) dataObject;
 153             assertEquals(createPoolTest.getPoolName(), pool.getPoolName());
 154             assertEquals(0, pool.getReleasedIdsHolder().getDelayedTimeSec().longValue());
 155             assertEquals(0, pool.getReleasedIdsHolder().getAvailableIdCount().longValue());
 156             assertEquals(createPoolTest.getLow(), pool.getAvailableIdsHolder().getStart());
 157             assertEquals(createPoolTest.getHigh(), pool.getAvailableIdsHolder().getEnd());
 158             assertEquals(createPoolTest.getLow() - 1, pool.getAvailableIdsHolder().getCursor().intValue());
 159             assertEquals(blockSize, pool.getBlockSize().longValue());
 160         }
 161         dataObject = configDataStore.get(childPoolIdentifier);
 162         if (dataObject instanceof ChildPools) {
 163             ChildPools childPool = (ChildPools) dataObject;
 164             assertEquals(localPoolName, childPool.getChildPoolName());
 165         }
 166     }
 167
 168     @Test
 169     public void testAllocateId() throws Exception
 170     {
 171         AllocateIdInput allocateIdInput = buildAllocateId(globalPoolName, idKey);
 172         List<IdEntries> idEntries = new ArrayList<>();
 173         List<Long> idValuesList = new ArrayList<>();
 174         idValuesList.add(idValue);
 175         idEntries.add(buildIdEntry(idKey2, idValuesList));
 176         Optional<IdPool> expectedLocalPool = Optional.of(buildLocalIdPool(blockSize, localPoolName, globalPoolName).build());
 177         IdPool globalIdPool = buildGlobalIdPool(globalPoolName, idStart, idEnd, blockSize, buildChildPool(localPoolName)).setIdEntries(idEntries).build();
 178         Optional<IdPool> expectedGlobalPool = Optional.of(globalIdPool);
 179         doReturn(Futures.immediateCheckedFuture(expectedGlobalPool)).when(mockReadTx).read(
 180                 LogicalDatastoreType.CONFIGURATION, identifier);
 181         doReturn(Futures.immediateCheckedFuture(expectedLocalPool)).when(mockReadTx).read(
 182                 LogicalDatastoreType.CONFIGURATION, childIdentifier);
 183         InstanceIdentifier<IdEntries> idEntriesIdentifier = buildIdEntriesIdentifier(idKey);
 184         doReturn(Futures.immediateCheckedFuture(Optional.absent())).when(mockReadTx).read(
 185                 LogicalDatastoreType.CONFIGURATION, idEntriesIdentifier);
 186         InstanceIdentifier<AvailableIdsHolder> availableIdsIdentifier = buildAvailbaleIdsIdentifier(globalPoolName);
 187
 188         Future<RpcResult<AllocateIdOutput>> result = idManager.allocateId(allocateIdInput);
 189         assertTrue(result.get().isSuccessful());
 190         assertEquals(0,configDataStore.size());
 191         DataObject dataObject = configDataStore.get(childIdentifier);
 192         if (dataObject instanceof IdPool) {
 193             IdPool pool = (IdPool) dataObject;
 194             assertEquals(localPoolName, pool.getPoolName());
 195             assertEquals(idStart, pool.getAvailableIdsHolder().getStart().intValue());
 196             assertEquals(idStart + blockSize - 1 , pool.getAvailableIdsHolder().getEnd().intValue());
 197             assertEquals(idStart, pool.getAvailableIdsHolder().getCursor().intValue());
 198         }
 199         dataObject = configDataStore.get(identifier);
 200         if (dataObject instanceof IdPool) {
 201             IdPool parentPool = (IdPool) dataObject;
 202             assertEquals(2, parentPool.getIdEntries().size());
 203         }
 204         dataObject = configDataStore.get(availableIdsIdentifier);
 205         if (dataObject instanceof AvailableIdsHolder) {
 206             AvailableIdsHolder availableIds = (AvailableIdsHolder) dataObject;
 207             assertEquals(idEnd, availableIds.getEnd().intValue());
 208             assertEquals(idStart, availableIds.getStart().intValue());
 209             assertEquals(idStart + blockSize - 1, availableIds.getCursor().intValue());
 210         }
 211     }
 212
 213     @Test
 214     public void testReleaseId() throws Exception {
 215         ReleaseIdInput releaseIdInput = createReleaseIdInput(globalPoolName, idKey);
 216         List<IdEntries> idEntries = new ArrayList<>();
 217         List<Long> idValuesList = new ArrayList<>();
 218         idValuesList.add(idValue);
 219         idEntries.add(buildIdEntry(idKey, idValuesList));
 220         Optional<IdPool> expectedLocalPool = Optional.of(buildLocalIdPool(blockSize, localPoolName, globalPoolName).build());
 221         IdPool globalIdPool = buildGlobalIdPool(globalPoolName, idStart, idEnd, blockSize, buildChildPool(localPoolName)).setIdEntries(idEntries).build();
 222         Optional<IdPool> expectedGlobalPool = Optional.of(globalIdPool);
 223         doReturn(Futures.immediateCheckedFuture(expectedGlobalPool)).when(mockReadTx).read(
 224                 LogicalDatastoreType.CONFIGURATION, identifier);
 225         doReturn(Futures.immediateCheckedFuture(expectedLocalPool)).when(mockReadTx).read(
 226                 LogicalDatastoreType.CONFIGURATION, childIdentifier);
 227         InstanceIdentifier<IdEntries> idEntriesIdentifier = buildIdEntriesIdentifier(idKey);
 228         idValuesList.add(idValue);
 229         Optional<IdEntries> expectedIdEntry = Optional.of(buildIdEntry(idKey, idValuesList));
 230         doReturn(Futures.immediateCheckedFuture(expectedIdEntry)).when(mockReadTx).read(
 231                 LogicalDatastoreType.CONFIGURATION, idEntriesIdentifier);
 232         Future<RpcResult<Void>> result = idManager.releaseId(releaseIdInput);
 233         assertTrue(result.get().isSuccessful());
 234         assertEquals(0, configDataStore.size());
 235         DataObject idPoolVal = configDataStore.get(childIdentifier);
 236         if (idPoolVal instanceof IdPool) {
 237             IdPool pool = (IdPool) idPoolVal;
 238             assertEquals(0, pool.getReleasedIdsHolder().getAvailableIdCount().intValue());
 239             assertEquals(idValue, pool.getReleasedIdsHolder().getDelayedIdEntries().get(0).getId().intValue());
 240         }
 241         idPoolVal = configDataStore.get(identifier);
 242         if (idPoolVal instanceof IdPool) {
 243             IdPool parentPool = (IdPool) idPoolVal;
 244             assertEquals(0, parentPool.getIdEntries().size());
 245         }
 246     }
 247
 248     @Test
 249     public void testCleanupReleasedIds() throws Exception {
 250         AllocateIdInput allocateIdInput = buildAllocateId(globalPoolName, idKey2);
 251         Optional<ReleasedIdsHolder> expected = Optional.of(createReleasedIdsHolder(0, null, 0));
 252         long[] excessIds = new long[] { 1, 2, 3, 4, 5 };
 253         List<IdEntries> idEntries = new ArrayList<>();
 254         List<Long> idValuesList = new ArrayList<>();
 255         idValuesList.add(idValue);
 256         idEntries.add(buildIdEntry(idKey2, idValuesList));
 257         ReleasedIdsHolder excessReleasedIds = createReleasedIdsHolder(0, buildDelayedIdEntries(excessIds), (long) 30);
 258         Optional<IdPool> expectedLocalPool = Optional.of(buildLocalIdPool(blockSize, localPoolName, globalPoolName)
 259                 .setReleasedIdsHolder(excessReleasedIds)
 260                 .build());
 261         InstanceIdentifier<ReleasedIdsHolder> releaseIdsIdentifier = buildReleaseIdsIdentifier(globalPoolName);
 262         IdPool globalIdPool = buildGlobalIdPool(globalPoolName, idStart, idEnd, blockSize, buildChildPool(localPoolName)).setIdEntries(idEntries).build();
 263         Optional<IdPool> expectedGlobalPool = Optional.of(globalIdPool);
 264         doReturn(Futures.immediateCheckedFuture(expectedGlobalPool)).when(mockReadTx).read(
 265                 LogicalDatastoreType.CONFIGURATION, identifier);
 266         doReturn(Futures.immediateCheckedFuture(expected)).when(mockReadTx)
 267                 .read(LogicalDatastoreType.CONFIGURATION, releaseIdsIdentifier);
 268         doReturn(Futures.immediateCheckedFuture(expectedLocalPool)).when(
 269                 mockReadTx).read(LogicalDatastoreType.CONFIGURATION,
 270                 childIdentifier);
 271         InstanceIdentifier<IdEntries> idEntriesIdentifier = buildIdEntriesIdentifier(idKey2);
 272         doReturn(Futures.immediateCheckedFuture(Optional.absent())).when(
 273                 mockReadTx).read(LogicalDatastoreType.CONFIGURATION,
 274                 idEntriesIdentifier);
 275
 276         Future<RpcResult<AllocateIdOutput>> result = idManager.allocateId(allocateIdInput);
 277         assertTrue(result.get().isSuccessful());
 278         assertEquals(0, configDataStore.size());
 279         DataObject dataObject = configDataStore.get(childIdentifier);
 280         if (dataObject instanceof IdPool) {
 281             IdPool pool = (IdPool) dataObject;
 282             assertEquals(localPoolName, pool.getPoolName());
 283             assertEquals(excessIds.length - 3, pool.getReleasedIdsHolder().getAvailableIdCount().intValue());
 284         }
 285         dataObject = configDataStore.get(identifier);
 286         if (dataObject instanceof IdPool) {
 287             IdPool parentPool = (IdPool) dataObject;
 288             assertEquals(2, parentPool.getIdEntries().size());
 289         }
 290         dataObject = configDataStore.get(releaseIdsIdentifier);
 291         if (dataObject instanceof ReleasedIdsHolder) {
 292             ReleasedIdsHolder releasedIds = (ReleasedIdsHolder) dataObject;
 293             assertEquals(2, releasedIds.getAvailableIdCount().intValue());
 294             assertEquals(2, releasedIds.getDelayedIdEntries().size());
 295         }
 296     }
 297
 298     @Test
 299     public void testAllocateIdBlockFromReleasedIds() throws Exception {
 300         AllocateIdInput allocateIdInput = buildAllocateId(globalPoolName, globalPoolName);
 301         List<DelayedIdEntries> delayedIdEntries = buildDelayedIdEntries(new long[] {1, 2, 3});
 302         ReleasedIdsHolder expectedReleasedIds = createReleasedIdsHolder(3, delayedIdEntries , 0);
 303         IdPool globalIdPool = buildGlobalIdPool(globalPoolName, idStart, idEnd, blockSize, buildChildPool(localPoolName)).setReleasedIdsHolder(expectedReleasedIds).build();
 304         Optional<IdPool> expected = Optional.of(globalIdPool);
 305         Optional<IdPool> expectedLocalPool = Optional.of(buildLocalIdPool(blockSize, localPoolName, globalPoolName).build());
 306         doReturn(Futures.immediateCheckedFuture(expected)).when(mockReadTx).read(
 307                 LogicalDatastoreType.CONFIGURATION, identifier);
 308         doReturn(Futures.immediateCheckedFuture(expectedLocalPool)).when(mockReadTx).read(
 309                 LogicalDatastoreType.CONFIGURATION, childIdentifier);
 310         InstanceIdentifier<IdEntries> idEntriesIdentifier = buildIdEntriesIdentifier(globalPoolName);
 311         doReturn(Futures.immediateCheckedFuture(Optional.absent())).when(mockReadTx).read(
 312                 LogicalDatastoreType.CONFIGURATION, idEntriesIdentifier);
 313         InstanceIdentifier<ReleasedIdsHolder> releaseIdsIdentifier = buildReleaseIdsIdentifier(globalPoolName);
 314
 315         Future<RpcResult<AllocateIdOutput>> result = idManager.allocateId(allocateIdInput);
 316         assertTrue(result.get().isSuccessful());
 317         assertEquals(0,configDataStore.size());
 318         DataObject dataObject = configDataStore.get(childIdentifier);
 319         if (dataObject instanceof IdPool) {
 320             IdPool pool = (IdPool) dataObject;
 321             assertEquals(localPoolName, pool.getPoolName());
 322             assertEquals(1, pool.getReleasedIdsHolder().getDelayedIdEntries().size());
 323             assertEquals(1, pool.getReleasedIdsHolder().getAvailableIdCount().intValue());
 324         }
 325         dataObject = configDataStore.get(identifier);
 326         if (dataObject instanceof IdPool) {
 327             IdPool parentPool = (IdPool) dataObject;
 328             assertEquals(1, parentPool.getIdEntries().size());
 329         }
 330         dataObject = configDataStore.get(releaseIdsIdentifier);
 331         if (dataObject instanceof ReleasedIdsHolder) {
 332             ReleasedIdsHolder releasedIds = (ReleasedIdsHolder) dataObject;
 333             assertEquals(1, releasedIds.getAvailableIdCount().intValue());
 334             assertEquals(1, releasedIds.getDelayedIdEntries().size());
 335         }
 336     }
 337
 338     @Test
 339     public void testDeletePool() throws Exception {
 340         IdPool globalIdPool = buildGlobalIdPool(globalPoolName, idStart, idEnd, blockSize, buildChildPool(localPoolName)).build();
 341         Optional<IdPool> expected = Optional.of(globalIdPool);
 342         Optional<IdPool> expectedLocalPool = Optional.of(buildLocalIdPool(blockSize, localPoolName, globalPoolName).build());
 343         doReturn(Futures.immediateCheckedFuture(expected)).when(mockReadTx).read(
 344                 LogicalDatastoreType.CONFIGURATION, identifier);
 345         doReturn(Futures.immediateCheckedFuture(expectedLocalPool)).when(mockReadTx).read(
 346                 LogicalDatastoreType.CONFIGURATION, childIdentifier);
 347         DeleteIdPoolInput deleteIdPoolInput = createDeleteIdPoolInput(globalPoolName);
 348         configDataStore.put(childIdentifier, null);
 349         configDataStore.put(identifier, null);
 350         Future<RpcResult<Void>> result = idManager.deleteIdPool(deleteIdPoolInput);
 351         assertTrue(result.get().isSuccessful());
 352         assertEquals(2, configDataStore.size());
 353     }
 354
 355     private InstanceIdentifier<ReleasedIdsHolder> buildReleaseIdsIdentifier(
 356             String poolName) {
 357         InstanceIdentifier<ReleasedIdsHolder> releasedIds = InstanceIdentifier
 358                 .builder(IdPools.class).child(IdPool.class,
 359                         new IdPoolKey(poolName)).child(ReleasedIdsHolder.class).build();
 360         return releasedIds;
 361     }
 362
 363     private InstanceIdentifier<AvailableIdsHolder> buildAvailbaleIdsIdentifier(
 364             String poolName) {
 365         InstanceIdentifier<AvailableIdsHolder> availableIds = InstanceIdentifier
 366                 .builder(IdPools.class).child(IdPool.class,
 367                         new IdPoolKey(poolName)).child(AvailableIdsHolder.class).build();
 368         return availableIds;
 369     }
 370
 371     private InstanceIdentifier<ChildPools> buildChildPoolInstanceIdentifier(String poolName, String childPoolName) {
 372         InstanceIdentifier<ChildPools> childPool = InstanceIdentifier
 373                 .builder(IdPools.class).child(IdPool.class,
 374                         new IdPoolKey(poolName)).child(ChildPools.class, new ChildPoolsKey(childPoolName)).build();
 375         return childPool;
 376     }
 377
 378     private ReleaseIdInput createReleaseIdInput(String poolName, String idKey) {
 379         return new ReleaseIdInputBuilder().setIdKey(idKey).setPoolName(poolName).build();
 380     }
 381
 382     private IdEntries buildIdEntry(String idKey, List<Long> idValuesList) {
 383         return new IdEntriesBuilder().setIdKey(idKey).setIdValue(idValuesList).build();
 384     }
 385
 386     private InstanceIdentifier<IdEntries> buildIdEntriesIdentifier(String idKey) {
 387         InstanceIdentifier.InstanceIdentifierBuilder<IdEntries> idEntriesBuilder = identifier
 388                 .builder().child(IdEntries.class, new IdEntriesKey(idKey));
 389         InstanceIdentifier<IdEntries> idEntry = idEntriesBuilder.build();
 390         return idEntry;
 391     }
 392
 393     private CreateIdPoolInput buildCreateIdPool(String poolName, long low, long high) {
 394         CreateIdPoolInput createPool = new CreateIdPoolInputBuilder().setPoolName(poolName)
 395                 .setLow(low)
 396                 .setHigh(high)
 397                 .build();
 398         return createPool;
 399     }
 400
 401     private IdPoolBuilder buildGlobalIdPool(String poolName, long idStart, long poolSize, int blockSize, List<ChildPools> childPools) {
 402         AvailableIdsHolder availableIdsHolder = createAvailableIdsHolder(idStart, poolSize, idStart - 1);
 403         ReleasedIdsHolder releasedIdsHolder = createReleasedIdsHolder(0, null, 0);
 404         return new IdPoolBuilder().setKey(new IdPoolKey(poolName))
 405                 .setPoolName(poolName)
 406                 .setBlockSize(blockSize)
 407                 .setChildPools(childPools)
 408                 .setAvailableIdsHolder(availableIdsHolder)
 409                 .setReleasedIdsHolder(releasedIdsHolder);
 410     }
 411
 412     private IdPoolBuilder buildLocalIdPool(int blockSize, String localPoolName, String parentPoolName) {
 413         ReleasedIdsHolder releasedIdsHolder = createReleasedIdsHolder(0, null, (long) 30);
 414         return new IdPoolBuilder().setBlockSize(blockSize)
 415                 .setKey(new IdPoolKey(localPoolName))
 416                 .setParentPoolName(parentPoolName)
 417                 .setReleasedIdsHolder(releasedIdsHolder);
 418     }
 419
 420     private AllocateIdInput buildAllocateId(String poolName, String idKey) {
 421         AllocateIdInput getIdInput = new AllocateIdInputBuilder().setPoolName(poolName)
 422                 .setIdKey(idKey).build();
 423         return getIdInput;
 424     }
 425
 426     private InstanceIdentifier<IdPool> buildInstanceIdentifier(String poolName) {
 427         InstanceIdentifier.InstanceIdentifierBuilder<IdPool> idBuilder =
 428                 InstanceIdentifier.builder(IdPools.class).child(IdPool.class, new IdPoolKey(poolName));
 429         InstanceIdentifier<IdPool> id = idBuilder.build();
 430         return id;
 431     }
 432
 433     private AvailableIdsHolder createAvailableIdsHolder(long low, long high, long cursor) {
 434         AvailableIdsHolder availableIdsHolder = new AvailableIdsHolderBuilder()
 435                 .setStart(low).setEnd(high).setCursor(cursor).build();
 436         return availableIdsHolder;
 437     }
 438
 439     private ReleasedIdsHolder createReleasedIdsHolder(long availableIdCount, List<DelayedIdEntries> delayedIdEntries, long delayTime) {
 440         ReleasedIdsHolder releasedIdsHolder = new ReleasedIdsHolderBuilder()
 441                 .setAvailableIdCount(availableIdCount)
 442                 .setDelayedIdEntries(delayedIdEntries)
 443                 .setDelayedTimeSec(delayTime).build();
 444         return releasedIdsHolder;
 445     }
 446
 447     private DeleteIdPoolInput createDeleteIdPoolInput(String poolName) {
 448         return new DeleteIdPoolInputBuilder().setPoolName(poolName).build();
 449     }
 450
 451     private List<DelayedIdEntries> buildDelayedIdEntries(long[] idValues) {
 452         List<DelayedIdEntries> delayedIdEntriesList = new ArrayList<>();
 453         for (long idValue : idValues) {
 454             DelayedIdEntries delayedIdEntries = new DelayedIdEntriesBuilder().setId(idValue).setReadyTimeSec(0L).build();
 455             delayedIdEntriesList.add(delayedIdEntries);
 456         }
 457         return delayedIdEntriesList;
 458     }
 459
 460     private List<ChildPools> buildChildPool(String childPoolName) {
 461         ChildPools childPools = new ChildPoolsBuilder().setChildPoolName(childPoolName).build();
 462         List<ChildPools> childPoolsList = new ArrayList<>();
 463         childPoolsList.add(childPools);
 464         return childPoolsList;
 465     }
 466 }