resource-assignment/provider/src/main/java/org/openecomp/sdnc/ra/ResourceAllocator.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.ra;
  23
  24 import java.util.ArrayList;
  25 import java.util.Collections;
  26 import java.util.Comparator;
  27 import java.util.HashMap;
  28 import java.util.List;
  29 import java.util.Map;
  30
  31 import org.onap.ccsdk.sli.core.sli.SvcLogicContext;
  32 import org.onap.ccsdk.sli.core.sli.SvcLogicException;
  33 import org.onap.ccsdk.sli.core.sli.SvcLogicResource;
  34 import org.onap.ccsdk.sli.core.sli.SvcLogicResource.QueryStatus;
  35 import org.openecomp.sdnc.ra.comp.EndPointAllocator;
  36 import org.openecomp.sdnc.ra.comp.EndPointData;
  37 import org.openecomp.sdnc.ra.comp.ServiceData;
  38 import org.openecomp.sdnc.ra.equip.dao.ServerDao;
  39 import org.openecomp.sdnc.ra.equip.dao.VpePortDao;
  40 import org.openecomp.sdnc.ra.equip.dao.VplspePortDao;
  41 import org.openecomp.sdnc.ra.equip.data.EquipmentData;
  42 import org.openecomp.sdnc.ra.equip.data.EquipmentLevel;
  43 import org.openecomp.sdnc.ra.rule.comp.AllocationRequestBuilder;
  44 import org.openecomp.sdnc.ra.rule.dao.MaxPortSpeedDao;
  45 import org.openecomp.sdnc.ra.rule.dao.MaxServerSpeedDao;
  46 import org.openecomp.sdnc.ra.rule.dao.ParameterDao;
  47 import org.openecomp.sdnc.ra.rule.data.ThresholdStatus;
  48 import org.openecomp.sdnc.ra.service.dao.ServiceResourceDao;
  49 import org.openecomp.sdnc.ra.service.data.ServiceResource;
  50 import org.openecomp.sdnc.ra.service.data.ServiceStatus;
  51 import org.openecomp.sdnc.rm.comp.ResourceManager;
  52 import org.openecomp.sdnc.rm.data.AllocationAction;
  53 import org.openecomp.sdnc.rm.data.AllocationItem;
  54 import org.openecomp.sdnc.rm.data.AllocationOutcome;
  55 import org.openecomp.sdnc.rm.data.AllocationRequest;
  56 import org.openecomp.sdnc.rm.data.AllocationStatus;
  57 import org.openecomp.sdnc.rm.data.LimitAllocationOutcome;
  58 import org.openecomp.sdnc.rm.data.LimitAllocationRequest;
  59 import org.openecomp.sdnc.rm.data.LimitResource;
  60 import org.openecomp.sdnc.rm.data.MultiResourceAllocationOutcome;
  61 import org.openecomp.sdnc.rm.data.RangeAllocationItem;
  62 import org.openecomp.sdnc.rm.data.RangeResource;
  63 import org.openecomp.sdnc.rm.data.Resource;
  64 import org.openecomp.sdnc.util.speed.SpeedUtil;
  65 import org.openecomp.sdnc.util.str.StrUtil;
  66 import org.slf4j.Logger;
  67 import org.slf4j.LoggerFactory;
  68
  69 public class ResourceAllocator implements SvcLogicResource {
  70
  71         private static final Logger log = LoggerFactory.getLogger(ResourceAllocator.class);
  72
  73         public ResourceAllocator() {
  74                 log.info("ResourceAllocator created.");
  75         }
  76
  77         private ServerDao serverDao;
  78         private VpePortDao vpePortDao;
  79         private VplspePortDao vplspePortDao;
  80         private MaxPortSpeedDao maxPortSpeedDao;
  81         private MaxServerSpeedDao maxServerSpeedDao;
  82         private ServiceResourceDao serviceResourceDao;
  83         private ParameterDao parameterDao;
  84
  85         private AllocationRequestBuilder allocationRequestBuilder;
  86         private ResourceManager resourceManager;
  87         private SpeedUtil speedUtil;
  88
  89         private EndPointAllocator endPointAllocator;
  90
  91         @Override
  92         public QueryStatus notify(String resource, String action, String key, SvcLogicContext ctx)
  93                 throws SvcLogicException {
  94                 return (QueryStatus.SUCCESS);
  95         }
  96
  97         @Override
  98         public QueryStatus update(
  99                 String resource,
 100                 String key,
 101                 Map<String, String> parms,
 102                 String prefix,
 103                 SvcLogicContext ctx) throws SvcLogicException {
 104
 105                 return QueryStatus.SUCCESS;
 106         }
 107
 108         @Override
 109         public QueryStatus exists(String resource, String key, String prefix, SvcLogicContext ctx)
 110                 throws SvcLogicException {
 111                 return QueryStatus.SUCCESS;
 112         }
 113
 114         @Override
 115         public QueryStatus delete(String arg0, String arg1, SvcLogicContext arg2) throws SvcLogicException {
 116                 return QueryStatus.SUCCESS;
 117         }
 118
 119         @Override
 120         public QueryStatus save(
 121                 String arg0,
 122                 boolean arg1,
 123                 boolean arg2,
 124                 String arg3,
 125                 Map<String, String> arg4,
 126                 String arg5,
 127                 SvcLogicContext arg6) throws SvcLogicException {
 128                 return QueryStatus.SUCCESS;
 129         }
 130
 131         @Override
 132         public QueryStatus isAvailable(String resource, String key, String prefix, SvcLogicContext ctx)
 133                 throws SvcLogicException {
 134                 String serviceModel = ctx.getAttribute("tmp.resource-allocator.service-model");
 135                 if (serviceModel != null && serviceModel.trim().length() > 0)
 136                         return allocateResources(serviceModel, ctx, true, prefix);
 137                 return allocateResourcesL3SDN(ctx, true, prefix);
 138         }
 139
 140         @Override
 141         public QueryStatus query(
 142                 String resource,
 143                 boolean localOnly,
 144                 String select,
 145                 String key,
 146                 String prefix,
 147                 String orderBy,
 148                 SvcLogicContext ctx) throws SvcLogicException {
 149
 150                 prefix = prefix == null ? "" : prefix + '.';
 151
 152                 if (!resource.equals("NetworkCapacity")) {
 153                         log.info("resource: " + resource);
 154                         log.info("key: " + key);
 155
 156                         Resource r = resourceManager.getResource(resource, key);
 157                         if (r == null)
 158                                 return QueryStatus.NOT_FOUND;
 159
 160                         if (r instanceof LimitResource) {
 161                                 ctx.setAttribute(prefix + "used", String.valueOf(((LimitResource) r).used));
 162
 163                                 log.info("Added context attr: " + prefix + "used: " + String.valueOf(((LimitResource) r).used));
 164                         }
 165
 166                         return QueryStatus.SUCCESS;
 167                 }
 168
 169                 log.info("key: " + key);
 170                 log.info("prefix: " + prefix);
 171
 172                 if (key == null)
 173                         return QueryStatus.SUCCESS;
 174
 175                 if (key.startsWith("'") && key.endsWith("'"))
 176                         key = key.substring(1, key.length() - 1);
 177
 178                 String endPointPosition = "VPE-Cust";
 179
 180                 String resourceUnionId = key + '/' + endPointPosition;
 181                 List<Resource> rlist = resourceManager.getResourceUnion(resourceUnionId);
 182
 183                 log.info("Resources found for " + resourceUnionId + ": " + rlist.size());
 184
 185                 String assetId = null;
 186                 for (Resource r : rlist) {
 187                         log.info("Resource: " + r.resourceKey.resourceName);
 188
 189                         if (r instanceof RangeResource) {
 190                                 RangeResource rr = (RangeResource) r;
 191                                 for (AllocationItem ai : r.allocationItems)
 192                                         if (ai.resourceUnionId.equals(resourceUnionId)) {
 193                                                 RangeAllocationItem rai = (RangeAllocationItem) ai;
 194                                                 ctx.setAttribute(prefix + r.resourceKey.resourceName, String.valueOf(rai.used.first()));
 195
 196                                                 log.info("Added context attr: " + prefix + r.resourceKey.resourceName + ": " +
 197                                                         String.valueOf(rr.used.first()));
 198
 199                                                 assetId = r.resourceKey.assetId;
 200                                                 String vpeName = assetId;
 201                                                 int i1 = assetId.indexOf('/');
 202                                                 if (i1 > 0)
 203                                                         vpeName = assetId.substring(0, i1);
 204                                                 ctx.setAttribute(prefix + "vpe-name", vpeName);
 205
 206                                                 log.info("Added context attr: " + prefix + "vpe-name: " + vpeName);
 207                                         }
 208                         }
 209                 }
 210
 211                 String affinityLink = "1";
 212                 if (assetId != null) {
 213                         for (Resource r : rlist) {
 214                                 if (r instanceof LimitResource) {
 215                                         LimitResource ll = (LimitResource) r;
 216                                         if (ll.resourceKey.assetId.startsWith(assetId + '-')) {
 217                                                 int i1 = ll.resourceKey.assetId.lastIndexOf('-');
 218                                                 affinityLink = ll.resourceKey.assetId.substring(i1 + 1);
 219                                                 break;
 220                                         }
 221                                 }
 222                         }
 223                 }
 224
 225                 ctx.setAttribute(prefix + "affinity-link", affinityLink);
 226
 227                 log.info("Added context attr: " + prefix + "affinity-link: " + affinityLink);
 228
 229                 return QueryStatus.SUCCESS;
 230         }
 231
 232         @Override
 233         public QueryStatus reserve(String resource, String select, String key, String prefix, SvcLogicContext ctx)
 234                 throws SvcLogicException {
 235                 String serviceModel = ctx.getAttribute("tmp.resource-allocator.service-model");
 236                 if (serviceModel != null && serviceModel.trim().length() > 0)
 237                         return allocateResources(serviceModel, ctx, false, prefix);
 238                 return allocateResourcesL3SDN(ctx, false, prefix);
 239         }
 240
 241         @Override
 242         public QueryStatus release(String resource, String key, SvcLogicContext ctx) throws SvcLogicException {
 243                 String serviceInstanceId = ctx.getAttribute("tmp.resource-allocator.service-instance-id");
 244                 if (serviceInstanceId == null)
 245                         throw new SvcLogicException("tmp.resource-allocator.service-instance-id is required in ResourceAllocator");
 246
 247                 String requestTypeStr = ctx.getAttribute("tmp.resource-allocator.request-type");
 248                 if (requestTypeStr == null)
 249                         throw new SvcLogicException("tmp.resource-allocator.request-type is required in ResourceAllocator");
 250
 251                 ReleaseRequestType requestType = null;
 252                 try {
 253                         requestType = ReleaseRequestType.convert(requestTypeStr);
 254                 } catch (IllegalArgumentException e) {
 255                         throw new SvcLogicException("Invalid tmp.resource-allocator.request-type: " + requestTypeStr +
 256                                 ". Supported values are Cancel, Activate, Disconnect.");
 257                 }
 258
 259                 log.info("Starting release: " + requestType + " for: " + serviceInstanceId);
 260
 261                 ServiceResource activeServiceResource =
 262                         serviceResourceDao.getServiceResource(serviceInstanceId, ServiceStatus.Active);
 263                 ServiceResource pendingServiceResource =
 264                         serviceResourceDao.getServiceResource(serviceInstanceId, ServiceStatus.Pending);
 265
 266                 log.info("Active ServiceResource: ");
 267                 StrUtil.info(log, activeServiceResource);
 268                 log.info("Pending ServiceResource: ");
 269                 StrUtil.info(log, pendingServiceResource);
 270
 271                 if (requestType == ReleaseRequestType.Cancel) {
 272                         if (pendingServiceResource != null) {
 273                                 log.info("Releasing pending resources: " + pendingServiceResource.resourceSetId);
 274
 275                                 resourceManager.releaseResourceSet(pendingServiceResource.resourceSetId);
 276                                 serviceResourceDao.deleteServiceResource(serviceInstanceId, ServiceStatus.Pending);
 277                         } else {
 278                                 log.info("Pending record not found for service instance: " + serviceInstanceId + ". Nothing to do.");
 279                         }
 280
 281                 } else if (requestType == ReleaseRequestType.Activate) {
 282                         if (pendingServiceResource != null) {
 283                                 if (activeServiceResource != null) {
 284                                         log.info("Releasing active resources: " + activeServiceResource.resourceSetId);
 285
 286                                         resourceManager.releaseResourceSet(activeServiceResource.resourceSetId);
 287                                         serviceResourceDao.deleteServiceResource(serviceInstanceId, ServiceStatus.Active);
 288                                 }
 289
 290                                 log.info("Updating the status of the pending record to active.");
 291
 292                                 serviceResourceDao.updateServiceStatus(serviceInstanceId, ServiceStatus.Pending, ServiceStatus.Active);
 293                         } else {
 294                                 log.info("Pending record not found for service instance: " + serviceInstanceId + ". Nothing to do.");
 295                         }
 296
 297                 } else if (requestType == ReleaseRequestType.Disconnect) {
 298                         if (pendingServiceResource != null) {
 299                                 log.info("Releasing pending resources: " + pendingServiceResource.resourceSetId);
 300
 301                                 resourceManager.releaseResourceSet(pendingServiceResource.resourceSetId);
 302                                 serviceResourceDao.deleteServiceResource(serviceInstanceId, ServiceStatus.Pending);
 303                         }
 304                         if (activeServiceResource != null) {
 305                                 log.info("Releasing active resources: " + activeServiceResource.resourceSetId);
 306
 307                                 resourceManager.releaseResourceSet(activeServiceResource.resourceSetId);
 308                                 serviceResourceDao.deleteServiceResource(serviceInstanceId, ServiceStatus.Active);
 309                         }
 310                 }
 311
 312                 return QueryStatus.SUCCESS;
 313         }
 314
 315         private QueryStatus allocateResourcesL3SDN(SvcLogicContext ctx, boolean checkOnly, String prefix)
 316                 throws SvcLogicException {
 317                 prefix = prefix == null ? "" : prefix + '.';
 318
 319                 String aicSiteId = getAicSiteId(ctx);
 320                 Map<String, Object> service = getServiceData(ctx);
 321
 322                 String requestTypeStr = ctx.getAttribute("tmp.resource-allocator.request-type");
 323                 if (requestTypeStr == null)
 324                         requestTypeStr = "New";
 325
 326                 ReserveRequestType requestType = null;
 327                 try {
 328                         requestType = ReserveRequestType.convert(requestTypeStr);
 329                 } catch (IllegalArgumentException e) {
 330                         throw new SvcLogicException("Invalid tmp.resource-allocator.request-type: " + requestTypeStr +
 331                                 ". Supported values are New, Change.");
 332                 }
 333
 334                 String serviceInstanceId = String.valueOf(service.get("service-instance-id"));
 335
 336                 ServiceResource activeServiceResource =
 337                         serviceResourceDao.getServiceResource(serviceInstanceId, ServiceStatus.Active);
 338                 ServiceResource pendingServiceResource =
 339                         serviceResourceDao.getServiceResource(serviceInstanceId, ServiceStatus.Pending);
 340
 341                 log.info("Active ServiceResource: ");
 342                 StrUtil.info(log, activeServiceResource);
 343                 log.info("Pending ServiceResource: ");
 344                 StrUtil.info(log, pendingServiceResource);
 345
 346                 ServiceResource sr = new ServiceResource();
 347                 sr.serviceInstanceId = serviceInstanceId;
 348                 sr.serviceStatus = ServiceStatus.Pending;
 349                 sr.serviceChangeNumber = 1;
 350                 if (pendingServiceResource != null)
 351                         sr.serviceChangeNumber = pendingServiceResource.serviceChangeNumber + 1;
 352                 else if (activeServiceResource != null)
 353                         sr.serviceChangeNumber = activeServiceResource.serviceChangeNumber + 1;
 354                 sr.resourceSetId = serviceInstanceId + "/" + sr.serviceChangeNumber;
 355                 sr.resourceUnionId = serviceInstanceId;
 356
 357                 log.info("New ServiceResource: ");
 358                 StrUtil.info(log, sr);
 359
 360                 List<Map<String, Object>> vpePortData = vpePortDao.getVpePortData(aicSiteId);
 361                 List<Map<String, Object>> vplspePortData = vplspePortDao.getVplspePortData(aicSiteId);
 362                 List<Map<String, Object>> serverData = serverDao.getServerData(aicSiteId);
 363
 364                 vpePortData = orderVpe(vpePortData);
 365
 366                 long maxAvailableSpeedVpePort = 0;
 367                 boolean vpePortFound = false;
 368
 369                 for (Map<String, Object> vpe : vpePortData) {
 370                         String vpeId = String.valueOf(vpe.get("vpe-id"));
 371                         String interfaceName = String.valueOf(vpe.get("physical-interface-name"));
 372                         String portId = vpeId + "/" + interfaceName;
 373
 374                         log.info("Checking VPE port: " + portId);
 375
 376                         String provStatus = String.valueOf(vpe.get("provisioning-status"));
 377                         if (!provStatus.equals("PROV")) {
 378                                 log.info("Skipping port " + portId + ": Provisioning status is not PROV.");
 379                                 continue;
 380                         }
 381
 382                         String imageFile = String.valueOf(vpe.get("image-file-name"));
 383                         String endPointPosition = "VPE-Cust";
 384                         long maxPortSpeed = maxPortSpeedDao.getMaxPortSpeed(imageFile, endPointPosition, interfaceName);
 385                         vpe.put("max-port-speed", maxPortSpeed);
 386
 387                         EquipmentData ed = new EquipmentData();
 388                         ed.data = vpe;
 389                         ed.equipmentId = portId;
 390                         ed.equipmentLevel = EquipmentLevel.Port;
 391
 392                         ServiceData sd = new ServiceData();
 393                         sd.data = service;
 394                         sd.serviceModel = "L3SDN";
 395                         sd.endPointPosition = endPointPosition;
 396                         sd.resourceUnionId = sr.resourceUnionId;
 397                         sd.resourceSetId = sr.resourceSetId;
 398
 399                         StrUtil.info(log, ed);
 400                         StrUtil.info(log, sd);
 401
 402                         AllocationRequest ar = allocationRequestBuilder.buildAllocationRequest(sd, ed, checkOnly,
 403                                 requestType == ReserveRequestType.Change);
 404                         AllocationOutcome ao = resourceManager.allocateResources(ar);
 405
 406                         if (ao.status == AllocationStatus.Success) {
 407
 408                                 // Assign affinity link
 409                                 if (!checkOnly) {
 410                                         List<String> affinityLinkIdList = new ArrayList<>();
 411                                         affinityLinkIdList.add("0");
 412                                         affinityLinkIdList.add("1");
 413                                         affinityLinkIdList.add("2");
 414                                         affinityLinkIdList.add("3");
 415
 416                                         String preferedAffinityLinkId = "0";
 417                                         long lowestAssignedBw = Long.MAX_VALUE;
 418                                         for (String affinityLinkId : affinityLinkIdList) {
 419                                                 long used = 0;
 420                                                 String assetId = ed.equipmentId + "-" + affinityLinkId;
 421                                                 Resource r = resourceManager.getResource("Bandwidth", assetId);
 422                                                 if (r != null) {
 423                                                         LimitResource ll = (LimitResource) r;
 424                                                         used = ll.used;
 425                                                 }
 426                                                 if (used < lowestAssignedBw) {
 427                                                         lowestAssignedBw = used;
 428                                                         preferedAffinityLinkId = affinityLinkId;
 429                                                 }
 430                                                 log.info("Assigned bandwidth on affinity link: " + assetId + ": " + used);
 431                                         }
 432
 433                                         log.info("Prefered affinity link for " + ed.equipmentId + ": " + preferedAffinityLinkId);
 434
 435                                         ctx.setAttribute(prefix + "affinity-link", preferedAffinityLinkId);
 436
 437                                         LimitAllocationRequest ar1 = new LimitAllocationRequest();
 438                                         ar1.resourceSetId = sd.resourceSetId;
 439                                         ar1.resourceUnionId = sd.resourceUnionId;
 440                                         ar1.resourceShareGroupList = null;
 441                                         ar1.resourceName = "Bandwidth";
 442                                         ar1.assetId = ed.equipmentId + "-" + preferedAffinityLinkId;
 443                                         ar1.missingResourceAction = AllocationAction.Succeed_Allocate;
 444                                         ar1.expiredResourceAction = AllocationAction.Succeed_Allocate;
 445                                         ar1.replace = true;
 446                                         ar1.strict = false;
 447                                         ar1.checkLimit = Long.MAX_VALUE;
 448                                         ar1.checkCount = 0;
 449                                         ar1.allocateCount = (Long) sd.data.get("service-speed-kbps");
 450
 451                                         resourceManager.allocateResources(ar1);
 452                                 }
 453
 454                                 ctx.setAttribute(prefix + "vpe-name", vpeId);
 455
 456                                 vpePortFound = true;
 457                                 break;
 458                         }
 459
 460                         if (ao instanceof LimitAllocationOutcome) {
 461                                 LimitAllocationOutcome lao = (LimitAllocationOutcome) ao;
 462                                 long available = lao.limit - lao.used;
 463                                 if (available > maxAvailableSpeedVpePort)
 464                                         maxAvailableSpeedVpePort = available;
 465                         }
 466                 }
 467
 468                 long maxAvailableSpeedVplspePort = 0;
 469                 boolean vplspePortFound = false;
 470
 471                 for (Map<String, Object> vplspe : vplspePortData) {
 472                         String vplspeId = String.valueOf(vplspe.get("vplspe-id"));
 473                         String interfaceName = String.valueOf(vplspe.get("physical-interface-name"));
 474                         String portId = vplspeId + "/" + interfaceName;
 475
 476                         log.info("Checking VPLSPE port: " + portId);
 477
 478                         String provStatus = String.valueOf(vplspe.get("provisioning-status"));
 479                         if (!provStatus.equals("PROV")) {
 480                                 log.info("Skipping port " + portId + ": Provisioning status is not PROV.");
 481                                 continue;
 482                         }
 483
 484                         long physicalSpeed = (Long) vplspe.get("physical-interface-speed");
 485                         String physicalSpeedUnit = String.valueOf(vplspe.get("physical-interface-speed-unit"));
 486                         long maxPortSpeed = speedUtil.convertToKbps(physicalSpeed, physicalSpeedUnit);
 487                         vplspe.put("max-port-speed", maxPortSpeed);
 488
 489                         EquipmentData ed = new EquipmentData();
 490                         ed.data = vplspe;
 491                         ed.equipmentId = portId;
 492                         ed.equipmentLevel = EquipmentLevel.Port;
 493
 494                         ServiceData sd = new ServiceData();
 495                         sd.data = service;
 496                         sd.serviceModel = "L3SDN";
 497                         sd.endPointPosition = "IPAG-TOA";
 498                         sd.resourceUnionId = sr.resourceUnionId;
 499                         sd.resourceSetId = sr.resourceSetId;
 500
 501                         StrUtil.info(log, ed);
 502                         StrUtil.info(log, sd);
 503
 504                         AllocationRequest ar = allocationRequestBuilder.buildAllocationRequest(sd, ed, checkOnly,
 505                                 requestType == ReserveRequestType.Change);
 506                         AllocationOutcome ao = resourceManager.allocateResources(ar);
 507
 508                         if (ao.status == AllocationStatus.Success) {
 509                                 vplspePortFound = true;
 510                                 break;
 511                         }
 512
 513                         if (ao instanceof LimitAllocationOutcome) {
 514                                 LimitAllocationOutcome lao = (LimitAllocationOutcome) ao;
 515                                 long available = lao.limit - lao.used;
 516                                 if (available > maxAvailableSpeedVplspePort)
 517                                         maxAvailableSpeedVplspePort = available;
 518                         }
 519                 }
 520
 521                 long maxAvailableSpeedServer = 0;
 522                 boolean serverFound = false;
 523
 524                 for (Map<String, Object> server : serverData) {
 525                         String serverId = String.valueOf(server.get("server-id"));
 526                         String serverModel = String.valueOf(server.get("server-model"));
 527
 528                         log.info("Checking Server: " + serverId);
 529
 530                         String endPointPosition = "VCE-Cust";
 531
 532                         int serverCount = (Integer) server.get("server-count");
 533                         if (serverCount == 0)
 534                                 serverCount = 1;
 535                         String ratioString = parameterDao.getParameter("homing.pserver.sparing.ratio");
 536                         if (ratioString == null || ratioString.length() == 0)
 537                                 ratioString = "1:1";
 538                         int primaryServerCount = calculatePrimaryServerCount(serverCount, ratioString);
 539                         server.put("number-primary-servers", primaryServerCount);
 540
 541                         int evcCount = getEvcCountOnServer(serverId);
 542                         int evcCountPerServer = (evcCount + primaryServerCount - 1) / primaryServerCount;
 543                         long maxServerSpeed = maxServerSpeedDao.getMaxServerSpeed(serverModel, evcCountPerServer);
 544                         server.put("max-server-speed", maxServerSpeed);
 545                         server.put("evc-count", evcCount);
 546                         server.put("evc-count-per-server", evcCountPerServer);
 547
 548                         EquipmentData ed = new EquipmentData();
 549                         ed.data = server;
 550                         ed.equipmentId = serverId;
 551                         ed.equipmentLevel = EquipmentLevel.Server;
 552
 553                         ServiceData sd = new ServiceData();
 554                         sd.data = service;
 555                         sd.serviceModel = "L3SDN";
 556                         sd.endPointPosition = endPointPosition;
 557                         sd.resourceUnionId = sr.resourceUnionId;
 558                         sd.resourceSetId = sr.resourceSetId;
 559
 560                         StrUtil.info(log, ed);
 561                         StrUtil.info(log, sd);
 562
 563                         AllocationRequest ar = allocationRequestBuilder.buildAllocationRequest(sd, ed, checkOnly,
 564                                 requestType == ReserveRequestType.Change);
 565                         AllocationOutcome ao = resourceManager.allocateResources(ar);
 566
 567                         if (ao.status == AllocationStatus.Success) {
 568                                 serverFound = true;
 569
 570                                 if (ao instanceof MultiResourceAllocationOutcome) {
 571                                         MultiResourceAllocationOutcome mrao = (MultiResourceAllocationOutcome) ao;
 572                                         for (AllocationOutcome ao1 : mrao.allocationOutcomeList) {
 573                                                 if (ao1 instanceof LimitAllocationOutcome) {
 574                                                         LimitAllocationOutcome lao = (LimitAllocationOutcome) ao1;
 575                                                         if (lao.request.resourceName.equals("Bandwidth")) {
 576                                                                 ThresholdStatus th = allocationRequestBuilder.getThresholdStatus(sd, ed, lao);
 577                                                                 setThresholdData(ctx, th, sd, ed);
 578                                                         }
 579                                                 }
 580                                         }
 581                                 }
 582
 583                                 break;
 584                         }
 585
 586                         if (ao instanceof MultiResourceAllocationOutcome) {
 587                                 MultiResourceAllocationOutcome mrao = (MultiResourceAllocationOutcome) ao;
 588                                 for (AllocationOutcome ao1 : mrao.allocationOutcomeList) {
 589                                         if (ao1 instanceof LimitAllocationOutcome) {
 590                                                 LimitAllocationOutcome lao = (LimitAllocationOutcome) ao1;
 591                                                 if (lao.status == AllocationStatus.Failure && lao.request.resourceName.equals("Bandwidth")) {
 592                                                         long available = lao.limit - lao.used;
 593                                                         if (available > maxAvailableSpeedServer)
 594                                                                 maxAvailableSpeedServer = available;
 595                                                 }
 596                                                 if (lao.status == AllocationStatus.Failure && lao.request.resourceName.equals("Connection")) {
 597                                                         maxAvailableSpeedServer = 0;
 598                                                         break;
 599                                                 }
 600
 601                                                 ThresholdStatus th = allocationRequestBuilder.getThresholdStatus(sd, ed, lao);
 602                                                 setThresholdData(ctx, th, sd, ed);
 603                                         }
 604                                 }
 605                         }
 606                 }
 607
 608                 if (vpePortFound && vplspePortFound && serverFound) {
 609                         if (!checkOnly) {
 610                                 if (pendingServiceResource == null) {
 611                                         log.info("Adding the pending service resource record to DB.");
 612                                         serviceResourceDao.addServiceResource(sr);
 613                                 } else {
 614                                         log.info("Releasing previously allocated resources for resource set id: " +
 615                                                 pendingServiceResource.resourceSetId);
 616                                         resourceManager.releaseResourceSet(pendingServiceResource.resourceSetId);
 617
 618                                         log.info("Updating the pending service resource record in DB with service change number: " +
 619                                                 sr.serviceChangeNumber);
 620                                         serviceResourceDao.updateServiceResource(sr);
 621                                 }
 622                         }
 623
 624                         return QueryStatus.SUCCESS;
 625                 }
 626
 627                 log.info("Releasing allocated resources (if any) for resource set id: " + sr.resourceSetId);
 628                 resourceManager.releaseResourceSet(sr.resourceSetId);
 629
 630                 long maxAvailableSpeed = Long.MAX_VALUE;
 631                 if (!vpePortFound && maxAvailableSpeedVpePort < maxAvailableSpeed)
 632                         maxAvailableSpeed = maxAvailableSpeedVpePort;
 633                 if (!vplspePortFound && maxAvailableSpeedVplspePort < maxAvailableSpeed)
 634                         maxAvailableSpeed = maxAvailableSpeedVplspePort;
 635                 if (!serverFound && maxAvailableSpeedServer < maxAvailableSpeed)
 636                         maxAvailableSpeed = maxAvailableSpeedServer;
 637
 638                 setOutputContext(ctx, maxAvailableSpeed, "kbps");
 639                 return QueryStatus.NOT_FOUND;
 640         }
 641
 642         private List<Map<String, Object>> orderVpe(List<Map<String, Object>> vpePortData) {
 643                 for (Map<String, Object> vpe : vpePortData) {
 644                         String vpeId = String.valueOf(vpe.get("vpe-id"));
 645                         String interfaceName = String.valueOf(vpe.get("physical-interface-name"));
 646                         String portId = vpeId + "/" + interfaceName;
 647                         Resource r = resourceManager.getResource("Bandwidth", portId);
 648                         long used = 0;
 649                         if (r != null) {
 650                                 LimitResource ll = (LimitResource) r;
 651                                 used = ll.used;
 652                         }
 653                         vpe.put("used-bandwidth", used);
 654
 655                         log.info("Used bandwidth on VPE: " + vpeId + ": " + used);
 656                 }
 657
 658                 Collections.sort(vpePortData, new Comparator<Map<String, Object>>() {
 659
 660                         @Override
 661                         public int compare(Map<String, Object> o1, Map<String, Object> o2) {
 662                                 long used1 = (Long) o1.get("used-bandwidth");
 663                                 long used2 = (Long) o2.get("used-bandwidth");
 664                                 if (used1 < used2)
 665                                         return -1;
 666                                 if (used1 > used2)
 667                                         return 1;
 668                                 return 0;
 669                         }
 670                 });
 671
 672                 return vpePortData;
 673         }
 674
 675         private void setThresholdData(SvcLogicContext ctx, ThresholdStatus th, ServiceData sd, EquipmentData ed) {
 676                 if (th == null)
 677                         return;
 678
 679                 String pp = "tmp.resource-allocator-output.threshold-notification-list.threshold-hotification[0].";
 680                 ctx.setAttribute("tmp.resource-allocator-output.threshold-notification-list.threshold-hotification_length",
 681                         "1");
 682                 ctx.setAttribute(pp + "message", th.resourceThreshold.message);
 683                 ctx.setAttribute(pp + "resource-rule.service-model", th.resourceRule.serviceModel);
 684                 ctx.setAttribute(pp + "resource-rule.endpoint-position", th.resourceRule.endPointPosition);
 685                 ctx.setAttribute(pp + "resource-rule.resource-name", th.resourceRule.resourceName);
 686                 ctx.setAttribute(pp + "resource-rule.equipment-level", th.resourceRule.equipmentLevel);
 687                 ctx.setAttribute(pp + "resource-rule.soft-limit-expression", th.resourceRule.softLimitExpression);
 688                 ctx.setAttribute(pp + "resource-rule.hard-limit-expression", th.resourceRule.hardLimitExpression);
 689                 ctx.setAttribute(pp + "resource-state.used", String.valueOf(th.used));
 690                 ctx.setAttribute(pp + "resource-state.limit-value", String.valueOf(th.limitValue));
 691                 ctx.setAttribute(pp + "resource-state.threshold-value", String.valueOf(th.thresholdValue));
 692                 ctx.setAttribute(pp + "resource-state.last-added", String.valueOf(th.lastAdded));
 693                 ctx.setAttribute(pp + "equipment-data.equipment-id", ed.equipmentId);
 694                 for (String edKey : ed.data.keySet())
 695                         ctx.setAttribute(pp + "equipment-data." + edKey, String.valueOf(ed.data.get(edKey)));
 696         }
 697
 698         private QueryStatus allocateResources(String serviceModel, SvcLogicContext ctx, boolean checkOnly, String prefix)
 699                 throws SvcLogicException {
 700                 prefix = prefix == null ? "" : prefix + '.';
 701
 702                 Map<String, Object> service = getServiceData(ctx);
 703                 Map<String, Object> ec = getEquipConstraints(ctx);
 704
 705                 String requestTypeStr = ctx.getAttribute("tmp.resource-allocator.request-type");
 706                 if (requestTypeStr == null)
 707                         requestTypeStr = "New";
 708
 709                 ReserveRequestType requestType = null;
 710                 try {
 711                         requestType = ReserveRequestType.convert(requestTypeStr);
 712                 } catch (IllegalArgumentException e) {
 713                         throw new SvcLogicException("Invalid tmp.resource-allocator.request-type: " + requestTypeStr +
 714                                 ". Supported values are New, Change.");
 715                 }
 716
 717                 String serviceInstanceId = String.valueOf(service.get("service-instance-id"));
 718
 719                 log.info("Starting reserve: " + requestType + ", service-instance-id: " + serviceInstanceId);
 720
 721                 ServiceResource activeServiceResource =
 722                         serviceResourceDao.getServiceResource(serviceInstanceId, ServiceStatus.Active);
 723                 ServiceResource pendingServiceResource =
 724                         serviceResourceDao.getServiceResource(serviceInstanceId, ServiceStatus.Pending);
 725
 726                 log.info("Active ServiceResource: ");
 727                 StrUtil.info(log, activeServiceResource);
 728                 log.info("Pending ServiceResource: ");
 729                 StrUtil.info(log, pendingServiceResource);
 730
 731                 int changeNumber = 1;
 732                 if (pendingServiceResource != null)
 733                         changeNumber = pendingServiceResource.serviceChangeNumber + 1;
 734                 else if (activeServiceResource != null)
 735                         changeNumber = activeServiceResource.serviceChangeNumber + 1;
 736
 737                 ServiceData sd = new ServiceData();
 738                 sd.data = service;
 739                 sd.serviceModel = serviceModel;
 740                 sd.endPointPosition = (String) service.get("end-point-position");
 741                 sd.resourceShareGroup = (String) service.get("resource-share-group");
 742                 sd.resourceName = (String) service.get("resource-name");
 743                 sd.serviceInstanceId = serviceInstanceId;
 744
 745                 StrUtil.info(log, sd);
 746
 747                 List<EndPointData> epList = endPointAllocator.allocateEndPoints(sd, ec, checkOnly,
 748                         requestType == ReserveRequestType.Change, changeNumber);
 749
 750                 if (epList != null && !epList.isEmpty()) {
 751                         if (!checkOnly) {
 752                                 EndPointData ep = epList.get(0);
 753
 754                                 if (sd.resourceName == null) {
 755                                 ServiceResource sr = new ServiceResource();
 756                                 sr.serviceInstanceId = serviceInstanceId;
 757                                 sr.serviceStatus = ServiceStatus.Pending;
 758                                 sr.serviceChangeNumber = changeNumber;
 759                                 sr.resourceSetId = ep.resourceSetId;
 760                                 sr.resourceUnionId = ep.resourceUnionId;
 761
 762                                 log.info("New ServiceResource: ");
 763                                 StrUtil.info(log, sr);
 764
 765                                 if (pendingServiceResource == null) {
 766                                         log.info("Adding the pending service resource record to DB.");
 767                                         serviceResourceDao.addServiceResource(sr);
 768                                 } else {
 769                                         log.info("Releasing previously allocated resources for resource set id: " +
 770                                                 pendingServiceResource.resourceSetId);
 771                                         resourceManager.releaseResourceSet(pendingServiceResource.resourceSetId);
 772
 773                                         log.info("Updating the pending service resource record in DB with service change number: " +
 774                                                 sr.serviceChangeNumber);
 775                                         serviceResourceDao.updateServiceResource(sr);
 776                                 }
 777                         }
 778
 779                                 for (EndPointData ep1 : epList)
 780                                         if (ep1.data != null && !ep1.data.isEmpty())
 781                                                 for (String key : ep1.data.keySet()) {
 782                                                         String value = String.valueOf(ep1.data.get(key));
 783                                                         ctx.setAttribute(prefix + key, value);
 784
 785                                                         log.info("Added context attr: " + prefix + key + ": " + value);
 786                                                 }
 787                         }
 788
 789                         return QueryStatus.SUCCESS;
 790                 }
 791
 792                 log.info("Capacity not found for EVC: " + serviceInstanceId);
 793
 794                 return QueryStatus.NOT_FOUND;
 795         }
 796
 797         private int getEvcCountOnServer(String serverId) {
 798                 LimitResource l = (LimitResource) resourceManager.getResource("Connection", serverId);
 799                 if (l != null)
 800                         return (int) l.used;
 801                 return 0;
 802         }
 803
 804         private String getAicSiteId(SvcLogicContext ctx) throws SvcLogicException {
 805                 String aicSiteId = ctx.getAttribute("tmp.resource-allocator.aic-site-id");
 806                 if (aicSiteId == null)
 807                         throw new SvcLogicException("tmp.resource-allocator.aic-site-id is required in ResourceAllocator");
 808                 return aicSiteId;
 809         }
 810
 811         private Map<String, Object> getServiceData(SvcLogicContext ctx) throws SvcLogicException {
 812                 Map<String, Object> sd = new HashMap<String, Object>();
 813
 814                 String endPointPosition = ctx.getAttribute("tmp.resource-allocator.end-point-position");
 815                 if (endPointPosition != null && endPointPosition.trim().length() > 0)
 816                         sd.put("end-point-position", endPointPosition.trim());
 817
 818                 String resourceName = ctx.getAttribute("tmp.resource-allocator.resource-name");
 819                 if (resourceName != null && resourceName.trim().length() > 0)
 820                         sd.put("resource-name", resourceName.trim());
 821
 822                 String resourceShareGroup = ctx.getAttribute("tmp.resource-allocator.resource-share-group");
 823                 if (resourceShareGroup != null && resourceShareGroup.trim().length() > 0)
 824                         sd.put("resource-share-group", resourceShareGroup.trim());
 825
 826                 String serviceInstanceId = ctx.getAttribute("tmp.resource-allocator.service-instance-id");
 827                 if (serviceInstanceId == null)
 828                         serviceInstanceId = "checkServiceInstance";
 829                 sd.put("service-instance-id", serviceInstanceId);
 830
 831                 String speedStr = ctx.getAttribute("tmp.resource-allocator.speed");
 832                 if (speedStr != null && speedStr.trim().length() > 0) {
 833                 long speed = 0;
 834                 try {
 835                         speed = Long.parseLong(speedStr);
 836                 } catch (NumberFormatException e) {
 837                         throw new SvcLogicException("Invalid tmp.resource-allocator.speed. Must be a number.");
 838                 }
 839                 String unit = ctx.getAttribute("tmp.resource-allocator.speed-unit");
 840                 if (unit == null || unit.trim().length() == 0)
 841                         throw new SvcLogicException("tmp.resource-allocator.speed-unit is required in ResourceAllocator");
 842                 long serviceSpeedKbps = speedUtil.convertToKbps(speed, unit);
 843
 844                 sd.put("service-speed-kbps", serviceSpeedKbps);
 845                 }
 846
 847                 String vpnId = ctx.getAttribute("tmp.resource-allocator.vpn-id");
 848                 if (vpnId != null && vpnId.trim().length() > 0)
 849                         sd.put("vpn-id", vpnId.trim());
 850
 851                 String vpnIdList = ctx.getAttribute("tmp.resource-allocator.vpn-id-list");
 852                 if (vpnIdList != null && vpnIdList.trim().length() > 0)
 853                         sd.put("vpn-id-list", vpnIdList.trim());
 854
 855                 String vrfName = ctx.getAttribute("tmp.resource-allocator.vrf-name");
 856                 if (vrfName != null && vrfName.trim().length() > 0)
 857                         sd.put("vrf-name", vrfName.trim());
 858
 859                 String vrfNameList = ctx.getAttribute("tmp.resource-allocator.vrf-name-list");
 860                 if (vrfNameList != null && vrfNameList.trim().length() > 0)
 861                         sd.put("vrf-name-list", vrfNameList.trim());
 862
 863                 String v4multicast = ctx.getAttribute("tmp.resource-allocator.v4-multicast");
 864                 if (v4multicast != null && v4multicast.trim().length() > 0)
 865                         sd.put("v4-multicast", v4multicast.trim());
 866
 867                 String v6multicast = ctx.getAttribute("tmp.resource-allocator.v6-multicast");
 868                 if (v6multicast != null && v6multicast.trim().length() > 0)
 869                         sd.put("v6-multicast", v6multicast.trim());
 870
 871                 String v4ServingSite = ctx.getAttribute("tmp.resource-allocator.v4-serving-site");
 872                 if (v4ServingSite != null && v4ServingSite.trim().length() > 0)
 873                         sd.put("v4-serving-site", v4ServingSite.trim());
 874
 875                 String v6ServingSite = ctx.getAttribute("tmp.resource-allocator.v6-serving-site");
 876                 if (v6ServingSite != null && v6ServingSite.trim().length() > 0)
 877                         sd.put("v6-serving-site", v6ServingSite.trim());
 878
 879                 return sd;
 880         }
 881
 882         private Map<String, Object> getEquipConstraints(SvcLogicContext ctx) throws SvcLogicException {
 883                 Map<String, Object> mm = new HashMap<String, Object>();
 884
 885                 String vrfRequired = ctx.getAttribute("tmp.resource-allocator.vrf-required");
 886                 if (vrfRequired != null && vrfRequired.trim().length() > 0)
 887                         mm.put("vrf-required", vrfRequired.trim());
 888
 889                 String clli = ctx.getAttribute("tmp.resource-allocator.clli");
 890                 if (clli == null || clli.trim().length() == 0)
 891                         clli = ctx.getAttribute("tmp.resource-allocator.aic-site-id");
 892                 if (clli != null) {
 893                 mm.put("clli", clli.trim());
 894                         mm.put("aic-site-id", clli.trim());
 895                 }
 896
 897                 String vpeName = ctx.getAttribute("tmp.resource-allocator.vpe-name");
 898                 if (vpeName != null && vpeName.trim().length() > 0)
 899                         mm.put("vpe-name", vpeName.trim());
 900
 901                 String vnfName = ctx.getAttribute("tmp.resource-allocator.device-name");
 902                 if (vnfName != null && vnfName.trim().length() > 0)
 903                         mm.put("vnf-name", vnfName.trim());
 904
 905                 String excludeVpeList = ctx.getAttribute("tmp.resource-allocator.exclude-vpe-list");
 906                 if (excludeVpeList != null && excludeVpeList.trim().length() > 0)
 907                         mm.put("exclude-vpe-list", excludeVpeList.trim());
 908
 909                 String uplinkCircuitCountStr =
 910                         ctx.getAttribute("tmp.resource-allocator.uplink-circuit-list.uplink-circuit_length");
 911                 if (uplinkCircuitCountStr != null) {
 912                         long uplinkCircuitCount = 0;
 913                         try {
 914                                 uplinkCircuitCount = Long.parseLong(uplinkCircuitCountStr);
 915                         } catch (NumberFormatException e) {
 916                                 throw new SvcLogicException(
 917                                         "Invalid tmp.resource-allocator.uplink-circuit-list.uplink-circuit_length. Must be a number.");
 918                         }
 919                         List<Map<String, Object>> uplinkCircuitList = new ArrayList<>();
 920                         for (int i = 0; i < uplinkCircuitCount; i++) {
 921                                 String uplinkCircuitId = ctx.getAttribute(
 922                                         "tmp.resource-allocator.uplink-circuit-list.uplink-circuit[" + i + "].uplink-circuit-id");
 923                                 String uplinkCircuitBandwidthStr =
 924                                         ctx.getAttribute("tmp.resource-allocator.uplink-circuit-list.uplink-circuit[" + i +
 925                                                 "].uplink-circuit-bandwidth");
 926                                 String uplinkCircuitBandwidthUnit =
 927                                         ctx.getAttribute("tmp.resource-allocator.uplink-circuit-list.uplink-circuit[" + i +
 928                                                 "].uplink-circuit-bandwidth-unit");
 929
 930                                 long uplinkCircuitBandwidth = 0;
 931                                 try {
 932                                         uplinkCircuitBandwidth = Long.parseLong(uplinkCircuitBandwidthStr);
 933                                 } catch (NumberFormatException e) {
 934                                         throw new SvcLogicException("Invalid tmp.resource-allocator.uplink-circuit-list.uplink-circuit[" +
 935                                                 i + "].uplink-circuit-id. Must be a number.");
 936                                 }
 937
 938                                 long uplinkCircuitBandwidthKbps =
 939                                         speedUtil.convertToKbps(uplinkCircuitBandwidth, uplinkCircuitBandwidthUnit);
 940
 941                                 Map<String, Object> uplinkCircuit = new HashMap<String, Object>();
 942                                 uplinkCircuit.put("uplink-circuit-id", uplinkCircuitId);
 943                                 uplinkCircuit.put("uplink-circuit-bandwidth", uplinkCircuitBandwidthKbps);
 944                                 uplinkCircuitList.add(uplinkCircuit);
 945                         }
 946                         mm.put("uplink-circuit-list", uplinkCircuitList);
 947                 }
 948
 949                 return mm;
 950         }
 951
 952         private void setOutputContext(SvcLogicContext ctx, long maxAvailableSpeed, String unit) {
 953                 ctx.setAttribute("tmp.resource-allocator-output.max-available-speed", String.valueOf(maxAvailableSpeed));
 954                 ctx.setAttribute("tmp.resource-allocator-output.speed-unit", unit);
 955         }
 956
 957         private int calculatePrimaryServerCount(int serverCount, String ratioString) throws SvcLogicException {
 958                 String[] ss = ratioString.split(":");
 959                 if (ss.length != 2)
 960                         throw new SvcLogicException("Invalid value for homing.pserver.sparing.ratio: " + ratioString);
 961
 962                 int n = 1, m = 1;
 963                 try {
 964                         n = Integer.parseInt(ss[0]);
 965                         m = Integer.parseInt(ss[1]);
 966                 } catch (Exception e) {
 967                         throw new SvcLogicException("Invalid value for homing.pserver.sparing.ratio: " + ratioString);
 968                 }
 969
 970                 return (serverCount - 1) * n / (n + m) + 1;
 971         }
 972
 973         public void setServerDao(ServerDao serverDao) {
 974                 this.serverDao = serverDao;
 975         }
 976
 977         public void setVpePortDao(VpePortDao vpePortDao) {
 978                 this.vpePortDao = vpePortDao;
 979         }
 980
 981         public void setVplspePortDao(VplspePortDao vplspePortDao) {
 982                 this.vplspePortDao = vplspePortDao;
 983         }
 984
 985         public void setMaxPortSpeedDao(MaxPortSpeedDao maxPortSpeedDao) {
 986                 this.maxPortSpeedDao = maxPortSpeedDao;
 987         }
 988
 989         public void setMaxServerSpeedDao(MaxServerSpeedDao maxServerSpeedDao) {
 990                 this.maxServerSpeedDao = maxServerSpeedDao;
 991         }
 992
 993         public void setAllocationRequestBuilder(AllocationRequestBuilder allocationRequestBuilder) {
 994                 this.allocationRequestBuilder = allocationRequestBuilder;
 995         }
 996
 997         public void setResourceManager(ResourceManager resourceManager) {
 998                 this.resourceManager = resourceManager;
 999         }
1000
1001         public void setSpeedUtil(SpeedUtil speedUtil) {
1002                 this.speedUtil = speedUtil;
1003         }
1004
1005         public void setServiceResourceDao(ServiceResourceDao serviceResourceDao) {
1006                 this.serviceResourceDao = serviceResourceDao;
1007         }
1008
1009         public void setEndPointAllocator(EndPointAllocator endPointAllocator) {
1010                 this.endPointAllocator = endPointAllocator;
1011         }
1012
1013         public void setParameterDao(ParameterDao parameterDao) {
1014                 this.parameterDao = parameterDao;
1015         }
1016 }