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.DataObject;
90 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
91 import org.opendaylight.yangtools.yang.common.RpcResult;
92 import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
93 import org.slf4j.Logger;
94 import org.slf4j.LoggerFactory;
96 import com.google.common.base.Optional;
97 import com.google.common.util.concurrent.CheckedFuture;
98 import com.google.common.util.concurrent.Futures;
101 * Defines a base implementation for your provider. This class extends from a helper class which provides storage for
102 * the most commonly used components of the MD-SAL. Additionally the base class provides some basic logging and
103 * initialization / clean up methods.
105 * To use this, copy and paste (overwrite) the following method into the TestApplicationProviderModule class which is
106 * auto generated under src/main/java in this project (created only once during first compilation):
111 * public java.lang.AutoCloseable createInstance() {
113 * // final GENERIC-RESOURCE-APIProvider provider = new
114 * // GENERIC-RESOURCE-APIProvider();
115 * final GenericResourceApiProvider provider = new GenericResourceApiProvider();
116 * provider.setDataBroker(getDataBrokerDependency());
117 * provider.setNotificationService(getNotificationServiceDependency());
118 * provider.setRpcRegistry(getRpcRegistryDependency());
119 * provider.initialize();
120 * return new AutoCloseable() {
123 * public void close() throws Exception {
124 * // TODO: CLOSE ANY REGISTRATION OBJECTS CREATED USING ABOVE
125 * // BROKER/NOTIFICATION
126 * // SERVIE/RPC REGISTRY
135 public class GenericResourceApiProvider implements AutoCloseable, GENERICRESOURCEAPIService {
137 private static final String APP_NAME = "generic-resource-api";
138 private static final String CALLED_STR = "{} called.";
139 private static final String NULL_OR_EMPTY_ERROR_MESSAGE = "exiting {} because of null or empty service-instance-id";
140 private static final String NULL_OR_EMPTY_ERROR_PARAM = "invalid input, null or empty service-instance-id";
141 private static final String ADDING_INPUT_DATA_LOG = "Adding INPUT data for {} [{}] input: {}";
142 private static final String ADDING_OPERATIONAL_DATA_LOG = "Adding OPERATIONAL data for {} [{}] operational-data: {}";
143 private static final String OPERATIONAL_DATA_PARAM = "operational-data";
144 private static final String NO_SERVICE_LOGIC_ACTIVE = "No service logic active for ";
145 private static final String SERVICE_LOGIC_SEARCH_ERROR_MESSAGE = "Caught exception looking for service logic";
146 private static final String ERROR_CODE_PARAM = "error-code";
147 private static final String ERROR_MESSAGE_PARAM = "error-message";
148 private static final String ACK_FINAL_PARAM = "ack-final";
149 private static final String SERVICE_OBJECT_PATH_PARAM = "service-object-path";
150 private static final String UPDATING_MDSAL_ERROR_MESSAGE = "Caught Exception updating MD-SAL for {} [{}] \n";
151 private static final String UPDATING_MDSAL_ERROR_MESSAGE_2 = "Caught Exception updating MD-SAL for {} [{},{}] \n";
152 private static final String RETURNED_FAILED_MESSAGE = "Returned FAILED for {} [{}] {}";
153 private static final String UPDATING_MDSAL_INFO_MESSAGE = "Updating MD-SAL for {} [{}] ServiceData: {}";
154 private static final String UPDATED_MDSAL_INFO_MESSAGE = "Updated MD-SAL for {} [{}]";
155 private static final String RETURNED_SUCCESS_MESSAGE = "Returned SUCCESS for {} [{}] {}";
156 private static final String NON_NULL_PARAM = "non-null";
157 private static final String NULL_PARAM = "null";
158 private static final String SERVICE_LOGIC_EXECUTION_ERROR_MESSAGE = "Caught exception executing service logic for {} ";
159 private static final String UPDATING_TREE_INFO_MESSAGE = "Updating OPERATIONAL tree.";
160 private static final String EMPTY_SERVICE_INSTANCE_MESSAGE = "exiting {} because the service-instance does not have any service data in SDNC";
161 private static final String INVALID_INPUT_ERROR_MESSAGE = "invalid input: the service-instance does not have any service data in SDNC";
162 private static final String ALLOTTED_RESOURCE_ID_PARAM = "allotted-resource-id";
163 private static final String ERROR_NETWORK_ID = "error";
165 private final Logger log = LoggerFactory.getLogger(GenericResourceApiProvider.class);
166 private final ExecutorService executor;
167 private final GenericResourceApiSvcLogicServiceClient svcLogicClient;
169 protected DataBroker dataBroker;
170 protected NotificationPublishService notificationService;
171 protected RpcProviderRegistry rpcRegistry;
172 protected BindingAwareBroker.RpcRegistration<GENERICRESOURCEAPIService> rpcRegistration;
174 public GenericResourceApiProvider(
175 DataBroker dataBroker,
176 NotificationPublishService notificationPublishService,
177 RpcProviderRegistry rpcProviderRegistry,
178 GenericResourceApiSvcLogicServiceClient client
180 log.info("Creating provider for {}", APP_NAME);
181 executor = Executors.newFixedThreadPool(1);
182 setDataBroker(dataBroker);
183 setNotificationService(notificationPublishService);
184 setRpcRegistry(rpcProviderRegistry);
185 svcLogicClient = client;
190 public void initialize() {
191 log.info("Initializing provider for {}", APP_NAME);
192 // Create the top level containers
195 GenericResourceApiUtil.loadProperties();
196 } catch (Exception e) {
197 log.error("Caught Exception while trying to load properties file", e);
200 log.info("Initialization complete for {}", APP_NAME);
203 protected void initializeChild() {
204 // Override if you have custom initialization intelligence
208 public void close() throws Exception {
209 log.info("Closing provider for {}", APP_NAME);
211 rpcRegistration.close();
212 log.info("Successfully closed provider for {}", APP_NAME);
215 private static class Iso8601Util {
217 private static TimeZone timeZone = TimeZone.getTimeZone("UTC");
218 private static DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'");
220 private Iso8601Util() {
224 dateFormat.setTimeZone(timeZone);
227 private static String now() {
228 return dateFormat.format(new Date());
232 public void setDataBroker(DataBroker dataBroker) {
233 this.dataBroker = dataBroker;
234 if (log.isDebugEnabled()) {
235 log.debug("DataBroker set to {}", dataBroker == null ? NULL_PARAM : NON_NULL_PARAM);
239 public void setNotificationService(NotificationPublishService notificationService) {
240 this.notificationService = notificationService;
241 if (log.isDebugEnabled()) {
242 log.debug("Notification Service set to {}", notificationService == null ? NULL_PARAM : NON_NULL_PARAM);
246 public void setRpcRegistry(RpcProviderRegistry rpcRegistry) {
247 this.rpcRegistry = rpcRegistry;
248 if (log.isDebugEnabled()) {
249 log.debug("RpcRegistry set to {}", rpcRegistry == null ? NULL_PARAM : NON_NULL_PARAM);
253 private void createContainers() {
255 final WriteTransaction t = dataBroker.newReadWriteTransaction();
257 // Create the service-instance container
258 t.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(Services.class),
259 new ServicesBuilder().build());
260 t.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(Services.class),
261 new ServicesBuilder().build());
263 // Create the PreloadVnfs container
264 t.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(PreloadVnfs.class),
265 new PreloadVnfsBuilder().build());
266 t.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(PreloadVnfs.class),
267 new PreloadVnfsBuilder().build());
270 CheckedFuture<Void, TransactionCommitFailedException> checkedFuture = t.submit();
272 log.info("Create containers succeeded!");
274 } catch (InterruptedException | ExecutionException e) {
275 log.error("Create containers failed: ", e);
279 private void setServiceStatus(ServiceStatusBuilder serviceStatusBuilder, String errorCode, String errorMessage,
281 serviceStatusBuilder.setResponseCode(errorCode);
282 serviceStatusBuilder.setResponseMessage(errorMessage);
283 serviceStatusBuilder.setFinalIndicator(ackFinal);
284 serviceStatusBuilder.setResponseTimestamp(Iso8601Util.now());
287 private void setServiceStatus(ServiceStatusBuilder serviceStatusBuilder, RequestInformation requestInformation) {
288 if (requestInformation != null && requestInformation.getRequestAction() != null) {
289 serviceStatusBuilder.setAction(requestInformation.getRequestAction().toString());
293 private void setServiceStatus(ServiceStatusBuilder serviceStatusBuilder, SdncRequestHeader requestHeader) {
294 if (requestHeader != null && requestHeader.getSvcAction() != null) {
295 switch (requestHeader.getSvcAction()) {
297 serviceStatusBuilder.setRpcAction(RpcAction.Assign);
300 serviceStatusBuilder.setRpcAction(RpcAction.Unassign);
303 serviceStatusBuilder.setRpcAction(RpcAction.Activate);
306 serviceStatusBuilder.setRpcAction(RpcAction.Deactivate);
309 serviceStatusBuilder.setRpcAction(RpcAction.Delete);
312 log.error("Unknown SvcAction: {}", requestHeader.getSvcAction());
318 private void getServiceData(String siid, ServiceDataBuilder serviceDataBuilder) {
320 getServiceData(siid, serviceDataBuilder, LogicalDatastoreType.CONFIGURATION);
323 private void getServiceData(String siid, ServiceDataBuilder serviceDataBuilder, LogicalDatastoreType type) {
324 // See if any data exists yet for this siid, if so grab it.
325 InstanceIdentifier<Service> serviceInstanceIdentifier = InstanceIdentifier
326 .builder(Services.class)
327 .child(Service.class, new ServiceKey(siid))
330 ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction();
331 Optional<Service> data = Optional.absent();
333 data = readTx.read(type, serviceInstanceIdentifier).get();
334 } catch (InterruptedException | ExecutionException e) {
335 log.error("Caught Exception reading MD-SAL ({}) data for [{}] ", type, siid, e);
338 if (data != null && data.isPresent()) {
339 ServiceData serviceData = data.get().getServiceData();
340 if (serviceData != null) {
341 log.info("Read MD-SAL ({}) data for [{}] ServiceData: {}", type, siid, serviceData);
342 serviceDataBuilder.setSdncRequestHeader(serviceData.getSdncRequestHeader());
343 serviceDataBuilder.setRequestInformation(serviceData.getRequestInformation());
344 serviceDataBuilder.setServiceInformation(serviceData.getServiceInformation());
345 serviceDataBuilder.setServiceRequestInput(serviceData.getServiceRequestInput());
346 serviceDataBuilder.setServiceTopology(serviceData.getServiceTopology());
347 serviceDataBuilder.setServiceLevelOperStatus(serviceData.getServiceLevelOperStatus());
348 serviceDataBuilder.setNetworks(serviceData.getNetworks());
349 serviceDataBuilder.setVnfs(serviceData.getVnfs());
350 serviceDataBuilder.setProvidedAllottedResources(serviceData.getProvidedAllottedResources());
351 serviceDataBuilder.setConsumedAllottedResources(serviceData.getConsumedAllottedResources());
352 // service-instance-id needs to be set
354 log.info("No service-data found in MD-SAL ({}) for [{}]", type, siid);
357 log.info("No data found in MD-SAL ({}) for [{}]", type, siid);
361 private void getPreloadData(String vnfName, String vnfType, PreloadDataBuilder preloadDataBuilder) {
363 getPreloadData(vnfName, vnfType, preloadDataBuilder, LogicalDatastoreType.CONFIGURATION);
366 private void getPreloadData(String preloadName, String preloadType, PreloadDataBuilder preloadDataBuilder,
367 LogicalDatastoreType type) {
368 // See if any data exists yet for this name/type, if so grab it.
369 InstanceIdentifier<VnfPreloadList> preloadInstanceIdentifier = InstanceIdentifier
370 .builder(PreloadVnfs.class)
371 .child(VnfPreloadList.class, new VnfPreloadListKey(preloadName, preloadType))
374 ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction();
375 Optional<VnfPreloadList> data = Optional.absent();
377 data = readTx.read(type, preloadInstanceIdentifier).get();
378 } catch (InterruptedException | ExecutionException e) {
379 log.error("Caught Exception reading MD-SAL ({}) for [{},{}] ", type, preloadName, preloadType, e);
382 if (data != null && data.isPresent()) {
383 PreloadData preloadData = data.get().getPreloadData();
384 if (preloadData != null) {
385 log.info("Read MD-SAL ({}) data for [{},{}] PreloadData: {}", type, preloadName, preloadType,
387 preloadDataBuilder.setVnfTopologyInformation(preloadData.getVnfTopologyInformation());
388 preloadDataBuilder.setNetworkTopologyInformation(preloadData.getNetworkTopologyInformation());
389 preloadDataBuilder.setOperStatus(preloadData.getOperStatus());
391 log.info("No preload-data found in MD-SAL ({}) for [{},{}] ", type, preloadName, preloadType);
394 log.info("No data found in MD-SAL ({}) for [{},{}] ", type, preloadName, preloadType);
398 private void saveService(final Service entry, boolean merge, LogicalDatastoreType storeType) {
399 // Each entry will be identifiable by a unique key, we have to create that
401 InstanceIdentifier<Service> path = InstanceIdentifier
402 .builder(Services.class)
403 .child(Service.class, entry.getKey())
406 trySaveEntry(entry, merge, storeType, path);
409 private void savePreloadList(final VnfPreloadList entry, boolean merge, LogicalDatastoreType storeType) {
411 // Each entry will be identifiable by a unique key, we have to create that
413 InstanceIdentifier<VnfPreloadList> path = InstanceIdentifier
414 .builder(PreloadVnfs.class)
415 .child(VnfPreloadList.class, entry.getKey())
418 trySaveEntry(entry, merge, storeType, path);
421 private <T extends DataObject> void trySaveEntry(T entry, boolean merge, LogicalDatastoreType storeType,
422 InstanceIdentifier<T> path) {
426 save(entry, merge, storeType, path);
428 } catch (OptimisticLockFailedException e) {
430 log.debug("Got OptimisticLockFailedException on last try - failing ");
431 throw new IllegalStateException(e);
433 log.debug("Got OptimisticLockFailedException - trying again ");
434 } catch (TransactionCommitFailedException ex) {
435 log.debug("Update DataStore failed");
436 throw new IllegalStateException(ex);
441 private <T extends DataObject> void save(T entry, boolean merge, LogicalDatastoreType storeType,
442 InstanceIdentifier<T> path)
443 throws TransactionCommitFailedException {
444 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
446 tx.merge(storeType, path, entry);
448 tx.put(storeType, path, entry);
450 tx.submit().checkedGet();
451 log.debug("Update DataStore succeeded");
454 private void deleteService(final Service entry, LogicalDatastoreType storeType) {
455 // Each entry will be identifiable by a unique key, we have to create
457 InstanceIdentifier<Service> path = InstanceIdentifier
458 .builder(Services.class)
459 .child(Service.class, entry.getKey())
462 tryDeleteEntry(storeType, path);
465 private void tryDeleteEntry(LogicalDatastoreType storeType, InstanceIdentifier<Service> path) {
469 delete(storeType, path);
471 } catch (OptimisticLockFailedException e) {
473 log.debug("Got OptimisticLockFailedException on last try - failing ");
474 throw new IllegalStateException(e);
476 log.debug("Got OptimisticLockFailedException - trying again ");
477 } catch (TransactionCommitFailedException ex) {
478 log.debug("Update DataStore failed");
479 throw new IllegalStateException(ex);
484 private void delete(LogicalDatastoreType storeType, InstanceIdentifier<Service> path)
485 throws TransactionCommitFailedException {
486 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
487 tx.delete(storeType, path);
488 tx.submit().checkedGet();
489 log.debug("DataStore delete succeeded");
493 public Future<RpcResult<ServiceTopologyOperationOutput>> serviceTopologyOperation(
494 ServiceTopologyOperationInput input) {
496 final String svcOperation = "service-topology-operation";
497 ServiceData serviceData;
498 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
499 Properties parms = new Properties();
501 log.info(CALLED_STR, svcOperation);
502 // create a new response object
503 ServiceTopologyOperationOutputBuilder responseBuilder = new ServiceTopologyOperationOutputBuilder();
505 if (input == null || input.getServiceInformation() == null
506 || input.getServiceInformation().getServiceInstanceId() == null
507 || input.getServiceInformation().getServiceInstanceId().length() == 0) {
508 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
509 responseBuilder.setResponseCode("404");
510 responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
511 responseBuilder.setAckFinalIndicator("Y");
512 RpcResult<ServiceTopologyOperationOutput> rpcResult = RpcResultBuilder
513 .<ServiceTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
514 return Futures.immediateFuture(rpcResult);
517 // Grab the service instance ID from the input buffer
518 String siid = input.getServiceInformation().getServiceInstanceId();
520 if (input.getSdncRequestHeader() != null) {
521 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
524 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
525 getServiceData(siid, serviceDataBuilder);
527 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
528 getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
530 // Set the serviceStatus based on input
531 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
532 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
535 * // setup a service-data object builder // ACTION service-topology-operation
536 * // INPUT: // USES uses service-operation-information // OUTPUT: // uses
537 * topology-response-common; // uses service-response-information;
540 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
541 ServiceTopologyOperationInputBuilder inputBuilder = new ServiceTopologyOperationInputBuilder(input);
542 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
544 log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid,
545 operDataBuilder.build());
546 GenericResourceApiUtil.toProperties(parms, OPERATIONAL_DATA_PARAM, operDataBuilder);
548 // Call SLI sync method
549 // Get SvcLogicService reference
551 ErrorObject error = new ErrorObject("200", "");
552 String ackFinal = "Y";
553 String serviceObjectPath = null;
554 Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, error);
556 if (respProps != null) {
557 error.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
558 error.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
559 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
560 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
563 setServiceStatus(serviceStatusBuilder, error.getStatusCode(), error.getMessage(), ackFinal);
564 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
565 serviceStatusBuilder.setRpcName(svcOperation);
567 if (validateErrorObject(error)) {
568 responseBuilder.setResponseCode(error.getStatusCode());
569 responseBuilder.setResponseMessage(error.getMessage());
570 responseBuilder.setAckFinalIndicator(ackFinal);
572 ServiceBuilder serviceBuilder = new ServiceBuilder();
573 serviceBuilder.setServiceInstanceId(siid);
574 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
576 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
577 } catch (Exception e) {
578 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
580 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
582 RpcResult<ServiceTopologyOperationOutput> rpcResult = RpcResultBuilder
583 .<ServiceTopologyOperationOutput>status(true)
584 .withResult(responseBuilder.build())
587 return Futures.immediateFuture(rpcResult);
590 // Got success from SLI
592 serviceData = serviceDataBuilder.build();
593 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
596 ServiceBuilder serviceBuilder = new ServiceBuilder();
597 serviceBuilder.setServiceData(serviceData);
598 serviceBuilder.setServiceInstanceId(siid);
599 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
600 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
602 if (isValidRequest(input) && input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete)) {
603 // Only update operational tree on delete
604 log.info("Delete from both CONFIGURATION and OPERATIONAL tree.");
605 deleteService(serviceBuilder.build(), LogicalDatastoreType.OPERATIONAL);
606 deleteService(serviceBuilder.build(), LogicalDatastoreType.CONFIGURATION);
609 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
610 serviceResponseInformationBuilder.setInstanceId(siid);
611 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
612 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
614 } catch (Exception e) {
615 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
616 responseBuilder.setResponseCode("500");
617 responseBuilder.setResponseMessage(e.toString());
618 responseBuilder.setAckFinalIndicator("Y");
619 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
621 RpcResult<ServiceTopologyOperationOutput> rpcResult = RpcResultBuilder
622 .<ServiceTopologyOperationOutput>status(true)
623 .withResult(responseBuilder.build())
626 return Futures.immediateFuture(rpcResult);
630 responseBuilder.setResponseCode(error.getStatusCode());
631 responseBuilder.setAckFinalIndicator(ackFinal);
632 if (!error.getMessage().isEmpty()) {
633 responseBuilder.setResponseMessage(error.getMessage());
635 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
636 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
638 RpcResult<ServiceTopologyOperationOutput> rpcResult = RpcResultBuilder
639 .<ServiceTopologyOperationOutput>status(true)
640 .withResult(responseBuilder.build())
643 return Futures.immediateFuture(rpcResult);
646 private Properties tryGetProperties(String svcOperation, Properties parms, ServiceDataBuilder serviceDataBuilder,
649 if (svcLogicClient.hasGraph(APP_NAME, svcOperation, null, "sync")) {
651 return svcLogicClient.execute(APP_NAME, svcOperation, null, "sync", serviceDataBuilder, parms);
652 } catch (Exception e) {
653 log.error(SERVICE_LOGIC_EXECUTION_ERROR_MESSAGE, svcOperation, e);
654 error.setMessage(e.getMessage());
655 error.setStatusCode("500");
658 error.setMessage(NO_SERVICE_LOGIC_ACTIVE + APP_NAME + ": '" + svcOperation + "'");
659 error.setStatusCode("503");
661 } catch (Exception e) {
662 error.setMessage(e.getMessage());
663 error.setStatusCode("500");
664 log.error(SERVICE_LOGIC_SEARCH_ERROR_MESSAGE, e);
670 private boolean validateErrorObject(ErrorObject error) {
672 !error.getStatusCode().isEmpty() && !("0".equals(error.getStatusCode()) || "200"
673 .equals(error.getStatusCode()));
676 private boolean isValidRequest(ServiceTopologyOperationInput input) {
677 return input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null;
681 public Future<RpcResult<VnfTopologyOperationOutput>> vnfTopologyOperation(VnfTopologyOperationInput input) {
683 final String svcOperation = "vnf-topology-operation";
684 ServiceData serviceData;
685 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
686 Properties parms = new Properties();
688 log.info(CALLED_STR, svcOperation);
689 // create a new response object
690 VnfTopologyOperationOutputBuilder responseBuilder = new VnfTopologyOperationOutputBuilder();
692 if (input == null || input.getServiceInformation() == null
693 || input.getServiceInformation().getServiceInstanceId() == null
694 || input.getServiceInformation().getServiceInstanceId().length() == 0) {
696 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
697 responseBuilder.setResponseCode("404");
698 responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
699 responseBuilder.setAckFinalIndicator("Y");
700 RpcResult<VnfTopologyOperationOutput> rpcResult = RpcResultBuilder.<VnfTopologyOperationOutput>status(true)
701 .withResult(responseBuilder.build()).build();
703 return Futures.immediateFuture(rpcResult);
706 // Grab the service instance ID from the input buffer
707 String siid = input.getServiceInformation().getServiceInstanceId();
709 if (input.getSdncRequestHeader() != null) {
710 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
713 if (input.getVnfInformation() == null || input.getVnfInformation().getVnfId() == null
714 || input.getVnfInformation().getVnfId().length() == 0) {
715 log.debug("exiting {} because of null or empty vnf-id", svcOperation);
716 responseBuilder.setResponseCode("404");
717 responseBuilder.setResponseMessage("invalid input, null or empty vnf-id");
718 responseBuilder.setAckFinalIndicator("Y");
720 RpcResult<VnfTopologyOperationOutput> rpcResult = RpcResultBuilder
721 .<VnfTopologyOperationOutput>status(true)
722 .withResult(responseBuilder.build())
725 return Futures.immediateFuture(rpcResult);
728 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
729 getServiceData(siid, serviceDataBuilder);
731 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
732 getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
734 // Set the serviceStatus based on input
735 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
736 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
739 // setup a service-data object builder
740 // ACTION vnf-topology-operation
742 // USES sdnc-request-header;
743 // USES request-information;
744 // USES service-information;
745 // USES vnf-request-information
747 // USES vnf-topology-response-body;
748 // USES vnf-information
749 // USES service-information
751 // container service-data
752 // uses vnf-configuration-information;
755 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
756 VnfTopologyOperationInputBuilder inputBuilder = new VnfTopologyOperationInputBuilder(input);
757 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
759 log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid,
760 operDataBuilder.build());
761 GenericResourceApiUtil.toProperties(parms, OPERATIONAL_DATA_PARAM, operDataBuilder);
763 // Call SLI sync method
764 // Get SvcLogicService reference
766 ErrorObject error = new ErrorObject("200", "");
767 String ackFinal = "Y";
768 String serviceObjectPath = null;
769 Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, error);
771 if (respProps != null) {
772 error.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
773 error.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
774 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
775 serviceObjectPath = respProps.getProperty("vnf-object-path");
778 setServiceStatus(serviceStatusBuilder, error.getStatusCode(), error.getMessage(), ackFinal);
779 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
780 serviceStatusBuilder.setRpcName(svcOperation);
782 if (validateErrorObject(error)) {
783 responseBuilder.setResponseCode(error.getStatusCode());
784 responseBuilder.setResponseMessage(error.getMessage());
785 responseBuilder.setAckFinalIndicator(ackFinal);
787 ServiceBuilder serviceBuilder = new ServiceBuilder();
788 serviceBuilder.setServiceInstanceId(siid);
789 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
791 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
792 if (isValidRequest(input) &&
793 (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete) ||
794 input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))) {
796 // Only update operational tree on activate or delete
797 log.info(UPDATING_TREE_INFO_MESSAGE);
798 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
800 } catch (Exception e) {
801 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
803 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
805 RpcResult<VnfTopologyOperationOutput> rpcResult = RpcResultBuilder
806 .<VnfTopologyOperationOutput>status(true)
807 .withResult(responseBuilder.build())
811 return Futures.immediateFuture(rpcResult);
814 // Got success from SLI
816 serviceData = serviceDataBuilder.build();
817 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
820 ServiceBuilder serviceBuilder = new ServiceBuilder();
821 serviceBuilder.setServiceData(serviceData);
822 serviceBuilder.setServiceInstanceId(siid);
823 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
824 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
826 if (isValidRequest(input) && input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate)) {
827 // Only update operational tree on Assign
829 log.info(UPDATING_TREE_INFO_MESSAGE);
830 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
833 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
834 serviceResponseInformationBuilder.setInstanceId(siid);
835 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
836 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
838 } catch (Exception e) {
839 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
840 responseBuilder.setResponseCode("500");
841 responseBuilder.setResponseMessage(e.toString());
842 responseBuilder.setAckFinalIndicator("Y");
843 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
845 RpcResult<VnfTopologyOperationOutput> rpcResult = RpcResultBuilder
846 .<VnfTopologyOperationOutput>status(true)
847 .withResult(responseBuilder.build())
850 return Futures.immediateFuture(rpcResult);
854 responseBuilder.setResponseCode(error.getStatusCode());
855 responseBuilder.setAckFinalIndicator(ackFinal);
856 if (!error.getMessage().isEmpty()) {
857 responseBuilder.setResponseMessage(error.getMessage());
859 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
860 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
862 RpcResult<VnfTopologyOperationOutput> rpcResult = RpcResultBuilder
863 .<VnfTopologyOperationOutput>status(true)
864 .withResult(responseBuilder.build())
868 return Futures.immediateFuture(rpcResult);
871 private boolean isValidRequest(VnfTopologyOperationInput input) {
872 return input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null;
876 public Future<RpcResult<VfModuleTopologyOperationOutput>> vfModuleTopologyOperation(
877 VfModuleTopologyOperationInput input) {
879 final String svcOperation = "vf-module-topology-operation";
880 ServiceData serviceData;
881 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
882 Properties parms = new Properties();
884 log.info(CALLED_STR, svcOperation);
885 // create a new response object
886 VfModuleTopologyOperationOutputBuilder responseBuilder = new VfModuleTopologyOperationOutputBuilder();
888 if (input == null || input.getServiceInformation() == null
889 || input.getServiceInformation().getServiceInstanceId() == null
890 || input.getServiceInformation().getServiceInstanceId().length() == 0) {
891 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
892 responseBuilder.setResponseCode("403");
893 responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
894 responseBuilder.setAckFinalIndicator("Y");
896 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
897 .<VfModuleTopologyOperationOutput>status(true)
898 .withResult(responseBuilder.build())
902 return Futures.immediateFuture(rpcResult);
905 if (input.getVnfInformation() == null || input.getVnfInformation().getVnfId() == null
906 || input.getVnfInformation().getVnfId().length() == 0) {
907 log.debug("exiting {} because of null or empty vnf-id", svcOperation);
908 responseBuilder.setResponseCode("403");
909 responseBuilder.setResponseMessage("invalid input, null or empty vnf-id");
910 responseBuilder.setAckFinalIndicator("Y");
911 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
912 .<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
913 return Futures.immediateFuture(rpcResult);
916 if (input.getVfModuleInformation() == null || input.getVfModuleInformation().getVfModuleId() == null
917 || input.getVfModuleInformation().getVfModuleId().length() == 0) {
918 log.debug("exiting {} because of null or empty vf-module-id", svcOperation);
919 responseBuilder.setResponseCode("403");
920 responseBuilder.setResponseMessage("invalid input, vf-module-id is null or empty");
921 responseBuilder.setAckFinalIndicator("Y");
923 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
924 .<VfModuleTopologyOperationOutput>status(true)
925 .withResult(responseBuilder.build())
928 return Futures.immediateFuture(rpcResult);
931 // Grab the service instance ID from the input buffer
932 String siid = input.getServiceInformation().getServiceInstanceId();
934 if (input.getSdncRequestHeader() != null) {
935 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
938 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
939 getServiceData(siid, serviceDataBuilder);
941 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
942 getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
944 // Set the serviceStatus based on input
945 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
946 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
949 // setup a service-data object builder
950 // ACTION vnf-topology-operation
952 // USES sdnc-request-header;
953 // USES request-information;
954 // USES service-information;
955 // USES vnf-request-information
957 // USES vnf-topology-response-body;
958 // USES vnf-information
959 // USES service-information
961 // container service-data
962 // uses vnf-configuration-information;
965 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
966 VfModuleTopologyOperationInputBuilder inputBuilder = new VfModuleTopologyOperationInputBuilder(input);
967 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
969 log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid,
970 operDataBuilder.build());
971 GenericResourceApiUtil.toProperties(parms, OPERATIONAL_DATA_PARAM, operDataBuilder);
973 // Call SLI sync method
974 // Get SvcLogicService reference
976 ErrorObject error = new ErrorObject("200", "");
977 String ackFinal = "Y";
978 String serviceObjectPath = null;
979 Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, error);
981 if (respProps != null) {
982 error.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
983 error.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
984 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
985 serviceObjectPath = respProps.getProperty("vf-module-object-path");
988 setServiceStatus(serviceStatusBuilder, error.getStatusCode(), error.getMessage(), ackFinal);
989 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
990 serviceStatusBuilder.setRpcName(svcOperation);
992 if (validateErrorObject(error)) {
993 responseBuilder.setResponseCode(error.getStatusCode());
994 responseBuilder.setResponseMessage(error.getStatusCode());
995 responseBuilder.setAckFinalIndicator(ackFinal);
997 ServiceBuilder serviceBuilder = new ServiceBuilder();
998 serviceBuilder.setServiceInstanceId(siid);
999 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1001 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
1002 } catch (Exception e) {
1003 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1005 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1007 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
1008 .<VfModuleTopologyOperationOutput>status(true)
1009 .withResult(responseBuilder.build())
1013 return Futures.immediateFuture(rpcResult);
1016 // Got success from SLI
1018 serviceData = serviceDataBuilder.build();
1019 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
1022 ServiceBuilder serviceBuilder = new ServiceBuilder();
1023 serviceBuilder.setServiceData(serviceData);
1024 serviceBuilder.setServiceInstanceId(siid);
1025 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1026 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1028 if (isValidRequest(input) &&
1029 (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Unassign) ||
1030 input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))) {
1031 // Only update operational tree on activate or delete
1033 log.info(UPDATING_TREE_INFO_MESSAGE);
1034 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1037 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1038 serviceResponseInformationBuilder.setInstanceId(siid);
1039 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1040 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1042 } catch (Exception e) {
1043 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1044 responseBuilder.setResponseCode("500");
1045 responseBuilder.setResponseMessage(e.toString());
1046 responseBuilder.setAckFinalIndicator("Y");
1047 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1049 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
1050 .<VfModuleTopologyOperationOutput>status(true)
1051 .withResult(responseBuilder.build())
1054 return Futures.immediateFuture(rpcResult);
1058 responseBuilder.setResponseCode(error.getStatusCode());
1059 responseBuilder.setAckFinalIndicator(ackFinal);
1060 if (!error.getMessage().isEmpty()) {
1061 responseBuilder.setResponseMessage(error.getMessage());
1063 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
1064 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
1066 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
1067 .<VfModuleTopologyOperationOutput>status(true)
1068 .withResult(responseBuilder.build())
1072 return Futures.immediateFuture(rpcResult);
1075 private boolean isValidRequest(VfModuleTopologyOperationInput input) {
1076 return input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null;
1080 public Future<RpcResult<NetworkTopologyOperationOutput>> networkTopologyOperation(
1081 NetworkTopologyOperationInput input) {
1083 final String svcOperation = "network-topology-operation";
1084 ServiceData serviceData;
1085 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1086 Properties parms = new Properties();
1088 log.info(CALLED_STR, svcOperation);
1089 // create a new response object
1090 NetworkTopologyOperationOutputBuilder responseBuilder = new NetworkTopologyOperationOutputBuilder();
1092 if (input == null || input.getServiceInformation() == null
1093 || input.getServiceInformation().getServiceInstanceId() == null
1094 || input.getServiceInformation().getServiceInstanceId().length() == 0) {
1095 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
1096 return buildRpcResultFuture(responseBuilder, NULL_OR_EMPTY_ERROR_PARAM);
1099 String siid = input.getServiceInformation().getServiceInstanceId();
1101 // Get the service-instance service data from MD-SAL
1102 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1103 getServiceData(siid, serviceDataBuilder);
1105 if (input.getSdncRequestHeader() != null) {
1106 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1109 ServiceData sd = serviceDataBuilder.build();
1110 if (sd == null || sd.getServiceLevelOperStatus() == null) {
1111 log.debug(EMPTY_SERVICE_INSTANCE_MESSAGE, svcOperation);
1112 return buildRpcResultFuture(responseBuilder, INVALID_INPUT_ERROR_MESSAGE);
1115 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
1116 NetworkTopologyOperationInputBuilder inputBuilder = new NetworkTopologyOperationInputBuilder(input);
1117 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1119 // Call SLI sync method
1120 // Get SvcLogicService reference
1122 ErrorObject error = new ErrorObject("200", "");
1123 String ackFinal = "Y";
1124 String networkId = ERROR_NETWORK_ID;
1125 String serviceObjectPath = null;
1126 String networkObjectPath = null;
1127 Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, error);
1129 if (respProps != null) {
1130 error.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
1131 error.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
1132 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
1133 networkId = respProps.getProperty("networkId");
1134 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
1135 networkObjectPath = respProps.getProperty("network-object-path");
1138 if (validateErrorObject(error)) {
1139 responseBuilder.setResponseCode(error.getStatusCode());
1140 responseBuilder.setResponseMessage(error.getMessage());
1141 responseBuilder.setAckFinalIndicator(ackFinal);
1143 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1145 RpcResult<NetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
1146 .<NetworkTopologyOperationOutput>status(true)
1147 .withResult(responseBuilder.build())
1150 return Futures.immediateFuture(rpcResult);
1153 // Got success from SLI
1156 serviceData = serviceDataBuilder.build();
1157 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
1160 ServiceBuilder serviceBuilder = new ServiceBuilder();
1161 serviceBuilder.setServiceData(serviceData);
1162 serviceBuilder.setServiceInstanceId(siid);
1163 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1164 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1166 if (isValidRequest(input) &&
1167 (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate) ||
1168 input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Create))) {
1169 // Only update operational tree on Activate
1170 log.info(UPDATING_TREE_INFO_MESSAGE);
1171 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1174 NetworkResponseInformationBuilder networkResponseInformationBuilder = new NetworkResponseInformationBuilder();
1175 networkResponseInformationBuilder.setInstanceId(networkId);
1176 networkResponseInformationBuilder.setObjectPath(networkObjectPath);
1177 responseBuilder.setNetworkResponseInformation(networkResponseInformationBuilder.build());
1179 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1180 serviceResponseInformationBuilder.setInstanceId(siid);
1181 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1182 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1184 } catch (IllegalStateException e) {
1185 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1186 responseBuilder.setResponseCode("500");
1187 responseBuilder.setResponseMessage(e.toString());
1188 responseBuilder.setAckFinalIndicator("Y");
1189 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1191 RpcResult<NetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
1192 .<NetworkTopologyOperationOutput>status(true)
1193 .withResult(responseBuilder.build())
1196 return Futures.immediateFuture(rpcResult);
1200 responseBuilder.setResponseCode(error.getStatusCode());
1201 responseBuilder.setAckFinalIndicator(ackFinal);
1202 if (!error.getMessage().isEmpty()) {
1203 responseBuilder.setResponseMessage(error.getMessage());
1205 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
1206 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
1208 RpcResult<NetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
1209 .<NetworkTopologyOperationOutput>status(true)
1210 .withResult(responseBuilder.build())
1213 return Futures.immediateFuture(rpcResult);
1216 private Future<RpcResult<NetworkTopologyOperationOutput>> buildRpcResultFuture(
1217 NetworkTopologyOperationOutputBuilder responseBuilder, String responseMessage) {
1219 responseBuilder.setResponseCode("404");
1221 .setResponseMessage(responseMessage);
1222 responseBuilder.setAckFinalIndicator("Y");
1224 RpcResult<NetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
1225 .<NetworkTopologyOperationOutput>status(true)
1226 .withResult(responseBuilder.build())
1229 return Futures.immediateFuture(rpcResult);
1232 private boolean isValidRequest(NetworkTopologyOperationInput input) {
1233 return input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null;
1237 public Future<RpcResult<ContrailRouteTopologyOperationOutput>> contrailRouteTopologyOperation(
1238 ContrailRouteTopologyOperationInput input) {
1240 final String svcOperation = "contrail-route-topology-operation";
1241 ServiceData serviceData;
1242 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1243 Properties parms = new Properties();
1245 log.info(CALLED_STR, svcOperation);
1246 // create a new response object
1247 ContrailRouteTopologyOperationOutputBuilder responseBuilder = new ContrailRouteTopologyOperationOutputBuilder();
1249 if (input == null || input.getServiceInformation() == null
1250 || input.getServiceInformation().getServiceInstanceId() == null
1251 || input.getServiceInformation().getServiceInstanceId().length() == 0) {
1252 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
1253 return buildRpcResultFuture(responseBuilder, NULL_OR_EMPTY_ERROR_PARAM);
1256 String siid = input.getServiceInformation().getServiceInstanceId();
1258 // Get the service-instance service data from MD-SAL
1259 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1260 getServiceData(siid, serviceDataBuilder);
1262 if (input.getSdncRequestHeader() != null) {
1263 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1266 ServiceData sd = serviceDataBuilder.build();
1267 if (sd == null || sd.getServiceLevelOperStatus() == null) {
1268 log.debug(EMPTY_SERVICE_INSTANCE_MESSAGE, svcOperation);
1269 return buildRpcResultFuture(responseBuilder, INVALID_INPUT_ERROR_MESSAGE);
1272 log.info("Adding INPUT data for " + svcOperation + " [" + siid + "] input: " + input);
1273 ContrailRouteTopologyOperationInputBuilder inputBuilder = new ContrailRouteTopologyOperationInputBuilder(input);
1274 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1276 // Call SLI sync method
1277 // Get SvcLogicService reference
1278 ErrorObject error = new ErrorObject("200", "");
1279 String ackFinal = "Y";
1280 String allottedResourceId = ERROR_NETWORK_ID;
1281 String serviceObjectPath = null;
1282 String contrailRouteObjectPath = null;
1283 Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, error);
1285 if (respProps != null) {
1286 error.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
1287 error.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
1288 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
1289 allottedResourceId = respProps.getProperty(ALLOTTED_RESOURCE_ID_PARAM);
1290 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
1291 contrailRouteObjectPath = respProps.getProperty("contrail-route-object-path");
1294 if (validateErrorObject(error)) {
1295 responseBuilder.setResponseCode(error.getStatusCode());
1296 responseBuilder.setResponseMessage(error.getMessage());
1297 responseBuilder.setAckFinalIndicator(ackFinal);
1298 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1300 RpcResult<ContrailRouteTopologyOperationOutput> rpcResult = RpcResultBuilder
1301 .<ContrailRouteTopologyOperationOutput>status(true)
1302 .withResult(responseBuilder.build())
1305 return Futures.immediateFuture(rpcResult);
1308 // Got success from SLI
1311 serviceData = serviceDataBuilder.build();
1312 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
1315 ServiceBuilder serviceBuilder = new ServiceBuilder();
1316 serviceBuilder.setServiceData(serviceData);
1317 serviceBuilder.setServiceInstanceId(siid);
1318 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1319 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1321 if (isValidRequest(input) &&
1322 (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Unassign) ||
1323 input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))) {
1324 // Only update operational tree on activate or delete
1325 log.info(UPDATING_TREE_INFO_MESSAGE);
1326 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1329 ContrailRouteResponseInformationBuilder contrailRouteResponseInformationBuilder = new ContrailRouteResponseInformationBuilder();
1330 contrailRouteResponseInformationBuilder.setInstanceId(allottedResourceId);
1331 contrailRouteResponseInformationBuilder.setObjectPath(contrailRouteObjectPath);
1332 responseBuilder.setContrailRouteResponseInformation(contrailRouteResponseInformationBuilder.build());
1334 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1335 serviceResponseInformationBuilder.setInstanceId(siid);
1336 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1337 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1339 } catch (IllegalStateException e) {
1340 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1341 responseBuilder.setResponseCode("500");
1342 responseBuilder.setResponseMessage(e.toString());
1343 responseBuilder.setAckFinalIndicator("Y");
1344 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1346 RpcResult<ContrailRouteTopologyOperationOutput> rpcResult = RpcResultBuilder
1347 .<ContrailRouteTopologyOperationOutput>status(true)
1348 .withResult(responseBuilder.build())
1351 return Futures.immediateFuture(rpcResult);
1355 responseBuilder.setResponseCode(error.getStatusCode());
1356 responseBuilder.setAckFinalIndicator(ackFinal);
1357 if (!error.getMessage().isEmpty()) {
1358 responseBuilder.setResponseMessage(error.getMessage());
1360 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
1361 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
1363 RpcResult<ContrailRouteTopologyOperationOutput> rpcResult = RpcResultBuilder
1364 .<ContrailRouteTopologyOperationOutput>status(true)
1365 .withResult(responseBuilder.build())
1368 return Futures.immediateFuture(rpcResult);
1371 private Future<RpcResult<ContrailRouteTopologyOperationOutput>>
1372 buildRpcResultFuture(ContrailRouteTopologyOperationOutputBuilder responseBuilder, String responseMessage) {
1374 responseBuilder.setResponseCode("404");
1375 responseBuilder.setResponseMessage(responseMessage);
1376 responseBuilder.setAckFinalIndicator("Y");
1378 RpcResult<ContrailRouteTopologyOperationOutput> rpcResult = RpcResultBuilder
1379 .<ContrailRouteTopologyOperationOutput>status(true)
1380 .withResult(responseBuilder.build())
1383 return Futures.immediateFuture(rpcResult);
1386 private boolean isValidRequest(ContrailRouteTopologyOperationInput input) {
1387 return input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null;
1391 public Future<RpcResult<SecurityZoneTopologyOperationOutput>> securityZoneTopologyOperation(
1392 SecurityZoneTopologyOperationInput input) {
1394 final String svcOperation = "security-zone-topology-operation";
1395 ServiceData serviceData;
1396 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1397 Properties parms = new Properties();
1399 log.info(CALLED_STR, svcOperation);
1400 // create a new response object
1401 SecurityZoneTopologyOperationOutputBuilder responseBuilder = new SecurityZoneTopologyOperationOutputBuilder();
1403 if (input == null || input.getServiceInformation() == null
1404 || input.getServiceInformation().getServiceInstanceId() == null
1405 || input.getServiceInformation().getServiceInstanceId().length() == 0) {
1406 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
1407 return buildRpcResultFuture(responseBuilder, NULL_OR_EMPTY_ERROR_PARAM);
1410 String siid = input.getServiceInformation().getServiceInstanceId();
1412 // Get the service-instance service data from MD-SAL
1413 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1414 getServiceData(siid, serviceDataBuilder);
1416 if (input.getSdncRequestHeader() != null) {
1417 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1420 ServiceData sd = serviceDataBuilder.build();
1421 if (sd == null || sd.getServiceLevelOperStatus() == null) {
1422 log.debug(EMPTY_SERVICE_INSTANCE_MESSAGE, svcOperation);
1423 return buildRpcResultFuture(responseBuilder, INVALID_INPUT_ERROR_MESSAGE);
1426 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
1427 SecurityZoneTopologyOperationInputBuilder inputBuilder = new SecurityZoneTopologyOperationInputBuilder(input);
1428 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1430 // Call SLI sync method
1431 // Get SvcLogicService reference
1433 Properties respProps = null;
1435 ErrorObject error = new ErrorObject("200", "");
1436 String ackFinal = "Y";
1437 String allottedResourceId = ERROR_NETWORK_ID;
1438 String serviceObjectPath = null;
1439 String securityZoneObjectPath = null;
1442 if (svcLogicClient.hasGraph(APP_NAME, svcOperation, null, "sync")) {
1445 respProps = svcLogicClient.execute(APP_NAME, svcOperation, null, "sync", serviceDataBuilder, parms);
1446 } catch (Exception e) {
1447 log.error(SERVICE_LOGIC_EXECUTION_ERROR_MESSAGE, svcOperation, e);
1448 error.setMessage(e.getMessage());
1449 error.setStatusCode("500");
1452 error.setMessage(NO_SERVICE_LOGIC_ACTIVE + APP_NAME + ": '" + svcOperation + "'");
1453 error.setStatusCode("503");
1455 } catch (Exception e) {
1456 error.setStatusCode("500");
1457 error.setMessage(e.getMessage());
1458 log.error(SERVICE_LOGIC_SEARCH_ERROR_MESSAGE, e);
1461 if (respProps != null) {
1462 error.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
1463 error.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
1464 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
1465 allottedResourceId = respProps.getProperty(ALLOTTED_RESOURCE_ID_PARAM);
1466 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
1467 securityZoneObjectPath = respProps.getProperty("security-zone-object-path");
1470 if (validateErrorObject(error)) {
1471 responseBuilder.setResponseCode(error.getStatusCode());
1472 responseBuilder.setResponseMessage(error.getMessage());
1473 responseBuilder.setAckFinalIndicator(ackFinal);
1474 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1476 RpcResult<SecurityZoneTopologyOperationOutput> rpcResult = RpcResultBuilder
1477 .<SecurityZoneTopologyOperationOutput>status(true)
1478 .withResult(responseBuilder.build())
1481 return Futures.immediateFuture(rpcResult);
1484 // Got success from SLI
1487 serviceData = serviceDataBuilder.build();
1488 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
1491 ServiceBuilder serviceBuilder = new ServiceBuilder();
1492 serviceBuilder.setServiceData(serviceData);
1493 serviceBuilder.setServiceInstanceId(siid);
1494 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1495 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1497 if (isValidRequest(input) &&
1498 (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Unassign) ||
1499 input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))) {
1500 // Only update operational tree on activate or delete
1501 log.info(UPDATING_TREE_INFO_MESSAGE);
1502 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1505 SecurityZoneResponseInformationBuilder securityZoneResponseInformationBuilder = new SecurityZoneResponseInformationBuilder();
1506 securityZoneResponseInformationBuilder.setInstanceId(allottedResourceId);
1507 securityZoneResponseInformationBuilder.setObjectPath(securityZoneObjectPath);
1508 responseBuilder.setSecurityZoneResponseInformation(securityZoneResponseInformationBuilder.build());
1510 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1511 serviceResponseInformationBuilder.setInstanceId(siid);
1512 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1513 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1515 } catch (IllegalStateException e) {
1516 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1517 responseBuilder.setResponseCode("500");
1518 responseBuilder.setResponseMessage(e.toString());
1519 responseBuilder.setAckFinalIndicator("Y");
1520 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1522 RpcResult<SecurityZoneTopologyOperationOutput> rpcResult = RpcResultBuilder
1523 .<SecurityZoneTopologyOperationOutput>status(true)
1524 .withResult(responseBuilder.build())
1527 return Futures.immediateFuture(rpcResult);
1531 responseBuilder.setResponseCode(error.getStatusCode());
1532 responseBuilder.setAckFinalIndicator(ackFinal);
1533 if (!error.getMessage().isEmpty()) {
1534 responseBuilder.setResponseMessage(error.getMessage());
1536 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
1537 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
1539 RpcResult<SecurityZoneTopologyOperationOutput> rpcResult = RpcResultBuilder
1540 .<SecurityZoneTopologyOperationOutput>status(true)
1541 .withResult(responseBuilder.build())
1544 return Futures.immediateFuture(rpcResult);
1547 private Future<RpcResult<SecurityZoneTopologyOperationOutput>>
1548 buildRpcResultFuture(SecurityZoneTopologyOperationOutputBuilder responseBuilder, String responseMessage) {
1550 responseBuilder.setResponseCode("404");
1551 responseBuilder.setResponseMessage(responseMessage);
1552 responseBuilder.setAckFinalIndicator("Y");
1554 RpcResult<SecurityZoneTopologyOperationOutput> rpcResult = RpcResultBuilder
1555 .<SecurityZoneTopologyOperationOutput>status(true)
1556 .withResult(responseBuilder.build())
1559 return Futures.immediateFuture(rpcResult);
1562 private boolean isValidRequest(SecurityZoneTopologyOperationInput input) {
1563 return input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null;
1567 public Future<RpcResult<TunnelxconnTopologyOperationOutput>> tunnelxconnTopologyOperation(
1568 TunnelxconnTopologyOperationInput input) {
1570 final String svcOperation = "tunnelxconn-topology-operation";
1571 Properties parms = new Properties();
1572 log.info(CALLED_STR, svcOperation);
1574 // create a new response object
1575 TunnelxconnTopologyOperationOutputBuilder responseBuilder = new TunnelxconnTopologyOperationOutputBuilder();
1576 if (input == null || input.getServiceInformation() == null
1577 || input.getServiceInformation().getServiceInstanceId() == null
1578 || input.getServiceInformation().getServiceInstanceId().length() == 0) {
1579 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
1580 responseBuilder.setResponseCode("404");
1581 responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
1582 responseBuilder.setAckFinalIndicator("Y");
1584 RpcResult<TunnelxconnTopologyOperationOutput> rpcResult = RpcResultBuilder
1585 .<TunnelxconnTopologyOperationOutput>status(true)
1586 .withResult(responseBuilder.build())
1589 return Futures.immediateFuture(rpcResult);
1591 String siid = input.getServiceInformation().getServiceInstanceId();
1592 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
1593 TunnelxconnTopologyOperationInputBuilder inputBuilder = new TunnelxconnTopologyOperationInputBuilder(input);
1594 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1596 // Call SLI sync method
1597 // Get SvcLogicService reference
1598 ErrorObject error = new ErrorObject("200", "");
1599 String ackFinal = "Y";
1600 String allottedResourceId = ERROR_NETWORK_ID;
1601 String serviceObjectPath = null;
1602 String tunnelxconnObjectPath = null;
1603 Properties respProps = tryGetProperties(svcOperation, parms, error);
1605 if (respProps != null) {
1606 error.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
1607 error.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
1608 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
1609 allottedResourceId = respProps.getProperty(ALLOTTED_RESOURCE_ID_PARAM);
1610 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
1611 tunnelxconnObjectPath = respProps.getProperty("tunnelxconn-object-path");
1614 if (validateErrorObject(error)) {
1615 responseBuilder.setResponseCode(error.getStatusCode());
1616 responseBuilder.setResponseMessage(error.getMessage());
1617 responseBuilder.setAckFinalIndicator(ackFinal);
1619 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1621 RpcResult<TunnelxconnTopologyOperationOutput> rpcResult = RpcResultBuilder
1622 .<TunnelxconnTopologyOperationOutput>status(true)
1623 .withResult(responseBuilder.build())
1626 return Futures.immediateFuture(rpcResult);
1629 // Got success from SLI
1631 TunnelxconnResponseInformationBuilder tunnelxconnResponseInformationBuilder = new TunnelxconnResponseInformationBuilder();
1632 tunnelxconnResponseInformationBuilder.setInstanceId(allottedResourceId);
1633 tunnelxconnResponseInformationBuilder.setObjectPath(tunnelxconnObjectPath);
1634 responseBuilder.setTunnelxconnResponseInformation(tunnelxconnResponseInformationBuilder.build());
1636 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1637 serviceResponseInformationBuilder.setInstanceId(siid);
1638 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1639 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1641 } catch (IllegalStateException e) {
1642 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1643 responseBuilder.setResponseCode("500");
1644 responseBuilder.setResponseMessage(e.toString());
1645 responseBuilder.setAckFinalIndicator("Y");
1646 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1648 RpcResult<TunnelxconnTopologyOperationOutput> rpcResult = RpcResultBuilder
1649 .<TunnelxconnTopologyOperationOutput>status(true)
1650 .withResult(responseBuilder.build())
1653 return Futures.immediateFuture(rpcResult);
1657 responseBuilder.setResponseCode(error.getStatusCode());
1658 responseBuilder.setAckFinalIndicator(ackFinal);
1659 if (!error.getMessage().isEmpty()) {
1660 responseBuilder.setResponseMessage(error.getMessage());
1662 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
1663 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
1665 RpcResult<TunnelxconnTopologyOperationOutput> rpcResult = RpcResultBuilder
1666 .<TunnelxconnTopologyOperationOutput>status(true)
1667 .withResult(responseBuilder.build())
1670 return Futures.immediateFuture(rpcResult);
1673 private Properties tryGetProperties(String svcOperation, Properties parms, ErrorObject error) {
1675 if (svcLogicClient.hasGraph(APP_NAME, svcOperation, null, "sync")) {
1678 return svcLogicClient.execute(APP_NAME, svcOperation, null, "sync", parms);
1679 } catch (Exception e) {
1680 log.error(SERVICE_LOGIC_EXECUTION_ERROR_MESSAGE, svcOperation, e);
1681 error.setMessage(e.getMessage());
1682 error.setStatusCode("500");
1685 error.setMessage(NO_SERVICE_LOGIC_ACTIVE + APP_NAME + ": '" + svcOperation + "'");
1686 error.setStatusCode("503");
1688 } catch (Exception e) {
1689 error.setMessage(e.getMessage());
1690 error.setStatusCode("500");
1691 log.error(SERVICE_LOGIC_SEARCH_ERROR_MESSAGE, e);
1697 public Future<RpcResult<BrgTopologyOperationOutput>> brgTopologyOperation(BrgTopologyOperationInput input) {
1698 final String svcOperation = "brg-topology-operation";
1699 Properties parms = new Properties();
1701 log.info(CALLED_STR, svcOperation);
1702 // create a new response object
1703 BrgTopologyOperationOutputBuilder responseBuilder = new BrgTopologyOperationOutputBuilder();
1705 if (input == null || input.getServiceInformation() == null
1706 || input.getServiceInformation().getServiceInstanceId() == null
1707 || input.getServiceInformation().getServiceInstanceId().length() == 0) {
1708 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
1709 responseBuilder.setResponseCode("404");
1710 responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
1711 responseBuilder.setAckFinalIndicator("Y");
1712 RpcResult<BrgTopologyOperationOutput> rpcResult = RpcResultBuilder.<BrgTopologyOperationOutput>status(true)
1713 .withResult(responseBuilder.build()).build();
1714 return Futures.immediateFuture(rpcResult);
1717 String siid = input.getServiceInformation().getServiceInstanceId();
1719 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
1720 BrgTopologyOperationInputBuilder inputBuilder = new BrgTopologyOperationInputBuilder(input);
1721 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1723 // Call SLI sync method
1724 // Get SvcLogicService reference
1725 ErrorObject error = new ErrorObject("200", "");
1726 String ackFinal = "Y";
1727 String allottedResourceId = ERROR_NETWORK_ID;
1728 String serviceObjectPath = null;
1729 String brgObjectPath = null;
1730 Properties respProps = tryGetProperties(svcOperation, parms, error);
1732 if (respProps != null) {
1733 error.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
1734 error.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
1735 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
1736 allottedResourceId = respProps.getProperty(ALLOTTED_RESOURCE_ID_PARAM);
1737 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
1738 brgObjectPath = respProps.getProperty("brg-object-path");
1741 if (validateErrorObject(error)) {
1742 responseBuilder.setResponseCode(error.getStatusCode());
1743 responseBuilder.setResponseMessage(error.getMessage());
1744 responseBuilder.setAckFinalIndicator(ackFinal);
1745 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1747 RpcResult<BrgTopologyOperationOutput> rpcResult = RpcResultBuilder
1748 .<BrgTopologyOperationOutput>status(true)
1749 .withResult(responseBuilder.build())
1752 return Futures.immediateFuture(rpcResult);
1755 // Got success from SLI
1758 BrgResponseInformationBuilder brgResponseInformationBuilder = new BrgResponseInformationBuilder();
1759 brgResponseInformationBuilder.setInstanceId(allottedResourceId);
1760 brgResponseInformationBuilder.setObjectPath(brgObjectPath);
1761 responseBuilder.setBrgResponseInformation(brgResponseInformationBuilder.build());
1763 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1764 serviceResponseInformationBuilder.setInstanceId(siid);
1765 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1766 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1768 } catch (IllegalStateException e) {
1769 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1770 responseBuilder.setResponseCode("500");
1771 responseBuilder.setResponseMessage(e.toString());
1772 responseBuilder.setAckFinalIndicator("Y");
1773 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1775 RpcResult<BrgTopologyOperationOutput> rpcResult = RpcResultBuilder
1776 .<BrgTopologyOperationOutput>status(true)
1777 .withResult(responseBuilder.build())
1780 return Futures.immediateFuture(rpcResult);
1784 responseBuilder.setResponseCode(error.getStatusCode());
1785 responseBuilder.setAckFinalIndicator(ackFinal);
1786 if (!error.getMessage().isEmpty()) {
1787 responseBuilder.setResponseMessage(error.getMessage());
1789 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
1790 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
1792 RpcResult<BrgTopologyOperationOutput> rpcResult = RpcResultBuilder
1793 .<BrgTopologyOperationOutput>status(true)
1794 .withResult(responseBuilder.build())
1797 return Futures.immediateFuture(rpcResult);
1801 public Future<RpcResult<PreloadVnfTopologyOperationOutput>> preloadVnfTopologyOperation(
1802 PreloadVnfTopologyOperationInput input) {
1804 final String svcOperation = "preload-vnf-topology-operation";
1805 Properties parms = new Properties();
1807 log.info(CALLED_STR, svcOperation);
1808 // create a new response object
1809 PreloadVnfTopologyOperationOutputBuilder responseBuilder = new PreloadVnfTopologyOperationOutputBuilder();
1811 if (input == null || input.getVnfTopologyInformation() == null
1812 || input.getVnfTopologyInformation().getVnfTopologyIdentifier() == null) {
1813 log.debug("exiting {} because of null input", svcOperation);
1814 responseBuilder.setResponseCode("403");
1815 responseBuilder.setResponseMessage("invalid input: input is null");
1816 responseBuilder.setAckFinalIndicator("Y");
1818 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult = RpcResultBuilder
1819 .<PreloadVnfTopologyOperationOutput>status(true)
1820 .withResult(responseBuilder.build())
1823 return Futures.immediateFuture(rpcResult);
1826 // Grab the name and type from the input buffer
1827 String preloadName = input.getVnfTopologyInformation().getVnfTopologyIdentifier().getVnfName();
1828 String preloadType = input.getVnfTopologyInformation().getVnfTopologyIdentifier().getVnfType();
1830 // Make sure we have a preload_name and preload_type
1831 if (preloadName == null || preloadName.length() == 0 || preloadType == null || preloadType.length() == 0) {
1832 log.debug("exiting {} vnf-name or vnf-type is null or empty", svcOperation);
1833 responseBuilder.setResponseCode("403");
1834 responseBuilder.setResponseMessage("invalid input: vnf-name or vnf-type is null or empty");
1835 responseBuilder.setAckFinalIndicator("Y");
1837 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult = RpcResultBuilder
1838 .<PreloadVnfTopologyOperationOutput>status(true)
1839 .withResult(responseBuilder.build())
1842 return Futures.immediateFuture(rpcResult);
1845 if (input.getSdncRequestHeader() != null) {
1846 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1849 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
1850 getPreloadData(preloadName, preloadType, preloadDataBuilder);
1852 PreloadDataBuilder operDataBuilder = new PreloadDataBuilder();
1853 getPreloadData(preloadName, preloadType, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
1855 // setup a preload-data object builder
1856 // ACTION preload-vnf-topology-operation
1858 // USES sdnc-request-header;
1859 // USES request-information;
1860 // uses vnf-topology-information;
1862 // USES vnf-topology-response-body;
1864 // container preload-data
1865 // uses vnf-topology-information;
1866 // uses network-topology-information;
1867 // uses oper-status;
1869 log.info("Adding INPUT data for {} [{},{}] input: {}", svcOperation, preloadName, preloadType, input);
1870 PreloadVnfTopologyOperationInputBuilder inputBuilder = new PreloadVnfTopologyOperationInputBuilder(input);
1871 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1872 log.info("Adding OPERATIONAL data for {} [{},{}] operational-data: {}", svcOperation, preloadName,
1873 preloadType, operDataBuilder.build());
1874 GenericResourceApiUtil.toProperties(parms, OPERATIONAL_DATA_PARAM, operDataBuilder);
1876 // Call SLI sync method
1877 // Get SvcLogicService reference
1878 ErrorObject error = new ErrorObject("200", "");
1879 String ackFinal = "Y";
1880 Properties respProps = tryGetProperties(svcOperation, parms, error);
1882 if (respProps != null) {
1883 error.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
1884 error.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
1885 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
1888 if (validateErrorObject(error)) {
1890 responseBuilder.setResponseCode(error.getStatusCode());
1891 responseBuilder.setResponseMessage(error.getMessage());
1892 responseBuilder.setAckFinalIndicator(ackFinal);
1894 VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
1895 preloadVnfListBuilder.setVnfName(preloadName);
1896 preloadVnfListBuilder.setVnfType(preloadType);
1897 preloadVnfListBuilder.setPreloadData(preloadDataBuilder.build());
1898 log.error("Returned FAILED for {} [{},{}] error code: '{}', Reason: '{}'", svcOperation, preloadName,
1899 preloadType, error.getStatusCode(), error.getMessage());
1901 savePreloadList(preloadVnfListBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
1902 } catch (Exception e) {
1903 log.error(UPDATING_MDSAL_ERROR_MESSAGE_2, svcOperation, preloadName,
1906 log.debug("Sending Success rpc result due to external error");
1908 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult = RpcResultBuilder
1909 .<PreloadVnfTopologyOperationOutput>status(true)
1910 .withResult(responseBuilder.build())
1913 return Futures.immediateFuture(rpcResult);
1916 // Got success from SLI
1918 updatePreloadData(svcOperation, preloadName, preloadType, preloadDataBuilder);
1919 } catch (Exception e) {
1920 log.error(UPDATING_MDSAL_ERROR_MESSAGE_2, svcOperation, preloadName, preloadType,
1922 responseBuilder.setResponseCode("500");
1923 responseBuilder.setResponseMessage(e.toString());
1924 responseBuilder.setAckFinalIndicator("Y");
1925 log.error("Returned FAILED for {} [{},{}] {}", svcOperation, preloadName, preloadType,
1926 responseBuilder.build());
1928 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult = RpcResultBuilder
1929 .<PreloadVnfTopologyOperationOutput>status(false)
1930 .withResult(responseBuilder.build())
1933 return Futures.immediateFuture(rpcResult);
1937 responseBuilder.setResponseCode(error.getStatusCode());
1938 responseBuilder.setAckFinalIndicator(ackFinal);
1939 if (!error.getMessage().isEmpty()) {
1940 responseBuilder.setResponseMessage(error.getMessage());
1942 log.info("Updated MD-SAL for {} [{},{}]", svcOperation, preloadName, preloadType);
1943 log.info("Returned SUCCESS for {} [{},{}] {}", svcOperation, preloadName, preloadType,
1944 responseBuilder.build());
1946 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult = RpcResultBuilder
1947 .<PreloadVnfTopologyOperationOutput>status(true)
1948 .withResult(responseBuilder.build())
1951 return Futures.immediateFuture(rpcResult);
1954 private void updatePreloadData(String svcOperation, String preloadName, String preloadType,
1955 PreloadDataBuilder preloadDataBuilder) {
1956 PreloadData preloadData;
1957 preloadData = preloadDataBuilder.build();
1958 log.info("Updating MD-SAL for {} [{},{}] preloadData: {}", svcOperation, preloadName, preloadType,
1960 // svc-configuration-list
1961 VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
1962 preloadVnfListBuilder.setVnfName(preloadName);
1963 preloadVnfListBuilder.setVnfType(preloadType);
1964 preloadVnfListBuilder.setPreloadData(preloadData);
1966 // merge flag sets to false to allow it to be overwritten (not appended)
1967 savePreloadList(preloadVnfListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1968 log.info(UPDATING_TREE_INFO_MESSAGE);
1969 savePreloadList(preloadVnfListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1973 public Future<RpcResult<PreloadNetworkTopologyOperationOutput>> preloadNetworkTopologyOperation(
1974 PreloadNetworkTopologyOperationInput input) {
1976 final String svcOperation = "preload-network-topology-operation";
1977 Properties parms = new Properties();
1979 log.info(CALLED_STR, svcOperation);
1980 // create a new response object
1981 PreloadNetworkTopologyOperationOutputBuilder responseBuilder = new PreloadNetworkTopologyOperationOutputBuilder();
1983 if (input == null || input.getNetworkTopologyInformation() == null
1984 || input.getNetworkTopologyInformation().getNetworkTopologyIdentifier() == null) {
1986 log.debug("exiting {} because of null input", svcOperation);
1987 responseBuilder.setResponseCode("403");
1988 responseBuilder.setResponseMessage("input is null");
1989 responseBuilder.setAckFinalIndicator("Y");
1991 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
1992 .<PreloadNetworkTopologyOperationOutput>status(true)
1993 .withResult(responseBuilder.build())
1996 return Futures.immediateFuture(rpcResult);
1999 // Grab the name and type from the input buffer
2000 String preloadName = input.getNetworkTopologyInformation().getNetworkTopologyIdentifier().getNetworkName();
2001 String preloadType = input.getNetworkTopologyInformation().getNetworkTopologyIdentifier().getNetworkType();
2003 // Make sure we have a preload_name and preload_type
2004 if (preloadName == null || preloadName.length() == 0 || preloadType == null || preloadType.length() == 0) {
2005 log.debug("exiting {} because of invalid preload-name", svcOperation);
2006 responseBuilder.setResponseCode("403");
2007 responseBuilder.setResponseMessage("input, invalid preload-name");
2008 responseBuilder.setAckFinalIndicator("Y");
2010 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
2011 .<PreloadNetworkTopologyOperationOutput>status(true)
2012 .withResult(responseBuilder.build())
2015 return Futures.immediateFuture(rpcResult);
2018 if (input.getSdncRequestHeader() != null) {
2019 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
2022 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
2023 getPreloadData(preloadName, preloadType, preloadDataBuilder);
2025 PreloadDataBuilder operDataBuilder = new PreloadDataBuilder();
2026 getPreloadData(preloadName, preloadType, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
2029 // setup a preload-data object builder
2030 // ACTION preload-network-topology-operation
2032 // USES sdnc-request-header;
2033 // USES request-information;
2034 // uses network-topology-information;
2036 // USES vnf-topology-response-body;
2038 // container preload-data
2039 // uses vnf-topology-information;
2040 // uses network-topology-information;
2041 // uses oper-status;
2043 log.info("Adding INPUT data for {} [{},{}] input: {}", svcOperation, preloadName, preloadType, input);
2044 PreloadNetworkTopologyOperationInputBuilder inputBuilder = new PreloadNetworkTopologyOperationInputBuilder(
2046 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
2047 log.info("Adding OPERATIONAL data for {} [{},{}] operational-data: {}", svcOperation, preloadName,
2048 preloadType, operDataBuilder.build());
2049 GenericResourceApiUtil.toProperties(parms, OPERATIONAL_DATA_PARAM, operDataBuilder);
2051 // Call SLI sync method
2052 // Get SvcLogicService reference
2053 ErrorObject error = new ErrorObject("200", "");
2054 String ackFinal = "Y";
2055 Properties respProps = tryGetProperties(svcOperation, parms, error);
2057 if (respProps != null) {
2058 error.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
2059 error.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
2060 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
2063 if (validateErrorObject(error)) {
2065 responseBuilder.setResponseCode(error.getStatusCode());
2066 responseBuilder.setResponseMessage(error.getMessage());
2067 responseBuilder.setAckFinalIndicator(ackFinal);
2069 VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
2070 preloadVnfListBuilder.setVnfName(preloadName);
2071 preloadVnfListBuilder.setVnfType(preloadType);
2072 preloadVnfListBuilder.setPreloadData(preloadDataBuilder.build());
2073 log.error("Returned FAILED for {} [{},{}] error code: '{}', Reason: '{}'", svcOperation, preloadName,
2074 preloadType, error.getStatusCode(), error.getMessage());
2076 savePreloadList(preloadVnfListBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
2077 } catch (Exception e) {
2078 log.error(UPDATING_MDSAL_ERROR_MESSAGE_2, svcOperation, preloadName,
2082 log.debug("Sending Success rpc result due to external error");
2084 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
2085 .<PreloadNetworkTopologyOperationOutput>status(true)
2086 .withResult(responseBuilder.build())
2089 return Futures.immediateFuture(rpcResult);
2092 // Got success from SLI
2094 updatePreloadData(svcOperation, preloadName, preloadType, preloadDataBuilder);
2095 } catch (Exception e) {
2096 log.error(UPDATING_MDSAL_ERROR_MESSAGE_2, svcOperation, preloadName, preloadType, e);
2097 responseBuilder.setResponseCode("500");
2098 responseBuilder.setResponseMessage(e.toString());
2099 responseBuilder.setAckFinalIndicator("Y");
2100 log.error("Returned FAILED for {} [{},{}] {}", svcOperation, preloadName, preloadType,
2101 responseBuilder.build());
2103 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
2104 .<PreloadNetworkTopologyOperationOutput>status(false)
2105 .withResult(responseBuilder.build())
2108 return Futures.immediateFuture(rpcResult);
2112 responseBuilder.setResponseCode(error.getStatusCode());
2113 responseBuilder.setAckFinalIndicator(ackFinal);
2114 if (!error.getMessage().isEmpty()) {
2115 responseBuilder.setResponseMessage(error.getMessage());
2117 log.info("Updated MD-SAL for {} [{},{}]", svcOperation, preloadName, preloadType);
2118 log.info("Returned SUCCESS for {} [{},{}] {}", svcOperation, preloadName, preloadType,
2119 responseBuilder.build());
2121 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
2122 .<PreloadNetworkTopologyOperationOutput>status(true)
2123 .withResult(responseBuilder.build())
2126 return Futures.immediateFuture(rpcResult);