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");
789 serviceObjectPath = respProps.getProperty("vnf-object-path");
792 setServiceStatus(serviceStatusBuilder, responseObject.getStatusCode(), responseObject.getMessage(), ackFinal);
793 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
794 serviceStatusBuilder.setRpcName(svcOperation);
796 if (failed(responseObject)) {
797 responseBuilder.setResponseCode(responseObject.getStatusCode());
798 responseBuilder.setResponseMessage(responseObject.getMessage());
799 responseBuilder.setAckFinalIndicator(ackFinal);
801 ServiceBuilder serviceBuilder = new ServiceBuilder();
802 serviceBuilder.setServiceInstanceId(siid);
803 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
805 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
806 trySaveService(input, serviceBuilder);
807 } catch (Exception e) {
808 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
810 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
812 RpcResult<VnfTopologyOperationOutput> rpcResult = RpcResultBuilder
813 .<VnfTopologyOperationOutput>status(true)
814 .withResult(responseBuilder.build())
818 return Futures.immediateFuture(rpcResult);
821 // Got success from SLI
823 serviceData = serviceDataBuilder.build();
824 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
827 ServiceBuilder serviceBuilder = new ServiceBuilder();
828 serviceBuilder.setServiceData(serviceData);
829 serviceBuilder.setServiceInstanceId(siid);
830 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
831 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
833 if (isValidRequest(input) && input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate)) {
834 // Only update operational tree on Assign
836 log.info(UPDATING_TREE_INFO_MESSAGE);
837 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
840 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
841 serviceResponseInformationBuilder.setInstanceId(siid);
842 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
843 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
845 } catch (Exception e) {
846 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
847 responseBuilder.setResponseCode("500");
848 responseBuilder.setResponseMessage(e.getMessage());
849 responseBuilder.setAckFinalIndicator("Y");
850 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
852 RpcResult<VnfTopologyOperationOutput> rpcResult = RpcResultBuilder
853 .<VnfTopologyOperationOutput>status(true)
854 .withResult(responseBuilder.build())
857 return Futures.immediateFuture(rpcResult);
861 responseBuilder.setResponseCode(responseObject.getStatusCode());
862 responseBuilder.setAckFinalIndicator(ackFinal);
863 trySetResponseMessage(responseBuilder, responseObject);
864 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
865 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
867 RpcResult<VnfTopologyOperationOutput> rpcResult = RpcResultBuilder
868 .<VnfTopologyOperationOutput>status(true)
869 .withResult(responseBuilder.build())
873 return Futures.immediateFuture(rpcResult);
876 private void trySetResponseMessage(VnfTopologyOperationOutputBuilder responseBuilder, ResponseObject error) {
877 if (!error.getMessage().isEmpty()) {
878 responseBuilder.setResponseMessage(error.getMessage());
882 private void trySaveService(VnfTopologyOperationInput input, ServiceBuilder serviceBuilder) {
883 if (isValidRequest(input) &&
884 (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete) ||
885 input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))) {
887 // Only update operational tree on activate or delete
888 log.info(UPDATING_TREE_INFO_MESSAGE);
889 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
893 private boolean hasInvalidVnfId(VnfTopologyOperationInput input) {
894 return input.getVnfInformation() == null || input.getVnfInformation().getVnfId() == null
895 || input.getVnfInformation().getVnfId().length() == 0;
898 private boolean hasInvalidServiceId(VnfTopologyOperationInput input) {
899 return input == null || input.getServiceInformation() == null
900 || input.getServiceInformation().getServiceInstanceId() == null
901 || input.getServiceInformation().getServiceInstanceId().length() == 0;
904 private void trySetSvcRequestId(VnfTopologyOperationInput input,
905 VnfTopologyOperationOutputBuilder responseBuilder) {
906 if (input.getSdncRequestHeader() != null) {
907 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
911 private boolean isValidRequest(VnfTopologyOperationInput input) {
912 return input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null;
916 public Future<RpcResult<VfModuleTopologyOperationOutput>> vfModuleTopologyOperation(
917 VfModuleTopologyOperationInput input) {
919 final String svcOperation = "vf-module-topology-operation";
920 ServiceData serviceData;
921 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
922 Properties parms = new Properties();
924 log.info(CALLED_STR, svcOperation);
925 // create a new response object
926 VfModuleTopologyOperationOutputBuilder responseBuilder = new VfModuleTopologyOperationOutputBuilder();
928 if (hasInvalidServiceId(input)) {
929 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
930 responseBuilder.setResponseCode("403");
931 responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
932 responseBuilder.setAckFinalIndicator("Y");
934 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
935 .<VfModuleTopologyOperationOutput>status(true)
936 .withResult(responseBuilder.build())
940 return Futures.immediateFuture(rpcResult);
943 if (hasInvalidVnfId(input)) {
944 log.debug("exiting {} because of null or empty vnf-id", svcOperation);
945 responseBuilder.setResponseCode("403");
946 responseBuilder.setResponseMessage("invalid input, null or empty vnf-id");
947 responseBuilder.setAckFinalIndicator("Y");
948 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
949 .<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
950 return Futures.immediateFuture(rpcResult);
953 if (hasInvalidVfModule(input)) {
954 log.debug("exiting {} because of null or empty vf-module-id", svcOperation);
955 responseBuilder.setResponseCode("403");
956 responseBuilder.setResponseMessage("invalid input, vf-module-id is null or empty");
957 responseBuilder.setAckFinalIndicator("Y");
959 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
960 .<VfModuleTopologyOperationOutput>status(true)
961 .withResult(responseBuilder.build())
964 return Futures.immediateFuture(rpcResult);
967 // Grab the service instance ID from the input buffer
968 String siid = input.getServiceInformation().getServiceInstanceId();
970 trySetSvcRequestId(input, responseBuilder);
972 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
973 getServiceData(siid, serviceDataBuilder);
975 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
976 getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
978 // Set the serviceStatus based on input
979 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
980 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
983 // setup a service-data object builder
984 // ACTION vnf-topology-operation
986 // USES sdnc-request-header;
987 // USES request-information;
988 // USES service-information;
989 // USES vnf-request-information
991 // USES vnf-topology-response-body;
992 // USES vnf-information
993 // USES service-information
995 // container service-data
996 // uses vnf-configuration-information;
999 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
1000 VfModuleTopologyOperationInputBuilder inputBuilder = new VfModuleTopologyOperationInputBuilder(input);
1001 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1003 log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid,
1004 operDataBuilder.build());
1005 GenericResourceApiUtil.toProperties(parms, OPERATIONAL_DATA_PARAM, operDataBuilder);
1007 // Call SLI sync method
1008 // Get SvcLogicService reference
1010 ResponseObject error = new ResponseObject("200", "");
1011 String ackFinal = "Y";
1012 String serviceObjectPath = null;
1013 Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, error);
1015 if (respProps != null) {
1016 error.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
1017 error.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
1018 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
1019 serviceObjectPath = respProps.getProperty("vf-module-object-path");
1022 setServiceStatus(serviceStatusBuilder, error.getStatusCode(), error.getMessage(), ackFinal);
1023 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
1024 serviceStatusBuilder.setRpcName(svcOperation);
1026 if (failed(error)) {
1027 responseBuilder.setResponseCode(error.getStatusCode());
1028 responseBuilder.setResponseMessage(error.getStatusCode());
1029 responseBuilder.setAckFinalIndicator(ackFinal);
1031 ServiceBuilder serviceBuilder = new ServiceBuilder();
1032 serviceBuilder.setServiceInstanceId(siid);
1033 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1035 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
1036 } catch (Exception e) {
1037 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1039 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1041 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
1042 .<VfModuleTopologyOperationOutput>status(true)
1043 .withResult(responseBuilder.build())
1047 return Futures.immediateFuture(rpcResult);
1050 // Got success from SLI
1052 serviceData = serviceDataBuilder.build();
1053 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
1056 ServiceBuilder serviceBuilder = new ServiceBuilder();
1057 serviceBuilder.setServiceData(serviceData);
1058 serviceBuilder.setServiceInstanceId(siid);
1059 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1060 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1062 trySaveService(input, serviceBuilder);
1064 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1065 serviceResponseInformationBuilder.setInstanceId(siid);
1066 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1067 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1069 } catch (Exception e) {
1070 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1071 responseBuilder.setResponseCode("500");
1072 responseBuilder.setResponseMessage(e.toString());
1073 responseBuilder.setAckFinalIndicator("Y");
1074 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1076 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
1077 .<VfModuleTopologyOperationOutput>status(true)
1078 .withResult(responseBuilder.build())
1081 return Futures.immediateFuture(rpcResult);
1085 responseBuilder.setResponseCode(error.getStatusCode());
1086 responseBuilder.setAckFinalIndicator(ackFinal);
1087 trySetResponseMessage(responseBuilder, error);
1088 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
1089 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
1091 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
1092 .<VfModuleTopologyOperationOutput>status(true)
1093 .withResult(responseBuilder.build())
1097 return Futures.immediateFuture(rpcResult);
1100 private void trySetResponseMessage(VfModuleTopologyOperationOutputBuilder responseBuilder, ResponseObject error) {
1101 if (!error.getMessage().isEmpty()) {
1102 responseBuilder.setResponseMessage(error.getMessage());
1106 private void trySaveService(VfModuleTopologyOperationInput input, ServiceBuilder serviceBuilder) {
1107 if (isValidRequest(input) &&
1108 (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Unassign) ||
1109 input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))) {
1110 // Only update operational tree on activate or delete
1112 log.info(UPDATING_TREE_INFO_MESSAGE);
1113 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1117 private void trySetSvcRequestId(VfModuleTopologyOperationInput input,
1118 VfModuleTopologyOperationOutputBuilder responseBuilder) {
1119 if (input.getSdncRequestHeader() != null) {
1120 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1124 private boolean hasInvalidVfModule(VfModuleTopologyOperationInput input) {
1125 return input.getVfModuleInformation() == null || input.getVfModuleInformation().getVfModuleId() == null
1126 || input.getVfModuleInformation().getVfModuleId().length() == 0;
1129 private boolean hasInvalidVnfId(VfModuleTopologyOperationInput input) {
1130 return input.getVnfInformation() == null || input.getVnfInformation().getVnfId() == null
1131 || input.getVnfInformation().getVnfId().length() == 0;
1134 private boolean hasInvalidServiceId(VfModuleTopologyOperationInput input) {
1135 return input == null || input.getServiceInformation() == null
1136 || input.getServiceInformation().getServiceInstanceId() == null
1137 || input.getServiceInformation().getServiceInstanceId().length() == 0;
1140 private boolean isValidRequest(VfModuleTopologyOperationInput input) {
1141 return input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null;
1145 public Future<RpcResult<NetworkTopologyOperationOutput>> networkTopologyOperation(
1146 NetworkTopologyOperationInput input) {
1148 final String svcOperation = "network-topology-operation";
1149 ServiceData serviceData;
1150 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1151 Properties parms = new Properties();
1153 log.info(CALLED_STR, svcOperation);
1154 // create a new response object
1155 NetworkTopologyOperationOutputBuilder responseBuilder = new NetworkTopologyOperationOutputBuilder();
1157 if (hasInvalidServiceId(input)) {
1158 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
1159 return buildRpcResultFuture(responseBuilder, NULL_OR_EMPTY_ERROR_PARAM);
1162 String siid = input.getServiceInformation().getServiceInstanceId();
1164 // Get the service-instance service data from MD-SAL
1165 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1166 getServiceData(siid, serviceDataBuilder);
1168 this.trySetSvcRequestId(input, responseBuilder);
1170 ServiceData sd = serviceDataBuilder.build();
1171 if (isInvalidServiceData(sd)) {
1172 log.debug(EMPTY_SERVICE_INSTANCE_MESSAGE, svcOperation);
1173 return buildRpcResultFuture(responseBuilder, INVALID_INPUT_ERROR_MESSAGE);
1176 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
1177 NetworkTopologyOperationInputBuilder inputBuilder = new NetworkTopologyOperationInputBuilder(input);
1178 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1180 // Call SLI sync method
1181 // Get SvcLogicService reference
1183 ResponseObject responseObject = new ResponseObject("200", "");
1184 String ackFinal = "Y";
1185 String networkId = ERROR_NETWORK_ID;
1186 String serviceObjectPath = null;
1187 String networkObjectPath = null;
1188 Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, responseObject);
1190 if (respProps != null) {
1191 responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
1192 responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
1193 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
1194 networkId = respProps.getProperty("networkId");
1195 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
1196 networkObjectPath = respProps.getProperty("network-object-path");
1199 if (failed(responseObject)) {
1200 responseBuilder.setResponseCode(responseObject.getStatusCode());
1201 responseBuilder.setResponseMessage(responseObject.getMessage());
1202 responseBuilder.setAckFinalIndicator(ackFinal);
1204 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1206 RpcResult<NetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
1207 .<NetworkTopologyOperationOutput>status(true)
1208 .withResult(responseBuilder.build())
1211 return Futures.immediateFuture(rpcResult);
1214 // Got success from SLI
1217 serviceData = serviceDataBuilder.build();
1218 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
1221 ServiceBuilder serviceBuilder = new ServiceBuilder();
1222 serviceBuilder.setServiceData(serviceData);
1223 serviceBuilder.setServiceInstanceId(siid);
1224 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1225 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1227 trySaveService(input, serviceBuilder);
1229 NetworkResponseInformationBuilder networkResponseInformationBuilder = new NetworkResponseInformationBuilder();
1230 networkResponseInformationBuilder.setInstanceId(networkId);
1231 networkResponseInformationBuilder.setObjectPath(networkObjectPath);
1232 responseBuilder.setNetworkResponseInformation(networkResponseInformationBuilder.build());
1234 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1235 serviceResponseInformationBuilder.setInstanceId(siid);
1236 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1237 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1239 } catch (IllegalStateException e) {
1240 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1241 responseBuilder.setResponseCode("500");
1242 responseBuilder.setResponseMessage(e.getMessage());
1243 responseBuilder.setAckFinalIndicator("Y");
1244 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1246 RpcResult<NetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
1247 .<NetworkTopologyOperationOutput>status(true)
1248 .withResult(responseBuilder.build())
1251 return Futures.immediateFuture(rpcResult);
1255 responseBuilder.setResponseCode(responseObject.getStatusCode());
1256 responseBuilder.setAckFinalIndicator(ackFinal);
1257 trySetResponseMessage(responseBuilder, responseObject);
1258 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
1259 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
1261 RpcResult<NetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
1262 .<NetworkTopologyOperationOutput>status(true)
1263 .withResult(responseBuilder.build())
1266 return Futures.immediateFuture(rpcResult);
1269 private void trySetResponseMessage(NetworkTopologyOperationOutputBuilder responseBuilder, ResponseObject error) {
1270 if (!error.getMessage().isEmpty()) {
1271 responseBuilder.setResponseMessage(error.getMessage());
1275 private void trySetSvcRequestId(NetworkTopologyOperationInput input,
1276 NetworkTopologyOperationOutputBuilder responseBuilder) {
1277 if (input.getSdncRequestHeader() != null) {
1278 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1282 private void trySaveService(NetworkTopologyOperationInput input, ServiceBuilder serviceBuilder) {
1283 if (isValidRequest(input) &&
1284 (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate) ||
1285 input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Create))) {
1286 // Only update operational tree on Activate
1287 log.info(UPDATING_TREE_INFO_MESSAGE);
1288 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1292 private boolean hasInvalidServiceId(NetworkTopologyOperationInput input) {
1293 return input == null || input.getServiceInformation() == null
1294 || input.getServiceInformation().getServiceInstanceId() == null
1295 || input.getServiceInformation().getServiceInstanceId().length() == 0;
1298 private Future<RpcResult<NetworkTopologyOperationOutput>> buildRpcResultFuture(
1299 NetworkTopologyOperationOutputBuilder responseBuilder, String responseMessage) {
1301 responseBuilder.setResponseCode("404");
1303 .setResponseMessage(responseMessage);
1304 responseBuilder.setAckFinalIndicator("Y");
1306 RpcResult<NetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
1307 .<NetworkTopologyOperationOutput>status(true)
1308 .withResult(responseBuilder.build())
1311 return Futures.immediateFuture(rpcResult);
1314 private boolean isValidRequest(NetworkTopologyOperationInput input) {
1315 return input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null;
1319 public Future<RpcResult<ContrailRouteTopologyOperationOutput>> contrailRouteTopologyOperation(
1320 ContrailRouteTopologyOperationInput input) {
1322 final String svcOperation = "contrail-route-topology-operation";
1323 ServiceData serviceData;
1324 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1325 Properties parms = new Properties();
1327 log.info(CALLED_STR, svcOperation);
1328 // create a new response object
1329 ContrailRouteTopologyOperationOutputBuilder responseBuilder = new ContrailRouteTopologyOperationOutputBuilder();
1331 if (hasInvalidServiceId(input)) {
1332 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
1333 return buildRpcResultFuture(responseBuilder, NULL_OR_EMPTY_ERROR_PARAM);
1336 String siid = input.getServiceInformation().getServiceInstanceId();
1338 // Get the service-instance service data from MD-SAL
1339 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1340 getServiceData(siid, serviceDataBuilder);
1342 trySetSvcRequestId(input, responseBuilder);
1344 ServiceData sd = serviceDataBuilder.build();
1345 if (isInvalidServiceData(sd)) {
1346 log.debug(EMPTY_SERVICE_INSTANCE_MESSAGE, svcOperation);
1347 return buildRpcResultFuture(responseBuilder, INVALID_INPUT_ERROR_MESSAGE);
1350 log.info("Adding INPUT data for " + svcOperation + " [" + siid + "] input: " + input);
1351 ContrailRouteTopologyOperationInputBuilder inputBuilder = new ContrailRouteTopologyOperationInputBuilder(input);
1352 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1354 // Call SLI sync method
1355 // Get SvcLogicService reference
1356 ResponseObject error = new ResponseObject("200", "");
1357 String ackFinal = "Y";
1358 String allottedResourceId = ERROR_NETWORK_ID;
1359 String serviceObjectPath = null;
1360 String contrailRouteObjectPath = null;
1361 Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, error);
1363 if (respProps != null) {
1364 error.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
1365 error.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
1366 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
1367 allottedResourceId = respProps.getProperty(ALLOTTED_RESOURCE_ID_PARAM);
1368 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
1369 contrailRouteObjectPath = respProps.getProperty("contrail-route-object-path");
1372 if (failed(error)) {
1373 responseBuilder.setResponseCode(error.getStatusCode());
1374 responseBuilder.setResponseMessage(error.getMessage());
1375 responseBuilder.setAckFinalIndicator(ackFinal);
1376 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1378 RpcResult<ContrailRouteTopologyOperationOutput> rpcResult = RpcResultBuilder
1379 .<ContrailRouteTopologyOperationOutput>status(true)
1380 .withResult(responseBuilder.build())
1383 return Futures.immediateFuture(rpcResult);
1386 // Got success from SLI
1388 serviceData = serviceDataBuilder.build();
1389 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
1392 ServiceBuilder serviceBuilder = new ServiceBuilder();
1393 serviceBuilder.setServiceData(serviceData);
1394 serviceBuilder.setServiceInstanceId(siid);
1395 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1396 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1398 trySaveService(input, serviceBuilder);
1400 ContrailRouteResponseInformationBuilder contrailRouteResponseInformationBuilder = new ContrailRouteResponseInformationBuilder();
1401 contrailRouteResponseInformationBuilder.setInstanceId(allottedResourceId);
1402 contrailRouteResponseInformationBuilder.setObjectPath(contrailRouteObjectPath);
1403 responseBuilder.setContrailRouteResponseInformation(contrailRouteResponseInformationBuilder.build());
1405 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1406 serviceResponseInformationBuilder.setInstanceId(siid);
1407 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1408 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1410 } catch (IllegalStateException e) {
1411 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1412 responseBuilder.setResponseCode("500");
1413 responseBuilder.setResponseMessage(e.toString());
1414 responseBuilder.setAckFinalIndicator("Y");
1415 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1417 RpcResult<ContrailRouteTopologyOperationOutput> rpcResult = RpcResultBuilder
1418 .<ContrailRouteTopologyOperationOutput>status(true)
1419 .withResult(responseBuilder.build())
1422 return Futures.immediateFuture(rpcResult);
1426 responseBuilder.setResponseCode(error.getStatusCode());
1427 responseBuilder.setAckFinalIndicator(ackFinal);
1428 trySetResponseMessage(responseBuilder, error);
1429 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
1430 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
1432 RpcResult<ContrailRouteTopologyOperationOutput> rpcResult = RpcResultBuilder
1433 .<ContrailRouteTopologyOperationOutput>status(true)
1434 .withResult(responseBuilder.build())
1437 return Futures.immediateFuture(rpcResult);
1440 private void trySetResponseMessage(ContrailRouteTopologyOperationOutputBuilder responseBuilder,
1441 ResponseObject error) {
1442 if (!error.getMessage().isEmpty()) {
1443 responseBuilder.setResponseMessage(error.getMessage());
1447 private void trySaveService(ContrailRouteTopologyOperationInput input, ServiceBuilder serviceBuilder) {
1448 if (isValidRequest(input) &&
1449 (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Unassign) ||
1450 input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))) {
1451 // Only update operational tree on activate or delete
1452 log.info(UPDATING_TREE_INFO_MESSAGE);
1453 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1457 private void trySetSvcRequestId(ContrailRouteTopologyOperationInput input,
1458 ContrailRouteTopologyOperationOutputBuilder responseBuilder) {
1459 if (input.getSdncRequestHeader() != null) {
1460 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1464 private boolean hasInvalidServiceId(ContrailRouteTopologyOperationInput input) {
1465 return input == null || input.getServiceInformation() == null
1466 || input.getServiceInformation().getServiceInstanceId() == null
1467 || input.getServiceInformation().getServiceInstanceId().length() == 0;
1470 private Future<RpcResult<ContrailRouteTopologyOperationOutput>>
1471 buildRpcResultFuture(ContrailRouteTopologyOperationOutputBuilder responseBuilder, String responseMessage) {
1473 responseBuilder.setResponseCode("404");
1474 responseBuilder.setResponseMessage(responseMessage);
1475 responseBuilder.setAckFinalIndicator("Y");
1477 RpcResult<ContrailRouteTopologyOperationOutput> rpcResult = RpcResultBuilder
1478 .<ContrailRouteTopologyOperationOutput>status(true)
1479 .withResult(responseBuilder.build())
1482 return Futures.immediateFuture(rpcResult);
1485 private boolean isValidRequest(ContrailRouteTopologyOperationInput input) {
1486 return input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null;
1490 public Future<RpcResult<SecurityZoneTopologyOperationOutput>> securityZoneTopologyOperation(
1491 SecurityZoneTopologyOperationInput input) {
1493 final String svcOperation = "security-zone-topology-operation";
1494 ServiceData serviceData;
1495 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1496 Properties parms = new Properties();
1498 log.info(CALLED_STR, svcOperation);
1499 // create a new response object
1500 SecurityZoneTopologyOperationOutputBuilder responseBuilder = new SecurityZoneTopologyOperationOutputBuilder();
1502 if (this.hasInvalidServiceId(input)) {
1503 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
1504 return buildRpcResultFuture(responseBuilder, NULL_OR_EMPTY_ERROR_PARAM);
1507 String siid = input.getServiceInformation().getServiceInstanceId();
1509 // Get the service-instance service data from MD-SAL
1510 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1511 getServiceData(siid, serviceDataBuilder);
1512 trySetSvcRequestId(input, responseBuilder);
1514 ServiceData sd = serviceDataBuilder.build();
1515 if (isInvalidServiceData(sd)) {
1516 log.debug(EMPTY_SERVICE_INSTANCE_MESSAGE, svcOperation);
1517 return buildRpcResultFuture(responseBuilder, INVALID_INPUT_ERROR_MESSAGE);
1520 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
1521 SecurityZoneTopologyOperationInputBuilder inputBuilder = new SecurityZoneTopologyOperationInputBuilder(input);
1522 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1524 // Call SLI sync method
1525 // Get SvcLogicService reference
1527 Properties respProps = null;
1529 ResponseObject error = new ResponseObject("200", "");
1530 String ackFinal = "Y";
1531 String allottedResourceId = ERROR_NETWORK_ID;
1532 String serviceObjectPath = null;
1533 String securityZoneObjectPath = null;
1536 if (svcLogicClient.hasGraph(APP_NAME, svcOperation, null, "sync")) {
1539 respProps = svcLogicClient.execute(APP_NAME, svcOperation, null, "sync", serviceDataBuilder, parms);
1540 } catch (Exception e) {
1541 log.error(SERVICE_LOGIC_EXECUTION_ERROR_MESSAGE, svcOperation, e);
1542 error.setMessage(e.getMessage());
1543 error.setStatusCode("500");
1546 error.setMessage(NO_SERVICE_LOGIC_ACTIVE + APP_NAME + ": '" + svcOperation + "'");
1547 error.setStatusCode("503");
1549 } catch (Exception e) {
1550 error.setStatusCode("500");
1551 error.setMessage(e.getMessage());
1552 log.error(SERVICE_LOGIC_SEARCH_ERROR_MESSAGE, e);
1555 if (respProps != null) {
1556 error.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
1557 error.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
1558 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
1559 allottedResourceId = respProps.getProperty(ALLOTTED_RESOURCE_ID_PARAM);
1560 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
1561 securityZoneObjectPath = respProps.getProperty("security-zone-object-path");
1564 if (failed(error)) {
1565 responseBuilder.setResponseCode(error.getStatusCode());
1566 responseBuilder.setResponseMessage(error.getMessage());
1567 responseBuilder.setAckFinalIndicator(ackFinal);
1568 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1570 RpcResult<SecurityZoneTopologyOperationOutput> rpcResult = RpcResultBuilder
1571 .<SecurityZoneTopologyOperationOutput>status(true)
1572 .withResult(responseBuilder.build())
1575 return Futures.immediateFuture(rpcResult);
1578 // Got success from SLI
1581 serviceData = serviceDataBuilder.build();
1582 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
1585 ServiceBuilder serviceBuilder = new ServiceBuilder();
1586 serviceBuilder.setServiceData(serviceData);
1587 serviceBuilder.setServiceInstanceId(siid);
1588 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1589 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1591 trySaveService(input, serviceBuilder);
1593 SecurityZoneResponseInformationBuilder securityZoneResponseInformationBuilder = new SecurityZoneResponseInformationBuilder();
1594 securityZoneResponseInformationBuilder.setInstanceId(allottedResourceId);
1595 securityZoneResponseInformationBuilder.setObjectPath(securityZoneObjectPath);
1596 responseBuilder.setSecurityZoneResponseInformation(securityZoneResponseInformationBuilder.build());
1598 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1599 serviceResponseInformationBuilder.setInstanceId(siid);
1600 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1601 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1603 } catch (IllegalStateException e) {
1604 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1605 responseBuilder.setResponseCode("500");
1606 responseBuilder.setResponseMessage(e.toString());
1607 responseBuilder.setAckFinalIndicator("Y");
1608 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1610 RpcResult<SecurityZoneTopologyOperationOutput> rpcResult = RpcResultBuilder
1611 .<SecurityZoneTopologyOperationOutput>status(true)
1612 .withResult(responseBuilder.build())
1615 return Futures.immediateFuture(rpcResult);
1619 responseBuilder.setResponseCode(error.getStatusCode());
1620 responseBuilder.setAckFinalIndicator(ackFinal);
1621 trySetResponseMessage(responseBuilder, error);
1622 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
1623 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
1625 RpcResult<SecurityZoneTopologyOperationOutput> rpcResult = RpcResultBuilder
1626 .<SecurityZoneTopologyOperationOutput>status(true)
1627 .withResult(responseBuilder.build())
1630 return Futures.immediateFuture(rpcResult);
1633 private void trySetResponseMessage(SecurityZoneTopologyOperationOutputBuilder responseBuilder,
1634 ResponseObject error) {
1635 if (!error.getMessage().isEmpty()) {
1636 responseBuilder.setResponseMessage(error.getMessage());
1640 private void trySaveService(SecurityZoneTopologyOperationInput input, ServiceBuilder serviceBuilder) {
1641 if (isValidRequest(input) &&
1642 (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Unassign) ||
1643 input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))) {
1644 // Only update operational tree on activate or delete
1645 log.info(UPDATING_TREE_INFO_MESSAGE);
1646 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1650 private void trySetSvcRequestId(SecurityZoneTopologyOperationInput input,
1651 SecurityZoneTopologyOperationOutputBuilder responseBuilder) {
1652 if (input.getSdncRequestHeader() != null) {
1653 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1657 private boolean isInvalidServiceData(ServiceData sd) {
1658 return sd == null || sd.getServiceLevelOperStatus() == null;
1661 private boolean hasInvalidServiceId(SecurityZoneTopologyOperationInput input) {
1662 return input == null || input.getServiceInformation() == null
1663 || input.getServiceInformation().getServiceInstanceId() == null
1664 || input.getServiceInformation().getServiceInstanceId().length() == 0;
1667 private Future<RpcResult<SecurityZoneTopologyOperationOutput>>
1668 buildRpcResultFuture(SecurityZoneTopologyOperationOutputBuilder responseBuilder, String responseMessage) {
1670 responseBuilder.setResponseCode("404");
1671 responseBuilder.setResponseMessage(responseMessage);
1672 responseBuilder.setAckFinalIndicator("Y");
1674 RpcResult<SecurityZoneTopologyOperationOutput> rpcResult = RpcResultBuilder
1675 .<SecurityZoneTopologyOperationOutput>status(true)
1676 .withResult(responseBuilder.build())
1679 return Futures.immediateFuture(rpcResult);
1682 private boolean isValidRequest(SecurityZoneTopologyOperationInput input) {
1683 return input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null;
1687 public Future<RpcResult<TunnelxconnTopologyOperationOutput>> tunnelxconnTopologyOperation(
1688 TunnelxconnTopologyOperationInput input) {
1690 final String svcOperation = "tunnelxconn-topology-operation";
1691 Properties parms = new Properties();
1692 log.info(CALLED_STR, svcOperation);
1694 // create a new response object
1695 TunnelxconnTopologyOperationOutputBuilder responseBuilder = new TunnelxconnTopologyOperationOutputBuilder();
1696 if (hasInvalidServiceId(input)) {
1697 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
1698 responseBuilder.setResponseCode("404");
1699 responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
1700 responseBuilder.setAckFinalIndicator("Y");
1702 RpcResult<TunnelxconnTopologyOperationOutput> rpcResult = RpcResultBuilder
1703 .<TunnelxconnTopologyOperationOutput>status(true)
1704 .withResult(responseBuilder.build())
1707 return Futures.immediateFuture(rpcResult);
1709 String siid = input.getServiceInformation().getServiceInstanceId();
1710 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
1711 TunnelxconnTopologyOperationInputBuilder inputBuilder = new TunnelxconnTopologyOperationInputBuilder(input);
1712 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1714 // Call SLI sync method
1715 // Get SvcLogicService reference
1716 ResponseObject error = new ResponseObject("200", "");
1717 String ackFinal = "Y";
1718 String allottedResourceId = ERROR_NETWORK_ID;
1719 String serviceObjectPath = null;
1720 String tunnelxconnObjectPath = null;
1721 Properties respProps = tryGetProperties(svcOperation, parms, error);
1723 if (respProps != null) {
1724 error.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
1725 error.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
1726 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
1727 allottedResourceId = respProps.getProperty(ALLOTTED_RESOURCE_ID_PARAM);
1728 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
1729 tunnelxconnObjectPath = respProps.getProperty("tunnelxconn-object-path");
1732 if (failed(error)) {
1733 responseBuilder.setResponseCode(error.getStatusCode());
1734 responseBuilder.setResponseMessage(error.getMessage());
1735 responseBuilder.setAckFinalIndicator(ackFinal);
1737 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1739 RpcResult<TunnelxconnTopologyOperationOutput> rpcResult = RpcResultBuilder
1740 .<TunnelxconnTopologyOperationOutput>status(true)
1741 .withResult(responseBuilder.build())
1744 return Futures.immediateFuture(rpcResult);
1747 // Got success from SLI
1749 TunnelxconnResponseInformationBuilder tunnelxconnResponseInformationBuilder = new TunnelxconnResponseInformationBuilder();
1750 tunnelxconnResponseInformationBuilder.setInstanceId(allottedResourceId);
1751 tunnelxconnResponseInformationBuilder.setObjectPath(tunnelxconnObjectPath);
1752 responseBuilder.setTunnelxconnResponseInformation(tunnelxconnResponseInformationBuilder.build());
1754 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1755 serviceResponseInformationBuilder.setInstanceId(siid);
1756 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1757 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1759 } catch (IllegalStateException e) {
1760 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1761 responseBuilder.setResponseCode("500");
1762 responseBuilder.setResponseMessage(e.toString());
1763 responseBuilder.setAckFinalIndicator("Y");
1764 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1766 RpcResult<TunnelxconnTopologyOperationOutput> rpcResult = RpcResultBuilder
1767 .<TunnelxconnTopologyOperationOutput>status(true)
1768 .withResult(responseBuilder.build())
1771 return Futures.immediateFuture(rpcResult);
1775 responseBuilder.setResponseCode(error.getStatusCode());
1776 responseBuilder.setAckFinalIndicator(ackFinal);
1777 trySetResponseMessage(responseBuilder, error);
1778 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
1779 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
1781 RpcResult<TunnelxconnTopologyOperationOutput> rpcResult = RpcResultBuilder
1782 .<TunnelxconnTopologyOperationOutput>status(true)
1783 .withResult(responseBuilder.build())
1786 return Futures.immediateFuture(rpcResult);
1789 private void trySetResponseMessage(TunnelxconnTopologyOperationOutputBuilder responseBuilder,
1790 ResponseObject error) {
1791 if (!error.getMessage().isEmpty()) {
1792 responseBuilder.setResponseMessage(error.getMessage());
1796 private boolean hasInvalidServiceId(TunnelxconnTopologyOperationInput input) {
1797 return input == null || input.getServiceInformation() == null
1798 || input.getServiceInformation().getServiceInstanceId() == null
1799 || input.getServiceInformation().getServiceInstanceId().length() == 0;
1802 private Properties tryGetProperties(String svcOperation, Properties parms, ResponseObject error) {
1804 if (svcLogicClient.hasGraph(APP_NAME, svcOperation, null, "sync")) {
1807 return svcLogicClient.execute(APP_NAME, svcOperation, null, "sync", parms);
1808 } catch (Exception e) {
1809 log.error(SERVICE_LOGIC_EXECUTION_ERROR_MESSAGE, svcOperation, e);
1810 error.setMessage(e.getMessage());
1811 error.setStatusCode("500");
1814 error.setMessage(NO_SERVICE_LOGIC_ACTIVE + APP_NAME + ": '" + svcOperation + "'");
1815 error.setStatusCode("503");
1817 } catch (Exception e) {
1818 error.setMessage(e.getMessage());
1819 error.setStatusCode("500");
1820 log.error(SERVICE_LOGIC_SEARCH_ERROR_MESSAGE, e);
1826 public Future<RpcResult<BrgTopologyOperationOutput>> brgTopologyOperation(BrgTopologyOperationInput input) {
1827 final String svcOperation = "brg-topology-operation";
1828 Properties parms = new Properties();
1830 log.info(CALLED_STR, svcOperation);
1831 // create a new response object
1832 BrgTopologyOperationOutputBuilder responseBuilder = new BrgTopologyOperationOutputBuilder();
1834 if (this.hasInvalidServiceId(input)) {
1836 log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
1837 responseBuilder.setResponseCode("404");
1838 responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
1839 responseBuilder.setAckFinalIndicator("Y");
1841 RpcResult<BrgTopologyOperationOutput> rpcResult = RpcResultBuilder
1842 .<BrgTopologyOperationOutput>status(true)
1843 .withResult(responseBuilder.build())
1846 return Futures.immediateFuture(rpcResult);
1849 String siid = input.getServiceInformation().getServiceInstanceId();
1851 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
1852 BrgTopologyOperationInputBuilder inputBuilder = new BrgTopologyOperationInputBuilder(input);
1853 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1855 // Call SLI sync method
1856 // Get SvcLogicService reference
1857 ResponseObject error = new ResponseObject("200", "");
1858 String ackFinal = "Y";
1859 String allottedResourceId = ERROR_NETWORK_ID;
1860 String serviceObjectPath = null;
1861 String brgObjectPath = null;
1862 Properties respProps = tryGetProperties(svcOperation, parms, error);
1864 if (respProps != null) {
1865 error.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
1866 error.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
1867 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
1868 allottedResourceId = respProps.getProperty(ALLOTTED_RESOURCE_ID_PARAM);
1869 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
1870 brgObjectPath = respProps.getProperty("brg-object-path");
1873 if (failed(error)) {
1874 responseBuilder.setResponseCode(error.getStatusCode());
1875 responseBuilder.setResponseMessage(error.getMessage());
1876 responseBuilder.setAckFinalIndicator(ackFinal);
1878 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1879 RpcResult<BrgTopologyOperationOutput> rpcResult = RpcResultBuilder
1880 .<BrgTopologyOperationOutput>status(true)
1881 .withResult(responseBuilder.build())
1884 return Futures.immediateFuture(rpcResult);
1887 // Got success from SLI
1890 BrgResponseInformationBuilder brgResponseInformationBuilder = new BrgResponseInformationBuilder();
1891 brgResponseInformationBuilder.setInstanceId(allottedResourceId);
1892 brgResponseInformationBuilder.setObjectPath(brgObjectPath);
1893 responseBuilder.setBrgResponseInformation(brgResponseInformationBuilder.build());
1895 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1896 serviceResponseInformationBuilder.setInstanceId(siid);
1897 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1898 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1900 } catch (IllegalStateException e) {
1901 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1902 responseBuilder.setResponseCode("500");
1903 responseBuilder.setResponseMessage(e.toString());
1904 responseBuilder.setAckFinalIndicator("Y");
1905 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1907 RpcResult<BrgTopologyOperationOutput> rpcResult = RpcResultBuilder
1908 .<BrgTopologyOperationOutput>status(true)
1909 .withResult(responseBuilder.build())
1912 return Futures.immediateFuture(rpcResult);
1916 responseBuilder.setResponseCode(error.getStatusCode());
1917 responseBuilder.setAckFinalIndicator(ackFinal);
1918 trySetResponseMessage(responseBuilder, error);
1919 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
1920 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
1922 RpcResult<BrgTopologyOperationOutput> rpcResult = RpcResultBuilder
1923 .<BrgTopologyOperationOutput>status(true)
1924 .withResult(responseBuilder.build())
1927 return Futures.immediateFuture(rpcResult);
1930 private void trySetResponseMessage(BrgTopologyOperationOutputBuilder responseBuilder, ResponseObject error) {
1931 if (!error.getMessage().isEmpty()) {
1932 responseBuilder.setResponseMessage(error.getMessage());
1936 private boolean hasInvalidServiceId(BrgTopologyOperationInput input) {
1937 return input == null || input.getServiceInformation() == null
1938 || input.getServiceInformation().getServiceInstanceId() == null
1939 || input.getServiceInformation().getServiceInstanceId().length() == 0;
1943 public Future<RpcResult<PreloadVnfTopologyOperationOutput>> preloadVnfTopologyOperation(
1944 PreloadVnfTopologyOperationInput input) {
1946 final String svcOperation = "preload-vnf-topology-operation";
1947 Properties parms = new Properties();
1949 log.info(CALLED_STR, svcOperation);
1950 // create a new response object
1951 PreloadVnfTopologyOperationOutputBuilder responseBuilder = new PreloadVnfTopologyOperationOutputBuilder();
1953 if (hasInvalidVnfTopology(input)) {
1955 log.debug("exiting {} because of null input", svcOperation);
1956 responseBuilder.setResponseCode("403");
1957 responseBuilder.setResponseMessage("invalid input: input is null");
1958 responseBuilder.setAckFinalIndicator("Y");
1960 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult = RpcResultBuilder
1961 .<PreloadVnfTopologyOperationOutput>status(true)
1962 .withResult(responseBuilder.build())
1965 return Futures.immediateFuture(rpcResult);
1968 // Grab the name and type from the input buffer
1969 String preloadName = input.getVnfTopologyInformation().getVnfTopologyIdentifier().getVnfName();
1970 String preloadType = input.getVnfTopologyInformation().getVnfTopologyIdentifier().getVnfType();
1972 // Make sure we have a preload_name and preload_type
1973 if (isValidPreloadData(preloadName, preloadType)) {
1974 log.debug("exiting {} vnf-name or vnf-type is null or empty", svcOperation);
1975 responseBuilder.setResponseCode("403");
1976 responseBuilder.setResponseMessage("invalid input: vnf-name or vnf-type is null or empty");
1977 responseBuilder.setAckFinalIndicator("Y");
1979 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult = RpcResultBuilder
1980 .<PreloadVnfTopologyOperationOutput>status(true)
1981 .withResult(responseBuilder.build())
1984 return Futures.immediateFuture(rpcResult);
1987 this.trySetSvcRequestId(input, responseBuilder);
1989 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
1990 getPreloadData(preloadName, preloadType, preloadDataBuilder);
1992 PreloadDataBuilder operDataBuilder = new PreloadDataBuilder();
1993 getPreloadData(preloadName, preloadType, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
1995 // setup a preload-data object builder
1996 // ACTION preload-vnf-topology-operation
1998 // USES sdnc-request-header;
1999 // USES request-information;
2000 // uses vnf-topology-information;
2002 // USES vnf-topology-response-body;
2004 // container preload-data
2005 // uses vnf-topology-information;
2006 // uses network-topology-information;
2007 // uses oper-status;
2009 log.info("Adding INPUT data for {} [{},{}] input: {}", svcOperation, preloadName, preloadType, input);
2010 PreloadVnfTopologyOperationInputBuilder inputBuilder = new PreloadVnfTopologyOperationInputBuilder(input);
2011 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
2012 log.info("Adding OPERATIONAL data for {} [{},{}] operational-data: {}", svcOperation, preloadName,
2013 preloadType, operDataBuilder.build());
2014 GenericResourceApiUtil.toProperties(parms, OPERATIONAL_DATA_PARAM, operDataBuilder);
2016 // Call SLI sync method
2017 // Get SvcLogicService reference
2018 ResponseObject error = new ResponseObject("200", "");
2019 Properties respProps = tryGetProperties(svcOperation, parms, error);
2020 String ackFinal = resolveAckFinal(error, respProps);
2022 if (failed(error)) {
2024 responseBuilder.setResponseCode(error.getStatusCode());
2025 responseBuilder.setResponseMessage(error.getMessage());
2026 responseBuilder.setAckFinalIndicator(ackFinal);
2028 VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
2029 preloadVnfListBuilder.setVnfName(preloadName);
2030 preloadVnfListBuilder.setVnfType(preloadType);
2031 preloadVnfListBuilder.setPreloadData(preloadDataBuilder.build());
2032 log.error("Returned FAILED for {} [{},{}] error code: '{}', Reason: '{}'", svcOperation, preloadName,
2033 preloadType, error.getStatusCode(), error.getMessage());
2035 savePreloadList(preloadVnfListBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
2036 } catch (Exception e) {
2037 log.error(UPDATING_MDSAL_ERROR_MESSAGE_2, svcOperation, preloadName,
2040 log.debug("Sending Success rpc result due to external error");
2042 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult = RpcResultBuilder
2043 .<PreloadVnfTopologyOperationOutput>status(true)
2044 .withResult(responseBuilder.build())
2047 return Futures.immediateFuture(rpcResult);
2050 // Got success from SLI
2052 updatePreloadData(svcOperation, preloadName, preloadType, preloadDataBuilder);
2053 } catch (Exception e) {
2054 log.error(UPDATING_MDSAL_ERROR_MESSAGE_2, svcOperation, preloadName, preloadType,
2056 responseBuilder.setResponseCode("500");
2057 responseBuilder.setResponseMessage(e.toString());
2058 responseBuilder.setAckFinalIndicator("Y");
2059 log.error("Returned FAILED for {} [{},{}] {}", svcOperation, preloadName, preloadType,
2060 responseBuilder.build());
2062 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult = RpcResultBuilder
2063 .<PreloadVnfTopologyOperationOutput>status(false)
2064 .withResult(responseBuilder.build())
2067 return Futures.immediateFuture(rpcResult);
2071 responseBuilder.setResponseCode(error.getStatusCode());
2072 responseBuilder.setAckFinalIndicator(ackFinal);
2073 trySetResponseMessage(responseBuilder, error);
2075 log.info("Updated MD-SAL for {} [{},{}]", svcOperation, preloadName, preloadType);
2076 log.info("Returned SUCCESS for {} [{},{}] {}", svcOperation, preloadName, preloadType,
2077 responseBuilder.build());
2079 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult = RpcResultBuilder
2080 .<PreloadVnfTopologyOperationOutput>status(true)
2081 .withResult(responseBuilder.build())
2084 return Futures.immediateFuture(rpcResult);
2087 private String resolveAckFinal(ResponseObject error, Properties respProps) {
2088 if (respProps != null) {
2089 error.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
2090 error.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
2091 return respProps.getProperty(ACK_FINAL_PARAM, "Y");
2096 private void trySetResponseMessage(PreloadVnfTopologyOperationOutputBuilder responseBuilder, ResponseObject error) {
2097 if (!error.getMessage().isEmpty()) {
2098 responseBuilder.setResponseMessage(error.getMessage());
2102 private void trySetSvcRequestId(PreloadVnfTopologyOperationInput input,
2103 PreloadVnfTopologyOperationOutputBuilder responseBuilder) {
2104 if (input.getSdncRequestHeader() != null) {
2105 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
2109 private boolean hasInvalidVnfTopology(PreloadVnfTopologyOperationInput input) {
2110 return input == null || input.getVnfTopologyInformation() == null
2111 || input.getVnfTopologyInformation().getVnfTopologyIdentifier() == null;
2114 private void updatePreloadData(String svcOperation, String preloadName, String preloadType,
2115 PreloadDataBuilder preloadDataBuilder) {
2116 PreloadData preloadData;
2117 preloadData = preloadDataBuilder.build();
2118 log.info("Updating MD-SAL for {} [{},{}] preloadData: {}", svcOperation, preloadName, preloadType,
2120 // svc-configuration-list
2121 VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
2122 preloadVnfListBuilder.setVnfName(preloadName);
2123 preloadVnfListBuilder.setVnfType(preloadType);
2124 preloadVnfListBuilder.setPreloadData(preloadData);
2126 // merge flag sets to false to allow it to be overwritten (not appended)
2127 savePreloadList(preloadVnfListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
2128 log.info(UPDATING_TREE_INFO_MESSAGE);
2129 savePreloadList(preloadVnfListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
2133 public Future<RpcResult<PreloadNetworkTopologyOperationOutput>> preloadNetworkTopologyOperation(
2134 PreloadNetworkTopologyOperationInput input) {
2136 final String svcOperation = "preload-network-topology-operation";
2137 Properties parms = new Properties();
2139 log.info(CALLED_STR, svcOperation);
2140 // create a new response object
2141 PreloadNetworkTopologyOperationOutputBuilder responseBuilder = new PreloadNetworkTopologyOperationOutputBuilder();
2143 if (hasInvalidNetworkTopology(input)) {
2145 log.debug("exiting {} because of null input", svcOperation);
2146 responseBuilder.setResponseCode("403");
2147 responseBuilder.setResponseMessage("input is null");
2148 responseBuilder.setAckFinalIndicator("Y");
2150 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
2151 .<PreloadNetworkTopologyOperationOutput>status(true)
2152 .withResult(responseBuilder.build())
2155 return Futures.immediateFuture(rpcResult);
2158 // Grab the name and type from the input buffer
2159 String preloadName = input.getNetworkTopologyInformation().getNetworkTopologyIdentifier().getNetworkName();
2160 String preloadType = input.getNetworkTopologyInformation().getNetworkTopologyIdentifier().getNetworkType();
2162 // Make sure we have a preload_name and preload_type
2163 if (isValidPreloadData(preloadName, preloadType)) {
2164 log.debug("exiting {} because of invalid preload-name", svcOperation);
2165 responseBuilder.setResponseCode("403");
2166 responseBuilder.setResponseMessage("input, invalid preload-name");
2167 responseBuilder.setAckFinalIndicator("Y");
2169 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
2170 .<PreloadNetworkTopologyOperationOutput>status(true)
2171 .withResult(responseBuilder.build())
2174 return Futures.immediateFuture(rpcResult);
2177 trySetSvcRequestId(input, responseBuilder);
2179 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
2180 getPreloadData(preloadName, preloadType, preloadDataBuilder);
2182 PreloadDataBuilder operDataBuilder = new PreloadDataBuilder();
2183 getPreloadData(preloadName, preloadType, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
2186 // setup a preload-data object builder
2187 // ACTION preload-network-topology-operation
2189 // USES sdnc-request-header;
2190 // USES request-information;
2191 // uses network-topology-information;
2193 // USES vnf-topology-response-body;
2195 // container preload-data
2196 // uses vnf-topology-information;
2197 // uses network-topology-information;
2198 // uses oper-status;
2200 log.info("Adding INPUT data for {} [{},{}] input: {}", svcOperation, preloadName, preloadType, input);
2201 PreloadNetworkTopologyOperationInputBuilder inputBuilder = new PreloadNetworkTopologyOperationInputBuilder(
2203 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
2204 log.info("Adding OPERATIONAL data for {} [{},{}] operational-data: {}", svcOperation, preloadName,
2205 preloadType, operDataBuilder.build());
2206 GenericResourceApiUtil.toProperties(parms, OPERATIONAL_DATA_PARAM, operDataBuilder);
2208 // Call SLI sync method
2209 // Get SvcLogicService reference
2210 ResponseObject error = new ResponseObject("200", "");
2211 Properties respProps = tryGetProperties(svcOperation, parms, error);
2213 String ackFinal = resolveAckFinal(error, respProps);
2215 if (failed(error)) {
2217 responseBuilder.setResponseCode(error.getStatusCode());
2218 responseBuilder.setResponseMessage(error.getMessage());
2219 responseBuilder.setAckFinalIndicator(ackFinal);
2221 VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
2222 preloadVnfListBuilder.setVnfName(preloadName);
2223 preloadVnfListBuilder.setVnfType(preloadType);
2224 preloadVnfListBuilder.setPreloadData(preloadDataBuilder.build());
2225 log.error("Returned FAILED for {} [{},{}] error code: '{}', Reason: '{}'", svcOperation, preloadName,
2226 preloadType, error.getStatusCode(), error.getMessage());
2228 savePreloadList(preloadVnfListBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
2229 } catch (Exception e) {
2230 log.error(UPDATING_MDSAL_ERROR_MESSAGE_2, svcOperation, preloadName,
2234 log.debug("Sending Success rpc result due to external error");
2236 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
2237 .<PreloadNetworkTopologyOperationOutput>status(true)
2238 .withResult(responseBuilder.build())
2241 return Futures.immediateFuture(rpcResult);
2244 // Got success from SLI
2246 updatePreloadData(svcOperation, preloadName, preloadType, preloadDataBuilder);
2247 } catch (Exception e) {
2248 log.error(UPDATING_MDSAL_ERROR_MESSAGE_2, svcOperation, preloadName, preloadType, e);
2249 responseBuilder.setResponseCode("500");
2250 responseBuilder.setResponseMessage(e.toString());
2251 responseBuilder.setAckFinalIndicator("Y");
2252 log.error("Returned FAILED for {} [{},{}] {}", svcOperation, preloadName, preloadType,
2253 responseBuilder.build());
2255 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
2256 .<PreloadNetworkTopologyOperationOutput>status(false)
2257 .withResult(responseBuilder.build())
2260 return Futures.immediateFuture(rpcResult);
2264 responseBuilder.setResponseCode(error.getStatusCode());
2265 responseBuilder.setAckFinalIndicator(ackFinal);
2266 trySetResponseMessage(responseBuilder, error);
2268 log.info("Updated MD-SAL for {} [{},{}]", svcOperation, preloadName, preloadType);
2269 log.info("Returned SUCCESS for {} [{},{}] {}", svcOperation, preloadName, preloadType,
2270 responseBuilder.build());
2272 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
2273 .<PreloadNetworkTopologyOperationOutput>status(true)
2274 .withResult(responseBuilder.build())
2277 return Futures.immediateFuture(rpcResult);
2280 private void trySetResponseMessage(PreloadNetworkTopologyOperationOutputBuilder responseBuilder,
2281 ResponseObject error) {
2282 if (!error.getMessage().isEmpty()) {
2283 responseBuilder.setResponseMessage(error.getMessage());
2287 private void trySetSvcRequestId(PreloadNetworkTopologyOperationInput input,
2288 PreloadNetworkTopologyOperationOutputBuilder responseBuilder) {
2289 if (input.getSdncRequestHeader() != null) {
2290 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
2294 private boolean isValidPreloadData(String preloadName, String preloadType) {
2295 return preloadName == null || preloadName.length() == 0 || preloadType == null || preloadType.length() == 0;
2298 private boolean hasInvalidNetworkTopology(PreloadNetworkTopologyOperationInput input) {
2299 return input == null || input.getNetworkTopologyInformation() == null
2300 || input.getNetworkTopologyInformation().getNetworkTopologyIdentifier() == null;