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         Optional<IdPool> expected = Optional.of(globalIdPool);
 166         List<IdEntries> idEntries = new ArrayList<IdEntries>();
 167         idEntries.add(buildIdEntry(idKey2, idValue));
 168         Optional<IdPool> expectedLocalPool = Optional.of(buildLocalIdPool(blockSize, localPoolName, globalPoolName).setIdEntries(idEntries).build());
 169         doReturn(Futures.immediateCheckedFuture(expected)).when(mockReadTx).read(
 170                 LogicalDatastoreType.CONFIGURATION, identifier);
 171         doReturn(Futures.immediateCheckedFuture(expectedLocalPool)).when(mockReadTx).read(
 172                 LogicalDatastoreType.CONFIGURATION, childIdentifier);
 173         InstanceIdentifier<IdEntries> idEntriesIdentifier = buildIdEntriesIdentifier(idKey);
 174         doReturn(Futures.immediateCheckedFuture(Optional.absent())).when(mockReadTx).read(
 175                 LogicalDatastoreType.CONFIGURATION, idEntriesIdentifier);
 176         InstanceIdentifier<AvailableIdsHolder> availableIdsIdentifier = buildAvailbaleIdsIdentifier(globalPoolName);
 177
 178         Future<RpcResult<AllocateIdOutput>> result = idManager.allocateId(allocateIdInput);
 179         assertTrue(result.get().isSuccessful());
 180         assertEquals(0,configDataStore.size());
 181         DataObject dataObject = configDataStore.get(childIdentifier);
 182         if (dataObject instanceof IdPool) {
 183             IdPool pool = (IdPool) dataObject;
 184             assertEquals(localPoolName, pool.getPoolName());
 185             assertEquals(idStart, pool.getAvailableIdsHolder().getStart().intValue());
 186             assertEquals(idStart + blockSize - 1 , pool.getAvailableIdsHolder().getEnd().intValue());
 187             assertEquals(idStart, pool.getAvailableIdsHolder().getCursor().intValue());
 188             assertEquals(2, pool.getIdEntries().size());
 189         }
 190         dataObject = configDataStore.get(availableIdsIdentifier);
 191         if (dataObject instanceof AvailableIdsHolder) {
 192             AvailableIdsHolder availableIds = (AvailableIdsHolder) dataObject;
 193             assertEquals(idEnd, availableIds.getEnd().intValue());
 194             assertEquals(idStart, availableIds.getStart().intValue());
 195             assertEquals(idStart + blockSize - 1, availableIds.getCursor().intValue());
 196         }
 197     }
 198
 199     @Test
 200     public void testReleaseId() throws Exception {
 201         ReleaseIdInput releaseIdInput = createReleaseIdInput(globalPoolName, idKey);
 202         List<IdEntries> idEntries = new ArrayList<IdEntries>();
 203         idEntries.add(buildIdEntry(idKey, idValue));
 204         Optional<IdPool> expectedLocalPool = Optional.of(buildLocalIdPool(blockSize, localPoolName, globalPoolName).setIdEntries(idEntries).build());
 205         doReturn(Futures.immediateCheckedFuture(expectedLocalPool)).when(mockReadTx).read(
 206                 LogicalDatastoreType.CONFIGURATION, childIdentifier);
 207         InstanceIdentifier<IdEntries> idEntriesIdentifier = buildIdEntriesIdentifier(idKey);
 208         Optional<IdEntries> expectedIdEntry = Optional.of(buildIdEntry(idKey, idValue));
 209         doReturn(Futures.immediateCheckedFuture(expectedIdEntry)).when(mockReadTx).read(
 210                 LogicalDatastoreType.CONFIGURATION, idEntriesIdentifier);
 211         Future<RpcResult<Void>> result = idManager.releaseId(releaseIdInput);
 212         assertTrue(result.get().isSuccessful());
 213         assertEquals(0, configDataStore.size());
 214         DataObject idPoolVal = configDataStore.get(childIdentifier);
 215         if (idPoolVal instanceof IdPool) {
 216             IdPool pool = (IdPool) idPoolVal;
 217             assertEquals(0, pool.getIdEntries().size());
 218             assertEquals(0, pool.getReleasedIdsHolder().getAvailableIdCount().intValue());
 219             assertEquals(idValue, pool.getReleasedIdsHolder().getDelayedIdEntries().get(0).getId().intValue());
 220         }
 221     }
 222
 223     @Test
 224     public void testCleanupReleasedIds() throws Exception {
 225         AllocateIdInput allocateIdInput = buildAllocateId(globalPoolName, idKey2);
 226         Optional<ReleasedIdsHolder> expected = Optional.of(createReleasedIdsHolder(0, null, 0));
 227         long[] excessIds = new long[] { 1, 2, 3, 4, 5 };
 228         List<IdEntries> idEntries = new ArrayList<IdEntries>();
 229         idEntries.add(buildIdEntry(idKey2, idValue));
 230         ReleasedIdsHolder excessReleasedIds = createReleasedIdsHolder(0, buildDelayedIdEntries(excessIds), (long) 30);
 231         Optional<IdPool> expectedLocalPool = Optional.of(buildLocalIdPool(blockSize, localPoolName, globalPoolName)
 232                 .setIdEntries(idEntries).setReleasedIdsHolder(excessReleasedIds)
 233                 .build());
 234         InstanceIdentifier<ReleasedIdsHolder> releaseIdsIdentifier = buildReleaseIdsIdentifier(globalPoolName);
 235         doReturn(Futures.immediateCheckedFuture(expected)).when(mockReadTx)
 236                 .read(LogicalDatastoreType.CONFIGURATION, releaseIdsIdentifier);
 237         doReturn(Futures.immediateCheckedFuture(expectedLocalPool)).when(
 238                 mockReadTx).read(LogicalDatastoreType.CONFIGURATION,
 239                 childIdentifier);
 240         InstanceIdentifier<IdEntries> idEntriesIdentifier = buildIdEntriesIdentifier(idKey2);
 241         doReturn(Futures.immediateCheckedFuture(Optional.absent())).when(
 242                 mockReadTx).read(LogicalDatastoreType.CONFIGURATION,
 243                 idEntriesIdentifier);
 244
 245         Future<RpcResult<AllocateIdOutput>> result = idManager.allocateId(allocateIdInput);
 246         assertTrue(result.get().isSuccessful());
 247         assertEquals(0, configDataStore.size());
 248         DataObject dataObject = configDataStore.get(childIdentifier);
 249         if (dataObject instanceof IdPool) {
 250             IdPool pool = (IdPool) dataObject;
 251             assertEquals(localPoolName, pool.getPoolName());
 252             assertEquals(excessIds.length - 3, pool.getReleasedIdsHolder().getAvailableIdCount().intValue());
 253             assertEquals(2, pool.getIdEntries().size());
 254         }
 255         dataObject = configDataStore.get(releaseIdsIdentifier);
 256         if (dataObject instanceof ReleasedIdsHolder) {
 257             ReleasedIdsHolder releasedIds = (ReleasedIdsHolder) dataObject;
 258             assertEquals(2, releasedIds.getAvailableIdCount().intValue());
 259             assertEquals(2, releasedIds.getDelayedIdEntries().size());
 260         }
 261     }
 262
 263     @Test
 264     public void testAllocateIdBlockFromReleasedIds() throws Exception {
 265         AllocateIdInput allocateIdInput = buildAllocateId(globalPoolName, globalPoolName);
 266         List<DelayedIdEntries> delayedIdEntries = buildDelayedIdEntries(new long[] {1, 2, 3});
 267         ReleasedIdsHolder expectedReleasedIds = createReleasedIdsHolder(3, delayedIdEntries , 0);
 268         IdPool globalIdPool = buildGlobalIdPool(globalPoolName, idStart, idEnd, blockSize, buildChildPool(localPoolName)).setReleasedIdsHolder(expectedReleasedIds).build();
 269         Optional<IdPool> expected = Optional.of(globalIdPool);
 270         Optional<IdPool> expectedLocalPool = Optional.of(buildLocalIdPool(blockSize, localPoolName, globalPoolName).build());
 271         doReturn(Futures.immediateCheckedFuture(expected)).when(mockReadTx).read(
 272                 LogicalDatastoreType.CONFIGURATION, identifier);
 273         doReturn(Futures.immediateCheckedFuture(expectedLocalPool)).when(mockReadTx).read(
 274                 LogicalDatastoreType.CONFIGURATION, childIdentifier);
 275         InstanceIdentifier<IdEntries> idEntriesIdentifier = buildIdEntriesIdentifier(globalPoolName);
 276         doReturn(Futures.immediateCheckedFuture(Optional.absent())).when(mockReadTx).read(
 277                 LogicalDatastoreType.CONFIGURATION, idEntriesIdentifier);
 278         InstanceIdentifier<ReleasedIdsHolder> releaseIdsIdentifier = buildReleaseIdsIdentifier(globalPoolName);
 279
 280         Future<RpcResult<AllocateIdOutput>> result = idManager.allocateId(allocateIdInput);
 281         assertTrue(result.get().isSuccessful());
 282         assertEquals(0,configDataStore.size());
 283         DataObject dataObject = configDataStore.get(childIdentifier);
 284         if (dataObject instanceof IdPool) {
 285             IdPool pool = (IdPool) dataObject;
 286             assertEquals(localPoolName, pool.getPoolName());
 287             assertEquals(1, pool.getReleasedIdsHolder().getDelayedIdEntries().size());
 288             assertEquals(1, pool.getIdEntries().size());
 289             assertEquals(1, pool.getReleasedIdsHolder().getAvailableIdCount().intValue());
 290         }
 291         dataObject = configDataStore.get(releaseIdsIdentifier);
 292         if (dataObject instanceof ReleasedIdsHolder) {
 293             ReleasedIdsHolder releasedIds = (ReleasedIdsHolder) dataObject;
 294             assertEquals(1, releasedIds.getAvailableIdCount().intValue());
 295             assertEquals(1, releasedIds.getDelayedIdEntries().size());
 296         }
 297     }
 298
 299     @Test
 300     public void testDeletePool() throws Exception {
 301         IdPool globalIdPool = buildGlobalIdPool(globalPoolName, idStart, idEnd, blockSize, buildChildPool(localPoolName)).build();
 302         Optional<IdPool> expected = Optional.of(globalIdPool);
 303         Optional<IdPool> expectedLocalPool = Optional.of(buildLocalIdPool(blockSize, localPoolName, globalPoolName).build());
 304         doReturn(Futures.immediateCheckedFuture(expected)).when(mockReadTx).read(
 305                 LogicalDatastoreType.CONFIGURATION, identifier);
 306         doReturn(Futures.immediateCheckedFuture(expectedLocalPool)).when(mockReadTx).read(
 307                 LogicalDatastoreType.CONFIGURATION, childIdentifier);
 308         DeleteIdPoolInput deleteIdPoolInput = createDeleteIdPoolInput(globalPoolName);
 309         configDataStore.put(childIdentifier, null);
 310         configDataStore.put(identifier, null);
 311         Future<RpcResult<Void>> result = idManager.deleteIdPool(deleteIdPoolInput);
 312         assertTrue(result.get().isSuccessful());
 313         assertEquals(2, configDataStore.size());
 314     }
 315
 316     private InstanceIdentifier<ReleasedIdsHolder> buildReleaseIdsIdentifier(
 317             String poolName) {
 318         InstanceIdentifier<ReleasedIdsHolder> releasedIds = InstanceIdentifier
 319                 .builder(IdPools.class).child(IdPool.class,
 320                         new IdPoolKey(poolName)).child(ReleasedIdsHolder.class).build();
 321         return releasedIds;
 322     }
 323
 324     private InstanceIdentifier<AvailableIdsHolder> buildAvailbaleIdsIdentifier(
 325             String poolName) {
 326         InstanceIdentifier<AvailableIdsHolder> availableIds = InstanceIdentifier
 327                 .builder(IdPools.class).child(IdPool.class,
 328                         new IdPoolKey(poolName)).child(AvailableIdsHolder.class).build();
 329         return availableIds;
 330     }
 331
 332     private InstanceIdentifier<ChildPools> buildChildPoolInstanceIdentifier(String poolName, String childPoolName) {
 333         InstanceIdentifier<ChildPools> childPool = InstanceIdentifier
 334                 .builder(IdPools.class).child(IdPool.class,
 335                         new IdPoolKey(poolName)).child(ChildPools.class, new ChildPoolsKey(childPoolName)).build();
 336         return childPool;
 337     }
 338
 339     private ReleaseIdInput createReleaseIdInput(String poolName, String idKey) {
 340         return new ReleaseIdInputBuilder().setIdKey(idKey).setPoolName(poolName).build();
 341     }
 342
 343     private IdEntries buildIdEntry(String idKey, long idValue) {
 344         return new IdEntriesBuilder().setIdKey(idKey).setIdValue(idValue).build();
 345     }
 346
 347     private InstanceIdentifier<IdEntries> buildIdEntriesIdentifier(String idKey) {
 348         InstanceIdentifier.InstanceIdentifierBuilder<IdEntries> idEntriesBuilder = childIdentifier
 349                 .builder().child(IdEntries.class, new IdEntriesKey(idKey));
 350         InstanceIdentifier<IdEntries> idEntry = idEntriesBuilder.build();
 351         return idEntry;
 352     }
 353
 354     private CreateIdPoolInput buildCreateIdPool(String poolName, long low, long high) {
 355         CreateIdPoolInput createPool = new CreateIdPoolInputBuilder().setPoolName(poolName)
 356                 .setLow(low)
 357                 .setHigh(high)
 358                 .build();
 359         return createPool;
 360     }
 361
 362     private IdPoolBuilder buildGlobalIdPool(String poolName, long idStart, long poolSize, int blockSize, List<ChildPools> childPools) {
 363         AvailableIdsHolder availableIdsHolder = createAvailableIdsHolder(idStart, poolSize, idStart - 1);
 364         ReleasedIdsHolder releasedIdsHolder = createReleasedIdsHolder(0, null, 0);
 365         return new IdPoolBuilder().setKey(new IdPoolKey(poolName))
 366                 .setPoolName(poolName)
 367                 .setBlockSize(blockSize)
 368                 .setChildPools(childPools)
 369                 .setAvailableIdsHolder(availableIdsHolder)
 370                 .setReleasedIdsHolder(releasedIdsHolder);
 371     }
 372
 373     private IdPoolBuilder buildLocalIdPool(int blockSize, String localPoolName, String parentPoolName) {
 374         ReleasedIdsHolder releasedIdsHolder = createReleasedIdsHolder(0, null, (long) 30);
 375         return new IdPoolBuilder().setBlockSize(blockSize)
 376                 .setKey(new IdPoolKey(localPoolName))
 377                 .setParentPoolName(parentPoolName)
 378                 .setReleasedIdsHolder(releasedIdsHolder);
 379     }
 380
 381     private AllocateIdInput buildAllocateId(String poolName, String idKey) {
 382         AllocateIdInput getIdInput = new AllocateIdInputBuilder().setPoolName(poolName)
 383                 .setIdKey(idKey).build();
 384         return getIdInput;
 385     }
 386
 387     private InstanceIdentifier<IdPool> buildInstanceIdentifier(String poolName) {
 388         InstanceIdentifier.InstanceIdentifierBuilder<IdPool> idBuilder =
 389                 InstanceIdentifier.builder(IdPools.class).child(IdPool.class, new IdPoolKey(poolName));
 390         InstanceIdentifier<IdPool> id = idBuilder.build();
 391         return id;
 392     }
 393
 394     private AvailableIdsHolder createAvailableIdsHolder(long low, long high, long cursor) {
 395         AvailableIdsHolder availableIdsHolder = new AvailableIdsHolderBuilder()
 396                 .setStart(low).setEnd(high).setCursor(cursor).build();
 397         return availableIdsHolder;
 398     }
 399
 400     private ReleasedIdsHolder createReleasedIdsHolder(long availableIdCount, List<DelayedIdEntries> delayedIdEntries, long delayTime) {
 401         ReleasedIdsHolder releasedIdsHolder = new ReleasedIdsHolderBuilder()
 402                 .setAvailableIdCount(availableIdCount)
 403                 .setDelayedIdEntries(delayedIdEntries)
 404                 .setDelayedTimeSec(delayTime).build();
 405         return releasedIdsHolder;
 406     }
 407
 408     private DeleteIdPoolInput createDeleteIdPoolInput(String poolName) {
 409         return new DeleteIdPoolInputBuilder().setPoolName(poolName).build();
 410     }
 411
 412     private List<DelayedIdEntries> buildDelayedIdEntries(long[] idValues) {
 413         List<DelayedIdEntries> delayedIdEntriesList = new ArrayList<DelayedIdEntries>();
 414         for (long idValue : idValues) {
 415             DelayedIdEntries delayedIdEntries = new DelayedIdEntriesBuilder().setId(idValue).setReadyTimeSec(0L).build();
 416             delayedIdEntriesList.add(delayedIdEntries);
 417         }
 418         return delayedIdEntriesList;
 419     }
 420
 421     private List<ChildPools> buildChildPool(String childPoolName) {
 422         ChildPools childPools = new ChildPoolsBuilder().setChildPoolName(childPoolName).build();
 423         List<ChildPools> childPoolsList = new ArrayList<ChildPools>();
 424         childPoolsList.add(childPools);
 425         return childPoolsList;
 426     }
 427 }