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.ContrailRouteTopologyOperationInput;
29 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ContrailRouteTopologyOperationInputBuilder;
30 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ContrailRouteTopologyOperationOutput;
31 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ContrailRouteTopologyOperationOutputBuilder;
32 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.GENERICRESOURCEAPIService;
33 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.NetworkTopologyOperationInput;
34 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.NetworkTopologyOperationInputBuilder;
35 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.NetworkTopologyOperationOutput;
36 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.NetworkTopologyOperationOutputBuilder;
37 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadNetworkTopologyOperationInput;
38 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadNetworkTopologyOperationInputBuilder;
39 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadNetworkTopologyOperationOutput;
40 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadNetworkTopologyOperationOutputBuilder;
41 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadVnfTopologyOperationInput;
42 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadVnfTopologyOperationInputBuilder;
43 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadVnfTopologyOperationOutput;
44 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadVnfTopologyOperationOutputBuilder;
45 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadVnfs;
46 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadVnfsBuilder;
47 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.SecurityZoneTopologyOperationInput;
48 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.SecurityZoneTopologyOperationInputBuilder;
49 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.SecurityZoneTopologyOperationOutput;
50 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.SecurityZoneTopologyOperationOutputBuilder;
51 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ServiceTopologyOperationInput;
52 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ServiceTopologyOperationInputBuilder;
53 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ServiceTopologyOperationOutput;
54 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ServiceTopologyOperationOutputBuilder;
55 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.Services;
56 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ServicesBuilder;
57 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.TunnelxconnTopologyOperationInput;
58 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.TunnelxconnTopologyOperationInputBuilder;
59 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.TunnelxconnTopologyOperationOutput;
60 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.TunnelxconnTopologyOperationOutputBuilder;
61 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.VfModuleTopologyOperationInput;
62 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.VfModuleTopologyOperationInputBuilder;
63 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.VfModuleTopologyOperationOutput;
64 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.VfModuleTopologyOperationOutputBuilder;
65 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.VnfTopologyOperationInput;
66 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.VnfTopologyOperationInputBuilder;
67 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.VnfTopologyOperationOutput;
68 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.VnfTopologyOperationOutputBuilder;
69 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.brg.response.information.BrgResponseInformationBuilder;
70 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.contrail.route.response.information.ContrailRouteResponseInformationBuilder;
71 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.network.response.information.NetworkResponseInformationBuilder;
72 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.preload.data.PreloadData;
73 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.preload.data.PreloadDataBuilder;
74 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.preload.model.information.VnfPreloadList;
75 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.preload.model.information.VnfPreloadListBuilder;
76 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.preload.model.information.VnfPreloadListKey;
77 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.request.information.RequestInformation;
78 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.sdnc.request.header.SdncRequestHeader;
79 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.sdnc.request.header.SdncRequestHeader.SvcAction;
80 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.security.zone.response.information.SecurityZoneResponseInformationBuilder;
81 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.data.ServiceData;
82 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.data.ServiceDataBuilder;
83 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.model.infrastructure.Service;
84 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.model.infrastructure.ServiceBuilder;
85 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.model.infrastructure.ServiceKey;
86 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.response.information.ServiceResponseInformationBuilder;
87 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.status.ServiceStatus.RequestStatus;
88 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.status.ServiceStatus.RpcAction;
89 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.status.ServiceStatusBuilder;
90 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.tunnelxconn.response.information.TunnelxconnResponseInformationBuilder;
91 import org.opendaylight.yangtools.yang.binding.DataObject;
92 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
93 import org.opendaylight.yangtools.yang.common.RpcResult;
94 import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
95 import org.slf4j.Logger;
96 import org.slf4j.LoggerFactory;
99 * Defines a base implementation for your provider. This class extends from a helper class which provides storage for
100 * the most commonly used components of the MD-SAL. Additionally the base class provides some basic logging and
101 * initialization / clean up methods.
103 * To use this, copy and paste (overwrite) the following method into the TestApplicationProviderModule class which is
104 * auto generated under src/main/java in this project (created only once during first compilation):
109 * public java.lang.AutoCloseable createInstance() {
111 * // final GENERIC-RESOURCE-APIProvider provider = new
112 * // GENERIC-RESOURCE-APIProvider();
113 * final GenericResourceApiProvider provider = new GenericResourceApiProvider();
114 * provider.setDataBroker(getDataBrokerDependency());
115 * provider.setNotificationService(getNotificationServiceDependency());
116 * provider.setRpcRegistry(getRpcRegistryDependency());
117 * provider.initialize();
118 * return new AutoCloseable() {
121 * public void close() throws Exception {
122 * // TODO: CLOSE ANY REGISTRATION OBJECTS CREATED USING ABOVE
123 * // BROKER/NOTIFICATION
124 * // SERVIE/RPC REGISTRY
133 public class GenericResourceApiProvider implements AutoCloseable, GENERICRESOURCEAPIService {
135 protected static final String APP_NAME = "generic-resource-api";
136 private static final String CALLED_STR = "{} called.";
137 private static final String NULL_OR_EMPTY_ERROR_MESSAGE = "exiting {} because of null or empty service-instance-id";
138 protected static final String NULL_OR_EMPTY_ERROR_PARAM = "invalid input, null or empty service-instance-id";
139 private static final String ADDING_INPUT_DATA_LOG = "Adding INPUT data for {} [{}] input: {}";
140 private static final String ADDING_OPERATIONAL_DATA_LOG = "Adding OPERATIONAL data for {} [{}] operational-data: {}";
141 private static final String OPERATIONAL_DATA_PARAM = "operational-data";
142 protected static final String NO_SERVICE_LOGIC_ACTIVE = "No service logic active for ";
143 private static final String SERVICE_LOGIC_SEARCH_ERROR_MESSAGE = "Caught exception looking for service logic";
144 private static final String ERROR_CODE_PARAM = "error-code";
145 private static final String ERROR_MESSAGE_PARAM = "error-message";
146 private static final String ACK_FINAL_PARAM = "ack-final";
147 private static final String SERVICE_OBJECT_PATH_PARAM = "service-object-path";
148 private static final String UPDATING_MDSAL_ERROR_MESSAGE = "Caught Exception updating MD-SAL for {} [{}] \n";
149 private static final String UPDATING_MDSAL_ERROR_MESSAGE_2 = "Caught Exception updating MD-SAL for {} [{},{}] \n";
150 private static final String RETURNED_FAILED_MESSAGE = "Returned FAILED for {} [{}] {}";
151 private static final String UPDATING_MDSAL_INFO_MESSAGE = "Updating MD-SAL for {} [{}] ServiceData: {}";
152 private static final String UPDATED_MDSAL_INFO_MESSAGE = "Updated MD-SAL for {} [{}]";
153 private static final String RETURNED_SUCCESS_MESSAGE = "Returned SUCCESS for {} [{}] {}";
154 private static final String NON_NULL_PARAM = "non-null";
155 private static final String NULL_PARAM = "null";
156 private static final String SERVICE_LOGIC_EXECUTION_ERROR_MESSAGE = "Caught exception executing service logic for {} ";
157 private static final String UPDATING_TREE_INFO_MESSAGE = "Updating OPERATIONAL tree.";
158 private static final String EMPTY_SERVICE_INSTANCE_MESSAGE = "exiting {} because the service-instance does not have any service data in SDNC";
159 protected static final String INVALID_INPUT_ERROR_MESSAGE = "invalid input: the service-instance does not have any service data in SDNC";
160 private static final String ALLOTTED_RESOURCE_ID_PARAM = "allotted-resource-id";
161 private static final String ERROR_NETWORK_ID = "error";
163 private final Logger log = LoggerFactory.getLogger(GenericResourceApiProvider.class);
164 private final ExecutorService executor;
165 private final GenericResourceApiSvcLogicServiceClient svcLogicClient;
167 protected DataBroker dataBroker;
168 protected NotificationPublishService notificationService;
169 protected RpcProviderRegistry rpcRegistry;
170 protected BindingAwareBroker.RpcRegistration<GENERICRESOURCEAPIService> rpcRegistration;
172 public GenericResourceApiProvider(
173 DataBroker dataBroker,
174 NotificationPublishService notificationPublishService,
175 RpcProviderRegistry rpcProviderRegistry,
176 GenericResourceApiSvcLogicServiceClient client
178 log.info("Creating provider for {}", APP_NAME);
179 executor = Executors.newFixedThreadPool(1);
180 setDataBroker(dataBroker);
181 setNotificationService(notificationPublishService);
182 setRpcRegistry(rpcProviderRegistry);
183 svcLogicClient = client;
188 public void initialize() {
189 log.info("Initializing provider for {}", APP_NAME);
190 // Create the top level containers
193 GenericResourceApiUtil.loadProperties();
194 } catch (Exception e) {
195 log.error("Caught Exception while trying to load properties file", e);
198 log.info("Initialization complete for {}", APP_NAME);
201 protected void initializeChild() {
202 // Override if you have custom initialization intelligence
206 public void close() throws Exception {
207 log.info("Closing provider for {}", APP_NAME);
209 rpcRegistration.close();
210 log.info("Successfully closed provider for {}", APP_NAME);
213 private static class Iso8601Util {
215 private static TimeZone timeZone = TimeZone.getTimeZone("UTC");
216 private static DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'");
218 private Iso8601Util() {
222 dateFormat.setTimeZone(timeZone);
225 private static String now() {
226 return dateFormat.format(new Date());
230 public void setDataBroker(DataBroker dataBroker) {
231 this.dataBroker = dataBroker;
232 if (log.isDebugEnabled()) {
233 log.debug("DataBroker set to {}", dataBroker == null ? NULL_PARAM : NON_NULL_PARAM);
237 public void setNotificationService(NotificationPublishService notificationService) {
238 this.notificationService = notificationService;
239 if (log.isDebugEnabled()) {
240 log.debug("Notification Service set to {}", notificationService == null ? NULL_PARAM : NON_NULL_PARAM);
244 public void setRpcRegistry(RpcProviderRegistry rpcRegistry) {
245 this.rpcRegistry = rpcRegistry;
246 if (log.isDebugEnabled()) {
247 log.debug("RpcRegistry set to {}", rpcRegistry == null ? NULL_PARAM : NON_NULL_PARAM);
251 private void createContainers() {
253 final WriteTransaction t = dataBroker.newReadWriteTransaction();
255 // Create the service-instance container
256 t.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(Services.class),
257 new ServicesBuilder().build());
258 t.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(Services.class),
259 new ServicesBuilder().build());
261 // Create the PreloadVnfs container
262 t.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(PreloadVnfs.class),
263 new PreloadVnfsBuilder().build());
264 t.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(PreloadVnfs.class),
265 new PreloadVnfsBuilder().build());
268 CheckedFuture<Void, TransactionCommitFailedException> checkedFuture = t.submit();
270 log.info("Create containers succeeded!");
272 } catch (InterruptedException | ExecutionException e) {
273 log.error("Create containers failed: ", e);
277 private void setServiceStatus(ServiceStatusBuilder serviceStatusBuilder, String errorCode, String errorMessage,
279 serviceStatusBuilder.setResponseCode(errorCode);
280 serviceStatusBuilder.setResponseMessage(errorMessage);
281 serviceStatusBuilder.setFinalIndicator(ackFinal);
282 serviceStatusBuilder.setResponseTimestamp(Iso8601Util.now());
285 private void setServiceStatus(ServiceStatusBuilder serviceStatusBuilder, RequestInformation requestInformation) {
286 if (requestInformation != null && requestInformation.getRequestAction() != null) {
287 serviceStatusBuilder.setAction(requestInformation.getRequestAction().toString());
291 private void setServiceStatus(ServiceStatusBuilder serviceStatusBuilder, SdncRequestHeader requestHeader) {
292 if (requestHeader != null && requestHeader.getSvcAction() != null) {
293 switch (requestHeader.getSvcAction()) {
295 serviceStatusBuilder.setRpcAction(RpcAction.Assign);
298 serviceStatusBuilder.setRpcAction(RpcAction.Unassign);
301 serviceStatusBuilder.setRpcAction(RpcAction.Activate);
304 serviceStatusBuilder.setRpcAction(RpcAction.Deactivate);
307 serviceStatusBuilder.setRpcAction(RpcAction.Delete);
310 log.error("Unknown SvcAction: {}", requestHeader.getSvcAction());
316 private void getServiceData(String siid, ServiceDataBuilder serviceDataBuilder) {
318 getServiceData(siid, serviceDataBuilder, LogicalDatastoreType.CONFIGURATION);
321 private void getServiceData(String siid, ServiceDataBuilder serviceDataBuilder, LogicalDatastoreType type) {
322 // See if any data exists yet for this siid, if so grab it.
323 InstanceIdentifier<Service> serviceInstanceIdentifier = InstanceIdentifier
324 .builder(Services.class)
325 .child(Service.class, new ServiceKey(siid))
328 ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction();
329 Optional<Service> data = Optional.absent();
331 data = readTx.read(type, serviceInstanceIdentifier).get();
332 } catch (InterruptedException | ExecutionException e) {
333 log.error("Caught Exception reading MD-SAL ({}) data for [{}] ", type, siid, e);
336 if (data != null && data.isPresent()) {
337 ServiceData serviceData = data.get().getServiceData();
338 if (serviceData != null) {
339 log.info("Read MD-SAL ({}) data for [{}] ServiceData: {}", type, siid, serviceData);
340 serviceDataBuilder.setSdncRequestHeader(serviceData.getSdncRequestHeader());
341 serviceDataBuilder.setRequestInformation(serviceData.getRequestInformation());
342 serviceDataBuilder.setServiceInformation(serviceData.getServiceInformation());
343 serviceDataBuilder.setServiceRequestInput(serviceData.getServiceRequestInput());
344 serviceDataBuilder.setServiceTopology(serviceData.getServiceTopology());
345 serviceDataBuilder.setServiceLevelOperStatus(serviceData.getServiceLevelOperStatus());
346 serviceDataBuilder.setNetworks(serviceData.getNetworks());
347 serviceDataBuilder.setVnfs(serviceData.getVnfs());
348 serviceDataBuilder.setProvidedAllottedResources(serviceData.getProvidedAllottedResources());
349 serviceDataBuilder.setConsumedAllottedResources(serviceData.getConsumedAllottedResources());
350 // service-instance-id needs to be set
352 log.info("No service-data found in MD-SAL ({}) for [{}]", type, siid);
355 log.info("No data found in MD-SAL ({}) for [{}]", type, siid);
359 private void getPreloadData(String vnfName, String vnfType, PreloadDataBuilder preloadDataBuilder) {
361 getPreloadData(vnfName, vnfType, preloadDataBuilder, LogicalDatastoreType.CONFIGURATION);
364 private void getPreloadData(String preloadName, String preloadType, PreloadDataBuilder preloadDataBuilder,
365 LogicalDatastoreType type) {
366 // See if any data exists yet for this name/type, if so grab it.
367 InstanceIdentifier<VnfPreloadList> preloadInstanceIdentifier = InstanceIdentifier
368 .builder(PreloadVnfs.class)
369 .child(VnfPreloadList.class, new VnfPreloadListKey(preloadName, preloadType))
372 ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction();
373 Optional<VnfPreloadList> data = Optional.absent();
375 data = readTx.read(type, preloadInstanceIdentifier).get();
376 } catch (InterruptedException | ExecutionException e) {
377 log.error("Caught Exception reading MD-SAL ({}) for [{},{}] ", type, preloadName, preloadType, e);
380 if (data != null && data.isPresent()) {
381 PreloadData preloadData = data.get().getPreloadData();
382 if (preloadData != null) {
383 log.info("Read MD-SAL ({}) data for [{},{}] PreloadData: {}", type, preloadName, preloadType,
385 preloadDataBuilder.setVnfTopologyInformation(preloadData.getVnfTopologyInformation());
386 preloadDataBuilder.setNetworkTopologyInformation(preloadData.getNetworkTopologyInformation());
387 preloadDataBuilder.setOperStatus(preloadData.getOperStatus());
389 log.info("No preload-data found in MD-SAL ({}) for [{},{}] ", type, preloadName, preloadType);
392 log.info("No data found in MD-SAL ({}) for [{},{}] ", type, preloadName, preloadType);
396 private void saveService(final Service entry, boolean merge, LogicalDatastoreType storeType) {
397 // Each entry will be identifiable by a unique key, we have to create that
399 InstanceIdentifier<Service> path = InstanceIdentifier
400 .builder(Services.class)
401 .child(Service.class, entry.getKey())
404 trySaveEntry(entry, merge, storeType, path);
407 private void savePreloadList(final VnfPreloadList entry, boolean merge, LogicalDatastoreType storeType) {
409 // Each entry will be identifiable by a unique key, we have to create that
411 InstanceIdentifier<VnfPreloadList> path = InstanceIdentifier
412 .builder(PreloadVnfs.class)
413 .child(VnfPreloadList.class, entry.getKey())
416 trySaveEntry(entry, merge, storeType, path);
419 private <T extends DataObject> void trySaveEntry(T entry, boolean merge, LogicalDatastoreType storeType,
420 InstanceIdentifier<T> path) {
424 save(entry, merge, storeType, path);
426 } catch (OptimisticLockFailedException e) {
428 log.debug("Got OptimisticLockFailedException on last try - failing ");
429 throw new IllegalStateException(e);
431 log.debug("Got OptimisticLockFailedException - trying again ");
432 } catch (TransactionCommitFailedException ex) {
433 log.debug("Update DataStore failed");
434 throw new IllegalStateException(ex);
439 private <T extends DataObject> void save(T entry, boolean merge, LogicalDatastoreType storeType,
440 InstanceIdentifier<T> path)
441 throws TransactionCommitFailedException {
442 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
444 tx.merge(storeType, path, entry);
446 tx.put(storeType, path, entry);
448 tx.submit().checkedGet();
449 log.debug("Update DataStore succeeded");
452 private void deleteService(final Service entry, LogicalDatastoreType storeType) {
453 // Each entry will be identifiable by a unique key, we have to create
455 InstanceIdentifier<Service> path = InstanceIdentifier
456 .builder(Services.class)
457 .child(Service.class, entry.getKey())
460 tryDeleteEntry(storeType, path);
463 private void tryDeleteEntry(LogicalDatastoreType storeType, InstanceIdentifier<Service> path) {
467 delete(storeType, path);
469 } catch (OptimisticLockFailedException e) {
471 log.debug("Got OptimisticLockFailedException on last try - failing ");
472 throw new IllegalStateException(e);
474 log.debug("Got OptimisticLockFailedException - trying again ");
475 } catch (TransactionCommitFailedException ex) {
476 log.debug("Update DataStore failed");
477 throw new IllegalStateException(ex);
482 private void delete(LogicalDatastoreType storeType, InstanceIdentifier<Service> path)
483 throws TransactionCommitFailedException {
484 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
485 tx.delete(storeType, path);
486 tx.submit().checkedGet();
487 log.debug("DataStore delete succeeded");
491 public Future<RpcResult<ServiceTopologyOperationOutput>> serviceTopologyOperation(
492 ServiceTopologyOperationInput input) {
494 final String svcOperation = "service-topology-operation";
495 ServiceData serviceData;
496 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
497 Properties parms = new Properties();
499 log.info(CALLED_STR, svcOperation);
500 // create a new response object
501 ServiceTopologyOperationOutputBuilder responseBuilder = new ServiceTopologyOperationOutputBuilder();
503 if (hasInvalidServiceId(input)) {
504 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
505 responseBuilder.setResponseCode("404");
506 responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
507 responseBuilder.setAckFinalIndicator("Y");
509 RpcResult<ServiceTopologyOperationOutput> rpcResult = RpcResultBuilder
510 .<ServiceTopologyOperationOutput>status(true)
511 .withResult(responseBuilder.build())
514 return Futures.immediateFuture(rpcResult);
517 // Grab the service instance ID from the input buffer
518 String siid = input.getServiceInformation().getServiceInstanceId();
520 trySetSvcRequestId(input, responseBuilder);
522 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
523 getServiceData(siid, serviceDataBuilder);
525 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
526 getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
528 // Set the serviceStatus based on input
529 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
530 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
533 * // setup a service-data object builder // ACTION service-topology-operation
534 * // INPUT: // USES uses service-operation-information // OUTPUT: // uses
535 * topology-response-common; // uses service-response-information;
538 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
539 ServiceTopologyOperationInputBuilder inputBuilder = new ServiceTopologyOperationInputBuilder(input);
540 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
542 log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid,
543 operDataBuilder.build());
544 GenericResourceApiUtil.toProperties(parms, OPERATIONAL_DATA_PARAM, operDataBuilder);
546 // Call SLI sync method
547 // Get SvcLogicService reference
549 ResponseObject responseObject = new ResponseObject("200", "");
550 String ackFinal = "Y";
551 String serviceObjectPath = null;
552 Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, responseObject);
554 if (respProps != null) {
555 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
556 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
557 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
558 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
561 setServiceStatus(serviceStatusBuilder, responseObject.getStatusCode(), responseObject.getMessage(), ackFinal);
562 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
563 serviceStatusBuilder.setRpcName(svcOperation);
565 if (failed(responseObject)) {
566 responseBuilder.setResponseCode(responseObject.getStatusCode());
567 responseBuilder.setResponseMessage(responseObject.getMessage());
568 responseBuilder.setAckFinalIndicator(ackFinal);
570 ServiceBuilder serviceBuilder = new ServiceBuilder();
571 serviceBuilder.setServiceInstanceId(siid);
572 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
574 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
575 } catch (Exception e) {
576 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
578 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
580 RpcResult<ServiceTopologyOperationOutput> rpcResult = RpcResultBuilder
581 .<ServiceTopologyOperationOutput>status(true)
582 .withResult(responseBuilder.build())
585 return Futures.immediateFuture(rpcResult);
588 // Got success from SLI
590 serviceData = serviceDataBuilder.build();
591 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
594 ServiceBuilder serviceBuilder = new ServiceBuilder();
595 serviceBuilder.setServiceData(serviceData);
596 serviceBuilder.setServiceInstanceId(siid);
597 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
598 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
600 tryDeleteService(input, serviceBuilder);
602 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
603 serviceResponseInformationBuilder.setInstanceId(siid);
604 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
605 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
607 } catch (Exception e) {
608 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
609 responseBuilder.setResponseCode("500");
610 responseBuilder.setResponseMessage(e.getMessage());
611 responseBuilder.setAckFinalIndicator("Y");
612 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
614 RpcResult<ServiceTopologyOperationOutput> rpcResult = RpcResultBuilder
615 .<ServiceTopologyOperationOutput>status(true)
616 .withResult(responseBuilder.build())
619 return Futures.immediateFuture(rpcResult);
623 responseBuilder.setResponseCode(responseObject.getStatusCode());
624 responseBuilder.setAckFinalIndicator(ackFinal);
625 trySetResponseMessage(responseBuilder, responseObject);
626 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
627 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
629 RpcResult<ServiceTopologyOperationOutput> rpcResult = RpcResultBuilder
630 .<ServiceTopologyOperationOutput>status(true)
631 .withResult(responseBuilder.build())
634 return Futures.immediateFuture(rpcResult);
637 private void trySetResponseMessage(ServiceTopologyOperationOutputBuilder responseBuilder, ResponseObject error) {
638 if (!error.getMessage().isEmpty()) {
639 responseBuilder.setResponseMessage(error.getMessage());
643 private boolean hasInvalidServiceId(ServiceTopologyOperationInput input) {
644 return input == null || input.getServiceInformation() == null
645 || input.getServiceInformation().getServiceInstanceId() == null
646 || input.getServiceInformation().getServiceInstanceId().length() == 0;
649 private void trySetSvcRequestId(ServiceTopologyOperationInput input,
650 ServiceTopologyOperationOutputBuilder responseBuilder) {
651 if (input.getSdncRequestHeader() != null) {
652 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
656 private void tryDeleteService(ServiceTopologyOperationInput input, ServiceBuilder serviceBuilder) {
657 if (isValidRequest(input) && input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete)) {
658 // Only update operational tree on delete
659 log.info("Delete from both CONFIGURATION and OPERATIONAL tree.");
660 deleteService(serviceBuilder.build(), LogicalDatastoreType.OPERATIONAL);
661 deleteService(serviceBuilder.build(), LogicalDatastoreType.CONFIGURATION);
665 private Properties tryGetProperties(String svcOperation, Properties parms, ServiceDataBuilder serviceDataBuilder,
666 ResponseObject responseObject) {
668 if (svcLogicClient.hasGraph(APP_NAME, svcOperation, null, "sync")) {
670 return svcLogicClient.execute(APP_NAME, svcOperation, null, "sync", serviceDataBuilder, parms);
671 } catch (Exception e) {
672 log.error(SERVICE_LOGIC_EXECUTION_ERROR_MESSAGE, svcOperation, e);
673 responseObject.setMessage(e.getMessage());
674 responseObject.setStatusCode("500");
677 responseObject.setMessage(NO_SERVICE_LOGIC_ACTIVE + APP_NAME + ": '" + svcOperation + "'");
678 responseObject.setStatusCode("503");
680 } catch (Exception e) {
681 responseObject.setMessage(e.getMessage());
682 responseObject.setStatusCode("500");
683 log.error(SERVICE_LOGIC_SEARCH_ERROR_MESSAGE, e);
689 private boolean failed(ResponseObject error) {
691 !error.getStatusCode().isEmpty() && !("0".equals(error.getStatusCode()) || "200"
692 .equals(error.getStatusCode()));
695 private boolean isValidRequest(ServiceTopologyOperationInput input) {
696 return input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null;
700 public Future<RpcResult<VnfTopologyOperationOutput>> vnfTopologyOperation(VnfTopologyOperationInput input) {
702 final String svcOperation = "vnf-topology-operation";
703 ServiceData serviceData;
704 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
705 Properties properties = new Properties();
707 log.info(CALLED_STR, svcOperation);
708 // create a new response object
709 VnfTopologyOperationOutputBuilder responseBuilder = new VnfTopologyOperationOutputBuilder();
711 if (hasInvalidServiceId(input)) {
713 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
714 responseBuilder.setResponseCode("404");
715 responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
716 responseBuilder.setAckFinalIndicator("Y");
717 RpcResult<VnfTopologyOperationOutput> rpcResult = RpcResultBuilder.<VnfTopologyOperationOutput>status(true)
718 .withResult(responseBuilder.build()).build();
720 return Futures.immediateFuture(rpcResult);
723 // Grab the service instance ID from the input buffer
724 String siid = input.getServiceInformation().getServiceInstanceId();
726 trySetSvcRequestId(input, responseBuilder);
728 if (hasInvalidVnfId(input)) {
729 log.debug("exiting {} because of null or empty vnf-id", svcOperation);
730 responseBuilder.setResponseCode("404");
731 responseBuilder.setResponseMessage("invalid input, null or empty vnf-id");
732 responseBuilder.setAckFinalIndicator("Y");
734 RpcResult<VnfTopologyOperationOutput> rpcResult = RpcResultBuilder
735 .<VnfTopologyOperationOutput>status(true)
736 .withResult(responseBuilder.build())
739 return Futures.immediateFuture(rpcResult);
742 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
743 getServiceData(siid, serviceDataBuilder);
745 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
746 getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
748 // Set the serviceStatus based on input
749 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
750 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
753 // setup a service-data object builder
754 // ACTION vnf-topology-operation
756 // USES sdnc-request-header;
757 // USES request-information;
758 // USES service-information;
759 // USES vnf-request-information
761 // USES vnf-topology-response-body;
762 // USES vnf-information
763 // USES service-information
765 // container service-data
766 // uses vnf-configuration-information;
769 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
770 VnfTopologyOperationInputBuilder inputBuilder = new VnfTopologyOperationInputBuilder(input);
771 GenericResourceApiUtil.toProperties(properties, inputBuilder.build());
773 log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid,
774 operDataBuilder.build());
775 GenericResourceApiUtil.toProperties(properties, OPERATIONAL_DATA_PARAM, operDataBuilder);
777 // Call SLI sync method
778 // Get SvcLogicService reference
780 ResponseObject responseObject = new ResponseObject("200", "");
781 String ackFinal = "Y";
782 String serviceObjectPath = null;
783 Properties respProps = tryGetProperties(svcOperation, properties, serviceDataBuilder, responseObject);
785 if (respProps != null) {
786 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
787 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
788 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
791 /*before was "vfn-object-path", but it didn't make sense, since everywhere else,
792 when extracting service object path the "service-object-path" property is used*/
793 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
796 setServiceStatus(serviceStatusBuilder, responseObject.getStatusCode(), responseObject.getMessage(), ackFinal);
797 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
798 serviceStatusBuilder.setRpcName(svcOperation);
800 if (failed(responseObject)) {
801 responseBuilder.setResponseCode(responseObject.getStatusCode());
802 responseBuilder.setResponseMessage(responseObject.getMessage());
803 responseBuilder.setAckFinalIndicator(ackFinal);
805 ServiceBuilder serviceBuilder = new ServiceBuilder();
806 serviceBuilder.setServiceInstanceId(siid);
807 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
809 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
810 trySaveService(input, serviceBuilder);
811 } catch (Exception e) {
812 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
814 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
816 RpcResult<VnfTopologyOperationOutput> rpcResult = RpcResultBuilder
817 .<VnfTopologyOperationOutput>status(true)
818 .withResult(responseBuilder.build())
822 return Futures.immediateFuture(rpcResult);
825 // Got success from SLI
827 serviceData = serviceDataBuilder.build();
828 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
831 ServiceBuilder serviceBuilder = new ServiceBuilder();
832 serviceBuilder.setServiceData(serviceData);
833 serviceBuilder.setServiceInstanceId(siid);
834 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
835 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
837 if (isValidRequest(input) && input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate)) {
838 // Only update operational tree on Assign
840 log.info(UPDATING_TREE_INFO_MESSAGE);
841 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
844 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
845 serviceResponseInformationBuilder.setInstanceId(siid);
846 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
847 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
849 } catch (Exception e) {
850 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
851 responseBuilder.setResponseCode("500");
852 responseBuilder.setResponseMessage(e.getMessage());
853 responseBuilder.setAckFinalIndicator("Y");
854 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
856 RpcResult<VnfTopologyOperationOutput> rpcResult = RpcResultBuilder
857 .<VnfTopologyOperationOutput>status(true)
858 .withResult(responseBuilder.build())
861 return Futures.immediateFuture(rpcResult);
865 responseBuilder.setResponseCode(responseObject.getStatusCode());
866 responseBuilder.setAckFinalIndicator(ackFinal);
867 trySetResponseMessage(responseBuilder, responseObject);
868 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
869 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
871 RpcResult<VnfTopologyOperationOutput> rpcResult = RpcResultBuilder
872 .<VnfTopologyOperationOutput>status(true)
873 .withResult(responseBuilder.build())
877 return Futures.immediateFuture(rpcResult);
880 private void trySetResponseMessage(VnfTopologyOperationOutputBuilder responseBuilder, ResponseObject error) {
881 if (!error.getMessage().isEmpty()) {
882 responseBuilder.setResponseMessage(error.getMessage());
886 private void trySaveService(VnfTopologyOperationInput input, ServiceBuilder serviceBuilder) {
887 if (isValidRequest(input) &&
888 (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete) ||
889 input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))) {
891 // Only update operational tree on activate or delete
892 log.info(UPDATING_TREE_INFO_MESSAGE);
893 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
897 private boolean hasInvalidVnfId(VnfTopologyOperationInput input) {
898 return input.getVnfInformation() == null || input.getVnfInformation().getVnfId() == null
899 || input.getVnfInformation().getVnfId().length() == 0;
902 private boolean hasInvalidServiceId(VnfTopologyOperationInput input) {
903 return input == null || input.getServiceInformation() == null
904 || input.getServiceInformation().getServiceInstanceId() == null
905 || input.getServiceInformation().getServiceInstanceId().length() == 0;
908 private void trySetSvcRequestId(VnfTopologyOperationInput input,
909 VnfTopologyOperationOutputBuilder responseBuilder) {
910 if (input.getSdncRequestHeader() != null) {
911 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
915 private boolean isValidRequest(VnfTopologyOperationInput input) {
916 return input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null;
920 public Future<RpcResult<VfModuleTopologyOperationOutput>> vfModuleTopologyOperation(
921 VfModuleTopologyOperationInput input) {
923 final String svcOperation = "vf-module-topology-operation";
924 ServiceData serviceData;
925 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
926 Properties parms = new Properties();
928 log.info(CALLED_STR, svcOperation);
929 // create a new response object
930 VfModuleTopologyOperationOutputBuilder responseBuilder = new VfModuleTopologyOperationOutputBuilder();
932 if (hasInvalidServiceId(input)) {
933 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
934 responseBuilder.setResponseCode("403");
935 responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
936 responseBuilder.setAckFinalIndicator("Y");
938 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
939 .<VfModuleTopologyOperationOutput>status(true)
940 .withResult(responseBuilder.build())
944 return Futures.immediateFuture(rpcResult);
947 if (hasInvalidVnfId(input)) {
948 log.debug("exiting {} because of null or empty vnf-id", svcOperation);
949 responseBuilder.setResponseCode("403");
950 responseBuilder.setResponseMessage("invalid input, null or empty vnf-id");
951 responseBuilder.setAckFinalIndicator("Y");
952 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
953 .<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
954 return Futures.immediateFuture(rpcResult);
957 if (hasInvalidVfModuleId(input)) {
958 log.debug("exiting {} because of null or empty vf-module-id", svcOperation);
959 responseBuilder.setResponseCode("403");
960 responseBuilder.setResponseMessage("invalid input, vf-module-id is null or empty");
961 responseBuilder.setAckFinalIndicator("Y");
963 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
964 .<VfModuleTopologyOperationOutput>status(true)
965 .withResult(responseBuilder.build())
968 return Futures.immediateFuture(rpcResult);
971 // Grab the service instance ID from the input buffer
972 String siid = input.getServiceInformation().getServiceInstanceId();
974 trySetSvcRequestId(input, responseBuilder);
976 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
977 getServiceData(siid, serviceDataBuilder);
979 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
980 getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
982 // Set the serviceStatus based on input
983 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
984 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
987 // setup a service-data object builder
988 // ACTION vnf-topology-operation
990 // USES sdnc-request-header;
991 // USES request-information;
992 // USES service-information;
993 // USES vnf-request-information
995 // USES vnf-topology-response-body;
996 // USES vnf-information
997 // USES service-information
999 // container service-data
1000 // uses vnf-configuration-information;
1001 // uses oper-status;
1003 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
1004 VfModuleTopologyOperationInputBuilder inputBuilder = new VfModuleTopologyOperationInputBuilder(input);
1005 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1007 log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid,
1008 operDataBuilder.build());
1009 GenericResourceApiUtil.toProperties(parms, OPERATIONAL_DATA_PARAM, operDataBuilder);
1011 // Call SLI sync method
1012 // Get SvcLogicService reference
1014 ResponseObject responseObject = new ResponseObject("200", "");
1015 String ackFinal = "Y";
1016 String serviceObjectPath = null;
1017 Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, responseObject);
1019 if (respProps != null) {
1020 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
1021 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
1022 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
1026 /*before was "vf-module-object-path", but it didnt make sense, since everywhere else,
1027 when extracting service object path the "service-object-path" property is used*/
1028 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
1031 setServiceStatus(serviceStatusBuilder, responseObject.getStatusCode(), responseObject.getMessage(), ackFinal);
1032 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
1033 serviceStatusBuilder.setRpcName(svcOperation);
1035 if (failed(responseObject)) {
1036 responseBuilder.setResponseCode(responseObject.getStatusCode());
1037 responseBuilder.setResponseMessage(responseObject.getMessage());
1038 responseBuilder.setAckFinalIndicator(ackFinal);
1040 ServiceBuilder serviceBuilder = new ServiceBuilder();
1041 serviceBuilder.setServiceInstanceId(siid);
1042 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1044 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
1045 } catch (Exception e) {
1046 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1048 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1050 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
1051 .<VfModuleTopologyOperationOutput>status(true)
1052 .withResult(responseBuilder.build())
1056 return Futures.immediateFuture(rpcResult);
1059 // Got success from SLI
1061 serviceData = serviceDataBuilder.build();
1062 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
1065 ServiceBuilder serviceBuilder = new ServiceBuilder();
1066 serviceBuilder.setServiceData(serviceData);
1067 serviceBuilder.setServiceInstanceId(siid);
1068 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1069 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1071 trySaveService(input, serviceBuilder);
1073 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1074 serviceResponseInformationBuilder.setInstanceId(siid);
1075 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1076 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1078 } catch (Exception e) {
1079 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1080 responseBuilder.setResponseCode("500");
1081 responseBuilder.setResponseMessage(e.getMessage());
1082 responseBuilder.setAckFinalIndicator("Y");
1083 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1085 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
1086 .<VfModuleTopologyOperationOutput>status(true)
1087 .withResult(responseBuilder.build())
1090 return Futures.immediateFuture(rpcResult);
1094 responseBuilder.setResponseCode(responseObject.getStatusCode());
1095 responseBuilder.setAckFinalIndicator(ackFinal);
1096 trySetResponseMessage(responseBuilder, responseObject);
1097 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
1098 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
1100 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
1101 .<VfModuleTopologyOperationOutput>status(true)
1102 .withResult(responseBuilder.build())
1106 return Futures.immediateFuture(rpcResult);
1109 private void trySetResponseMessage(VfModuleTopologyOperationOutputBuilder responseBuilder, ResponseObject error) {
1110 if (!error.getMessage().isEmpty()) {
1111 responseBuilder.setResponseMessage(error.getMessage());
1115 private void trySaveService(VfModuleTopologyOperationInput input, ServiceBuilder serviceBuilder) {
1116 if (isValidRequest(input) &&
1117 (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Unassign) ||
1118 input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))) {
1119 // Only update operational tree on activate or delete
1121 log.info(UPDATING_TREE_INFO_MESSAGE);
1122 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1126 private void trySetSvcRequestId(VfModuleTopologyOperationInput input,
1127 VfModuleTopologyOperationOutputBuilder responseBuilder) {
1128 if (input.getSdncRequestHeader() != null) {
1129 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1133 private boolean hasInvalidVfModuleId(VfModuleTopologyOperationInput input) {
1134 return input.getVfModuleInformation() == null || input.getVfModuleInformation().getVfModuleId() == null
1135 || input.getVfModuleInformation().getVfModuleId().length() == 0;
1138 private boolean hasInvalidVnfId(VfModuleTopologyOperationInput input) {
1139 return input.getVnfInformation() == null || input.getVnfInformation().getVnfId() == null
1140 || input.getVnfInformation().getVnfId().length() == 0;
1143 private boolean hasInvalidServiceId(VfModuleTopologyOperationInput input) {
1144 return input == null || input.getServiceInformation() == null
1145 || input.getServiceInformation().getServiceInstanceId() == null
1146 || input.getServiceInformation().getServiceInstanceId().length() == 0;
1149 private boolean isValidRequest(VfModuleTopologyOperationInput input) {
1150 return input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null;
1154 public Future<RpcResult<NetworkTopologyOperationOutput>> networkTopologyOperation(
1155 NetworkTopologyOperationInput input) {
1157 final String svcOperation = "network-topology-operation";
1158 ServiceData serviceData;
1159 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1160 Properties parms = new Properties();
1162 log.info(CALLED_STR, svcOperation);
1163 // create a new response object
1164 NetworkTopologyOperationOutputBuilder responseBuilder = new NetworkTopologyOperationOutputBuilder();
1166 if (hasInvalidServiceId(input)) {
1167 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
1168 return buildRpcResultFuture(responseBuilder, NULL_OR_EMPTY_ERROR_PARAM);
1171 String siid = input.getServiceInformation().getServiceInstanceId();
1173 // Get the service-instance service data from MD-SAL
1174 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1175 getServiceData(siid, serviceDataBuilder);
1177 this.trySetSvcRequestId(input, responseBuilder);
1179 ServiceData sd = serviceDataBuilder.build();
1180 if (isInvalidServiceData(sd)) {
1181 log.debug(EMPTY_SERVICE_INSTANCE_MESSAGE, svcOperation);
1182 return buildRpcResultFuture(responseBuilder, INVALID_INPUT_ERROR_MESSAGE);
1185 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
1186 NetworkTopologyOperationInputBuilder inputBuilder = new NetworkTopologyOperationInputBuilder(input);
1187 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1189 // Call SLI sync method
1190 // Get SvcLogicService reference
1192 ResponseObject responseObject = new ResponseObject("200", "");
1193 String ackFinal = "Y";
1194 String networkId = ERROR_NETWORK_ID;
1195 String serviceObjectPath = null;
1196 String networkObjectPath = null;
1197 Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, responseObject);
1199 if (respProps != null) {
1200 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
1201 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
1202 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
1203 networkId = respProps.getProperty("networkId");
1204 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
1205 networkObjectPath = respProps.getProperty("network-object-path");
1208 if (failed(responseObject)) {
1209 responseBuilder.setResponseCode(responseObject.getStatusCode());
1210 responseBuilder.setResponseMessage(responseObject.getMessage());
1211 responseBuilder.setAckFinalIndicator(ackFinal);
1213 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1215 RpcResult<NetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
1216 .<NetworkTopologyOperationOutput>status(true)
1217 .withResult(responseBuilder.build())
1220 return Futures.immediateFuture(rpcResult);
1223 // Got success from SLI
1226 serviceData = serviceDataBuilder.build();
1227 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
1230 ServiceBuilder serviceBuilder = new ServiceBuilder();
1231 serviceBuilder.setServiceData(serviceData);
1232 serviceBuilder.setServiceInstanceId(siid);
1233 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1234 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1236 trySaveService(input, serviceBuilder);
1238 NetworkResponseInformationBuilder networkResponseInformationBuilder = new NetworkResponseInformationBuilder();
1239 networkResponseInformationBuilder.setInstanceId(networkId);
1240 networkResponseInformationBuilder.setObjectPath(networkObjectPath);
1241 responseBuilder.setNetworkResponseInformation(networkResponseInformationBuilder.build());
1243 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1244 serviceResponseInformationBuilder.setInstanceId(siid);
1245 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1246 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1248 } catch (IllegalStateException e) {
1249 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1250 responseBuilder.setResponseCode("500");
1251 responseBuilder.setResponseMessage(e.getMessage());
1252 responseBuilder.setAckFinalIndicator("Y");
1253 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1255 RpcResult<NetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
1256 .<NetworkTopologyOperationOutput>status(true)
1257 .withResult(responseBuilder.build())
1260 return Futures.immediateFuture(rpcResult);
1264 responseBuilder.setResponseCode(responseObject.getStatusCode());
1265 responseBuilder.setAckFinalIndicator(ackFinal);
1266 trySetResponseMessage(responseBuilder, responseObject);
1267 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
1268 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
1270 RpcResult<NetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
1271 .<NetworkTopologyOperationOutput>status(true)
1272 .withResult(responseBuilder.build())
1275 return Futures.immediateFuture(rpcResult);
1278 private void trySetResponseMessage(NetworkTopologyOperationOutputBuilder responseBuilder, ResponseObject error) {
1279 if (!error.getMessage().isEmpty()) {
1280 responseBuilder.setResponseMessage(error.getMessage());
1284 private void trySetSvcRequestId(NetworkTopologyOperationInput input,
1285 NetworkTopologyOperationOutputBuilder responseBuilder) {
1286 if (input.getSdncRequestHeader() != null) {
1287 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1291 private void trySaveService(NetworkTopologyOperationInput input, ServiceBuilder serviceBuilder) {
1292 if (isValidRequest(input) &&
1293 (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate) ||
1294 input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Create))) {
1295 // Only update operational tree on Activate
1296 log.info(UPDATING_TREE_INFO_MESSAGE);
1297 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1301 private boolean hasInvalidServiceId(NetworkTopologyOperationInput input) {
1302 return input == null || input.getServiceInformation() == null
1303 || input.getServiceInformation().getServiceInstanceId() == null
1304 || input.getServiceInformation().getServiceInstanceId().length() == 0;
1307 private Future<RpcResult<NetworkTopologyOperationOutput>> buildRpcResultFuture(
1308 NetworkTopologyOperationOutputBuilder responseBuilder, String responseMessage) {
1310 responseBuilder.setResponseCode("404");
1312 .setResponseMessage(responseMessage);
1313 responseBuilder.setAckFinalIndicator("Y");
1315 RpcResult<NetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
1316 .<NetworkTopologyOperationOutput>status(true)
1317 .withResult(responseBuilder.build())
1320 return Futures.immediateFuture(rpcResult);
1323 private boolean isValidRequest(NetworkTopologyOperationInput input) {
1324 return input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null;
1328 public Future<RpcResult<ContrailRouteTopologyOperationOutput>> contrailRouteTopologyOperation(
1329 ContrailRouteTopologyOperationInput input) {
1331 final String svcOperation = "contrail-route-topology-operation";
1332 ServiceData serviceData;
1333 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1334 Properties properties = new Properties();
1336 log.info(CALLED_STR, svcOperation);
1337 // create a new response object
1338 ContrailRouteTopologyOperationOutputBuilder responseBuilder = new ContrailRouteTopologyOperationOutputBuilder();
1340 if (hasInvalidServiceId(input)) {
1341 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
1342 return buildRpcResultFuture(responseBuilder, NULL_OR_EMPTY_ERROR_PARAM);
1345 String siid = input.getServiceInformation().getServiceInstanceId();
1347 // Get the service-instance service data from MD-SAL
1348 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1349 getServiceData(siid, serviceDataBuilder);
1351 trySetSvcRequestId(input, responseBuilder);
1353 ServiceData sd = serviceDataBuilder.build();
1354 if (isInvalidServiceData(sd)) {
1355 log.debug(EMPTY_SERVICE_INSTANCE_MESSAGE, svcOperation);
1356 return buildRpcResultFuture(responseBuilder, INVALID_INPUT_ERROR_MESSAGE);
1359 log.info("Adding INPUT data for " + svcOperation + " [" + siid + "] input: " + input);
1360 ContrailRouteTopologyOperationInputBuilder inputBuilder = new ContrailRouteTopologyOperationInputBuilder(input);
1361 GenericResourceApiUtil.toProperties(properties, inputBuilder.build());
1363 // Call SLI sync method
1364 // Get SvcLogicService reference
1365 ResponseObject error = new ResponseObject("200", "");
1366 String ackFinal = "Y";
1367 String allottedResourceId = ERROR_NETWORK_ID;
1368 String serviceObjectPath = null;
1369 String contrailRouteObjectPath = null;
1370 Properties respProps = tryGetProperties(svcOperation, properties, serviceDataBuilder, error);
1372 if (respProps != null) {
1373 error.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
1374 error.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
1375 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
1376 allottedResourceId = respProps.getProperty(ALLOTTED_RESOURCE_ID_PARAM);
1377 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
1378 contrailRouteObjectPath = respProps.getProperty("contrail-route-object-path");
1381 if (failed(error)) {
1382 responseBuilder.setResponseCode(error.getStatusCode());
1383 responseBuilder.setResponseMessage(error.getMessage());
1384 responseBuilder.setAckFinalIndicator(ackFinal);
1385 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1387 RpcResult<ContrailRouteTopologyOperationOutput> rpcResult = RpcResultBuilder
1388 .<ContrailRouteTopologyOperationOutput>status(true)
1389 .withResult(responseBuilder.build())
1392 return Futures.immediateFuture(rpcResult);
1395 // Got success from SLI
1397 serviceData = serviceDataBuilder.build();
1398 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
1401 ServiceBuilder serviceBuilder = new ServiceBuilder();
1402 serviceBuilder.setServiceData(serviceData);
1403 serviceBuilder.setServiceInstanceId(siid);
1404 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1405 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1407 trySaveService(input, serviceBuilder);
1409 ContrailRouteResponseInformationBuilder contrailRouteResponseInformationBuilder = new ContrailRouteResponseInformationBuilder();
1410 contrailRouteResponseInformationBuilder.setInstanceId(allottedResourceId);
1411 contrailRouteResponseInformationBuilder.setObjectPath(contrailRouteObjectPath);
1412 responseBuilder.setContrailRouteResponseInformation(contrailRouteResponseInformationBuilder.build());
1414 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1415 serviceResponseInformationBuilder.setInstanceId(siid);
1416 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1417 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1419 } catch (IllegalStateException e) {
1420 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1421 responseBuilder.setResponseCode("500");
1422 responseBuilder.setResponseMessage(e.getMessage());
1423 responseBuilder.setAckFinalIndicator("Y");
1424 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1426 RpcResult<ContrailRouteTopologyOperationOutput> rpcResult = RpcResultBuilder
1427 .<ContrailRouteTopologyOperationOutput>status(true)
1428 .withResult(responseBuilder.build())
1431 return Futures.immediateFuture(rpcResult);
1435 responseBuilder.setResponseCode(error.getStatusCode());
1436 responseBuilder.setAckFinalIndicator(ackFinal);
1437 trySetResponseMessage(responseBuilder, error);
1438 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
1439 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
1441 RpcResult<ContrailRouteTopologyOperationOutput> rpcResult = RpcResultBuilder
1442 .<ContrailRouteTopologyOperationOutput>status(true)
1443 .withResult(responseBuilder.build())
1446 return Futures.immediateFuture(rpcResult);
1449 private void trySetResponseMessage(ContrailRouteTopologyOperationOutputBuilder responseBuilder,
1450 ResponseObject error) {
1451 if (!error.getMessage().isEmpty()) {
1452 responseBuilder.setResponseMessage(error.getMessage());
1456 private void trySaveService(ContrailRouteTopologyOperationInput input, ServiceBuilder serviceBuilder) {
1457 if (isValidRequest(input) &&
1458 (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Unassign) ||
1459 input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))) {
1460 // Only update operational tree on activate or delete
1461 log.info(UPDATING_TREE_INFO_MESSAGE);
1462 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1466 private void trySetSvcRequestId(ContrailRouteTopologyOperationInput input,
1467 ContrailRouteTopologyOperationOutputBuilder responseBuilder) {
1468 if (input.getSdncRequestHeader() != null) {
1469 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1473 private boolean hasInvalidServiceId(ContrailRouteTopologyOperationInput input) {
1474 return input == null || input.getServiceInformation() == null
1475 || input.getServiceInformation().getServiceInstanceId() == null
1476 || input.getServiceInformation().getServiceInstanceId().length() == 0;
1479 private Future<RpcResult<ContrailRouteTopologyOperationOutput>>
1480 buildRpcResultFuture(ContrailRouteTopologyOperationOutputBuilder responseBuilder, String responseMessage) {
1482 responseBuilder.setResponseCode("404");
1483 responseBuilder.setResponseMessage(responseMessage);
1484 responseBuilder.setAckFinalIndicator("Y");
1486 RpcResult<ContrailRouteTopologyOperationOutput> rpcResult = RpcResultBuilder
1487 .<ContrailRouteTopologyOperationOutput>status(true)
1488 .withResult(responseBuilder.build())
1491 return Futures.immediateFuture(rpcResult);
1494 private boolean isValidRequest(ContrailRouteTopologyOperationInput input) {
1495 return input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null;
1499 public Future<RpcResult<SecurityZoneTopologyOperationOutput>> securityZoneTopologyOperation(
1500 SecurityZoneTopologyOperationInput input) {
1502 final String svcOperation = "security-zone-topology-operation";
1503 ServiceData serviceData;
1504 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1505 Properties parms = new Properties();
1507 log.info(CALLED_STR, svcOperation);
1508 // create a new response object
1509 SecurityZoneTopologyOperationOutputBuilder responseBuilder = new SecurityZoneTopologyOperationOutputBuilder();
1511 if (this.hasInvalidServiceId(input)) {
1512 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
1513 return buildRpcResultFuture(responseBuilder, NULL_OR_EMPTY_ERROR_PARAM);
1516 String siid = input.getServiceInformation().getServiceInstanceId();
1518 // Get the service-instance service data from MD-SAL
1519 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1520 getServiceData(siid, serviceDataBuilder);
1521 trySetSvcRequestId(input, responseBuilder);
1523 ServiceData sd = serviceDataBuilder.build();
1524 if (isInvalidServiceData(sd)) {
1525 log.debug(EMPTY_SERVICE_INSTANCE_MESSAGE, svcOperation);
1526 return buildRpcResultFuture(responseBuilder, INVALID_INPUT_ERROR_MESSAGE);
1529 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
1530 SecurityZoneTopologyOperationInputBuilder inputBuilder = new SecurityZoneTopologyOperationInputBuilder(input);
1531 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1533 // Call SLI sync method
1534 // Get SvcLogicService reference
1536 Properties respProps = null;
1538 ResponseObject responseObject = new ResponseObject("200", "");
1539 String ackFinal = "Y";
1540 String allottedResourceId = ERROR_NETWORK_ID;
1541 String serviceObjectPath = null;
1542 String securityZoneObjectPath = null;
1545 if (svcLogicClient.hasGraph(APP_NAME, svcOperation, null, "sync")) {
1548 respProps = svcLogicClient.execute(APP_NAME, svcOperation, null, "sync", serviceDataBuilder, parms);
1549 } catch (Exception e) {
1550 log.error(SERVICE_LOGIC_EXECUTION_ERROR_MESSAGE, svcOperation, e);
1551 responseObject.setMessage(e.getMessage());
1552 responseObject.setStatusCode("500");
1555 responseObject.setMessage(NO_SERVICE_LOGIC_ACTIVE + APP_NAME + ": '" + svcOperation + "'");
1556 responseObject.setStatusCode("503");
1558 } catch (Exception e) {
1559 responseObject.setStatusCode("500");
1560 responseObject.setMessage(e.getMessage());
1561 log.error(SERVICE_LOGIC_SEARCH_ERROR_MESSAGE, e);
1564 if (respProps != null) {
1565 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
1566 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
1567 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
1568 allottedResourceId = respProps.getProperty(ALLOTTED_RESOURCE_ID_PARAM);
1569 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
1570 securityZoneObjectPath = respProps.getProperty("security-zone-object-path");
1573 if (failed(responseObject)) {
1574 responseBuilder.setResponseCode(responseObject.getStatusCode());
1575 responseBuilder.setResponseMessage(responseObject.getMessage());
1576 responseBuilder.setAckFinalIndicator(ackFinal);
1577 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1579 RpcResult<SecurityZoneTopologyOperationOutput> rpcResult = RpcResultBuilder
1580 .<SecurityZoneTopologyOperationOutput>status(true)
1581 .withResult(responseBuilder.build())
1584 return Futures.immediateFuture(rpcResult);
1587 // Got success from SLI
1590 serviceData = serviceDataBuilder.build();
1591 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
1594 ServiceBuilder serviceBuilder = new ServiceBuilder();
1595 serviceBuilder.setServiceData(serviceData);
1596 serviceBuilder.setServiceInstanceId(siid);
1597 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1598 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1600 trySaveService(input, serviceBuilder);
1602 SecurityZoneResponseInformationBuilder securityZoneResponseInformationBuilder = new SecurityZoneResponseInformationBuilder();
1603 securityZoneResponseInformationBuilder.setInstanceId(allottedResourceId);
1604 securityZoneResponseInformationBuilder.setObjectPath(securityZoneObjectPath);
1605 responseBuilder.setSecurityZoneResponseInformation(securityZoneResponseInformationBuilder.build());
1607 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1608 serviceResponseInformationBuilder.setInstanceId(siid);
1609 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1610 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1612 } catch (IllegalStateException e) {
1613 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1614 responseBuilder.setResponseCode("500");
1615 responseBuilder.setResponseMessage(e.getMessage());
1616 responseBuilder.setAckFinalIndicator("Y");
1617 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1619 RpcResult<SecurityZoneTopologyOperationOutput> rpcResult = RpcResultBuilder
1620 .<SecurityZoneTopologyOperationOutput>status(true)
1621 .withResult(responseBuilder.build())
1624 return Futures.immediateFuture(rpcResult);
1628 responseBuilder.setResponseCode(responseObject.getStatusCode());
1629 responseBuilder.setAckFinalIndicator(ackFinal);
1630 trySetResponseMessage(responseBuilder, responseObject);
1631 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
1632 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
1634 RpcResult<SecurityZoneTopologyOperationOutput> rpcResult = RpcResultBuilder
1635 .<SecurityZoneTopologyOperationOutput>status(true)
1636 .withResult(responseBuilder.build())
1639 return Futures.immediateFuture(rpcResult);
1642 private void trySetResponseMessage(SecurityZoneTopologyOperationOutputBuilder responseBuilder,
1643 ResponseObject error) {
1644 if (!error.getMessage().isEmpty()) {
1645 responseBuilder.setResponseMessage(error.getMessage());
1649 private void trySaveService(SecurityZoneTopologyOperationInput input, ServiceBuilder serviceBuilder) {
1650 if (isValidRequest(input) &&
1651 (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Unassign) ||
1652 input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))) {
1653 // Only update operational tree on activate or delete
1654 log.info(UPDATING_TREE_INFO_MESSAGE);
1655 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1659 private void trySetSvcRequestId(SecurityZoneTopologyOperationInput input,
1660 SecurityZoneTopologyOperationOutputBuilder responseBuilder) {
1661 if (input.getSdncRequestHeader() != null) {
1662 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1666 private boolean isInvalidServiceData(ServiceData sd) {
1667 return sd == null || sd.getServiceLevelOperStatus() == null;
1670 private boolean hasInvalidServiceId(SecurityZoneTopologyOperationInput input) {
1671 return input == null || input.getServiceInformation() == null
1672 || input.getServiceInformation().getServiceInstanceId() == null
1673 || input.getServiceInformation().getServiceInstanceId().length() == 0;
1676 private Future<RpcResult<SecurityZoneTopologyOperationOutput>>
1677 buildRpcResultFuture(SecurityZoneTopologyOperationOutputBuilder responseBuilder, String responseMessage) {
1679 responseBuilder.setResponseCode("404");
1680 responseBuilder.setResponseMessage(responseMessage);
1681 responseBuilder.setAckFinalIndicator("Y");
1683 RpcResult<SecurityZoneTopologyOperationOutput> rpcResult = RpcResultBuilder
1684 .<SecurityZoneTopologyOperationOutput>status(true)
1685 .withResult(responseBuilder.build())
1688 return Futures.immediateFuture(rpcResult);
1691 private boolean isValidRequest(SecurityZoneTopologyOperationInput input) {
1692 return input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null;
1696 public Future<RpcResult<TunnelxconnTopologyOperationOutput>> tunnelxconnTopologyOperation(
1697 TunnelxconnTopologyOperationInput input) {
1699 final String svcOperation = "tunnelxconn-topology-operation";
1700 Properties parms = new Properties();
1701 log.info(CALLED_STR, svcOperation);
1703 // create a new response object
1704 TunnelxconnTopologyOperationOutputBuilder responseBuilder = new TunnelxconnTopologyOperationOutputBuilder();
1705 if (hasInvalidServiceId(input)) {
1706 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
1707 responseBuilder.setResponseCode("404");
1708 responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
1709 responseBuilder.setAckFinalIndicator("Y");
1711 RpcResult<TunnelxconnTopologyOperationOutput> rpcResult = RpcResultBuilder
1712 .<TunnelxconnTopologyOperationOutput>status(true)
1713 .withResult(responseBuilder.build())
1716 return Futures.immediateFuture(rpcResult);
1718 String siid = input.getServiceInformation().getServiceInstanceId();
1719 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
1720 TunnelxconnTopologyOperationInputBuilder inputBuilder = new TunnelxconnTopologyOperationInputBuilder(input);
1721 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1723 // Call SLI sync method
1724 // Get SvcLogicService reference
1725 ResponseObject responseObject = new ResponseObject("200", "");
1726 String ackFinal = "Y";
1727 String allottedResourceId = ERROR_NETWORK_ID;
1728 String serviceObjectPath = null;
1729 String tunnelxconnObjectPath = null;
1730 Properties respProps = tryGetProperties(svcOperation, parms, responseObject);
1732 if (respProps != null) {
1733 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
1734 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
1735 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
1736 allottedResourceId = respProps.getProperty(ALLOTTED_RESOURCE_ID_PARAM);
1737 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
1738 tunnelxconnObjectPath = respProps.getProperty("tunnelxconn-object-path");
1741 if (failed(responseObject)) {
1742 responseBuilder.setResponseCode(responseObject.getStatusCode());
1743 responseBuilder.setResponseMessage(responseObject.getMessage());
1744 responseBuilder.setAckFinalIndicator(ackFinal);
1746 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1748 RpcResult<TunnelxconnTopologyOperationOutput> rpcResult = RpcResultBuilder
1749 .<TunnelxconnTopologyOperationOutput>status(true)
1750 .withResult(responseBuilder.build())
1753 return Futures.immediateFuture(rpcResult);
1756 // Got success from SLI
1758 TunnelxconnResponseInformationBuilder tunnelxconnResponseInformationBuilder = new TunnelxconnResponseInformationBuilder();
1759 tunnelxconnResponseInformationBuilder.setInstanceId(allottedResourceId);
1760 tunnelxconnResponseInformationBuilder.setObjectPath(tunnelxconnObjectPath);
1761 responseBuilder.setTunnelxconnResponseInformation(tunnelxconnResponseInformationBuilder.build());
1763 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1764 serviceResponseInformationBuilder.setInstanceId(siid);
1765 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1766 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1768 } catch (IllegalStateException e) {
1769 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1770 responseBuilder.setResponseCode("500");
1771 responseBuilder.setResponseMessage(e.toString());
1772 responseBuilder.setAckFinalIndicator("Y");
1773 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1775 RpcResult<TunnelxconnTopologyOperationOutput> rpcResult = RpcResultBuilder
1776 .<TunnelxconnTopologyOperationOutput>status(true)
1777 .withResult(responseBuilder.build())
1780 return Futures.immediateFuture(rpcResult);
1784 responseBuilder.setResponseCode(responseObject.getStatusCode());
1785 responseBuilder.setAckFinalIndicator(ackFinal);
1786 trySetResponseMessage(responseBuilder, responseObject);
1787 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
1788 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
1790 RpcResult<TunnelxconnTopologyOperationOutput> rpcResult = RpcResultBuilder
1791 .<TunnelxconnTopologyOperationOutput>status(true)
1792 .withResult(responseBuilder.build())
1795 return Futures.immediateFuture(rpcResult);
1798 private void trySetResponseMessage(TunnelxconnTopologyOperationOutputBuilder responseBuilder,
1799 ResponseObject error) {
1800 if (!error.getMessage().isEmpty()) {
1801 responseBuilder.setResponseMessage(error.getMessage());
1805 private boolean hasInvalidServiceId(TunnelxconnTopologyOperationInput input) {
1806 return input == null || input.getServiceInformation() == null
1807 || input.getServiceInformation().getServiceInstanceId() == null
1808 || input.getServiceInformation().getServiceInstanceId().length() == 0;
1811 private Properties tryGetProperties(String svcOperation, Properties parms, ResponseObject responseObject) {
1813 if (svcLogicClient.hasGraph(APP_NAME, svcOperation, null, "sync")) {
1816 return svcLogicClient.execute(APP_NAME, svcOperation, null, "sync", parms);
1817 } catch (Exception e) {
1818 log.error(SERVICE_LOGIC_EXECUTION_ERROR_MESSAGE, svcOperation, e);
1819 responseObject.setMessage(e.getMessage());
1820 responseObject.setStatusCode("500");
1823 responseObject.setMessage(NO_SERVICE_LOGIC_ACTIVE + APP_NAME + ": '" + svcOperation + "'");
1824 responseObject.setStatusCode("503");
1826 } catch (Exception e) {
1827 responseObject.setMessage(e.getMessage());
1828 responseObject.setStatusCode("500");
1829 log.error(SERVICE_LOGIC_SEARCH_ERROR_MESSAGE, e);
1835 public Future<RpcResult<BrgTopologyOperationOutput>> brgTopologyOperation(BrgTopologyOperationInput input) {
1836 final String svcOperation = "brg-topology-operation";
1837 Properties parms = new Properties();
1839 log.info(CALLED_STR, svcOperation);
1840 // create a new response object
1841 BrgTopologyOperationOutputBuilder responseBuilder = new BrgTopologyOperationOutputBuilder();
1843 if (this.hasInvalidServiceId(input)) {
1845 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
1846 responseBuilder.setResponseCode("404");
1847 responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
1848 responseBuilder.setAckFinalIndicator("Y");
1850 RpcResult<BrgTopologyOperationOutput> rpcResult = RpcResultBuilder
1851 .<BrgTopologyOperationOutput>status(true)
1852 .withResult(responseBuilder.build())
1855 return Futures.immediateFuture(rpcResult);
1858 String siid = input.getServiceInformation().getServiceInstanceId();
1860 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
1861 BrgTopologyOperationInputBuilder inputBuilder = new BrgTopologyOperationInputBuilder(input);
1862 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1864 // Call SLI sync method
1865 // Get SvcLogicService reference
1866 ResponseObject error = new ResponseObject("200", "");
1867 String ackFinal = "Y";
1868 String allottedResourceId = ERROR_NETWORK_ID;
1869 String serviceObjectPath = null;
1870 String brgObjectPath = null;
1871 Properties respProps = tryGetProperties(svcOperation, parms, error);
1873 if (respProps != null) {
1874 error.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
1875 error.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
1876 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
1877 allottedResourceId = respProps.getProperty(ALLOTTED_RESOURCE_ID_PARAM);
1878 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
1879 brgObjectPath = respProps.getProperty("brg-object-path");
1882 if (failed(error)) {
1883 responseBuilder.setResponseCode(error.getStatusCode());
1884 responseBuilder.setResponseMessage(error.getMessage());
1885 responseBuilder.setAckFinalIndicator(ackFinal);
1887 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1888 RpcResult<BrgTopologyOperationOutput> rpcResult = RpcResultBuilder
1889 .<BrgTopologyOperationOutput>status(true)
1890 .withResult(responseBuilder.build())
1893 return Futures.immediateFuture(rpcResult);
1896 // Got success from SLI
1899 BrgResponseInformationBuilder brgResponseInformationBuilder = new BrgResponseInformationBuilder();
1900 brgResponseInformationBuilder.setInstanceId(allottedResourceId);
1901 brgResponseInformationBuilder.setObjectPath(brgObjectPath);
1902 responseBuilder.setBrgResponseInformation(brgResponseInformationBuilder.build());
1904 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1905 serviceResponseInformationBuilder.setInstanceId(siid);
1906 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1907 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1909 } catch (IllegalStateException e) {
1910 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1911 responseBuilder.setResponseCode("500");
1912 responseBuilder.setResponseMessage(e.toString());
1913 responseBuilder.setAckFinalIndicator("Y");
1914 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1916 RpcResult<BrgTopologyOperationOutput> rpcResult = RpcResultBuilder
1917 .<BrgTopologyOperationOutput>status(true)
1918 .withResult(responseBuilder.build())
1921 return Futures.immediateFuture(rpcResult);
1925 responseBuilder.setResponseCode(error.getStatusCode());
1926 responseBuilder.setAckFinalIndicator(ackFinal);
1927 trySetResponseMessage(responseBuilder, error);
1928 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
1929 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
1931 RpcResult<BrgTopologyOperationOutput> rpcResult = RpcResultBuilder
1932 .<BrgTopologyOperationOutput>status(true)
1933 .withResult(responseBuilder.build())
1936 return Futures.immediateFuture(rpcResult);
1939 private void trySetResponseMessage(BrgTopologyOperationOutputBuilder responseBuilder, ResponseObject error) {
1940 if (!error.getMessage().isEmpty()) {
1941 responseBuilder.setResponseMessage(error.getMessage());
1945 private boolean hasInvalidServiceId(BrgTopologyOperationInput input) {
1946 return input == null || input.getServiceInformation() == null
1947 || input.getServiceInformation().getServiceInstanceId() == null
1948 || input.getServiceInformation().getServiceInstanceId().length() == 0;
1952 public Future<RpcResult<PreloadVnfTopologyOperationOutput>> preloadVnfTopologyOperation(
1953 PreloadVnfTopologyOperationInput input) {
1955 final String svcOperation = "preload-vnf-topology-operation";
1956 Properties parms = new Properties();
1958 log.info(CALLED_STR, svcOperation);
1959 // create a new response object
1960 PreloadVnfTopologyOperationOutputBuilder responseBuilder = new PreloadVnfTopologyOperationOutputBuilder();
1962 if (hasInvalidVnfTopology(input)) {
1964 log.debug("exiting {} because of null input", svcOperation);
1965 responseBuilder.setResponseCode("403");
1966 responseBuilder.setResponseMessage("invalid input: input is null");
1967 responseBuilder.setAckFinalIndicator("Y");
1969 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult = RpcResultBuilder
1970 .<PreloadVnfTopologyOperationOutput>status(true)
1971 .withResult(responseBuilder.build())
1974 return Futures.immediateFuture(rpcResult);
1977 // Grab the name and type from the input buffer
1978 String preloadName = input.getVnfTopologyInformation().getVnfTopologyIdentifier().getVnfName();
1979 String preloadType = input.getVnfTopologyInformation().getVnfTopologyIdentifier().getVnfType();
1981 // Make sure we have a preload_name and preload_type
1982 if (invalidPreloadData(preloadName, preloadType)) {
1983 log.debug("exiting {} vnf-name or vnf-type is null or empty", svcOperation);
1984 responseBuilder.setResponseCode("403");
1985 responseBuilder.setResponseMessage("invalid input: vnf-name or vnf-type is null or empty");
1986 responseBuilder.setAckFinalIndicator("Y");
1988 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult = RpcResultBuilder
1989 .<PreloadVnfTopologyOperationOutput>status(true)
1990 .withResult(responseBuilder.build())
1993 return Futures.immediateFuture(rpcResult);
1996 trySetSvcRequestId(input, responseBuilder);
1998 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
1999 getPreloadData(preloadName, preloadType, preloadDataBuilder);
2001 PreloadDataBuilder operDataBuilder = new PreloadDataBuilder();
2002 getPreloadData(preloadName, preloadType, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
2004 // setup a preload-data object builder
2005 // ACTION preload-vnf-topology-operation
2007 // USES sdnc-request-header;
2008 // USES request-information;
2009 // uses vnf-topology-information;
2011 // USES vnf-topology-response-body;
2013 // container preload-data
2014 // uses vnf-topology-information;
2015 // uses network-topology-information;
2016 // uses oper-status;
2018 log.info("Adding INPUT data for {} [{},{}] input: {}", svcOperation, preloadName, preloadType, input);
2019 PreloadVnfTopologyOperationInputBuilder inputBuilder = new PreloadVnfTopologyOperationInputBuilder(input);
2020 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
2021 log.info("Adding OPERATIONAL data for {} [{},{}] operational-data: {}", svcOperation, preloadName,
2022 preloadType, operDataBuilder.build());
2023 GenericResourceApiUtil.toProperties(parms, OPERATIONAL_DATA_PARAM, operDataBuilder);
2025 // Call SLI sync method
2026 // Get SvcLogicService reference
2027 ResponseObject responseObject = new ResponseObject("200", "");
2028 Properties respProps = tryGetProperties(svcOperation, parms, responseObject);
2029 String ackFinal = resolveAckFinal(responseObject, respProps);
2031 if (failed(responseObject)) {
2033 responseBuilder.setResponseCode(responseObject.getStatusCode());
2034 responseBuilder.setResponseMessage(responseObject.getMessage());
2035 responseBuilder.setAckFinalIndicator(ackFinal);
2037 VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
2038 preloadVnfListBuilder.setVnfName(preloadName);
2039 preloadVnfListBuilder.setVnfType(preloadType);
2040 preloadVnfListBuilder.setPreloadData(preloadDataBuilder.build());
2041 log.error("Returned FAILED for {} [{},{}] error code: '{}', Reason: '{}'", svcOperation, preloadName,
2042 preloadType, responseObject.getStatusCode(), responseObject.getMessage());
2044 savePreloadList(preloadVnfListBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
2045 } catch (Exception e) {
2046 log.error(UPDATING_MDSAL_ERROR_MESSAGE_2, svcOperation, preloadName,
2049 log.debug("Sending Success rpc result due to external error");
2051 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult = RpcResultBuilder
2052 .<PreloadVnfTopologyOperationOutput>status(true)
2053 .withResult(responseBuilder.build())
2056 return Futures.immediateFuture(rpcResult);
2059 // Got success from SLI
2061 updatePreloadData(svcOperation, preloadName, preloadType, preloadDataBuilder);
2062 } catch (Exception e) {
2063 log.error(UPDATING_MDSAL_ERROR_MESSAGE_2, svcOperation, preloadName, preloadType,
2065 responseBuilder.setResponseCode("500");
2066 responseBuilder.setResponseMessage(e.getMessage());
2067 responseBuilder.setAckFinalIndicator("Y");
2068 log.error("Returned FAILED for {} [{},{}] {}", svcOperation, preloadName, preloadType,
2069 responseBuilder.build());
2071 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult = RpcResultBuilder
2072 .<PreloadVnfTopologyOperationOutput>status(false)
2073 .withResult(responseBuilder.build())
2076 return Futures.immediateFuture(rpcResult);
2080 responseBuilder.setResponseCode(responseObject.getStatusCode());
2081 responseBuilder.setAckFinalIndicator(ackFinal);
2082 trySetResponseMessage(responseBuilder, responseObject);
2084 log.info("Updated MD-SAL for {} [{},{}]", svcOperation, preloadName, preloadType);
2085 log.info("Returned SUCCESS for {} [{},{}] {}", svcOperation, preloadName, preloadType,
2086 responseBuilder.build());
2088 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult = RpcResultBuilder
2089 .<PreloadVnfTopologyOperationOutput>status(true)
2090 .withResult(responseBuilder.build())
2093 return Futures.immediateFuture(rpcResult);
2096 private String resolveAckFinal(ResponseObject responseObject, Properties respProps) {
2097 if (respProps != null) {
2098 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
2099 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
2100 return respProps.getProperty(ACK_FINAL_PARAM, "Y");
2105 private void trySetResponseMessage(PreloadVnfTopologyOperationOutputBuilder responseBuilder, ResponseObject error) {
2106 if (!error.getMessage().isEmpty()) {
2107 responseBuilder.setResponseMessage(error.getMessage());
2111 private void trySetSvcRequestId(PreloadVnfTopologyOperationInput input,
2112 PreloadVnfTopologyOperationOutputBuilder responseBuilder) {
2113 if (input.getSdncRequestHeader() != null) {
2114 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
2118 private boolean hasInvalidVnfTopology(PreloadVnfTopologyOperationInput input) {
2119 return input == null || input.getVnfTopologyInformation() == null
2120 || input.getVnfTopologyInformation().getVnfTopologyIdentifier() == null;
2123 private void updatePreloadData(String svcOperation, String preloadName, String preloadType,
2124 PreloadDataBuilder preloadDataBuilder) {
2125 PreloadData preloadData;
2126 preloadData = preloadDataBuilder.build();
2127 log.info("Updating MD-SAL for {} [{},{}] preloadData: {}", svcOperation, preloadName, preloadType,
2129 // svc-configuration-list
2130 VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
2131 preloadVnfListBuilder.setVnfName(preloadName);
2132 preloadVnfListBuilder.setVnfType(preloadType);
2133 preloadVnfListBuilder.setPreloadData(preloadData);
2135 // merge flag sets to false to allow it to be overwritten (not appended)
2136 savePreloadList(preloadVnfListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
2137 log.info(UPDATING_TREE_INFO_MESSAGE);
2138 savePreloadList(preloadVnfListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
2142 public Future<RpcResult<PreloadNetworkTopologyOperationOutput>> preloadNetworkTopologyOperation(
2143 PreloadNetworkTopologyOperationInput input) {
2145 final String svcOperation = "preload-network-topology-operation";
2146 Properties parms = new Properties();
2148 log.info(CALLED_STR, svcOperation);
2149 // create a new response object
2150 PreloadNetworkTopologyOperationOutputBuilder responseBuilder = new PreloadNetworkTopologyOperationOutputBuilder();
2152 if (hasInvalidNetworkTopology(input)) {
2154 log.debug("exiting {} because of null input", svcOperation);
2155 responseBuilder.setResponseCode("403");
2156 responseBuilder.setResponseMessage("input is null");
2157 responseBuilder.setAckFinalIndicator("Y");
2159 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
2160 .<PreloadNetworkTopologyOperationOutput>status(true)
2161 .withResult(responseBuilder.build())
2164 return Futures.immediateFuture(rpcResult);
2167 // Grab the name and type from the input buffer
2168 String preloadName = input.getNetworkTopologyInformation().getNetworkTopologyIdentifier().getNetworkName();
2169 String preloadType = input.getNetworkTopologyInformation().getNetworkTopologyIdentifier().getNetworkType();
2171 // Make sure we have a preload_name and preload_type
2172 if (invalidPreloadData(preloadName, preloadType)) {
2173 log.debug("exiting {} because of invalid preload-name or preload-type", svcOperation);
2174 responseBuilder.setResponseCode("403");
2175 responseBuilder.setResponseMessage("invalid input: network-name or network-type is null or empty");
2176 responseBuilder.setAckFinalIndicator("Y");
2178 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
2179 .<PreloadNetworkTopologyOperationOutput>status(true)
2180 .withResult(responseBuilder.build())
2183 return Futures.immediateFuture(rpcResult);
2186 trySetSvcRequestId(input, responseBuilder);
2188 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
2189 getPreloadData(preloadName, preloadType, preloadDataBuilder);
2191 PreloadDataBuilder operDataBuilder = new PreloadDataBuilder();
2192 getPreloadData(preloadName, preloadType, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
2195 // setup a preload-data object builder
2196 // ACTION preload-network-topology-operation
2198 // USES sdnc-request-header;
2199 // USES request-information;
2200 // uses network-topology-information;
2202 // USES vnf-topology-response-body;
2204 // container preload-data
2205 // uses vnf-topology-information;
2206 // uses network-topology-information;
2207 // uses oper-status;
2209 log.info("Adding INPUT data for {} [{},{}] input: {}", svcOperation, preloadName, preloadType, input);
2210 PreloadNetworkTopologyOperationInputBuilder inputBuilder = new PreloadNetworkTopologyOperationInputBuilder(
2212 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
2213 log.info("Adding OPERATIONAL data for {} [{},{}] operational-data: {}", svcOperation, preloadName,
2214 preloadType, operDataBuilder.build());
2215 GenericResourceApiUtil.toProperties(parms, OPERATIONAL_DATA_PARAM, operDataBuilder);
2217 // Call SLI sync method
2218 // Get SvcLogicService reference
2219 ResponseObject responseObject = new ResponseObject("200", "");
2220 Properties respProps = tryGetProperties(svcOperation, parms, responseObject);
2222 String ackFinal = resolveAckFinal(responseObject, respProps);
2224 if (failed(responseObject)) {
2226 responseBuilder.setResponseCode(responseObject.getStatusCode());
2227 responseBuilder.setResponseMessage(responseObject.getMessage());
2228 responseBuilder.setAckFinalIndicator(ackFinal);
2230 VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
2231 preloadVnfListBuilder.setVnfName(preloadName);
2232 preloadVnfListBuilder.setVnfType(preloadType);
2233 preloadVnfListBuilder.setPreloadData(preloadDataBuilder.build());
2234 log.error("Returned FAILED for {} [{},{}] error code: '{}', Reason: '{}'", svcOperation, preloadName,
2235 preloadType, responseObject.getStatusCode(), responseObject.getMessage());
2237 savePreloadList(preloadVnfListBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
2238 } catch (Exception e) {
2239 log.error(UPDATING_MDSAL_ERROR_MESSAGE_2, svcOperation, preloadName,
2243 log.debug("Sending Success rpc result due to external error");
2245 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
2246 .<PreloadNetworkTopologyOperationOutput>status(true)
2247 .withResult(responseBuilder.build())
2250 return Futures.immediateFuture(rpcResult);
2253 // Got success from SLI
2255 updatePreloadData(svcOperation, preloadName, preloadType, preloadDataBuilder);
2256 } catch (Exception e) {
2257 log.error(UPDATING_MDSAL_ERROR_MESSAGE_2, svcOperation, preloadName, preloadType, e);
2258 responseBuilder.setResponseCode("500");
2259 responseBuilder.setResponseMessage(e.getMessage());
2260 responseBuilder.setAckFinalIndicator("Y");
2261 log.error("Returned FAILED for {} [{},{}] {}", svcOperation, preloadName, preloadType,
2262 responseBuilder.build());
2264 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
2265 .<PreloadNetworkTopologyOperationOutput>status(false)
2266 .withResult(responseBuilder.build())
2269 return Futures.immediateFuture(rpcResult);
2273 responseBuilder.setResponseCode(responseObject.getStatusCode());
2274 responseBuilder.setAckFinalIndicator(ackFinal);
2275 trySetResponseMessage(responseBuilder, responseObject);
2277 log.info("Updated MD-SAL for {} [{},{}]", svcOperation, preloadName, preloadType);
2278 log.info("Returned SUCCESS for {} [{},{}] {}", svcOperation, preloadName, preloadType,
2279 responseBuilder.build());
2281 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
2282 .<PreloadNetworkTopologyOperationOutput>status(true)
2283 .withResult(responseBuilder.build())
2286 return Futures.immediateFuture(rpcResult);
2289 private void trySetResponseMessage(PreloadNetworkTopologyOperationOutputBuilder responseBuilder,
2290 ResponseObject error) {
2291 if (!error.getMessage().isEmpty()) {
2292 responseBuilder.setResponseMessage(error.getMessage());
2296 private void trySetSvcRequestId(PreloadNetworkTopologyOperationInput input,
2297 PreloadNetworkTopologyOperationOutputBuilder responseBuilder) {
2298 if (input.getSdncRequestHeader() != null) {
2299 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
2303 private boolean invalidPreloadData(String preloadName, String preloadType) {
2304 return preloadName == null || preloadName.length() == 0 || preloadType == null || preloadType.length() == 0;
2307 private boolean hasInvalidNetworkTopology(PreloadNetworkTopologyOperationInput input) {
2308 return input == null || input.getNetworkTopologyInformation() == null
2309 || input.getNetworkTopologyInformation().getNetworkTopologyIdentifier() == null;