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         try {
  73             BLADE_ID = InetAddresses.coerceToInteger(InetAddress.getLocalHost());
  74         } catch (Exception e) {
  75             LOG.error("IdManager - Exception - {}", e.getMessage());
  76         }
  77     }
  78
  79     Map<InstanceIdentifier<?>,DataObject> configDataStore = new HashMap<>();
  80     @Mock DataBroker dataBroker;
  81     @Mock ReadOnlyTransaction mockReadTx;
  82     @Mock WriteTransaction mockWriteTx;
  83     @Mock LockManagerService lockManager;
  84     Future<RpcResult<Void>> rpcResult;
  85     IdManager idManager;
  86     IdPool globalIdPool;
  87     InstanceIdentifier<IdPool> identifier;
  88     InstanceIdentifier<IdPool> childIdentifier;
  89     InstanceIdentifier<ChildPools> childPoolIdentifier;
  90     String globalPoolName = "test-pool";
  91     String localPoolName = new StringBuilder(globalPoolName).append(".").append(BLADE_ID).toString();
  92     String idKey = "test-key1";
  93     int idStart = 100;
  94     int idEnd = 200;
  95     int blockSize = 2;
  96     String idKey2 = "test-key2";
  97     int idValue = 25;
  98
  99     @Before
 100     public void setUp() throws Exception {
 101
 102         idManager = new IdManager(dataBroker);
 103         idManager.setLockManager(lockManager);
 104         setupMocks();
 105     }
 106
 107     private void setupMocks() {
 108         globalIdPool = buildGlobalIdPool(globalPoolName, idStart, idEnd, blockSize, buildChildPool(localPoolName)).build();
 109         identifier = buildInstanceIdentifier(globalPoolName);
 110         childIdentifier = buildInstanceIdentifier(localPoolName);
 111         childPoolIdentifier = buildChildPoolInstanceIdentifier(globalPoolName, localPoolName);
 112         when(dataBroker.newReadOnlyTransaction()).thenReturn(mockReadTx);
 113         when(dataBroker.newWriteOnlyTransaction()).thenReturn(mockWriteTx);
 114         when(lockManager.lock(any(LockInput.class))).thenReturn(Futures.immediateFuture(RpcResultBuilder.<Void>success().build()));
 115         when(lockManager.unlock(any(UnlockInput.class))).thenReturn(Futures.immediateFuture(RpcResultBuilder.<Void>success().build()));
 116         doReturn(Futures.immediateCheckedFuture(null)).when(mockWriteTx).submit();
 117         doReturn(Futures.immediateCheckedFuture(null)).when(mockReadTx).read(eq(LogicalDatastoreType.OPERATIONAL), any(InstanceIdentifier.class));
 118     }
 119
 120     @Test
 121     public void testCreateIdPool() throws Exception
 122     {
 123         CreateIdPoolInput createPoolTest = buildCreateIdPool(globalPoolName, idStart, idEnd);
 124         doReturn(Futures.immediateCheckedFuture(Optional.absent())).when(mockReadTx).read(
 125                 LogicalDatastoreType.CONFIGURATION, identifier);
 126         doReturn(Futures.immediateCheckedFuture(Optional.absent())).when(mockReadTx).read(
 127                 LogicalDatastoreType.CONFIGURATION, childIdentifier);
 128         Future<RpcResult<Void>> result = idManager.createIdPool(createPoolTest);
 129         DataObject dataObject;
 130         IdPool pool;
 131         assertTrue(result.get().isSuccessful());
 132         assertEquals(0,configDataStore.size());
 133         dataObject = configDataStore.get(childIdentifier);
 134         if (dataObject instanceof IdPool) {
 135             pool = (IdPool) dataObject;
 136             assertEquals(localPoolName, pool.getPoolName());
 137             assertEquals(createPoolTest.getPoolName(), pool.getParentPoolName());
 138             assertEquals(null, pool.getAvailableIdsHolder());
 139             assertEquals(30, pool.getReleasedIdsHolder().getDelayedTimeSec().longValue());
 140             assertEquals(0, pool.getReleasedIdsHolder().getAvailableIdCount().longValue());
 141             assertEquals(blockSize, pool.getBlockSize().longValue());
 142         }
 143         dataObject = configDataStore.get(identifier);
 144         if (dataObject instanceof IdPool) {
 145             pool = (IdPool) dataObject;
 146             assertEquals(createPoolTest.getPoolName(), pool.getPoolName());
 147             assertEquals(0, pool.getReleasedIdsHolder().getDelayedTimeSec().longValue());
 148             assertEquals(0, pool.getReleasedIdsHolder().getAvailableIdCount().longValue());
 149             assertEquals(createPoolTest.getLow(), pool.getAvailableIdsHolder().getStart());
 150             assertEquals(createPoolTest.getHigh(), pool.getAvailableIdsHolder().getEnd());
 151             assertEquals(createPoolTest.getLow() - 1, pool.getAvailableIdsHolder().getCursor().intValue());
 152             assertEquals(blockSize, pool.getBlockSize().longValue());
 153         }
 154         dataObject = configDataStore.get(childPoolIdentifier);
 155         if (dataObject instanceof ChildPools) {
 156             ChildPools childPool = (ChildPools) dataObject;
 157             assertEquals(localPoolName, childPool.getChildPoolName());
 158         }
 159     }
 160
 161     @Test
 162     public void testAllocateId() throws Exception
 163     {
 164         AllocateIdInput allocateIdInput = buildAllocateId(globalPoolName, idKey);
 165         List<IdEntries> idEntries = new ArrayList<IdEntries>();
 166         idEntries.add(buildIdEntry(idKey2, idValue));
 167         Optional<IdPool> expectedLocalPool = Optional.of(buildLocalIdPool(blockSize, localPoolName, globalPoolName).build());
 168         IdPool globalIdPool = buildGlobalIdPool(globalPoolName, idStart, idEnd, blockSize, buildChildPool(localPoolName)).setIdEntries(idEntries).build();
 169         Optional<IdPool> expectedGlobalPool = Optional.of(globalIdPool);
 170         doReturn(Futures.immediateCheckedFuture(expectedGlobalPool)).when(mockReadTx).read(
 171                 LogicalDatastoreType.CONFIGURATION, identifier);
 172         doReturn(Futures.immediateCheckedFuture(expectedLocalPool)).when(mockReadTx).read(
 173                 LogicalDatastoreType.CONFIGURATION, childIdentifier);
 174         InstanceIdentifier<IdEntries> idEntriesIdentifier = buildIdEntriesIdentifier(idKey);
 175         doReturn(Futures.immediateCheckedFuture(Optional.absent())).when(mockReadTx).read(
 176                 LogicalDatastoreType.CONFIGURATION, idEntriesIdentifier);
 177         InstanceIdentifier<AvailableIdsHolder> availableIdsIdentifier = buildAvailbaleIdsIdentifier(globalPoolName);
 178
 179         Future<RpcResult<AllocateIdOutput>> result = idManager.allocateId(allocateIdInput);
 180         assertTrue(result.get().isSuccessful());
 181         assertEquals(0,configDataStore.size());
 182         DataObject dataObject = configDataStore.get(childIdentifier);
 183         if (dataObject instanceof IdPool) {
 184             IdPool pool = (IdPool) dataObject;
 185             assertEquals(localPoolName, pool.getPoolName());
 186             assertEquals(idStart, pool.getAvailableIdsHolder().getStart().intValue());
 187             assertEquals(idStart + blockSize - 1 , pool.getAvailableIdsHolder().getEnd().intValue());
 188             assertEquals(idStart, pool.getAvailableIdsHolder().getCursor().intValue());
 189         }
 190         dataObject = configDataStore.get(identifier);
 191         if (dataObject instanceof IdPool) {
 192             IdPool parentPool = (IdPool) dataObject;
 193             assertEquals(2, parentPool.getIdEntries().size());
 194         }
 195         dataObject = configDataStore.get(availableIdsIdentifier);
 196         if (dataObject instanceof AvailableIdsHolder) {
 197             AvailableIdsHolder availableIds = (AvailableIdsHolder) dataObject;
 198             assertEquals(idEnd, availableIds.getEnd().intValue());
 199             assertEquals(idStart, availableIds.getStart().intValue());
 200             assertEquals(idStart + blockSize - 1, availableIds.getCursor().intValue());
 201         }
 202     }
 203
 204     @Test
 205     public void testReleaseId() throws Exception {
 206         ReleaseIdInput releaseIdInput = createReleaseIdInput(globalPoolName, idKey);
 207         List<IdEntries> idEntries = new ArrayList<IdEntries>();
 208         idEntries.add(buildIdEntry(idKey, idValue));
 209         Optional<IdPool> expectedLocalPool = Optional.of(buildLocalIdPool(blockSize, localPoolName, globalPoolName).build());
 210         IdPool globalIdPool = buildGlobalIdPool(globalPoolName, idStart, idEnd, blockSize, buildChildPool(localPoolName)).setIdEntries(idEntries).build();
 211         Optional<IdPool> expectedGlobalPool = Optional.of(globalIdPool);
 212         doReturn(Futures.immediateCheckedFuture(expectedGlobalPool)).when(mockReadTx).read(
 213                 LogicalDatastoreType.CONFIGURATION, identifier);
 214         doReturn(Futures.immediateCheckedFuture(expectedLocalPool)).when(mockReadTx).read(
 215                 LogicalDatastoreType.CONFIGURATION, childIdentifier);
 216         InstanceIdentifier<IdEntries> idEntriesIdentifier = buildIdEntriesIdentifier(idKey);
 217         Optional<IdEntries> expectedIdEntry = Optional.of(buildIdEntry(idKey, idValue));
 218         doReturn(Futures.immediateCheckedFuture(expectedIdEntry)).when(mockReadTx).read(
 219                 LogicalDatastoreType.CONFIGURATION, idEntriesIdentifier);
 220         Future<RpcResult<Void>> result = idManager.releaseId(releaseIdInput);
 221         assertTrue(result.get().isSuccessful());
 222         assertEquals(0, configDataStore.size());
 223         DataObject idPoolVal = configDataStore.get(childIdentifier);
 224         if (idPoolVal instanceof IdPool) {
 225             IdPool pool = (IdPool) idPoolVal;
 226             assertEquals(0, pool.getReleasedIdsHolder().getAvailableIdCount().intValue());
 227             assertEquals(idValue, pool.getReleasedIdsHolder().getDelayedIdEntries().get(0).getId().intValue());
 228         }
 229         idPoolVal = configDataStore.get(identifier);
 230         if (idPoolVal instanceof IdPool) {
 231             IdPool parentPool = (IdPool) idPoolVal;
 232             assertEquals(0, parentPool.getIdEntries().size());
 233         }
 234     }
 235
 236     @Test
 237     public void testCleanupReleasedIds() throws Exception {
 238         AllocateIdInput allocateIdInput = buildAllocateId(globalPoolName, idKey2);
 239         Optional<ReleasedIdsHolder> expected = Optional.of(createReleasedIdsHolder(0, null, 0));
 240         long[] excessIds = new long[] { 1, 2, 3, 4, 5 };
 241         List<IdEntries> idEntries = new ArrayList<IdEntries>();
 242         idEntries.add(buildIdEntry(idKey2, idValue));
 243         ReleasedIdsHolder excessReleasedIds = createReleasedIdsHolder(0, buildDelayedIdEntries(excessIds), (long) 30);
 244         Optional<IdPool> expectedLocalPool = Optional.of(buildLocalIdPool(blockSize, localPoolName, globalPoolName)
 245                 .setReleasedIdsHolder(excessReleasedIds)
 246                 .build());
 247         InstanceIdentifier<ReleasedIdsHolder> releaseIdsIdentifier = buildReleaseIdsIdentifier(globalPoolName);
 248         IdPool globalIdPool = buildGlobalIdPool(globalPoolName, idStart, idEnd, blockSize, buildChildPool(localPoolName)).setIdEntries(idEntries).build();
 249         Optional<IdPool> expectedGlobalPool = Optional.of(globalIdPool);
 250         doReturn(Futures.immediateCheckedFuture(expectedGlobalPool)).when(mockReadTx).read(
 251                 LogicalDatastoreType.CONFIGURATION, identifier);
 252         doReturn(Futures.immediateCheckedFuture(expected)).when(mockReadTx)
 253                 .read(LogicalDatastoreType.CONFIGURATION, releaseIdsIdentifier);
 254         doReturn(Futures.immediateCheckedFuture(expectedLocalPool)).when(
 255                 mockReadTx).read(LogicalDatastoreType.CONFIGURATION,
 256                 childIdentifier);
 257         InstanceIdentifier<IdEntries> idEntriesIdentifier = buildIdEntriesIdentifier(idKey2);
 258         doReturn(Futures.immediateCheckedFuture(Optional.absent())).when(
 259                 mockReadTx).read(LogicalDatastoreType.CONFIGURATION,
 260                 idEntriesIdentifier);
 261
 262         Future<RpcResult<AllocateIdOutput>> result = idManager.allocateId(allocateIdInput);
 263         assertTrue(result.get().isSuccessful());
 264         assertEquals(0, configDataStore.size());
 265         DataObject dataObject = configDataStore.get(childIdentifier);
 266         if (dataObject instanceof IdPool) {
 267             IdPool pool = (IdPool) dataObject;
 268             assertEquals(localPoolName, pool.getPoolName());
 269             assertEquals(excessIds.length - 3, pool.getReleasedIdsHolder().getAvailableIdCount().intValue());
 270         }
 271         dataObject = configDataStore.get(identifier);
 272         if (dataObject instanceof IdPool) {
 273             IdPool parentPool = (IdPool) dataObject;
 274             assertEquals(2, parentPool.getIdEntries().size());
 275         }
 276         dataObject = configDataStore.get(releaseIdsIdentifier);
 277         if (dataObject instanceof ReleasedIdsHolder) {
 278             ReleasedIdsHolder releasedIds = (ReleasedIdsHolder) dataObject;
 279             assertEquals(2, releasedIds.getAvailableIdCount().intValue());
 280             assertEquals(2, releasedIds.getDelayedIdEntries().size());
 281         }
 282     }
 283
 284     @Test
 285     public void testAllocateIdBlockFromReleasedIds() throws Exception {
 286         AllocateIdInput allocateIdInput = buildAllocateId(globalPoolName, globalPoolName);
 287         List<DelayedIdEntries> delayedIdEntries = buildDelayedIdEntries(new long[] {1, 2, 3});
 288         ReleasedIdsHolder expectedReleasedIds = createReleasedIdsHolder(3, delayedIdEntries , 0);
 289         IdPool globalIdPool = buildGlobalIdPool(globalPoolName, idStart, idEnd, blockSize, buildChildPool(localPoolName)).setReleasedIdsHolder(expectedReleasedIds).build();
 290         Optional<IdPool> expected = Optional.of(globalIdPool);
 291         Optional<IdPool> expectedLocalPool = Optional.of(buildLocalIdPool(blockSize, localPoolName, globalPoolName).build());
 292         doReturn(Futures.immediateCheckedFuture(expected)).when(mockReadTx).read(
 293                 LogicalDatastoreType.CONFIGURATION, identifier);
 294         doReturn(Futures.immediateCheckedFuture(expectedLocalPool)).when(mockReadTx).read(
 295                 LogicalDatastoreType.CONFIGURATION, childIdentifier);
 296         InstanceIdentifier<IdEntries> idEntriesIdentifier = buildIdEntriesIdentifier(globalPoolName);
 297         doReturn(Futures.immediateCheckedFuture(Optional.absent())).when(mockReadTx).read(
 298                 LogicalDatastoreType.CONFIGURATION, idEntriesIdentifier);
 299         InstanceIdentifier<ReleasedIdsHolder> releaseIdsIdentifier = buildReleaseIdsIdentifier(globalPoolName);
 300
 301         Future<RpcResult<AllocateIdOutput>> result = idManager.allocateId(allocateIdInput);
 302         assertTrue(result.get().isSuccessful());
 303         assertEquals(0,configDataStore.size());
 304         DataObject dataObject = configDataStore.get(childIdentifier);
 305         if (dataObject instanceof IdPool) {
 306             IdPool pool = (IdPool) dataObject;
 307             assertEquals(localPoolName, pool.getPoolName());
 308             assertEquals(1, pool.getReleasedIdsHolder().getDelayedIdEntries().size());
 309             assertEquals(1, pool.getReleasedIdsHolder().getAvailableIdCount().intValue());
 310         }
 311         dataObject = configDataStore.get(identifier);
 312         if (dataObject instanceof IdPool) {
 313             IdPool parentPool = (IdPool) dataObject;
 314             assertEquals(1, parentPool.getIdEntries().size());
 315         }
 316         dataObject = configDataStore.get(releaseIdsIdentifier);
 317         if (dataObject instanceof ReleasedIdsHolder) {
 318             ReleasedIdsHolder releasedIds = (ReleasedIdsHolder) dataObject;
 319             assertEquals(1, releasedIds.getAvailableIdCount().intValue());
 320             assertEquals(1, releasedIds.getDelayedIdEntries().size());
 321         }
 322     }
 323
 324     @Test
 325     public void testDeletePool() throws Exception {
 326         IdPool globalIdPool = buildGlobalIdPool(globalPoolName, idStart, idEnd, blockSize, buildChildPool(localPoolName)).build();
 327         Optional<IdPool> expected = Optional.of(globalIdPool);
 328         Optional<IdPool> expectedLocalPool = Optional.of(buildLocalIdPool(blockSize, localPoolName, globalPoolName).build());
 329         doReturn(Futures.immediateCheckedFuture(expected)).when(mockReadTx).read(
 330                 LogicalDatastoreType.CONFIGURATION, identifier);
 331         doReturn(Futures.immediateCheckedFuture(expectedLocalPool)).when(mockReadTx).read(
 332                 LogicalDatastoreType.CONFIGURATION, childIdentifier);
 333         DeleteIdPoolInput deleteIdPoolInput = createDeleteIdPoolInput(globalPoolName);
 334         configDataStore.put(childIdentifier, null);
 335         configDataStore.put(identifier, null);
 336         Future<RpcResult<Void>> result = idManager.deleteIdPool(deleteIdPoolInput);
 337         assertTrue(result.get().isSuccessful());
 338         assertEquals(2, configDataStore.size());
 339     }
 340
 341     private InstanceIdentifier<ReleasedIdsHolder> buildReleaseIdsIdentifier(
 342             String poolName) {
 343         InstanceIdentifier<ReleasedIdsHolder> releasedIds = InstanceIdentifier
 344                 .builder(IdPools.class).child(IdPool.class,
 345                         new IdPoolKey(poolName)).child(ReleasedIdsHolder.class).build();
 346         return releasedIds;
 347     }
 348
 349     private InstanceIdentifier<AvailableIdsHolder> buildAvailbaleIdsIdentifier(
 350             String poolName) {
 351         InstanceIdentifier<AvailableIdsHolder> availableIds = InstanceIdentifier
 352                 .builder(IdPools.class).child(IdPool.class,
 353                         new IdPoolKey(poolName)).child(AvailableIdsHolder.class).build();
 354         return availableIds;
 355     }
 356
 357     private InstanceIdentifier<ChildPools> buildChildPoolInstanceIdentifier(String poolName, String childPoolName) {
 358         InstanceIdentifier<ChildPools> childPool = InstanceIdentifier
 359                 .builder(IdPools.class).child(IdPool.class,
 360                         new IdPoolKey(poolName)).child(ChildPools.class, new ChildPoolsKey(childPoolName)).build();
 361         return childPool;
 362     }
 363
 364     private ReleaseIdInput createReleaseIdInput(String poolName, String idKey) {
 365         return new ReleaseIdInputBuilder().setIdKey(idKey).setPoolName(poolName).build();
 366     }
 367
 368     private IdEntries buildIdEntry(String idKey, long idValue) {
 369         return new IdEntriesBuilder().setIdKey(idKey).setIdValue(idValue).build();
 370     }
 371
 372     private InstanceIdentifier<IdEntries> buildIdEntriesIdentifier(String idKey) {
 373         InstanceIdentifier.InstanceIdentifierBuilder<IdEntries> idEntriesBuilder = identifier
 374                 .builder().child(IdEntries.class, new IdEntriesKey(idKey));
 375         InstanceIdentifier<IdEntries> idEntry = idEntriesBuilder.build();
 376         return idEntry;
 377     }
 378
 379     private CreateIdPoolInput buildCreateIdPool(String poolName, long low, long high) {
 380         CreateIdPoolInput createPool = new CreateIdPoolInputBuilder().setPoolName(poolName)
 381                 .setLow(low)
 382                 .setHigh(high)
 383                 .build();
 384         return createPool;
 385     }
 386
 387     private IdPoolBuilder buildGlobalIdPool(String poolName, long idStart, long poolSize, int blockSize, List<ChildPools> childPools) {
 388         AvailableIdsHolder availableIdsHolder = createAvailableIdsHolder(idStart, poolSize, idStart - 1);
 389         ReleasedIdsHolder releasedIdsHolder = createReleasedIdsHolder(0, null, 0);
 390         return new IdPoolBuilder().setKey(new IdPoolKey(poolName))
 391                 .setPoolName(poolName)
 392                 .setBlockSize(blockSize)
 393                 .setChildPools(childPools)
 394                 .setAvailableIdsHolder(availableIdsHolder)
 395                 .setReleasedIdsHolder(releasedIdsHolder);
 396     }
 397
 398     private IdPoolBuilder buildLocalIdPool(int blockSize, String localPoolName, String parentPoolName) {
 399         ReleasedIdsHolder releasedIdsHolder = createReleasedIdsHolder(0, null, (long) 30);
 400         return new IdPoolBuilder().setBlockSize(blockSize)
 401                 .setKey(new IdPoolKey(localPoolName))
 402                 .setParentPoolName(parentPoolName)
 403                 .setReleasedIdsHolder(releasedIdsHolder);
 404     }
 405
 406     private AllocateIdInput buildAllocateId(String poolName, String idKey) {
 407         AllocateIdInput getIdInput = new AllocateIdInputBuilder().setPoolName(poolName)
 408                 .setIdKey(idKey).build();
 409         return getIdInput;
 410     }
 411
 412     private InstanceIdentifier<IdPool> buildInstanceIdentifier(String poolName) {
 413         InstanceIdentifier.InstanceIdentifierBuilder<IdPool> idBuilder =
 414                 InstanceIdentifier.builder(IdPools.class).child(IdPool.class, new IdPoolKey(poolName));
 415         InstanceIdentifier<IdPool> id = idBuilder.build();
 416         return id;
 417     }
 418
 419     private AvailableIdsHolder createAvailableIdsHolder(long low, long high, long cursor) {
 420         AvailableIdsHolder availableIdsHolder = new AvailableIdsHolderBuilder()
 421                 .setStart(low).setEnd(high).setCursor(cursor).build();
 422         return availableIdsHolder;
 423     }
 424
 425     private ReleasedIdsHolder createReleasedIdsHolder(long availableIdCount, List<DelayedIdEntries> delayedIdEntries, long delayTime) {
 426         ReleasedIdsHolder releasedIdsHolder = new ReleasedIdsHolderBuilder()
 427                 .setAvailableIdCount(availableIdCount)
 428                 .setDelayedIdEntries(delayedIdEntries)
 429                 .setDelayedTimeSec(delayTime).build();
 430         return releasedIdsHolder;
 431     }
 432
 433     private DeleteIdPoolInput createDeleteIdPoolInput(String poolName) {
 434         return new DeleteIdPoolInputBuilder().setPoolName(poolName).build();
 435     }
 436
 437     private List<DelayedIdEntries> buildDelayedIdEntries(long[] idValues) {
 438         List<DelayedIdEntries> delayedIdEntriesList = new ArrayList<DelayedIdEntries>();
 439         for (long idValue : idValues) {
 440             DelayedIdEntries delayedIdEntries = new DelayedIdEntriesBuilder().setId(idValue).setReadyTimeSec(0L).build();
 441             delayedIdEntriesList.add(delayedIdEntries);
 442         }
 443         return delayedIdEntriesList;
 444     }
 445
 446     private List<ChildPools> buildChildPool(String childPoolName) {
 447         ChildPools childPools = new ChildPoolsBuilder().setChildPoolName(childPoolName).build();
 448         List<ChildPools> childPoolsList = new ArrayList<ChildPools>();
 449         childPoolsList.add(childPools);
 450         return childPoolsList;
 451     }
 452 }