gerrit.onap Code Review - so.git/blob

   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()).setServiceInstanceId(instanceIdMap.get("serviceId")).
 457                                         setServiceType(e2eDelReq.getServiceType()).setRequestDetails(jjo.toString()).
 458                                         setRecipeParamXsd(recipeLookupResult.getRecipeParamXsd()).build();
 459                         response = requestClient.post(requestClientParamater);
 460
 461                         msoLogger.recordMetricEvent(subStartTime,
 462                                         MsoLogger.StatusCode.COMPLETE, MsoLogger.ResponseCode.Suc,
 463                                         "Successfully received response from BPMN engine", "BPMN",
 464                                         recipeLookupResult.getOrchestrationURI(), null);
 465                 } catch (Exception e) {
 466                         msoLogger.recordMetricEvent(subStartTime,
 467                                         MsoLogger.StatusCode.ERROR,
 468                                         MsoLogger.ResponseCode.CommunicationError,
 469                                         "Exception while communicate with BPMN engine", "BPMN",
 470                                         recipeLookupResult.getOrchestrationURI(), null);
 471                         Response resp = msoRequest.buildServiceErrorResponse(
 472                                         HttpStatus.SC_BAD_GATEWAY, MsoException.ServiceException,
 473                                         "Failed calling bpmn " + e.getMessage(),
 474                                         ErrorNumbers.SVC_NO_SERVER_RESOURCES, null);
 475                         alarmLogger.sendAlarm("MsoConfigurationError",
 476                                         MsoAlarmLogger.CRITICAL,
 477                                         Messages.errors.get(ErrorNumbers.NO_COMMUNICATION_TO_BPEL));
 478                         msoLogger.error(MessageEnum.APIH_BPEL_COMMUNICATE_ERROR,
 479                                         MSO_PROP_APIHANDLER_INFRA, "", "",
 480                                         MsoLogger.ErrorCode.AvailabilityError,
 481                                         "Exception while communicate with BPMN engine");
 482                         msoLogger.recordAuditEvent(startTime, MsoLogger.StatusCode.ERROR,
 483                                         MsoLogger.ResponseCode.CommunicationError,
 484                                         "Exception while communicate with BPMN engine");
 485                         msoLogger.debug("End of the transaction, the final response is: "
 486                                         + (String) resp.getEntity());
 487                         return resp;
 488                 }
 489
 490                 if (response == null) {
 491                         Response resp = msoRequest.buildServiceErrorResponse(
 492                                         HttpStatus.SC_BAD_GATEWAY, MsoException.ServiceException,
 493                                         "bpelResponse is null",
 494                                         ErrorNumbers.SVC_NO_SERVER_RESOURCES, null);
 495                         msoLogger.error(MessageEnum.APIH_BPEL_COMMUNICATE_ERROR,
 496                                         MSO_PROP_APIHANDLER_INFRA, "", "",
 497                                         MsoLogger.ErrorCode.BusinessProcesssError,
 498                                         "Null response from BPEL");
 499                         msoLogger.recordAuditEvent(startTime, MsoLogger.StatusCode.ERROR,
 500                                         MsoLogger.ResponseCode.InternalError,
 501                                         "Null response from BPMN");
 502                         msoLogger.debug(END_OF_THE_TRANSACTION + (String) resp.getEntity());
 503                         return resp;
 504                 }
 505
 506                 ResponseHandler respHandler = new ResponseHandler(response,
 507                                 requestClient.getType());
 508                 int bpelStatus = respHandler.getStatus();
 509
 510                 return beplStatusUpdate(requestId, startTime, msoRequest,
 511                                 requestClient, respHandler, bpelStatus, action, instanceIdMap);
 512         }
 513
 514         private Response updateE2EserviceInstances(String requestJSON, Action action,
 515                         HashMap<String, String> instanceIdMap, String version) {
 516
 517                 String requestId = UUIDChecker.generateUUID(msoLogger);
 518                 long startTime = System.currentTimeMillis();
 519                 msoLogger.debug("requestId is: " + requestId);
 520                 E2EServiceInstanceRequest e2eSir = null;
 521                 String serviceId = instanceIdMap.get("serviceId");
 522
 523                 MsoRequest msoRequest = new MsoRequest(requestId);
 524                 ObjectMapper mapper = new ObjectMapper();
 525                 try {
 526                         e2eSir = mapper.readValue(requestJSON, E2EServiceInstanceRequest.class);
 527
 528                 } catch (Exception e) {
 529
 530                         msoLogger.debug("Mapping of request to JSON object failed : ", e);
 531                         Response response = msoRequest.buildServiceErrorResponse(HttpStatus.SC_BAD_REQUEST,
 532                                         MsoException.ServiceException, "Mapping of request to JSON object failed.  " + e.getMessage(),
 533                                         ErrorNumbers.SVC_BAD_PARAMETER, null);
 534                         msoLogger.error(MessageEnum.APIH_REQUEST_VALIDATION_ERROR, MSO_PROP_APIHANDLER_INFRA, "", "",
 535                                         MsoLogger.ErrorCode.SchemaError, requestJSON, e);
 536                         msoLogger.recordAuditEvent(startTime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.SchemaError,
 537                                         "Mapping of request to JSON object failed");
 538                         msoLogger.debug("End of the transaction, the final response is: " + (String) response.getEntity());
 539                         return response;
 540                 }
 541
 542                 mapReqJsonToSvcInstReq(e2eSir, requestJSON);
 543                 sir.getRequestDetails().getRequestParameters().setaLaCarte(true);
 544                 try {
 545                         msoRequest.parse(sir, instanceIdMap, action, version, requestJSON);
 546                 } catch (Exception e) {
 547                         msoLogger.debug("Validation failed: ", e);
 548                         Response response = msoRequest.buildServiceErrorResponse(HttpStatus.SC_BAD_REQUEST,
 549                                         MsoException.ServiceException, "Error parsing request.  " + e.getMessage(),
 550                                         ErrorNumbers.SVC_BAD_PARAMETER, null);
 551                         if (msoRequest.getRequestId() != null) {
 552                                 msoLogger.debug("Logging failed message to the database");
 553                         }
 554                         msoLogger.error(MessageEnum.APIH_REQUEST_VALIDATION_ERROR, MSO_PROP_APIHANDLER_INFRA, "", "",
 555                                         MsoLogger.ErrorCode.SchemaError, requestJSON, e);
 556                         msoLogger.recordAuditEvent(startTime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.SchemaError,
 557                                         "Validation of the input request failed");
 558                         msoLogger.debug("End of the transaction, the final response is: " + (String) response.getEntity());
 559                         return response;
 560                 }
 561
 562                 CatalogDatabase db = null;
 563                 RecipeLookupResult recipeLookupResult = null;
 564                 try {
 565                         db = CatalogDatabase.getInstance();
 566                         recipeLookupResult = getServiceInstanceOrchestrationURI(db, e2eSir.getService().getServiceUuid(), action);
 567                 } catch (Exception e) {
 568                         msoLogger.error(MessageEnum.APIH_DB_ACCESS_EXC, MSO_PROP_APIHANDLER_INFRA, "", "",
 569                                         MsoLogger.ErrorCode.AvailabilityError, "Exception while communciate with Catalog DB", e);
 570                         msoRequest.setStatus(org.openecomp.mso.apihandlerinfra.vnfbeans.RequestStatusType.FAILED);
 571                         Response response = msoRequest.buildServiceErrorResponse(HttpStatus.SC_NOT_FOUND,
 572                                         MsoException.ServiceException, "No communication to catalog DB " + e.getMessage(),
 573                                         ErrorNumbers.SVC_NO_SERVER_RESOURCES, null);
 574                         alarmLogger.sendAlarm("MsoDatabaseAccessError", MsoAlarmLogger.CRITICAL,
 575                                         Messages.errors.get(ErrorNumbers.NO_COMMUNICATION_TO_CATALOG_DB));
 576
 577                         msoLogger.recordAuditEvent(startTime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.DBAccessError,
 578                                         "Exception while communciate with DB");
 579                         msoLogger.debug(END_OF_THE_TRANSACTION + (String) response.getEntity());
 580
 581                         return response;
 582                 } finally {
 583                         closeCatalogDB(db);
 584                 }
 585
 586                 if (recipeLookupResult == null) {
 587                         msoLogger.error(MessageEnum.APIH_DB_ATTRIBUTE_NOT_FOUND, MSO_PROP_APIHANDLER_INFRA, "", "",
 588                                         MsoLogger.ErrorCode.DataError, "No recipe found in DB");
 589                         msoRequest.setStatus(org.openecomp.mso.apihandlerinfra.vnfbeans.RequestStatusType.FAILED);
 590                         Response response = msoRequest.buildServiceErrorResponse(HttpStatus.SC_NOT_FOUND,
 591                                         MsoException.ServiceException, "Recipe does not exist in catalog DB",
 592                                         ErrorNumbers.SVC_GENERAL_SERVICE_ERROR, null);
 593
 594                         msoLogger.recordAuditEvent(startTime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.DataNotFound,
 595                                         "No recipe found in DB");
 596                         msoLogger.debug(END_OF_THE_TRANSACTION + (String) response.getEntity());
 597
 598                         return response;
 599                 }
 600
 601                 String serviceInstanceType = e2eSir.getService().getServiceType();
 602
 603                 RequestClient requestClient = null;
 604                 HttpResponse response = null;
 605
 606                 long subStartTime = System.currentTimeMillis();
 607                 try {
 608                         requestClient = RequestClientFactory.getRequestClient(recipeLookupResult.getOrchestrationURI(),
 609                                         MsoPropertiesUtils.loadMsoProperties());
 610
 611                         // Capture audit event
 612                         msoLogger.debug("MSO API Handler Posting call to BPEL engine for url: " + requestClient.getUrl());
 613                         RequestClientParamater requestClientParamater = new RequestClientParamater.Builder().setRequestId(requestId).
 614                                         setBaseVfModule(false).setRecipeTimeout(recipeLookupResult.getRecipeTimeout()).setRequestAction(action.name()).
 615                                         setServiceInstanceId(serviceId).setServiceType(serviceInstanceType).
 616                                         setRequestDetails(mapReqJsonToSvcInstReq(e2eSir, requestJSON)).
 617                                         setRecipeParamXsd(recipeLookupResult.getRecipeParamXsd()).build();
 618
 619                         response = requestClient.post(requestClientParamater);
 620
 621                         msoLogger.recordMetricEvent(subStartTime, MsoLogger.StatusCode.COMPLETE, MsoLogger.ResponseCode.Suc,
 622                                         "Successfully received response from BPMN engine", "BPMN", recipeLookupResult.getOrchestrationURI(),
 623                                         null);
 624                 } catch (Exception e) {
 625                         msoLogger.debug("Exception while communicate with BPMN engine", e);
 626                         msoLogger.recordMetricEvent(subStartTime, MsoLogger.StatusCode.ERROR,
 627                                         MsoLogger.ResponseCode.CommunicationError, "Exception while communicate with BPMN engine", "BPMN",
 628                                         recipeLookupResult.getOrchestrationURI(), null);
 629                         Response getBPMNResp = msoRequest.buildServiceErrorResponse(HttpStatus.SC_BAD_GATEWAY,
 630                                         MsoException.ServiceException, "Failed calling bpmn " + e.getMessage(),
 631                                         ErrorNumbers.SVC_NO_SERVER_RESOURCES, null);
 632                         alarmLogger.sendAlarm("MsoConfigurationError", MsoAlarmLogger.CRITICAL,
 633                                         Messages.errors.get(ErrorNumbers.NO_COMMUNICATION_TO_BPEL));
 634                         msoLogger.error(MessageEnum.APIH_BPEL_COMMUNICATE_ERROR, MSO_PROP_APIHANDLER_INFRA, "", "",
 635                                         MsoLogger.ErrorCode.AvailabilityError, "Exception while communicate with BPMN engine");
 636                         msoLogger.recordAuditEvent(startTime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.CommunicationError,
 637                                         "Exception while communicate with BPMN engine");
 638                         msoLogger.debug("End of the transaction, the final response is: " + (String) getBPMNResp.getEntity());
 639
 640                         return getBPMNResp;
 641                 }
 642
 643                 if (response == null) {
 644                         Response getBPMNResp = msoRequest.buildServiceErrorResponse(HttpStatus.SC_BAD_GATEWAY,
 645                                         MsoException.ServiceException, "bpelResponse is null", ErrorNumbers.SVC_NO_SERVER_RESOURCES, null);
 646                         msoLogger.error(MessageEnum.APIH_BPEL_COMMUNICATE_ERROR, MSO_PROP_APIHANDLER_INFRA, "", "",
 647                                         MsoLogger.ErrorCode.BusinessProcesssError, "Null response from BPEL");
 648                         msoLogger.recordAuditEvent(startTime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.InternalError,
 649                                         "Null response from BPMN");
 650                         msoLogger.debug(END_OF_THE_TRANSACTION + (String) getBPMNResp.getEntity());
 651
 652                         return getBPMNResp;
 653                 }
 654
 655                 ResponseHandler respHandler = new ResponseHandler(response, requestClient.getType());
 656                 int bpelStatus = respHandler.getStatus();
 657
 658                 return beplStatusUpdate(serviceId, startTime, msoRequest, requestClient, respHandler, bpelStatus, action, instanceIdMap);
 659         }
 660
 661         private Response processE2EserviceInstances(String requestJSON, Action action,
 662                         HashMap<String, String> instanceIdMap, String version) {
 663
 664                 String requestId = UUIDChecker.generateUUID(msoLogger);
 665                 long startTime = System.currentTimeMillis();
 666                 msoLogger.debug("requestId is: " + requestId);
 667                 E2EServiceInstanceRequest e2eSir = null;
 668
 669                 MsoRequest msoRequest = new MsoRequest(requestId);
 670                 ObjectMapper mapper = new ObjectMapper();
 671                 try {
 672                         e2eSir = mapper.readValue(requestJSON, E2EServiceInstanceRequest.class);
 673
 674                 } catch (Exception e) {
 675
 676                         msoLogger.debug("Mapping of request to JSON object failed : ", e);
 677                         Response response = msoRequest.buildServiceErrorResponse(HttpStatus.SC_BAD_REQUEST,
 678                                         MsoException.ServiceException, "Mapping of request to JSON object failed.  " + e.getMessage(),
 679                                         ErrorNumbers.SVC_BAD_PARAMETER, null);
 680                         msoLogger.error(MessageEnum.APIH_REQUEST_VALIDATION_ERROR, MSO_PROP_APIHANDLER_INFRA, "", "",
 681                                         MsoLogger.ErrorCode.SchemaError, requestJSON, e);
 682                         msoLogger.recordAuditEvent(startTime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.SchemaError,
 683                                         "Mapping of request to JSON object failed");
 684                         msoLogger.debug("End of the transaction, the final response is: " + (String) response.getEntity());
 685                         return response;
 686                 }
 687
 688                 mapReqJsonToSvcInstReq(e2eSir, requestJSON);
 689                 sir.getRequestDetails().getRequestParameters().setaLaCarte(true);
 690                 try {
 691                         msoRequest.parse(sir, instanceIdMap, action, version, requestJSON);
 692                 } catch (Exception e) {
 693                         msoLogger.debug("Validation failed: ", e);
 694                         Response response = msoRequest.buildServiceErrorResponse(HttpStatus.SC_BAD_REQUEST,
 695                                         MsoException.ServiceException, "Error parsing request.  " + e.getMessage(),
 696                                         ErrorNumbers.SVC_BAD_PARAMETER, null);
 697                         if (msoRequest.getRequestId() != null) {
 698                                 msoLogger.debug("Logging failed message to the database");
 699                         }
 700                         msoLogger.error(MessageEnum.APIH_REQUEST_VALIDATION_ERROR, MSO_PROP_APIHANDLER_INFRA, "", "",
 701                                         MsoLogger.ErrorCode.SchemaError, requestJSON, e);
 702                         msoLogger.recordAuditEvent(startTime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.SchemaError,
 703                                         "Validation of the input request failed");
 704                         msoLogger.debug("End of the transaction, the final response is: " + (String) response.getEntity());
 705                         return response;
 706                 }
 707
 708                 CatalogDatabase db = null;
 709                 RecipeLookupResult recipeLookupResult = null;
 710                 try {
 711                         db = CatalogDatabase.getInstance();
 712                         recipeLookupResult = getServiceInstanceOrchestrationURI(db, e2eSir.getService().getServiceUuid(), action);
 713                 } catch (Exception e) {
 714                         msoLogger.error(MessageEnum.APIH_DB_ACCESS_EXC, MSO_PROP_APIHANDLER_INFRA, "", "",
 715                                         MsoLogger.ErrorCode.AvailabilityError, "Exception while communciate with Catalog DB", e);
 716                         msoRequest.setStatus(org.openecomp.mso.apihandlerinfra.vnfbeans.RequestStatusType.FAILED);
 717                         Response response = msoRequest.buildServiceErrorResponse(HttpStatus.SC_NOT_FOUND,
 718                                         MsoException.ServiceException, "No communication to catalog DB " + e.getMessage(),
 719                                         ErrorNumbers.SVC_NO_SERVER_RESOURCES, null);
 720                         alarmLogger.sendAlarm("MsoDatabaseAccessError", MsoAlarmLogger.CRITICAL,
 721                                         Messages.errors.get(ErrorNumbers.NO_COMMUNICATION_TO_CATALOG_DB));
 722
 723                         msoLogger.recordAuditEvent(startTime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.DBAccessError,
 724                                         "Exception while communciate with DB");
 725                         msoLogger.debug(END_OF_THE_TRANSACTION + (String) response.getEntity());
 726                         return response;
 727                 } finally {
 728                         closeCatalogDB(db);
 729                 }
 730
 731                 if (recipeLookupResult == null) {
 732                         msoLogger.error(MessageEnum.APIH_DB_ATTRIBUTE_NOT_FOUND, MSO_PROP_APIHANDLER_INFRA, "", "",
 733                                         MsoLogger.ErrorCode.DataError, "No recipe found in DB");
 734                         msoRequest.setStatus(org.openecomp.mso.apihandlerinfra.vnfbeans.RequestStatusType.FAILED);
 735                         Response response = msoRequest.buildServiceErrorResponse(HttpStatus.SC_NOT_FOUND,
 736                                         MsoException.ServiceException, "Recipe does not exist in catalog DB",
 737                                         ErrorNumbers.SVC_GENERAL_SERVICE_ERROR, null);
 738
 739                         msoLogger.recordAuditEvent(startTime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.DataNotFound,
 740                                         "No recipe found in DB");
 741                         msoLogger.debug(END_OF_THE_TRANSACTION + (String) response.getEntity());
 742                         return response;
 743                 }
 744
 745                 RequestClient requestClient = null;
 746                 HttpResponse response = null;
 747
 748                 long subStartTime = System.currentTimeMillis();
 749                 try {
 750                         requestClient = RequestClientFactory.getRequestClient(recipeLookupResult.getOrchestrationURI(),
 751                                         MsoPropertiesUtils.loadMsoProperties());
 752
 753                         // Capture audit event
 754                         msoLogger.debug("MSO API Handler Posting call to BPEL engine for url: " + requestClient.getUrl());
 755                         RequestClientParamater requestClientParamater = new RequestClientParamater.Builder().setRequestId(requestId).
 756                                         setBaseVfModule(false).setRecipeTimeout(recipeLookupResult.getRecipeTimeout()).setRequestAction(action.name()).
 757                                         setServiceInstanceId("").setServiceType(e2eSir.getService().getServiceType()).
 758                                         setRequestDetails(mapReqJsonToSvcInstReq(e2eSir, requestJSON)).
 759                                         setRecipeParamXsd(recipeLookupResult.getRecipeParamXsd()).build();
 760
 761                         response = requestClient.post(requestClientParamater);
 762
 763                         msoLogger.recordMetricEvent(subStartTime, MsoLogger.StatusCode.COMPLETE, MsoLogger.ResponseCode.Suc,
 764                                         "Successfully received response from BPMN engine", "BPMN", recipeLookupResult.getOrchestrationURI(),
 765                                         null);
 766                 } catch (Exception e) {
 767                         msoLogger.recordMetricEvent(subStartTime, MsoLogger.StatusCode.ERROR,
 768                                         MsoLogger.ResponseCode.CommunicationError, "Exception while communicate with BPMN engine", "BPMN",
 769                                         recipeLookupResult.getOrchestrationURI(), null);
 770                         Response resp = msoRequest.buildServiceErrorResponse(HttpStatus.SC_BAD_GATEWAY,
 771                                         MsoException.ServiceException, "Failed calling bpmn " + e.getMessage(),
 772                                         ErrorNumbers.SVC_NO_SERVER_RESOURCES, null);
 773                         alarmLogger.sendAlarm("MsoConfigurationError", MsoAlarmLogger.CRITICAL,
 774                                         Messages.errors.get(ErrorNumbers.NO_COMMUNICATION_TO_BPEL));
 775                         msoLogger.error(MessageEnum.APIH_BPEL_COMMUNICATE_ERROR, MSO_PROP_APIHANDLER_INFRA, "", "",
 776                                         MsoLogger.ErrorCode.AvailabilityError, "Exception while communicate with BPMN engine");
 777                         msoLogger.recordAuditEvent(startTime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.CommunicationError,
 778                                         "Exception while communicate with BPMN engine");
 779                         msoLogger.debug("End of the transaction, the final response is: " + (String) resp.getEntity());
 780                         return resp;
 781                 }
 782
 783                 if (response == null) {
 784                         Response resp = msoRequest.buildServiceErrorResponse(HttpStatus.SC_BAD_GATEWAY,
 785                                         MsoException.ServiceException, "bpelResponse is null", ErrorNumbers.SVC_NO_SERVER_RESOURCES, null);
 786                         msoLogger.error(MessageEnum.APIH_BPEL_COMMUNICATE_ERROR, MSO_PROP_APIHANDLER_INFRA, "", "",
 787                                         MsoLogger.ErrorCode.BusinessProcesssError, "Null response from BPEL");
 788                         msoLogger.recordAuditEvent(startTime, MsoLogger.StatusCode.ERROR, MsoLogger.ResponseCode.InternalError,
 789                                         "Null response from BPMN");
 790                         msoLogger.debug(END_OF_THE_TRANSACTION + (String) resp.getEntity());
 791                         return resp;
 792                 }
 793
 794                 ResponseHandler respHandler = new ResponseHandler(response, requestClient.getType());
 795                 int bpelStatus = respHandler.getStatus();
 796
 797                 return beplStatusUpdate(requestId, startTime, msoRequest, requestClient, respHandler, bpelStatus, action, instanceIdMap);
 798         }
 799
 800    private Response scaleE2EserviceInstances(String requestJSON,
 801                                                Action action, HashMap<String, String> instanceIdMap, String version) {
 802
 803         String requestId = UUIDChecker.generateUUID(msoLogger);
 804         long startTime = System.currentTimeMillis();
 805         msoLogger.debug("requestId is: " + requestId);
 806                 E2EServiceInstanceScaleRequest e2eScaleReq = null;
 807
 808         MsoRequest msoRequest = new MsoRequest(requestId);
 809
 810         ObjectMapper mapper = new ObjectMapper();
 811         try {
 812                 e2eScaleReq = mapper.readValue(requestJSON,
 813                                         E2EServiceInstanceScaleRequest.class);
 814
 815         } catch (Exception e) {
 816
 817             msoLogger.debug("Mapping of request to JSON object failed : ", e);
 818             Response response = msoRequest.buildServiceErrorResponse(
 819                     HttpStatus.SC_BAD_REQUEST,
 820                     MsoException.ServiceException,
 821                     "Mapping of request to JSON object failed.  "
 822                             + e.getMessage(), ErrorNumbers.SVC_BAD_PARAMETER,
 823                     null);
 824             msoLogger.error(MessageEnum.APIH_REQUEST_VALIDATION_ERROR,
 825                     MSO_PROP_APIHANDLER_INFRA, "", "",
 826                     MsoLogger.ErrorCode.SchemaError, requestJSON, e);
 827             msoLogger.recordAuditEvent(startTime, MsoLogger.StatusCode.ERROR,
 828                     MsoLogger.ResponseCode.SchemaError,
 829                     "Mapping of request to JSON object failed");
 830             msoLogger.debug("End of the transaction, the final response is: "
 831                     + (String) response.getEntity());
 832             return response;
 833         }
 834
 835         CatalogDatabase db = null;
 836         RecipeLookupResult recipeLookupResult = null;
 837         try {
 838             db = CatalogDatabase.getInstance();
 839                         //TODO  Get the service template model version uuid from AAI.
 840                         recipeLookupResult = getServiceInstanceOrchestrationURI(db, null, action);
 841         } catch (Exception e) {
 842             msoLogger.error(MessageEnum.APIH_DB_ACCESS_EXC,
 843                     MSO_PROP_APIHANDLER_INFRA, "", "",
 844                     MsoLogger.ErrorCode.AvailabilityError,
 845                     "Exception while communciate with Catalog DB", e);
 846             msoRequest
 847                     .setStatus(org.openecomp.mso.apihandlerinfra.vnfbeans.RequestStatusType.FAILED);
 848             Response response = msoRequest.buildServiceErrorResponse(
 849                     HttpStatus.SC_NOT_FOUND, MsoException.ServiceException,
 850                     "No communication to catalog DB " + e.getMessage(),
 851                     ErrorNumbers.SVC_NO_SERVER_RESOURCES, null);
 852             alarmLogger.sendAlarm("MsoDatabaseAccessError",
 853                     MsoAlarmLogger.CRITICAL, Messages.errors
 854                             .get(ErrorNumbers.NO_COMMUNICATION_TO_CATALOG_DB));
 855             msoRequest.createRequestRecord(Status.FAILED, action);
 856             msoLogger.recordAuditEvent(startTime, MsoLogger.StatusCode.ERROR,
 857                     MsoLogger.ResponseCode.DBAccessError,
 858                     "Exception while communciate with DB");
 859             msoLogger.debug(END_OF_THE_TRANSACTION
 860                     + (String) response.getEntity());
 861             return response;
 862         } finally {
 863             closeCatalogDB(db);
 864         }
 865         if (recipeLookupResult == null) {
 866             msoLogger.error(MessageEnum.APIH_DB_ATTRIBUTE_NOT_FOUND,
 867                     MSO_PROP_APIHANDLER_INFRA, "", "",
 868                     MsoLogger.ErrorCode.DataError, "No recipe found in DB");
 869             msoRequest
 870                     .setStatus(org.openecomp.mso.apihandlerinfra.vnfbeans.RequestStatusType.FAILED);
 871             Response response = msoRequest.buildServiceErrorResponse(
 872                     HttpStatus.SC_NOT_FOUND, MsoException.ServiceException,
 873                     "Recipe does not exist in catalog DB",
 874                     ErrorNumbers.SVC_GENERAL_SERVICE_ERROR, null);
 875             msoRequest.createRequestRecord(Status.FAILED, action);
 876             msoLogger.recordAuditEvent(startTime, MsoLogger.StatusCode.ERROR,
 877                     MsoLogger.ResponseCode.DataNotFound,
 878                     "No recipe found in DB");
 879             msoLogger.debug(END_OF_THE_TRANSACTION
 880                     + (String) response.getEntity());
 881             return response;
 882         }
 883
 884         RequestClient requestClient = null;
 885         HttpResponse response = null;
 886
 887         long subStartTime = System.currentTimeMillis();
 888         try {
 889             requestClient = RequestClientFactory.getRequestClient(
 890                     recipeLookupResult.getOrchestrationURI(),
 891                     MsoPropertiesUtils.loadMsoProperties());
 892
 893             JSONObject jjo = new JSONObject(requestJSON);
 894             jjo.put("operationId", UUIDChecker.generateUUID(msoLogger));
 895
 896             // Capture audit event
 897             msoLogger
 898                     .debug("MSO API Handler Posting call to BPEL engine for url: "
 899                             + requestClient.getUrl());
 900                         RequestClientParamater requestClientParamater = new RequestClientParamater.Builder().setRequestId(requestId).
 901                                         setBaseVfModule(false).setRecipeTimeout(recipeLookupResult.getRecipeTimeout()).setRequestAction(action.name()).
 902                                         setServiceInstanceId(instanceIdMap.get("serviceId")).
 903                                         setServiceType(e2eScaleReq.getService().getServiceType()).
 904                                         setRequestDetails(jjo.toString()).
 905                                         setRecipeParamXsd(recipeLookupResult.getRecipeParamXsd()).build();
 906
 907             response = requestClient.post(requestClientParamater);
 908
 909             msoLogger.recordMetricEvent(subStartTime,
 910                     MsoLogger.StatusCode.COMPLETE, MsoLogger.ResponseCode.Suc,
 911                     "Successfully received response from BPMN engine", "BPMN",
 912                     recipeLookupResult.getOrchestrationURI(), null);
 913         } catch (Exception e) {
 914             msoLogger.recordMetricEvent(subStartTime,
 915                     MsoLogger.StatusCode.ERROR,
 916                     MsoLogger.ResponseCode.CommunicationError,
 917                     "Exception while communicate with BPMN engine", "BPMN",
 918                     recipeLookupResult.getOrchestrationURI(), null);
 919             Response resp = msoRequest.buildServiceErrorResponse(
 920                     HttpStatus.SC_BAD_GATEWAY, MsoException.ServiceException,
 921                     "Failed calling bpmn " + e.getMessage(),
 922                     ErrorNumbers.SVC_NO_SERVER_RESOURCES, null);
 923             alarmLogger.sendAlarm("MsoConfigurationError",
 924                     MsoAlarmLogger.CRITICAL,
 925                     Messages.errors.get(ErrorNumbers.NO_COMMUNICATION_TO_BPEL));
 926             msoLogger.error(MessageEnum.APIH_BPEL_COMMUNICATE_ERROR,
 927                     MSO_PROP_APIHANDLER_INFRA, "", "",
 928                     MsoLogger.ErrorCode.AvailabilityError,
 929                     "Exception while communicate with BPMN engine",e);
 930             msoLogger.recordAuditEvent(startTime, MsoLogger.StatusCode.ERROR,
 931                     MsoLogger.ResponseCode.CommunicationError,
 932                     "Exception while communicate with BPMN engine");
 933             msoLogger.debug("End of the transaction, the final response is: "
 934                     + (String) resp.getEntity());
 935             return resp;
 936         }
 937
 938         if (response == null) {
 939             Response resp = msoRequest.buildServiceErrorResponse(
 940                     HttpStatus.SC_BAD_GATEWAY, MsoException.ServiceException,
 941                     "bpelResponse is null",
 942                     ErrorNumbers.SVC_NO_SERVER_RESOURCES, null);
 943             msoLogger.error(MessageEnum.APIH_BPEL_COMMUNICATE_ERROR,
 944                     MSO_PROP_APIHANDLER_INFRA, "", "",
 945                     MsoLogger.ErrorCode.BusinessProcesssError,
 946                     "Null response from BPEL");
 947             msoLogger.recordAuditEvent(startTime, MsoLogger.StatusCode.ERROR,
 948                     MsoLogger.ResponseCode.InternalError,
 949                     "Null response from BPMN");
 950             msoLogger.debug(END_OF_THE_TRANSACTION + (String) resp.getEntity());
 951             return resp;
 952         }
 953
 954         ResponseHandler respHandler = new ResponseHandler(response,
 955                 requestClient.getType());
 956         int bpelStatus = respHandler.getStatus();
 957
 958         return beplStatusUpdate(requestId, startTime, msoRequest,
 959                 requestClient, respHandler, bpelStatus, action, instanceIdMap);
 960     }
 961
 962         private void closeCatalogDB(CatalogDatabase db) {
 963                 if (db != null) {
 964                         db.close();
 965                 }
 966         }
 967
 968         private Response beplStatusUpdate(String serviceId, long startTime,
 969                         MsoRequest msoRequest, RequestClient requestClient,
 970                         ResponseHandler respHandler, int bpelStatus, Action action,
 971                         HashMap<String, String> instanceIdMap) {
 972                 // BPMN accepted the request, the request is in progress
 973                 if (bpelStatus == HttpStatus.SC_ACCEPTED) {
 974                         String camundaJSONResponseBody = respHandler.getContent();
 975                         msoLogger.debug("Received from Camunda: " + camundaJSONResponseBody);
 976                         msoLogger.recordAuditEvent(startTime,
 977                                         MsoLogger.StatusCode.COMPLETE, MsoLogger.ResponseCode.Suc,
 978                                         "BPMN accepted the request, the request is in progress");
 979                         msoLogger.debug(END_OF_THE_TRANSACTION + camundaJSONResponseBody);
 980                         return Response.status(HttpStatus.SC_ACCEPTED)
 981                                         .entity(camundaJSONResponseBody).build();
 982                 } else {
 983                         List<String> variables = new ArrayList<>();
 984                         variables.add(bpelStatus + "");
 985                         String camundaJSONResponseBody = respHandler.getContent();
 986                         if (camundaJSONResponseBody != null
 987                                         && !camundaJSONResponseBody.isEmpty()) {
 988                                 Response resp = msoRequest.buildServiceErrorResponse(
 989                                                 bpelStatus, MsoException.ServiceException,
 990                                                 "Request Failed due to BPEL error with HTTP Status= %1 "
 991                                                                 + '\n' + camundaJSONResponseBody,
 992                                                 ErrorNumbers.SVC_DETAILED_SERVICE_ERROR, variables);
 993                                 msoLogger.error(MessageEnum.APIH_BPEL_RESPONSE_ERROR,
 994                                                 requestClient.getUrl(), "", "",
 995                                                 MsoLogger.ErrorCode.BusinessProcesssError,
 996                                                 "Response from BPEL engine is failed with HTTP Status="
 997                                                                 + bpelStatus);
 998                                 msoLogger.recordAuditEvent(startTime,
 999                                                 MsoLogger.StatusCode.ERROR,
1000                                                 MsoLogger.ResponseCode.InternalError,
1001                                                 "Response from BPMN engine is failed");
1002                                 msoLogger.debug(END_OF_THE_TRANSACTION
1003                                                 + (String) resp.getEntity());
1004                                 return resp;
1005                         } else {
1006                                 Response resp = msoRequest
1007                                                 .buildServiceErrorResponse(
1008                                                                 bpelStatus,
1009                                                                 MsoException.ServiceException,
1010                                                                 "Request Failed due to BPEL error with HTTP Status= %1",
1011                                                                 ErrorNumbers.SVC_DETAILED_SERVICE_ERROR,
1012                                                                 variables);
1013                                 msoLogger.error(MessageEnum.APIH_BPEL_RESPONSE_ERROR,
1014                                                 requestClient.getUrl(), "", "",
1015                                                 MsoLogger.ErrorCode.BusinessProcesssError,
1016                                                 "Response from BPEL engine is empty");
1017                                 msoLogger.recordAuditEvent(startTime,
1018                                                 MsoLogger.StatusCode.ERROR,
1019                                                 MsoLogger.ResponseCode.InternalError,
1020                                                 "Response from BPEL engine is empty");
1021                                 msoLogger.debug(END_OF_THE_TRANSACTION
1022                                                 + (String) resp.getEntity());
1023                                 return resp;
1024                         }
1025                 }
1026         }
1027
1028         /**
1029          * Getting recipes from catalogDb
1030          *
1031          * @param db the catalog db
1032          * @param serviceModelUUID the service model version uuid
1033          * @param action the action for the service
1034          * @return the service recipe result
1035          */
1036         private RecipeLookupResult getServiceInstanceOrchestrationURI(
1037                         CatalogDatabase db, String serviceModelUUID, Action action) {
1038
1039                 RecipeLookupResult recipeLookupResult = getServiceURI(db, serviceModelUUID, action);
1040
1041                 if (recipeLookupResult != null) {
1042                         msoLogger.debug("Orchestration URI is: "
1043                                         + recipeLookupResult.getOrchestrationURI()
1044                                         + ", recipe Timeout is: "
1045                                         + Integer.toString(recipeLookupResult.getRecipeTimeout()));
1046                 } else {
1047                         msoLogger.debug("No matching recipe record found");
1048                 }
1049                 return recipeLookupResult;
1050         }
1051
1052         /**
1053          * Getting recipes from catalogDb
1054          * If Service recipe is not set, use default recipe, if set , use special recipe.
1055          * @param db the catalog db
1056          * @param serviceModelUUID the service version uuid
1057          * @param action the action of the service.
1058          * @return the service recipe result.
1059          */
1060         private RecipeLookupResult getServiceURI(CatalogDatabase db, String serviceModelUUID, Action action) {
1061
1062                 String defaultServiceModelName = "UUI_DEFAULT";
1063
1064                 Service defaultServiceRecord = db
1065                                 .getServiceByModelName(defaultServiceModelName);
1066                 ServiceRecipe defaultRecipe = db.getServiceRecipeByModelUUID(
1067                         defaultServiceRecord.getModelUUID(), action.name());
1068                 //set recipe as default generic recipe
1069                 ServiceRecipe recipe = defaultRecipe;
1070                 //check the service special recipe
1071                 if(null != serviceModelUUID && ! serviceModelUUID.isEmpty()){
1072                       ServiceRecipe serviceSpecialRecipe = db.getServiceRecipeByModelUUID(
1073                               serviceModelUUID, action.name());
1074                       if(null != serviceSpecialRecipe){
1075                           //set service special recipe.
1076                           recipe = serviceSpecialRecipe;
1077                       }
1078                 }
1079
1080                 if (recipe == null) {
1081                         return null;
1082                 }
1083                 return new RecipeLookupResult(recipe.getOrchestrationUri(),
1084                                 recipe.getRecipeTimeout(), recipe.getServiceParamXSD());
1085
1086         }
1087
1088         /**
1089          * Converting E2EServiceInstanceRequest to ServiceInstanceRequest and
1090          * passing it to camunda engine.
1091          *
1092          * @param e2eSir
1093          * @return
1094          */
1095         private String mapReqJsonToSvcInstReq(E2EServiceInstanceRequest e2eSir,
1096                         String requestJSON) {
1097
1098                 sir = new ServiceInstancesRequest();
1099
1100                 String returnString = null;
1101                 RequestDetails requestDetails = new RequestDetails();
1102                 ModelInfo modelInfo = new ModelInfo();
1103
1104                 // ModelInvariantId
1105                 modelInfo.setModelInvariantId(e2eSir.getService().getServiceInvariantUuid());
1106
1107                 // modelNameVersionId
1108                 modelInfo.setModelNameVersionId(e2eSir.getService().getServiceUuid());
1109
1110                 // String modelInfoValue =
1111                 // e2eSir.getService().getParameters().getNodeTemplateName();
1112                 // String[] arrayOfInfo = modelInfoValue.split(":");
1113                 // String modelName = arrayOfInfo[0];
1114                 // String modelVersion = arrayOfInfo[1];
1115
1116                 // TODO: To ensure, if we dont get the values from the UUI
1117                 String modelName = "voLTE";
1118                 String modelVersion = "1.0";
1119                 // modelName
1120                 modelInfo.setModelName(modelName);
1121
1122                 // modelVersion
1123                 modelInfo.setModelVersion(modelVersion);
1124
1125                 // modelType
1126                 modelInfo.setModelType(ModelType.service);
1127
1128                 // setting modelInfo to requestDetails
1129                 requestDetails.setModelInfo(modelInfo);
1130
1131                 SubscriberInfo subscriberInfo = new SubscriberInfo();
1132
1133                 // globalsubscriberId
1134                 subscriberInfo.setGlobalSubscriberId(e2eSir.getService().getGlobalSubscriberId());
1135
1136                 // setting subscriberInfo to requestDetails
1137                 requestDetails.setSubscriberInfo(subscriberInfo);
1138
1139                 RequestInfo requestInfo = new RequestInfo();
1140
1141                 // instanceName
1142                 requestInfo.setInstanceName(e2eSir.getService().getName());
1143
1144                 // source
1145                 requestInfo.setSource("UUI");
1146
1147                 // suppressRollback
1148                 requestInfo.setSuppressRollback(true);
1149
1150                 // setting requestInfo to requestDetails
1151                 requestDetails.setRequestInfo(requestInfo);
1152
1153                 RequestParameters requestParameters = new RequestParameters();
1154
1155                 // subscriptionServiceType
1156                 requestParameters.setSubscriptionServiceType("MOG");
1157
1158                 // Userparams
1159                 //List<E2EUserParam> userParams;
1160                 // userParams =
1161                 // e2eSir.getService().getParameters().getRequestParameters().getUserParams();
1162                 List<Map<String, Object>> userParamList = new ArrayList<>();
1163                 Map<String, Object> userParamMap = new HashMap<>();
1164                 // complete json request updated in the camunda
1165                 userParamMap.put("UUIRequest", requestJSON);
1166                 userParamMap.put("ServiceInstanceName", e2eSir.getService().getName());
1167
1168                 // Map<String, String> userParamMap3 = null;
1169                 // for (E2EUserParam userp : userParams) {
1170                 // userParamMap.put(userp.getName(), userp.getValue());
1171                 //
1172                 // }
1173                 userParamList.add(userParamMap);
1174                 requestParameters.setUserParams(userParamList);
1175
1176                 // setting requestParameters to requestDetails
1177                 requestDetails.setRequestParameters(requestParameters);
1178
1179                 sir.setRequestDetails(requestDetails);
1180
1181                 // converting to string
1182                 ObjectMapper mapper = new ObjectMapper();
1183                 try {
1184                         returnString = mapper.writeValueAsString(sir);
1185                 } catch (IOException e) {
1186                         msoLogger
1187                                         .debug("Exception while converting ServiceInstancesRequest object to string",
1188                                                         e);
1189                 }
1190
1191                 return returnString;
1192         }
1193
1194 }