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

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