add new action ConfigScaleIn
[appc.git] / appc-inbound / appc-artifact-handler / provider / src / main / java / org / onap / appc / artifact / handler / node / ArtifactHandlerNode.java
1 /*-
2  * ============LICENSE_START=======================================================
3  * ONAP : APPC
4  * ================================================================================
5  * Copyright (C) 2017-2019 AT&T Intellectual Property. All rights reserved.
6  * ================================================================================
7  * Copyright (C) 2017 Amdocs
8  * ================================================================================
9  * Modifications Copyright (C) 2019 Ericsson
10  * =============================================================================
11  * Licensed under the Apache License, Version 2.0 (the "License");
12  * you may not use this file except in compliance with the License.
13  * You may obtain a copy of the License at
14  *
15  *      http://www.apache.org/licenses/LICENSE-2.0
16  *
17  * Unless required by applicable law or agreed to in writing, software
18  * distributed under the License is distributed on an "AS IS" BASIS,
19  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
20  * See the License for the specific language governing permissions and
21  * limitations under the License.
22  *
23  * ============LICENSE_END=========================================================
24  */
25
26 package org.onap.appc.artifact.handler.node;
27
28 import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.ACTION;
29 import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.ACTION_LEVEL;
30 import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.ACTION_LEVEL_VF_MODULE;
31 import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.ACTION_LEVEL_VM;
32 import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.ACTION_LEVEL_VNF;
33 import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.ACTION_LEVEL_VNFC;
34 import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.ARTIFACT_CONTENTS;
35 import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.ARTIFACT_DESRIPTION;
36 import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.ARTIFACT_NAME;
37 import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.ARTIFACT_NAME_CAPABILITY;
38 import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.ARTIFACT_NAME_REFERENCE;
39 import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.ARTIFACT_TYPE;
40 import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.ARTIFACT_UUID;
41 import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.ARTIFACT_VERSION;
42 import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.CAPABILITY;
43 import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.DB_CONFIG_ACTION_DG;
44 import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.DB_DEVICE_AUTHENTICATION;
45 import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.DB_DEVICE_INTERFACE_PROTOCOL;
46 import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.DB_DOWNLOAD_DG_REFERENCE;
47 import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.DB_SDC_REFERENCE;
48 import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.DEVICE_PROTOCOL;
49 import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.DISTRIBUTION_ID;
50 import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.DOCUMENT_PARAMETERS;
51 import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.DOWNLOAD_DG_REFERENCE;
52 import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.FILE_CATEGORY;
53 import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.GROUP_NOTATION_TYPE;
54 import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.GROUP_NOTATION_VALUE;
55 import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.IPADDRESS_V4_OAM_VIP;
56 import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.PARAMETER_YANG;
57 import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.PD;
58 import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.PORT_NUMBER;
59 import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.REFERENCE;
60 import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.REQUEST_ID;
61 import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.REQUEST_INFORMATION;
62 import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.RESOURCE_INSTANCE_NAME;
63 import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.RESOURCE_NAME;
64 import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.RESOURCE_TYPE;
65 import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.RESOURCE_UUID;
66 import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.RESOURCE_VERSION;
67 import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.SERVICE_DESCRIPTION;
68 import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.SERVICE_NAME;
69 import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.SERVICE_UUID;
70 import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.TEMPLATE;
71 import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.TEMPLATE_ID;
72 import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.TOSCA_MODEL;
73 import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.USER_NAME;
74 import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.VM;
75 import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.VM_INSTANCE;
76 import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.VNFC;
77 import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.VNFC_FUNCTION_CODE;
78 import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.VNFC_FUNCTION_CODE_LIST;
79 import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.VNFC_INSTANCE;
80 import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.VNFC_TYPE;
81 import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.VNFC_TYPE_LIST;
82 import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.VNF_TYPE;
83 import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.URL;
84 import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.OPENSTACK;
85 import static org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants.ANSIBLE;
86 import com.att.eelf.configuration.EELFLogger;
87 import com.att.eelf.configuration.EELFManager;
88 import java.io.ByteArrayOutputStream;
89 import java.io.OutputStream;
90 import java.sql.SQLException;
91 import java.util.Map;
92 import java.util.function.Function;
93 import org.apache.commons.configuration.ConfigurationException;
94 import org.apache.commons.lang.StringUtils;
95 import org.json.JSONArray;
96 import org.json.JSONException;
97 import org.json.JSONObject;
98 import org.onap.appc.artifact.handler.dbservices.DBException;
99 import org.onap.appc.artifact.handler.dbservices.DBService;
100 import org.onap.appc.artifact.handler.utils.ArtifactHandlerProviderUtil;
101 import org.onap.appc.yang.YANGGenerator;
102 import org.onap.appc.yang.impl.YANGGeneratorFactory;
103 import org.onap.ccsdk.sli.core.sli.SvcLogicContext;
104 import org.onap.ccsdk.sli.core.sli.SvcLogicException;
105 import org.onap.ccsdk.sli.core.sli.SvcLogicJavaPlugin;
106 import org.onap.sdnc.config.params.transformer.tosca.ArtifactProcessorImpl;
107 import org.onap.sdnc.config.params.transformer.tosca.exceptions.ArtifactProcessorException;
108 import java.util.ArrayList;
109 import java.util.HashMap;
110 import java.util.List;
111
112 public class ArtifactHandlerNode implements SvcLogicJavaPlugin {
113
114     private static final EELFLogger log = EELFManager.getInstance().getLogger(ArtifactHandlerNode.class);
115     private static final String TOSCA_PARAM = "Tosca";
116     private static final String YANG_PARAM = "Yang";
117     private static final String ARTIFACT_LIST_PARAM = "artifact-list";
118     private static final String CONFIGURE_PARAM = "Configure";
119     private static final String CONFIG_SCALE_OUT_PARAM = "ConfigScaleOut";
120     private static final String CONFIG_MODIFY_PARAM = "ConfigModify";
121     private static final String GET_CONFIG = "GetConfig";
122     private static final String POST_EVACUATE = "PostEvacuate";
123     private static final String PRE_EVACUATE = "PreEvacuate";
124     private static final String POST_MIGRATE = "PostMigrate";
125     private static final String PRE_MIGRATE = "PreMigrate";
126     private static final String PRE_REBUILD = "PreRebuild";
127     private static final String POST_REBUILD = "PostRebuild";
128     private static final String STOP_TRAFFIC = "StopTraffic";
129     private static final String CONFIG_SCALE_IN_PARAM = "ConfigScaleIn";
130     
131     public void processArtifact(Map<String, String> inParams, SvcLogicContext ctx) throws ArtifactProcessorException {
132
133         if (inParams == null || inParams.isEmpty()) {
134             return;
135         }
136         String postData = inParams.get("postData");
137         if (StringUtils.isBlank(postData)) {
138             return;
139         }
140         try {
141             log.info("Received request for process Artifact with params: " + inParams.toString());
142             JSONObject input = new JSONObject(postData).getJSONObject("input");
143             storeUpdateSdcArtifacts(input);
144         } catch (Exception e) {
145             log.error("Error when processing artifact", e);
146             throw new ArtifactProcessorException("Error occurred while processing artifact, " + e.getMessage(), e);
147         }
148     }
149
150     private boolean storeUpdateSdcArtifacts(JSONObject postDataJson) throws ArtifactHandlerInternalException {
151         log.info("Starting processing of SDC Artifacts into Handler with Data: " + postDataJson.toString());
152         try {
153             JSONObject requestInfo = (JSONObject) postDataJson.get(REQUEST_INFORMATION);
154             JSONObject documentInfo = (JSONObject) postDataJson.get(DOCUMENT_PARAMETERS);
155             String artifactName = documentInfo.getString(ARTIFACT_NAME);
156
157             if (StringUtils.isBlank(artifactName)) {
158                 throw new ArtifactHandlerInternalException("Missing Artifact Name");
159             }
160
161             if (artifactName.toLowerCase().startsWith(ANSIBLE)) {
162                 validateAnsibleAdminArtifact(documentInfo);
163                 log.info("validateAnsibleAdminArtifact sucessfully done");
164             }
165
166             updateStoreArtifacts(requestInfo, documentInfo);
167
168             if (artifactName.toLowerCase().startsWith(REFERENCE)) {
169                 return storeReferenceData(requestInfo, documentInfo);
170             } else if (artifactName.toLowerCase().startsWith(PD)) {
171                 return createDataForPD(requestInfo, documentInfo);
172             }
173
174         } catch (Exception e) {
175             log.error("Error while processing request with id: "
176                     + ((JSONObject) postDataJson.get(REQUEST_INFORMATION)).getString(REQUEST_ID), e);
177             throw new ArtifactHandlerInternalException("Error while processing request with id: "
178                     + ((JSONObject) postDataJson.get(REQUEST_INFORMATION)).getString(REQUEST_ID)
179                     + ", Exception Message: " + e.getMessage(), e);
180         }
181         return false;
182     }
183
184     public void validateAnsibleAdminArtifact(JSONObject documentInfo) throws ArtifactHandlerInternalException {
185
186         String fn = "ArtifactHandlerNode.validateAnsibleAdminArtifact";
187         String artifactName = documentInfo.getString(ARTIFACT_NAME);
188         log.info(fn + ": Received Admin File Name: " + artifactName
189                 + ", ArtifactContent: " + documentInfo.getString(ARTIFACT_CONTENTS));
190         try {
191             ArtifactHandlerProviderUtil ahpUtil = new ArtifactHandlerProviderUtil();
192             String contentString = ahpUtil.escapeSql(documentInfo.getString(ARTIFACT_CONTENTS));
193             JSONObject artifact = new JSONObject(contentString);
194             JSONArray fqdnList = artifact.getJSONArray("fqdn-list");
195             Map<String, List<String>> artifactMap = new HashMap<>();
196
197             for (int i = 0; i < fqdnList.length(); i++) {
198                 JSONObject fqdn = fqdnList.getJSONObject(i);
199                 List<String> valuesforFQDN = populateValueForFQDN(fqdn);
200                 artifactMap.put(fqdn.getString("vnf-management-server-fqdn"), valuesforFQDN);
201             }
202
203             validateKeyValue(artifactMap);
204
205         } catch (JSONException je) {
206             log.error(fn + " ansible admin artifact content may not be a valid JSON, error message: "
207                     + je.getMessage());
208             throw new ArtifactHandlerInternalException(
209                     "JSON Exception:ansible admin artifact content may not be a valid JSON, error message: "
210                     + je.getMessage(),
211                     je);
212         } catch (ArtifactHandlerInternalException ae) {
213             throw ae;
214         } catch (Exception e) {
215             log.error(fn + "Error while creating Admin data records", e);
216             throw new ArtifactHandlerInternalException(
217                     "Error while processing ansible admin artifact: " + e.getMessage(), e);
218         }
219
220     }
221
222     private void validateKeyValue(Map<String, List<String>> artifactMap) throws ArtifactHandlerInternalException {
223         for (String fqdn1 : artifactMap.keySet()) {
224
225             for (String value : artifactMap.get(fqdn1)) {
226
227                 for (String fqdn2 : artifactMap.keySet()) {
228
229                     if (!fqdn1.equals(fqdn2) && artifactMap.get(fqdn2).contains(value)) {
230                         String msg = "Validation Failure: Ansible Admin artifact has CloudOwner-RegionId-Tenant: "
231                                 + value + " mapped to multiple FQDN: " + fqdn1 + " & " + fqdn2;
232                         log.info(msg);
233                         throw new ArtifactHandlerInternalException(msg);
234                     }
235
236                 }
237             }
238
239         }
240
241     }
242
243     private List<String> populateValueForFQDN(JSONObject fqdn) {
244         log.info("Inside populateValueForFQDN: " + fqdn.getString("vnf-management-server-fqdn"));
245         List<String> valuesforFQDN = new ArrayList<>();
246         JSONArray cloudJsonList = fqdn.getJSONArray("cloud-owner-list");
247         for (int j = 0; j < cloudJsonList.length(); j++) {
248             String cloudOwner = cloudJsonList.getJSONObject(j).getString("cloud-owner");
249             JSONArray regionList = cloudJsonList.getJSONObject(j).getJSONArray("region-id-list");
250
251             for (int i = 0; i < regionList.length(); i++) {
252
253                 String region = regionList.getJSONObject(i).getString("region-id");
254
255                 JSONArray tenantList = regionList.getJSONObject(i).getJSONArray("tenant-id-list");
256
257                 for (int k = 0; k < tenantList.length(); k++) {
258                     String tenant = tenantList.getString(k);
259                     String valueforFQDN = cloudOwner + "-" + region + "-" + tenant;
260                     log.info("valueforFQDN for i " + i + " & j " + j + ": " + valueforFQDN);
261                     valuesforFQDN.add(valueforFQDN);
262                 }
263             }
264         }
265
266         return valuesforFQDN;
267     }
268
269     private boolean createDataForPD(JSONObject requestInfo, JSONObject documentInfo)
270             throws ArtifactHandlerInternalException {
271
272         String fn = "ArtifactHandlerNode.createReferenceDataForPD";
273         String artifactName = documentInfo.getString(ARTIFACT_NAME);
274         log.info(fn + " Received PD File Name: " + artifactName + " and suffix length " + PD.length());
275         try {
276
277             String suffix = artifactName.substring(PD.length());
278             createArtifactRecords(requestInfo, documentInfo, suffix);
279         } catch (Exception e) {
280             log.error("Error while creating PD data records", e);
281             throw new ArtifactHandlerInternalException("Error while creating PD data records", e);
282         }
283         return true;
284     }
285
286     private void createArtifactRecords(JSONObject requestInfo, JSONObject documentInfo, String suffix)
287             throws ArtifactHandlerInternalException {
288
289         try {
290             log.info("Creating Tosca Records and storing into SDC Artifacts");
291             String[] docs = { TOSCA_PARAM, YANG_PARAM };
292             ArtifactHandlerProviderUtil ahpUtil = new ArtifactHandlerProviderUtil();
293             String pdFileContents = documentInfo.getString(ARTIFACT_CONTENTS);
294
295             // Tosca generation
296             OutputStream toscaStream = new ByteArrayOutputStream();
297             String toscaContents;
298             ArtifactProcessorImpl toscaGenerator = getArtifactProcessorImpl();
299             toscaGenerator.generateArtifact(pdFileContents, toscaStream);
300             toscaContents = toscaStream.toString();
301             log.info("Generated Tosca File: " + toscaContents);
302
303             String yangContents = "YANG generation is in Progress";
304             String yangName = null;
305
306             for (String doc : docs) {
307                 documentInfo.put(ARTIFACT_TYPE, doc.concat("Type"));
308                 documentInfo.put(ARTIFACT_DESRIPTION, doc.concat("Model"));
309                 if (doc.equals(TOSCA_PARAM)) {
310                     documentInfo.put(ARTIFACT_CONTENTS, ahpUtil.escapeSql(toscaContents));
311                 } else if (doc.equals(YANG_PARAM)) {
312                     documentInfo.put(ARTIFACT_CONTENTS, ahpUtil.escapeSql(yangContents));
313                 }
314                 documentInfo.put(ARTIFACT_NAME, doc.concat(suffix));
315                 yangName = doc.concat(suffix);
316                 updateStoreArtifacts(requestInfo, documentInfo);
317             }
318
319             String artifactId = getArtifactID(yangName);
320             OutputStream yangStream = new ByteArrayOutputStream();
321             YANGGenerator yangGenerator = YANGGeneratorFactory.getYANGGenerator();
322             yangGenerator.generateYANG(artifactId, toscaContents, yangStream);
323             yangContents = yangStream.toString();
324
325             if (yangContents != null) {
326                 updateYangContents(artifactId, ahpUtil.escapeSql(yangContents));
327             }
328         } catch (Exception e) {
329             log.error("Error while creating artifact records", e);
330             throw new ArtifactHandlerInternalException("Error while creating artifact records", e);
331         }
332
333     }
334
335     private void updateYangContents(String artifactId, String yangContents) throws SvcLogicException {
336         SvcLogicContext context = new SvcLogicContext();
337         DBService dbservice = DBService.initialise();
338         dbservice.updateYangContents(context, artifactId, yangContents);
339     }
340
341     private String getArtifactID(String yangName) throws SvcLogicException {
342         SvcLogicContext context = new SvcLogicContext();
343         DBService dbservice = DBService.initialise();
344         return dbservice.getArtifactID(context, yangName);
345     }
346
347     protected boolean updateStoreArtifacts(JSONObject requestInfo, JSONObject documentInfo)
348             throws SvcLogicException, SQLException {
349         log.info("updateStoreArtifacts started storing of SDC Artifacts");
350
351         SvcLogicContext context = new SvcLogicContext();
352         DBService dbservice = DBService.initialise();
353         ArtifactHandlerProviderUtil ahpUtil = new ArtifactHandlerProviderUtil();
354         int intversion = 0;
355         context.setAttribute("artifact_name", documentInfo.getString(ARTIFACT_NAME));
356         String internalVersion =
357                 dbservice.getInternalVersionNumber(context, documentInfo.getString(ARTIFACT_NAME), null);
358         log.info("Internal Version number received from Database: " + internalVersion);
359         if (internalVersion != null) {
360             intversion = Integer.parseInt(internalVersion);
361             intversion++;
362         }
363         setAttribute(context, documentInfo::getString, SERVICE_UUID);
364         setAttribute(context, documentInfo::getString, DISTRIBUTION_ID);
365         setAttribute(context, documentInfo::getString, SERVICE_NAME);
366         setAttribute(context, documentInfo::getString, SERVICE_DESCRIPTION);
367         setAttribute(context, documentInfo::getString, RESOURCE_UUID);
368         setAttribute(context, documentInfo::getString, RESOURCE_INSTANCE_NAME);
369         setAttribute(context, documentInfo::getString, RESOURCE_VERSION);
370         setAttribute(context, documentInfo::getString, RESOURCE_NAME);
371         setAttribute(context, documentInfo::getString, RESOURCE_TYPE);
372         setAttribute(context, documentInfo::getString, ARTIFACT_UUID);
373         setAttribute(context, documentInfo::getString, ARTIFACT_TYPE);
374         setAttribute(context, documentInfo::getString, ARTIFACT_VERSION);
375         setAttribute(context, documentInfo::getString, ARTIFACT_DESRIPTION);
376         setAttribute(context, documentInfo::getString, ARTIFACT_NAME);
377         setAttribute(context, s -> ahpUtil.escapeSql(documentInfo.getString(s)), ARTIFACT_CONTENTS);
378
379         dbservice.saveArtifacts(context, intversion);
380         return true;
381     }
382
383     public boolean storeReferenceData(JSONObject requestInfo, JSONObject documentInfo)
384             throws ArtifactHandlerInternalException {
385         log.info("Started storing of SDC Artifacts into Handler");
386         try {
387             DBService dbservice = DBService.initialise();
388             ArtifactHandlerProviderUtil ahpUtil = new ArtifactHandlerProviderUtil();
389             String contentString = ahpUtil.escapeSql(documentInfo.getString(ARTIFACT_CONTENTS));
390             String artifactName = ahpUtil.escapeSql(documentInfo.getString(ARTIFACT_NAME));
391             String capabilityArtifactName =
392                     StringUtils.replace(artifactName, ARTIFACT_NAME_REFERENCE, ARTIFACT_NAME_CAPABILITY);
393             JSONObject capabilities = new JSONObject();
394             JSONArray vnfActionList = new JSONArray();
395             JSONArray vfModuleActionList = new JSONArray();
396             JSONArray vnfcActionList = new JSONArray();
397             JSONArray vmActionVnfcFunctionCodesList = new JSONArray();
398             String vnfType = null;
399             JSONObject contentObject = new JSONObject(contentString);
400             JSONArray contentArray = contentObject.getJSONArray("reference_data");
401             boolean storeCapabilityArtifact = true;
402
403             for (int a = 0; a < contentArray.length(); a++) {
404                 JSONObject content = contentArray.getJSONObject(a);
405                 log.info("contentString = " + content.toString());
406                 JSONObject scope = content.getJSONObject("scope");
407                 log.info("scope: " + scope);
408                 SvcLogicContext context = new SvcLogicContext();
409                 vnfType = scope.getString(VNF_TYPE);
410                 setAttribute(context, scope::getString, VNF_TYPE);
411                 setAttribute(context, content::getString, ACTION);
412                 String actionLevel = content.getString(ACTION_LEVEL);
413                 setAttribute(context, content::getString, ACTION_LEVEL);
414                 setAttribute(context, documentInfo::getString, ARTIFACT_TYPE);
415                 processActionLists(content, actionLevel, vnfcActionList, vfModuleActionList, vnfActionList,
416                         vmActionVnfcFunctionCodesList);
417                 JSONArray vnfcTypeList = setVnfcTypeInformation(scope, context);
418                 storeCapabilityArtifact = isCapabilityArtifactNeeded(context);
419
420                 if (content.has(DEVICE_PROTOCOL)) {
421                     setAttribute(context, content::getString, DEVICE_PROTOCOL);
422                 }
423                 if (content.has(USER_NAME)) {
424                     setAttribute(context, content::getString, USER_NAME);
425                 }
426                 if (content.has(PORT_NUMBER)) {
427                     setAttribute(context, content::getString, PORT_NUMBER);
428                 }
429                 if (content.has(URL)) {
430                     setAttribute(context, content::getString, URL);
431                 }
432                 processArtifactList(content, dbservice, context, vnfcTypeList);
433                 processConfigTypeActions(content, dbservice, context);
434                 dbservice.processDeviceAuthentication(context,
435                         dbservice.isArtifactUpdateRequired(context, DB_DEVICE_AUTHENTICATION));
436
437                 String actionProtocol = tryGetProtocol(content);
438                 if (!StringUtils.equalsIgnoreCase(actionProtocol, OPENSTACK)) {
439                     populateProtocolReference(dbservice, content);
440                 }
441                 context.setAttribute(VNFC_TYPE, null);
442                 if (content.has(VM) && content.get(VM) instanceof JSONArray) {
443                     processVmList(content, context, dbservice);
444                 }
445             }
446             if (storeCapabilityArtifact) {
447                 capabilities.put("vnf", vnfActionList);
448                 capabilities.put("vf-module", vfModuleActionList);
449                 capabilities.put("vnfc", vnfcActionList);
450                 capabilities.put("vm", vmActionVnfcFunctionCodesList);
451                 processAndStoreCapabilitiesArtifact(dbservice, documentInfo, capabilities, capabilityArtifactName,
452                         vnfType);
453             }
454
455         } catch (Exception e) {
456
457             log.error("Error while storing reference data", e);
458             throw new ArtifactHandlerInternalException("Error while storing reference data", e);
459         }
460
461         return true;
462     }
463
464     public boolean isCapabilityArtifactNeeded(SvcLogicContext context) {
465         String vnfcType = context.getAttribute(VNFC_TYPE);
466         if (StringUtils.isNotBlank(vnfcType)) {
467             log.info("No capability Artifact for this reference data as it is at VNFC level!!");
468             return false;
469         } else {
470             return true;
471         }
472     }
473
474     public JSONArray setVnfcTypeInformation(JSONObject scope, SvcLogicContext context) {
475         JSONArray vnfcTypeList = null;
476         if (scope.has(VNFC_TYPE) && !scope.isNull(VNFC_TYPE)) {
477             String vnfcTypeScope = scope.getString(VNFC_TYPE);
478             if (StringUtils.isNotBlank(vnfcTypeScope)) {
479                 setAttribute(context, scope::getString, VNFC_TYPE);
480                 log.info("VNFC type has been set for this reference artifact!! " + vnfcTypeScope);
481             } else {
482                 context.setAttribute(VNFC_TYPE, null);
483             }
484         } else {
485             context.setAttribute(VNFC_TYPE, null);
486         }
487         if (scope.has(VNFC_TYPE_LIST) && !scope.isNull(VNFC_TYPE_LIST)
488                 && scope.get(VNFC_TYPE_LIST) instanceof JSONArray) {
489             vnfcTypeList = scope.getJSONArray(VNFC_TYPE_LIST);
490             log.info("VNFC TYPE LIST found for this artifact!! " + vnfcTypeList.toString());
491         }
492         return vnfcTypeList;
493     }
494
495     public void processActionLists(JSONObject content, String actionLevel, JSONArray vnfcActionList,
496             JSONArray vfModuleActionList, JSONArray vnfActionList, JSONArray vmActionVnfcFunctionCodesList) {
497         if (validateActionLevel(actionLevel, ACTION_LEVEL_VNFC)) {
498             vnfcActionList.put(content.getString(ACTION));
499         }
500         if (validateActionLevel(actionLevel, ACTION_LEVEL_VF_MODULE)) {
501             vfModuleActionList.put(content.getString(ACTION));
502         }
503         if (validateActionLevel(actionLevel, ACTION_LEVEL_VNF)) {
504             vnfActionList.put(content.getString(ACTION));
505         }
506         if (validateActionLevel(actionLevel, ACTION_LEVEL_VM)) {
507             if (content.has(VNFC_FUNCTION_CODE_LIST)
508                     && !content.isNull(VNFC_FUNCTION_CODE_LIST)
509                     && content.get(VNFC_FUNCTION_CODE_LIST) instanceof JSONArray) {
510                 log.info("Found vnfc-function-code-list!!");
511                 JSONArray vnfcList = content.getJSONArray(VNFC_FUNCTION_CODE_LIST);
512                 JSONObject obj = new JSONObject();
513                 obj.put(content.getString(ACTION), vnfcList);
514                 vmActionVnfcFunctionCodesList.put(obj);
515             } else {
516                 log.info("Not getting JSONArray for VNFC FUNCTION CODES");
517             }
518         }
519
520     }
521
522     private boolean validateActionLevel(String actionLevel, String actionLevelVnfc) {
523         return null != actionLevel && actionLevel.equalsIgnoreCase(actionLevelVnfc);
524     }
525
526     public void processArtifactList(JSONObject content, DBService dbservice, SvcLogicContext context,
527             JSONArray vnfcTypeList)
528             throws ArtifactHandlerInternalException {
529
530         try {
531             if (content.has(ARTIFACT_LIST_PARAM) && content.get(ARTIFACT_LIST_PARAM) instanceof JSONArray) {
532                 JSONArray artifactLists = (JSONArray) content.get(ARTIFACT_LIST_PARAM);
533                 JSONArray templateIdList = null;
534                 if (content.has("template-id-list") && null != content.get("template-id-list")
535                         && content.get("template-id-list") instanceof JSONArray) {
536                     templateIdList = content.getJSONArray("template-id-list");
537                 }
538                 doProcessArtifactList(dbservice, context, artifactLists, templateIdList, vnfcTypeList);
539             }
540         } catch (Exception e) {
541             log.error("An error occurred when processing artifact list", e);
542             throw new ArtifactHandlerInternalException(e);
543         }
544     }
545
546     private void doProcessArtifactList(DBService dbservice, SvcLogicContext context, JSONArray artifactLists,
547             JSONArray templateIdList, JSONArray vnfcTypeList)
548             throws SvcLogicException, SQLException, ConfigurationException, DBException {
549         boolean pdFile = false;
550         int modelInd = 0;
551         int vnfcRefInd = 0;
552
553         for (int i = 0; i < artifactLists.length(); i++) {
554             String suffix = null;
555             String model = null;
556             JSONObject artifact = (JSONObject) artifactLists.get(i);
557             log.info("artifact is " + artifact);
558
559             // Get Model details
560             if (null != templateIdList && i > 0 && i % 2 == 0) { // Should this be changed to 3
561                 modelInd++; // to account for 3 artifacts
562             }
563             if (null != vnfcTypeList && i > 0 && i % 3 == 0) {
564                 // TDP 517180 - CD tool has made changes to send 3 artifacts instead of 2
565                 vnfcRefInd++;
566             }
567             setAttribute(context, artifact::getString, ARTIFACT_NAME);
568             context.setAttribute(FILE_CATEGORY, artifact.getString(ARTIFACT_TYPE));
569
570             if (artifact.getString(ARTIFACT_NAME) != null
571                     && artifact.getString(ARTIFACT_NAME).toLowerCase().startsWith(PD)) {
572
573                 suffix = artifact.getString(ARTIFACT_NAME).substring(PD.length());
574                 pdFile = true;
575             }
576             log.info("Artifact-type = " + context.getAttribute(FILE_CATEGORY));
577             log.info("Artifact-name = " + context.getAttribute(ARTIFACT_NAME));
578
579             if (null != templateIdList && modelInd < templateIdList.length()) {
580                 model = templateIdList.getString(modelInd);
581                 log.info("Model is ::: " + model + ", modelInd = " + modelInd);
582             }
583             if (null != vnfcTypeList && vnfcRefInd < vnfcTypeList.length()) {
584                 String vnfcType = vnfcTypeList.getString(vnfcRefInd);
585                 if (StringUtils.isNotBlank(vnfcType)) {
586                     context.setAttribute(VNFC_TYPE, vnfcType);
587                 }
588                 log.info("Setting vnfc type from vnfc-type-list :: " + vnfcType);
589             }
590             if (StringUtils.isNotBlank(model)) {
591                 dbservice.processSdcReferences(context,
592                         dbservice.isArtifactUpdateRequired(context, DB_SDC_REFERENCE, model),
593                         model);
594             } else {
595                 dbservice.processSdcReferences(context, dbservice.isArtifactUpdateRequired(context, DB_SDC_REFERENCE));
596             }
597
598             cleanArtifactInstanceData(context);
599             // Moving this into the for loop to account for mulitple artifact sets with pds
600             if (pdFile) {
601                 log.info("Sending information related to pdfile Artifact");
602                 tryUpdateContext(dbservice, context, pdFile, suffix, model);
603                 pdFile = false; // set to false after processing yang and Tosca
604             }
605         }
606     }
607
608     private void tryUpdateContext(DBService dbservice, SvcLogicContext context, boolean pdFile, String suffix,
609             String model)
610             throws SvcLogicException, SQLException, ConfigurationException, DBException {
611         if (pdFile) {
612             context.setAttribute(ARTIFACT_NAME, "Tosca".concat(suffix));
613             context.setAttribute(FILE_CATEGORY, TOSCA_MODEL);
614             dbservice.processSdcReferences(context,
615                     dbservice.isArtifactUpdateRequired(context, DB_SDC_REFERENCE, model), model);
616             context.setAttribute(ARTIFACT_NAME, "Yang".concat(suffix));
617             context.setAttribute(FILE_CATEGORY, PARAMETER_YANG);
618             dbservice.processSdcReferences(context,
619                     dbservice.isArtifactUpdateRequired(context, DB_SDC_REFERENCE, model), model);
620         }
621     }
622
623     public void processConfigTypeActions(JSONObject content, DBService dbservice, SvcLogicContext context)
624             throws ArtifactHandlerInternalException {
625
626         try {
627             if (contentsActionEquals(content, CONFIGURE_PARAM)
628                     || contentsActionEquals(content, CONFIG_MODIFY_PARAM)
629                     || contentsActionEquals(content, CONFIG_SCALE_OUT_PARAM)
630                     || contentsActionEquals(content, CONFIG_SCALE_IN_PARAM)
631                     || contentsActionEquals(content, GET_CONFIG)
632                     || contentsActionEquals(content, POST_EVACUATE)
633                     || contentsActionEquals(content, PRE_EVACUATE)
634                     || contentsActionEquals(content, POST_MIGRATE)
635                     || contentsActionEquals(content, PRE_MIGRATE)
636                     || contentsActionEquals(content, POST_REBUILD)
637                     || contentsActionEquals(content, PRE_REBUILD)
638                     || contentsActionEquals(content, STOP_TRAFFIC)
639                     ) {
640
641                 if (content.has(DOWNLOAD_DG_REFERENCE) && content.getString(DOWNLOAD_DG_REFERENCE).length() > 0) {
642
643                     setAttribute(context, content::getString, DOWNLOAD_DG_REFERENCE);
644                     dbservice.processDownloadDgReference(context,
645                             dbservice.isArtifactUpdateRequired(context, DB_DOWNLOAD_DG_REFERENCE));
646                 }
647                 if (StringUtils.isBlank(context.getAttribute(DOWNLOAD_DG_REFERENCE))) {
648                     context.setAttribute(DOWNLOAD_DG_REFERENCE, dbservice.getDownLoadDGReference(context));
649                 }
650                 dbservice.processConfigActionDg(context,
651                         dbservice.isArtifactUpdateRequired(context, DB_CONFIG_ACTION_DG));
652
653                 tryProcessInterfaceProtocol(content, dbservice, context);
654             }
655         } catch (Exception e) {
656             log.error("An error occurred when processing config type actions", e);
657             throw new ArtifactHandlerInternalException(e);
658         }
659     }
660
661     private void tryProcessInterfaceProtocol(JSONObject content, DBService dbservice, SvcLogicContext context)
662             throws SvcLogicException, SQLException, ConfigurationException, DBException {
663
664         if (contentsActionEquals(content, CONFIGURE_PARAM) || contentsActionEquals(content, CONFIG_SCALE_OUT_PARAM)
665                 || contentsActionEquals(content, CONFIG_SCALE_IN_PARAM)) {
666             boolean isUpdateRequired = dbservice.isArtifactUpdateRequired(context, DB_DEVICE_INTERFACE_PROTOCOL);
667             if (contentsActionEquals(content, CONFIGURE_PARAM) || (contentsActionEquals(content, CONFIG_SCALE_OUT_PARAM)
668                     || contentsActionEquals(content, CONFIG_SCALE_IN_PARAM)
669                         && !isUpdateRequired)) {
670
671                 dbservice.processDeviceInterfaceProtocol(context, isUpdateRequired);
672             }
673         }
674     }
675
676     private boolean contentsActionEquals(JSONObject content, String action) {
677         return content.getString(ACTION).equals(action);
678     }
679
680     public void processVmList(JSONObject content, SvcLogicContext context, DBService dbservice)
681             throws SvcLogicException {
682         JSONArray vmList = (JSONArray) content.get(VM);
683         dbservice.cleanUpVnfcReferencesForVnf(context);
684         for (int i = 0; i < vmList.length(); i++) {
685             JSONObject vmInstance = (JSONObject) vmList.get(i);
686             setAttribute(context, s -> String.valueOf(vmInstance.getInt(s)), VM_INSTANCE);
687             log.info("VALUE = " + context.getAttribute(VM_INSTANCE));
688             String templateId = vmInstance.optString(TEMPLATE_ID);
689             trySetContext(context, vmInstance, templateId);
690             if (vmInstance.get(VNFC) instanceof JSONArray) {
691                 JSONArray vnfcInstanceList = (JSONArray) vmInstance.get(VNFC);
692                 for (int k = 0; k < vnfcInstanceList.length(); k++) {
693                     JSONObject vnfcInstance = (JSONObject) vnfcInstanceList.get(k);
694
695                     setAttribute(context, s -> String.valueOf(vnfcInstance.getInt(s)), VNFC_INSTANCE);
696                     setAttribute(context, vnfcInstance::getString, VNFC_TYPE);
697                     setAttribute(context, vnfcInstance::getString, VNFC_FUNCTION_CODE);
698                     resolveContext(context, vnfcInstance);
699                     tryProcessVnfcReference(content, context, dbservice);
700                     cleanVnfcInstance(context);
701                 }
702                 context.setAttribute(VM_INSTANCE, null);
703                 context.setAttribute(TEMPLATE_ID, null);
704             }
705         }
706     }
707
708     private void trySetContext(SvcLogicContext context, JSONObject vmInstance, String templateId) {
709         if (StringUtils.isNotBlank(templateId)) {
710             setAttribute(context, vmInstance::optString, TEMPLATE_ID);
711         }
712     }
713
714     private void tryProcessVnfcReference(JSONObject content, SvcLogicContext context, DBService dbservice)
715             throws SvcLogicException {
716         if (content.getString(ACTION).equals(CONFIGURE_PARAM)
717                 || content.getString(ACTION).equals(CONFIG_SCALE_OUT_PARAM)
718                 || content.getString(ACTION).equals(CONFIG_SCALE_IN_PARAM)) {
719
720             dbservice.processVnfcReference(context, false);
721         }
722     }
723
724     private void resolveContext(SvcLogicContext context, JSONObject vnfcInstance) {
725         if (vnfcInstance.has(IPADDRESS_V4_OAM_VIP)) {
726             setAttribute(context, vnfcInstance::getString, IPADDRESS_V4_OAM_VIP);
727         }
728         if (vnfcInstance.has(GROUP_NOTATION_TYPE)) {
729             setAttribute(context, vnfcInstance::getString, GROUP_NOTATION_TYPE);
730         }
731         if (vnfcInstance.has(GROUP_NOTATION_VALUE)) {
732             setAttribute(context, vnfcInstance::getString, GROUP_NOTATION_VALUE);
733         }
734     }
735
736     private void cleanArtifactInstanceData(SvcLogicContext context) {
737         context.setAttribute(ARTIFACT_NAME, null);
738         context.setAttribute(FILE_CATEGORY, null);
739     }
740
741     private void cleanVnfcInstance(SvcLogicContext context) {
742
743         context.setAttribute(VNFC_INSTANCE, null);
744         context.setAttribute(VNFC_TYPE, null);
745         context.setAttribute(VNFC_FUNCTION_CODE, null);
746         context.setAttribute(IPADDRESS_V4_OAM_VIP, null);
747         context.setAttribute(GROUP_NOTATION_TYPE, null);
748         context.setAttribute(GROUP_NOTATION_VALUE, null);
749
750     }
751
752     private void processAndStoreCapabilitiesArtifact(DBService dbService, JSONObject documentInfo,
753             JSONObject capabilities, String capabilityArtifactName, String vnfType)
754             throws ArtifactHandlerInternalException {
755
756         log.info("Begin-->processAndStoreCapabilitiesArtifact");
757
758         try {
759             JSONObject newCapabilitiesObject = new JSONObject();
760             newCapabilitiesObject.put("capabilities", capabilities);
761             SvcLogicContext context = new SvcLogicContext();
762             context.setAttribute(ARTIFACT_NAME, capabilityArtifactName);
763             context.setAttribute(FILE_CATEGORY, CAPABILITY);
764             context.setAttribute(ACTION, null);
765             context.setAttribute(VNFC_TYPE, null);
766             context.setAttribute(ARTIFACT_TYPE, null);
767             context.setAttribute(VNF_TYPE, vnfType);
768             context.setAttribute(ARTIFACT_CONTENTS, newCapabilitiesObject.toString());
769             dbService.processSdcReferences(context, dbService.isArtifactUpdateRequired(context, DB_SDC_REFERENCE));
770             int intVersion = 0;
771             String internalVersion =
772                     dbService.getInternalVersionNumber(context, context.getAttribute(ARTIFACT_NAME), null);
773             log.info("Internal Version number received from Database: " + internalVersion);
774             if (internalVersion != null) {
775                 intVersion = Integer.parseInt(internalVersion) + 1;
776             }
777             setAttribute(context, documentInfo::getString, SERVICE_UUID);
778             setAttribute(context, documentInfo::getString, DISTRIBUTION_ID);
779             setAttribute(context, documentInfo::getString, SERVICE_NAME);
780             setAttribute(context, documentInfo::getString, SERVICE_DESCRIPTION);
781             setAttribute(context, documentInfo::getString, RESOURCE_UUID);
782             setAttribute(context, documentInfo::getString, RESOURCE_INSTANCE_NAME);
783             setAttribute(context, documentInfo::getString, RESOURCE_VERSION);
784             setAttribute(context, documentInfo::getString, RESOURCE_TYPE);
785             setAttribute(context, documentInfo::getString, ARTIFACT_UUID);
786             setAttribute(context, documentInfo::getString, ARTIFACT_VERSION);
787             setAttribute(context, documentInfo::getString, ARTIFACT_DESRIPTION);
788             dbService.saveArtifacts(context, intVersion);
789         } catch (Exception e) {
790             log.error("Error saving capabilities artifact to DB", e);
791             throw new ArtifactHandlerInternalException("Error saving capabilities artifact to DB", e);
792         } finally {
793             log.info("End-->processAndStoreCapabilitiesArtifact");
794         }
795     }
796
797     private void setAttribute(SvcLogicContext context, Function<String, String> value, String key) {
798         context.setAttribute(key, value.apply(key));
799     }
800
801     private void populateProtocolReference(DBService dbservice, JSONObject content)
802             throws ArtifactHandlerInternalException {
803         log.info("Begin-->populateProtocolReference");
804         try {
805             SvcLogicContext context = new SvcLogicContext();
806             JSONObject scope = content.getJSONObject("scope");
807             String vnfType = tryGetVnfType(scope);
808             String protocol = tryGetProtocol(content);
809             String action = tryGetAction(content);
810             String actionLevel = tryGetActionLevel(content);
811             String template = tryGetTemplate(content);
812
813             boolean isUpdateNeeded = dbservice.isProtocolReferenceUpdateRequired(context, vnfType, protocol, action,
814                     actionLevel, template);
815             if (isUpdateNeeded) {
816                 dbservice.updateProtocolReference(context, vnfType, protocol, action, actionLevel, template);
817             } else {
818                 dbservice.insertProtocolReference(context, vnfType, protocol, action, actionLevel, template);
819             }
820         } catch (Exception e) {
821             log.error("Error inserting record into protocolReference", e);
822             throw new ArtifactHandlerInternalException("Error inserting record into protocolReference", e);
823         } finally {
824             log.info("End-->populateProtocolReference");
825         }
826     }
827
828     private String tryGetVnfType(JSONObject scope) {
829         if (scope.has(VNF_TYPE) && !scope.isNull(VNF_TYPE)) {
830             return scope.getString(VNF_TYPE);
831         }
832         return null;
833     }
834
835     private String tryGetProtocol(JSONObject content) {
836         if (content.has(DEVICE_PROTOCOL)) {
837             return content.getString(DEVICE_PROTOCOL);
838         }
839         return null;
840     }
841
842     private String tryGetAction(JSONObject content) {
843         if (content.has(ACTION)) {
844             return content.getString(ACTION);
845         }
846         return null;
847     }
848
849     private String tryGetActionLevel(JSONObject content) {
850         if (content.has(ACTION_LEVEL)) {
851             return content.getString(ACTION_LEVEL);
852         }
853         return null;
854     }
855
856     private String tryGetTemplate(JSONObject content) {
857         if (content.has(TEMPLATE) && !content.isNull(TEMPLATE)) {
858             return content.getString(TEMPLATE);
859         }
860         return null;
861     }
862
863     protected ArtifactProcessorImpl getArtifactProcessorImpl() {
864         return new ArtifactProcessorImpl();
865     }
866 }