gerrit.onap Code Review - so.git/blob

   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.openecomp.mso.adapters.network;
  23
  24
  25 import java.util.HashMap;
  26 import java.util.List;
  27 import java.util.Map;
  28
  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
  45 import org.openecomp.mso.adapters.network.exceptions.NetworkException;
  46 import org.openecomp.mso.adapters.nwrest.ContrailNetwork;
  47 import org.openecomp.mso.adapters.nwrest.CreateNetworkError;
  48 import org.openecomp.mso.adapters.nwrest.CreateNetworkRequest;
  49 import org.openecomp.mso.adapters.nwrest.CreateNetworkResponse;
  50 import org.openecomp.mso.adapters.nwrest.DeleteNetworkError;
  51 import org.openecomp.mso.adapters.nwrest.DeleteNetworkRequest;
  52 import org.openecomp.mso.adapters.nwrest.DeleteNetworkResponse;
  53 import org.openecomp.mso.adapters.nwrest.ProviderVlanNetwork;
  54 import org.openecomp.mso.adapters.nwrest.QueryNetworkError;
  55 import org.openecomp.mso.adapters.nwrest.QueryNetworkResponse;
  56 import org.openecomp.mso.adapters.nwrest.RollbackNetworkError;
  57 import org.openecomp.mso.adapters.nwrest.RollbackNetworkRequest;
  58 import org.openecomp.mso.adapters.nwrest.RollbackNetworkResponse;
  59 import org.openecomp.mso.adapters.nwrest.UpdateNetworkError;
  60 import org.openecomp.mso.adapters.nwrest.UpdateNetworkRequest;
  61 import org.openecomp.mso.adapters.nwrest.UpdateNetworkResponse;
  62 import org.openecomp.mso.cloud.CloudConfigFactory;
  63 import org.openecomp.mso.entity.MsoRequest;
  64 import org.openecomp.mso.logger.MessageEnum;
  65 import org.openecomp.mso.logger.MsoLogger;
  66 import org.openecomp.mso.openstack.beans.NetworkRollback;
  67 import org.openecomp.mso.openstack.beans.NetworkStatus;
  68 import org.openecomp.mso.openstack.exceptions.MsoExceptionCategory;
  69 import org.openecomp.mso.properties.MsoPropertiesFactory;
  70
  71 @Path("/v1/networks")
  72 public class NetworkAdapterRest {
  73         private static final MsoLogger LOGGER = MsoLogger.getMsoLogger (MsoLogger.Catalog.RA);
  74         private static final String TESTING_KEYWORD = "___TESTING___";
  75         private final CloudConfigFactory cloudConfigFactory = new CloudConfigFactory();
  76         private final MsoPropertiesFactory msoPropertiesFactory = new MsoPropertiesFactory();
  77         private final MsoNetworkAdapterImpl adapter = new MsoNetworkAdapterImpl(msoPropertiesFactory, cloudConfigFactory);
  78
  79         @POST
  80         @Path("")
  81         @Consumes({ MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON })
  82         @Produces({ MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON })
  83         public Response createNetwork(CreateNetworkRequest req) {
  84                 LOGGER.debug("createNetwork enter: " + req.toJsonString());
  85                 CreateNetworkTask task = new CreateNetworkTask(req);
  86                 if (req.isSynchronous()) {
  87                         // This is a synchronous request
  88                         task.run();
  89                         return Response
  90                                 .status(task.getStatusCode())
  91                                 .entity(task.getGenericEntityResponse())
  92                                 .build();
  93                 } else {
  94                         // This is an asynchronous request
  95                         try {
  96                                 Thread t1 = new Thread(task);
  97                                 t1.start();
  98                         } catch (Exception e) {
  99                                 // problem handling create, send generic failure as sync resp to caller
 100                                 LOGGER.error (MessageEnum.RA_CREATE_NETWORK_EXC, "", "", MsoLogger.ErrorCode.BusinessProcesssError, "Exception while create network", e);
 101                                 return Response.serverError().build();
 102                         }
 103                         // send sync response (ACK) to caller
 104                         LOGGER.debug ("createNetwork exit");
 105                         return Response.status(HttpStatus.SC_ACCEPTED).build();
 106                 }
 107         }
 108
 109         public class CreateNetworkTask implements Runnable {
 110                 private final CreateNetworkRequest req;
 111                 private CreateNetworkResponse response = null;
 112                 private CreateNetworkError eresp = null;
 113                 private boolean sendxml;
 114
 115                 public CreateNetworkTask(CreateNetworkRequest req) {
 116                         this.req = req;
 117                         this.sendxml = true; // can be set with a field or header later
 118                 }
 119                 public int getStatusCode() {
 120                         return (response != null) ? HttpStatus.SC_OK : HttpStatus.SC_BAD_REQUEST;
 121                 }
 122                 public Object getGenericEntityResponse() {
 123                         return (response != null)
 124                                 ? new GenericEntity<CreateNetworkResponse>(response) {}
 125                                 : new GenericEntity<CreateNetworkError>(eresp) {};
 126                 }
 127                 private String getResponse() {
 128                         if (response != null) {
 129                                 return sendxml ? response.toXmlString() : response.toJsonString();
 130                         } else {
 131                                 return sendxml ? eresp.toXmlString() : eresp.toJsonString();
 132                         }
 133                 }
 134                 @Override
 135                 public void run() {
 136                         LOGGER.debug ("CreateNetworkTask start");
 137                         try {
 138                                 // Synchronous Web Service Outputs
 139                                 Holder<String> networkId = new Holder<>();
 140                                 Holder<String> neutronNetworkId = new Holder<>();
 141                                 Holder<String> networkFqdn = new Holder<>();
 142                                 Holder<Map<String, String>> subnetIdMap = new Holder<>();
 143                                 Holder<NetworkRollback> rollback = new Holder<>();
 144
 145                                 String cloudsite = req.getCloudSiteId();
 146                                 if (cloudsite != null && cloudsite.equals(TESTING_KEYWORD)) {
 147                                         String tenant = req.getTenantId();
 148                                         if (tenant != null && tenant.equals(TESTING_KEYWORD)) {
 149                                                 throw new NetworkException("testing.");
 150                                         }
 151                                         networkId.value = "479D3D8B-6360-47BC-AB75-21CC91981484";
 152                                         neutronNetworkId.value = "55e55884-28fa-11e6-8971-0017f20fe1b8";
 153                                         networkFqdn.value = "086f70b6-28fb-11e6-8260-0017f20fe1b8";
 154                                         subnetIdMap.value = testMap();
 155                                         rollback.value = new NetworkRollback();
 156                                 } else if (req.isContrailRequest()) {
 157                                         ContrailNetwork ctn = req.getContrailNetwork();
 158                                         if (ctn == null) {
 159                                                 ctn = new ContrailNetwork();
 160                                                 req.setContrailNetwork(ctn);
 161                                         }
 162                                         adapter.createNetworkContrail(
 163                                                 req.getCloudSiteId(),
 164                                                 req.getTenantId(),
 165                                                 req.getNetworkType(),
 166                                                 req.getModelCustomizationUuid(),
 167                                                 req.getNetworkName(),
 168                         req.getContrailNetwork().getRouteTargets(),
 169                         req.getContrailNetwork().getShared(),
 170                         req.getContrailNetwork().getExternal(),
 171                         req.getFailIfExists(),
 172                         req.getBackout(),
 173                         req.getSubnets(),
 174                         req.getContrailNetwork().getPolicyFqdns(),
 175                         req.getContrailNetwork().getRouteTableFqdns(),
 176                                 req.getMsoRequest(),
 177                                         networkId,
 178                                                 neutronNetworkId,
 179                                                 networkFqdn,
 180                                                 subnetIdMap,
 181                                                 rollback);
 182                                 } else {
 183                                         ProviderVlanNetwork pvn = req.getProviderVlanNetwork();
 184                                         if (pvn == null) {
 185                                                 pvn = new ProviderVlanNetwork();
 186                                                 req.setProviderVlanNetwork(pvn);
 187                                         }
 188                                         adapter.createNetwork(
 189                                                 req.getCloudSiteId(),
 190                                                 req.getTenantId(),
 191                                                 req.getNetworkType(),
 192                                                 req.getModelCustomizationUuid(),
 193                                                 req.getNetworkName(),
 194                                                 req.getProviderVlanNetwork().getPhysicalNetworkName(),
 195                                                 req.getProviderVlanNetwork().getVlans(),
 196                         req.getFailIfExists(),
 197                         req.getBackout(),
 198                         req.getSubnets(),
 199                         req.getMsoRequest(),
 200                                         networkId,
 201                                         neutronNetworkId,
 202                                         subnetIdMap,
 203                                         rollback);
 204                                 }
 205                                 response = new CreateNetworkResponse(
 206                                                 req.getNetworkId(),
 207                                                 neutronNetworkId.value,
 208                                                 rollback.value.getNetworkStackId(),
 209                                                 networkFqdn.value,
 210                                                 rollback.value.getNetworkCreated(),
 211                                                 subnetIdMap.value,
 212                                                 rollback.value,
 213                                                 req.getMessageId());
 214                         } catch (NetworkException e) {
 215                             LOGGER.debug ("Exception:", e);
 216                                 eresp = new CreateNetworkError(
 217                                         e.getMessage(), MsoExceptionCategory.INTERNAL, true, req.getMessageId());
 218                         }
 219                         if (!req.isSynchronous()) {
 220                                 // This is asynch, so POST response back to caller
 221                                 BpelRestClient bpelClient = new BpelRestClient();
 222                                 bpelClient.bpelPost(getResponse(), req.getNotificationUrl(), sendxml);
 223                         }
 224                         LOGGER.debug ("CreateNetworkTask exit: code=" + getStatusCode() + ", resp="+ getResponse());
 225                 }
 226         }
 227
 228         @DELETE
 229         @Path("{aaiNetworkId}")
 230         @Consumes({ MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON })
 231         @Produces({ MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON })
 232         public Response deleteNetwork(
 233                 @PathParam("aaiNetworkId") String aaiNetworkId,
 234                 DeleteNetworkRequest req)
 235         {
 236                 LOGGER.debug("deleteNetwork enter: " + req.toJsonString());
 237                 if (aaiNetworkId == null || !aaiNetworkId.equals(req.getNetworkId())) {
 238                         return Response
 239                                 .status(HttpStatus.SC_BAD_REQUEST)
 240                                 .type(MediaType.TEXT_PLAIN)
 241                                 .entity("A&AI NetworkId in URL ("+aaiNetworkId+") does not match content ("+req.getNetworkId()+")")
 242                                 .build();
 243                 }
 244                 DeleteNetworkTask task = new DeleteNetworkTask(req);
 245                 if (req.isSynchronous()) {
 246                         // This is a synchronous request
 247                         task.run();
 248                         return Response
 249                                 .status(task.getStatusCode())
 250                                 .entity(task.getGenericEntityResponse())
 251                                 .build();
 252                 } else {
 253                         // This is an asynchronous request
 254                         try {
 255                                 Thread t1 = new Thread(task);
 256                                 t1.start();
 257                         } catch (Exception e) {
 258                                 // problem handling create, send generic failure as sync resp to caller
 259                                 LOGGER.error (MessageEnum.RA_DELETE_NETWORK_EXC, "", "", MsoLogger.ErrorCode.BusinessProcesssError, "Exception while delete network", e);
 260                                 return Response.serverError().build();
 261                         }
 262                         // send sync response (ACK) to caller
 263                         LOGGER.debug ("deleteNetwork exit");
 264                         return Response.status(HttpStatus.SC_ACCEPTED).build();
 265                 }
 266         }
 267
 268         public class DeleteNetworkTask implements Runnable {
 269                 private final DeleteNetworkRequest req;
 270                 private DeleteNetworkResponse response = null;
 271                 private DeleteNetworkError eresp = null;
 272                 private boolean sendxml;
 273
 274                 public DeleteNetworkTask(DeleteNetworkRequest req) {
 275                         this.req = req;
 276                         this.sendxml = true; // can be set with a field or header later
 277                 }
 278                 public int getStatusCode() {
 279                         return (response != null) ? HttpStatus.SC_OK : HttpStatus.SC_BAD_REQUEST;
 280                 }
 281                 public Object getGenericEntityResponse() {
 282                         return (response != null)
 283                                 ? new GenericEntity<DeleteNetworkResponse>(response) {}
 284                                 : new GenericEntity<DeleteNetworkError>(eresp) {};
 285                 }
 286                 private String getResponse() {
 287                         if (response != null) {
 288                                 return sendxml ? response.toXmlString() : response.toJsonString();
 289                         } else {
 290                                 return sendxml ? eresp.toXmlString() : eresp.toJsonString();
 291                         }
 292                 }
 293                 @Override
 294                 public void run() {
 295                         LOGGER.debug("DeleteNetworkTask start");
 296                         try {
 297                                 Holder<Boolean> networkDeleted = new Holder<>();
 298                                 if (req.getCloudSiteId().equals(TESTING_KEYWORD)) {
 299                                         networkDeleted.value = true;
 300                                 } else {
 301                                         adapter.deleteNetwork(
 302                                                 req.getCloudSiteId(),
 303                                                 req.getTenantId(),
 304                                                 req.getNetworkType(),
 305                                                 req.getModelCustomizationUuid(),
 306                                                 req.getNetworkStackId(),
 307                                                 req.getMsoRequest(),
 308                                                 networkDeleted);
 309                                 }
 310                                 response = new DeleteNetworkResponse(req.getNetworkId(), networkDeleted.value, req.getMessageId());
 311                         } catch (NetworkException e) {
 312                             LOGGER.debug ("Exception:", e);
 313                                 eresp = new DeleteNetworkError(e.getMessage(), MsoExceptionCategory.INTERNAL, true, req.getMessageId());
 314                         }
 315                         if (!req.isSynchronous()) {
 316                                 // This is asynch, so POST response back to caller
 317                                 BpelRestClient bpelClient = new BpelRestClient();
 318                                 bpelClient.bpelPost(getResponse(), req.getNotificationUrl(), sendxml);
 319                         }
 320                         LOGGER.debug("DeleteNetworkTask exit: code=" + getStatusCode() + ", resp="+ getResponse());
 321                 }
 322         }
 323
 324         @GET
 325         @Path("{aaiNetworkId}")
 326         @Produces({ MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON })
 327         public Response queryNetwork(
 328                 @QueryParam("cloudSiteId") String cloudSiteId,
 329                 @QueryParam("tenantId") String tenantId,
 330                 @QueryParam("networkStackId") String networkStackId,
 331                 @QueryParam("skipAAI") String skipAAI,
 332                 @QueryParam("msoRequest.requestId") String requestId,
 333                 @QueryParam("msoRequest.serviceInstanceId") String serviceInstanceId,
 334                 @PathParam("aaiNetworkId") String aaiNetworkId)
 335         {
 336                 //This request responds synchronously only
 337                 LOGGER.debug ("Query network enter:" + aaiNetworkId);
 338                 MsoRequest msoRequest = new MsoRequest(requestId, serviceInstanceId);
 339
 340                 try {
 341                         int respStatus = HttpStatus.SC_OK;
 342                         QueryNetworkResponse resp = new QueryNetworkResponse(networkStackId, null, networkStackId, null, null);
 343                         Holder<Boolean> networkExists = new Holder<>();
 344             Holder<String> networkId = new Holder<>();
 345             Holder<String> neutronNetworkId = new Holder<>();
 346             Holder<NetworkStatus> status = new Holder<>();
 347             Holder<List<String>> routeTargets = new Holder<>();
 348             Holder<Map<String, String>> subnetIdMap = new Holder<>();
 349
 350                         adapter.queryNetworkContrail(cloudSiteId,  tenantId, aaiNetworkId,  msoRequest,
 351                                 networkExists, networkId, neutronNetworkId, status, routeTargets, subnetIdMap);
 352
 353                         if (!networkExists.value) {
 354                                 LOGGER.debug ("network not found");
 355                                 respStatus = HttpStatus.SC_NOT_FOUND;
 356                         } else {
 357                                 LOGGER.debug ("network found" + networkId.value + ", status=" + status.value);
 358                                 resp.setNetworkExists(networkExists.value);
 359                                 resp.setNetworkId(networkId.value);
 360                                 resp.setNeutronNetworkId(neutronNetworkId.value);
 361                                 resp.setNetworkStatus(status.value);
 362                                 resp.setRouteTargets(routeTargets.value);
 363                                 resp.setSubnetIdMap(subnetIdMap.value);
 364                         }
 365                         LOGGER.debug ("Query network exit");
 366                         return Response
 367                                 .status(respStatus)
 368                                 .entity(new GenericEntity<QueryNetworkResponse>(resp) {})
 369                                 .build();
 370                 } catch (NetworkException e) {
 371                         LOGGER.error (MessageEnum.RA_QUERY_VNF_ERR, aaiNetworkId, "", "", MsoLogger.ErrorCode.BusinessProcesssError, "Exception when query VNF", e);
 372                         QueryNetworkError err = new QueryNetworkError();
 373                         err.setMessage(e.getMessage());
 374                         err.setCategory(MsoExceptionCategory.INTERNAL);
 375                         return Response
 376                                 .status(HttpStatus.SC_INTERNAL_SERVER_ERROR)
 377                                 .entity(new GenericEntity<QueryNetworkError>(err) {})
 378                                 .build();
 379                 }
 380         }
 381
 382         @DELETE
 383         @Path("{aaiNetworkId}/rollback")
 384         @Consumes({ MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON })
 385         @Produces({ MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON })
 386         public Response rollbackNetwork(
 387                 RollbackNetworkRequest req)
 388         {
 389                 LOGGER.debug("rollbackNetwork enter: " + req.toJsonString());
 390                 RollbackNetworkTask task = new RollbackNetworkTask(req);
 391                 if (req.isSynchronous()) {
 392                         // This is a synchronous request
 393                         task.run();
 394                         return Response
 395                                 .status(task.getStatusCode())
 396                                 .entity(task.getGenericEntityResponse())
 397                                 .build();
 398                 } else {
 399                         // This is an asynchronous request
 400                         try {
 401                                 Thread t1 = new Thread(task);
 402                                 t1.start();
 403                         } catch (Exception e) {
 404                                 // problem handling create, send generic failure as sync resp to caller
 405                                 LOGGER.error (MessageEnum.RA_ROLLBACK_NULL, "", "", MsoLogger.ErrorCode.BusinessProcesssError, "Exception in rollbackNetwork", e);
 406                                 return Response.serverError().build();
 407                         }
 408                         // send sync response (ACK) to caller
 409                         LOGGER.debug("rollbackNetwork exit");
 410                         return Response.status(HttpStatus.SC_ACCEPTED).build();
 411                 }
 412         }
 413
 414         public class RollbackNetworkTask implements Runnable {
 415                 private final RollbackNetworkRequest req;
 416                 private RollbackNetworkResponse response = null;
 417                 private RollbackNetworkError eresp = null;
 418                 private boolean sendxml;
 419
 420                 public RollbackNetworkTask(RollbackNetworkRequest req) {
 421                         this.req = req;
 422                         this.sendxml = true; // can be set with a field or header later
 423                 }
 424                 public int getStatusCode() {
 425                         return (response != null) ? HttpStatus.SC_OK : HttpStatus.SC_BAD_REQUEST;
 426                 }
 427                 public Object getGenericEntityResponse() {
 428                         return (response != null)
 429                                 ? new GenericEntity<RollbackNetworkResponse>(response) {}
 430                                 : new GenericEntity<RollbackNetworkError>(eresp) {};
 431                 }
 432                 private String getResponse() {
 433                         if (response != null) {
 434                                 return sendxml ? response.toXmlString() : response.toJsonString();
 435                         } else {
 436                                 return sendxml ? eresp.toXmlString() : eresp.toJsonString();
 437                         }
 438                 }
 439                 @Override
 440                 public void run() {
 441                         LOGGER.debug("RollbackNetworkTask start");
 442                         try {
 443                                 NetworkRollback nwr = req.getNetworkRollback();
 444                                 adapter.rollbackNetwork(nwr);
 445                                 response = new RollbackNetworkResponse(true, req.getMessageId());
 446                         } catch (NetworkException e) {
 447                             LOGGER.debug ("Exception:", e);
 448                                 eresp = new RollbackNetworkError(e.getMessage(), MsoExceptionCategory.INTERNAL, true, req.getMessageId());
 449                         }
 450                         if (!req.isSynchronous()) {
 451                                 // This is asynch, so POST response back to caller
 452                                 BpelRestClient bpelClient = new BpelRestClient();
 453                                 bpelClient.bpelPost(getResponse(), req.getNotificationUrl(), sendxml);
 454                         }
 455                         LOGGER.debug("RollbackNetworkTask exit: code=" + getStatusCode() + ", resp="+ getResponse());
 456                 }
 457         }
 458
 459         @PUT
 460         @Path("{aaiNetworkId}")
 461         @Consumes({ MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON })
 462         @Produces({ MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON })
 463         public Response updateNetwork(
 464                 @PathParam("aaiNetworkId") String aaiNetworkId,
 465                 UpdateNetworkRequest req)
 466         {
 467                 LOGGER.debug("updateNetwork enter: " + req.toJsonString());
 468                 if (aaiNetworkId == null || !aaiNetworkId.equals(req.getNetworkId())) {
 469                         return Response
 470                                 .status(HttpStatus.SC_BAD_REQUEST)
 471                                 .type(MediaType.TEXT_PLAIN)
 472                                 .entity("A&AI NetworkId in URL ("+aaiNetworkId+") does not match content ("+req.getNetworkId()+")")
 473                                 .build();
 474                 }
 475                 UpdateNetworkTask task = new UpdateNetworkTask(req);
 476                 if (req.isSynchronous()) {
 477                         // This is a synchronous request
 478                         task.run();
 479                         return Response
 480                                 .status(task.getStatusCode())
 481                                 .entity(task.getGenericEntityResponse())
 482                                 .build();
 483                 } else {
 484                         // This is an asynchronous request
 485                 try {
 486                         Thread t1 = new Thread(task);
 487                         t1.start();
 488                 } catch (Exception e) {
 489                         // problem handling create, send generic failure as sync resp to caller
 490                         LOGGER.error (MessageEnum.RA_UPDATE_NETWORK_ERR, "", "", MsoLogger.ErrorCode.BusinessProcesssError, "Exception in updateNetwork", e);
 491                         return Response.serverError().build();
 492                 }
 493                 // send sync response (ACK) to caller
 494                 LOGGER.debug ("updateNetwork exit");
 495                 return Response.status(HttpStatus.SC_ACCEPTED).build();
 496                 }
 497         }
 498
 499         public class UpdateNetworkTask implements Runnable {
 500                 private final UpdateNetworkRequest req;
 501                 private UpdateNetworkResponse response = null;
 502                 private UpdateNetworkError eresp = null;
 503                 private boolean sendxml;
 504
 505                 public UpdateNetworkTask(UpdateNetworkRequest req) {
 506                         this.req = req;
 507                         this.sendxml = true; // can be set with a field or header later
 508                 }
 509                 public int getStatusCode() {
 510                         return (response != null) ? HttpStatus.SC_OK : HttpStatus.SC_BAD_REQUEST;
 511                 }
 512                 public Object getGenericEntityResponse() {
 513                         return (response != null)
 514                                 ? new GenericEntity<UpdateNetworkResponse>(response) {}
 515                                 : new GenericEntity<UpdateNetworkError>(eresp) {};
 516                 }
 517                 private String getResponse() {
 518                         if (response != null) {
 519                                 return sendxml ? response.toXmlString() : response.toJsonString();
 520                         } else {
 521                                 return sendxml ? eresp.toXmlString() : eresp.toJsonString();
 522                         }
 523                 }
 524                 @Override
 525                 public void run() {
 526                         LOGGER.debug("UpdateNetworkTask start");
 527                         try {
 528                                 Holder<Map<String, String>> subnetIdMap = new Holder<>();
 529                                 Holder<NetworkRollback> rollback = new Holder<> ();
 530
 531                                 if (req.getCloudSiteId().equals(TESTING_KEYWORD)) {
 532                                         subnetIdMap.value = testMap();
 533                                 NetworkRollback rb = new NetworkRollback ();
 534                                 rb.setCloudId(req.getCloudSiteId());
 535                                 rb.setTenantId(req.getTenantId());
 536                                 rb.setMsoRequest(req.getMsoRequest());
 537                                 rollback.value = rb;
 538                                 } else if (req.isContrailRequest()) {
 539                                         ContrailNetwork ctn = req.getContrailNetwork();
 540                                         if (ctn == null) {
 541                                                 ctn = new ContrailNetwork();
 542                                                 req.setContrailNetwork(ctn);
 543                                         }
 544                                         adapter.updateNetworkContrail(
 545                                                 req.getCloudSiteId(),
 546                                                 req.getTenantId(),
 547                                                 req.getNetworkType(),
 548                                                 req.getModelCustomizationUuid(),
 549                                                 req.getNetworkStackId(),
 550                                                 req.getNetworkName(),
 551                                                 req.getContrailNetwork().getRouteTargets(),
 552                             req.getContrailNetwork().getShared(),
 553                             req.getContrailNetwork().getExternal(),
 554                             req.getSubnets(),
 555                             req.getContrailNetwork().getPolicyFqdns(),
 556                             req.getContrailNetwork().getRouteTableFqdns(),
 557                             req.getMsoRequest(),
 558                             subnetIdMap,
 559                             rollback);
 560                                 } else {
 561                                         ProviderVlanNetwork pvn = req.getProviderVlanNetwork();
 562                                         if (pvn == null) {
 563                                                 pvn = new ProviderVlanNetwork();
 564                                                 req.setProviderVlanNetwork(pvn);
 565                                         }
 566                                         adapter.updateNetwork(
 567                                                 req.getCloudSiteId(),
 568                                                 req.getTenantId(),
 569                                                 req.getNetworkType(),
 570                                                 req.getModelCustomizationUuid(),
 571                                                 req.getNetworkStackId(),
 572                                                 req.getNetworkName(),
 573                                                 req.getProviderVlanNetwork().getPhysicalNetworkName(),
 574                                                 req.getProviderVlanNetwork().getVlans(),
 575                                                 req.getSubnets(),
 576                                                 req.getMsoRequest(),
 577                                                 subnetIdMap,
 578                                                 rollback);
 579                                 }
 580                                 response = new UpdateNetworkResponse(
 581                                         req.getNetworkId(),
 582                                         null,   // NeutronNetworkId is not available from an update
 583                                         subnetIdMap.value,
 584                                         req.getMessageId());
 585                         } catch (NetworkException e) {
 586                             LOGGER.debug ("Exception:", e);
 587                                 eresp = new UpdateNetworkError(e.getMessage(), MsoExceptionCategory.INTERNAL, true, req.getMessageId());
 588                         }
 589                         if (!req.isSynchronous()) {
 590                                 // This is asynch, so POST response back to caller
 591                                 BpelRestClient bpelClient = new BpelRestClient();
 592                                 bpelClient.bpelPost(getResponse(), req.getNotificationUrl(), sendxml);
 593                         }
 594                         LOGGER.debug("UpdateNetworkTask exit: code=" + getStatusCode() + ", resp="+ getResponse());
 595                 }
 596         }
 597
 598         public static Map<String, String> testMap() {
 599                 Map<String, String> m = new HashMap<>();
 600                 m.put("mickey", "7");
 601                 m.put("clyde", "10");
 602                 m.put("wayne", "99");
 603                 return m;
 604     }
 605 }