2 * Copyright (c) 2016 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.genius.idmanager;
11 import com.google.common.net.InetAddresses;
12 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.DelayedIdEntry;
13 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.IdPools;
14 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.id.pools.IdPool;
15 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.id.pools.IdPoolBuilder;
16 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.id.pools.IdPoolKey;
17 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.id.pools.id.pool.*;
18 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.released.ids.DelayedIdEntries;
19 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.released.ids.DelayedIdEntriesBuilder;
20 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.lockmanager.rev160413.*;
21 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
22 import org.opendaylight.yangtools.yang.common.RpcResult;
23 import org.slf4j.Logger;
24 import org.slf4j.LoggerFactory;
26 import java.net.InetAddress;
27 import java.util.LinkedList;
28 import java.util.List;
29 import java.util.concurrent.ExecutionException;
30 import java.util.concurrent.Future;
34 private static final Logger LOGGER = LoggerFactory.getLogger(IdUtils.class);
35 private static final long DEFAULT_DELAY_TIME = 30;
36 private static final long DEFAULT_AVAILABLE_ID_COUNT = 0;
37 private static final int DEFAULT_BLOCK_SIZE_DIFF = 50;
39 private static int BLADE_ID;
42 BLADE_ID = InetAddresses.coerceToInteger(InetAddress.getLocalHost());
43 } catch (Exception e) {
44 LOGGER.error("IdManager - Exception - {}", e.getMessage());
48 protected static InstanceIdentifier<IdEntries> getIdEntry(InstanceIdentifier<IdPool> poolName, String idKey) {
49 InstanceIdentifier.InstanceIdentifierBuilder<IdEntries> idEntriesBuilder = poolName
50 .builder().child(IdEntries.class, new IdEntriesKey(idKey));
51 InstanceIdentifier<IdEntries> idEntry = idEntriesBuilder.build();
55 protected static IdEntries createIdEntries(String idKey, long newIdVal) {
56 return new IdEntriesBuilder().setKey(new IdEntriesKey(idKey))
57 .setIdKey(idKey).setIdValue(newIdVal).build();
60 protected static DelayedIdEntries createDelayedIdEntry(long idValue, long delayTime) {
61 return new DelayedIdEntriesBuilder()
63 .setReadyTimeSec(delayTime).build();
66 protected static IdPool createGlobalPool(String poolName, long low, long high, long blockSize) {
67 AvailableIdsHolder availableIdsHolder = createAvailableIdsHolder(low, high, low - 1);
68 ReleasedIdsHolder releasedIdsHolder = createReleasedIdsHolder(DEFAULT_AVAILABLE_ID_COUNT, 0);
69 int size = (int) blockSize;
70 return new IdPoolBuilder().setKey(new IdPoolKey(poolName))
71 .setBlockSize(size).setPoolName(poolName)
72 .setAvailableIdsHolder(availableIdsHolder)
73 .setReleasedIdsHolder(releasedIdsHolder).build();
76 protected static AvailableIdsHolder createAvailableIdsHolder(long low, long high, long cursor) {
77 AvailableIdsHolder availableIdsHolder = new AvailableIdsHolderBuilder()
78 .setStart(low).setEnd(high).setCursor(cursor).build();
79 return availableIdsHolder;
82 protected static ReleasedIdsHolder createReleasedIdsHolder(long availableIdCount, long delayTime) {
83 ReleasedIdsHolder releasedIdsHolder = new ReleasedIdsHolderBuilder()
84 .setAvailableIdCount(availableIdCount)
85 .setDelayedTimeSec(delayTime).build();
86 return releasedIdsHolder;
89 protected static InstanceIdentifier<IdPool> getIdPoolInstance(String poolName) {
90 InstanceIdentifier.InstanceIdentifierBuilder<IdPool> idPoolBuilder = InstanceIdentifier
91 .builder(IdPools.class).child(IdPool.class,
92 new IdPoolKey(poolName));
93 InstanceIdentifier<IdPool> id = idPoolBuilder.build();
97 protected static InstanceIdentifier<ReleasedIdsHolder> getReleasedIdsHolderInstance(String poolName) {
98 InstanceIdentifier.InstanceIdentifierBuilder<ReleasedIdsHolder> releasedIdsHolder = InstanceIdentifier
99 .builder(IdPools.class).child(IdPool.class,
100 new IdPoolKey(poolName)).child(ReleasedIdsHolder.class);
101 InstanceIdentifier<ReleasedIdsHolder> releasedIds = releasedIdsHolder.build();
106 * Changes made to releasedIds are not persisted in the datastore.
110 protected static long getIdFromReleaseIdsIfAvailable(ReleasedIdsHolderBuilder releasedIds) {
111 List<DelayedIdEntries> delayedIdEntries = releasedIds.getDelayedIdEntries();
112 long newIdValue = -1;
113 if (delayedIdEntries != null && !delayedIdEntries.isEmpty()) {
114 processDelayList(releasedIds);
115 if (releasedIds.getAvailableIdCount() > 0) {
116 DelayedIdEntries delayedIdEntry= delayedIdEntries.get(0);
117 newIdValue = delayedIdEntry.getId();
118 delayedIdEntries.remove(delayedIdEntry);
119 releasedIds.setDelayedIdEntries(delayedIdEntries);
120 releasedIds.setAvailableIdCount(releasedIds.getAvailableIdCount() - 1);
127 * Changes made to availableIds are not persisted to datastore.
128 * @param availableIds
131 protected static long getIdFromAvailableIds(AvailableIdsHolderBuilder availableIds) {
132 long newIdValue = -1;
133 if (availableIds != null && isIdAvailable(availableIds)) {
134 newIdValue = availableIds.getCursor() + 1;
135 availableIds.setCursor(newIdValue);
140 protected static boolean isIdAvailable(AvailableIdsHolderBuilder availableIds) {
141 if (availableIds.getCursor() != null && availableIds.getEnd() != null)
142 return availableIds.getCursor() < availableIds.getEnd();
146 protected static String getLocalPoolName(String poolName) {
147 return (poolName + "." + BLADE_ID);
150 protected static IdPool createLocalIdPool(String localPoolName, IdPool parentIdPool) {
151 ReleasedIdsHolder releasedIdsHolder = createReleasedIdsHolder(DEFAULT_AVAILABLE_ID_COUNT, DEFAULT_DELAY_TIME);
152 return new IdPoolBuilder().setKey(new IdPoolKey(localPoolName))
153 .setPoolName(localPoolName)
154 .setParentPoolName(parentIdPool.getPoolName())
155 .setBlockSize(parentIdPool.getBlockSize())
156 .setReleasedIdsHolder(releasedIdsHolder).build();
159 protected static ChildPools createChildPool(String childPoolName) {
160 return new ChildPoolsBuilder().setKey(new ChildPoolsKey(childPoolName)).setChildPoolName(childPoolName).setLastAccessTime(System.currentTimeMillis() / 1000).build();
163 protected static AvailableIdsHolderBuilder getAvailableIdsHolderBuilder(IdPool pool) {
164 AvailableIdsHolder availableIds = pool.getAvailableIdsHolder();
165 if (availableIds != null )
166 return new AvailableIdsHolderBuilder(availableIds);
167 return new AvailableIdsHolderBuilder();
170 protected static ReleasedIdsHolderBuilder getReleaseIdsHolderBuilder(IdPool pool) {
171 ReleasedIdsHolder releasedIds = pool.getReleasedIdsHolder();
172 if (releasedIds != null)
173 return new ReleasedIdsHolderBuilder(releasedIds);
174 return new ReleasedIdsHolderBuilder();
178 * Changes made to releaseIds are not persisted to the Datastore. Method invoking should ensure that releaseIds gets persisted.
181 protected static void processDelayList(ReleasedIdsHolderBuilder releasedIds) {
182 List<DelayedIdEntries> delayedIdEntries = releasedIds.getDelayedIdEntries();
183 if (delayedIdEntries == null)
185 long availableIdCount = releasedIds.getAvailableIdCount() == null ? 0 : releasedIds.getAvailableIdCount();
186 int index = (int) availableIdCount;
187 long currentTimeSec = System.currentTimeMillis() / 1000;
188 DelayedIdEntry delayedIdEntry;
189 while (index < delayedIdEntries.size()) {
190 delayedIdEntry = delayedIdEntries.get(index);
191 if (delayedIdEntry.getReadyTimeSec() > currentTimeSec) {
197 releasedIds.setAvailableIdCount(availableIdCount);
201 * Changes made to the parameters passed are not persisted to the Datastore. Method invoking should ensure that these gets persisted.
202 * @param releasedIdsChild
203 * @param releasedIdsParent
204 * @param idCountToBeFreed
206 protected static void freeExcessAvailableIds(ReleasedIdsHolderBuilder releasedIdsChild, ReleasedIdsHolderBuilder releasedIdsParent, int idCountToBeFreed) {
207 List<DelayedIdEntries> existingDelayedIdEntriesInParent = releasedIdsParent.getDelayedIdEntries();
208 List<DelayedIdEntries> delayedIdEntriesChild = releasedIdsChild.getDelayedIdEntries();
209 long availableIdCountParent = releasedIdsParent.getAvailableIdCount();
210 long availableIdCountChild = releasedIdsChild.getAvailableIdCount();
211 if (existingDelayedIdEntriesInParent == null) {
212 existingDelayedIdEntriesInParent = new LinkedList<>();
214 idCountToBeFreed = Math.min(idCountToBeFreed, delayedIdEntriesChild.size());
215 for (int index = 0; index < idCountToBeFreed; index++) {
216 existingDelayedIdEntriesInParent.add(delayedIdEntriesChild.get(0));
217 delayedIdEntriesChild.remove(0);
219 releasedIdsChild.setDelayedIdEntries(delayedIdEntriesChild).setAvailableIdCount(availableIdCountChild - idCountToBeFreed);
220 releasedIdsParent.setDelayedIdEntries(existingDelayedIdEntriesInParent).setAvailableIdCount(availableIdCountParent + idCountToBeFreed);
223 protected static InstanceIdentifier<IdEntries> getIdEntriesInstanceIdentifier(String poolName, String idKey) {
224 InstanceIdentifier<IdEntries> idEntries = InstanceIdentifier
225 .builder(IdPools.class).child(IdPool.class,
226 new IdPoolKey(poolName)).child(IdEntries.class, new IdEntriesKey(idKey)).build();
230 protected static InstanceIdentifier<ChildPools> getChildPoolsInstanceIdentifier(String poolName, String localPoolName) {
231 InstanceIdentifier<ChildPools> childPools = InstanceIdentifier
232 .builder(IdPools.class)
233 .child(IdPool.class, new IdPoolKey(poolName))
234 .child(ChildPools.class, new ChildPoolsKey(localPoolName)).build();
238 protected static long computeBlockSize(long low, long high) {
241 long diff = high - low;
242 if (diff > DEFAULT_BLOCK_SIZE_DIFF) {
243 blockSize = diff / DEFAULT_BLOCK_SIZE_DIFF;
250 public static long getAvailableIdsCount(AvailableIdsHolderBuilder availableIds) {
251 if(availableIds != null && isIdAvailable(availableIds)) {
252 return availableIds.getEnd() - availableIds.getCursor();
257 public static void lockPool(LockManagerService lockManager, String poolName) {
258 LockInput input = new LockInputBuilder().setLockName(poolName).build();
259 Future<RpcResult<Void>> result = lockManager.lock(input);
261 if ((result != null) && (result.get().isSuccessful())) {
262 LOGGER.debug("Acquired lock {}", poolName);
264 throw new RuntimeException(String.format("Unable to getLock for pool %s", poolName));
266 } catch (InterruptedException | ExecutionException e) {
267 LOGGER.error("Unable to getLock for pool {}", poolName);
268 throw new RuntimeException(String.format("Unable to getLock for pool %s", poolName), e.getCause());
272 public static void unlockPool(LockManagerService lockManager, String poolName) {
273 UnlockInput input = new UnlockInputBuilder().setLockName(poolName).build();
274 Future<RpcResult<Void>> result = lockManager.unlock(input);
276 if ((result != null) && (result.get().isSuccessful())) {
277 LOGGER.debug("Unlocked {}", poolName);
279 LOGGER.debug("Unable to unlock pool {}", poolName);
281 } catch (InterruptedException | ExecutionException e) {
282 LOGGER.error("Unable to unlock for pool {}", poolName);
283 throw new RuntimeException(String.format("Unable to unlock pool %s", poolName), e.getCause());