package org.opendaylight.idmanager.test;
import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.eq;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.when;
+
+import java.net.InetAddress;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.Future;
+
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.runners.MockitoJUnitRunner;
-import com.google.common.base.Optional;
-import com.google.common.util.concurrent.FutureCallback;
-import com.google.common.util.concurrent.Futures;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.idmanager.IdManager;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.*;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.pools.IdPool;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.pools.IdPoolBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.pools.IdPoolKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.pools.id.pool.GeneratedIds;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.AllocateIdInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.AllocateIdInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.AllocateIdOutput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.CreateIdPoolInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.CreateIdPoolInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.DeleteIdPoolInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.DeleteIdPoolInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.IdPools;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.ReleaseIdInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.ReleaseIdInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.id.pools.IdPool;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.id.pools.IdPoolBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.id.pools.IdPoolKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.id.pools.id.pool.AvailableIdsHolder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.id.pools.id.pool.AvailableIdsHolderBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.id.pools.id.pool.ChildPools;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.id.pools.id.pool.ChildPoolsBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.id.pools.id.pool.ChildPoolsKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.id.pools.id.pool.IdEntries;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.id.pools.id.pool.IdEntriesBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.id.pools.id.pool.IdEntriesKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.id.pools.id.pool.ReleasedIdsHolder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.id.pools.id.pool.ReleasedIdsHolderBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.released.ids.DelayedIdEntries;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.released.ids.DelayedIdEntriesBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.lockmanager.rev150819.LockInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.lockmanager.rev150819.LockManagerService;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.lockmanager.rev150819.UnlockInput;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.RpcResult;
+import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import java.math.BigInteger;
-import java.util.*;
-import java.util.concurrent.Future;
+
+import com.google.common.base.Optional;
+import com.google.common.net.InetAddresses;
+import com.google.common.util.concurrent.Futures;
@RunWith(MockitoJUnitRunner.class)
public class IdManagerTest {
private static final Logger LOG = LoggerFactory.getLogger(IdManagerTest.class);
- Map<InstanceIdentifier<?>,DataObject> written = new HashMap<>();
- Map<InstanceIdentifier<?>,DataObject> updated = new HashMap<>();
+ private static int BLADE_ID;
+ static {
+ String hostName;
+ try {
+ hostName = InetAddress.getLocalHost().getHostName();
+ BLADE_ID = InetAddresses.coerceToInteger(InetAddress.getLocalHost());
+ if (hostName.indexOf("-") > 0) {
+ BLADE_ID = new Integer(hostName.split("-")[1].toString()).intValue();
+ } else {
+ LOG.error("Host name {} is not matching with the condition!! PL-X is expected", hostName);
+ }
+ } catch (Exception e) {
+ LOG.error("IdManager - Exception - {}", e.getMessage());
+ }
+ }
+
+ Map<InstanceIdentifier<?>,DataObject> configDataStore = new HashMap<>();
@Mock DataBroker dataBroker;
@Mock ReadOnlyTransaction mockReadTx;
@Mock WriteTransaction mockWriteTx;
- CreateIdPoolInput createPoolTest;
- GetUniqueIdInput getIdInputTest;
+ @Mock LockManagerService lockManager;
+ Future<RpcResult<Void>> rpcResult;
IdManager idManager;
- IdPool idPoolTest;
+ IdPool globalIdPool;
InstanceIdentifier<IdPool> identifier;
+ InstanceIdentifier<IdPool> childIdentifier;
+ InstanceIdentifier<ChildPools> childPoolIdentifier;
+ String globalPoolName = "test-pool";
+ String localPoolName = new StringBuilder(globalPoolName).append(".").append(BLADE_ID).toString();
+ String idKey = "test-key1";
+ int idStart = 100;
+ int idEnd = 200;
+ int blockSize = 2;
+ String idKey2 = "test-key2";
+ int idValue = 25;
@Before
public void setUp() throws Exception {
- idManager = new IdManager(dataBroker) {
- protected <T extends DataObject> void asyncWrite(LogicalDatastoreType datastoreType,
- InstanceIdentifier<T> path, T data, FutureCallback<Void> callback) {
- written.put(path, data);
- }
- protected <T extends DataObject> void asyncUpdate(LogicalDatastoreType datastoreType,
- InstanceIdentifier<T> path, T data, FutureCallback<Void> callback) {
- updated.put(path, data);
- }
-
- };
+ idManager = new IdManager(dataBroker);
+ idManager.setLockManager(lockManager);
setupMocks();
}
private void setupMocks() {
- createPoolTest = buildCreateIdPool("vpn", 100, 100);
- getIdInputTest = buildUniqueId("vpn", "vpn1");
- idPoolTest = buildIdPool("vpn", 100, 100);
- identifier = buildInstanceIdentifier("vpn");
+ globalIdPool = buildGlobalIdPool(globalPoolName, idStart, idEnd, blockSize, buildChildPool(localPoolName)).build();
+ identifier = buildInstanceIdentifier(globalPoolName);
+ childIdentifier = buildInstanceIdentifier(localPoolName);
+ childPoolIdentifier = buildChildPoolInstanceIdentifier(globalPoolName, localPoolName);
when(dataBroker.newReadOnlyTransaction()).thenReturn(mockReadTx);
when(dataBroker.newWriteOnlyTransaction()).thenReturn(mockWriteTx);
+ when(lockManager.lock(any(LockInput.class))).thenReturn(Futures.immediateFuture(RpcResultBuilder.<Void>success().build()));
+ when(lockManager.unlock(any(UnlockInput.class))).thenReturn(Futures.immediateFuture(RpcResultBuilder.<Void>success().build()));
+ doReturn(Futures.immediateCheckedFuture(null)).when(mockWriteTx).submit();
+ doReturn(Futures.immediateCheckedFuture(null)).when(mockReadTx).read(eq(LogicalDatastoreType.OPERATIONAL), any(InstanceIdentifier.class));
}
@Test
- public void testCreateIdPool()
+ public void testCreateIdPool() throws Exception
{
+ CreateIdPoolInput createPoolTest = buildCreateIdPool(globalPoolName, idStart, idEnd);
doReturn(Futures.immediateCheckedFuture(Optional.absent())).when(mockReadTx).read(
- LogicalDatastoreType.OPERATIONAL, identifier);
-
+ LogicalDatastoreType.CONFIGURATION, identifier);
+ doReturn(Futures.immediateCheckedFuture(Optional.absent())).when(mockReadTx).read(
+ LogicalDatastoreType.CONFIGURATION, childIdentifier);
Future<RpcResult<Void>> result = idManager.createIdPool(createPoolTest);
- Collection<DataObject> idPoolVal = new ArrayList< >();
- idPoolVal = written.values();
- assertEquals(1,written.size());
- for (DataObject poolData: idPoolVal) {
- IdPool pool = null;
- if (poolData instanceof IdPool) {
- pool = (IdPool) poolData;
- assertEquals(createPoolTest.getPoolName(), pool.getPoolName());
- assertEquals(createPoolTest.getIdStart(), pool.getIdStart());
- assertEquals(createPoolTest.getPoolSize(), pool.getPoolSize());
- }
- }
+ DataObject dataObject;
+ IdPool pool;
+ assertTrue(result.get().isSuccessful());
+ assertEquals(0,configDataStore.size());
+ dataObject = configDataStore.get(childIdentifier);
+ if (dataObject instanceof IdPool) {
+ pool = (IdPool) dataObject;
+ assertEquals(localPoolName, pool.getPoolName());
+ assertEquals(createPoolTest.getPoolName(), pool.getParentPoolName());
+ assertEquals(null, pool.getAvailableIdsHolder());
+ assertEquals(30, pool.getReleasedIdsHolder().getDelayedTimeSec().longValue());
+ assertEquals(0, pool.getReleasedIdsHolder().getAvailableIdCount().longValue());
+ assertEquals(blockSize, pool.getBlockSize().longValue());
+ }
+ dataObject = configDataStore.get(identifier);
+ if (dataObject instanceof IdPool) {
+ pool = (IdPool) dataObject;
+ assertEquals(createPoolTest.getPoolName(), pool.getPoolName());
+ assertEquals(0, pool.getReleasedIdsHolder().getDelayedTimeSec().longValue());
+ assertEquals(0, pool.getReleasedIdsHolder().getAvailableIdCount().longValue());
+ assertEquals(createPoolTest.getLow(), pool.getAvailableIdsHolder().getStart());
+ assertEquals(createPoolTest.getHigh(), pool.getAvailableIdsHolder().getEnd());
+ assertEquals(createPoolTest.getLow() - 1, pool.getAvailableIdsHolder().getCursor().intValue());
+ assertEquals(blockSize, pool.getBlockSize().longValue());
+ }
+ dataObject = configDataStore.get(childPoolIdentifier);
+ if (dataObject instanceof ChildPools) {
+ ChildPools childPool = (ChildPools) dataObject;
+ assertEquals(localPoolName, childPool.getChildPoolName());
+ }
}
@Test
- public void testUniqueId()
+ public void testAllocateId() throws Exception
{
- Optional<IdPool> expected = Optional.of(idPoolTest);
+ AllocateIdInput allocateIdInput = buildAllocateId(globalPoolName, idKey);
+ Optional<IdPool> expected = Optional.of(globalIdPool);
+ List<IdEntries> idEntries = new ArrayList<IdEntries>();
+ idEntries.add(buildIdEntry(idKey2, idValue));
+ Optional<IdPool> expectedLocalPool = Optional.of(buildLocalIdPool(blockSize, localPoolName, globalPoolName).setIdEntries(idEntries).build());
doReturn(Futures.immediateCheckedFuture(expected)).when(mockReadTx).read(
- LogicalDatastoreType.OPERATIONAL, identifier);
-
- idManager.getUniqueId(getIdInputTest);
- Collection<DataObject> idPoolVal = new ArrayList< >();
- idPoolVal = updated.values();
- assertEquals(1,updated.size());
- for (DataObject poolData: idPoolVal) {
- IdPool pool = null;
- if (poolData instanceof IdPool) {
- pool = (IdPool) poolData;
- assertEquals(getIdInputTest.getPoolName(), pool.getPoolName());
- List <GeneratedIds> genIds = pool.getGeneratedIds();
- assertEquals(1,genIds.size());
- }
- }
+ LogicalDatastoreType.CONFIGURATION, identifier);
+ doReturn(Futures.immediateCheckedFuture(expectedLocalPool)).when(mockReadTx).read(
+ LogicalDatastoreType.CONFIGURATION, childIdentifier);
+ InstanceIdentifier<IdEntries> idEntriesIdentifier = buildIdEntriesIdentifier(idKey);
+ doReturn(Futures.immediateCheckedFuture(Optional.absent())).when(mockReadTx).read(
+ LogicalDatastoreType.CONFIGURATION, idEntriesIdentifier);
+ InstanceIdentifier<AvailableIdsHolder> availableIdsIdentifier = buildAvailbaleIdsIdentifier(globalPoolName);
+
+ Future<RpcResult<AllocateIdOutput>> result = idManager.allocateId(allocateIdInput);
+ assertTrue(result.get().isSuccessful());
+ assertEquals(0,configDataStore.size());
+ DataObject dataObject = configDataStore.get(childIdentifier);
+ if (dataObject instanceof IdPool) {
+ IdPool pool = (IdPool) dataObject;
+ assertEquals(localPoolName, pool.getPoolName());
+ assertEquals(idStart, pool.getAvailableIdsHolder().getStart().intValue());
+ assertEquals(idStart + blockSize - 1 , pool.getAvailableIdsHolder().getEnd().intValue());
+ assertEquals(idStart, pool.getAvailableIdsHolder().getCursor().intValue());
+ assertEquals(2, pool.getIdEntries().size());
+ }
+ dataObject = configDataStore.get(availableIdsIdentifier);
+ if (dataObject instanceof AvailableIdsHolder) {
+ AvailableIdsHolder availableIds = (AvailableIdsHolder) dataObject;
+ assertEquals(idEnd, availableIds.getEnd().intValue());
+ assertEquals(idStart, availableIds.getStart().intValue());
+ assertEquals(idStart + blockSize - 1, availableIds.getCursor().intValue());
+ }
+ }
+
+ @Test
+ public void testReleaseId() throws Exception {
+ ReleaseIdInput releaseIdInput = createReleaseIdInput(globalPoolName, idKey);
+ List<IdEntries> idEntries = new ArrayList<IdEntries>();
+ idEntries.add(buildIdEntry(idKey, idValue));
+ Optional<IdPool> expectedLocalPool = Optional.of(buildLocalIdPool(blockSize, localPoolName, globalPoolName).setIdEntries(idEntries).build());
+ doReturn(Futures.immediateCheckedFuture(expectedLocalPool)).when(mockReadTx).read(
+ LogicalDatastoreType.CONFIGURATION, childIdentifier);
+ InstanceIdentifier<IdEntries> idEntriesIdentifier = buildIdEntriesIdentifier(idKey);
+ Optional<IdEntries> expectedIdEntry = Optional.of(buildIdEntry(idKey, idValue));
+ doReturn(Futures.immediateCheckedFuture(expectedIdEntry)).when(mockReadTx).read(
+ LogicalDatastoreType.CONFIGURATION, idEntriesIdentifier);
+ Future<RpcResult<Void>> result = idManager.releaseId(releaseIdInput);
+ assertTrue(result.get().isSuccessful());
+ assertEquals(0, configDataStore.size());
+ DataObject idPoolVal = configDataStore.get(childIdentifier);
+ if (idPoolVal instanceof IdPool) {
+ IdPool pool = (IdPool) idPoolVal;
+ assertEquals(0, pool.getIdEntries().size());
+ assertEquals(0, pool.getReleasedIdsHolder().getAvailableIdCount().intValue());
+ assertEquals(idValue, pool.getReleasedIdsHolder().getDelayedIdEntries().get(0).getId().intValue());
+ }
+ }
+
+ @Test
+ public void testCleanupReleasedIds() throws Exception {
+ AllocateIdInput allocateIdInput = buildAllocateId(globalPoolName, idKey2);
+ Optional<ReleasedIdsHolder> expected = Optional.of(createReleasedIdsHolder(0, null, 0));
+ long[] excessIds = new long[] { 1, 2, 3, 4, 5 };
+ List<IdEntries> idEntries = new ArrayList<IdEntries>();
+ idEntries.add(buildIdEntry(idKey2, idValue));
+ ReleasedIdsHolder excessReleasedIds = createReleasedIdsHolder(0, buildDelayedIdEntries(excessIds), (long) 30);
+ Optional<IdPool> expectedLocalPool = Optional.of(buildLocalIdPool(blockSize, localPoolName, globalPoolName)
+ .setIdEntries(idEntries).setReleasedIdsHolder(excessReleasedIds)
+ .build());
+ InstanceIdentifier<ReleasedIdsHolder> releaseIdsIdentifier = buildReleaseIdsIdentifier(globalPoolName);
+ doReturn(Futures.immediateCheckedFuture(expected)).when(mockReadTx)
+ .read(LogicalDatastoreType.CONFIGURATION, releaseIdsIdentifier);
+ doReturn(Futures.immediateCheckedFuture(expectedLocalPool)).when(
+ mockReadTx).read(LogicalDatastoreType.CONFIGURATION,
+ childIdentifier);
+ InstanceIdentifier<IdEntries> idEntriesIdentifier = buildIdEntriesIdentifier(idKey2);
+ doReturn(Futures.immediateCheckedFuture(Optional.absent())).when(
+ mockReadTx).read(LogicalDatastoreType.CONFIGURATION,
+ idEntriesIdentifier);
+
+ Future<RpcResult<AllocateIdOutput>> result = idManager.allocateId(allocateIdInput);
+ assertTrue(result.get().isSuccessful());
+ assertEquals(0, configDataStore.size());
+ DataObject dataObject = configDataStore.get(childIdentifier);
+ if (dataObject instanceof IdPool) {
+ IdPool pool = (IdPool) dataObject;
+ assertEquals(localPoolName, pool.getPoolName());
+ assertEquals(excessIds.length - 3, pool.getReleasedIdsHolder().getAvailableIdCount().intValue());
+ assertEquals(2, pool.getIdEntries().size());
+ }
+ dataObject = configDataStore.get(releaseIdsIdentifier);
+ if (dataObject instanceof ReleasedIdsHolder) {
+ ReleasedIdsHolder releasedIds = (ReleasedIdsHolder) dataObject;
+ assertEquals(2, releasedIds.getAvailableIdCount().intValue());
+ assertEquals(2, releasedIds.getDelayedIdEntries().size());
+ }
+ }
+
+ @Test
+ public void testAllocateIdBlockFromReleasedIds() throws Exception {
+ AllocateIdInput allocateIdInput = buildAllocateId(globalPoolName, globalPoolName);
+ List<DelayedIdEntries> delayedIdEntries = buildDelayedIdEntries(new long[] {1, 2, 3});
+ ReleasedIdsHolder expectedReleasedIds = createReleasedIdsHolder(3, delayedIdEntries , 0);
+ IdPool globalIdPool = buildGlobalIdPool(globalPoolName, idStart, idEnd, blockSize, buildChildPool(localPoolName)).setReleasedIdsHolder(expectedReleasedIds).build();
+ Optional<IdPool> expected = Optional.of(globalIdPool);
+ Optional<IdPool> expectedLocalPool = Optional.of(buildLocalIdPool(blockSize, localPoolName, globalPoolName).build());
+ doReturn(Futures.immediateCheckedFuture(expected)).when(mockReadTx).read(
+ LogicalDatastoreType.CONFIGURATION, identifier);
+ doReturn(Futures.immediateCheckedFuture(expectedLocalPool)).when(mockReadTx).read(
+ LogicalDatastoreType.CONFIGURATION, childIdentifier);
+ InstanceIdentifier<IdEntries> idEntriesIdentifier = buildIdEntriesIdentifier(globalPoolName);
+ doReturn(Futures.immediateCheckedFuture(Optional.absent())).when(mockReadTx).read(
+ LogicalDatastoreType.CONFIGURATION, idEntriesIdentifier);
+ InstanceIdentifier<ReleasedIdsHolder> releaseIdsIdentifier = buildReleaseIdsIdentifier(globalPoolName);
+
+ Future<RpcResult<AllocateIdOutput>> result = idManager.allocateId(allocateIdInput);
+ assertTrue(result.get().isSuccessful());
+ assertEquals(0,configDataStore.size());
+ DataObject dataObject = configDataStore.get(childIdentifier);
+ if (dataObject instanceof IdPool) {
+ IdPool pool = (IdPool) dataObject;
+ assertEquals(localPoolName, pool.getPoolName());
+ assertEquals(1, pool.getReleasedIdsHolder().getDelayedIdEntries().size());
+ assertEquals(1, pool.getIdEntries().size());
+ assertEquals(1, pool.getReleasedIdsHolder().getAvailableIdCount().intValue());
+ }
+ dataObject = configDataStore.get(releaseIdsIdentifier);
+ if (dataObject instanceof ReleasedIdsHolder) {
+ ReleasedIdsHolder releasedIds = (ReleasedIdsHolder) dataObject;
+ assertEquals(1, releasedIds.getAvailableIdCount().intValue());
+ assertEquals(1, releasedIds.getDelayedIdEntries().size());
+ }
+ }
+
+ @Test
+ public void testDeletePool() throws Exception {
+ IdPool globalIdPool = buildGlobalIdPool(globalPoolName, idStart, idEnd, blockSize, buildChildPool(localPoolName)).build();
+ Optional<IdPool> expected = Optional.of(globalIdPool);
+ Optional<IdPool> expectedLocalPool = Optional.of(buildLocalIdPool(blockSize, localPoolName, globalPoolName).build());
+ doReturn(Futures.immediateCheckedFuture(expected)).when(mockReadTx).read(
+ LogicalDatastoreType.CONFIGURATION, identifier);
+ doReturn(Futures.immediateCheckedFuture(expectedLocalPool)).when(mockReadTx).read(
+ LogicalDatastoreType.CONFIGURATION, childIdentifier);
+ DeleteIdPoolInput deleteIdPoolInput = createDeleteIdPoolInput(globalPoolName);
+ configDataStore.put(childIdentifier, null);
+ configDataStore.put(identifier, null);
+ Future<RpcResult<Void>> result = idManager.deleteIdPool(deleteIdPoolInput);
+ assertTrue(result.get().isSuccessful());
+ assertEquals(2, configDataStore.size());
+ }
+
+ private InstanceIdentifier<ReleasedIdsHolder> buildReleaseIdsIdentifier(
+ String poolName) {
+ InstanceIdentifier<ReleasedIdsHolder> releasedIds = InstanceIdentifier
+ .builder(IdPools.class).child(IdPool.class,
+ new IdPoolKey(poolName)).child(ReleasedIdsHolder.class).build();
+ return releasedIds;
+ }
+
+ private InstanceIdentifier<AvailableIdsHolder> buildAvailbaleIdsIdentifier(
+ String poolName) {
+ InstanceIdentifier<AvailableIdsHolder> availableIds = InstanceIdentifier
+ .builder(IdPools.class).child(IdPool.class,
+ new IdPoolKey(poolName)).child(AvailableIdsHolder.class).build();
+ return availableIds;
+ }
+
+ private InstanceIdentifier<ChildPools> buildChildPoolInstanceIdentifier(String poolName, String childPoolName) {
+ InstanceIdentifier<ChildPools> childPool = InstanceIdentifier
+ .builder(IdPools.class).child(IdPool.class,
+ new IdPoolKey(poolName)).child(ChildPools.class, new ChildPoolsKey(childPoolName)).build();
+ return childPool;
+ }
+
+ private ReleaseIdInput createReleaseIdInput(String poolName, String idKey) {
+ return new ReleaseIdInputBuilder().setIdKey(idKey).setPoolName(poolName).build();
}
- private CreateIdPoolInput buildCreateIdPool(String poolName, long idStart, long poolSize) {
+ private IdEntries buildIdEntry(String idKey, long idValue) {
+ return new IdEntriesBuilder().setIdKey(idKey).setIdValue(idValue).build();
+ }
+
+ private InstanceIdentifier<IdEntries> buildIdEntriesIdentifier(String idKey) {
+ InstanceIdentifier.InstanceIdentifierBuilder<IdEntries> idEntriesBuilder = childIdentifier
+ .builder().child(IdEntries.class, new IdEntriesKey(idKey));
+ InstanceIdentifier<IdEntries> idEntry = idEntriesBuilder.build();
+ return idEntry;
+ }
+
+ private CreateIdPoolInput buildCreateIdPool(String poolName, long low, long high) {
CreateIdPoolInput createPool = new CreateIdPoolInputBuilder().setPoolName(poolName)
- .setIdStart(idStart)
- .setPoolSize(BigInteger.valueOf(poolSize))
+ .setLow(low)
+ .setHigh(high)
.build();
return createPool;
}
- private IdPool buildIdPool(String poolName, long idStart, long poolSize) {
- IdPool idPool = new IdPoolBuilder().setPoolName(poolName)
- .setIdStart(idStart)
- .setPoolSize(BigInteger.valueOf(poolSize))
- .build();
- return idPool;
+ private IdPoolBuilder buildGlobalIdPool(String poolName, long idStart, long poolSize, int blockSize, List<ChildPools> childPools) {
+ AvailableIdsHolder availableIdsHolder = createAvailableIdsHolder(idStart, poolSize, idStart - 1);
+ ReleasedIdsHolder releasedIdsHolder = createReleasedIdsHolder(0, null, 0);
+ return new IdPoolBuilder().setKey(new IdPoolKey(poolName))
+ .setPoolName(poolName)
+ .setBlockSize(blockSize)
+ .setChildPools(childPools)
+ .setAvailableIdsHolder(availableIdsHolder)
+ .setReleasedIdsHolder(releasedIdsHolder);
}
- private GetUniqueIdInput buildUniqueId(String poolName, String idKey) {
- GetUniqueIdInput getIdInput = new GetUniqueIdInputBuilder().setPoolName(poolName)
+ private IdPoolBuilder buildLocalIdPool(int blockSize, String localPoolName, String parentPoolName) {
+ ReleasedIdsHolder releasedIdsHolder = createReleasedIdsHolder(0, null, (long) 30);
+ return new IdPoolBuilder().setBlockSize(blockSize)
+ .setKey(new IdPoolKey(localPoolName))
+ .setParentPoolName(parentPoolName)
+ .setReleasedIdsHolder(releasedIdsHolder);
+ }
+
+ private AllocateIdInput buildAllocateId(String poolName, String idKey) {
+ AllocateIdInput getIdInput = new AllocateIdInputBuilder().setPoolName(poolName)
.setIdKey(idKey).build();
return getIdInput;
}
- private InstanceIdentifier<IdPool> buildInstanceIdentifier(String poolName){
+ private InstanceIdentifier<IdPool> buildInstanceIdentifier(String poolName) {
InstanceIdentifier.InstanceIdentifierBuilder<IdPool> idBuilder =
- InstanceIdentifier.builder(Pools.class).child(IdPool.class, new IdPoolKey(poolName));
+ InstanceIdentifier.builder(IdPools.class).child(IdPool.class, new IdPoolKey(poolName));
InstanceIdentifier<IdPool> id = idBuilder.build();
return id;
}
-}
+ private AvailableIdsHolder createAvailableIdsHolder(long low, long high, long cursor) {
+ AvailableIdsHolder availableIdsHolder = new AvailableIdsHolderBuilder()
+ .setStart(low).setEnd(high).setCursor(cursor).build();
+ return availableIdsHolder;
+ }
+
+ private ReleasedIdsHolder createReleasedIdsHolder(long availableIdCount, List<DelayedIdEntries> delayedIdEntries, long delayTime) {
+ ReleasedIdsHolder releasedIdsHolder = new ReleasedIdsHolderBuilder()
+ .setAvailableIdCount(availableIdCount)
+ .setDelayedIdEntries(delayedIdEntries)
+ .setDelayedTimeSec(delayTime).build();
+ return releasedIdsHolder;
+ }
+
+ private DeleteIdPoolInput createDeleteIdPoolInput(String poolName) {
+ return new DeleteIdPoolInputBuilder().setPoolName(poolName).build();
+ }
+
+ private List<DelayedIdEntries> buildDelayedIdEntries(long[] idValues) {
+ List<DelayedIdEntries> delayedIdEntriesList = new ArrayList<DelayedIdEntries>();
+ for (long idValue : idValues) {
+ DelayedIdEntries delayedIdEntries = new DelayedIdEntriesBuilder().setId(idValue).setReadyTimeSec(0L).build();
+ delayedIdEntriesList.add(delayedIdEntries);
+ }
+ return delayedIdEntriesList;
+ }
+
+ private List<ChildPools> buildChildPool(String childPoolName) {
+ ChildPools childPools = new ChildPoolsBuilder().setChildPoolName(childPoolName).build();
+ List<ChildPools> childPoolsList = new ArrayList<ChildPools>();
+ childPoolsList.add(childPools);
+ return childPoolsList;
+ }
+}
\ No newline at end of file
Code Review / vpnservice.git / blobdiff