adapters/mso-network-adapter/src/main/java/org/openecomp/mso/adapters/network/NetworkAdapterRest.java

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