2 * ============LICENSE_START=======================================================
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
12 * http://www.apache.org/licenses/LICENSE-2.0
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=========================================================
22 package org.onap.so.adapters.network;
25 import java.util.HashMap;
26 import java.util.List;
29 import javax.inject.Provider;
30 import javax.ws.rs.Consumes;
31 import javax.ws.rs.DELETE;
32 import javax.ws.rs.GET;
33 import javax.ws.rs.POST;
34 import javax.ws.rs.PUT;
35 import javax.ws.rs.Path;
36 import javax.ws.rs.PathParam;
37 import javax.ws.rs.Produces;
38 import javax.ws.rs.QueryParam;
39 import javax.ws.rs.core.GenericEntity;
40 import javax.ws.rs.core.MediaType;
41 import javax.ws.rs.core.Response;
42 import javax.xml.ws.Holder;
44 import org.apache.http.HttpStatus;
45 import org.onap.so.adapters.network.exceptions.NetworkException;
46 import org.onap.so.adapters.nwrest.ContrailNetwork;
47 import org.onap.so.adapters.nwrest.CreateNetworkError;
48 import org.onap.so.adapters.nwrest.CreateNetworkRequest;
49 import org.onap.so.adapters.nwrest.CreateNetworkResponse;
50 import org.onap.so.adapters.nwrest.DeleteNetworkError;
51 import org.onap.so.adapters.nwrest.DeleteNetworkRequest;
52 import org.onap.so.adapters.nwrest.DeleteNetworkResponse;
53 import org.onap.so.adapters.nwrest.ProviderVlanNetwork;
54 import org.onap.so.adapters.nwrest.QueryNetworkError;
55 import org.onap.so.adapters.nwrest.QueryNetworkResponse;
56 import org.onap.so.adapters.nwrest.RollbackNetworkError;
57 import org.onap.so.adapters.nwrest.RollbackNetworkRequest;
58 import org.onap.so.adapters.nwrest.RollbackNetworkResponse;
59 import org.onap.so.adapters.nwrest.UpdateNetworkError;
60 import org.onap.so.adapters.nwrest.UpdateNetworkRequest;
61 import org.onap.so.adapters.nwrest.UpdateNetworkResponse;
62 import org.onap.so.entity.MsoRequest;
63 import org.onap.so.logger.MessageEnum;
64 import org.onap.so.logger.MsoLogger;
65 import org.onap.so.openstack.beans.NetworkRollback;
66 import org.onap.so.openstack.beans.NetworkStatus;
67 import org.onap.so.openstack.beans.RouteTarget;
68 import org.onap.so.openstack.exceptions.MsoExceptionCategory;
69 import org.springframework.beans.factory.annotation.Autowired;
70 import org.springframework.beans.factory.annotation.Qualifier;
71 import org.springframework.stereotype.Component;
72 import org.springframework.transaction.annotation.Transactional;
74 import io.swagger.annotations.Api;
75 import io.swagger.annotations.ApiOperation;
76 import io.swagger.annotations.ApiParam;
77 import io.swagger.annotations.ApiResponse;
78 import io.swagger.annotations.ApiResponses;
81 @Api(value = "/v1/networks", description = "root of network adapters restful web service")
84 public class NetworkAdapterRest {
85 private static final MsoLogger LOGGER = MsoLogger.getMsoLogger (MsoLogger.Catalog.RA,NetworkAdapterRest.class);
86 private static final String TESTING_KEYWORD = "___TESTING___";
91 private MsoNetworkAdapterImpl adapter;
93 @Qualifier("NetworkBpel")
94 private Provider<BpelRestClient> bpelRestClientProvider;
99 @Consumes({ MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON })
100 @Produces({ MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON })
101 @ApiOperation(value = "CreateNetwork",
102 response = Response.class,
103 notes = "Creates a new network, CreateNetworkRquest JSON is required")
105 @ApiResponse(code = 200, message = "network has been successfully created"),
106 @ApiResponse(code = 202, message = "create network request has been accepted (async only)"),
107 @ApiResponse(code = 500, message = "create network failed, examine entity object for details") })
108 public Response createNetwork(
109 @ApiParam(value = "details of network being created", required = true)
110 CreateNetworkRequest req) {
111 LOGGER.debug("createNetwork enter: " + req.toJsonString());
112 CreateNetworkTask task = new CreateNetworkTask(req);
113 if (req.isSynchronous()) {
114 // This is a synchronous request
117 .status(task.getStatusCode())
118 .entity(task.getGenericEntityResponse())
121 // This is an asynchronous request
123 Thread t1 = new Thread(task);
125 } catch (Exception e) {
126 // problem handling create, send generic failure as sync resp to caller
127 LOGGER.error (MessageEnum.RA_CREATE_NETWORK_EXC, "", "", MsoLogger.ErrorCode.BusinessProcesssError, "Exception while create network", e);
128 return Response.serverError().build();
130 // send sync response (ACK) to caller
131 LOGGER.debug ("createNetwork exit");
132 return Response.status(HttpStatus.SC_ACCEPTED).build();
136 public class CreateNetworkTask implements Runnable {
137 private final CreateNetworkRequest req;
138 private CreateNetworkResponse response = null;
139 private CreateNetworkError eresp = null;
140 private boolean sendxml;
142 public CreateNetworkTask(CreateNetworkRequest req) {
144 this.sendxml = true; // can be set with a field or header later
146 public int getStatusCode() {
147 return (response != null) ? HttpStatus.SC_OK : HttpStatus.SC_BAD_REQUEST;
149 public Object getGenericEntityResponse() {
150 return (response != null)
151 ? new GenericEntity<CreateNetworkResponse>(response) {}
152 : new GenericEntity<CreateNetworkError>(eresp) {};
154 private String getResponse() {
155 if (response != null) {
156 return sendxml ? response.toXmlString() : response.toJsonString();
158 return sendxml ? eresp.toXmlString() : eresp.toJsonString();
163 LOGGER.debug ("CreateNetworkTask start");
165 // Synchronous Web Service Outputs
166 Holder<String> networkId = new Holder<>();
167 Holder<String> neutronNetworkId = new Holder<>();
168 Holder<String> networkFqdn = new Holder<>();
169 Holder<Map<String, String>> subnetIdMap = new Holder<>();
170 Holder<NetworkRollback> rollback = new Holder<>();
172 String cloudsite = req.getCloudSiteId();
173 if (cloudsite != null && cloudsite.equals(TESTING_KEYWORD)) {
174 String tenant = req.getTenantId();
175 if (tenant != null && tenant.equals(TESTING_KEYWORD)) {
176 throw new NetworkException("testing.");
178 networkId.value = "479D3D8B-6360-47BC-AB75-21CC91981484";
179 neutronNetworkId.value = "55e55884-28fa-11e6-8971-0017f20fe1b8";
180 networkFqdn.value = "086f70b6-28fb-11e6-8260-0017f20fe1b8";
181 subnetIdMap.value = testMap();
182 rollback.value = new NetworkRollback();
183 } else if (req.isContrailRequest()) {
184 ContrailNetwork ctn = req.getContrailNetwork();
186 ctn = new ContrailNetwork();
187 req.setContrailNetwork(ctn);
189 adapter.createNetworkContrail(
190 req.getCloudSiteId(),
192 req.getNetworkType(),
193 req.getModelCustomizationUuid(),
194 req.getNetworkName(),
195 req.getContrailNetwork().getRouteTargets(),
196 req.getContrailNetwork().getShared(),
197 req.getContrailNetwork().getExternal(),
198 req.getFailIfExists(),
201 req.getContrailNetwork().getPolicyFqdns(),
202 req.getContrailNetwork().getRouteTableFqdns(),
210 ProviderVlanNetwork pvn = req.getProviderVlanNetwork();
212 pvn = new ProviderVlanNetwork();
213 req.setProviderVlanNetwork(pvn);
215 adapter.createNetwork(
216 req.getCloudSiteId(),
218 req.getNetworkType(),
219 req.getModelCustomizationUuid(),
220 req.getNetworkName(),
221 req.getProviderVlanNetwork().getPhysicalNetworkName(),
222 req.getProviderVlanNetwork().getVlans(),
223 req.getFailIfExists(),
232 response = new CreateNetworkResponse(
234 neutronNetworkId.value,
235 rollback.value.getNetworkStackId(),
237 rollback.value.getNetworkCreated(),
241 } catch (NetworkException e) {
242 LOGGER.debug ("Exception:", e);
243 eresp = new CreateNetworkError(
244 e.getMessage(), MsoExceptionCategory.INTERNAL, true, req.getMessageId());
246 if (!req.isSynchronous()) {
247 // This is asynch, so POST response back to caller
248 BpelRestClient bpelClient = bpelRestClientProvider.get();
249 bpelClient.bpelPost(getResponse(), req.getNotificationUrl(), sendxml);
251 LOGGER.debug ("CreateNetworkTask exit: code=" + getStatusCode() + ", resp="+ getResponse());
256 @Path("{aaiNetworkId}")
257 @Consumes({ MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON })
258 @Produces({ MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON })
259 @ApiOperation(value = "DeleteNetwork",
260 response = Response.class,
261 notes = "Deletes an existing network, aaiNetworkId and DeleteNetworkRequest JSON are required")
263 @ApiResponse(code = 200, message = "network has been successfully deleted"),
264 @ApiResponse(code = 202, message = "request to delete network has been accepted (async only)"),
265 @ApiResponse(code = 500, message = "delete network failed, examine entity object for details") })
266 public Response deleteNetwork(
267 @ApiParam(value = "aaiNetworkId to be deleted ", required = true)
268 @PathParam("aaiNetworkId") String aaiNetworkId,
269 @ApiParam(value = "details of network being deleted", required = true)
270 DeleteNetworkRequest req)
272 LOGGER.debug("deleteNetwork enter: " + req.toJsonString());
273 if (aaiNetworkId == null || !aaiNetworkId.equals(req.getNetworkId())) {
275 .status(HttpStatus.SC_BAD_REQUEST)
276 .type(MediaType.TEXT_PLAIN)
277 .entity("A&AI NetworkId in URL ("+aaiNetworkId+") does not match content ("+req.getNetworkId()+")")
280 DeleteNetworkTask task = new DeleteNetworkTask(req);
281 if (req.isSynchronous()) {
282 // This is a synchronous request
285 .status(task.getStatusCode())
286 .entity(task.getGenericEntityResponse())
289 // This is an asynchronous request
291 Thread t1 = new Thread(task);
293 } catch (Exception e) {
294 // problem handling create, send generic failure as sync resp to caller
295 LOGGER.error (MessageEnum.RA_DELETE_NETWORK_EXC, "", "", MsoLogger.ErrorCode.BusinessProcesssError, "Exception while delete network", e);
296 return Response.serverError().build();
298 // send sync response (ACK) to caller
299 LOGGER.debug ("deleteNetwork exit");
300 return Response.status(HttpStatus.SC_ACCEPTED).build();
304 public class DeleteNetworkTask implements Runnable {
305 private final DeleteNetworkRequest req;
306 private DeleteNetworkResponse response = null;
307 private DeleteNetworkError eresp = null;
308 private boolean sendxml;
310 public DeleteNetworkTask(DeleteNetworkRequest req) {
312 this.sendxml = true; // can be set with a field or header later
314 public int getStatusCode() {
315 return (response != null) ? HttpStatus.SC_OK : HttpStatus.SC_BAD_REQUEST;
317 public Object getGenericEntityResponse() {
318 return (response != null)
319 ? new GenericEntity<DeleteNetworkResponse>(response) {}
320 : new GenericEntity<DeleteNetworkError>(eresp) {};
322 private String getResponse() {
323 if (response != null) {
324 return sendxml ? response.toXmlString() : response.toJsonString();
326 return sendxml ? eresp.toXmlString() : eresp.toJsonString();
331 LOGGER.debug("DeleteNetworkTask start");
333 Holder<Boolean> networkDeleted = new Holder<>();
334 if (req.getCloudSiteId().equals(TESTING_KEYWORD)) {
335 networkDeleted.value = true;
337 adapter.deleteNetwork(
338 req.getCloudSiteId(),
340 req.getNetworkType(),
341 req.getModelCustomizationUuid(),
342 req.getNetworkStackId(),
346 response = new DeleteNetworkResponse(req.getNetworkId(), networkDeleted.value, req.getMessageId());
347 } catch (NetworkException e) {
348 LOGGER.debug ("Exception:", e);
349 eresp = new DeleteNetworkError(e.getMessage(), MsoExceptionCategory.INTERNAL, true, req.getMessageId());
351 if (!req.isSynchronous()) {
352 // This is asynch, so POST response back to caller
353 BpelRestClient bpelClient = bpelRestClientProvider.get();
354 bpelClient.bpelPost(getResponse(), req.getNotificationUrl(), sendxml);
356 LOGGER.debug("DeleteNetworkTask exit: code=" + getStatusCode() + ", resp="+ getResponse());
361 @Path("{aaiNetworkId}")
362 @Produces({ MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON })
363 @ApiOperation(value = "QueryNetwork",
364 response = Response.class,
365 notes = "Queries an existing network")
367 @ApiResponse(code = 200, message = "Query network successful"),
368 @ApiResponse(code = 500, message = "Query network failed, examine entity object for details") })
369 public Response queryNetwork(
370 @ApiParam(value = "cloudSiteId", required = false)
371 @QueryParam("cloudSiteId") String cloudSiteId,
372 @ApiParam(value = "tenantId", required = false)
373 @QueryParam("tenantId") String tenantId,
374 @ApiParam(value = "networkStackId", required = false)
375 @QueryParam("networkStackId") String networkStackId,
376 @ApiParam(value = "skipAAI", required = false)
377 @QueryParam("skipAAI") String skipAAI,
378 @ApiParam(value = "msoRequest.requestId", required = false)
379 @QueryParam("msoRequest.requestId") String requestId,
380 @ApiParam(value = "msoRequest.serviceInstanceId", required = false)
381 @QueryParam("msoRequest.serviceInstanceId") String serviceInstanceId,
382 @ApiParam(value = "aaiNetworkId", required = false)
383 @PathParam("aaiNetworkId") String aaiNetworkId)
385 //This request responds synchronously only
386 LOGGER.debug ("Query network enter:" + aaiNetworkId);
387 MsoRequest msoRequest = new MsoRequest(requestId, serviceInstanceId);
390 int respStatus = HttpStatus.SC_OK;
391 QueryNetworkResponse resp = new QueryNetworkResponse(networkStackId, null, networkStackId, null, null);
392 Holder<Boolean> networkExists = new Holder<>();
393 Holder<String> networkId = new Holder<>();
394 Holder<String> neutronNetworkId = new Holder<>();
395 Holder<NetworkStatus> status = new Holder<>();
396 Holder<List<RouteTarget>> routeTargets = new Holder<>();
397 Holder<Map<String, String>> subnetIdMap = new Holder<>();
399 adapter.queryNetworkContrail(cloudSiteId, tenantId, aaiNetworkId, msoRequest,
400 networkExists, networkId, neutronNetworkId, status, routeTargets, subnetIdMap);
402 if (!networkExists.value) {
403 LOGGER.debug ("network not found");
404 respStatus = HttpStatus.SC_NOT_FOUND;
406 LOGGER.debug ("network found" + networkId.value + ", status=" + status.value);
407 resp.setNetworkExists(networkExists.value);
408 resp.setNetworkId(networkId.value);
409 resp.setNeutronNetworkId(neutronNetworkId.value);
410 resp.setNetworkStatus(status.value);
411 resp.setRouteTargets(routeTargets.value);
412 resp.setSubnetIdMap(subnetIdMap.value);
414 LOGGER.debug ("Query network exit");
417 .entity(new GenericEntity<QueryNetworkResponse>(resp) {})
419 } catch (NetworkException e) {
420 LOGGER.error (MessageEnum.RA_QUERY_VNF_ERR, aaiNetworkId, "", "", MsoLogger.ErrorCode.BusinessProcesssError, "Exception when query VNF", e);
421 QueryNetworkError err = new QueryNetworkError();
422 err.setMessage(e.getMessage());
423 err.setCategory(MsoExceptionCategory.INTERNAL);
425 .status(HttpStatus.SC_INTERNAL_SERVER_ERROR)
426 .entity(new GenericEntity<QueryNetworkError>(err) {})
432 @Path("{aaiNetworkId}/rollback")
433 @Consumes({ MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON })
434 @Produces({ MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON })
435 @ApiOperation(value = "RollbackNetwork",
436 response = Response.class,
437 notes = "Rollback an existing network")
439 @ApiResponse(code = 200, message = "Rollback network successful"),
440 @ApiResponse(code = 202, message = "Rollback network request has been accepted (async only)"),
441 @ApiResponse(code = 500, message = "Rollback network failed, examine entity object for details") })
442 public Response rollbackNetwork(
443 @ApiParam(value = "RollbackNetworkRequest in JSON format", required = true)
444 RollbackNetworkRequest req)
446 LOGGER.debug("rollbackNetwork enter: " + req.toJsonString());
447 RollbackNetworkTask task = new RollbackNetworkTask(req);
448 if (req.isSynchronous()) {
449 // This is a synchronous request
452 .status(task.getStatusCode())
453 .entity(task.getGenericEntityResponse())
456 // This is an asynchronous request
458 Thread t1 = new Thread(task);
460 } catch (Exception e) {
461 // problem handling create, send generic failure as sync resp to caller
462 LOGGER.error (MessageEnum.RA_ROLLBACK_NULL, "", "", MsoLogger.ErrorCode.BusinessProcesssError, "Exception in rollbackNetwork", e);
463 return Response.serverError().build();
465 // send sync response (ACK) to caller
466 LOGGER.debug("rollbackNetwork exit");
467 return Response.status(HttpStatus.SC_ACCEPTED).build();
471 public class RollbackNetworkTask implements Runnable {
472 private final RollbackNetworkRequest req;
473 private RollbackNetworkResponse response = null;
474 private RollbackNetworkError eresp = null;
475 private boolean sendxml;
477 public RollbackNetworkTask(RollbackNetworkRequest req) {
479 this.sendxml = true; // can be set with a field or header later
481 public int getStatusCode() {
482 return (response != null) ? HttpStatus.SC_OK : HttpStatus.SC_BAD_REQUEST;
484 public Object getGenericEntityResponse() {
485 return (response != null)
486 ? new GenericEntity<RollbackNetworkResponse>(response) {}
487 : new GenericEntity<RollbackNetworkError>(eresp) {};
489 private String getResponse() {
490 if (response != null) {
491 return sendxml ? response.toXmlString() : response.toJsonString();
493 return sendxml ? eresp.toXmlString() : eresp.toJsonString();
498 LOGGER.debug("RollbackNetworkTask start");
500 NetworkRollback nwr = req.getNetworkRollback();
501 adapter.rollbackNetwork(nwr);
502 response = new RollbackNetworkResponse(true, req.getMessageId());
503 } catch (NetworkException e) {
504 LOGGER.debug ("Exception:", e);
505 eresp = new RollbackNetworkError(e.getMessage(), MsoExceptionCategory.INTERNAL, true, req.getMessageId());
507 if (!req.isSynchronous()) {
508 // This is asynch, so POST response back to caller
509 BpelRestClient bpelClient = bpelRestClientProvider.get();
510 bpelClient.bpelPost(getResponse(), req.getNotificationUrl(), sendxml);
512 LOGGER.debug("RollbackNetworkTask exit: code=" + getStatusCode() + ", resp="+ getResponse());
517 @Path("{aaiNetworkId}")
518 @Consumes({ MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON })
519 @Produces({ MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON })
520 @ApiOperation(value = "UpdateNetwork",
521 response = Response.class,
522 notes = "Update an existing network")
524 @ApiResponse(code = 200, message = "Update network successful"),
525 @ApiResponse(code = 202, message = "Update network request has been accepted (async only)"),
526 @ApiResponse(code = 500, message = "Update network failed, examine entity object for details") })
527 public Response updateNetwork(
528 @ApiParam(value = "aaiNetworkId", required = true)
529 @PathParam("aaiNetworkId") String aaiNetworkId,
530 @ApiParam(value = "UpdateNetworkRequest in JSON format", required = true)
531 UpdateNetworkRequest req)
533 LOGGER.debug("updateNetwork enter: " + req.toJsonString());
534 if (aaiNetworkId == null || !aaiNetworkId.equals(req.getNetworkId())) {
536 .status(HttpStatus.SC_BAD_REQUEST)
537 .type(MediaType.TEXT_PLAIN)
538 .entity("A&AI NetworkId in URL ("+aaiNetworkId+") does not match content ("+req.getNetworkId()+")")
541 UpdateNetworkTask task = new UpdateNetworkTask(req);
542 if (req.isSynchronous()) {
543 // This is a synchronous request
546 .status(task.getStatusCode())
547 .entity(task.getGenericEntityResponse())
550 // This is an asynchronous request
552 Thread t1 = new Thread(task);
554 } catch (Exception e) {
555 // problem handling create, send generic failure as sync resp to caller
556 LOGGER.error (MessageEnum.RA_UPDATE_NETWORK_ERR, "", "", MsoLogger.ErrorCode.BusinessProcesssError, "Exception in updateNetwork", e);
557 return Response.serverError().build();
559 // send sync response (ACK) to caller
560 LOGGER.debug ("updateNetwork exit");
561 return Response.status(HttpStatus.SC_ACCEPTED).build();
565 public class UpdateNetworkTask implements Runnable {
566 private final UpdateNetworkRequest req;
567 private UpdateNetworkResponse response = null;
568 private UpdateNetworkError eresp = null;
569 private boolean sendxml;
571 public UpdateNetworkTask(UpdateNetworkRequest req) {
573 this.sendxml = true; // can be set with a field or header later
575 public int getStatusCode() {
576 return (response != null) ? HttpStatus.SC_OK : HttpStatus.SC_BAD_REQUEST;
578 public Object getGenericEntityResponse() {
579 return (response != null)
580 ? new GenericEntity<UpdateNetworkResponse>(response) {}
581 : new GenericEntity<UpdateNetworkError>(eresp) {};
583 private String getResponse() {
584 if (response != null) {
585 return sendxml ? response.toXmlString() : response.toJsonString();
587 return sendxml ? eresp.toXmlString() : eresp.toJsonString();
592 LOGGER.debug("UpdateNetworkTask start");
594 Holder<Map<String, String>> subnetIdMap = new Holder<>();
595 Holder<NetworkRollback> rollback = new Holder<> ();
597 if (req.getCloudSiteId().equals(TESTING_KEYWORD)) {
598 subnetIdMap.value = testMap();
599 NetworkRollback rb = new NetworkRollback ();
600 rb.setCloudId(req.getCloudSiteId());
601 rb.setTenantId(req.getTenantId());
602 rb.setMsoRequest(req.getMsoRequest());
604 } else if (req.isContrailRequest()) {
605 ContrailNetwork ctn = req.getContrailNetwork();
607 ctn = new ContrailNetwork();
608 req.setContrailNetwork(ctn);
610 adapter.updateNetworkContrail(
611 req.getCloudSiteId(),
613 req.getNetworkType(),
614 req.getModelCustomizationUuid(),
615 req.getNetworkStackId(),
616 req.getNetworkName(),
617 req.getContrailNetwork().getRouteTargets(),
618 req.getContrailNetwork().getShared(),
619 req.getContrailNetwork().getExternal(),
621 req.getContrailNetwork().getPolicyFqdns(),
622 req.getContrailNetwork().getRouteTableFqdns(),
627 ProviderVlanNetwork pvn = req.getProviderVlanNetwork();
629 pvn = new ProviderVlanNetwork();
630 req.setProviderVlanNetwork(pvn);
632 adapter.updateNetwork(
633 req.getCloudSiteId(),
635 req.getNetworkType(),
636 req.getModelCustomizationUuid(),
637 req.getNetworkStackId(),
638 req.getNetworkName(),
639 req.getProviderVlanNetwork().getPhysicalNetworkName(),
640 req.getProviderVlanNetwork().getVlans(),
646 response = new UpdateNetworkResponse(
648 null, // NeutronNetworkId is not available from an update
651 } catch (NetworkException e) {
652 LOGGER.debug ("Exception:", e);
653 eresp = new UpdateNetworkError(e.getMessage(), MsoExceptionCategory.INTERNAL, true, req.getMessageId());
655 if (!req.isSynchronous()) {
656 // This is asynch, so POST response back to caller
657 BpelRestClient bpelClient = bpelRestClientProvider.get();
658 bpelClient.bpelPost(getResponse(), req.getNotificationUrl(), sendxml);
660 LOGGER.debug("UpdateNetworkTask exit: code=" + getStatusCode() + ", resp="+ getResponse());
664 public static Map<String, String> testMap() {
665 Map<String, String> m = new HashMap<>();
666 m.put("mickey", "7");
667 m.put("clyde", "10");
668 m.put("wayne", "99");