1 package org.opendaylight.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.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;
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;
74 hostName = InetAddress.getLocalHost().getHostName();
75 BLADE_ID = InetAddresses.coerceToInteger(InetAddress.getLocalHost());
76 if (hostName.indexOf("-") > 0) {
77 BLADE_ID = new Integer(hostName.split("-")[1].toString()).intValue();
79 LOG.error("Host name {} is not matching with the condition!! PL-X is expected", hostName);
81 } catch (Exception e) {
82 LOG.error("IdManager - Exception - {}", e.getMessage());
86 Map<InstanceIdentifier<?>,DataObject> configDataStore = new HashMap<>();
87 @Mock DataBroker dataBroker;
88 @Mock ReadOnlyTransaction mockReadTx;
89 @Mock WriteTransaction mockWriteTx;
90 @Mock LockManagerService lockManager;
91 Future<RpcResult<Void>> rpcResult;
94 InstanceIdentifier<IdPool> identifier;
95 InstanceIdentifier<IdPool> childIdentifier;
96 InstanceIdentifier<ChildPools> childPoolIdentifier;
97 String globalPoolName = "test-pool";
98 String localPoolName = new StringBuilder(globalPoolName).append(".").append(BLADE_ID).toString();
99 String idKey = "test-key1";
103 String idKey2 = "test-key2";
107 public void setUp() throws Exception {
109 idManager = new IdManager(dataBroker);
110 idManager.setLockManager(lockManager);
114 private void setupMocks() {
115 globalIdPool = buildGlobalIdPool(globalPoolName, idStart, idEnd, blockSize, buildChildPool(localPoolName)).build();
116 identifier = buildInstanceIdentifier(globalPoolName);
117 childIdentifier = buildInstanceIdentifier(localPoolName);
118 childPoolIdentifier = buildChildPoolInstanceIdentifier(globalPoolName, localPoolName);
119 when(dataBroker.newReadOnlyTransaction()).thenReturn(mockReadTx);
120 when(dataBroker.newWriteOnlyTransaction()).thenReturn(mockWriteTx);
121 when(lockManager.lock(any(LockInput.class))).thenReturn(Futures.immediateFuture(RpcResultBuilder.<Void>success().build()));
122 when(lockManager.unlock(any(UnlockInput.class))).thenReturn(Futures.immediateFuture(RpcResultBuilder.<Void>success().build()));
123 doReturn(Futures.immediateCheckedFuture(null)).when(mockWriteTx).submit();
124 doReturn(Futures.immediateCheckedFuture(null)).when(mockReadTx).read(eq(LogicalDatastoreType.OPERATIONAL), any(InstanceIdentifier.class));
128 public void testCreateIdPool() throws Exception
130 CreateIdPoolInput createPoolTest = buildCreateIdPool(globalPoolName, idStart, idEnd);
131 doReturn(Futures.immediateCheckedFuture(Optional.absent())).when(mockReadTx).read(
132 LogicalDatastoreType.CONFIGURATION, identifier);
133 doReturn(Futures.immediateCheckedFuture(Optional.absent())).when(mockReadTx).read(
134 LogicalDatastoreType.CONFIGURATION, childIdentifier);
135 Future<RpcResult<Void>> result = idManager.createIdPool(createPoolTest);
136 DataObject dataObject;
138 assertTrue(result.get().isSuccessful());
139 assertEquals(0,configDataStore.size());
140 dataObject = configDataStore.get(childIdentifier);
141 if (dataObject instanceof IdPool) {
142 pool = (IdPool) dataObject;
143 assertEquals(localPoolName, pool.getPoolName());
144 assertEquals(createPoolTest.getPoolName(), pool.getParentPoolName());
145 assertEquals(null, pool.getAvailableIdsHolder());
146 assertEquals(30, pool.getReleasedIdsHolder().getDelayedTimeSec().longValue());
147 assertEquals(0, pool.getReleasedIdsHolder().getAvailableIdCount().longValue());
148 assertEquals(blockSize, pool.getBlockSize().longValue());
150 dataObject = configDataStore.get(identifier);
151 if (dataObject instanceof IdPool) {
152 pool = (IdPool) dataObject;
153 assertEquals(createPoolTest.getPoolName(), pool.getPoolName());
154 assertEquals(0, pool.getReleasedIdsHolder().getDelayedTimeSec().longValue());
155 assertEquals(0, pool.getReleasedIdsHolder().getAvailableIdCount().longValue());
156 assertEquals(createPoolTest.getLow(), pool.getAvailableIdsHolder().getStart());
157 assertEquals(createPoolTest.getHigh(), pool.getAvailableIdsHolder().getEnd());
158 assertEquals(createPoolTest.getLow() - 1, pool.getAvailableIdsHolder().getCursor().intValue());
159 assertEquals(blockSize, pool.getBlockSize().longValue());
161 dataObject = configDataStore.get(childPoolIdentifier);
162 if (dataObject instanceof ChildPools) {
163 ChildPools childPool = (ChildPools) dataObject;
164 assertEquals(localPoolName, childPool.getChildPoolName());
169 public void testAllocateId() throws Exception
171 AllocateIdInput allocateIdInput = buildAllocateId(globalPoolName, idKey);
172 Optional<IdPool> expected = Optional.of(globalIdPool);
173 List<IdEntries> idEntries = new ArrayList<IdEntries>();
174 idEntries.add(buildIdEntry(idKey2, idValue));
175 Optional<IdPool> expectedLocalPool = Optional.of(buildLocalIdPool(blockSize, localPoolName, globalPoolName).setIdEntries(idEntries).build());
176 doReturn(Futures.immediateCheckedFuture(expected)).when(mockReadTx).read(
177 LogicalDatastoreType.CONFIGURATION, identifier);
178 doReturn(Futures.immediateCheckedFuture(expectedLocalPool)).when(mockReadTx).read(
179 LogicalDatastoreType.CONFIGURATION, childIdentifier);
180 InstanceIdentifier<IdEntries> idEntriesIdentifier = buildIdEntriesIdentifier(idKey);
181 doReturn(Futures.immediateCheckedFuture(Optional.absent())).when(mockReadTx).read(
182 LogicalDatastoreType.CONFIGURATION, idEntriesIdentifier);
183 InstanceIdentifier<AvailableIdsHolder> availableIdsIdentifier = buildAvailbaleIdsIdentifier(globalPoolName);
185 Future<RpcResult<AllocateIdOutput>> result = idManager.allocateId(allocateIdInput);
186 assertTrue(result.get().isSuccessful());
187 assertEquals(0,configDataStore.size());
188 DataObject dataObject = configDataStore.get(childIdentifier);
189 if (dataObject instanceof IdPool) {
190 IdPool pool = (IdPool) dataObject;
191 assertEquals(localPoolName, pool.getPoolName());
192 assertEquals(idStart, pool.getAvailableIdsHolder().getStart().intValue());
193 assertEquals(idStart + blockSize - 1 , pool.getAvailableIdsHolder().getEnd().intValue());
194 assertEquals(idStart, pool.getAvailableIdsHolder().getCursor().intValue());
195 assertEquals(2, pool.getIdEntries().size());
197 dataObject = configDataStore.get(availableIdsIdentifier);
198 if (dataObject instanceof AvailableIdsHolder) {
199 AvailableIdsHolder availableIds = (AvailableIdsHolder) dataObject;
200 assertEquals(idEnd, availableIds.getEnd().intValue());
201 assertEquals(idStart, availableIds.getStart().intValue());
202 assertEquals(idStart + blockSize - 1, availableIds.getCursor().intValue());
207 public void testReleaseId() throws Exception {
208 ReleaseIdInput releaseIdInput = createReleaseIdInput(globalPoolName, idKey);
209 List<IdEntries> idEntries = new ArrayList<IdEntries>();
210 idEntries.add(buildIdEntry(idKey, idValue));
211 Optional<IdPool> expectedLocalPool = Optional.of(buildLocalIdPool(blockSize, localPoolName, globalPoolName).setIdEntries(idEntries).build());
212 doReturn(Futures.immediateCheckedFuture(expectedLocalPool)).when(mockReadTx).read(
213 LogicalDatastoreType.CONFIGURATION, childIdentifier);
214 InstanceIdentifier<IdEntries> idEntriesIdentifier = buildIdEntriesIdentifier(idKey);
215 Optional<IdEntries> expectedIdEntry = Optional.of(buildIdEntry(idKey, idValue));
216 doReturn(Futures.immediateCheckedFuture(expectedIdEntry)).when(mockReadTx).read(
217 LogicalDatastoreType.CONFIGURATION, idEntriesIdentifier);
218 Future<RpcResult<Void>> result = idManager.releaseId(releaseIdInput);
219 assertTrue(result.get().isSuccessful());
220 assertEquals(0, configDataStore.size());
221 DataObject idPoolVal = configDataStore.get(childIdentifier);
222 if (idPoolVal instanceof IdPool) {
223 IdPool pool = (IdPool) idPoolVal;
224 assertEquals(0, pool.getIdEntries().size());
225 assertEquals(0, pool.getReleasedIdsHolder().getAvailableIdCount().intValue());
226 assertEquals(idValue, pool.getReleasedIdsHolder().getDelayedIdEntries().get(0).getId().intValue());
231 public void testCleanupReleasedIds() throws Exception {
232 AllocateIdInput allocateIdInput = buildAllocateId(globalPoolName, idKey2);
233 Optional<ReleasedIdsHolder> expected = Optional.of(createReleasedIdsHolder(0, null, 0));
234 long[] excessIds = new long[] { 1, 2, 3, 4, 5 };
235 List<IdEntries> idEntries = new ArrayList<IdEntries>();
236 idEntries.add(buildIdEntry(idKey2, idValue));
237 ReleasedIdsHolder excessReleasedIds = createReleasedIdsHolder(0, buildDelayedIdEntries(excessIds), (long) 30);
238 Optional<IdPool> expectedLocalPool = Optional.of(buildLocalIdPool(blockSize, localPoolName, globalPoolName)
239 .setIdEntries(idEntries).setReleasedIdsHolder(excessReleasedIds)
241 InstanceIdentifier<ReleasedIdsHolder> releaseIdsIdentifier = buildReleaseIdsIdentifier(globalPoolName);
242 doReturn(Futures.immediateCheckedFuture(expected)).when(mockReadTx)
243 .read(LogicalDatastoreType.CONFIGURATION, releaseIdsIdentifier);
244 doReturn(Futures.immediateCheckedFuture(expectedLocalPool)).when(
245 mockReadTx).read(LogicalDatastoreType.CONFIGURATION,
247 InstanceIdentifier<IdEntries> idEntriesIdentifier = buildIdEntriesIdentifier(idKey2);
248 doReturn(Futures.immediateCheckedFuture(Optional.absent())).when(
249 mockReadTx).read(LogicalDatastoreType.CONFIGURATION,
250 idEntriesIdentifier);
252 Future<RpcResult<AllocateIdOutput>> result = idManager.allocateId(allocateIdInput);
253 assertTrue(result.get().isSuccessful());
254 assertEquals(0, configDataStore.size());
255 DataObject dataObject = configDataStore.get(childIdentifier);
256 if (dataObject instanceof IdPool) {
257 IdPool pool = (IdPool) dataObject;
258 assertEquals(localPoolName, pool.getPoolName());
259 assertEquals(excessIds.length - 3, pool.getReleasedIdsHolder().getAvailableIdCount().intValue());
260 assertEquals(2, pool.getIdEntries().size());
262 dataObject = configDataStore.get(releaseIdsIdentifier);
263 if (dataObject instanceof ReleasedIdsHolder) {
264 ReleasedIdsHolder releasedIds = (ReleasedIdsHolder) dataObject;
265 assertEquals(2, releasedIds.getAvailableIdCount().intValue());
266 assertEquals(2, releasedIds.getDelayedIdEntries().size());
271 public void testAllocateIdBlockFromReleasedIds() throws Exception {
272 AllocateIdInput allocateIdInput = buildAllocateId(globalPoolName, globalPoolName);
273 List<DelayedIdEntries> delayedIdEntries = buildDelayedIdEntries(new long[] {1, 2, 3});
274 ReleasedIdsHolder expectedReleasedIds = createReleasedIdsHolder(3, delayedIdEntries , 0);
275 IdPool globalIdPool = buildGlobalIdPool(globalPoolName, idStart, idEnd, blockSize, buildChildPool(localPoolName)).setReleasedIdsHolder(expectedReleasedIds).build();
276 Optional<IdPool> expected = Optional.of(globalIdPool);
277 Optional<IdPool> expectedLocalPool = Optional.of(buildLocalIdPool(blockSize, localPoolName, globalPoolName).build());
278 doReturn(Futures.immediateCheckedFuture(expected)).when(mockReadTx).read(
279 LogicalDatastoreType.CONFIGURATION, identifier);
280 doReturn(Futures.immediateCheckedFuture(expectedLocalPool)).when(mockReadTx).read(
281 LogicalDatastoreType.CONFIGURATION, childIdentifier);
282 InstanceIdentifier<IdEntries> idEntriesIdentifier = buildIdEntriesIdentifier(globalPoolName);
283 doReturn(Futures.immediateCheckedFuture(Optional.absent())).when(mockReadTx).read(
284 LogicalDatastoreType.CONFIGURATION, idEntriesIdentifier);
285 InstanceIdentifier<ReleasedIdsHolder> releaseIdsIdentifier = buildReleaseIdsIdentifier(globalPoolName);
287 Future<RpcResult<AllocateIdOutput>> result = idManager.allocateId(allocateIdInput);
288 assertTrue(result.get().isSuccessful());
289 assertEquals(0,configDataStore.size());
290 DataObject dataObject = configDataStore.get(childIdentifier);
291 if (dataObject instanceof IdPool) {
292 IdPool pool = (IdPool) dataObject;
293 assertEquals(localPoolName, pool.getPoolName());
294 assertEquals(1, pool.getReleasedIdsHolder().getDelayedIdEntries().size());
295 assertEquals(1, pool.getIdEntries().size());
296 assertEquals(1, pool.getReleasedIdsHolder().getAvailableIdCount().intValue());
298 dataObject = configDataStore.get(releaseIdsIdentifier);
299 if (dataObject instanceof ReleasedIdsHolder) {
300 ReleasedIdsHolder releasedIds = (ReleasedIdsHolder) dataObject;
301 assertEquals(1, releasedIds.getAvailableIdCount().intValue());
302 assertEquals(1, releasedIds.getDelayedIdEntries().size());
307 public void testDeletePool() throws Exception {
308 IdPool globalIdPool = buildGlobalIdPool(globalPoolName, idStart, idEnd, blockSize, buildChildPool(localPoolName)).build();
309 Optional<IdPool> expected = Optional.of(globalIdPool);
310 Optional<IdPool> expectedLocalPool = Optional.of(buildLocalIdPool(blockSize, localPoolName, globalPoolName).build());
311 doReturn(Futures.immediateCheckedFuture(expected)).when(mockReadTx).read(
312 LogicalDatastoreType.CONFIGURATION, identifier);
313 doReturn(Futures.immediateCheckedFuture(expectedLocalPool)).when(mockReadTx).read(
314 LogicalDatastoreType.CONFIGURATION, childIdentifier);
315 DeleteIdPoolInput deleteIdPoolInput = createDeleteIdPoolInput(globalPoolName);
316 configDataStore.put(childIdentifier, null);
317 configDataStore.put(identifier, null);
318 Future<RpcResult<Void>> result = idManager.deleteIdPool(deleteIdPoolInput);
319 assertTrue(result.get().isSuccessful());
320 assertEquals(2, configDataStore.size());
323 private InstanceIdentifier<ReleasedIdsHolder> buildReleaseIdsIdentifier(
325 InstanceIdentifier<ReleasedIdsHolder> releasedIds = InstanceIdentifier
326 .builder(IdPools.class).child(IdPool.class,
327 new IdPoolKey(poolName)).child(ReleasedIdsHolder.class).build();
331 private InstanceIdentifier<AvailableIdsHolder> buildAvailbaleIdsIdentifier(
333 InstanceIdentifier<AvailableIdsHolder> availableIds = InstanceIdentifier
334 .builder(IdPools.class).child(IdPool.class,
335 new IdPoolKey(poolName)).child(AvailableIdsHolder.class).build();
339 private InstanceIdentifier<ChildPools> buildChildPoolInstanceIdentifier(String poolName, String childPoolName) {
340 InstanceIdentifier<ChildPools> childPool = InstanceIdentifier
341 .builder(IdPools.class).child(IdPool.class,
342 new IdPoolKey(poolName)).child(ChildPools.class, new ChildPoolsKey(childPoolName)).build();
346 private ReleaseIdInput createReleaseIdInput(String poolName, String idKey) {
347 return new ReleaseIdInputBuilder().setIdKey(idKey).setPoolName(poolName).build();
350 private IdEntries buildIdEntry(String idKey, long idValue) {
351 return new IdEntriesBuilder().setIdKey(idKey).setIdValue(idValue).build();
354 private InstanceIdentifier<IdEntries> buildIdEntriesIdentifier(String idKey) {
355 InstanceIdentifier.InstanceIdentifierBuilder<IdEntries> idEntriesBuilder = childIdentifier
356 .builder().child(IdEntries.class, new IdEntriesKey(idKey));
357 InstanceIdentifier<IdEntries> idEntry = idEntriesBuilder.build();
361 private CreateIdPoolInput buildCreateIdPool(String poolName, long low, long high) {
362 CreateIdPoolInput createPool = new CreateIdPoolInputBuilder().setPoolName(poolName)
369 private IdPoolBuilder buildGlobalIdPool(String poolName, long idStart, long poolSize, int blockSize, List<ChildPools> childPools) {
370 AvailableIdsHolder availableIdsHolder = createAvailableIdsHolder(idStart, poolSize, idStart - 1);
371 ReleasedIdsHolder releasedIdsHolder = createReleasedIdsHolder(0, null, 0);
372 return new IdPoolBuilder().setKey(new IdPoolKey(poolName))
373 .setPoolName(poolName)
374 .setBlockSize(blockSize)
375 .setChildPools(childPools)
376 .setAvailableIdsHolder(availableIdsHolder)
377 .setReleasedIdsHolder(releasedIdsHolder);
380 private IdPoolBuilder buildLocalIdPool(int blockSize, String localPoolName, String parentPoolName) {
381 ReleasedIdsHolder releasedIdsHolder = createReleasedIdsHolder(0, null, (long) 30);
382 return new IdPoolBuilder().setBlockSize(blockSize)
383 .setKey(new IdPoolKey(localPoolName))
384 .setParentPoolName(parentPoolName)
385 .setReleasedIdsHolder(releasedIdsHolder);
388 private AllocateIdInput buildAllocateId(String poolName, String idKey) {
389 AllocateIdInput getIdInput = new AllocateIdInputBuilder().setPoolName(poolName)
390 .setIdKey(idKey).build();
394 private InstanceIdentifier<IdPool> buildInstanceIdentifier(String poolName) {
395 InstanceIdentifier.InstanceIdentifierBuilder<IdPool> idBuilder =
396 InstanceIdentifier.builder(IdPools.class).child(IdPool.class, new IdPoolKey(poolName));
397 InstanceIdentifier<IdPool> id = idBuilder.build();
401 private AvailableIdsHolder createAvailableIdsHolder(long low, long high, long cursor) {
402 AvailableIdsHolder availableIdsHolder = new AvailableIdsHolderBuilder()
403 .setStart(low).setEnd(high).setCursor(cursor).build();
404 return availableIdsHolder;
407 private ReleasedIdsHolder createReleasedIdsHolder(long availableIdCount, List<DelayedIdEntries> delayedIdEntries, long delayTime) {
408 ReleasedIdsHolder releasedIdsHolder = new ReleasedIdsHolderBuilder()
409 .setAvailableIdCount(availableIdCount)
410 .setDelayedIdEntries(delayedIdEntries)
411 .setDelayedTimeSec(delayTime).build();
412 return releasedIdsHolder;
415 private DeleteIdPoolInput createDeleteIdPoolInput(String poolName) {
416 return new DeleteIdPoolInputBuilder().setPoolName(poolName).build();
419 private List<DelayedIdEntries> buildDelayedIdEntries(long[] idValues) {
420 List<DelayedIdEntries> delayedIdEntriesList = new ArrayList<DelayedIdEntries>();
421 for (long idValue : idValues) {
422 DelayedIdEntries delayedIdEntries = new DelayedIdEntriesBuilder().setId(idValue).setReadyTimeSec(0L).build();
423 delayedIdEntriesList.add(delayedIdEntries);
425 return delayedIdEntriesList;
428 private List<ChildPools> buildChildPool(String childPoolName) {
429 ChildPools childPools = new ChildPoolsBuilder().setChildPoolName(childPoolName).build();
430 List<ChildPools> childPoolsList = new ArrayList<ChildPools>();
431 childPoolsList.add(childPools);
432 return childPoolsList;