gerrit.onap Code Review - sdnc/apps.git/blob

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * ONAP - SDNC
   4  * ================================================================================
   5  * Copyright (C) 2020 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.onap.sdnc.apps.ms.gra.controllers;
  22
  23 import com.fasterxml.jackson.core.JsonProcessingException;
  24 import com.fasterxml.jackson.databind.JsonMappingException;
  25 import com.fasterxml.jackson.databind.ObjectMapper;
  26 import com.google.gson.JsonParser;
  27 import org.onap.ccsdk.apps.services.SvcLogicFactory;
  28 import org.onap.ccsdk.sli.core.sli.SvcLogicContext;
  29 import org.onap.ccsdk.sli.core.sli.SvcLogicException;
  30 import org.onap.ccsdk.sli.core.sli.provider.base.SvcLogicServiceBase;
  31 import org.onap.sdnc.apps.ms.gra.data.ConfigPreloadData;
  32 import org.onap.sdnc.apps.ms.gra.data.ConfigPreloadDataRepository;
  33 import org.onap.sdnc.apps.ms.gra.data.OperationalPreloadData;
  34 import org.onap.sdnc.apps.ms.gra.data.OperationalPreloadDataRepository;
  35 import org.onap.sdnc.apps.ms.gra.swagger.OperationsApi;
  36 import org.onap.sdnc.apps.ms.gra.swagger.model.*;
  37 import org.springframework.beans.factory.annotation.Autowired;
  38 import org.springframework.boot.autoconfigure.domain.EntityScan;
  39 import org.springframework.context.annotation.ComponentScan;
  40 import org.springframework.context.annotation.Import;
  41 import org.springframework.http.HttpStatus;
  42 import org.springframework.http.ResponseEntity;
  43 import org.springframework.stereotype.Controller;
  44
  45 import javax.servlet.http.HttpServletRequest;
  46 import javax.validation.Valid;
  47 import java.util.*;
  48 import java.util.concurrent.atomic.AtomicBoolean;
  49
  50
  51 @Controller
  52 @ComponentScan(basePackages = {"org.onap.sdnc.apps.ms.gra.*"})
  53 @EntityScan("org.onap.sdnc.apps.ms.gra.*")
  54 @Import(value = SvcLogicFactory.class)
  55 public class OperationsApiController implements OperationsApi {
  56
  57     private static final String CALLED_STR = "{} called.";
  58     private static final String MODULE_NAME = "GENERIC-RESOURCE-API";
  59
  60     private final ObjectMapper objectMapper;
  61
  62     private final HttpServletRequest request;
  63
  64     @Autowired
  65     protected SvcLogicServiceBase svc;
  66
  67     @Autowired
  68     private ConfigPreloadDataRepository configPreloadDataRepository;
  69
  70     @Autowired
  71     private OperationalPreloadDataRepository operationalPreloadDataRepository;
  72
  73
  74     @org.springframework.beans.factory.annotation.Autowired
  75     public OperationsApiController(ObjectMapper objectMapper, HttpServletRequest request) {
  76         this.objectMapper = objectMapper;
  77         this.request = request;
  78     }
  79
  80     @Override
  81     public Optional<ObjectMapper> getObjectMapper() {
  82         return Optional.ofNullable(objectMapper);
  83     }
  84
  85     @Override
  86     public Optional<HttpServletRequest> getRequest() {
  87         return Optional.ofNullable(request);
  88     }
  89
  90     @Override
  91     public ResponseEntity<GenericResourceApiPreloadNetworkTopologyOperation> operationsGENERICRESOURCEAPIpreloadNetworkTopologyOperationPost(@Valid GenericResourceApiPreloadnetworktopologyoperationInputBodyparam graInput) {
  92         final String svcOperation = "preload-network-topology-operation";
  93         GenericResourceApiPreloadNetworkTopologyOperation retval = new GenericResourceApiPreloadNetworkTopologyOperation();
  94         GenericResourceApiPreloadTopologyResponseBody resp = new GenericResourceApiPreloadTopologyResponseBody();
  95
  96         log.info(CALLED_STR, svcOperation);
  97         if (hasInvalidPreloadNetwork(graInput)) {
  98             log.debug("exiting {} because of null or empty preload-network-topology-information", svcOperation);
  99
 100
 101             resp.setResponseCode("403");
 102             resp.setResponseMessage("invalid input, null or empty preload-network-topology-information");
 103             resp.setAckFinalIndicator("Y");
 104
 105
 106             retval.setOutput(resp);
 107
 108             return new ResponseEntity<>(retval, HttpStatus.FORBIDDEN);
 109         }
 110
 111         String preloadId = graInput.getInput().getPreloadNetworkTopologyInformation().getNetworkTopologyIdentifierStructure().getNetworkId();
 112         String preloadType = "network";
 113
 114         resp.setSvcRequestId(graInput.getInput().getSdncRequestHeader().getSvcRequestId());
 115
 116         SvcLogicContext ctxIn = new SvcLogicContext();
 117
 118         GenericResourceApiPreloadModelInformation preloadModelInfo = null;
 119
 120
 121         // Add input to SvcLogicContext
 122         try {
 123             ctxIn.mergeJson("input", objectMapper.writeValueAsString(graInput.getInput()));
 124         } catch (JsonProcessingException e) {
 125             log.error("exiting {} due to parse error on input preload data", svcOperation);
 126             resp.setResponseCode("500");
 127             resp.setResponseMessage("internal error");
 128             resp.setAckFinalIndicator("Y");
 129             retval.setOutput(resp);
 130             return new ResponseEntity<>(retval, HttpStatus.INTERNAL_SERVER_ERROR);
 131         }
 132
 133
 134         // Add config tree data to SvcLogicContext
 135         try {
 136             preloadModelInfo = getConfigPreloadData(preloadId, preloadType);
 137             ctxIn.mergeJson("preload-data", objectMapper.writeValueAsString(preloadModelInfo.getPreloadList()));
 138         } catch (JsonProcessingException e) {
 139             log.error("exiting {} due to parse error on saved config preload data", svcOperation);
 140             resp.setResponseCode("500");
 141             resp.setResponseMessage("internal error");
 142             resp.setAckFinalIndicator("Y");
 143             retval.setOutput(resp);
 144             return new ResponseEntity<>(retval, HttpStatus.INTERNAL_SERVER_ERROR);
 145         }
 146
 147
 148         // Add operational tree data to SvcLogicContext
 149         try {
 150             preloadModelInfo = getOperationalPreloadData(preloadId, preloadType);
 151             ctxIn.mergeJson("operational-data", objectMapper.writeValueAsString(preloadModelInfo.getPreloadList()));
 152         } catch (JsonProcessingException e) {
 153             log.error("exiting {} due to parse error on saved operational preload data", svcOperation);
 154             resp.setResponseCode("500");
 155             resp.setResponseMessage("internal error");
 156             resp.setAckFinalIndicator("Y");
 157             retval.setOutput(resp);
 158             return new ResponseEntity<>(retval, HttpStatus.INTERNAL_SERVER_ERROR);
 159         }
 160
 161
 162         // Call DG
 163         try {
 164             // Any of these can throw a nullpointer exception
 165             // execute should only throw a SvcLogicException
 166             SvcLogicContext ctxOut = svc.execute(MODULE_NAME, svcOperation, null, "sync", ctxIn);
 167             Properties respProps = ctxOut.toProperties();
 168
 169             resp.setAckFinalIndicator(respProps.getProperty("ack-final-indicator", "Y"));
 170             resp.setResponseCode(respProps.getProperty("error-code", "200"));
 171             resp.setResponseMessage(respProps.getProperty("error-message", "SUCCESS"));
 172
 173             if ("200".equals(resp.getResponseCode())) {
 174                 // If DG returns success, update database
 175                 String ctxJson = ctxOut.toJsonString("preload-data");
 176                 GenericResourceApiPreloadModelInformation preloadToLoad = objectMapper.readValue(ctxJson, GenericResourceApiPreloadModelInformation.class);
 177                 saveConfigPreloadData(preloadToLoad);
 178                 saveOperationalPreloadData(preloadToLoad);
 179             }
 180
 181         } catch (NullPointerException npe) {
 182             resp.setAckFinalIndicator("true");
 183             resp.setResponseCode("500");
 184             resp.setResponseMessage("Check that you populated module, rpc and or mode correctly.");
 185         } catch (SvcLogicException e) {
 186             resp.setAckFinalIndicator("true");
 187             resp.setResponseCode("500");
 188             resp.setResponseMessage(e.getMessage());
 189         } catch (JsonMappingException e) {
 190             resp.setAckFinalIndicator("true");
 191             resp.setResponseCode("500");
 192             resp.setResponseMessage(e.getMessage());
 193         } catch (JsonProcessingException e) {
 194             resp.setAckFinalIndicator("true");
 195             resp.setResponseCode("500");
 196             resp.setResponseMessage(e.getMessage());
 197         }
 198
 199
 200         retval.setOutput(resp);
 201         return (new ResponseEntity<>(retval, HttpStatus.valueOf(Integer.parseInt(resp.getResponseCode()))));
 202     }
 203
 204     @Override
 205     public ResponseEntity<GenericResourceApiPreloadVfModuleTopologyOperation> operationsGENERICRESOURCEAPIpreloadVfModuleTopologyOperationPost(@Valid GenericResourceApiPreloadvfmoduletopologyoperationInputBodyparam graInput) {
 206         final String svcOperation = "preload-vf-module-topology-operation";
 207         GenericResourceApiPreloadVfModuleTopologyOperation retval = new GenericResourceApiPreloadVfModuleTopologyOperation();
 208         GenericResourceApiPreloadTopologyResponseBody resp = new GenericResourceApiPreloadTopologyResponseBody();
 209
 210         log.info(CALLED_STR, svcOperation);
 211         if (hasInvalidPreloadNetwork(graInput)) {
 212             log.debug("exiting {} because of null or empty preload-network-topology-information", svcOperation);
 213
 214
 215             resp.setResponseCode("403");
 216             resp.setResponseMessage("invalid input, null or empty preload-network-topology-information");
 217             resp.setAckFinalIndicator("Y");
 218
 219
 220             retval.setOutput(resp);
 221
 222             return new ResponseEntity<>(retval, HttpStatus.FORBIDDEN);
 223         }
 224
 225         String preloadId = graInput.getInput().getPreloadVfModuleTopologyInformation().getVfModuleTopology().getVfModuleTopologyIdentifier().getVfModuleName();
 226         String preloadType = "vf-module";
 227
 228         resp.setSvcRequestId(graInput.getInput().getSdncRequestHeader().getSvcRequestId());
 229
 230         SvcLogicContext ctxIn = new SvcLogicContext();
 231
 232         GenericResourceApiPreloadModelInformation preloadModelInfo = null;
 233
 234
 235         // Add input to SvcLogicContext
 236         try {
 237             ctxIn.mergeJson("input", objectMapper.writeValueAsString(graInput.getInput()));
 238         } catch (JsonProcessingException e) {
 239             log.error("exiting {} due to parse error on input preload data", svcOperation);
 240             resp.setResponseCode("500");
 241             resp.setResponseMessage("internal error");
 242             resp.setAckFinalIndicator("Y");
 243             retval.setOutput(resp);
 244             return new ResponseEntity<>(retval, HttpStatus.INTERNAL_SERVER_ERROR);
 245         }
 246
 247
 248         // Add config tree data to SvcLogicContext
 249         try {
 250             preloadModelInfo = getConfigPreloadData(preloadId, preloadType);
 251             ctxIn.mergeJson("preload-data", objectMapper.writeValueAsString(preloadModelInfo.getPreloadList()));
 252         } catch (JsonProcessingException e) {
 253             log.error("exiting {} due to parse error on saved config preload data", svcOperation);
 254             resp.setResponseCode("500");
 255             resp.setResponseMessage("internal error");
 256             resp.setAckFinalIndicator("Y");
 257             retval.setOutput(resp);
 258             return new ResponseEntity<>(retval, HttpStatus.INTERNAL_SERVER_ERROR);
 259         }
 260
 261
 262         // Add operational tree data to SvcLogicContext
 263         try {
 264             preloadModelInfo = getOperationalPreloadData(preloadId, preloadType);
 265             ctxIn.mergeJson("operational-data", objectMapper.writeValueAsString(preloadModelInfo.getPreloadList()));
 266         } catch (JsonProcessingException e) {
 267             log.error("exiting {} due to parse error on saved operational preload data", svcOperation);
 268             resp.setResponseCode("500");
 269             resp.setResponseMessage("internal error");
 270             resp.setAckFinalIndicator("Y");
 271             retval.setOutput(resp);
 272             return new ResponseEntity<>(retval, HttpStatus.INTERNAL_SERVER_ERROR);
 273         }
 274
 275
 276         // Call DG
 277         try {
 278             // Any of these can throw a nullpointer exception
 279             // execute should only throw a SvcLogicException
 280             SvcLogicContext ctxOut = svc.execute(MODULE_NAME, svcOperation, null, "sync", ctxIn);
 281             Properties respProps = ctxOut.toProperties();
 282
 283             resp.setAckFinalIndicator(respProps.getProperty("ack-final-indicator", "Y"));
 284             resp.setResponseCode(respProps.getProperty("error-code", "200"));
 285             resp.setResponseMessage(respProps.getProperty("error-message", "SUCCESS"));
 286
 287             if ("200".equals(resp.getResponseCode())) {
 288                 // If DG returns success, update database
 289                 String ctxJson = ctxOut.toJsonString("preload-data");
 290                 GenericResourceApiPreloadModelInformation preloadToLoad = objectMapper.readValue(ctxJson, GenericResourceApiPreloadModelInformation.class);
 291                 saveConfigPreloadData(preloadToLoad);
 292                 saveOperationalPreloadData(preloadToLoad);
 293             }
 294
 295         } catch (NullPointerException npe) {
 296             resp.setAckFinalIndicator("true");
 297             resp.setResponseCode("500");
 298             resp.setResponseMessage("Check that you populated module, rpc and or mode correctly.");
 299         } catch (SvcLogicException e) {
 300             resp.setAckFinalIndicator("true");
 301             resp.setResponseCode("500");
 302             resp.setResponseMessage(e.getMessage());
 303         } catch (JsonMappingException e) {
 304             resp.setAckFinalIndicator("true");
 305             resp.setResponseCode("500");
 306             resp.setResponseMessage(e.getMessage());
 307         } catch (JsonProcessingException e) {
 308             resp.setAckFinalIndicator("true");
 309             resp.setResponseCode("500");
 310             resp.setResponseMessage(e.getMessage());
 311         }
 312
 313
 314         retval.setOutput(resp);
 315         return (new ResponseEntity<>(retval, HttpStatus.valueOf(Integer.parseInt(resp.getResponseCode()))));
 316     }
 317
 318     private boolean hasInvalidPreloadNetwork(GenericResourceApiPreloadnetworktopologyoperationInputBodyparam preloadData) {
 319         return ((preloadData == null) ||
 320                 (preloadData.getInput() == null) ||
 321                 (preloadData.getInput().getPreloadNetworkTopologyInformation() == null));
 322     }
 323     private boolean hasInvalidPreloadNetwork(GenericResourceApiPreloadvfmoduletopologyoperationInputBodyparam preloadData) {
 324         return ((preloadData == null) ||
 325                 (preloadData.getInput() == null) ||
 326                 (preloadData.getInput().getPreloadVfModuleTopologyInformation() == null));
 327     }
 328
 329     private GenericResourceApiPreloadModelInformation getConfigPreloadData(String preloadId, String preloadType) throws JsonProcessingException {
 330         GenericResourceApiPreloadModelInformation preloadModelInfo = new GenericResourceApiPreloadModelInformation();
 331         List<ConfigPreloadData> configPreloadData = configPreloadDataRepository.findByPreloadIdAndPreloadType(preloadId, preloadType);
 332
 333         for (ConfigPreloadData preloadItem : configPreloadData) {
 334
 335             GenericResourceApiPreloadmodelinformationPreloadList preloadListItem = new GenericResourceApiPreloadmodelinformationPreloadList();
 336             preloadListItem.setPreloadId(preloadItem.getPreloadId());
 337             preloadListItem.setPreloadType(preloadItem.getPreloadType());
 338             preloadListItem.setPreloadData(objectMapper.readValue(preloadItem.getPreloadData(), GenericResourceApiPreloaddataPreloadData.class));
 339             preloadModelInfo.addPreloadListItem(preloadListItem);
 340
 341         }
 342         return (preloadModelInfo);
 343     }
 344
 345     private void saveConfigPreloadData(GenericResourceApiPreloadModelInformation preloadModelInfo) throws JsonProcessingException {
 346         List<GenericResourceApiPreloadmodelinformationPreloadList> preloadListItems = preloadModelInfo.getPreloadList();
 347
 348         for (GenericResourceApiPreloadmodelinformationPreloadList preloadListItem: preloadListItems) {
 349             String preloadId = preloadListItem.getPreloadId();
 350             String preloadType = preloadListItem.getPreloadType();
 351             configPreloadDataRepository.deleteByPreloadIdAndPreloadType(preloadId, preloadType);
 352             configPreloadDataRepository.save(new ConfigPreloadData(preloadId, preloadType, objectMapper.writeValueAsString(preloadListItem.getPreloadData())));
 353         }
 354     }
 355     private void saveOperationalPreloadData(GenericResourceApiPreloadModelInformation preloadModelInfo) throws JsonProcessingException {
 356         List<GenericResourceApiPreloadmodelinformationPreloadList> preloadListItems = preloadModelInfo.getPreloadList();
 357
 358         for (GenericResourceApiPreloadmodelinformationPreloadList preloadListItem: preloadListItems) {
 359             String preloadId = preloadListItem.getPreloadId();
 360             String preloadType = preloadListItem.getPreloadType();
 361             operationalPreloadDataRepository.deleteByPreloadIdAndPreloadType(preloadId, preloadType);
 362             operationalPreloadDataRepository.save(new OperationalPreloadData(preloadId, preloadType, objectMapper.writeValueAsString(preloadListItem.getPreloadData())));
 363         }
 364     }
 365
 366
 367     private GenericResourceApiPreloadModelInformation getOperationalPreloadData(String preloadId, String preloadType) throws JsonProcessingException {
 368         GenericResourceApiPreloadModelInformation preloadModelInfo = new GenericResourceApiPreloadModelInformation();
 369         List<OperationalPreloadData> operPreloadData = operationalPreloadDataRepository.findByPreloadIdAndPreloadType(preloadId, preloadType);
 370
 371         for (OperationalPreloadData preloadItem : operPreloadData) {
 372
 373             GenericResourceApiPreloadmodelinformationPreloadList preloadListItem = new GenericResourceApiPreloadmodelinformationPreloadList();
 374             preloadListItem.setPreloadId(preloadItem.getPreloadId());
 375             preloadListItem.setPreloadType(preloadItem.getPreloadType());
 376             preloadListItem.setPreloadData(objectMapper.readValue(preloadItem.getPreloadData(), GenericResourceApiPreloaddataPreloadData.class));
 377             preloadModelInfo.addPreloadListItem(preloadListItem);
 378
 379         }
 380         return (preloadModelInfo);
 381     }
 382
 383
 384 }