1 package org.onap.sdnc.northbound;
3 import java.text.DateFormat;
4 import java.text.SimpleDateFormat;
6 import java.util.Properties;
7 import java.util.TimeZone;
8 import java.util.concurrent.ExecutionException;
9 import java.util.concurrent.ExecutorService;
10 import java.util.concurrent.Executors;
11 import java.util.concurrent.Future;
13 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
14 import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
15 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
16 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
17 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
18 import org.opendaylight.controller.md.sal.common.api.data.OptimisticLockFailedException;
19 import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
20 import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
21 import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
22 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.BrgTopologyOperationInput;
23 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.BrgTopologyOperationInputBuilder;
24 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.BrgTopologyOperationOutput;
25 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.BrgTopologyOperationOutputBuilder;
26 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ContrailRouteTopologyOperationInput;
27 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ContrailRouteTopologyOperationInputBuilder;
28 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ContrailRouteTopologyOperationOutput;
29 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ContrailRouteTopologyOperationOutputBuilder;
30 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.GENERICRESOURCEAPIService;
31 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.NetworkTopologyOperationInput;
32 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.NetworkTopologyOperationInputBuilder;
33 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.NetworkTopologyOperationOutput;
34 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.NetworkTopologyOperationOutputBuilder;
35 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadNetworkTopologyOperationInput;
36 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadNetworkTopologyOperationInputBuilder;
37 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadNetworkTopologyOperationOutput;
38 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadNetworkTopologyOperationOutputBuilder;
39 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadVnfTopologyOperationInput;
40 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadVnfTopologyOperationInputBuilder;
41 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadVnfTopologyOperationOutput;
42 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadVnfTopologyOperationOutputBuilder;
43 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadVnfs;
44 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadVnfsBuilder;
45 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.SecurityZoneTopologyOperationInput;
46 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.SecurityZoneTopologyOperationInputBuilder;
47 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.SecurityZoneTopologyOperationOutput;
48 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.SecurityZoneTopologyOperationOutputBuilder;
49 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ServiceTopologyOperationInput;
50 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ServiceTopologyOperationInputBuilder;
51 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ServiceTopologyOperationOutput;
52 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ServiceTopologyOperationOutputBuilder;
53 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.Services;
54 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ServicesBuilder;
55 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.TunnelxconnTopologyOperationInput;
56 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.TunnelxconnTopologyOperationInputBuilder;
57 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.TunnelxconnTopologyOperationOutput;
58 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.TunnelxconnTopologyOperationOutputBuilder;
59 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.VfModuleTopologyOperationInput;
60 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.VfModuleTopologyOperationInputBuilder;
61 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.VfModuleTopologyOperationOutput;
62 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.VfModuleTopologyOperationOutputBuilder;
63 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.VnfTopologyOperationInput;
64 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.VnfTopologyOperationInputBuilder;
65 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.VnfTopologyOperationOutput;
66 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.VnfTopologyOperationOutputBuilder;
67 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.brg.response.information.BrgResponseInformationBuilder;
68 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.contrail.route.response.information.ContrailRouteResponseInformationBuilder;
69 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.network.response.information.NetworkResponseInformationBuilder;
70 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.preload.data.PreloadData;
71 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.preload.data.PreloadDataBuilder;
72 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.preload.model.information.VnfPreloadList;
73 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.preload.model.information.VnfPreloadListBuilder;
74 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.preload.model.information.VnfPreloadListKey;
75 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.request.information.RequestInformation;
76 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.sdnc.request.header.SdncRequestHeader;
77 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.sdnc.request.header.SdncRequestHeader.SvcAction;
78 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.security.zone.response.information.SecurityZoneResponseInformationBuilder;
79 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.data.ServiceData;
80 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.data.ServiceDataBuilder;
81 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.model.infrastructure.Service;
82 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.model.infrastructure.ServiceBuilder;
83 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.model.infrastructure.ServiceKey;
84 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.response.information.ServiceResponseInformationBuilder;
85 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.status.ServiceStatus.RequestStatus;
86 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.status.ServiceStatus.RpcAction;
87 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.status.ServiceStatusBuilder;
88 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.tunnelxconn.response.information.TunnelxconnResponseInformationBuilder;
89 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
90 import org.opendaylight.yangtools.yang.common.RpcResult;
91 import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
92 import org.slf4j.Logger;
93 import org.slf4j.LoggerFactory;
95 import com.google.common.base.Optional;
96 import com.google.common.util.concurrent.CheckedFuture;
97 import com.google.common.util.concurrent.Futures;
98 import com.google.common.util.concurrent.SettableFuture;
101 * Defines a base implementation for your provider. This class extends from a
102 * helper class which provides storage for the most commonly used components of
103 * the MD-SAL. Additionally the base class provides some basic logging and
104 * initialization / clean up methods.
106 * To use this, copy and paste (overwrite) the following method into the
107 * TestApplicationProviderModule class which is auto generated under
108 * src/main/java in this project (created only once during first compilation):
113 * public java.lang.AutoCloseable createInstance() {
115 * // final GENERIC-RESOURCE-APIProvider provider = new
116 * // GENERIC-RESOURCE-APIProvider();
117 * final GenericResourceApiProvider provider = new GenericResourceApiProvider();
118 * provider.setDataBroker(getDataBrokerDependency());
119 * provider.setNotificationService(getNotificationServiceDependency());
120 * provider.setRpcRegistry(getRpcRegistryDependency());
121 * provider.initialize();
122 * return new AutoCloseable() {
125 * public void close() throws Exception {
126 * // TODO: CLOSE ANY REGISTRATION OBJECTS CREATED USING ABOVE
127 * // BROKER/NOTIFICATION
128 * // SERVIE/RPC REGISTRY
137 public class GenericResourceApiProvider implements AutoCloseable, GENERICRESOURCEAPIService {
139 private final Logger log = LoggerFactory.getLogger(GenericResourceApiProvider.class);
140 private final String appName = "generic-resource-api";
142 private final ExecutorService executor;
144 protected DataBroker dataBroker;
145 protected NotificationPublishService notificationService;
146 protected RpcProviderRegistry rpcRegistry;
147 protected BindingAwareBroker.RpcRegistration<GENERICRESOURCEAPIService> rpcRegistration;
149 private final GenericResourceApiSvcLogicServiceClient svcLogicClient;
151 public GenericResourceApiProvider(
152 DataBroker dataBroker,
153 NotificationPublishService notificationPublishService,
154 RpcProviderRegistry rpcProviderRegistry,
155 GenericResourceApiSvcLogicServiceClient client
157 log.info("Creating provider for {}", appName);
158 executor = Executors.newFixedThreadPool(1);
159 setDataBroker(dataBroker);
160 setNotificationService(notificationPublishService);
161 setRpcRegistry(rpcProviderRegistry);
162 svcLogicClient = client;
167 public void initialize() {
168 log.info("Initializing provider for {}", appName);
169 // Create the top level containers
172 GenericResourceApiUtil.loadProperties();
173 } catch (Exception e) {
174 log.error("Caught Exception while trying to load properties file");
177 log.info("Initialization complete for {}", appName);
180 protected void initializeChild() {
181 // Override if you have custom initialization intelligence
185 public void close() throws Exception {
186 log.info("Closing provider for {}", appName);
188 rpcRegistration.close();
189 log.info("Successfully closed provider for {}", appName);
192 private static class Iso8601Util {
193 private static TimeZone tz = TimeZone.getTimeZone("UTC");
194 private static DateFormat df = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'");
200 private static String now() {
201 return df.format(new Date());
205 public void setDataBroker(DataBroker dataBroker) {
206 this.dataBroker = dataBroker;
207 if (log.isDebugEnabled()) {
208 log.debug("DataBroker set to {}", (dataBroker == null ? "null" : "non-null"));
212 public void setNotificationService(NotificationPublishService notificationService) {
213 this.notificationService = notificationService;
214 if (log.isDebugEnabled()) {
215 log.debug("Notification Service set to {}", (notificationService == null ? "null" : "non-null"));
219 public void setRpcRegistry(RpcProviderRegistry rpcRegistry) {
220 this.rpcRegistry = rpcRegistry;
221 if (log.isDebugEnabled()) {
222 log.debug("RpcRegistry set to {}", (rpcRegistry == null ? "null" : "non-null"));
226 private void createContainers() {
228 final WriteTransaction t = dataBroker.newReadWriteTransaction();
230 // Create the service-instance container
231 t.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(Services.class),
232 new ServicesBuilder().build());
233 t.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(Services.class),
234 new ServicesBuilder().build());
236 // Create the PreloadVnfs container
237 t.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(PreloadVnfs.class),
238 new PreloadVnfsBuilder().build());
239 t.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(PreloadVnfs.class),
240 new PreloadVnfsBuilder().build());
243 CheckedFuture<Void, TransactionCommitFailedException> checkedFuture = t.submit();
245 log.info("Create containers succeeded!");
247 } catch (InterruptedException | ExecutionException e) {
248 log.error("Create containers failed: ", e);
252 private void setServiceStatus(ServiceStatusBuilder serviceStatusBuilder, String errorCode, String errorMessage,
254 serviceStatusBuilder.setResponseCode(errorCode);
255 serviceStatusBuilder.setResponseMessage(errorMessage);
256 serviceStatusBuilder.setFinalIndicator(ackFinal);
257 serviceStatusBuilder.setResponseTimestamp(Iso8601Util.now());
260 private void setServiceStatus(ServiceStatusBuilder serviceStatusBuilder, RequestInformation requestInformation) {
261 if (requestInformation != null && requestInformation.getRequestAction() != null) {
262 serviceStatusBuilder.setAction(requestInformation.getRequestAction().toString());
266 * if (requestInformation != null && requestInformation.getRequestSubAction() !=
267 * null) { switch (requestInformation.getRequestSubAction()) { case SUPP:
268 * serviceStatusBuilder.setVnfsdnSubaction(VnfsdnSubaction.SUPP); break; case
269 * CANCEL: serviceStatusBuilder.setVnfsdnSubaction(VnfsdnSubaction.CANCEL);
270 * break; default: log.error("Unknown RequestSubAction: " +
271 * requestInformation.getRequestSubAction() ); break; }; }
275 private void setServiceStatus(ServiceStatusBuilder serviceStatusBuilder, SdncRequestHeader requestHeader) {
276 if (requestHeader != null && requestHeader.getSvcAction() != null) {
277 switch (requestHeader.getSvcAction()) {
279 serviceStatusBuilder.setRpcAction(RpcAction.Assign);
282 serviceStatusBuilder.setRpcAction(RpcAction.Unassign);
285 serviceStatusBuilder.setRpcAction(RpcAction.Activate);
288 serviceStatusBuilder.setRpcAction(RpcAction.Deactivate);
291 serviceStatusBuilder.setRpcAction(RpcAction.Delete);
294 log.error("Unknown SvcAction: {}", requestHeader.getSvcAction());
300 private void getServiceData(String siid, ServiceDataBuilder serviceDataBuilder) {
302 getServiceData(siid, serviceDataBuilder, LogicalDatastoreType.CONFIGURATION);
305 private void getServiceData(String siid, ServiceDataBuilder serviceDataBuilder, LogicalDatastoreType type) {
306 // See if any data exists yet for this siid, if so grab it.
307 InstanceIdentifier serviceInstanceIdentifier = InstanceIdentifier.<Services>builder(Services.class)
308 .child(Service.class, new ServiceKey(siid)).build();
309 ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction();
310 Optional<Service> data = null;
312 data = (Optional<Service>) readTx.read(type, serviceInstanceIdentifier).get();
313 } catch (InterruptedException | ExecutionException e) {
314 log.error("Caught Exception reading MD-SAL ({}) data for [{}] ", type, siid, e);
317 if (data != null && data.isPresent()) {
318 ServiceData serviceData = data.get().getServiceData();
319 if (serviceData != null) {
320 log.info("Read MD-SAL ({}) data for [{}] ServiceData: {}", type, siid, serviceData);
321 serviceDataBuilder.setSdncRequestHeader(serviceData.getSdncRequestHeader());
322 serviceDataBuilder.setRequestInformation(serviceData.getRequestInformation());
323 serviceDataBuilder.setServiceInformation(serviceData.getServiceInformation());
324 serviceDataBuilder.setServiceRequestInput(serviceData.getServiceRequestInput());
325 serviceDataBuilder.setServiceTopology(serviceData.getServiceTopology());
326 serviceDataBuilder.setServiceLevelOperStatus(serviceData.getServiceLevelOperStatus());
327 serviceDataBuilder.setNetworks(serviceData.getNetworks());
328 serviceDataBuilder.setVnfs(serviceData.getVnfs());
329 serviceDataBuilder.setProvidedAllottedResources(serviceData.getProvidedAllottedResources());
330 serviceDataBuilder.setConsumedAllottedResources(serviceData.getConsumedAllottedResources());
331 // service-instance-id needs to be set
333 log.info("No service-data found in MD-SAL ({}) for [{}]", type, siid);
336 log.info("No data found in MD-SAL ({}) for [{}]", type, siid);
340 private void getPreloadData(String vnf_name, String vnf_type, PreloadDataBuilder preloadDataBuilder) {
342 getPreloadData(vnf_name, vnf_type, preloadDataBuilder, LogicalDatastoreType.CONFIGURATION);
345 private void getPreloadData(String preload_name, String preload_type, PreloadDataBuilder preloadDataBuilder,
346 LogicalDatastoreType type) {
347 // See if any data exists yet for this name/type, if so grab it.
348 InstanceIdentifier preloadInstanceIdentifier = InstanceIdentifier.<PreloadVnfs>builder(PreloadVnfs.class)
349 .child(VnfPreloadList.class, new VnfPreloadListKey(preload_name, preload_type)).build();
350 ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction();
351 Optional<VnfPreloadList> data = null;
353 data = (Optional<VnfPreloadList>) readTx.read(type, preloadInstanceIdentifier).get();
354 } catch (InterruptedException | ExecutionException e) {
355 log.error("Caught Exception reading MD-SAL ({}) for [{},{}] ", type, preload_name, preload_type, e);
358 if (data != null && data.isPresent()) {
359 PreloadData preloadData = data.get().getPreloadData();
360 if (preloadData != null) {
361 log.info("Read MD-SAL ({}) data for [{},{}] PreloadData: {}", type, preload_name, preload_type,
363 preloadDataBuilder.setVnfTopologyInformation(preloadData.getVnfTopologyInformation());
364 preloadDataBuilder.setNetworkTopologyInformation(preloadData.getNetworkTopologyInformation());
365 preloadDataBuilder.setOperStatus(preloadData.getOperStatus());
367 log.info("No preload-data found in MD-SAL ({}) for [{},{}] ", type, preload_name, preload_type);
370 log.info("No data found in MD-SAL ({}) for [{},{}] ", type, preload_name, preload_type);
374 private void saveService(final Service entry, boolean merge, LogicalDatastoreType storeType)
375 throws IllegalStateException {
376 // Each entry will be identifiable by a unique key, we have to create that
378 InstanceIdentifier.InstanceIdentifierBuilder<Service> serviceBuilder = InstanceIdentifier
379 .<Services>builder(Services.class).child(Service.class, entry.getKey());
380 InstanceIdentifier<Service> path = serviceBuilder.build();
385 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
387 tx.merge(storeType, path, entry);
389 tx.put(storeType, path, entry);
391 tx.submit().checkedGet();
392 log.debug("Update DataStore succeeded");
394 } catch (final TransactionCommitFailedException e) {
395 if (e instanceof OptimisticLockFailedException) {
397 log.debug("Got OptimisticLockFailedException on last try - failing ");
398 throw new IllegalStateException(e);
400 log.debug("Got OptimisticLockFailedException - trying again ");
402 log.debug("Update DataStore failed");
403 throw new IllegalStateException(e);
409 private void deleteService(final Service entry, LogicalDatastoreType storeType) throws IllegalStateException {
410 // Each entry will be identifiable by a unique key, we have to create
412 InstanceIdentifier.InstanceIdentifierBuilder<Service> serviceListIdBuilder = InstanceIdentifier
413 .<Services>builder(Services.class).child(Service.class, entry.getKey());
414 InstanceIdentifier<Service> path = serviceListIdBuilder.build();
419 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
420 tx.delete(storeType, path);
421 tx.submit().checkedGet();
422 log.debug("DataStore delete succeeded");
424 } catch (final TransactionCommitFailedException e) {
425 if (e instanceof OptimisticLockFailedException) {
427 log.debug("Got OptimisticLockFailedException on last try - failing ");
428 throw new IllegalStateException(e);
430 log.debug("Got OptimisticLockFailedException - trying again ");
432 log.debug("Update DataStore failed");
433 throw new IllegalStateException(e);
439 private void savePreloadList(final VnfPreloadList entry, boolean merge, LogicalDatastoreType storeType)
440 throws IllegalStateException {
442 // Each entry will be identifiable by a unique key, we have to create that
444 InstanceIdentifier.InstanceIdentifierBuilder<VnfPreloadList> vnfPreloadListBuilder = InstanceIdentifier
445 .<PreloadVnfs>builder(PreloadVnfs.class).child(VnfPreloadList.class, entry.getKey());
446 InstanceIdentifier<VnfPreloadList> path = vnfPreloadListBuilder.build();
450 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
452 tx.merge(storeType, path, entry);
454 tx.put(storeType, path, entry);
456 tx.submit().checkedGet();
457 log.debug("Update DataStore succeeded");
459 } catch (final TransactionCommitFailedException e) {
460 if (e instanceof OptimisticLockFailedException) {
462 log.debug("Got OptimisticLockFailedException on last try - failing ");
463 throw new IllegalStateException(e);
465 log.debug("Got OptimisticLockFailedException - trying again ");
467 log.debug("Update DataStore failed");
468 throw new IllegalStateException(e);
475 public Future<RpcResult<ServiceTopologyOperationOutput>> serviceTopologyOperation(
476 ServiceTopologyOperationInput input) {
478 final String SVC_OPERATION = "service-topology-operation";
479 ServiceData serviceData;
480 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
481 Properties parms = new Properties();
483 log.info("{} called.", SVC_OPERATION);
484 // create a new response object
485 ServiceTopologyOperationOutputBuilder responseBuilder = new ServiceTopologyOperationOutputBuilder();
487 if (input == null || input.getServiceInformation() == null
488 || input.getServiceInformation().getServiceInstanceId() == null
489 || input.getServiceInformation().getServiceInstanceId().length() == 0) {
490 log.debug("exiting {} because of null or empty service-instance-id", SVC_OPERATION);
491 responseBuilder.setResponseCode("404");
492 responseBuilder.setResponseMessage("invalid input, null or empty service-instance-id");
493 responseBuilder.setAckFinalIndicator("Y");
494 RpcResult<ServiceTopologyOperationOutput> rpcResult = RpcResultBuilder
495 .<ServiceTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
496 return Futures.immediateFuture(rpcResult);
499 // Grab the service instance ID from the input buffer
500 String siid = input.getServiceInformation().getServiceInstanceId();
502 if (input.getSdncRequestHeader() != null) {
503 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
506 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
507 getServiceData(siid, serviceDataBuilder);
509 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
510 getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
512 // Set the serviceStatus based on input
513 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
514 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
517 * // setup a service-data object builder // ACTION service-topology-operation
518 * // INPUT: // USES uses service-operation-information // OUTPUT: // uses
519 * topology-response-common; // uses service-response-information;
522 log.info("Adding INPUT data for {} [{}] input: {}", SVC_OPERATION, siid, input);
523 ServiceTopologyOperationInputBuilder inputBuilder = new ServiceTopologyOperationInputBuilder(input);
524 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
526 log.info("Adding OPERATIONAL data for {} [{}] operational-data: {}", SVC_OPERATION, siid,
527 operDataBuilder.build());
528 GenericResourceApiUtil.toProperties(parms, "operational-data", operDataBuilder);
530 // Call SLI sync method
531 // Get SvcLogicService reference
533 Properties respProps = null;
535 String errorCode = "200";
536 String errorMessage = null;
537 String ackFinal = "Y";
538 String serviceObjectPath = null;
541 if (svcLogicClient.hasGraph(appName, SVC_OPERATION, null, "sync")) {
544 respProps = svcLogicClient.execute(appName, SVC_OPERATION, null, "sync", serviceDataBuilder, parms);
545 } catch (Exception e) {
546 log.error("Caught exception executing service logic for {} ", SVC_OPERATION, e);
547 errorMessage = e.getMessage();
551 errorMessage = "No service logic active for " + appName + ": '" + SVC_OPERATION + "'";
554 } catch (Exception e) {
556 errorMessage = e.getMessage();
557 log.error("Caught exception looking for service logic", e);
560 if (respProps != null) {
561 errorCode = respProps.getProperty("error-code");
562 errorMessage = respProps.getProperty("error-message");
563 ackFinal = respProps.getProperty("ack-final", "Y");
564 serviceObjectPath = respProps.getProperty("service-object-path");
567 setServiceStatus(serviceStatusBuilder, errorCode, errorMessage, ackFinal);
568 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
569 // serviceStatusBuilder.setRpcName(RpcName.ServiceTopologyOperation);
570 serviceStatusBuilder.setRpcName(SVC_OPERATION);
572 if (errorCode != null && errorCode.length() != 0 && !(errorCode.equals("0") || errorCode.equals("200"))) {
573 responseBuilder.setResponseCode(errorCode);
574 responseBuilder.setResponseMessage(errorMessage);
575 responseBuilder.setAckFinalIndicator(ackFinal);
577 ServiceBuilder serviceBuilder = new ServiceBuilder();
578 serviceBuilder.setServiceInstanceId(siid);
579 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
581 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
582 } catch (Exception e) {
583 log.error("Caught Exception updating MD-SAL for {} [{}] \n", SVC_OPERATION, siid, e);
585 log.error("Returned FAILED for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
586 RpcResult<ServiceTopologyOperationOutput> rpcResult = RpcResultBuilder
587 .<ServiceTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
588 return Futures.immediateFuture(rpcResult);
591 // Got success from SLI
593 serviceData = serviceDataBuilder.build();
594 log.info("Updating MD-SAL for {} [{}] ServiceData: {}", SVC_OPERATION, siid, serviceData);
597 ServiceBuilder serviceBuilder = new ServiceBuilder();
598 serviceBuilder.setServiceData(serviceData);
599 serviceBuilder.setServiceInstanceId(siid);
600 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
601 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
603 if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null) {
604 // Only update operational tree on delete
605 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete)) {
606 log.info("Delete from both CONFIGURATION and OPERATIONAL tree.");
607 deleteService(serviceBuilder.build(), LogicalDatastoreType.OPERATIONAL);
608 deleteService(serviceBuilder.build(), LogicalDatastoreType.CONFIGURATION);
612 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
613 serviceResponseInformationBuilder.setInstanceId(siid);
614 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
615 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
617 } catch (Exception e) {
618 log.error("Caught Exception updating MD-SAL for {} [{}] \n", SVC_OPERATION, siid, e);
619 responseBuilder.setResponseCode("500");
620 responseBuilder.setResponseMessage(e.toString());
621 responseBuilder.setAckFinalIndicator("Y");
622 log.error("Returned FAILED for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
623 RpcResult<ServiceTopologyOperationOutput> rpcResult = RpcResultBuilder
624 .<ServiceTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
625 return Futures.immediateFuture(rpcResult);
629 responseBuilder.setResponseCode(errorCode);
630 responseBuilder.setAckFinalIndicator(ackFinal);
631 if (errorMessage != null) {
632 responseBuilder.setResponseMessage(errorMessage);
634 log.info("Updated MD-SAL for {} [{}]", SVC_OPERATION, siid);
635 log.info("Returned SUCCESS for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
637 RpcResult<ServiceTopologyOperationOutput> rpcResult = RpcResultBuilder
638 .<ServiceTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
639 return Futures.immediateFuture(rpcResult);
643 public Future<RpcResult<VnfTopologyOperationOutput>> vnfTopologyOperation(VnfTopologyOperationInput input) {
645 final String SVC_OPERATION = "vnf-topology-operation";
646 ServiceData serviceData;
647 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
648 Properties parms = new Properties();
650 log.info("{} called.", SVC_OPERATION);
651 // create a new response object
652 VnfTopologyOperationOutputBuilder responseBuilder = new VnfTopologyOperationOutputBuilder();
654 if (input == null || input.getServiceInformation() == null
655 || input.getServiceInformation().getServiceInstanceId() == null
656 || input.getServiceInformation().getServiceInstanceId().length() == 0) {
657 log.debug("exiting {} because of null or empty service-instance-id", SVC_OPERATION);
658 responseBuilder.setResponseCode("404");
659 responseBuilder.setResponseMessage("invalid input, null or empty service-instance-id");
660 responseBuilder.setAckFinalIndicator("Y");
661 RpcResult<VnfTopologyOperationOutput> rpcResult = RpcResultBuilder.<VnfTopologyOperationOutput>status(true)
662 .withResult(responseBuilder.build()).build();
664 return Futures.immediateFuture(rpcResult);
667 // Grab the service instance ID from the input buffer
668 String siid = input.getServiceInformation().getServiceInstanceId();
670 if (input.getSdncRequestHeader() != null) {
671 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
674 if (input.getVnfInformation() == null || input.getVnfInformation().getVnfId() == null
675 || input.getVnfInformation().getVnfId().length() == 0) {
676 log.debug("exiting {} because of null or empty vnf-id", SVC_OPERATION);
677 responseBuilder.setResponseCode("404");
678 responseBuilder.setResponseMessage("invalid input, null or empty vnf-id");
679 responseBuilder.setAckFinalIndicator("Y");
680 RpcResult<VnfTopologyOperationOutput> rpcResult = RpcResultBuilder.<VnfTopologyOperationOutput>status(true)
681 .withResult(responseBuilder.build()).build();
682 return Futures.immediateFuture(rpcResult);
686 * Mobility wont use vipr intf in 1707
688 * String preload_name = null; String preload_type = null; if
689 * (input.getVnfRequestInput() != null &&
690 * input.getVnfRequestInput().getVnfName() != null &&
691 * input.getVnfRequestInput().getVnfName().length() != 0) { preload_name =
692 * input.getVnfRequestInput().getVnfName(); } if
693 * (input.getVnfInformation().getVnfType() != null &&
694 * input.getVnfInformation().getVnfType().length() != 0) { preload_type =
695 * input.getVnfInformation().getVnfType(); }
697 * PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder(); if
698 * (preload_name != null && preload_type != null) { getPreloadData(preload_name,
699 * preload_type, preloadDataBuilder); } else {
700 * log.info("vnf-name and vnf-type not present in the request"); }
703 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
704 getServiceData(siid, serviceDataBuilder);
706 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
707 getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
709 // Set the serviceStatus based on input
710 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
711 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
714 // setup a service-data object builder
715 // ACTION vnf-topology-operation
717 // USES sdnc-request-header;
718 // USES request-information;
719 // USES service-information;
720 // USES vnf-request-information
722 // USES vnf-topology-response-body;
723 // USES vnf-information
724 // USES service-information
726 // container service-data
727 // uses vnf-configuration-information;
730 log.info("Adding INPUT data for {} [{}] input: {}", SVC_OPERATION, siid, input);
731 VnfTopologyOperationInputBuilder inputBuilder = new VnfTopologyOperationInputBuilder(input);
732 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
734 log.info("Adding OPERATIONAL data for {} [{}] operational-data: {}", SVC_OPERATION, siid,
735 operDataBuilder.build());
736 GenericResourceApiUtil.toProperties(parms, "operational-data", operDataBuilder);
739 * log.info("Adding CONFIG data for "+SVC_OPERATION+" ["+preload_name+","+
740 * preload_type+"] preload-data: " + preloadDataBuilder.build());
741 * GenericResourceApiUtil.toProperties(parms, "preload-data",
742 * preloadDataBuilder);
745 // Call SLI sync method
746 // Get SvcLogicService reference
748 Properties respProps = null;
750 String errorCode = "200";
751 String errorMessage = null;
752 String ackFinal = "Y";
753 String serviceObjectPath = null;
756 if (svcLogicClient.hasGraph(appName, SVC_OPERATION, null, "sync")) {
759 respProps = svcLogicClient.execute(appName, SVC_OPERATION, null, "sync", serviceDataBuilder, parms);
760 } catch (Exception e) {
761 log.error("Caught exception executing service logic for {} ", SVC_OPERATION, e);
762 errorMessage = e.getMessage();
766 errorMessage = "No service logic active for " + appName + ": '" + SVC_OPERATION + "'";
769 } catch (Exception e) {
771 errorMessage = e.getMessage();
772 log.error("Caught exception looking for service logic", e);
775 if (respProps != null) {
776 errorCode = respProps.getProperty("error-code");
777 errorMessage = respProps.getProperty("error-message");
778 ackFinal = respProps.getProperty("ack-final", "Y");
779 serviceObjectPath = respProps.getProperty("vnf-object-path");
782 setServiceStatus(serviceStatusBuilder, errorCode, errorMessage, ackFinal);
783 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
784 // serviceStatusBuilder.setRpcName(RpcName.VnfTopologyOperation);
785 serviceStatusBuilder.setRpcName(SVC_OPERATION);
787 if (errorCode != null && errorCode.length() != 0 && !(errorCode.equals("0") || errorCode.equals("200"))) {
788 responseBuilder.setResponseCode(errorCode);
789 responseBuilder.setResponseMessage(errorMessage);
790 responseBuilder.setAckFinalIndicator(ackFinal);
792 ServiceBuilder serviceBuilder = new ServiceBuilder();
793 serviceBuilder.setServiceInstanceId(siid);
794 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
796 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
797 if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null) {
798 // Only update operational tree on activate or delete
799 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete)
800 || input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate)) {
801 log.info("Updating OPERATIONAL tree.");
802 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
805 } catch (Exception e) {
806 log.error("Caught Exception updating MD-SAL for {} [{}] \n", SVC_OPERATION, siid, e);
808 log.error("Returned FAILED for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
809 RpcResult<VnfTopologyOperationOutput> rpcResult = RpcResultBuilder.<VnfTopologyOperationOutput>status(true)
810 .withResult(responseBuilder.build()).build();
812 return Futures.immediateFuture(rpcResult);
815 // Got success from SLI
817 serviceData = serviceDataBuilder.build();
818 log.info("Updating MD-SAL for {} [{}] ServiceData: {}", SVC_OPERATION, siid, serviceData);
821 ServiceBuilder serviceBuilder = new ServiceBuilder();
822 serviceBuilder.setServiceData(serviceData);
823 serviceBuilder.setServiceInstanceId(siid);
824 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
825 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
827 if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null) {
828 // Only update operational tree on Assign
829 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate)) {
830 log.info("Updating OPERATIONAL tree.");
831 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
835 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
836 serviceResponseInformationBuilder.setInstanceId(siid);
837 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
838 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
840 } catch (Exception e) {
841 log.error("Caught Exception updating MD-SAL for {} [{}] \n", SVC_OPERATION, siid, e);
842 responseBuilder.setResponseCode("500");
843 responseBuilder.setResponseMessage(e.toString());
844 responseBuilder.setAckFinalIndicator("Y");
845 log.error("Returned FAILED for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
846 RpcResult<VnfTopologyOperationOutput> rpcResult = RpcResultBuilder.<VnfTopologyOperationOutput>status(true)
847 .withResult(responseBuilder.build()).build();
848 return Futures.immediateFuture(rpcResult);
852 responseBuilder.setResponseCode(errorCode);
853 responseBuilder.setAckFinalIndicator(ackFinal);
854 if (errorMessage != null) {
855 responseBuilder.setResponseMessage(errorMessage);
857 log.info("Updated MD-SAL for {} [{}]", SVC_OPERATION, siid);
858 log.info("Returned SUCCESS for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
860 RpcResult<VnfTopologyOperationOutput> rpcResult = RpcResultBuilder.<VnfTopologyOperationOutput>status(true)
861 .withResult(responseBuilder.build()).build();
863 return Futures.immediateFuture(rpcResult);
867 public Future<RpcResult<VfModuleTopologyOperationOutput>> vfModuleTopologyOperation(
868 VfModuleTopologyOperationInput input) {
870 final String SVC_OPERATION = "vf-module-topology-operation";
871 ServiceData serviceData;
872 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
873 Properties parms = new Properties();
875 log.info("{} called.", SVC_OPERATION);
876 // create a new response object
877 VfModuleTopologyOperationOutputBuilder responseBuilder = new VfModuleTopologyOperationOutputBuilder();
879 if (input == null || input.getServiceInformation() == null
880 || input.getServiceInformation().getServiceInstanceId() == null
881 || input.getServiceInformation().getServiceInstanceId().length() == 0) {
882 log.debug("exiting {} because of null or empty service-instance-id", SVC_OPERATION);
883 responseBuilder.setResponseCode("403");
884 responseBuilder.setResponseMessage("invalid input, null or empty service-instance-id");
885 responseBuilder.setAckFinalIndicator("Y");
886 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
887 .<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
889 return Futures.immediateFuture(rpcResult);
892 if (input.getVnfInformation() == null || input.getVnfInformation().getVnfId() == null
893 || input.getVnfInformation().getVnfId().length() == 0) {
894 log.debug("exiting {} because of null or empty vnf-id", SVC_OPERATION);
895 responseBuilder.setResponseCode("403");
896 responseBuilder.setResponseMessage("invalid input, null or empty vnf-id");
897 responseBuilder.setAckFinalIndicator("Y");
898 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
899 .<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
900 return Futures.immediateFuture(rpcResult);
903 if (input.getVfModuleInformation() == null || input.getVfModuleInformation().getVfModuleId() == null
904 || input.getVfModuleInformation().getVfModuleId().length() == 0) {
905 log.debug("exiting {} because of null or empty vf-module-id", SVC_OPERATION);
906 responseBuilder.setResponseCode("403");
907 responseBuilder.setResponseMessage("invalid input, vf-module-id is null or empty");
908 responseBuilder.setAckFinalIndicator("Y");
909 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
910 .<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
911 return Futures.immediateFuture(rpcResult);
914 // Grab the service instance ID from the input buffer
915 String siid = input.getServiceInformation().getServiceInstanceId();
917 if (input.getSdncRequestHeader() != null) {
918 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
922 * String preload_name = null; String preload_type = null;
924 * preload_name = input.getVfModuleRequestInput().getVfModuleName();
926 * if(input.getVfModuleInformation().getVfModuleType() != null &&
927 * input.getVfModuleInformation().getVfModuleType().length() != 0) {
928 * preload_type = input.getVfModuleInformation().getVfModuleType(); }
930 * PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder(); if
931 * (preload_name != null && preload_type != null) { getPreloadData(preload_name,
932 * preload_type, preloadDataBuilder); } else {
933 * log.debug("vf-module-name and vf-module-type not present in the request."); }
936 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
937 getServiceData(siid, serviceDataBuilder);
939 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
940 getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
942 // Set the serviceStatus based on input
943 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
944 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
947 // setup a service-data object builder
948 // ACTION vnf-topology-operation
950 // USES sdnc-request-header;
951 // USES request-information;
952 // USES service-information;
953 // USES vnf-request-information
955 // USES vnf-topology-response-body;
956 // USES vnf-information
957 // USES service-information
959 // container service-data
960 // uses vnf-configuration-information;
963 log.info("Adding INPUT data for {} [{}] input: {}", SVC_OPERATION, siid, input);
964 VfModuleTopologyOperationInputBuilder inputBuilder = new VfModuleTopologyOperationInputBuilder(input);
965 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
967 log.info("Adding OPERATIONAL data for {} [{}] operational-data: {}", SVC_OPERATION, siid,
968 operDataBuilder.build());
969 GenericResourceApiUtil.toProperties(parms, "operational-data", operDataBuilder);
972 * log.info("Adding CONFIG data for "+SVC_OPERATION+" ["+preload_name+","+
973 * preload_type+"] preload-data: " +preloadDataBuilder.build());
974 * GenericResourceApiUtil.toProperties(parms, "preload-data",
975 * preloadDataBuilder);
978 // Call SLI sync method
979 // Get SvcLogicService reference
981 Properties respProps = null;
983 String errorCode = "200";
984 String errorMessage = null;
985 String ackFinal = "Y";
986 String serviceObjectPath = null;
989 if (svcLogicClient.hasGraph(appName, SVC_OPERATION, null, "sync")) {
992 respProps = svcLogicClient.execute(appName, SVC_OPERATION, null, "sync", serviceDataBuilder, parms);
993 } catch (Exception e) {
994 log.error("Caught exception executing service logic for " + SVC_OPERATION, e);
995 errorMessage = e.getMessage();
999 errorMessage = "No service logic active for " + appName + ": '" + SVC_OPERATION + "'";
1002 } catch (Exception e) {
1004 errorMessage = e.getMessage();
1005 log.error("Caught exception looking for service logic", e);
1008 if (respProps != null) {
1009 errorCode = respProps.getProperty("error-code");
1010 errorMessage = respProps.getProperty("error-message");
1011 ackFinal = respProps.getProperty("ack-final", "Y");
1012 serviceObjectPath = respProps.getProperty("vf-module-object-path");
1015 setServiceStatus(serviceStatusBuilder, errorCode, errorMessage, ackFinal);
1016 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
1017 serviceStatusBuilder.setRpcName(SVC_OPERATION);
1019 if (errorCode != null && errorCode.length() != 0 && !(errorCode.equals("0") || errorCode.equals("200"))) {
1020 responseBuilder.setResponseCode(errorCode);
1021 responseBuilder.setResponseMessage(errorMessage);
1022 responseBuilder.setAckFinalIndicator(ackFinal);
1024 ServiceBuilder serviceBuilder = new ServiceBuilder();
1025 serviceBuilder.setServiceInstanceId(siid);
1026 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1028 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
1029 } catch (Exception e) {
1030 log.error("Caught Exception updating MD-SAL for {} [{}] \n", SVC_OPERATION, siid, e);
1032 log.error("Returned FAILED for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
1033 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
1034 .<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1036 return Futures.immediateFuture(rpcResult);
1039 // Got success from SLI
1041 serviceData = serviceDataBuilder.build();
1042 log.info("Updating MD-SAL for {} [{}] ServiceData: {}", SVC_OPERATION, siid, serviceData);
1045 ServiceBuilder serviceBuilder = new ServiceBuilder();
1046 serviceBuilder.setServiceData(serviceData);
1047 // serviceBuilder.setServiceInstanceId(serviceData.getServiceTopology().getServiceTopologyIdentifier().getServiceInstanceId());
1048 serviceBuilder.setServiceInstanceId(siid);
1049 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1050 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1052 if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null) {
1053 // Only update operational tree on activate or delete
1054 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Unassign)
1055 || input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate)) {
1056 log.info("Updating OPERATIONAL tree.");
1057 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1061 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1062 serviceResponseInformationBuilder.setInstanceId(siid);
1063 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1064 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1066 } catch (Exception e) {
1067 log.error("Caught Exception updating MD-SAL for {} [{}] \n", SVC_OPERATION, siid, e);
1068 responseBuilder.setResponseCode("500");
1069 responseBuilder.setResponseMessage(e.toString());
1070 responseBuilder.setAckFinalIndicator("Y");
1071 log.error("Returned FAILED for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
1072 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
1073 .<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1074 return Futures.immediateFuture(rpcResult);
1078 responseBuilder.setResponseCode(errorCode);
1079 responseBuilder.setAckFinalIndicator(ackFinal);
1080 if (errorMessage != null) {
1081 responseBuilder.setResponseMessage(errorMessage);
1083 log.info("Updated MD-SAL for {} [{}]", SVC_OPERATION, siid);
1084 log.info("Returned SUCCESS for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
1086 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
1087 .<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1089 return Futures.immediateFuture(rpcResult);
1093 public Future<RpcResult<NetworkTopologyOperationOutput>> networkTopologyOperation(
1094 NetworkTopologyOperationInput input) {
1096 final String SVC_OPERATION = "network-topology-operation";
1097 ServiceData serviceData;
1098 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1099 Properties parms = new Properties();
1101 log.info("{} called.", SVC_OPERATION);
1102 // create a new response object
1103 NetworkTopologyOperationOutputBuilder responseBuilder = new NetworkTopologyOperationOutputBuilder();
1105 if (input == null || input.getServiceInformation() == null
1106 || input.getServiceInformation().getServiceInstanceId() == null
1107 || input.getServiceInformation().getServiceInstanceId().length() == 0) {
1108 log.debug("exiting {} because of null or empty service-instance-id", SVC_OPERATION);
1109 responseBuilder.setResponseCode("404");
1110 responseBuilder.setResponseMessage("invalid input, null or empty service-instance-id");
1111 responseBuilder.setAckFinalIndicator("Y");
1112 RpcResult<NetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
1113 .<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1114 return Futures.immediateFuture(rpcResult);
1117 String siid = input.getServiceInformation().getServiceInstanceId();
1119 // Get the service-instance service data from MD-SAL
1120 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1121 getServiceData(siid, serviceDataBuilder);
1123 if (input.getSdncRequestHeader() != null) {
1124 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1127 ServiceData sd = serviceDataBuilder.build();
1128 if (sd == null || sd.getServiceLevelOperStatus() == null) {
1129 log.debug("exiting {} because the service-instance does not have any service data in SDNC", SVC_OPERATION);
1130 responseBuilder.setResponseCode("404");
1132 .setResponseMessage("invalid input: the service-instance does not have any service data in SDNC");
1133 responseBuilder.setAckFinalIndicator("Y");
1134 RpcResult<NetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
1135 .<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1136 return Futures.immediateFuture(rpcResult);
1140 * //String preload_name = null; //String preload_type = null; // If both
1141 * network-name and network-type are present in request, get the preload network
1142 * from MD-SAL if (input.getNetworkRequestInput() != null &&
1143 * input.getNetworkRequestInput().getNetworkName() != null &&
1144 * input.getNetworkRequestInput().getNetworkName().length() != 0) { preload_name
1145 * = input.getNetworkRequestInput().getNetworkName(); } if
1146 * (input.getNetworkInformation() != null &&
1147 * input.getNetworkInformation().getNetworkType() != null &&
1148 * input.getNetworkInformation().getNetworkType().length() != 0) { preload_type
1149 * = input.getNetworkInformation().getNetworkType(); }
1151 * PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder(); if
1152 * (preload_name != null && preload_type != null) { getPreloadData(preload_name,
1153 * preload_type, preloadDataBuilder); } else {
1154 * log.debug("network-name and network-type not present in request"); }
1157 log.info("Adding INPUT data for {} [{}] input: {}", SVC_OPERATION, siid, input);
1158 NetworkTopologyOperationInputBuilder inputBuilder = new NetworkTopologyOperationInputBuilder(input);
1159 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1161 // Call SLI sync method
1162 // Get SvcLogicService reference
1164 Properties respProps = null;
1166 String errorCode = "200";
1167 String errorMessage = null;
1168 String ackFinal = "Y";
1169 String networkId = "error";
1170 String serviceObjectPath = null;
1171 String networkObjectPath = null;
1174 if (svcLogicClient.hasGraph(appName, SVC_OPERATION, null, "sync")) {
1177 respProps = svcLogicClient.execute(appName, SVC_OPERATION, null, "sync", serviceDataBuilder, parms);
1178 } catch (Exception e) {
1179 log.error("Caught exception executing service logic for {}", SVC_OPERATION, e);
1180 errorMessage = e.getMessage();
1184 errorMessage = "No service logic active for " + appName + ": '" + SVC_OPERATION + "'";
1187 } catch (Exception e) {
1189 errorMessage = e.getMessage();
1190 log.error("Caught exception looking for service logic", e);
1193 if (respProps != null) {
1194 errorCode = respProps.getProperty("error-code");
1195 errorMessage = respProps.getProperty("error-message");
1196 ackFinal = respProps.getProperty("ack-final", "Y");
1197 networkId = respProps.getProperty("networkId");
1198 serviceObjectPath = respProps.getProperty("service-object-path");
1199 networkObjectPath = respProps.getProperty("network-object-path");
1202 if (errorCode != null && errorCode.length() != 0 && !(errorCode.equals("0") || errorCode.equals("200"))) {
1203 responseBuilder.setResponseCode(errorCode);
1204 responseBuilder.setResponseMessage(errorMessage);
1205 responseBuilder.setAckFinalIndicator(ackFinal);
1207 log.error("Returned FAILED for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
1209 RpcResult<NetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
1210 .<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1211 return Futures.immediateFuture(rpcResult);
1214 // Got success from SLI
1217 serviceData = serviceDataBuilder.build();
1218 log.info("Updating MD-SAL for {} [{}] ServiceData: {}", SVC_OPERATION, siid, serviceData);
1221 ServiceBuilder serviceBuilder = new ServiceBuilder();
1222 serviceBuilder.setServiceData(serviceData);
1223 serviceBuilder.setServiceInstanceId(siid);
1224 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1225 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1227 if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null) {
1228 // Only update operational tree on Activate
1229 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate)
1230 || input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Create)) {
1231 log.info("Updating OPERATIONAL tree.");
1232 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1236 NetworkResponseInformationBuilder networkResponseInformationBuilder = new NetworkResponseInformationBuilder();
1237 networkResponseInformationBuilder.setInstanceId(networkId);
1238 networkResponseInformationBuilder.setObjectPath(networkObjectPath);
1239 responseBuilder.setNetworkResponseInformation(networkResponseInformationBuilder.build());
1241 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1242 serviceResponseInformationBuilder.setInstanceId(siid);
1243 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1244 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1246 } catch (IllegalStateException e) {
1247 log.error("Caught Exception updating MD-SAL for {} [{}] \n", SVC_OPERATION, siid, e);
1248 responseBuilder.setResponseCode("500");
1249 responseBuilder.setResponseMessage(e.toString());
1250 responseBuilder.setAckFinalIndicator("Y");
1251 log.error("Returned FAILED for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
1252 RpcResult<NetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
1253 .<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1254 return Futures.immediateFuture(rpcResult);
1258 responseBuilder.setResponseCode(errorCode);
1259 responseBuilder.setAckFinalIndicator(ackFinal);
1260 if (errorMessage != null) {
1261 responseBuilder.setResponseMessage(errorMessage);
1263 log.info("Updated MD-SAL for {} [{}]", SVC_OPERATION, siid);
1264 log.info("Returned SUCCESS for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
1266 RpcResult<NetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
1267 .<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1268 return Futures.immediateFuture(rpcResult);
1272 public Future<RpcResult<ContrailRouteTopologyOperationOutput>> contrailRouteTopologyOperation(
1273 ContrailRouteTopologyOperationInput input) {
1275 final String SVC_OPERATION = "contrail-route-topology-operation";
1276 ServiceData serviceData;
1277 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1278 Properties parms = new Properties();
1280 log.info("{} called.", SVC_OPERATION);
1281 // create a new response object
1282 ContrailRouteTopologyOperationOutputBuilder responseBuilder = new ContrailRouteTopologyOperationOutputBuilder();
1284 if (input == null || input.getServiceInformation() == null
1285 || input.getServiceInformation().getServiceInstanceId() == null
1286 || input.getServiceInformation().getServiceInstanceId().length() == 0) {
1287 log.debug("exiting {} because of null or empty service-instance-id", SVC_OPERATION);
1288 responseBuilder.setResponseCode("404");
1289 responseBuilder.setResponseMessage("invalid input, null or empty service-instance-id");
1290 responseBuilder.setAckFinalIndicator("Y");
1291 RpcResult<ContrailRouteTopologyOperationOutput> rpcResult = RpcResultBuilder
1292 .<ContrailRouteTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1293 return Futures.immediateFuture(rpcResult);
1296 String siid = input.getServiceInformation().getServiceInstanceId();
1298 // Get the service-instance service data from MD-SAL
1299 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1300 getServiceData(siid, serviceDataBuilder);
1302 if (input.getSdncRequestHeader() != null) {
1303 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1306 ServiceData sd = serviceDataBuilder.build();
1307 if (sd == null || sd.getServiceLevelOperStatus() == null) {
1308 log.debug("exiting {} because the service-instance does not have any service data in SDNC", SVC_OPERATION);
1309 responseBuilder.setResponseCode("404");
1311 .setResponseMessage("invalid input: the service-instance does not have any service data in SDNC");
1312 responseBuilder.setAckFinalIndicator("Y");
1313 RpcResult<ContrailRouteTopologyOperationOutput> rpcResult = RpcResultBuilder
1314 .<ContrailRouteTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1315 return Futures.immediateFuture(rpcResult);
1318 log.info("Adding INPUT data for " + SVC_OPERATION + " [" + siid + "] input: " + input);
1319 ContrailRouteTopologyOperationInputBuilder inputBuilder = new ContrailRouteTopologyOperationInputBuilder(input);
1320 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1322 // Call SLI sync method
1323 // Get SvcLogicService reference
1325 Properties respProps = null;
1327 String errorCode = "200";
1328 String errorMessage = null;
1329 String ackFinal = "Y";
1330 String allottedResourceId = "error";
1331 String serviceObjectPath = null;
1332 String contrailRouteObjectPath = null;
1335 if (svcLogicClient.hasGraph(appName, SVC_OPERATION, null, "sync")) {
1338 respProps = svcLogicClient.execute(appName, SVC_OPERATION, null, "sync", serviceDataBuilder, parms);
1339 } catch (Exception e) {
1340 log.error("Caught exception executing service logic for {}", SVC_OPERATION, e);
1341 errorMessage = e.getMessage();
1345 errorMessage = "No service logic active for " + appName + ": '" + SVC_OPERATION + "'";
1348 } catch (Exception e) {
1350 errorMessage = e.getMessage();
1351 log.error("Caught exception looking for service logic", e);
1354 if (respProps != null) {
1355 errorCode = respProps.getProperty("error-code");
1356 errorMessage = respProps.getProperty("error-message");
1357 ackFinal = respProps.getProperty("ack-final", "Y");
1358 allottedResourceId = respProps.getProperty("allotted-resource-id");
1359 serviceObjectPath = respProps.getProperty("service-object-path");
1360 contrailRouteObjectPath = respProps.getProperty("contrail-route-object-path");
1363 if (errorCode != null && errorCode.length() != 0 && !(errorCode.equals("0") || errorCode.equals("200"))) {
1364 responseBuilder.setResponseCode(errorCode);
1365 responseBuilder.setResponseMessage(errorMessage);
1366 responseBuilder.setAckFinalIndicator(ackFinal);
1368 log.error("Returned FAILED for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
1370 RpcResult<ContrailRouteTopologyOperationOutput> rpcResult = RpcResultBuilder
1371 .<ContrailRouteTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1372 return Futures.immediateFuture(rpcResult);
1375 // Got success from SLI
1378 serviceData = serviceDataBuilder.build();
1379 log.info("Updating MD-SAL for {} [{}] ServiceData: {}", SVC_OPERATION, siid, serviceData);
1382 ServiceBuilder serviceBuilder = new ServiceBuilder();
1383 serviceBuilder.setServiceData(serviceData);
1384 serviceBuilder.setServiceInstanceId(siid);
1385 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1386 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1388 if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null) {
1389 // Only update operational tree on activate or delete
1390 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Unassign)
1391 || input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate)) {
1392 log.info("Updating OPERATIONAL tree.");
1393 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1397 ContrailRouteResponseInformationBuilder contrailRouteResponseInformationBuilder = new ContrailRouteResponseInformationBuilder();
1398 contrailRouteResponseInformationBuilder.setInstanceId(allottedResourceId);
1399 contrailRouteResponseInformationBuilder.setObjectPath(contrailRouteObjectPath);
1400 responseBuilder.setContrailRouteResponseInformation(contrailRouteResponseInformationBuilder.build());
1402 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1403 serviceResponseInformationBuilder.setInstanceId(siid);
1404 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1405 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1407 } catch (IllegalStateException e) {
1408 log.error("Caught Exception updating MD-SAL for {} [{}] \n", SVC_OPERATION, siid, e);
1409 responseBuilder.setResponseCode("500");
1410 responseBuilder.setResponseMessage(e.toString());
1411 responseBuilder.setAckFinalIndicator("Y");
1412 log.error("Returned FAILED for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
1413 RpcResult<ContrailRouteTopologyOperationOutput> rpcResult = RpcResultBuilder
1414 .<ContrailRouteTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1415 return Futures.immediateFuture(rpcResult);
1419 responseBuilder.setResponseCode(errorCode);
1420 responseBuilder.setAckFinalIndicator(ackFinal);
1421 if (errorMessage != null) {
1422 responseBuilder.setResponseMessage(errorMessage);
1424 log.info("Updated MD-SAL for {} [{}]", SVC_OPERATION, siid);
1425 log.info("Returned SUCCESS for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
1427 RpcResult<ContrailRouteTopologyOperationOutput> rpcResult = RpcResultBuilder
1428 .<ContrailRouteTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1429 return Futures.immediateFuture(rpcResult);
1433 public Future<RpcResult<SecurityZoneTopologyOperationOutput>> securityZoneTopologyOperation(
1434 SecurityZoneTopologyOperationInput input) {
1436 final String SVC_OPERATION = "security-zone-topology-operation";
1437 ServiceData serviceData;
1438 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1439 Properties parms = new Properties();
1441 log.info("{} called.", SVC_OPERATION);
1442 // create a new response object
1443 SecurityZoneTopologyOperationOutputBuilder responseBuilder = new SecurityZoneTopologyOperationOutputBuilder();
1445 if (input == null || input.getServiceInformation() == null
1446 || input.getServiceInformation().getServiceInstanceId() == null
1447 || input.getServiceInformation().getServiceInstanceId().length() == 0) {
1448 log.debug("exiting {} because of null or empty service-instance-id", SVC_OPERATION);
1449 responseBuilder.setResponseCode("404");
1450 responseBuilder.setResponseMessage("invalid input, null or empty service-instance-id");
1451 responseBuilder.setAckFinalIndicator("Y");
1452 RpcResult<SecurityZoneTopologyOperationOutput> rpcResult = RpcResultBuilder
1453 .<SecurityZoneTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1454 return Futures.immediateFuture(rpcResult);
1457 String siid = input.getServiceInformation().getServiceInstanceId();
1459 // Get the service-instance service data from MD-SAL
1460 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1461 getServiceData(siid, serviceDataBuilder);
1463 if (input.getSdncRequestHeader() != null) {
1464 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1467 ServiceData sd = serviceDataBuilder.build();
1468 if (sd == null || sd.getServiceLevelOperStatus() == null) {
1469 log.debug("exiting {} because the service-instance does not have any service data in SDNC", SVC_OPERATION);
1470 responseBuilder.setResponseCode("404");
1472 .setResponseMessage("invalid input: the service-instance does not have any service data in SDNC");
1473 responseBuilder.setAckFinalIndicator("Y");
1474 RpcResult<SecurityZoneTopologyOperationOutput> rpcResult = RpcResultBuilder
1475 .<SecurityZoneTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1476 return Futures.immediateFuture(rpcResult);
1479 log.info("Adding INPUT data for {} [{}] input: {}", SVC_OPERATION, siid, input);
1480 SecurityZoneTopologyOperationInputBuilder inputBuilder = new SecurityZoneTopologyOperationInputBuilder(input);
1481 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1483 // Call SLI sync method
1484 // Get SvcLogicService reference
1486 Properties respProps = null;
1488 String errorCode = "200";
1489 String errorMessage = null;
1490 String ackFinal = "Y";
1491 String allottedResourceId = "error";
1492 String serviceObjectPath = null;
1493 String securityZoneObjectPath = null;
1496 if (svcLogicClient.hasGraph(appName, SVC_OPERATION, null, "sync")) {
1499 respProps = svcLogicClient.execute(appName, SVC_OPERATION, null, "sync", serviceDataBuilder, parms);
1500 } catch (Exception e) {
1501 log.error("Caught exception executing service logic for {}", SVC_OPERATION, e);
1502 errorMessage = e.getMessage();
1506 errorMessage = "No service logic active for " + appName + ": '" + SVC_OPERATION + "'";
1509 } catch (Exception e) {
1511 errorMessage = e.getMessage();
1512 log.error("Caught exception looking for service logic", e);
1515 if (respProps != null) {
1516 errorCode = respProps.getProperty("error-code");
1517 errorMessage = respProps.getProperty("error-message");
1518 ackFinal = respProps.getProperty("ack-final", "Y");
1519 allottedResourceId = respProps.getProperty("allotted-resource-id");
1520 serviceObjectPath = respProps.getProperty("service-object-path");
1521 securityZoneObjectPath = respProps.getProperty("security-zone-object-path");
1524 if (errorCode != null && errorCode.length() != 0 && !(errorCode.equals("0") || errorCode.equals("200"))) {
1525 responseBuilder.setResponseCode(errorCode);
1526 responseBuilder.setResponseMessage(errorMessage);
1527 responseBuilder.setAckFinalIndicator(ackFinal);
1529 log.error("Returned FAILED for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
1531 RpcResult<SecurityZoneTopologyOperationOutput> rpcResult = RpcResultBuilder
1532 .<SecurityZoneTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1533 return Futures.immediateFuture(rpcResult);
1536 // Got success from SLI
1539 serviceData = serviceDataBuilder.build();
1540 log.info("Updating MD-SAL for {} [{}] ServiceData: {}", SVC_OPERATION, siid, serviceData);
1543 ServiceBuilder serviceBuilder = new ServiceBuilder();
1544 serviceBuilder.setServiceData(serviceData);
1545 serviceBuilder.setServiceInstanceId(siid);
1546 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1547 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1549 if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null) {
1550 // Only update operational tree on activate or delete
1551 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Unassign)
1552 || input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate)) {
1553 log.info("Updating OPERATIONAL tree.");
1554 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1558 SecurityZoneResponseInformationBuilder securityZoneResponseInformationBuilder = new SecurityZoneResponseInformationBuilder();
1559 securityZoneResponseInformationBuilder.setInstanceId(allottedResourceId);
1560 securityZoneResponseInformationBuilder.setObjectPath(securityZoneObjectPath);
1561 responseBuilder.setSecurityZoneResponseInformation(securityZoneResponseInformationBuilder.build());
1563 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1564 serviceResponseInformationBuilder.setInstanceId(siid);
1565 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1566 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1568 } catch (IllegalStateException e) {
1569 log.error("Caught Exception updating MD-SAL for {} [{}] \n", SVC_OPERATION, siid, e);
1570 responseBuilder.setResponseCode("500");
1571 responseBuilder.setResponseMessage(e.toString());
1572 responseBuilder.setAckFinalIndicator("Y");
1573 log.error("Returned FAILED for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
1574 RpcResult<SecurityZoneTopologyOperationOutput> rpcResult = RpcResultBuilder
1575 .<SecurityZoneTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1576 return Futures.immediateFuture(rpcResult);
1580 responseBuilder.setResponseCode(errorCode);
1581 responseBuilder.setAckFinalIndicator(ackFinal);
1582 if (errorMessage != null) {
1583 responseBuilder.setResponseMessage(errorMessage);
1585 log.info("Updated MD-SAL for {} [{}]", SVC_OPERATION, siid);
1586 log.info("Returned SUCCESS for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
1588 RpcResult<SecurityZoneTopologyOperationOutput> rpcResult = RpcResultBuilder
1589 .<SecurityZoneTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1590 return Futures.immediateFuture(rpcResult);
1594 public Future<RpcResult<TunnelxconnTopologyOperationOutput>> tunnelxconnTopologyOperation(
1595 TunnelxconnTopologyOperationInput input) {
1597 final String SVC_OPERATION = "tunnelxconn-topology-operation";
1598 ServiceData serviceData;
1599 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1600 Properties parms = new Properties();
1602 log.info("{} called.", SVC_OPERATION);
1603 // create a new response object
1604 TunnelxconnTopologyOperationOutputBuilder responseBuilder = new TunnelxconnTopologyOperationOutputBuilder();
1606 if (input == null || input.getServiceInformation() == null
1607 || input.getServiceInformation().getServiceInstanceId() == null
1608 || input.getServiceInformation().getServiceInstanceId().length() == 0) {
1609 log.debug("exiting {} because of null or empty service-instance-id", SVC_OPERATION);
1610 responseBuilder.setResponseCode("404");
1611 responseBuilder.setResponseMessage("invalid input, null or empty service-instance-id");
1612 responseBuilder.setAckFinalIndicator("Y");
1613 RpcResult<TunnelxconnTopologyOperationOutput> rpcResult = RpcResultBuilder
1614 .<TunnelxconnTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1615 return Futures.immediateFuture(rpcResult);
1618 String siid = input.getServiceInformation().getServiceInstanceId();
1620 // Get the service-instance service data from MD-SAL
1621 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1622 getServiceData(siid, serviceDataBuilder);
1624 if (input.getSdncRequestHeader() != null) {
1625 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1628 ServiceData sd = serviceDataBuilder.build();
1629 if (sd == null || sd.getServiceLevelOperStatus() == null) {
1630 log.debug("exiting {} because the service-instance does not have any service data in SDNC", SVC_OPERATION);
1631 responseBuilder.setResponseCode("404");
1633 .setResponseMessage("invalid input: the service-instance does not have any service data in SDNC");
1634 responseBuilder.setAckFinalIndicator("Y");
1635 RpcResult<TunnelxconnTopologyOperationOutput> rpcResult = RpcResultBuilder
1636 .<TunnelxconnTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1637 return Futures.immediateFuture(rpcResult);
1640 log.info("Adding INPUT data for {} [{}] input: {}", SVC_OPERATION, siid, input);
1641 TunnelxconnTopologyOperationInputBuilder inputBuilder = new TunnelxconnTopologyOperationInputBuilder(input);
1642 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1644 // Call SLI sync method
1645 // Get SvcLogicService reference
1647 Properties respProps = null;
1649 String errorCode = "200";
1650 String errorMessage = null;
1651 String ackFinal = "Y";
1652 String allottedResourceId = "error";
1653 String serviceObjectPath = null;
1654 String tunnelxconnObjectPath = null;
1657 if (svcLogicClient.hasGraph(appName, SVC_OPERATION, null, "sync")) {
1660 respProps = svcLogicClient.execute(appName, SVC_OPERATION, null, "sync", parms);
1661 } catch (Exception e) {
1662 log.error("Caught exception executing service logic for {}", SVC_OPERATION, e);
1663 errorMessage = e.getMessage();
1667 errorMessage = "No service logic active for " + appName + ": '" + SVC_OPERATION + "'";
1670 } catch (Exception e) {
1672 errorMessage = e.getMessage();
1673 log.error("Caught exception looking for service logic", e);
1676 if (respProps != null) {
1677 errorCode = respProps.getProperty("error-code");
1678 errorMessage = respProps.getProperty("error-message");
1679 ackFinal = respProps.getProperty("ack-final", "Y");
1680 allottedResourceId = respProps.getProperty("allotted-resource-id");
1681 serviceObjectPath = respProps.getProperty("service-object-path");
1682 tunnelxconnObjectPath = respProps.getProperty("tunnelxconn-object-path");
1685 if (errorCode != null && errorCode.length() != 0 && !(errorCode.equals("0") || errorCode.equals("200"))) {
1686 responseBuilder.setResponseCode(errorCode);
1687 responseBuilder.setResponseMessage(errorMessage);
1688 responseBuilder.setAckFinalIndicator(ackFinal);
1690 log.error("Returned FAILED for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
1692 RpcResult<TunnelxconnTopologyOperationOutput> rpcResult = RpcResultBuilder
1693 .<TunnelxconnTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1694 return Futures.immediateFuture(rpcResult);
1697 // Got success from SLI
1702 TunnelxconnResponseInformationBuilder tunnelxconnResponseInformationBuilder = new TunnelxconnResponseInformationBuilder();
1703 tunnelxconnResponseInformationBuilder.setInstanceId(allottedResourceId);
1704 tunnelxconnResponseInformationBuilder.setObjectPath(tunnelxconnObjectPath);
1705 responseBuilder.setTunnelxconnResponseInformation(tunnelxconnResponseInformationBuilder.build());
1707 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1708 serviceResponseInformationBuilder.setInstanceId(siid);
1709 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1710 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1712 } catch (IllegalStateException e) {
1713 log.error("Caught Exception updating MD-SAL for {} [{}] \n", SVC_OPERATION, siid, e);
1714 responseBuilder.setResponseCode("500");
1715 responseBuilder.setResponseMessage(e.toString());
1716 responseBuilder.setAckFinalIndicator("Y");
1717 log.error("Returned FAILED for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
1718 RpcResult<TunnelxconnTopologyOperationOutput> rpcResult = RpcResultBuilder
1719 .<TunnelxconnTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1720 return Futures.immediateFuture(rpcResult);
1724 responseBuilder.setResponseCode(errorCode);
1725 responseBuilder.setAckFinalIndicator(ackFinal);
1726 if (errorMessage != null) {
1727 responseBuilder.setResponseMessage(errorMessage);
1729 log.info("Updated MD-SAL for {} [{}]", SVC_OPERATION, siid);
1730 log.info("Returned SUCCESS for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
1732 RpcResult<TunnelxconnTopologyOperationOutput> rpcResult = RpcResultBuilder
1733 .<TunnelxconnTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1734 return Futures.immediateFuture(rpcResult);
1738 public Future<RpcResult<BrgTopologyOperationOutput>> brgTopologyOperation(BrgTopologyOperationInput input) {
1739 final String SVC_OPERATION = "brg-topology-operation";
1740 ServiceData serviceData;
1741 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1742 Properties parms = new Properties();
1744 log.info("{} called.", SVC_OPERATION);
1745 // create a new response object
1746 BrgTopologyOperationOutputBuilder responseBuilder = new BrgTopologyOperationOutputBuilder();
1748 if (input == null || input.getServiceInformation() == null
1749 || input.getServiceInformation().getServiceInstanceId() == null
1750 || input.getServiceInformation().getServiceInstanceId().length() == 0) {
1751 log.debug("exiting {} because of null or empty service-instance-id", SVC_OPERATION);
1752 responseBuilder.setResponseCode("404");
1753 responseBuilder.setResponseMessage("invalid input, null or empty service-instance-id");
1754 responseBuilder.setAckFinalIndicator("Y");
1755 RpcResult<BrgTopologyOperationOutput> rpcResult = RpcResultBuilder.<BrgTopologyOperationOutput>status(true)
1756 .withResult(responseBuilder.build()).build();
1757 return Futures.immediateFuture(rpcResult);
1760 String siid = input.getServiceInformation().getServiceInstanceId();
1762 /* // Get the service-instance service data from MD-SAL
1763 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1764 getServiceData(siid, serviceDataBuilder);
1766 if (input.getSdncRequestHeader() != null) {
1767 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1770 ServiceData sd = serviceDataBuilder.build();
1771 if (sd == null || sd.getServiceLevelOperStatus() == null) {
1772 log.debug("exiting {} because the service-instance does not have any service data in SDNC", SVC_OPERATION);
1773 responseBuilder.setResponseCode("404");
1775 .setResponseMessage("invalid input: the service-instance does not have any service data in SDNC");
1776 responseBuilder.setAckFinalIndicator("Y");
1777 RpcResult<BrgTopologyOperationOutput> rpcResult = RpcResultBuilder.<BrgTopologyOperationOutput>status(true)
1778 .withResult(responseBuilder.build()).build();
1779 return Futures.immediateFuture(rpcResult);
1782 log.info("Adding INPUT data for {} [{}] input: {}", SVC_OPERATION, siid, input);
1783 BrgTopologyOperationInputBuilder inputBuilder = new BrgTopologyOperationInputBuilder(input);
1784 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1786 // Call SLI sync method
1787 // Get SvcLogicService reference
1789 Properties respProps = null;
1791 String errorCode = "200";
1792 String errorMessage = null;
1793 String ackFinal = "Y";
1794 String allottedResourceId = "error";
1795 String serviceObjectPath = null;
1796 String brgObjectPath = null;
1799 if (svcLogicClient.hasGraph(appName, SVC_OPERATION, null, "sync")) {
1802 respProps = svcLogicClient.execute(appName, SVC_OPERATION, null, "sync", parms);
1803 } catch (Exception e) {
1804 log.error("Caught exception executing service logic for {}", SVC_OPERATION, e);
1805 errorMessage = e.getMessage();
1809 errorMessage = "No service logic active for " + appName + ": '" + SVC_OPERATION + "'";
1812 } catch (Exception e) {
1814 errorMessage = e.getMessage();
1815 log.error("Caught exception looking for service logic", e);
1818 if (respProps != null) {
1819 errorCode = respProps.getProperty("error-code");
1820 errorMessage = respProps.getProperty("error-message");
1821 ackFinal = respProps.getProperty("ack-final", "Y");
1822 allottedResourceId = respProps.getProperty("allotted-resource-id");
1823 serviceObjectPath = respProps.getProperty("service-object-path");
1824 brgObjectPath = respProps.getProperty("brg-object-path");
1827 if (errorCode != null && errorCode.length() != 0 && !(errorCode.equals("0") || errorCode.equals("200"))) {
1828 responseBuilder.setResponseCode(errorCode);
1829 responseBuilder.setResponseMessage(errorMessage);
1830 responseBuilder.setAckFinalIndicator(ackFinal);
1832 log.error("Returned FAILED for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
1834 RpcResult<BrgTopologyOperationOutput> rpcResult = RpcResultBuilder.<BrgTopologyOperationOutput>status(true)
1835 .withResult(responseBuilder.build()).build();
1836 return Futures.immediateFuture(rpcResult);
1839 // Got success from SLI
1843 BrgResponseInformationBuilder brgResponseInformationBuilder = new BrgResponseInformationBuilder();
1844 brgResponseInformationBuilder.setInstanceId(allottedResourceId);
1845 brgResponseInformationBuilder.setObjectPath(brgObjectPath);
1846 responseBuilder.setBrgResponseInformation(brgResponseInformationBuilder.build());
1848 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1849 serviceResponseInformationBuilder.setInstanceId(siid);
1850 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1851 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1853 } catch (IllegalStateException e) {
1854 log.error("Caught Exception updating MD-SAL for {} [{}] \n", SVC_OPERATION, siid, e);
1855 responseBuilder.setResponseCode("500");
1856 responseBuilder.setResponseMessage(e.toString());
1857 responseBuilder.setAckFinalIndicator("Y");
1858 log.error("Returned FAILED for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
1859 RpcResult<BrgTopologyOperationOutput> rpcResult = RpcResultBuilder.<BrgTopologyOperationOutput>status(true)
1860 .withResult(responseBuilder.build()).build();
1861 return Futures.immediateFuture(rpcResult);
1865 responseBuilder.setResponseCode(errorCode);
1866 responseBuilder.setAckFinalIndicator(ackFinal);
1867 if (errorMessage != null) {
1868 responseBuilder.setResponseMessage(errorMessage);
1870 log.info("Updated MD-SAL for {} [{}]", SVC_OPERATION, siid);
1871 log.info("Returned SUCCESS for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
1873 RpcResult<BrgTopologyOperationOutput> rpcResult = RpcResultBuilder.<BrgTopologyOperationOutput>status(true)
1874 .withResult(responseBuilder.build()).build();
1875 return Futures.immediateFuture(rpcResult);
1879 public Future<RpcResult<PreloadVnfTopologyOperationOutput>> preloadVnfTopologyOperation(
1880 PreloadVnfTopologyOperationInput input) {
1882 final String SVC_OPERATION = "preload-vnf-topology-operation";
1883 PreloadData preloadData;
1884 Properties parms = new Properties();
1886 log.info("{} called.", SVC_OPERATION);
1887 // create a new response object
1888 PreloadVnfTopologyOperationOutputBuilder responseBuilder = new PreloadVnfTopologyOperationOutputBuilder();
1890 // Result from savePreloadData
1891 final SettableFuture<RpcResult<Void>> futureResult = SettableFuture.create();
1893 if (input == null || input.getVnfTopologyInformation() == null
1894 || input.getVnfTopologyInformation().getVnfTopologyIdentifier() == null) {
1895 log.debug("exiting {} because of null input", SVC_OPERATION);
1896 responseBuilder.setResponseCode("403");
1897 responseBuilder.setResponseMessage("invalid input: input is null");
1898 responseBuilder.setAckFinalIndicator("Y");
1899 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult = RpcResultBuilder
1900 .<PreloadVnfTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1901 return Futures.immediateFuture(rpcResult);
1904 // Grab the name and type from the input buffer
1905 String preload_name = input.getVnfTopologyInformation().getVnfTopologyIdentifier().getVnfName();
1906 String preload_type = input.getVnfTopologyInformation().getVnfTopologyIdentifier().getVnfType();
1908 // Make sure we have a preload_name and preload_type
1909 if (preload_name == null || preload_name.length() == 0 || preload_type == null || preload_type.length() == 0) {
1910 log.debug("exiting {} vnf-name or vnf-type is null or empty", SVC_OPERATION);
1911 responseBuilder.setResponseCode("403");
1912 responseBuilder.setResponseMessage("invalid input: vnf-name or vnf-type is null or empty");
1913 responseBuilder.setAckFinalIndicator("Y");
1914 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult = RpcResultBuilder
1915 .<PreloadVnfTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1916 return Futures.immediateFuture(rpcResult);
1919 if (input.getSdncRequestHeader() != null) {
1920 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1923 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
1924 getPreloadData(preload_name, preload_type, preloadDataBuilder);
1926 PreloadDataBuilder operDataBuilder = new PreloadDataBuilder();
1927 getPreloadData(preload_name, preload_type, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
1929 // setup a preload-data object builder
1930 // ACTION preload-vnf-topology-operation
1932 // USES sdnc-request-header;
1933 // USES request-information;
1934 // uses vnf-topology-information;
1936 // USES vnf-topology-response-body;
1938 // container preload-data
1939 // uses vnf-topology-information;
1940 // uses network-topology-information;
1941 // uses oper-status;
1943 log.info("Adding INPUT data for {} [{},{}] input: {}", SVC_OPERATION, preload_name, preload_type, input);
1944 PreloadVnfTopologyOperationInputBuilder inputBuilder = new PreloadVnfTopologyOperationInputBuilder(input);
1945 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1946 log.info("Adding OPERATIONAL data for {} [{},{}] operational-data: {}", SVC_OPERATION, preload_name,
1947 preload_type, operDataBuilder.build());
1948 GenericResourceApiUtil.toProperties(parms, "operational-data", operDataBuilder);
1950 // Call SLI sync method
1951 // Get SvcLogicService reference
1953 Properties respProps = null;
1955 String errorCode = "200";
1956 String errorMessage = null;
1957 String ackFinal = "Y";
1960 if (svcLogicClient.hasGraph(appName, SVC_OPERATION, null, "sync")) {
1963 respProps = svcLogicClient.execute(appName, SVC_OPERATION, null, "sync", preloadDataBuilder, parms);
1964 } catch (Exception e) {
1965 log.error("Caught exception executing service logic for {}", SVC_OPERATION, e);
1966 errorMessage = e.getMessage();
1970 errorMessage = "No service logic active for " + appName + ": '" + SVC_OPERATION + "'";
1973 } catch (Exception e) {
1975 errorMessage = e.getMessage();
1976 log.error("Caught exception looking for service logic", e);
1979 if (respProps != null) {
1980 errorCode = respProps.getProperty("error-code");
1981 errorMessage = respProps.getProperty("error-message");
1982 ackFinal = respProps.getProperty("ack-final", "Y");
1983 // internalError = respProps.getProperty("internal-error", "false");
1986 if (errorCode != null && errorCode.length() != 0 && !(errorCode.equals("0") || errorCode.equals("200"))) {
1988 responseBuilder.setResponseCode(errorCode);
1989 responseBuilder.setResponseMessage(errorMessage);
1990 responseBuilder.setAckFinalIndicator(ackFinal);
1992 VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
1993 preloadVnfListBuilder.setVnfName(preload_name);
1994 preloadVnfListBuilder.setVnfType(preload_type);
1995 preloadVnfListBuilder.setPreloadData(preloadDataBuilder.build());
1996 log.error("Returned FAILED for {} [{},{}] error code: '{}', Reason: '{}'", SVC_OPERATION, preload_name,
1997 preload_type, errorCode, errorMessage);
1999 savePreloadList(preloadVnfListBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
2000 } catch (Exception e) {
2001 log.error("Caught Exception updating MD-SAL for {} [{},{}] \n", SVC_OPERATION, preload_name,
2004 log.debug("Sending Success rpc result due to external error");
2005 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult = RpcResultBuilder
2006 .<PreloadVnfTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2007 return Futures.immediateFuture(rpcResult);
2010 // Got success from SLI
2012 preloadData = preloadDataBuilder.build();
2013 log.info("Updating MD-SAL for {} [{},{}] preloadData: {}", SVC_OPERATION, preload_name, preload_type,
2015 // svc-configuration-list
2016 VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
2017 preloadVnfListBuilder.setVnfName(preload_name);
2018 preloadVnfListBuilder.setVnfType(preload_type);
2019 preloadVnfListBuilder.setPreloadData(preloadData);
2021 // merge flag sets to false to allow it to be overwritten (not appended)
2022 savePreloadList(preloadVnfListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
2023 log.info("Updating OPERATIONAL tree.");
2024 savePreloadList(preloadVnfListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
2025 } catch (Exception e) {
2026 log.error("Caught Exception updating MD-SAL for {} [{},{}] \n", SVC_OPERATION, preload_name, preload_type,
2028 responseBuilder.setResponseCode("500");
2029 responseBuilder.setResponseMessage(e.toString());
2030 responseBuilder.setAckFinalIndicator("Y");
2031 log.error("Returned FAILED for {} [{},{}] {}", SVC_OPERATION, preload_name, preload_type,
2032 responseBuilder.build());
2033 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult = RpcResultBuilder
2034 .<PreloadVnfTopologyOperationOutput>status(false).withResult(responseBuilder.build()).build();
2035 return Futures.immediateFuture(rpcResult);
2039 responseBuilder.setResponseCode(errorCode);
2040 responseBuilder.setAckFinalIndicator(ackFinal);
2041 if (errorMessage != null) {
2042 responseBuilder.setResponseMessage(errorMessage);
2044 log.info("Updated MD-SAL for {} [{},{}]", SVC_OPERATION, preload_name, preload_type);
2045 log.info("Returned SUCCESS for {} [{},{}] {}", SVC_OPERATION, preload_name, preload_type,
2046 responseBuilder.build());
2048 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult = RpcResultBuilder
2049 .<PreloadVnfTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2050 return Futures.immediateFuture(rpcResult);
2054 public Future<RpcResult<PreloadNetworkTopologyOperationOutput>> preloadNetworkTopologyOperation(
2055 PreloadNetworkTopologyOperationInput input) {
2057 final String SVC_OPERATION = "preload-network-topology-operation";
2058 PreloadData preloadData;
2059 Properties parms = new Properties();
2061 log.info("{} called.", SVC_OPERATION);
2062 // create a new response object
2063 PreloadNetworkTopologyOperationOutputBuilder responseBuilder = new PreloadNetworkTopologyOperationOutputBuilder();
2065 // Result from savePreloadData
2066 final SettableFuture<RpcResult<Void>> futureResult = SettableFuture.create();
2068 if (input == null || input.getNetworkTopologyInformation() == null
2069 || input.getNetworkTopologyInformation().getNetworkTopologyIdentifier() == null) {
2071 log.debug("exiting {} because of null input", SVC_OPERATION);
2072 responseBuilder.setResponseCode("403");
2073 responseBuilder.setResponseMessage("input is null");
2074 responseBuilder.setAckFinalIndicator("Y");
2075 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
2076 .<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2077 return Futures.immediateFuture(rpcResult);
2080 // Grab the name and type from the input buffer
2081 String preload_name = input.getNetworkTopologyInformation().getNetworkTopologyIdentifier().getNetworkName();
2082 String preload_type = input.getNetworkTopologyInformation().getNetworkTopologyIdentifier().getNetworkType();
2084 // Make sure we have a preload_name and preload_type
2085 if (preload_name == null || preload_name.length() == 0 || preload_type == null || preload_type.length() == 0) {
2086 log.debug("exiting {} because of invalid preload-name", SVC_OPERATION);
2087 responseBuilder.setResponseCode("403");
2088 responseBuilder.setResponseMessage("input, invalid preload-name");
2089 responseBuilder.setAckFinalIndicator("Y");
2090 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
2091 .<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2092 return Futures.immediateFuture(rpcResult);
2095 if (input.getSdncRequestHeader() != null) {
2096 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
2099 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
2100 getPreloadData(preload_name, preload_type, preloadDataBuilder);
2102 PreloadDataBuilder operDataBuilder = new PreloadDataBuilder();
2103 getPreloadData(preload_name, preload_type, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
2106 // setup a preload-data object builder
2107 // ACTION preload-network-topology-operation
2109 // USES sdnc-request-header;
2110 // USES request-information;
2111 // uses network-topology-information;
2113 // USES vnf-topology-response-body;
2115 // container preload-data
2116 // uses vnf-topology-information;
2117 // uses network-topology-information;
2118 // uses oper-status;
2120 log.info("Adding INPUT data for {} [{},{}] input: {}", SVC_OPERATION, preload_name, preload_type, input);
2121 PreloadNetworkTopologyOperationInputBuilder inputBuilder = new PreloadNetworkTopologyOperationInputBuilder(
2123 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
2124 log.info("Adding OPERATIONAL data for {} [{},{}] operational-data: {}", SVC_OPERATION, preload_name,
2125 preload_type, operDataBuilder.build());
2126 GenericResourceApiUtil.toProperties(parms, "operational-data", operDataBuilder);
2128 // Call SLI sync method
2129 // Get SvcLogicService reference
2131 Properties respProps = null;
2133 String errorCode = "200";
2134 String errorMessage = null;
2135 String ackFinal = "Y";
2138 if (svcLogicClient.hasGraph(appName, SVC_OPERATION, null, "sync")) {
2141 respProps = svcLogicClient.execute(appName, SVC_OPERATION, null, "sync", preloadDataBuilder, parms);
2142 } catch (Exception e) {
2143 log.error("Caught exception executing service logic for {}", SVC_OPERATION, e);
2144 errorMessage = e.getMessage();
2148 errorMessage = "No service logic active for " + appName + ": '" + SVC_OPERATION + "'";
2151 } catch (Exception e) {
2153 errorMessage = e.getMessage();
2154 log.error("Caught exception looking for service logic", e);
2157 if (respProps != null) {
2158 errorCode = respProps.getProperty("error-code");
2159 errorMessage = respProps.getProperty("error-message");
2160 ackFinal = respProps.getProperty("ack-final", "Y");
2161 // internalError = respProps.getProperty("internal-error", "false");
2164 if (errorCode != null && errorCode.length() != 0 && !(errorCode.equals("0") || errorCode.equals("200"))) {
2166 responseBuilder.setResponseCode(errorCode);
2167 responseBuilder.setResponseMessage(errorMessage);
2168 responseBuilder.setAckFinalIndicator(ackFinal);
2170 VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
2171 preloadVnfListBuilder.setVnfName(preload_name);
2172 preloadVnfListBuilder.setVnfType(preload_type);
2173 preloadVnfListBuilder.setPreloadData(preloadDataBuilder.build());
2174 log.error("Returned FAILED for {} [{},{}] error code: '{}', Reason: '{}'", SVC_OPERATION, preload_name,
2175 preload_type, errorCode, errorMessage);
2177 savePreloadList(preloadVnfListBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
2178 } catch (Exception e) {
2179 log.error("Caught Exception updating MD-SAL for {} [{},{}] \n", SVC_OPERATION, preload_name,
2183 log.debug("Sending Success rpc result due to external error");
2184 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
2185 .<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2186 return Futures.immediateFuture(rpcResult);
2189 // Got success from SLI
2191 preloadData = preloadDataBuilder.build();
2192 log.info("Updating MD-SAL for {} [{},{}] preloadData: {}", SVC_OPERATION, preload_name, preload_type,
2194 // svc-configuration-list
2195 VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
2196 preloadVnfListBuilder.setVnfName(preload_name);
2197 preloadVnfListBuilder.setVnfType(preload_type);
2198 preloadVnfListBuilder.setPreloadData(preloadData);
2200 // merge flag sets to false to allow it to be overwritten (not appended)
2201 savePreloadList(preloadVnfListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
2202 log.info("Updating OPERATIONAL tree.");
2203 savePreloadList(preloadVnfListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
2204 } catch (Exception e) {
2205 log.error("Caught Exception updating MD-SAL for " + SVC_OPERATION + " [" + preload_name + "," + preload_type
2207 responseBuilder.setResponseCode("500");
2208 responseBuilder.setResponseMessage(e.toString());
2209 responseBuilder.setAckFinalIndicator("Y");
2210 log.error("Returned FAILED for {} [{},{}] {}", SVC_OPERATION, preload_name, preload_type,
2211 responseBuilder.build());
2212 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
2213 .<PreloadNetworkTopologyOperationOutput>status(false).withResult(responseBuilder.build()).build();
2214 return Futures.immediateFuture(rpcResult);
2218 responseBuilder.setResponseCode(errorCode);
2219 responseBuilder.setAckFinalIndicator(ackFinal);
2220 if (errorMessage != null) {
2221 responseBuilder.setResponseMessage(errorMessage);
2223 log.info("Updated MD-SAL for {} [{},{}]", SVC_OPERATION, preload_name, preload_type);
2224 log.info("Returned SUCCESS for {} [{},{}] {}", SVC_OPERATION, preload_name, preload_type,
2225 responseBuilder.build());
2227 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
2228 .<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2229 return Futures.immediateFuture(rpcResult);