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 GenericResourceApiSvcLogicServiceClient svcLogicClient;
151 public GenericResourceApiProvider(DataBroker dataBroker2, NotificationPublishService notificationPublishService,
152 RpcProviderRegistry rpcProviderRegistry, GenericResourceApiSvcLogicServiceClient client) {
153 log.info("Creating provider for {}", appName);
154 executor = Executors.newFixedThreadPool(1);
155 dataBroker = dataBroker2;
156 notificationService = notificationPublishService;
157 rpcRegistry = rpcProviderRegistry;
158 svcLogicClient = client;
163 public void initialize() {
164 log.info("Initializing provider for {}", appName);
165 // Create the top level containers
168 GenericResourceApiUtil.loadProperties();
169 } catch (Exception e) {
170 log.error("Caught Exception while trying to load properties file");
173 log.info("Initialization complete for {}", appName);
176 protected void initializeChild() {
177 // Override if you have custom initialization intelligence
181 public void close() throws Exception {
182 log.info("Closing provider for {}", appName);
184 rpcRegistration.close();
185 log.info("Successfully closed provider for {}", appName);
188 private static class Iso8601Util {
189 private static TimeZone tz = TimeZone.getTimeZone("UTC");
190 private static DateFormat df = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'");
196 private static String now() {
197 return df.format(new Date());
201 public void setDataBroker(DataBroker dataBroker) {
202 this.dataBroker = dataBroker;
203 if (log.isDebugEnabled()) {
204 log.debug("DataBroker set to {}", (dataBroker == null ? "null" : "non-null"));
208 public void setNotificationService(NotificationPublishService notificationService) {
209 this.notificationService = notificationService;
210 if (log.isDebugEnabled()) {
211 log.debug("Notification Service set to {}", (notificationService == null ? "null" : "non-null"));
215 public void setRpcRegistry(RpcProviderRegistry rpcRegistry) {
216 this.rpcRegistry = rpcRegistry;
217 if (log.isDebugEnabled()) {
218 log.debug("RpcRegistry set to {}", (rpcRegistry == null ? "null" : "non-null"));
222 private void createContainers() {
224 final WriteTransaction t = dataBroker.newReadWriteTransaction();
226 // Create the service-instance container
227 t.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(Services.class),
228 new ServicesBuilder().build());
229 t.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(Services.class),
230 new ServicesBuilder().build());
232 // Create the PreloadVnfs container
233 t.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(PreloadVnfs.class),
234 new PreloadVnfsBuilder().build());
235 t.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(PreloadVnfs.class),
236 new PreloadVnfsBuilder().build());
239 CheckedFuture<Void, TransactionCommitFailedException> checkedFuture = t.submit();
241 log.info("Create containers succeeded!");
243 } catch (InterruptedException | ExecutionException e) {
244 log.error("Create containers failed: ", e);
248 private void setServiceStatus(ServiceStatusBuilder serviceStatusBuilder, String errorCode, String errorMessage,
250 serviceStatusBuilder.setResponseCode(errorCode);
251 serviceStatusBuilder.setResponseMessage(errorMessage);
252 serviceStatusBuilder.setFinalIndicator(ackFinal);
253 serviceStatusBuilder.setResponseTimestamp(Iso8601Util.now());
256 private void setServiceStatus(ServiceStatusBuilder serviceStatusBuilder, RequestInformation requestInformation) {
257 if (requestInformation != null && requestInformation.getRequestAction() != null) {
258 serviceStatusBuilder.setAction(requestInformation.getRequestAction().toString());
262 * if (requestInformation != null && requestInformation.getRequestSubAction() !=
263 * null) { switch (requestInformation.getRequestSubAction()) { case SUPP:
264 * serviceStatusBuilder.setVnfsdnSubaction(VnfsdnSubaction.SUPP); break; case
265 * CANCEL: serviceStatusBuilder.setVnfsdnSubaction(VnfsdnSubaction.CANCEL);
266 * break; default: log.error("Unknown RequestSubAction: " +
267 * requestInformation.getRequestSubAction() ); break; }; }
271 private void setServiceStatus(ServiceStatusBuilder serviceStatusBuilder, SdncRequestHeader requestHeader) {
272 if (requestHeader != null && requestHeader.getSvcAction() != null) {
273 switch (requestHeader.getSvcAction()) {
275 serviceStatusBuilder.setRpcAction(RpcAction.Assign);
278 serviceStatusBuilder.setRpcAction(RpcAction.Unassign);
281 serviceStatusBuilder.setRpcAction(RpcAction.Activate);
284 serviceStatusBuilder.setRpcAction(RpcAction.Deactivate);
287 serviceStatusBuilder.setRpcAction(RpcAction.Delete);
290 log.error("Unknown SvcAction: {}", requestHeader.getSvcAction());
296 private void getServiceData(String siid, ServiceDataBuilder serviceDataBuilder) {
298 getServiceData(siid, serviceDataBuilder, LogicalDatastoreType.CONFIGURATION);
301 private void getServiceData(String siid, ServiceDataBuilder serviceDataBuilder, LogicalDatastoreType type) {
302 // See if any data exists yet for this siid, if so grab it.
303 InstanceIdentifier serviceInstanceIdentifier = InstanceIdentifier.<Services>builder(Services.class)
304 .child(Service.class, new ServiceKey(siid)).build();
305 ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction();
306 Optional<Service> data = null;
308 data = (Optional<Service>) readTx.read(type, serviceInstanceIdentifier).get();
309 } catch (InterruptedException | ExecutionException e) {
310 log.error("Caught Exception reading MD-SAL ({}) data for [{}] ", type, siid, e);
313 if (data != null && data.isPresent()) {
314 ServiceData serviceData = data.get().getServiceData();
315 if (serviceData != null) {
316 log.info("Read MD-SAL ({}) data for [{}] ServiceData: {}", type, siid, serviceData);
317 serviceDataBuilder.setSdncRequestHeader(serviceData.getSdncRequestHeader());
318 serviceDataBuilder.setRequestInformation(serviceData.getRequestInformation());
319 serviceDataBuilder.setServiceInformation(serviceData.getServiceInformation());
320 serviceDataBuilder.setServiceRequestInput(serviceData.getServiceRequestInput());
321 serviceDataBuilder.setServiceTopology(serviceData.getServiceTopology());
322 serviceDataBuilder.setServiceLevelOperStatus(serviceData.getServiceLevelOperStatus());
323 serviceDataBuilder.setNetworks(serviceData.getNetworks());
324 serviceDataBuilder.setVnfs(serviceData.getVnfs());
325 serviceDataBuilder.setProvidedAllottedResources(serviceData.getProvidedAllottedResources());
326 serviceDataBuilder.setConsumedAllottedResources(serviceData.getConsumedAllottedResources());
327 // service-instance-id needs to be set
329 log.info("No service-data found in MD-SAL ({}) for [{}]", type, siid);
332 log.info("No data found in MD-SAL ({}) for [{}]", type, siid);
336 private void getPreloadData(String vnf_name, String vnf_type, PreloadDataBuilder preloadDataBuilder) {
338 getPreloadData(vnf_name, vnf_type, preloadDataBuilder, LogicalDatastoreType.CONFIGURATION);
341 private void getPreloadData(String preload_name, String preload_type, PreloadDataBuilder preloadDataBuilder,
342 LogicalDatastoreType type) {
343 // See if any data exists yet for this name/type, if so grab it.
344 InstanceIdentifier preloadInstanceIdentifier = InstanceIdentifier.<PreloadVnfs>builder(PreloadVnfs.class)
345 .child(VnfPreloadList.class, new VnfPreloadListKey(preload_name, preload_type)).build();
346 ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction();
347 Optional<VnfPreloadList> data = null;
349 data = (Optional<VnfPreloadList>) readTx.read(type, preloadInstanceIdentifier).get();
350 } catch (InterruptedException | ExecutionException e) {
351 log.error("Caught Exception reading MD-SAL ({}) for [{},{}] ", type, preload_name, preload_type, e);
354 if (data != null && data.isPresent()) {
355 PreloadData preloadData = data.get().getPreloadData();
356 if (preloadData != null) {
357 log.info("Read MD-SAL ({}) data for [{},{}] PreloadData: {}", type, preload_name, preload_type,
359 preloadDataBuilder.setVnfTopologyInformation(preloadData.getVnfTopologyInformation());
360 preloadDataBuilder.setNetworkTopologyInformation(preloadData.getNetworkTopologyInformation());
361 preloadDataBuilder.setOperStatus(preloadData.getOperStatus());
363 log.info("No preload-data found in MD-SAL ({}) for [{},{}] ", type, preload_name, preload_type);
366 log.info("No data found in MD-SAL ({}) for [{},{}] ", type, preload_name, preload_type);
370 private void saveService(final Service entry, boolean merge, LogicalDatastoreType storeType)
371 throws IllegalStateException {
372 // Each entry will be identifiable by a unique key, we have to create that
374 InstanceIdentifier.InstanceIdentifierBuilder<Service> serviceBuilder = InstanceIdentifier
375 .<Services>builder(Services.class).child(Service.class, entry.getKey());
376 InstanceIdentifier<Service> path = serviceBuilder.build();
381 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
383 tx.merge(storeType, path, entry);
385 tx.put(storeType, path, entry);
387 tx.submit().checkedGet();
388 log.debug("Update DataStore succeeded");
390 } catch (final TransactionCommitFailedException e) {
391 if (e instanceof OptimisticLockFailedException) {
393 log.debug("Got OptimisticLockFailedException on last try - failing ");
394 throw new IllegalStateException(e);
396 log.debug("Got OptimisticLockFailedException - trying again ");
398 log.debug("Update DataStore failed");
399 throw new IllegalStateException(e);
405 private void deleteService(final Service entry, LogicalDatastoreType storeType) throws IllegalStateException {
406 // Each entry will be identifiable by a unique key, we have to create
408 InstanceIdentifier.InstanceIdentifierBuilder<Service> serviceListIdBuilder = InstanceIdentifier
409 .<Services>builder(Services.class).child(Service.class, entry.getKey());
410 InstanceIdentifier<Service> path = serviceListIdBuilder.build();
415 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
416 tx.delete(storeType, path);
417 tx.submit().checkedGet();
418 log.debug("DataStore delete succeeded");
420 } catch (final TransactionCommitFailedException e) {
421 if (e instanceof OptimisticLockFailedException) {
423 log.debug("Got OptimisticLockFailedException on last try - failing ");
424 throw new IllegalStateException(e);
426 log.debug("Got OptimisticLockFailedException - trying again ");
428 log.debug("Update DataStore failed");
429 throw new IllegalStateException(e);
435 private void savePreloadList(final VnfPreloadList entry, boolean merge, LogicalDatastoreType storeType)
436 throws IllegalStateException {
438 // Each entry will be identifiable by a unique key, we have to create that
440 InstanceIdentifier.InstanceIdentifierBuilder<VnfPreloadList> vnfPreloadListBuilder = InstanceIdentifier
441 .<PreloadVnfs>builder(PreloadVnfs.class).child(VnfPreloadList.class, entry.getKey());
442 InstanceIdentifier<VnfPreloadList> path = vnfPreloadListBuilder.build();
446 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
448 tx.merge(storeType, path, entry);
450 tx.put(storeType, path, entry);
452 tx.submit().checkedGet();
453 log.debug("Update DataStore succeeded");
455 } catch (final TransactionCommitFailedException e) {
456 if (e instanceof OptimisticLockFailedException) {
458 log.debug("Got OptimisticLockFailedException on last try - failing ");
459 throw new IllegalStateException(e);
461 log.debug("Got OptimisticLockFailedException - trying again ");
463 log.debug("Update DataStore failed");
464 throw new IllegalStateException(e);
471 public Future<RpcResult<ServiceTopologyOperationOutput>> serviceTopologyOperation(
472 ServiceTopologyOperationInput input) {
474 final String SVC_OPERATION = "service-topology-operation";
475 ServiceData serviceData;
476 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
477 Properties parms = new Properties();
479 log.info("{} called.", SVC_OPERATION);
480 // create a new response object
481 ServiceTopologyOperationOutputBuilder responseBuilder = new ServiceTopologyOperationOutputBuilder();
483 if (input == null || input.getServiceInformation() == null
484 || input.getServiceInformation().getServiceInstanceId() == null
485 || input.getServiceInformation().getServiceInstanceId().length() == 0) {
486 log.debug("exiting {} because of null or empty service-instance-id", SVC_OPERATION);
487 responseBuilder.setResponseCode("404");
488 responseBuilder.setResponseMessage("invalid input, null or empty service-instance-id");
489 responseBuilder.setAckFinalIndicator("Y");
490 RpcResult<ServiceTopologyOperationOutput> rpcResult = RpcResultBuilder
491 .<ServiceTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
492 return Futures.immediateFuture(rpcResult);
495 // Grab the service instance ID from the input buffer
496 String siid = input.getServiceInformation().getServiceInstanceId();
498 if (input.getSdncRequestHeader() != null) {
499 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
502 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
503 getServiceData(siid, serviceDataBuilder);
505 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
506 getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
508 // Set the serviceStatus based on input
509 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
510 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
513 * // setup a service-data object builder // ACTION service-topology-operation
514 * // INPUT: // USES uses service-operation-information // OUTPUT: // uses
515 * topology-response-common; // uses service-response-information;
518 log.info("Adding INPUT data for {} [{}] input: {}", SVC_OPERATION, siid, input);
519 ServiceTopologyOperationInputBuilder inputBuilder = new ServiceTopologyOperationInputBuilder(input);
520 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
522 log.info("Adding OPERATIONAL data for {} [{}] operational-data: {}", SVC_OPERATION, siid,
523 operDataBuilder.build());
524 GenericResourceApiUtil.toProperties(parms, "operational-data", operDataBuilder);
526 // Call SLI sync method
527 // Get SvcLogicService reference
529 Properties respProps = null;
531 String errorCode = "200";
532 String errorMessage = null;
533 String ackFinal = "Y";
534 String serviceObjectPath = null;
537 if (svcLogicClient.hasGraph(appName, SVC_OPERATION, null, "sync")) {
540 respProps = svcLogicClient.execute(appName, SVC_OPERATION, null, "sync", serviceDataBuilder, parms);
541 } catch (Exception e) {
542 log.error("Caught exception executing service logic for {} ", SVC_OPERATION, e);
543 errorMessage = e.getMessage();
547 errorMessage = "No service logic active for " + appName + ": '" + SVC_OPERATION + "'";
550 } catch (Exception e) {
552 errorMessage = e.getMessage();
553 log.error("Caught exception looking for service logic", e);
556 if (respProps != null) {
557 errorCode = respProps.getProperty("error-code");
558 errorMessage = respProps.getProperty("error-message");
559 ackFinal = respProps.getProperty("ack-final", "Y");
560 serviceObjectPath = respProps.getProperty("service-object-path");
563 setServiceStatus(serviceStatusBuilder, errorCode, errorMessage, ackFinal);
564 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
565 // serviceStatusBuilder.setRpcName(RpcName.ServiceTopologyOperation);
566 serviceStatusBuilder.setRpcName(SVC_OPERATION);
568 if (errorCode != null && errorCode.length() != 0 && !(errorCode.equals("0") || errorCode.equals("200"))) {
569 responseBuilder.setResponseCode(errorCode);
570 responseBuilder.setResponseMessage(errorMessage);
571 responseBuilder.setAckFinalIndicator(ackFinal);
573 ServiceBuilder serviceBuilder = new ServiceBuilder();
574 serviceBuilder.setServiceInstanceId(siid);
575 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
577 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
578 } catch (Exception e) {
579 log.error("Caught Exception updating MD-SAL for {} [{}] \n", SVC_OPERATION, siid, e);
581 log.error("Returned FAILED for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
582 RpcResult<ServiceTopologyOperationOutput> rpcResult = RpcResultBuilder
583 .<ServiceTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
584 return Futures.immediateFuture(rpcResult);
587 // Got success from SLI
589 serviceData = serviceDataBuilder.build();
590 log.info("Updating MD-SAL for {} [{}] ServiceData: {}", SVC_OPERATION, siid, serviceData);
593 ServiceBuilder serviceBuilder = new ServiceBuilder();
594 serviceBuilder.setServiceData(serviceData);
595 serviceBuilder.setServiceInstanceId(siid);
596 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
597 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
599 if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null) {
600 // Only update operational tree on delete
601 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete)) {
602 log.info("Delete from both CONFIGURATION and OPERATIONAL tree.");
603 deleteService(serviceBuilder.build(), LogicalDatastoreType.OPERATIONAL);
604 deleteService(serviceBuilder.build(), LogicalDatastoreType.CONFIGURATION);
608 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
609 serviceResponseInformationBuilder.setInstanceId(siid);
610 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
611 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
613 } catch (Exception e) {
614 log.error("Caught Exception updating MD-SAL for {} [{}] \n", SVC_OPERATION, siid, e);
615 responseBuilder.setResponseCode("500");
616 responseBuilder.setResponseMessage(e.toString());
617 responseBuilder.setAckFinalIndicator("Y");
618 log.error("Returned FAILED for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
619 RpcResult<ServiceTopologyOperationOutput> rpcResult = RpcResultBuilder
620 .<ServiceTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
621 return Futures.immediateFuture(rpcResult);
625 responseBuilder.setResponseCode(errorCode);
626 responseBuilder.setAckFinalIndicator(ackFinal);
627 if (errorMessage != null) {
628 responseBuilder.setResponseMessage(errorMessage);
630 log.info("Updated MD-SAL for {} [{}]", SVC_OPERATION, siid);
631 log.info("Returned SUCCESS for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
633 RpcResult<ServiceTopologyOperationOutput> rpcResult = RpcResultBuilder
634 .<ServiceTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
635 return Futures.immediateFuture(rpcResult);
639 public Future<RpcResult<VnfTopologyOperationOutput>> vnfTopologyOperation(VnfTopologyOperationInput input) {
641 final String SVC_OPERATION = "vnf-topology-operation";
642 ServiceData serviceData;
643 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
644 Properties parms = new Properties();
646 log.info("{} called.", SVC_OPERATION);
647 // create a new response object
648 VnfTopologyOperationOutputBuilder responseBuilder = new VnfTopologyOperationOutputBuilder();
650 if (input == null || input.getServiceInformation() == null
651 || input.getServiceInformation().getServiceInstanceId() == null
652 || input.getServiceInformation().getServiceInstanceId().length() == 0) {
653 log.debug("exiting {} because of null or empty service-instance-id", SVC_OPERATION);
654 responseBuilder.setResponseCode("404");
655 responseBuilder.setResponseMessage("invalid input, null or empty service-instance-id");
656 responseBuilder.setAckFinalIndicator("Y");
657 RpcResult<VnfTopologyOperationOutput> rpcResult = RpcResultBuilder.<VnfTopologyOperationOutput>status(true)
658 .withResult(responseBuilder.build()).build();
660 return Futures.immediateFuture(rpcResult);
663 // Grab the service instance ID from the input buffer
664 String siid = input.getServiceInformation().getServiceInstanceId();
666 if (input.getSdncRequestHeader() != null) {
667 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
670 if (input.getVnfInformation() == null || input.getVnfInformation().getVnfId() == null
671 || input.getVnfInformation().getVnfId().length() == 0) {
672 log.debug("exiting {} because of null or empty vnf-id", SVC_OPERATION);
673 responseBuilder.setResponseCode("404");
674 responseBuilder.setResponseMessage("invalid input, null or empty vnf-id");
675 responseBuilder.setAckFinalIndicator("Y");
676 RpcResult<VnfTopologyOperationOutput> rpcResult = RpcResultBuilder.<VnfTopologyOperationOutput>status(true)
677 .withResult(responseBuilder.build()).build();
678 return Futures.immediateFuture(rpcResult);
682 * Mobility wont use vipr intf in 1707
684 * String preload_name = null; String preload_type = null; if
685 * (input.getVnfRequestInput() != null &&
686 * input.getVnfRequestInput().getVnfName() != null &&
687 * input.getVnfRequestInput().getVnfName().length() != 0) { preload_name =
688 * input.getVnfRequestInput().getVnfName(); } if
689 * (input.getVnfInformation().getVnfType() != null &&
690 * input.getVnfInformation().getVnfType().length() != 0) { preload_type =
691 * input.getVnfInformation().getVnfType(); }
693 * PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder(); if
694 * (preload_name != null && preload_type != null) { getPreloadData(preload_name,
695 * preload_type, preloadDataBuilder); } else {
696 * log.info("vnf-name and vnf-type not present in the request"); }
699 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
700 getServiceData(siid, serviceDataBuilder);
702 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
703 getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
705 // Set the serviceStatus based on input
706 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
707 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
710 // setup a service-data object builder
711 // ACTION vnf-topology-operation
713 // USES sdnc-request-header;
714 // USES request-information;
715 // USES service-information;
716 // USES vnf-request-information
718 // USES vnf-topology-response-body;
719 // USES vnf-information
720 // USES service-information
722 // container service-data
723 // uses vnf-configuration-information;
726 log.info("Adding INPUT data for {} [{}] input: {}", SVC_OPERATION, siid, input);
727 VnfTopologyOperationInputBuilder inputBuilder = new VnfTopologyOperationInputBuilder(input);
728 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
730 log.info("Adding OPERATIONAL data for {} [{}] operational-data: {}", SVC_OPERATION, siid,
731 operDataBuilder.build());
732 GenericResourceApiUtil.toProperties(parms, "operational-data", operDataBuilder);
735 * log.info("Adding CONFIG data for "+SVC_OPERATION+" ["+preload_name+","+
736 * preload_type+"] preload-data: " + preloadDataBuilder.build());
737 * GenericResourceApiUtil.toProperties(parms, "preload-data",
738 * preloadDataBuilder);
741 // Call SLI sync method
742 // Get SvcLogicService reference
744 Properties respProps = null;
746 String errorCode = "200";
747 String errorMessage = null;
748 String ackFinal = "Y";
749 String serviceObjectPath = null;
752 if (svcLogicClient.hasGraph(appName, SVC_OPERATION, null, "sync")) {
755 respProps = svcLogicClient.execute(appName, SVC_OPERATION, null, "sync", serviceDataBuilder, parms);
756 } catch (Exception e) {
757 log.error("Caught exception executing service logic for {} ", SVC_OPERATION, e);
758 errorMessage = e.getMessage();
762 errorMessage = "No service logic active for " + appName + ": '" + SVC_OPERATION + "'";
765 } catch (Exception e) {
767 errorMessage = e.getMessage();
768 log.error("Caught exception looking for service logic", e);
771 if (respProps != null) {
772 errorCode = respProps.getProperty("error-code");
773 errorMessage = respProps.getProperty("error-message");
774 ackFinal = respProps.getProperty("ack-final", "Y");
775 serviceObjectPath = respProps.getProperty("vnf-object-path");
778 setServiceStatus(serviceStatusBuilder, errorCode, errorMessage, ackFinal);
779 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
780 // serviceStatusBuilder.setRpcName(RpcName.VnfTopologyOperation);
781 serviceStatusBuilder.setRpcName(SVC_OPERATION);
783 if (errorCode != null && errorCode.length() != 0 && !(errorCode.equals("0") || errorCode.equals("200"))) {
784 responseBuilder.setResponseCode(errorCode);
785 responseBuilder.setResponseMessage(errorMessage);
786 responseBuilder.setAckFinalIndicator(ackFinal);
788 ServiceBuilder serviceBuilder = new ServiceBuilder();
789 serviceBuilder.setServiceInstanceId(siid);
790 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
792 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
793 if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null) {
794 // Only update operational tree on activate or delete
795 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete)
796 || input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate)) {
797 log.info("Updating OPERATIONAL tree.");
798 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
801 } catch (Exception e) {
802 log.error("Caught Exception updating MD-SAL for {} [{}] \n", SVC_OPERATION, siid, e);
804 log.error("Returned FAILED for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
805 RpcResult<VnfTopologyOperationOutput> rpcResult = RpcResultBuilder.<VnfTopologyOperationOutput>status(true)
806 .withResult(responseBuilder.build()).build();
808 return Futures.immediateFuture(rpcResult);
811 // Got success from SLI
813 serviceData = serviceDataBuilder.build();
814 log.info("Updating MD-SAL for {} [{}] ServiceData: {}", SVC_OPERATION, siid, serviceData);
817 ServiceBuilder serviceBuilder = new ServiceBuilder();
818 serviceBuilder.setServiceData(serviceData);
819 serviceBuilder.setServiceInstanceId(siid);
820 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
821 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
823 if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null) {
824 // Only update operational tree on Assign
825 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate)) {
826 log.info("Updating OPERATIONAL tree.");
827 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
831 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
832 serviceResponseInformationBuilder.setInstanceId(siid);
833 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
834 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
836 } catch (Exception e) {
837 log.error("Caught Exception updating MD-SAL for {} [{}] \n", SVC_OPERATION, siid, e);
838 responseBuilder.setResponseCode("500");
839 responseBuilder.setResponseMessage(e.toString());
840 responseBuilder.setAckFinalIndicator("Y");
841 log.error("Returned FAILED for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
842 RpcResult<VnfTopologyOperationOutput> rpcResult = RpcResultBuilder.<VnfTopologyOperationOutput>status(true)
843 .withResult(responseBuilder.build()).build();
844 return Futures.immediateFuture(rpcResult);
848 responseBuilder.setResponseCode(errorCode);
849 responseBuilder.setAckFinalIndicator(ackFinal);
850 if (errorMessage != null) {
851 responseBuilder.setResponseMessage(errorMessage);
853 log.info("Updated MD-SAL for {} [{}]", SVC_OPERATION, siid);
854 log.info("Returned SUCCESS for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
856 RpcResult<VnfTopologyOperationOutput> rpcResult = RpcResultBuilder.<VnfTopologyOperationOutput>status(true)
857 .withResult(responseBuilder.build()).build();
859 return Futures.immediateFuture(rpcResult);
863 public Future<RpcResult<VfModuleTopologyOperationOutput>> vfModuleTopologyOperation(
864 VfModuleTopologyOperationInput input) {
866 final String SVC_OPERATION = "vf-module-topology-operation";
867 ServiceData serviceData;
868 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
869 Properties parms = new Properties();
871 log.info("{} called.", SVC_OPERATION);
872 // create a new response object
873 VfModuleTopologyOperationOutputBuilder responseBuilder = new VfModuleTopologyOperationOutputBuilder();
875 if (input == null || input.getServiceInformation() == null
876 || input.getServiceInformation().getServiceInstanceId() == null
877 || input.getServiceInformation().getServiceInstanceId().length() == 0) {
878 log.debug("exiting {} because of null or empty service-instance-id", SVC_OPERATION);
879 responseBuilder.setResponseCode("403");
880 responseBuilder.setResponseMessage("invalid input, null or empty service-instance-id");
881 responseBuilder.setAckFinalIndicator("Y");
882 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
883 .<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
885 return Futures.immediateFuture(rpcResult);
888 if (input.getVnfInformation() == null || input.getVnfInformation().getVnfId() == null
889 || input.getVnfInformation().getVnfId().length() == 0) {
890 log.debug("exiting {} because of null or empty vnf-id", SVC_OPERATION);
891 responseBuilder.setResponseCode("403");
892 responseBuilder.setResponseMessage("invalid input, null or empty vnf-id");
893 responseBuilder.setAckFinalIndicator("Y");
894 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
895 .<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
896 return Futures.immediateFuture(rpcResult);
899 if (input.getVfModuleInformation() == null || input.getVfModuleInformation().getVfModuleId() == null
900 || input.getVfModuleInformation().getVfModuleId().length() == 0) {
901 log.debug("exiting {} because of null or empty vf-module-id", SVC_OPERATION);
902 responseBuilder.setResponseCode("403");
903 responseBuilder.setResponseMessage("invalid input, vf-module-id is null or empty");
904 responseBuilder.setAckFinalIndicator("Y");
905 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
906 .<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
907 return Futures.immediateFuture(rpcResult);
910 // Grab the service instance ID from the input buffer
911 String siid = input.getServiceInformation().getServiceInstanceId();
913 if (input.getSdncRequestHeader() != null) {
914 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
918 * String preload_name = null; String preload_type = null;
920 * preload_name = input.getVfModuleRequestInput().getVfModuleName();
922 * if(input.getVfModuleInformation().getVfModuleType() != null &&
923 * input.getVfModuleInformation().getVfModuleType().length() != 0) {
924 * preload_type = input.getVfModuleInformation().getVfModuleType(); }
926 * PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder(); if
927 * (preload_name != null && preload_type != null) { getPreloadData(preload_name,
928 * preload_type, preloadDataBuilder); } else {
929 * log.debug("vf-module-name and vf-module-type not present in the request."); }
932 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
933 getServiceData(siid, serviceDataBuilder);
935 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
936 getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
938 // Set the serviceStatus based on input
939 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
940 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
943 // setup a service-data object builder
944 // ACTION vnf-topology-operation
946 // USES sdnc-request-header;
947 // USES request-information;
948 // USES service-information;
949 // USES vnf-request-information
951 // USES vnf-topology-response-body;
952 // USES vnf-information
953 // USES service-information
955 // container service-data
956 // uses vnf-configuration-information;
959 log.info("Adding INPUT data for {} [{}] input: {}", SVC_OPERATION, siid, input);
960 VfModuleTopologyOperationInputBuilder inputBuilder = new VfModuleTopologyOperationInputBuilder(input);
961 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
963 log.info("Adding OPERATIONAL data for {} [{}] operational-data: {}", SVC_OPERATION, siid,
964 operDataBuilder.build());
965 GenericResourceApiUtil.toProperties(parms, "operational-data", operDataBuilder);
968 * log.info("Adding CONFIG data for "+SVC_OPERATION+" ["+preload_name+","+
969 * preload_type+"] preload-data: " +preloadDataBuilder.build());
970 * GenericResourceApiUtil.toProperties(parms, "preload-data",
971 * preloadDataBuilder);
974 // Call SLI sync method
975 // Get SvcLogicService reference
977 Properties respProps = null;
979 String errorCode = "200";
980 String errorMessage = null;
981 String ackFinal = "Y";
982 String serviceObjectPath = null;
985 if (svcLogicClient.hasGraph(appName, SVC_OPERATION, null, "sync")) {
988 respProps = svcLogicClient.execute(appName, SVC_OPERATION, null, "sync", serviceDataBuilder, parms);
989 } catch (Exception e) {
990 log.error("Caught exception executing service logic for " + SVC_OPERATION, e);
991 errorMessage = e.getMessage();
995 errorMessage = "No service logic active for " + appName + ": '" + SVC_OPERATION + "'";
998 } catch (Exception e) {
1000 errorMessage = e.getMessage();
1001 log.error("Caught exception looking for service logic", e);
1004 if (respProps != null) {
1005 errorCode = respProps.getProperty("error-code");
1006 errorMessage = respProps.getProperty("error-message");
1007 ackFinal = respProps.getProperty("ack-final", "Y");
1008 serviceObjectPath = respProps.getProperty("vf-module-object-path");
1011 setServiceStatus(serviceStatusBuilder, errorCode, errorMessage, ackFinal);
1012 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
1013 serviceStatusBuilder.setRpcName(SVC_OPERATION);
1015 if (errorCode != null && errorCode.length() != 0 && !(errorCode.equals("0") || errorCode.equals("200"))) {
1016 responseBuilder.setResponseCode(errorCode);
1017 responseBuilder.setResponseMessage(errorMessage);
1018 responseBuilder.setAckFinalIndicator(ackFinal);
1020 ServiceBuilder serviceBuilder = new ServiceBuilder();
1021 serviceBuilder.setServiceInstanceId(siid);
1022 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1024 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
1025 } catch (Exception e) {
1026 log.error("Caught Exception updating MD-SAL for {} [{}] \n", SVC_OPERATION, siid, e);
1028 log.error("Returned FAILED for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
1029 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
1030 .<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1032 return Futures.immediateFuture(rpcResult);
1035 // Got success from SLI
1037 serviceData = serviceDataBuilder.build();
1038 log.info("Updating MD-SAL for {} [{}] ServiceData: {}", SVC_OPERATION, siid, serviceData);
1041 ServiceBuilder serviceBuilder = new ServiceBuilder();
1042 serviceBuilder.setServiceData(serviceData);
1043 // serviceBuilder.setServiceInstanceId(serviceData.getServiceTopology().getServiceTopologyIdentifier().getServiceInstanceId());
1044 serviceBuilder.setServiceInstanceId(siid);
1045 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1046 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1048 if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null) {
1049 // Only update operational tree on activate or delete
1050 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Unassign)
1051 || input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate)) {
1052 log.info("Updating OPERATIONAL tree.");
1053 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1057 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1058 serviceResponseInformationBuilder.setInstanceId(siid);
1059 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1060 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1062 } catch (Exception e) {
1063 log.error("Caught Exception updating MD-SAL for {} [{}] \n", SVC_OPERATION, siid, e);
1064 responseBuilder.setResponseCode("500");
1065 responseBuilder.setResponseMessage(e.toString());
1066 responseBuilder.setAckFinalIndicator("Y");
1067 log.error("Returned FAILED for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
1068 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
1069 .<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1070 return Futures.immediateFuture(rpcResult);
1074 responseBuilder.setResponseCode(errorCode);
1075 responseBuilder.setAckFinalIndicator(ackFinal);
1076 if (errorMessage != null) {
1077 responseBuilder.setResponseMessage(errorMessage);
1079 log.info("Updated MD-SAL for {} [{}]", SVC_OPERATION, siid);
1080 log.info("Returned SUCCESS for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
1082 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
1083 .<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1085 return Futures.immediateFuture(rpcResult);
1089 public Future<RpcResult<NetworkTopologyOperationOutput>> networkTopologyOperation(
1090 NetworkTopologyOperationInput input) {
1092 final String SVC_OPERATION = "network-topology-operation";
1093 ServiceData serviceData;
1094 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1095 Properties parms = new Properties();
1097 log.info("{} called.", SVC_OPERATION);
1098 // create a new response object
1099 NetworkTopologyOperationOutputBuilder responseBuilder = new NetworkTopologyOperationOutputBuilder();
1101 if (input == null || input.getServiceInformation() == null
1102 || input.getServiceInformation().getServiceInstanceId() == null
1103 || input.getServiceInformation().getServiceInstanceId().length() == 0) {
1104 log.debug("exiting {} because of null or empty service-instance-id", SVC_OPERATION);
1105 responseBuilder.setResponseCode("404");
1106 responseBuilder.setResponseMessage("invalid input, null or empty service-instance-id");
1107 responseBuilder.setAckFinalIndicator("Y");
1108 RpcResult<NetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
1109 .<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1110 return Futures.immediateFuture(rpcResult);
1113 String siid = input.getServiceInformation().getServiceInstanceId();
1115 // Get the service-instance service data from MD-SAL
1116 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1117 getServiceData(siid, serviceDataBuilder);
1119 if (input.getSdncRequestHeader() != null) {
1120 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1123 ServiceData sd = serviceDataBuilder.build();
1124 if (sd == null || sd.getServiceLevelOperStatus() == null) {
1125 log.debug("exiting {} because the service-instance does not have any service data in SDNC", SVC_OPERATION);
1126 responseBuilder.setResponseCode("404");
1128 .setResponseMessage("invalid input: the service-instance does not have any service data in SDNC");
1129 responseBuilder.setAckFinalIndicator("Y");
1130 RpcResult<NetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
1131 .<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1132 return Futures.immediateFuture(rpcResult);
1136 * //String preload_name = null; //String preload_type = null; // If both
1137 * network-name and network-type are present in request, get the preload network
1138 * from MD-SAL if (input.getNetworkRequestInput() != null &&
1139 * input.getNetworkRequestInput().getNetworkName() != null &&
1140 * input.getNetworkRequestInput().getNetworkName().length() != 0) { preload_name
1141 * = input.getNetworkRequestInput().getNetworkName(); } if
1142 * (input.getNetworkInformation() != null &&
1143 * input.getNetworkInformation().getNetworkType() != null &&
1144 * input.getNetworkInformation().getNetworkType().length() != 0) { preload_type
1145 * = input.getNetworkInformation().getNetworkType(); }
1147 * PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder(); if
1148 * (preload_name != null && preload_type != null) { getPreloadData(preload_name,
1149 * preload_type, preloadDataBuilder); } else {
1150 * log.debug("network-name and network-type not present in request"); }
1153 log.info("Adding INPUT data for {} [{}] input: {}", SVC_OPERATION, siid, input);
1154 NetworkTopologyOperationInputBuilder inputBuilder = new NetworkTopologyOperationInputBuilder(input);
1155 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1157 // Call SLI sync method
1158 // Get SvcLogicService reference
1160 Properties respProps = null;
1162 String errorCode = "200";
1163 String errorMessage = null;
1164 String ackFinal = "Y";
1165 String networkId = "error";
1166 String serviceObjectPath = null;
1167 String networkObjectPath = null;
1170 if (svcLogicClient.hasGraph(appName, SVC_OPERATION, null, "sync")) {
1173 respProps = svcLogicClient.execute(appName, SVC_OPERATION, null, "sync", serviceDataBuilder, parms);
1174 } catch (Exception e) {
1175 log.error("Caught exception executing service logic for {}", SVC_OPERATION, e);
1176 errorMessage = e.getMessage();
1180 errorMessage = "No service logic active for " + appName + ": '" + SVC_OPERATION + "'";
1183 } catch (Exception e) {
1185 errorMessage = e.getMessage();
1186 log.error("Caught exception looking for service logic", e);
1189 if (respProps != null) {
1190 errorCode = respProps.getProperty("error-code");
1191 errorMessage = respProps.getProperty("error-message");
1192 ackFinal = respProps.getProperty("ack-final", "Y");
1193 networkId = respProps.getProperty("networkId");
1194 serviceObjectPath = respProps.getProperty("service-object-path");
1195 networkObjectPath = respProps.getProperty("network-object-path");
1198 if (errorCode != null && errorCode.length() != 0 && !(errorCode.equals("0") || errorCode.equals("200"))) {
1199 responseBuilder.setResponseCode(errorCode);
1200 responseBuilder.setResponseMessage(errorMessage);
1201 responseBuilder.setAckFinalIndicator(ackFinal);
1203 log.error("Returned FAILED for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
1205 RpcResult<NetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
1206 .<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1207 return Futures.immediateFuture(rpcResult);
1210 // Got success from SLI
1213 serviceData = serviceDataBuilder.build();
1214 log.info("Updating MD-SAL for {} [{}] ServiceData: {}", SVC_OPERATION, siid, serviceData);
1217 ServiceBuilder serviceBuilder = new ServiceBuilder();
1218 serviceBuilder.setServiceData(serviceData);
1219 serviceBuilder.setServiceInstanceId(siid);
1220 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1221 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1223 if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null) {
1224 // Only update operational tree on Activate
1225 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate)) {
1226 log.info("Updating OPERATIONAL tree.");
1227 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1231 NetworkResponseInformationBuilder networkResponseInformationBuilder = new NetworkResponseInformationBuilder();
1232 networkResponseInformationBuilder.setInstanceId(networkId);
1233 networkResponseInformationBuilder.setObjectPath(networkObjectPath);
1234 responseBuilder.setNetworkResponseInformation(networkResponseInformationBuilder.build());
1236 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1237 serviceResponseInformationBuilder.setInstanceId(siid);
1238 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1239 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1241 } catch (IllegalStateException e) {
1242 log.error("Caught Exception updating MD-SAL for {} [{}] \n", SVC_OPERATION, siid, e);
1243 responseBuilder.setResponseCode("500");
1244 responseBuilder.setResponseMessage(e.toString());
1245 responseBuilder.setAckFinalIndicator("Y");
1246 log.error("Returned FAILED for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
1247 RpcResult<NetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
1248 .<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1249 return Futures.immediateFuture(rpcResult);
1253 responseBuilder.setResponseCode(errorCode);
1254 responseBuilder.setAckFinalIndicator(ackFinal);
1255 if (errorMessage != null) {
1256 responseBuilder.setResponseMessage(errorMessage);
1258 log.info("Updated MD-SAL for {} [{}]", SVC_OPERATION, siid);
1259 log.info("Returned SUCCESS for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
1261 RpcResult<NetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
1262 .<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1263 return Futures.immediateFuture(rpcResult);
1267 public Future<RpcResult<ContrailRouteTopologyOperationOutput>> contrailRouteTopologyOperation(
1268 ContrailRouteTopologyOperationInput input) {
1270 final String SVC_OPERATION = "contrail-route-topology-operation";
1271 ServiceData serviceData;
1272 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1273 Properties parms = new Properties();
1275 log.info("{} called.", SVC_OPERATION);
1276 // create a new response object
1277 ContrailRouteTopologyOperationOutputBuilder responseBuilder = new ContrailRouteTopologyOperationOutputBuilder();
1279 if (input == null || input.getServiceInformation() == null
1280 || input.getServiceInformation().getServiceInstanceId() == null
1281 || input.getServiceInformation().getServiceInstanceId().length() == 0) {
1282 log.debug("exiting {} because of null or empty service-instance-id", SVC_OPERATION);
1283 responseBuilder.setResponseCode("404");
1284 responseBuilder.setResponseMessage("invalid input, null or empty service-instance-id");
1285 responseBuilder.setAckFinalIndicator("Y");
1286 RpcResult<ContrailRouteTopologyOperationOutput> rpcResult = RpcResultBuilder
1287 .<ContrailRouteTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1288 return Futures.immediateFuture(rpcResult);
1291 String siid = input.getServiceInformation().getServiceInstanceId();
1293 // Get the service-instance service data from MD-SAL
1294 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1295 getServiceData(siid, serviceDataBuilder);
1297 if (input.getSdncRequestHeader() != null) {
1298 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1301 ServiceData sd = serviceDataBuilder.build();
1302 if (sd == null || sd.getServiceLevelOperStatus() == null) {
1303 log.debug("exiting {} because the service-instance does not have any service data in SDNC", SVC_OPERATION);
1304 responseBuilder.setResponseCode("404");
1306 .setResponseMessage("invalid input: the service-instance does not have any service data in SDNC");
1307 responseBuilder.setAckFinalIndicator("Y");
1308 RpcResult<ContrailRouteTopologyOperationOutput> rpcResult = RpcResultBuilder
1309 .<ContrailRouteTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1310 return Futures.immediateFuture(rpcResult);
1313 log.info("Adding INPUT data for " + SVC_OPERATION + " [" + siid + "] input: " + input);
1314 ContrailRouteTopologyOperationInputBuilder inputBuilder = new ContrailRouteTopologyOperationInputBuilder(input);
1315 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1317 // Call SLI sync method
1318 // Get SvcLogicService reference
1320 Properties respProps = null;
1322 String errorCode = "200";
1323 String errorMessage = null;
1324 String ackFinal = "Y";
1325 String allottedResourceId = "error";
1326 String serviceObjectPath = null;
1327 String contrailRouteObjectPath = null;
1330 if (svcLogicClient.hasGraph(appName, SVC_OPERATION, null, "sync")) {
1333 respProps = svcLogicClient.execute(appName, SVC_OPERATION, null, "sync", serviceDataBuilder, parms);
1334 } catch (Exception e) {
1335 log.error("Caught exception executing service logic for {}", SVC_OPERATION, e);
1336 errorMessage = e.getMessage();
1340 errorMessage = "No service logic active for " + appName + ": '" + SVC_OPERATION + "'";
1343 } catch (Exception e) {
1345 errorMessage = e.getMessage();
1346 log.error("Caught exception looking for service logic", e);
1349 if (respProps != null) {
1350 errorCode = respProps.getProperty("error-code");
1351 errorMessage = respProps.getProperty("error-message");
1352 ackFinal = respProps.getProperty("ack-final", "Y");
1353 allottedResourceId = respProps.getProperty("allotted-resource-id");
1354 serviceObjectPath = respProps.getProperty("service-object-path");
1355 contrailRouteObjectPath = respProps.getProperty("contrail-route-object-path");
1358 if (errorCode != null && errorCode.length() != 0 && !(errorCode.equals("0") || errorCode.equals("200"))) {
1359 responseBuilder.setResponseCode(errorCode);
1360 responseBuilder.setResponseMessage(errorMessage);
1361 responseBuilder.setAckFinalIndicator(ackFinal);
1363 log.error("Returned FAILED for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
1365 RpcResult<ContrailRouteTopologyOperationOutput> rpcResult = RpcResultBuilder
1366 .<ContrailRouteTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1367 return Futures.immediateFuture(rpcResult);
1370 // Got success from SLI
1373 serviceData = serviceDataBuilder.build();
1374 log.info("Updating MD-SAL for {} [{}] ServiceData: {}", SVC_OPERATION, siid, serviceData);
1377 ServiceBuilder serviceBuilder = new ServiceBuilder();
1378 serviceBuilder.setServiceData(serviceData);
1379 serviceBuilder.setServiceInstanceId(siid);
1380 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1381 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1383 if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null) {
1384 // Only update operational tree on activate or delete
1385 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Unassign)
1386 || input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate)) {
1387 log.info("Updating OPERATIONAL tree.");
1388 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1392 ContrailRouteResponseInformationBuilder contrailRouteResponseInformationBuilder = new ContrailRouteResponseInformationBuilder();
1393 contrailRouteResponseInformationBuilder.setInstanceId(allottedResourceId);
1394 contrailRouteResponseInformationBuilder.setObjectPath(contrailRouteObjectPath);
1395 responseBuilder.setContrailRouteResponseInformation(contrailRouteResponseInformationBuilder.build());
1397 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1398 serviceResponseInformationBuilder.setInstanceId(siid);
1399 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1400 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1402 } catch (IllegalStateException e) {
1403 log.error("Caught Exception updating MD-SAL for {} [{}] \n", SVC_OPERATION, siid, e);
1404 responseBuilder.setResponseCode("500");
1405 responseBuilder.setResponseMessage(e.toString());
1406 responseBuilder.setAckFinalIndicator("Y");
1407 log.error("Returned FAILED for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
1408 RpcResult<ContrailRouteTopologyOperationOutput> rpcResult = RpcResultBuilder
1409 .<ContrailRouteTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1410 return Futures.immediateFuture(rpcResult);
1414 responseBuilder.setResponseCode(errorCode);
1415 responseBuilder.setAckFinalIndicator(ackFinal);
1416 if (errorMessage != null) {
1417 responseBuilder.setResponseMessage(errorMessage);
1419 log.info("Updated MD-SAL for {} [{}]", SVC_OPERATION, siid);
1420 log.info("Returned SUCCESS for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
1422 RpcResult<ContrailRouteTopologyOperationOutput> rpcResult = RpcResultBuilder
1423 .<ContrailRouteTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1424 return Futures.immediateFuture(rpcResult);
1428 public Future<RpcResult<SecurityZoneTopologyOperationOutput>> securityZoneTopologyOperation(
1429 SecurityZoneTopologyOperationInput input) {
1431 final String SVC_OPERATION = "security-zone-topology-operation";
1432 ServiceData serviceData;
1433 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1434 Properties parms = new Properties();
1436 log.info("{} called.", SVC_OPERATION);
1437 // create a new response object
1438 SecurityZoneTopologyOperationOutputBuilder responseBuilder = new SecurityZoneTopologyOperationOutputBuilder();
1440 if (input == null || input.getServiceInformation() == null
1441 || input.getServiceInformation().getServiceInstanceId() == null
1442 || input.getServiceInformation().getServiceInstanceId().length() == 0) {
1443 log.debug("exiting {} because of null or empty service-instance-id", SVC_OPERATION);
1444 responseBuilder.setResponseCode("404");
1445 responseBuilder.setResponseMessage("invalid input, null or empty service-instance-id");
1446 responseBuilder.setAckFinalIndicator("Y");
1447 RpcResult<SecurityZoneTopologyOperationOutput> rpcResult = RpcResultBuilder
1448 .<SecurityZoneTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1449 return Futures.immediateFuture(rpcResult);
1452 String siid = input.getServiceInformation().getServiceInstanceId();
1454 // Get the service-instance service data from MD-SAL
1455 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1456 getServiceData(siid, serviceDataBuilder);
1458 if (input.getSdncRequestHeader() != null) {
1459 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1462 ServiceData sd = serviceDataBuilder.build();
1463 if (sd == null || sd.getServiceLevelOperStatus() == null) {
1464 log.debug("exiting {} because the service-instance does not have any service data in SDNC", SVC_OPERATION);
1465 responseBuilder.setResponseCode("404");
1467 .setResponseMessage("invalid input: the service-instance does not have any service data in SDNC");
1468 responseBuilder.setAckFinalIndicator("Y");
1469 RpcResult<SecurityZoneTopologyOperationOutput> rpcResult = RpcResultBuilder
1470 .<SecurityZoneTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1471 return Futures.immediateFuture(rpcResult);
1474 log.info("Adding INPUT data for {} [{}] input: {}", SVC_OPERATION, siid, input);
1475 SecurityZoneTopologyOperationInputBuilder inputBuilder = new SecurityZoneTopologyOperationInputBuilder(input);
1476 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1478 // Call SLI sync method
1479 // Get SvcLogicService reference
1481 Properties respProps = null;
1483 String errorCode = "200";
1484 String errorMessage = null;
1485 String ackFinal = "Y";
1486 String allottedResourceId = "error";
1487 String serviceObjectPath = null;
1488 String securityZoneObjectPath = null;
1491 if (svcLogicClient.hasGraph(appName, SVC_OPERATION, null, "sync")) {
1494 respProps = svcLogicClient.execute(appName, SVC_OPERATION, null, "sync", serviceDataBuilder, parms);
1495 } catch (Exception e) {
1496 log.error("Caught exception executing service logic for {}", SVC_OPERATION, e);
1497 errorMessage = e.getMessage();
1501 errorMessage = "No service logic active for " + appName + ": '" + SVC_OPERATION + "'";
1504 } catch (Exception e) {
1506 errorMessage = e.getMessage();
1507 log.error("Caught exception looking for service logic", e);
1510 if (respProps != null) {
1511 errorCode = respProps.getProperty("error-code");
1512 errorMessage = respProps.getProperty("error-message");
1513 ackFinal = respProps.getProperty("ack-final", "Y");
1514 allottedResourceId = respProps.getProperty("allotted-resource-id");
1515 serviceObjectPath = respProps.getProperty("service-object-path");
1516 securityZoneObjectPath = respProps.getProperty("security-zone-object-path");
1519 if (errorCode != null && errorCode.length() != 0 && !(errorCode.equals("0") || errorCode.equals("200"))) {
1520 responseBuilder.setResponseCode(errorCode);
1521 responseBuilder.setResponseMessage(errorMessage);
1522 responseBuilder.setAckFinalIndicator(ackFinal);
1524 log.error("Returned FAILED for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
1526 RpcResult<SecurityZoneTopologyOperationOutput> rpcResult = RpcResultBuilder
1527 .<SecurityZoneTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1528 return Futures.immediateFuture(rpcResult);
1531 // Got success from SLI
1534 serviceData = serviceDataBuilder.build();
1535 log.info("Updating MD-SAL for {} [{}] ServiceData: {}", SVC_OPERATION, siid, serviceData);
1538 ServiceBuilder serviceBuilder = new ServiceBuilder();
1539 serviceBuilder.setServiceData(serviceData);
1540 serviceBuilder.setServiceInstanceId(siid);
1541 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1542 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1544 if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null) {
1545 // Only update operational tree on activate or delete
1546 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Unassign)
1547 || input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate)) {
1548 log.info("Updating OPERATIONAL tree.");
1549 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1553 SecurityZoneResponseInformationBuilder securityZoneResponseInformationBuilder = new SecurityZoneResponseInformationBuilder();
1554 securityZoneResponseInformationBuilder.setInstanceId(allottedResourceId);
1555 securityZoneResponseInformationBuilder.setObjectPath(securityZoneObjectPath);
1556 responseBuilder.setSecurityZoneResponseInformation(securityZoneResponseInformationBuilder.build());
1558 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1559 serviceResponseInformationBuilder.setInstanceId(siid);
1560 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1561 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1563 } catch (IllegalStateException e) {
1564 log.error("Caught Exception updating MD-SAL for {} [{}] \n", SVC_OPERATION, siid, e);
1565 responseBuilder.setResponseCode("500");
1566 responseBuilder.setResponseMessage(e.toString());
1567 responseBuilder.setAckFinalIndicator("Y");
1568 log.error("Returned FAILED for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
1569 RpcResult<SecurityZoneTopologyOperationOutput> rpcResult = RpcResultBuilder
1570 .<SecurityZoneTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1571 return Futures.immediateFuture(rpcResult);
1575 responseBuilder.setResponseCode(errorCode);
1576 responseBuilder.setAckFinalIndicator(ackFinal);
1577 if (errorMessage != null) {
1578 responseBuilder.setResponseMessage(errorMessage);
1580 log.info("Updated MD-SAL for {} [{}]", SVC_OPERATION, siid);
1581 log.info("Returned SUCCESS for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
1583 RpcResult<SecurityZoneTopologyOperationOutput> rpcResult = RpcResultBuilder
1584 .<SecurityZoneTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1585 return Futures.immediateFuture(rpcResult);
1589 public Future<RpcResult<TunnelxconnTopologyOperationOutput>> tunnelxconnTopologyOperation(
1590 TunnelxconnTopologyOperationInput input) {
1592 final String SVC_OPERATION = "tunnelxconn-topology-operation";
1593 ServiceData serviceData;
1594 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1595 Properties parms = new Properties();
1597 log.info("{} called.", SVC_OPERATION);
1598 // create a new response object
1599 TunnelxconnTopologyOperationOutputBuilder responseBuilder = new TunnelxconnTopologyOperationOutputBuilder();
1601 if (input == null || input.getServiceInformation() == null
1602 || input.getServiceInformation().getServiceInstanceId() == null
1603 || input.getServiceInformation().getServiceInstanceId().length() == 0) {
1604 log.debug("exiting {} because of null or empty service-instance-id", SVC_OPERATION);
1605 responseBuilder.setResponseCode("404");
1606 responseBuilder.setResponseMessage("invalid input, null or empty service-instance-id");
1607 responseBuilder.setAckFinalIndicator("Y");
1608 RpcResult<TunnelxconnTopologyOperationOutput> rpcResult = RpcResultBuilder
1609 .<TunnelxconnTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1610 return Futures.immediateFuture(rpcResult);
1613 String siid = input.getServiceInformation().getServiceInstanceId();
1615 // Get the service-instance service data from MD-SAL
1616 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1617 getServiceData(siid, serviceDataBuilder);
1619 if (input.getSdncRequestHeader() != null) {
1620 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1623 ServiceData sd = serviceDataBuilder.build();
1624 if (sd == null || sd.getServiceLevelOperStatus() == null) {
1625 log.debug("exiting {} because the service-instance does not have any service data in SDNC", SVC_OPERATION);
1626 responseBuilder.setResponseCode("404");
1628 .setResponseMessage("invalid input: the service-instance does not have any service data in SDNC");
1629 responseBuilder.setAckFinalIndicator("Y");
1630 RpcResult<TunnelxconnTopologyOperationOutput> rpcResult = RpcResultBuilder
1631 .<TunnelxconnTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1632 return Futures.immediateFuture(rpcResult);
1635 log.info("Adding INPUT data for {} [{}] input: {}", SVC_OPERATION, siid, input);
1636 TunnelxconnTopologyOperationInputBuilder inputBuilder = new TunnelxconnTopologyOperationInputBuilder(input);
1637 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1639 // Call SLI sync method
1640 // Get SvcLogicService reference
1642 Properties respProps = null;
1644 String errorCode = "200";
1645 String errorMessage = null;
1646 String ackFinal = "Y";
1647 String allottedResourceId = "error";
1648 String serviceObjectPath = null;
1649 String tunnelxconnObjectPath = null;
1652 if (svcLogicClient.hasGraph(appName, SVC_OPERATION, null, "sync")) {
1655 respProps = svcLogicClient.execute(appName, SVC_OPERATION, null, "sync", serviceDataBuilder, parms);
1656 } catch (Exception e) {
1657 log.error("Caught exception executing service logic for {}", SVC_OPERATION, e);
1658 errorMessage = e.getMessage();
1662 errorMessage = "No service logic active for " + appName + ": '" + SVC_OPERATION + "'";
1665 } catch (Exception e) {
1667 errorMessage = e.getMessage();
1668 log.error("Caught exception looking for service logic", e);
1671 if (respProps != null) {
1672 errorCode = respProps.getProperty("error-code");
1673 errorMessage = respProps.getProperty("error-message");
1674 ackFinal = respProps.getProperty("ack-final", "Y");
1675 allottedResourceId = respProps.getProperty("allotted-resource-id");
1676 serviceObjectPath = respProps.getProperty("service-object-path");
1677 tunnelxconnObjectPath = respProps.getProperty("tunnelxconn-object-path");
1680 if (errorCode != null && errorCode.length() != 0 && !(errorCode.equals("0") || errorCode.equals("200"))) {
1681 responseBuilder.setResponseCode(errorCode);
1682 responseBuilder.setResponseMessage(errorMessage);
1683 responseBuilder.setAckFinalIndicator(ackFinal);
1685 log.error("Returned FAILED for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
1687 RpcResult<TunnelxconnTopologyOperationOutput> rpcResult = RpcResultBuilder
1688 .<TunnelxconnTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1689 return Futures.immediateFuture(rpcResult);
1692 // Got success from SLI
1695 serviceData = serviceDataBuilder.build();
1696 log.info("Updating MD-SAL for {} [{}] ServiceData: {}", SVC_OPERATION, siid, serviceData);
1699 ServiceBuilder serviceBuilder = new ServiceBuilder();
1700 serviceBuilder.setServiceData(serviceData);
1701 serviceBuilder.setServiceInstanceId(siid);
1702 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1703 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1705 if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null) {
1706 // Only update operational tree on activate or delete
1707 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Unassign)
1708 || input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate)) {
1709 log.info("Updating OPERATIONAL tree.");
1710 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1714 TunnelxconnResponseInformationBuilder tunnelxconnResponseInformationBuilder = new TunnelxconnResponseInformationBuilder();
1715 tunnelxconnResponseInformationBuilder.setInstanceId(allottedResourceId);
1716 tunnelxconnResponseInformationBuilder.setObjectPath(tunnelxconnObjectPath);
1717 responseBuilder.setTunnelxconnResponseInformation(tunnelxconnResponseInformationBuilder.build());
1719 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1720 serviceResponseInformationBuilder.setInstanceId(siid);
1721 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1722 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1724 } catch (IllegalStateException e) {
1725 log.error("Caught Exception updating MD-SAL for {} [{}] \n", SVC_OPERATION, siid, e);
1726 responseBuilder.setResponseCode("500");
1727 responseBuilder.setResponseMessage(e.toString());
1728 responseBuilder.setAckFinalIndicator("Y");
1729 log.error("Returned FAILED for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
1730 RpcResult<TunnelxconnTopologyOperationOutput> rpcResult = RpcResultBuilder
1731 .<TunnelxconnTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1732 return Futures.immediateFuture(rpcResult);
1736 responseBuilder.setResponseCode(errorCode);
1737 responseBuilder.setAckFinalIndicator(ackFinal);
1738 if (errorMessage != null) {
1739 responseBuilder.setResponseMessage(errorMessage);
1741 log.info("Updated MD-SAL for {} [{}]", SVC_OPERATION, siid);
1742 log.info("Returned SUCCESS for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
1744 RpcResult<TunnelxconnTopologyOperationOutput> rpcResult = RpcResultBuilder
1745 .<TunnelxconnTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1746 return Futures.immediateFuture(rpcResult);
1750 public Future<RpcResult<BrgTopologyOperationOutput>> brgTopologyOperation(BrgTopologyOperationInput input) {
1751 final String SVC_OPERATION = "brg-topology-operation";
1752 ServiceData serviceData;
1753 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1754 Properties parms = new Properties();
1756 log.info("{} called.", SVC_OPERATION);
1757 // create a new response object
1758 BrgTopologyOperationOutputBuilder responseBuilder = new BrgTopologyOperationOutputBuilder();
1760 if (input == null || input.getServiceInformation() == null
1761 || input.getServiceInformation().getServiceInstanceId() == null
1762 || input.getServiceInformation().getServiceInstanceId().length() == 0) {
1763 log.debug("exiting {} because of null or empty service-instance-id", SVC_OPERATION);
1764 responseBuilder.setResponseCode("404");
1765 responseBuilder.setResponseMessage("invalid input, null or empty service-instance-id");
1766 responseBuilder.setAckFinalIndicator("Y");
1767 RpcResult<BrgTopologyOperationOutput> rpcResult = RpcResultBuilder.<BrgTopologyOperationOutput>status(true)
1768 .withResult(responseBuilder.build()).build();
1769 return Futures.immediateFuture(rpcResult);
1772 String siid = input.getServiceInformation().getServiceInstanceId();
1774 // Get the service-instance service data from MD-SAL
1775 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1776 getServiceData(siid, serviceDataBuilder);
1778 if (input.getSdncRequestHeader() != null) {
1779 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1782 ServiceData sd = serviceDataBuilder.build();
1783 if (sd == null || sd.getServiceLevelOperStatus() == null) {
1784 log.debug("exiting {} because the service-instance does not have any service data in SDNC", SVC_OPERATION);
1785 responseBuilder.setResponseCode("404");
1787 .setResponseMessage("invalid input: the service-instance does not have any service data in SDNC");
1788 responseBuilder.setAckFinalIndicator("Y");
1789 RpcResult<BrgTopologyOperationOutput> rpcResult = RpcResultBuilder.<BrgTopologyOperationOutput>status(true)
1790 .withResult(responseBuilder.build()).build();
1791 return Futures.immediateFuture(rpcResult);
1794 log.info("Adding INPUT data for {} [{}] input: {}", SVC_OPERATION, siid, input);
1795 BrgTopologyOperationInputBuilder inputBuilder = new BrgTopologyOperationInputBuilder(input);
1796 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1798 // Call SLI sync method
1799 // Get SvcLogicService reference
1801 Properties respProps = null;
1803 String errorCode = "200";
1804 String errorMessage = null;
1805 String ackFinal = "Y";
1806 String allottedResourceId = "error";
1807 String serviceObjectPath = null;
1808 String brgObjectPath = null;
1811 if (svcLogicClient.hasGraph(appName, SVC_OPERATION, null, "sync")) {
1814 respProps = svcLogicClient.execute(appName, SVC_OPERATION, null, "sync", serviceDataBuilder, parms);
1815 } catch (Exception e) {
1816 log.error("Caught exception executing service logic for {}", SVC_OPERATION, e);
1817 errorMessage = e.getMessage();
1821 errorMessage = "No service logic active for " + appName + ": '" + SVC_OPERATION + "'";
1824 } catch (Exception e) {
1826 errorMessage = e.getMessage();
1827 log.error("Caught exception looking for service logic", e);
1830 if (respProps != null) {
1831 errorCode = respProps.getProperty("error-code");
1832 errorMessage = respProps.getProperty("error-message");
1833 ackFinal = respProps.getProperty("ack-final", "Y");
1834 allottedResourceId = respProps.getProperty("allotted-resource-id");
1835 serviceObjectPath = respProps.getProperty("service-object-path");
1836 brgObjectPath = respProps.getProperty("brg-object-path");
1839 if (errorCode != null && errorCode.length() != 0 && !(errorCode.equals("0") || errorCode.equals("200"))) {
1840 responseBuilder.setResponseCode(errorCode);
1841 responseBuilder.setResponseMessage(errorMessage);
1842 responseBuilder.setAckFinalIndicator(ackFinal);
1844 log.error("Returned FAILED for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
1846 RpcResult<BrgTopologyOperationOutput> rpcResult = RpcResultBuilder.<BrgTopologyOperationOutput>status(true)
1847 .withResult(responseBuilder.build()).build();
1848 return Futures.immediateFuture(rpcResult);
1851 // Got success from SLI
1854 serviceData = serviceDataBuilder.build();
1855 log.info("Updating MD-SAL for {} [{}] ServiceData: {}", SVC_OPERATION, siid, serviceData);
1858 ServiceBuilder serviceBuilder = new ServiceBuilder();
1859 serviceBuilder.setServiceData(serviceData);
1860 serviceBuilder.setServiceInstanceId(siid);
1861 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1862 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1864 if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null) {
1865 // Only update operational tree on activate or delete
1866 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Unassign)
1867 || input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate)) {
1868 log.info("Updating OPERATIONAL tree.");
1869 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1873 BrgResponseInformationBuilder brgResponseInformationBuilder = new BrgResponseInformationBuilder();
1874 brgResponseInformationBuilder.setInstanceId(allottedResourceId);
1875 brgResponseInformationBuilder.setObjectPath(brgObjectPath);
1876 responseBuilder.setBrgResponseInformation(brgResponseInformationBuilder.build());
1878 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1879 serviceResponseInformationBuilder.setInstanceId(siid);
1880 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1881 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1883 } catch (IllegalStateException e) {
1884 log.error("Caught Exception updating MD-SAL for {} [{}] \n", SVC_OPERATION, siid, e);
1885 responseBuilder.setResponseCode("500");
1886 responseBuilder.setResponseMessage(e.toString());
1887 responseBuilder.setAckFinalIndicator("Y");
1888 log.error("Returned FAILED for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
1889 RpcResult<BrgTopologyOperationOutput> rpcResult = RpcResultBuilder.<BrgTopologyOperationOutput>status(true)
1890 .withResult(responseBuilder.build()).build();
1891 return Futures.immediateFuture(rpcResult);
1895 responseBuilder.setResponseCode(errorCode);
1896 responseBuilder.setAckFinalIndicator(ackFinal);
1897 if (errorMessage != null) {
1898 responseBuilder.setResponseMessage(errorMessage);
1900 log.info("Updated MD-SAL for {} [{}]", SVC_OPERATION, siid);
1901 log.info("Returned SUCCESS for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
1903 RpcResult<BrgTopologyOperationOutput> rpcResult = RpcResultBuilder.<BrgTopologyOperationOutput>status(true)
1904 .withResult(responseBuilder.build()).build();
1905 return Futures.immediateFuture(rpcResult);
1909 public Future<RpcResult<PreloadVnfTopologyOperationOutput>> preloadVnfTopologyOperation(
1910 PreloadVnfTopologyOperationInput input) {
1912 final String SVC_OPERATION = "preload-vnf-topology-operation";
1913 PreloadData preloadData;
1914 Properties parms = new Properties();
1916 log.info("{} called.", SVC_OPERATION);
1917 // create a new response object
1918 PreloadVnfTopologyOperationOutputBuilder responseBuilder = new PreloadVnfTopologyOperationOutputBuilder();
1920 // Result from savePreloadData
1921 final SettableFuture<RpcResult<Void>> futureResult = SettableFuture.create();
1923 if (input == null || input.getVnfTopologyInformation() == null
1924 || input.getVnfTopologyInformation().getVnfTopologyIdentifier() == null) {
1925 log.debug("exiting {} because of null input", SVC_OPERATION);
1926 responseBuilder.setResponseCode("403");
1927 responseBuilder.setResponseMessage("invalid input: input is null");
1928 responseBuilder.setAckFinalIndicator("Y");
1929 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult = RpcResultBuilder
1930 .<PreloadVnfTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1931 return Futures.immediateFuture(rpcResult);
1934 // Grab the name and type from the input buffer
1935 String preload_name = input.getVnfTopologyInformation().getVnfTopologyIdentifier().getVnfName();
1936 String preload_type = input.getVnfTopologyInformation().getVnfTopologyIdentifier().getVnfType();
1938 // Make sure we have a preload_name and preload_type
1939 if (preload_name == null || preload_name.length() == 0 || preload_type == null || preload_type.length() == 0) {
1940 log.debug("exiting {} vnf-name or vnf-type is null or empty", SVC_OPERATION);
1941 responseBuilder.setResponseCode("403");
1942 responseBuilder.setResponseMessage("invalid input: vnf-name or vnf-type is null or empty");
1943 responseBuilder.setAckFinalIndicator("Y");
1944 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult = RpcResultBuilder
1945 .<PreloadVnfTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1946 return Futures.immediateFuture(rpcResult);
1949 if (input.getSdncRequestHeader() != null) {
1950 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1953 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
1954 getPreloadData(preload_name, preload_type, preloadDataBuilder);
1956 PreloadDataBuilder operDataBuilder = new PreloadDataBuilder();
1957 getPreloadData(preload_name, preload_type, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
1959 // setup a preload-data object builder
1960 // ACTION preload-vnf-topology-operation
1962 // USES sdnc-request-header;
1963 // USES request-information;
1964 // uses vnf-topology-information;
1966 // USES vnf-topology-response-body;
1968 // container preload-data
1969 // uses vnf-topology-information;
1970 // uses network-topology-information;
1971 // uses oper-status;
1973 log.info("Adding INPUT data for {} [{},{}] input: {}", SVC_OPERATION, preload_name, preload_type, input);
1974 PreloadVnfTopologyOperationInputBuilder inputBuilder = new PreloadVnfTopologyOperationInputBuilder(input);
1975 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1976 log.info("Adding OPERATIONAL data for {} [{},{}] operational-data: {}", SVC_OPERATION, preload_name,
1977 preload_type, operDataBuilder.build());
1978 GenericResourceApiUtil.toProperties(parms, "operational-data", operDataBuilder);
1980 // Call SLI sync method
1981 // Get SvcLogicService reference
1983 Properties respProps = null;
1985 String errorCode = "200";
1986 String errorMessage = null;
1987 String ackFinal = "Y";
1990 if (svcLogicClient.hasGraph(appName, SVC_OPERATION, null, "sync")) {
1993 respProps = svcLogicClient.execute(appName, SVC_OPERATION, null, "sync", preloadDataBuilder, parms);
1994 } catch (Exception e) {
1995 log.error("Caught exception executing service logic for {}", SVC_OPERATION, e);
1996 errorMessage = e.getMessage();
2000 errorMessage = "No service logic active for " + appName + ": '" + SVC_OPERATION + "'";
2003 } catch (Exception e) {
2005 errorMessage = e.getMessage();
2006 log.error("Caught exception looking for service logic", e);
2009 if (respProps != null) {
2010 errorCode = respProps.getProperty("error-code");
2011 errorMessage = respProps.getProperty("error-message");
2012 ackFinal = respProps.getProperty("ack-final", "Y");
2013 // internalError = respProps.getProperty("internal-error", "false");
2016 if (errorCode != null && errorCode.length() != 0 && !(errorCode.equals("0") || errorCode.equals("200"))) {
2018 responseBuilder.setResponseCode(errorCode);
2019 responseBuilder.setResponseMessage(errorMessage);
2020 responseBuilder.setAckFinalIndicator(ackFinal);
2022 VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
2023 preloadVnfListBuilder.setVnfName(preload_name);
2024 preloadVnfListBuilder.setVnfType(preload_type);
2025 preloadVnfListBuilder.setPreloadData(preloadDataBuilder.build());
2026 log.error("Returned FAILED for {} [{},{}] error code: '{}', Reason: '{}'", SVC_OPERATION, preload_name,
2027 preload_type, errorCode, errorMessage);
2029 savePreloadList(preloadVnfListBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
2030 } catch (Exception e) {
2031 log.error("Caught Exception updating MD-SAL for {} [{},{}] \n", SVC_OPERATION, preload_name,
2034 log.debug("Sending Success rpc result due to external error");
2035 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult = RpcResultBuilder
2036 .<PreloadVnfTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2037 return Futures.immediateFuture(rpcResult);
2040 // Got success from SLI
2042 preloadData = preloadDataBuilder.build();
2043 log.info("Updating MD-SAL for {} [{},{}] preloadData: {}", SVC_OPERATION, preload_name, preload_type,
2045 // svc-configuration-list
2046 VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
2047 preloadVnfListBuilder.setVnfName(preload_name);
2048 preloadVnfListBuilder.setVnfType(preload_type);
2049 preloadVnfListBuilder.setPreloadData(preloadData);
2051 // merge flag sets to false to allow it to be overwritten (not appended)
2052 savePreloadList(preloadVnfListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
2053 log.info("Updating OPERATIONAL tree.");
2054 savePreloadList(preloadVnfListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
2055 } catch (Exception e) {
2056 log.error("Caught Exception updating MD-SAL for {} [{},{}] \n", SVC_OPERATION, preload_name, preload_type,
2058 responseBuilder.setResponseCode("500");
2059 responseBuilder.setResponseMessage(e.toString());
2060 responseBuilder.setAckFinalIndicator("Y");
2061 log.error("Returned FAILED for {} [{},{}] {}", SVC_OPERATION, preload_name, preload_type,
2062 responseBuilder.build());
2063 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult = RpcResultBuilder
2064 .<PreloadVnfTopologyOperationOutput>status(false).withResult(responseBuilder.build()).build();
2065 return Futures.immediateFuture(rpcResult);
2069 responseBuilder.setResponseCode(errorCode);
2070 responseBuilder.setAckFinalIndicator(ackFinal);
2071 if (errorMessage != null) {
2072 responseBuilder.setResponseMessage(errorMessage);
2074 log.info("Updated MD-SAL for {} [{},{}]", SVC_OPERATION, preload_name, preload_type);
2075 log.info("Returned SUCCESS for {} [{},{}] {}", SVC_OPERATION, preload_name, preload_type,
2076 responseBuilder.build());
2078 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult = RpcResultBuilder
2079 .<PreloadVnfTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2080 return Futures.immediateFuture(rpcResult);
2084 public Future<RpcResult<PreloadNetworkTopologyOperationOutput>> preloadNetworkTopologyOperation(
2085 PreloadNetworkTopologyOperationInput input) {
2087 final String SVC_OPERATION = "preload-network-topology-operation";
2088 PreloadData preloadData;
2089 Properties parms = new Properties();
2091 log.info("{} called.", SVC_OPERATION);
2092 // create a new response object
2093 PreloadNetworkTopologyOperationOutputBuilder responseBuilder = new PreloadNetworkTopologyOperationOutputBuilder();
2095 // Result from savePreloadData
2096 final SettableFuture<RpcResult<Void>> futureResult = SettableFuture.create();
2098 if (input == null || input.getNetworkTopologyInformation() == null
2099 || input.getNetworkTopologyInformation().getNetworkTopologyIdentifier() == null) {
2101 log.debug("exiting {} because of null input", SVC_OPERATION);
2102 responseBuilder.setResponseCode("403");
2103 responseBuilder.setResponseMessage("input is null");
2104 responseBuilder.setAckFinalIndicator("Y");
2105 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
2106 .<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2107 return Futures.immediateFuture(rpcResult);
2110 // Grab the name and type from the input buffer
2111 String preload_name = input.getNetworkTopologyInformation().getNetworkTopologyIdentifier().getNetworkName();
2112 String preload_type = input.getNetworkTopologyInformation().getNetworkTopologyIdentifier().getNetworkType();
2114 // Make sure we have a preload_name and preload_type
2115 if (preload_name == null || preload_name.length() == 0 || preload_type == null || preload_type.length() == 0) {
2116 log.debug("exiting {} because of invalid preload-name", SVC_OPERATION);
2117 responseBuilder.setResponseCode("403");
2118 responseBuilder.setResponseMessage("input, invalid preload-name");
2119 responseBuilder.setAckFinalIndicator("Y");
2120 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
2121 .<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2122 return Futures.immediateFuture(rpcResult);
2125 if (input.getSdncRequestHeader() != null) {
2126 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
2129 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
2130 getPreloadData(preload_name, preload_type, preloadDataBuilder);
2132 PreloadDataBuilder operDataBuilder = new PreloadDataBuilder();
2133 getPreloadData(preload_name, preload_type, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
2136 // setup a preload-data object builder
2137 // ACTION preload-network-topology-operation
2139 // USES sdnc-request-header;
2140 // USES request-information;
2141 // uses network-topology-information;
2143 // USES vnf-topology-response-body;
2145 // container preload-data
2146 // uses vnf-topology-information;
2147 // uses network-topology-information;
2148 // uses oper-status;
2150 log.info("Adding INPUT data for {} [{},{}] input: {}", SVC_OPERATION, preload_name, preload_type, input);
2151 PreloadNetworkTopologyOperationInputBuilder inputBuilder = new PreloadNetworkTopologyOperationInputBuilder(
2153 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
2154 log.info("Adding OPERATIONAL data for {} [{},{}] operational-data: {}", SVC_OPERATION, preload_name,
2155 preload_type, operDataBuilder.build());
2156 GenericResourceApiUtil.toProperties(parms, "operational-data", operDataBuilder);
2158 // Call SLI sync method
2159 // Get SvcLogicService reference
2161 Properties respProps = null;
2163 String errorCode = "200";
2164 String errorMessage = null;
2165 String ackFinal = "Y";
2168 if (svcLogicClient.hasGraph(appName, SVC_OPERATION, null, "sync")) {
2171 respProps = svcLogicClient.execute(appName, SVC_OPERATION, null, "sync", preloadDataBuilder, parms);
2172 } catch (Exception e) {
2173 log.error("Caught exception executing service logic for {}", SVC_OPERATION, e);
2174 errorMessage = e.getMessage();
2178 errorMessage = "No service logic active for " + appName + ": '" + SVC_OPERATION + "'";
2181 } catch (Exception e) {
2183 errorMessage = e.getMessage();
2184 log.error("Caught exception looking for service logic", e);
2187 if (respProps != null) {
2188 errorCode = respProps.getProperty("error-code");
2189 errorMessage = respProps.getProperty("error-message");
2190 ackFinal = respProps.getProperty("ack-final", "Y");
2191 // internalError = respProps.getProperty("internal-error", "false");
2194 if (errorCode != null && errorCode.length() != 0 && !(errorCode.equals("0") || errorCode.equals("200"))) {
2196 responseBuilder.setResponseCode(errorCode);
2197 responseBuilder.setResponseMessage(errorMessage);
2198 responseBuilder.setAckFinalIndicator(ackFinal);
2200 VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
2201 preloadVnfListBuilder.setVnfName(preload_name);
2202 preloadVnfListBuilder.setVnfType(preload_type);
2203 preloadVnfListBuilder.setPreloadData(preloadDataBuilder.build());
2204 log.error("Returned FAILED for {} [{},{}] error code: '{}', Reason: '{}'", SVC_OPERATION, preload_name,
2205 preload_type, errorCode, errorMessage);
2207 savePreloadList(preloadVnfListBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
2208 } catch (Exception e) {
2209 log.error("Caught Exception updating MD-SAL for {} [{},{}] \n", SVC_OPERATION, preload_name,
2213 log.debug("Sending Success rpc result due to external error");
2214 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
2215 .<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2216 return Futures.immediateFuture(rpcResult);
2219 // Got success from SLI
2221 preloadData = preloadDataBuilder.build();
2222 log.info("Updating MD-SAL for {} [{},{}] preloadData: {}", SVC_OPERATION, preload_name, preload_type,
2224 // svc-configuration-list
2225 VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
2226 preloadVnfListBuilder.setVnfName(preload_name);
2227 preloadVnfListBuilder.setVnfType(preload_type);
2228 preloadVnfListBuilder.setPreloadData(preloadData);
2230 // merge flag sets to false to allow it to be overwritten (not appended)
2231 savePreloadList(preloadVnfListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
2232 log.info("Updating OPERATIONAL tree.");
2233 savePreloadList(preloadVnfListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
2234 } catch (Exception e) {
2235 log.error("Caught Exception updating MD-SAL for " + SVC_OPERATION + " [" + preload_name + "," + preload_type
2237 responseBuilder.setResponseCode("500");
2238 responseBuilder.setResponseMessage(e.toString());
2239 responseBuilder.setAckFinalIndicator("Y");
2240 log.error("Returned FAILED for {} [{},{}] {}", SVC_OPERATION, preload_name, preload_type,
2241 responseBuilder.build());
2242 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
2243 .<PreloadNetworkTopologyOperationOutput>status(false).withResult(responseBuilder.build()).build();
2244 return Futures.immediateFuture(rpcResult);
2248 responseBuilder.setResponseCode(errorCode);
2249 responseBuilder.setAckFinalIndicator(ackFinal);
2250 if (errorMessage != null) {
2251 responseBuilder.setResponseMessage(errorMessage);
2253 log.info("Updated MD-SAL for {} [{},{}]", SVC_OPERATION, preload_name, preload_type);
2254 log.info("Returned SUCCESS for {} [{},{}] {}", SVC_OPERATION, preload_name, preload_type,
2255 responseBuilder.build());
2257 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
2258 .<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2259 return Futures.immediateFuture(rpcResult);