1 package org.onap.sdnc.northbound;
3 import java.text.DateFormat;
4 import java.text.SimpleDateFormat;
6 import java.util.Properties;
7 import java.util.TimeZone;
8 import java.util.concurrent.ExecutionException;
9 import java.util.concurrent.ExecutorService;
10 import java.util.concurrent.Executors;
11 import java.util.concurrent.Future;
13 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
14 import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
15 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
16 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
17 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
18 import org.opendaylight.controller.md.sal.common.api.data.OptimisticLockFailedException;
19 import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
20 import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
21 import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
22 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.BrgTopologyOperationInput;
23 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.BrgTopologyOperationInputBuilder;
24 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.BrgTopologyOperationOutput;
25 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.BrgTopologyOperationOutputBuilder;
26 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ContrailRouteTopologyOperationInput;
27 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ContrailRouteTopologyOperationInputBuilder;
28 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ContrailRouteTopologyOperationOutput;
29 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ContrailRouteTopologyOperationOutputBuilder;
30 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.GENERICRESOURCEAPIService;
31 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.NetworkTopologyOperationInput;
32 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.NetworkTopologyOperationInputBuilder;
33 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.NetworkTopologyOperationOutput;
34 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.NetworkTopologyOperationOutputBuilder;
35 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadNetworkTopologyOperationInput;
36 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadNetworkTopologyOperationInputBuilder;
37 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadNetworkTopologyOperationOutput;
38 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadNetworkTopologyOperationOutputBuilder;
39 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadVnfTopologyOperationInput;
40 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadVnfTopologyOperationInputBuilder;
41 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadVnfTopologyOperationOutput;
42 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadVnfTopologyOperationOutputBuilder;
43 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadVnfs;
44 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadVnfsBuilder;
45 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.SecurityZoneTopologyOperationInput;
46 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.SecurityZoneTopologyOperationInputBuilder;
47 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.SecurityZoneTopologyOperationOutput;
48 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.SecurityZoneTopologyOperationOutputBuilder;
49 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ServiceTopologyOperationInput;
50 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ServiceTopologyOperationInputBuilder;
51 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ServiceTopologyOperationOutput;
52 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ServiceTopologyOperationOutputBuilder;
53 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.Services;
54 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ServicesBuilder;
55 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.TunnelxconnTopologyOperationInput;
56 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.TunnelxconnTopologyOperationInputBuilder;
57 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.TunnelxconnTopologyOperationOutput;
58 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.TunnelxconnTopologyOperationOutputBuilder;
59 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.VfModuleTopologyOperationInput;
60 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.VfModuleTopologyOperationInputBuilder;
61 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.VfModuleTopologyOperationOutput;
62 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.VfModuleTopologyOperationOutputBuilder;
63 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.VnfTopologyOperationInput;
64 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.VnfTopologyOperationInputBuilder;
65 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.VnfTopologyOperationOutput;
66 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.VnfTopologyOperationOutputBuilder;
67 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.brg.response.information.BrgResponseInformationBuilder;
68 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.contrail.route.response.information.ContrailRouteResponseInformationBuilder;
69 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.network.response.information.NetworkResponseInformationBuilder;
70 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.preload.data.PreloadData;
71 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.preload.data.PreloadDataBuilder;
72 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.preload.model.information.VnfPreloadList;
73 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.preload.model.information.VnfPreloadListBuilder;
74 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.preload.model.information.VnfPreloadListKey;
75 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.request.information.RequestInformation;
76 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.sdnc.request.header.SdncRequestHeader;
77 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.sdnc.request.header.SdncRequestHeader.SvcAction;
78 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.security.zone.response.information.SecurityZoneResponseInformationBuilder;
79 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.data.ServiceData;
80 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.data.ServiceDataBuilder;
81 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.model.infrastructure.Service;
82 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.model.infrastructure.ServiceBuilder;
83 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.model.infrastructure.ServiceKey;
84 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.response.information.ServiceResponseInformationBuilder;
85 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.status.ServiceStatus.RequestStatus;
86 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.status.ServiceStatus.RpcAction;
87 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.status.ServiceStatusBuilder;
88 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.tunnelxconn.response.information.TunnelxconnResponseInformationBuilder;
89 import org.opendaylight.yangtools.yang.binding.DataObject;
90 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
91 import org.opendaylight.yangtools.yang.common.RpcResult;
92 import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
93 import org.slf4j.Logger;
94 import org.slf4j.LoggerFactory;
96 import com.google.common.base.Optional;
97 import com.google.common.util.concurrent.CheckedFuture;
98 import com.google.common.util.concurrent.Futures;
99 import com.google.common.util.concurrent.SettableFuture;
102 * Defines a base implementation for your provider. This class extends from a
103 * helper class which provides storage for the most commonly used components of
104 * the MD-SAL. Additionally the base class provides some basic logging and
105 * initialization / clean up methods.
107 * To use this, copy and paste (overwrite) the following method into the
108 * TestApplicationProviderModule class which is auto generated under
109 * src/main/java in this project (created only once during first compilation):
114 * public java.lang.AutoCloseable createInstance() {
116 * // final GENERIC-RESOURCE-APIProvider provider = new
117 * // GENERIC-RESOURCE-APIProvider();
118 * final GenericResourceApiProvider provider = new GenericResourceApiProvider();
119 * provider.setDataBroker(getDataBrokerDependency());
120 * provider.setNotificationService(getNotificationServiceDependency());
121 * provider.setRpcRegistry(getRpcRegistryDependency());
122 * provider.initialize();
123 * return new AutoCloseable() {
126 * public void close() throws Exception {
127 * // TODO: CLOSE ANY REGISTRATION OBJECTS CREATED USING ABOVE
128 * // BROKER/NOTIFICATION
129 * // SERVIE/RPC REGISTRY
138 public class GenericResourceApiProvider implements AutoCloseable, GENERICRESOURCEAPIService {
140 private static final String APP_NAME = "generic-resource-api";
141 private static final String CALLED_STR = "{} called.";
142 private static final String NULL_OR_EMPTY_ERROR_LOG = "exiting {} because of null or empty service-instance-id";
143 private static final String NULL_OR_EMPTY_ERROR_PARAM = "invalid input, null or empty service-instance-id";
144 private static final String ADDING_INPUT_DATA_LOG = "Adding INPUT data for {} [{}] input: {}";
145 private static final String ADDING_OPERATIONAL_DATA_LOG = "Adding OPERATIONAL data for {} [{}] operational-data: {}";
146 private static final String OPERATIONAL_DATA_PARAM = "operational-data";
147 private static final String NO_SERVICE_LOGIC_ACTIVE = "No service logic active for ";
148 private static final String SERVICE_LOGIC_SEARCH_ERROR_MESSAGE = "Caught exception looking for service logic";
149 private static final String ERROR_CODE_PARAM = "error-code";
150 private static final String ERROR_MESSAGE_PARAM = "error-message";
151 private static final String ACK_FINAL_PARAM = "ack-final";
152 private static final String SERVICE_OBJECT_PATH_PARAM = "service-object-path";
153 private static final String UPDATING_MDSAL_ERROR_MESSAGE = "Caught Exception updating MD-SAL for {} [{}] \n";
154 private static final String RETURNED_FAILED_MESSAGE = "Returned FAILED for {} [{}] {}";
155 private static final String UPDATING_MDSAL_INFO_MESSAGE = "Updating MD-SAL for {} [{}] ServiceData: {}";
156 private static final String UPDATED_MDSAL_INFO_MESSAGE = "Updated MD-SAL for {} [{}]";
157 private static final String RETURNED_SUCCESS_MESSAGE = "Returned SUCCESS for {} [{}] {}";
158 private static final String NON_NULL_PARAM = "non-null";
159 private static final String NULL_PARAM = "null";
160 private static final String SERVICE_LOGIC_EXECUTION_ERROR_MESSAGE = "Caught exception executing service logic for {} ";
161 private static final String UPDATING_TREE_INFO_MESSAGE = "Updating OPERATIONAL tree.";
162 private static final String EMPTY_SERVICE_INSTANCE_MESSAGE = "exiting {} because the service-instance does not have any service data in SDNC";
163 private static final String INVALID_INPUT_ERROR_MESSAGE = "invalid input: the service-instance does not have any service data in SDNC";
164 private static final String ALLOTTED_RESOURCE_ID_PARAM = "allotted-resource-id";
165 private static final String ERROR_NETWORK_ID = "error";
167 private final Logger log = LoggerFactory.getLogger(GenericResourceApiProvider.class);
168 private final ExecutorService executor;
169 private final GenericResourceApiSvcLogicServiceClient svcLogicClient;
171 protected DataBroker dataBroker;
172 protected NotificationPublishService notificationService;
173 protected RpcProviderRegistry rpcRegistry;
174 protected BindingAwareBroker.RpcRegistration<GENERICRESOURCEAPIService> rpcRegistration;
176 public GenericResourceApiProvider(
177 DataBroker dataBroker,
178 NotificationPublishService notificationPublishService,
179 RpcProviderRegistry rpcProviderRegistry,
180 GenericResourceApiSvcLogicServiceClient client
182 log.info("Creating provider for {}", APP_NAME);
183 executor = Executors.newFixedThreadPool(1);
184 setDataBroker(dataBroker);
185 setNotificationService(notificationPublishService);
186 setRpcRegistry(rpcProviderRegistry);
187 svcLogicClient = client;
192 public void initialize() {
193 log.info("Initializing provider for {}", APP_NAME);
194 // Create the top level containers
197 GenericResourceApiUtil.loadProperties();
198 } catch (Exception e) {
199 log.error("Caught Exception while trying to load properties file", e);
202 log.info("Initialization complete for {}", APP_NAME);
205 protected void initializeChild() {
206 // Override if you have custom initialization intelligence
210 public void close() throws Exception {
211 log.info("Closing provider for {}", APP_NAME);
213 rpcRegistration.close();
214 log.info("Successfully closed provider for {}", APP_NAME);
217 private static class Iso8601Util {
219 private static TimeZone timeZone = TimeZone.getTimeZone("UTC");
220 private static DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'");
222 private Iso8601Util() {}
225 dateFormat.setTimeZone(timeZone);
227 private static String now() {
228 return dateFormat.format(new Date());
232 public void setDataBroker(DataBroker dataBroker) {
233 this.dataBroker = dataBroker;
234 if (log.isDebugEnabled()) {
235 log.debug("DataBroker set to {}", dataBroker == null ? NULL_PARAM : NON_NULL_PARAM);
239 public void setNotificationService(NotificationPublishService notificationService) {
240 this.notificationService = notificationService;
241 if (log.isDebugEnabled()) {
242 log.debug("Notification Service set to {}", notificationService == null ? NULL_PARAM : NON_NULL_PARAM);
246 public void setRpcRegistry(RpcProviderRegistry rpcRegistry) {
247 this.rpcRegistry = rpcRegistry;
248 if (log.isDebugEnabled()) {
249 log.debug("RpcRegistry set to {}", rpcRegistry == null ? NULL_PARAM : NON_NULL_PARAM);
253 private void createContainers() {
255 final WriteTransaction t = dataBroker.newReadWriteTransaction();
257 // Create the service-instance container
258 t.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(Services.class),
259 new ServicesBuilder().build());
260 t.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(Services.class),
261 new ServicesBuilder().build());
263 // Create the PreloadVnfs container
264 t.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(PreloadVnfs.class),
265 new PreloadVnfsBuilder().build());
266 t.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(PreloadVnfs.class),
267 new PreloadVnfsBuilder().build());
270 CheckedFuture<Void, TransactionCommitFailedException> checkedFuture = t.submit();
272 log.info("Create containers succeeded!");
274 } catch (InterruptedException | ExecutionException e) {
275 log.error("Create containers failed: ", e);
279 private void setServiceStatus(ServiceStatusBuilder serviceStatusBuilder, String errorCode, String errorMessage,
281 serviceStatusBuilder.setResponseCode(errorCode);
282 serviceStatusBuilder.setResponseMessage(errorMessage);
283 serviceStatusBuilder.setFinalIndicator(ackFinal);
284 serviceStatusBuilder.setResponseTimestamp(Iso8601Util.now());
287 private void setServiceStatus(ServiceStatusBuilder serviceStatusBuilder, RequestInformation requestInformation) {
288 if (requestInformation != null && requestInformation.getRequestAction() != null) {
289 serviceStatusBuilder.setAction(requestInformation.getRequestAction().toString());
293 private void setServiceStatus(ServiceStatusBuilder serviceStatusBuilder, SdncRequestHeader requestHeader) {
294 if (requestHeader != null && requestHeader.getSvcAction() != null) {
295 switch (requestHeader.getSvcAction()) {
297 serviceStatusBuilder.setRpcAction(RpcAction.Assign);
300 serviceStatusBuilder.setRpcAction(RpcAction.Unassign);
303 serviceStatusBuilder.setRpcAction(RpcAction.Activate);
306 serviceStatusBuilder.setRpcAction(RpcAction.Deactivate);
309 serviceStatusBuilder.setRpcAction(RpcAction.Delete);
312 log.error("Unknown SvcAction: {}", requestHeader.getSvcAction());
318 private void getServiceData(String siid, ServiceDataBuilder serviceDataBuilder) {
320 getServiceData(siid, serviceDataBuilder, LogicalDatastoreType.CONFIGURATION);
323 private void getServiceData(String siid, ServiceDataBuilder serviceDataBuilder, LogicalDatastoreType type) {
324 // See if any data exists yet for this siid, if so grab it.
325 InstanceIdentifier<Service> serviceInstanceIdentifier = InstanceIdentifier
326 .builder(Services.class)
327 .child(Service.class, new ServiceKey(siid))
330 ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction();
331 Optional<Service> data = Optional.absent();
333 data = readTx.read(type, serviceInstanceIdentifier).get();
334 } catch (InterruptedException | ExecutionException e) {
335 log.error("Caught Exception reading MD-SAL ({}) data for [{}] ", type, siid, e);
338 if (data != null && data.isPresent()) {
339 ServiceData serviceData = data.get().getServiceData();
340 if (serviceData != null) {
341 log.info("Read MD-SAL ({}) data for [{}] ServiceData: {}", type, siid, serviceData);
342 serviceDataBuilder.setSdncRequestHeader(serviceData.getSdncRequestHeader());
343 serviceDataBuilder.setRequestInformation(serviceData.getRequestInformation());
344 serviceDataBuilder.setServiceInformation(serviceData.getServiceInformation());
345 serviceDataBuilder.setServiceRequestInput(serviceData.getServiceRequestInput());
346 serviceDataBuilder.setServiceTopology(serviceData.getServiceTopology());
347 serviceDataBuilder.setServiceLevelOperStatus(serviceData.getServiceLevelOperStatus());
348 serviceDataBuilder.setNetworks(serviceData.getNetworks());
349 serviceDataBuilder.setVnfs(serviceData.getVnfs());
350 serviceDataBuilder.setProvidedAllottedResources(serviceData.getProvidedAllottedResources());
351 serviceDataBuilder.setConsumedAllottedResources(serviceData.getConsumedAllottedResources());
352 // service-instance-id needs to be set
354 log.info("No service-data found in MD-SAL ({}) for [{}]", type, siid);
357 log.info("No data found in MD-SAL ({}) for [{}]", type, siid);
361 private void getPreloadData(String vnfName, String vnfType, PreloadDataBuilder preloadDataBuilder) {
363 getPreloadData(vnfName, vnfType, preloadDataBuilder, LogicalDatastoreType.CONFIGURATION);
366 private void getPreloadData(String preloadName, String preloadType, PreloadDataBuilder preloadDataBuilder,
367 LogicalDatastoreType type) {
368 // See if any data exists yet for this name/type, if so grab it.
369 InstanceIdentifier<VnfPreloadList> preloadInstanceIdentifier = InstanceIdentifier
370 .builder(PreloadVnfs.class)
371 .child(VnfPreloadList.class, new VnfPreloadListKey(preloadName, preloadType))
374 ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction();
375 Optional<VnfPreloadList> data = Optional.absent();
377 data = readTx.read(type, preloadInstanceIdentifier).get();
378 } catch (InterruptedException | ExecutionException e) {
379 log.error("Caught Exception reading MD-SAL ({}) for [{},{}] ", type, preloadName, preloadType, e);
382 if (data != null && data.isPresent()) {
383 PreloadData preloadData = data.get().getPreloadData();
384 if (preloadData != null) {
385 log.info("Read MD-SAL ({}) data for [{},{}] PreloadData: {}", type, preloadName, preloadType,
387 preloadDataBuilder.setVnfTopologyInformation(preloadData.getVnfTopologyInformation());
388 preloadDataBuilder.setNetworkTopologyInformation(preloadData.getNetworkTopologyInformation());
389 preloadDataBuilder.setOperStatus(preloadData.getOperStatus());
391 log.info("No preload-data found in MD-SAL ({}) for [{},{}] ", type, preloadName, preloadType);
394 log.info("No data found in MD-SAL ({}) for [{},{}] ", type, preloadName, preloadType);
398 private void saveService(final Service entry, boolean merge, LogicalDatastoreType storeType) {
399 // Each entry will be identifiable by a unique key, we have to create that
401 InstanceIdentifier<Service> path = InstanceIdentifier
402 .builder(Services.class)
403 .child(Service.class, entry.getKey())
406 trySaveEntry(entry, merge, storeType, path);
409 private void savePreloadList(final VnfPreloadList entry, boolean merge, LogicalDatastoreType storeType) {
411 // Each entry will be identifiable by a unique key, we have to create that
413 InstanceIdentifier<VnfPreloadList> path = InstanceIdentifier
414 .builder(PreloadVnfs.class)
415 .child(VnfPreloadList.class, entry.getKey())
418 trySaveEntry(entry, merge, storeType, path);
421 private <T extends DataObject> void trySaveEntry(T entry, boolean merge, LogicalDatastoreType storeType,
422 InstanceIdentifier<T> path) {
426 save(entry, merge, storeType, path);
428 } catch (OptimisticLockFailedException e) {
430 log.debug("Got OptimisticLockFailedException on last try - failing ");
431 throw new IllegalStateException(e);
433 log.debug("Got OptimisticLockFailedException - trying again ");
435 catch (TransactionCommitFailedException ex){
436 log.debug("Update DataStore failed");
437 throw new IllegalStateException(ex);
442 private <T extends DataObject> void save(T entry, boolean merge, LogicalDatastoreType storeType,
443 InstanceIdentifier<T> path)
444 throws TransactionCommitFailedException {
445 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
447 tx.merge(storeType, path, entry);
449 tx.put(storeType, path, entry);
451 tx.submit().checkedGet();
452 log.debug("Update DataStore succeeded");
455 private void deleteService(final Service entry, LogicalDatastoreType storeType) {
456 // Each entry will be identifiable by a unique key, we have to create
458 InstanceIdentifier<Service> path = InstanceIdentifier
459 .builder(Services.class)
460 .child(Service.class, entry.getKey())
463 tryDeleteEntry(storeType, path);
466 private void tryDeleteEntry(LogicalDatastoreType storeType, InstanceIdentifier<Service> path) {
470 delete(storeType, path);
472 } catch (OptimisticLockFailedException e) {
474 log.debug("Got OptimisticLockFailedException on last try - failing ");
475 throw new IllegalStateException(e);
477 log.debug("Got OptimisticLockFailedException - trying again ");
479 catch (TransactionCommitFailedException ex){
480 log.debug("Update DataStore failed");
481 throw new IllegalStateException(ex);
486 private void delete(LogicalDatastoreType storeType, InstanceIdentifier<Service> path)
487 throws TransactionCommitFailedException {
488 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
489 tx.delete(storeType, path);
490 tx.submit().checkedGet();
491 log.debug("DataStore delete succeeded");
495 public Future<RpcResult<ServiceTopologyOperationOutput>> serviceTopologyOperation(
496 ServiceTopologyOperationInput input) {
498 final String svcOperation = "service-topology-operation";
499 ServiceData serviceData;
500 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
501 Properties parms = new Properties();
503 log.info(CALLED_STR, svcOperation);
504 // create a new response object
505 ServiceTopologyOperationOutputBuilder responseBuilder = new ServiceTopologyOperationOutputBuilder();
507 if (input == null || input.getServiceInformation() == null
508 || input.getServiceInformation().getServiceInstanceId() == null
509 || input.getServiceInformation().getServiceInstanceId().length() == 0) {
510 log.debug(NULL_OR_EMPTY_ERROR_LOG, svcOperation);
511 responseBuilder.setResponseCode("404");
512 responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
513 responseBuilder.setAckFinalIndicator("Y");
514 RpcResult<ServiceTopologyOperationOutput> rpcResult = RpcResultBuilder
515 .<ServiceTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
516 return Futures.immediateFuture(rpcResult);
519 // Grab the service instance ID from the input buffer
520 String siid = input.getServiceInformation().getServiceInstanceId();
522 if (input.getSdncRequestHeader() != null) {
523 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
526 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
527 getServiceData(siid, serviceDataBuilder);
529 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
530 getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
532 // Set the serviceStatus based on input
533 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
534 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
537 * // setup a service-data object builder // ACTION service-topology-operation
538 * // INPUT: // USES uses service-operation-information // OUTPUT: // uses
539 * topology-response-common; // uses service-response-information;
542 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
543 ServiceTopologyOperationInputBuilder inputBuilder = new ServiceTopologyOperationInputBuilder(input);
544 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
546 log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid,
547 operDataBuilder.build());
548 GenericResourceApiUtil.toProperties(parms, OPERATIONAL_DATA_PARAM, operDataBuilder);
550 // Call SLI sync method
551 // Get SvcLogicService reference
553 ErrorObject error = new ErrorObject("200", "");
554 Properties respProps = null;
555 String ackFinal = "Y";
556 String serviceObjectPath = null;
559 if (svcLogicClient.hasGraph(APP_NAME, svcOperation, null, "sync")) {
561 respProps = svcLogicClient.execute(APP_NAME, svcOperation, null, "sync", serviceDataBuilder, parms);
562 } catch (Exception e) {
563 log.error(SERVICE_LOGIC_EXECUTION_ERROR_MESSAGE, svcOperation, e);
564 error.setMessage(e.getMessage());
565 error.setStatusCode("500");
568 error.setMessage(NO_SERVICE_LOGIC_ACTIVE + APP_NAME + ": '" + svcOperation + "'");
569 error.setStatusCode("503");
571 } catch (Exception e) {
572 error.setMessage(e.getMessage());
573 error.setStatusCode("500");
574 log.error(SERVICE_LOGIC_SEARCH_ERROR_MESSAGE, e);
577 if (respProps != null) {
578 error.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
579 error.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
580 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
581 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
584 setServiceStatus(serviceStatusBuilder, error.getStatusCode(), error.getMessage(), ackFinal);
585 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
586 serviceStatusBuilder.setRpcName(svcOperation);
588 if (validateErrorObject(error)) {
589 responseBuilder.setResponseCode(error.getStatusCode());
590 responseBuilder.setResponseMessage(error.getMessage());
591 responseBuilder.setAckFinalIndicator(ackFinal);
593 ServiceBuilder serviceBuilder = new ServiceBuilder();
594 serviceBuilder.setServiceInstanceId(siid);
595 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
597 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
598 } catch (Exception e) {
599 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
601 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
602 RpcResult<ServiceTopologyOperationOutput> rpcResult = RpcResultBuilder
603 .<ServiceTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
604 return Futures.immediateFuture(rpcResult);
607 // Got success from SLI
609 serviceData = serviceDataBuilder.build();
610 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
613 ServiceBuilder serviceBuilder = new ServiceBuilder();
614 serviceBuilder.setServiceData(serviceData);
615 serviceBuilder.setServiceInstanceId(siid);
616 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
617 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
619 if (isValidRequest(input) && input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete)) {
620 // Only update operational tree on delete
621 log.info("Delete from both CONFIGURATION and OPERATIONAL tree.");
622 deleteService(serviceBuilder.build(), LogicalDatastoreType.OPERATIONAL);
623 deleteService(serviceBuilder.build(), LogicalDatastoreType.CONFIGURATION);
626 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
627 serviceResponseInformationBuilder.setInstanceId(siid);
628 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
629 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
631 } catch (Exception e) {
632 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
633 responseBuilder.setResponseCode("500");
634 responseBuilder.setResponseMessage(e.toString());
635 responseBuilder.setAckFinalIndicator("Y");
636 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
637 RpcResult<ServiceTopologyOperationOutput> rpcResult = RpcResultBuilder
638 .<ServiceTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
639 return Futures.immediateFuture(rpcResult);
643 responseBuilder.setResponseCode(error.getStatusCode());
644 responseBuilder.setAckFinalIndicator(ackFinal);
645 if (!error.getMessage().isEmpty()) {
646 responseBuilder.setResponseMessage(error.getMessage());
648 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
649 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
651 RpcResult<ServiceTopologyOperationOutput> rpcResult = RpcResultBuilder
652 .<ServiceTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
653 return Futures.immediateFuture(rpcResult);
656 private boolean validateErrorObject(ErrorObject error) {
658 !error.getStatusCode().isEmpty() && !("0".equals(error.getStatusCode()) || "200".equals(error.getStatusCode()));
661 private boolean isValidRequest(ServiceTopologyOperationInput input){
662 return input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null;
666 public Future<RpcResult<VnfTopologyOperationOutput>> vnfTopologyOperation(VnfTopologyOperationInput input) {
668 final String svcOperation = "vnf-topology-operation";
669 ServiceData serviceData;
670 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
671 Properties parms = new Properties();
673 log.info(CALLED_STR, svcOperation);
674 // create a new response object
675 VnfTopologyOperationOutputBuilder responseBuilder = new VnfTopologyOperationOutputBuilder();
677 if (input == null || input.getServiceInformation() == null
678 || input.getServiceInformation().getServiceInstanceId() == null
679 || input.getServiceInformation().getServiceInstanceId().length() == 0) {
680 log.debug(NULL_OR_EMPTY_ERROR_LOG, svcOperation);
681 responseBuilder.setResponseCode("404");
682 responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
683 responseBuilder.setAckFinalIndicator("Y");
684 RpcResult<VnfTopologyOperationOutput> rpcResult = RpcResultBuilder.<VnfTopologyOperationOutput>status(true)
685 .withResult(responseBuilder.build()).build();
687 return Futures.immediateFuture(rpcResult);
690 // Grab the service instance ID from the input buffer
691 String siid = input.getServiceInformation().getServiceInstanceId();
693 if (input.getSdncRequestHeader() != null) {
694 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
697 if (input.getVnfInformation() == null || input.getVnfInformation().getVnfId() == null
698 || input.getVnfInformation().getVnfId().length() == 0) {
699 log.debug("exiting {} because of null or empty vnf-id", svcOperation);
700 responseBuilder.setResponseCode("404");
701 responseBuilder.setResponseMessage("invalid input, null or empty vnf-id");
702 responseBuilder.setAckFinalIndicator("Y");
703 RpcResult<VnfTopologyOperationOutput> rpcResult = RpcResultBuilder.<VnfTopologyOperationOutput>status(true)
704 .withResult(responseBuilder.build()).build();
705 return Futures.immediateFuture(rpcResult);
708 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
709 getServiceData(siid, serviceDataBuilder);
711 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
712 getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
714 // Set the serviceStatus based on input
715 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
716 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
719 // setup a service-data object builder
720 // ACTION vnf-topology-operation
722 // USES sdnc-request-header;
723 // USES request-information;
724 // USES service-information;
725 // USES vnf-request-information
727 // USES vnf-topology-response-body;
728 // USES vnf-information
729 // USES service-information
731 // container service-data
732 // uses vnf-configuration-information;
735 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
736 VnfTopologyOperationInputBuilder inputBuilder = new VnfTopologyOperationInputBuilder(input);
737 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
739 log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid,
740 operDataBuilder.build());
741 GenericResourceApiUtil.toProperties(parms, OPERATIONAL_DATA_PARAM, operDataBuilder);
743 // Call SLI sync method
744 // Get SvcLogicService reference
746 Properties respProps = null;
747 ErrorObject error = new ErrorObject("200", "");
748 String ackFinal = "Y";
749 String serviceObjectPath = null;
752 if (svcLogicClient.hasGraph(APP_NAME, svcOperation, null, "sync")) {
754 respProps = svcLogicClient.execute(APP_NAME, svcOperation, null, "sync", serviceDataBuilder, parms);
755 } catch (Exception e) {
756 log.error(SERVICE_LOGIC_EXECUTION_ERROR_MESSAGE, svcOperation, e);
757 error.setMessage(e.getMessage());
758 error.setStatusCode("500");
761 error.setMessage(NO_SERVICE_LOGIC_ACTIVE + APP_NAME + ": '" + svcOperation + "'");
762 error.setStatusCode("503");
764 } catch (Exception e) {
765 error.setStatusCode("500");
766 error.setMessage(e.getMessage());
767 log.error(SERVICE_LOGIC_SEARCH_ERROR_MESSAGE, e);
770 if (respProps != null) {
771 error.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
772 error.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
773 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
774 serviceObjectPath = respProps.getProperty("vnf-object-path");
777 setServiceStatus(serviceStatusBuilder, error.getStatusCode(), error.getMessage(), ackFinal);
778 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
779 serviceStatusBuilder.setRpcName(svcOperation);
781 if (validateErrorObject(error)) {
782 responseBuilder.setResponseCode(error.getStatusCode());
783 responseBuilder.setResponseMessage(error.getMessage());
784 responseBuilder.setAckFinalIndicator(ackFinal);
786 ServiceBuilder serviceBuilder = new ServiceBuilder();
787 serviceBuilder.setServiceInstanceId(siid);
788 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
790 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
791 if (isValidRequest(input) &&
792 (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete) ||
793 input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))) {
795 // Only update operational tree on activate or delete
796 log.info(UPDATING_TREE_INFO_MESSAGE);
797 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
799 } catch (Exception e) {
800 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
802 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
803 RpcResult<VnfTopologyOperationOutput> rpcResult = RpcResultBuilder.<VnfTopologyOperationOutput>status(true)
804 .withResult(responseBuilder.build()).build();
806 return Futures.immediateFuture(rpcResult);
809 // Got success from SLI
811 serviceData = serviceDataBuilder.build();
812 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
815 ServiceBuilder serviceBuilder = new ServiceBuilder();
816 serviceBuilder.setServiceData(serviceData);
817 serviceBuilder.setServiceInstanceId(siid);
818 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
819 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
821 if (isValidRequest(input) && input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate) ) {
822 // Only update operational tree on Assign
824 log.info(UPDATING_TREE_INFO_MESSAGE);
825 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
828 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
829 serviceResponseInformationBuilder.setInstanceId(siid);
830 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
831 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
833 } catch (Exception e) {
834 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
835 responseBuilder.setResponseCode("500");
836 responseBuilder.setResponseMessage(e.toString());
837 responseBuilder.setAckFinalIndicator("Y");
838 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
839 RpcResult<VnfTopologyOperationOutput> rpcResult = RpcResultBuilder.<VnfTopologyOperationOutput>status(true)
840 .withResult(responseBuilder.build()).build();
841 return Futures.immediateFuture(rpcResult);
845 responseBuilder.setResponseCode(error.getStatusCode());
846 responseBuilder.setAckFinalIndicator(ackFinal);
847 if (!error.getMessage().isEmpty()) {
848 responseBuilder.setResponseMessage(error.getMessage());
850 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
851 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
853 RpcResult<VnfTopologyOperationOutput> rpcResult = RpcResultBuilder.<VnfTopologyOperationOutput>status(true)
854 .withResult(responseBuilder.build()).build();
856 return Futures.immediateFuture(rpcResult);
859 private boolean isValidRequest(VnfTopologyOperationInput input){
860 return input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null;
864 public Future<RpcResult<VfModuleTopologyOperationOutput>> vfModuleTopologyOperation(
865 VfModuleTopologyOperationInput input) {
867 final String svcOperation = "vf-module-topology-operation";
868 ServiceData serviceData;
869 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
870 Properties parms = new Properties();
872 log.info(CALLED_STR, svcOperation);
873 // create a new response object
874 VfModuleTopologyOperationOutputBuilder responseBuilder = new VfModuleTopologyOperationOutputBuilder();
876 if (input == null || input.getServiceInformation() == null
877 || input.getServiceInformation().getServiceInstanceId() == null
878 || input.getServiceInformation().getServiceInstanceId().length() == 0) {
879 log.debug(NULL_OR_EMPTY_ERROR_LOG, svcOperation);
880 responseBuilder.setResponseCode("403");
881 responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
882 responseBuilder.setAckFinalIndicator("Y");
883 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
884 .<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
886 return Futures.immediateFuture(rpcResult);
889 if (input.getVnfInformation() == null || input.getVnfInformation().getVnfId() == null
890 || input.getVnfInformation().getVnfId().length() == 0) {
891 log.debug("exiting {} because of null or empty vnf-id", svcOperation);
892 responseBuilder.setResponseCode("403");
893 responseBuilder.setResponseMessage("invalid input, null or empty vnf-id");
894 responseBuilder.setAckFinalIndicator("Y");
895 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
896 .<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
897 return Futures.immediateFuture(rpcResult);
900 if (input.getVfModuleInformation() == null || input.getVfModuleInformation().getVfModuleId() == null
901 || input.getVfModuleInformation().getVfModuleId().length() == 0) {
902 log.debug("exiting {} because of null or empty vf-module-id", svcOperation);
903 responseBuilder.setResponseCode("403");
904 responseBuilder.setResponseMessage("invalid input, vf-module-id is null or empty");
905 responseBuilder.setAckFinalIndicator("Y");
906 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
907 .<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
908 return Futures.immediateFuture(rpcResult);
911 // Grab the service instance ID from the input buffer
912 String siid = input.getServiceInformation().getServiceInstanceId();
914 if (input.getSdncRequestHeader() != null) {
915 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
918 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
919 getServiceData(siid, serviceDataBuilder);
921 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
922 getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
924 // Set the serviceStatus based on input
925 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
926 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
929 // setup a service-data object builder
930 // ACTION vnf-topology-operation
932 // USES sdnc-request-header;
933 // USES request-information;
934 // USES service-information;
935 // USES vnf-request-information
937 // USES vnf-topology-response-body;
938 // USES vnf-information
939 // USES service-information
941 // container service-data
942 // uses vnf-configuration-information;
945 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
946 VfModuleTopologyOperationInputBuilder inputBuilder = new VfModuleTopologyOperationInputBuilder(input);
947 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
949 log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid,
950 operDataBuilder.build());
951 GenericResourceApiUtil.toProperties(parms, OPERATIONAL_DATA_PARAM, operDataBuilder);
953 // Call SLI sync method
954 // Get SvcLogicService reference
956 ErrorObject error = new ErrorObject("200", "");
957 Properties respProps = null;
958 String ackFinal = "Y";
959 String serviceObjectPath = null;
962 if (svcLogicClient.hasGraph(APP_NAME, svcOperation, null, "sync")) {
965 respProps = svcLogicClient.execute(APP_NAME, svcOperation, null, "sync", serviceDataBuilder, parms);
966 } catch (Exception e) {
967 log.error("Caught exception executing service logic for " + svcOperation, e);
968 error.setMessage(e.getMessage());
969 error.setStatusCode("500");
972 error.setMessage(NO_SERVICE_LOGIC_ACTIVE + APP_NAME + ": '" + svcOperation + "'");
973 error.setStatusCode("503");
975 } catch (Exception e) {
976 error.setMessage(e.getMessage());
977 error.setStatusCode("500");
978 log.error(SERVICE_LOGIC_SEARCH_ERROR_MESSAGE, e);
981 if (respProps != null) {
982 error.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
983 error.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
984 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
985 serviceObjectPath = respProps.getProperty("vf-module-object-path");
988 setServiceStatus(serviceStatusBuilder, error.getStatusCode(), error.getMessage(), ackFinal);
989 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
990 serviceStatusBuilder.setRpcName(svcOperation);
992 if (validateErrorObject(error)) {
993 responseBuilder.setResponseCode(error.getStatusCode());
994 responseBuilder.setResponseMessage(error.getStatusCode());
995 responseBuilder.setAckFinalIndicator(ackFinal);
997 ServiceBuilder serviceBuilder = new ServiceBuilder();
998 serviceBuilder.setServiceInstanceId(siid);
999 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1001 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
1002 } catch (Exception e) {
1003 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1005 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1006 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
1007 .<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1009 return Futures.immediateFuture(rpcResult);
1012 // Got success from SLI
1014 serviceData = serviceDataBuilder.build();
1015 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
1018 ServiceBuilder serviceBuilder = new ServiceBuilder();
1019 serviceBuilder.setServiceData(serviceData);
1020 serviceBuilder.setServiceInstanceId(siid);
1021 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1022 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1024 if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null) {
1025 // Only update operational tree on activate or delete
1026 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Unassign)
1027 || input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate)) {
1028 log.info(UPDATING_TREE_INFO_MESSAGE);
1029 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1033 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1034 serviceResponseInformationBuilder.setInstanceId(siid);
1035 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1036 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1038 } catch (Exception e) {
1039 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1040 responseBuilder.setResponseCode("500");
1041 responseBuilder.setResponseMessage(e.toString());
1042 responseBuilder.setAckFinalIndicator("Y");
1043 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1044 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
1045 .<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1046 return Futures.immediateFuture(rpcResult);
1050 responseBuilder.setResponseCode(error.getStatusCode());
1051 responseBuilder.setAckFinalIndicator(ackFinal);
1052 if (!error.getMessage().isEmpty()) {
1053 responseBuilder.setResponseMessage(error.getMessage());
1055 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
1056 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
1058 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
1059 .<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1061 return Futures.immediateFuture(rpcResult);
1065 public Future<RpcResult<NetworkTopologyOperationOutput>> networkTopologyOperation(
1066 NetworkTopologyOperationInput input) {
1068 final String svcOperation = "network-topology-operation";
1069 ServiceData serviceData;
1070 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1071 Properties parms = new Properties();
1073 log.info(CALLED_STR, svcOperation);
1074 // create a new response object
1075 NetworkTopologyOperationOutputBuilder responseBuilder = new NetworkTopologyOperationOutputBuilder();
1077 if (input == null || input.getServiceInformation() == null
1078 || input.getServiceInformation().getServiceInstanceId() == null
1079 || input.getServiceInformation().getServiceInstanceId().length() == 0) {
1080 log.debug(NULL_OR_EMPTY_ERROR_LOG, svcOperation);
1081 responseBuilder.setResponseCode("404");
1082 responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
1083 responseBuilder.setAckFinalIndicator("Y");
1084 RpcResult<NetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
1085 .<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1086 return Futures.immediateFuture(rpcResult);
1089 String siid = input.getServiceInformation().getServiceInstanceId();
1091 // Get the service-instance service data from MD-SAL
1092 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1093 getServiceData(siid, serviceDataBuilder);
1095 if (input.getSdncRequestHeader() != null) {
1096 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1099 ServiceData sd = serviceDataBuilder.build();
1100 if (sd == null || sd.getServiceLevelOperStatus() == null) {
1101 log.debug(EMPTY_SERVICE_INSTANCE_MESSAGE, svcOperation);
1102 responseBuilder.setResponseCode("404");
1104 .setResponseMessage(INVALID_INPUT_ERROR_MESSAGE);
1105 responseBuilder.setAckFinalIndicator("Y");
1106 RpcResult<NetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
1107 .<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1108 return Futures.immediateFuture(rpcResult);
1111 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
1112 NetworkTopologyOperationInputBuilder inputBuilder = new NetworkTopologyOperationInputBuilder(input);
1113 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1115 // Call SLI sync method
1116 // Get SvcLogicService reference
1118 Properties respProps = null;
1120 ErrorObject error = new ErrorObject("200", "");
1121 String ackFinal = "Y";
1122 String networkId = ERROR_NETWORK_ID;
1123 String serviceObjectPath = null;
1124 String networkObjectPath = null;
1127 if (svcLogicClient.hasGraph(APP_NAME, svcOperation, null, "sync")) {
1130 respProps = svcLogicClient.execute(APP_NAME, svcOperation, null, "sync", serviceDataBuilder, parms);
1131 } catch (Exception e) {
1132 log.error(SERVICE_LOGIC_EXECUTION_ERROR_MESSAGE, svcOperation, e);
1133 error.setStatusCode("500");
1134 error.setMessage(e.getMessage());
1137 error.setStatusCode("503");
1138 error.setMessage(NO_SERVICE_LOGIC_ACTIVE + APP_NAME + ": '" + svcOperation + "'");
1140 } catch (Exception e) {
1141 error.setStatusCode("500");
1142 error.setMessage(e.getMessage());
1143 log.error(SERVICE_LOGIC_SEARCH_ERROR_MESSAGE, e);
1146 if (respProps != null) {
1147 error.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
1148 error.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
1149 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
1150 networkId = respProps.getProperty("networkId");
1151 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
1152 networkObjectPath = respProps.getProperty("network-object-path");
1155 if (validateErrorObject(error)) {
1156 responseBuilder.setResponseCode(error.getStatusCode());
1157 responseBuilder.setResponseMessage(error.getMessage());
1158 responseBuilder.setAckFinalIndicator(ackFinal);
1160 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1162 RpcResult<NetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
1163 .<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1164 return Futures.immediateFuture(rpcResult);
1167 // Got success from SLI
1170 serviceData = serviceDataBuilder.build();
1171 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
1174 ServiceBuilder serviceBuilder = new ServiceBuilder();
1175 serviceBuilder.setServiceData(serviceData);
1176 serviceBuilder.setServiceInstanceId(siid);
1177 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1178 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1180 if (isValidRequest(input) &&
1181 (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate) ||
1182 input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Create))) {
1183 // Only update operational tree on Activate
1184 log.info(UPDATING_TREE_INFO_MESSAGE);
1185 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1188 NetworkResponseInformationBuilder networkResponseInformationBuilder = new NetworkResponseInformationBuilder();
1189 networkResponseInformationBuilder.setInstanceId(networkId);
1190 networkResponseInformationBuilder.setObjectPath(networkObjectPath);
1191 responseBuilder.setNetworkResponseInformation(networkResponseInformationBuilder.build());
1193 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1194 serviceResponseInformationBuilder.setInstanceId(siid);
1195 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1196 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1198 } catch (IllegalStateException e) {
1199 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1200 responseBuilder.setResponseCode("500");
1201 responseBuilder.setResponseMessage(e.toString());
1202 responseBuilder.setAckFinalIndicator("Y");
1203 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1204 RpcResult<NetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
1205 .<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1206 return Futures.immediateFuture(rpcResult);
1210 responseBuilder.setResponseCode(error.getStatusCode());
1211 responseBuilder.setAckFinalIndicator(ackFinal);
1212 if (!error.getMessage().isEmpty()) {
1213 responseBuilder.setResponseMessage(error.getMessage());
1215 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
1216 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
1218 RpcResult<NetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
1219 .<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1220 return Futures.immediateFuture(rpcResult);
1223 private boolean isValidRequest(NetworkTopologyOperationInput input) {
1224 return input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null;
1228 public Future<RpcResult<ContrailRouteTopologyOperationOutput>> contrailRouteTopologyOperation(
1229 ContrailRouteTopologyOperationInput input) {
1231 final String svcOperation = "contrail-route-topology-operation";
1232 ServiceData serviceData;
1233 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1234 Properties parms = new Properties();
1236 log.info(CALLED_STR, svcOperation);
1237 // create a new response object
1238 ContrailRouteTopologyOperationOutputBuilder responseBuilder = new ContrailRouteTopologyOperationOutputBuilder();
1240 if (input == null || input.getServiceInformation() == null
1241 || input.getServiceInformation().getServiceInstanceId() == null
1242 || input.getServiceInformation().getServiceInstanceId().length() == 0) {
1243 log.debug(NULL_OR_EMPTY_ERROR_LOG, svcOperation);
1244 responseBuilder.setResponseCode("404");
1245 responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
1246 responseBuilder.setAckFinalIndicator("Y");
1247 RpcResult<ContrailRouteTopologyOperationOutput> rpcResult = RpcResultBuilder
1248 .<ContrailRouteTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1249 return Futures.immediateFuture(rpcResult);
1252 String siid = input.getServiceInformation().getServiceInstanceId();
1254 // Get the service-instance service data from MD-SAL
1255 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1256 getServiceData(siid, serviceDataBuilder);
1258 if (input.getSdncRequestHeader() != null) {
1259 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1262 ServiceData sd = serviceDataBuilder.build();
1263 if (sd == null || sd.getServiceLevelOperStatus() == null) {
1264 log.debug(EMPTY_SERVICE_INSTANCE_MESSAGE, svcOperation);
1265 responseBuilder.setResponseCode("404");
1267 .setResponseMessage(INVALID_INPUT_ERROR_MESSAGE);
1268 responseBuilder.setAckFinalIndicator("Y");
1269 RpcResult<ContrailRouteTopologyOperationOutput> rpcResult = RpcResultBuilder
1270 .<ContrailRouteTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1271 return Futures.immediateFuture(rpcResult);
1274 log.info("Adding INPUT data for " + svcOperation + " [" + siid + "] input: " + input);
1275 ContrailRouteTopologyOperationInputBuilder inputBuilder = new ContrailRouteTopologyOperationInputBuilder(input);
1276 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1278 // Call SLI sync method
1279 // Get SvcLogicService reference
1281 Properties respProps = null;
1283 ErrorObject error = new ErrorObject("200", "");
1284 String ackFinal = "Y";
1285 String allottedResourceId = ERROR_NETWORK_ID;
1286 String serviceObjectPath = null;
1287 String contrailRouteObjectPath = null;
1290 if (svcLogicClient.hasGraph(APP_NAME, svcOperation, null, "sync")) {
1293 respProps = svcLogicClient.execute(APP_NAME, svcOperation, null, "sync", serviceDataBuilder, parms);
1294 } catch (Exception e) {
1295 log.error(SERVICE_LOGIC_EXECUTION_ERROR_MESSAGE, svcOperation, e);
1296 error.setMessage(e.getMessage());
1297 error.setStatusCode("500");
1300 error.setMessage(NO_SERVICE_LOGIC_ACTIVE + APP_NAME + ": '" + svcOperation + "'");
1301 error.setStatusCode("503");
1303 } catch (Exception e) {
1304 error.setMessage(e.getMessage());
1305 error.setStatusCode("500");
1306 log.error(SERVICE_LOGIC_SEARCH_ERROR_MESSAGE, e);
1309 if (respProps != null) {
1310 error.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
1311 error.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
1312 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
1313 allottedResourceId = respProps.getProperty(ALLOTTED_RESOURCE_ID_PARAM);
1314 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
1315 contrailRouteObjectPath = respProps.getProperty("contrail-route-object-path");
1318 if (validateErrorObject(error)) {
1319 responseBuilder.setResponseCode(error.getStatusCode());
1320 responseBuilder.setResponseMessage(error.getMessage());
1321 responseBuilder.setAckFinalIndicator(ackFinal);
1323 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1325 RpcResult<ContrailRouteTopologyOperationOutput> rpcResult = RpcResultBuilder
1326 .<ContrailRouteTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1327 return Futures.immediateFuture(rpcResult);
1330 // Got success from SLI
1333 serviceData = serviceDataBuilder.build();
1334 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
1337 ServiceBuilder serviceBuilder = new ServiceBuilder();
1338 serviceBuilder.setServiceData(serviceData);
1339 serviceBuilder.setServiceInstanceId(siid);
1340 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1341 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1343 if (isValidRequest(input) &&
1344 (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Unassign) ||
1345 input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))) {
1346 // Only update operational tree on activate or delete
1347 log.info(UPDATING_TREE_INFO_MESSAGE);
1348 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1351 ContrailRouteResponseInformationBuilder contrailRouteResponseInformationBuilder = new ContrailRouteResponseInformationBuilder();
1352 contrailRouteResponseInformationBuilder.setInstanceId(allottedResourceId);
1353 contrailRouteResponseInformationBuilder.setObjectPath(contrailRouteObjectPath);
1354 responseBuilder.setContrailRouteResponseInformation(contrailRouteResponseInformationBuilder.build());
1356 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1357 serviceResponseInformationBuilder.setInstanceId(siid);
1358 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1359 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1361 } catch (IllegalStateException e) {
1362 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1363 responseBuilder.setResponseCode("500");
1364 responseBuilder.setResponseMessage(e.toString());
1365 responseBuilder.setAckFinalIndicator("Y");
1366 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1367 RpcResult<ContrailRouteTopologyOperationOutput> rpcResult = RpcResultBuilder
1368 .<ContrailRouteTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1369 return Futures.immediateFuture(rpcResult);
1373 responseBuilder.setResponseCode(error.getStatusCode());
1374 responseBuilder.setAckFinalIndicator(ackFinal);
1375 if (!error.getMessage().isEmpty()) {
1376 responseBuilder.setResponseMessage(error.getMessage());
1378 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
1379 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
1381 RpcResult<ContrailRouteTopologyOperationOutput> rpcResult = RpcResultBuilder
1382 .<ContrailRouteTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1383 return Futures.immediateFuture(rpcResult);
1386 private boolean isValidRequest(ContrailRouteTopologyOperationInput input) {
1387 return input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null;
1391 public Future<RpcResult<SecurityZoneTopologyOperationOutput>> securityZoneTopologyOperation(
1392 SecurityZoneTopologyOperationInput input) {
1394 final String svcOperation = "security-zone-topology-operation";
1395 ServiceData serviceData;
1396 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1397 Properties parms = new Properties();
1399 log.info(CALLED_STR, svcOperation);
1400 // create a new response object
1401 SecurityZoneTopologyOperationOutputBuilder responseBuilder = new SecurityZoneTopologyOperationOutputBuilder();
1403 if (input == null || input.getServiceInformation() == null
1404 || input.getServiceInformation().getServiceInstanceId() == null
1405 || input.getServiceInformation().getServiceInstanceId().length() == 0) {
1406 log.debug(NULL_OR_EMPTY_ERROR_LOG, svcOperation);
1407 responseBuilder.setResponseCode("404");
1408 responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
1409 responseBuilder.setAckFinalIndicator("Y");
1410 RpcResult<SecurityZoneTopologyOperationOutput> rpcResult = RpcResultBuilder
1411 .<SecurityZoneTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1412 return Futures.immediateFuture(rpcResult);
1415 String siid = input.getServiceInformation().getServiceInstanceId();
1417 // Get the service-instance service data from MD-SAL
1418 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1419 getServiceData(siid, serviceDataBuilder);
1421 if (input.getSdncRequestHeader() != null) {
1422 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1425 ServiceData sd = serviceDataBuilder.build();
1426 if (sd == null || sd.getServiceLevelOperStatus() == null) {
1427 log.debug(EMPTY_SERVICE_INSTANCE_MESSAGE, svcOperation);
1428 responseBuilder.setResponseCode("404");
1430 .setResponseMessage(INVALID_INPUT_ERROR_MESSAGE);
1431 responseBuilder.setAckFinalIndicator("Y");
1432 RpcResult<SecurityZoneTopologyOperationOutput> rpcResult = RpcResultBuilder
1433 .<SecurityZoneTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1434 return Futures.immediateFuture(rpcResult);
1437 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
1438 SecurityZoneTopologyOperationInputBuilder inputBuilder = new SecurityZoneTopologyOperationInputBuilder(input);
1439 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1441 // Call SLI sync method
1442 // Get SvcLogicService reference
1444 Properties respProps = null;
1446 ErrorObject error = new ErrorObject("200", "");
1447 String ackFinal = "Y";
1448 String allottedResourceId = ERROR_NETWORK_ID;
1449 String serviceObjectPath = null;
1450 String securityZoneObjectPath = null;
1453 if (svcLogicClient.hasGraph(APP_NAME, svcOperation, null, "sync")) {
1456 respProps = svcLogicClient.execute(APP_NAME, svcOperation, null, "sync", serviceDataBuilder, parms);
1457 } catch (Exception e) {
1458 log.error(SERVICE_LOGIC_EXECUTION_ERROR_MESSAGE, svcOperation, e);
1459 error.setMessage(e.getMessage());
1460 error.setStatusCode("500");
1463 error.setMessage(NO_SERVICE_LOGIC_ACTIVE + APP_NAME + ": '" + svcOperation + "'");
1464 error.setStatusCode("503");
1466 } catch (Exception e) {
1467 error.setStatusCode("500");
1468 error.setMessage(e.getMessage());
1469 log.error(SERVICE_LOGIC_SEARCH_ERROR_MESSAGE, e);
1472 if (respProps != null) {
1473 error.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
1474 error.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
1475 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
1476 allottedResourceId = respProps.getProperty(ALLOTTED_RESOURCE_ID_PARAM);
1477 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
1478 securityZoneObjectPath = respProps.getProperty("security-zone-object-path");
1481 if (validateErrorObject(error)) {
1482 responseBuilder.setResponseCode(error.getStatusCode());
1483 responseBuilder.setResponseMessage(error.getMessage());
1484 responseBuilder.setAckFinalIndicator(ackFinal);
1486 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1488 RpcResult<SecurityZoneTopologyOperationOutput> rpcResult = RpcResultBuilder
1489 .<SecurityZoneTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1490 return Futures.immediateFuture(rpcResult);
1493 // Got success from SLI
1496 serviceData = serviceDataBuilder.build();
1497 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
1500 ServiceBuilder serviceBuilder = new ServiceBuilder();
1501 serviceBuilder.setServiceData(serviceData);
1502 serviceBuilder.setServiceInstanceId(siid);
1503 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1504 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1506 if (isValidRequest(input) &&
1507 (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Unassign) ||
1508 input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))) {
1509 // Only update operational tree on activate or delete
1510 log.info(UPDATING_TREE_INFO_MESSAGE);
1511 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1514 SecurityZoneResponseInformationBuilder securityZoneResponseInformationBuilder = new SecurityZoneResponseInformationBuilder();
1515 securityZoneResponseInformationBuilder.setInstanceId(allottedResourceId);
1516 securityZoneResponseInformationBuilder.setObjectPath(securityZoneObjectPath);
1517 responseBuilder.setSecurityZoneResponseInformation(securityZoneResponseInformationBuilder.build());
1519 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1520 serviceResponseInformationBuilder.setInstanceId(siid);
1521 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1522 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1524 } catch (IllegalStateException e) {
1525 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1526 responseBuilder.setResponseCode("500");
1527 responseBuilder.setResponseMessage(e.toString());
1528 responseBuilder.setAckFinalIndicator("Y");
1529 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1530 RpcResult<SecurityZoneTopologyOperationOutput> rpcResult = RpcResultBuilder
1531 .<SecurityZoneTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1532 return Futures.immediateFuture(rpcResult);
1536 responseBuilder.setResponseCode(error.getStatusCode());
1537 responseBuilder.setAckFinalIndicator(ackFinal);
1538 if (!error.getMessage().isEmpty()) {
1539 responseBuilder.setResponseMessage(error.getMessage());
1541 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
1542 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
1544 RpcResult<SecurityZoneTopologyOperationOutput> rpcResult = RpcResultBuilder
1545 .<SecurityZoneTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1546 return Futures.immediateFuture(rpcResult);
1549 private boolean isValidRequest(SecurityZoneTopologyOperationInput input) {
1550 return input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null;
1554 public Future<RpcResult<TunnelxconnTopologyOperationOutput>> tunnelxconnTopologyOperation(
1555 TunnelxconnTopologyOperationInput input) {
1557 final String SVC_OPERATION = "tunnelxconn-topology-operation";
1558 ServiceData serviceData;
1559 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1560 Properties parms = new Properties();
1562 log.info(CALLED_STR, SVC_OPERATION);
1563 // create a new response object
1564 TunnelxconnTopologyOperationOutputBuilder responseBuilder = new TunnelxconnTopologyOperationOutputBuilder();
1566 if (input == null || input.getServiceInformation() == null
1567 || input.getServiceInformation().getServiceInstanceId() == null
1568 || input.getServiceInformation().getServiceInstanceId().length() == 0) {
1569 log.debug(NULL_OR_EMPTY_ERROR_LOG, SVC_OPERATION);
1570 responseBuilder.setResponseCode("404");
1571 responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
1572 responseBuilder.setAckFinalIndicator("Y");
1573 RpcResult<TunnelxconnTopologyOperationOutput> rpcResult = RpcResultBuilder
1574 .<TunnelxconnTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1575 return Futures.immediateFuture(rpcResult);
1578 String siid = input.getServiceInformation().getServiceInstanceId();
1580 // Get the service-instance service data from MD-SAL
1581 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1582 getServiceData(siid, serviceDataBuilder);
1584 if (input.getSdncRequestHeader() != null) {
1585 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1588 ServiceData sd = serviceDataBuilder.build();
1589 if (sd == null || sd.getServiceLevelOperStatus() == null) {
1590 log.debug("exiting {} because the service-instance does not have any service data in SDNC", SVC_OPERATION);
1591 responseBuilder.setResponseCode("404");
1593 .setResponseMessage("invalid input: the service-instance does not have any service data in SDNC");
1594 responseBuilder.setAckFinalIndicator("Y");
1595 RpcResult<TunnelxconnTopologyOperationOutput> rpcResult = RpcResultBuilder
1596 .<TunnelxconnTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1597 return Futures.immediateFuture(rpcResult);
1600 log.info(ADDING_INPUT_DATA_LOG, SVC_OPERATION, siid, input);
1601 TunnelxconnTopologyOperationInputBuilder inputBuilder = new TunnelxconnTopologyOperationInputBuilder(input);
1602 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1604 // Call SLI sync method
1605 // Get SvcLogicService reference
1607 Properties respProps = null;
1609 String errorCode = "200";
1610 String errorMessage = null;
1611 String ackFinal = "Y";
1612 String allottedResourceId = ERROR_NETWORK_ID;
1613 String serviceObjectPath = null;
1614 String tunnelxconnObjectPath = null;
1617 if (svcLogicClient.hasGraph(APP_NAME, SVC_OPERATION, null, "sync")) {
1620 respProps = svcLogicClient.execute(APP_NAME, SVC_OPERATION, null, "sync", parms);
1621 } catch (Exception e) {
1622 log.error("Caught exception executing service logic for {}", SVC_OPERATION, e);
1623 errorMessage = e.getMessage();
1627 errorMessage = NO_SERVICE_LOGIC_ACTIVE + APP_NAME + ": '" + SVC_OPERATION + "'";
1630 } catch (Exception e) {
1632 errorMessage = e.getMessage();
1633 log.error(SERVICE_LOGIC_SEARCH_ERROR_MESSAGE, e);
1636 if (respProps != null) {
1637 errorCode = respProps.getProperty(ERROR_CODE_PARAM);
1638 errorMessage = respProps.getProperty(ERROR_MESSAGE_PARAM);
1639 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
1640 allottedResourceId = respProps.getProperty(ALLOTTED_RESOURCE_ID_PARAM);
1641 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
1642 tunnelxconnObjectPath = respProps.getProperty("tunnelxconn-object-path");
1645 if (errorCode != null && errorCode.length() != 0 && !(errorCode.equals("0") || errorCode.equals("200"))) {
1646 responseBuilder.setResponseCode(errorCode);
1647 responseBuilder.setResponseMessage(errorMessage);
1648 responseBuilder.setAckFinalIndicator(ackFinal);
1650 log.error(RETURNED_FAILED_MESSAGE, SVC_OPERATION, siid, responseBuilder.build());
1652 RpcResult<TunnelxconnTopologyOperationOutput> rpcResult = RpcResultBuilder
1653 .<TunnelxconnTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1654 return Futures.immediateFuture(rpcResult);
1657 // Got success from SLI
1662 TunnelxconnResponseInformationBuilder tunnelxconnResponseInformationBuilder = new TunnelxconnResponseInformationBuilder();
1663 tunnelxconnResponseInformationBuilder.setInstanceId(allottedResourceId);
1664 tunnelxconnResponseInformationBuilder.setObjectPath(tunnelxconnObjectPath);
1665 responseBuilder.setTunnelxconnResponseInformation(tunnelxconnResponseInformationBuilder.build());
1667 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1668 serviceResponseInformationBuilder.setInstanceId(siid);
1669 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1670 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1672 } catch (IllegalStateException e) {
1673 log.error(UPDATING_MDSAL_ERROR_MESSAGE, SVC_OPERATION, siid, e);
1674 responseBuilder.setResponseCode("500");
1675 responseBuilder.setResponseMessage(e.toString());
1676 responseBuilder.setAckFinalIndicator("Y");
1677 log.error(RETURNED_FAILED_MESSAGE, SVC_OPERATION, siid, responseBuilder.build());
1678 RpcResult<TunnelxconnTopologyOperationOutput> rpcResult = RpcResultBuilder
1679 .<TunnelxconnTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1680 return Futures.immediateFuture(rpcResult);
1684 responseBuilder.setResponseCode(errorCode);
1685 responseBuilder.setAckFinalIndicator(ackFinal);
1686 if (errorMessage != null) {
1687 responseBuilder.setResponseMessage(errorMessage);
1689 log.info(UPDATED_MDSAL_INFO_MESSAGE, SVC_OPERATION, siid);
1690 log.info(RETURNED_SUCCESS_MESSAGE, SVC_OPERATION, siid, responseBuilder.build());
1692 RpcResult<TunnelxconnTopologyOperationOutput> rpcResult = RpcResultBuilder
1693 .<TunnelxconnTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1694 return Futures.immediateFuture(rpcResult);
1698 public Future<RpcResult<BrgTopologyOperationOutput>> brgTopologyOperation(BrgTopologyOperationInput input) {
1699 final String SVC_OPERATION = "brg-topology-operation";
1700 ServiceData serviceData;
1701 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1702 Properties parms = new Properties();
1704 log.info(CALLED_STR, SVC_OPERATION);
1705 // create a new response object
1706 BrgTopologyOperationOutputBuilder responseBuilder = new BrgTopologyOperationOutputBuilder();
1708 if (input == null || input.getServiceInformation() == null
1709 || input.getServiceInformation().getServiceInstanceId() == null
1710 || input.getServiceInformation().getServiceInstanceId().length() == 0) {
1711 log.debug(NULL_OR_EMPTY_ERROR_LOG, SVC_OPERATION);
1712 responseBuilder.setResponseCode("404");
1713 responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
1714 responseBuilder.setAckFinalIndicator("Y");
1715 RpcResult<BrgTopologyOperationOutput> rpcResult = RpcResultBuilder.<BrgTopologyOperationOutput>status(true)
1716 .withResult(responseBuilder.build()).build();
1717 return Futures.immediateFuture(rpcResult);
1720 String siid = input.getServiceInformation().getServiceInstanceId();
1722 /* // Get the service-instance service data from MD-SAL
1723 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1724 getServiceData(siid, serviceDataBuilder);
1726 if (input.getSdncRequestHeader() != null) {
1727 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1730 ServiceData sd = serviceDataBuilder.build();
1731 if (sd == null || sd.getServiceLevelOperStatus() == null) {
1732 log.debug("exiting {} because the service-instance does not have any service data in SDNC", SVC_OPERATION);
1733 responseBuilder.setResponseCode("404");
1735 .setResponseMessage("invalid input: the service-instance does not have any service data in SDNC");
1736 responseBuilder.setAckFinalIndicator("Y");
1737 RpcResult<BrgTopologyOperationOutput> rpcResult = RpcResultBuilder.<BrgTopologyOperationOutput>status(true)
1738 .withResult(responseBuilder.build()).build();
1739 return Futures.immediateFuture(rpcResult);
1742 log.info(ADDING_INPUT_DATA_LOG, SVC_OPERATION, siid, input);
1743 BrgTopologyOperationInputBuilder inputBuilder = new BrgTopologyOperationInputBuilder(input);
1744 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1746 // Call SLI sync method
1747 // Get SvcLogicService reference
1749 Properties respProps = null;
1751 String errorCode = "200";
1752 String errorMessage = null;
1753 String ackFinal = "Y";
1754 String allottedResourceId = ERROR_NETWORK_ID;
1755 String serviceObjectPath = null;
1756 String brgObjectPath = null;
1759 if (svcLogicClient.hasGraph(APP_NAME, SVC_OPERATION, null, "sync")) {
1762 respProps = svcLogicClient.execute(APP_NAME, SVC_OPERATION, null, "sync", parms);
1763 } catch (Exception e) {
1764 log.error("Caught exception executing service logic for {}", SVC_OPERATION, e);
1765 errorMessage = e.getMessage();
1769 errorMessage = NO_SERVICE_LOGIC_ACTIVE + APP_NAME + ": '" + SVC_OPERATION + "'";
1772 } catch (Exception e) {
1774 errorMessage = e.getMessage();
1775 log.error(SERVICE_LOGIC_SEARCH_ERROR_MESSAGE, e);
1778 if (respProps != null) {
1779 errorCode = respProps.getProperty(ERROR_CODE_PARAM);
1780 errorMessage = respProps.getProperty(ERROR_MESSAGE_PARAM);
1781 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
1782 allottedResourceId = respProps.getProperty(ALLOTTED_RESOURCE_ID_PARAM);
1783 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
1784 brgObjectPath = respProps.getProperty("brg-object-path");
1787 if (errorCode != null && errorCode.length() != 0 && !(errorCode.equals("0") || errorCode.equals("200"))) {
1788 responseBuilder.setResponseCode(errorCode);
1789 responseBuilder.setResponseMessage(errorMessage);
1790 responseBuilder.setAckFinalIndicator(ackFinal);
1792 log.error(RETURNED_FAILED_MESSAGE, SVC_OPERATION, siid, responseBuilder.build());
1794 RpcResult<BrgTopologyOperationOutput> rpcResult = RpcResultBuilder.<BrgTopologyOperationOutput>status(true)
1795 .withResult(responseBuilder.build()).build();
1796 return Futures.immediateFuture(rpcResult);
1799 // Got success from SLI
1803 BrgResponseInformationBuilder brgResponseInformationBuilder = new BrgResponseInformationBuilder();
1804 brgResponseInformationBuilder.setInstanceId(allottedResourceId);
1805 brgResponseInformationBuilder.setObjectPath(brgObjectPath);
1806 responseBuilder.setBrgResponseInformation(brgResponseInformationBuilder.build());
1808 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1809 serviceResponseInformationBuilder.setInstanceId(siid);
1810 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1811 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1813 } catch (IllegalStateException e) {
1814 log.error(UPDATING_MDSAL_ERROR_MESSAGE, SVC_OPERATION, siid, e);
1815 responseBuilder.setResponseCode("500");
1816 responseBuilder.setResponseMessage(e.toString());
1817 responseBuilder.setAckFinalIndicator("Y");
1818 log.error(RETURNED_FAILED_MESSAGE, SVC_OPERATION, siid, responseBuilder.build());
1819 RpcResult<BrgTopologyOperationOutput> rpcResult = RpcResultBuilder.<BrgTopologyOperationOutput>status(true)
1820 .withResult(responseBuilder.build()).build();
1821 return Futures.immediateFuture(rpcResult);
1825 responseBuilder.setResponseCode(errorCode);
1826 responseBuilder.setAckFinalIndicator(ackFinal);
1827 if (errorMessage != null) {
1828 responseBuilder.setResponseMessage(errorMessage);
1830 log.info(UPDATED_MDSAL_INFO_MESSAGE, SVC_OPERATION, siid);
1831 log.info(RETURNED_SUCCESS_MESSAGE, SVC_OPERATION, siid, responseBuilder.build());
1833 RpcResult<BrgTopologyOperationOutput> rpcResult = RpcResultBuilder.<BrgTopologyOperationOutput>status(true)
1834 .withResult(responseBuilder.build()).build();
1835 return Futures.immediateFuture(rpcResult);
1839 public Future<RpcResult<PreloadVnfTopologyOperationOutput>> preloadVnfTopologyOperation(
1840 PreloadVnfTopologyOperationInput input) {
1842 final String SVC_OPERATION = "preload-vnf-topology-operation";
1843 PreloadData preloadData;
1844 Properties parms = new Properties();
1846 log.info(CALLED_STR, SVC_OPERATION);
1847 // create a new response object
1848 PreloadVnfTopologyOperationOutputBuilder responseBuilder = new PreloadVnfTopologyOperationOutputBuilder();
1850 // Result from savePreloadData
1851 final SettableFuture<RpcResult<Void>> futureResult = SettableFuture.create();
1853 if (input == null || input.getVnfTopologyInformation() == null
1854 || input.getVnfTopologyInformation().getVnfTopologyIdentifier() == null) {
1855 log.debug("exiting {} because of null input", SVC_OPERATION);
1856 responseBuilder.setResponseCode("403");
1857 responseBuilder.setResponseMessage("invalid input: input is null");
1858 responseBuilder.setAckFinalIndicator("Y");
1859 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult = RpcResultBuilder
1860 .<PreloadVnfTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1861 return Futures.immediateFuture(rpcResult);
1864 // Grab the name and type from the input buffer
1865 String preload_name = input.getVnfTopologyInformation().getVnfTopologyIdentifier().getVnfName();
1866 String preload_type = input.getVnfTopologyInformation().getVnfTopologyIdentifier().getVnfType();
1868 // Make sure we have a preload_name and preload_type
1869 if (preload_name == null || preload_name.length() == 0 || preload_type == null || preload_type.length() == 0) {
1870 log.debug("exiting {} vnf-name or vnf-type is null or empty", SVC_OPERATION);
1871 responseBuilder.setResponseCode("403");
1872 responseBuilder.setResponseMessage("invalid input: vnf-name or vnf-type is null or empty");
1873 responseBuilder.setAckFinalIndicator("Y");
1874 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult = RpcResultBuilder
1875 .<PreloadVnfTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1876 return Futures.immediateFuture(rpcResult);
1879 if (input.getSdncRequestHeader() != null) {
1880 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1883 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
1884 getPreloadData(preload_name, preload_type, preloadDataBuilder);
1886 PreloadDataBuilder operDataBuilder = new PreloadDataBuilder();
1887 getPreloadData(preload_name, preload_type, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
1889 // setup a preload-data object builder
1890 // ACTION preload-vnf-topology-operation
1892 // USES sdnc-request-header;
1893 // USES request-information;
1894 // uses vnf-topology-information;
1896 // USES vnf-topology-response-body;
1898 // container preload-data
1899 // uses vnf-topology-information;
1900 // uses network-topology-information;
1901 // uses oper-status;
1903 log.info("Adding INPUT data for {} [{},{}] input: {}", SVC_OPERATION, preload_name, preload_type, input);
1904 PreloadVnfTopologyOperationInputBuilder inputBuilder = new PreloadVnfTopologyOperationInputBuilder(input);
1905 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1906 log.info("Adding OPERATIONAL data for {} [{},{}] operational-data: {}", SVC_OPERATION, preload_name,
1907 preload_type, operDataBuilder.build());
1908 GenericResourceApiUtil.toProperties(parms, OPERATIONAL_DATA_PARAM, operDataBuilder);
1910 // Call SLI sync method
1911 // Get SvcLogicService reference
1913 Properties respProps = null;
1915 String errorCode = "200";
1916 String errorMessage = null;
1917 String ackFinal = "Y";
1920 if (svcLogicClient.hasGraph(APP_NAME, SVC_OPERATION, null, "sync")) {
1923 respProps = svcLogicClient.execute(APP_NAME, SVC_OPERATION, null, "sync", preloadDataBuilder, parms);
1924 } catch (Exception e) {
1925 log.error("Caught exception executing service logic for {}", SVC_OPERATION, e);
1926 errorMessage = e.getMessage();
1930 errorMessage = NO_SERVICE_LOGIC_ACTIVE + APP_NAME + ": '" + SVC_OPERATION + "'";
1933 } catch (Exception e) {
1935 errorMessage = e.getMessage();
1936 log.error(SERVICE_LOGIC_SEARCH_ERROR_MESSAGE, e);
1939 if (respProps != null) {
1940 errorCode = respProps.getProperty(ERROR_CODE_PARAM);
1941 errorMessage = respProps.getProperty(ERROR_MESSAGE_PARAM);
1942 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
1943 // internalError = respProps.getProperty("internal-error", "false");
1946 if (errorCode != null && errorCode.length() != 0 && !(errorCode.equals("0") || errorCode.equals("200"))) {
1948 responseBuilder.setResponseCode(errorCode);
1949 responseBuilder.setResponseMessage(errorMessage);
1950 responseBuilder.setAckFinalIndicator(ackFinal);
1952 VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
1953 preloadVnfListBuilder.setVnfName(preload_name);
1954 preloadVnfListBuilder.setVnfType(preload_type);
1955 preloadVnfListBuilder.setPreloadData(preloadDataBuilder.build());
1956 log.error("Returned FAILED for {} [{},{}] error code: '{}', Reason: '{}'", SVC_OPERATION, preload_name,
1957 preload_type, errorCode, errorMessage);
1959 savePreloadList(preloadVnfListBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
1960 } catch (Exception e) {
1961 log.error("Caught Exception updating MD-SAL for {} [{},{}] \n", SVC_OPERATION, preload_name,
1964 log.debug("Sending Success rpc result due to external error");
1965 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult = RpcResultBuilder
1966 .<PreloadVnfTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1967 return Futures.immediateFuture(rpcResult);
1970 // Got success from SLI
1972 preloadData = preloadDataBuilder.build();
1973 log.info("Updating MD-SAL for {} [{},{}] preloadData: {}", SVC_OPERATION, preload_name, preload_type,
1975 // svc-configuration-list
1976 VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
1977 preloadVnfListBuilder.setVnfName(preload_name);
1978 preloadVnfListBuilder.setVnfType(preload_type);
1979 preloadVnfListBuilder.setPreloadData(preloadData);
1981 // merge flag sets to false to allow it to be overwritten (not appended)
1982 savePreloadList(preloadVnfListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1983 log.info(UPDATING_TREE_INFO_MESSAGE);
1984 savePreloadList(preloadVnfListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1985 } catch (Exception e) {
1986 log.error("Caught Exception updating MD-SAL for {} [{},{}] \n", SVC_OPERATION, preload_name, preload_type,
1988 responseBuilder.setResponseCode("500");
1989 responseBuilder.setResponseMessage(e.toString());
1990 responseBuilder.setAckFinalIndicator("Y");
1991 log.error("Returned FAILED for {} [{},{}] {}", SVC_OPERATION, preload_name, preload_type,
1992 responseBuilder.build());
1993 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult = RpcResultBuilder
1994 .<PreloadVnfTopologyOperationOutput>status(false).withResult(responseBuilder.build()).build();
1995 return Futures.immediateFuture(rpcResult);
1999 responseBuilder.setResponseCode(errorCode);
2000 responseBuilder.setAckFinalIndicator(ackFinal);
2001 if (errorMessage != null) {
2002 responseBuilder.setResponseMessage(errorMessage);
2004 log.info("Updated MD-SAL for {} [{},{}]", SVC_OPERATION, preload_name, preload_type);
2005 log.info("Returned SUCCESS for {} [{},{}] {}", SVC_OPERATION, preload_name, preload_type,
2006 responseBuilder.build());
2008 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult = RpcResultBuilder
2009 .<PreloadVnfTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2010 return Futures.immediateFuture(rpcResult);
2014 public Future<RpcResult<PreloadNetworkTopologyOperationOutput>> preloadNetworkTopologyOperation(
2015 PreloadNetworkTopologyOperationInput input) {
2017 final String SVC_OPERATION = "preload-network-topology-operation";
2018 PreloadData preloadData;
2019 Properties parms = new Properties();
2021 log.info(CALLED_STR, SVC_OPERATION);
2022 // create a new response object
2023 PreloadNetworkTopologyOperationOutputBuilder responseBuilder = new PreloadNetworkTopologyOperationOutputBuilder();
2025 // Result from savePreloadData
2026 final SettableFuture<RpcResult<Void>> futureResult = SettableFuture.create();
2028 if (input == null || input.getNetworkTopologyInformation() == null
2029 || input.getNetworkTopologyInformation().getNetworkTopologyIdentifier() == null) {
2031 log.debug("exiting {} because of null input", SVC_OPERATION);
2032 responseBuilder.setResponseCode("403");
2033 responseBuilder.setResponseMessage("input is null");
2034 responseBuilder.setAckFinalIndicator("Y");
2035 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
2036 .<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2037 return Futures.immediateFuture(rpcResult);
2040 // Grab the name and type from the input buffer
2041 String preload_name = input.getNetworkTopologyInformation().getNetworkTopologyIdentifier().getNetworkName();
2042 String preload_type = input.getNetworkTopologyInformation().getNetworkTopologyIdentifier().getNetworkType();
2044 // Make sure we have a preload_name and preload_type
2045 if (preload_name == null || preload_name.length() == 0 || preload_type == null || preload_type.length() == 0) {
2046 log.debug("exiting {} because of invalid preload-name", SVC_OPERATION);
2047 responseBuilder.setResponseCode("403");
2048 responseBuilder.setResponseMessage("input, invalid preload-name");
2049 responseBuilder.setAckFinalIndicator("Y");
2050 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
2051 .<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2052 return Futures.immediateFuture(rpcResult);
2055 if (input.getSdncRequestHeader() != null) {
2056 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
2059 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
2060 getPreloadData(preload_name, preload_type, preloadDataBuilder);
2062 PreloadDataBuilder operDataBuilder = new PreloadDataBuilder();
2063 getPreloadData(preload_name, preload_type, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
2066 // setup a preload-data object builder
2067 // ACTION preload-network-topology-operation
2069 // USES sdnc-request-header;
2070 // USES request-information;
2071 // uses network-topology-information;
2073 // USES vnf-topology-response-body;
2075 // container preload-data
2076 // uses vnf-topology-information;
2077 // uses network-topology-information;
2078 // uses oper-status;
2080 log.info("Adding INPUT data for {} [{},{}] input: {}", SVC_OPERATION, preload_name, preload_type, input);
2081 PreloadNetworkTopologyOperationInputBuilder inputBuilder = new PreloadNetworkTopologyOperationInputBuilder(
2083 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
2084 log.info("Adding OPERATIONAL data for {} [{},{}] operational-data: {}", SVC_OPERATION, preload_name,
2085 preload_type, operDataBuilder.build());
2086 GenericResourceApiUtil.toProperties(parms, OPERATIONAL_DATA_PARAM, operDataBuilder);
2088 // Call SLI sync method
2089 // Get SvcLogicService reference
2091 Properties respProps = null;
2093 String errorCode = "200";
2094 String errorMessage = null;
2095 String ackFinal = "Y";
2098 if (svcLogicClient.hasGraph(APP_NAME, SVC_OPERATION, null, "sync")) {
2101 respProps = svcLogicClient.execute(APP_NAME, SVC_OPERATION, null, "sync", preloadDataBuilder, parms);
2102 } catch (Exception e) {
2103 log.error("Caught exception executing service logic for {}", SVC_OPERATION, e);
2104 errorMessage = e.getMessage();
2108 errorMessage = NO_SERVICE_LOGIC_ACTIVE + APP_NAME + ": '" + SVC_OPERATION + "'";
2111 } catch (Exception e) {
2113 errorMessage = e.getMessage();
2114 log.error(SERVICE_LOGIC_SEARCH_ERROR_MESSAGE, e);
2117 if (respProps != null) {
2118 errorCode = respProps.getProperty(ERROR_CODE_PARAM);
2119 errorMessage = respProps.getProperty(ERROR_MESSAGE_PARAM);
2120 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
2121 // internalError = respProps.getProperty("internal-error", "false");
2124 if (errorCode != null && errorCode.length() != 0 && !(errorCode.equals("0") || errorCode.equals("200"))) {
2126 responseBuilder.setResponseCode(errorCode);
2127 responseBuilder.setResponseMessage(errorMessage);
2128 responseBuilder.setAckFinalIndicator(ackFinal);
2130 VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
2131 preloadVnfListBuilder.setVnfName(preload_name);
2132 preloadVnfListBuilder.setVnfType(preload_type);
2133 preloadVnfListBuilder.setPreloadData(preloadDataBuilder.build());
2134 log.error("Returned FAILED for {} [{},{}] error code: '{}', Reason: '{}'", SVC_OPERATION, preload_name,
2135 preload_type, errorCode, errorMessage);
2137 savePreloadList(preloadVnfListBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
2138 } catch (Exception e) {
2139 log.error("Caught Exception updating MD-SAL for {} [{},{}] \n", SVC_OPERATION, preload_name,
2143 log.debug("Sending Success rpc result due to external error");
2144 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
2145 .<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2146 return Futures.immediateFuture(rpcResult);
2149 // Got success from SLI
2151 preloadData = preloadDataBuilder.build();
2152 log.info("Updating MD-SAL for {} [{},{}] preloadData: {}", SVC_OPERATION, preload_name, preload_type,
2154 // svc-configuration-list
2155 VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
2156 preloadVnfListBuilder.setVnfName(preload_name);
2157 preloadVnfListBuilder.setVnfType(preload_type);
2158 preloadVnfListBuilder.setPreloadData(preloadData);
2160 // merge flag sets to false to allow it to be overwritten (not appended)
2161 savePreloadList(preloadVnfListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
2162 log.info(UPDATING_TREE_INFO_MESSAGE);
2163 savePreloadList(preloadVnfListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
2164 } catch (Exception e) {
2165 log.error("Caught Exception updating MD-SAL for " + SVC_OPERATION + " [" + preload_name + "," + preload_type
2167 responseBuilder.setResponseCode("500");
2168 responseBuilder.setResponseMessage(e.toString());
2169 responseBuilder.setAckFinalIndicator("Y");
2170 log.error("Returned FAILED for {} [{},{}] {}", SVC_OPERATION, preload_name, preload_type,
2171 responseBuilder.build());
2172 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
2173 .<PreloadNetworkTopologyOperationOutput>status(false).withResult(responseBuilder.build()).build();
2174 return Futures.immediateFuture(rpcResult);
2178 responseBuilder.setResponseCode(errorCode);
2179 responseBuilder.setAckFinalIndicator(ackFinal);
2180 if (errorMessage != null) {
2181 responseBuilder.setResponseMessage(errorMessage);
2183 log.info("Updated MD-SAL for {} [{},{}]", SVC_OPERATION, preload_name, preload_type);
2184 log.info("Returned SUCCESS for {} [{},{}] {}", SVC_OPERATION, preload_name, preload_type,
2185 responseBuilder.build());
2187 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
2188 .<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2189 return Futures.immediateFuture(rpcResult);