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 log.info("Updating OPERATIONAL tree.");
1231 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1235 NetworkResponseInformationBuilder networkResponseInformationBuilder = new NetworkResponseInformationBuilder();
1236 networkResponseInformationBuilder.setInstanceId(networkId);
1237 networkResponseInformationBuilder.setObjectPath(networkObjectPath);
1238 responseBuilder.setNetworkResponseInformation(networkResponseInformationBuilder.build());
1240 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1241 serviceResponseInformationBuilder.setInstanceId(siid);
1242 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1243 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1245 } catch (IllegalStateException e) {
1246 log.error("Caught Exception updating MD-SAL for {} [{}] \n", SVC_OPERATION, siid, e);
1247 responseBuilder.setResponseCode("500");
1248 responseBuilder.setResponseMessage(e.toString());
1249 responseBuilder.setAckFinalIndicator("Y");
1250 log.error("Returned FAILED for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
1251 RpcResult<NetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
1252 .<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1253 return Futures.immediateFuture(rpcResult);
1257 responseBuilder.setResponseCode(errorCode);
1258 responseBuilder.setAckFinalIndicator(ackFinal);
1259 if (errorMessage != null) {
1260 responseBuilder.setResponseMessage(errorMessage);
1262 log.info("Updated MD-SAL for {} [{}]", SVC_OPERATION, siid);
1263 log.info("Returned SUCCESS for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
1265 RpcResult<NetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
1266 .<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1267 return Futures.immediateFuture(rpcResult);
1271 public Future<RpcResult<ContrailRouteTopologyOperationOutput>> contrailRouteTopologyOperation(
1272 ContrailRouteTopologyOperationInput input) {
1274 final String SVC_OPERATION = "contrail-route-topology-operation";
1275 ServiceData serviceData;
1276 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1277 Properties parms = new Properties();
1279 log.info("{} called.", SVC_OPERATION);
1280 // create a new response object
1281 ContrailRouteTopologyOperationOutputBuilder responseBuilder = new ContrailRouteTopologyOperationOutputBuilder();
1283 if (input == null || input.getServiceInformation() == null
1284 || input.getServiceInformation().getServiceInstanceId() == null
1285 || input.getServiceInformation().getServiceInstanceId().length() == 0) {
1286 log.debug("exiting {} because of null or empty service-instance-id", SVC_OPERATION);
1287 responseBuilder.setResponseCode("404");
1288 responseBuilder.setResponseMessage("invalid input, null or empty service-instance-id");
1289 responseBuilder.setAckFinalIndicator("Y");
1290 RpcResult<ContrailRouteTopologyOperationOutput> rpcResult = RpcResultBuilder
1291 .<ContrailRouteTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1292 return Futures.immediateFuture(rpcResult);
1295 String siid = input.getServiceInformation().getServiceInstanceId();
1297 // Get the service-instance service data from MD-SAL
1298 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1299 getServiceData(siid, serviceDataBuilder);
1301 if (input.getSdncRequestHeader() != null) {
1302 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1305 ServiceData sd = serviceDataBuilder.build();
1306 if (sd == null || sd.getServiceLevelOperStatus() == null) {
1307 log.debug("exiting {} because the service-instance does not have any service data in SDNC", SVC_OPERATION);
1308 responseBuilder.setResponseCode("404");
1310 .setResponseMessage("invalid input: the service-instance does not have any service data in SDNC");
1311 responseBuilder.setAckFinalIndicator("Y");
1312 RpcResult<ContrailRouteTopologyOperationOutput> rpcResult = RpcResultBuilder
1313 .<ContrailRouteTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1314 return Futures.immediateFuture(rpcResult);
1317 log.info("Adding INPUT data for " + SVC_OPERATION + " [" + siid + "] input: " + input);
1318 ContrailRouteTopologyOperationInputBuilder inputBuilder = new ContrailRouteTopologyOperationInputBuilder(input);
1319 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1321 // Call SLI sync method
1322 // Get SvcLogicService reference
1324 Properties respProps = null;
1326 String errorCode = "200";
1327 String errorMessage = null;
1328 String ackFinal = "Y";
1329 String allottedResourceId = "error";
1330 String serviceObjectPath = null;
1331 String contrailRouteObjectPath = null;
1334 if (svcLogicClient.hasGraph(appName, SVC_OPERATION, null, "sync")) {
1337 respProps = svcLogicClient.execute(appName, SVC_OPERATION, null, "sync", serviceDataBuilder, parms);
1338 } catch (Exception e) {
1339 log.error("Caught exception executing service logic for {}", SVC_OPERATION, e);
1340 errorMessage = e.getMessage();
1344 errorMessage = "No service logic active for " + appName + ": '" + SVC_OPERATION + "'";
1347 } catch (Exception e) {
1349 errorMessage = e.getMessage();
1350 log.error("Caught exception looking for service logic", e);
1353 if (respProps != null) {
1354 errorCode = respProps.getProperty("error-code");
1355 errorMessage = respProps.getProperty("error-message");
1356 ackFinal = respProps.getProperty("ack-final", "Y");
1357 allottedResourceId = respProps.getProperty("allotted-resource-id");
1358 serviceObjectPath = respProps.getProperty("service-object-path");
1359 contrailRouteObjectPath = respProps.getProperty("contrail-route-object-path");
1362 if (errorCode != null && errorCode.length() != 0 && !(errorCode.equals("0") || errorCode.equals("200"))) {
1363 responseBuilder.setResponseCode(errorCode);
1364 responseBuilder.setResponseMessage(errorMessage);
1365 responseBuilder.setAckFinalIndicator(ackFinal);
1367 log.error("Returned FAILED for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
1369 RpcResult<ContrailRouteTopologyOperationOutput> rpcResult = RpcResultBuilder
1370 .<ContrailRouteTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1371 return Futures.immediateFuture(rpcResult);
1374 // Got success from SLI
1377 serviceData = serviceDataBuilder.build();
1378 log.info("Updating MD-SAL for {} [{}] ServiceData: {}", SVC_OPERATION, siid, serviceData);
1381 ServiceBuilder serviceBuilder = new ServiceBuilder();
1382 serviceBuilder.setServiceData(serviceData);
1383 serviceBuilder.setServiceInstanceId(siid);
1384 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1385 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1387 if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null) {
1388 // Only update operational tree on activate or delete
1389 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Unassign)
1390 || input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate)) {
1391 log.info("Updating OPERATIONAL tree.");
1392 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1396 ContrailRouteResponseInformationBuilder contrailRouteResponseInformationBuilder = new ContrailRouteResponseInformationBuilder();
1397 contrailRouteResponseInformationBuilder.setInstanceId(allottedResourceId);
1398 contrailRouteResponseInformationBuilder.setObjectPath(contrailRouteObjectPath);
1399 responseBuilder.setContrailRouteResponseInformation(contrailRouteResponseInformationBuilder.build());
1401 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1402 serviceResponseInformationBuilder.setInstanceId(siid);
1403 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1404 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1406 } catch (IllegalStateException e) {
1407 log.error("Caught Exception updating MD-SAL for {} [{}] \n", SVC_OPERATION, siid, e);
1408 responseBuilder.setResponseCode("500");
1409 responseBuilder.setResponseMessage(e.toString());
1410 responseBuilder.setAckFinalIndicator("Y");
1411 log.error("Returned FAILED for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
1412 RpcResult<ContrailRouteTopologyOperationOutput> rpcResult = RpcResultBuilder
1413 .<ContrailRouteTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1414 return Futures.immediateFuture(rpcResult);
1418 responseBuilder.setResponseCode(errorCode);
1419 responseBuilder.setAckFinalIndicator(ackFinal);
1420 if (errorMessage != null) {
1421 responseBuilder.setResponseMessage(errorMessage);
1423 log.info("Updated MD-SAL for {} [{}]", SVC_OPERATION, siid);
1424 log.info("Returned SUCCESS for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
1426 RpcResult<ContrailRouteTopologyOperationOutput> rpcResult = RpcResultBuilder
1427 .<ContrailRouteTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1428 return Futures.immediateFuture(rpcResult);
1432 public Future<RpcResult<SecurityZoneTopologyOperationOutput>> securityZoneTopologyOperation(
1433 SecurityZoneTopologyOperationInput input) {
1435 final String SVC_OPERATION = "security-zone-topology-operation";
1436 ServiceData serviceData;
1437 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1438 Properties parms = new Properties();
1440 log.info("{} called.", SVC_OPERATION);
1441 // create a new response object
1442 SecurityZoneTopologyOperationOutputBuilder responseBuilder = new SecurityZoneTopologyOperationOutputBuilder();
1444 if (input == null || input.getServiceInformation() == null
1445 || input.getServiceInformation().getServiceInstanceId() == null
1446 || input.getServiceInformation().getServiceInstanceId().length() == 0) {
1447 log.debug("exiting {} because of null or empty service-instance-id", SVC_OPERATION);
1448 responseBuilder.setResponseCode("404");
1449 responseBuilder.setResponseMessage("invalid input, null or empty service-instance-id");
1450 responseBuilder.setAckFinalIndicator("Y");
1451 RpcResult<SecurityZoneTopologyOperationOutput> rpcResult = RpcResultBuilder
1452 .<SecurityZoneTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1453 return Futures.immediateFuture(rpcResult);
1456 String siid = input.getServiceInformation().getServiceInstanceId();
1458 // Get the service-instance service data from MD-SAL
1459 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1460 getServiceData(siid, serviceDataBuilder);
1462 if (input.getSdncRequestHeader() != null) {
1463 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1466 ServiceData sd = serviceDataBuilder.build();
1467 if (sd == null || sd.getServiceLevelOperStatus() == null) {
1468 log.debug("exiting {} because the service-instance does not have any service data in SDNC", SVC_OPERATION);
1469 responseBuilder.setResponseCode("404");
1471 .setResponseMessage("invalid input: the service-instance does not have any service data in SDNC");
1472 responseBuilder.setAckFinalIndicator("Y");
1473 RpcResult<SecurityZoneTopologyOperationOutput> rpcResult = RpcResultBuilder
1474 .<SecurityZoneTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1475 return Futures.immediateFuture(rpcResult);
1478 log.info("Adding INPUT data for {} [{}] input: {}", SVC_OPERATION, siid, input);
1479 SecurityZoneTopologyOperationInputBuilder inputBuilder = new SecurityZoneTopologyOperationInputBuilder(input);
1480 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1482 // Call SLI sync method
1483 // Get SvcLogicService reference
1485 Properties respProps = null;
1487 String errorCode = "200";
1488 String errorMessage = null;
1489 String ackFinal = "Y";
1490 String allottedResourceId = "error";
1491 String serviceObjectPath = null;
1492 String securityZoneObjectPath = null;
1495 if (svcLogicClient.hasGraph(appName, SVC_OPERATION, null, "sync")) {
1498 respProps = svcLogicClient.execute(appName, SVC_OPERATION, null, "sync", serviceDataBuilder, parms);
1499 } catch (Exception e) {
1500 log.error("Caught exception executing service logic for {}", SVC_OPERATION, e);
1501 errorMessage = e.getMessage();
1505 errorMessage = "No service logic active for " + appName + ": '" + SVC_OPERATION + "'";
1508 } catch (Exception e) {
1510 errorMessage = e.getMessage();
1511 log.error("Caught exception looking for service logic", e);
1514 if (respProps != null) {
1515 errorCode = respProps.getProperty("error-code");
1516 errorMessage = respProps.getProperty("error-message");
1517 ackFinal = respProps.getProperty("ack-final", "Y");
1518 allottedResourceId = respProps.getProperty("allotted-resource-id");
1519 serviceObjectPath = respProps.getProperty("service-object-path");
1520 securityZoneObjectPath = respProps.getProperty("security-zone-object-path");
1523 if (errorCode != null && errorCode.length() != 0 && !(errorCode.equals("0") || errorCode.equals("200"))) {
1524 responseBuilder.setResponseCode(errorCode);
1525 responseBuilder.setResponseMessage(errorMessage);
1526 responseBuilder.setAckFinalIndicator(ackFinal);
1528 log.error("Returned FAILED for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
1530 RpcResult<SecurityZoneTopologyOperationOutput> rpcResult = RpcResultBuilder
1531 .<SecurityZoneTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1532 return Futures.immediateFuture(rpcResult);
1535 // Got success from SLI
1538 serviceData = serviceDataBuilder.build();
1539 log.info("Updating MD-SAL for {} [{}] ServiceData: {}", SVC_OPERATION, siid, serviceData);
1542 ServiceBuilder serviceBuilder = new ServiceBuilder();
1543 serviceBuilder.setServiceData(serviceData);
1544 serviceBuilder.setServiceInstanceId(siid);
1545 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1546 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1548 if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null) {
1549 // Only update operational tree on activate or delete
1550 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Unassign)
1551 || input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate)) {
1552 log.info("Updating OPERATIONAL tree.");
1553 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1557 SecurityZoneResponseInformationBuilder securityZoneResponseInformationBuilder = new SecurityZoneResponseInformationBuilder();
1558 securityZoneResponseInformationBuilder.setInstanceId(allottedResourceId);
1559 securityZoneResponseInformationBuilder.setObjectPath(securityZoneObjectPath);
1560 responseBuilder.setSecurityZoneResponseInformation(securityZoneResponseInformationBuilder.build());
1562 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1563 serviceResponseInformationBuilder.setInstanceId(siid);
1564 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1565 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1567 } catch (IllegalStateException e) {
1568 log.error("Caught Exception updating MD-SAL for {} [{}] \n", SVC_OPERATION, siid, e);
1569 responseBuilder.setResponseCode("500");
1570 responseBuilder.setResponseMessage(e.toString());
1571 responseBuilder.setAckFinalIndicator("Y");
1572 log.error("Returned FAILED for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
1573 RpcResult<SecurityZoneTopologyOperationOutput> rpcResult = RpcResultBuilder
1574 .<SecurityZoneTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1575 return Futures.immediateFuture(rpcResult);
1579 responseBuilder.setResponseCode(errorCode);
1580 responseBuilder.setAckFinalIndicator(ackFinal);
1581 if (errorMessage != null) {
1582 responseBuilder.setResponseMessage(errorMessage);
1584 log.info("Updated MD-SAL for {} [{}]", SVC_OPERATION, siid);
1585 log.info("Returned SUCCESS for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
1587 RpcResult<SecurityZoneTopologyOperationOutput> rpcResult = RpcResultBuilder
1588 .<SecurityZoneTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1589 return Futures.immediateFuture(rpcResult);
1593 public Future<RpcResult<TunnelxconnTopologyOperationOutput>> tunnelxconnTopologyOperation(
1594 TunnelxconnTopologyOperationInput input) {
1596 final String SVC_OPERATION = "tunnelxconn-topology-operation";
1597 ServiceData serviceData;
1598 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1599 Properties parms = new Properties();
1601 log.info("{} called.", SVC_OPERATION);
1602 // create a new response object
1603 TunnelxconnTopologyOperationOutputBuilder responseBuilder = new TunnelxconnTopologyOperationOutputBuilder();
1605 if (input == null || input.getServiceInformation() == null
1606 || input.getServiceInformation().getServiceInstanceId() == null
1607 || input.getServiceInformation().getServiceInstanceId().length() == 0) {
1608 log.debug("exiting {} because of null or empty service-instance-id", SVC_OPERATION);
1609 responseBuilder.setResponseCode("404");
1610 responseBuilder.setResponseMessage("invalid input, null or empty service-instance-id");
1611 responseBuilder.setAckFinalIndicator("Y");
1612 RpcResult<TunnelxconnTopologyOperationOutput> rpcResult = RpcResultBuilder
1613 .<TunnelxconnTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1614 return Futures.immediateFuture(rpcResult);
1617 String siid = input.getServiceInformation().getServiceInstanceId();
1619 // Get the service-instance service data from MD-SAL
1620 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1621 getServiceData(siid, serviceDataBuilder);
1623 if (input.getSdncRequestHeader() != null) {
1624 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1627 ServiceData sd = serviceDataBuilder.build();
1628 if (sd == null || sd.getServiceLevelOperStatus() == null) {
1629 log.debug("exiting {} because the service-instance does not have any service data in SDNC", SVC_OPERATION);
1630 responseBuilder.setResponseCode("404");
1632 .setResponseMessage("invalid input: the service-instance does not have any service data in SDNC");
1633 responseBuilder.setAckFinalIndicator("Y");
1634 RpcResult<TunnelxconnTopologyOperationOutput> rpcResult = RpcResultBuilder
1635 .<TunnelxconnTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1636 return Futures.immediateFuture(rpcResult);
1639 log.info("Adding INPUT data for {} [{}] input: {}", SVC_OPERATION, siid, input);
1640 TunnelxconnTopologyOperationInputBuilder inputBuilder = new TunnelxconnTopologyOperationInputBuilder(input);
1641 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1643 // Call SLI sync method
1644 // Get SvcLogicService reference
1646 Properties respProps = null;
1648 String errorCode = "200";
1649 String errorMessage = null;
1650 String ackFinal = "Y";
1651 String allottedResourceId = "error";
1652 String serviceObjectPath = null;
1653 String tunnelxconnObjectPath = null;
1656 if (svcLogicClient.hasGraph(appName, SVC_OPERATION, null, "sync")) {
1659 respProps = svcLogicClient.execute(appName, SVC_OPERATION, null, "sync", parms);
1660 } catch (Exception e) {
1661 log.error("Caught exception executing service logic for {}", SVC_OPERATION, e);
1662 errorMessage = e.getMessage();
1666 errorMessage = "No service logic active for " + appName + ": '" + SVC_OPERATION + "'";
1669 } catch (Exception e) {
1671 errorMessage = e.getMessage();
1672 log.error("Caught exception looking for service logic", e);
1675 if (respProps != null) {
1676 errorCode = respProps.getProperty("error-code");
1677 errorMessage = respProps.getProperty("error-message");
1678 ackFinal = respProps.getProperty("ack-final", "Y");
1679 allottedResourceId = respProps.getProperty("allotted-resource-id");
1680 serviceObjectPath = respProps.getProperty("service-object-path");
1681 tunnelxconnObjectPath = respProps.getProperty("tunnelxconn-object-path");
1684 if (errorCode != null && errorCode.length() != 0 && !(errorCode.equals("0") || errorCode.equals("200"))) {
1685 responseBuilder.setResponseCode(errorCode);
1686 responseBuilder.setResponseMessage(errorMessage);
1687 responseBuilder.setAckFinalIndicator(ackFinal);
1689 log.error("Returned FAILED for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
1691 RpcResult<TunnelxconnTopologyOperationOutput> rpcResult = RpcResultBuilder
1692 .<TunnelxconnTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1693 return Futures.immediateFuture(rpcResult);
1696 // Got success from SLI
1701 TunnelxconnResponseInformationBuilder tunnelxconnResponseInformationBuilder = new TunnelxconnResponseInformationBuilder();
1702 tunnelxconnResponseInformationBuilder.setInstanceId(allottedResourceId);
1703 tunnelxconnResponseInformationBuilder.setObjectPath(tunnelxconnObjectPath);
1704 responseBuilder.setTunnelxconnResponseInformation(tunnelxconnResponseInformationBuilder.build());
1706 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1707 serviceResponseInformationBuilder.setInstanceId(siid);
1708 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1709 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1711 } catch (IllegalStateException e) {
1712 log.error("Caught Exception updating MD-SAL for {} [{}] \n", SVC_OPERATION, siid, e);
1713 responseBuilder.setResponseCode("500");
1714 responseBuilder.setResponseMessage(e.toString());
1715 responseBuilder.setAckFinalIndicator("Y");
1716 log.error("Returned FAILED for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
1717 RpcResult<TunnelxconnTopologyOperationOutput> rpcResult = RpcResultBuilder
1718 .<TunnelxconnTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1719 return Futures.immediateFuture(rpcResult);
1723 responseBuilder.setResponseCode(errorCode);
1724 responseBuilder.setAckFinalIndicator(ackFinal);
1725 if (errorMessage != null) {
1726 responseBuilder.setResponseMessage(errorMessage);
1728 log.info("Updated MD-SAL for {} [{}]", SVC_OPERATION, siid);
1729 log.info("Returned SUCCESS for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
1731 RpcResult<TunnelxconnTopologyOperationOutput> rpcResult = RpcResultBuilder
1732 .<TunnelxconnTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1733 return Futures.immediateFuture(rpcResult);
1737 public Future<RpcResult<BrgTopologyOperationOutput>> brgTopologyOperation(BrgTopologyOperationInput input) {
1738 final String SVC_OPERATION = "brg-topology-operation";
1739 ServiceData serviceData;
1740 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1741 Properties parms = new Properties();
1743 log.info("{} called.", SVC_OPERATION);
1744 // create a new response object
1745 BrgTopologyOperationOutputBuilder responseBuilder = new BrgTopologyOperationOutputBuilder();
1747 if (input == null || input.getServiceInformation() == null
1748 || input.getServiceInformation().getServiceInstanceId() == null
1749 || input.getServiceInformation().getServiceInstanceId().length() == 0) {
1750 log.debug("exiting {} because of null or empty service-instance-id", SVC_OPERATION);
1751 responseBuilder.setResponseCode("404");
1752 responseBuilder.setResponseMessage("invalid input, null or empty service-instance-id");
1753 responseBuilder.setAckFinalIndicator("Y");
1754 RpcResult<BrgTopologyOperationOutput> rpcResult = RpcResultBuilder.<BrgTopologyOperationOutput>status(true)
1755 .withResult(responseBuilder.build()).build();
1756 return Futures.immediateFuture(rpcResult);
1759 String siid = input.getServiceInformation().getServiceInstanceId();
1761 /* // Get the service-instance service data from MD-SAL
1762 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1763 getServiceData(siid, serviceDataBuilder);
1765 if (input.getSdncRequestHeader() != null) {
1766 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1769 ServiceData sd = serviceDataBuilder.build();
1770 if (sd == null || sd.getServiceLevelOperStatus() == null) {
1771 log.debug("exiting {} because the service-instance does not have any service data in SDNC", SVC_OPERATION);
1772 responseBuilder.setResponseCode("404");
1774 .setResponseMessage("invalid input: the service-instance does not have any service data in SDNC");
1775 responseBuilder.setAckFinalIndicator("Y");
1776 RpcResult<BrgTopologyOperationOutput> rpcResult = RpcResultBuilder.<BrgTopologyOperationOutput>status(true)
1777 .withResult(responseBuilder.build()).build();
1778 return Futures.immediateFuture(rpcResult);
1781 log.info("Adding INPUT data for {} [{}] input: {}", SVC_OPERATION, siid, input);
1782 BrgTopologyOperationInputBuilder inputBuilder = new BrgTopologyOperationInputBuilder(input);
1783 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1785 // Call SLI sync method
1786 // Get SvcLogicService reference
1788 Properties respProps = null;
1790 String errorCode = "200";
1791 String errorMessage = null;
1792 String ackFinal = "Y";
1793 String allottedResourceId = "error";
1794 String serviceObjectPath = null;
1795 String brgObjectPath = null;
1798 if (svcLogicClient.hasGraph(appName, SVC_OPERATION, null, "sync")) {
1801 respProps = svcLogicClient.execute(appName, SVC_OPERATION, null, "sync", parms);
1802 } catch (Exception e) {
1803 log.error("Caught exception executing service logic for {}", SVC_OPERATION, e);
1804 errorMessage = e.getMessage();
1808 errorMessage = "No service logic active for " + appName + ": '" + SVC_OPERATION + "'";
1811 } catch (Exception e) {
1813 errorMessage = e.getMessage();
1814 log.error("Caught exception looking for service logic", e);
1817 if (respProps != null) {
1818 errorCode = respProps.getProperty("error-code");
1819 errorMessage = respProps.getProperty("error-message");
1820 ackFinal = respProps.getProperty("ack-final", "Y");
1821 allottedResourceId = respProps.getProperty("allotted-resource-id");
1822 serviceObjectPath = respProps.getProperty("service-object-path");
1823 brgObjectPath = respProps.getProperty("brg-object-path");
1826 if (errorCode != null && errorCode.length() != 0 && !(errorCode.equals("0") || errorCode.equals("200"))) {
1827 responseBuilder.setResponseCode(errorCode);
1828 responseBuilder.setResponseMessage(errorMessage);
1829 responseBuilder.setAckFinalIndicator(ackFinal);
1831 log.error("Returned FAILED for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
1833 RpcResult<BrgTopologyOperationOutput> rpcResult = RpcResultBuilder.<BrgTopologyOperationOutput>status(true)
1834 .withResult(responseBuilder.build()).build();
1835 return Futures.immediateFuture(rpcResult);
1838 // Got success from SLI
1842 BrgResponseInformationBuilder brgResponseInformationBuilder = new BrgResponseInformationBuilder();
1843 brgResponseInformationBuilder.setInstanceId(allottedResourceId);
1844 brgResponseInformationBuilder.setObjectPath(brgObjectPath);
1845 responseBuilder.setBrgResponseInformation(brgResponseInformationBuilder.build());
1847 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1848 serviceResponseInformationBuilder.setInstanceId(siid);
1849 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1850 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1852 } catch (IllegalStateException e) {
1853 log.error("Caught Exception updating MD-SAL for {} [{}] \n", SVC_OPERATION, siid, e);
1854 responseBuilder.setResponseCode("500");
1855 responseBuilder.setResponseMessage(e.toString());
1856 responseBuilder.setAckFinalIndicator("Y");
1857 log.error("Returned FAILED for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
1858 RpcResult<BrgTopologyOperationOutput> rpcResult = RpcResultBuilder.<BrgTopologyOperationOutput>status(true)
1859 .withResult(responseBuilder.build()).build();
1860 return Futures.immediateFuture(rpcResult);
1864 responseBuilder.setResponseCode(errorCode);
1865 responseBuilder.setAckFinalIndicator(ackFinal);
1866 if (errorMessage != null) {
1867 responseBuilder.setResponseMessage(errorMessage);
1869 log.info("Updated MD-SAL for {} [{}]", SVC_OPERATION, siid);
1870 log.info("Returned SUCCESS for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
1872 RpcResult<BrgTopologyOperationOutput> rpcResult = RpcResultBuilder.<BrgTopologyOperationOutput>status(true)
1873 .withResult(responseBuilder.build()).build();
1874 return Futures.immediateFuture(rpcResult);
1878 public Future<RpcResult<PreloadVnfTopologyOperationOutput>> preloadVnfTopologyOperation(
1879 PreloadVnfTopologyOperationInput input) {
1881 final String SVC_OPERATION = "preload-vnf-topology-operation";
1882 PreloadData preloadData;
1883 Properties parms = new Properties();
1885 log.info("{} called.", SVC_OPERATION);
1886 // create a new response object
1887 PreloadVnfTopologyOperationOutputBuilder responseBuilder = new PreloadVnfTopologyOperationOutputBuilder();
1889 // Result from savePreloadData
1890 final SettableFuture<RpcResult<Void>> futureResult = SettableFuture.create();
1892 if (input == null || input.getVnfTopologyInformation() == null
1893 || input.getVnfTopologyInformation().getVnfTopologyIdentifier() == null) {
1894 log.debug("exiting {} because of null input", SVC_OPERATION);
1895 responseBuilder.setResponseCode("403");
1896 responseBuilder.setResponseMessage("invalid input: input is null");
1897 responseBuilder.setAckFinalIndicator("Y");
1898 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult = RpcResultBuilder
1899 .<PreloadVnfTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1900 return Futures.immediateFuture(rpcResult);
1903 // Grab the name and type from the input buffer
1904 String preload_name = input.getVnfTopologyInformation().getVnfTopologyIdentifier().getVnfName();
1905 String preload_type = input.getVnfTopologyInformation().getVnfTopologyIdentifier().getVnfType();
1907 // Make sure we have a preload_name and preload_type
1908 if (preload_name == null || preload_name.length() == 0 || preload_type == null || preload_type.length() == 0) {
1909 log.debug("exiting {} vnf-name or vnf-type is null or empty", SVC_OPERATION);
1910 responseBuilder.setResponseCode("403");
1911 responseBuilder.setResponseMessage("invalid input: vnf-name or vnf-type is null or empty");
1912 responseBuilder.setAckFinalIndicator("Y");
1913 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult = RpcResultBuilder
1914 .<PreloadVnfTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1915 return Futures.immediateFuture(rpcResult);
1918 if (input.getSdncRequestHeader() != null) {
1919 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1922 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
1923 getPreloadData(preload_name, preload_type, preloadDataBuilder);
1925 PreloadDataBuilder operDataBuilder = new PreloadDataBuilder();
1926 getPreloadData(preload_name, preload_type, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
1928 // setup a preload-data object builder
1929 // ACTION preload-vnf-topology-operation
1931 // USES sdnc-request-header;
1932 // USES request-information;
1933 // uses vnf-topology-information;
1935 // USES vnf-topology-response-body;
1937 // container preload-data
1938 // uses vnf-topology-information;
1939 // uses network-topology-information;
1940 // uses oper-status;
1942 log.info("Adding INPUT data for {} [{},{}] input: {}", SVC_OPERATION, preload_name, preload_type, input);
1943 PreloadVnfTopologyOperationInputBuilder inputBuilder = new PreloadVnfTopologyOperationInputBuilder(input);
1944 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1945 log.info("Adding OPERATIONAL data for {} [{},{}] operational-data: {}", SVC_OPERATION, preload_name,
1946 preload_type, operDataBuilder.build());
1947 GenericResourceApiUtil.toProperties(parms, "operational-data", operDataBuilder);
1949 // Call SLI sync method
1950 // Get SvcLogicService reference
1952 Properties respProps = null;
1954 String errorCode = "200";
1955 String errorMessage = null;
1956 String ackFinal = "Y";
1959 if (svcLogicClient.hasGraph(appName, SVC_OPERATION, null, "sync")) {
1962 respProps = svcLogicClient.execute(appName, SVC_OPERATION, null, "sync", preloadDataBuilder, parms);
1963 } catch (Exception e) {
1964 log.error("Caught exception executing service logic for {}", SVC_OPERATION, e);
1965 errorMessage = e.getMessage();
1969 errorMessage = "No service logic active for " + appName + ": '" + SVC_OPERATION + "'";
1972 } catch (Exception e) {
1974 errorMessage = e.getMessage();
1975 log.error("Caught exception looking for service logic", e);
1978 if (respProps != null) {
1979 errorCode = respProps.getProperty("error-code");
1980 errorMessage = respProps.getProperty("error-message");
1981 ackFinal = respProps.getProperty("ack-final", "Y");
1982 // internalError = respProps.getProperty("internal-error", "false");
1985 if (errorCode != null && errorCode.length() != 0 && !(errorCode.equals("0") || errorCode.equals("200"))) {
1987 responseBuilder.setResponseCode(errorCode);
1988 responseBuilder.setResponseMessage(errorMessage);
1989 responseBuilder.setAckFinalIndicator(ackFinal);
1991 VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
1992 preloadVnfListBuilder.setVnfName(preload_name);
1993 preloadVnfListBuilder.setVnfType(preload_type);
1994 preloadVnfListBuilder.setPreloadData(preloadDataBuilder.build());
1995 log.error("Returned FAILED for {} [{},{}] error code: '{}', Reason: '{}'", SVC_OPERATION, preload_name,
1996 preload_type, errorCode, errorMessage);
1998 savePreloadList(preloadVnfListBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
1999 } catch (Exception e) {
2000 log.error("Caught Exception updating MD-SAL for {} [{},{}] \n", SVC_OPERATION, preload_name,
2003 log.debug("Sending Success rpc result due to external error");
2004 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult = RpcResultBuilder
2005 .<PreloadVnfTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2006 return Futures.immediateFuture(rpcResult);
2009 // Got success from SLI
2011 preloadData = preloadDataBuilder.build();
2012 log.info("Updating MD-SAL for {} [{},{}] preloadData: {}", SVC_OPERATION, preload_name, preload_type,
2014 // svc-configuration-list
2015 VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
2016 preloadVnfListBuilder.setVnfName(preload_name);
2017 preloadVnfListBuilder.setVnfType(preload_type);
2018 preloadVnfListBuilder.setPreloadData(preloadData);
2020 // merge flag sets to false to allow it to be overwritten (not appended)
2021 savePreloadList(preloadVnfListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
2022 log.info("Updating OPERATIONAL tree.");
2023 savePreloadList(preloadVnfListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
2024 } catch (Exception e) {
2025 log.error("Caught Exception updating MD-SAL for {} [{},{}] \n", SVC_OPERATION, preload_name, preload_type,
2027 responseBuilder.setResponseCode("500");
2028 responseBuilder.setResponseMessage(e.toString());
2029 responseBuilder.setAckFinalIndicator("Y");
2030 log.error("Returned FAILED for {} [{},{}] {}", SVC_OPERATION, preload_name, preload_type,
2031 responseBuilder.build());
2032 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult = RpcResultBuilder
2033 .<PreloadVnfTopologyOperationOutput>status(false).withResult(responseBuilder.build()).build();
2034 return Futures.immediateFuture(rpcResult);
2038 responseBuilder.setResponseCode(errorCode);
2039 responseBuilder.setAckFinalIndicator(ackFinal);
2040 if (errorMessage != null) {
2041 responseBuilder.setResponseMessage(errorMessage);
2043 log.info("Updated MD-SAL for {} [{},{}]", SVC_OPERATION, preload_name, preload_type);
2044 log.info("Returned SUCCESS for {} [{},{}] {}", SVC_OPERATION, preload_name, preload_type,
2045 responseBuilder.build());
2047 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult = RpcResultBuilder
2048 .<PreloadVnfTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2049 return Futures.immediateFuture(rpcResult);
2053 public Future<RpcResult<PreloadNetworkTopologyOperationOutput>> preloadNetworkTopologyOperation(
2054 PreloadNetworkTopologyOperationInput input) {
2056 final String SVC_OPERATION = "preload-network-topology-operation";
2057 PreloadData preloadData;
2058 Properties parms = new Properties();
2060 log.info("{} called.", SVC_OPERATION);
2061 // create a new response object
2062 PreloadNetworkTopologyOperationOutputBuilder responseBuilder = new PreloadNetworkTopologyOperationOutputBuilder();
2064 // Result from savePreloadData
2065 final SettableFuture<RpcResult<Void>> futureResult = SettableFuture.create();
2067 if (input == null || input.getNetworkTopologyInformation() == null
2068 || input.getNetworkTopologyInformation().getNetworkTopologyIdentifier() == null) {
2070 log.debug("exiting {} because of null input", SVC_OPERATION);
2071 responseBuilder.setResponseCode("403");
2072 responseBuilder.setResponseMessage("input is null");
2073 responseBuilder.setAckFinalIndicator("Y");
2074 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
2075 .<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2076 return Futures.immediateFuture(rpcResult);
2079 // Grab the name and type from the input buffer
2080 String preload_name = input.getNetworkTopologyInformation().getNetworkTopologyIdentifier().getNetworkName();
2081 String preload_type = input.getNetworkTopologyInformation().getNetworkTopologyIdentifier().getNetworkType();
2083 // Make sure we have a preload_name and preload_type
2084 if (preload_name == null || preload_name.length() == 0 || preload_type == null || preload_type.length() == 0) {
2085 log.debug("exiting {} because of invalid preload-name", SVC_OPERATION);
2086 responseBuilder.setResponseCode("403");
2087 responseBuilder.setResponseMessage("input, invalid preload-name");
2088 responseBuilder.setAckFinalIndicator("Y");
2089 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
2090 .<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2091 return Futures.immediateFuture(rpcResult);
2094 if (input.getSdncRequestHeader() != null) {
2095 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
2098 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
2099 getPreloadData(preload_name, preload_type, preloadDataBuilder);
2101 PreloadDataBuilder operDataBuilder = new PreloadDataBuilder();
2102 getPreloadData(preload_name, preload_type, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
2105 // setup a preload-data object builder
2106 // ACTION preload-network-topology-operation
2108 // USES sdnc-request-header;
2109 // USES request-information;
2110 // uses network-topology-information;
2112 // USES vnf-topology-response-body;
2114 // container preload-data
2115 // uses vnf-topology-information;
2116 // uses network-topology-information;
2117 // uses oper-status;
2119 log.info("Adding INPUT data for {} [{},{}] input: {}", SVC_OPERATION, preload_name, preload_type, input);
2120 PreloadNetworkTopologyOperationInputBuilder inputBuilder = new PreloadNetworkTopologyOperationInputBuilder(
2122 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
2123 log.info("Adding OPERATIONAL data for {} [{},{}] operational-data: {}", SVC_OPERATION, preload_name,
2124 preload_type, operDataBuilder.build());
2125 GenericResourceApiUtil.toProperties(parms, "operational-data", operDataBuilder);
2127 // Call SLI sync method
2128 // Get SvcLogicService reference
2130 Properties respProps = null;
2132 String errorCode = "200";
2133 String errorMessage = null;
2134 String ackFinal = "Y";
2137 if (svcLogicClient.hasGraph(appName, SVC_OPERATION, null, "sync")) {
2140 respProps = svcLogicClient.execute(appName, SVC_OPERATION, null, "sync", preloadDataBuilder, parms);
2141 } catch (Exception e) {
2142 log.error("Caught exception executing service logic for {}", SVC_OPERATION, e);
2143 errorMessage = e.getMessage();
2147 errorMessage = "No service logic active for " + appName + ": '" + SVC_OPERATION + "'";
2150 } catch (Exception e) {
2152 errorMessage = e.getMessage();
2153 log.error("Caught exception looking for service logic", e);
2156 if (respProps != null) {
2157 errorCode = respProps.getProperty("error-code");
2158 errorMessage = respProps.getProperty("error-message");
2159 ackFinal = respProps.getProperty("ack-final", "Y");
2160 // internalError = respProps.getProperty("internal-error", "false");
2163 if (errorCode != null && errorCode.length() != 0 && !(errorCode.equals("0") || errorCode.equals("200"))) {
2165 responseBuilder.setResponseCode(errorCode);
2166 responseBuilder.setResponseMessage(errorMessage);
2167 responseBuilder.setAckFinalIndicator(ackFinal);
2169 VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
2170 preloadVnfListBuilder.setVnfName(preload_name);
2171 preloadVnfListBuilder.setVnfType(preload_type);
2172 preloadVnfListBuilder.setPreloadData(preloadDataBuilder.build());
2173 log.error("Returned FAILED for {} [{},{}] error code: '{}', Reason: '{}'", SVC_OPERATION, preload_name,
2174 preload_type, errorCode, errorMessage);
2176 savePreloadList(preloadVnfListBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
2177 } catch (Exception e) {
2178 log.error("Caught Exception updating MD-SAL for {} [{},{}] \n", SVC_OPERATION, preload_name,
2182 log.debug("Sending Success rpc result due to external error");
2183 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
2184 .<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2185 return Futures.immediateFuture(rpcResult);
2188 // Got success from SLI
2190 preloadData = preloadDataBuilder.build();
2191 log.info("Updating MD-SAL for {} [{},{}] preloadData: {}", SVC_OPERATION, preload_name, preload_type,
2193 // svc-configuration-list
2194 VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
2195 preloadVnfListBuilder.setVnfName(preload_name);
2196 preloadVnfListBuilder.setVnfType(preload_type);
2197 preloadVnfListBuilder.setPreloadData(preloadData);
2199 // merge flag sets to false to allow it to be overwritten (not appended)
2200 savePreloadList(preloadVnfListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
2201 log.info("Updating OPERATIONAL tree.");
2202 savePreloadList(preloadVnfListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
2203 } catch (Exception e) {
2204 log.error("Caught Exception updating MD-SAL for " + SVC_OPERATION + " [" + preload_name + "," + preload_type
2206 responseBuilder.setResponseCode("500");
2207 responseBuilder.setResponseMessage(e.toString());
2208 responseBuilder.setAckFinalIndicator("Y");
2209 log.error("Returned FAILED for {} [{},{}] {}", SVC_OPERATION, preload_name, preload_type,
2210 responseBuilder.build());
2211 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
2212 .<PreloadNetworkTopologyOperationOutput>status(false).withResult(responseBuilder.build()).build();
2213 return Futures.immediateFuture(rpcResult);
2217 responseBuilder.setResponseCode(errorCode);
2218 responseBuilder.setAckFinalIndicator(ackFinal);
2219 if (errorMessage != null) {
2220 responseBuilder.setResponseMessage(errorMessage);
2222 log.info("Updated MD-SAL for {} [{},{}]", SVC_OPERATION, preload_name, preload_type);
2223 log.info("Returned SUCCESS for {} [{},{}] {}", SVC_OPERATION, preload_name, preload_type,
2224 responseBuilder.build());
2226 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
2227 .<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2228 return Futures.immediateFuture(rpcResult);