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