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  * ================================================================================
  10  * Licensed under the Apache License, Version 2.0 (the "License");
  11  * you may not use this file except in compliance with the License.
  12  * You may obtain a copy of the License at
  13  *
  14  *      http://www.apache.org/licenses/LICENSE-2.0
  15  *
  16  * Unless required by applicable law or agreed to in writing, software
  17  * distributed under the License is distributed on an "AS IS" BASIS,
  18  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  19  * See the License for the specific language governing permissions and
  20  * limitations under the License.
  21  * ============LICENSE_END=========================================================
  22  */
  23
  24 package org.onap.so.adapters.vnf;
  25
  26
  27 import java.util.HashMap;
  28 import java.util.Map;
  29
  30 import javax.inject.Provider;
  31 import javax.ws.rs.Consumes;
  32 import javax.ws.rs.DELETE;
  33 import javax.ws.rs.GET;
  34 import javax.ws.rs.POST;
  35 import javax.ws.rs.PUT;
  36 import javax.ws.rs.Path;
  37 import javax.ws.rs.PathParam;
  38 import javax.ws.rs.Produces;
  39 import javax.ws.rs.QueryParam;
  40 import javax.ws.rs.core.GenericEntity;
  41 import javax.ws.rs.core.MediaType;
  42 import javax.ws.rs.core.Response;
  43 import javax.xml.ws.Holder;
  44
  45 import org.apache.http.HttpStatus;
  46 import org.onap.so.adapters.vnf.exceptions.VnfException;
  47 import org.onap.so.adapters.vnfrest.CreateVolumeGroupRequest;
  48 import org.onap.so.adapters.vnfrest.CreateVolumeGroupResponse;
  49 import org.onap.so.adapters.vnfrest.DeleteVolumeGroupRequest;
  50 import org.onap.so.adapters.vnfrest.DeleteVolumeGroupResponse;
  51 import org.onap.so.adapters.vnfrest.QueryVolumeGroupResponse;
  52 import org.onap.so.adapters.vnfrest.RollbackVolumeGroupRequest;
  53 import org.onap.so.adapters.vnfrest.RollbackVolumeGroupResponse;
  54 import org.onap.so.adapters.vnfrest.UpdateVolumeGroupRequest;
  55 import org.onap.so.adapters.vnfrest.UpdateVolumeGroupResponse;
  56 import org.onap.so.adapters.vnfrest.VolumeGroupExceptionResponse;
  57 import org.onap.so.adapters.vnfrest.VolumeGroupRollback;
  58 import org.onap.so.entity.MsoRequest;
  59 import org.onap.so.logger.MessageEnum;
  60 import org.onap.so.logger.MsoLogger;
  61 import org.onap.so.openstack.beans.VnfRollback;
  62 import org.onap.so.openstack.beans.VnfStatus;
  63 import org.onap.so.openstack.exceptions.MsoExceptionCategory;
  64 import org.springframework.beans.factory.annotation.Autowired;
  65 import org.springframework.beans.factory.annotation.Qualifier;
  66 import org.springframework.stereotype.Component;
  67
  68 import io.swagger.annotations.Api;
  69 import io.swagger.annotations.ApiOperation;
  70 import io.swagger.annotations.ApiParam;
  71 import io.swagger.annotations.ApiResponse;
  72 import io.swagger.annotations.ApiResponses;
  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         private static final MsoLogger LOGGER = MsoLogger.getMsoLogger(MsoLogger.Catalog.RA, 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         @Qualifier("VnfBpel")
  94         private Provider<BpelRestClient> bpelRestClientProvider;
  95
  96         @POST
  97         @Path("")
  98         @Consumes({ MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON })
  99         @Produces({ MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON })
 100         @ApiOperation(value = "CreateVNFVolumes",
 101                 response = Response.class,
 102                 notes = "Create a new vnfVolume")
 103         @ApiResponses({
 104                 @ApiResponse(code = 200, message = "vnfVolume has been successfully created"),
 105                 @ApiResponse(code = 202, message = "create vnfVolume request has been successfully accepted (async only)"),
 106                 @ApiResponse(code = 500, message = "create vnfVolume failed, examine entity object for details") })
 107         public Response createVNFVolumes(
 108                         @ApiParam(value = "CreateVolumeGroupRequest", required = true)
 109                         final CreateVolumeGroupRequest req
 110                         ) {
 111                 LOGGER.debug("createVNFVolumes enter: " + req.toJsonString());
 112                 CreateVNFVolumesTask task = new CreateVNFVolumesTask(req);
 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
 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 (MessageEnum.RA_DELETE_VNF_ERR, "", "deleteVNFVolumes", MsoLogger.ErrorCode.BusinessProcesssError, "Exception - deleteVNFVolumes", e);
 289                                 return Response.serverError().build();
 290                         }
 291                         // send sync response (ACK) to caller
 292                         LOGGER.debug ("deleteVNFVolumes exit");
 293                         return Response.status(HttpStatus.SC_ACCEPTED).build();
 294                 }
 295         }
 296
 297         public class DeleteVNFVolumesTask implements Runnable {
 298                 private final DeleteVolumeGroupRequest req;
 299                 private DeleteVolumeGroupResponse response = null;
 300                 private VolumeGroupExceptionResponse eresp = null;
 301                 private boolean sendxml;
 302
 303                 public DeleteVNFVolumesTask(DeleteVolumeGroupRequest req) {
 304                         this.req = req;
 305                         this.sendxml = true; // can be set with a field or header later
 306                 }
 307                 public int getStatusCode() {
 308                         return (response != null) ? HttpStatus.SC_OK : HttpStatus.SC_BAD_REQUEST;
 309                 }
 310                 public Object getGenericEntityResponse() {
 311                         return (response != null)
 312                                 ? new GenericEntity<DeleteVolumeGroupResponse>(response) {}
 313                                 : new GenericEntity<VolumeGroupExceptionResponse>(eresp) {};
 314                 }
 315                 private String getResponse() {
 316                         if (response != null) {
 317                                 return sendxml ? response.toXmlString() : response.toJsonString();
 318                         } else {
 319                                 return sendxml ? eresp.toXmlString() : eresp.toJsonString();
 320                         }
 321                 }
 322                 @Override
 323                 public void run() {
 324                         LOGGER.debug("DeleteVNFVolumesTask start");
 325                         try {
 326                                 if (!req.getCloudSiteId().equals(TESTING_KEYWORD)) {
 327                                         vnfAdapter.deleteVnf(req.getCloudSiteId(), req.getTenantId(), req.getVolumeGroupStackId(), req.getMsoRequest());
 328                                 }
 329                                 response = new DeleteVolumeGroupResponse(true, req.getMessageId());
 330                         } catch (VnfException e) {
 331                                 LOGGER.debug(EXCEPTION,e);
 332                                 eresp = new VolumeGroupExceptionResponse(e.getMessage(), MsoExceptionCategory.INTERNAL, true, req.getMessageId());
 333                         }
 334                         if (!req.isSynchronous()) {
 335                                 // This is asynch, so POST response back to caller
 336                                 BpelRestClient bpelClient = bpelRestClientProvider.get();
 337                                 bpelClient.bpelPost(getResponse(), req.getNotificationUrl(), sendxml);
 338                         }
 339                         LOGGER.debug("DeleteVNFVolumesTask exit: code=" + getStatusCode() + RESP+ getResponse());
 340                 }
 341         }
 342
 343         @DELETE
 344         @Path("{aaiVolumeGroupId}/rollback")
 345         @Consumes({ MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON })
 346         @Produces({ MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON })
 347         @ApiOperation(value = "RollbackVNFVolumes",
 348                 response = Response.class,
 349                 notes = "Delete an existing vnfVolume")
 350         @ApiResponses({
 351                 @ApiResponse(code = 200, message = "vnfVolume has been successfully rolled back"),
 352                 @ApiResponse(code = 202, message = "rollback vnfVolume request has been successfully accepted (async only)"),
 353                 @ApiResponse(code = 500, message = "rollback vnfVolume failed, examine entity object for details") })
 354         public Response rollbackVNFVolumes(
 355                 @ApiParam(value = "aaiVolumeGroupId", required = true)
 356                 @PathParam("aaiVolumeGroupId") String aaiVolumeGroupId,
 357                 @ApiParam(value = "RollbackVolumeGroupRequest", required = true)
 358                 final RollbackVolumeGroupRequest req
 359                 )
 360         {
 361                 LOGGER.debug("rollbackVNFVolumes enter: " + req.toJsonString());
 362                 if (aaiVolumeGroupId == null || req.getVolumeGroupRollback() == null || !aaiVolumeGroupId.equals(req.getVolumeGroupRollback().getVolumeGroupId())) {
 363                         return Response
 364                                 .status(HttpStatus.SC_BAD_REQUEST)
 365                                 .type(MediaType.TEXT_PLAIN)
 366                                 .entity(VOLUME_GROUPID_IN_URL_DOESNT_MATCH_CONTENT)
 367                                 .build();
 368                 }
 369                 RollbackVNFVolumesTask task = new RollbackVNFVolumesTask(req);
 370                 if (req.isSynchronous()) {
 371                         // This is a synchronous request
 372                         task.run();
 373                         return Response
 374                                 .status(task.getStatusCode())
 375                                 .entity(task.getGenericEntityResponse())
 376                                 .build();
 377                 } else {
 378                         // This is an asynchronous request
 379                         try {
 380                                 Thread t1 = new Thread(task);
 381                                 t1.start();
 382                         } catch (Exception e) {
 383                                 // problem handling create, send generic failure as sync resp to caller
 384                                 LOGGER.error (MessageEnum.RA_ROLLBACK_VNF_ERR, "", "rollbackVNFVolumes", MsoLogger.ErrorCode.BusinessProcesssError, "Exception - rollbackVNFVolumes", e);
 385                                 return Response.serverError().build();
 386                         }
 387                         // send sync response (ACK) to caller
 388                         LOGGER.debug("rollbackVNFVolumes exit");
 389                         return Response.status(HttpStatus.SC_ACCEPTED).build();
 390                 }
 391         }
 392
 393         public class RollbackVNFVolumesTask implements Runnable {
 394                 private final RollbackVolumeGroupRequest req;
 395                 private RollbackVolumeGroupResponse response = null;
 396                 private VolumeGroupExceptionResponse eresp = null;
 397                 private boolean sendxml;
 398
 399                 public RollbackVNFVolumesTask(RollbackVolumeGroupRequest req) {
 400                         this.req = req;
 401                         this.sendxml = true; // can be set with a field or header later
 402                 }
 403                 public int getStatusCode() {
 404                         return (response != null) ? HttpStatus.SC_OK : HttpStatus.SC_BAD_REQUEST;
 405                 }
 406                 public Object getGenericEntityResponse() {
 407                         return (response != null)
 408                                 ? new GenericEntity<RollbackVolumeGroupResponse>(response) {}
 409                                 : new GenericEntity<VolumeGroupExceptionResponse>(eresp) {};
 410                 }
 411                 private String getResponse() {
 412                         if (response != null) {
 413                                 return sendxml ? response.toXmlString() : response.toJsonString();
 414                         } else {
 415                                 return sendxml ? eresp.toXmlString() : eresp.toJsonString();
 416                         }
 417                 }
 418                 @Override
 419                 public void run() {
 420                         LOGGER.debug("DeleteVNFVolumesTask start");
 421                         try {
 422                                 VolumeGroupRollback vgr = req.getVolumeGroupRollback();
 423                                 VnfRollback vrb = new VnfRollback(
 424                                                 vgr.getVolumeGroupStackId(), vgr.getTenantId(), vgr.getCloudSiteId(), true, true,
 425                                                 vgr.getMsoRequest(), null, null, null, null);
 426                                 vnfAdapter.rollbackVnf(vrb);
 427                                 response = new RollbackVolumeGroupResponse(true, req.getMessageId());
 428                         } catch (VnfException e) {
 429                                 LOGGER.debug(EXCEPTION,e);
 430                                 eresp = new VolumeGroupExceptionResponse(e.getMessage(), MsoExceptionCategory.INTERNAL, true, req.getMessageId());
 431                         }
 432                         if (!req.isSynchronous()) {
 433                                 // This is asynch, so POST response back to caller
 434                                 BpelRestClient bpelClient = bpelRestClientProvider.get();
 435                                 bpelClient.bpelPost(getResponse(), req.getNotificationUrl(), sendxml);
 436                         }
 437                         LOGGER.debug("DeleteVNFVolumesTask exit: code=" + getStatusCode() + RESP+ getResponse());
 438                 }
 439
 440         }
 441
 442         @PUT
 443         @Path("{aaiVolumeGroupId}")
 444         @Consumes({ MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON })
 445         @Produces({ MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON })
 446         @ApiOperation(value = "UpdateVNFVolumes",
 447                 response = Response.class,
 448                 notes = "Update an existing vnfVolume")
 449         @ApiResponses({
 450                 @ApiResponse(code = 200, message = "vnfVolume has been successfully updated"),
 451                 @ApiResponse(code = 202, message = "update vnfVolume request has been successfully accepted (async only)"),
 452                 @ApiResponse(code = 500, message = "update vnfVolume failed, examine entity object for details") })
 453         public Response updateVNFVolumes(
 454                 @ApiParam(value = "aaiVolumeGroupId", required = true)
 455                 @PathParam("aaiVolumeGroupId") String aaiVolumeGroupId,
 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(VOLUME_GROUPID_IN_URL_DOESNT_MATCH_CONTENT)
 466                                 .build();
 467                 }
 468                 UpdateVNFVolumesTask task = new UpdateVNFVolumesTask(req);
 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
 498                 public UpdateVNFVolumesTask(UpdateVolumeGroupRequest req) {
 499                         this.req = req;
 500                         this.sendxml = true; // can be set with a field or header later
 501                 }
 502                 public int getStatusCode() {
 503                         return (response != null) ? HttpStatus.SC_OK : HttpStatus.SC_BAD_REQUEST;
 504                 }
 505                 public Object getGenericEntityResponse() {
 506                         return (response != null)
 507                                 ? new GenericEntity<UpdateVolumeGroupResponse>(response) {}
 508                                 : new GenericEntity<VolumeGroupExceptionResponse>(eresp) {};
 509                 }
 510                 private String getResponse() {
 511                         if (response != null) {
 512                                 return sendxml ? response.toXmlString() : response.toJsonString();
 513                         } else {
 514                                 return sendxml ? eresp.toXmlString() : eresp.toJsonString();
 515                         }
 516                 }
 517                 @Override
 518                 public void run() {
 519                         LOGGER.debug("UpdateVNFVolumesTask start");
 520                         try {
 521                                 Holder<Map<String, String>> outputs = new Holder<> ();
 522                                 Holder<VnfRollback> vnfRollback = new Holder<> ();
 523                                 String completeVnfVfModuleType = req.getVnfType() + "::" + req.getVfModuleType();
 524                                 LOGGER.debug("in updateVfModuleVolume - completeVnfVfModuleType=" + completeVnfVfModuleType);
 525
 526                                 if (req.getCloudSiteId().equals(TESTING_KEYWORD)) {
 527                                         outputs.value = testMap();
 528                                 } else {
 529                                         //vnfAdapter.updateVnf(
 530                                         //              req.getCloudSiteId(),
 531                                         //              req.getTenantId(),
 532                                         //              req.getVnfType(),
 533                                         //              req.getVnfVersion(),
 534                                         //              req.getVfModuleType(),
 535                                         //              "VOLUME",                       // request type is VOLUME
 536                                         //              req.getVolumeGroupStackId(),
 537                                         //              req.getVolumeGroupParams(),
 538                                         //              req.getMsoRequest(),
 539                                         //              outputs,
 540                                         //              vnfRollback);
 541                                         vnfAdapter.updateVfModule (req.getCloudSiteId(),
 542                                                         req.getTenantId(),
 543                                                         //req.getVnfType(),
 544                                                         completeVnfVfModuleType,
 545                                                         req.getVnfVersion(),
 546                                                         req.getVolumeGroupStackId(),
 547                                                         "VOLUME",
 548                                                         null,
 549                                                         null,
 550                                                         req.getVolumeGroupStackId(),
 551                                                         req.getModelCustomizationUuid(),
 552                                                         req.getVolumeGroupParams(),
 553                                                         req.getMsoRequest(),
 554                                                         outputs,
 555                                                         vnfRollback);
 556                                 }
 557                                 response = new UpdateVolumeGroupResponse(
 558                                                 req.getVolumeGroupId(), req.getVolumeGroupStackId(),
 559                                                 outputs.value, req.getMessageId());
 560                         } catch (VnfException e) {
 561                                 LOGGER.debug(EXCEPTION,e);
 562                                 eresp = new VolumeGroupExceptionResponse(e.getMessage(), MsoExceptionCategory.INTERNAL, true, req.getMessageId());
 563                         }
 564                         if (!req.isSynchronous()) {
 565                                 // This is asynch, so POST response back to caller
 566                                 BpelRestClient bpelClient = bpelRestClientProvider.get();
 567                                 bpelClient.bpelPost(getResponse(), req.getNotificationUrl(), sendxml);
 568                         }
 569                         LOGGER.debug("UpdateVNFVolumesTask exit: code=" + getStatusCode() + RESP+ getResponse());
 570                 }
 571         }
 572
 573         @GET
 574         @Path("{aaiVolumeGroupId}")
 575         @Produces({ MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON })
 576         @ApiOperation(value = "QueryVNFVolumes",
 577                 response = Response.class,
 578                 notes = "Query an existing vnfVolume")
 579         @ApiResponses({
 580                 @ApiResponse(code = 200, message = "vnfVolume has been successfully queried"),
 581                 @ApiResponse(code = 500, message = "query vnfVolume failed, examine entity object for details") })
 582         public Response queryVNFVolumes(
 583                 @ApiParam(value = "aaiVolumeGroupId", required = true)
 584                 @PathParam("aaiVolumeGroupId") String aaiVolumeGroupId,
 585                 @ApiParam(value = "cloudSiteId", required = true)
 586                 @QueryParam("cloudSiteId") String cloudSiteId,
 587                 @ApiParam(value = "tenantId", required = true)
 588                 @QueryParam("tenantId") String tenantId,
 589                 @ApiParam(value = "volumeGroupStackId", required = true)
 590                 @QueryParam("volumeGroupStackId") String volumeGroupStackId,
 591                 @ApiParam(value = "skipAAI", required = true)
 592                 @QueryParam("skipAAI") Boolean skipAAI,
 593                 @ApiParam(value = "msoRequest.requestId", required = true)
 594                 @QueryParam("msoRequest.requestId") String requestId,
 595                 @ApiParam(value = "msoRequest.serviceInstanceId", required = true)
 596                 @QueryParam("msoRequest.serviceInstanceId") String serviceInstanceId
 597                 )
 598         {
 599         //This request responds synchronously only
 600         LOGGER.debug ("queryVNFVolumes enter:" + aaiVolumeGroupId + " " + volumeGroupStackId);
 601         MsoRequest msoRequest = new MsoRequest(requestId, serviceInstanceId);
 602
 603         try {
 604                 int respStatus = HttpStatus.SC_OK;
 605                 QueryVolumeGroupResponse qryResp = new QueryVolumeGroupResponse(aaiVolumeGroupId, volumeGroupStackId, null, null);
 606                 Holder<Boolean> vnfExists = new Holder<>();
 607                 Holder<String> vfModuleId = new Holder<>();
 608                 Holder<VnfStatus> status = new Holder<>();
 609                 Holder<Map<String, String>> outputs = new Holder<>();
 610                         if (cloudSiteId != null && cloudSiteId.equals(TESTING_KEYWORD)) {
 611                                 if (tenantId != null && tenantId.equals(TESTING_KEYWORD)) {
 612                                         throw new VnfException("testing.");
 613                                 }
 614                                 vnfExists.value = true;
 615                                 vfModuleId.value = TESTING_KEYWORD;
 616                                 status.value = VnfStatus.ACTIVE;
 617                                 outputs.value = testMap();
 618                         } else {
 619                                 vnfAdapter.queryVnf(cloudSiteId, tenantId, volumeGroupStackId, msoRequest, vnfExists, vfModuleId, status, outputs);
 620                         }
 621                 if (!vnfExists.value) {
 622                         LOGGER.debug ("VNFVolumes not found");
 623                         qryResp.setVolumeGroupStatus(status.value);
 624                         respStatus = HttpStatus.SC_NOT_FOUND;
 625                 } else {
 626                         LOGGER.debug ("VNFVolumes found " + vfModuleId.value + ", status=" + status.value);
 627                         qryResp.setVolumeGroupStatus(status.value);
 628                         qryResp.setVolumeGroupOutputs(outputs.value);
 629                 }
 630                 LOGGER.debug("Query queryVNFVolumes exit");
 631                 return Response
 632                         .status(respStatus)
 633                         .entity(new GenericEntity<QueryVolumeGroupResponse>(qryResp) {})
 634                         .build();
 635         } catch (VnfException e) {
 636                 LOGGER.error(MessageEnum.RA_QUERY_VNF_ERR,  aaiVolumeGroupId, "", "queryVNFVolumes", MsoLogger.ErrorCode.BusinessProcesssError, "VnfException - queryVNFVolumes", e);
 637                 VolumeGroupExceptionResponse excResp = new VolumeGroupExceptionResponse(e.getMessage(), MsoExceptionCategory.INTERNAL, Boolean.FALSE, null);
 638                 LOGGER.debug("Query queryVNFVolumes exit");
 639                 return Response
 640                         .status(HttpStatus.SC_INTERNAL_SERVER_ERROR)
 641                         .entity(new GenericEntity<VolumeGroupExceptionResponse>(excResp) {})
 642                         .build();
 643                 }
 644         }
 645     public static Map<String, String> testMap() {
 646                 Map<String, String> m = new HashMap<>();
 647                 m.put("mickey", "7");
 648                 m.put("clyde", "10");
 649                 m.put("wayne", "99");
 650                 return m;
 651     }
 652 }