2 * Copyright (c) 2015 Ericsson India Global Services Pvt Ltd. and others. All rights reserved.
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
9 package org.opendaylight.idmanager.test;
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;
18 import java.net.InetAddress;
19 import java.util.ArrayList;
20 import java.util.HashMap;
21 import java.util.List;
23 import java.util.concurrent.Future;
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;
70 import com.google.common.base.Optional;
71 import com.google.common.net.InetAddresses;
72 import com.google.common.util.concurrent.Futures;
75 @RunWith(MockitoJUnitRunner.class)
76 public class IdManagerTest {
77 private static final Logger LOG = LoggerFactory.getLogger(IdManagerTest.class);
78 private static int BLADE_ID;
81 BLADE_ID = InetAddresses.coerceToInteger(InetAddress.getLocalHost());
82 } catch (Exception e) {
83 LOG.error("IdManager - Exception - {}", e.getMessage());
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;
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";
104 String idKey2 = "test-key2";
108 public void setUp() throws Exception {
110 idManager = new IdManager(dataBroker);
111 idManager.setLockManager(lockManager);
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));
129 public void testCreateIdPool() throws Exception
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;
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());
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());
162 dataObject = configDataStore.get(childPoolIdentifier);
163 if (dataObject instanceof ChildPools) {
164 ChildPools childPool = (ChildPools) dataObject;
165 assertEquals(localPoolName, childPool.getChildPoolName());
170 public void testAllocateId() throws Exception
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);
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());
198 dataObject = configDataStore.get(identifier);
199 if (dataObject instanceof IdPool) {
200 IdPool parentPool = (IdPool) dataObject;
201 assertEquals(2, parentPool.getIdEntries().size());
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());
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());
237 idPoolVal = configDataStore.get(identifier);
238 if (idPoolVal instanceof IdPool) {
239 IdPool parentPool = (IdPool) idPoolVal;
240 assertEquals(0, parentPool.getIdEntries().size());
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)
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,
265 InstanceIdentifier<IdEntries> idEntriesIdentifier = buildIdEntriesIdentifier(idKey2);
266 doReturn(Futures.immediateCheckedFuture(Optional.absent())).when(
267 mockReadTx).read(LogicalDatastoreType.CONFIGURATION,
268 idEntriesIdentifier);
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());
279 dataObject = configDataStore.get(identifier);
280 if (dataObject instanceof IdPool) {
281 IdPool parentPool = (IdPool) dataObject;
282 assertEquals(2, parentPool.getIdEntries().size());
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());
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);
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());
319 dataObject = configDataStore.get(identifier);
320 if (dataObject instanceof IdPool) {
321 IdPool parentPool = (IdPool) dataObject;
322 assertEquals(1, parentPool.getIdEntries().size());
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());
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());
349 private InstanceIdentifier<ReleasedIdsHolder> buildReleaseIdsIdentifier(
351 InstanceIdentifier<ReleasedIdsHolder> releasedIds = InstanceIdentifier
352 .builder(IdPools.class).child(IdPool.class,
353 new IdPoolKey(poolName)).child(ReleasedIdsHolder.class).build();
357 private InstanceIdentifier<AvailableIdsHolder> buildAvailbaleIdsIdentifier(
359 InstanceIdentifier<AvailableIdsHolder> availableIds = InstanceIdentifier
360 .builder(IdPools.class).child(IdPool.class,
361 new IdPoolKey(poolName)).child(AvailableIdsHolder.class).build();
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();
372 private ReleaseIdInput createReleaseIdInput(String poolName, String idKey) {
373 return new ReleaseIdInputBuilder().setIdKey(idKey).setPoolName(poolName).build();
376 private IdEntries buildIdEntry(String idKey, long idValue) {
377 return new IdEntriesBuilder().setIdKey(idKey).setIdValue(idValue).build();
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();
387 private CreateIdPoolInput buildCreateIdPool(String poolName, long low, long high) {
388 CreateIdPoolInput createPool = new CreateIdPoolInputBuilder().setPoolName(poolName)
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);
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);
414 private AllocateIdInput buildAllocateId(String poolName, String idKey) {
415 AllocateIdInput getIdInput = new AllocateIdInputBuilder().setPoolName(poolName)
416 .setIdKey(idKey).build();
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();
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;
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;
441 private DeleteIdPoolInput createDeleteIdPoolInput(String poolName) {
442 return new DeleteIdPoolInputBuilder().setPoolName(poolName).build();
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);
451 return delayedIdEntriesList;
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;