gerrit.onap Code Review - so.git/blob

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * ONAP - SO
   4  * ================================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Modifications Copyright (c) 2019 Samsung
   8  * ================================================================================
   9  * Licensed under the Apache License, Version 2.0 (the "License");
  10  * you may not use this file except in compliance with the License.
  11  * You may obtain a copy of the License at
  12  *
  13  *      http://www.apache.org/licenses/LICENSE-2.0
  14  *
  15  * Unless required by applicable law or agreed to in writing, software
  16  * distributed under the License is distributed on an "AS IS" BASIS,
  17  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  18  * See the License for the specific language governing permissions and
  19  * limitations under the License.
  20  * ============LICENSE_END=========================================================
  21  */
  22
  23 package org.onap.so.apihandlerinfra.tenantisolation;
  24
  25 import java.sql.Timestamp;
  26 import java.util.HashMap;
  27 import java.util.List;
  28 import java.util.Map;
  29 import java.util.Map.Entry;
  30 import javax.ws.rs.core.MultivaluedMap;
  31 import org.apache.commons.lang3.StringUtils;
  32 import org.onap.so.apihandlerinfra.Constants;
  33 import org.onap.so.apihandlerinfra.tenantisolationbeans.Action;
  34 import org.onap.so.apihandlerinfra.tenantisolationbeans.Manifest;
  35 import org.onap.so.apihandlerinfra.tenantisolationbeans.OperationalEnvironment;
  36 import org.onap.so.apihandlerinfra.tenantisolationbeans.RelatedInstance;
  37 import org.onap.so.apihandlerinfra.tenantisolationbeans.RelatedInstanceList;
  38 import org.onap.so.apihandlerinfra.tenantisolationbeans.RequestDetails;
  39 import org.onap.so.apihandlerinfra.tenantisolationbeans.RequestInfo;
  40 import org.onap.so.apihandlerinfra.tenantisolationbeans.RequestParameters;
  41 import org.onap.so.apihandlerinfra.tenantisolationbeans.ResourceType;
  42 import org.onap.so.apihandlerinfra.tenantisolationbeans.ServiceModelList;
  43 import org.onap.so.apihandlerinfra.vnfbeans.RequestStatusType;
  44 import org.onap.so.constants.Status;
  45 import org.onap.so.db.request.beans.InfraActiveRequests;
  46 import org.onap.so.db.request.client.RequestsDbClient;
  47 import org.onap.so.exceptions.ValidationException;
  48 import org.onap.so.utils.UUIDChecker;
  49 import org.slf4j.Logger;
  50 import org.slf4j.LoggerFactory;
  51 import org.springframework.beans.factory.annotation.Autowired;
  52 import org.springframework.context.annotation.Scope;
  53 import org.springframework.stereotype.Component;
  54 import com.fasterxml.jackson.core.JsonProcessingException;
  55 import com.fasterxml.jackson.databind.ObjectMapper;
  56
  57 @Component
  58 @Scope("prototype")
  59 public class TenantIsolationRequest {
  60
  61     private String requestId;
  62     private String requestJSON;
  63     private RequestInfo requestInfo;
  64
  65     private String errorMessage;
  66     private String responseBody;
  67     private RequestStatusType status;
  68     private String operationalEnvironmentId;
  69     private long progress = Constants.PROGRESS_REQUEST_RECEIVED;
  70     private String requestScope;
  71     private CloudOrchestrationRequest cor;
  72
  73     @Autowired
  74     private RequestsDbClient requestsDbClient;
  75
  76     private static Logger logger = LoggerFactory.getLogger(TenantIsolationRequest.class);
  77
  78
  79     TenantIsolationRequest(String requestId) {
  80         this.requestId = requestId;
  81     }
  82
  83     TenantIsolationRequest() {}
  84
  85     void parse(CloudOrchestrationRequest request, HashMap<String, String> instanceIdMap, Action action)
  86             throws ValidationException {
  87         this.cor = request;
  88         this.requestInfo = request.getRequestDetails().getRequestInfo();
  89
  90         try {
  91             ObjectMapper mapper = new ObjectMapper();
  92             requestJSON = mapper.writeValueAsString(request.getRequestDetails());
  93
  94         } catch (JsonProcessingException e) {
  95             logger.error("Exception in JSON processing", e);
  96             throw new ValidationException("Parse ServiceInstanceRequest to JSON string", true);
  97         }
  98
  99         String envId = null;
 100         if (instanceIdMap != null) {
 101             envId = instanceIdMap.get("operationalEnvironmentId");
 102             if (envId != null && !UUIDChecker.isValidUUID(envId)) {
 103                 throw new ValidationException("operationalEnvironmentId", true);
 104             }
 105             cor.setOperationalEnvironmentId(envId);
 106         }
 107
 108         this.operationalEnvironmentId = envId;
 109
 110         RequestDetails requestDetails = request.getRequestDetails();
 111         RequestParameters requestParameters = requestDetails.getRequestParameters();
 112
 113         requestInfoValidation(action, requestInfo);
 114
 115         requestParamsValidation(action, requestParameters);
 116
 117         relatedInstanceValidation(action, requestDetails, requestParameters);
 118
 119     }
 120
 121     private void relatedInstanceValidation(Action action, RequestDetails requestDetails,
 122             RequestParameters requestParameters) throws ValidationException {
 123         RelatedInstanceList[] instanceList = requestDetails.getRelatedInstanceList();
 124
 125         if (requestParameters == null) {
 126             throw new ValidationException("requestParameters", true);
 127         }
 128         if ((Action.activate.equals(action) || Action.deactivate.equals(action))
 129                 && OperationalEnvironment.ECOMP.equals(requestParameters.getOperationalEnvironmentType())) {
 130             throw new ValidationException("operationalEnvironmentType in requestParameters", true);
 131         }
 132
 133         if (!Action.deactivate.equals(action)
 134                 && OperationalEnvironment.VNF.equals(requestParameters.getOperationalEnvironmentType())) {
 135             if (instanceList != null && instanceList.length > 0) {
 136                 for (RelatedInstanceList relatedInstanceList : instanceList) {
 137                     RelatedInstance relatedInstance = relatedInstanceList.getRelatedInstance();
 138
 139                     if (relatedInstance.getResourceType() == null) {
 140                         throw new ValidationException("ResourceType in relatedInstance", true);
 141                     }
 142
 143                     if (!empty(relatedInstance.getInstanceName())
 144                             && !relatedInstance.getInstanceName().matches(Constants.VALID_INSTANCE_NAME_FORMAT)) {
 145                         throw new ValidationException("instanceName format", true);
 146                     }
 147
 148                     if (empty(relatedInstance.getInstanceId())) {
 149                         throw new ValidationException("instanceId in relatedInstance", true);
 150                     }
 151
 152                     if (!UUIDChecker.isValidUUID(relatedInstance.getInstanceId())) {
 153                         throw new ValidationException("instanceId format in relatedInstance", true);
 154                     }
 155                 }
 156             } else {
 157                 throw new ValidationException("relatedInstanceList", true);
 158             }
 159         }
 160     }
 161
 162     private void requestParamsValidation(Action action, RequestParameters requestParameters)
 163             throws ValidationException {
 164
 165         if (requestParameters != null) {
 166             if (!Action.deactivate.equals(action) && requestParameters.getOperationalEnvironmentType() == null) {
 167                 throw new ValidationException("OperationalEnvironmentType", true);
 168             }
 169
 170             if (Action.create.equals(action) && empty(requestParameters.getTenantContext())) {
 171                 throw new ValidationException("Tenant Context", true);
 172             }
 173             if (!Action.deactivate.equals(action) && empty(requestParameters.getWorkloadContext())) {
 174                 throw new ValidationException("Workload Context", true);
 175             }
 176
 177             Manifest manifest = requestParameters.getManifest();
 178
 179             if (Action.activate.equals(action)) {
 180                 if (manifest == null) {
 181                     throw new ValidationException("Manifest on Activate", true);
 182                 } else {
 183                     List<ServiceModelList> serviceModelList = manifest.getServiceModelList();
 184
 185                     if (serviceModelList.isEmpty()) {
 186                         throw new ValidationException(" empty ServiceModelList", true);
 187                     }
 188
 189                     for (ServiceModelList list : serviceModelList) {
 190                         if (empty(list.getServiceModelVersionId())) {
 191                             throw new ValidationException("ServiceModelVersionId", true);
 192                         }
 193
 194                         if (!UUIDChecker.isValidUUID(list.getServiceModelVersionId())) {
 195                             throw new ValidationException("ServiceModelVersionId format", true);
 196                         }
 197
 198                         if (list.getRecoveryAction() == null) {
 199                             throw new ValidationException("RecoveryAction", true);
 200                         }
 201                     }
 202                 }
 203             }
 204         } else if (!Action.deactivate.equals(action)) {
 205             throw new ValidationException("request Parameters", true);
 206         }
 207     }
 208
 209     private void requestInfoValidation(Action action, RequestInfo requestInfo) throws ValidationException {
 210
 211         if (Action.create.equals(action) && empty(requestInfo.getInstanceName())) {
 212             throw new ValidationException("instanceName", true);
 213         }
 214
 215         if (!empty(requestInfo.getInstanceName())
 216                 && !requestInfo.getInstanceName().matches(Constants.VALID_INSTANCE_NAME_FORMAT)) {
 217             throw new ValidationException("instanceName format", true);
 218         }
 219
 220         if (empty(requestInfo.getSource())) {
 221             throw new ValidationException("source", true);
 222         }
 223
 224         if (empty(requestInfo.getRequestorId())) {
 225             throw new ValidationException("requestorId", true);
 226         }
 227
 228         ResourceType resourceType = requestInfo.getResourceType();
 229         if (resourceType == null) {
 230             throw new ValidationException("resourceType", true);
 231         }
 232
 233         this.requestScope = resourceType.name();
 234     }
 235
 236     void parseOrchestration(CloudOrchestrationRequest cor) throws ValidationException {
 237
 238         this.cor = cor;
 239
 240         try {
 241             ObjectMapper mapper = new ObjectMapper();
 242             requestJSON = mapper.writeValueAsString(cor.getRequestDetails());
 243
 244         } catch (JsonProcessingException e) {
 245             throw new ValidationException("Parse CloudOrchestrationRequest to JSON string", e);
 246         }
 247
 248         if (cor.getRequestDetails() == null) {
 249             throw new ValidationException("requestDetails", true);
 250         }
 251         this.requestInfo = cor.getRequestDetails().getRequestInfo();
 252
 253         if (this.requestInfo == null) {
 254             throw new ValidationException("requestInfo", true);
 255         }
 256
 257         if (empty(requestInfo.getSource())) {
 258             throw new ValidationException("source", true);
 259         }
 260         if (empty(requestInfo.getRequestorId())) {
 261             throw new ValidationException("requestorId", true);
 262         }
 263     }
 264
 265     public void createRequestRecord(Status status, Action action) {
 266
 267         InfraActiveRequests aq = new InfraActiveRequests();
 268         aq.setRequestId(requestId);
 269
 270         aq.setRequestAction(action.name());
 271
 272         Timestamp startTimeStamp = new Timestamp(System.currentTimeMillis());
 273
 274         aq.setStartTime(startTimeStamp);
 275
 276         if (requestInfo != null) {
 277
 278             if (requestInfo.getSource() != null) {
 279                 aq.setSource(requestInfo.getSource());
 280             }
 281             if (requestInfo.getRequestorId() != null) {
 282                 aq.setRequestorId(requestInfo.getRequestorId());
 283             }
 284             if (requestInfo.getResourceType() != null) {
 285                 aq.setRequestScope(requestInfo.getResourceType().name());
 286             }
 287         }
 288
 289         if (ResourceType.operationalEnvironment.name().equalsIgnoreCase(requestScope) && requestInfo != null) {
 290             aq.setOperationalEnvId(operationalEnvironmentId);
 291             aq.setOperationalEnvName(requestInfo.getInstanceName());
 292         }
 293
 294         aq.setRequestBody(this.requestJSON);
 295
 296         aq.setRequestStatus(status.toString());
 297         aq.setLastModifiedBy(Constants.MODIFIED_BY_APIHANDLER);
 298
 299         if ((status == Status.FAILED) || (status == Status.COMPLETE)) {
 300             aq.setStatusMessage(this.errorMessage);
 301             aq.setResponseBody(this.responseBody);
 302             aq.setProgress(Long.valueOf(100));
 303
 304             Timestamp endTimeStamp = new Timestamp(System.currentTimeMillis());
 305             aq.setEndTime(endTimeStamp);
 306         } else if (status == Status.IN_PROGRESS) {
 307             aq.setProgress(Constants.PROGRESS_REQUEST_IN_PROGRESS);
 308         }
 309         requestsDbClient.save(aq);
 310     }
 311
 312
 313     public Map<String, String> getOrchestrationFilters(MultivaluedMap<String, String> queryParams)
 314             throws ValidationException {
 315         String queryParam = null;
 316         Map<String, String> orchestrationFilterParams = new HashMap<>();
 317
 318         for (Entry<String, List<String>> entry : queryParams.entrySet()) {
 319             queryParam = entry.getKey();
 320             try {
 321                 for (String value : entry.getValue()) {
 322                     if (StringUtils.isBlank(value)) {
 323                         throw (new Exception(queryParam + " value"));
 324                     }
 325                     orchestrationFilterParams.put(queryParam, value);
 326                 }
 327             } catch (Exception e) {
 328                 logger.error("Exception in getOrchestrationFilters", e);
 329                 throw new ValidationException(e.getMessage(), true);
 330             }
 331         }
 332
 333         return orchestrationFilterParams;
 334     }
 335
 336     private static boolean empty(String s) {
 337         return (s == null || s.trim().isEmpty());
 338     }
 339
 340     public String getRequestId() {
 341         return requestId;
 342     }
 343
 344     public void setRequestId(String requestId) {
 345         this.requestId = requestId;
 346     }
 347
 348     public void updateFinalStatus() {
 349         try {
 350             InfraActiveRequests request = new InfraActiveRequests(requestId);
 351             request.setRequestStatus(status.toString());
 352             request.setStatusMessage(this.errorMessage);
 353             request.setProgress(this.progress);
 354             request.setResponseBody(this.responseBody);
 355             request.setLastModifiedBy(Constants.MODIFIED_BY_APIHANDLER);
 356             requestsDbClient.save(request);
 357         } catch (Exception e) {
 358             logger.error("Exception when updating record in DB", e);
 359             logger.debug("Exception: ", e);
 360         }
 361     }
 362
 363     public void setStatus(RequestStatusType status) {
 364         this.status = status;
 365         switch (status) {
 366             case FAILED:
 367             case COMPLETE:
 368                 this.progress = Constants.PROGRESS_REQUEST_COMPLETED;
 369                 break;
 370             case IN_PROGRESS:
 371                 this.progress = Constants.PROGRESS_REQUEST_IN_PROGRESS;
 372                 break;
 373             case PENDING:
 374                 break;
 375             case TIMEOUT:
 376                 break;
 377             case UNLOCKED:
 378                 break;
 379             default:
 380                 break;
 381         }
 382     }
 383
 384     public String getOperationalEnvironmentId() {
 385         return operationalEnvironmentId;
 386     }
 387
 388     public void setOperationalEnvironmentId(String operationalEnvironmentId) {
 389         this.operationalEnvironmentId = operationalEnvironmentId;
 390     }
 391 }