mso-api-handlers/mso-api-handler-infra/src/main/java/org/onap/so/apihandlerinfra/tenantisolation/TenantIsolationRequest.java

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