1 package org.onap.sdnc.northbound;
3 import com.google.common.base.Optional;
4 import com.google.common.util.concurrent.CheckedFuture;
5 import com.google.common.util.concurrent.Futures;
6 import java.text.DateFormat;
7 import java.text.SimpleDateFormat;
9 import java.util.Properties;
10 import java.util.TimeZone;
11 import java.util.concurrent.ExecutionException;
12 import java.util.concurrent.ExecutorService;
13 import java.util.concurrent.Executors;
14 import java.util.concurrent.Future;
15 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
16 import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
17 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
18 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
19 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
20 import org.opendaylight.controller.md.sal.common.api.data.OptimisticLockFailedException;
21 import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
22 import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
23 import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
24 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.BrgTopologyOperationInput;
25 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.BrgTopologyOperationInputBuilder;
26 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.BrgTopologyOperationOutput;
27 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.BrgTopologyOperationOutputBuilder;
28 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ConnectionAttachmentTopologyOperationInput;
29 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ConnectionAttachmentTopologyOperationOutput;
30 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ContrailRouteTopologyOperationInput;
31 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ContrailRouteTopologyOperationInputBuilder;
32 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ContrailRouteTopologyOperationOutput;
33 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ContrailRouteTopologyOperationOutputBuilder;
34 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.GENERICRESOURCEAPIService;
35 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.NetworkTopologyOperationInput;
36 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.NetworkTopologyOperationInputBuilder;
37 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.NetworkTopologyOperationOutput;
38 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.NetworkTopologyOperationOutputBuilder;
39 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadNetworkTopologyOperationInput;
40 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadNetworkTopologyOperationInputBuilder;
41 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadNetworkTopologyOperationOutput;
42 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadNetworkTopologyOperationOutputBuilder;
43 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadVnfTopologyOperationInput;
44 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadVnfTopologyOperationInputBuilder;
45 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadVnfTopologyOperationOutput;
46 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadVnfTopologyOperationOutputBuilder;
47 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadVnfs;
48 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadVnfsBuilder;
49 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.SecurityZoneTopologyOperationInput;
50 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.SecurityZoneTopologyOperationInputBuilder;
51 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.SecurityZoneTopologyOperationOutput;
52 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.SecurityZoneTopologyOperationOutputBuilder;
53 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ServiceTopologyOperationInput;
54 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ServiceTopologyOperationInputBuilder;
55 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ServiceTopologyOperationOutput;
56 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ServiceTopologyOperationOutputBuilder;
57 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.Services;
58 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ServicesBuilder;
59 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.TunnelxconnTopologyOperationInput;
60 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.TunnelxconnTopologyOperationInputBuilder;
61 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.TunnelxconnTopologyOperationOutput;
62 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.TunnelxconnTopologyOperationOutputBuilder;
63 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.VfModuleTopologyOperationInput;
64 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.VfModuleTopologyOperationInputBuilder;
65 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.VfModuleTopologyOperationOutput;
66 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.VfModuleTopologyOperationOutputBuilder;
67 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.VnfTopologyOperationInput;
68 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.VnfTopologyOperationInputBuilder;
69 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.VnfTopologyOperationOutput;
70 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.VnfTopologyOperationOutputBuilder;
71 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.brg.response.information.BrgResponseInformationBuilder;
72 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.contrail.route.response.information.ContrailRouteResponseInformationBuilder;
73 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.network.response.information.NetworkResponseInformationBuilder;
74 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.preload.data.PreloadData;
75 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.preload.data.PreloadDataBuilder;
76 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.preload.model.information.VnfPreloadList;
77 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.preload.model.information.VnfPreloadListBuilder;
78 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.preload.model.information.VnfPreloadListKey;
79 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.request.information.RequestInformation;
80 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.sdnc.request.header.SdncRequestHeader;
81 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.sdnc.request.header.SdncRequestHeader.SvcAction;
82 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.security.zone.response.information.SecurityZoneResponseInformationBuilder;
83 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.data.ServiceData;
84 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.data.ServiceDataBuilder;
85 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.model.infrastructure.Service;
86 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.model.infrastructure.ServiceBuilder;
87 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.model.infrastructure.ServiceKey;
88 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.response.information.ServiceResponseInformationBuilder;
89 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.status.ServiceStatus.RequestStatus;
90 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.status.ServiceStatus.RpcAction;
91 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.status.ServiceStatusBuilder;
92 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.tunnelxconn.response.information.TunnelxconnResponseInformationBuilder;
93 import org.opendaylight.yangtools.yang.binding.DataObject;
94 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
95 import org.opendaylight.yangtools.yang.common.RpcResult;
96 import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
97 import org.slf4j.Logger;
98 import org.slf4j.LoggerFactory;
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 protected 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 protected 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 protected 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 protected 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 (hasInvalidServiceId(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 ResponseObject responseObject = new ResponseObject("200", "");
552 String ackFinal = "Y";
553 String serviceObjectPath = null;
554 Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, responseObject);
556 if (respProps != null) {
557 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
558 responseObject.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, responseObject.getStatusCode(), responseObject.getMessage(), ackFinal);
564 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
565 serviceStatusBuilder.setRpcName(svcOperation);
567 if (failed(responseObject)) {
568 responseBuilder.setResponseCode(responseObject.getStatusCode());
569 responseBuilder.setResponseMessage(responseObject.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.getMessage());
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(responseObject.getStatusCode());
626 responseBuilder.setAckFinalIndicator(ackFinal);
627 trySetResponseMessage(responseBuilder, responseObject);
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, ResponseObject error) {
640 if (!error.getMessage().isEmpty()) {
641 responseBuilder.setResponseMessage(error.getMessage());
645 private boolean hasInvalidServiceId(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,
668 ResponseObject responseObject) {
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 responseObject.setMessage(e.getMessage());
676 responseObject.setStatusCode("500");
679 responseObject.setMessage(NO_SERVICE_LOGIC_ACTIVE + APP_NAME + ": '" + svcOperation + "'");
680 responseObject.setStatusCode("503");
682 } catch (Exception e) {
683 responseObject.setMessage(e.getMessage());
684 responseObject.setStatusCode("500");
685 log.error(SERVICE_LOGIC_SEARCH_ERROR_MESSAGE, e);
691 private boolean failed(ResponseObject 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 properties = new Properties();
709 log.info(CALLED_STR, svcOperation);
710 // create a new response object
711 VnfTopologyOperationOutputBuilder responseBuilder = new VnfTopologyOperationOutputBuilder();
713 if (hasInvalidServiceId(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 (hasInvalidVnfId(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(properties, inputBuilder.build());
775 log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid,
776 operDataBuilder.build());
777 GenericResourceApiUtil.toProperties(properties, OPERATIONAL_DATA_PARAM, operDataBuilder);
779 // Call SLI sync method
780 // Get SvcLogicService reference
782 ResponseObject responseObject = new ResponseObject("200", "");
783 String ackFinal = "Y";
784 String serviceObjectPath = null;
785 Properties respProps = tryGetProperties(svcOperation, properties, serviceDataBuilder, responseObject);
787 if (respProps != null) {
788 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
789 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
790 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
793 /*before was "vfn-object-path", but it didn't make sense, since everywhere else,
794 when extracting service object path the "service-object-path" property is used*/
795 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
798 setServiceStatus(serviceStatusBuilder, responseObject.getStatusCode(), responseObject.getMessage(), ackFinal);
799 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
800 serviceStatusBuilder.setRpcName(svcOperation);
802 if (failed(responseObject)) {
803 responseBuilder.setResponseCode(responseObject.getStatusCode());
804 responseBuilder.setResponseMessage(responseObject.getMessage());
805 responseBuilder.setAckFinalIndicator(ackFinal);
807 ServiceBuilder serviceBuilder = new ServiceBuilder();
808 serviceBuilder.setServiceInstanceId(siid);
809 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
811 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
812 trySaveService(input, serviceBuilder);
813 } catch (Exception e) {
814 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
816 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
818 RpcResult<VnfTopologyOperationOutput> rpcResult = RpcResultBuilder
819 .<VnfTopologyOperationOutput>status(true)
820 .withResult(responseBuilder.build())
824 return Futures.immediateFuture(rpcResult);
827 // Got success from SLI
829 serviceData = serviceDataBuilder.build();
830 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
833 ServiceBuilder serviceBuilder = new ServiceBuilder();
834 serviceBuilder.setServiceData(serviceData);
835 serviceBuilder.setServiceInstanceId(siid);
836 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
837 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
839 if (isValidRequest(input) && input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate)) {
840 // Only update operational tree on Assign
842 log.info(UPDATING_TREE_INFO_MESSAGE);
843 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
846 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
847 serviceResponseInformationBuilder.setInstanceId(siid);
848 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
849 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
851 } catch (Exception e) {
852 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
853 responseBuilder.setResponseCode("500");
854 responseBuilder.setResponseMessage(e.getMessage());
855 responseBuilder.setAckFinalIndicator("Y");
856 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
858 RpcResult<VnfTopologyOperationOutput> rpcResult = RpcResultBuilder
859 .<VnfTopologyOperationOutput>status(true)
860 .withResult(responseBuilder.build())
863 return Futures.immediateFuture(rpcResult);
867 responseBuilder.setResponseCode(responseObject.getStatusCode());
868 responseBuilder.setAckFinalIndicator(ackFinal);
869 trySetResponseMessage(responseBuilder, responseObject);
870 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
871 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
873 RpcResult<VnfTopologyOperationOutput> rpcResult = RpcResultBuilder
874 .<VnfTopologyOperationOutput>status(true)
875 .withResult(responseBuilder.build())
879 return Futures.immediateFuture(rpcResult);
882 private void trySetResponseMessage(VnfTopologyOperationOutputBuilder responseBuilder, ResponseObject error) {
883 if (!error.getMessage().isEmpty()) {
884 responseBuilder.setResponseMessage(error.getMessage());
888 private void trySaveService(VnfTopologyOperationInput input, ServiceBuilder serviceBuilder) {
889 if (isValidRequest(input) &&
890 (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete) ||
891 input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))) {
893 // Only update operational tree on activate or delete
894 log.info(UPDATING_TREE_INFO_MESSAGE);
895 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
899 private boolean hasInvalidVnfId(VnfTopologyOperationInput input) {
900 return input.getVnfInformation() == null || input.getVnfInformation().getVnfId() == null
901 || input.getVnfInformation().getVnfId().length() == 0;
904 private boolean hasInvalidServiceId(VnfTopologyOperationInput input) {
905 return input == null || input.getServiceInformation() == null
906 || input.getServiceInformation().getServiceInstanceId() == null
907 || input.getServiceInformation().getServiceInstanceId().length() == 0;
910 private void trySetSvcRequestId(VnfTopologyOperationInput input,
911 VnfTopologyOperationOutputBuilder responseBuilder) {
912 if (input.getSdncRequestHeader() != null) {
913 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
917 private boolean isValidRequest(VnfTopologyOperationInput input) {
918 return input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null;
922 public Future<RpcResult<VfModuleTopologyOperationOutput>> vfModuleTopologyOperation(
923 VfModuleTopologyOperationInput input) {
925 final String svcOperation = "vf-module-topology-operation";
926 ServiceData serviceData;
927 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
928 Properties parms = new Properties();
930 log.info(CALLED_STR, svcOperation);
931 // create a new response object
932 VfModuleTopologyOperationOutputBuilder responseBuilder = new VfModuleTopologyOperationOutputBuilder();
934 if (hasInvalidServiceId(input)) {
935 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
936 responseBuilder.setResponseCode("403");
937 responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
938 responseBuilder.setAckFinalIndicator("Y");
940 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
941 .<VfModuleTopologyOperationOutput>status(true)
942 .withResult(responseBuilder.build())
946 return Futures.immediateFuture(rpcResult);
949 if (hasInvalidVnfId(input)) {
950 log.debug("exiting {} because of null or empty vnf-id", svcOperation);
951 responseBuilder.setResponseCode("403");
952 responseBuilder.setResponseMessage("invalid input, null or empty vnf-id");
953 responseBuilder.setAckFinalIndicator("Y");
954 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
955 .<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
956 return Futures.immediateFuture(rpcResult);
959 if (hasInvalidVfModuleId(input)) {
960 log.debug("exiting {} because of null or empty vf-module-id", svcOperation);
961 responseBuilder.setResponseCode("403");
962 responseBuilder.setResponseMessage("invalid input, vf-module-id is null or empty");
963 responseBuilder.setAckFinalIndicator("Y");
965 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
966 .<VfModuleTopologyOperationOutput>status(true)
967 .withResult(responseBuilder.build())
970 return Futures.immediateFuture(rpcResult);
973 // Grab the service instance ID from the input buffer
974 String siid = input.getServiceInformation().getServiceInstanceId();
976 trySetSvcRequestId(input, responseBuilder);
978 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
979 getServiceData(siid, serviceDataBuilder);
981 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
982 getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
984 // Set the serviceStatus based on input
985 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
986 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
989 // setup a service-data object builder
990 // ACTION vnf-topology-operation
992 // USES sdnc-request-header;
993 // USES request-information;
994 // USES service-information;
995 // USES vnf-request-information
997 // USES vnf-topology-response-body;
998 // USES vnf-information
999 // USES service-information
1001 // container service-data
1002 // uses vnf-configuration-information;
1003 // uses oper-status;
1005 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
1006 VfModuleTopologyOperationInputBuilder inputBuilder = new VfModuleTopologyOperationInputBuilder(input);
1007 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1009 log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid,
1010 operDataBuilder.build());
1011 GenericResourceApiUtil.toProperties(parms, OPERATIONAL_DATA_PARAM, operDataBuilder);
1013 // Call SLI sync method
1014 // Get SvcLogicService reference
1016 ResponseObject responseObject = new ResponseObject("200", "");
1017 String ackFinal = "Y";
1018 String serviceObjectPath = null;
1019 Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, responseObject);
1021 if (respProps != null) {
1022 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
1023 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
1024 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
1028 /*before was "vf-module-object-path", but it didnt make sense, since everywhere else,
1029 when extracting service object path the "service-object-path" property is used*/
1030 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
1033 setServiceStatus(serviceStatusBuilder, responseObject.getStatusCode(), responseObject.getMessage(), ackFinal);
1034 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
1035 serviceStatusBuilder.setRpcName(svcOperation);
1037 if (failed(responseObject)) {
1038 responseBuilder.setResponseCode(responseObject.getStatusCode());
1039 responseBuilder.setResponseMessage(responseObject.getMessage());
1040 responseBuilder.setAckFinalIndicator(ackFinal);
1042 ServiceBuilder serviceBuilder = new ServiceBuilder();
1043 serviceBuilder.setServiceInstanceId(siid);
1044 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1046 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
1047 } catch (Exception e) {
1048 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1050 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1052 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
1053 .<VfModuleTopologyOperationOutput>status(true)
1054 .withResult(responseBuilder.build())
1058 return Futures.immediateFuture(rpcResult);
1061 // Got success from SLI
1063 serviceData = serviceDataBuilder.build();
1064 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
1067 ServiceBuilder serviceBuilder = new ServiceBuilder();
1068 serviceBuilder.setServiceData(serviceData);
1069 serviceBuilder.setServiceInstanceId(siid);
1070 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1071 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1073 trySaveService(input, serviceBuilder);
1075 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1076 serviceResponseInformationBuilder.setInstanceId(siid);
1077 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1078 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1080 } catch (Exception e) {
1081 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1082 responseBuilder.setResponseCode("500");
1083 responseBuilder.setResponseMessage(e.getMessage());
1084 responseBuilder.setAckFinalIndicator("Y");
1085 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1087 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
1088 .<VfModuleTopologyOperationOutput>status(true)
1089 .withResult(responseBuilder.build())
1092 return Futures.immediateFuture(rpcResult);
1096 responseBuilder.setResponseCode(responseObject.getStatusCode());
1097 responseBuilder.setAckFinalIndicator(ackFinal);
1098 trySetResponseMessage(responseBuilder, responseObject);
1099 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
1100 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
1102 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
1103 .<VfModuleTopologyOperationOutput>status(true)
1104 .withResult(responseBuilder.build())
1108 return Futures.immediateFuture(rpcResult);
1111 private void trySetResponseMessage(VfModuleTopologyOperationOutputBuilder responseBuilder, ResponseObject error) {
1112 if (!error.getMessage().isEmpty()) {
1113 responseBuilder.setResponseMessage(error.getMessage());
1117 private void trySaveService(VfModuleTopologyOperationInput input, ServiceBuilder serviceBuilder) {
1118 if (isValidRequest(input) &&
1119 (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Unassign) ||
1120 input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))) {
1121 // Only update operational tree on activate or delete
1123 log.info(UPDATING_TREE_INFO_MESSAGE);
1124 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1128 private void trySetSvcRequestId(VfModuleTopologyOperationInput input,
1129 VfModuleTopologyOperationOutputBuilder responseBuilder) {
1130 if (input.getSdncRequestHeader() != null) {
1131 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1135 private boolean hasInvalidVfModuleId(VfModuleTopologyOperationInput input) {
1136 return input.getVfModuleInformation() == null || input.getVfModuleInformation().getVfModuleId() == null
1137 || input.getVfModuleInformation().getVfModuleId().length() == 0;
1140 private boolean hasInvalidVnfId(VfModuleTopologyOperationInput input) {
1141 return input.getVnfInformation() == null || input.getVnfInformation().getVnfId() == null
1142 || input.getVnfInformation().getVnfId().length() == 0;
1145 private boolean hasInvalidServiceId(VfModuleTopologyOperationInput input) {
1146 return input == null || input.getServiceInformation() == null
1147 || input.getServiceInformation().getServiceInstanceId() == null
1148 || input.getServiceInformation().getServiceInstanceId().length() == 0;
1151 private boolean isValidRequest(VfModuleTopologyOperationInput input) {
1152 return input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null;
1156 public Future<RpcResult<NetworkTopologyOperationOutput>> networkTopologyOperation(
1157 NetworkTopologyOperationInput input) {
1159 final String svcOperation = "network-topology-operation";
1160 ServiceData serviceData;
1161 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1162 Properties parms = new Properties();
1164 log.info(CALLED_STR, svcOperation);
1165 // create a new response object
1166 NetworkTopologyOperationOutputBuilder responseBuilder = new NetworkTopologyOperationOutputBuilder();
1168 if (hasInvalidServiceId(input)) {
1169 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
1170 return buildRpcResultFuture(responseBuilder, NULL_OR_EMPTY_ERROR_PARAM);
1173 String siid = input.getServiceInformation().getServiceInstanceId();
1175 // Get the service-instance service data from MD-SAL
1176 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1177 getServiceData(siid, serviceDataBuilder);
1179 this.trySetSvcRequestId(input, responseBuilder);
1181 ServiceData sd = serviceDataBuilder.build();
1182 if (isInvalidServiceData(sd)) {
1183 log.debug(EMPTY_SERVICE_INSTANCE_MESSAGE, svcOperation);
1184 return buildRpcResultFuture(responseBuilder, INVALID_INPUT_ERROR_MESSAGE);
1187 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
1188 NetworkTopologyOperationInputBuilder inputBuilder = new NetworkTopologyOperationInputBuilder(input);
1189 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1191 // Call SLI sync method
1192 // Get SvcLogicService reference
1194 ResponseObject responseObject = new ResponseObject("200", "");
1195 String ackFinal = "Y";
1196 String networkId = ERROR_NETWORK_ID;
1197 String serviceObjectPath = null;
1198 String networkObjectPath = null;
1199 Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, responseObject);
1201 if (respProps != null) {
1202 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
1203 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
1204 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
1205 networkId = respProps.getProperty("networkId");
1206 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
1207 networkObjectPath = respProps.getProperty("network-object-path");
1210 if (failed(responseObject)) {
1211 responseBuilder.setResponseCode(responseObject.getStatusCode());
1212 responseBuilder.setResponseMessage(responseObject.getMessage());
1213 responseBuilder.setAckFinalIndicator(ackFinal);
1215 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1217 RpcResult<NetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
1218 .<NetworkTopologyOperationOutput>status(true)
1219 .withResult(responseBuilder.build())
1222 return Futures.immediateFuture(rpcResult);
1225 // Got success from SLI
1228 serviceData = serviceDataBuilder.build();
1229 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
1232 ServiceBuilder serviceBuilder = new ServiceBuilder();
1233 serviceBuilder.setServiceData(serviceData);
1234 serviceBuilder.setServiceInstanceId(siid);
1235 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1236 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1238 trySaveService(input, serviceBuilder);
1240 NetworkResponseInformationBuilder networkResponseInformationBuilder = new NetworkResponseInformationBuilder();
1241 networkResponseInformationBuilder.setInstanceId(networkId);
1242 networkResponseInformationBuilder.setObjectPath(networkObjectPath);
1243 responseBuilder.setNetworkResponseInformation(networkResponseInformationBuilder.build());
1245 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1246 serviceResponseInformationBuilder.setInstanceId(siid);
1247 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1248 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1250 } catch (IllegalStateException e) {
1251 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1252 responseBuilder.setResponseCode("500");
1253 responseBuilder.setResponseMessage(e.getMessage());
1254 responseBuilder.setAckFinalIndicator("Y");
1255 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1257 RpcResult<NetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
1258 .<NetworkTopologyOperationOutput>status(true)
1259 .withResult(responseBuilder.build())
1262 return Futures.immediateFuture(rpcResult);
1266 responseBuilder.setResponseCode(responseObject.getStatusCode());
1267 responseBuilder.setAckFinalIndicator(ackFinal);
1268 trySetResponseMessage(responseBuilder, responseObject);
1269 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
1270 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
1272 RpcResult<NetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
1273 .<NetworkTopologyOperationOutput>status(true)
1274 .withResult(responseBuilder.build())
1277 return Futures.immediateFuture(rpcResult);
1280 private void trySetResponseMessage(NetworkTopologyOperationOutputBuilder responseBuilder, ResponseObject error) {
1281 if (!error.getMessage().isEmpty()) {
1282 responseBuilder.setResponseMessage(error.getMessage());
1286 private void trySetSvcRequestId(NetworkTopologyOperationInput input,
1287 NetworkTopologyOperationOutputBuilder responseBuilder) {
1288 if (input.getSdncRequestHeader() != null) {
1289 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1293 private void trySaveService(NetworkTopologyOperationInput input, ServiceBuilder serviceBuilder) {
1294 if (isValidRequest(input) &&
1295 (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate) ||
1296 input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Create))) {
1297 // Only update operational tree on Activate
1298 log.info(UPDATING_TREE_INFO_MESSAGE);
1299 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1303 private boolean hasInvalidServiceId(NetworkTopologyOperationInput input) {
1304 return input == null || input.getServiceInformation() == null
1305 || input.getServiceInformation().getServiceInstanceId() == null
1306 || input.getServiceInformation().getServiceInstanceId().length() == 0;
1309 private Future<RpcResult<NetworkTopologyOperationOutput>> buildRpcResultFuture(
1310 NetworkTopologyOperationOutputBuilder responseBuilder, String responseMessage) {
1312 responseBuilder.setResponseCode("404");
1314 .setResponseMessage(responseMessage);
1315 responseBuilder.setAckFinalIndicator("Y");
1317 RpcResult<NetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
1318 .<NetworkTopologyOperationOutput>status(true)
1319 .withResult(responseBuilder.build())
1322 return Futures.immediateFuture(rpcResult);
1325 private boolean isValidRequest(NetworkTopologyOperationInput input) {
1326 return input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null;
1330 public Future<RpcResult<ContrailRouteTopologyOperationOutput>> contrailRouteTopologyOperation(
1331 ContrailRouteTopologyOperationInput input) {
1333 final String svcOperation = "contrail-route-topology-operation";
1334 ServiceData serviceData;
1335 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1336 Properties properties = new Properties();
1338 log.info(CALLED_STR, svcOperation);
1339 // create a new response object
1340 ContrailRouteTopologyOperationOutputBuilder responseBuilder = new ContrailRouteTopologyOperationOutputBuilder();
1342 if (hasInvalidServiceId(input)) {
1343 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
1344 return buildRpcResultFuture(responseBuilder, NULL_OR_EMPTY_ERROR_PARAM);
1347 String siid = input.getServiceInformation().getServiceInstanceId();
1349 // Get the service-instance service data from MD-SAL
1350 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1351 getServiceData(siid, serviceDataBuilder);
1353 trySetSvcRequestId(input, responseBuilder);
1355 ServiceData sd = serviceDataBuilder.build();
1356 if (isInvalidServiceData(sd)) {
1357 log.debug(EMPTY_SERVICE_INSTANCE_MESSAGE, svcOperation);
1358 return buildRpcResultFuture(responseBuilder, INVALID_INPUT_ERROR_MESSAGE);
1361 log.info("Adding INPUT data for " + svcOperation + " [" + siid + "] input: " + input);
1362 ContrailRouteTopologyOperationInputBuilder inputBuilder = new ContrailRouteTopologyOperationInputBuilder(input);
1363 GenericResourceApiUtil.toProperties(properties, inputBuilder.build());
1365 // Call SLI sync method
1366 // Get SvcLogicService reference
1367 ResponseObject error = new ResponseObject("200", "");
1368 String ackFinal = "Y";
1369 String allottedResourceId = ERROR_NETWORK_ID;
1370 String serviceObjectPath = null;
1371 String contrailRouteObjectPath = null;
1372 Properties respProps = tryGetProperties(svcOperation, properties, serviceDataBuilder, error);
1374 if (respProps != null) {
1375 error.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
1376 error.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
1377 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
1378 allottedResourceId = respProps.getProperty(ALLOTTED_RESOURCE_ID_PARAM);
1379 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
1380 contrailRouteObjectPath = respProps.getProperty("contrail-route-object-path");
1383 if (failed(error)) {
1384 responseBuilder.setResponseCode(error.getStatusCode());
1385 responseBuilder.setResponseMessage(error.getMessage());
1386 responseBuilder.setAckFinalIndicator(ackFinal);
1387 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1389 RpcResult<ContrailRouteTopologyOperationOutput> rpcResult = RpcResultBuilder
1390 .<ContrailRouteTopologyOperationOutput>status(true)
1391 .withResult(responseBuilder.build())
1394 return Futures.immediateFuture(rpcResult);
1397 // Got success from SLI
1399 serviceData = serviceDataBuilder.build();
1400 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
1403 ServiceBuilder serviceBuilder = new ServiceBuilder();
1404 serviceBuilder.setServiceData(serviceData);
1405 serviceBuilder.setServiceInstanceId(siid);
1406 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1407 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1409 trySaveService(input, serviceBuilder);
1411 ContrailRouteResponseInformationBuilder contrailRouteResponseInformationBuilder = new ContrailRouteResponseInformationBuilder();
1412 contrailRouteResponseInformationBuilder.setInstanceId(allottedResourceId);
1413 contrailRouteResponseInformationBuilder.setObjectPath(contrailRouteObjectPath);
1414 responseBuilder.setContrailRouteResponseInformation(contrailRouteResponseInformationBuilder.build());
1416 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1417 serviceResponseInformationBuilder.setInstanceId(siid);
1418 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1419 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1421 } catch (IllegalStateException e) {
1422 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1423 responseBuilder.setResponseCode("500");
1424 responseBuilder.setResponseMessage(e.getMessage());
1425 responseBuilder.setAckFinalIndicator("Y");
1426 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1428 RpcResult<ContrailRouteTopologyOperationOutput> rpcResult = RpcResultBuilder
1429 .<ContrailRouteTopologyOperationOutput>status(true)
1430 .withResult(responseBuilder.build())
1433 return Futures.immediateFuture(rpcResult);
1437 responseBuilder.setResponseCode(error.getStatusCode());
1438 responseBuilder.setAckFinalIndicator(ackFinal);
1439 trySetResponseMessage(responseBuilder, error);
1440 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
1441 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
1443 RpcResult<ContrailRouteTopologyOperationOutput> rpcResult = RpcResultBuilder
1444 .<ContrailRouteTopologyOperationOutput>status(true)
1445 .withResult(responseBuilder.build())
1448 return Futures.immediateFuture(rpcResult);
1451 private void trySetResponseMessage(ContrailRouteTopologyOperationOutputBuilder responseBuilder,
1452 ResponseObject error) {
1453 if (!error.getMessage().isEmpty()) {
1454 responseBuilder.setResponseMessage(error.getMessage());
1458 private void trySaveService(ContrailRouteTopologyOperationInput input, ServiceBuilder serviceBuilder) {
1459 if (isValidRequest(input) &&
1460 (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Unassign) ||
1461 input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))) {
1462 // Only update operational tree on activate or delete
1463 log.info(UPDATING_TREE_INFO_MESSAGE);
1464 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1468 private void trySetSvcRequestId(ContrailRouteTopologyOperationInput input,
1469 ContrailRouteTopologyOperationOutputBuilder responseBuilder) {
1470 if (input.getSdncRequestHeader() != null) {
1471 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1475 private boolean hasInvalidServiceId(ContrailRouteTopologyOperationInput input) {
1476 return input == null || input.getServiceInformation() == null
1477 || input.getServiceInformation().getServiceInstanceId() == null
1478 || input.getServiceInformation().getServiceInstanceId().length() == 0;
1481 private Future<RpcResult<ContrailRouteTopologyOperationOutput>>
1482 buildRpcResultFuture(ContrailRouteTopologyOperationOutputBuilder responseBuilder, String responseMessage) {
1484 responseBuilder.setResponseCode("404");
1485 responseBuilder.setResponseMessage(responseMessage);
1486 responseBuilder.setAckFinalIndicator("Y");
1488 RpcResult<ContrailRouteTopologyOperationOutput> rpcResult = RpcResultBuilder
1489 .<ContrailRouteTopologyOperationOutput>status(true)
1490 .withResult(responseBuilder.build())
1493 return Futures.immediateFuture(rpcResult);
1496 private boolean isValidRequest(ContrailRouteTopologyOperationInput input) {
1497 return input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null;
1501 public Future<RpcResult<SecurityZoneTopologyOperationOutput>> securityZoneTopologyOperation(
1502 SecurityZoneTopologyOperationInput input) {
1504 final String svcOperation = "security-zone-topology-operation";
1505 ServiceData serviceData;
1506 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1507 Properties parms = new Properties();
1509 log.info(CALLED_STR, svcOperation);
1510 // create a new response object
1511 SecurityZoneTopologyOperationOutputBuilder responseBuilder = new SecurityZoneTopologyOperationOutputBuilder();
1513 if (this.hasInvalidServiceId(input)) {
1514 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
1515 return buildRpcResultFuture(responseBuilder, NULL_OR_EMPTY_ERROR_PARAM);
1518 String siid = input.getServiceInformation().getServiceInstanceId();
1520 // Get the service-instance service data from MD-SAL
1521 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1522 getServiceData(siid, serviceDataBuilder);
1523 trySetSvcRequestId(input, responseBuilder);
1525 ServiceData sd = serviceDataBuilder.build();
1526 if (isInvalidServiceData(sd)) {
1527 log.debug(EMPTY_SERVICE_INSTANCE_MESSAGE, svcOperation);
1528 return buildRpcResultFuture(responseBuilder, INVALID_INPUT_ERROR_MESSAGE);
1531 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
1532 SecurityZoneTopologyOperationInputBuilder inputBuilder = new SecurityZoneTopologyOperationInputBuilder(input);
1533 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1535 // Call SLI sync method
1536 // Get SvcLogicService reference
1538 Properties respProps = null;
1540 ResponseObject responseObject = new ResponseObject("200", "");
1541 String ackFinal = "Y";
1542 String allottedResourceId = ERROR_NETWORK_ID;
1543 String serviceObjectPath = null;
1544 String securityZoneObjectPath = null;
1547 if (svcLogicClient.hasGraph(APP_NAME, svcOperation, null, "sync")) {
1550 respProps = svcLogicClient.execute(APP_NAME, svcOperation, null, "sync", serviceDataBuilder, parms);
1551 } catch (Exception e) {
1552 log.error(SERVICE_LOGIC_EXECUTION_ERROR_MESSAGE, svcOperation, e);
1553 responseObject.setMessage(e.getMessage());
1554 responseObject.setStatusCode("500");
1557 responseObject.setMessage(NO_SERVICE_LOGIC_ACTIVE + APP_NAME + ": '" + svcOperation + "'");
1558 responseObject.setStatusCode("503");
1560 } catch (Exception e) {
1561 responseObject.setStatusCode("500");
1562 responseObject.setMessage(e.getMessage());
1563 log.error(SERVICE_LOGIC_SEARCH_ERROR_MESSAGE, e);
1566 if (respProps != null) {
1567 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
1568 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
1569 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
1570 allottedResourceId = respProps.getProperty(ALLOTTED_RESOURCE_ID_PARAM);
1571 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
1572 securityZoneObjectPath = respProps.getProperty("security-zone-object-path");
1575 if (failed(responseObject)) {
1576 responseBuilder.setResponseCode(responseObject.getStatusCode());
1577 responseBuilder.setResponseMessage(responseObject.getMessage());
1578 responseBuilder.setAckFinalIndicator(ackFinal);
1579 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1581 RpcResult<SecurityZoneTopologyOperationOutput> rpcResult = RpcResultBuilder
1582 .<SecurityZoneTopologyOperationOutput>status(true)
1583 .withResult(responseBuilder.build())
1586 return Futures.immediateFuture(rpcResult);
1589 // Got success from SLI
1592 serviceData = serviceDataBuilder.build();
1593 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
1596 ServiceBuilder serviceBuilder = new ServiceBuilder();
1597 serviceBuilder.setServiceData(serviceData);
1598 serviceBuilder.setServiceInstanceId(siid);
1599 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1600 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1602 trySaveService(input, serviceBuilder);
1604 SecurityZoneResponseInformationBuilder securityZoneResponseInformationBuilder = new SecurityZoneResponseInformationBuilder();
1605 securityZoneResponseInformationBuilder.setInstanceId(allottedResourceId);
1606 securityZoneResponseInformationBuilder.setObjectPath(securityZoneObjectPath);
1607 responseBuilder.setSecurityZoneResponseInformation(securityZoneResponseInformationBuilder.build());
1609 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1610 serviceResponseInformationBuilder.setInstanceId(siid);
1611 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1612 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1614 } catch (IllegalStateException e) {
1615 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1616 responseBuilder.setResponseCode("500");
1617 responseBuilder.setResponseMessage(e.getMessage());
1618 responseBuilder.setAckFinalIndicator("Y");
1619 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1621 RpcResult<SecurityZoneTopologyOperationOutput> rpcResult = RpcResultBuilder
1622 .<SecurityZoneTopologyOperationOutput>status(true)
1623 .withResult(responseBuilder.build())
1626 return Futures.immediateFuture(rpcResult);
1630 responseBuilder.setResponseCode(responseObject.getStatusCode());
1631 responseBuilder.setAckFinalIndicator(ackFinal);
1632 trySetResponseMessage(responseBuilder, responseObject);
1633 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
1634 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
1636 RpcResult<SecurityZoneTopologyOperationOutput> rpcResult = RpcResultBuilder
1637 .<SecurityZoneTopologyOperationOutput>status(true)
1638 .withResult(responseBuilder.build())
1641 return Futures.immediateFuture(rpcResult);
1644 private void trySetResponseMessage(SecurityZoneTopologyOperationOutputBuilder responseBuilder,
1645 ResponseObject error) {
1646 if (!error.getMessage().isEmpty()) {
1647 responseBuilder.setResponseMessage(error.getMessage());
1651 private void trySaveService(SecurityZoneTopologyOperationInput input, ServiceBuilder serviceBuilder) {
1652 if (isValidRequest(input) &&
1653 (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Unassign) ||
1654 input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))) {
1655 // Only update operational tree on activate or delete
1656 log.info(UPDATING_TREE_INFO_MESSAGE);
1657 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1661 private void trySetSvcRequestId(SecurityZoneTopologyOperationInput input,
1662 SecurityZoneTopologyOperationOutputBuilder responseBuilder) {
1663 if (input.getSdncRequestHeader() != null) {
1664 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1668 private boolean isInvalidServiceData(ServiceData sd) {
1669 return sd == null || sd.getServiceLevelOperStatus() == null;
1672 private boolean hasInvalidServiceId(SecurityZoneTopologyOperationInput input) {
1673 return input == null || input.getServiceInformation() == null
1674 || input.getServiceInformation().getServiceInstanceId() == null
1675 || input.getServiceInformation().getServiceInstanceId().length() == 0;
1678 private Future<RpcResult<SecurityZoneTopologyOperationOutput>>
1679 buildRpcResultFuture(SecurityZoneTopologyOperationOutputBuilder responseBuilder, String responseMessage) {
1681 responseBuilder.setResponseCode("404");
1682 responseBuilder.setResponseMessage(responseMessage);
1683 responseBuilder.setAckFinalIndicator("Y");
1685 RpcResult<SecurityZoneTopologyOperationOutput> rpcResult = RpcResultBuilder
1686 .<SecurityZoneTopologyOperationOutput>status(true)
1687 .withResult(responseBuilder.build())
1690 return Futures.immediateFuture(rpcResult);
1693 private boolean isValidRequest(SecurityZoneTopologyOperationInput input) {
1694 return input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null;
1698 public Future<RpcResult<TunnelxconnTopologyOperationOutput>> tunnelxconnTopologyOperation(
1699 TunnelxconnTopologyOperationInput input) {
1701 final String svcOperation = "tunnelxconn-topology-operation";
1702 Properties parms = new Properties();
1703 log.info(CALLED_STR, svcOperation);
1705 // create a new response object
1706 TunnelxconnTopologyOperationOutputBuilder responseBuilder = new TunnelxconnTopologyOperationOutputBuilder();
1707 if (hasInvalidServiceId(input)) {
1708 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
1709 responseBuilder.setResponseCode("404");
1710 responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
1711 responseBuilder.setAckFinalIndicator("Y");
1713 RpcResult<TunnelxconnTopologyOperationOutput> rpcResult = RpcResultBuilder
1714 .<TunnelxconnTopologyOperationOutput>status(true)
1715 .withResult(responseBuilder.build())
1718 return Futures.immediateFuture(rpcResult);
1720 String siid = input.getServiceInformation().getServiceInstanceId();
1721 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
1722 TunnelxconnTopologyOperationInputBuilder inputBuilder = new TunnelxconnTopologyOperationInputBuilder(input);
1723 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1725 // Call SLI sync method
1726 // Get SvcLogicService reference
1727 ResponseObject responseObject = new ResponseObject("200", "");
1728 String ackFinal = "Y";
1729 String allottedResourceId = ERROR_NETWORK_ID;
1730 String serviceObjectPath = null;
1731 String tunnelxconnObjectPath = null;
1732 Properties respProps = tryGetProperties(svcOperation, parms, responseObject);
1734 if (respProps != null) {
1735 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
1736 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
1737 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
1738 allottedResourceId = respProps.getProperty(ALLOTTED_RESOURCE_ID_PARAM);
1739 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
1740 tunnelxconnObjectPath = respProps.getProperty("tunnelxconn-object-path");
1743 if (failed(responseObject)) {
1744 responseBuilder.setResponseCode(responseObject.getStatusCode());
1745 responseBuilder.setResponseMessage(responseObject.getMessage());
1746 responseBuilder.setAckFinalIndicator(ackFinal);
1748 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1750 RpcResult<TunnelxconnTopologyOperationOutput> rpcResult = RpcResultBuilder
1751 .<TunnelxconnTopologyOperationOutput>status(true)
1752 .withResult(responseBuilder.build())
1755 return Futures.immediateFuture(rpcResult);
1758 // Got success from SLI
1760 TunnelxconnResponseInformationBuilder tunnelxconnResponseInformationBuilder = new TunnelxconnResponseInformationBuilder();
1761 tunnelxconnResponseInformationBuilder.setInstanceId(allottedResourceId);
1762 tunnelxconnResponseInformationBuilder.setObjectPath(tunnelxconnObjectPath);
1763 responseBuilder.setTunnelxconnResponseInformation(tunnelxconnResponseInformationBuilder.build());
1765 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1766 serviceResponseInformationBuilder.setInstanceId(siid);
1767 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1768 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1770 } catch (IllegalStateException e) {
1771 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1772 responseBuilder.setResponseCode("500");
1773 responseBuilder.setResponseMessage(e.toString());
1774 responseBuilder.setAckFinalIndicator("Y");
1775 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1777 RpcResult<TunnelxconnTopologyOperationOutput> rpcResult = RpcResultBuilder
1778 .<TunnelxconnTopologyOperationOutput>status(true)
1779 .withResult(responseBuilder.build())
1782 return Futures.immediateFuture(rpcResult);
1786 responseBuilder.setResponseCode(responseObject.getStatusCode());
1787 responseBuilder.setAckFinalIndicator(ackFinal);
1788 trySetResponseMessage(responseBuilder, responseObject);
1789 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
1790 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
1792 RpcResult<TunnelxconnTopologyOperationOutput> rpcResult = RpcResultBuilder
1793 .<TunnelxconnTopologyOperationOutput>status(true)
1794 .withResult(responseBuilder.build())
1797 return Futures.immediateFuture(rpcResult);
1801 public Future<RpcResult<ConnectionAttachmentTopologyOperationOutput>> connectionAttachmentTopologyOperation(
1802 ConnectionAttachmentTopologyOperationInput input) {
1803 //TODO after YANG review
1807 private void trySetResponseMessage(TunnelxconnTopologyOperationOutputBuilder responseBuilder,
1808 ResponseObject error) {
1809 if (!error.getMessage().isEmpty()) {
1810 responseBuilder.setResponseMessage(error.getMessage());
1814 private boolean hasInvalidServiceId(TunnelxconnTopologyOperationInput input) {
1815 return input == null || input.getServiceInformation() == null
1816 || input.getServiceInformation().getServiceInstanceId() == null
1817 || input.getServiceInformation().getServiceInstanceId().length() == 0;
1820 private Properties tryGetProperties(String svcOperation, Properties parms, ResponseObject responseObject) {
1822 if (svcLogicClient.hasGraph(APP_NAME, svcOperation, null, "sync")) {
1825 return svcLogicClient.execute(APP_NAME, svcOperation, null, "sync", parms);
1826 } catch (Exception e) {
1827 log.error(SERVICE_LOGIC_EXECUTION_ERROR_MESSAGE, svcOperation, e);
1828 responseObject.setMessage(e.getMessage());
1829 responseObject.setStatusCode("500");
1832 responseObject.setMessage(NO_SERVICE_LOGIC_ACTIVE + APP_NAME + ": '" + svcOperation + "'");
1833 responseObject.setStatusCode("503");
1835 } catch (Exception e) {
1836 responseObject.setMessage(e.getMessage());
1837 responseObject.setStatusCode("500");
1838 log.error(SERVICE_LOGIC_SEARCH_ERROR_MESSAGE, e);
1844 public Future<RpcResult<BrgTopologyOperationOutput>> brgTopologyOperation(BrgTopologyOperationInput input) {
1845 final String svcOperation = "brg-topology-operation";
1846 Properties parms = new Properties();
1848 log.info(CALLED_STR, svcOperation);
1849 // create a new response object
1850 BrgTopologyOperationOutputBuilder responseBuilder = new BrgTopologyOperationOutputBuilder();
1852 if (this.hasInvalidServiceId(input)) {
1854 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
1855 responseBuilder.setResponseCode("404");
1856 responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
1857 responseBuilder.setAckFinalIndicator("Y");
1859 RpcResult<BrgTopologyOperationOutput> rpcResult = RpcResultBuilder
1860 .<BrgTopologyOperationOutput>status(true)
1861 .withResult(responseBuilder.build())
1864 return Futures.immediateFuture(rpcResult);
1867 String siid = input.getServiceInformation().getServiceInstanceId();
1869 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
1870 BrgTopologyOperationInputBuilder inputBuilder = new BrgTopologyOperationInputBuilder(input);
1871 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1873 // Call SLI sync method
1874 // Get SvcLogicService reference
1875 ResponseObject error = new ResponseObject("200", "");
1876 String ackFinal = "Y";
1877 String allottedResourceId = ERROR_NETWORK_ID;
1878 String serviceObjectPath = null;
1879 String brgObjectPath = null;
1880 Properties respProps = tryGetProperties(svcOperation, parms, error);
1882 if (respProps != null) {
1883 error.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
1884 error.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
1885 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
1886 allottedResourceId = respProps.getProperty(ALLOTTED_RESOURCE_ID_PARAM);
1887 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
1888 brgObjectPath = respProps.getProperty("brg-object-path");
1891 if (failed(error)) {
1892 responseBuilder.setResponseCode(error.getStatusCode());
1893 responseBuilder.setResponseMessage(error.getMessage());
1894 responseBuilder.setAckFinalIndicator(ackFinal);
1896 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1897 RpcResult<BrgTopologyOperationOutput> rpcResult = RpcResultBuilder
1898 .<BrgTopologyOperationOutput>status(true)
1899 .withResult(responseBuilder.build())
1902 return Futures.immediateFuture(rpcResult);
1905 // Got success from SLI
1908 BrgResponseInformationBuilder brgResponseInformationBuilder = new BrgResponseInformationBuilder();
1909 brgResponseInformationBuilder.setInstanceId(allottedResourceId);
1910 brgResponseInformationBuilder.setObjectPath(brgObjectPath);
1911 responseBuilder.setBrgResponseInformation(brgResponseInformationBuilder.build());
1913 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1914 serviceResponseInformationBuilder.setInstanceId(siid);
1915 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1916 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1918 } catch (IllegalStateException e) {
1919 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1920 responseBuilder.setResponseCode("500");
1921 responseBuilder.setResponseMessage(e.toString());
1922 responseBuilder.setAckFinalIndicator("Y");
1923 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1925 RpcResult<BrgTopologyOperationOutput> rpcResult = RpcResultBuilder
1926 .<BrgTopologyOperationOutput>status(true)
1927 .withResult(responseBuilder.build())
1930 return Futures.immediateFuture(rpcResult);
1934 responseBuilder.setResponseCode(error.getStatusCode());
1935 responseBuilder.setAckFinalIndicator(ackFinal);
1936 trySetResponseMessage(responseBuilder, error);
1937 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
1938 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
1940 RpcResult<BrgTopologyOperationOutput> rpcResult = RpcResultBuilder
1941 .<BrgTopologyOperationOutput>status(true)
1942 .withResult(responseBuilder.build())
1945 return Futures.immediateFuture(rpcResult);
1948 private void trySetResponseMessage(BrgTopologyOperationOutputBuilder responseBuilder, ResponseObject error) {
1949 if (!error.getMessage().isEmpty()) {
1950 responseBuilder.setResponseMessage(error.getMessage());
1954 private boolean hasInvalidServiceId(BrgTopologyOperationInput input) {
1955 return input == null || input.getServiceInformation() == null
1956 || input.getServiceInformation().getServiceInstanceId() == null
1957 || input.getServiceInformation().getServiceInstanceId().length() == 0;
1961 public Future<RpcResult<PreloadVnfTopologyOperationOutput>> preloadVnfTopologyOperation(
1962 PreloadVnfTopologyOperationInput input) {
1964 final String svcOperation = "preload-vnf-topology-operation";
1965 Properties parms = new Properties();
1967 log.info(CALLED_STR, svcOperation);
1968 // create a new response object
1969 PreloadVnfTopologyOperationOutputBuilder responseBuilder = new PreloadVnfTopologyOperationOutputBuilder();
1971 if (hasInvalidVnfTopology(input)) {
1973 log.debug("exiting {} because of null input", svcOperation);
1974 responseBuilder.setResponseCode("403");
1975 responseBuilder.setResponseMessage("invalid input: input is null");
1976 responseBuilder.setAckFinalIndicator("Y");
1978 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult = RpcResultBuilder
1979 .<PreloadVnfTopologyOperationOutput>status(true)
1980 .withResult(responseBuilder.build())
1983 return Futures.immediateFuture(rpcResult);
1986 // Grab the name and type from the input buffer
1987 String preloadName = input.getVnfTopologyInformation().getVnfTopologyIdentifier().getVnfName();
1988 String preloadType = input.getVnfTopologyInformation().getVnfTopologyIdentifier().getVnfType();
1990 // Make sure we have a preload_name and preload_type
1991 if (invalidPreloadData(preloadName, preloadType)) {
1992 log.debug("exiting {} vnf-name or vnf-type is null or empty", svcOperation);
1993 responseBuilder.setResponseCode("403");
1994 responseBuilder.setResponseMessage("invalid input: vnf-name or vnf-type is null or empty");
1995 responseBuilder.setAckFinalIndicator("Y");
1997 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult = RpcResultBuilder
1998 .<PreloadVnfTopologyOperationOutput>status(true)
1999 .withResult(responseBuilder.build())
2002 return Futures.immediateFuture(rpcResult);
2005 trySetSvcRequestId(input, responseBuilder);
2007 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
2008 getPreloadData(preloadName, preloadType, preloadDataBuilder);
2010 PreloadDataBuilder operDataBuilder = new PreloadDataBuilder();
2011 getPreloadData(preloadName, preloadType, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
2013 // setup a preload-data object builder
2014 // ACTION preload-vnf-topology-operation
2016 // USES sdnc-request-header;
2017 // USES request-information;
2018 // uses vnf-topology-information;
2020 // USES vnf-topology-response-body;
2022 // container preload-data
2023 // uses vnf-topology-information;
2024 // uses network-topology-information;
2025 // uses oper-status;
2027 log.info("Adding INPUT data for {} [{},{}] input: {}", svcOperation, preloadName, preloadType, input);
2028 PreloadVnfTopologyOperationInputBuilder inputBuilder = new PreloadVnfTopologyOperationInputBuilder(input);
2029 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
2030 log.info("Adding OPERATIONAL data for {} [{},{}] operational-data: {}", svcOperation, preloadName,
2031 preloadType, operDataBuilder.build());
2032 GenericResourceApiUtil.toProperties(parms, OPERATIONAL_DATA_PARAM, operDataBuilder);
2034 // Call SLI sync method
2035 // Get SvcLogicService reference
2036 ResponseObject responseObject = new ResponseObject("200", "");
2037 Properties respProps = tryGetProperties(svcOperation, parms, responseObject);
2038 String ackFinal = resolveAckFinal(responseObject, respProps);
2040 if (failed(responseObject)) {
2042 responseBuilder.setResponseCode(responseObject.getStatusCode());
2043 responseBuilder.setResponseMessage(responseObject.getMessage());
2044 responseBuilder.setAckFinalIndicator(ackFinal);
2046 VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
2047 preloadVnfListBuilder.setVnfName(preloadName);
2048 preloadVnfListBuilder.setVnfType(preloadType);
2049 preloadVnfListBuilder.setPreloadData(preloadDataBuilder.build());
2050 log.error("Returned FAILED for {} [{},{}] error code: '{}', Reason: '{}'", svcOperation, preloadName,
2051 preloadType, responseObject.getStatusCode(), responseObject.getMessage());
2053 savePreloadList(preloadVnfListBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
2054 } catch (Exception e) {
2055 log.error(UPDATING_MDSAL_ERROR_MESSAGE_2, svcOperation, preloadName,
2058 log.debug("Sending Success rpc result due to external error");
2060 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult = RpcResultBuilder
2061 .<PreloadVnfTopologyOperationOutput>status(true)
2062 .withResult(responseBuilder.build())
2065 return Futures.immediateFuture(rpcResult);
2068 // Got success from SLI
2070 updatePreloadData(svcOperation, preloadName, preloadType, preloadDataBuilder);
2071 } catch (Exception e) {
2072 log.error(UPDATING_MDSAL_ERROR_MESSAGE_2, svcOperation, preloadName, preloadType,
2074 responseBuilder.setResponseCode("500");
2075 responseBuilder.setResponseMessage(e.getMessage());
2076 responseBuilder.setAckFinalIndicator("Y");
2077 log.error("Returned FAILED for {} [{},{}] {}", svcOperation, preloadName, preloadType,
2078 responseBuilder.build());
2080 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult = RpcResultBuilder
2081 .<PreloadVnfTopologyOperationOutput>status(false)
2082 .withResult(responseBuilder.build())
2085 return Futures.immediateFuture(rpcResult);
2089 responseBuilder.setResponseCode(responseObject.getStatusCode());
2090 responseBuilder.setAckFinalIndicator(ackFinal);
2091 trySetResponseMessage(responseBuilder, responseObject);
2093 log.info("Updated MD-SAL for {} [{},{}]", svcOperation, preloadName, preloadType);
2094 log.info("Returned SUCCESS for {} [{},{}] {}", svcOperation, preloadName, preloadType,
2095 responseBuilder.build());
2097 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult = RpcResultBuilder
2098 .<PreloadVnfTopologyOperationOutput>status(true)
2099 .withResult(responseBuilder.build())
2102 return Futures.immediateFuture(rpcResult);
2105 private String resolveAckFinal(ResponseObject responseObject, Properties respProps) {
2106 if (respProps != null) {
2107 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
2108 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
2109 return respProps.getProperty(ACK_FINAL_PARAM, "Y");
2114 private void trySetResponseMessage(PreloadVnfTopologyOperationOutputBuilder responseBuilder, ResponseObject error) {
2115 if (!error.getMessage().isEmpty()) {
2116 responseBuilder.setResponseMessage(error.getMessage());
2120 private void trySetSvcRequestId(PreloadVnfTopologyOperationInput input,
2121 PreloadVnfTopologyOperationOutputBuilder responseBuilder) {
2122 if (input.getSdncRequestHeader() != null) {
2123 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
2127 private boolean hasInvalidVnfTopology(PreloadVnfTopologyOperationInput input) {
2128 return input == null || input.getVnfTopologyInformation() == null
2129 || input.getVnfTopologyInformation().getVnfTopologyIdentifier() == null;
2132 private void updatePreloadData(String svcOperation, String preloadName, String preloadType,
2133 PreloadDataBuilder preloadDataBuilder) {
2134 PreloadData preloadData;
2135 preloadData = preloadDataBuilder.build();
2136 log.info("Updating MD-SAL for {} [{},{}] preloadData: {}", svcOperation, preloadName, preloadType,
2138 // svc-configuration-list
2139 VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
2140 preloadVnfListBuilder.setVnfName(preloadName);
2141 preloadVnfListBuilder.setVnfType(preloadType);
2142 preloadVnfListBuilder.setPreloadData(preloadData);
2144 // merge flag sets to false to allow it to be overwritten (not appended)
2145 savePreloadList(preloadVnfListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
2146 log.info(UPDATING_TREE_INFO_MESSAGE);
2147 savePreloadList(preloadVnfListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
2151 public Future<RpcResult<PreloadNetworkTopologyOperationOutput>> preloadNetworkTopologyOperation(
2152 PreloadNetworkTopologyOperationInput input) {
2154 final String svcOperation = "preload-network-topology-operation";
2155 Properties parms = new Properties();
2157 log.info(CALLED_STR, svcOperation);
2158 // create a new response object
2159 PreloadNetworkTopologyOperationOutputBuilder responseBuilder = new PreloadNetworkTopologyOperationOutputBuilder();
2161 if (hasInvalidNetworkTopology(input)) {
2163 log.debug("exiting {} because of null input", svcOperation);
2164 responseBuilder.setResponseCode("403");
2165 responseBuilder.setResponseMessage("input is null");
2166 responseBuilder.setAckFinalIndicator("Y");
2168 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
2169 .<PreloadNetworkTopologyOperationOutput>status(true)
2170 .withResult(responseBuilder.build())
2173 return Futures.immediateFuture(rpcResult);
2176 // Grab the name and type from the input buffer
2177 String preloadName = input.getNetworkTopologyInformation().getNetworkTopologyIdentifier().getNetworkName();
2178 String preloadType = input.getNetworkTopologyInformation().getNetworkTopologyIdentifier().getNetworkType();
2180 // Make sure we have a preload_name and preload_type
2181 if (invalidPreloadData(preloadName, preloadType)) {
2182 log.debug("exiting {} because of invalid preload-name or preload-type", svcOperation);
2183 responseBuilder.setResponseCode("403");
2184 responseBuilder.setResponseMessage("invalid input: network-name or network-type is null or empty");
2185 responseBuilder.setAckFinalIndicator("Y");
2187 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
2188 .<PreloadNetworkTopologyOperationOutput>status(true)
2189 .withResult(responseBuilder.build())
2192 return Futures.immediateFuture(rpcResult);
2195 trySetSvcRequestId(input, responseBuilder);
2197 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
2198 getPreloadData(preloadName, preloadType, preloadDataBuilder);
2200 PreloadDataBuilder operDataBuilder = new PreloadDataBuilder();
2201 getPreloadData(preloadName, preloadType, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
2204 // setup a preload-data object builder
2205 // ACTION preload-network-topology-operation
2207 // USES sdnc-request-header;
2208 // USES request-information;
2209 // uses network-topology-information;
2211 // USES vnf-topology-response-body;
2213 // container preload-data
2214 // uses vnf-topology-information;
2215 // uses network-topology-information;
2216 // uses oper-status;
2218 log.info("Adding INPUT data for {} [{},{}] input: {}", svcOperation, preloadName, preloadType, input);
2219 PreloadNetworkTopologyOperationInputBuilder inputBuilder = new PreloadNetworkTopologyOperationInputBuilder(
2221 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
2222 log.info("Adding OPERATIONAL data for {} [{},{}] operational-data: {}", svcOperation, preloadName,
2223 preloadType, operDataBuilder.build());
2224 GenericResourceApiUtil.toProperties(parms, OPERATIONAL_DATA_PARAM, operDataBuilder);
2226 // Call SLI sync method
2227 // Get SvcLogicService reference
2228 ResponseObject responseObject = new ResponseObject("200", "");
2229 Properties respProps = tryGetProperties(svcOperation, parms, responseObject);
2231 String ackFinal = resolveAckFinal(responseObject, respProps);
2233 if (failed(responseObject)) {
2235 responseBuilder.setResponseCode(responseObject.getStatusCode());
2236 responseBuilder.setResponseMessage(responseObject.getMessage());
2237 responseBuilder.setAckFinalIndicator(ackFinal);
2239 VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
2240 preloadVnfListBuilder.setVnfName(preloadName);
2241 preloadVnfListBuilder.setVnfType(preloadType);
2242 preloadVnfListBuilder.setPreloadData(preloadDataBuilder.build());
2243 log.error("Returned FAILED for {} [{},{}] error code: '{}', Reason: '{}'", svcOperation, preloadName,
2244 preloadType, responseObject.getStatusCode(), responseObject.getMessage());
2246 savePreloadList(preloadVnfListBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
2247 } catch (Exception e) {
2248 log.error(UPDATING_MDSAL_ERROR_MESSAGE_2, svcOperation, preloadName,
2252 log.debug("Sending Success rpc result due to external error");
2254 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
2255 .<PreloadNetworkTopologyOperationOutput>status(true)
2256 .withResult(responseBuilder.build())
2259 return Futures.immediateFuture(rpcResult);
2262 // Got success from SLI
2264 updatePreloadData(svcOperation, preloadName, preloadType, preloadDataBuilder);
2265 } catch (Exception e) {
2266 log.error(UPDATING_MDSAL_ERROR_MESSAGE_2, svcOperation, preloadName, preloadType, e);
2267 responseBuilder.setResponseCode("500");
2268 responseBuilder.setResponseMessage(e.getMessage());
2269 responseBuilder.setAckFinalIndicator("Y");
2270 log.error("Returned FAILED for {} [{},{}] {}", svcOperation, preloadName, preloadType,
2271 responseBuilder.build());
2273 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
2274 .<PreloadNetworkTopologyOperationOutput>status(false)
2275 .withResult(responseBuilder.build())
2278 return Futures.immediateFuture(rpcResult);
2282 responseBuilder.setResponseCode(responseObject.getStatusCode());
2283 responseBuilder.setAckFinalIndicator(ackFinal);
2284 trySetResponseMessage(responseBuilder, responseObject);
2286 log.info("Updated MD-SAL for {} [{},{}]", svcOperation, preloadName, preloadType);
2287 log.info("Returned SUCCESS for {} [{},{}] {}", svcOperation, preloadName, preloadType,
2288 responseBuilder.build());
2290 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
2291 .<PreloadNetworkTopologyOperationOutput>status(true)
2292 .withResult(responseBuilder.build())
2295 return Futures.immediateFuture(rpcResult);
2298 private void trySetResponseMessage(PreloadNetworkTopologyOperationOutputBuilder responseBuilder,
2299 ResponseObject error) {
2300 if (!error.getMessage().isEmpty()) {
2301 responseBuilder.setResponseMessage(error.getMessage());
2305 private void trySetSvcRequestId(PreloadNetworkTopologyOperationInput input,
2306 PreloadNetworkTopologyOperationOutputBuilder responseBuilder) {
2307 if (input.getSdncRequestHeader() != null) {
2308 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
2312 private boolean invalidPreloadData(String preloadName, String preloadType) {
2313 return preloadName == null || preloadName.length() == 0 || preloadType == null || preloadType.length() == 0;
2316 private boolean hasInvalidNetworkTopology(PreloadNetworkTopologyOperationInput input) {
2317 return input == null || input.getNetworkTopologyInformation() == null
2318 || input.getNetworkTopologyInformation().getNetworkTopologyIdentifier() == null;