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

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