mso-api-handlers/mso-api-handler-infra/src/main/java/org/openecomp/mso/apihandlerinfra/E2EServiceInstances.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * ONAP - SO
   4  * ================================================================================
   5  * Copyright (C) 2017 Huawei Technologies Co., Ltd. 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;
  22
  23 import java.io.IOException;
  24 import java.sql.Timestamp;
  25 import java.util.ArrayList;
  26 import java.util.HashMap;
  27 import java.util.List;
  28 import java.util.Map;
  29
  30 import javax.ws.rs.Consumes;
  31 import javax.ws.rs.DELETE;
  32 import javax.ws.rs.POST;
  33 import javax.ws.rs.Path;
  34 import javax.ws.rs.PathParam;
  35 import javax.ws.rs.Produces;
  36 import javax.ws.rs.core.MediaType;
  37 import javax.ws.rs.core.Response;
  38
  39 import org.apache.http.HttpResponse;
  40 import org.apache.http.HttpStatus;
  41 import org.codehaus.jackson.map.ObjectMapper;
  42 import org.hibernate.Session;
  43
  44 import org.openecomp.mso.apihandler.common.ErrorNumbers;
  45 import org.openecomp.mso.apihandler.common.RequestClient;
  46 import org.openecomp.mso.apihandler.common.RequestClientFactory;
  47 import org.openecomp.mso.apihandler.common.ResponseHandler;
  48 import org.openecomp.mso.apihandlerinfra.e2eserviceinstancebeans.E2EServiceInstanceRequest;
  49 import org.openecomp.mso.apihandlerinfra.e2eserviceinstancebeans.E2EUserParam;
  50 import org.openecomp.mso.apihandlerinfra.serviceinstancebeans.ModelInfo;
  51 import org.openecomp.mso.apihandlerinfra.serviceinstancebeans.RequestDetails;
  52 import org.openecomp.mso.apihandlerinfra.serviceinstancebeans.RequestInfo;
  53 import org.openecomp.mso.apihandlerinfra.serviceinstancebeans.RequestParameters;
  54 import org.openecomp.mso.apihandlerinfra.serviceinstancebeans.ServiceInstancesRequest;
  55 import org.openecomp.mso.apihandlerinfra.serviceinstancebeans.SubscriberInfo;
  56 import org.openecomp.mso.db.AbstractSessionFactoryManager;
  57 import org.openecomp.mso.db.catalog.CatalogDatabase;
  58 import org.openecomp.mso.db.catalog.beans.Service;
  59 import org.openecomp.mso.db.catalog.beans.ServiceRecipe;
  60 import org.openecomp.mso.logger.MessageEnum;
  61 import org.openecomp.mso.logger.MsoAlarmLogger;
  62 import org.openecomp.mso.logger.MsoLogger;
  63 import org.openecomp.mso.requestsdb.InfraActiveRequests;
  64 import org.openecomp.mso.requestsdb.OperationStatus;
  65 import org.openecomp.mso.requestsdb.RequestsDatabase;
  66 import org.openecomp.mso.requestsdb.RequestsDbSessionFactoryManager;
  67 import org.openecomp.mso.utils.UUIDChecker;
  68
  69 import com.wordnik.swagger.annotations.Api;
  70 import com.wordnik.swagger.annotations.ApiOperation;
  71
  72 @Path("/e2eServiceInstances")
  73 @Api(value = "/e2eServiceInstances", description = "API Requests for E2E Service Instances")
  74 public class E2EServiceInstances {
  75
  76         private HashMap<String, String> instanceIdMap = new HashMap<>();
  77         private static MsoLogger msoLogger = MsoLogger.getMsoLogger(MsoLogger.Catalog.APIH);
  78         private static MsoAlarmLogger alarmLogger = new MsoAlarmLogger();
  79         public static final String MSO_PROP_APIHANDLER_INFRA = "MSO_PROP_APIHANDLER_INFRA";
  80         private ServiceInstancesRequest sir = null;
  81
  82         public static final String END_OF_THE_TRANSACTION = "End of the transaction, the final response is: ";
  83         public static final String EXCEPTION_CREATING_DB_RECORD = "Exception while creating record in DB";
  84         public static final String EXCEPTION_COMMUNICATE_BPMN_ENGINE = "Exception while communicate with BPMN engine";
  85
  86         /**
  87          * POST Requests for E2E Service create Instance on a version provided
  88          */
  89
  90         @POST
  91         @Path("/{version:[vV][3-5]}")
  92         @Consumes(MediaType.APPLICATION_JSON)
  93         @Produces(MediaType.APPLICATION_JSON)
  94         @ApiOperation(value = "Create a E2E Service Instance on a version provided", response = Response.class)
  95         public Response createE2EServiceInstance(String request, @PathParam("version") String version) {
  96
  97                 return processE2EserviceInstances(request, Action.createInstance, null, version);
  98         }
  99
 100         /**
 101          * DELETE Requests for E2E Service delete Instance on a specified version
 102          * and serviceId
 103          */
 104
 105         @DELETE
 106         @Path("/{version:[vV][3-5]}/{serviceId}")
 107         @Consumes(MediaType.APPLICATION_JSON)
 108         @Produces(MediaType.APPLICATION_JSON)
 109         @ApiOperation(value = "Delete E2E Service Instance on a specified version and serviceId", response = Response.class)
 110         public Response deleteE2EServiceInstance(String request, @PathParam("version") String version,
 111                         @PathParam("serviceId") String serviceId) {
 112
 113                 instanceIdMap.put("serviceId", serviceId);
 114
 115                 return processE2EserviceInstances(request, Action.deleteInstance, null, version);
 116         }
 117
 118         private Response processE2EserviceInstances(String requestJSON, Action action,
 119                         HashMap<String, String> instanceIdMap, String version) {
 120
 121                 String requestId = UUIDChecker.generateUUID(msoLogger);
 122                 long startTime = System.currentTimeMillis();
 123                 msoLogger.debug("requestId is: " + requestId);
 124                 E2EServiceInstanceRequest e2eSir = null;
 125
 126                 MsoRequest msoRequest = new MsoRequest(requestId);
 127                 ObjectMapper mapper = new ObjectMapper();
 128                 try {
 129                         e2eSir = mapper.readValue(requestJSON, E2EServiceInstanceRequest.class);
 130
 131                 } catch (Exception e) {
 132
 133                         msoLogger.debug("Mapping of request to JSON object failed : ", e);
 134                         Response response = msoRequest.buildServiceErrorResponse(HttpStatus.SC_BAD_REQUEST,
 135                                         MsoException.ServiceException, "Mapping of request to JSON object failed.  " + e.getMessage(),
 136                                         ErrorNumbers.SVC_BAD_PARAMETER, null);
 137                         msoLogger.error(MessageEnum.APIH_REQUEST_VALIDATION_ERROR, MSO_PROP_APIHANDLER_INFRA, "", "",
 138                                         MsoLogger.ErrorCode.SchemaError, requestJSON, e);
 139                         msoLogger.recordAuditEvent(startTime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.SchemaError,
 140                                         "Mapping of request to JSON object failed");
 141                         msoLogger.debug("End of the transaction, the final response is: " + (String) response.getEntity());
 142                         return response;
 143                 }
 144
 145                 mapReqJsonToSvcInstReq(e2eSir, requestJSON);
 146                 sir.getRequestDetails().getRequestParameters().setaLaCarte(true);
 147                 try {
 148                         msoRequest.parse(sir, instanceIdMap, action, version);
 149                 } catch (Exception e) {
 150                         msoLogger.debug("Validation failed: ", e);
 151                         Response response = msoRequest.buildServiceErrorResponse(HttpStatus.SC_BAD_REQUEST,
 152                                         MsoException.ServiceException, "Error parsing request.  " + e.getMessage(),
 153                                         ErrorNumbers.SVC_BAD_PARAMETER, null);
 154                         if (msoRequest.getRequestId() != null) {
 155                                 msoLogger.debug("Logging failed message to the database");
 156                                 msoRequest.createRequestRecord(Status.FAILED, action);
 157                         }
 158                         msoLogger.error(MessageEnum.APIH_REQUEST_VALIDATION_ERROR, MSO_PROP_APIHANDLER_INFRA, "", "",
 159                                         MsoLogger.ErrorCode.SchemaError, requestJSON, e);
 160                         msoLogger.recordAuditEvent(startTime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.SchemaError,
 161                                         "Validation of the input request failed");
 162                         msoLogger.debug("End of the transaction, the final response is: " + (String) response.getEntity());
 163                         return response;
 164                 }
 165
 166                 InfraActiveRequests dup = null;
 167 //              String instanceName = sir.getService().getName();
 168 //              String requestScope = sir.getService().getParameters().getNodeType();
 169                 String instanceName = sir.getRequestDetails().getRequestInfo().getInstanceName();
 170                 String requestScope = sir.getRequestDetails().getModelInfo().getModelType().name();
 171                 try {
 172                         if (!(instanceName == null && "service".equals(requestScope)
 173                                         && (action == Action.createInstance || action == Action.activateInstance))) {
 174                                 dup = (RequestsDatabase.getInstance()).checkInstanceNameDuplicate(instanceIdMap, instanceName,
 175                                                 requestScope);
 176                         }
 177                 } catch (Exception e) {
 178                         msoLogger.error(MessageEnum.APIH_DUPLICATE_CHECK_EXC, MSO_PROP_APIHANDLER_INFRA, "", "",
 179                                         MsoLogger.ErrorCode.DataError, "Error during duplicate check ", e);
 180
 181                         Response response = msoRequest.buildServiceErrorResponse(HttpStatus.SC_INTERNAL_SERVER_ERROR,
 182                                         MsoException.ServiceException, e.getMessage(), ErrorNumbers.SVC_DETAILED_SERVICE_ERROR, null);
 183
 184                         msoLogger.recordAuditEvent(startTime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.DBAccessError,
 185                                         "Error during duplicate check");
 186                         msoLogger.debug("End of the transaction, the final response is: " + (String) response.getEntity());
 187                         return response;
 188                 }
 189
 190                 if (dup != null) {
 191                         // Found the duplicate record. Return the appropriate error.
 192                         String instance = null;
 193                         if (instanceName != null) {
 194                                 instance = instanceName;
 195                         } else {
 196                                 instance = instanceIdMap.get(requestScope + "InstanceId");
 197                         }
 198                         String dupMessage = "Error: Locked instance - This " + requestScope + " (" + instance + ") "
 199                                         + "already has a request being worked with a status of " + dup.getRequestStatus() + " (RequestId - "
 200                                         + dup.getRequestId() + "). The existing request must finish or be cleaned up before proceeding.";
 201
 202                         Response response = msoRequest.buildServiceErrorResponse(HttpStatus.SC_CONFLICT,
 203                                         MsoException.ServiceException, dupMessage, ErrorNumbers.SVC_DETAILED_SERVICE_ERROR, null);
 204
 205                         msoLogger.warn(MessageEnum.APIH_DUPLICATE_FOUND, dupMessage, "", "", MsoLogger.ErrorCode.SchemaError,
 206                                         "Duplicate request - Subscriber already has a request for this service");
 207                         msoRequest.createRequestRecord(Status.FAILED, action);
 208                         msoLogger.recordAuditEvent(startTime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.Conflict,
 209                                         dupMessage);
 210                         msoLogger.debug("End of the transaction, the final response is: " + (String) response.getEntity());
 211                         return response;
 212                 }
 213
 214                 CatalogDatabase db = null;
 215                 RecipeLookupResult recipeLookupResult = null;
 216                 try {
 217                         db = CatalogDatabase.getInstance();
 218                         recipeLookupResult = getServiceInstanceOrchestrationURI(db, action);
 219                 } catch (Exception e) {
 220                         msoLogger.error(MessageEnum.APIH_DB_ACCESS_EXC, MSO_PROP_APIHANDLER_INFRA, "", "",
 221                                         MsoLogger.ErrorCode.AvailabilityError, "Exception while communciate with Catalog DB", e);
 222                         msoRequest.setStatus(org.openecomp.mso.apihandlerinfra.vnfbeans.RequestStatusType.FAILED);
 223                         Response response = msoRequest.buildServiceErrorResponse(HttpStatus.SC_NOT_FOUND,
 224                                         MsoException.ServiceException, "No communication to catalog DB " + e.getMessage(),
 225                                         ErrorNumbers.SVC_NO_SERVER_RESOURCES, null);
 226                         alarmLogger.sendAlarm("MsoDatabaseAccessError", MsoAlarmLogger.CRITICAL,
 227                                         Messages.errors.get(ErrorNumbers.NO_COMMUNICATION_TO_CATALOG_DB));
 228                         msoRequest.createRequestRecord(Status.FAILED, action);
 229                         msoLogger.recordAuditEvent(startTime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.DBAccessError,
 230                                         "Exception while communciate with DB");
 231                         msoLogger.debug(END_OF_THE_TRANSACTION + (String) response.getEntity());
 232                         return response;
 233                 } finally {
 234                         closeCatalogDB(db);
 235                 }
 236
 237                 if (recipeLookupResult == null) {
 238                         msoLogger.error(MessageEnum.APIH_DB_ATTRIBUTE_NOT_FOUND, MSO_PROP_APIHANDLER_INFRA, "", "",
 239                                         MsoLogger.ErrorCode.DataError, "No recipe found in DB");
 240                         msoRequest.setStatus(org.openecomp.mso.apihandlerinfra.vnfbeans.RequestStatusType.FAILED);
 241                         Response response = msoRequest.buildServiceErrorResponse(HttpStatus.SC_NOT_FOUND,
 242                                         MsoException.ServiceException, "Recipe does not exist in catalog DB",
 243                                         ErrorNumbers.SVC_GENERAL_SERVICE_ERROR, null);
 244                         msoRequest.createRequestRecord(Status.FAILED, action);
 245                         msoLogger.recordAuditEvent(startTime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.DataNotFound,
 246                                         "No recipe found in DB");
 247                         msoLogger.debug(END_OF_THE_TRANSACTION + (String) response.getEntity());
 248
 249                         return response;
 250                 }
 251
 252                 try {
 253                         msoRequest.createRequestRecord(Status.PENDING, action);
 254                         createOperationStatusRecord(action, requestId);
 255                 } catch (Exception e) {
 256                         msoLogger.error(MessageEnum.APIH_DB_ACCESS_EXC_REASON, "Exception while creating record in DB", "", "",
 257                                         MsoLogger.ErrorCode.SchemaError, "Exception while creating record in DB", e);
 258                         msoRequest.setStatus(org.openecomp.mso.apihandlerinfra.vnfbeans.RequestStatusType.FAILED);
 259                         Response response = msoRequest.buildServiceErrorResponse(HttpStatus.SC_INTERNAL_SERVER_ERROR,
 260                                         MsoException.ServiceException, "Exception while creating record in DB " + e.getMessage(),
 261                                         ErrorNumbers.SVC_BAD_PARAMETER, null);
 262                         msoLogger.recordAuditEvent(startTime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.DBAccessError,
 263                                         "Exception while creating record in DB");
 264                         msoLogger.debug("End of the transaction, the final response is: " + (String) response.getEntity());
 265                         return response;
 266                 }
 267
 268                 String modelInfo = e2eSir.getService().getParameters().getNodeTemplateName();
 269                 String[] arrayOfInfo = modelInfo.split(":");
 270                 String serviceInstanceType = arrayOfInfo[0];
 271
 272                 String serviceId = "";
 273
 274                 RequestClient requestClient = null;
 275                 HttpResponse response = null;
 276
 277                 long subStartTime = System.currentTimeMillis();
 278                 String sirRequestJson = mapReqJsonToSvcInstReq(e2eSir, requestJSON);
 279
 280                 try {
 281                         requestClient = RequestClientFactory.getRequestClient(recipeLookupResult.getOrchestrationURI(),
 282                                         MsoPropertiesUtils.loadMsoProperties());
 283
 284                         // Capture audit event
 285                         msoLogger.debug("MSO API Handler Posting call to BPEL engine for url: " + requestClient.getUrl());
 286
 287                         response = requestClient.post(requestId, false, recipeLookupResult.getRecipeTimeout(), action.name(),
 288                                         serviceId, null, null, null, null, serviceInstanceType, null, null, null, sirRequestJson);
 289
 290                         msoLogger.recordMetricEvent(subStartTime, MsoLogger.StatusCode.COMPLETE, MsoLogger.ResponseCode.Suc,
 291                                         "Successfully received response from BPMN engine", "BPMN", recipeLookupResult.getOrchestrationURI(),
 292                                         null);
 293                 } catch (Exception e) {
 294                         msoLogger.recordMetricEvent(subStartTime, MsoLogger.StatusCode.ERROR,
 295                                         MsoLogger.ResponseCode.CommunicationError, "Exception while communicate with BPMN engine", "BPMN",
 296                                         recipeLookupResult.getOrchestrationURI(), null);
 297                         Response resp = msoRequest.buildServiceErrorResponse(HttpStatus.SC_BAD_GATEWAY,
 298                                         MsoException.ServiceException, "Failed calling bpmn " + e.getMessage(),
 299                                         ErrorNumbers.SVC_NO_SERVER_RESOURCES, null);
 300                         alarmLogger.sendAlarm("MsoConfigurationError", MsoAlarmLogger.CRITICAL,
 301                                         Messages.errors.get(ErrorNumbers.NO_COMMUNICATION_TO_BPEL));
 302                         msoLogger.error(MessageEnum.APIH_BPEL_COMMUNICATE_ERROR, MSO_PROP_APIHANDLER_INFRA, "", "",
 303                                         MsoLogger.ErrorCode.AvailabilityError, "Exception while communicate with BPMN engine");
 304                         msoLogger.recordAuditEvent(startTime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.CommunicationError,
 305                                         "Exception while communicate with BPMN engine");
 306                         msoLogger.debug("End of the transaction, the final response is: " + (String) resp.getEntity());
 307                         return resp;
 308                 }
 309
 310                 if (response == null) {
 311                         Response resp = msoRequest.buildServiceErrorResponse(HttpStatus.SC_BAD_GATEWAY,
 312                                         MsoException.ServiceException, "bpelResponse is null", ErrorNumbers.SVC_NO_SERVER_RESOURCES, null);
 313                         msoLogger.error(MessageEnum.APIH_BPEL_COMMUNICATE_ERROR, MSO_PROP_APIHANDLER_INFRA, "", "",
 314                                         MsoLogger.ErrorCode.BusinessProcesssError, "Null response from BPEL");
 315                         msoLogger.recordAuditEvent(startTime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.InternalError,
 316                                         "Null response from BPMN");
 317                         msoLogger.debug(END_OF_THE_TRANSACTION + (String) resp.getEntity());
 318                         return resp;
 319                 }
 320
 321                 ResponseHandler respHandler = new ResponseHandler(response, requestClient.getType());
 322                 int bpelStatus = respHandler.getStatus();
 323
 324                 return beplStatusUpdate(requestId, startTime, msoRequest, requestClient, respHandler, bpelStatus);
 325         }
 326
 327         private void closeCatalogDB(CatalogDatabase db) {
 328                 if (db != null) {
 329                         db.close();
 330                 }
 331         }
 332
 333         private InfraActiveRequests checkForDuplicateRecord(Action action, HashMap<String, String> instanceIdMap,
 334                         String instanceName, String requestScope) {
 335                 InfraActiveRequests dupValue = null;
 336                 if (!(instanceName == null && "service".equals(requestScope)
 337                                 && (action == Action.createInstance || action == Action.activateInstance))) {
 338                         dupValue = (RequestsDatabase.getInstance()).checkInstanceNameDuplicate(instanceIdMap, instanceName,
 339                                         requestScope);
 340                 }
 341                 return dupValue;
 342         }
 343
 344         private Response duplicateRecordFound(Action action, HashMap<String, String> instanceIdMap, long startTime,
 345                         MsoRequest msoRequest, InfraActiveRequests dup, String instanceName, String requestScope) {
 346                 String instance = null;
 347                 if (instanceName != null) {
 348                         instance = instanceName;
 349                 } else {
 350                         instance = instanceIdMap.get(requestScope + "InstanceId");
 351                 }
 352                 String dupMessage = "Error: Locked instance - This " + requestScope + " (" + instance + ") "
 353                                 + "already has a request being worked with a status of " + dup.getRequestStatus() + " (RequestId - "
 354                                 + dup.getRequestId() + "). The existing request must finish or be cleaned up before proceeding.";
 355
 356                 Response response = msoRequest.buildServiceErrorResponse(HttpStatus.SC_CONFLICT, MsoException.ServiceException,
 357                                 dupMessage, ErrorNumbers.SVC_DETAILED_SERVICE_ERROR, null);
 358
 359                 msoLogger.warn(MessageEnum.APIH_DUPLICATE_FOUND, dupMessage, "", "", MsoLogger.ErrorCode.SchemaError,
 360                                 "Duplicate request - Subscriber already has a request for this service");
 361                 msoRequest.createRequestRecord(Status.FAILED, action);
 362                 msoLogger.recordAuditEvent(startTime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.Conflict, dupMessage);
 363                 msoLogger.debug(END_OF_THE_TRANSACTION + (String) response.getEntity());
 364                 return response;
 365         }
 366
 367         private Response beplStatusUpdate(String requestId, long startTime, MsoRequest msoRequest,
 368                         RequestClient requestClient, ResponseHandler respHandler, int bpelStatus) {
 369                 // BPEL accepted the request, the request is in progress
 370                 if (bpelStatus == HttpStatus.SC_ACCEPTED) {
 371                         String camundaJSONResponseBody = respHandler.getResponseBody();
 372                         msoLogger.debug("Received from Camunda: " + camundaJSONResponseBody);
 373                         (RequestsDatabase.getInstance()).updateInfraStatus(requestId, Status.IN_PROGRESS.toString(),
 374                                         Constants.PROGRESS_REQUEST_IN_PROGRESS, Constants.MODIFIED_BY_APIHANDLER);
 375
 376                         msoLogger.recordAuditEvent(startTime, MsoLogger.StatusCode.COMPLETE, MsoLogger.ResponseCode.Suc,
 377                                         "BPMN accepted the request, the request is in progress");
 378                         msoLogger.debug(END_OF_THE_TRANSACTION + camundaJSONResponseBody);
 379                         return Response.status(HttpStatus.SC_ACCEPTED).entity(camundaJSONResponseBody).build();
 380                 } else {
 381                         List<String> variables = new ArrayList<>();
 382                         variables.add(bpelStatus + "");
 383                         String camundaJSONResponseBody = respHandler.getResponseBody();
 384                         if (camundaJSONResponseBody != null && !camundaJSONResponseBody.isEmpty()) {
 385                                 Response resp = msoRequest.buildServiceErrorResponse(bpelStatus, MsoException.ServiceException,
 386                                                 "Request Failed due to BPEL error with HTTP Status= %1 " + '\n' + camundaJSONResponseBody,
 387                                                 ErrorNumbers.SVC_DETAILED_SERVICE_ERROR, variables);
 388                                 msoLogger.error(MessageEnum.APIH_BPEL_RESPONSE_ERROR, requestClient.getUrl(), "", "",
 389                                                 MsoLogger.ErrorCode.BusinessProcesssError,
 390                                                 "Response from BPEL engine is failed with HTTP Status=" + bpelStatus);
 391                                 msoLogger.recordAuditEvent(startTime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.InternalError,
 392                                                 "Response from BPMN engine is failed");
 393                                 msoLogger.debug(END_OF_THE_TRANSACTION + (String) resp.getEntity());
 394                                 return resp;
 395                         } else {
 396                                 Response resp = msoRequest.buildServiceErrorResponse(bpelStatus, MsoException.ServiceException,
 397                                                 "Request Failed due to BPEL error with HTTP Status= %1",
 398                                                 ErrorNumbers.SVC_DETAILED_SERVICE_ERROR, variables);
 399                                 msoLogger.error(MessageEnum.APIH_BPEL_RESPONSE_ERROR, requestClient.getUrl(), "", "",
 400                                                 MsoLogger.ErrorCode.BusinessProcesssError, "Response from BPEL engine is empty");
 401                                 msoLogger.recordAuditEvent(startTime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.InternalError,
 402                                                 "Response from BPEL engine is empty");
 403                                 msoLogger.debug(END_OF_THE_TRANSACTION + (String) resp.getEntity());
 404                                 return resp;
 405                         }
 406                 }
 407         }
 408
 409         /**
 410          * Getting recipes from catalogDb
 411          *
 412          * @param db
 413          * @param action
 414          * @return
 415          */
 416         private RecipeLookupResult getServiceInstanceOrchestrationURI(CatalogDatabase db, Action action) {
 417
 418                 RecipeLookupResult recipeLookupResult = getServiceURI(db, action);
 419
 420                 if (recipeLookupResult != null) {
 421                         msoLogger.debug("Orchestration URI is: " + recipeLookupResult.getOrchestrationURI()
 422                                         + ", recipe Timeout is: " + Integer.toString(recipeLookupResult.getRecipeTimeout()));
 423                 } else {
 424                         msoLogger.debug("No matching recipe record found");
 425                 }
 426                 return recipeLookupResult;
 427         }
 428
 429         /**
 430          * Getting recipes from catalogDb
 431          *
 432          * @param db
 433          * @param action
 434          * @return
 435          */
 436         private RecipeLookupResult getServiceURI(CatalogDatabase db, Action action) {
 437
 438                 String defaultServiceModelName = "UUI_DEFAULT";
 439
 440                 Service serviceRecord = db.getServiceByModelName(defaultServiceModelName);
 441                 ServiceRecipe recipe = db.getServiceRecipeByModelUUID(serviceRecord.getModelUUID(), action.name());
 442
 443                 if (recipe == null) {
 444                         return null;
 445                 }
 446                 return new RecipeLookupResult(recipe.getOrchestrationUri(), recipe.getRecipeTimeout());
 447
 448         }
 449
 450         /**
 451          * Converting E2EServiceInstanceRequest to ServiceInstanceRequest and
 452          * passing it to camunda engine.
 453          *
 454          * @param e2eSir
 455          * @return
 456          */
 457         private String mapReqJsonToSvcInstReq(E2EServiceInstanceRequest e2eSir, String requestJSON) {
 458
 459                 sir = new ServiceInstancesRequest();
 460
 461                 String returnString = null;
 462                 RequestDetails requestDetails = new RequestDetails();
 463                 ModelInfo modelInfo = new ModelInfo();
 464
 465                 // ModelInvariantId
 466                 modelInfo.setModelInvariantId(e2eSir.getService().getServiceDefId());
 467
 468                 // modelNameVersionId
 469                 modelInfo.setModelNameVersionId(e2eSir.getService().getTemplateId());
 470
 471                 String modelInfoValue = e2eSir.getService().getParameters().getNodeTemplateName();
 472                 String[] arrayOfInfo = modelInfoValue.split(":");
 473                 String modelName = arrayOfInfo[0];
 474                 String modelVersion = arrayOfInfo[1];
 475
 476                 // modelName
 477                 modelInfo.setModelName(modelName);
 478
 479                 // modelVersion
 480                 modelInfo.setModelVersion(modelVersion);
 481
 482                 // modelType
 483                 modelInfo.setModelType(ModelType.service);
 484
 485                 // setting modelInfo to requestDetails
 486                 requestDetails.setModelInfo(modelInfo);
 487
 488                 SubscriberInfo subscriberInfo = new SubscriberInfo();
 489
 490                 // globalsubscriberId
 491                 subscriberInfo.setGlobalSubscriberId(e2eSir.getService().getParameters().getGlobalSubscriberId());
 492
 493                 // subscriberName
 494                 subscriberInfo.setSubscriberName(e2eSir.getService().getParameters().getSubscriberName());
 495
 496                 // setting subscriberInfo to requestDetails
 497                 requestDetails.setSubscriberInfo(subscriberInfo);
 498
 499                 RequestInfo requestInfo = new RequestInfo();
 500
 501                 // instanceName
 502                 requestInfo.setInstanceName(e2eSir.getService().getName());
 503
 504                 // source
 505                 requestInfo.setSource("UUI");
 506
 507                 // suppressRollback
 508                 requestInfo.setSuppressRollback(true);
 509
 510                 // setting requestInfo to requestDetails
 511                 requestDetails.setRequestInfo(requestInfo);
 512
 513                 RequestParameters requestParameters = new RequestParameters();
 514
 515                 // subscriptionServiceType
 516                 requestParameters.setSubscriptionServiceType("MOG");
 517
 518                 // Userparams
 519                 List<E2EUserParam> userParams;
 520                 userParams = e2eSir.getService().getParameters().getRequestParameters().getUserParams();
 521                 List<Map<String, String>> userParamList = new ArrayList<>();
 522                 Map<String, String> userParamMap = new HashMap<>();
 523                 //complete json request updated in the camunda
 524                 userParamMap.put("UUIRequest", requestJSON);
 525                 userParamMap.put("ServiceInstanceName", e2eSir.getService().getName());
 526
 527                 Map<String, String> userParamMap3 = null;
 528                 for (E2EUserParam userp : userParams) {
 529                         userParamMap.put(userp.getName(), userp.getValue());
 530                         userParamList.add(userParamMap);
 531                 }
 532
 533                 requestParameters.setUserParams(userParamList);
 534
 535                 // setting requestParameters to requestDetails
 536                 requestDetails.setRequestParameters(requestParameters);
 537
 538                 sir.setRequestDetails(requestDetails);
 539
 540                 // converting to string
 541                 ObjectMapper mapper = new ObjectMapper();
 542                 try {
 543                         returnString = mapper.writeValueAsString(sir);
 544                 } catch (IOException e) {
 545                         msoLogger.debug("Exception while converting ServiceInstancesRequest object to string", e);
 546                 }
 547
 548                 return returnString;
 549         }
 550
 551         private void createOperationStatusRecord(Action action, String requestId) {
 552                 {
 553                         AbstractSessionFactoryManager requestsDbSessionFactoryManager = new RequestsDbSessionFactoryManager();
 554
 555                         Session session = null;
 556                         try {
 557
 558                                 session = requestsDbSessionFactoryManager.getSessionFactory().openSession();
 559                                 session.beginTransaction();
 560
 561                                 // if (null == sir) {
 562                                 // sir = new ServiceInstancesRequest();
 563                                 // }
 564                                 OperationStatus os = new OperationStatus();
 565                                 os.setOperation(action.name());
 566                                 os.setOperationContent("");
 567                                 os.setOperationId("");
 568                                 os.setProgress("0");
 569                                 os.setReason("");
 570                                 os.setResult("Processing");
 571                                 os.setServiceId(requestId);
 572                                 os.setUserId("");
 573                                 os.setFinishedAt(new Timestamp(System.currentTimeMillis()));
 574                                 os.setOperateAt(new Timestamp(System.currentTimeMillis()));
 575
 576                                 session.save(os);
 577                                 session.getTransaction().commit();
 578
 579                         } catch (Exception e) {
 580                                 msoLogger.error (MessageEnum.APIH_DB_INSERT_EXC, "", "", MsoLogger.ErrorCode.DataError, "Exception when creation record request in Operation", e);
 581                         } finally {
 582                                 if (null != session) {
 583                                         session.close();
 584                                 }
 585                         }
 586                 }
 587         }
 588 }