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 (hasValidService(input)) {
506 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
507 responseBuilder.setResponseCode("404");
508 responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
509 responseBuilder.setAckFinalIndicator("Y");
511 RpcResult<ServiceTopologyOperationOutput> rpcResult = RpcResultBuilder
512 .<ServiceTopologyOperationOutput>status(true)
513 .withResult(responseBuilder.build())
516 return Futures.immediateFuture(rpcResult);
519 // Grab the service instance ID from the input buffer
520 String siid = input.getServiceInformation().getServiceInstanceId();
522 trySetSvcRequestId(input, responseBuilder);
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 (isValidErrorObject(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 tryDeleteService(input, serviceBuilder);
604 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
605 serviceResponseInformationBuilder.setInstanceId(siid);
606 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
607 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
609 } catch (Exception e) {
610 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
611 responseBuilder.setResponseCode("500");
612 responseBuilder.setResponseMessage(e.toString());
613 responseBuilder.setAckFinalIndicator("Y");
614 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
616 RpcResult<ServiceTopologyOperationOutput> rpcResult = RpcResultBuilder
617 .<ServiceTopologyOperationOutput>status(true)
618 .withResult(responseBuilder.build())
621 return Futures.immediateFuture(rpcResult);
625 responseBuilder.setResponseCode(error.getStatusCode());
626 responseBuilder.setAckFinalIndicator(ackFinal);
627 trySetResponseMessage(responseBuilder, error);
628 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
629 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
631 RpcResult<ServiceTopologyOperationOutput> rpcResult = RpcResultBuilder
632 .<ServiceTopologyOperationOutput>status(true)
633 .withResult(responseBuilder.build())
636 return Futures.immediateFuture(rpcResult);
639 private void trySetResponseMessage(ServiceTopologyOperationOutputBuilder responseBuilder, ErrorObject error) {
640 if (!error.getMessage().isEmpty()) {
641 responseBuilder.setResponseMessage(error.getMessage());
645 private boolean hasValidService(ServiceTopologyOperationInput input) {
646 return input == null || input.getServiceInformation() == null
647 || input.getServiceInformation().getServiceInstanceId() == null
648 || input.getServiceInformation().getServiceInstanceId().length() == 0;
651 private void trySetSvcRequestId(ServiceTopologyOperationInput input,
652 ServiceTopologyOperationOutputBuilder responseBuilder) {
653 if (input.getSdncRequestHeader() != null) {
654 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
658 private void tryDeleteService(ServiceTopologyOperationInput input, ServiceBuilder serviceBuilder) {
659 if (isValidRequest(input) && input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete)) {
660 // Only update operational tree on delete
661 log.info("Delete from both CONFIGURATION and OPERATIONAL tree.");
662 deleteService(serviceBuilder.build(), LogicalDatastoreType.OPERATIONAL);
663 deleteService(serviceBuilder.build(), LogicalDatastoreType.CONFIGURATION);
667 private Properties tryGetProperties(String svcOperation, Properties parms, ServiceDataBuilder serviceDataBuilder,
670 if (svcLogicClient.hasGraph(APP_NAME, svcOperation, null, "sync")) {
672 return svcLogicClient.execute(APP_NAME, svcOperation, null, "sync", serviceDataBuilder, parms);
673 } catch (Exception e) {
674 log.error(SERVICE_LOGIC_EXECUTION_ERROR_MESSAGE, svcOperation, e);
675 error.setMessage(e.getMessage());
676 error.setStatusCode("500");
679 error.setMessage(NO_SERVICE_LOGIC_ACTIVE + APP_NAME + ": '" + svcOperation + "'");
680 error.setStatusCode("503");
682 } catch (Exception e) {
683 error.setMessage(e.getMessage());
684 error.setStatusCode("500");
685 log.error(SERVICE_LOGIC_SEARCH_ERROR_MESSAGE, e);
691 private boolean isValidErrorObject(ErrorObject error) {
693 !error.getStatusCode().isEmpty() && !("0".equals(error.getStatusCode()) || "200"
694 .equals(error.getStatusCode()));
697 private boolean isValidRequest(ServiceTopologyOperationInput input) {
698 return input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null;
702 public Future<RpcResult<VnfTopologyOperationOutput>> vnfTopologyOperation(VnfTopologyOperationInput input) {
704 final String svcOperation = "vnf-topology-operation";
705 ServiceData serviceData;
706 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
707 Properties parms = new Properties();
709 log.info(CALLED_STR, svcOperation);
710 // create a new response object
711 VnfTopologyOperationOutputBuilder responseBuilder = new VnfTopologyOperationOutputBuilder();
713 if (hasInvalidService(input)) {
715 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
716 responseBuilder.setResponseCode("404");
717 responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
718 responseBuilder.setAckFinalIndicator("Y");
719 RpcResult<VnfTopologyOperationOutput> rpcResult = RpcResultBuilder.<VnfTopologyOperationOutput>status(true)
720 .withResult(responseBuilder.build()).build();
722 return Futures.immediateFuture(rpcResult);
725 // Grab the service instance ID from the input buffer
726 String siid = input.getServiceInformation().getServiceInstanceId();
728 trySetSvcRequestId(input, responseBuilder);
730 if (hasInvalidVnf(input)) {
731 log.debug("exiting {} because of null or empty vnf-id", svcOperation);
732 responseBuilder.setResponseCode("404");
733 responseBuilder.setResponseMessage("invalid input, null or empty vnf-id");
734 responseBuilder.setAckFinalIndicator("Y");
736 RpcResult<VnfTopologyOperationOutput> rpcResult = RpcResultBuilder
737 .<VnfTopologyOperationOutput>status(true)
738 .withResult(responseBuilder.build())
741 return Futures.immediateFuture(rpcResult);
744 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
745 getServiceData(siid, serviceDataBuilder);
747 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
748 getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
750 // Set the serviceStatus based on input
751 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
752 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
755 // setup a service-data object builder
756 // ACTION vnf-topology-operation
758 // USES sdnc-request-header;
759 // USES request-information;
760 // USES service-information;
761 // USES vnf-request-information
763 // USES vnf-topology-response-body;
764 // USES vnf-information
765 // USES service-information
767 // container service-data
768 // uses vnf-configuration-information;
771 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
772 VnfTopologyOperationInputBuilder inputBuilder = new VnfTopologyOperationInputBuilder(input);
773 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
775 log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid,
776 operDataBuilder.build());
777 GenericResourceApiUtil.toProperties(parms, OPERATIONAL_DATA_PARAM, operDataBuilder);
779 // Call SLI sync method
780 // Get SvcLogicService reference
782 ErrorObject error = new ErrorObject("200", "");
783 String ackFinal = "Y";
784 String serviceObjectPath = null;
785 Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, error);
787 if (respProps != null) {
788 error.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
789 error.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
790 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
791 serviceObjectPath = respProps.getProperty("vnf-object-path");
794 setServiceStatus(serviceStatusBuilder, error.getStatusCode(), error.getMessage(), ackFinal);
795 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
796 serviceStatusBuilder.setRpcName(svcOperation);
798 if (isValidErrorObject(error)) {
799 responseBuilder.setResponseCode(error.getStatusCode());
800 responseBuilder.setResponseMessage(error.getMessage());
801 responseBuilder.setAckFinalIndicator(ackFinal);
803 ServiceBuilder serviceBuilder = new ServiceBuilder();
804 serviceBuilder.setServiceInstanceId(siid);
805 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
807 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
808 trySaveService(input, serviceBuilder);
809 } catch (Exception e) {
810 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
812 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
814 RpcResult<VnfTopologyOperationOutput> rpcResult = RpcResultBuilder
815 .<VnfTopologyOperationOutput>status(true)
816 .withResult(responseBuilder.build())
820 return Futures.immediateFuture(rpcResult);
823 // Got success from SLI
825 serviceData = serviceDataBuilder.build();
826 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
829 ServiceBuilder serviceBuilder = new ServiceBuilder();
830 serviceBuilder.setServiceData(serviceData);
831 serviceBuilder.setServiceInstanceId(siid);
832 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
833 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
835 if (isValidRequest(input) && input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate)) {
836 // Only update operational tree on Assign
838 log.info(UPDATING_TREE_INFO_MESSAGE);
839 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
842 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
843 serviceResponseInformationBuilder.setInstanceId(siid);
844 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
845 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
847 } catch (Exception e) {
848 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
849 responseBuilder.setResponseCode("500");
850 responseBuilder.setResponseMessage(e.toString());
851 responseBuilder.setAckFinalIndicator("Y");
852 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
854 RpcResult<VnfTopologyOperationOutput> rpcResult = RpcResultBuilder
855 .<VnfTopologyOperationOutput>status(true)
856 .withResult(responseBuilder.build())
859 return Futures.immediateFuture(rpcResult);
863 responseBuilder.setResponseCode(error.getStatusCode());
864 responseBuilder.setAckFinalIndicator(ackFinal);
865 trySetResponseMessage(responseBuilder, error);
866 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
867 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
869 RpcResult<VnfTopologyOperationOutput> rpcResult = RpcResultBuilder
870 .<VnfTopologyOperationOutput>status(true)
871 .withResult(responseBuilder.build())
875 return Futures.immediateFuture(rpcResult);
878 private void trySetResponseMessage(VnfTopologyOperationOutputBuilder responseBuilder, ErrorObject error) {
879 if (!error.getMessage().isEmpty()) {
880 responseBuilder.setResponseMessage(error.getMessage());
884 private void trySaveService(VnfTopologyOperationInput input, ServiceBuilder serviceBuilder) {
885 if (isValidRequest(input) &&
886 (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete) ||
887 input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))) {
889 // Only update operational tree on activate or delete
890 log.info(UPDATING_TREE_INFO_MESSAGE);
891 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
895 private boolean hasInvalidVnf(VnfTopologyOperationInput input) {
896 return input.getVnfInformation() == null || input.getVnfInformation().getVnfId() == null
897 || input.getVnfInformation().getVnfId().length() == 0;
900 private boolean hasInvalidService(VnfTopologyOperationInput input) {
901 return input == null || input.getServiceInformation() == null
902 || input.getServiceInformation().getServiceInstanceId() == null
903 || input.getServiceInformation().getServiceInstanceId().length() == 0;
906 private void trySetSvcRequestId(VnfTopologyOperationInput input,
907 VnfTopologyOperationOutputBuilder responseBuilder) {
908 if (input.getSdncRequestHeader() != null) {
909 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
913 private boolean isValidRequest(VnfTopologyOperationInput input) {
914 return input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null;
918 public Future<RpcResult<VfModuleTopologyOperationOutput>> vfModuleTopologyOperation(
919 VfModuleTopologyOperationInput input) {
921 final String svcOperation = "vf-module-topology-operation";
922 ServiceData serviceData;
923 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
924 Properties parms = new Properties();
926 log.info(CALLED_STR, svcOperation);
927 // create a new response object
928 VfModuleTopologyOperationOutputBuilder responseBuilder = new VfModuleTopologyOperationOutputBuilder();
930 if (hasInvalidService(input)) {
931 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
932 responseBuilder.setResponseCode("403");
933 responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
934 responseBuilder.setAckFinalIndicator("Y");
936 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
937 .<VfModuleTopologyOperationOutput>status(true)
938 .withResult(responseBuilder.build())
942 return Futures.immediateFuture(rpcResult);
945 if (hasInvalidVnf(input)) {
946 log.debug("exiting {} because of null or empty vnf-id", svcOperation);
947 responseBuilder.setResponseCode("403");
948 responseBuilder.setResponseMessage("invalid input, null or empty vnf-id");
949 responseBuilder.setAckFinalIndicator("Y");
950 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
951 .<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
952 return Futures.immediateFuture(rpcResult);
955 if (hasInvalidVfModule(input)) {
956 log.debug("exiting {} because of null or empty vf-module-id", svcOperation);
957 responseBuilder.setResponseCode("403");
958 responseBuilder.setResponseMessage("invalid input, vf-module-id is null or empty");
959 responseBuilder.setAckFinalIndicator("Y");
961 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
962 .<VfModuleTopologyOperationOutput>status(true)
963 .withResult(responseBuilder.build())
966 return Futures.immediateFuture(rpcResult);
969 // Grab the service instance ID from the input buffer
970 String siid = input.getServiceInformation().getServiceInstanceId();
972 trySetSvcRequestId(input, responseBuilder);
974 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
975 getServiceData(siid, serviceDataBuilder);
977 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
978 getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
980 // Set the serviceStatus based on input
981 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
982 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
985 // setup a service-data object builder
986 // ACTION vnf-topology-operation
988 // USES sdnc-request-header;
989 // USES request-information;
990 // USES service-information;
991 // USES vnf-request-information
993 // USES vnf-topology-response-body;
994 // USES vnf-information
995 // USES service-information
997 // container service-data
998 // uses vnf-configuration-information;
1001 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
1002 VfModuleTopologyOperationInputBuilder inputBuilder = new VfModuleTopologyOperationInputBuilder(input);
1003 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1005 log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid,
1006 operDataBuilder.build());
1007 GenericResourceApiUtil.toProperties(parms, OPERATIONAL_DATA_PARAM, operDataBuilder);
1009 // Call SLI sync method
1010 // Get SvcLogicService reference
1012 ErrorObject error = new ErrorObject("200", "");
1013 String ackFinal = "Y";
1014 String serviceObjectPath = null;
1015 Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, error);
1017 if (respProps != null) {
1018 error.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
1019 error.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
1020 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
1021 serviceObjectPath = respProps.getProperty("vf-module-object-path");
1024 setServiceStatus(serviceStatusBuilder, error.getStatusCode(), error.getMessage(), ackFinal);
1025 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
1026 serviceStatusBuilder.setRpcName(svcOperation);
1028 if (isValidErrorObject(error)) {
1029 responseBuilder.setResponseCode(error.getStatusCode());
1030 responseBuilder.setResponseMessage(error.getStatusCode());
1031 responseBuilder.setAckFinalIndicator(ackFinal);
1033 ServiceBuilder serviceBuilder = new ServiceBuilder();
1034 serviceBuilder.setServiceInstanceId(siid);
1035 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1037 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
1038 } catch (Exception e) {
1039 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1041 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1043 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
1044 .<VfModuleTopologyOperationOutput>status(true)
1045 .withResult(responseBuilder.build())
1049 return Futures.immediateFuture(rpcResult);
1052 // Got success from SLI
1054 serviceData = serviceDataBuilder.build();
1055 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
1058 ServiceBuilder serviceBuilder = new ServiceBuilder();
1059 serviceBuilder.setServiceData(serviceData);
1060 serviceBuilder.setServiceInstanceId(siid);
1061 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1062 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1064 trySaveService(input, serviceBuilder);
1066 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1067 serviceResponseInformationBuilder.setInstanceId(siid);
1068 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1069 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1071 } catch (Exception e) {
1072 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1073 responseBuilder.setResponseCode("500");
1074 responseBuilder.setResponseMessage(e.toString());
1075 responseBuilder.setAckFinalIndicator("Y");
1076 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1078 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
1079 .<VfModuleTopologyOperationOutput>status(true)
1080 .withResult(responseBuilder.build())
1083 return Futures.immediateFuture(rpcResult);
1087 responseBuilder.setResponseCode(error.getStatusCode());
1088 responseBuilder.setAckFinalIndicator(ackFinal);
1089 trySetResponseMessage(responseBuilder, error);
1090 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
1091 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
1093 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
1094 .<VfModuleTopologyOperationOutput>status(true)
1095 .withResult(responseBuilder.build())
1099 return Futures.immediateFuture(rpcResult);
1102 private void trySetResponseMessage(VfModuleTopologyOperationOutputBuilder responseBuilder, ErrorObject error) {
1103 if (!error.getMessage().isEmpty()) {
1104 responseBuilder.setResponseMessage(error.getMessage());
1108 private void trySaveService(VfModuleTopologyOperationInput input, ServiceBuilder serviceBuilder) {
1109 if (isValidRequest(input) &&
1110 (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Unassign) ||
1111 input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))) {
1112 // Only update operational tree on activate or delete
1114 log.info(UPDATING_TREE_INFO_MESSAGE);
1115 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1119 private void trySetSvcRequestId(VfModuleTopologyOperationInput input,
1120 VfModuleTopologyOperationOutputBuilder responseBuilder) {
1121 if (input.getSdncRequestHeader() != null) {
1122 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1126 private boolean hasInvalidVfModule(VfModuleTopologyOperationInput input) {
1127 return input.getVfModuleInformation() == null || input.getVfModuleInformation().getVfModuleId() == null
1128 || input.getVfModuleInformation().getVfModuleId().length() == 0;
1131 private boolean hasInvalidVnf(VfModuleTopologyOperationInput input) {
1132 return input.getVnfInformation() == null || input.getVnfInformation().getVnfId() == null
1133 || input.getVnfInformation().getVnfId().length() == 0;
1136 private boolean hasInvalidService(VfModuleTopologyOperationInput input) {
1137 return input == null || input.getServiceInformation() == null
1138 || input.getServiceInformation().getServiceInstanceId() == null
1139 || input.getServiceInformation().getServiceInstanceId().length() == 0;
1142 private boolean isValidRequest(VfModuleTopologyOperationInput input) {
1143 return input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null;
1147 public Future<RpcResult<NetworkTopologyOperationOutput>> networkTopologyOperation(
1148 NetworkTopologyOperationInput input) {
1150 final String svcOperation = "network-topology-operation";
1151 ServiceData serviceData;
1152 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1153 Properties parms = new Properties();
1155 log.info(CALLED_STR, svcOperation);
1156 // create a new response object
1157 NetworkTopologyOperationOutputBuilder responseBuilder = new NetworkTopologyOperationOutputBuilder();
1159 if (this.hasInvalidService(input)) {
1160 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
1161 return buildRpcResultFuture(responseBuilder, NULL_OR_EMPTY_ERROR_PARAM);
1164 String siid = input.getServiceInformation().getServiceInstanceId();
1166 // Get the service-instance service data from MD-SAL
1167 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1168 getServiceData(siid, serviceDataBuilder);
1170 this.trySetSvcRequestId(input, responseBuilder);
1172 ServiceData sd = serviceDataBuilder.build();
1173 if (isInvalidServiceData(sd)) {
1174 log.debug(EMPTY_SERVICE_INSTANCE_MESSAGE, svcOperation);
1175 return buildRpcResultFuture(responseBuilder, INVALID_INPUT_ERROR_MESSAGE);
1178 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
1179 NetworkTopologyOperationInputBuilder inputBuilder = new NetworkTopologyOperationInputBuilder(input);
1180 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1182 // Call SLI sync method
1183 // Get SvcLogicService reference
1185 ErrorObject error = new ErrorObject("200", "");
1186 String ackFinal = "Y";
1187 String networkId = ERROR_NETWORK_ID;
1188 String serviceObjectPath = null;
1189 String networkObjectPath = null;
1190 Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, error);
1192 if (respProps != null) {
1193 error.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
1194 error.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
1195 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
1196 networkId = respProps.getProperty("networkId");
1197 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
1198 networkObjectPath = respProps.getProperty("network-object-path");
1201 if (isValidErrorObject(error)) {
1202 responseBuilder.setResponseCode(error.getStatusCode());
1203 responseBuilder.setResponseMessage(error.getMessage());
1204 responseBuilder.setAckFinalIndicator(ackFinal);
1206 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1208 RpcResult<NetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
1209 .<NetworkTopologyOperationOutput>status(true)
1210 .withResult(responseBuilder.build())
1213 return Futures.immediateFuture(rpcResult);
1216 // Got success from SLI
1219 serviceData = serviceDataBuilder.build();
1220 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
1223 ServiceBuilder serviceBuilder = new ServiceBuilder();
1224 serviceBuilder.setServiceData(serviceData);
1225 serviceBuilder.setServiceInstanceId(siid);
1226 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1227 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1229 trySaveService(input, serviceBuilder);
1231 NetworkResponseInformationBuilder networkResponseInformationBuilder = new NetworkResponseInformationBuilder();
1232 networkResponseInformationBuilder.setInstanceId(networkId);
1233 networkResponseInformationBuilder.setObjectPath(networkObjectPath);
1234 responseBuilder.setNetworkResponseInformation(networkResponseInformationBuilder.build());
1236 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1237 serviceResponseInformationBuilder.setInstanceId(siid);
1238 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1239 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1241 } catch (IllegalStateException e) {
1242 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1243 responseBuilder.setResponseCode("500");
1244 responseBuilder.setResponseMessage(e.toString());
1245 responseBuilder.setAckFinalIndicator("Y");
1246 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1248 RpcResult<NetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
1249 .<NetworkTopologyOperationOutput>status(true)
1250 .withResult(responseBuilder.build())
1253 return Futures.immediateFuture(rpcResult);
1257 responseBuilder.setResponseCode(error.getStatusCode());
1258 responseBuilder.setAckFinalIndicator(ackFinal);
1259 trySetResponseMessage(responseBuilder, error);
1260 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
1261 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
1263 RpcResult<NetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
1264 .<NetworkTopologyOperationOutput>status(true)
1265 .withResult(responseBuilder.build())
1268 return Futures.immediateFuture(rpcResult);
1271 private void trySetResponseMessage(NetworkTopologyOperationOutputBuilder responseBuilder, ErrorObject error) {
1272 if (!error.getMessage().isEmpty()) {
1273 responseBuilder.setResponseMessage(error.getMessage());
1277 private void trySetSvcRequestId(NetworkTopologyOperationInput input,
1278 NetworkTopologyOperationOutputBuilder responseBuilder) {
1279 if (input.getSdncRequestHeader() != null) {
1280 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1284 private void trySaveService(NetworkTopologyOperationInput input, ServiceBuilder serviceBuilder) {
1285 if (isValidRequest(input) &&
1286 (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate) ||
1287 input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Create))) {
1288 // Only update operational tree on Activate
1289 log.info(UPDATING_TREE_INFO_MESSAGE);
1290 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1294 private boolean hasInvalidService(NetworkTopologyOperationInput input) {
1295 return input == null || input.getServiceInformation() == null
1296 || input.getServiceInformation().getServiceInstanceId() == null
1297 || input.getServiceInformation().getServiceInstanceId().length() == 0;
1300 private Future<RpcResult<NetworkTopologyOperationOutput>> buildRpcResultFuture(
1301 NetworkTopologyOperationOutputBuilder responseBuilder, String responseMessage) {
1303 responseBuilder.setResponseCode("404");
1305 .setResponseMessage(responseMessage);
1306 responseBuilder.setAckFinalIndicator("Y");
1308 RpcResult<NetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
1309 .<NetworkTopologyOperationOutput>status(true)
1310 .withResult(responseBuilder.build())
1313 return Futures.immediateFuture(rpcResult);
1316 private boolean isValidRequest(NetworkTopologyOperationInput input) {
1317 return input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null;
1321 public Future<RpcResult<ContrailRouteTopologyOperationOutput>> contrailRouteTopologyOperation(
1322 ContrailRouteTopologyOperationInput input) {
1324 final String svcOperation = "contrail-route-topology-operation";
1325 ServiceData serviceData;
1326 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1327 Properties parms = new Properties();
1329 log.info(CALLED_STR, svcOperation);
1330 // create a new response object
1331 ContrailRouteTopologyOperationOutputBuilder responseBuilder = new ContrailRouteTopologyOperationOutputBuilder();
1333 if (hasInvalidService(input)) {
1334 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
1335 return buildRpcResultFuture(responseBuilder, NULL_OR_EMPTY_ERROR_PARAM);
1338 String siid = input.getServiceInformation().getServiceInstanceId();
1340 // Get the service-instance service data from MD-SAL
1341 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1342 getServiceData(siid, serviceDataBuilder);
1344 trySetSvcRequestId(input, responseBuilder);
1346 ServiceData sd = serviceDataBuilder.build();
1347 if (isInvalidServiceData(sd)) {
1348 log.debug(EMPTY_SERVICE_INSTANCE_MESSAGE, svcOperation);
1349 return buildRpcResultFuture(responseBuilder, INVALID_INPUT_ERROR_MESSAGE);
1352 log.info("Adding INPUT data for " + svcOperation + " [" + siid + "] input: " + input);
1353 ContrailRouteTopologyOperationInputBuilder inputBuilder = new ContrailRouteTopologyOperationInputBuilder(input);
1354 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1356 // Call SLI sync method
1357 // Get SvcLogicService reference
1358 ErrorObject error = new ErrorObject("200", "");
1359 String ackFinal = "Y";
1360 String allottedResourceId = ERROR_NETWORK_ID;
1361 String serviceObjectPath = null;
1362 String contrailRouteObjectPath = null;
1363 Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, error);
1365 if (respProps != null) {
1366 error.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
1367 error.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
1368 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
1369 allottedResourceId = respProps.getProperty(ALLOTTED_RESOURCE_ID_PARAM);
1370 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
1371 contrailRouteObjectPath = respProps.getProperty("contrail-route-object-path");
1374 if (isValidErrorObject(error)) {
1375 responseBuilder.setResponseCode(error.getStatusCode());
1376 responseBuilder.setResponseMessage(error.getMessage());
1377 responseBuilder.setAckFinalIndicator(ackFinal);
1378 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1380 RpcResult<ContrailRouteTopologyOperationOutput> rpcResult = RpcResultBuilder
1381 .<ContrailRouteTopologyOperationOutput>status(true)
1382 .withResult(responseBuilder.build())
1385 return Futures.immediateFuture(rpcResult);
1388 // Got success from SLI
1390 serviceData = serviceDataBuilder.build();
1391 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
1394 ServiceBuilder serviceBuilder = new ServiceBuilder();
1395 serviceBuilder.setServiceData(serviceData);
1396 serviceBuilder.setServiceInstanceId(siid);
1397 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1398 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1400 trySaveService(input, serviceBuilder);
1402 ContrailRouteResponseInformationBuilder contrailRouteResponseInformationBuilder = new ContrailRouteResponseInformationBuilder();
1403 contrailRouteResponseInformationBuilder.setInstanceId(allottedResourceId);
1404 contrailRouteResponseInformationBuilder.setObjectPath(contrailRouteObjectPath);
1405 responseBuilder.setContrailRouteResponseInformation(contrailRouteResponseInformationBuilder.build());
1407 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1408 serviceResponseInformationBuilder.setInstanceId(siid);
1409 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1410 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1412 } catch (IllegalStateException e) {
1413 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1414 responseBuilder.setResponseCode("500");
1415 responseBuilder.setResponseMessage(e.toString());
1416 responseBuilder.setAckFinalIndicator("Y");
1417 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1419 RpcResult<ContrailRouteTopologyOperationOutput> rpcResult = RpcResultBuilder
1420 .<ContrailRouteTopologyOperationOutput>status(true)
1421 .withResult(responseBuilder.build())
1424 return Futures.immediateFuture(rpcResult);
1428 responseBuilder.setResponseCode(error.getStatusCode());
1429 responseBuilder.setAckFinalIndicator(ackFinal);
1430 trySetResponseMessage(responseBuilder, error);
1431 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
1432 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
1434 RpcResult<ContrailRouteTopologyOperationOutput> rpcResult = RpcResultBuilder
1435 .<ContrailRouteTopologyOperationOutput>status(true)
1436 .withResult(responseBuilder.build())
1439 return Futures.immediateFuture(rpcResult);
1442 private void trySetResponseMessage(ContrailRouteTopologyOperationOutputBuilder responseBuilder, ErrorObject error) {
1443 if (!error.getMessage().isEmpty()) {
1444 responseBuilder.setResponseMessage(error.getMessage());
1448 private void trySaveService(ContrailRouteTopologyOperationInput input, ServiceBuilder serviceBuilder) {
1449 if (isValidRequest(input) &&
1450 (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Unassign) ||
1451 input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))) {
1452 // Only update operational tree on activate or delete
1453 log.info(UPDATING_TREE_INFO_MESSAGE);
1454 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1458 private void trySetSvcRequestId(ContrailRouteTopologyOperationInput input,
1459 ContrailRouteTopologyOperationOutputBuilder responseBuilder) {
1460 if (input.getSdncRequestHeader() != null) {
1461 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1465 private boolean hasInvalidService(ContrailRouteTopologyOperationInput input) {
1466 return input == null || input.getServiceInformation() == null
1467 || input.getServiceInformation().getServiceInstanceId() == null
1468 || input.getServiceInformation().getServiceInstanceId().length() == 0;
1471 private Future<RpcResult<ContrailRouteTopologyOperationOutput>>
1472 buildRpcResultFuture(ContrailRouteTopologyOperationOutputBuilder responseBuilder, String responseMessage) {
1474 responseBuilder.setResponseCode("404");
1475 responseBuilder.setResponseMessage(responseMessage);
1476 responseBuilder.setAckFinalIndicator("Y");
1478 RpcResult<ContrailRouteTopologyOperationOutput> rpcResult = RpcResultBuilder
1479 .<ContrailRouteTopologyOperationOutput>status(true)
1480 .withResult(responseBuilder.build())
1483 return Futures.immediateFuture(rpcResult);
1486 private boolean isValidRequest(ContrailRouteTopologyOperationInput input) {
1487 return input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null;
1491 public Future<RpcResult<SecurityZoneTopologyOperationOutput>> securityZoneTopologyOperation(
1492 SecurityZoneTopologyOperationInput input) {
1494 final String svcOperation = "security-zone-topology-operation";
1495 ServiceData serviceData;
1496 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1497 Properties parms = new Properties();
1499 log.info(CALLED_STR, svcOperation);
1500 // create a new response object
1501 SecurityZoneTopologyOperationOutputBuilder responseBuilder = new SecurityZoneTopologyOperationOutputBuilder();
1503 if (this.hasInvalidService(input)) {
1504 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
1505 return buildRpcResultFuture(responseBuilder, NULL_OR_EMPTY_ERROR_PARAM);
1508 String siid = input.getServiceInformation().getServiceInstanceId();
1510 // Get the service-instance service data from MD-SAL
1511 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1512 getServiceData(siid, serviceDataBuilder);
1513 trySetSvcRequestId(input, responseBuilder);
1515 ServiceData sd = serviceDataBuilder.build();
1516 if (isInvalidServiceData(sd)) {
1517 log.debug(EMPTY_SERVICE_INSTANCE_MESSAGE, svcOperation);
1518 return buildRpcResultFuture(responseBuilder, INVALID_INPUT_ERROR_MESSAGE);
1521 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
1522 SecurityZoneTopologyOperationInputBuilder inputBuilder = new SecurityZoneTopologyOperationInputBuilder(input);
1523 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1525 // Call SLI sync method
1526 // Get SvcLogicService reference
1528 Properties respProps = null;
1530 ErrorObject error = new ErrorObject("200", "");
1531 String ackFinal = "Y";
1532 String allottedResourceId = ERROR_NETWORK_ID;
1533 String serviceObjectPath = null;
1534 String securityZoneObjectPath = null;
1537 if (svcLogicClient.hasGraph(APP_NAME, svcOperation, null, "sync")) {
1540 respProps = svcLogicClient.execute(APP_NAME, svcOperation, null, "sync", serviceDataBuilder, parms);
1541 } catch (Exception e) {
1542 log.error(SERVICE_LOGIC_EXECUTION_ERROR_MESSAGE, svcOperation, e);
1543 error.setMessage(e.getMessage());
1544 error.setStatusCode("500");
1547 error.setMessage(NO_SERVICE_LOGIC_ACTIVE + APP_NAME + ": '" + svcOperation + "'");
1548 error.setStatusCode("503");
1550 } catch (Exception e) {
1551 error.setStatusCode("500");
1552 error.setMessage(e.getMessage());
1553 log.error(SERVICE_LOGIC_SEARCH_ERROR_MESSAGE, e);
1556 if (respProps != null) {
1557 error.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
1558 error.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
1559 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
1560 allottedResourceId = respProps.getProperty(ALLOTTED_RESOURCE_ID_PARAM);
1561 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
1562 securityZoneObjectPath = respProps.getProperty("security-zone-object-path");
1565 if (isValidErrorObject(error)) {
1566 responseBuilder.setResponseCode(error.getStatusCode());
1567 responseBuilder.setResponseMessage(error.getMessage());
1568 responseBuilder.setAckFinalIndicator(ackFinal);
1569 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1571 RpcResult<SecurityZoneTopologyOperationOutput> rpcResult = RpcResultBuilder
1572 .<SecurityZoneTopologyOperationOutput>status(true)
1573 .withResult(responseBuilder.build())
1576 return Futures.immediateFuture(rpcResult);
1579 // Got success from SLI
1582 serviceData = serviceDataBuilder.build();
1583 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
1586 ServiceBuilder serviceBuilder = new ServiceBuilder();
1587 serviceBuilder.setServiceData(serviceData);
1588 serviceBuilder.setServiceInstanceId(siid);
1589 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1590 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1592 trySaveService(input, serviceBuilder);
1594 SecurityZoneResponseInformationBuilder securityZoneResponseInformationBuilder = new SecurityZoneResponseInformationBuilder();
1595 securityZoneResponseInformationBuilder.setInstanceId(allottedResourceId);
1596 securityZoneResponseInformationBuilder.setObjectPath(securityZoneObjectPath);
1597 responseBuilder.setSecurityZoneResponseInformation(securityZoneResponseInformationBuilder.build());
1599 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1600 serviceResponseInformationBuilder.setInstanceId(siid);
1601 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1602 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1604 } catch (IllegalStateException e) {
1605 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1606 responseBuilder.setResponseCode("500");
1607 responseBuilder.setResponseMessage(e.toString());
1608 responseBuilder.setAckFinalIndicator("Y");
1609 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1611 RpcResult<SecurityZoneTopologyOperationOutput> rpcResult = RpcResultBuilder
1612 .<SecurityZoneTopologyOperationOutput>status(true)
1613 .withResult(responseBuilder.build())
1616 return Futures.immediateFuture(rpcResult);
1620 responseBuilder.setResponseCode(error.getStatusCode());
1621 responseBuilder.setAckFinalIndicator(ackFinal);
1622 trySetResponseMessage(responseBuilder, error);
1623 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
1624 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
1626 RpcResult<SecurityZoneTopologyOperationOutput> rpcResult = RpcResultBuilder
1627 .<SecurityZoneTopologyOperationOutput>status(true)
1628 .withResult(responseBuilder.build())
1631 return Futures.immediateFuture(rpcResult);
1634 private void trySetResponseMessage(SecurityZoneTopologyOperationOutputBuilder responseBuilder, ErrorObject error) {
1635 if (!error.getMessage().isEmpty()) {
1636 responseBuilder.setResponseMessage(error.getMessage());
1640 private void trySaveService(SecurityZoneTopologyOperationInput input, ServiceBuilder serviceBuilder) {
1641 if (isValidRequest(input) &&
1642 (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Unassign) ||
1643 input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))) {
1644 // Only update operational tree on activate or delete
1645 log.info(UPDATING_TREE_INFO_MESSAGE);
1646 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1650 private void trySetSvcRequestId(SecurityZoneTopologyOperationInput input,
1651 SecurityZoneTopologyOperationOutputBuilder responseBuilder) {
1652 if (input.getSdncRequestHeader() != null) {
1653 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1657 private boolean isInvalidServiceData(ServiceData sd) {
1658 return sd == null || sd.getServiceLevelOperStatus() == null;
1661 private boolean hasInvalidService(SecurityZoneTopologyOperationInput input) {
1662 return input == null || input.getServiceInformation() == null
1663 || input.getServiceInformation().getServiceInstanceId() == null
1664 || input.getServiceInformation().getServiceInstanceId().length() == 0;
1667 private Future<RpcResult<SecurityZoneTopologyOperationOutput>>
1668 buildRpcResultFuture(SecurityZoneTopologyOperationOutputBuilder responseBuilder, String responseMessage) {
1670 responseBuilder.setResponseCode("404");
1671 responseBuilder.setResponseMessage(responseMessage);
1672 responseBuilder.setAckFinalIndicator("Y");
1674 RpcResult<SecurityZoneTopologyOperationOutput> rpcResult = RpcResultBuilder
1675 .<SecurityZoneTopologyOperationOutput>status(true)
1676 .withResult(responseBuilder.build())
1679 return Futures.immediateFuture(rpcResult);
1682 private boolean isValidRequest(SecurityZoneTopologyOperationInput input) {
1683 return input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null;
1687 public Future<RpcResult<TunnelxconnTopologyOperationOutput>> tunnelxconnTopologyOperation(
1688 TunnelxconnTopologyOperationInput input) {
1690 final String svcOperation = "tunnelxconn-topology-operation";
1691 Properties parms = new Properties();
1692 log.info(CALLED_STR, svcOperation);
1694 // create a new response object
1695 TunnelxconnTopologyOperationOutputBuilder responseBuilder = new TunnelxconnTopologyOperationOutputBuilder();
1696 if (hasInvalidService(input)) {
1697 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
1698 responseBuilder.setResponseCode("404");
1699 responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
1700 responseBuilder.setAckFinalIndicator("Y");
1702 RpcResult<TunnelxconnTopologyOperationOutput> rpcResult = RpcResultBuilder
1703 .<TunnelxconnTopologyOperationOutput>status(true)
1704 .withResult(responseBuilder.build())
1707 return Futures.immediateFuture(rpcResult);
1709 String siid = input.getServiceInformation().getServiceInstanceId();
1710 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
1711 TunnelxconnTopologyOperationInputBuilder inputBuilder = new TunnelxconnTopologyOperationInputBuilder(input);
1712 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1714 // Call SLI sync method
1715 // Get SvcLogicService reference
1716 ErrorObject error = new ErrorObject("200", "");
1717 String ackFinal = "Y";
1718 String allottedResourceId = ERROR_NETWORK_ID;
1719 String serviceObjectPath = null;
1720 String tunnelxconnObjectPath = null;
1721 Properties respProps = tryGetProperties(svcOperation, parms, error);
1723 if (respProps != null) {
1724 error.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
1725 error.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
1726 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
1727 allottedResourceId = respProps.getProperty(ALLOTTED_RESOURCE_ID_PARAM);
1728 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
1729 tunnelxconnObjectPath = respProps.getProperty("tunnelxconn-object-path");
1732 if (isValidErrorObject(error)) {
1733 responseBuilder.setResponseCode(error.getStatusCode());
1734 responseBuilder.setResponseMessage(error.getMessage());
1735 responseBuilder.setAckFinalIndicator(ackFinal);
1737 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1739 RpcResult<TunnelxconnTopologyOperationOutput> rpcResult = RpcResultBuilder
1740 .<TunnelxconnTopologyOperationOutput>status(true)
1741 .withResult(responseBuilder.build())
1744 return Futures.immediateFuture(rpcResult);
1747 // Got success from SLI
1749 TunnelxconnResponseInformationBuilder tunnelxconnResponseInformationBuilder = new TunnelxconnResponseInformationBuilder();
1750 tunnelxconnResponseInformationBuilder.setInstanceId(allottedResourceId);
1751 tunnelxconnResponseInformationBuilder.setObjectPath(tunnelxconnObjectPath);
1752 responseBuilder.setTunnelxconnResponseInformation(tunnelxconnResponseInformationBuilder.build());
1754 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1755 serviceResponseInformationBuilder.setInstanceId(siid);
1756 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1757 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1759 } catch (IllegalStateException e) {
1760 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1761 responseBuilder.setResponseCode("500");
1762 responseBuilder.setResponseMessage(e.toString());
1763 responseBuilder.setAckFinalIndicator("Y");
1764 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1766 RpcResult<TunnelxconnTopologyOperationOutput> rpcResult = RpcResultBuilder
1767 .<TunnelxconnTopologyOperationOutput>status(true)
1768 .withResult(responseBuilder.build())
1771 return Futures.immediateFuture(rpcResult);
1775 responseBuilder.setResponseCode(error.getStatusCode());
1776 responseBuilder.setAckFinalIndicator(ackFinal);
1777 trySetResponseMessage(responseBuilder, error);
1778 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
1779 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
1781 RpcResult<TunnelxconnTopologyOperationOutput> rpcResult = RpcResultBuilder
1782 .<TunnelxconnTopologyOperationOutput>status(true)
1783 .withResult(responseBuilder.build())
1786 return Futures.immediateFuture(rpcResult);
1789 private void trySetResponseMessage(TunnelxconnTopologyOperationOutputBuilder responseBuilder, ErrorObject error) {
1790 if (!error.getMessage().isEmpty()) {
1791 responseBuilder.setResponseMessage(error.getMessage());
1795 private boolean hasInvalidService(TunnelxconnTopologyOperationInput input) {
1796 return input == null || input.getServiceInformation() == null
1797 || input.getServiceInformation().getServiceInstanceId() == null
1798 || input.getServiceInformation().getServiceInstanceId().length() == 0;
1801 private Properties tryGetProperties(String svcOperation, Properties parms, ErrorObject error) {
1803 if (svcLogicClient.hasGraph(APP_NAME, svcOperation, null, "sync")) {
1806 return svcLogicClient.execute(APP_NAME, svcOperation, null, "sync", parms);
1807 } catch (Exception e) {
1808 log.error(SERVICE_LOGIC_EXECUTION_ERROR_MESSAGE, svcOperation, e);
1809 error.setMessage(e.getMessage());
1810 error.setStatusCode("500");
1813 error.setMessage(NO_SERVICE_LOGIC_ACTIVE + APP_NAME + ": '" + svcOperation + "'");
1814 error.setStatusCode("503");
1816 } catch (Exception e) {
1817 error.setMessage(e.getMessage());
1818 error.setStatusCode("500");
1819 log.error(SERVICE_LOGIC_SEARCH_ERROR_MESSAGE, e);
1825 public Future<RpcResult<BrgTopologyOperationOutput>> brgTopologyOperation(BrgTopologyOperationInput input) {
1826 final String svcOperation = "brg-topology-operation";
1827 Properties parms = new Properties();
1829 log.info(CALLED_STR, svcOperation);
1830 // create a new response object
1831 BrgTopologyOperationOutputBuilder responseBuilder = new BrgTopologyOperationOutputBuilder();
1833 if (this.hasInvalidService(input)) {
1835 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
1836 responseBuilder.setResponseCode("404");
1837 responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
1838 responseBuilder.setAckFinalIndicator("Y");
1840 RpcResult<BrgTopologyOperationOutput> rpcResult = RpcResultBuilder
1841 .<BrgTopologyOperationOutput>status(true)
1842 .withResult(responseBuilder.build())
1845 return Futures.immediateFuture(rpcResult);
1848 String siid = input.getServiceInformation().getServiceInstanceId();
1850 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
1851 BrgTopologyOperationInputBuilder inputBuilder = new BrgTopologyOperationInputBuilder(input);
1852 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1854 // Call SLI sync method
1855 // Get SvcLogicService reference
1856 ErrorObject error = new ErrorObject("200", "");
1857 String ackFinal = "Y";
1858 String allottedResourceId = ERROR_NETWORK_ID;
1859 String serviceObjectPath = null;
1860 String brgObjectPath = null;
1861 Properties respProps = tryGetProperties(svcOperation, parms, error);
1863 if (respProps != null) {
1864 error.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
1865 error.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
1866 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
1867 allottedResourceId = respProps.getProperty(ALLOTTED_RESOURCE_ID_PARAM);
1868 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
1869 brgObjectPath = respProps.getProperty("brg-object-path");
1872 if (isValidErrorObject(error)) {
1873 responseBuilder.setResponseCode(error.getStatusCode());
1874 responseBuilder.setResponseMessage(error.getMessage());
1875 responseBuilder.setAckFinalIndicator(ackFinal);
1877 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1878 RpcResult<BrgTopologyOperationOutput> rpcResult = RpcResultBuilder
1879 .<BrgTopologyOperationOutput>status(true)
1880 .withResult(responseBuilder.build())
1883 return Futures.immediateFuture(rpcResult);
1886 // Got success from SLI
1889 BrgResponseInformationBuilder brgResponseInformationBuilder = new BrgResponseInformationBuilder();
1890 brgResponseInformationBuilder.setInstanceId(allottedResourceId);
1891 brgResponseInformationBuilder.setObjectPath(brgObjectPath);
1892 responseBuilder.setBrgResponseInformation(brgResponseInformationBuilder.build());
1894 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1895 serviceResponseInformationBuilder.setInstanceId(siid);
1896 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1897 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1899 } catch (IllegalStateException e) {
1900 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1901 responseBuilder.setResponseCode("500");
1902 responseBuilder.setResponseMessage(e.toString());
1903 responseBuilder.setAckFinalIndicator("Y");
1904 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1906 RpcResult<BrgTopologyOperationOutput> rpcResult = RpcResultBuilder
1907 .<BrgTopologyOperationOutput>status(true)
1908 .withResult(responseBuilder.build())
1911 return Futures.immediateFuture(rpcResult);
1915 responseBuilder.setResponseCode(error.getStatusCode());
1916 responseBuilder.setAckFinalIndicator(ackFinal);
1917 trySetResponseMessage(responseBuilder, error);
1918 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
1919 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
1921 RpcResult<BrgTopologyOperationOutput> rpcResult = RpcResultBuilder
1922 .<BrgTopologyOperationOutput>status(true)
1923 .withResult(responseBuilder.build())
1926 return Futures.immediateFuture(rpcResult);
1929 private void trySetResponseMessage(BrgTopologyOperationOutputBuilder responseBuilder, ErrorObject error) {
1930 if (!error.getMessage().isEmpty()) {
1931 responseBuilder.setResponseMessage(error.getMessage());
1935 private boolean hasInvalidService(BrgTopologyOperationInput input) {
1936 return input == null || input.getServiceInformation() == null
1937 || input.getServiceInformation().getServiceInstanceId() == null
1938 || input.getServiceInformation().getServiceInstanceId().length() == 0;
1942 public Future<RpcResult<PreloadVnfTopologyOperationOutput>> preloadVnfTopologyOperation(
1943 PreloadVnfTopologyOperationInput input) {
1945 final String svcOperation = "preload-vnf-topology-operation";
1946 Properties parms = new Properties();
1948 log.info(CALLED_STR, svcOperation);
1949 // create a new response object
1950 PreloadVnfTopologyOperationOutputBuilder responseBuilder = new PreloadVnfTopologyOperationOutputBuilder();
1952 if (hasInvalidVnfTopology(input)) {
1954 log.debug("exiting {} because of null input", svcOperation);
1955 responseBuilder.setResponseCode("403");
1956 responseBuilder.setResponseMessage("invalid input: input is null");
1957 responseBuilder.setAckFinalIndicator("Y");
1959 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult = RpcResultBuilder
1960 .<PreloadVnfTopologyOperationOutput>status(true)
1961 .withResult(responseBuilder.build())
1964 return Futures.immediateFuture(rpcResult);
1967 // Grab the name and type from the input buffer
1968 String preloadName = input.getVnfTopologyInformation().getVnfTopologyIdentifier().getVnfName();
1969 String preloadType = input.getVnfTopologyInformation().getVnfTopologyIdentifier().getVnfType();
1971 // Make sure we have a preload_name and preload_type
1972 if (isValidPreloadData(preloadName, preloadType)) {
1973 log.debug("exiting {} vnf-name or vnf-type is null or empty", svcOperation);
1974 responseBuilder.setResponseCode("403");
1975 responseBuilder.setResponseMessage("invalid input: vnf-name or vnf-type is null or empty");
1976 responseBuilder.setAckFinalIndicator("Y");
1978 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult = RpcResultBuilder
1979 .<PreloadVnfTopologyOperationOutput>status(true)
1980 .withResult(responseBuilder.build())
1983 return Futures.immediateFuture(rpcResult);
1986 this.trySetSvcRequestId(input, responseBuilder);
1988 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
1989 getPreloadData(preloadName, preloadType, preloadDataBuilder);
1991 PreloadDataBuilder operDataBuilder = new PreloadDataBuilder();
1992 getPreloadData(preloadName, preloadType, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
1994 // setup a preload-data object builder
1995 // ACTION preload-vnf-topology-operation
1997 // USES sdnc-request-header;
1998 // USES request-information;
1999 // uses vnf-topology-information;
2001 // USES vnf-topology-response-body;
2003 // container preload-data
2004 // uses vnf-topology-information;
2005 // uses network-topology-information;
2006 // uses oper-status;
2008 log.info("Adding INPUT data for {} [{},{}] input: {}", svcOperation, preloadName, preloadType, input);
2009 PreloadVnfTopologyOperationInputBuilder inputBuilder = new PreloadVnfTopologyOperationInputBuilder(input);
2010 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
2011 log.info("Adding OPERATIONAL data for {} [{},{}] operational-data: {}", svcOperation, preloadName,
2012 preloadType, operDataBuilder.build());
2013 GenericResourceApiUtil.toProperties(parms, OPERATIONAL_DATA_PARAM, operDataBuilder);
2015 // Call SLI sync method
2016 // Get SvcLogicService reference
2017 ErrorObject error = new ErrorObject("200", "");
2018 Properties respProps = tryGetProperties(svcOperation, parms, error);
2019 String ackFinal = resolveAckFinal(error, respProps);
2021 if (isValidErrorObject(error)) {
2023 responseBuilder.setResponseCode(error.getStatusCode());
2024 responseBuilder.setResponseMessage(error.getMessage());
2025 responseBuilder.setAckFinalIndicator(ackFinal);
2027 VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
2028 preloadVnfListBuilder.setVnfName(preloadName);
2029 preloadVnfListBuilder.setVnfType(preloadType);
2030 preloadVnfListBuilder.setPreloadData(preloadDataBuilder.build());
2031 log.error("Returned FAILED for {} [{},{}] error code: '{}', Reason: '{}'", svcOperation, preloadName,
2032 preloadType, error.getStatusCode(), error.getMessage());
2034 savePreloadList(preloadVnfListBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
2035 } catch (Exception e) {
2036 log.error(UPDATING_MDSAL_ERROR_MESSAGE_2, svcOperation, preloadName,
2039 log.debug("Sending Success rpc result due to external error");
2041 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult = RpcResultBuilder
2042 .<PreloadVnfTopologyOperationOutput>status(true)
2043 .withResult(responseBuilder.build())
2046 return Futures.immediateFuture(rpcResult);
2049 // Got success from SLI
2051 updatePreloadData(svcOperation, preloadName, preloadType, preloadDataBuilder);
2052 } catch (Exception e) {
2053 log.error(UPDATING_MDSAL_ERROR_MESSAGE_2, svcOperation, preloadName, preloadType,
2055 responseBuilder.setResponseCode("500");
2056 responseBuilder.setResponseMessage(e.toString());
2057 responseBuilder.setAckFinalIndicator("Y");
2058 log.error("Returned FAILED for {} [{},{}] {}", svcOperation, preloadName, preloadType,
2059 responseBuilder.build());
2061 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult = RpcResultBuilder
2062 .<PreloadVnfTopologyOperationOutput>status(false)
2063 .withResult(responseBuilder.build())
2066 return Futures.immediateFuture(rpcResult);
2070 responseBuilder.setResponseCode(error.getStatusCode());
2071 responseBuilder.setAckFinalIndicator(ackFinal);
2072 trySetResponseMessage(responseBuilder, error);
2074 log.info("Updated MD-SAL for {} [{},{}]", svcOperation, preloadName, preloadType);
2075 log.info("Returned SUCCESS for {} [{},{}] {}", svcOperation, preloadName, preloadType,
2076 responseBuilder.build());
2078 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult = RpcResultBuilder
2079 .<PreloadVnfTopologyOperationOutput>status(true)
2080 .withResult(responseBuilder.build())
2083 return Futures.immediateFuture(rpcResult);
2086 private String resolveAckFinal(ErrorObject error, Properties respProps) {
2087 if (respProps != null) {
2088 error.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
2089 error.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
2090 return respProps.getProperty(ACK_FINAL_PARAM, "Y");
2095 private void trySetResponseMessage(PreloadVnfTopologyOperationOutputBuilder responseBuilder, ErrorObject error) {
2096 if (!error.getMessage().isEmpty()) {
2097 responseBuilder.setResponseMessage(error.getMessage());
2101 private void trySetSvcRequestId(PreloadVnfTopologyOperationInput input,
2102 PreloadVnfTopologyOperationOutputBuilder responseBuilder) {
2103 if (input.getSdncRequestHeader() != null) {
2104 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
2108 private boolean hasInvalidVnfTopology(PreloadVnfTopologyOperationInput input) {
2109 return input == null || input.getVnfTopologyInformation() == null
2110 || input.getVnfTopologyInformation().getVnfTopologyIdentifier() == null;
2113 private void updatePreloadData(String svcOperation, String preloadName, String preloadType,
2114 PreloadDataBuilder preloadDataBuilder) {
2115 PreloadData preloadData;
2116 preloadData = preloadDataBuilder.build();
2117 log.info("Updating MD-SAL for {} [{},{}] preloadData: {}", svcOperation, preloadName, preloadType,
2119 // svc-configuration-list
2120 VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
2121 preloadVnfListBuilder.setVnfName(preloadName);
2122 preloadVnfListBuilder.setVnfType(preloadType);
2123 preloadVnfListBuilder.setPreloadData(preloadData);
2125 // merge flag sets to false to allow it to be overwritten (not appended)
2126 savePreloadList(preloadVnfListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
2127 log.info(UPDATING_TREE_INFO_MESSAGE);
2128 savePreloadList(preloadVnfListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
2132 public Future<RpcResult<PreloadNetworkTopologyOperationOutput>> preloadNetworkTopologyOperation(
2133 PreloadNetworkTopologyOperationInput input) {
2135 final String svcOperation = "preload-network-topology-operation";
2136 Properties parms = new Properties();
2138 log.info(CALLED_STR, svcOperation);
2139 // create a new response object
2140 PreloadNetworkTopologyOperationOutputBuilder responseBuilder = new PreloadNetworkTopologyOperationOutputBuilder();
2142 if (hasInvalidNetworkTopology(input)) {
2144 log.debug("exiting {} because of null input", svcOperation);
2145 responseBuilder.setResponseCode("403");
2146 responseBuilder.setResponseMessage("input is null");
2147 responseBuilder.setAckFinalIndicator("Y");
2149 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
2150 .<PreloadNetworkTopologyOperationOutput>status(true)
2151 .withResult(responseBuilder.build())
2154 return Futures.immediateFuture(rpcResult);
2157 // Grab the name and type from the input buffer
2158 String preloadName = input.getNetworkTopologyInformation().getNetworkTopologyIdentifier().getNetworkName();
2159 String preloadType = input.getNetworkTopologyInformation().getNetworkTopologyIdentifier().getNetworkType();
2161 // Make sure we have a preload_name and preload_type
2162 if (isValidPreloadData(preloadName, preloadType)) {
2163 log.debug("exiting {} because of invalid preload-name", svcOperation);
2164 responseBuilder.setResponseCode("403");
2165 responseBuilder.setResponseMessage("input, invalid preload-name");
2166 responseBuilder.setAckFinalIndicator("Y");
2168 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
2169 .<PreloadNetworkTopologyOperationOutput>status(true)
2170 .withResult(responseBuilder.build())
2173 return Futures.immediateFuture(rpcResult);
2176 trySetSvcRequestId(input, responseBuilder);
2178 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
2179 getPreloadData(preloadName, preloadType, preloadDataBuilder);
2181 PreloadDataBuilder operDataBuilder = new PreloadDataBuilder();
2182 getPreloadData(preloadName, preloadType, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
2185 // setup a preload-data object builder
2186 // ACTION preload-network-topology-operation
2188 // USES sdnc-request-header;
2189 // USES request-information;
2190 // uses network-topology-information;
2192 // USES vnf-topology-response-body;
2194 // container preload-data
2195 // uses vnf-topology-information;
2196 // uses network-topology-information;
2197 // uses oper-status;
2199 log.info("Adding INPUT data for {} [{},{}] input: {}", svcOperation, preloadName, preloadType, input);
2200 PreloadNetworkTopologyOperationInputBuilder inputBuilder = new PreloadNetworkTopologyOperationInputBuilder(
2202 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
2203 log.info("Adding OPERATIONAL data for {} [{},{}] operational-data: {}", svcOperation, preloadName,
2204 preloadType, operDataBuilder.build());
2205 GenericResourceApiUtil.toProperties(parms, OPERATIONAL_DATA_PARAM, operDataBuilder);
2207 // Call SLI sync method
2208 // Get SvcLogicService reference
2209 ErrorObject error = new ErrorObject("200", "");
2210 Properties respProps = tryGetProperties(svcOperation, parms, error);
2212 String ackFinal = resolveAckFinal(error, respProps);
2214 if (isValidErrorObject(error)) {
2216 responseBuilder.setResponseCode(error.getStatusCode());
2217 responseBuilder.setResponseMessage(error.getMessage());
2218 responseBuilder.setAckFinalIndicator(ackFinal);
2220 VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
2221 preloadVnfListBuilder.setVnfName(preloadName);
2222 preloadVnfListBuilder.setVnfType(preloadType);
2223 preloadVnfListBuilder.setPreloadData(preloadDataBuilder.build());
2224 log.error("Returned FAILED for {} [{},{}] error code: '{}', Reason: '{}'", svcOperation, preloadName,
2225 preloadType, error.getStatusCode(), error.getMessage());
2227 savePreloadList(preloadVnfListBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
2228 } catch (Exception e) {
2229 log.error(UPDATING_MDSAL_ERROR_MESSAGE_2, svcOperation, preloadName,
2233 log.debug("Sending Success rpc result due to external error");
2235 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
2236 .<PreloadNetworkTopologyOperationOutput>status(true)
2237 .withResult(responseBuilder.build())
2240 return Futures.immediateFuture(rpcResult);
2243 // Got success from SLI
2245 updatePreloadData(svcOperation, preloadName, preloadType, preloadDataBuilder);
2246 } catch (Exception e) {
2247 log.error(UPDATING_MDSAL_ERROR_MESSAGE_2, svcOperation, preloadName, preloadType, e);
2248 responseBuilder.setResponseCode("500");
2249 responseBuilder.setResponseMessage(e.toString());
2250 responseBuilder.setAckFinalIndicator("Y");
2251 log.error("Returned FAILED for {} [{},{}] {}", svcOperation, preloadName, preloadType,
2252 responseBuilder.build());
2254 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
2255 .<PreloadNetworkTopologyOperationOutput>status(false)
2256 .withResult(responseBuilder.build())
2259 return Futures.immediateFuture(rpcResult);
2263 responseBuilder.setResponseCode(error.getStatusCode());
2264 responseBuilder.setAckFinalIndicator(ackFinal);
2265 trySetResponseMessage(responseBuilder, error);
2267 log.info("Updated MD-SAL for {} [{},{}]", svcOperation, preloadName, preloadType);
2268 log.info("Returned SUCCESS for {} [{},{}] {}", svcOperation, preloadName, preloadType,
2269 responseBuilder.build());
2271 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
2272 .<PreloadNetworkTopologyOperationOutput>status(true)
2273 .withResult(responseBuilder.build())
2276 return Futures.immediateFuture(rpcResult);
2279 private void trySetResponseMessage(PreloadNetworkTopologyOperationOutputBuilder responseBuilder,
2280 ErrorObject error) {
2281 if (!error.getMessage().isEmpty()) {
2282 responseBuilder.setResponseMessage(error.getMessage());
2286 private void trySetSvcRequestId(PreloadNetworkTopologyOperationInput input,
2287 PreloadNetworkTopologyOperationOutputBuilder responseBuilder) {
2288 if (input.getSdncRequestHeader() != null) {
2289 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
2293 private boolean isValidPreloadData(String preloadName, String preloadType) {
2294 return preloadName == null || preloadName.length() == 0 || preloadType == null || preloadType.length() == 0;
2297 private boolean hasInvalidNetworkTopology(PreloadNetworkTopologyOperationInput input) {
2298 return input == null || input.getNetworkTopologyInformation() == null
2299 || input.getNetworkTopologyInformation().getNetworkTopologyIdentifier() == null;