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

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