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

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * ONAP CLAMP
   4  * ================================================================================
   5  * Copyright (C) 2017 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  * ===================================================================
  21  * ECOMP is a trademark and service mark of AT&T Intellectual Property.
  22  */
  23
  24 package org.onap.clamp.clds.service;
  25
  26 import com.att.ajsc.common.AjscService;
  27 import com.fasterxml.jackson.databind.JsonNode;
  28 import com.fasterxml.jackson.databind.ObjectMapper;
  29 import com.fasterxml.jackson.databind.node.ObjectNode;
  30
  31 import java.io.IOException;
  32 import java.io.InputStream;
  33 import java.util.Date;
  34 import java.util.HashMap;
  35 import java.util.List;
  36 import java.util.Map;
  37 import java.util.Properties;
  38 import java.util.UUID;
  39 import java.util.concurrent.TimeUnit;
  40
  41 import javax.annotation.PostConstruct;
  42 import javax.ws.rs.Consumes;
  43 import javax.ws.rs.DefaultValue;
  44 import javax.ws.rs.GET;
  45 import javax.ws.rs.NotAuthorizedException;
  46 import javax.ws.rs.POST;
  47 import javax.ws.rs.PUT;
  48 import javax.ws.rs.Path;
  49 import javax.ws.rs.PathParam;
  50 import javax.ws.rs.Produces;
  51 import javax.ws.rs.QueryParam;
  52 import javax.ws.rs.core.MediaType;
  53 import javax.xml.transform.TransformerException;
  54
  55 import org.apache.commons.lang3.StringUtils;
  56 import org.camunda.bpm.engine.RuntimeService;
  57 import org.camunda.bpm.engine.runtime.ProcessInstance;
  58 import org.json.simple.parser.ParseException;
  59 import org.onap.clamp.clds.client.DcaeDispatcherServices;
  60 import org.onap.clamp.clds.client.DcaeInventoryServices;
  61 import org.onap.clamp.clds.client.SdcCatalogServices;
  62 import org.onap.clamp.clds.dao.CldsDao;
  63 import org.onap.clamp.clds.exception.CldsConfigException;
  64 import org.onap.clamp.clds.exception.SdcCommunicationException;
  65 import org.onap.clamp.clds.model.CldsDBServiceCache;
  66 import org.onap.clamp.clds.model.CldsEvent;
  67 import org.onap.clamp.clds.model.CldsHealthCheck;
  68 import org.onap.clamp.clds.model.CldsInfo;
  69 import org.onap.clamp.clds.model.CldsModel;
  70 import org.onap.clamp.clds.model.CldsSdcResource;
  71 import org.onap.clamp.clds.model.CldsSdcServiceDetail;
  72 import org.onap.clamp.clds.model.CldsSdcServiceInfo;
  73 import org.onap.clamp.clds.model.CldsServiceData;
  74 import org.onap.clamp.clds.model.CldsTemplate;
  75 import org.onap.clamp.clds.model.DcaeEvent;
  76 import org.onap.clamp.clds.model.ValueItem;
  77 import org.onap.clamp.clds.model.prop.ModelProperties;
  78 import org.onap.clamp.clds.model.refprop.RefProp;
  79 import org.onap.clamp.clds.transform.XslTransformer;
  80 import org.onap.clamp.clds.util.LoggingUtils;
  81 import org.springframework.beans.factory.annotation.Autowired;
  82 import org.springframework.beans.factory.annotation.Value;
  83 import org.springframework.context.ApplicationContext;
  84 import org.springframework.http.HttpStatus;
  85 import org.springframework.web.client.HttpClientErrorException;
  86
  87 import io.swagger.annotations.Api;
  88 import io.swagger.annotations.ApiOperation;
  89
  90 /**
  91  * Service to save and retrieve the CLDS model attributes.
  92  */
  93 @AjscService
  94 @Api(value = "/clds")
  95 @Path("/clds")
  96 public class CldsService extends SecureServiceBase {
  97
  98     @Autowired
  99     private ApplicationContext      appContext;
 100
 101     private static final String     RESOURCE_NAME = "clds-version.properties";
 102
 103     @Value("${CLDS_PERMISSION_TYPE_CL:permission-type-cl}")
 104     private String                  cldsPersmissionTypeCl;
 105
 106     @Value("${CLDS_PERMISSION_TYPE_CL_MANAGE:permission-type-cl-manage}")
 107     private String                  cldsPermissionTypeClManage;
 108
 109     @Value("${CLDS_PERMISSION_TYPE_CL_EVENT:permission-type-cl-event}")
 110     private String                  cldsPermissionTypeClEvent;
 111
 112     @Value("${CLDS_PERMISSION_TYPE_FILTER_VF:permission-type-filter-vf}")
 113     private String                  cldsPermissionTypeFilterVf;
 114
 115     @Value("${CLDS_PERMISSION_TYPE_TEMPLATE:permission-type-template}")
 116     private String                  cldsPermissionTypeTemplate;
 117
 118     @Value("${CLDS_PERMISSION_INSTANCE:dev}")
 119     private String                  cldsPermissionInstance;
 120
 121     private SecureServicePermission permissionReadCl;
 122
 123     private SecureServicePermission permissionUpdateCl;
 124
 125     private SecureServicePermission permissionReadTemplate;
 126
 127     private SecureServicePermission permissionUpdateTemplate;
 128
 129     @PostConstruct
 130     private final void afterConstruction() {
 131         permissionReadCl = SecureServicePermission.create(cldsPersmissionTypeCl, cldsPermissionInstance, "read");
 132         permissionUpdateCl = SecureServicePermission.create(cldsPersmissionTypeCl, cldsPermissionInstance, "update");
 133         permissionReadTemplate = SecureServicePermission.create(cldsPermissionTypeTemplate, cldsPermissionInstance,
 134                 "read");
 135         permissionUpdateTemplate = SecureServicePermission.create(cldsPermissionTypeTemplate, cldsPermissionInstance,
 136                 "update");
 137     }
 138
 139     @Value("${org.onap.clamp.config.files.globalClds:'classpath:/clds/globalClds.properties'}")
 140     private String                 globalClds;
 141
 142     private Properties             globalCldsProperties;
 143
 144     @Autowired
 145     private CldsDao                cldsDao;
 146     @Autowired
 147     private RuntimeService         runtimeService;
 148     @Autowired
 149     private XslTransformer         cldsBpmnTransformer;
 150
 151     @Autowired
 152     private RefProp                refProp;
 153
 154     @Autowired
 155     private SdcCatalogServices     sdcCatalogServices;
 156
 157     @Autowired
 158     private DcaeDispatcherServices dcaeDispatcherServices;
 159
 160     @Autowired
 161     private DcaeInventoryServices  dcaeInventoryServices;
 162
 163     public CldsService() {
 164     }
 165
 166     public CldsService(RefProp refProp) {
 167         this.refProp = refProp;
 168     }
 169
 170     /*
 171      *
 172      * CLDS IFO service will return 3 things 1. User Name 2. CLDS code version
 173      * that is currently installed from pom.xml file 3. User permissions
 174      *
 175      */
 176
 177     @GET
 178     @Path("/cldsInfo")
 179     @Produces(MediaType.APPLICATION_JSON)
 180     public CldsInfo getCldsInfo() {
 181
 182         CldsInfo cldsInfo = new CldsInfo();
 183
 184         // Get the user info
 185         cldsInfo.setUserName(getUserName());
 186
 187         // Get CLDS application version
 188         String cldsVersion = "";
 189         Properties props = new Properties();
 190
 191         ClassLoader loader = Thread.currentThread().getContextClassLoader();
 192
 193         try (InputStream resourceStream = loader.getResourceAsStream(RESOURCE_NAME)) {
 194             props.load(resourceStream);
 195             cldsVersion = props.getProperty("clds.version");
 196         } catch (Exception ex) {
 197             logger.error("Exception caught during the clds.version reading", ex);
 198         }
 199         cldsInfo.setCldsVersion(cldsVersion);
 200
 201         // Get the user list of permissions
 202         cldsInfo.setPermissionReadCl(isAuthorizedNoException(permissionReadCl));
 203         cldsInfo.setPermissionUpdateCl(isAuthorizedNoException(permissionUpdateCl));
 204         cldsInfo.setPermissionReadTemplate(isAuthorizedNoException(permissionReadTemplate));
 205         cldsInfo.setPermissionUpdateTemplate(isAuthorizedNoException(permissionUpdateTemplate));
 206         return cldsInfo;
 207     }
 208
 209     @GET
 210     @Path("/healthcheck")
 211     @Produces(MediaType.APPLICATION_JSON)
 212     public CldsHealthCheck gethealthcheck() {
 213
 214         CldsHealthCheck cldsHealthCheck = new CldsHealthCheck();
 215
 216         try {
 217             cldsDao.doHealthCheck();
 218             cldsHealthCheck.setHealthCheckComponent("CLDS-APP");
 219             cldsHealthCheck.setHealthCheckStatus("UP");
 220             cldsHealthCheck.setDescription("OK");
 221         } catch (Exception e) {
 222             logger.error("CLAMP application DB Error", e);
 223             cldsHealthCheck.setHealthCheckComponent("CLDS-APP");
 224             cldsHealthCheck.setHealthCheckStatus("DOWN");
 225             cldsHealthCheck.setDescription("NOT-OK");
 226         }
 227         return cldsHealthCheck;
 228
 229     }
 230
 231     /**
 232      * REST service that retrieves BPMN for a CLDS model name from the database.
 233      * This is subset of the json getModel. This is only expected to be used for
 234      * testing purposes, not by the UI.
 235      *
 236      * @param modelName
 237      * @return bpmn xml text - content of bpmn given name
 238      */
 239     @ApiOperation(value = "Retrieves BPMN for a CLDS model name from the database", notes = "This is only expected to be used for testing purposes, not by the UI", response = String.class)
 240     @GET
 241     @Path("/model/bpmn/{modelName}")
 242     @Produces(MediaType.TEXT_XML)
 243     public String getBpmnXml(@PathParam("modelName") String modelName) {
 244         Date startTime = new Date();
 245         LoggingUtils.setRequestContext("CldsService: GET model bpmn", getPrincipalName());
 246         isAuthorized(permissionReadCl);
 247         logger.info("GET bpmnText for modelName={}", modelName);
 248         CldsModel model = CldsModel.retrieve(cldsDao, modelName, false);
 249         // audit log
 250         LoggingUtils.setTimeContext(startTime, new Date());
 251         LoggingUtils.setResponseContext("0", "Get model bpmn success", this.getClass().getName());
 252         auditLogger.info("GET model bpmn completed");
 253         return model.getBpmnText();
 254     }
 255
 256     /**
 257      * REST service that saves BPMN for a CLDS model by name in the database.
 258      * This is subset of the json putModel. This is only expected to be used for
 259      * testing purposes, not by the UI.
 260      *
 261      * @param modelName
 262      */
 263     @ApiOperation(value = "Saves BPMN for a CLDS model by name in the database", notes = "This is only expected to be used for testing purposes, not by the UI", response = String.class)
 264     @PUT
 265     @Path("/model/bpmn/{modelName}")
 266     @Consumes(MediaType.TEXT_XML)
 267     public String putBpmnXml(@PathParam("modelName") String modelName, String bpmnText) {
 268         LoggingUtils.setRequestContext("CldsService: PUT model bpmn", getPrincipalName());
 269         isAuthorized(permissionUpdateCl);
 270         logger.info("PUT bpmnText for modelName={}", modelName);
 271         logger.info("PUT bpmnText={}", bpmnText);
 272         CldsModel cldsModel = CldsModel.retrieve(cldsDao, modelName, true);
 273         cldsModel.setBpmnText(bpmnText);
 274         cldsModel.save(cldsDao, getUserId());
 275         // audit log
 276         LoggingUtils.setTimeContext(new Date(), new Date());
 277         LoggingUtils.setResponseContext("0", "Put model bpmn success", this.getClass().getName());
 278         auditLogger.info("PUT model bpmn completed");
 279         return "wrote bpmnText for modelName=" + modelName;
 280     }
 281
 282     /**
 283      * REST service that retrieves image for a CLDS model name from the
 284      * database. This is subset of the json getModel. This is only expected to
 285      * be used for testing purposes, not by the UI.
 286      *
 287      * @param modelName
 288      * @return image xml text - content of image given name
 289      */
 290     @ApiOperation(value = "Retrieves image for a CLDS model name from the database", notes = "This is only expected to be used for testing purposes, not by the UI", response = String.class)
 291     @GET
 292     @Path("/model/image/{modelName}")
 293     @Produces(MediaType.TEXT_XML)
 294     public String getImageXml(@PathParam("modelName") String modelName) {
 295         Date startTime = new Date();
 296         LoggingUtils.setRequestContext("CldsService: GET model image", getPrincipalName());
 297         isAuthorized(permissionReadCl);
 298         logger.info("GET imageText for modelName={}", modelName);
 299         CldsModel model = CldsModel.retrieve(cldsDao, modelName, false);
 300         // audit log
 301         LoggingUtils.setTimeContext(startTime, new Date());
 302         LoggingUtils.setResponseContext("0", "Get model image success", this.getClass().getName());
 303         auditLogger.info("GET model image completed");
 304         return model.getImageText();
 305     }
 306
 307     /**
 308      * REST service that saves image for a CLDS model by name in the database.
 309      * This is subset of the json putModel. This is only expected to be used for
 310      * testing purposes, not by the UI.
 311      *
 312      * @param modelName
 313      */
 314     @ApiOperation(value = "Saves image for a CLDS model by name in the database", notes = "This is only expected to be used for testing purposes, not by the UI", response = String.class)
 315     @PUT
 316     @Path("/model/image/{modelName}")
 317     @Consumes(MediaType.TEXT_XML)
 318     public String putImageXml(@PathParam("modelName") String modelName, String imageText) {
 319         Date startTime = new Date();
 320         LoggingUtils.setRequestContext("CldsService: PUT model image", getPrincipalName());
 321         isAuthorized(permissionUpdateCl);
 322         logger.info("PUT iamgeText for modelName={}", modelName);
 323         logger.info("PUT imageText={}", imageText);
 324         CldsModel cldsModel = CldsModel.retrieve(cldsDao, modelName, true);
 325         cldsModel.setImageText(imageText);
 326         cldsModel.save(cldsDao, getUserId());
 327         // audit log
 328         LoggingUtils.setTimeContext(startTime, new Date());
 329         LoggingUtils.setResponseContext("0", "Put model image success", this.getClass().getName());
 330         auditLogger.info("PUT model image completed");
 331         return "wrote imageText for modelName=" + modelName;
 332     }
 333
 334     /**
 335      * REST service that retrieves a CLDS model by name from the database.
 336      *
 337      * @param modelName
 338      * @return clds model - clds model for the given model name
 339      */
 340     @ApiOperation(value = "Retrieves a CLDS model by name from the database", notes = "", response = String.class)
 341     @GET
 342     @Path("/model/{modelName}")
 343     @Produces(MediaType.APPLICATION_JSON)
 344     public CldsModel getModel(@PathParam("modelName") String modelName) {
 345         Date startTime = new Date();
 346         LoggingUtils.setRequestContext("CldsService: GET model", getPrincipalName());
 347         isAuthorized(permissionReadCl);
 348         logger.debug("GET model for  modelName={}", modelName);
 349         CldsModel cldsModel = CldsModel.retrieve(cldsDao, modelName, false);
 350         isAuthorizedForVf(cldsModel);
 351         cldsModel.setUserAuthorizedToUpdate(isAuthorizedNoException(permissionUpdateCl));
 352
 353         /**
 354          * Checking condition whether our CLDS model can call INventory Method
 355          */
 356         if (cldsModel.canInventoryCall()) {
 357             try {
 358                 /*
 359                  * Below is the method to for inventory call and DB insert for
 360                  * event methods
 361                  */
 362                 dcaeInventoryServices.setEventInventory(cldsModel, getUserId());
 363             } catch (Exception e) {
 364                 LoggingUtils.setErrorContext("900", "Set event inventory error");
 365                 logger.error("getModel set event Inventory error:" + e);
 366             }
 367         }
 368         // audit log
 369         LoggingUtils.setTimeContext(startTime, new Date());
 370         LoggingUtils.setResponseContext("0", "Get model success", this.getClass().getName());
 371         auditLogger.info("GET model completed");
 372         return cldsModel;
 373     }
 374
 375     /**
 376      * REST service that saves a CLDS model by name in the database.
 377      *
 378      * @param modelName
 379      */
 380     @ApiOperation(value = "Saves a CLDS model by name in the database", notes = "", response = String.class)
 381     @PUT
 382     @Path("/model/{modelName}")
 383     @Consumes(MediaType.APPLICATION_JSON)
 384     @Produces(MediaType.APPLICATION_JSON)
 385     public CldsModel putModel(@PathParam("modelName") String modelName, CldsModel cldsModel) {
 386         Date startTime = new Date();
 387         LoggingUtils.setRequestContext("CldsService: PUT model", getPrincipalName());
 388         isAuthorized(permissionUpdateCl);
 389         isAuthorizedForVf(cldsModel);
 390         logger.info("PUT model for  modelName={}", modelName);
 391         logger.info("PUT bpmnText={}", cldsModel.getBpmnText());
 392         logger.info("PUT propText={}", cldsModel.getPropText());
 393         logger.info("PUT imageText={}", cldsModel.getImageText());
 394         cldsModel.setName(modelName);
 395
 396         if (cldsModel.getTemplateName() != null) {
 397             CldsTemplate template = cldsDao.getTemplate(cldsModel.getTemplateName());
 398             if (template != null) {
 399                 cldsModel.setTemplateId(template.getId());
 400                 cldsModel.setDocText(template.getPropText());
 401                 cldsModel.setDocId(template.getPropId());
 402             }
 403         }
 404         cldsModel.save(cldsDao, getUserId());
 405         // audit log
 406         LoggingUtils.setTimeContext(startTime, new Date());
 407         LoggingUtils.setResponseContext("0", "Put model success", this.getClass().getName());
 408         auditLogger.info("PUT model completed");
 409         return cldsModel;
 410     }
 411
 412     /**
 413      * REST service that retrieves a list of CLDS model names.
 414      *
 415      * @return model names in JSON
 416      */
 417     @ApiOperation(value = "Retrieves a list of CLDS model names", notes = "", response = String.class)
 418     @GET
 419     @Path("/model-names")
 420     @Produces(MediaType.APPLICATION_JSON)
 421     public List<ValueItem> getModelNames() {
 422         Date startTime = new Date();
 423         LoggingUtils.setRequestContext("CldsService: GET model names", getPrincipalName());
 424         isAuthorized(permissionReadCl);
 425         logger.info("GET list of model names");
 426         List<ValueItem> names = cldsDao.getBpmnNames();
 427         // audit log
 428         LoggingUtils.setTimeContext(startTime, new Date());
 429         LoggingUtils.setResponseContext("0", "Get model names success", this.getClass().getName());
 430         auditLogger.info("GET model names completed");
 431         return names;
 432     }
 433
 434     /**
 435      * REST service that saves and processes an action for a CLDS model by name.
 436      *
 437      * @param action
 438      * @param modelName
 439      * @param test
 440      * @param model
 441      * @return
 442      * @throws TransformerException
 443      * @throws ParseException
 444      */
 445     @ApiOperation(value = "Saves and processes an action for a CLDS model by name", notes = "", response = String.class)
 446     @PUT
 447     @Path("/action/{action}/{modelName}")
 448     @Consumes(MediaType.APPLICATION_JSON)
 449     @Produces(MediaType.APPLICATION_JSON)
 450     public CldsModel putModelAndProcessAction(@PathParam("action") String action,
 451             @PathParam("modelName") String modelName, @QueryParam("test") String test, CldsModel model)
 452             throws TransformerException, ParseException {
 453         Date startTime = new Date();
 454         LoggingUtils.setRequestContext("CldsService: Process model action", getPrincipalName());
 455         String actionCd = action.toUpperCase();
 456         SecureServicePermission permisionManage = SecureServicePermission.create(cldsPermissionTypeClManage,
 457                 cldsPermissionInstance, actionCd);
 458         isAuthorized(permisionManage);
 459         isAuthorizedForVf(model);
 460         String userid = getUserId();
 461         String actionStateCd = CldsEvent.ACTION_STATE_INITIATED;
 462         String processDefinitionKey = "clds-process-action-wf";
 463
 464         logger.info("PUT actionCd={}", actionCd);
 465         logger.info("PUT actionStateCd={}", actionStateCd);
 466         logger.info("PUT processDefinitionKey={}", processDefinitionKey);
 467         logger.info("PUT modelName={}", modelName);
 468         logger.info("PUT test={}", test);
 469         logger.info("PUT bpmnText={}", model.getBpmnText());
 470         logger.info("PUT propText={}", model.getPropText());
 471         logger.info("PUT userid={}", userid);
 472         logger.info("PUT getTypeId={}", model.getTypeId());
 473         logger.info("PUT deploymentId={}", model.getDeploymentId());
 474
 475         if (model.getTemplateName() != null) {
 476             CldsTemplate template = cldsDao.getTemplate(model.getTemplateName());
 477             if (template != null) {
 478                 model.setTemplateId(template.getId());
 479                 model.setDocText(template.getPropText());
 480                 model.setDocId(template.getPropId());
 481             }
 482         }
 483         // save model to db
 484         model.setName(modelName);
 485         model.save(cldsDao, getUserId());
 486
 487         // get vars and format if necessary
 488         String prop = model.getPropText();
 489         String bpmn = model.getBpmnText();
 490         String docText = model.getDocText();
 491         String controlName = model.getControlName();
 492
 493         String bpmnJson = cldsBpmnTransformer.doXslTransformToString(bpmn);
 494         logger.info("PUT bpmnJson={}", bpmnJson);
 495
 496         // Flag indicates whether it is triggered by Validation Test button from
 497         // UI
 498         boolean isTest = false;
 499         if (test != null && test.equalsIgnoreCase("true")) {
 500             isTest = true;
 501         } else {
 502             String actionTestOverride = refProp.getStringValue("action.test.override");
 503             if (actionTestOverride != null && actionTestOverride.equalsIgnoreCase("true")) {
 504                 logger.info("PUT actionTestOverride={}", actionTestOverride);
 505                 logger.info("PUT override test indicator and setting it to true");
 506                 isTest = true;
 507             }
 508         }
 509         logger.info("PUT isTest={}", isTest);
 510
 511         boolean isInsertTestEvent = false;
 512         String insertTestEvent = refProp.getStringValue("action.insert.test.event");
 513         if (insertTestEvent != null && insertTestEvent.equalsIgnoreCase("true")) {
 514             isInsertTestEvent = true;
 515         }
 516         logger.info("PUT isInsertTestEvent={}", isInsertTestEvent);
 517
 518         // determine if requested action is permitted
 519         model.validateAction(actionCd);
 520
 521         // input variables to camunda process
 522         Map<String, Object> variables = new HashMap<>();
 523         variables.put("actionCd", actionCd);
 524         variables.put("modelProp", prop.getBytes());
 525         variables.put("modelBpmnProp", bpmnJson);
 526         variables.put("modelName", modelName);
 527         variables.put("controlName", controlName);
 528         variables.put("docText", docText.getBytes());
 529         variables.put("isTest", isTest);
 530         variables.put("userid", userid);
 531         variables.put("isInsertTestEvent", isInsertTestEvent);
 532         logger.info("modelProp - " + prop);
 533         logger.info("docText - " + docText);
 534
 535         // start camunda process
 536         ProcessInstance pi = runtimeService.startProcessInstanceByKey(processDefinitionKey, variables);
 537
 538         // log process info
 539         logger.info("Started processDefinitionId={}, processInstanceId={}", pi.getProcessDefinitionId(),
 540                 pi.getProcessInstanceId());
 541
 542         // refresh model info from db (get fresh event info)
 543         CldsModel retreivedModel = CldsModel.retrieve(cldsDao, modelName, false);
 544
 545         if (actionCd.equalsIgnoreCase(CldsEvent.ACTION_SUBMIT)
 546                 || actionCd.equalsIgnoreCase(CldsEvent.ACTION_RESUBMIT)) {
 547             // To verify inventory status and modify model status to distribute
 548             dcaeInventoryServices.setEventInventory(retreivedModel, getUserId());
 549             retreivedModel.save(cldsDao, getUserId());
 550         }
 551         // audit log
 552         LoggingUtils.setTimeContext(startTime, new Date());
 553         LoggingUtils.setResponseContext("0", "Process model action success", this.getClass().getName());
 554         auditLogger.info("Process model action completed");
 555
 556         return retreivedModel;
 557     }
 558
 559     /**
 560      * REST service that accepts events for a model.
 561      *
 562      * @param test
 563      * @param dcaeEvent
 564      */
 565     @ApiOperation(value = "Accepts events for a model", notes = "", response = String.class)
 566     @POST
 567     @Path("/dcae/event")
 568     @Consumes(MediaType.APPLICATION_JSON)
 569     @Produces(MediaType.APPLICATION_JSON)
 570     public String postDcaeEvent(@QueryParam("test") String test, DcaeEvent dcaeEvent) {
 571         Date startTime = new Date();
 572         LoggingUtils.setRequestContext("CldsService: Post dcae event", getPrincipalName());
 573         String userid = null;
 574         // TODO: allow auth checking to be turned off by removing the permission
 575         // type property
 576         if (cldsPermissionTypeClEvent != null && cldsPermissionTypeClEvent.length() > 0) {
 577             SecureServicePermission permissionEvent = SecureServicePermission.create(cldsPermissionTypeClEvent,
 578                     cldsPermissionInstance, dcaeEvent.getEvent());
 579             isAuthorized(permissionEvent);
 580             userid = getUserId();
 581         }
 582
 583         // Flag indicates whether it is triggered by Validation Test button from
 584         // UI
 585         boolean isTest = false;
 586         if (test != null && test.equalsIgnoreCase("true")) {
 587             isTest = true;
 588         }
 589
 590         int instanceCount = 0;
 591         if (dcaeEvent.getInstances() != null) {
 592             instanceCount = dcaeEvent.getInstances().size();
 593         }
 594         String msgInfo = "event=" + dcaeEvent.getEvent() + " serviceUUID=" + dcaeEvent.getServiceUUID()
 595                 + " resourceUUID=" + dcaeEvent.getResourceUUID() + " artifactName=" + dcaeEvent.getArtifactName()
 596                 + " instance count=" + instanceCount + " isTest=" + isTest;
 597         logger.info("POST dcae event {}", msgInfo);
 598
 599         if (isTest) {
 600             logger.warn("Ignorning test event from DCAE");
 601         } else {
 602             if (DcaeEvent.EVENT_DEPLOYMENT.equalsIgnoreCase(dcaeEvent.getEvent())) {
 603                 CldsModel.insertModelInstance(cldsDao, dcaeEvent, userid);
 604             } else {
 605                 CldsEvent.insEvent(cldsDao, dcaeEvent.getControlName(), userid, dcaeEvent.getCldsActionCd(),
 606                         CldsEvent.ACTION_STATE_RECEIVED, null);
 607             }
 608         }
 609         // audit log
 610         LoggingUtils.setTimeContext(startTime, new Date());
 611         LoggingUtils.setResponseContext("0", "Post dcae event success", this.getClass().getName());
 612         auditLogger.info("Post dcae event completed");
 613
 614         return msgInfo;
 615     }
 616
 617     /**
 618      * REST service that retrieves sdc services
 619      *
 620      * @throws Exception
 621      */
 622     @ApiOperation(value = "Retrieves sdc services", notes = "", response = String.class)
 623     @GET
 624     @Path("/sdc/services")
 625     @Produces(MediaType.APPLICATION_JSON)
 626     public String getSdcServices() {
 627         Date startTime = new Date();
 628         LoggingUtils.setRequestContext("CldsService: GET sdc services", getPrincipalName());
 629         String retStr;
 630
 631         String responseStr = sdcCatalogServices.getSdcServicesInformation(null);
 632         try {
 633             retStr = createUiServiceFormatJson(responseStr);
 634         } catch (IOException e) {
 635             logger.error("IOException during SDC communication", e);
 636             throw new SdcCommunicationException("IOException during SDC communication", e);
 637         }
 638
 639         logger.info("value of sdcServices : {}", retStr);
 640         // audit log
 641         LoggingUtils.setTimeContext(startTime, new Date());
 642         LoggingUtils.setResponseContext("0", "Get sdc services success", this.getClass().getName());
 643         auditLogger.info("GET sdc services completed");
 644         return retStr;
 645     }
 646
 647     /**
 648      * REST service that retrieves total properties required by UI
 649      *
 650      * @throws IOException
 651      *             In case of issues
 652      *
 653      */
 654     @ApiOperation(value = "Retrieves total properties required by UI", notes = "", response = String.class)
 655     @GET
 656     @Path("/properties")
 657     @Produces(MediaType.APPLICATION_JSON)
 658     public String getSdcProperties() throws IOException {
 659         return createPropertiesObjectByUUID(getGlobalCldsString(), "{}");
 660     }
 661
 662     /**
 663      * REST service that retrieves total properties by using invariantUUID based
 664      * on refresh and non refresh
 665      *
 666      */
 667     @ApiOperation(value = "Retrieves total properties by using invariantUUID based on refresh and non refresh", notes = "", response = String.class)
 668     @GET
 669     @Path("/properties/{serviceInvariantUUID}")
 670     @Produces(MediaType.APPLICATION_JSON)
 671     public String getSdcPropertiesByServiceUUIDForRefresh(
 672             @PathParam("serviceInvariantUUID") String serviceInvariantUUID,
 673             @DefaultValue("false") @QueryParam("refresh") String refresh) {
 674         Date startTime = new Date();
 675         LoggingUtils.setRequestContext("CldsService: GET sdc properties by uuid", getPrincipalName());
 676         CldsServiceData cldsServiceData = new CldsServiceData();
 677         cldsServiceData.setServiceInvariantUUID(serviceInvariantUUID);
 678
 679         boolean isCldsSdcDataExpired = true;
 680         // To getcldsService information from database cache using invariantUUID
 681         // only when refresh = false
 682         if (refresh != null && refresh.equalsIgnoreCase("false")) {
 683             cldsServiceData = cldsServiceData.getCldsServiceCache(cldsDao, serviceInvariantUUID);
 684             // If cldsService is available in database Cache , verify is data
 685             // expired or not
 686             if (cldsServiceData != null) {
 687                 isCldsSdcDataExpired = sdcCatalogServices.isCldsSdcCacheDataExpired(cldsServiceData);
 688             }
 689         }
 690         // If user Requested for refresh or database cache expired , get all
 691         // data from sdc api.
 692         if ((refresh != null && refresh.equalsIgnoreCase("true")) || isCldsSdcDataExpired) {
 693             cldsServiceData = sdcCatalogServices.getCldsServiceDataWithAlarmConditions(serviceInvariantUUID);
 694             CldsDBServiceCache cldsDBServiceCache = sdcCatalogServices
 695                     .getCldsDbServiceCacheUsingCldsServiceData(cldsServiceData);
 696             if (cldsDBServiceCache != null && cldsDBServiceCache.getInvariantId() != null
 697                     && cldsDBServiceCache.getServiceId() != null) {
 698                 cldsServiceData.setCldsServiceCache(cldsDao, cldsDBServiceCache);
 699             }
 700         }
 701
 702         // filter out VFs the user is not authorized for
 703         cldsServiceData.filterVfs(this);
 704
 705         // audit log
 706         LoggingUtils.setTimeContext(startTime, new Date());
 707         LoggingUtils.setResponseContext("0", "Get sdc properties by uuid success", this.getClass().getName());
 708         auditLogger.info("GET sdc properties by uuid completed");
 709
 710         // format retrieved data into properties json
 711         return sdcCatalogServices.createPropertiesObjectByUUID(getGlobalCldsString(), cldsServiceData);
 712     }
 713
 714     /**
 715      * Determine if the user is authorized for a particular VF by its invariant
 716      * UUID.
 717      *
 718      * @param vfInvariantUuid
 719      * @throws NotAuthorizedException
 720      * @return
 721      */
 722     public boolean isAuthorizedForVf(String vfInvariantUuid) {
 723         if (cldsPermissionTypeFilterVf != null && !cldsPermissionTypeFilterVf.isEmpty()) {
 724             SecureServicePermission permission = SecureServicePermission.create(cldsPermissionTypeFilterVf,
 725                     cldsPermissionInstance, vfInvariantUuid);
 726             return isAuthorized(permission);
 727         } else {
 728             // if CLDS_PERMISSION_TYPE_FILTER_VF property is not provided, then
 729             // VF filtering is turned off
 730             logger.warn("VF filtering turned off");
 731             return true;
 732         }
 733     }
 734
 735     /**
 736      * Determine if the user is authorized for a particular VF by its invariant
 737      * UUID. If not authorized, then NotAuthorizedException is thrown.
 738      *
 739      * @param model
 740      * @return
 741      */
 742     private boolean isAuthorizedForVf(CldsModel model) {
 743         String vf = ModelProperties.getVf(model);
 744         if (vf == null || vf.length() == 0) {
 745             logger.info("VF not found in model");
 746             return true;
 747         } else {
 748             return isAuthorizedForVf(vf);
 749         }
 750     }
 751
 752     private String createUiServiceFormatJson(String responseStr) throws IOException {
 753         if (StringUtils.isBlank(responseStr)) {
 754             return "";
 755         }
 756         ObjectMapper objectMapper = new ObjectMapper();
 757         List<CldsSdcServiceInfo> rawList = objectMapper.readValue(responseStr,
 758                 objectMapper.getTypeFactory().constructCollectionType(List.class, CldsSdcServiceInfo.class));
 759         ObjectNode invariantIdServiceNode = objectMapper.createObjectNode();
 760         ObjectNode serviceNode = objectMapper.createObjectNode();
 761         logger.info("value of cldsserviceiNfolist: {}", rawList);
 762         if (rawList != null && !rawList.isEmpty()) {
 763             List<CldsSdcServiceInfo> cldsSdcServiceInfoList = sdcCatalogServices.removeDuplicateServices(rawList);
 764
 765             for (CldsSdcServiceInfo currCldsSdcServiceInfo : cldsSdcServiceInfoList) {
 766                 if (currCldsSdcServiceInfo != null) {
 767                     invariantIdServiceNode.put(currCldsSdcServiceInfo.getInvariantUUID(),
 768                             currCldsSdcServiceInfo.getName());
 769                 }
 770             }
 771             serviceNode.putPOJO("service", invariantIdServiceNode);
 772         }
 773         return serviceNode.toString();
 774     }
 775
 776     private String createPropertiesObjectByUUID(String globalProps, String cldsResponseStr) throws IOException {
 777         ObjectMapper mapper = new ObjectMapper();
 778         CldsSdcServiceDetail cldsSdcServiceDetail = mapper.readValue(cldsResponseStr, CldsSdcServiceDetail.class);
 779         ObjectNode globalPropsJson = null;
 780         if (cldsSdcServiceDetail != null && cldsSdcServiceDetail.getUuid() != null) {
 781             /**
 782              * to create json with vf, alarm and locations
 783              */
 784             ObjectNode serviceObjectNode = createEmptyVfAlarmObject(mapper);
 785             ObjectNode vfObjectNode = mapper.createObjectNode();
 786
 787             /**
 788              * to create json with vf and vfresourceId
 789              */
 790             createVfObjectNode(vfObjectNode, mapper, cldsSdcServiceDetail.getResources());
 791             serviceObjectNode.putPOJO(cldsSdcServiceDetail.getInvariantUUID(), vfObjectNode);
 792             ObjectNode byServiceBasicObjetNode = mapper.createObjectNode();
 793             byServiceBasicObjetNode.putPOJO("byService", serviceObjectNode);
 794
 795             /**
 796              * to create json with VFC Node
 797              */
 798             ObjectNode emptyvfcobjectNode = createByVFCObjectNode(mapper, cldsSdcServiceDetail.getResources());
 799             byServiceBasicObjetNode.putPOJO("byVf", emptyvfcobjectNode);
 800             globalPropsJson = (ObjectNode) mapper.readValue(globalProps, JsonNode.class);
 801             globalPropsJson.putPOJO("shared", byServiceBasicObjetNode);
 802             logger.info("valuie of objNode: {}", globalPropsJson);
 803         } else {
 804             /**
 805              * to create json with total properties when no serviceUUID passed
 806              */
 807             globalPropsJson = (ObjectNode) mapper.readValue(globalProps, JsonNode.class);
 808         }
 809         return globalPropsJson.toString();
 810     }
 811
 812     private ObjectNode createEmptyVfAlarmObject(ObjectMapper mapper) {
 813         ObjectNode emptyObjectNode = mapper.createObjectNode();
 814         emptyObjectNode.put("", "");
 815         ObjectNode vfObjectNode = mapper.createObjectNode();
 816         vfObjectNode.putPOJO("vf", emptyObjectNode);
 817         vfObjectNode.putPOJO("location", emptyObjectNode);
 818         vfObjectNode.putPOJO("alarmCondition", emptyObjectNode);
 819         ObjectNode emptyServiceObjectNode = mapper.createObjectNode();
 820         emptyServiceObjectNode.putPOJO("", vfObjectNode);
 821         return emptyServiceObjectNode;
 822     }
 823
 824     private void createVfObjectNode(ObjectNode vfObjectNode2, ObjectMapper mapper,
 825             List<CldsSdcResource> rawCldsSdcResourceList) {
 826         ObjectNode vfNode = mapper.createObjectNode();
 827         vfNode.put("", "");
 828
 829         // To remove repeated resource instance name from
 830         // resourceInstanceList
 831         List<CldsSdcResource> cldsSdcResourceList = sdcCatalogServices
 832                 .removeDuplicateSdcResourceInstances(rawCldsSdcResourceList);
 833         /**
 834          * Creating vf resource node using cldsSdcResource Object
 835          */
 836         if (cldsSdcResourceList != null && !cldsSdcResourceList.isEmpty()) {
 837             for (CldsSdcResource cldsSdcResource : cldsSdcResourceList) {
 838                 if (cldsSdcResource != null && "VF".equalsIgnoreCase(cldsSdcResource.getResoucreType())) {
 839                     vfNode.put(cldsSdcResource.getResourceUUID(), cldsSdcResource.getResourceName());
 840                 }
 841             }
 842         }
 843         vfObjectNode2.putPOJO("vf", vfNode);
 844
 845         /**
 846          * creating location json object using properties file value
 847          */
 848         ObjectNode locationJsonNode;
 849         try {
 850             locationJsonNode = (ObjectNode) mapper.readValue(refProp.getStringValue("ui.location.default"),
 851                     JsonNode.class);
 852         } catch (IOException e) {
 853             logger.error("Unable to load ui.location.default JSON in clds-references.properties properly", e);
 854             throw new CldsConfigException(
 855                     "Unable to load ui.location.default JSON in clds-references.properties properly", e);
 856         }
 857         vfObjectNode2.putPOJO("location", locationJsonNode);
 858
 859         /**
 860          * creating alarm json object using properties file value
 861          */
 862         String alarmStringValue = refProp.getStringValue("ui.alarm.default");
 863         logger.info("value of alarm: {}", alarmStringValue);
 864         ObjectNode alarmStringJsonNode;
 865         try {
 866             alarmStringJsonNode = (ObjectNode) mapper.readValue(alarmStringValue, JsonNode.class);
 867         } catch (IOException e) {
 868             logger.error("Unable to ui.alarm.default JSON in clds-references.properties properly", e);
 869             throw new CldsConfigException("Unable to load ui.alarm.default JSON in clds-references.properties properly",
 870                     e);
 871         }
 872         vfObjectNode2.putPOJO("alarmCondition", alarmStringJsonNode);
 873
 874     }
 875
 876     private ObjectNode createByVFCObjectNode(ObjectMapper mapper, List<CldsSdcResource> cldsSdcResourceList) {
 877         ObjectNode emptyObjectNode = mapper.createObjectNode();
 878         ObjectNode emptyvfcobjectNode = mapper.createObjectNode();
 879         ObjectNode vfCObjectNode = mapper.createObjectNode();
 880         vfCObjectNode.putPOJO("vfC", emptyObjectNode);
 881         ObjectNode subVfCObjectNode = mapper.createObjectNode();
 882         subVfCObjectNode.putPOJO("vfc", emptyObjectNode);
 883         if (cldsSdcResourceList != null && !cldsSdcResourceList.isEmpty()) {
 884             for (CldsSdcResource cldsSdcResource : cldsSdcResourceList) {
 885                 if (cldsSdcResource != null && "VF".equalsIgnoreCase(cldsSdcResource.getResoucreType())) {
 886                     vfCObjectNode.putPOJO(cldsSdcResource.getResourceUUID(), subVfCObjectNode);
 887                 }
 888             }
 889         }
 890         emptyvfcobjectNode.putPOJO("", vfCObjectNode);
 891         return emptyvfcobjectNode;
 892     }
 893
 894     @PUT
 895     @Path("/deploy/{modelName}")
 896     @Consumes(MediaType.APPLICATION_JSON)
 897     @Produces(MediaType.APPLICATION_JSON)
 898     public CldsModel deployModel(@PathParam("action") String action, @PathParam("modelName") String modelName,
 899             @QueryParam("test") String test, CldsModel model) throws IOException {
 900         Date startTime = new Date();
 901         LoggingUtils.setRequestContext("CldsService: Deploy model", getPrincipalName());
 902         String deploymentId = "closedLoop_" + UUID.randomUUID() + "_deploymentId";
 903         String createNewDeploymentStatusUrl = dcaeDispatcherServices.createNewDeployment(deploymentId,
 904                 model.getTypeId());
 905         String operationStatus = "processing";
 906         long waitingTime = System.nanoTime() + TimeUnit.MINUTES.toNanos(10);
 907         while ("processing".equalsIgnoreCase(operationStatus)) {
 908             // Break the loop if waiting for more than 10 mins
 909             if (waitingTime < System.nanoTime()) {
 910                 break;
 911             }
 912             operationStatus = dcaeDispatcherServices.getOperationStatus(createNewDeploymentStatusUrl);
 913         }
 914         if ("succeeded".equalsIgnoreCase(operationStatus)) {
 915             String artifactName = model.getControlName();
 916             if (artifactName != null) {
 917                 artifactName = artifactName + ".yml";
 918             }
 919             DcaeEvent dcaeEvent = new DcaeEvent();
 920             /* set dcae events */
 921             dcaeEvent.setArtifactName(artifactName);
 922             dcaeEvent.setEvent(DcaeEvent.EVENT_DEPLOYMENT);
 923             CldsEvent.insEvent(cldsDao, dcaeEvent.getControlName(), getUserId(), dcaeEvent.getCldsActionCd(),
 924                     CldsEvent.ACTION_STATE_RECEIVED, null);
 925             model.setDeploymentId(deploymentId);
 926             model.save(cldsDao, getUserId());
 927         } else {
 928             logger.info("Deploy model (" + modelName + ") failed...Operation Status is - " + operationStatus);
 929             throw new HttpClientErrorException(HttpStatus.INTERNAL_SERVER_ERROR,
 930                     "Deploy model (" + modelName + ") failed...Operation Status is - " + operationStatus);
 931         }
 932         logger.info("Deploy model (" + modelName + ") succeeded...Deployment Id is - " + deploymentId);
 933         // audit log
 934         LoggingUtils.setTimeContext(startTime, new Date());
 935         LoggingUtils.setResponseContext("0", "Deploy model success", this.getClass().getName());
 936         auditLogger.info("Deploy model completed");
 937         return model;
 938     }
 939
 940     @PUT
 941     @Path("/undeploy/{modelName}")
 942     @Consumes(MediaType.APPLICATION_JSON)
 943     @Produces(MediaType.APPLICATION_JSON)
 944     public CldsModel unDeployModel(@PathParam("action") String action, @PathParam("modelName") String modelName,
 945             @QueryParam("test") String test, CldsModel model) throws IOException {
 946         Date startTime = new Date();
 947         LoggingUtils.setRequestContext("CldsService: Undeploy model", getPrincipalName());
 948         String operationStatusUndeployUrl = dcaeDispatcherServices.deleteExistingDeployment(model.getDeploymentId(),
 949                 model.getTypeId());
 950         String operationStatus = "processing";
 951         long waitingTime = System.nanoTime() + TimeUnit.MINUTES.toNanos(10);
 952         while ("processing".equalsIgnoreCase(operationStatus)) {
 953             if (waitingTime < System.nanoTime()) {
 954                 break;
 955             }
 956             operationStatus = dcaeDispatcherServices.getOperationStatus(operationStatusUndeployUrl);
 957         }
 958         if ("succeeded".equalsIgnoreCase(operationStatus)) {
 959             String artifactName = model.getControlName();
 960             if (artifactName != null) {
 961                 artifactName = artifactName + ".yml";
 962             }
 963             DcaeEvent dcaeEvent = new DcaeEvent();
 964             // set dcae events
 965             dcaeEvent.setArtifactName(artifactName);
 966             dcaeEvent.setEvent(DcaeEvent.EVENT_UNDEPLOYMENT);
 967             CldsEvent.insEvent(cldsDao, model.getControlName(), getUserId(), dcaeEvent.getCldsActionCd(),
 968                     CldsEvent.ACTION_STATE_RECEIVED, null);
 969             model.setDeploymentId(null);
 970             model.save(cldsDao, getUserId());
 971         } else {
 972             logger.info("Undeploy model (" + modelName + ") failed...Operation Status is - " + operationStatus);
 973             throw new HttpClientErrorException(HttpStatus.INTERNAL_SERVER_ERROR,
 974                     "Undeploy model (" + modelName + ") failed...Operation Status is - " + operationStatus);
 975         }
 976         logger.info("Undeploy model (" + modelName + ") succeeded.");
 977         // audit log
 978         LoggingUtils.setTimeContext(startTime, new Date());
 979         LoggingUtils.setResponseContext("0", "Undeploy model success", this.getClass().getName());
 980         auditLogger.info("Undeploy model completed");
 981         return model;
 982     }
 983
 984     private String getGlobalCldsString() {
 985         try {
 986             if (null == globalCldsProperties) {
 987                 globalCldsProperties = new Properties();
 988                 globalCldsProperties.load(appContext.getResource(globalClds).getInputStream());
 989             }
 990             return (String) globalCldsProperties.get("globalCldsProps");
 991         } catch (IOException e) {
 992             logger.error("Unable to load the globalClds due to an exception", e);
 993             throw new CldsConfigException("Unable to load the globalClds due to an exception", e);
 994         }
 995     }
 996 }