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 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Copyright (C) 2017 Amdocs
   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
  12  *
  13  *      http://www.apache.org/licenses/LICENSE-2.0
  14  *
  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  *
  21  * ECOMP is a trademark and service mark of AT&T Intellectual Property.
  22  * ============LICENSE_END=========================================================
  23  */
  24
  25 package org.onap.appc.artifact.handler.node;
  26
  27 import java.io.ByteArrayOutputStream;
  28 import java.io.OutputStream;
  29 import java.util.Map;
  30
  31 import org.apache.commons.lang.StringUtils;
  32 import org.json.JSONArray;
  33 import org.json.JSONObject;
  34 import org.onap.appc.artifact.handler.dbservices.DBService;
  35 import org.onap.appc.artifact.handler.utils.ArtifactHandlerProviderUtil;
  36 import org.onap.appc.artifact.handler.utils.SdcArtifactHandlerConstants;
  37 import org.onap.appc.yang.YANGGenerator;
  38 import org.onap.appc.yang.impl.YANGGeneratorFactory;
  39 import org.onap.sdnc.config.params.transformer.tosca.ArtifactProcessorImpl;
  40 import org.onap.ccsdk.sli.core.sli.SvcLogicContext;
  41 import org.onap.ccsdk.sli.core.sli.SvcLogicException;
  42 import org.onap.ccsdk.sli.core.sli.SvcLogicJavaPlugin;
  43
  44 import com.att.eelf.configuration.EELFLogger;
  45 import com.att.eelf.configuration.EELFManager;
  46
  47
  48
  49 public class ArtifactHandlerNode implements SvcLogicJavaPlugin {
  50
  51     private static final EELFLogger log = EELFManager.getInstance().getLogger(ArtifactHandlerNode.class);
  52
  53     public void processArtifact(Map<String, String> inParams, SvcLogicContext ctx) throws Exception {
  54         String responsePrefix = inParams.get("response_prefix");
  55         try {
  56             if (inParams != null && !inParams.isEmpty() && inParams.get("postData") != null) {
  57                 log.info("Received request for process Artifact with params: " + inParams.toString());
  58                 String postData = inParams.get("postData");
  59                 JSONObject input = new JSONObject(postData).getJSONObject("input");
  60                 responsePrefix = StringUtils.isNotBlank(responsePrefix) ? (responsePrefix + ".") : "";
  61                 storeUpdateSdcArtifacts(input);
  62             }
  63         } catch (Exception e) {
  64             e.printStackTrace();
  65             throw e;
  66         }
  67     }
  68
  69     private boolean storeUpdateSdcArtifacts(JSONObject postDataJson) throws Exception {
  70         log.info("Starting processing of SDC Artifacs into Handler with Data : " + postDataJson.toString());
  71         try {
  72             JSONObject request_information =
  73                     (JSONObject) postDataJson.get(SdcArtifactHandlerConstants.REQUEST_INFORMATION);
  74             JSONObject document_information =
  75                     (JSONObject) postDataJson.get(SdcArtifactHandlerConstants.DOCUMENT_PARAMETERS);
  76             String artifact_name = document_information.getString(SdcArtifactHandlerConstants.ARTIFACT_NAME);
  77             if (artifact_name != null) {
  78                 updateStoreArtifacts(request_information, document_information);
  79                 if (artifact_name.toLowerCase().startsWith(SdcArtifactHandlerConstants.REFERENCE))
  80                     return storeReferenceData(request_information, document_information);
  81                 else if (artifact_name.toLowerCase().startsWith(SdcArtifactHandlerConstants.PD))
  82                     return createDataForPD(request_information, document_information);
  83
  84             } else
  85                 throw new Exception("Missing Artifact Name for Request : "
  86                         + request_information.getString(SdcArtifactHandlerConstants.REQUETS_ID));
  87         } catch (Exception e) {
  88             e.printStackTrace();
  89             throw new Exception("Error while processing Request ID : "
  90                     + ((JSONObject) postDataJson.get(SdcArtifactHandlerConstants.REQUEST_INFORMATION))
  91                             .getString(SdcArtifactHandlerConstants.REQUETS_ID)
  92                     + e.getMessage());
  93         }
  94         return false;
  95
  96     }
  97
  98     private boolean createDataForPD(JSONObject request_information, JSONObject document_information) throws Exception {
  99
 100         String fn = "ArtifactHandlerNode.createReferenceDataForPD";
 101         String artifact_name = document_information.getString(SdcArtifactHandlerConstants.ARTIFACT_NAME);
 102         log.info(fn + "Received PD File Name: " + artifact_name + " and suffix lenght "
 103                 + SdcArtifactHandlerConstants.PD.length());
 104         try {
 105
 106             String suffix = artifact_name.substring(SdcArtifactHandlerConstants.PD.length());
 107             createArtifactRecords(request_information, document_information, suffix);
 108         } catch (Exception e) {
 109             e.printStackTrace();
 110             throw new Exception("Error while createing PD data records " + e.getMessage());
 111         }
 112         return true;
 113     }
 114
 115     private void createArtifactRecords(JSONObject request_information, JSONObject document_information, String suffix)
 116             throws Exception {
 117
 118         log.info("Creating Tosca Records and storing into SDC Artifacs");
 119         String[] docs = {"Tosca", "Yang"};
 120         ArtifactHandlerProviderUtil ahpUtil = new ArtifactHandlerProviderUtil();
 121         String PDFileContents = document_information.getString(SdcArtifactHandlerConstants.ARTIFACT_CONTENTS);
 122
 123         // Tosca generation
 124         OutputStream toscaStream = new ByteArrayOutputStream();
 125         String toscaContents = null;
 126         ArtifactProcessorImpl toscaGenerator = new ArtifactProcessorImpl();
 127         toscaGenerator.generateArtifact(PDFileContents, toscaStream);
 128         if (toscaStream != null)
 129             toscaContents = toscaStream.toString();
 130         log.info("Generated Tosca File : " + toscaContents);
 131
 132         String yangContents = "YANG generation is in Progress";
 133         String yangName = null;
 134
 135         for (String doc : docs) {
 136             document_information.put(SdcArtifactHandlerConstants.ARTIFACT_TYPE, doc.concat("Type"));
 137             document_information.put(SdcArtifactHandlerConstants.ARTIFACT_DESRIPTION, doc.concat("Model"));
 138             if (doc.equals("Tosca"))
 139                 document_information.put(SdcArtifactHandlerConstants.ARTIFACT_CONTENTS,
 140                         ahpUtil.escapeSql(toscaContents));
 141             else if (doc.equals("Yang"))
 142                 document_information.put(SdcArtifactHandlerConstants.ARTIFACT_CONTENTS,
 143                         ahpUtil.escapeSql(yangContents));
 144             document_information.put(SdcArtifactHandlerConstants.ARTIFACT_NAME, doc.concat(suffix));
 145             yangName = doc.concat(suffix);
 146             updateStoreArtifacts(request_information, document_information);
 147         }
 148
 149         String artifactId = getArtifactID(yangName);
 150         OutputStream yangStream = new ByteArrayOutputStream();
 151         YANGGenerator yangGenerator = YANGGeneratorFactory.getYANGGenerator();
 152         yangGenerator.generateYANG(artifactId, toscaContents, yangStream);
 153         if (yangStream != null)
 154             yangContents = yangStream.toString();
 155
 156         if (yangContents != null) {
 157             updateYangContents(artifactId, ahpUtil.escapeSql(yangContents));
 158         }
 159
 160     }
 161
 162     private void updateYangContents(String artifactId, String yangContents) throws SvcLogicException {
 163         SvcLogicContext context = new SvcLogicContext();
 164         DBService dbservice = DBService.initialise();
 165         dbservice.updateYangContents(context, artifactId, yangContents);
 166     }
 167
 168     private String getArtifactID(String yangName) throws SvcLogicException {
 169         SvcLogicContext context = new SvcLogicContext();
 170         DBService dbservice = DBService.initialise();
 171         return dbservice.getArtifactID(context, yangName);
 172     }
 173
 174     protected boolean updateStoreArtifacts(JSONObject request_information, JSONObject document_information)
 175             throws Exception {
 176         log.info("UpdateStoreArtifactsStarted storing of SDC Artifacs ");
 177
 178         SvcLogicContext context = new SvcLogicContext();
 179         DBService dbservice = DBService.initialise();
 180         ArtifactHandlerProviderUtil ahpUtil = new ArtifactHandlerProviderUtil();
 181         int intversion = 0;
 182         context.setAttribute("artifact_name",
 183                 document_information.getString(SdcArtifactHandlerConstants.ARTIFACT_NAME));
 184         String internal_version = dbservice.getInternalVersionNumber(context,
 185                 document_information.getString(SdcArtifactHandlerConstants.ARTIFACT_NAME), null);
 186         log.info("Internal Version number received from Database : " + internal_version);
 187         if (internal_version != null) {
 188             intversion = Integer.parseInt(internal_version);
 189             intversion++;
 190         }
 191         context.setAttribute(SdcArtifactHandlerConstants.SERVICE_UUID,
 192                 document_information.getString(SdcArtifactHandlerConstants.SERVICE_UUID));
 193         context.setAttribute(SdcArtifactHandlerConstants.DISTRIBUTION_ID,
 194                 document_information.getString(SdcArtifactHandlerConstants.DISTRIBUTION_ID));
 195         context.setAttribute(SdcArtifactHandlerConstants.SERVICE_NAME,
 196                 document_information.getString(SdcArtifactHandlerConstants.SERVICE_NAME));
 197         context.setAttribute(SdcArtifactHandlerConstants.SERVICE_DESCRIPTION,
 198                 document_information.getString(SdcArtifactHandlerConstants.SERVICE_DESCRIPTION));
 199         context.setAttribute(SdcArtifactHandlerConstants.RESOURCE_UUID,
 200                 document_information.getString(SdcArtifactHandlerConstants.RESOURCE_UUID));
 201         context.setAttribute(SdcArtifactHandlerConstants.RESOURCE_INSTANCE_NAME,
 202                 document_information.getString(SdcArtifactHandlerConstants.RESOURCE_INSTANCE_NAME));
 203         context.setAttribute(SdcArtifactHandlerConstants.RESOURCE_VERSOIN,
 204                 document_information.getString(SdcArtifactHandlerConstants.RESOURCE_VERSOIN));
 205         context.setAttribute(SdcArtifactHandlerConstants.RESOURCE_TYPE,
 206                 document_information.getString(SdcArtifactHandlerConstants.RESOURCE_TYPE));
 207         context.setAttribute(SdcArtifactHandlerConstants.ARTIFACT_UUID,
 208                 document_information.getString(SdcArtifactHandlerConstants.ARTIFACT_UUID));
 209         context.setAttribute(SdcArtifactHandlerConstants.ARTIFACT_TYPE,
 210                 document_information.getString(SdcArtifactHandlerConstants.ARTIFACT_TYPE));
 211         context.setAttribute(SdcArtifactHandlerConstants.ARTIFACT_VERSOIN,
 212                 document_information.getString(SdcArtifactHandlerConstants.ARTIFACT_VERSOIN));
 213         context.setAttribute(SdcArtifactHandlerConstants.ARTIFACT_DESRIPTION,
 214                 document_information.getString(SdcArtifactHandlerConstants.ARTIFACT_DESRIPTION));
 215         context.setAttribute(SdcArtifactHandlerConstants.ARTIFACT_CONTENTS,
 216                 ahpUtil.escapeSql(document_information.getString(SdcArtifactHandlerConstants.ARTIFACT_CONTENTS)));
 217         context.setAttribute(SdcArtifactHandlerConstants.ARTIFACT_NAME,
 218                 document_information.getString(SdcArtifactHandlerConstants.ARTIFACT_NAME));
 219         dbservice.saveArtifacts(context, intversion);
 220         return true;
 221
 222     }
 223
 224     public boolean storeReferenceData(JSONObject request_information, JSONObject document_information)
 225             throws Exception {
 226         log.info("Started storing of SDC Artifacs into Handler");
 227         try {
 228             boolean updateRequired = false;
 229             boolean pdFile = false;
 230             String suffix = null;
 231             String categorySuffix = null;
 232             DBService dbservice = DBService.initialise();
 233             ArtifactHandlerProviderUtil ahpUtil = new ArtifactHandlerProviderUtil();
 234             String contentString =
 235                     ahpUtil.escapeSql(document_information.getString(SdcArtifactHandlerConstants.ARTIFACT_CONTENTS));
 236             String artifactName =
 237                     ahpUtil.escapeSql(document_information.getString(SdcArtifactHandlerConstants.ARTIFACT_NAME));
 238             String capabilityArtifactName =
 239                     StringUtils.replace(artifactName, SdcArtifactHandlerConstants.ARTIFACT_NAME_REFERENCE,
 240                             SdcArtifactHandlerConstants.ARTIFACT_NAME_CAPABILITY);
 241             JSONObject capabilities = new JSONObject();
 242             JSONArray vnfActionList = new JSONArray();
 243             JSONArray vfModuleActionList = new JSONArray();
 244             JSONArray vnfcActionList = new JSONArray();
 245         JSONArray vmActionVnfcFunctionCodesList=new JSONArray();
 246             JSONArray vmActionList = new JSONArray();
 247             String vnfType = null;
 248             JSONObject contentObject = new JSONObject(contentString);
 249             JSONArray contentArray = contentObject.getJSONArray("reference_data");
 250             boolean storeCapabilityArtifact = true;
 251             for (int a = 0; a < contentArray.length(); a++) {
 252         pdFile = false;
 253                 JSONObject content = (JSONObject) contentArray.get(a);
 254                 log.info("contentString =" + content.toString());
 255                 JSONObject scope = content.getJSONObject("scope");
 256                 log.info("scope :" + scope);
 257                 SvcLogicContext context = new SvcLogicContext();
 258                 vnfType = scope.getString(SdcArtifactHandlerConstants.VNF_TYPE);
 259                 context.setAttribute(SdcArtifactHandlerConstants.VNF_TYPE,
 260                         scope.getString(SdcArtifactHandlerConstants.VNF_TYPE));
 261                 context.setAttribute(SdcArtifactHandlerConstants.ACTION,
 262                         content.getString(SdcArtifactHandlerConstants.ACTION));
 263                 String actionLevel = content.getString(SdcArtifactHandlerConstants.ACTION_LEVEL);
 264                 context.setAttribute(SdcArtifactHandlerConstants.ACTION_LEVEL,
 265                         content.getString(SdcArtifactHandlerConstants.ACTION_LEVEL));
 266             context.setAttribute(SdcArtifactHandlerConstants.ARTIFACT_TYPE,
 267                     document_information.getString(SdcArtifactHandlerConstants.ARTIFACT_TYPE));
 268                 if ((null != actionLevel)
 269                         && actionLevel.equalsIgnoreCase(SdcArtifactHandlerConstants.ACTION_LEVEL_VNFC)) {
 270                     vnfcActionList.put(content.getString(SdcArtifactHandlerConstants.ACTION));
 271                 }
 272                 if (null != actionLevel
 273                         && actionLevel.equalsIgnoreCase(SdcArtifactHandlerConstants.ACTION_LEVEL_VF_MODULE)) {
 274                     vfModuleActionList.put(content.getString(SdcArtifactHandlerConstants.ACTION));
 275                 }
 276                 if (null != actionLevel && actionLevel.equalsIgnoreCase(SdcArtifactHandlerConstants.ACTION_LEVEL_VNF)) {
 277                     vnfActionList.put(content.getString(SdcArtifactHandlerConstants.ACTION));
 278                 }
 279                 if (null != actionLevel && actionLevel.equalsIgnoreCase(SdcArtifactHandlerConstants.ACTION_LEVEL_VM)) {
 280                 if (content.has(SdcArtifactHandlerConstants.VNFC_FUNCTION_CODE_LIST)
 281                             && !content.isNull(SdcArtifactHandlerConstants.VNFC_FUNCTION_CODE_LIST) && content.get(
 282                                     SdcArtifactHandlerConstants.VNFC_FUNCTION_CODE_LIST) instanceof JSONArray) {
 283                         log.info("Found vnfc-function-code-list!!");
 284                         JSONArray vnfcList = content.getJSONArray(SdcArtifactHandlerConstants.VNFC_FUNCTION_CODE_LIST);
 285                         JSONObject obj = new JSONObject();
 286                         obj.put(content.getString(SdcArtifactHandlerConstants.ACTION), vnfcList);
 287                         vmActionVnfcFunctionCodesList.put(obj);
 288                     } else {
 289                         log.info("Not getting JSONArray for VNFC FUNCTION CODES");
 290                     }
 291                 }
 292                 if (scope.has(SdcArtifactHandlerConstants.VNFC_TYPE)
 293                         && !scope.isNull(SdcArtifactHandlerConstants.VNFC_TYPE)) {
 294             String vnfcTypeScope = scope.getString(SdcArtifactHandlerConstants.VNFC_TYPE);
 295                     if (StringUtils.isNotBlank(vnfcTypeScope)) {
 296                     context.setAttribute(SdcArtifactHandlerConstants.VNFC_TYPE,
 297                             scope.getString(SdcArtifactHandlerConstants.VNFC_TYPE));
 298                     storeCapabilityArtifact = false;
 299                         log.info("No capability Artifact for this reference data as it is at VNFC level!!");
 300                     }
 301             else {
 302                          context.setAttribute(SdcArtifactHandlerConstants.VNFC_TYPE, null);
 303                     }
 304                 }
 305                 else
 306                     context.setAttribute(SdcArtifactHandlerConstants.VNFC_TYPE, null);
 307                 if (content.has(SdcArtifactHandlerConstants.DEVICE_PROTOCOL))
 308                     context.setAttribute(SdcArtifactHandlerConstants.DEVICE_PROTOCOL,
 309                             content.getString(SdcArtifactHandlerConstants.DEVICE_PROTOCOL));
 310                 if (content.has(SdcArtifactHandlerConstants.USER_NAME))
 311                     context.setAttribute(SdcArtifactHandlerConstants.USER_NAME,
 312                             content.getString(SdcArtifactHandlerConstants.USER_NAME));
 313                 if (content.has(SdcArtifactHandlerConstants.PORT_NUMBER))
 314                     context.setAttribute(SdcArtifactHandlerConstants.PORT_NUMBER,
 315                             content.getString(SdcArtifactHandlerConstants.PORT_NUMBER));
 316                 //context.setAttribute(SdcArtifactHandlerConstants.ARTIFACT_TYPE, "");
 317                 if (content.has("artifact-list") && content.get("artifact-list") instanceof JSONArray) {
 318                     JSONArray artifactLists = (JSONArray) content.get("artifact-list");
 319                     for (int i = 0; i < artifactLists.length(); i++) {
 320                         JSONObject artifact = (JSONObject) artifactLists.get(i);
 321                         log.info("artifact is " + artifact);
 322                         context.setAttribute(SdcArtifactHandlerConstants.ARTIFACT_NAME,
 323                                 artifact.getString(SdcArtifactHandlerConstants.ARTIFACT_NAME));
 324                         context.setAttribute(SdcArtifactHandlerConstants.FILE_CATEGORY,
 325                                 artifact.getString(SdcArtifactHandlerConstants.ARTIFACT_TYPE));
 326
 327                         if (artifact.getString(SdcArtifactHandlerConstants.ARTIFACT_NAME) != null
 328                                 && artifact.getString(SdcArtifactHandlerConstants.ARTIFACT_NAME).toLowerCase()
 329                                         .startsWith(SdcArtifactHandlerConstants.PD)) {
 330                             suffix = artifact.getString(SdcArtifactHandlerConstants.ARTIFACT_NAME)
 331                                     .substring(SdcArtifactHandlerConstants.PD.length());
 332                             categorySuffix = artifact.getString(SdcArtifactHandlerConstants.ARTIFACT_TYPE)
 333                                     .substring(SdcArtifactHandlerConstants.PD.length());
 334                             pdFile = true;
 335                         }
 336             log.info("Artifact-type = " + context.getAttribute(SdcArtifactHandlerConstants.ARTIFACT_TYPE));
 337                         dbservice.processSdcReferences(context, dbservice.isArtifactUpdateRequired(context,
 338                                 SdcArtifactHandlerConstants.DB_SDC_REFERENCE));
 339
 340                         cleanArtifactInstanceData(context);
 341                     }
 342
 343                     if (pdFile) {
 344                         context.setAttribute(SdcArtifactHandlerConstants.ARTIFACT_NAME, "Tosca".concat(suffix));
 345                         context.setAttribute(SdcArtifactHandlerConstants.FILE_CATEGORY,
 346                                 SdcArtifactHandlerConstants.TOSCA_MODEL);
 347                         dbservice.processSdcReferences(context, dbservice.isArtifactUpdateRequired(context,
 348                                 SdcArtifactHandlerConstants.DB_SDC_REFERENCE));
 349                         context.setAttribute(SdcArtifactHandlerConstants.ARTIFACT_NAME, "Yang".concat(suffix));
 350                         context.setAttribute(SdcArtifactHandlerConstants.FILE_CATEGORY,
 351                                 SdcArtifactHandlerConstants.PARAMETER_YANG);
 352                         dbservice.processSdcReferences(context, dbservice.isArtifactUpdateRequired(context,
 353                                 SdcArtifactHandlerConstants.DB_SDC_REFERENCE));
 354                     }
 355                 }
 356                 if (content.getString(SdcArtifactHandlerConstants.ACTION).equals("Configure")
 357                     || content.getString(SdcArtifactHandlerConstants.ACTION).equals("ConfigModify")) {
 358                     if (content.has(SdcArtifactHandlerConstants.DOWNLOAD_DG_REFERENCE)
 359                             && content.getString(SdcArtifactHandlerConstants.DOWNLOAD_DG_REFERENCE).length() > 0) {
 360                         context.setAttribute(SdcArtifactHandlerConstants.DOWNLOAD_DG_REFERENCE,
 361                                 content.getString(SdcArtifactHandlerConstants.DOWNLOAD_DG_REFERENCE));
 362                         dbservice.processDownloadDgReference(context, dbservice.isArtifactUpdateRequired(context,
 363                                 SdcArtifactHandlerConstants.DB_DOWNLOAD_DG_REFERENCE));
 364                     }
 365                     if (StringUtils.isBlank(context.getAttribute(SdcArtifactHandlerConstants.DOWNLOAD_DG_REFERENCE))) {
 366                         context.setAttribute(SdcArtifactHandlerConstants.DOWNLOAD_DG_REFERENCE,
 367                                 dbservice.getDownLoadDGReference(context));
 368             }
 369                     dbservice.processConfigActionDg(context, dbservice.isArtifactUpdateRequired(context,
 370                             SdcArtifactHandlerConstants.DB_CONFIG_ACTION_DG));
 371                     if (content.getString(SdcArtifactHandlerConstants.ACTION).equals("Configure")) {
 372                         dbservice.processDeviceInterfaceProtocol(context, dbservice.isArtifactUpdateRequired(context,
 373                                 SdcArtifactHandlerConstants.DB_DEVICE_INTERFACE_PROTOCOL));
 374                     }
 375
 376                 }
 377         dbservice.processDeviceAuthentication(context, dbservice.isArtifactUpdateRequired(context,
 378                                 SdcArtifactHandlerConstants.DB_DEVICE_AUTHENTICATION));
 379
 380                 populateProtocolReference(dbservice, content);
 381
 382                 context.setAttribute(SdcArtifactHandlerConstants.VNFC_TYPE, null);
 383
 384                 if (content.has(SdcArtifactHandlerConstants.VM)
 385                         && content.get(SdcArtifactHandlerConstants.VM) instanceof JSONArray) {
 386                     JSONArray vmList = (JSONArray) content.get(SdcArtifactHandlerConstants.VM);
 387                     dbservice.cleanUpVnfcReferencesForVnf(context);
 388                     for (int i = 0; i < vmList.length(); i++) {
 389                         JSONObject vmInstance = (JSONObject) vmList.get(i);
 390                         context.setAttribute(SdcArtifactHandlerConstants.VM_INSTANCE,
 391                                 String.valueOf(vmInstance.getInt(SdcArtifactHandlerConstants.VM_INSTANCE)));
 392                         log.info("VALUE = " + context.getAttribute(SdcArtifactHandlerConstants.VM_INSTANCE));
 393                         if (vmInstance.get(SdcArtifactHandlerConstants.VNFC) instanceof JSONArray) {
 394                             JSONArray vnfcInstanceList = (JSONArray) vmInstance.get(SdcArtifactHandlerConstants.VNFC);
 395                             for (int k = 0; k < vnfcInstanceList.length(); k++) {
 396                                 JSONObject vnfcInstance = (JSONObject) vnfcInstanceList.get(k);
 397                                 context.setAttribute(SdcArtifactHandlerConstants.VNFC_INSTANCE,
 398                                         String.valueOf(vnfcInstance.getInt(SdcArtifactHandlerConstants.VNFC_INSTANCE)));
 399                                 context.setAttribute(SdcArtifactHandlerConstants.VNFC_TYPE,
 400                                         vnfcInstance.getString(SdcArtifactHandlerConstants.VNFC_TYPE));
 401                                 context.setAttribute(SdcArtifactHandlerConstants.VNFC_FUNCTION_CODE,
 402                                         vnfcInstance.getString(SdcArtifactHandlerConstants.VNFC_FUNCTION_CODE));
 403                                 if (vnfcInstance.has(SdcArtifactHandlerConstants.IPADDRESS_V4_OAM_VIP))
 404                                     context.setAttribute(SdcArtifactHandlerConstants.IPADDRESS_V4_OAM_VIP,
 405                                             vnfcInstance.getString(SdcArtifactHandlerConstants.IPADDRESS_V4_OAM_VIP));
 406                                 if (vnfcInstance.has(SdcArtifactHandlerConstants.GROUP_NOTATION_TYPE))
 407                                     context.setAttribute(SdcArtifactHandlerConstants.GROUP_NOTATION_TYPE,
 408                                             vnfcInstance.getString(SdcArtifactHandlerConstants.GROUP_NOTATION_TYPE));
 409                                 if (vnfcInstance.has(SdcArtifactHandlerConstants.GROUP_NOTATION_VALUE))
 410                                     context.setAttribute(SdcArtifactHandlerConstants.GROUP_NOTATION_VALUE,
 411                                             vnfcInstance.getString(SdcArtifactHandlerConstants.GROUP_NOTATION_VALUE));
 412                                 if (content.getString(SdcArtifactHandlerConstants.ACTION).equals("Configure")) {
 413                                     dbservice.processVnfcReference(context,false);
 414                                 }
 415                                 cleanVnfcInstance(context);
 416                             }
 417                             context.setAttribute(SdcArtifactHandlerConstants.VM_INSTANCE, null);
 418                         }
 419                     }
 420                 }
 421
 422
 423             }
 424             if (storeCapabilityArtifact) {
 425                 capabilities.put("vnf", vnfActionList);
 426                 capabilities.put("vf-module", vfModuleActionList);
 427                 capabilities.put("vnfc", vnfcActionList);
 428                 capabilities.put("vm", vmActionVnfcFunctionCodesList);
 429                 processAndStoreCapablitiesArtifact(dbservice, document_information, capabilities, capabilityArtifactName,
 430                     vnfType);
 431             }
 432
 433         } catch (Exception e) {
 434             e.printStackTrace();
 435             throw new Exception("Error While Storing :  " + e.getMessage());
 436         }
 437
 438         return true;
 439     }
 440
 441     private void cleanArtifactInstanceData(SvcLogicContext context) {
 442         context.setAttribute(SdcArtifactHandlerConstants.ARTIFACT_NAME, null);
 443         context.setAttribute(SdcArtifactHandlerConstants.FILE_CATEGORY, null);
 444     }
 445
 446     private void cleanVnfcInstance(SvcLogicContext context) {
 447
 448         context.setAttribute(SdcArtifactHandlerConstants.VNFC_INSTANCE, null);
 449         context.setAttribute(SdcArtifactHandlerConstants.VNFC_TYPE, null);
 450         context.setAttribute(SdcArtifactHandlerConstants.VNFC_FUNCTION_CODE, null);
 451         context.setAttribute(SdcArtifactHandlerConstants.IPADDRESS_V4_OAM_VIP, null);
 452         context.setAttribute(SdcArtifactHandlerConstants.GROUP_NOTATION_TYPE, null);
 453         context.setAttribute(SdcArtifactHandlerConstants.GROUP_NOTATION_VALUE, null);
 454
 455     }
 456
 457     private void processAndStoreCapablitiesArtifact(DBService dbservice, JSONObject document_information,
 458             JSONObject capabilities, String capabilityArtifactName, String vnfType) throws Exception {
 459         log.info("Begin-->processAndStoreCapablitiesArtifact ");
 460
 461         try {
 462
 463             JSONObject newCapabilitiesObject = new JSONObject();
 464             newCapabilitiesObject.put("capabilities", capabilities);
 465             SvcLogicContext context = new SvcLogicContext();
 466             context.setAttribute(SdcArtifactHandlerConstants.ARTIFACT_NAME, capabilityArtifactName);
 467             context.setAttribute(SdcArtifactHandlerConstants.FILE_CATEGORY, SdcArtifactHandlerConstants.CAPABILITY);
 468             context.setAttribute(SdcArtifactHandlerConstants.ACTION, null);
 469             context.setAttribute(SdcArtifactHandlerConstants.VNFC_TYPE, null);
 470             context.setAttribute(SdcArtifactHandlerConstants.ARTIFACT_TYPE, null);
 471             context.setAttribute(SdcArtifactHandlerConstants.VNF_TYPE, vnfType);
 472             context.setAttribute(SdcArtifactHandlerConstants.ARTIFACT_CONTENTS, newCapabilitiesObject.toString());
 473             dbservice.processSdcReferences(context,
 474                     dbservice.isArtifactUpdateRequired(context, SdcArtifactHandlerConstants.DB_SDC_REFERENCE));
 475             int intversion = 0;
 476
 477             String internal_version = dbservice.getInternalVersionNumber(context,
 478                     context.getAttribute(SdcArtifactHandlerConstants.ARTIFACT_NAME), null);
 479             log.info("Internal Version number received from Database : " + internal_version);
 480             if (internal_version != null) {
 481                 intversion = Integer.parseInt(internal_version);
 482                 intversion++;
 483             }
 484             context.setAttribute(SdcArtifactHandlerConstants.SERVICE_UUID,
 485                     document_information.getString(SdcArtifactHandlerConstants.SERVICE_UUID));
 486             context.setAttribute(SdcArtifactHandlerConstants.DISTRIBUTION_ID,
 487                     document_information.getString(SdcArtifactHandlerConstants.DISTRIBUTION_ID));
 488             context.setAttribute(SdcArtifactHandlerConstants.SERVICE_NAME,
 489                     document_information.getString(SdcArtifactHandlerConstants.SERVICE_NAME));
 490             context.setAttribute(SdcArtifactHandlerConstants.SERVICE_DESCRIPTION,
 491                     document_information.getString(SdcArtifactHandlerConstants.SERVICE_DESCRIPTION));
 492             context.setAttribute(SdcArtifactHandlerConstants.RESOURCE_UUID,
 493                     document_information.getString(SdcArtifactHandlerConstants.RESOURCE_UUID));
 494             context.setAttribute(SdcArtifactHandlerConstants.RESOURCE_INSTANCE_NAME,
 495                     document_information.getString(SdcArtifactHandlerConstants.RESOURCE_INSTANCE_NAME));
 496             context.setAttribute(SdcArtifactHandlerConstants.RESOURCE_VERSOIN,
 497                     document_information.getString(SdcArtifactHandlerConstants.RESOURCE_VERSOIN));
 498             context.setAttribute(SdcArtifactHandlerConstants.RESOURCE_TYPE,
 499                     document_information.getString(SdcArtifactHandlerConstants.RESOURCE_TYPE));
 500             context.setAttribute(SdcArtifactHandlerConstants.ARTIFACT_UUID,
 501                     document_information.getString(SdcArtifactHandlerConstants.ARTIFACT_UUID));
 502             context.setAttribute(SdcArtifactHandlerConstants.ARTIFACT_VERSOIN,
 503                     document_information.getString(SdcArtifactHandlerConstants.ARTIFACT_VERSOIN));
 504             context.setAttribute(SdcArtifactHandlerConstants.ARTIFACT_DESRIPTION,
 505                     document_information.getString(SdcArtifactHandlerConstants.ARTIFACT_DESRIPTION));
 506
 507
 508             dbservice.saveArtifacts(context, intversion);
 509             return;
 510         } catch (Exception e) {
 511             log.error("Error saving capabilities artifact to DB: " + e.toString());
 512             throw e;
 513         } finally {
 514             log.info("End-->processAndStoreCapablitiesArtifact ");
 515         }
 516
 517     }
 518
 519     private void populateProtocolReference(DBService dbservice, JSONObject content) throws Exception {
 520         log.info("Begin-->populateProtocolReference ");
 521         try {
 522             SvcLogicContext context = new SvcLogicContext();
 523             JSONObject scope = content.getJSONObject("scope");
 524             String vnfType = null, protocol = null, action = null, actionLevel = null, template = null;
 525             if (scope.has(SdcArtifactHandlerConstants.VNF_TYPE) && !scope.isNull(SdcArtifactHandlerConstants.VNF_TYPE))
 526                 vnfType = scope.getString(SdcArtifactHandlerConstants.VNF_TYPE);
 527             if (content.has(SdcArtifactHandlerConstants.DEVICE_PROTOCOL))
 528                 protocol = content.getString(SdcArtifactHandlerConstants.DEVICE_PROTOCOL);
 529             if (content.has(SdcArtifactHandlerConstants.ACTION))
 530                 action = content.getString(SdcArtifactHandlerConstants.ACTION);
 531             if (content.has(SdcArtifactHandlerConstants.ACTION_LEVEL))
 532                 actionLevel = content.getString(SdcArtifactHandlerConstants.ACTION_LEVEL);
 533             if (content.has(SdcArtifactHandlerConstants.TEMPLATE)
 534                     && !content.isNull(SdcArtifactHandlerConstants.TEMPLATE))
 535                 template = content.getString(SdcArtifactHandlerConstants.TEMPLATE);
 536             boolean isUpdateNeeded=dbservice.isProtocolReferenceUpdateRequired(context, vnfType, protocol, action, actionLevel, template);
 537             if (isUpdateNeeded)
 538                 dbservice.updateProtocolReference(context, vnfType, protocol, action, actionLevel, template);
 539             else
 540                 dbservice.insertProtocolReference(context, vnfType,protocol,action,actionLevel,template);
 541         } catch (Exception e) {
 542             log.error("Error inserting record into protocolReference: " + e.toString());
 543             throw e;
 544         } finally {
 545             log.info("End-->populateProtocolReference ");
 546         }
 547     }
 548
 549 }