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 serviceInstanceType = e2eSir.getService().getParameters().getServiceType();
 269
 270                 String serviceId = "";
 271                 RequestClient requestClient = null;
 272                 HttpResponse response = null;
 273
 274                 long subStartTime = System.currentTimeMillis();
 275                 String sirRequestJson = mapReqJsonToSvcInstReq(e2eSir, requestJSON);
 276
 277                 try {
 278                         requestClient = RequestClientFactory.getRequestClient(recipeLookupResult.getOrchestrationURI(),
 279                                         MsoPropertiesUtils.loadMsoProperties());
 280
 281                         // Capture audit event
 282                         msoLogger.debug("MSO API Handler Posting call to BPEL engine for url: " + requestClient.getUrl());
 283
 284                         response = requestClient.post(requestId, false, recipeLookupResult.getRecipeTimeout(), action.name(),
 285                                         serviceId, null, null, null, null, serviceInstanceType, null, null, null, sirRequestJson);
 286
 287                         msoLogger.recordMetricEvent(subStartTime, MsoLogger.StatusCode.COMPLETE, MsoLogger.ResponseCode.Suc,
 288                                         "Successfully received response from BPMN engine", "BPMN", recipeLookupResult.getOrchestrationURI(),
 289                                         null);
 290                 } catch (Exception e) {
 291                         msoLogger.recordMetricEvent(subStartTime, MsoLogger.StatusCode.ERROR,
 292                                         MsoLogger.ResponseCode.CommunicationError, "Exception while communicate with BPMN engine", "BPMN",
 293                                         recipeLookupResult.getOrchestrationURI(), null);
 294                         Response resp = msoRequest.buildServiceErrorResponse(HttpStatus.SC_BAD_GATEWAY,
 295                                         MsoException.ServiceException, "Failed calling bpmn " + e.getMessage(),
 296                                         ErrorNumbers.SVC_NO_SERVER_RESOURCES, null);
 297                         alarmLogger.sendAlarm("MsoConfigurationError", MsoAlarmLogger.CRITICAL,
 298                                         Messages.errors.get(ErrorNumbers.NO_COMMUNICATION_TO_BPEL));
 299                         msoLogger.error(MessageEnum.APIH_BPEL_COMMUNICATE_ERROR, MSO_PROP_APIHANDLER_INFRA, "", "",
 300                                         MsoLogger.ErrorCode.AvailabilityError, "Exception while communicate with BPMN engine");
 301                         msoLogger.recordAuditEvent(startTime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.CommunicationError,
 302                                         "Exception while communicate with BPMN engine");
 303                         msoLogger.debug("End of the transaction, the final response is: " + (String) resp.getEntity());
 304                         return resp;
 305                 }
 306
 307                 if (response == null) {
 308                         Response resp = msoRequest.buildServiceErrorResponse(HttpStatus.SC_BAD_GATEWAY,
 309                                         MsoException.ServiceException, "bpelResponse is null", ErrorNumbers.SVC_NO_SERVER_RESOURCES, null);
 310                         msoLogger.error(MessageEnum.APIH_BPEL_COMMUNICATE_ERROR, MSO_PROP_APIHANDLER_INFRA, "", "",
 311                                         MsoLogger.ErrorCode.BusinessProcesssError, "Null response from BPEL");
 312                         msoLogger.recordAuditEvent(startTime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.InternalError,
 313                                         "Null response from BPMN");
 314                         msoLogger.debug(END_OF_THE_TRANSACTION + (String) resp.getEntity());
 315                         return resp;
 316                 }
 317
 318                 ResponseHandler respHandler = new ResponseHandler(response, requestClient.getType());
 319                 int bpelStatus = respHandler.getStatus();
 320
 321                 return beplStatusUpdate(requestId, startTime, msoRequest, requestClient, respHandler, bpelStatus);
 322         }
 323
 324         private void closeCatalogDB(CatalogDatabase db) {
 325                 if (db != null) {
 326                         db.close();
 327                 }
 328         }
 329
 330         private InfraActiveRequests checkForDuplicateRecord(Action action, HashMap<String, String> instanceIdMap,
 331                         String instanceName, String requestScope) {
 332                 InfraActiveRequests dupValue = null;
 333                 if (!(instanceName == null && "service".equals(requestScope)
 334                                 && (action == Action.createInstance || action == Action.activateInstance))) {
 335                         dupValue = (RequestsDatabase.getInstance()).checkInstanceNameDuplicate(instanceIdMap, instanceName,
 336                                         requestScope);
 337                 }
 338                 return dupValue;
 339         }
 340
 341         private Response duplicateRecordFound(Action action, HashMap<String, String> instanceIdMap, long startTime,
 342                         MsoRequest msoRequest, InfraActiveRequests dup, String instanceName, String requestScope) {
 343                 String instance = null;
 344                 if (instanceName != null) {
 345                         instance = instanceName;
 346                 } else {
 347                         instance = instanceIdMap.get(requestScope + "InstanceId");
 348                 }
 349                 String dupMessage = "Error: Locked instance - This " + requestScope + " (" + instance + ") "
 350                                 + "already has a request being worked with a status of " + dup.getRequestStatus() + " (RequestId - "
 351                                 + dup.getRequestId() + "). The existing request must finish or be cleaned up before proceeding.";
 352
 353                 Response response = msoRequest.buildServiceErrorResponse(HttpStatus.SC_CONFLICT, MsoException.ServiceException,
 354                                 dupMessage, ErrorNumbers.SVC_DETAILED_SERVICE_ERROR, null);
 355
 356                 msoLogger.warn(MessageEnum.APIH_DUPLICATE_FOUND, dupMessage, "", "", MsoLogger.ErrorCode.SchemaError,
 357                                 "Duplicate request - Subscriber already has a request for this service");
 358                 msoRequest.createRequestRecord(Status.FAILED, action);
 359                 msoLogger.recordAuditEvent(startTime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.Conflict, dupMessage);
 360                 msoLogger.debug(END_OF_THE_TRANSACTION + (String) response.getEntity());
 361                 return response;
 362         }
 363
 364         private Response beplStatusUpdate(String requestId, long startTime, MsoRequest msoRequest,
 365                         RequestClient requestClient, ResponseHandler respHandler, int bpelStatus) {
 366                 // BPEL accepted the request, the request is in progress
 367                 if (bpelStatus == HttpStatus.SC_ACCEPTED) {
 368                         String camundaJSONResponseBody = respHandler.getResponseBody();
 369                         msoLogger.debug("Received from Camunda: " + camundaJSONResponseBody);
 370                         (RequestsDatabase.getInstance()).updateInfraStatus(requestId, Status.IN_PROGRESS.toString(),
 371                                         Constants.PROGRESS_REQUEST_IN_PROGRESS, Constants.MODIFIED_BY_APIHANDLER);
 372
 373                         msoLogger.recordAuditEvent(startTime, MsoLogger.StatusCode.COMPLETE, MsoLogger.ResponseCode.Suc,
 374                                         "BPMN accepted the request, the request is in progress");
 375                         msoLogger.debug(END_OF_THE_TRANSACTION + camundaJSONResponseBody);
 376                         return Response.status(HttpStatus.SC_ACCEPTED).entity(camundaJSONResponseBody).build();
 377                 } else {
 378                         List<String> variables = new ArrayList<>();
 379                         variables.add(bpelStatus + "");
 380                         String camundaJSONResponseBody = respHandler.getResponseBody();
 381                         if (camundaJSONResponseBody != null && !camundaJSONResponseBody.isEmpty()) {
 382                                 Response resp = msoRequest.buildServiceErrorResponse(bpelStatus, MsoException.ServiceException,
 383                                                 "Request Failed due to BPEL error with HTTP Status= %1 " + '\n' + camundaJSONResponseBody,
 384                                                 ErrorNumbers.SVC_DETAILED_SERVICE_ERROR, variables);
 385                                 msoLogger.error(MessageEnum.APIH_BPEL_RESPONSE_ERROR, requestClient.getUrl(), "", "",
 386                                                 MsoLogger.ErrorCode.BusinessProcesssError,
 387                                                 "Response from BPEL engine is failed with HTTP Status=" + bpelStatus);
 388                                 msoLogger.recordAuditEvent(startTime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.InternalError,
 389                                                 "Response from BPMN engine is failed");
 390                                 msoLogger.debug(END_OF_THE_TRANSACTION + (String) resp.getEntity());
 391                                 return resp;
 392                         } else {
 393                                 Response resp = msoRequest.buildServiceErrorResponse(bpelStatus, MsoException.ServiceException,
 394                                                 "Request Failed due to BPEL error with HTTP Status= %1",
 395                                                 ErrorNumbers.SVC_DETAILED_SERVICE_ERROR, variables);
 396                                 msoLogger.error(MessageEnum.APIH_BPEL_RESPONSE_ERROR, requestClient.getUrl(), "", "",
 397                                                 MsoLogger.ErrorCode.BusinessProcesssError, "Response from BPEL engine is empty");
 398                                 msoLogger.recordAuditEvent(startTime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.InternalError,
 399                                                 "Response from BPEL engine is empty");
 400                                 msoLogger.debug(END_OF_THE_TRANSACTION + (String) resp.getEntity());
 401                                 return resp;
 402                         }
 403                 }
 404         }
 405
 406         /**
 407          * Getting recipes from catalogDb
 408          *
 409          * @param db
 410          * @param action
 411          * @return
 412          */
 413         private RecipeLookupResult getServiceInstanceOrchestrationURI(CatalogDatabase db, Action action) {
 414
 415                 RecipeLookupResult recipeLookupResult = getServiceURI(db, action);
 416
 417                 if (recipeLookupResult != null) {
 418                         msoLogger.debug("Orchestration URI is: " + recipeLookupResult.getOrchestrationURI()
 419                                         + ", recipe Timeout is: " + Integer.toString(recipeLookupResult.getRecipeTimeout()));
 420                 } else {
 421                         msoLogger.debug("No matching recipe record found");
 422                 }
 423                 return recipeLookupResult;
 424         }
 425
 426         /**
 427          * Getting recipes from catalogDb
 428          *
 429          * @param db
 430          * @param action
 431          * @return
 432          */
 433         private RecipeLookupResult getServiceURI(CatalogDatabase db, Action action) {
 434
 435                 String defaultServiceModelName = "UUI_DEFAULT";
 436
 437                 Service serviceRecord = db.getServiceByModelName(defaultServiceModelName);
 438                 ServiceRecipe recipe = db.getServiceRecipeByModelUUID(serviceRecord.getModelUUID(), action.name());
 439
 440                 if (recipe == null) {
 441                         return null;
 442                 }
 443                 return new RecipeLookupResult(recipe.getOrchestrationUri(), recipe.getRecipeTimeout());
 444
 445         }
 446
 447         /**
 448          * Converting E2EServiceInstanceRequest to ServiceInstanceRequest and
 449          * passing it to camunda engine.
 450          *
 451          * @param e2eSir
 452          * @return
 453          */
 454         private String mapReqJsonToSvcInstReq(E2EServiceInstanceRequest e2eSir, String requestJSON) {
 455
 456                 sir = new ServiceInstancesRequest();
 457
 458                 String returnString = null;
 459                 RequestDetails requestDetails = new RequestDetails();
 460                 ModelInfo modelInfo = new ModelInfo();
 461
 462                 // ModelInvariantId
 463                 modelInfo.setModelInvariantId(e2eSir.getService().getServiceDefId());
 464
 465                 // modelNameVersionId
 466                 modelInfo.setModelNameVersionId(e2eSir.getService().getTemplateId());
 467
 468 //              String modelInfoValue = e2eSir.getService().getParameters().getNodeTemplateName();
 469 //              String[] arrayOfInfo = modelInfoValue.split(":");
 470 //              String modelName = arrayOfInfo[0];
 471 //              String modelVersion = arrayOfInfo[1];
 472         String modelName = "voLTE";
 473         String modelVersion = "1.0";
 474                 // modelName
 475                 modelInfo.setModelName(modelName);
 476
 477                 // modelVersion
 478                 modelInfo.setModelVersion(modelVersion);
 479
 480                 // modelType
 481                 modelInfo.setModelType(ModelType.service);
 482
 483                 // setting modelInfo to requestDetails
 484                 requestDetails.setModelInfo(modelInfo);
 485
 486                 SubscriberInfo subscriberInfo = new SubscriberInfo();
 487
 488                 // globalsubscriberId
 489                 subscriberInfo.setGlobalSubscriberId(e2eSir.getService().getParameters().getGlobalSubscriberId());
 490
 491                 // subscriberName
 492                 subscriberInfo.setSubscriberName(e2eSir.getService().getParameters().getSubscriberName());
 493
 494                 // setting subscriberInfo to requestDetails
 495                 requestDetails.setSubscriberInfo(subscriberInfo);
 496
 497                 RequestInfo requestInfo = new RequestInfo();
 498
 499                 // instanceName
 500                 requestInfo.setInstanceName(e2eSir.getService().getName());
 501
 502                 // source
 503                 requestInfo.setSource("UUI");
 504
 505                 // suppressRollback
 506                 requestInfo.setSuppressRollback(true);
 507
 508                 // setting requestInfo to requestDetails
 509                 requestDetails.setRequestInfo(requestInfo);
 510
 511                 RequestParameters requestParameters = new RequestParameters();
 512
 513                 // subscriptionServiceType
 514                 requestParameters.setSubscriptionServiceType("MOG");
 515
 516                 // Userparams
 517                 List<E2EUserParam> userParams;
 518                 //userParams = e2eSir.getService().getParameters().getRequestParameters().getUserParams();
 519                 List<Map<String, String>> userParamList = new ArrayList<>();
 520                 Map<String, String> userParamMap = new HashMap<>();
 521                 //complete json request updated in the camunda
 522                 userParamMap.put("UUIRequest", requestJSON);
 523                 userParamMap.put("ServiceInstanceName", e2eSir.getService().getName());
 524
 525 //              Map<String, String> userParamMap3 = null;
 526 //              for (E2EUserParam userp : userParams) {
 527 //                      userParamMap.put(userp.getName(), userp.getValue());
 528 //
 529 //              }
 530                 userParamList.add(userParamMap);
 531                 requestParameters.setUserParams(userParamList);
 532
 533                 // setting requestParameters to requestDetails
 534                 requestDetails.setRequestParameters(requestParameters);
 535
 536                 sir.setRequestDetails(requestDetails);
 537
 538                 // converting to string
 539                 ObjectMapper mapper = new ObjectMapper();
 540                 try {
 541                         returnString = mapper.writeValueAsString(sir);
 542                 } catch (IOException e) {
 543                         msoLogger.debug("Exception while converting ServiceInstancesRequest object to string", e);
 544                 }
 545
 546                 return returnString;
 547         }
 548
 549         private void createOperationStatusRecord(Action action, String requestId) {
 550                 {
 551                         AbstractSessionFactoryManager requestsDbSessionFactoryManager = new RequestsDbSessionFactoryManager();
 552
 553                         Session session = null;
 554                         try {
 555
 556                                 session = requestsDbSessionFactoryManager.getSessionFactory().openSession();
 557                                 session.beginTransaction();
 558
 559                                 // if (null == sir) {
 560                                 // sir = new ServiceInstancesRequest();
 561                                 // }
 562                                 OperationStatus os = new OperationStatus();
 563                                 os.setOperation(action.name());
 564                                 os.setOperationContent("");
 565                                 os.setOperationId("");
 566                                 os.setProgress("0");
 567                                 os.setReason("");
 568                                 os.setResult("Processing");
 569                                 os.setServiceId(requestId);
 570                                 os.setUserId("");
 571                                 os.setFinishedAt(new Timestamp(System.currentTimeMillis()));
 572                                 os.setOperateAt(new Timestamp(System.currentTimeMillis()));
 573
 574                                 session.save(os);
 575                                 session.getTransaction().commit();
 576
 577                         } catch (Exception e) {
 578                                 msoLogger.error (MessageEnum.APIH_DB_INSERT_EXC, "", "", MsoLogger.ErrorCode.DataError, "Exception when creation record request in Operation", e);
 579                         } finally {
 580                                 if (null != session) {
 581                                         session.close();
 582                                 }
 583                         }
 584                 }
 585         }
 586 }