src/main/java/org/onap/clamp/clds/service/CldsService.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * ONAP CLAMP
   4  * ================================================================================
   5  * Copyright (C) 2017-2018 AT&T Intellectual Property. All rights
   6  *                             reserved.
   7  * ================================================================================
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  * http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  * ============LICENSE_END============================================
  20  * Modifications copyright (c) 2018 Nokia
  21  * ===================================================================
  22  *
  23  */
  24
  25 package org.onap.clamp.clds.service;
  26
  27 import com.att.eelf.configuration.EELFLogger;
  28 import com.att.eelf.configuration.EELFManager;
  29 import com.fasterxml.jackson.databind.JsonNode;
  30 import com.fasterxml.jackson.databind.ObjectMapper;
  31 import com.fasterxml.jackson.databind.node.ObjectNode;
  32
  33 import java.io.IOException;
  34 import java.security.GeneralSecurityException;
  35 import java.util.Date;
  36 import java.util.List;
  37 import java.util.Optional;
  38 import java.util.UUID;
  39
  40 import javax.ws.rs.BadRequestException;
  41 import javax.ws.rs.NotAuthorizedException;
  42 import javax.xml.transform.TransformerException;
  43
  44 import org.apache.camel.Produce;
  45 import org.apache.commons.codec.DecoderException;
  46 import org.apache.commons.lang3.StringUtils;
  47 import org.json.simple.parser.ParseException;
  48 import org.onap.clamp.clds.camel.CamelProxy;
  49 import org.onap.clamp.clds.client.DcaeDispatcherServices;
  50 import org.onap.clamp.clds.client.DcaeInventoryServices;
  51 import org.onap.clamp.clds.client.req.sdc.SdcCatalogServices;
  52 import org.onap.clamp.clds.config.ClampProperties;
  53 import org.onap.clamp.clds.dao.CldsDao;
  54 import org.onap.clamp.clds.exception.CldsConfigException;
  55 import org.onap.clamp.clds.exception.policy.PolicyClientException;
  56 import org.onap.clamp.clds.exception.sdc.SdcCommunicationException;
  57 import org.onap.clamp.clds.model.CldsDbServiceCache;
  58 import org.onap.clamp.clds.model.CldsEvent;
  59 import org.onap.clamp.clds.model.CldsInfo;
  60 import org.onap.clamp.clds.model.CldsModel;
  61 import org.onap.clamp.clds.model.CldsModelProp;
  62 import org.onap.clamp.clds.model.CldsMonitoringDetails;
  63 import org.onap.clamp.clds.model.CldsServiceData;
  64 import org.onap.clamp.clds.model.CldsTemplate;
  65 import org.onap.clamp.clds.model.DcaeEvent;
  66 import org.onap.clamp.clds.model.ValueItem;
  67 import org.onap.clamp.clds.model.properties.AbstractModelElement;
  68 import org.onap.clamp.clds.model.properties.ModelProperties;
  69 import org.onap.clamp.clds.model.sdc.SdcResource;
  70 import org.onap.clamp.clds.model.sdc.SdcServiceDetail;
  71 import org.onap.clamp.clds.model.sdc.SdcServiceInfo;
  72 import org.onap.clamp.clds.sdc.controller.installer.CsarInstallerImpl;
  73 import org.onap.clamp.clds.transform.XslTransformer;
  74 import org.onap.clamp.clds.util.JacksonUtils;
  75 import org.onap.clamp.clds.util.LoggingUtils;
  76 import org.springframework.beans.factory.annotation.Autowired;
  77 import org.springframework.beans.factory.annotation.Value;
  78 import org.springframework.http.HttpStatus;
  79 import org.springframework.http.ResponseEntity;
  80 import org.springframework.stereotype.Component;
  81 import org.springframework.web.client.HttpClientErrorException;
  82
  83 /**
  84  * Service to save and retrieve the CLDS model attributes.
  85  */
  86 @Component
  87 public class CldsService extends SecureServiceBase {
  88
  89     @Produce(uri = "direct:processSubmit")
  90     private CamelProxy camelProxy;
  91     protected static final EELFLogger securityLogger = EELFManager.getInstance().getSecurityLogger();
  92
  93     public static final String GLOBAL_PROPERTIES_KEY = "files.globalProperties";
  94     private final String cldsPersmissionTypeCl;
  95     private final String cldsPermissionTypeClManage;
  96     private final String cldsPermissionTypeClEvent;
  97     private final String cldsPermissionTypeFilterVf;
  98     private final String cldsPermissionTypeTemplate;
  99     private final String cldsPermissionInstance;
 100     final SecureServicePermission permissionReadCl;
 101     final SecureServicePermission permissionUpdateCl;
 102     final SecureServicePermission permissionReadTemplate;
 103     final SecureServicePermission permissionUpdateTemplate;
 104
 105     private final CldsDao cldsDao;
 106     private final XslTransformer cldsBpmnTransformer;
 107     private final ClampProperties refProp;
 108     private final SdcCatalogServices sdcCatalogServices;
 109     private final DcaeDispatcherServices dcaeDispatcherServices;
 110     private final DcaeInventoryServices dcaeInventoryServices;
 111
 112     @Autowired
 113     public CldsService(CldsDao cldsDao, XslTransformer cldsBpmnTransformer, ClampProperties refProp,
 114         SdcCatalogServices sdcCatalogServices, DcaeDispatcherServices dcaeDispatcherServices,
 115         DcaeInventoryServices dcaeInventoryServices,
 116         @Value("${clamp.config.security.permission.type.cl:permission-type-cl}") String cldsPersmissionTypeCl,
 117         @Value("${clamp.config.security.permission.type.cl.manage:permission-type-cl-manage}") String cldsPermissionTypeClManage,
 118         @Value("${clamp.config.security.permission.type.cl.event:permission-type-cl-event}") String cldsPermissionTypeClEvent,
 119         @Value("${clamp.config.security.permission.type.filter.vf:permission-type-filter-vf}") String cldsPermissionTypeFilterVf,
 120         @Value("${clamp.config.security.permission.type.template:permission-type-template}") String cldsPermissionTypeTemplate,
 121         @Value("${clamp.config.security.permission.instance:dev}") String cldsPermissionInstance) {
 122         this.cldsDao = cldsDao;
 123         this.cldsBpmnTransformer = cldsBpmnTransformer;
 124         this.refProp = refProp;
 125         this.sdcCatalogServices = sdcCatalogServices;
 126         this.dcaeDispatcherServices = dcaeDispatcherServices;
 127         this.dcaeInventoryServices = dcaeInventoryServices;
 128         this.cldsPersmissionTypeCl = cldsPersmissionTypeCl;
 129         this.cldsPermissionTypeClManage = cldsPermissionTypeClManage;
 130         this.cldsPermissionTypeClEvent = cldsPermissionTypeClEvent;
 131         this.cldsPermissionTypeFilterVf = cldsPermissionTypeFilterVf;
 132         this.cldsPermissionTypeTemplate = cldsPermissionTypeTemplate;
 133         this.cldsPermissionInstance = cldsPermissionInstance;
 134         permissionReadCl = SecureServicePermission.create(cldsPersmissionTypeCl, cldsPermissionInstance, "read");
 135         permissionUpdateCl = SecureServicePermission.create(cldsPersmissionTypeCl, cldsPermissionInstance, "update");
 136         permissionReadTemplate = SecureServicePermission.create(cldsPermissionTypeTemplate, cldsPermissionInstance,
 137             "read");
 138         permissionUpdateTemplate = SecureServicePermission.create(cldsPermissionTypeTemplate, cldsPermissionInstance,
 139             "update");
 140     }
 141
 142     /*
 143      * @return list of CLDS-Monitoring-Details: CLOSELOOP_NAME | Close loop name
 144      * used in the CLDS application (prefix: ClosedLoop- + unique ClosedLoop ID)
 145      * MODEL_NAME | Model Name in CLDS application SERVICE_TYPE_ID | TypeId returned
 146      * from the DCAE application when the ClosedLoop is submitted
 147      * (DCAEServiceTypeRequest generated in DCAE application). DEPLOYMENT_ID | Id
 148      * generated when the ClosedLoop is deployed in DCAE. TEMPLATE_NAME | Template
 149      * used to generate the ClosedLoop model. ACTION_CD | Current state of the
 150      * ClosedLoop in CLDS application.
 151      */
 152     public List<CldsMonitoringDetails> getCLDSDetails() {
 153         Date startTime = new Date();
 154         LoggingUtils.setRequestContext("CldsService: GET model details", getPrincipalName());
 155         List<CldsMonitoringDetails> cldsMonitoringDetailsList = cldsDao.getCLDSMonitoringDetails();
 156         // audit log
 157         LoggingUtils.setTimeContext(startTime, new Date());
 158         LoggingUtils.setResponseContext("0", "Get cldsDetails success", this.getClass().getName());
 159         auditLogger.info("GET cldsDetails completed");
 160         return cldsMonitoringDetailsList;
 161     }
 162
 163     /*
 164      * CLDS IFO service will return 3 things 1. User Name 2. CLDS code version that
 165      * is currently installed from pom.xml file 3. User permissions
 166      */
 167     public CldsInfo getCldsInfo() {
 168         Date startTime = new Date();
 169         LoggingUtils.setRequestContext("CldsService: GET cldsInfo", getPrincipalName());
 170         LoggingUtils.setTimeContext(startTime, new Date());
 171
 172         CldsInfoProvider cldsInfoProvider = new CldsInfoProvider(this);
 173         CldsInfo cldsInfo = cldsInfoProvider.getCldsInfo();
 174
 175         // audit log
 176         LoggingUtils.setTimeContext(startTime, new Date());
 177         LoggingUtils.setResponseContext("0", "Get cldsInfo success", this.getClass().getName());
 178         securityLogger.info("GET cldsInfo completed");
 179         return cldsInfo;
 180     }
 181
 182     /**
 183      * REST service that retrieves BPMN for a CLDS model name from the database.
 184      * This is subset of the json getModel. This is only expected to be used for
 185      * testing purposes, not by the UI.
 186      *
 187      * @param modelName
 188      * @return bpmn xml text - content of bpmn given name
 189      */
 190     public String getBpmnXml(String modelName) {
 191         Date startTime = new Date();
 192         LoggingUtils.setRequestContext("CldsService: GET model bpmn", getPrincipalName());
 193         isAuthorized(permissionReadCl);
 194         logger.info("GET bpmnText for modelName={}", modelName);
 195         CldsModel model = CldsModel.retrieve(cldsDao, modelName, false);
 196         // audit log
 197         LoggingUtils.setTimeContext(startTime, new Date());
 198         LoggingUtils.setResponseContext("0", "Get model bpmn success", this.getClass().getName());
 199         auditLogger.info("GET model bpmn completed");
 200         return model.getBpmnText();
 201     }
 202
 203     /**
 204      * REST service that retrieves image for a CLDS model name from the database.
 205      * This is subset of the json getModel. This is only expected to be used for
 206      * testing purposes, not by the UI.
 207      *
 208      * @param modelName
 209      * @return image xml text - content of image given name
 210      */
 211     public String getImageXml(String modelName) {
 212         Date startTime = new Date();
 213         LoggingUtils.setRequestContext("CldsService: GET model image", getPrincipalName());
 214         isAuthorized(permissionReadCl);
 215         logger.info("GET imageText for modelName={}", modelName);
 216         CldsModel model = CldsModel.retrieve(cldsDao, modelName, false);
 217         // audit log
 218         LoggingUtils.setTimeContext(startTime, new Date());
 219         LoggingUtils.setResponseContext("0", "Get model image success", this.getClass().getName());
 220         auditLogger.info("GET model image completed");
 221         return model.getImageText();
 222     }
 223
 224     /**
 225      * REST service that retrieves a CLDS model by name from the database.
 226      *
 227      * @param modelName
 228      * @return clds model - clds model for the given model name
 229      */
 230     public CldsModel getModel(String modelName) {
 231         Date startTime = new Date();
 232         LoggingUtils.setRequestContext("CldsService: GET model", getPrincipalName());
 233         isAuthorized(permissionReadCl);
 234         logger.debug("GET model for  modelName={}", modelName);
 235         CldsModel cldsModel = CldsModel.retrieve(cldsDao, modelName, false);
 236         isAuthorizedForVf(cldsModel);
 237         // Checking condition whether our CLDS model can call Inventory Method
 238         if (cldsModel.canInventoryCall()) {
 239             try {
 240                 // Method to call dcae inventory and invoke insert event method
 241                 dcaeInventoryServices.setEventInventory(cldsModel, getUserId());
 242             } catch (Exception e) {
 243                 LoggingUtils.setErrorContext("900", "Set event inventory error");
 244                 logger.error("getModel set event Inventory error:" + e);
 245             }
 246         }
 247         // audit log
 248         LoggingUtils.setTimeContext(startTime, new Date());
 249         LoggingUtils.setResponseContext("0", "Get model success", this.getClass().getName());
 250         auditLogger.info("GET model completed");
 251         return cldsModel;
 252     }
 253
 254     /**
 255      * REST service that saves a CLDS model by name in the database.
 256      *
 257      * @param modelName
 258      */
 259     public CldsModel putModel(String modelName, CldsModel cldsModel) {
 260         Date startTime = new Date();
 261         LoggingUtils.setRequestContext("CldsService: PUT model", getPrincipalName());
 262         isAuthorized(permissionUpdateCl);
 263         isAuthorizedForVf(cldsModel);
 264         logger.info("PUT model for  modelName={}", modelName);
 265         logger.info("PUT bpmnText={}", cldsModel.getBpmnText());
 266         logger.info("PUT propText={}", cldsModel.getPropText());
 267         logger.info("PUT imageText={}", cldsModel.getImageText());
 268         cldsModel.setName(modelName);
 269         fillInCldsModel(cldsModel);
 270         updateAndInsertNewEvent(cldsModel.getName(), cldsModel.getControlNamePrefix(), cldsModel.getEvent(),
 271             CldsEvent.ACTION_MODIFY);
 272         cldsModel.save(cldsDao, getUserId());
 273         // audit log
 274         LoggingUtils.setTimeContext(startTime, new Date());
 275         LoggingUtils.setResponseContext("0", "Put model success", this.getClass().getName());
 276         auditLogger.info("PUT model completed");
 277         return cldsModel;
 278     }
 279
 280     /**
 281      * REST service that retrieves a list of CLDS model names.
 282      *
 283      * @return model names in JSON
 284      */
 285     public List<ValueItem> getModelNames() {
 286         Date startTime = new Date();
 287         LoggingUtils.setRequestContext("CldsService: GET model names", getPrincipalName());
 288         isAuthorized(permissionReadCl);
 289         logger.info("GET list of model names");
 290         List<ValueItem> names = cldsDao.getBpmnNames();
 291         // audit log
 292         LoggingUtils.setTimeContext(startTime, new Date());
 293         LoggingUtils.setResponseContext("0", "Get model names success", this.getClass().getName());
 294         auditLogger.info("GET model names completed");
 295         return names;
 296     }
 297
 298     private void fillInCldsModel(CldsModel model) {
 299         if (model.getTemplateName() != null) {
 300             CldsTemplate template = cldsDao.getTemplate(model.getTemplateName());
 301             if (template != null) {
 302                 model.setTemplateId(template.getId());
 303                 model.setDocText(template.getPropText());
 304                 // This is to provide the Bpmn XML when Template part in UI
 305                 // is
 306                 // disabled
 307                 model.setBpmnText(template.getBpmnText());
 308             }
 309         }
 310     }
 311
 312     /**
 313      * REST service that saves and processes an action for a CLDS model by name.
 314      *
 315      * @param action
 316      * @param modelName
 317      * @param validateFlag
 318      * @param model
 319      * @return
 320      * @throws TransformerException
 321      *         In case of issues when doing the XSLT of the BPMN flow
 322      * @throws ParseException
 323      *         In case of issues when parsing the JSON
 324      * @throws GeneralSecurityException
 325      *         In case of issues when decrypting the password
 326      * @throws DecoderException
 327      *         In case of issues with the Hex String decoding
 328      */
 329     public ResponseEntity<?> putModelAndProcessAction(String action,
 330         String modelName,String test, CldsModel model)
 331             throws TransformerException, ParseException {
 332         Date startTime = new Date();
 333         CldsModel retrievedModel = null;
 334         Boolean errorCase = false;
 335         try {
 336             LoggingUtils.setRequestContext("CldsService: Process model action", getPrincipalName());
 337             String actionCd = action.toUpperCase();
 338             SecureServicePermission permisionManage = SecureServicePermission.create(cldsPermissionTypeClManage,
 339                 cldsPermissionInstance, actionCd);
 340             isAuthorized(permisionManage);
 341             isAuthorizedForVf(model);
 342             String userId = getUserId();
 343             logger.info("PUT actionCd={}", actionCd);
 344             logger.info("PUT modelName={}", modelName);
 345             logger.info("PUT test={}", test);
 346             logger.info("PUT bpmnText={}", model.getBpmnText());
 347             logger.info("PUT propText={}", model.getPropText());
 348             logger.info("PUT userId={}", userId);
 349             logger.info("PUT getTypeId={}", model.getTypeId());
 350             logger.info("PUT deploymentId={}", model.getDeploymentId());
 351             this.fillInCldsModel(model);
 352             // save model to db
 353             model.setName(modelName);
 354             updateAndInsertNewEvent(modelName, model.getControlNamePrefix(), model.getEvent(), CldsEvent.ACTION_MODIFY);
 355             model.save(cldsDao, getUserId());
 356             // get vars and format if necessary
 357             String prop = model.getPropText();
 358             String bpmn = model.getBpmnText();
 359             String docText = model.getDocText();
 360             String controlName = model.getControlName();
 361             String bpmnJson = cldsBpmnTransformer.doXslTransformToString(bpmn);
 362             logger.info("PUT bpmnJson={}", bpmnJson);
 363             // Flag indicates whether it is triggered by Validation Test button
 364             // from
 365             // UI
 366             boolean isTest = Boolean.valueOf(test);
 367             if (!isTest) {
 368                 String actionTestOverride = refProp.getStringValue("action.test.override");
 369                 if (Boolean.valueOf(actionTestOverride)) {
 370                     logger.info("PUT actionTestOverride={}", actionTestOverride);
 371                     logger.info("PUT override test indicator and setting it to true");
 372                     isTest = true;
 373                 }
 374             }
 375             logger.info("PUT isTest={}", isTest);
 376             String insertTestEvent = refProp.getStringValue("action.insert.test.event");
 377             boolean isInsertTestEvent = Boolean.valueOf(insertTestEvent);
 378
 379             logger.info("PUT isInsertTestEvent={}", isInsertTestEvent);
 380             // determine if requested action is permitted
 381             model.validateAction(actionCd);
 382             logger.info("modelProp - " + prop);
 383             logger.info("docText - " + docText);
 384             try {
 385                 String result = camelProxy.submit(actionCd, prop, bpmnJson, modelName, controlName, docText, isTest,
 386                     userId, isInsertTestEvent, model.getEvent().getActionCd());
 387                 logger.info("Starting Camel flow on request, result is: ", result);
 388             } catch (SdcCommunicationException | PolicyClientException | BadRequestException e) {
 389                 errorCase = true;
 390                 logger.error("Exception occured during invoking Camel process", e);
 391             }
 392             if (!actionCd.equalsIgnoreCase(CldsEvent.ACTION_DELETE)) {
 393                 // refresh model info from db (get fresh event info)
 394                 retrievedModel = CldsModel.retrieve(cldsDao, modelName, false);
 395             }
 396             if (retrievedModel != null) {
 397                 if (!isTest && (actionCd.equalsIgnoreCase(CldsEvent.ACTION_SUBMIT)
 398                     || actionCd.equalsIgnoreCase(CldsEvent.ACTION_RESUBMIT)
 399                     || actionCd.equalsIgnoreCase(CldsEvent.ACTION_SUBMITDCAE))) {
 400                     if (retrievedModel.getTemplateName().startsWith(CsarInstallerImpl.TEMPLATE_NAME_PREFIX)) {
 401                         // SDC artifact case
 402                         logger.info("Skipping DCAE inventory call as closed loop has been created from SDC notification");
 403                         DcaeEvent dcaeEvent = new DcaeEvent();
 404                         dcaeEvent.setArtifactName(retrievedModel.getControlName() + ".yml");
 405                         dcaeEvent.setEvent(DcaeEvent.EVENT_DISTRIBUTION);
 406                         CldsEvent.insEvent(cldsDao, dcaeEvent.getControlName(), userId, dcaeEvent.getCldsActionCd(),
 407                             CldsEvent.ACTION_STATE_RECEIVED, null);
 408                     } else {
 409                         // This should be done only when the call to DCAE
 410                         // has not yet been done. When CL comes from SDC
 411                         // this is not required as the DCAE inventory call is done
 412                         // during the CL deployment.
 413                         dcaeInventoryServices.setEventInventory(retrievedModel, getUserId());
 414                     }
 415                     retrievedModel.save(cldsDao, getUserId());
 416                 }
 417                 // audit log
 418                 LoggingUtils.setTimeContext(startTime, new Date());
 419                 LoggingUtils.setResponseContext("0", "Process model action success", this.getClass().getName());
 420                 auditLogger.info("Process model action completed");
 421             } else {
 422                 logger.error("CldsModel not found in database with modelName: " + modelName);
 423                 return new ResponseEntity<String>("CldsModel not found in database with modelName: \" + modelName", HttpStatus.INTERNAL_SERVER_ERROR);
 424             }
 425         } catch (Exception e) {
 426             errorCase = true;
 427             logger.error("Exception occured during putModelAndProcessAction", e);
 428         }
 429         if (errorCase) {
 430             return new ResponseEntity<>(retrievedModel, HttpStatus.INTERNAL_SERVER_ERROR);
 431         }
 432         return new ResponseEntity<>(retrievedModel, HttpStatus.OK);
 433     }
 434
 435     /**
 436      * REST service that accepts events for a model.
 437      *
 438      * @param test
 439      * @param dcaeEvent
 440      */
 441     public String postDcaeEvent(String test, DcaeEvent dcaeEvent) {
 442         Date startTime = new Date();
 443         LoggingUtils.setRequestContext("CldsService: Post dcae event", getPrincipalName());
 444         String userid = null;
 445         // TODO: allow auth checking to be turned off by removing the permission
 446         // type property
 447         if (cldsPermissionTypeClEvent != null && cldsPermissionTypeClEvent.length() > 0) {
 448             SecureServicePermission permissionEvent = SecureServicePermission.create(cldsPermissionTypeClEvent,
 449                 cldsPermissionInstance, dcaeEvent.getEvent());
 450             isAuthorized(permissionEvent);
 451             userid = getUserId();
 452         }
 453         // Flag indicates whether it is triggered by Validation Test button from
 454         // UI
 455         boolean isTest = Boolean.valueOf(test);
 456         int instanceCount = 0;
 457         if (dcaeEvent.getInstances() != null) {
 458             instanceCount = dcaeEvent.getInstances().size();
 459         }
 460         String msgInfo = "event=" + dcaeEvent.getEvent() + " serviceUUID=" + dcaeEvent.getServiceUUID()
 461         + " resourceUUID=" + dcaeEvent.getResourceUUID() + " artifactName=" + dcaeEvent.getArtifactName()
 462         + " instance count=" + instanceCount + " isTest=" + isTest;
 463         logger.info("POST dcae event {}", msgInfo);
 464         if (isTest) {
 465             logger.warn("Ignorning test event from DCAE");
 466         } else {
 467             if (DcaeEvent.EVENT_DEPLOYMENT.equalsIgnoreCase(dcaeEvent.getEvent())) {
 468                 CldsModel.insertModelInstance(cldsDao, dcaeEvent, userid);
 469             } else {
 470                 CldsEvent.insEvent(cldsDao, dcaeEvent.getControlName(), userid, dcaeEvent.getCldsActionCd(),
 471                     CldsEvent.ACTION_STATE_RECEIVED, null);
 472             }
 473         }
 474         // audit log
 475         LoggingUtils.setTimeContext(startTime, new Date());
 476         LoggingUtils.setResponseContext("0", "Post dcae event success", this.getClass().getName());
 477         auditLogger.info("Post dcae event completed");
 478         return msgInfo;
 479     }
 480
 481     /**
 482      * REST service that retrieves sdc services
 483      *
 484      * @throws GeneralSecurityException
 485      *         In case of issue when decryting the SDC password
 486      * @throws DecoderException
 487      *         In case of issues with the decoding of the Hex String
 488      */
 489     public String getSdcServices() throws GeneralSecurityException, DecoderException {
 490         Date startTime = new Date();
 491         LoggingUtils.setRequestContext("CldsService: GET sdc services", getPrincipalName());
 492         String retStr;
 493         try {
 494             retStr = createUiServiceFormatJson(sdcCatalogServices.getSdcServicesInformation(null));
 495         } catch (IOException e) {
 496             logger.error("IOException during SDC communication", e);
 497             throw new SdcCommunicationException("IOException during SDC communication", e);
 498         }
 499         logger.info("value of sdcServices : {}", retStr);
 500         // audit log
 501         LoggingUtils.setTimeContext(startTime, new Date());
 502         LoggingUtils.setResponseContext("0", "Get sdc services success", this.getClass().getName());
 503         auditLogger.info("GET sdc services completed");
 504         return retStr;
 505     }
 506
 507     /**
 508      * REST service that retrieves total properties required by UI
 509      *
 510      * @throws IOException
 511      *         In case of issues
 512      */
 513     public String getSdcProperties() throws IOException {
 514         return createPropertiesObjectByUUID("{}");
 515     }
 516
 517     /**
 518      * REST service that retrieves total properties by using invariantUUID based on
 519      * refresh and non refresh
 520      *
 521      * @throws GeneralSecurityException
 522      *         In case of issues with the decryting the encrypted password
 523      * @throws DecoderException
 524      *         In case of issues with the decoding of the Hex String
 525      * @throws IOException
 526      *         In case of issue to convert CldsServiceCache to InputStream
 527      */
 528     public String getSdcPropertiesByServiceUUIDForRefresh(
 529         String serviceInvariantUUID, Boolean refresh)
 530             throws GeneralSecurityException, DecoderException, IOException {
 531         Date startTime = new Date();
 532         LoggingUtils.setRequestContext("CldsService: GET sdc properties by uuid", getPrincipalName());
 533         CldsServiceData cldsServiceData = new CldsServiceData();
 534         cldsServiceData.setServiceInvariantUUID(serviceInvariantUUID);
 535         if (!Optional.ofNullable(refresh).orElse(false)) {
 536             cldsServiceData = cldsDao.getCldsServiceCache(serviceInvariantUUID);
 537         }
 538         if (sdcCatalogServices.isCldsSdcCacheDataExpired(cldsServiceData)) {
 539             cldsServiceData = sdcCatalogServices.getCldsServiceDataWithAlarmConditions(serviceInvariantUUID);
 540             cldsDao.setCldsServiceCache(new CldsDbServiceCache(cldsServiceData));
 541         }
 542         // filter out VFs the user is not authorized for
 543         cldsServiceData.filterVfs(this);
 544         // format retrieved data into properties json
 545         String sdcProperties = sdcCatalogServices.createPropertiesObjectByUUID(cldsServiceData);
 546         // audit log
 547         LoggingUtils.setTimeContext(startTime, new Date());
 548         LoggingUtils.setResponseContext("0", "Get sdc properties by uuid success", this.getClass().getName());
 549         auditLogger.info("GET sdc properties by uuid completed");
 550         return sdcProperties;
 551     }
 552
 553     /**
 554      * Determine if the user is authorized for a particular VF by its invariant
 555      * UUID.
 556      *
 557      * @param vfInvariantUuid
 558      * @throws NotAuthorizedException
 559      * @return
 560      */
 561     public boolean isAuthorizedForVf(String vfInvariantUuid) {
 562         if (cldsPermissionTypeFilterVf != null && !cldsPermissionTypeFilterVf.isEmpty()) {
 563             SecureServicePermission permission = SecureServicePermission.create(cldsPermissionTypeFilterVf,
 564                 cldsPermissionInstance, vfInvariantUuid);
 565             return isAuthorized(permission);
 566         } else {
 567             // if CLDS_PERMISSION_TYPE_FILTER_VF property is not provided, then
 568             // VF filtering is turned off
 569             logger.warn("VF filtering turned off");
 570             return true;
 571         }
 572     }
 573
 574     /**
 575      * Determine if the user is authorized for a particular VF by its invariant
 576      * UUID. If not authorized, then NotAuthorizedException is thrown.
 577      *
 578      * @param model
 579      * @return
 580      */
 581     private boolean isAuthorizedForVf(CldsModel model) {
 582         String vf = ModelProperties.getVf(model);
 583         if (vf == null || vf.length() == 0) {
 584             logger.info("VF not found in model");
 585             return true;
 586         } else {
 587             return isAuthorizedForVf(vf);
 588         }
 589     }
 590
 591     private String createUiServiceFormatJson(String responseStr) throws IOException {
 592         if (StringUtils.isBlank(responseStr)) {
 593             return "";
 594         }
 595         ObjectMapper objectMapper = JacksonUtils.getObjectMapperInstance();
 596         List<SdcServiceInfo> rawList = objectMapper.readValue(responseStr,
 597             objectMapper.getTypeFactory().constructCollectionType(List.class, SdcServiceInfo.class));
 598         ObjectNode invariantIdServiceNode = objectMapper.createObjectNode();
 599         ObjectNode serviceNode = objectMapper.createObjectNode();
 600         logger.info("value of cldsserviceiNfolist: {}", rawList);
 601         if (rawList != null && !rawList.isEmpty()) {
 602             List<SdcServiceInfo> cldsSdcServiceInfoList = sdcCatalogServices.removeDuplicateServices(rawList);
 603             for (SdcServiceInfo currCldsSdcServiceInfo : cldsSdcServiceInfoList) {
 604                 if (currCldsSdcServiceInfo != null) {
 605                     invariantIdServiceNode.put(currCldsSdcServiceInfo.getInvariantUUID(),
 606                         currCldsSdcServiceInfo.getName());
 607                 }
 608             }
 609             serviceNode.putPOJO("service", invariantIdServiceNode);
 610         }
 611         return serviceNode.toString();
 612     }
 613
 614     private String createPropertiesObjectByUUID(String cldsResponseStr) throws IOException {
 615         ObjectMapper mapper = JacksonUtils.getObjectMapperInstance();
 616         SdcServiceDetail cldsSdcServiceDetail = mapper.readValue(cldsResponseStr, SdcServiceDetail.class);
 617         ObjectNode globalPropsJson = (ObjectNode) refProp.getJsonTemplate(GLOBAL_PROPERTIES_KEY);
 618         if (cldsSdcServiceDetail != null && cldsSdcServiceDetail.getUuid() != null) {
 619             /**
 620              * to create json with vf, alarm and locations
 621              */
 622             ObjectNode serviceObjectNode = createEmptyVfAlarmObject();
 623             ObjectNode vfObjectNode = mapper.createObjectNode();
 624             /**
 625              * to create json with vf and vfresourceId
 626              */
 627             createVfObjectNode(vfObjectNode, cldsSdcServiceDetail.getResources());
 628             serviceObjectNode.putPOJO(cldsSdcServiceDetail.getInvariantUUID(), vfObjectNode);
 629             ObjectNode byServiceBasicObjetNode = mapper.createObjectNode();
 630             byServiceBasicObjetNode.putPOJO("byService", serviceObjectNode);
 631             /**
 632              * to create json with VFC Node
 633              */
 634             ObjectNode emptyvfcobjectNode = createByVFCObjectNode(cldsSdcServiceDetail.getResources());
 635             byServiceBasicObjetNode.putPOJO("byVf", emptyvfcobjectNode);
 636             globalPropsJson.putPOJO("shared", byServiceBasicObjetNode);
 637             logger.info("valuie of objNode: {}", globalPropsJson);
 638         }
 639         return globalPropsJson.toString();
 640     }
 641
 642     private ObjectNode createEmptyVfAlarmObject() {
 643         ObjectMapper mapper = JacksonUtils.getObjectMapperInstance();
 644         ObjectNode emptyObjectNode = mapper.createObjectNode();
 645         emptyObjectNode.put("", "");
 646         ObjectNode vfObjectNode = mapper.createObjectNode();
 647         vfObjectNode.putPOJO("vf", emptyObjectNode);
 648         vfObjectNode.putPOJO("location", emptyObjectNode);
 649         vfObjectNode.putPOJO("alarmCondition", emptyObjectNode);
 650         ObjectNode emptyServiceObjectNode = mapper.createObjectNode();
 651         emptyServiceObjectNode.putPOJO("", vfObjectNode);
 652         return emptyServiceObjectNode;
 653     }
 654
 655     private void createVfObjectNode(ObjectNode vfObjectNode2, List<SdcResource> rawCldsSdcResourceList) {
 656         ObjectMapper mapper = JacksonUtils.getObjectMapperInstance();
 657         ObjectNode vfNode = mapper.createObjectNode();
 658         vfNode.put("", "");
 659         // To remove repeated resource instance name from
 660         // resourceInstanceList
 661         List<SdcResource> cldsSdcResourceList = sdcCatalogServices
 662             .removeDuplicateSdcResourceInstances(rawCldsSdcResourceList);
 663         /**
 664          * Creating vf resource node using cldsSdcResource Object
 665          */
 666         if (cldsSdcResourceList != null && !cldsSdcResourceList.isEmpty()) {
 667             for (SdcResource cldsSdcResource : cldsSdcResourceList) {
 668                 if (cldsSdcResource != null && "VF".equalsIgnoreCase(cldsSdcResource.getResoucreType())) {
 669                     vfNode.put(cldsSdcResource.getResourceUUID(), cldsSdcResource.getResourceName());
 670                 }
 671             }
 672         }
 673         vfObjectNode2.putPOJO("vf", vfNode);
 674         /**
 675          * creating location json object using properties file value
 676          */
 677         ObjectNode locationJsonNode;
 678         try {
 679             locationJsonNode = (ObjectNode) mapper.readValue(refProp.getStringValue("ui.location.default"),
 680                 JsonNode.class);
 681         } catch (IOException e) {
 682             logger.error("Unable to load ui.location.default JSON in clds-references.properties properly", e);
 683             throw new CldsConfigException(
 684                 "Unable to load ui.location.default JSON in clds-references.properties properly", e);
 685         }
 686         vfObjectNode2.putPOJO("location", locationJsonNode);
 687         /**
 688          * creating alarm json object using properties file value
 689          */
 690         String alarmStringValue = refProp.getStringValue("ui.alarm.default");
 691         logger.info("value of alarm: {}", alarmStringValue);
 692         ObjectNode alarmStringJsonNode;
 693         try {
 694             alarmStringJsonNode = (ObjectNode) mapper.readValue(alarmStringValue, JsonNode.class);
 695         } catch (IOException e) {
 696             logger.error("Unable to ui.alarm.default JSON in clds-references.properties properly", e);
 697             throw new CldsConfigException("Unable to load ui.alarm.default JSON in clds-references.properties properly",
 698                 e);
 699         }
 700         vfObjectNode2.putPOJO("alarmCondition", alarmStringJsonNode);
 701     }
 702
 703     private ObjectNode createByVFCObjectNode(List<SdcResource> cldsSdcResourceList) {
 704         ObjectMapper mapper = JacksonUtils.getObjectMapperInstance();
 705         ObjectNode emptyObjectNode = mapper.createObjectNode();
 706         ObjectNode emptyvfcobjectNode = mapper.createObjectNode();
 707         ObjectNode vfCObjectNode = mapper.createObjectNode();
 708         vfCObjectNode.putPOJO("vfC", emptyObjectNode);
 709         ObjectNode subVfCObjectNode = mapper.createObjectNode();
 710         subVfCObjectNode.putPOJO("vfc", emptyObjectNode);
 711         if (cldsSdcResourceList != null && !cldsSdcResourceList.isEmpty()) {
 712             for (SdcResource cldsSdcResource : cldsSdcResourceList) {
 713                 if (cldsSdcResource != null && "VF".equalsIgnoreCase(cldsSdcResource.getResoucreType())) {
 714                     vfCObjectNode.putPOJO(cldsSdcResource.getResourceUUID(), subVfCObjectNode);
 715                 }
 716             }
 717         }
 718         emptyvfcobjectNode.putPOJO("", vfCObjectNode);
 719         return emptyvfcobjectNode;
 720     }
 721
 722     public ResponseEntity<CldsModel> deployModel(String modelName, CldsModel model) {
 723         Date startTime = new Date();
 724         LoggingUtils.setRequestContext("CldsService: Deploy model", getPrincipalName());
 725         Boolean errorCase = false;
 726         try {
 727             fillInCldsModel(model);
 728             String bpmnJson = cldsBpmnTransformer.doXslTransformToString(model.getBpmnText());
 729             logger.info("PUT bpmnJson={}", bpmnJson);
 730             SecureServicePermission permisionManage = SecureServicePermission.create(cldsPermissionTypeClManage,
 731                 cldsPermissionInstance, CldsEvent.ACTION_DEPLOY);
 732             isAuthorized(permisionManage);
 733             isAuthorizedForVf(model);
 734             ModelProperties modelProp = new ModelProperties(modelName, model.getControlName(), CldsEvent.ACTION_DEPLOY,
 735                 false, bpmnJson, model.getPropText());
 736             checkForDuplicateServiceVf(modelName, model.getPropText());
 737             String deploymentId = "";
 738             // If model is already deployed then pass same deployment id
 739             if (model.getDeploymentId() != null && !model.getDeploymentId().isEmpty()) {
 740                 deploymentId = model.getDeploymentId();
 741             } else {
 742                 deploymentId = "closedLoop_" + UUID.randomUUID() + "_deploymentId";
 743             }
 744             String createNewDeploymentStatusUrl = dcaeDispatcherServices.createNewDeployment(deploymentId,
 745                 model.getTypeId(), modelProp.getGlobal().getDeployParameters());
 746             String operationStatus = dcaeDispatcherServices.getOperationStatusWithRetry(createNewDeploymentStatusUrl);
 747             if ("succeeded".equalsIgnoreCase(operationStatus)) {
 748                 String artifactName = model.getControlName();
 749                 if (artifactName != null) {
 750                     artifactName = artifactName + ".yml";
 751                 }
 752                 DcaeEvent dcaeEvent = new DcaeEvent();
 753                 /* set dcae events */
 754                 dcaeEvent.setArtifactName(artifactName);
 755                 dcaeEvent.setEvent(DcaeEvent.EVENT_DEPLOYMENT);
 756                 CldsEvent.insEvent(cldsDao, dcaeEvent.getControlName(), getUserId(), dcaeEvent.getCldsActionCd(),
 757                     CldsEvent.ACTION_STATE_RECEIVED, null);
 758                 model.setDeploymentId(deploymentId);
 759                 model.save(cldsDao, getUserId());
 760             } else {
 761                 logger.info("Deploy model (" + modelName + ") failed...Operation Status is - " + operationStatus);
 762                 throw new HttpClientErrorException(HttpStatus.INTERNAL_SERVER_ERROR,
 763                     "Deploy model (" + modelName + ") failed...Operation Status is - " + operationStatus);
 764             }
 765             logger.info("Deploy model (" + modelName + ") succeeded...Deployment Id is - " + deploymentId);
 766             // audit log
 767             LoggingUtils.setTimeContext(startTime, new Date());
 768             LoggingUtils.setResponseContext("0", "Deploy model success", this.getClass().getName());
 769             auditLogger.info("Deploy model completed");
 770         } catch (Exception e) {
 771             errorCase = true;
 772             logger.error("Exception occured during deployModel", e);
 773         }
 774         if (errorCase) {
 775             return new ResponseEntity<>(model, HttpStatus.INTERNAL_SERVER_ERROR);
 776         }
 777         return new ResponseEntity<>(model, HttpStatus.OK);
 778     }
 779
 780     public ResponseEntity<CldsModel> unDeployModel(String modelName, CldsModel model) {
 781         Date startTime = new Date();
 782         LoggingUtils.setRequestContext("CldsService: Undeploy model", getPrincipalName());
 783         Boolean errorCase = false;
 784         try {
 785             SecureServicePermission permisionManage = SecureServicePermission.create(cldsPermissionTypeClManage,
 786                 cldsPermissionInstance, CldsEvent.ACTION_UNDEPLOY);
 787             isAuthorized(permisionManage);
 788             isAuthorizedForVf(model);
 789             String operationStatusUndeployUrl = dcaeDispatcherServices.deleteExistingDeployment(model.getDeploymentId(),
 790                 model.getTypeId());
 791             String operationStatus = dcaeDispatcherServices.getOperationStatusWithRetry(operationStatusUndeployUrl);
 792             if ("succeeded".equalsIgnoreCase(operationStatus)) {
 793                 String artifactName = model.getControlName();
 794                 if (artifactName != null) {
 795                     artifactName = artifactName + ".yml";
 796                 }
 797                 DcaeEvent dcaeEvent = new DcaeEvent();
 798                 // set dcae events
 799                 dcaeEvent.setArtifactName(artifactName);
 800                 dcaeEvent.setEvent(DcaeEvent.EVENT_UNDEPLOYMENT);
 801                 CldsEvent.insEvent(cldsDao, model.getControlName(), getUserId(), dcaeEvent.getCldsActionCd(),
 802                     CldsEvent.ACTION_STATE_RECEIVED, null);
 803                 model.setDeploymentId(null);
 804                 model.save(cldsDao, getUserId());
 805             } else {
 806                 logger.info("Undeploy model (" + modelName + ") failed...Operation Status is - " + operationStatus);
 807                 throw new HttpClientErrorException(HttpStatus.INTERNAL_SERVER_ERROR,
 808                     "Undeploy model (" + modelName + ") failed...Operation Status is - " + operationStatus);
 809             }
 810             logger.info("Undeploy model (" + modelName + ") succeeded.");
 811             // audit log
 812             LoggingUtils.setTimeContext(startTime, new Date());
 813             LoggingUtils.setResponseContext("0", "Undeploy model success", this.getClass().getName());
 814             auditLogger.info("Undeploy model completed");
 815         } catch (Exception e) {
 816             errorCase = true;
 817             logger.error("Exception occured during unDeployModel", e);
 818         }
 819         if (errorCase) {
 820             return new ResponseEntity<>(model, HttpStatus.INTERNAL_SERVER_ERROR);
 821         }
 822         return new ResponseEntity<>(model, HttpStatus.OK);
 823     }
 824
 825     private void checkForDuplicateServiceVf(String modelName, String modelPropText) throws IOException {
 826         JsonNode globalNode = JacksonUtils.getObjectMapperInstance().readTree(modelPropText).get("global");
 827         String service = AbstractModelElement.getValueByName(globalNode, "service");
 828         List<String> resourceVf = AbstractModelElement.getValuesByName(globalNode, "vf");
 829         if (service != null && resourceVf != null && !resourceVf.isEmpty()) {
 830             List<CldsModelProp> cldsModelPropList = cldsDao.getDeployedModelProperties();
 831             for (CldsModelProp cldsModelProp : cldsModelPropList) {
 832                 JsonNode currentNode = JacksonUtils.getObjectMapperInstance().readTree(cldsModelProp.getPropText())
 833                     .get("global");
 834                 String currentService = AbstractModelElement.getValueByName(currentNode, "service");
 835                 List<String> currentVf = AbstractModelElement.getValuesByName(currentNode, "vf");
 836                 if (currentVf != null && !currentVf.isEmpty()) {
 837                     if (!modelName.equalsIgnoreCase(cldsModelProp.getName()) && service.equalsIgnoreCase(currentService)
 838                         && resourceVf.get(0).equalsIgnoreCase(currentVf.get(0))) {
 839                         throw new BadRequestException("Same Service/VF already exists in " + cldsModelProp.getName()
 840                         + " model, please select different Service/VF.");
 841                     }
 842                 }
 843             }
 844         }
 845     }
 846
 847     private void updateAndInsertNewEvent(String cldsModelName, String cldsControlNamePrfx, CldsEvent event,
 848         String newAction) {
 849         // If model action is in submit/resubmit/distributed and user try
 850         // to save then we are changing action back to create.
 851         if (event != null && (CldsEvent.ACTION_SUBMIT.equalsIgnoreCase(event.getActionCd())
 852             || CldsEvent.ACTION_RESUBMIT.equalsIgnoreCase(event.getActionCd())
 853             || CldsEvent.ACTION_DISTRIBUTE.equalsIgnoreCase(event.getActionCd()))) {
 854             CldsEvent newEvent = new CldsEvent();
 855             newEvent.setUserid(getUserId());
 856             newEvent.setActionCd(newAction);
 857             newEvent.setActionStateCd(CldsEvent.ACTION_STATE_COMPLETED);
 858             cldsDao.insEvent(cldsModelName, cldsControlNamePrfx, null, newEvent);
 859         }
 860     }
 861 }