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.MessageEnum;
  64 import org.onap.so.logger.MsoLogger;
  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.beans.factory.annotation.Qualifier;
  72 import org.springframework.stereotype.Component;
  73
  74 /**
  75  * This class services calls to the REST interface for VNF Volumes (http://host:port/vnfs/rest/v1/volume-groups)
  76  * Both XML and JSON can be produced/consumed.  Set Accept: and Content-Type: headers appropriately.  XML is the default.
  77  * For testing, call with cloudSiteId = ___TESTING___
  78  * To test exceptions, also set tenantId = ___TESTING___
  79  */
  80 @Path("/v1/volume-groups")
  81 @Api(value = "/v1/volume-groups", description = "root of volume-groups adapters restful web service")
  82 @Component
  83 public class VolumeAdapterRest {
  84
  85     private static final Logger logger = LoggerFactory.getLogger(VolumeAdapterRest.class);
  86         private static final String TESTING_KEYWORD = "___TESTING___";
  87         private static final String EXCEPTION="Exception :";
  88         private static final String RESP=", resp=";
  89         private static final String VOLUME_GROUPID_IN_URL_DOESNT_MATCH_CONTENT="VolumeGroupId in URL does not match content";
  90         @Autowired
  91         private MsoVnfAdapterImpl vnfAdapter;
  92
  93         @Autowired
  94         @Qualifier("VnfBpel")
  95         private Provider<BpelRestClient> bpelRestClientProvider;
  96
  97         @POST
  98         @Path("")
  99         @Consumes({ MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON })
 100         @Produces({ MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON })
 101         @ApiOperation(value = "CreateVNFVolumes",
 102                 response = Response.class,
 103                 notes = "Create a new vnfVolume")
 104         @ApiResponses({
 105                 @ApiResponse(code = 200, message = "vnfVolume has been successfully created"),
 106                 @ApiResponse(code = 202, message = "create vnfVolume request has been successfully accepted (async only)"),
 107                 @ApiResponse(code = 500, message = "create vnfVolume failed, examine entity object for details") })
 108         public Response createVNFVolumes(
 109                         @ApiParam(value = "CreateVolumeGroupRequest", required = true)
 110                         final CreateVolumeGroupRequest req
 111                         ) {
 112       logger.debug("createVNFVolumes enter: {}", req.toJsonString());
 113                 CreateVNFVolumesTask task = new CreateVNFVolumesTask(req);
 114                 if (req.isSynchronous()) {
 115                         // This is a synchronous request
 116                         task.run();
 117                         return Response
 118                                 .status(task.getStatusCode())
 119                                 .entity(task.getGenericEntityResponse())
 120                                 .build();
 121                 } else {
 122                         // This is an asynchronous request
 123                         try {
 124                                 Thread t1 = new Thread(task);
 125                                 t1.start();
 126                         } catch (Exception e) {
 127                                 // problem handling create, send generic failure as sync resp to caller
 128           logger.error("{} {} Exception - createVNFVolumes: ", MessageEnum.RA_CREATE_VNF_ERR,
 129               MsoLogger.ErrorCode.BusinessProcesssError.getValue(), e);
 130                                 return Response.serverError().build();
 131                         }
 132                         // send sync response (ACK) to caller
 133         logger.debug("createVNFVolumes exit");
 134                         return Response.status(HttpStatus.SC_ACCEPTED).build();
 135                 }
 136         }
 137
 138         public class CreateVNFVolumesTask implements Runnable {
 139                 private final CreateVolumeGroupRequest req;
 140                 private CreateVolumeGroupResponse response = null;
 141                 private VolumeGroupExceptionResponse eresp = null;
 142                 private boolean sendxml;
 143
 144                 public CreateVNFVolumesTask(CreateVolumeGroupRequest req) {
 145                         this.req = req;
 146                         this.sendxml = true; // can be set with a field or header later
 147                 }
 148                 public int getStatusCode() {
 149                         return (response != null) ? HttpStatus.SC_OK : HttpStatus.SC_BAD_REQUEST;
 150                 }
 151                 public Object getGenericEntityResponse() {
 152                         return (response != null)
 153                                 ? new GenericEntity<CreateVolumeGroupResponse>(response) {}
 154                                 : new GenericEntity<VolumeGroupExceptionResponse>(eresp) {};
 155                 }
 156                 private String getResponse() {
 157                         if (response != null) {
 158                                 return sendxml ? response.toXmlString() : response.toJsonString();
 159                         } else {
 160                                 return sendxml ? eresp.toXmlString() : eresp.toJsonString();
 161                         }
 162                 }
 163                 @Override
 164                 public void run() {
 165         logger.debug("CreateVFModule VolumesTask start");
 166                         try {
 167                                 // Synchronous Web Service Outputs
 168                                 Holder<String> stackId = new Holder<>();
 169                                 Holder<Map<String, String>> outputs = new Holder<>();
 170                                 Holder<VnfRollback> vnfRollback = new Holder<>();
 171                                 String completeVnfVfModuleType = req.getVnfType() + "::" + req.getVfModuleType();
 172           logger.debug("in createVfModuleVolumes - completeVnfVfModuleType={}", completeVnfVfModuleType);
 173
 174                                 String cloudsite = req.getCloudSiteId();
 175                                 if (cloudsite != null && cloudsite.equals(TESTING_KEYWORD)) {
 176                                         String tenant = req.getTenantId();
 177                                         if (tenant != null && tenant.equals(TESTING_KEYWORD)) {
 178                                                 throw new VnfException("testing.");
 179                                         }
 180                                         stackId.value = "479D3D8B-6360-47BC-AB75-21CC91981484";
 181                                         outputs.value = testMap();
 182                                 } else {
 183 //                                      vnfAdapter.createVnf(
 184 //                                                      req.getCloudSiteId(),
 185 //                                                      req.getTenantId(),
 186 //                                                      req.getVnfType(),
 187 //                                                      req.getVnfVersion(),
 188 //                                                      req.getVolumeGroupName(),
 189 //                                                      "VOLUME",                       // request type is VOLUME
 190 //                                                      null,                           // not sure about this
 191 //                                                      req.getVolumeGroupParams(),
 192 //                                                      req.getFailIfExists(),
 193 //                                                      req.getSuppressBackout(),
 194 //                                                      req.getMsoRequest(),
 195 //                                                      stackId,
 196 //                                                      outputs,
 197 //                                                      vnfRollback);
 198                                         vnfAdapter.createVfModule(
 199                                                         req.getCloudSiteId(), //cloudSiteId,
 200                                                         req.getTenantId(), //tenantId,
 201                                                         //req.getVnfType(), //vnfType,
 202                                                         completeVnfVfModuleType,
 203                                                         req.getVnfVersion(), //vnfVersion,
 204                                                         "", // genericVnfId
 205                                                         req.getVolumeGroupName(), //vnfName,
 206                                                         "", // vfModuleid
 207                                                         "VOLUME", //requestType,
 208                                                         null, //volumeGroupHeatStackId,
 209                                                         null, //baseVfHeatStackId,
 210                                                         req.getModelCustomizationUuid(),
 211                                                         req.getVolumeGroupParams(), //inputs,
 212                                                         req.getFailIfExists(), //failIfExists,
 213                                                         req.getSuppressBackout(), //backout,
 214                                                         req.getEnableBridge(),
 215                                                         req.getMsoRequest(), // msoRequest,
 216                                                         stackId,
 217                                                         outputs,
 218                                                         vnfRollback);
 219                                 }
 220                                 VolumeGroupRollback rb = new VolumeGroupRollback(
 221                                                 req.getVolumeGroupId(),
 222                                                 stackId.value,
 223                                                 true,                                           // TODO boolean volumeGroupCreated, when would it be false?
 224                                                 req.getTenantId(),
 225                                                 req.getCloudSiteId(),
 226                                                 req.getMsoRequest(),
 227                                                 req.getMessageId());
 228                                 response = new CreateVolumeGroupResponse(
 229                                                 req.getVolumeGroupId(),
 230                                                 stackId.value,
 231                                                 true,                                           // TODO boolean volumeGroupCreated, when would it be false?
 232                                                 outputs.value,
 233                                                 rb,
 234                                                 req.getMessageId());
 235                         } catch (VnfException e) {
 236           logger.debug(EXCEPTION, e);
 237                                 eresp = new VolumeGroupExceptionResponse(
 238                                         e.getMessage(), MsoExceptionCategory.INTERNAL, true, req.getMessageId());
 239                         }
 240                         if (!req.isSynchronous()) {
 241                                 // This is asynch, so POST response back to caller
 242                                 BpelRestClient bpelClient = bpelRestClientProvider.get();
 243                                 bpelClient.bpelPost(getResponse(), req.getNotificationUrl(), sendxml);
 244                         }
 245         logger.debug("CreateVFModule VolumesTask exit: code={} {} {}", getStatusCode(), RESP, getResponse());
 246                 }
 247         }
 248
 249         @DELETE
 250         @Path("{aaiVolumeGroupId}")
 251         @Consumes({ MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON })
 252         @Produces({ MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON })
 253         @ApiOperation(value = "DeleteVNFVolumes",
 254                 response = Response.class,
 255                 notes = "Delete an existing vnfVolume")
 256         @ApiResponses({
 257                 @ApiResponse(code = 200, message = "vnfVolume has been successfully deleted"),
 258                 @ApiResponse(code = 202, message = "delete vnfVolume request has been successfully accepted (async only)"),
 259                 @ApiResponse(code = 500, message = "delete vnfVolume failed, examine entity object for details") })
 260         public Response deleteVNFVolumes(
 261                 @ApiParam(value = "aaiVolumeGroupId", required = true)
 262                 @PathParam("aaiVolumeGroupId") String aaiVolumeGroupId,
 263                 @ApiParam(value = "DeleteVolumeGroupRequest", required = true)
 264                 final DeleteVolumeGroupRequest req
 265                 )
 266         {
 267       logger.debug("deleteVNFVolumes enter: {}", req.toJsonString());
 268                 if (aaiVolumeGroupId == null || !aaiVolumeGroupId.equals(req.getVolumeGroupId())) {
 269                         return Response
 270                                 .status(HttpStatus.SC_BAD_REQUEST)
 271                                 .type(MediaType.TEXT_PLAIN)
 272                                 .entity(VOLUME_GROUPID_IN_URL_DOESNT_MATCH_CONTENT)
 273                                 .build();
 274                 }
 275                 DeleteVNFVolumesTask task = new DeleteVNFVolumesTask(req);
 276                 if (req.isSynchronous()) {
 277                         // This is a synchronous request
 278                         task.run();
 279                         return Response
 280                                 .status(task.getStatusCode())
 281                                 .entity(task.getGenericEntityResponse())
 282                                 .build();
 283                 } else {
 284                         // This is an asynchronous request
 285                         try {
 286                                 Thread t1 = new Thread(task);
 287                                 t1.start();
 288                         } catch (Exception e) {
 289                                 // problem handling create, send generic failure as sync resp to caller
 290           logger.error("{} {} Exception - deleteVNFVolumes: ", MessageEnum.RA_DELETE_VNF_ERR,
 291               MsoLogger.ErrorCode.BusinessProcesssError.getValue(), e);
 292                                 return Response.serverError().build();
 293                         }
 294                         // send sync response (ACK) to caller
 295         logger.debug("deleteVNFVolumes exit");
 296                         return Response.status(HttpStatus.SC_ACCEPTED).build();
 297                 }
 298         }
 299
 300         public class DeleteVNFVolumesTask implements Runnable {
 301                 private final DeleteVolumeGroupRequest req;
 302                 private DeleteVolumeGroupResponse response = null;
 303                 private VolumeGroupExceptionResponse eresp = null;
 304                 private boolean sendxml;
 305
 306                 public DeleteVNFVolumesTask(DeleteVolumeGroupRequest req) {
 307                         this.req = req;
 308                         this.sendxml = true; // can be set with a field or header later
 309                 }
 310                 public int getStatusCode() {
 311                         return (response != null) ? HttpStatus.SC_OK : HttpStatus.SC_BAD_REQUEST;
 312                 }
 313                 public Object getGenericEntityResponse() {
 314                         return (response != null)
 315                                 ? new GenericEntity<DeleteVolumeGroupResponse>(response) {}
 316                                 : new GenericEntity<VolumeGroupExceptionResponse>(eresp) {};
 317                 }
 318                 private String getResponse() {
 319                         if (response != null) {
 320                                 return sendxml ? response.toXmlString() : response.toJsonString();
 321                         } else {
 322                                 return sendxml ? eresp.toXmlString() : eresp.toJsonString();
 323                         }
 324                 }
 325                 @Override
 326                 public void run() {
 327         logger.debug("DeleteVNFVolumesTask start");
 328                         try {
 329                                 if (!req.getCloudSiteId().equals(TESTING_KEYWORD)) {
 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_IN_URL_DOESNT_MATCH_CONTENT)
 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               MsoLogger.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("DeleteVNFVolumesTask 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                                 vnfAdapter.rollbackVnf(vrb);
 431                                 response = new RollbackVolumeGroupResponse(true, req.getMessageId());
 432                         } catch (VnfException e) {
 433           logger.debug(EXCEPTION, e);
 434                                 eresp = new VolumeGroupExceptionResponse(e.getMessage(), MsoExceptionCategory.INTERNAL, true, req.getMessageId());
 435                         }
 436                         if (!req.isSynchronous()) {
 437                                 // This is asynch, so POST response back to caller
 438                                 BpelRestClient bpelClient = bpelRestClientProvider.get();
 439                                 bpelClient.bpelPost(getResponse(), req.getNotificationUrl(), sendxml);
 440                         }
 441         logger.debug("DeleteVNFVolumesTask exit: code={} {} {}", getStatusCode(), RESP, getResponse());
 442                 }
 443
 444         }
 445
 446         @PUT
 447         @Path("{aaiVolumeGroupId}")
 448         @Consumes({ MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON })
 449         @Produces({ MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON })
 450         @ApiOperation(value = "UpdateVNFVolumes",
 451                 response = Response.class,
 452                 notes = "Update an existing vnfVolume")
 453         @ApiResponses({
 454                 @ApiResponse(code = 200, message = "vnfVolume has been successfully updated"),
 455                 @ApiResponse(code = 202, message = "update vnfVolume request has been successfully accepted (async only)"),
 456                 @ApiResponse(code = 500, message = "update vnfVolume failed, examine entity object for details") })
 457         public Response updateVNFVolumes(
 458                 @ApiParam(value = "aaiVolumeGroupId", required = true)
 459                 @PathParam("aaiVolumeGroupId") String aaiVolumeGroupId,
 460                 @ApiParam(value = "UpdateVolumeGroupRequest", required = true)
 461                 final UpdateVolumeGroupRequest req
 462                 )
 463         {
 464       logger.debug("updateVNFVolumes enter: {}", req.toJsonString());
 465                 if (aaiVolumeGroupId == null || !aaiVolumeGroupId.equals(req.getVolumeGroupId())) {
 466                         return Response
 467                                 .status(HttpStatus.SC_BAD_REQUEST)
 468                                 .type(MediaType.TEXT_PLAIN)
 469                                 .entity(VOLUME_GROUPID_IN_URL_DOESNT_MATCH_CONTENT)
 470                                 .build();
 471                 }
 472                 UpdateVNFVolumesTask task = new UpdateVNFVolumesTask(req);
 473                 if (req.isSynchronous()) {
 474                         // This is a synchronous request
 475                         task.run();
 476                         return Response
 477                                 .status(task.getStatusCode())
 478                                 .entity(task.getGenericEntityResponse())
 479                                 .build();
 480                 } else {
 481                         // This is an asynchronous request
 482                 try {
 483                         Thread t1 = new Thread(task);
 484                         t1.start();
 485                 } catch (Exception e) {
 486                         // problem handling create, send generic failure as sync resp to caller
 487             logger.error("{} {} Exception - updateVNFVolumes: ", MessageEnum.RA_UPDATE_VNF_ERR,
 488                 MsoLogger.ErrorCode.BusinessProcesssError.getValue(), e);
 489                         return Response.serverError().build();
 490                 }
 491                 // send sync response (ACK) to caller
 492         logger.debug("updateVNFVolumes exit");
 493                 return Response.status(HttpStatus.SC_ACCEPTED).build();
 494                 }
 495         }
 496
 497         public class UpdateVNFVolumesTask implements Runnable {
 498                 private final UpdateVolumeGroupRequest req;
 499                 private UpdateVolumeGroupResponse response = null;
 500                 private VolumeGroupExceptionResponse eresp = null;
 501                 private boolean sendxml;
 502
 503                 public UpdateVNFVolumesTask(UpdateVolumeGroupRequest req) {
 504                         this.req = req;
 505                         this.sendxml = true; // can be set with a field or header later
 506                 }
 507                 public int getStatusCode() {
 508                         return (response != null) ? HttpStatus.SC_OK : HttpStatus.SC_BAD_REQUEST;
 509                 }
 510                 public Object getGenericEntityResponse() {
 511                         return (response != null)
 512                                 ? new GenericEntity<UpdateVolumeGroupResponse>(response) {}
 513                                 : new GenericEntity<VolumeGroupExceptionResponse>(eresp) {};
 514                 }
 515                 private String getResponse() {
 516                         if (response != null) {
 517                                 return sendxml ? response.toXmlString() : response.toJsonString();
 518                         } else {
 519                                 return sendxml ? eresp.toXmlString() : eresp.toJsonString();
 520                         }
 521                 }
 522                 @Override
 523                 public void run() {
 524         logger.debug("UpdateVNFVolumesTask start");
 525                         try {
 526                                 Holder<Map<String, String>> outputs = new Holder<> ();
 527                                 Holder<VnfRollback> vnfRollback = new Holder<> ();
 528                                 String completeVnfVfModuleType = req.getVnfType() + "::" + req.getVfModuleType();
 529           logger.debug("in updateVfModuleVolume - completeVnfVfModuleType={}", completeVnfVfModuleType);
 530
 531                                 if (req.getCloudSiteId().equals(TESTING_KEYWORD)) {
 532                                         outputs.value = testMap();
 533                                 } else {
 534                                         //vnfAdapter.updateVnf(
 535                                         //              req.getCloudSiteId(),
 536                                         //              req.getTenantId(),
 537                                         //              req.getVnfType(),
 538                                         //              req.getVnfVersion(),
 539                                         //              req.getVfModuleType(),
 540                                         //              "VOLUME",                       // request type is VOLUME
 541                                         //              req.getVolumeGroupStackId(),
 542                                         //              req.getVolumeGroupParams(),
 543                                         //              req.getMsoRequest(),
 544                                         //              outputs,
 545                                         //              vnfRollback);
 546                                         vnfAdapter.updateVfModule (req.getCloudSiteId(),
 547                                                         req.getTenantId(),
 548                                                         //req.getVnfType(),
 549                                                         completeVnfVfModuleType,
 550                                                         req.getVnfVersion(),
 551                                                         req.getVolumeGroupStackId(),
 552                                                         "VOLUME",
 553                                                         null,
 554                                                         null,
 555                                                         req.getVolumeGroupStackId(),
 556                                                         req.getModelCustomizationUuid(),
 557                                                         req.getVolumeGroupParams(),
 558                                                         req.getMsoRequest(),
 559                                                         outputs,
 560                                                         vnfRollback);
 561                                 }
 562                                 response = new UpdateVolumeGroupResponse(
 563                                                 req.getVolumeGroupId(), req.getVolumeGroupStackId(),
 564                                                 outputs.value, req.getMessageId());
 565                         } catch (VnfException e) {
 566           logger.debug(EXCEPTION, e);
 567                                 eresp = new VolumeGroupExceptionResponse(e.getMessage(), MsoExceptionCategory.INTERNAL, true, req.getMessageId());
 568                         }
 569                         if (!req.isSynchronous()) {
 570                                 // This is asynch, so POST response back to caller
 571                                 BpelRestClient bpelClient = bpelRestClientProvider.get();
 572                                 bpelClient.bpelPost(getResponse(), req.getNotificationUrl(), sendxml);
 573                         }
 574         logger.debug("UpdateVNFVolumesTask exit: code={} {} {}", getStatusCode(), RESP, getResponse());
 575                 }
 576         }
 577
 578         @GET
 579         @Path("{aaiVolumeGroupId}")
 580         @Produces({ MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON })
 581         @ApiOperation(value = "QueryVNFVolumes",
 582                 response = Response.class,
 583                 notes = "Query an existing vnfVolume")
 584         @ApiResponses({
 585                 @ApiResponse(code = 200, message = "vnfVolume has been successfully queried"),
 586                 @ApiResponse(code = 500, message = "query vnfVolume failed, examine entity object for details") })
 587         public Response queryVNFVolumes(
 588                 @ApiParam(value = "aaiVolumeGroupId", required = true)
 589                 @PathParam("aaiVolumeGroupId") String aaiVolumeGroupId,
 590                 @ApiParam(value = "cloudSiteId", required = true)
 591                 @QueryParam("cloudSiteId") String cloudSiteId,
 592                 @ApiParam(value = "tenantId", required = true)
 593                 @QueryParam("tenantId") String tenantId,
 594                 @ApiParam(value = "volumeGroupStackId", required = true)
 595                 @QueryParam("volumeGroupStackId") String volumeGroupStackId,
 596                 @ApiParam(value = "skipAAI", required = true)
 597                 @QueryParam("skipAAI") Boolean skipAAI,
 598                 @ApiParam(value = "msoRequest.requestId", required = true)
 599                 @QueryParam("msoRequest.requestId") String requestId,
 600                 @ApiParam(value = "msoRequest.serviceInstanceId", required = true)
 601                 @QueryParam("msoRequest.serviceInstanceId") String serviceInstanceId
 602                 )
 603         {
 604         //This request responds synchronously only
 605       logger.debug("queryVNFVolumes enter: {} {}", aaiVolumeGroupId, volumeGroupStackId);
 606         MsoRequest msoRequest = new MsoRequest(requestId, serviceInstanceId);
 607
 608         try {
 609                 int respStatus = HttpStatus.SC_OK;
 610                 QueryVolumeGroupResponse qryResp = new QueryVolumeGroupResponse(aaiVolumeGroupId, volumeGroupStackId, null, null);
 611                 Holder<Boolean> vnfExists = new Holder<>();
 612                 Holder<String> vfModuleId = new Holder<>();
 613                 Holder<VnfStatus> status = new Holder<>();
 614                 Holder<Map<String, String>> outputs = new Holder<>();
 615                         if (cloudSiteId != null && cloudSiteId.equals(TESTING_KEYWORD)) {
 616                                 if (tenantId != null && tenantId.equals(TESTING_KEYWORD)) {
 617                                         throw new VnfException("testing.");
 618                                 }
 619                                 vnfExists.value = true;
 620                                 vfModuleId.value = TESTING_KEYWORD;
 621                                 status.value = VnfStatus.ACTIVE;
 622                                 outputs.value = testMap();
 623                         } else {
 624                                 vnfAdapter.queryVnf(cloudSiteId, tenantId, volumeGroupStackId, msoRequest, vnfExists, vfModuleId, status, outputs);
 625                         }
 626                 if (!vnfExists.value) {
 627             logger.debug("VNFVolumes not found");
 628                         qryResp.setVolumeGroupStatus(status.value);
 629                         respStatus = HttpStatus.SC_NOT_FOUND;
 630                 } else {
 631             logger.debug("VNFVolumes found {}, status={}", vfModuleId.value, status.value);
 632                         qryResp.setVolumeGroupStatus(status.value);
 633                         qryResp.setVolumeGroupOutputs(outputs.value);
 634                 }
 635           logger.debug("Query queryVNFVolumes exit");
 636                 return Response
 637                         .status(respStatus)
 638                         .entity(new GenericEntity<QueryVolumeGroupResponse>(qryResp) {})
 639                         .build();
 640         } catch (VnfException e) {
 641           logger.error("{} {} AaiVolumeGroupId: {} VnfException - queryVNFVolumes", MessageEnum.RA_QUERY_VNF_ERR,
 642               MsoLogger.ErrorCode.BusinessProcesssError.getValue(), aaiVolumeGroupId, e);
 643                 VolumeGroupExceptionResponse excResp = new VolumeGroupExceptionResponse(e.getMessage(), MsoExceptionCategory.INTERNAL, Boolean.FALSE, null);
 644           logger.debug("Query queryVNFVolumes exit");
 645                 return Response
 646                         .status(HttpStatus.SC_INTERNAL_SERVER_ERROR)
 647                         .entity(new GenericEntity<VolumeGroupExceptionResponse>(excResp) {})
 648                         .build();
 649                 }
 650         }
 651     public static Map<String, String> testMap() {
 652                 Map<String, String> m = new HashMap<>();
 653                 m.put("mickey", "7");
 654                 m.put("clyde", "10");
 655                 m.put("wayne", "99");
 656                 return m;
 657     }
 658 }