resource-assignment/provider/src/main/java/org/openecomp/sdnc/rm/comp/AllocationFunction.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * openECOMP : SDN-C
   4  * ================================================================================
   5  * Copyright (C) 2017 ONAP Intellectual Property. All rights
   6  *                                              reserved.
   7  * ================================================================================
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  *      http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  * ============LICENSE_END=========================================================
  20  */
  21
  22 package org.openecomp.sdnc.rm.comp;
  23
  24 import java.util.ArrayList;
  25 import java.util.Collection;
  26 import java.util.HashSet;
  27 import java.util.Iterator;
  28 import java.util.List;
  29 import java.util.Set;
  30 import java.util.SortedSet;
  31 import java.util.TreeSet;
  32
  33 import org.openecomp.sdnc.lock.comp.LockHelper;
  34 import org.openecomp.sdnc.lock.comp.ResourceLockedException;
  35 import org.openecomp.sdnc.lock.comp.SynchronizedFunction;
  36 import org.openecomp.sdnc.rm.dao.ResourceDao;
  37 import org.openecomp.sdnc.rm.data.AllocationOutcome;
  38 import org.openecomp.sdnc.rm.data.AllocationRequest;
  39 import org.openecomp.sdnc.rm.data.AllocationStatus;
  40 import org.openecomp.sdnc.rm.data.LabelAllocationOutcome;
  41 import org.openecomp.sdnc.rm.data.LabelAllocationRequest;
  42 import org.openecomp.sdnc.rm.data.LabelResource;
  43 import org.openecomp.sdnc.rm.data.LimitAllocationOutcome;
  44 import org.openecomp.sdnc.rm.data.LimitAllocationRequest;
  45 import org.openecomp.sdnc.rm.data.LimitResource;
  46 import org.openecomp.sdnc.rm.data.MultiAssetAllocationOutcome;
  47 import org.openecomp.sdnc.rm.data.MultiAssetAllocationRequest;
  48 import org.openecomp.sdnc.rm.data.MultiResourceAllocationOutcome;
  49 import org.openecomp.sdnc.rm.data.MultiResourceAllocationRequest;
  50 import org.openecomp.sdnc.rm.data.RangeAllocationOutcome;
  51 import org.openecomp.sdnc.rm.data.RangeAllocationRequest;
  52 import org.openecomp.sdnc.rm.data.RangeResource;
  53 import org.openecomp.sdnc.rm.data.Resource;
  54 import org.openecomp.sdnc.rm.data.ResourceKey;
  55 import org.openecomp.sdnc.rm.data.ResourceType;
  56 import org.openecomp.sdnc.rm.util.LabelUtil;
  57 import org.openecomp.sdnc.rm.util.LimitUtil;
  58 import org.openecomp.sdnc.rm.util.RangeUtil;
  59 import org.slf4j.Logger;
  60 import org.slf4j.LoggerFactory;
  61
  62 class AllocationFunction extends SynchronizedFunction {
  63
  64         @SuppressWarnings("unused")
  65         private static final Logger log = LoggerFactory.getLogger(AllocationFunction.class);
  66
  67         private ResourceDao resourceDao;
  68
  69         private String applicationId;
  70         private AllocationRequest request;
  71         private AllocationOutcome outcome;
  72
  73         private List<Resource> updateList = new ArrayList<Resource>();
  74
  75         public AllocationFunction(LockHelper lockHelper, ResourceDao resourceDao, String applicationId,
  76                 AllocationRequest request, int lockTimeout) {
  77                 super(lockHelper, getLockNames(request), lockTimeout);
  78                 this.applicationId = applicationId;
  79                 this.resourceDao = resourceDao;
  80                 this.request = request;
  81         }
  82
  83         private static Collection<String> getLockNames(AllocationRequest request) {
  84                 Set<String> lockResourceNames = new HashSet<String>();
  85                 addLockNames(lockResourceNames, request);
  86                 return lockResourceNames;
  87         }
  88
  89         private static void addLockNames(Set<String> lockResourceNames, AllocationRequest request) {
  90                 if (request instanceof MultiAssetAllocationRequest) {
  91                         MultiAssetAllocationRequest req = (MultiAssetAllocationRequest) request;
  92                         if (req.assetIdList != null)
  93                                 lockResourceNames.addAll(req.assetIdList);
  94                 } else if (request instanceof MultiResourceAllocationRequest) {
  95                         MultiResourceAllocationRequest req = (MultiResourceAllocationRequest) request;
  96                         if (req.allocationRequestList != null)
  97                                 for (AllocationRequest request1 : req.allocationRequestList)
  98                                         addLockNames(lockResourceNames, request1);
  99                 } else if (request.assetId != null)
 100                         lockResourceNames.add(request.assetId);
 101         }
 102
 103         @Override
 104         public void _exec() throws ResourceLockedException {
 105                 outcome = allocate(request);
 106                 if (outcome.status == AllocationStatus.Success)
 107                         for (Resource r : updateList)
 108                                 resourceDao.saveResource(r);
 109         }
 110
 111         private AllocationOutcome allocate(AllocationRequest allocationRequest) throws ResourceLockedException {
 112                 if (allocationRequest instanceof MultiAssetAllocationRequest)
 113                         return allocateMultiAsset((MultiAssetAllocationRequest) allocationRequest);
 114                 if (allocationRequest instanceof MultiResourceAllocationRequest)
 115                         return allocateMultiResource((MultiResourceAllocationRequest) allocationRequest);
 116                 if (allocationRequest instanceof LimitAllocationRequest)
 117                         return allocateLimit((LimitAllocationRequest) allocationRequest);
 118                 if (allocationRequest instanceof LabelAllocationRequest)
 119                         return allocateLabel((LabelAllocationRequest) allocationRequest);
 120                 if (allocationRequest instanceof RangeAllocationRequest)
 121                         return allocateRange((RangeAllocationRequest) allocationRequest);
 122                 return null;
 123         }
 124
 125         private MultiAssetAllocationOutcome allocateMultiAsset(MultiAssetAllocationRequest req) {
 126                 // TODO Auto-generated method stub
 127                 return null;
 128         }
 129
 130         private MultiResourceAllocationOutcome allocateMultiResource(MultiResourceAllocationRequest req) {
 131                 MultiResourceAllocationOutcome out = new MultiResourceAllocationOutcome();
 132                 out.request = req;
 133                 out.allocationOutcomeList = new ArrayList<AllocationOutcome>();
 134                 out.status = AllocationStatus.Success;
 135
 136                 if (req.allocationRequestList != null)
 137                         for (AllocationRequest req1 : req.allocationRequestList) {
 138                                 AllocationOutcome out1 = allocate(req1);
 139                                 out.allocationOutcomeList.add(out1);
 140                                 if (out1.status != AllocationStatus.Success)
 141                                         out.status = AllocationStatus.Failure;
 142                         }
 143
 144                 return out;
 145         }
 146
 147         private LimitAllocationOutcome allocateLimit(LimitAllocationRequest req) {
 148                 LimitAllocationOutcome out = new LimitAllocationOutcome();
 149                 out.request = req;
 150
 151                 Resource r = resourceDao.getResource(req.assetId, req.resourceName);
 152                 if (r == null) {
 153                         r = new LimitResource();
 154                         r.resourceKey = new ResourceKey();
 155                         r.resourceKey.assetId = req.assetId;
 156                         r.resourceKey.resourceName = req.resourceName;
 157                         r.resourceType = ResourceType.Limit;
 158                 } else {
 159                         if (r.resourceType != ResourceType.Limit) {
 160                                 out.status = AllocationStatus.ResourceNotFound;
 161                                 return out;
 162                         }
 163                         LimitUtil.recalculate((LimitResource) r);
 164                 }
 165
 166                 LimitResource l = (LimitResource) r;
 167                 if (LimitUtil.checkLimit(l, req)) {
 168                         out.status = AllocationStatus.Success;
 169                         if (req.allocateCount > 0) {
 170                                 out.allocatedCount = LimitUtil.allocateLimit(l, req, applicationId);
 171                                 updateList.add(l);
 172                         }
 173                 } else
 174                         out.status = AllocationStatus.Failure;
 175
 176                 out.used = l.used;
 177                 out.limit = req.checkLimit;
 178
 179                 return out;
 180         }
 181
 182         private LabelAllocationOutcome allocateLabel(LabelAllocationRequest req) {
 183                 LabelAllocationOutcome out = new LabelAllocationOutcome();
 184
 185                 out.request = req;
 186
 187                 Resource r = resourceDao.getResource(req.assetId, req.resourceName);
 188                 if (r == null) {
 189                         r = new LabelResource();
 190                         r.resourceKey = new ResourceKey();
 191                         r.resourceKey.assetId = req.assetId;
 192                         r.resourceKey.resourceName = req.resourceName;
 193                         r.resourceType = ResourceType.Label;
 194                 } else {
 195                         if (r.resourceType != ResourceType.Label) {
 196                                 out.status = AllocationStatus.ResourceNotFound;
 197                                 return out;
 198                         }
 199                         LabelUtil.recalculate((LabelResource) r);
 200                 }
 201
 202                 LabelResource l = (LabelResource) r;
 203                 if (LabelUtil.checkLabel(l, req)) {
 204                         out.status = AllocationStatus.Success;
 205                         out.currentLabel = l.label;
 206                         if (req.allocate) {
 207                                 out.allocatedLabel = LabelUtil.allocateLabel(l, req, applicationId);
 208                                 updateList.add(l);
 209                         }
 210                 } else
 211                         out.status = AllocationStatus.Failure;
 212
 213                 return out;
 214         }
 215
 216         private RangeAllocationOutcome allocateRange(RangeAllocationRequest req) {
 217                 RangeAllocationOutcome out = new RangeAllocationOutcome();
 218
 219                 out.request = req;
 220
 221                 Resource r = resourceDao.getResource(req.assetId, req.resourceName);
 222                 if (r == null) {
 223                         r = new RangeResource();
 224                         r.resourceKey = new ResourceKey();
 225                         r.resourceKey.assetId = req.assetId;
 226                         r.resourceKey.resourceName = req.resourceName;
 227                         r.resourceType = ResourceType.Range;
 228                 } else {
 229                         if (r.resourceType != ResourceType.Range) {
 230                                 out.status = AllocationStatus.ResourceNotFound;
 231                                 return out;
 232                         }
 233                         RangeUtil.recalculate((RangeResource) r);
 234                 }
 235
 236                 RangeResource rr = (RangeResource) r;
 237                 SortedSet<Integer> foundNumbers = null;
 238                 if (!req.check) {
 239                         out.status = AllocationStatus.Success;
 240                         foundNumbers = req.requestedNumbers;
 241                 } else {
 242                         if (req.requestedNumbers != null && req.requestedNumbers.size() > 0) {
 243                                 foundNumbers = req.requestedNumbers;
 244                                 out.status = AllocationStatus.Success;
 245                                 for (int n : foundNumbers)
 246                                         if (!RangeUtil.checkRange(rr, req, n)) {
 247                                                 out.status = AllocationStatus.Failure;
 248                                                 break;
 249                                         }
 250                         } else {
 251                                 foundNumbers = new TreeSet<Integer>();
 252                                 int foundCount = 0;
 253
 254                                 // First try to reuse the numbers already taken by the same resource union
 255                                 SortedSet<Integer> uu = RangeUtil.getUsed(rr, req.resourceUnionId);
 256                                 if (uu != null && !uu.isEmpty()) {
 257                                         if (uu.size() >= req.requestedCount) {
 258                                                 // Just take the first req.requestedCount numbers from uu
 259                                                 Iterator<Integer> i = uu.iterator();
 260                                                 while (foundCount < req.requestedCount) {
 261                                                         foundNumbers.add(i.next());
 262                                                         foundCount++;
 263                                                 }
 264                                         } else {
 265                                                 // Additional numbers are requested. Try to find them starting from
 266                                                 // the minimum we have in uu (the first element) towards the min
 267                                                 // parameter, and then starting from the maximum in uu (the last
 268                                                 // element) towards the max parameter.
 269                                                 // NOTE: In case of request for sequential numbers, the parameters
 270                                                 // alignBlockSize and alignModulus are ignored. It would be harder
 271                                                 // to take them into account, and currently it is not needed.
 272
 273                                                 int uumin = uu.first() - 1;
 274                                                 int uumax = uu.last() + 1;
 275                                                 foundNumbers.addAll(uu);
 276                                                 foundCount = uu.size();
 277                                                 for (int n = uumin; foundCount < req.requestedCount && n >= req.checkMin; n--) {
 278                                                         if (RangeUtil.checkRange(rr, req, n)) {
 279                                                                 foundNumbers.add(n);
 280                                                                 foundCount++;
 281                                                         } else if (req.sequential)
 282                                                                 break;
 283                                                 }
 284                                                 for (int n = uumax; foundCount < req.requestedCount && n <= req.checkMax; n++) {
 285                                                         if (RangeUtil.checkRange(rr, req, n)) {
 286                                                                 foundNumbers.add(n);
 287                                                                 foundCount++;
 288                                                         } else if (req.sequential)
 289                                                                 break;
 290                                                 }
 291
 292                                                 // If we could not find enough numbers trying to reuse currently
 293                                                 // allocated, reset foundNumbers and foundCount, continue with
 294                                                 // the normal allocation of new numbers.
 295                                                 if (foundCount < req.requestedCount) {
 296                                                         foundNumbers = new TreeSet<Integer>();
 297                                                         foundCount = 0;
 298                                                 }
 299                                         }
 300                                 }
 301
 302                                 for (int n = req.checkMin; foundCount < req.requestedCount && n <= req.checkMax; n++)
 303                                         if (RangeUtil.checkRange(rr, req, n)) {
 304                                                 foundNumbers.add(n);
 305                                                 foundCount++;
 306                                         } else if (req.sequential)
 307                                                 foundCount = 0;
 308
 309                                 out.status = foundCount == req.requestedCount ? AllocationStatus.Success : AllocationStatus.Failure;
 310                         }
 311                 }
 312
 313                 if (out.status == AllocationStatus.Success) {
 314                         out.allocated = foundNumbers;
 315                         if (req.allocate) {
 316                                 RangeUtil.allocateRange(rr, out.allocated, req, applicationId);
 317                                 updateList.add(rr);
 318                         }
 319                 } else
 320                         out.allocated = new TreeSet<Integer>();
 321
 322                 out.used = rr.used;
 323
 324                 return out;
 325         }
 326
 327         public AllocationOutcome getAllocationOutcome() {
 328                 return outcome;
 329         }
 330 }