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

   1 package org.opendaylight.idmanager.test;
   2
   3 import static org.junit.Assert.assertEquals;
   4 import static org.junit.Assert.assertTrue;
   5 import static org.mockito.Matchers.any;
   6 import static org.mockito.Matchers.eq;
   7 import static org.mockito.Mockito.doReturn;
   8 import static org.mockito.Mockito.when;
   9
  10 import java.net.InetAddress;
  11 import java.util.ArrayList;
  12 import java.util.HashMap;
  13 import java.util.List;
  14 import java.util.Map;
  15 import java.util.concurrent.Future;
  16
  17 import org.junit.Before;
  18 import org.junit.Test;
  19 import org.junit.runner.RunWith;
  20 import org.mockito.Mock;
  21 import org.mockito.runners.MockitoJUnitRunner;
  22 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  23 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
  24 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
  25 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  26 import org.opendaylight.idmanager.IdManager;
  27 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.AllocateIdInput;
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.AllocateIdInputBuilder;
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.AllocateIdOutput;
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.CreateIdPoolInput;
  31 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.CreateIdPoolInputBuilder;
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.DeleteIdPoolInput;
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.DeleteIdPoolInputBuilder;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.IdPools;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.ReleaseIdInput;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.ReleaseIdInputBuilder;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.id.pools.IdPool;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.id.pools.IdPoolBuilder;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.id.pools.IdPoolKey;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.id.pools.id.pool.AvailableIdsHolder;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.id.pools.id.pool.AvailableIdsHolderBuilder;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.id.pools.id.pool.ChildPools;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.id.pools.id.pool.ChildPoolsBuilder;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.id.pools.id.pool.ChildPoolsKey;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.id.pools.id.pool.IdEntries;
  46 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.id.pools.id.pool.IdEntriesBuilder;
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.id.pools.id.pool.IdEntriesKey;
  48 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.id.pools.id.pool.ReleasedIdsHolder;
  49 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.id.pools.id.pool.ReleasedIdsHolderBuilder;
  50 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.released.ids.DelayedIdEntries;
  51 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.released.ids.DelayedIdEntriesBuilder;
  52 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.lockmanager.rev150819.LockInput;
  53 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.lockmanager.rev150819.LockManagerService;
  54 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.lockmanager.rev150819.UnlockInput;
  55 import org.opendaylight.yangtools.yang.binding.DataObject;
  56 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  57 import org.opendaylight.yangtools.yang.common.RpcResult;
  58 import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
  59 import org.slf4j.Logger;
  60 import org.slf4j.LoggerFactory;
  61
  62 import com.google.common.base.Optional;
  63 import com.google.common.net.InetAddresses;
  64 import com.google.common.util.concurrent.Futures;
  65
  66
  67 @RunWith(MockitoJUnitRunner.class)
  68 public class IdManagerTest {
  69     private static final Logger LOG = LoggerFactory.getLogger(IdManagerTest.class);
  70     private static int BLADE_ID;
  71     static {
  72         String hostName;
  73         try {
  74             hostName = InetAddress.getLocalHost().getHostName();
  75             BLADE_ID = InetAddresses.coerceToInteger(InetAddress.getLocalHost());
  76             if (hostName.indexOf("-") > 0) {
  77                 BLADE_ID = new Integer(hostName.split("-")[1].toString()).intValue();
  78             } else {
  79                 LOG.error("Host name {} is not matching with the condition!! PL-X is expected", hostName);
  80             }
  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     int 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         Optional<IdPool> expected = Optional.of(globalIdPool);
 173         List<IdEntries> idEntries = new ArrayList<IdEntries>();
 174         idEntries.add(buildIdEntry(idKey2, idValue));
 175         Optional<IdPool> expectedLocalPool = Optional.of(buildLocalIdPool(blockSize, localPoolName, globalPoolName).setIdEntries(idEntries).build());
 176         doReturn(Futures.immediateCheckedFuture(expected)).when(mockReadTx).read(
 177                 LogicalDatastoreType.CONFIGURATION, identifier);
 178         doReturn(Futures.immediateCheckedFuture(expectedLocalPool)).when(mockReadTx).read(
 179                 LogicalDatastoreType.CONFIGURATION, childIdentifier);
 180         InstanceIdentifier<IdEntries> idEntriesIdentifier = buildIdEntriesIdentifier(idKey);
 181         doReturn(Futures.immediateCheckedFuture(Optional.absent())).when(mockReadTx).read(
 182                 LogicalDatastoreType.CONFIGURATION, idEntriesIdentifier);
 183         InstanceIdentifier<AvailableIdsHolder> availableIdsIdentifier = buildAvailbaleIdsIdentifier(globalPoolName);
 184
 185         Future<RpcResult<AllocateIdOutput>> result = idManager.allocateId(allocateIdInput);
 186         assertTrue(result.get().isSuccessful());
 187         assertEquals(0,configDataStore.size());
 188         DataObject dataObject = configDataStore.get(childIdentifier);
 189         if (dataObject instanceof IdPool) {
 190             IdPool pool = (IdPool) dataObject;
 191             assertEquals(localPoolName, pool.getPoolName());
 192             assertEquals(idStart, pool.getAvailableIdsHolder().getStart().intValue());
 193             assertEquals(idStart + blockSize - 1 , pool.getAvailableIdsHolder().getEnd().intValue());
 194             assertEquals(idStart, pool.getAvailableIdsHolder().getCursor().intValue());
 195             assertEquals(2, pool.getIdEntries().size());
 196         }
 197         dataObject = configDataStore.get(availableIdsIdentifier);
 198         if (dataObject instanceof AvailableIdsHolder) {
 199             AvailableIdsHolder availableIds = (AvailableIdsHolder) dataObject;
 200             assertEquals(idEnd, availableIds.getEnd().intValue());
 201             assertEquals(idStart, availableIds.getStart().intValue());
 202             assertEquals(idStart + blockSize - 1, availableIds.getCursor().intValue());
 203         }
 204     }
 205
 206     @Test
 207     public void testReleaseId() throws Exception {
 208         ReleaseIdInput releaseIdInput = createReleaseIdInput(globalPoolName, idKey);
 209         List<IdEntries> idEntries = new ArrayList<IdEntries>();
 210         idEntries.add(buildIdEntry(idKey, idValue));
 211         Optional<IdPool> expectedLocalPool = Optional.of(buildLocalIdPool(blockSize, localPoolName, globalPoolName).setIdEntries(idEntries).build());
 212         doReturn(Futures.immediateCheckedFuture(expectedLocalPool)).when(mockReadTx).read(
 213                 LogicalDatastoreType.CONFIGURATION, childIdentifier);
 214         InstanceIdentifier<IdEntries> idEntriesIdentifier = buildIdEntriesIdentifier(idKey);
 215         Optional<IdEntries> expectedIdEntry = Optional.of(buildIdEntry(idKey, idValue));
 216         doReturn(Futures.immediateCheckedFuture(expectedIdEntry)).when(mockReadTx).read(
 217                 LogicalDatastoreType.CONFIGURATION, idEntriesIdentifier);
 218         Future<RpcResult<Void>> result = idManager.releaseId(releaseIdInput);
 219         assertTrue(result.get().isSuccessful());
 220         assertEquals(0, configDataStore.size());
 221         DataObject idPoolVal = configDataStore.get(childIdentifier);
 222         if (idPoolVal instanceof IdPool) {
 223             IdPool pool = (IdPool) idPoolVal;
 224             assertEquals(0, pool.getIdEntries().size());
 225             assertEquals(0, pool.getReleasedIdsHolder().getAvailableIdCount().intValue());
 226             assertEquals(idValue, pool.getReleasedIdsHolder().getDelayedIdEntries().get(0).getId().intValue());
 227         }
 228     }
 229
 230     @Test
 231     public void testCleanupReleasedIds() throws Exception {
 232         AllocateIdInput allocateIdInput = buildAllocateId(globalPoolName, idKey2);
 233         Optional<ReleasedIdsHolder> expected = Optional.of(createReleasedIdsHolder(0, null, 0));
 234         long[] excessIds = new long[] { 1, 2, 3, 4, 5 };
 235         List<IdEntries> idEntries = new ArrayList<IdEntries>();
 236         idEntries.add(buildIdEntry(idKey2, idValue));
 237         ReleasedIdsHolder excessReleasedIds = createReleasedIdsHolder(0, buildDelayedIdEntries(excessIds), (long) 30);
 238         Optional<IdPool> expectedLocalPool = Optional.of(buildLocalIdPool(blockSize, localPoolName, globalPoolName)
 239                 .setIdEntries(idEntries).setReleasedIdsHolder(excessReleasedIds)
 240                 .build());
 241         InstanceIdentifier<ReleasedIdsHolder> releaseIdsIdentifier = buildReleaseIdsIdentifier(globalPoolName);
 242         doReturn(Futures.immediateCheckedFuture(expected)).when(mockReadTx)
 243                 .read(LogicalDatastoreType.CONFIGURATION, releaseIdsIdentifier);
 244         doReturn(Futures.immediateCheckedFuture(expectedLocalPool)).when(
 245                 mockReadTx).read(LogicalDatastoreType.CONFIGURATION,
 246                 childIdentifier);
 247         InstanceIdentifier<IdEntries> idEntriesIdentifier = buildIdEntriesIdentifier(idKey2);
 248         doReturn(Futures.immediateCheckedFuture(Optional.absent())).when(
 249                 mockReadTx).read(LogicalDatastoreType.CONFIGURATION,
 250                 idEntriesIdentifier);
 251
 252         Future<RpcResult<AllocateIdOutput>> result = idManager.allocateId(allocateIdInput);
 253         assertTrue(result.get().isSuccessful());
 254         assertEquals(0, configDataStore.size());
 255         DataObject dataObject = configDataStore.get(childIdentifier);
 256         if (dataObject instanceof IdPool) {
 257             IdPool pool = (IdPool) dataObject;
 258             assertEquals(localPoolName, pool.getPoolName());
 259             assertEquals(excessIds.length - 3, pool.getReleasedIdsHolder().getAvailableIdCount().intValue());
 260             assertEquals(2, pool.getIdEntries().size());
 261         }
 262         dataObject = configDataStore.get(releaseIdsIdentifier);
 263         if (dataObject instanceof ReleasedIdsHolder) {
 264             ReleasedIdsHolder releasedIds = (ReleasedIdsHolder) dataObject;
 265             assertEquals(2, releasedIds.getAvailableIdCount().intValue());
 266             assertEquals(2, releasedIds.getDelayedIdEntries().size());
 267         }
 268     }
 269
 270     @Test
 271     public void testAllocateIdBlockFromReleasedIds() throws Exception {
 272         AllocateIdInput allocateIdInput = buildAllocateId(globalPoolName, globalPoolName);
 273         List<DelayedIdEntries> delayedIdEntries = buildDelayedIdEntries(new long[] {1, 2, 3});
 274         ReleasedIdsHolder expectedReleasedIds = createReleasedIdsHolder(3, delayedIdEntries , 0);
 275         IdPool globalIdPool = buildGlobalIdPool(globalPoolName, idStart, idEnd, blockSize, buildChildPool(localPoolName)).setReleasedIdsHolder(expectedReleasedIds).build();
 276         Optional<IdPool> expected = Optional.of(globalIdPool);
 277         Optional<IdPool> expectedLocalPool = Optional.of(buildLocalIdPool(blockSize, localPoolName, globalPoolName).build());
 278         doReturn(Futures.immediateCheckedFuture(expected)).when(mockReadTx).read(
 279                 LogicalDatastoreType.CONFIGURATION, identifier);
 280         doReturn(Futures.immediateCheckedFuture(expectedLocalPool)).when(mockReadTx).read(
 281                 LogicalDatastoreType.CONFIGURATION, childIdentifier);
 282         InstanceIdentifier<IdEntries> idEntriesIdentifier = buildIdEntriesIdentifier(globalPoolName);
 283         doReturn(Futures.immediateCheckedFuture(Optional.absent())).when(mockReadTx).read(
 284                 LogicalDatastoreType.CONFIGURATION, idEntriesIdentifier);
 285         InstanceIdentifier<ReleasedIdsHolder> releaseIdsIdentifier = buildReleaseIdsIdentifier(globalPoolName);
 286
 287         Future<RpcResult<AllocateIdOutput>> result = idManager.allocateId(allocateIdInput);
 288         assertTrue(result.get().isSuccessful());
 289         assertEquals(0,configDataStore.size());
 290         DataObject dataObject = configDataStore.get(childIdentifier);
 291         if (dataObject instanceof IdPool) {
 292             IdPool pool = (IdPool) dataObject;
 293             assertEquals(localPoolName, pool.getPoolName());
 294             assertEquals(1, pool.getReleasedIdsHolder().getDelayedIdEntries().size());
 295             assertEquals(1, pool.getIdEntries().size());
 296             assertEquals(1, pool.getReleasedIdsHolder().getAvailableIdCount().intValue());
 297         }
 298         dataObject = configDataStore.get(releaseIdsIdentifier);
 299         if (dataObject instanceof ReleasedIdsHolder) {
 300             ReleasedIdsHolder releasedIds = (ReleasedIdsHolder) dataObject;
 301             assertEquals(1, releasedIds.getAvailableIdCount().intValue());
 302             assertEquals(1, releasedIds.getDelayedIdEntries().size());
 303         }
 304     }
 305
 306     @Test
 307     public void testDeletePool() throws Exception {
 308         IdPool globalIdPool = buildGlobalIdPool(globalPoolName, idStart, idEnd, blockSize, buildChildPool(localPoolName)).build();
 309         Optional<IdPool> expected = Optional.of(globalIdPool);
 310         Optional<IdPool> expectedLocalPool = Optional.of(buildLocalIdPool(blockSize, localPoolName, globalPoolName).build());
 311         doReturn(Futures.immediateCheckedFuture(expected)).when(mockReadTx).read(
 312                 LogicalDatastoreType.CONFIGURATION, identifier);
 313         doReturn(Futures.immediateCheckedFuture(expectedLocalPool)).when(mockReadTx).read(
 314                 LogicalDatastoreType.CONFIGURATION, childIdentifier);
 315         DeleteIdPoolInput deleteIdPoolInput = createDeleteIdPoolInput(globalPoolName);
 316         configDataStore.put(childIdentifier, null);
 317         configDataStore.put(identifier, null);
 318         Future<RpcResult<Void>> result = idManager.deleteIdPool(deleteIdPoolInput);
 319         assertTrue(result.get().isSuccessful());
 320         assertEquals(2, configDataStore.size());
 321     }
 322
 323     private InstanceIdentifier<ReleasedIdsHolder> buildReleaseIdsIdentifier(
 324             String poolName) {
 325         InstanceIdentifier<ReleasedIdsHolder> releasedIds = InstanceIdentifier
 326                 .builder(IdPools.class).child(IdPool.class,
 327                         new IdPoolKey(poolName)).child(ReleasedIdsHolder.class).build();
 328         return releasedIds;
 329     }
 330
 331     private InstanceIdentifier<AvailableIdsHolder> buildAvailbaleIdsIdentifier(
 332             String poolName) {
 333         InstanceIdentifier<AvailableIdsHolder> availableIds = InstanceIdentifier
 334                 .builder(IdPools.class).child(IdPool.class,
 335                         new IdPoolKey(poolName)).child(AvailableIdsHolder.class).build();
 336         return availableIds;
 337     }
 338
 339     private InstanceIdentifier<ChildPools> buildChildPoolInstanceIdentifier(String poolName, String childPoolName) {
 340         InstanceIdentifier<ChildPools> childPool = InstanceIdentifier
 341                 .builder(IdPools.class).child(IdPool.class,
 342                         new IdPoolKey(poolName)).child(ChildPools.class, new ChildPoolsKey(childPoolName)).build();
 343         return childPool;
 344     }
 345
 346     private ReleaseIdInput createReleaseIdInput(String poolName, String idKey) {
 347         return new ReleaseIdInputBuilder().setIdKey(idKey).setPoolName(poolName).build();
 348     }
 349
 350     private IdEntries buildIdEntry(String idKey, long idValue) {
 351         return new IdEntriesBuilder().setIdKey(idKey).setIdValue(idValue).build();
 352     }
 353
 354     private InstanceIdentifier<IdEntries> buildIdEntriesIdentifier(String idKey) {
 355         InstanceIdentifier.InstanceIdentifierBuilder<IdEntries> idEntriesBuilder = childIdentifier
 356                 .builder().child(IdEntries.class, new IdEntriesKey(idKey));
 357         InstanceIdentifier<IdEntries> idEntry = idEntriesBuilder.build();
 358         return idEntry;
 359     }
 360
 361     private CreateIdPoolInput buildCreateIdPool(String poolName, long low, long high) {
 362         CreateIdPoolInput createPool = new CreateIdPoolInputBuilder().setPoolName(poolName)
 363                 .setLow(low)
 364                 .setHigh(high)
 365                 .build();
 366         return createPool;
 367     }
 368
 369     private IdPoolBuilder buildGlobalIdPool(String poolName, long idStart, long poolSize, int blockSize, List<ChildPools> childPools) {
 370         AvailableIdsHolder availableIdsHolder = createAvailableIdsHolder(idStart, poolSize, idStart - 1);
 371         ReleasedIdsHolder releasedIdsHolder = createReleasedIdsHolder(0, null, 0);
 372         return new IdPoolBuilder().setKey(new IdPoolKey(poolName))
 373                 .setPoolName(poolName)
 374                 .setBlockSize(blockSize)
 375                 .setChildPools(childPools)
 376                 .setAvailableIdsHolder(availableIdsHolder)
 377                 .setReleasedIdsHolder(releasedIdsHolder);
 378     }
 379
 380     private IdPoolBuilder buildLocalIdPool(int blockSize, String localPoolName, String parentPoolName) {
 381         ReleasedIdsHolder releasedIdsHolder = createReleasedIdsHolder(0, null, (long) 30);
 382         return new IdPoolBuilder().setBlockSize(blockSize)
 383                 .setKey(new IdPoolKey(localPoolName))
 384                 .setParentPoolName(parentPoolName)
 385                 .setReleasedIdsHolder(releasedIdsHolder);
 386     }
 387
 388     private AllocateIdInput buildAllocateId(String poolName, String idKey) {
 389         AllocateIdInput getIdInput = new AllocateIdInputBuilder().setPoolName(poolName)
 390                 .setIdKey(idKey).build();
 391         return getIdInput;
 392     }
 393
 394     private InstanceIdentifier<IdPool> buildInstanceIdentifier(String poolName) {
 395         InstanceIdentifier.InstanceIdentifierBuilder<IdPool> idBuilder =
 396                 InstanceIdentifier.builder(IdPools.class).child(IdPool.class, new IdPoolKey(poolName));
 397         InstanceIdentifier<IdPool> id = idBuilder.build();
 398         return id;
 399     }
 400
 401     private AvailableIdsHolder createAvailableIdsHolder(long low, long high, long cursor) {
 402         AvailableIdsHolder availableIdsHolder = new AvailableIdsHolderBuilder()
 403                 .setStart(low).setEnd(high).setCursor(cursor).build();
 404         return availableIdsHolder;
 405     }
 406
 407     private ReleasedIdsHolder createReleasedIdsHolder(long availableIdCount, List<DelayedIdEntries> delayedIdEntries, long delayTime) {
 408         ReleasedIdsHolder releasedIdsHolder = new ReleasedIdsHolderBuilder()
 409                 .setAvailableIdCount(availableIdCount)
 410                 .setDelayedIdEntries(delayedIdEntries)
 411                 .setDelayedTimeSec(delayTime).build();
 412         return releasedIdsHolder;
 413     }
 414
 415     private DeleteIdPoolInput createDeleteIdPoolInput(String poolName) {
 416         return new DeleteIdPoolInputBuilder().setPoolName(poolName).build();
 417     }
 418
 419     private List<DelayedIdEntries> buildDelayedIdEntries(long[] idValues) {
 420         List<DelayedIdEntries> delayedIdEntriesList = new ArrayList<DelayedIdEntries>();
 421         for (long idValue : idValues) {
 422             DelayedIdEntries delayedIdEntries = new DelayedIdEntriesBuilder().setId(idValue).setReadyTimeSec(0L).build();
 423             delayedIdEntriesList.add(delayedIdEntries);
 424         }
 425         return delayedIdEntriesList;
 426     }
 427
 428     private List<ChildPools> buildChildPool(String childPoolName) {
 429         ChildPools childPools = new ChildPoolsBuilder().setChildPoolName(childPoolName).build();
 430         List<ChildPools> childPoolsList = new ArrayList<ChildPools>();
 431         childPoolsList.add(childPools);
 432         return childPoolsList;
 433     }
 434 }