mso-api-handlers/mso-api-handler-infra/src/main/java/org/openecomp/mso/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.openecomp.mso.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 import javax.ws.rs.core.Response;
  31
  32 import org.apache.commons.lang3.StringUtils;
  33 import org.hibernate.Session;
  34 import org.openecomp.mso.apihandler.common.ValidationException;
  35 import org.openecomp.mso.apihandlerinfra.Constants;
  36 import org.openecomp.mso.apihandlerinfra.MsoException;
  37 import org.openecomp.mso.apihandlerinfra.Status;
  38 import org.openecomp.mso.apihandlerinfra.tenantisolationbeans.Action;
  39 import org.openecomp.mso.apihandlerinfra.tenantisolationbeans.Manifest;
  40 import org.openecomp.mso.apihandlerinfra.tenantisolationbeans.OperationalEnvironment;
  41 import org.openecomp.mso.apihandlerinfra.tenantisolationbeans.RelatedInstance;
  42 import org.openecomp.mso.apihandlerinfra.tenantisolationbeans.RelatedInstanceList;
  43 import org.openecomp.mso.apihandlerinfra.tenantisolationbeans.RequestDetails;
  44 import org.openecomp.mso.apihandlerinfra.tenantisolationbeans.RequestInfo;
  45 import org.openecomp.mso.apihandlerinfra.tenantisolationbeans.RequestParameters;
  46 import org.openecomp.mso.apihandlerinfra.tenantisolationbeans.ResourceType;
  47 import org.openecomp.mso.apihandlerinfra.tenantisolationbeans.ServiceModelList;
  48 import org.openecomp.mso.apihandlerinfra.vnfbeans.RequestStatusType;
  49 import org.openecomp.mso.db.AbstractSessionFactoryManager;
  50 import org.openecomp.mso.logger.MessageEnum;
  51 import org.openecomp.mso.logger.MsoLogger;
  52 import org.openecomp.mso.requestsdb.InfraActiveRequests;
  53 import org.openecomp.mso.requestsdb.RequestsDatabase;
  54 import org.openecomp.mso.requestsdb.RequestsDbSessionFactoryManager;
  55 import org.openecomp.mso.serviceinstancebeans.PolicyException;
  56 import org.openecomp.mso.serviceinstancebeans.RequestError;
  57 import org.openecomp.mso.serviceinstancebeans.ServiceException;
  58 import org.openecomp.mso.utils.UUIDChecker;
  59
  60 import com.fasterxml.jackson.annotation.JsonInclude.Include;
  61 import com.fasterxml.jackson.databind.ObjectMapper;
  62
  63 public class TenantIsolationRequest {
  64
  65     private String requestId;
  66     private String requestJSON;
  67     private RequestInfo requestInfo;
  68
  69     private String errorMessage;
  70     private String errorCode;
  71     private String httpResponse;
  72     private String responseBody;
  73     private RequestStatusType status;
  74     private CloudOrchestrationRequest cor;
  75     private String operationalEnvironmentId;
  76     private long progress = Constants.PROGRESS_REQUEST_RECEIVED;
  77     private String requestScope;
  78
  79
  80
  81     private static MsoLogger msoLogger = MsoLogger.getMsoLogger (MsoLogger.Catalog.APIH);
  82     protected AbstractSessionFactoryManager requestsDbSessionFactoryManager = new RequestsDbSessionFactoryManager ();
  83
  84         TenantIsolationRequest (String requestId) {
  85         this.requestId = requestId;
  86         MsoLogger.setLogContext (requestId, null);
  87     }
  88
  89         TenantIsolationRequest () {
  90         MsoLogger.setLogContext (requestId, null);
  91     }
  92
  93         void parse(CloudOrchestrationRequest request, HashMap<String,String> instanceIdMap, Action action) throws ValidationException {
  94                 msoLogger.debug ("Validating the Cloud Orchestration request");
  95                 this.cor = request;
  96                 this.requestInfo = request.getRequestDetails().getRequestInfo();
  97
  98                 try{
  99                 ObjectMapper mapper = new ObjectMapper();
 100                 requestJSON = mapper.writeValueAsString(request.getRequestDetails());
 101
 102         } catch(Exception e){
 103                 throw new ValidationException ("Parse ServiceInstanceRequest to JSON string");
 104         }
 105
 106                 String envId = null;
 107                 if(instanceIdMap != null) {
 108                         envId = instanceIdMap.get("operationalEnvironmentId");
 109                         if(envId != null && !UUIDChecker.isValidUUID (envId)){
 110                                 throw new ValidationException ("operationalEnvironmentId");
 111                         }
 112                         cor.setOperationalEnvironmentId(envId);
 113                 }
 114
 115                 this.operationalEnvironmentId = envId;
 116
 117                 RequestDetails requestDetails = request.getRequestDetails();
 118                 RequestParameters requestParameters = requestDetails.getRequestParameters();
 119
 120                 requestInfoValidation(action, requestInfo);
 121
 122                 requestParamsValidation(action, requestParameters);
 123
 124                 relatedInstanceValidation(action, requestDetails, requestParameters);
 125
 126         }
 127
 128         private void relatedInstanceValidation(Action action, RequestDetails requestDetails, RequestParameters requestParameters) throws ValidationException {
 129                 RelatedInstanceList[] instanceList = requestDetails.getRelatedInstanceList();
 130
 131                 if((Action.activate.equals(action) || Action.deactivate.equals(action)) && OperationalEnvironment.ECOMP.equals(requestParameters.getOperationalEnvironmentType())) {
 132                         throw new ValidationException("operationalEnvironmentType in requestParameters");
 133                 }
 134
 135                 if(!Action.deactivate.equals(action) && OperationalEnvironment.VNF.equals(requestParameters.getOperationalEnvironmentType())) {
 136                         if(instanceList != null && instanceList.length > 0) {
 137                                 for(RelatedInstanceList relatedInstanceList : instanceList){
 138                                         RelatedInstance relatedInstance = relatedInstanceList.getRelatedInstance();
 139
 140                                         if(relatedInstance.getResourceType() == null) {
 141                                                 throw new ValidationException("ResourceType in relatedInstance");
 142                                         }
 143
 144                                         if(!empty(relatedInstance.getInstanceName()) && !relatedInstance.getInstanceName().matches(Constants.VALID_INSTANCE_NAME_FORMAT)) {
 145                                                 throw new ValidationException ("instanceName format");
 146                                         }
 147
 148                                         if (empty (relatedInstance.getInstanceId ())) {
 149                                                 throw new ValidationException ("instanceId in relatedInstance");
 150                                         }
 151
 152                                         if (!UUIDChecker.isValidUUID (relatedInstance.getInstanceId ())) {
 153                                                 throw new ValidationException ("instanceId format in relatedInstance");
 154                                         }
 155                                 }
 156                         } else {
 157                                 throw new ValidationException ("relatedInstanceList");
 158                         }
 159                 }
 160         }
 161
 162         private void requestParamsValidation(Action action, RequestParameters requestParameters) throws ValidationException {
 163
 164                 if(requestParameters != null) {
 165                         if(!Action.deactivate.equals(action) && requestParameters.getOperationalEnvironmentType() == null) {
 166                                 throw new ValidationException ("OperationalEnvironmentType");
 167                         }
 168
 169                         if (Action.create.equals(action) && empty(requestParameters.getTenantContext())) {
 170                                 throw new ValidationException ("Tenant Context");
 171                         }
 172                         if (!Action.deactivate.equals(action) && empty(requestParameters.getWorkloadContext())) {
 173                                 throw new ValidationException ("Workload Context");
 174                         }
 175
 176                         Manifest manifest = requestParameters.getManifest();
 177
 178                         if(Action.activate.equals(action)) {
 179                                 if(manifest == null) {
 180                                         throw new ValidationException ("Manifest on Activate");
 181                                 } else {
 182                                         List<ServiceModelList> serviceModelList = manifest.getServiceModelList();
 183
 184                                         if(serviceModelList.size() == 0) {
 185                                                 throw new ValidationException (" empty ServiceModelList");
 186                                         }
 187
 188                                         for(ServiceModelList list : serviceModelList) {
 189                                                 if(empty(list.getServiceModelVersionId())) {
 190                                                         throw new ValidationException ("ServiceModelVersionId");
 191                                                 }
 192
 193                                                 if (!UUIDChecker.isValidUUID (list.getServiceModelVersionId())) {
 194                                                         throw new ValidationException ("ServiceModelVersionId format");
 195                                                 }
 196
 197                                                 if(list.getRecoveryAction() == null) {
 198                                                         throw new ValidationException ("RecoveryAction");
 199                                                 }
 200                                         }
 201                                 }
 202                         }
 203                 } else if(!Action.deactivate.equals(action)) {
 204                         throw new ValidationException("request Parameters");
 205                 }
 206         }
 207
 208         private void requestInfoValidation(Action action, RequestInfo requestInfo) throws ValidationException {
 209
 210                 if(Action.create.equals(action) && empty(requestInfo.getInstanceName())) {
 211                         throw new ValidationException ("instanceName");
 212                 }
 213
 214                 if(!empty(requestInfo.getInstanceName()) && !requestInfo.getInstanceName().matches(Constants.VALID_INSTANCE_NAME_FORMAT)) {
 215                         throw new ValidationException ("instanceName format");
 216                 }
 217
 218                 if (empty(requestInfo.getSource())) {
 219                 throw new ValidationException ("source");
 220         }
 221
 222                 if(empty(requestInfo.getRequestorId())) {
 223                 throw new ValidationException ("requestorId");
 224         }
 225
 226                 ResourceType resourceType = requestInfo.getResourceType();
 227                 if(resourceType == null) {
 228                         throw new ValidationException ("resourceType");
 229                 }
 230
 231                 this.requestScope = resourceType.name();
 232         }
 233
 234         void parseOrchestration (CloudOrchestrationRequest cor) throws ValidationException {
 235
 236         msoLogger.debug ("Validating the Orchestration request");
 237
 238         this.cor = cor;
 239
 240         try{
 241                 ObjectMapper mapper = new ObjectMapper();
 242                 //mapper.configure(Feature.WRAP_ROOT_VALUE, true);
 243                 requestJSON = mapper.writeValueAsString(cor.getRequestDetails());
 244
 245         } catch(Exception e){
 246                 throw new ValidationException ("Parse CloudOrchestrationRequest to JSON string", e);
 247         }
 248
 249         this.requestInfo = cor.getRequestDetails().getRequestInfo();
 250
 251         if (this.requestInfo == null) {
 252             throw new ValidationException ("requestInfo");
 253         }
 254
 255         if (empty (requestInfo.getSource ())) {
 256                 throw new ValidationException ("source");
 257         }
 258         if (empty (requestInfo.getRequestorId ())) {
 259                 throw new ValidationException ("requestorId");
 260         }
 261     }
 262
 263     public void createRequestRecord (Status status, Action action) {
 264          Session session = null;
 265          try {
 266
 267              session = requestsDbSessionFactoryManager.getSessionFactory ().openSession ();
 268              session.beginTransaction ();
 269
 270              if (null == cor) {
 271                  cor = new CloudOrchestrationRequest();
 272              }
 273
 274              InfraActiveRequests aq = new InfraActiveRequests ();
 275              aq.setRequestId (requestId);
 276
 277              aq.setRequestAction(action.name());
 278              aq.setAction(action.name());
 279
 280              Timestamp startTimeStamp = new Timestamp (System.currentTimeMillis());
 281
 282              aq.setStartTime (startTimeStamp);
 283
 284              if (requestInfo != null) {
 285
 286                 if(requestInfo.getSource() != null){
 287                         aq.setSource(requestInfo.getSource());
 288                 }
 289                 if(requestInfo.getRequestorId() != null) {
 290                         aq.setRequestorId(requestInfo.getRequestorId());
 291                 }
 292                 if(requestInfo.getResourceType() != null) {
 293                         aq.setRequestScope(requestInfo.getResourceType().name());
 294                 }
 295              }
 296
 297              if(ResourceType.operationalEnvironment.name().equalsIgnoreCase(requestScope)) {
 298                 aq.setOperationalEnvId(operationalEnvironmentId);
 299                 aq.setOperationalEnvName(requestInfo.getInstanceName());
 300              }
 301
 302              aq.setRequestBody (this.requestJSON);
 303
 304              aq.setRequestStatus (status.toString ());
 305              aq.setLastModifiedBy (Constants.MODIFIED_BY_APIHANDLER);
 306
 307              if ((status == Status.FAILED) || (status == Status.COMPLETE)) {
 308                  aq.setStatusMessage (this.errorMessage);
 309                  aq.setResponseBody (this.responseBody);
 310                  aq.setProgress(new Long(100));
 311
 312                  Timestamp endTimeStamp = new Timestamp (System.currentTimeMillis());
 313                  aq.setEndTime (endTimeStamp);
 314              } else if(status == Status.IN_PROGRESS) {
 315                  aq.setProgress(Constants.PROGRESS_REQUEST_IN_PROGRESS);
 316              }
 317
 318              msoLogger.debug ("About to insert a record");
 319
 320              session.save (aq);
 321              session.getTransaction ().commit ();
 322              session.close ();
 323          } catch (Exception e) {
 324                 msoLogger.error (MessageEnum.APIH_DB_INSERT_EXC, "", "", MsoLogger.ErrorCode.DataError, "Exception when creation record request", e);
 325              if (session != null) {
 326                  session.close ();
 327              }
 328              if (!status.equals (Status.FAILED)) {
 329                  throw e;
 330              }
 331          }
 332     }
 333
 334
 335     public Map<String, String> getOrchestrationFilters (MultivaluedMap<String, String> queryParams) throws ValidationException {
 336         String queryParam = null;
 337         Map<String, String> orchestrationFilterParams = new HashMap<String, String>();
 338
 339         for (Entry<String,List<String>> entry : queryParams.entrySet()) {
 340             queryParam = entry.getKey();
 341             try{
 342                           for(String value : entry.getValue()) {
 343                                   if(StringUtils.isBlank(value)) {
 344                                           throw new Exception(queryParam + " value");
 345                                   }
 346                                   orchestrationFilterParams.put(queryParam, value);
 347                           }
 348             }catch(Exception e){
 349                 throw new ValidationException (e.getMessage());
 350                 }
 351         }
 352
 353         return orchestrationFilterParams;
 354   }
 355
 356     /**
 357      * Build Error Response for Exception handling.
 358      *
 359      * @param int
 360      * @param httpResponseCode the HTTP response code
 361      * @param exceptionType.
 362      * @param text the error description
 363      * @param messageId
 364      * @return the web service response
 365      *
 366      */
 367     public Response buildServiceErrorResponse (int httpResponseCode,
 368                                                                                     MsoException exceptionType,
 369                                                                                     String text,
 370                                                                                     String messageId,
 371                                                                                     List<String> variables) {
 372
 373         this.errorCode = messageId;
 374
 375         if (text != null) {
 376                 this.errorMessage = text;
 377         }
 378         else {
 379                 this.errorMessage = "";
 380         }
 381         this.httpResponse = Integer.toString(httpResponseCode);
 382         if(errorMessage.length() > 1999){
 383             errorMessage = errorMessage.substring(0, 1999);
 384         }
 385
 386         RequestError re = new RequestError();
 387
 388         if(exceptionType.name().equals("PolicyException")){
 389
 390                 PolicyException pe = new PolicyException();
 391                 pe.setMessageId(messageId);
 392                 pe.setText(text);
 393                 if(variables != null){
 394                         for(String variable: variables){
 395                                 pe.getVariables().add(variable);
 396                         }
 397                 }
 398                 re.setPolicyException(pe);
 399
 400         } else {
 401
 402                 ServiceException se = new ServiceException();
 403                 se.setMessageId(messageId);
 404                 se.setText(text);
 405                 if(variables != null){
 406                         if(variables != null){
 407                                 for(String variable: variables){
 408                                         se.getVariables().add(variable);
 409                                 }
 410                         }
 411                 }
 412                 re.setServiceException(se);
 413         }
 414
 415         String requestErrorStr = null;
 416
 417         try{
 418                 ObjectMapper mapper = new ObjectMapper();
 419                 mapper.setSerializationInclusion(Include.NON_DEFAULT);
 420                 requestErrorStr = mapper.writeValueAsString(re);
 421         }catch(Exception e){
 422                 msoLogger.error (MessageEnum.APIH_VALIDATION_ERROR, "", "", MsoLogger.ErrorCode.DataError, "Exception in buildServiceErrorResponse writing exceptionType to string ", e);
 423         }
 424
 425
 426         return Response.status (httpResponseCode).entity(requestErrorStr).build ();
 427
 428     }
 429
 430         private static boolean empty(String s) {
 431                 return (s == null || s.trim().isEmpty());
 432         }
 433
 434     public String getRequestId () {
 435         return requestId;
 436     }
 437
 438     public void setRequestId(String requestId) {
 439         this.requestId = requestId;
 440     }
 441
 442         public void updateFinalStatus(Status failed) {
 443                 try {
 444                         (RequestsDatabase.getInstance()).updateInfraFinalStatus (requestId,
 445                                                                                                                                         status.toString (),
 446                                                                                                                                         this.errorMessage,
 447                                                                                                                                         this.progress,
 448                                                                                                                                         this.responseBody,
 449                                                                                                                                         Constants.MODIFIED_BY_APIHANDLER);
 450                 } catch (Exception e) {
 451                         msoLogger.error(MessageEnum.APIH_DB_UPDATE_EXC, e.getMessage(), "", "", MsoLogger.ErrorCode.DataError, "Exception when updating record in DB");
 452                         msoLogger.debug ("Exception: ", e);
 453                 }
 454         }
 455
 456         public void setStatus (RequestStatusType status) {
 457         this.status = status;
 458         switch (status) {
 459         case FAILED:
 460         case COMPLETE:
 461                 this.progress = Constants.PROGRESS_REQUEST_COMPLETED;
 462                 break;
 463         case IN_PROGRESS:
 464                 this.progress = Constants.PROGRESS_REQUEST_IN_PROGRESS;
 465                 break;
 466         }
 467     }
 468
 469         public String getOperationalEnvironmentId() {
 470                 return operationalEnvironmentId;
 471         }
 472
 473         public void setOperationalEnvironmentId(String operationalEnvironmentId) {
 474                 this.operationalEnvironmentId = operationalEnvironmentId;
 475         }
 476 }