adapters/mso-openstack-adapters/src/main/java/org/onap/so/adapters/vnf/VolumeAdapterRestV2.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * OPENECOMP - SO
   4  * ================================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Modifications Copyright (C) 2018 IBM.
   8  * Modifications Copyright (c) 2019 Samsung
   9  * ================================================================================
  10  * Licensed under the Apache License, Version 2.0 (the "License");
  11  * you may not use this file except in compliance with the License.
  12  * You may obtain a copy of the License at
  13  *
  14  *      http://www.apache.org/licenses/LICENSE-2.0
  15  *
  16  * Unless required by applicable law or agreed to in writing, software
  17  * distributed under the License is distributed on an "AS IS" BASIS,
  18  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  19  * See the License for the specific language governing permissions and
  20  * limitations under the License.
  21  * ============LICENSE_END=========================================================
  22  */
  23
  24 package org.onap.so.adapters.vnf;
  25
  26
  27 import io.swagger.annotations.Api;
  28 import io.swagger.annotations.ApiOperation;
  29 import io.swagger.annotations.ApiParam;
  30 import io.swagger.annotations.ApiResponse;
  31 import io.swagger.annotations.ApiResponses;
  32 import java.util.HashMap;
  33 import java.util.Map;
  34 import javax.inject.Provider;
  35 import javax.ws.rs.Consumes;
  36 import javax.ws.rs.DELETE;
  37 import javax.ws.rs.GET;
  38 import javax.ws.rs.POST;
  39 import javax.ws.rs.PUT;
  40 import javax.ws.rs.Path;
  41 import javax.ws.rs.PathParam;
  42 import javax.ws.rs.Produces;
  43 import javax.ws.rs.QueryParam;
  44 import javax.ws.rs.core.GenericEntity;
  45 import javax.ws.rs.core.MediaType;
  46 import javax.ws.rs.core.Response;
  47 import javax.xml.ws.Holder;
  48 import org.apache.http.HttpStatus;
  49 import org.onap.so.adapters.vnf.exceptions.VnfException;
  50 import org.onap.so.adapters.vnfrest.CreateVolumeGroupRequest;
  51 import org.onap.so.adapters.vnfrest.CreateVolumeGroupResponse;
  52 import org.onap.so.adapters.vnfrest.DeleteVolumeGroupRequest;
  53 import org.onap.so.adapters.vnfrest.DeleteVolumeGroupResponse;
  54 import org.onap.so.adapters.vnfrest.QueryVolumeGroupResponse;
  55 import org.onap.so.adapters.vnfrest.RollbackVolumeGroupRequest;
  56 import org.onap.so.adapters.vnfrest.RollbackVolumeGroupResponse;
  57 import org.onap.so.adapters.vnfrest.UpdateVolumeGroupRequest;
  58 import org.onap.so.adapters.vnfrest.UpdateVolumeGroupResponse;
  59 import org.onap.so.adapters.vnfrest.VolumeGroupExceptionResponse;
  60 import org.onap.so.adapters.vnfrest.VolumeGroupRollback;
  61 import org.onap.so.entity.MsoRequest;
  62 import org.onap.so.logger.ErrorCode;
  63 import org.onap.so.logger.MessageEnum;
  64 import org.onap.so.openstack.beans.VnfRollback;
  65 import org.onap.so.openstack.beans.VnfStatus;
  66 import org.onap.so.openstack.exceptions.MsoExceptionCategory;
  67 import org.slf4j.Logger;
  68 import org.slf4j.LoggerFactory;
  69 import org.springframework.beans.factory.annotation.Autowired;
  70 import org.springframework.stereotype.Component;
  71
  72 /**
  73  * This class services calls to the REST interface for VNF Volumes (http://host:port/vnfs/rest/v1/volume-groups)
  74  * Both XML and JSON can be produced/consumed.  Set Accept: and Content-Type: headers appropriately.  XML is the default.
  75  * For testing, call with cloudSiteId = ___TESTING___
  76  * To test exceptions, also set tenantId = ___TESTING___
  77  *
  78  * V2 incorporates run-time selection of sub-orchestrator implementation (Heat or Cloudify)
  79  * based on the target cloud.
  80  */
  81 @Path("/v2/volume-groups")
  82 @Api(value = "/v2/volume-groups", description = "root of volume-groups adapters restful web service v2")
  83 @Component
  84 public class VolumeAdapterRestV2 {
  85
  86     private static final Logger logger = LoggerFactory.getLogger(VolumeAdapterRestV2.class);
  87         private static final String TESTING_KEYWORD = "___TESTING___";
  88         private static final String RESP=", resp=";
  89         private static final String EXCEPTION="Exception :";
  90         private static final String VOLUME_GROUPID_MISSING="VolumeGroupId in URL does not match content";
  91
  92         @Autowired
  93         private VnfAdapterRestUtils vnfAdapterRestUtils;
  94
  95         @Autowired
  96         private Provider<BpelRestClient> bpelRestClientProvider;
  97
  98         @POST
  99         @Path("")
 100         @Consumes({ MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON })
 101         @Produces({ MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON })
 102         @ApiOperation(value = "CreateVNFVolumes",
 103                 response = Response.class,
 104                 notes = "Create a new vnfVolume")
 105         @ApiResponses({
 106                 @ApiResponse(code = 200, message = "vnfVolume has been successfully created"),
 107                 @ApiResponse(code = 202, message = "create vnfVolume request has been successfully accepted (async only)"),
 108                 @ApiResponse(code = 500, message = "create vnfVolume failed, examine entity object for details") })
 109         public Response createVNFVolumes(
 110                         @ApiParam(value = "mode", required = true)
 111                         @QueryParam("mode") String mode,
 112                         @ApiParam(value = "CreateVolumeGroupRequest", required = true)
 113                         final CreateVolumeGroupRequest req)
 114         {
 115       logger.debug("createVNFVolumes enter: {}", req.toJsonString());
 116                 CreateVNFVolumesTask task = new CreateVNFVolumesTask(req, mode);
 117                 if (req.isSynchronous()) {
 118                         // This is a synchronous request
 119                         task.run();
 120                         return Response
 121                                 .status(task.getStatusCode())
 122                                 .entity(task.getGenericEntityResponse())
 123                                 .build();
 124                 } else {
 125                         // This is an asynchronous request
 126                         try {
 127                                 Thread t1 = new Thread(task);
 128                                 t1.start();
 129                         } catch (Exception e) {
 130                                 // problem handling create, send generic failure as sync resp to caller
 131           logger.error("{} {} Exception - createVNFVolumes: ", MessageEnum.RA_CREATE_VNF_ERR,
 132               ErrorCode.BusinessProcesssError.getValue(), e);
 133                                 return Response.serverError().build();
 134                         }
 135                         // send sync response (ACK) to caller
 136         logger.debug("createVNFVolumes exit");
 137                         return Response.status(HttpStatus.SC_ACCEPTED).build();
 138                 }
 139         }
 140
 141         public class CreateVNFVolumesTask implements Runnable {
 142                 private final CreateVolumeGroupRequest req;
 143                 private CreateVolumeGroupResponse response = null;
 144                 private VolumeGroupExceptionResponse eresp = null;
 145                 private boolean sendxml;
 146                 private String mode;
 147
 148                 public CreateVNFVolumesTask(CreateVolumeGroupRequest req, String mode) {
 149                         this.req = req;
 150                         this.sendxml = true; // can be set with a field or header later
 151                         this.mode = mode;
 152                 }
 153                 public int getStatusCode() {
 154                         return (response != null) ? HttpStatus.SC_OK : HttpStatus.SC_BAD_REQUEST;
 155                 }
 156                 public Object getGenericEntityResponse() {
 157                         return (response != null)
 158                                 ? new GenericEntity<CreateVolumeGroupResponse>(response) {}
 159                                 : new GenericEntity<VolumeGroupExceptionResponse>(eresp) {};
 160                 }
 161                 private String getResponse() {
 162                         if (response != null) {
 163                                 return sendxml ? response.toXmlString() : response.toJsonString();
 164                         } else {
 165                                 return sendxml ? eresp.toXmlString() : eresp.toJsonString();
 166                         }
 167                 }
 168                 @Override
 169                 public void run() {
 170         logger.debug("CreateVFModule VolumesTask start");
 171                         try {
 172                                 // Synchronous Web Service Outputs
 173                                 Holder<String> stackId = new Holder<>();
 174                                 Holder<Map<String, String>> outputs = new Holder<>();
 175                                 Holder<VnfRollback> vnfRollback = new Holder<>();
 176                                 String completeVnfVfModuleType = req.getVnfType() + "::" + req.getVfModuleType();
 177           logger.debug("in createVfModuleVolumes - completeVnfVfModuleType={}", completeVnfVfModuleType);
 178
 179                                 String cloudsiteId = req.getCloudSiteId();
 180                                 if (cloudsiteId != null && cloudsiteId.equals(TESTING_KEYWORD)) {
 181                                         String tenant = req.getTenantId();
 182                                         if (tenant != null && tenant.equals(TESTING_KEYWORD)) {
 183                                                 throw new VnfException("testing.");
 184                                         }
 185                                         stackId.value = "479D3D8B-6360-47BC-AB75-21CC91981484";
 186                                         outputs.value = testMap();
 187                                 } else {
 188                                         // Support different Adapter Implementations
 189                                         MsoVnfAdapter vnfAdapter = vnfAdapterRestUtils.getVnfAdapterImpl(mode, cloudsiteId);
 190                                         vnfAdapter.createVfModule(
 191                                                         req.getCloudSiteId(), //cloudSiteId,
 192                                                         req.getTenantId(), //tenantId,
 193                                                         completeVnfVfModuleType, //vnfType,
 194                                                         req.getVnfVersion(), //vnfVersion,
 195                                                         "", // genericVnfId
 196                                                         req.getVolumeGroupName(), //vnfName,
 197                                                         "", // vfModuleId
 198                                                         "VOLUME", //requestType,
 199                                                         null, //volumeGroupHeatStackId,
 200                                                         null, //baseVfHeatStackId,
 201                                                         req.getModelCustomizationUuid(),
 202                                                         req.getVolumeGroupParams(), //inputs,
 203                                                         req.getFailIfExists(), //failIfExists,
 204                                                         req.getSuppressBackout(), //backout,
 205                                                         req.getEnableBridge(),
 206                                                         req.getMsoRequest(), // msoRequest,
 207                                                         stackId,
 208                                                         outputs,
 209                                                         vnfRollback);
 210                                 }
 211
 212                                 VolumeGroupRollback rb = new VolumeGroupRollback(
 213                                                 req.getVolumeGroupId(),
 214                                                 stackId.value,
 215                                                 vnfRollback.value.getVnfCreated(),
 216                                                 req.getTenantId(),
 217                                                 req.getCloudSiteId(),
 218                                                 req.getMsoRequest(),
 219                                                 req.getMessageId());
 220
 221                                 response = new CreateVolumeGroupResponse(
 222                                                 req.getVolumeGroupId(),
 223                                                 stackId.value,
 224                                                 vnfRollback.value.getVnfCreated(),
 225                                                 outputs.value,
 226                                                 rb,
 227                                                 req.getMessageId());
 228                         } catch (VnfException e) {
 229           logger.debug(EXCEPTION, e);
 230                                 eresp = new VolumeGroupExceptionResponse(
 231                                         e.getMessage(), MsoExceptionCategory.INTERNAL, true, req.getMessageId());
 232                         }
 233                         if (!req.isSynchronous()) {
 234                                 // This is asynch, so POST response back to caller
 235                                 BpelRestClient bpelClient = bpelRestClientProvider.get();
 236                                 bpelClient.bpelPost(getResponse(), req.getNotificationUrl(), sendxml);
 237                         }
 238         logger.debug("CreateVFModule VolumesTask exit: code= {} {} {}", getStatusCode(), RESP, getResponse());
 239                 }
 240         }
 241
 242         @DELETE
 243         @Path("{aaiVolumeGroupId}")
 244         @Consumes({ MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON })
 245         @Produces({ MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON })
 246         @ApiOperation(value = "DeleteVNFVolumes",
 247                 response = Response.class,
 248                 notes = "Delete an existing vnfVolume")
 249         @ApiResponses({
 250                 @ApiResponse(code = 200, message = "vnfVolume has been successfully deleted"),
 251                 @ApiResponse(code = 202, message = "delete vnfVolume request has been successfully accepted (async only)"),
 252                 @ApiResponse(code = 500, message = "delete vnfVolume failed, examine entity object for details") })
 253         public Response deleteVNFVolumes(
 254                 @ApiParam(value = "aaiVolumeGroupId", required = true)
 255                 @PathParam("aaiVolumeGroupId") String aaiVolumeGroupId,
 256                 @ApiParam(value = "mode", required = true)
 257                 @QueryParam("mode") String mode,
 258                 @ApiParam(value = "DeleteVolumeGroupRequest", required = true)
 259                 final DeleteVolumeGroupRequest req
 260                 )
 261         {
 262       logger.debug("deleteVNFVolumes enter: {}", req.toJsonString());
 263                 if (aaiVolumeGroupId == null || !aaiVolumeGroupId.equals(req.getVolumeGroupId())) {
 264                         return Response
 265                                 .status(HttpStatus.SC_BAD_REQUEST)
 266                                 .type(MediaType.TEXT_PLAIN)
 267                                 .entity(VOLUME_GROUPID_MISSING)
 268                                 .build();
 269                 }
 270                 DeleteVNFVolumesTask task = new DeleteVNFVolumesTask(req, mode);
 271                 if (req.isSynchronous()) {
 272                         // This is a synchronous request
 273                         task.run();
 274                         return Response
 275                                 .status(task.getStatusCode())
 276                                 .entity(task.getGenericEntityResponse())
 277                                 .build();
 278                 } else {
 279                         // This is an asynchronous request
 280                         try {
 281                                 Thread t1 = new Thread(task);
 282                                 t1.start();
 283                         } catch (Exception e) {
 284                                 // problem handling create, send generic failure as sync resp to caller
 285           logger.error("{} {} Exception - deleteVNFVolumes: ", MessageEnum.RA_DELETE_VNF_ERR,
 286               ErrorCode.BusinessProcesssError.getValue(), e);
 287                                 return Response.serverError().build();
 288                         }
 289                         // send sync response (ACK) to caller
 290         logger.debug("deleteVNFVolumes exit");
 291                         return Response.status(HttpStatus.SC_ACCEPTED).build();
 292                 }
 293         }
 294
 295         public class DeleteVNFVolumesTask implements Runnable {
 296                 private final DeleteVolumeGroupRequest req;
 297                 private DeleteVolumeGroupResponse response = null;
 298                 private VolumeGroupExceptionResponse eresp = null;
 299                 private boolean sendxml;
 300                 private String mode;
 301
 302                 public DeleteVNFVolumesTask(DeleteVolumeGroupRequest req, String mode) {
 303                         this.req = req;
 304                         this.sendxml = true; // can be set with a field or header later
 305                         this.mode = mode;
 306                 }
 307                 public int getStatusCode() {
 308                         return (response != null) ? HttpStatus.SC_OK : HttpStatus.SC_BAD_REQUEST;
 309                 }
 310                 public Object getGenericEntityResponse() {
 311                         return (response != null)
 312                                 ? new GenericEntity<DeleteVolumeGroupResponse>(response) {}
 313                                 : new GenericEntity<VolumeGroupExceptionResponse>(eresp) {};
 314                 }
 315                 private String getResponse() {
 316                         if (response != null) {
 317                                 return sendxml ? response.toXmlString() : response.toJsonString();
 318                         } else {
 319                                 return sendxml ? eresp.toXmlString() : eresp.toJsonString();
 320                         }
 321                 }
 322                 @Override
 323                 public void run() {
 324         logger.debug("DeleteVNFVolumesTask start");
 325                         String cloudSiteId = req.getCloudSiteId();
 326                         try {
 327                                 if (! cloudSiteId.equals(TESTING_KEYWORD)) {
 328                                         // Support different Adapter Implementations
 329                                         MsoVnfAdapter vnfAdapter = vnfAdapterRestUtils.getVnfAdapterImpl(mode, cloudSiteId);
 330                                         vnfAdapter.deleteVnf(req.getCloudSiteId(), req.getTenantId(), req.getVolumeGroupStackId(), req.getMsoRequest());
 331                                 }
 332                                 response = new DeleteVolumeGroupResponse(true, req.getMessageId());
 333                         } catch (VnfException e) {
 334           logger.debug(EXCEPTION, e);
 335                                 eresp = new VolumeGroupExceptionResponse(e.getMessage(), MsoExceptionCategory.INTERNAL, true, req.getMessageId());
 336                         }
 337                         if (!req.isSynchronous()) {
 338                                 // This is asynch, so POST response back to caller
 339                                 BpelRestClient bpelClient = bpelRestClientProvider.get();
 340                                 bpelClient.bpelPost(getResponse(), req.getNotificationUrl(), sendxml);
 341                         }
 342         logger.debug("DeleteVNFVolumesTask exit: code= {} {} {}", getStatusCode(), RESP, getResponse());
 343                 }
 344         }
 345
 346         @DELETE
 347         @Path("{aaiVolumeGroupId}/rollback")
 348         @Consumes({ MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON })
 349         @Produces({ MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON })
 350         @ApiOperation(value = "RollbackVNFVolumes",
 351                 response = Response.class,
 352                 notes = "Delete an existing vnfVolume")
 353         @ApiResponses({
 354                 @ApiResponse(code = 200, message = "vnfVolume has been successfully rolled back"),
 355                 @ApiResponse(code = 202, message = "rollback vnfVolume request has been successfully accepted (async only)"),
 356                 @ApiResponse(code = 500, message = "rollback vnfVolume failed, examine entity object for details") })
 357         public Response rollbackVNFVolumes(
 358                 @ApiParam(value = "aaiVolumeGroupId", required = true)
 359                 @PathParam("aaiVolumeGroupId") String aaiVolumeGroupId,
 360                 @ApiParam(value = "RollbackVolumeGroupRequest", required = true)
 361                 final RollbackVolumeGroupRequest req
 362                 )
 363         {
 364       logger.debug("rollbackVNFVolumes enter: {}", req.toJsonString());
 365                 if (aaiVolumeGroupId == null || req.getVolumeGroupRollback() == null || !aaiVolumeGroupId.equals(req.getVolumeGroupRollback().getVolumeGroupId())) {
 366                         return Response
 367                                 .status(HttpStatus.SC_BAD_REQUEST)
 368                                 .type(MediaType.TEXT_PLAIN)
 369                                 .entity(VOLUME_GROUPID_MISSING)
 370                                 .build();
 371                 }
 372                 RollbackVNFVolumesTask task = new RollbackVNFVolumesTask(req);
 373                 if (req.isSynchronous()) {
 374                         // This is a synchronous request
 375                         task.run();
 376                         return Response
 377                                 .status(task.getStatusCode())
 378                                 .entity(task.getGenericEntityResponse())
 379                                 .build();
 380                 } else {
 381                         // This is an asynchronous request
 382                         try {
 383                                 Thread t1 = new Thread(task);
 384                                 t1.start();
 385                         } catch (Exception e) {
 386                                 // problem handling create, send generic failure as sync resp to caller
 387           logger.error("{} {} Exception - rollbackVNFVolumes: ", MessageEnum.RA_ROLLBACK_VNF_ERR,
 388               ErrorCode.BusinessProcesssError.getValue(), e);
 389                                 return Response.serverError().build();
 390                         }
 391                         // send sync response (ACK) to caller
 392         logger.debug("rollbackVNFVolumes exit");
 393                         return Response.status(HttpStatus.SC_ACCEPTED).build();
 394                 }
 395         }
 396
 397         public class RollbackVNFVolumesTask implements Runnable {
 398                 private final RollbackVolumeGroupRequest req;
 399                 private RollbackVolumeGroupResponse response = null;
 400                 private VolumeGroupExceptionResponse eresp = null;
 401                 private boolean sendxml;
 402
 403                 public RollbackVNFVolumesTask(RollbackVolumeGroupRequest req) {
 404                         this.req = req;
 405                         this.sendxml = true; // can be set with a field or header later
 406                 }
 407                 public int getStatusCode() {
 408                         return (response != null) ? HttpStatus.SC_OK : HttpStatus.SC_BAD_REQUEST;
 409                 }
 410                 public Object getGenericEntityResponse() {
 411                         return (response != null)
 412                                 ? new GenericEntity<RollbackVolumeGroupResponse>(response) {}
 413                                 : new GenericEntity<VolumeGroupExceptionResponse>(eresp) {};
 414                 }
 415                 private String getResponse() {
 416                         if (response != null) {
 417                                 return sendxml ? response.toXmlString() : response.toJsonString();
 418                         } else {
 419                                 return sendxml ? eresp.toXmlString() : eresp.toJsonString();
 420                         }
 421                 }
 422                 @Override
 423                 public void run() {
 424         logger.debug("RollbackVNFVolumesTask start");
 425                         try {
 426                                 VolumeGroupRollback vgr = req.getVolumeGroupRollback();
 427                                 VnfRollback vrb = new VnfRollback(
 428                                                 vgr.getVolumeGroupStackId(), vgr.getTenantId(), vgr.getCloudSiteId(), true, true,
 429                                                 vgr.getMsoRequest(), null, null, null, null);
 430
 431                                 // Support different Adapter Implementations
 432                                 MsoVnfAdapter vnfAdapter = vnfAdapterRestUtils.getVnfAdapterImpl(vrb.getMode(), vrb.getCloudSiteId());
 433                                 vnfAdapter.rollbackVnf(vrb);
 434                                 response = new RollbackVolumeGroupResponse(true, req.getMessageId());
 435                         } catch (VnfException e) {
 436           logger.debug(EXCEPTION, e);
 437                                 eresp = new VolumeGroupExceptionResponse(e.getMessage(), MsoExceptionCategory.INTERNAL, true, req.getMessageId());
 438                         }
 439                         if (!req.isSynchronous()) {
 440                                 // This is asynch, so POST response back to caller
 441                                 BpelRestClient bpelClient = bpelRestClientProvider.get();
 442                                 bpelClient.bpelPost(getResponse(), req.getNotificationUrl(), sendxml);
 443                         }
 444         logger.debug("RollbackVNFVolumesTask exit: code= {} {} {}", getStatusCode(), RESP, getResponse());
 445                 }
 446
 447         }
 448
 449         @PUT
 450         @Path("{aaiVolumeGroupId}")
 451         @Consumes({ MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON })
 452         @Produces({ MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON })
 453         @ApiOperation(value = "UpdateVNFVolumes",
 454                 response = Response.class,
 455                 notes = "Update an existing vnfVolume")
 456         @ApiResponses({
 457                 @ApiResponse(code = 200, message = "vnfVolume has been successfully updated"),
 458                 @ApiResponse(code = 202, message = "update vnfVolume request has been successfully accepted (async only)"),
 459                 @ApiResponse(code = 500, message = "update vnfVolume failed, examine entity object for details") })
 460         public Response updateVNFVolumes(
 461                 @ApiParam(value = "aaiVolumeGroupId", required = true)
 462                 @PathParam("aaiVolumeGroupId") String aaiVolumeGroupId,
 463                 @ApiParam(value = "mode", required = true)
 464                 @QueryParam("mode") String mode,
 465                 @ApiParam(value = "UpdateVolumeGroupRequest", required = true)
 466                 final UpdateVolumeGroupRequest req
 467                 )
 468         {
 469       logger.debug("updateVNFVolumes enter: {}", req.toJsonString());
 470                 if (aaiVolumeGroupId == null || !aaiVolumeGroupId.equals(req.getVolumeGroupId())) {
 471                         return Response
 472                                 .status(HttpStatus.SC_BAD_REQUEST)
 473                                 .type(MediaType.TEXT_PLAIN)
 474                                 .entity(VOLUME_GROUPID_MISSING)
 475                                 .build();
 476                 }
 477                 UpdateVNFVolumesTask task = new UpdateVNFVolumesTask(req, mode);
 478                 if (req.isSynchronous()) {
 479                         // This is a synchronous request
 480                         task.run();
 481                         return Response
 482                                 .status(task.getStatusCode())
 483                                 .entity(task.getGenericEntityResponse())
 484                                 .build();
 485                 } else {
 486                         // This is an asynchronous request
 487                 try {
 488                         Thread t1 = new Thread(task);
 489                         t1.start();
 490                 } catch (Exception e) {
 491                         // problem handling create, send generic failure as sync resp to caller
 492             logger.error("{} {} Exception - updateVNFVolumes: ", MessageEnum.RA_UPDATE_VNF_ERR,
 493                 ErrorCode.BusinessProcesssError.getValue(), e);
 494                         return Response.serverError().build();
 495                 }
 496                 // send sync response (ACK) to caller
 497         logger.debug("updateVNFVolumes exit");
 498                 return Response.status(HttpStatus.SC_ACCEPTED).build();
 499                 }
 500         }
 501
 502         public class UpdateVNFVolumesTask implements Runnable {
 503                 private final UpdateVolumeGroupRequest req;
 504                 private UpdateVolumeGroupResponse response = null;
 505                 private VolumeGroupExceptionResponse eresp = null;
 506                 private boolean sendxml;
 507                 private String mode;
 508
 509                 public UpdateVNFVolumesTask(UpdateVolumeGroupRequest req, String mode) {
 510                         this.req = req;
 511                         this.sendxml = true; // can be set with a field or header later
 512                         this.mode = mode;
 513                 }
 514                 public int getStatusCode() {
 515                         return (response != null) ? HttpStatus.SC_OK : HttpStatus.SC_BAD_REQUEST;
 516                 }
 517                 public Object getGenericEntityResponse() {
 518                         return (response != null)
 519                                 ? new GenericEntity<UpdateVolumeGroupResponse>(response) {}
 520                                 : new GenericEntity<VolumeGroupExceptionResponse>(eresp) {};
 521                 }
 522                 private String getResponse() {
 523                         if (response != null) {
 524                                 return sendxml ? response.toXmlString() : response.toJsonString();
 525                         } else {
 526                                 return sendxml ? eresp.toXmlString() : eresp.toJsonString();
 527                         }
 528                 }
 529                 @Override
 530                 public void run() {
 531         logger.debug("UpdateVNFVolumesTask start");
 532                         try {
 533                                 Holder<Map<String, String>> outputs = new Holder<> ();
 534                                 Holder<VnfRollback> vnfRollback = new Holder<> ();
 535                                 String completeVnfVfModuleType = req.getVnfType() + "::" + req.getVfModuleType();
 536           logger.debug("in updateVfModuleVolume - completeVnfVfModuleType={}", completeVnfVfModuleType);
 537
 538                                 if (req.getCloudSiteId().equals(TESTING_KEYWORD)) {
 539                                         outputs.value = testMap();
 540                                 } else {
 541                                         // Support different Adapter Implementations
 542                                         MsoVnfAdapter vnfAdapter = vnfAdapterRestUtils.getVnfAdapterImpl(mode, req.getCloudSiteId());
 543                                         vnfAdapter.updateVfModule (req.getCloudSiteId(),
 544                                                         req.getTenantId(),
 545                                                         //req.getVnfType(),
 546                                                         completeVnfVfModuleType,
 547                                                         req.getVnfVersion(),
 548                                                         req.getVolumeGroupStackId(),
 549                                                         "VOLUME",
 550                                                         null,
 551                                                         null,
 552                                                         req.getVolumeGroupStackId(),
 553                                                         req.getModelCustomizationUuid(),
 554                                                         req.getVolumeGroupParams(),
 555                                                         req.getMsoRequest(),
 556                                                         outputs,
 557                                                         vnfRollback);
 558                                 }
 559                                 response = new UpdateVolumeGroupResponse(
 560                                                 req.getVolumeGroupId(), req.getVolumeGroupStackId(),
 561                                                 outputs.value, req.getMessageId());
 562                         } catch (VnfException e) {
 563           logger.debug(EXCEPTION, e);
 564                                 eresp = new VolumeGroupExceptionResponse(e.getMessage(), MsoExceptionCategory.INTERNAL, true, req.getMessageId());
 565                         }
 566                         if (!req.isSynchronous()) {
 567                                 // This is asynch, so POST response back to caller
 568                                 BpelRestClient bpelClient = bpelRestClientProvider.get();
 569                                 bpelClient.bpelPost(getResponse(), req.getNotificationUrl(), sendxml);
 570                         }
 571         logger.debug("UpdateVNFVolumesTask exit: code= {} {} {}", getStatusCode(), RESP, getResponse());
 572                 }
 573         }
 574
 575         @GET
 576         @Path("{aaiVolumeGroupId}")
 577         @Produces({ MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON })
 578         @ApiOperation(value = "QueryVNFVolumes",
 579                 response = Response.class,
 580                 notes = "Query an existing vnfVolume")
 581         @ApiResponses({
 582                 @ApiResponse(code = 200, message = "vnfVolume has been successfully queried"),
 583                 @ApiResponse(code = 500, message = "query vnfVolume failed, examine entity object for details") })
 584         public Response queryVNFVolumes(
 585                 @ApiParam(value = "aaiVolumeGroupId", required = true)
 586                 @PathParam("aaiVolumeGroupId") String aaiVolumeGroupId,
 587                 @ApiParam(value = "cloudSiteId", required = true)
 588                 @QueryParam("cloudSiteId") String cloudSiteId,
 589                 @ApiParam(value = "tenantId", required = true)
 590                 @QueryParam("tenantId") String tenantId,
 591                 @ApiParam(value = "volumeGroupStackId", required = true)
 592                 @QueryParam("volumeGroupStackId") String volumeGroupStackId,
 593                 @ApiParam(value = "skipAAI", required = true)
 594                 @QueryParam("skipAAI") Boolean skipAAI,
 595                 @ApiParam(value = "msoRequest.requestId", required = true)
 596                 @QueryParam("msoRequest.requestId") String requestId,
 597                 @ApiParam(value = "msoRequest.serviceInstanceId", required = true)
 598                 @QueryParam("msoRequest.serviceInstanceId") String serviceInstanceId,
 599                 @ApiParam(value = "mode", required = true)
 600                 @QueryParam("mode") String mode
 601                 )
 602         {
 603         //This request responds synchronously only
 604       logger.debug("queryVNFVolumes enter: {} {}", aaiVolumeGroupId, volumeGroupStackId);
 605         MsoRequest msoRequest = new MsoRequest(requestId, serviceInstanceId);
 606
 607         try {
 608                 int respStatus = HttpStatus.SC_OK;
 609                 QueryVolumeGroupResponse qryResp = new QueryVolumeGroupResponse(aaiVolumeGroupId, volumeGroupStackId, null, null);
 610                 Holder<Boolean> vnfExists = new Holder<>();
 611                 Holder<String> vfModuleId = new Holder<>();
 612                 Holder<VnfStatus> status = new Holder<>();
 613                 Holder<Map<String, String>> outputs = new Holder<>();
 614                         if (cloudSiteId != null && cloudSiteId.equals(TESTING_KEYWORD)) {
 615                                 if (tenantId != null && tenantId.equals(TESTING_KEYWORD)) {
 616                                         throw new VnfException("testing.");
 617                                 }
 618                                 vnfExists.value = true;
 619                                 vfModuleId.value = TESTING_KEYWORD;
 620                                 status.value = VnfStatus.ACTIVE;
 621                                 outputs.value = testMap();
 622                         } else {
 623                                 // Support different Adapter Implementations
 624                                 MsoVnfAdapter vnfAdapter = vnfAdapterRestUtils.getVnfAdapterImpl(mode, cloudSiteId);
 625                                 vnfAdapter.queryVnf(cloudSiteId, tenantId, volumeGroupStackId, msoRequest, vnfExists, vfModuleId, status, outputs);
 626                         }
 627                 if (!vnfExists.value) {
 628             logger.debug("VNFVolumes not found");
 629                         qryResp.setVolumeGroupStatus(status.value);
 630                         respStatus = HttpStatus.SC_NOT_FOUND;
 631                 } else {
 632             logger.debug("VNFVolumes found {}, status={}", vfModuleId.value, status.value);
 633                         qryResp.setVolumeGroupStatus(status.value);
 634                         qryResp.setVolumeGroupOutputs(outputs.value);
 635                 }
 636           logger.debug("Query queryVNFVolumes exit");
 637                 return Response
 638                         .status(respStatus)
 639                         .entity(new GenericEntity<QueryVolumeGroupResponse>(qryResp) {})
 640                         .build();
 641         } catch (VnfException e) {
 642           logger.error("{} {} AaiVolumeGroupId: {} VnfException - queryVNFVolumes: ", MessageEnum.RA_QUERY_VNF_ERR,
 643               ErrorCode.BusinessProcesssError.getValue(), aaiVolumeGroupId, e);
 644                 VolumeGroupExceptionResponse excResp = new VolumeGroupExceptionResponse(e.getMessage(), MsoExceptionCategory.INTERNAL, Boolean.FALSE, null);
 645           logger.debug("Query queryVNFVolumes exit");
 646                 return Response
 647                         .status(HttpStatus.SC_INTERNAL_SERVER_ERROR)
 648                         .entity(new GenericEntity<VolumeGroupExceptionResponse>(excResp) {})
 649                         .build();
 650                 }
 651         }
 652     public static Map<String, String> testMap() {
 653                 Map<String, String> m = new HashMap<>();
 654                 m.put("mickey", "7");
 655                 m.put("clyde", "10");
 656                 m.put("wayne", "99");
 657                 return m;
 658     }
 659 }