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.util.ArrayList;
  25 import java.util.HashMap;
  26 import java.util.List;
  27 import java.util.Map;
  28
  29 import javax.ws.rs.Consumes;
  30 import javax.ws.rs.DELETE;
  31 import javax.ws.rs.GET;
  32 import javax.ws.rs.POST;
  33 import javax.ws.rs.PUT;
  34 import javax.ws.rs.Path;
  35 import javax.ws.rs.PathParam;
  36 import javax.ws.rs.Produces;
  37 import javax.ws.rs.core.MediaType;
  38 import javax.ws.rs.core.Response;
  39
  40 import org.apache.http.HttpResponse;
  41 import org.apache.http.HttpStatus;
  42 import org.json.JSONObject;
  43 import org.openecomp.mso.apihandler.common.ErrorNumbers;
  44 import org.openecomp.mso.apihandler.common.RequestClient;
  45 import org.openecomp.mso.apihandler.common.RequestClientFactory;
  46 import org.openecomp.mso.apihandler.common.RequestClientParamater;
  47 import org.openecomp.mso.apihandler.common.ResponseHandler;
  48 import org.openecomp.mso.apihandlerinfra.e2eserviceinstancebeans.CompareModelsRequest;
  49 import org.openecomp.mso.apihandlerinfra.e2eserviceinstancebeans.E2EServiceInstanceDeleteRequest;
  50 import org.openecomp.mso.apihandlerinfra.e2eserviceinstancebeans.E2EServiceInstanceRequest;
  51 import org.openecomp.mso.apihandlerinfra.e2eserviceinstancebeans.E2EServiceInstanceScaleRequest;
  52 import org.openecomp.mso.apihandlerinfra.e2eserviceinstancebeans.GetE2EServiceInstanceResponse;
  53 import org.openecomp.mso.db.catalog.CatalogDatabase;
  54 import org.openecomp.mso.db.catalog.beans.Service;
  55 import org.openecomp.mso.db.catalog.beans.ServiceRecipe;
  56 import org.openecomp.mso.logger.MessageEnum;
  57 import org.openecomp.mso.logger.MsoAlarmLogger;
  58 import org.openecomp.mso.logger.MsoLogger;
  59 import org.openecomp.mso.requestsdb.OperationStatus;
  60 import org.openecomp.mso.requestsdb.RequestsDatabase;
  61 import org.openecomp.mso.serviceinstancebeans.ModelInfo;
  62 import org.openecomp.mso.serviceinstancebeans.ModelType;
  63 import org.openecomp.mso.serviceinstancebeans.RequestDetails;
  64 import org.openecomp.mso.serviceinstancebeans.RequestInfo;
  65 import org.openecomp.mso.serviceinstancebeans.RequestParameters;
  66 import org.openecomp.mso.serviceinstancebeans.ServiceInstancesRequest;
  67 import org.openecomp.mso.serviceinstancebeans.SubscriberInfo;
  68 import org.openecomp.mso.utils.UUIDChecker;
  69
  70 import com.fasterxml.jackson.databind.ObjectMapper;
  71 import com.wordnik.swagger.annotations.Api;
  72 import com.wordnik.swagger.annotations.ApiOperation;
  73
  74 @Path("/e2eServiceInstances")
  75 @Api(value = "/e2eServiceInstances", description = "API Requests for E2E Service Instances")
  76 public class E2EServiceInstances {
  77
  78         private HashMap<String, String> instanceIdMap = new HashMap<>();
  79         private static MsoLogger msoLogger = MsoLogger
  80                         .getMsoLogger(MsoLogger.Catalog.APIH);
  81         private static MsoAlarmLogger alarmLogger = new MsoAlarmLogger();
  82         public static final String MSO_PROP_APIHANDLER_INFRA = "MSO_PROP_APIHANDLER_INFRA";
  83         private ServiceInstancesRequest sir = null;
  84
  85         public static final String END_OF_THE_TRANSACTION = "End of the transaction, the final response is: ";
  86
  87         /**
  88          * POST Requests for E2E Service create Instance on a version provided
  89          */
  90
  91         @POST
  92         @Path("/{version:[vV][3-5]}")
  93         @Consumes(MediaType.APPLICATION_JSON)
  94         @Produces(MediaType.APPLICATION_JSON)
  95         @ApiOperation(value = "Create an E2E Service Instance on a version provided", response = Response.class)
  96         public Response createE2EServiceInstance(String request,
  97                         @PathParam("version") String version) {
  98
  99                 return processE2EserviceInstances(request, Action.createInstance, null,
 100                                 version);
 101         }
 102
 103         /**
 104          * PUT Requests for E2E Service update Instance on a version provided
 105          */
 106
 107         @PUT
 108         @Path("/{version:[vV][3-5]}/{serviceId}")
 109         @Consumes(MediaType.APPLICATION_JSON)
 110         @Produces(MediaType.APPLICATION_JSON)
 111         @ApiOperation(value = "Update an E2E Service Instance on a version provided and serviceId", response = Response.class)
 112         public Response updateE2EServiceInstance(String request,
 113                         @PathParam("version") String version,
 114                         @PathParam("serviceId") String serviceId) {
 115
 116                 instanceIdMap.put("serviceId", serviceId);
 117
 118                 return updateE2EserviceInstances(request, Action.updateInstance, instanceIdMap,
 119                                 version);
 120         }
 121
 122         /**
 123          * DELETE Requests for E2E Service delete Instance on a specified version
 124          * and serviceId
 125          */
 126
 127         @DELETE
 128         @Path("/{version:[vV][3-5]}/{serviceId}")
 129         @Consumes(MediaType.APPLICATION_JSON)
 130         @Produces(MediaType.APPLICATION_JSON)
 131         @ApiOperation(value = "Delete E2E Service Instance on a specified version and serviceId", response = Response.class)
 132         public Response deleteE2EServiceInstance(String request,
 133                         @PathParam("version") String version,
 134                         @PathParam("serviceId") String serviceId) {
 135
 136                 instanceIdMap.put("serviceId", serviceId);
 137
 138                 return deleteE2EserviceInstances(request, Action.deleteInstance,
 139                                 instanceIdMap, version);
 140         }
 141
 142         @GET
 143         @Path("/{version:[vV][3-5]}/{serviceId}/operations/{operationId}")
 144         @ApiOperation(value = "Find e2eServiceInstances Requests for a given serviceId and operationId", response = Response.class)
 145         @Produces(MediaType.APPLICATION_JSON)
 146         public Response getE2EServiceInstances(
 147                         @PathParam("serviceId") String serviceId,
 148                         @PathParam("version") String version,
 149                         @PathParam("operationId") String operationId) {
 150                 return getE2EServiceInstances(serviceId, operationId);
 151         }
 152
 153     /**
 154          * Scale Requests for E2E Service scale Instance on a specified version
 155      */
 156
 157         @POST
 158         @Path("/{version:[vV][3-5]}/{serviceId}/scale")
 159         @Consumes(MediaType.APPLICATION_JSON)
 160         @Produces(MediaType.APPLICATION_JSON)
 161         @ApiOperation(value="Scale E2E Service Instance on a specified version",response=Response.class)
 162         public Response scaleE2EServiceInstance(String request,
 163                                             @PathParam("version") String version,
 164                                             @PathParam("serviceId") String serviceId) {
 165
 166                 msoLogger.debug("------------------scale begin------------------");
 167                 instanceIdMap.put("serviceId", serviceId);
 168                 return scaleE2EserviceInstances(request, Action.scaleInstance, instanceIdMap, version);
 169         }
 170         /**
 171          * GET Requests for Comparing model of service instance with target version
 172          */
 173
 174         @POST
 175         @Path("/{version:[vV][3-5]}/{serviceId}/modeldifferences")
 176         @Consumes(MediaType.APPLICATION_JSON)
 177         @Produces(MediaType.APPLICATION_JSON)
 178         @ApiOperation(value = "Find added and deleted resources of target model for the e2eserviceInstance on a given serviceId ", response = Response.class)
 179         public Response compareModelwithTargetVersion(String request,
 180                         @PathParam("serviceId") String serviceId,
 181                         @PathParam("version") String version) {
 182
 183                 instanceIdMap.put("serviceId", serviceId);
 184
 185                 return compareModelwithTargetVersion(request, Action.compareModel, instanceIdMap, version);
 186         }
 187
 188         private Response compareModelwithTargetVersion(String requestJSON, Action action,
 189                         HashMap<String, String> instanceIdMap, String version) {
 190
 191                 String requestId = UUIDChecker.generateUUID(msoLogger);
 192                 long startTime = System.currentTimeMillis();
 193                 msoLogger.debug("requestId is: " + requestId);
 194
 195                 CompareModelsRequest e2eCompareModelReq = null;
 196
 197                 MsoRequest msoRequest = new MsoRequest(requestId);
 198
 199                 ObjectMapper mapper = new ObjectMapper();
 200                 try {
 201                         e2eCompareModelReq = mapper.readValue(requestJSON, CompareModelsRequest.class);
 202
 203                 } catch (Exception e) {
 204
 205                         msoLogger.debug("Mapping of request to JSON object failed : ", e);
 206                         Response response = msoRequest.buildServiceErrorResponse(HttpStatus.SC_BAD_REQUEST,
 207                                         MsoException.ServiceException, "Mapping of request to JSON object failed.  " + e.getMessage(),
 208                                         ErrorNumbers.SVC_BAD_PARAMETER, null);
 209                         msoLogger.error(MessageEnum.APIH_REQUEST_VALIDATION_ERROR, MSO_PROP_APIHANDLER_INFRA, "", "",
 210                                         MsoLogger.ErrorCode.SchemaError, requestJSON, e);
 211                         msoLogger.recordAuditEvent(startTime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.SchemaError,
 212                                         "Mapping of request to JSON object failed");
 213                         msoLogger.debug("End of the transaction, the final response is: " + response.getEntity().toString());
 214
 215                         return response;
 216                 }
 217
 218                 Response returnResp = runCompareModelBPMWorkflow(e2eCompareModelReq, msoRequest, requestJSON, requestId,
 219                                 startTime, action);
 220
 221                 return returnResp;
 222
 223         }
 224
 225         private Response runCompareModelBPMWorkflow(CompareModelsRequest e2eCompareModelReq, MsoRequest msoRequest,
 226                         String requestJSON, String requestId, long startTime, Action action) {
 227
 228                 // Define RecipeLookupResult info here instead of query DB for efficiency
 229                 String workflowUrl = "/mso/async/services/CompareModelofE2EServiceInstance";
 230
 231                 RequestClient requestClient = null;
 232                 HttpResponse response = null;
 233
 234                 long subStartTime = System.currentTimeMillis();
 235
 236                 try {
 237                         requestClient = RequestClientFactory.getRequestClient(workflowUrl, MsoPropertiesUtils.loadMsoProperties());
 238
 239                         JSONObject jjo = new JSONObject(requestJSON);
 240
 241                         // Capture audit event
 242                         msoLogger.debug("MSO API Handler Posting call to BPEL engine for url: " + requestClient.getUrl());
 243                         RequestClientParamater requestClientParamater = new RequestClientParamater.Builder().setRequestId(requestId).
 244                                         setBaseVfModule(false).setRecipeTimeout(180).setRequestAction(action.name()).
 245                                         setServiceInstanceId(instanceIdMap.get("serviceId")).setServiceType(e2eCompareModelReq.getServiceType()).
 246                                         setRequestDetails(jjo.toString()).build();
 247
 248                         response = requestClient.post(requestClientParamater);
 249
 250                         msoLogger.recordMetricEvent(subStartTime, MsoLogger.StatusCode.COMPLETE, MsoLogger.ResponseCode.Suc,
 251                                         "Successfully received response from BPMN engine", "BPMN", workflowUrl, null);
 252                 } catch (Exception e) {
 253                         msoLogger.recordMetricEvent(subStartTime, MsoLogger.StatusCode.ERROR,
 254                                         MsoLogger.ResponseCode.CommunicationError, "Exception while communicate with BPMN engine", "BPMN",
 255                                         workflowUrl, null);
 256                         Response resp = msoRequest.buildServiceErrorResponse(HttpStatus.SC_BAD_GATEWAY,
 257                                         MsoException.ServiceException, "Failed calling bpmn " + e.getMessage(),
 258                                         ErrorNumbers.SVC_NO_SERVER_RESOURCES, null);
 259                         alarmLogger.sendAlarm("MsoConfigurationError", MsoAlarmLogger.CRITICAL,
 260                                         Messages.errors.get(ErrorNumbers.NO_COMMUNICATION_TO_BPEL));
 261                         msoLogger.error(MessageEnum.APIH_BPEL_COMMUNICATE_ERROR, MSO_PROP_APIHANDLER_INFRA, "", "",
 262                                         MsoLogger.ErrorCode.AvailabilityError, "Exception while communicate with BPMN engine",e);
 263                         msoLogger.recordAuditEvent(startTime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.CommunicationError,
 264                                         "Exception while communicate with BPMN engine");
 265                         msoLogger.debug("End of the transaction, the final response is: " + resp.getEntity().toString());
 266                         return resp;
 267                 }
 268
 269                 if (response == null) {
 270                         Response resp = msoRequest.buildServiceErrorResponse(HttpStatus.SC_BAD_GATEWAY,
 271                                         MsoException.ServiceException, "bpelResponse is null", ErrorNumbers.SVC_NO_SERVER_RESOURCES, null);
 272                         msoLogger.error(MessageEnum.APIH_BPEL_COMMUNICATE_ERROR, MSO_PROP_APIHANDLER_INFRA, "", "",
 273                                         MsoLogger.ErrorCode.BusinessProcesssError, "Null response from BPEL");
 274                         msoLogger.recordAuditEvent(startTime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.InternalError,
 275                                         "Null response from BPMN");
 276                         msoLogger.debug(END_OF_THE_TRANSACTION + resp.getEntity().toString());
 277                         return resp;
 278                 }
 279
 280                 ResponseHandler respHandler = new ResponseHandler(response, requestClient.getType());
 281                 int bpelStatus = respHandler.getStatus();
 282                 // String responseBody = respHandler.getResponseBody();
 283                 // CompareModelsResult modelDiffResponse = new CompareModelsResult();
 284
 285                 return beplStatusUpdate(requestId, startTime, msoRequest, requestClient, respHandler, bpelStatus, action,
 286                                 instanceIdMap);
 287         }
 288
 289         private Response getE2EServiceInstances(String serviceId, String operationId) {
 290                 RequestsDatabase requestsDB = RequestsDatabase.getInstance();
 291
 292                 GetE2EServiceInstanceResponse e2eServiceResponse = new GetE2EServiceInstanceResponse();
 293
 294                 MsoRequest msoRequest = new MsoRequest(serviceId);
 295
 296                 long startTime = System.currentTimeMillis();
 297
 298                 OperationStatus operationStatus = null;
 299
 300                 try {
 301                         operationStatus = requestsDB.getOperationStatus(serviceId,
 302                                         operationId);
 303
 304                 } catch (Exception e) {
 305                         msoLogger
 306                                         .error(MessageEnum.APIH_DB_ACCESS_EXC,
 307                                                         MSO_PROP_APIHANDLER_INFRA,
 308                                                         "",
 309                                                         "",
 310                                                         MsoLogger.ErrorCode.AvailabilityError,
 311                                                         "Exception while communciate with Request DB - Infra Request Lookup",
 312                                                         e);
 313                         msoRequest
 314                                         .setStatus(org.openecomp.mso.apihandlerinfra.vnfbeans.RequestStatusType.FAILED);
 315                         Response response = msoRequest.buildServiceErrorResponse(
 316                                         HttpStatus.SC_NOT_FOUND, MsoException.ServiceException,
 317                                         e.getMessage(),
 318                                         ErrorNumbers.NO_COMMUNICATION_TO_REQUESTS_DB, null);
 319                         alarmLogger.sendAlarm("MsoDatabaseAccessError",
 320                                         MsoAlarmLogger.CRITICAL, Messages.errors
 321                                                         .get(ErrorNumbers.NO_COMMUNICATION_TO_REQUESTS_DB));
 322                         msoLogger.recordAuditEvent(startTime, MsoLogger.StatusCode.ERROR,
 323                                         MsoLogger.ResponseCode.DBAccessError,
 324                                         "Exception while communciate with Request DB");
 325                         msoLogger.debug("End of the transaction, the final response is: "
 326                                         + (String) response.getEntity());
 327                         return response;
 328
 329                 }
 330
 331                 if (operationStatus == null) {
 332                         Response resp = msoRequest.buildServiceErrorResponse(
 333                                         HttpStatus.SC_NO_CONTENT, MsoException.ServiceException,
 334                                         "E2E serviceId " + serviceId + " is not found in DB",
 335                                         ErrorNumbers.SVC_DETAILED_SERVICE_ERROR, null);
 336                         msoLogger.error(MessageEnum.APIH_BPEL_COMMUNICATE_ERROR,
 337                                         MSO_PROP_APIHANDLER_INFRA, "", "",
 338                                         MsoLogger.ErrorCode.BusinessProcesssError,
 339                                         "Null response from RequestDB when searching by serviceId");
 340                         msoLogger.recordAuditEvent(startTime, MsoLogger.StatusCode.ERROR,
 341                                         MsoLogger.ResponseCode.DataNotFound,
 342                                         "Null response from RequestDB when searching by serviceId");
 343                         msoLogger.debug("End of the transaction, the final response is: "
 344                                         + (String) resp.getEntity());
 345                         return resp;
 346
 347                 }
 348
 349                 e2eServiceResponse.setOperationStatus(operationStatus);
 350
 351                 return Response.status(200).entity(e2eServiceResponse).build();
 352         }
 353
 354         private Response deleteE2EserviceInstances(String requestJSON,
 355                         Action action, HashMap<String, String> instanceIdMap, String version) {
 356                 // TODO should be a new one or the same service instance Id
 357                 String requestId = UUIDChecker.generateUUID(msoLogger);
 358                 long startTime = System.currentTimeMillis();
 359                 msoLogger.debug("requestId is: " + requestId);
 360                 E2EServiceInstanceDeleteRequest e2eDelReq = null;
 361
 362                 MsoRequest msoRequest = new MsoRequest(requestId);
 363
 364                 ObjectMapper mapper = new ObjectMapper();
 365                 try {
 366                         e2eDelReq = mapper.readValue(requestJSON,
 367                                         E2EServiceInstanceDeleteRequest.class);
 368
 369                 } catch (Exception e) {
 370
 371                         msoLogger.debug("Mapping of request to JSON object failed : ", e);
 372                         Response response = msoRequest.buildServiceErrorResponse(
 373                                         HttpStatus.SC_BAD_REQUEST,
 374                                         MsoException.ServiceException,
 375                                         "Mapping of request to JSON object failed.  "
 376                                                         + e.getMessage(), ErrorNumbers.SVC_BAD_PARAMETER,
 377                                         null);
 378                         msoLogger.error(MessageEnum.APIH_REQUEST_VALIDATION_ERROR,
 379                                         MSO_PROP_APIHANDLER_INFRA, "", "",
 380                                         MsoLogger.ErrorCode.SchemaError, requestJSON, e);
 381                         msoLogger.recordAuditEvent(startTime, MsoLogger.StatusCode.ERROR,
 382                                         MsoLogger.ResponseCode.SchemaError,
 383                                         "Mapping of request to JSON object failed");
 384                         msoLogger.debug("End of the transaction, the final response is: "
 385                                         + (String) response.getEntity());
 386                         return response;
 387                 }
 388
 389                 CatalogDatabase db = null;
 390                 RecipeLookupResult recipeLookupResult = null;
 391                 try {
 392                         db = CatalogDatabase.getInstance();
 393                         //TODO  Get the service template model version uuid from AAI.
 394                         recipeLookupResult = getServiceInstanceOrchestrationURI(db, null, action);
 395                 } catch (Exception e) {
 396                         msoLogger.error(MessageEnum.APIH_DB_ACCESS_EXC,
 397                                         MSO_PROP_APIHANDLER_INFRA, "", "",
 398                                         MsoLogger.ErrorCode.AvailabilityError,
 399                                         "Exception while communciate with Catalog DB", e);
 400                         msoRequest
 401                                         .setStatus(org.openecomp.mso.apihandlerinfra.vnfbeans.RequestStatusType.FAILED);
 402                         Response response = msoRequest.buildServiceErrorResponse(
 403                                         HttpStatus.SC_NOT_FOUND, MsoException.ServiceException,
 404                                         "No communication to catalog DB " + e.getMessage(),
 405                                         ErrorNumbers.SVC_NO_SERVER_RESOURCES, null);
 406                         alarmLogger.sendAlarm("MsoDatabaseAccessError",
 407                                         MsoAlarmLogger.CRITICAL, Messages.errors
 408                                                         .get(ErrorNumbers.NO_COMMUNICATION_TO_CATALOG_DB));
 409                         msoRequest.createRequestRecord(Status.FAILED, action);
 410                         msoLogger.recordAuditEvent(startTime, MsoLogger.StatusCode.ERROR,
 411                                         MsoLogger.ResponseCode.DBAccessError,
 412                                         "Exception while communciate with DB");
 413                         msoLogger.debug(END_OF_THE_TRANSACTION
 414                                         + (String) response.getEntity());
 415                         return response;
 416                 } finally {
 417                         closeCatalogDB(db);
 418                 }
 419                 if (recipeLookupResult == null) {
 420                         msoLogger.error(MessageEnum.APIH_DB_ATTRIBUTE_NOT_FOUND,
 421                                         MSO_PROP_APIHANDLER_INFRA, "", "",
 422                                         MsoLogger.ErrorCode.DataError, "No recipe found in DB");
 423                         msoRequest
 424                                         .setStatus(org.openecomp.mso.apihandlerinfra.vnfbeans.RequestStatusType.FAILED);
 425                         Response response = msoRequest.buildServiceErrorResponse(
 426                                         HttpStatus.SC_NOT_FOUND, MsoException.ServiceException,
 427                                         "Recipe does not exist in catalog DB",
 428                                         ErrorNumbers.SVC_GENERAL_SERVICE_ERROR, null);
 429                         msoRequest.createRequestRecord(Status.FAILED, action);
 430                         msoLogger.recordAuditEvent(startTime, MsoLogger.StatusCode.ERROR,
 431                                         MsoLogger.ResponseCode.DataNotFound,
 432                                         "No recipe found in DB");
 433                         msoLogger.debug(END_OF_THE_TRANSACTION
 434                                         + (String) response.getEntity());
 435                         return response;
 436                 }
 437
 438                 RequestClient requestClient = null;
 439                 HttpResponse response = null;
 440
 441                 long subStartTime = System.currentTimeMillis();
 442                 try {
 443                         requestClient = RequestClientFactory.getRequestClient(
 444                                         recipeLookupResult.getOrchestrationURI(),
 445                                         MsoPropertiesUtils.loadMsoProperties());
 446
 447                         JSONObject jjo = new JSONObject(requestJSON);
 448                         jjo.put("operationId", UUIDChecker.generateUUID(msoLogger));
 449                         // Capture audit event
 450                         msoLogger
 451                                         .debug("MSO API Handler Posting call to BPEL engine for url: "
 452                                                         + requestClient.getUrl());
 453
 454                         RequestClientParamater requestClientParamater = new RequestClientParamater.Builder().setRequestId(requestId).
 455                                         setBaseVfModule(false).setRecipeTimeout(recipeLookupResult.getRecipeTimeout()).
 456                                         setRequestAction(action.name()).setServiceType(e2eDelReq.getServiceType()).
 457                                         setRequestDetails(jjo.toString()).setRecipeParamXsd(recipeLookupResult.getRecipeParamXsd()).build();
 458                         response = requestClient.post(requestClientParamater);
 459
 460                         msoLogger.recordMetricEvent(subStartTime,
 461                                         MsoLogger.StatusCode.COMPLETE, MsoLogger.ResponseCode.Suc,
 462                                         "Successfully received response from BPMN engine", "BPMN",
 463                                         recipeLookupResult.getOrchestrationURI(), null);
 464                 } catch (Exception e) {
 465                         msoLogger.recordMetricEvent(subStartTime,
 466                                         MsoLogger.StatusCode.ERROR,
 467                                         MsoLogger.ResponseCode.CommunicationError,
 468                                         "Exception while communicate with BPMN engine", "BPMN",
 469                                         recipeLookupResult.getOrchestrationURI(), null);
 470                         Response resp = msoRequest.buildServiceErrorResponse(
 471                                         HttpStatus.SC_BAD_GATEWAY, MsoException.ServiceException,
 472                                         "Failed calling bpmn " + e.getMessage(),
 473                                         ErrorNumbers.SVC_NO_SERVER_RESOURCES, null);
 474                         alarmLogger.sendAlarm("MsoConfigurationError",
 475                                         MsoAlarmLogger.CRITICAL,
 476                                         Messages.errors.get(ErrorNumbers.NO_COMMUNICATION_TO_BPEL));
 477                         msoLogger.error(MessageEnum.APIH_BPEL_COMMUNICATE_ERROR,
 478                                         MSO_PROP_APIHANDLER_INFRA, "", "",
 479                                         MsoLogger.ErrorCode.AvailabilityError,
 480                                         "Exception while communicate with BPMN engine");
 481                         msoLogger.recordAuditEvent(startTime, MsoLogger.StatusCode.ERROR,
 482                                         MsoLogger.ResponseCode.CommunicationError,
 483                                         "Exception while communicate with BPMN engine");
 484                         msoLogger.debug("End of the transaction, the final response is: "
 485                                         + (String) resp.getEntity());
 486                         return resp;
 487                 }
 488
 489                 if (response == null) {
 490                         Response resp = msoRequest.buildServiceErrorResponse(
 491                                         HttpStatus.SC_BAD_GATEWAY, MsoException.ServiceException,
 492                                         "bpelResponse is null",
 493                                         ErrorNumbers.SVC_NO_SERVER_RESOURCES, null);
 494                         msoLogger.error(MessageEnum.APIH_BPEL_COMMUNICATE_ERROR,
 495                                         MSO_PROP_APIHANDLER_INFRA, "", "",
 496                                         MsoLogger.ErrorCode.BusinessProcesssError,
 497                                         "Null response from BPEL");
 498                         msoLogger.recordAuditEvent(startTime, MsoLogger.StatusCode.ERROR,
 499                                         MsoLogger.ResponseCode.InternalError,
 500                                         "Null response from BPMN");
 501                         msoLogger.debug(END_OF_THE_TRANSACTION + (String) resp.getEntity());
 502                         return resp;
 503                 }
 504
 505                 ResponseHandler respHandler = new ResponseHandler(response,
 506                                 requestClient.getType());
 507                 int bpelStatus = respHandler.getStatus();
 508
 509                 return beplStatusUpdate(requestId, startTime, msoRequest,
 510                                 requestClient, respHandler, bpelStatus, action, instanceIdMap);
 511         }
 512
 513         private Response updateE2EserviceInstances(String requestJSON, Action action,
 514                         HashMap<String, String> instanceIdMap, String version) {
 515
 516                 String requestId = UUIDChecker.generateUUID(msoLogger);
 517                 long startTime = System.currentTimeMillis();
 518                 msoLogger.debug("requestId is: " + requestId);
 519                 E2EServiceInstanceRequest e2eSir = null;
 520                 String serviceId = instanceIdMap.get("serviceId");
 521
 522                 MsoRequest msoRequest = new MsoRequest(requestId);
 523                 ObjectMapper mapper = new ObjectMapper();
 524                 try {
 525                         e2eSir = mapper.readValue(requestJSON, E2EServiceInstanceRequest.class);
 526
 527                 } catch (Exception e) {
 528
 529                         msoLogger.debug("Mapping of request to JSON object failed : ", e);
 530                         Response response = msoRequest.buildServiceErrorResponse(HttpStatus.SC_BAD_REQUEST,
 531                                         MsoException.ServiceException, "Mapping of request to JSON object failed.  " + e.getMessage(),
 532                                         ErrorNumbers.SVC_BAD_PARAMETER, null);
 533                         msoLogger.error(MessageEnum.APIH_REQUEST_VALIDATION_ERROR, MSO_PROP_APIHANDLER_INFRA, "", "",
 534                                         MsoLogger.ErrorCode.SchemaError, requestJSON, e);
 535                         msoLogger.recordAuditEvent(startTime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.SchemaError,
 536                                         "Mapping of request to JSON object failed");
 537                         msoLogger.debug("End of the transaction, the final response is: " + (String) response.getEntity());
 538                         return response;
 539                 }
 540
 541                 mapReqJsonToSvcInstReq(e2eSir, requestJSON);
 542                 sir.getRequestDetails().getRequestParameters().setaLaCarte(true);
 543                 try {
 544                         msoRequest.parse(sir, instanceIdMap, action, version, requestJSON);
 545                 } catch (Exception e) {
 546                         msoLogger.debug("Validation failed: ", e);
 547                         Response response = msoRequest.buildServiceErrorResponse(HttpStatus.SC_BAD_REQUEST,
 548                                         MsoException.ServiceException, "Error parsing request.  " + e.getMessage(),
 549                                         ErrorNumbers.SVC_BAD_PARAMETER, null);
 550                         if (msoRequest.getRequestId() != null) {
 551                                 msoLogger.debug("Logging failed message to the database");
 552                         }
 553                         msoLogger.error(MessageEnum.APIH_REQUEST_VALIDATION_ERROR, MSO_PROP_APIHANDLER_INFRA, "", "",
 554                                         MsoLogger.ErrorCode.SchemaError, requestJSON, e);
 555                         msoLogger.recordAuditEvent(startTime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.SchemaError,
 556                                         "Validation of the input request failed");
 557                         msoLogger.debug("End of the transaction, the final response is: " + (String) response.getEntity());
 558                         return response;
 559                 }
 560
 561                 CatalogDatabase db = null;
 562                 RecipeLookupResult recipeLookupResult = null;
 563                 try {
 564                         db = CatalogDatabase.getInstance();
 565                         recipeLookupResult = getServiceInstanceOrchestrationURI(db, e2eSir.getService().getServiceUuid(), action);
 566                 } catch (Exception e) {
 567                         msoLogger.error(MessageEnum.APIH_DB_ACCESS_EXC, MSO_PROP_APIHANDLER_INFRA, "", "",
 568                                         MsoLogger.ErrorCode.AvailabilityError, "Exception while communciate with Catalog DB", e);
 569                         msoRequest.setStatus(org.openecomp.mso.apihandlerinfra.vnfbeans.RequestStatusType.FAILED);
 570                         Response response = msoRequest.buildServiceErrorResponse(HttpStatus.SC_NOT_FOUND,
 571                                         MsoException.ServiceException, "No communication to catalog DB " + e.getMessage(),
 572                                         ErrorNumbers.SVC_NO_SERVER_RESOURCES, null);
 573                         alarmLogger.sendAlarm("MsoDatabaseAccessError", MsoAlarmLogger.CRITICAL,
 574                                         Messages.errors.get(ErrorNumbers.NO_COMMUNICATION_TO_CATALOG_DB));
 575
 576                         msoLogger.recordAuditEvent(startTime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.DBAccessError,
 577                                         "Exception while communciate with DB");
 578                         msoLogger.debug(END_OF_THE_TRANSACTION + (String) response.getEntity());
 579
 580                         return response;
 581                 } finally {
 582                         closeCatalogDB(db);
 583                 }
 584
 585                 if (recipeLookupResult == null) {
 586                         msoLogger.error(MessageEnum.APIH_DB_ATTRIBUTE_NOT_FOUND, MSO_PROP_APIHANDLER_INFRA, "", "",
 587                                         MsoLogger.ErrorCode.DataError, "No recipe found in DB");
 588                         msoRequest.setStatus(org.openecomp.mso.apihandlerinfra.vnfbeans.RequestStatusType.FAILED);
 589                         Response response = msoRequest.buildServiceErrorResponse(HttpStatus.SC_NOT_FOUND,
 590                                         MsoException.ServiceException, "Recipe does not exist in catalog DB",
 591                                         ErrorNumbers.SVC_GENERAL_SERVICE_ERROR, null);
 592
 593                         msoLogger.recordAuditEvent(startTime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.DataNotFound,
 594                                         "No recipe found in DB");
 595                         msoLogger.debug(END_OF_THE_TRANSACTION + (String) response.getEntity());
 596
 597                         return response;
 598                 }
 599
 600                 String serviceInstanceType = e2eSir.getService().getServiceType();
 601
 602                 RequestClient requestClient = null;
 603                 HttpResponse response = null;
 604
 605                 long subStartTime = System.currentTimeMillis();
 606                 try {
 607                         requestClient = RequestClientFactory.getRequestClient(recipeLookupResult.getOrchestrationURI(),
 608                                         MsoPropertiesUtils.loadMsoProperties());
 609
 610                         // Capture audit event
 611                         msoLogger.debug("MSO API Handler Posting call to BPEL engine for url: " + requestClient.getUrl());
 612                         RequestClientParamater requestClientParamater = new RequestClientParamater.Builder().setRequestId(requestId).
 613                                         setBaseVfModule(false).setRecipeTimeout(recipeLookupResult.getRecipeTimeout()).setRequestAction(action.name()).
 614                                         setServiceInstanceId(serviceId).setServiceType(serviceInstanceType).
 615                                         setRequestDetails(mapReqJsonToSvcInstReq(e2eSir, requestJSON)).
 616                                         setRecipeParamXsd(recipeLookupResult.getRecipeParamXsd()).build();
 617
 618                         response = requestClient.post(requestClientParamater);
 619
 620                         msoLogger.recordMetricEvent(subStartTime, MsoLogger.StatusCode.COMPLETE, MsoLogger.ResponseCode.Suc,
 621                                         "Successfully received response from BPMN engine", "BPMN", recipeLookupResult.getOrchestrationURI(),
 622                                         null);
 623                 } catch (Exception e) {
 624                         msoLogger.debug("Exception while communicate with BPMN engine", e);
 625                         msoLogger.recordMetricEvent(subStartTime, MsoLogger.StatusCode.ERROR,
 626                                         MsoLogger.ResponseCode.CommunicationError, "Exception while communicate with BPMN engine", "BPMN",
 627                                         recipeLookupResult.getOrchestrationURI(), null);
 628                         Response getBPMNResp = msoRequest.buildServiceErrorResponse(HttpStatus.SC_BAD_GATEWAY,
 629                                         MsoException.ServiceException, "Failed calling bpmn " + e.getMessage(),
 630                                         ErrorNumbers.SVC_NO_SERVER_RESOURCES, null);
 631                         alarmLogger.sendAlarm("MsoConfigurationError", MsoAlarmLogger.CRITICAL,
 632                                         Messages.errors.get(ErrorNumbers.NO_COMMUNICATION_TO_BPEL));
 633                         msoLogger.error(MessageEnum.APIH_BPEL_COMMUNICATE_ERROR, MSO_PROP_APIHANDLER_INFRA, "", "",
 634                                         MsoLogger.ErrorCode.AvailabilityError, "Exception while communicate with BPMN engine");
 635                         msoLogger.recordAuditEvent(startTime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.CommunicationError,
 636                                         "Exception while communicate with BPMN engine");
 637                         msoLogger.debug("End of the transaction, the final response is: " + (String) getBPMNResp.getEntity());
 638
 639                         return getBPMNResp;
 640                 }
 641
 642                 if (response == null) {
 643                         Response getBPMNResp = msoRequest.buildServiceErrorResponse(HttpStatus.SC_BAD_GATEWAY,
 644                                         MsoException.ServiceException, "bpelResponse is null", ErrorNumbers.SVC_NO_SERVER_RESOURCES, null);
 645                         msoLogger.error(MessageEnum.APIH_BPEL_COMMUNICATE_ERROR, MSO_PROP_APIHANDLER_INFRA, "", "",
 646                                         MsoLogger.ErrorCode.BusinessProcesssError, "Null response from BPEL");
 647                         msoLogger.recordAuditEvent(startTime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.InternalError,
 648                                         "Null response from BPMN");
 649                         msoLogger.debug(END_OF_THE_TRANSACTION + (String) getBPMNResp.getEntity());
 650
 651                         return getBPMNResp;
 652                 }
 653
 654                 ResponseHandler respHandler = new ResponseHandler(response, requestClient.getType());
 655                 int bpelStatus = respHandler.getStatus();
 656
 657                 return beplStatusUpdate(serviceId, startTime, msoRequest, requestClient, respHandler, bpelStatus, action, instanceIdMap);
 658         }
 659
 660         private Response processE2EserviceInstances(String requestJSON, Action action,
 661                         HashMap<String, String> instanceIdMap, String version) {
 662
 663                 String requestId = UUIDChecker.generateUUID(msoLogger);
 664                 long startTime = System.currentTimeMillis();
 665                 msoLogger.debug("requestId is: " + requestId);
 666                 E2EServiceInstanceRequest e2eSir = null;
 667
 668                 MsoRequest msoRequest = new MsoRequest(requestId);
 669                 ObjectMapper mapper = new ObjectMapper();
 670                 try {
 671                         e2eSir = mapper.readValue(requestJSON, E2EServiceInstanceRequest.class);
 672
 673                 } catch (Exception e) {
 674
 675                         msoLogger.debug("Mapping of request to JSON object failed : ", e);
 676                         Response response = msoRequest.buildServiceErrorResponse(HttpStatus.SC_BAD_REQUEST,
 677                                         MsoException.ServiceException, "Mapping of request to JSON object failed.  " + e.getMessage(),
 678                                         ErrorNumbers.SVC_BAD_PARAMETER, null);
 679                         msoLogger.error(MessageEnum.APIH_REQUEST_VALIDATION_ERROR, MSO_PROP_APIHANDLER_INFRA, "", "",
 680                                         MsoLogger.ErrorCode.SchemaError, requestJSON, e);
 681                         msoLogger.recordAuditEvent(startTime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.SchemaError,
 682                                         "Mapping of request to JSON object failed");
 683                         msoLogger.debug("End of the transaction, the final response is: " + (String) response.getEntity());
 684                         return response;
 685                 }
 686
 687                 mapReqJsonToSvcInstReq(e2eSir, requestJSON);
 688                 sir.getRequestDetails().getRequestParameters().setaLaCarte(true);
 689                 try {
 690                         msoRequest.parse(sir, instanceIdMap, action, version, requestJSON);
 691                 } catch (Exception e) {
 692                         msoLogger.debug("Validation failed: ", e);
 693                         Response response = msoRequest.buildServiceErrorResponse(HttpStatus.SC_BAD_REQUEST,
 694                                         MsoException.ServiceException, "Error parsing request.  " + e.getMessage(),
 695                                         ErrorNumbers.SVC_BAD_PARAMETER, null);
 696                         if (msoRequest.getRequestId() != null) {
 697                                 msoLogger.debug("Logging failed message to the database");
 698                         }
 699                         msoLogger.error(MessageEnum.APIH_REQUEST_VALIDATION_ERROR, MSO_PROP_APIHANDLER_INFRA, "", "",
 700                                         MsoLogger.ErrorCode.SchemaError, requestJSON, e);
 701                         msoLogger.recordAuditEvent(startTime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.SchemaError,
 702                                         "Validation of the input request failed");
 703                         msoLogger.debug("End of the transaction, the final response is: " + (String) response.getEntity());
 704                         return response;
 705                 }
 706
 707                 CatalogDatabase db = null;
 708                 RecipeLookupResult recipeLookupResult = null;
 709                 try {
 710                         db = CatalogDatabase.getInstance();
 711                         recipeLookupResult = getServiceInstanceOrchestrationURI(db, e2eSir.getService().getServiceUuid(), action);
 712                 } catch (Exception e) {
 713                         msoLogger.error(MessageEnum.APIH_DB_ACCESS_EXC, MSO_PROP_APIHANDLER_INFRA, "", "",
 714                                         MsoLogger.ErrorCode.AvailabilityError, "Exception while communciate with Catalog DB", e);
 715                         msoRequest.setStatus(org.openecomp.mso.apihandlerinfra.vnfbeans.RequestStatusType.FAILED);
 716                         Response response = msoRequest.buildServiceErrorResponse(HttpStatus.SC_NOT_FOUND,
 717                                         MsoException.ServiceException, "No communication to catalog DB " + e.getMessage(),
 718                                         ErrorNumbers.SVC_NO_SERVER_RESOURCES, null);
 719                         alarmLogger.sendAlarm("MsoDatabaseAccessError", MsoAlarmLogger.CRITICAL,
 720                                         Messages.errors.get(ErrorNumbers.NO_COMMUNICATION_TO_CATALOG_DB));
 721
 722                         msoLogger.recordAuditEvent(startTime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.DBAccessError,
 723                                         "Exception while communciate with DB");
 724                         msoLogger.debug(END_OF_THE_TRANSACTION + (String) response.getEntity());
 725                         return response;
 726                 } finally {
 727                         closeCatalogDB(db);
 728                 }
 729
 730                 if (recipeLookupResult == null) {
 731                         msoLogger.error(MessageEnum.APIH_DB_ATTRIBUTE_NOT_FOUND, MSO_PROP_APIHANDLER_INFRA, "", "",
 732                                         MsoLogger.ErrorCode.DataError, "No recipe found in DB");
 733                         msoRequest.setStatus(org.openecomp.mso.apihandlerinfra.vnfbeans.RequestStatusType.FAILED);
 734                         Response response = msoRequest.buildServiceErrorResponse(HttpStatus.SC_NOT_FOUND,
 735                                         MsoException.ServiceException, "Recipe does not exist in catalog DB",
 736                                         ErrorNumbers.SVC_GENERAL_SERVICE_ERROR, null);
 737
 738                         msoLogger.recordAuditEvent(startTime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.DataNotFound,
 739                                         "No recipe found in DB");
 740                         msoLogger.debug(END_OF_THE_TRANSACTION + (String) response.getEntity());
 741                         return response;
 742                 }
 743
 744                 RequestClient requestClient = null;
 745                 HttpResponse response = null;
 746
 747                 long subStartTime = System.currentTimeMillis();
 748                 try {
 749                         requestClient = RequestClientFactory.getRequestClient(recipeLookupResult.getOrchestrationURI(),
 750                                         MsoPropertiesUtils.loadMsoProperties());
 751
 752                         // Capture audit event
 753                         msoLogger.debug("MSO API Handler Posting call to BPEL engine for url: " + requestClient.getUrl());
 754                         RequestClientParamater requestClientParamater = new RequestClientParamater.Builder().setRequestId(requestId).
 755                                         setBaseVfModule(false).setRecipeTimeout(recipeLookupResult.getRecipeTimeout()).setRequestAction(action.name()).
 756                                         setServiceInstanceId("").setServiceType(e2eSir.getService().getServiceType()).
 757                                         setRequestDetails(mapReqJsonToSvcInstReq(e2eSir, requestJSON)).
 758                                         setRecipeParamXsd(recipeLookupResult.getRecipeParamXsd()).build();
 759
 760                         response = requestClient.post(requestClientParamater);
 761
 762                         msoLogger.recordMetricEvent(subStartTime, MsoLogger.StatusCode.COMPLETE, MsoLogger.ResponseCode.Suc,
 763                                         "Successfully received response from BPMN engine", "BPMN", recipeLookupResult.getOrchestrationURI(),
 764                                         null);
 765                 } catch (Exception e) {
 766                         msoLogger.recordMetricEvent(subStartTime, MsoLogger.StatusCode.ERROR,
 767                                         MsoLogger.ResponseCode.CommunicationError, "Exception while communicate with BPMN engine", "BPMN",
 768                                         recipeLookupResult.getOrchestrationURI(), null);
 769                         Response resp = msoRequest.buildServiceErrorResponse(HttpStatus.SC_BAD_GATEWAY,
 770                                         MsoException.ServiceException, "Failed calling bpmn " + e.getMessage(),
 771                                         ErrorNumbers.SVC_NO_SERVER_RESOURCES, null);
 772                         alarmLogger.sendAlarm("MsoConfigurationError", MsoAlarmLogger.CRITICAL,
 773                                         Messages.errors.get(ErrorNumbers.NO_COMMUNICATION_TO_BPEL));
 774                         msoLogger.error(MessageEnum.APIH_BPEL_COMMUNICATE_ERROR, MSO_PROP_APIHANDLER_INFRA, "", "",
 775                                         MsoLogger.ErrorCode.AvailabilityError, "Exception while communicate with BPMN engine");
 776                         msoLogger.recordAuditEvent(startTime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.CommunicationError,
 777                                         "Exception while communicate with BPMN engine");
 778                         msoLogger.debug("End of the transaction, the final response is: " + (String) resp.getEntity());
 779                         return resp;
 780                 }
 781
 782                 if (response == null) {
 783                         Response resp = msoRequest.buildServiceErrorResponse(HttpStatus.SC_BAD_GATEWAY,
 784                                         MsoException.ServiceException, "bpelResponse is null", ErrorNumbers.SVC_NO_SERVER_RESOURCES, null);
 785                         msoLogger.error(MessageEnum.APIH_BPEL_COMMUNICATE_ERROR, MSO_PROP_APIHANDLER_INFRA, "", "",
 786                                         MsoLogger.ErrorCode.BusinessProcesssError, "Null response from BPEL");
 787                         msoLogger.recordAuditEvent(startTime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.InternalError,
 788                                         "Null response from BPMN");
 789                         msoLogger.debug(END_OF_THE_TRANSACTION + (String) resp.getEntity());
 790                         return resp;
 791                 }
 792
 793                 ResponseHandler respHandler = new ResponseHandler(response, requestClient.getType());
 794                 int bpelStatus = respHandler.getStatus();
 795
 796                 return beplStatusUpdate(requestId, startTime, msoRequest, requestClient, respHandler, bpelStatus, action, instanceIdMap);
 797         }
 798
 799    private Response scaleE2EserviceInstances(String requestJSON,
 800                                                Action action, HashMap<String, String> instanceIdMap, String version) {
 801
 802         String requestId = UUIDChecker.generateUUID(msoLogger);
 803         long startTime = System.currentTimeMillis();
 804         msoLogger.debug("requestId is: " + requestId);
 805                 E2EServiceInstanceScaleRequest e2eScaleReq = null;
 806
 807         MsoRequest msoRequest = new MsoRequest(requestId);
 808
 809         ObjectMapper mapper = new ObjectMapper();
 810         try {
 811                 e2eScaleReq = mapper.readValue(requestJSON,
 812                                         E2EServiceInstanceScaleRequest.class);
 813
 814         } catch (Exception e) {
 815
 816             msoLogger.debug("Mapping of request to JSON object failed : ", e);
 817             Response response = msoRequest.buildServiceErrorResponse(
 818                     HttpStatus.SC_BAD_REQUEST,
 819                     MsoException.ServiceException,
 820                     "Mapping of request to JSON object failed.  "
 821                             + e.getMessage(), ErrorNumbers.SVC_BAD_PARAMETER,
 822                     null);
 823             msoLogger.error(MessageEnum.APIH_REQUEST_VALIDATION_ERROR,
 824                     MSO_PROP_APIHANDLER_INFRA, "", "",
 825                     MsoLogger.ErrorCode.SchemaError, requestJSON, e);
 826             msoLogger.recordAuditEvent(startTime, MsoLogger.StatusCode.ERROR,
 827                     MsoLogger.ResponseCode.SchemaError,
 828                     "Mapping of request to JSON object failed");
 829             msoLogger.debug("End of the transaction, the final response is: "
 830                     + (String) response.getEntity());
 831             return response;
 832         }
 833
 834         CatalogDatabase db = null;
 835         RecipeLookupResult recipeLookupResult = null;
 836         try {
 837             db = CatalogDatabase.getInstance();
 838                         //TODO  Get the service template model version uuid from AAI.
 839                         recipeLookupResult = getServiceInstanceOrchestrationURI(db, null, action);
 840         } catch (Exception e) {
 841             msoLogger.error(MessageEnum.APIH_DB_ACCESS_EXC,
 842                     MSO_PROP_APIHANDLER_INFRA, "", "",
 843                     MsoLogger.ErrorCode.AvailabilityError,
 844                     "Exception while communciate with Catalog DB", e);
 845             msoRequest
 846                     .setStatus(org.openecomp.mso.apihandlerinfra.vnfbeans.RequestStatusType.FAILED);
 847             Response response = msoRequest.buildServiceErrorResponse(
 848                     HttpStatus.SC_NOT_FOUND, MsoException.ServiceException,
 849                     "No communication to catalog DB " + e.getMessage(),
 850                     ErrorNumbers.SVC_NO_SERVER_RESOURCES, null);
 851             alarmLogger.sendAlarm("MsoDatabaseAccessError",
 852                     MsoAlarmLogger.CRITICAL, Messages.errors
 853                             .get(ErrorNumbers.NO_COMMUNICATION_TO_CATALOG_DB));
 854             msoRequest.createRequestRecord(Status.FAILED, action);
 855             msoLogger.recordAuditEvent(startTime, MsoLogger.StatusCode.ERROR,
 856                     MsoLogger.ResponseCode.DBAccessError,
 857                     "Exception while communciate with DB");
 858             msoLogger.debug(END_OF_THE_TRANSACTION
 859                     + (String) response.getEntity());
 860             return response;
 861         } finally {
 862             closeCatalogDB(db);
 863         }
 864         if (recipeLookupResult == null) {
 865             msoLogger.error(MessageEnum.APIH_DB_ATTRIBUTE_NOT_FOUND,
 866                     MSO_PROP_APIHANDLER_INFRA, "", "",
 867                     MsoLogger.ErrorCode.DataError, "No recipe found in DB");
 868             msoRequest
 869                     .setStatus(org.openecomp.mso.apihandlerinfra.vnfbeans.RequestStatusType.FAILED);
 870             Response response = msoRequest.buildServiceErrorResponse(
 871                     HttpStatus.SC_NOT_FOUND, MsoException.ServiceException,
 872                     "Recipe does not exist in catalog DB",
 873                     ErrorNumbers.SVC_GENERAL_SERVICE_ERROR, null);
 874             msoRequest.createRequestRecord(Status.FAILED, action);
 875             msoLogger.recordAuditEvent(startTime, MsoLogger.StatusCode.ERROR,
 876                     MsoLogger.ResponseCode.DataNotFound,
 877                     "No recipe found in DB");
 878             msoLogger.debug(END_OF_THE_TRANSACTION
 879                     + (String) response.getEntity());
 880             return response;
 881         }
 882
 883         RequestClient requestClient = null;
 884         HttpResponse response = null;
 885
 886         long subStartTime = System.currentTimeMillis();
 887         try {
 888             requestClient = RequestClientFactory.getRequestClient(
 889                     recipeLookupResult.getOrchestrationURI(),
 890                     MsoPropertiesUtils.loadMsoProperties());
 891
 892             JSONObject jjo = new JSONObject(requestJSON);
 893             jjo.put("operationId", UUIDChecker.generateUUID(msoLogger));
 894
 895             // Capture audit event
 896             msoLogger
 897                     .debug("MSO API Handler Posting call to BPEL engine for url: "
 898                             + requestClient.getUrl());
 899                         RequestClientParamater requestClientParamater = new RequestClientParamater.Builder().setRequestId(requestId).
 900                                         setBaseVfModule(false).setRecipeTimeout(recipeLookupResult.getRecipeTimeout()).setRequestAction(action.name()).
 901                                         setServiceInstanceId(instanceIdMap.get("serviceId")).
 902                                         setServiceType(e2eScaleReq.getService().getServiceType()).
 903                                         setRequestDetails(jjo.toString()).
 904                                         setRecipeParamXsd(recipeLookupResult.getRecipeParamXsd()).build();
 905
 906             response = requestClient.post(requestClientParamater);
 907
 908             msoLogger.recordMetricEvent(subStartTime,
 909                     MsoLogger.StatusCode.COMPLETE, MsoLogger.ResponseCode.Suc,
 910                     "Successfully received response from BPMN engine", "BPMN",
 911                     recipeLookupResult.getOrchestrationURI(), null);
 912         } catch (Exception e) {
 913             msoLogger.recordMetricEvent(subStartTime,
 914                     MsoLogger.StatusCode.ERROR,
 915                     MsoLogger.ResponseCode.CommunicationError,
 916                     "Exception while communicate with BPMN engine", "BPMN",
 917                     recipeLookupResult.getOrchestrationURI(), null);
 918             Response resp = msoRequest.buildServiceErrorResponse(
 919                     HttpStatus.SC_BAD_GATEWAY, MsoException.ServiceException,
 920                     "Failed calling bpmn " + e.getMessage(),
 921                     ErrorNumbers.SVC_NO_SERVER_RESOURCES, null);
 922             alarmLogger.sendAlarm("MsoConfigurationError",
 923                     MsoAlarmLogger.CRITICAL,
 924                     Messages.errors.get(ErrorNumbers.NO_COMMUNICATION_TO_BPEL));
 925             msoLogger.error(MessageEnum.APIH_BPEL_COMMUNICATE_ERROR,
 926                     MSO_PROP_APIHANDLER_INFRA, "", "",
 927                     MsoLogger.ErrorCode.AvailabilityError,
 928                     "Exception while communicate with BPMN engine",e);
 929             msoLogger.recordAuditEvent(startTime, MsoLogger.StatusCode.ERROR,
 930                     MsoLogger.ResponseCode.CommunicationError,
 931                     "Exception while communicate with BPMN engine");
 932             msoLogger.debug("End of the transaction, the final response is: "
 933                     + (String) resp.getEntity());
 934             return resp;
 935         }
 936
 937         if (response == null) {
 938             Response resp = msoRequest.buildServiceErrorResponse(
 939                     HttpStatus.SC_BAD_GATEWAY, MsoException.ServiceException,
 940                     "bpelResponse is null",
 941                     ErrorNumbers.SVC_NO_SERVER_RESOURCES, null);
 942             msoLogger.error(MessageEnum.APIH_BPEL_COMMUNICATE_ERROR,
 943                     MSO_PROP_APIHANDLER_INFRA, "", "",
 944                     MsoLogger.ErrorCode.BusinessProcesssError,
 945                     "Null response from BPEL");
 946             msoLogger.recordAuditEvent(startTime, MsoLogger.StatusCode.ERROR,
 947                     MsoLogger.ResponseCode.InternalError,
 948                     "Null response from BPMN");
 949             msoLogger.debug(END_OF_THE_TRANSACTION + (String) resp.getEntity());
 950             return resp;
 951         }
 952
 953         ResponseHandler respHandler = new ResponseHandler(response,
 954                 requestClient.getType());
 955         int bpelStatus = respHandler.getStatus();
 956
 957         return beplStatusUpdate(requestId, startTime, msoRequest,
 958                 requestClient, respHandler, bpelStatus, action, instanceIdMap);
 959     }
 960
 961         private void closeCatalogDB(CatalogDatabase db) {
 962                 if (db != null) {
 963                         db.close();
 964                 }
 965         }
 966
 967         private Response beplStatusUpdate(String serviceId, long startTime,
 968                         MsoRequest msoRequest, RequestClient requestClient,
 969                         ResponseHandler respHandler, int bpelStatus, Action action,
 970                         HashMap<String, String> instanceIdMap) {
 971                 // BPMN accepted the request, the request is in progress
 972                 if (bpelStatus == HttpStatus.SC_ACCEPTED) {
 973                         String camundaJSONResponseBody = respHandler.getContent();
 974                         msoLogger.debug("Received from Camunda: " + camundaJSONResponseBody);
 975                         msoLogger.recordAuditEvent(startTime,
 976                                         MsoLogger.StatusCode.COMPLETE, MsoLogger.ResponseCode.Suc,
 977                                         "BPMN accepted the request, the request is in progress");
 978                         msoLogger.debug(END_OF_THE_TRANSACTION + camundaJSONResponseBody);
 979                         return Response.status(HttpStatus.SC_ACCEPTED)
 980                                         .entity(camundaJSONResponseBody).build();
 981                 } else {
 982                         List<String> variables = new ArrayList<>();
 983                         variables.add(bpelStatus + "");
 984                         String camundaJSONResponseBody = respHandler.getContent();
 985                         if (camundaJSONResponseBody != null
 986                                         && !camundaJSONResponseBody.isEmpty()) {
 987                                 Response resp = msoRequest.buildServiceErrorResponse(
 988                                                 bpelStatus, MsoException.ServiceException,
 989                                                 "Request Failed due to BPEL error with HTTP Status= %1 "
 990                                                                 + '\n' + camundaJSONResponseBody,
 991                                                 ErrorNumbers.SVC_DETAILED_SERVICE_ERROR, variables);
 992                                 msoLogger.error(MessageEnum.APIH_BPEL_RESPONSE_ERROR,
 993                                                 requestClient.getUrl(), "", "",
 994                                                 MsoLogger.ErrorCode.BusinessProcesssError,
 995                                                 "Response from BPEL engine is failed with HTTP Status="
 996                                                                 + bpelStatus);
 997                                 msoLogger.recordAuditEvent(startTime,
 998                                                 MsoLogger.StatusCode.ERROR,
 999                                                 MsoLogger.ResponseCode.InternalError,
1000                                                 "Response from BPMN engine is failed");
1001                                 msoLogger.debug(END_OF_THE_TRANSACTION
1002                                                 + (String) resp.getEntity());
1003                                 return resp;
1004                         } else {
1005                                 Response resp = msoRequest
1006                                                 .buildServiceErrorResponse(
1007                                                                 bpelStatus,
1008                                                                 MsoException.ServiceException,
1009                                                                 "Request Failed due to BPEL error with HTTP Status= %1",
1010                                                                 ErrorNumbers.SVC_DETAILED_SERVICE_ERROR,
1011                                                                 variables);
1012                                 msoLogger.error(MessageEnum.APIH_BPEL_RESPONSE_ERROR,
1013                                                 requestClient.getUrl(), "", "",
1014                                                 MsoLogger.ErrorCode.BusinessProcesssError,
1015                                                 "Response from BPEL engine is empty");
1016                                 msoLogger.recordAuditEvent(startTime,
1017                                                 MsoLogger.StatusCode.ERROR,
1018                                                 MsoLogger.ResponseCode.InternalError,
1019                                                 "Response from BPEL engine is empty");
1020                                 msoLogger.debug(END_OF_THE_TRANSACTION
1021                                                 + (String) resp.getEntity());
1022                                 return resp;
1023                         }
1024                 }
1025         }
1026
1027         /**
1028          * Getting recipes from catalogDb
1029          *
1030          * @param db the catalog db
1031          * @param serviceModelUUID the service model version uuid
1032          * @param action the action for the service
1033          * @return the service recipe result
1034          */
1035         private RecipeLookupResult getServiceInstanceOrchestrationURI(
1036                         CatalogDatabase db, String serviceModelUUID, Action action) {
1037
1038                 RecipeLookupResult recipeLookupResult = getServiceURI(db, serviceModelUUID, action);
1039
1040                 if (recipeLookupResult != null) {
1041                         msoLogger.debug("Orchestration URI is: "
1042                                         + recipeLookupResult.getOrchestrationURI()
1043                                         + ", recipe Timeout is: "
1044                                         + Integer.toString(recipeLookupResult.getRecipeTimeout()));
1045                 } else {
1046                         msoLogger.debug("No matching recipe record found");
1047                 }
1048                 return recipeLookupResult;
1049         }
1050
1051         /**
1052          * Getting recipes from catalogDb
1053          * If Service recipe is not set, use default recipe, if set , use special recipe.
1054          * @param db the catalog db
1055          * @param serviceModelUUID the service version uuid
1056          * @param action the action of the service.
1057          * @return the service recipe result.
1058          */
1059         private RecipeLookupResult getServiceURI(CatalogDatabase db, String serviceModelUUID, Action action) {
1060
1061                 String defaultServiceModelName = "UUI_DEFAULT";
1062
1063                 Service defaultServiceRecord = db
1064                                 .getServiceByModelName(defaultServiceModelName);
1065                 ServiceRecipe defaultRecipe = db.getServiceRecipeByModelUUID(
1066                         defaultServiceRecord.getModelUUID(), action.name());
1067                 //set recipe as default generic recipe
1068                 ServiceRecipe recipe = defaultRecipe;
1069                 //check the service special recipe
1070                 if(null != serviceModelUUID && ! serviceModelUUID.isEmpty()){
1071                       ServiceRecipe serviceSpecialRecipe = db.getServiceRecipeByModelUUID(
1072                               serviceModelUUID, action.name());
1073                       if(null != serviceSpecialRecipe){
1074                           //set service special recipe.
1075                           recipe = serviceSpecialRecipe;
1076                       }
1077                 }
1078
1079                 if (recipe == null) {
1080                         return null;
1081                 }
1082                 return new RecipeLookupResult(recipe.getOrchestrationUri(),
1083                                 recipe.getRecipeTimeout(), recipe.getServiceParamXSD());
1084
1085         }
1086
1087         /**
1088          * Converting E2EServiceInstanceRequest to ServiceInstanceRequest and
1089          * passing it to camunda engine.
1090          *
1091          * @param e2eSir
1092          * @return
1093          */
1094         private String mapReqJsonToSvcInstReq(E2EServiceInstanceRequest e2eSir,
1095                         String requestJSON) {
1096
1097                 sir = new ServiceInstancesRequest();
1098
1099                 String returnString = null;
1100                 RequestDetails requestDetails = new RequestDetails();
1101                 ModelInfo modelInfo = new ModelInfo();
1102
1103                 // ModelInvariantId
1104                 modelInfo.setModelInvariantId(e2eSir.getService().getServiceInvariantUuid());
1105
1106                 // modelNameVersionId
1107                 modelInfo.setModelNameVersionId(e2eSir.getService().getServiceUuid());
1108
1109                 // String modelInfoValue =
1110                 // e2eSir.getService().getParameters().getNodeTemplateName();
1111                 // String[] arrayOfInfo = modelInfoValue.split(":");
1112                 // String modelName = arrayOfInfo[0];
1113                 // String modelVersion = arrayOfInfo[1];
1114
1115                 // TODO: To ensure, if we dont get the values from the UUI
1116                 String modelName = "voLTE";
1117                 String modelVersion = "1.0";
1118                 // modelName
1119                 modelInfo.setModelName(modelName);
1120
1121                 // modelVersion
1122                 modelInfo.setModelVersion(modelVersion);
1123
1124                 // modelType
1125                 modelInfo.setModelType(ModelType.service);
1126
1127                 // setting modelInfo to requestDetails
1128                 requestDetails.setModelInfo(modelInfo);
1129
1130                 SubscriberInfo subscriberInfo = new SubscriberInfo();
1131
1132                 // globalsubscriberId
1133                 subscriberInfo.setGlobalSubscriberId(e2eSir.getService().getGlobalSubscriberId());
1134
1135                 // setting subscriberInfo to requestDetails
1136                 requestDetails.setSubscriberInfo(subscriberInfo);
1137
1138                 RequestInfo requestInfo = new RequestInfo();
1139
1140                 // instanceName
1141                 requestInfo.setInstanceName(e2eSir.getService().getName());
1142
1143                 // source
1144                 requestInfo.setSource("UUI");
1145
1146                 // suppressRollback
1147                 requestInfo.setSuppressRollback(true);
1148
1149                 // setting requestInfo to requestDetails
1150                 requestDetails.setRequestInfo(requestInfo);
1151
1152                 RequestParameters requestParameters = new RequestParameters();
1153
1154                 // subscriptionServiceType
1155                 requestParameters.setSubscriptionServiceType("MOG");
1156
1157                 // Userparams
1158                 //List<E2EUserParam> userParams;
1159                 // userParams =
1160                 // e2eSir.getService().getParameters().getRequestParameters().getUserParams();
1161                 List<Map<String, Object>> userParamList = new ArrayList<>();
1162                 Map<String, Object> userParamMap = new HashMap<>();
1163                 // complete json request updated in the camunda
1164                 userParamMap.put("UUIRequest", requestJSON);
1165                 userParamMap.put("ServiceInstanceName", e2eSir.getService().getName());
1166
1167                 // Map<String, String> userParamMap3 = null;
1168                 // for (E2EUserParam userp : userParams) {
1169                 // userParamMap.put(userp.getName(), userp.getValue());
1170                 //
1171                 // }
1172                 userParamList.add(userParamMap);
1173                 requestParameters.setUserParams(userParamList);
1174
1175                 // setting requestParameters to requestDetails
1176                 requestDetails.setRequestParameters(requestParameters);
1177
1178                 sir.setRequestDetails(requestDetails);
1179
1180                 // converting to string
1181                 ObjectMapper mapper = new ObjectMapper();
1182                 try {
1183                         returnString = mapper.writeValueAsString(sir);
1184                 } catch (IOException e) {
1185                         msoLogger
1186                                         .debug("Exception while converting ServiceInstancesRequest object to string",
1187                                                         e);
1188                 }
1189
1190                 return returnString;
1191         }
1192
1193 }