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