2 * ============LICENSE_START=======================================================
4 * ================================================================================
5 * Copyright (C) 2017 - 2018 AT&T Intellectual Property. All rights reserved.
6 * ================================================================================
7 * Modifications Copyright (c) 2019 Samsung
8 * ================================================================================
9 * Licensed under the Apache License, Version 2.0 (the "License");
10 * you may not use this file except in compliance with the License.
11 * You may obtain a copy of the License at
13 * http://www.apache.org/licenses/LICENSE-2.0
15 * Unless required by applicable law or agreed to in writing, software
16 * distributed under the License is distributed on an "AS IS" BASIS,
17 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
18 * See the License for the specific language governing permissions and
19 * limitations under the License.
20 * ============LICENSE_END=========================================================
23 package org.onap.so.bpmn.buildingblock;
25 import static org.apache.commons.lang3.StringUtils.*;
26 import java.time.Duration;
27 import java.util.ArrayList;
28 import java.util.List;
30 import java.util.UUID;
31 import org.apache.commons.lang.SerializationUtils;
32 import org.camunda.bpm.engine.delegate.BpmnError;
33 import org.json.JSONArray;
34 import org.json.JSONObject;
35 import org.onap.so.bpmn.common.BuildingBlockExecution;
36 import org.onap.so.bpmn.core.json.JsonUtils;
37 import org.onap.so.bpmn.servicedecomposition.bbobjects.AllottedResource;
38 import org.onap.so.bpmn.servicedecomposition.bbobjects.CloudRegion;
39 import org.onap.so.bpmn.servicedecomposition.bbobjects.Customer;
40 import org.onap.so.bpmn.servicedecomposition.bbobjects.GenericVnf;
41 import org.onap.so.bpmn.servicedecomposition.bbobjects.Pnf;
42 import org.onap.so.bpmn.servicedecomposition.bbobjects.ServiceInstance;
43 import org.onap.so.bpmn.servicedecomposition.bbobjects.ServiceProxy;
44 import org.onap.so.bpmn.servicedecomposition.bbobjects.VpnBondingLink;
45 import org.onap.so.bpmn.servicedecomposition.entities.GeneralBuildingBlock;
46 import org.onap.so.bpmn.servicedecomposition.generalobjects.License;
47 import org.onap.so.bpmn.servicedecomposition.generalobjects.RequestContext;
48 import org.onap.so.bpmn.servicedecomposition.generalobjects.RequestParameters;
49 import org.onap.so.bpmn.servicedecomposition.homingobjects.Candidate;
50 import org.onap.so.bpmn.servicedecomposition.homingobjects.CandidateType;
51 import org.onap.so.bpmn.servicedecomposition.homingobjects.SolutionCandidates;
52 import org.onap.so.bpmn.servicedecomposition.homingobjects.SolutionInfo;
53 import org.onap.so.bpmn.servicedecomposition.modelinfo.ModelInfoMetadata;
54 import org.onap.so.bpmn.servicedecomposition.modelinfo.ModelInfoServiceInstance;
55 import org.onap.so.client.exception.BadResponseException;
56 import org.onap.so.client.exception.ExceptionBuilder;
57 import org.onap.so.client.sniro.SniroClient;
58 import static org.onap.so.client.sniro.SniroValidator.*;
59 import org.onap.so.client.sniro.beans.Demand;
60 import org.onap.so.client.sniro.beans.LicenseInfo;
61 import org.onap.so.client.sniro.beans.ModelInfo;
62 import org.onap.so.client.sniro.beans.PlacementInfo;
63 import org.onap.so.client.sniro.beans.RequestInfo;
64 import org.onap.so.client.sniro.beans.ServiceInfo;
65 import org.onap.so.client.sniro.beans.SniroManagerRequest;
66 import org.onap.so.client.sniro.beans.SubscriberInfo;
67 import org.onap.so.db.catalog.beans.OrchestrationStatus;
68 import org.slf4j.Logger;
69 import org.slf4j.LoggerFactory;
70 import org.springframework.beans.factory.annotation.Autowired;
71 import org.springframework.core.env.Environment;
72 import org.springframework.stereotype.Component;
73 import org.springframework.web.util.UriUtils;
77 * The sniro homing building block obtains licensing and homing solutions for a given resource or set of resources.
82 @Component("SniroHoming")
83 public class SniroHomingV2 {
85 private static final Logger logger = LoggerFactory.getLogger(SniroHomingV2.class);
86 private JsonUtils jsonUtils = new JsonUtils();
88 private Environment env;
90 private SniroClient client;
92 private ExceptionBuilder exceptionUtil;
93 private static final String MODEL_NAME = "modelName";
94 private static final String MODEL_INVARIANT_ID = "modelInvariantId";
95 private static final String MODEL_VERSION_ID = "modelVersionId";
96 private static final String MODEL_VERSION = "modelVersion";
97 private static final String SERVICE_RESOURCE_ID = "serviceResourceId";
98 private static final String RESOURCE_MODULE_NAME = "resourceModuleName";
99 private static final String RESOURCE_MODEL_INFO = "resourceModelInfo";
100 private static final String IDENTIFIER_TYPE = "identifierType";
101 private static final String SOLUTIONS = "solutions";
102 private static final String RESOURCE_MISSING_DATA = "Resource does not contain: ";
103 private static final String SERVICE_MISSING_DATA = "Service Instance does not contain: ";
104 private static final String UNPROCESSABLE = "422";
105 private static final int INTERNAL = 500;
108 * Generates the request payload then sends to sniro manager to perform homing and licensing for the provided
113 public void callSniro(BuildingBlockExecution execution) {
114 logger.debug("Started Sniro Homing Call Sniro");
116 GeneralBuildingBlock bb = execution.getGeneralBuildingBlock();
118 RequestContext requestContext = bb.getRequestContext();
119 RequestParameters requestParams = requestContext.getRequestParameters();
120 String requestId = requestContext.getMsoRequestId();
122 ServiceInstance serviceInstance = bb.getCustomer().getServiceSubscription().getServiceInstances().get(0);
123 Customer customer = bb.getCustomer();
125 String timeout = execution.getVariable("timeout");
126 if (isBlank(timeout)) {
127 timeout = env.getProperty("sniro.manager.timeout", "PT30M");
130 SniroManagerRequest request = new SniroManagerRequest();
132 RequestInfo requestInfo = buildRequestInfo(requestId, timeout);
133 request.setRequestInformation(requestInfo);
135 ServiceInfo serviceInfo = buildServiceInfo(serviceInstance);
136 request.setServiceInformation(serviceInfo);
138 PlacementInfo placementInfo = buildPlacementInfo(customer, requestParams);
140 List<Demand> placementDemands = buildPlacementDemands(serviceInstance);
141 placementInfo.setDemands(placementDemands);
142 request.setPlacementInformation(placementInfo);
144 LicenseInfo licenseInfo = new LicenseInfo();
146 List<Demand> licenseDemands = buildLicenseDemands(serviceInstance);
147 licenseInfo.setDemands(licenseDemands);
148 request.setLicenseInformation(licenseInfo);
150 if (placementDemands.size() > 0 || licenseDemands.size() > 0) {
151 client.postDemands(request);
153 logger.debug(SERVICE_MISSING_DATA + "resources eligible for homing or licensing");
154 throw new BpmnError(UNPROCESSABLE, SERVICE_MISSING_DATA + "resources eligible for homing or licensing");
157 // Variables for ReceiveWorkflowMessage subflow
158 execution.setVariable("asyncCorrelator", requestId);
159 execution.setVariable("asyncMessageType", "SNIROResponse");
160 execution.setVariable("asyncTimeout", timeout);
162 logger.trace("Completed Sniro Homing Call Sniro");
163 } catch (BpmnError e) {
164 logger.error("Exception occurred", e);
165 exceptionUtil.buildAndThrowWorkflowException(execution, Integer.parseInt(e.getErrorCode()), e.getMessage());
166 } catch (BadResponseException e) {
167 logger.error("Exception occurred", e);
168 exceptionUtil.buildAndThrowWorkflowException(execution, 400, e.getMessage());
169 } catch (Exception e) {
170 logger.error("Exception occurred", e);
171 exceptionUtil.buildAndThrowWorkflowException(execution, INTERNAL,
172 "Internal Error - occurred while preparing sniro request: " + e.getMessage());
177 * Validates, processes, and sets the homing and licensing solutions that are returned by sniro manager
180 * @param asyncResponse
182 public void processSolution(BuildingBlockExecution execution, String asyncResponse) {
183 logger.trace("Started Sniro Homing Process Solution");
185 // TODO improve handling multiple solutions but is dependent on sniro enhancing api + work with sniro
186 // conductor to improve "inventoryType" representation
187 validateSolution(asyncResponse);
188 ServiceInstance serviceInstance = execution.getGeneralBuildingBlock().getCustomer().getServiceSubscription()
189 .getServiceInstances().get(0);
191 logger.debug("Processing sniro manager asyncronous response");
192 JSONObject response = new JSONObject(asyncResponse);
193 if (response.has(SOLUTIONS)) {
194 JSONObject allSolutions = response.getJSONObject(SOLUTIONS);
195 if (allSolutions.has("placementSolutions")) {
196 JSONArray placementSolutions = allSolutions.getJSONArray("placementSolutions");
197 for (int i = 0; i < placementSolutions.length(); i++) {
198 JSONArray placements = placementSolutions.getJSONArray(i);
199 processPlacementSolution(serviceInstance, placements, i);
202 if (allSolutions.has("licenseSolutions")) {
203 JSONArray licenseSolutions = allSolutions.getJSONArray("licenseSolutions");
204 if (licenseSolutions.length() > 0) {
205 processLicenseSolution(serviceInstance, licenseSolutions);
209 throw new BpmnError(UNPROCESSABLE, "Sniro Managers response does not contain: " + SOLUTIONS);
212 execution.setVariable("generalBuildingBlock", execution.getGeneralBuildingBlock());
214 logger.trace("Completed Sniro Homing Process Solution");
215 } catch (BpmnError e) {
216 logger.error("Exception occurred", e);
217 exceptionUtil.buildAndThrowWorkflowException(execution, Integer.parseInt(e.getErrorCode()), e.getMessage());
218 } catch (BadResponseException e) {
219 logger.error("Exception occurred", e);
220 exceptionUtil.buildAndThrowWorkflowException(execution, 400, e.getMessage());
221 } catch (Exception e) {
222 logger.error("Exception occurred", e);
223 exceptionUtil.buildAndThrowWorkflowException(execution, INTERNAL,
224 "Internal Error - occurred while processing sniro asynchronous response: " + e.getMessage());
229 * Builds the request information section for the homing/licensing request
233 private RequestInfo buildRequestInfo(String requestId, String timeout) throws Exception {
234 logger.trace("Building request information");
235 RequestInfo requestInfo = new RequestInfo();
236 if (requestId != null) {
237 String host = env.getProperty("mso.workflow.message.endpoint");
238 String callbackUrl = host + "/" + UriUtils.encodePathSegment("SNIROResponse", "UTF-8") + "/"
239 + UriUtils.encodePathSegment(requestId, "UTF-8");
241 Duration d = Duration.parse(timeout);
243 requestInfo.setTransactionId(requestId);
244 requestInfo.setRequestId(requestId);
245 requestInfo.setCallbackUrl(callbackUrl);
246 requestInfo.setRequestType("create");
247 requestInfo.setTimeout(d.getSeconds());
250 throw new BpmnError(UNPROCESSABLE, "Request Context does not contain: requestId");
256 * Builds the request information section for the homing/licensing request
259 private ServiceInfo buildServiceInfo(ServiceInstance serviceInstance) {
260 logger.trace("Building service information");
261 ServiceInfo info = new ServiceInfo();
262 ModelInfoServiceInstance modelInfo = serviceInstance.getModelInfoServiceInstance();
263 if (isNotBlank(modelInfo.getModelInvariantUuid()) && isNotBlank(modelInfo.getModelUuid())) {
264 info.setServiceInstanceId(serviceInstance.getServiceInstanceId());
265 if (modelInfo.getServiceType() != null && modelInfo.getServiceType().length() > 0) { // temp solution
266 info.setServiceName(modelInfo.getServiceType());
268 if (modelInfo.getServiceRole() != null) {
269 info.setServiceRole(modelInfo.getServiceRole());
271 info.setModelInfo(buildModelInfo(modelInfo));
273 throw new BpmnError(UNPROCESSABLE, SERVICE_MISSING_DATA + MODEL_VERSION_ID + ", " + MODEL_INVARIANT_ID);
279 * Builds initial section of placement info for the homing/licensing request
282 private PlacementInfo buildPlacementInfo(Customer customer, RequestParameters requestParams) {
283 PlacementInfo placementInfo = new PlacementInfo();
284 if (customer != null) {
285 logger.debug("Adding subscriber to placement information");
286 SubscriberInfo subscriber = new SubscriberInfo();
287 subscriber.setGlobalSubscriberId(customer.getGlobalCustomerId());
288 subscriber.setSubscriberName(customer.getSubscriberName());
289 subscriber.setSubscriberCommonSiteId(customer.getSubscriberCommonSiteId());
290 placementInfo.setSubscriberInfo(subscriber);
291 if (requestParams != null) {
292 logger.debug("Adding request parameters to placement information");
293 placementInfo.setRequestParameters(requestParams.toJsonString());
296 throw new BpmnError(UNPROCESSABLE, SERVICE_MISSING_DATA + "customer");
298 return placementInfo;
303 * Builds the placement demand list for the homing/licensing request
306 private List<Demand> buildPlacementDemands(ServiceInstance serviceInstance) {
307 logger.trace("Building placement information demands");
308 List<Demand> placementDemands = new ArrayList<Demand>();
310 List<AllottedResource> allottedResourceList = serviceInstance.getAllottedResources();
311 if (!allottedResourceList.isEmpty()) {
312 logger.debug("Adding allotted resources to placement demands list");
313 for (AllottedResource ar : allottedResourceList) {
314 if (isBlank(ar.getId())) {
315 ar.setId(UUID.randomUUID().toString());
317 Demand demand = buildDemand(ar.getId(), ar.getModelInfoAllottedResource());
318 addCandidates(ar, demand);
319 placementDemands.add(demand);
322 List<VpnBondingLink> vpnBondingLinkList = serviceInstance.getVpnBondingLinks();
323 if (!vpnBondingLinkList.isEmpty()) {
324 logger.debug("Adding vpn bonding links to placement demands list");
325 for (VpnBondingLink vbl : vpnBondingLinkList) {
326 List<ServiceProxy> serviceProxyList = vbl.getServiceProxies();
327 for (ServiceProxy sp : serviceProxyList) {
328 if (isBlank(sp.getId())) {
329 sp.setId(UUID.randomUUID().toString());
331 Demand demand = buildDemand(sp.getId(), sp.getModelInfoServiceProxy());
332 addCandidates(sp, demand);
333 placementDemands.add(demand);
337 return placementDemands;
341 * Builds the license demand list for the homing/licensing request
344 private List<Demand> buildLicenseDemands(ServiceInstance serviceInstance) {
345 logger.trace("Building license information");
346 List<Demand> licenseDemands = new ArrayList<Demand>();
347 List<GenericVnf> vnfList = serviceInstance.getVnfs();
348 if (!vnfList.isEmpty()) {
349 logger.debug("Adding vnfs to license demands list");
350 for (GenericVnf vnf : vnfList) {
351 Demand demand = buildDemand(vnf.getVnfId(), vnf.getModelInfoGenericVnf());
352 licenseDemands.add(demand);
355 return licenseDemands;
359 * Builds a single demand object
362 private Demand buildDemand(String id, ModelInfoMetadata metadata) {
363 logger.debug("Building demand for service or resource: " + id);
364 Demand demand = new Demand();
365 if (isNotBlank(id) && isNotBlank(metadata.getModelInstanceName())) {
366 demand.setServiceResourceId(id);
367 demand.setResourceModuleName(metadata.getModelInstanceName());
368 demand.setModelInfo(buildModelInfo(metadata));
370 throw new BpmnError(UNPROCESSABLE, RESOURCE_MISSING_DATA + "modelInstanceName");
376 * Builds the resource model info section
379 private ModelInfo buildModelInfo(ModelInfoMetadata metadata) {
380 ModelInfo object = new ModelInfo();
381 String invariantUuid = metadata.getModelInvariantUuid();
382 String modelUuid = metadata.getModelUuid();
383 if (isNotBlank(invariantUuid) && isNotBlank(modelUuid)) {
384 object.setModelInvariantId(invariantUuid);
385 object.setModelVersionId(modelUuid);
386 object.setModelName(metadata.getModelName());
387 object.setModelVersion(metadata.getModelVersion());
388 } else if (isNotBlank(invariantUuid)) {
389 throw new BpmnError(UNPROCESSABLE, RESOURCE_MISSING_DATA + MODEL_VERSION_ID);
391 throw new BpmnError(UNPROCESSABLE, RESOURCE_MISSING_DATA + MODEL_INVARIANT_ID);
397 * Adds required, excluded, and existing candidates to a demand
400 private void addCandidates(SolutionCandidates candidates, Demand demand) {
401 List<Candidate> required = candidates.getRequiredCandidates();
402 List<Candidate> excluded = candidates.getExcludedCandidates();
403 if (!required.isEmpty()) {
404 List<org.onap.so.client.sniro.beans.Candidate> cans =
405 new ArrayList<org.onap.so.client.sniro.beans.Candidate>();
406 for (Candidate c : required) {
407 org.onap.so.client.sniro.beans.Candidate can = new org.onap.so.client.sniro.beans.Candidate();
408 can.setIdentifierType(c.getIdentifierType());
409 can.setIdentifiers(c.getIdentifiers());
410 can.setCloudOwner(c.getCloudOwner());
413 demand.setRequiredCandidates(cans);
415 if (!excluded.isEmpty()) {
416 List<org.onap.so.client.sniro.beans.Candidate> cans =
417 new ArrayList<org.onap.so.client.sniro.beans.Candidate>();
418 for (Candidate c : excluded) {
419 org.onap.so.client.sniro.beans.Candidate can = new org.onap.so.client.sniro.beans.Candidate();
420 can.setIdentifierType(c.getIdentifierType());
421 can.setIdentifiers(c.getIdentifiers());
422 can.setCloudOwner(c.getCloudOwner());
425 demand.setExcludedCandidates(cans);
427 // TODO support existing candidates
431 * Processes the license solutions and sets to the corresponding generic vnf
434 private void processLicenseSolution(ServiceInstance serviceInstance, JSONArray licenseSolutions) {
435 List<GenericVnf> vnfs = serviceInstance.getVnfs();
437 logger.debug("Processing the license solution");
438 for (int i = 0; i < licenseSolutions.length(); i++) {
439 JSONObject licenseSolution = licenseSolutions.getJSONObject(i);
440 for (GenericVnf vnf : vnfs) {
441 if (licenseSolution.getString(SERVICE_RESOURCE_ID).equals(vnf.getVnfId())) {
442 License license = new License();
443 JSONArray entitlementPools = licenseSolution.getJSONArray("entitlementPoolUUID");
444 List<String> entitlementPoolsList = jsonUtils.StringArrayToList(entitlementPools);
445 license.setEntitlementPoolUuids(entitlementPoolsList);
446 JSONArray licenseKeys = licenseSolution.getJSONArray("licenseKeyGroupUUID");
447 List<String> licenseKeysList = jsonUtils.StringArrayToList(licenseKeys);
448 license.setLicenseKeyGroupUuids(licenseKeysList);
450 vnf.setLicense(license);
457 * Processes a placement solution list then correlates and sets each placement solution to its corresponding
461 private void processPlacementSolution(ServiceInstance serviceInstance, JSONArray placements, int i) {
462 List<VpnBondingLink> links = serviceInstance.getVpnBondingLinks();
463 List<AllottedResource> allottes = serviceInstance.getAllottedResources();
464 List<GenericVnf> vnfs = serviceInstance.getVnfs();
466 logger.debug("Processing placement solution " + i + 1);
467 for (int p = 0; p < placements.length(); p++) {
468 JSONObject placement = placements.getJSONObject(p);
469 SolutionInfo solutionInfo = new SolutionInfo();
470 solutionInfo.setSolutionId(i + 1);
472 for (VpnBondingLink vbl : links) {
473 List<ServiceProxy> proxies = vbl.getServiceProxies();
474 for (ServiceProxy sp : proxies) {
475 if (placement.getString(SERVICE_RESOURCE_ID).equals(sp.getId())) {
478 VpnBondingLink vblNew = (VpnBondingLink) SerializationUtils.clone(vbl);
479 vblNew.setVpnBondingLinkId(UUID.randomUUID().toString());
482 links.get(links.size() - 1).getServiceProxy(sp.getId())
483 .setServiceInstance(setSolution(solutionInfo, placement));
485 sp.setServiceInstance(setSolution(solutionInfo, placement));
491 for (AllottedResource ar : allottes) {
492 if (placement.getString(SERVICE_RESOURCE_ID).equals(ar.getId())) {
493 ar.setParentServiceInstance(setSolution(solutionInfo, placement));
497 for (GenericVnf vnf : vnfs) {
498 if (placement.getString(SERVICE_RESOURCE_ID).equals(vnf.getVnfId())) {
499 ServiceInstance si = setSolution(solutionInfo, placement);
500 serviceInstance.setSolutionInfo(si.getSolutionInfo());
501 serviceInstance.getVnfs().add(si.getVnfs().get(0));
511 * Creates and sets necessary pojos with placement solution data for a given demand
514 private ServiceInstance setSolution(SolutionInfo solutionInfo, JSONObject placement) {
515 logger.debug("Mapping placement solution");
516 String invalidMessage = "Sniro Managers Response contains invalid: ";
518 JSONObject solution = placement.getJSONObject("solution");
519 String identifierType = solution.getString(IDENTIFIER_TYPE);
520 List<String> identifiersList = jsonUtils.StringArrayToList(solution.getJSONArray("identifiers").toString());
521 String identifierValue = identifiersList.get(0);
523 JSONArray assignments = placement.getJSONArray("assignmentInfo");
524 Map<String, String> assignmentsMap = jsonUtils.entryArrayToMap(assignments.toString(), "key", "value");
525 solutionInfo.setRehome(Boolean.parseBoolean(assignmentsMap.get("isRehome")));
527 ServiceInstance si = new ServiceInstance();
528 CloudRegion cloud = setCloud(assignmentsMap);
529 if (identifierType.equals(CandidateType.SERVICE_INSTANCE_ID.toString())) {
530 solutionInfo.setHomed(true);
531 si.setServiceInstanceId(identifierValue);
532 si.setOrchestrationStatus(OrchestrationStatus.CREATED);
533 cloud.setLcpCloudRegionId(assignmentsMap.get("cloudRegionId"));
534 if (assignmentsMap.containsKey("vnfHostName") && !assignmentsMap.get("vnfHostName").isEmpty()) {
535 logger.debug("Resources has been homed to a vnf");
536 GenericVnf vnf = setVnf(assignmentsMap);
537 vnf.setCloudRegion(cloud);
538 si.getVnfs().add(vnf);
540 } else if (assignmentsMap.containsKey("primaryPnfName")) {
541 logger.debug("Resources has been homed to a pnf");
542 Pnf priPnf = setPnf(assignmentsMap, "primary");
543 priPnf.setCloudRegion(cloud);
544 si.getPnfs().add(priPnf);
545 if (assignmentsMap.containsKey("secondaryPnfName")) {
546 Pnf secPnf = setPnf(assignmentsMap, "secondary");
547 secPnf.setCloudRegion(cloud);
548 si.getPnfs().add(secPnf);
551 } else if (identifierType.equals(CandidateType.CLOUD_REGION_ID.toString())) {
552 logger.debug("Resources has been homed to a cloud region");
553 cloud.setLcpCloudRegionId(identifierValue);
554 solutionInfo.setHomed(false);
555 solutionInfo.setTargetedCloudRegion(cloud);
556 si.setOrchestrationStatus(OrchestrationStatus.PRECREATED);
558 logger.debug(invalidMessage + IDENTIFIER_TYPE);
559 throw new BpmnError(UNPROCESSABLE, invalidMessage + IDENTIFIER_TYPE);
561 si.setSolutionInfo(solutionInfo);
566 * Sets the cloud data to a cloud region object
569 private CloudRegion setCloud(Map<String, String> assignmentsMap) {
570 CloudRegion cloud = new CloudRegion();
571 cloud.setCloudOwner(assignmentsMap.get("cloudOwner"));
572 cloud.setCloudRegionVersion(assignmentsMap.get("aicVersion"));
573 cloud.setComplex(assignmentsMap.get("aicClli"));
578 * Sets the vnf data to a generic vnf object
581 private GenericVnf setVnf(Map<String, String> assignmentsMap) {
582 GenericVnf vnf = new GenericVnf();
583 vnf.setOrchestrationStatus(OrchestrationStatus.CREATED);
584 vnf.setVnfName(assignmentsMap.get("vnfHostName"));
585 vnf.setVnfId(assignmentsMap.get("vnfId"));
590 * Sets the pnf data to a pnf object
593 private Pnf setPnf(Map<String, String> assignmentsMap, String role) {
596 pnf.setOrchestrationStatus(OrchestrationStatus.CREATED);
597 pnf.setPnfName(assignmentsMap.get(role + "PnfName"));