1 package org.opendaylight.genius.idmanager.test;
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;
10 import java.net.InetAddress;
11 import java.util.ArrayList;
12 import java.util.HashMap;
13 import java.util.List;
15 import java.util.concurrent.Future;
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.genius.idmanager.IdManager;
27 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.AllocateIdInput;
28 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.AllocateIdInputBuilder;
29 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.AllocateIdOutput;
30 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.CreateIdPoolInput;
31 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.CreateIdPoolInputBuilder;
32 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.DeleteIdPoolInput;
33 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.DeleteIdPoolInputBuilder;
34 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.IdPools;
35 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.ReleaseIdInput;
36 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.ReleaseIdInputBuilder;
37 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.id.pools.IdPool;
38 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.id.pools.IdPoolBuilder;
39 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.id.pools.IdPoolKey;
40 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.id.pools.id.pool.AvailableIdsHolder;
41 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.id.pools.id.pool.AvailableIdsHolderBuilder;
42 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.id.pools.id.pool.ChildPools;
43 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.id.pools.id.pool.ChildPoolsBuilder;
44 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.id.pools.id.pool.ChildPoolsKey;
45 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.id.pools.id.pool.IdEntries;
46 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.id.pools.id.pool.IdEntriesBuilder;
47 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.id.pools.id.pool.IdEntriesKey;
48 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.id.pools.id.pool.ReleasedIdsHolder;
49 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.id.pools.id.pool.ReleasedIdsHolderBuilder;
50 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.released.ids.DelayedIdEntries;
51 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.released.ids.DelayedIdEntriesBuilder;
52 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.lockmanager.rev160413.LockInput;
53 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.lockmanager.rev160413.LockManagerService;
54 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.lockmanager.rev160413.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;
62 import com.google.common.base.Optional;
63 import com.google.common.net.InetAddresses;
64 import com.google.common.util.concurrent.Futures;
67 @RunWith(MockitoJUnitRunner.class)
68 public class IdManagerTest {
69 private static final Logger LOG = LoggerFactory.getLogger(IdManagerTest.class);
70 private static int BLADE_ID;
73 BLADE_ID = InetAddresses.coerceToInteger(InetAddress.getLocalHost());
74 } catch (Exception e) {
75 LOG.error("IdManager - Exception - {}", e.getMessage());
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;
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";
96 String idKey2 = "test-key2";
100 public void setUp() throws Exception {
102 idManager = new IdManager(dataBroker);
103 idManager.setLockManager(lockManager);
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));
121 public void testCreateIdPool() throws Exception
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;
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());
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());
154 dataObject = configDataStore.get(childPoolIdentifier);
155 if (dataObject instanceof ChildPools) {
156 ChildPools childPool = (ChildPools) dataObject;
157 assertEquals(localPoolName, childPool.getChildPoolName());
162 public void testAllocateId() throws Exception
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);
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());
190 dataObject = configDataStore.get(identifier);
191 if (dataObject instanceof IdPool) {
192 IdPool parentPool = (IdPool) dataObject;
193 assertEquals(2, parentPool.getIdEntries().size());
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());
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());
229 idPoolVal = configDataStore.get(identifier);
230 if (idPoolVal instanceof IdPool) {
231 IdPool parentPool = (IdPool) idPoolVal;
232 assertEquals(0, parentPool.getIdEntries().size());
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)
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,
257 InstanceIdentifier<IdEntries> idEntriesIdentifier = buildIdEntriesIdentifier(idKey2);
258 doReturn(Futures.immediateCheckedFuture(Optional.absent())).when(
259 mockReadTx).read(LogicalDatastoreType.CONFIGURATION,
260 idEntriesIdentifier);
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());
271 dataObject = configDataStore.get(identifier);
272 if (dataObject instanceof IdPool) {
273 IdPool parentPool = (IdPool) dataObject;
274 assertEquals(2, parentPool.getIdEntries().size());
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());
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);
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());
311 dataObject = configDataStore.get(identifier);
312 if (dataObject instanceof IdPool) {
313 IdPool parentPool = (IdPool) dataObject;
314 assertEquals(1, parentPool.getIdEntries().size());
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());
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());
341 private InstanceIdentifier<ReleasedIdsHolder> buildReleaseIdsIdentifier(
343 InstanceIdentifier<ReleasedIdsHolder> releasedIds = InstanceIdentifier
344 .builder(IdPools.class).child(IdPool.class,
345 new IdPoolKey(poolName)).child(ReleasedIdsHolder.class).build();
349 private InstanceIdentifier<AvailableIdsHolder> buildAvailbaleIdsIdentifier(
351 InstanceIdentifier<AvailableIdsHolder> availableIds = InstanceIdentifier
352 .builder(IdPools.class).child(IdPool.class,
353 new IdPoolKey(poolName)).child(AvailableIdsHolder.class).build();
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();
364 private ReleaseIdInput createReleaseIdInput(String poolName, String idKey) {
365 return new ReleaseIdInputBuilder().setIdKey(idKey).setPoolName(poolName).build();
368 private IdEntries buildIdEntry(String idKey, long idValue) {
369 return new IdEntriesBuilder().setIdKey(idKey).setIdValue(idValue).build();
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();
379 private CreateIdPoolInput buildCreateIdPool(String poolName, long low, long high) {
380 CreateIdPoolInput createPool = new CreateIdPoolInputBuilder().setPoolName(poolName)
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);
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);
406 private AllocateIdInput buildAllocateId(String poolName, String idKey) {
407 AllocateIdInput getIdInput = new AllocateIdInputBuilder().setPoolName(poolName)
408 .setIdKey(idKey).build();
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();
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;
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;
433 private DeleteIdPoolInput createDeleteIdPoolInput(String poolName) {
434 return new DeleteIdPoolInputBuilder().setPoolName(poolName).build();
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);
443 return delayedIdEntriesList;
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;