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