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         aq.setAction(action.name());
 272
 273         Timestamp startTimeStamp = new Timestamp(System.currentTimeMillis());
 274
 275         aq.setStartTime(startTimeStamp);
 276
 277         if (requestInfo != null) {
 278
 279             if (requestInfo.getSource() != null) {
 280                 aq.setSource(requestInfo.getSource());
 281             }
 282             if (requestInfo.getRequestorId() != null) {
 283                 aq.setRequestorId(requestInfo.getRequestorId());
 284             }
 285             if (requestInfo.getResourceType() != null) {
 286                 aq.setRequestScope(requestInfo.getResourceType().name());
 287             }
 288         }
 289
 290         if (ResourceType.operationalEnvironment.name().equalsIgnoreCase(requestScope) && requestInfo != null) {
 291             aq.setOperationalEnvId(operationalEnvironmentId);
 292             aq.setOperationalEnvName(requestInfo.getInstanceName());
 293         }
 294
 295         aq.setRequestBody(this.requestJSON);
 296
 297         aq.setRequestStatus(status.toString());
 298         aq.setLastModifiedBy(Constants.MODIFIED_BY_APIHANDLER);
 299
 300         if ((status == Status.FAILED) || (status == Status.COMPLETE)) {
 301             aq.setStatusMessage(this.errorMessage);
 302             aq.setResponseBody(this.responseBody);
 303             aq.setProgress(Long.valueOf(100));
 304
 305             Timestamp endTimeStamp = new Timestamp(System.currentTimeMillis());
 306             aq.setEndTime(endTimeStamp);
 307         } else if (status == Status.IN_PROGRESS) {
 308             aq.setProgress(Constants.PROGRESS_REQUEST_IN_PROGRESS);
 309         }
 310         requestsDbClient.save(aq);
 311     }
 312
 313
 314     public Map<String, String> getOrchestrationFilters(MultivaluedMap<String, String> queryParams)
 315             throws ValidationException {
 316         String queryParam = null;
 317         Map<String, String> orchestrationFilterParams = new HashMap<>();
 318
 319         for (Entry<String, List<String>> entry : queryParams.entrySet()) {
 320             queryParam = entry.getKey();
 321             try {
 322                 for (String value : entry.getValue()) {
 323                     if (StringUtils.isBlank(value)) {
 324                         throw (new Exception(queryParam + " value"));
 325                     }
 326                     orchestrationFilterParams.put(queryParam, value);
 327                 }
 328             } catch (Exception e) {
 329                 logger.error("Exception in getOrchestrationFilters", e);
 330                 throw new ValidationException(e.getMessage(), true);
 331             }
 332         }
 333
 334         return orchestrationFilterParams;
 335     }
 336
 337     private static boolean empty(String s) {
 338         return (s == null || s.trim().isEmpty());
 339     }
 340
 341     public String getRequestId() {
 342         return requestId;
 343     }
 344
 345     public void setRequestId(String requestId) {
 346         this.requestId = requestId;
 347     }
 348
 349     public void updateFinalStatus() {
 350         try {
 351             InfraActiveRequests request = new InfraActiveRequests(requestId);
 352             request.setRequestStatus(status.toString());
 353             request.setStatusMessage(this.errorMessage);
 354             request.setProgress(this.progress);
 355             request.setResponseBody(this.responseBody);
 356             request.setLastModifiedBy(Constants.MODIFIED_BY_APIHANDLER);
 357             requestsDbClient.save(request);
 358         } catch (Exception e) {
 359             logger.error("Exception when updating record in DB", e);
 360             logger.debug("Exception: ", e);
 361         }
 362     }
 363
 364     public void setStatus(RequestStatusType status) {
 365         this.status = status;
 366         switch (status) {
 367             case FAILED:
 368             case COMPLETE:
 369                 this.progress = Constants.PROGRESS_REQUEST_COMPLETED;
 370                 break;
 371             case IN_PROGRESS:
 372                 this.progress = Constants.PROGRESS_REQUEST_IN_PROGRESS;
 373                 break;
 374             case PENDING:
 375                 break;
 376             case TIMEOUT:
 377                 break;
 378             case UNLOCKED:
 379                 break;
 380             default:
 381                 break;
 382         }
 383     }
 384
 385     public String getOperationalEnvironmentId() {
 386         return operationalEnvironmentId;
 387     }
 388
 389     public void setOperationalEnvironmentId(String operationalEnvironmentId) {
 390         this.operationalEnvironmentId = operationalEnvironmentId;
 391     }
 392 }