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