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 UPDATING_MDSAL_ERROR_MESSAGE_2 = "Caught Exception updating MD-SAL for {} [{},{}] \n";
155 private static final String RETURNED_FAILED_MESSAGE = "Returned FAILED for {} [{}] {}";
156 private static final String UPDATING_MDSAL_INFO_MESSAGE = "Updating MD-SAL for {} [{}] ServiceData: {}";
157 private static final String UPDATED_MDSAL_INFO_MESSAGE = "Updated MD-SAL for {} [{}]";
158 private static final String RETURNED_SUCCESS_MESSAGE = "Returned SUCCESS for {} [{}] {}";
159 private static final String NON_NULL_PARAM = "non-null";
160 private static final String NULL_PARAM = "null";
161 private static final String SERVICE_LOGIC_EXECUTION_ERROR_MESSAGE = "Caught exception executing service logic for {} ";
162 private static final String UPDATING_TREE_INFO_MESSAGE = "Updating OPERATIONAL tree.";
163 private static final String EMPTY_SERVICE_INSTANCE_MESSAGE = "exiting {} because the service-instance does not have any service data in SDNC";
164 private static final String INVALID_INPUT_ERROR_MESSAGE = "invalid input: the service-instance does not have any service data in SDNC";
165 private static final String ALLOTTED_RESOURCE_ID_PARAM = "allotted-resource-id";
166 private static final String ERROR_NETWORK_ID = "error";
168 private final Logger log = LoggerFactory.getLogger(GenericResourceApiProvider.class);
169 private final ExecutorService executor;
170 private final GenericResourceApiSvcLogicServiceClient svcLogicClient;
173 protected DataBroker dataBroker;
174 protected NotificationPublishService notificationService;
175 protected RpcProviderRegistry rpcRegistry;
176 protected BindingAwareBroker.RpcRegistration<GENERICRESOURCEAPIService> rpcRegistration;
178 public GenericResourceApiProvider(
179 DataBroker dataBroker,
180 NotificationPublishService notificationPublishService,
181 RpcProviderRegistry rpcProviderRegistry,
182 GenericResourceApiSvcLogicServiceClient client
184 log.info("Creating provider for {}", APP_NAME);
185 executor = Executors.newFixedThreadPool(1);
186 setDataBroker(dataBroker);
187 setNotificationService(notificationPublishService);
188 setRpcRegistry(rpcProviderRegistry);
189 svcLogicClient = client;
194 public void initialize() {
195 log.info("Initializing provider for {}", APP_NAME);
196 // Create the top level containers
199 GenericResourceApiUtil.loadProperties();
200 } catch (Exception e) {
201 log.error("Caught Exception while trying to load properties file", e);
204 log.info("Initialization complete for {}", APP_NAME);
207 protected void initializeChild() {
208 // Override if you have custom initialization intelligence
212 public void close() throws Exception {
213 log.info("Closing provider for {}", APP_NAME);
215 rpcRegistration.close();
216 log.info("Successfully closed provider for {}", APP_NAME);
219 private static class Iso8601Util {
221 private static TimeZone timeZone = TimeZone.getTimeZone("UTC");
222 private static DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'");
224 private Iso8601Util() {}
227 dateFormat.setTimeZone(timeZone);
229 private static String now() {
230 return dateFormat.format(new Date());
234 public void setDataBroker(DataBroker dataBroker) {
235 this.dataBroker = dataBroker;
236 if (log.isDebugEnabled()) {
237 log.debug("DataBroker set to {}", dataBroker == null ? NULL_PARAM : NON_NULL_PARAM);
241 public void setNotificationService(NotificationPublishService notificationService) {
242 this.notificationService = notificationService;
243 if (log.isDebugEnabled()) {
244 log.debug("Notification Service set to {}", notificationService == null ? NULL_PARAM : NON_NULL_PARAM);
248 public void setRpcRegistry(RpcProviderRegistry rpcRegistry) {
249 this.rpcRegistry = rpcRegistry;
250 if (log.isDebugEnabled()) {
251 log.debug("RpcRegistry set to {}", rpcRegistry == null ? NULL_PARAM : NON_NULL_PARAM);
255 private void createContainers() {
257 final WriteTransaction t = dataBroker.newReadWriteTransaction();
259 // Create the service-instance container
260 t.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(Services.class),
261 new ServicesBuilder().build());
262 t.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(Services.class),
263 new ServicesBuilder().build());
265 // Create the PreloadVnfs container
266 t.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(PreloadVnfs.class),
267 new PreloadVnfsBuilder().build());
268 t.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(PreloadVnfs.class),
269 new PreloadVnfsBuilder().build());
272 CheckedFuture<Void, TransactionCommitFailedException> checkedFuture = t.submit();
274 log.info("Create containers succeeded!");
276 } catch (InterruptedException | ExecutionException e) {
277 log.error("Create containers failed: ", e);
281 private void setServiceStatus(ServiceStatusBuilder serviceStatusBuilder, String errorCode, String errorMessage,
283 serviceStatusBuilder.setResponseCode(errorCode);
284 serviceStatusBuilder.setResponseMessage(errorMessage);
285 serviceStatusBuilder.setFinalIndicator(ackFinal);
286 serviceStatusBuilder.setResponseTimestamp(Iso8601Util.now());
289 private void setServiceStatus(ServiceStatusBuilder serviceStatusBuilder, RequestInformation requestInformation) {
290 if (requestInformation != null && requestInformation.getRequestAction() != null) {
291 serviceStatusBuilder.setAction(requestInformation.getRequestAction().toString());
295 private void setServiceStatus(ServiceStatusBuilder serviceStatusBuilder, SdncRequestHeader requestHeader) {
296 if (requestHeader != null && requestHeader.getSvcAction() != null) {
297 switch (requestHeader.getSvcAction()) {
299 serviceStatusBuilder.setRpcAction(RpcAction.Assign);
302 serviceStatusBuilder.setRpcAction(RpcAction.Unassign);
305 serviceStatusBuilder.setRpcAction(RpcAction.Activate);
308 serviceStatusBuilder.setRpcAction(RpcAction.Deactivate);
311 serviceStatusBuilder.setRpcAction(RpcAction.Delete);
314 log.error("Unknown SvcAction: {}", requestHeader.getSvcAction());
320 private void getServiceData(String siid, ServiceDataBuilder serviceDataBuilder) {
322 getServiceData(siid, serviceDataBuilder, LogicalDatastoreType.CONFIGURATION);
325 private void getServiceData(String siid, ServiceDataBuilder serviceDataBuilder, LogicalDatastoreType type) {
326 // See if any data exists yet for this siid, if so grab it.
327 InstanceIdentifier<Service> serviceInstanceIdentifier = InstanceIdentifier
328 .builder(Services.class)
329 .child(Service.class, new ServiceKey(siid))
332 ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction();
333 Optional<Service> data = Optional.absent();
335 data = readTx.read(type, serviceInstanceIdentifier).get();
336 } catch (InterruptedException | ExecutionException e) {
337 log.error("Caught Exception reading MD-SAL ({}) data for [{}] ", type, siid, e);
340 if (data != null && data.isPresent()) {
341 ServiceData serviceData = data.get().getServiceData();
342 if (serviceData != null) {
343 log.info("Read MD-SAL ({}) data for [{}] ServiceData: {}", type, siid, serviceData);
344 serviceDataBuilder.setSdncRequestHeader(serviceData.getSdncRequestHeader());
345 serviceDataBuilder.setRequestInformation(serviceData.getRequestInformation());
346 serviceDataBuilder.setServiceInformation(serviceData.getServiceInformation());
347 serviceDataBuilder.setServiceRequestInput(serviceData.getServiceRequestInput());
348 serviceDataBuilder.setServiceTopology(serviceData.getServiceTopology());
349 serviceDataBuilder.setServiceLevelOperStatus(serviceData.getServiceLevelOperStatus());
350 serviceDataBuilder.setNetworks(serviceData.getNetworks());
351 serviceDataBuilder.setVnfs(serviceData.getVnfs());
352 serviceDataBuilder.setProvidedAllottedResources(serviceData.getProvidedAllottedResources());
353 serviceDataBuilder.setConsumedAllottedResources(serviceData.getConsumedAllottedResources());
354 // service-instance-id needs to be set
356 log.info("No service-data found in MD-SAL ({}) for [{}]", type, siid);
359 log.info("No data found in MD-SAL ({}) for [{}]", type, siid);
363 private void getPreloadData(String vnfName, String vnfType, PreloadDataBuilder preloadDataBuilder) {
365 getPreloadData(vnfName, vnfType, preloadDataBuilder, LogicalDatastoreType.CONFIGURATION);
368 private void getPreloadData(String preloadName, String preloadType, PreloadDataBuilder preloadDataBuilder,
369 LogicalDatastoreType type) {
370 // See if any data exists yet for this name/type, if so grab it.
371 InstanceIdentifier<VnfPreloadList> preloadInstanceIdentifier = InstanceIdentifier
372 .builder(PreloadVnfs.class)
373 .child(VnfPreloadList.class, new VnfPreloadListKey(preloadName, preloadType))
376 ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction();
377 Optional<VnfPreloadList> data = Optional.absent();
379 data = readTx.read(type, preloadInstanceIdentifier).get();
380 } catch (InterruptedException | ExecutionException e) {
381 log.error("Caught Exception reading MD-SAL ({}) for [{},{}] ", type, preloadName, preloadType, e);
384 if (data != null && data.isPresent()) {
385 PreloadData preloadData = data.get().getPreloadData();
386 if (preloadData != null) {
387 log.info("Read MD-SAL ({}) data for [{},{}] PreloadData: {}", type, preloadName, preloadType,
389 preloadDataBuilder.setVnfTopologyInformation(preloadData.getVnfTopologyInformation());
390 preloadDataBuilder.setNetworkTopologyInformation(preloadData.getNetworkTopologyInformation());
391 preloadDataBuilder.setOperStatus(preloadData.getOperStatus());
393 log.info("No preload-data found in MD-SAL ({}) for [{},{}] ", type, preloadName, preloadType);
396 log.info("No data found in MD-SAL ({}) for [{},{}] ", type, preloadName, preloadType);
400 private void saveService(final Service entry, boolean merge, LogicalDatastoreType storeType) {
401 // Each entry will be identifiable by a unique key, we have to create that
403 InstanceIdentifier<Service> path = InstanceIdentifier
404 .builder(Services.class)
405 .child(Service.class, entry.getKey())
408 trySaveEntry(entry, merge, storeType, path);
411 private void savePreloadList(final VnfPreloadList entry, boolean merge, LogicalDatastoreType storeType) {
413 // Each entry will be identifiable by a unique key, we have to create that
415 InstanceIdentifier<VnfPreloadList> path = InstanceIdentifier
416 .builder(PreloadVnfs.class)
417 .child(VnfPreloadList.class, entry.getKey())
420 trySaveEntry(entry, merge, storeType, path);
423 private <T extends DataObject> void trySaveEntry(T entry, boolean merge, LogicalDatastoreType storeType,
424 InstanceIdentifier<T> path) {
428 save(entry, merge, storeType, path);
430 } catch (OptimisticLockFailedException e) {
432 log.debug("Got OptimisticLockFailedException on last try - failing ");
433 throw new IllegalStateException(e);
435 log.debug("Got OptimisticLockFailedException - trying again ");
437 catch (TransactionCommitFailedException ex){
438 log.debug("Update DataStore failed");
439 throw new IllegalStateException(ex);
444 private <T extends DataObject> void save(T entry, boolean merge, LogicalDatastoreType storeType,
445 InstanceIdentifier<T> path)
446 throws TransactionCommitFailedException {
447 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
449 tx.merge(storeType, path, entry);
451 tx.put(storeType, path, entry);
453 tx.submit().checkedGet();
454 log.debug("Update DataStore succeeded");
457 private void deleteService(final Service entry, LogicalDatastoreType storeType) {
458 // Each entry will be identifiable by a unique key, we have to create
460 InstanceIdentifier<Service> path = InstanceIdentifier
461 .builder(Services.class)
462 .child(Service.class, entry.getKey())
465 tryDeleteEntry(storeType, path);
468 private void tryDeleteEntry(LogicalDatastoreType storeType, InstanceIdentifier<Service> path) {
472 delete(storeType, path);
474 } catch (OptimisticLockFailedException e) {
476 log.debug("Got OptimisticLockFailedException on last try - failing ");
477 throw new IllegalStateException(e);
479 log.debug("Got OptimisticLockFailedException - trying again ");
481 catch (TransactionCommitFailedException ex){
482 log.debug("Update DataStore failed");
483 throw new IllegalStateException(ex);
488 private void delete(LogicalDatastoreType storeType, InstanceIdentifier<Service> path)
489 throws TransactionCommitFailedException {
490 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
491 tx.delete(storeType, path);
492 tx.submit().checkedGet();
493 log.debug("DataStore delete succeeded");
497 public Future<RpcResult<ServiceTopologyOperationOutput>> serviceTopologyOperation(
498 ServiceTopologyOperationInput input) {
500 final String svcOperation = "service-topology-operation";
501 ServiceData serviceData;
502 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
503 Properties parms = new Properties();
505 log.info(CALLED_STR, svcOperation);
506 // create a new response object
507 ServiceTopologyOperationOutputBuilder responseBuilder = new ServiceTopologyOperationOutputBuilder();
509 if (input == null || input.getServiceInformation() == null
510 || input.getServiceInformation().getServiceInstanceId() == null
511 || input.getServiceInformation().getServiceInstanceId().length() == 0) {
512 log.debug(NULL_OR_EMPTY_ERROR_LOG, svcOperation);
513 responseBuilder.setResponseCode("404");
514 responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
515 responseBuilder.setAckFinalIndicator("Y");
516 RpcResult<ServiceTopologyOperationOutput> rpcResult = RpcResultBuilder
517 .<ServiceTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
518 return Futures.immediateFuture(rpcResult);
521 // Grab the service instance ID from the input buffer
522 String siid = input.getServiceInformation().getServiceInstanceId();
524 if (input.getSdncRequestHeader() != null) {
525 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
528 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
529 getServiceData(siid, serviceDataBuilder);
531 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
532 getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
534 // Set the serviceStatus based on input
535 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
536 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
539 * // setup a service-data object builder // ACTION service-topology-operation
540 * // INPUT: // USES uses service-operation-information // OUTPUT: // uses
541 * topology-response-common; // uses service-response-information;
544 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
545 ServiceTopologyOperationInputBuilder inputBuilder = new ServiceTopologyOperationInputBuilder(input);
546 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
548 log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid,
549 operDataBuilder.build());
550 GenericResourceApiUtil.toProperties(parms, OPERATIONAL_DATA_PARAM, operDataBuilder);
552 // Call SLI sync method
553 // Get SvcLogicService reference
555 ErrorObject error = new ErrorObject("200", "");
556 Properties respProps = null;
557 String ackFinal = "Y";
558 String serviceObjectPath = null;
561 if (svcLogicClient.hasGraph(APP_NAME, svcOperation, null, "sync")) {
563 respProps = svcLogicClient.execute(APP_NAME, svcOperation, null, "sync", serviceDataBuilder, parms);
564 } catch (Exception e) {
565 log.error(SERVICE_LOGIC_EXECUTION_ERROR_MESSAGE, svcOperation, e);
566 error.setMessage(e.getMessage());
567 error.setStatusCode("500");
570 error.setMessage(NO_SERVICE_LOGIC_ACTIVE + APP_NAME + ": '" + svcOperation + "'");
571 error.setStatusCode("503");
573 } catch (Exception e) {
574 error.setMessage(e.getMessage());
575 error.setStatusCode("500");
576 log.error(SERVICE_LOGIC_SEARCH_ERROR_MESSAGE, e);
579 if (respProps != null) {
580 error.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
581 error.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
582 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
583 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
586 setServiceStatus(serviceStatusBuilder, error.getStatusCode(), error.getMessage(), ackFinal);
587 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
588 serviceStatusBuilder.setRpcName(svcOperation);
590 if (validateErrorObject(error)) {
591 responseBuilder.setResponseCode(error.getStatusCode());
592 responseBuilder.setResponseMessage(error.getMessage());
593 responseBuilder.setAckFinalIndicator(ackFinal);
595 ServiceBuilder serviceBuilder = new ServiceBuilder();
596 serviceBuilder.setServiceInstanceId(siid);
597 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
599 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
600 } catch (Exception e) {
601 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
603 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
604 RpcResult<ServiceTopologyOperationOutput> rpcResult = RpcResultBuilder
605 .<ServiceTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
606 return Futures.immediateFuture(rpcResult);
609 // Got success from SLI
611 serviceData = serviceDataBuilder.build();
612 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
615 ServiceBuilder serviceBuilder = new ServiceBuilder();
616 serviceBuilder.setServiceData(serviceData);
617 serviceBuilder.setServiceInstanceId(siid);
618 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
619 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
621 if (isValidRequest(input) && input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete)) {
622 // Only update operational tree on delete
623 log.info("Delete from both CONFIGURATION and OPERATIONAL tree.");
624 deleteService(serviceBuilder.build(), LogicalDatastoreType.OPERATIONAL);
625 deleteService(serviceBuilder.build(), LogicalDatastoreType.CONFIGURATION);
628 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
629 serviceResponseInformationBuilder.setInstanceId(siid);
630 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
631 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
633 } catch (Exception e) {
634 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
635 responseBuilder.setResponseCode("500");
636 responseBuilder.setResponseMessage(e.toString());
637 responseBuilder.setAckFinalIndicator("Y");
638 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
639 RpcResult<ServiceTopologyOperationOutput> rpcResult = RpcResultBuilder
640 .<ServiceTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
641 return Futures.immediateFuture(rpcResult);
645 responseBuilder.setResponseCode(error.getStatusCode());
646 responseBuilder.setAckFinalIndicator(ackFinal);
647 if (!error.getMessage().isEmpty()) {
648 responseBuilder.setResponseMessage(error.getMessage());
650 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
651 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
653 RpcResult<ServiceTopologyOperationOutput> rpcResult = RpcResultBuilder
654 .<ServiceTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
655 return Futures.immediateFuture(rpcResult);
658 private boolean validateErrorObject(ErrorObject error) {
660 !error.getStatusCode().isEmpty() && !("0".equals(error.getStatusCode()) || "200".equals(error.getStatusCode()));
663 private boolean isValidRequest(ServiceTopologyOperationInput input){
664 return input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null;
668 public Future<RpcResult<VnfTopologyOperationOutput>> vnfTopologyOperation(VnfTopologyOperationInput input) {
670 final String svcOperation = "vnf-topology-operation";
671 ServiceData serviceData;
672 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
673 Properties parms = new Properties();
675 log.info(CALLED_STR, svcOperation);
676 // create a new response object
677 VnfTopologyOperationOutputBuilder responseBuilder = new VnfTopologyOperationOutputBuilder();
679 if (input == null || input.getServiceInformation() == null
680 || input.getServiceInformation().getServiceInstanceId() == null
681 || input.getServiceInformation().getServiceInstanceId().length() == 0) {
682 log.debug(NULL_OR_EMPTY_ERROR_LOG, svcOperation);
683 responseBuilder.setResponseCode("404");
684 responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
685 responseBuilder.setAckFinalIndicator("Y");
686 RpcResult<VnfTopologyOperationOutput> rpcResult = RpcResultBuilder.<VnfTopologyOperationOutput>status(true)
687 .withResult(responseBuilder.build()).build();
689 return Futures.immediateFuture(rpcResult);
692 // Grab the service instance ID from the input buffer
693 String siid = input.getServiceInformation().getServiceInstanceId();
695 if (input.getSdncRequestHeader() != null) {
696 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
699 if (input.getVnfInformation() == null || input.getVnfInformation().getVnfId() == null
700 || input.getVnfInformation().getVnfId().length() == 0) {
701 log.debug("exiting {} because of null or empty vnf-id", svcOperation);
702 responseBuilder.setResponseCode("404");
703 responseBuilder.setResponseMessage("invalid input, null or empty vnf-id");
704 responseBuilder.setAckFinalIndicator("Y");
705 RpcResult<VnfTopologyOperationOutput> rpcResult = RpcResultBuilder.<VnfTopologyOperationOutput>status(true)
706 .withResult(responseBuilder.build()).build();
707 return Futures.immediateFuture(rpcResult);
710 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
711 getServiceData(siid, serviceDataBuilder);
713 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
714 getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
716 // Set the serviceStatus based on input
717 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
718 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
721 // setup a service-data object builder
722 // ACTION vnf-topology-operation
724 // USES sdnc-request-header;
725 // USES request-information;
726 // USES service-information;
727 // USES vnf-request-information
729 // USES vnf-topology-response-body;
730 // USES vnf-information
731 // USES service-information
733 // container service-data
734 // uses vnf-configuration-information;
737 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
738 VnfTopologyOperationInputBuilder inputBuilder = new VnfTopologyOperationInputBuilder(input);
739 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
741 log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid,
742 operDataBuilder.build());
743 GenericResourceApiUtil.toProperties(parms, OPERATIONAL_DATA_PARAM, operDataBuilder);
745 // Call SLI sync method
746 // Get SvcLogicService reference
748 Properties respProps = null;
749 ErrorObject error = new ErrorObject("200", "");
750 String ackFinal = "Y";
751 String serviceObjectPath = null;
754 if (svcLogicClient.hasGraph(APP_NAME, svcOperation, null, "sync")) {
756 respProps = svcLogicClient.execute(APP_NAME, svcOperation, null, "sync", serviceDataBuilder, parms);
757 } catch (Exception e) {
758 log.error(SERVICE_LOGIC_EXECUTION_ERROR_MESSAGE, svcOperation, e);
759 error.setMessage(e.getMessage());
760 error.setStatusCode("500");
763 error.setMessage(NO_SERVICE_LOGIC_ACTIVE + APP_NAME + ": '" + svcOperation + "'");
764 error.setStatusCode("503");
766 } catch (Exception e) {
767 error.setStatusCode("500");
768 error.setMessage(e.getMessage());
769 log.error(SERVICE_LOGIC_SEARCH_ERROR_MESSAGE, e);
772 if (respProps != null) {
773 error.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
774 error.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
775 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
776 serviceObjectPath = respProps.getProperty("vnf-object-path");
779 setServiceStatus(serviceStatusBuilder, error.getStatusCode(), error.getMessage(), ackFinal);
780 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
781 serviceStatusBuilder.setRpcName(svcOperation);
783 if (validateErrorObject(error)) {
784 responseBuilder.setResponseCode(error.getStatusCode());
785 responseBuilder.setResponseMessage(error.getMessage());
786 responseBuilder.setAckFinalIndicator(ackFinal);
788 ServiceBuilder serviceBuilder = new ServiceBuilder();
789 serviceBuilder.setServiceInstanceId(siid);
790 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
792 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
793 if (isValidRequest(input) &&
794 (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete) ||
795 input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))) {
797 // Only update operational tree on activate or delete
798 log.info(UPDATING_TREE_INFO_MESSAGE);
799 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
801 } catch (Exception e) {
802 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
804 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
805 RpcResult<VnfTopologyOperationOutput> rpcResult = RpcResultBuilder.<VnfTopologyOperationOutput>status(true)
806 .withResult(responseBuilder.build()).build();
808 return Futures.immediateFuture(rpcResult);
811 // Got success from SLI
813 serviceData = serviceDataBuilder.build();
814 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
817 ServiceBuilder serviceBuilder = new ServiceBuilder();
818 serviceBuilder.setServiceData(serviceData);
819 serviceBuilder.setServiceInstanceId(siid);
820 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
821 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
823 if (isValidRequest(input) && input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate) ) {
824 // Only update operational tree on Assign
826 log.info(UPDATING_TREE_INFO_MESSAGE);
827 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
830 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
831 serviceResponseInformationBuilder.setInstanceId(siid);
832 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
833 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
835 } catch (Exception e) {
836 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
837 responseBuilder.setResponseCode("500");
838 responseBuilder.setResponseMessage(e.toString());
839 responseBuilder.setAckFinalIndicator("Y");
840 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
841 RpcResult<VnfTopologyOperationOutput> rpcResult = RpcResultBuilder.<VnfTopologyOperationOutput>status(true)
842 .withResult(responseBuilder.build()).build();
843 return Futures.immediateFuture(rpcResult);
847 responseBuilder.setResponseCode(error.getStatusCode());
848 responseBuilder.setAckFinalIndicator(ackFinal);
849 if (!error.getMessage().isEmpty()) {
850 responseBuilder.setResponseMessage(error.getMessage());
852 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
853 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
855 RpcResult<VnfTopologyOperationOutput> rpcResult = RpcResultBuilder.<VnfTopologyOperationOutput>status(true)
856 .withResult(responseBuilder.build()).build();
858 return Futures.immediateFuture(rpcResult);
861 private boolean isValidRequest(VnfTopologyOperationInput input){
862 return input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null;
866 public Future<RpcResult<VfModuleTopologyOperationOutput>> vfModuleTopologyOperation(
867 VfModuleTopologyOperationInput input) {
869 final String svcOperation = "vf-module-topology-operation";
870 ServiceData serviceData;
871 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
872 Properties parms = new Properties();
874 log.info(CALLED_STR, svcOperation);
875 // create a new response object
876 VfModuleTopologyOperationOutputBuilder responseBuilder = new VfModuleTopologyOperationOutputBuilder();
878 if (input == null || input.getServiceInformation() == null
879 || input.getServiceInformation().getServiceInstanceId() == null
880 || input.getServiceInformation().getServiceInstanceId().length() == 0) {
881 log.debug(NULL_OR_EMPTY_ERROR_LOG, svcOperation);
882 responseBuilder.setResponseCode("403");
883 responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
884 responseBuilder.setAckFinalIndicator("Y");
885 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
886 .<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
888 return Futures.immediateFuture(rpcResult);
891 if (input.getVnfInformation() == null || input.getVnfInformation().getVnfId() == null
892 || input.getVnfInformation().getVnfId().length() == 0) {
893 log.debug("exiting {} because of null or empty vnf-id", svcOperation);
894 responseBuilder.setResponseCode("403");
895 responseBuilder.setResponseMessage("invalid input, null or empty vnf-id");
896 responseBuilder.setAckFinalIndicator("Y");
897 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
898 .<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
899 return Futures.immediateFuture(rpcResult);
902 if (input.getVfModuleInformation() == null || input.getVfModuleInformation().getVfModuleId() == null
903 || input.getVfModuleInformation().getVfModuleId().length() == 0) {
904 log.debug("exiting {} because of null or empty vf-module-id", svcOperation);
905 responseBuilder.setResponseCode("403");
906 responseBuilder.setResponseMessage("invalid input, vf-module-id is null or empty");
907 responseBuilder.setAckFinalIndicator("Y");
908 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
909 .<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
910 return Futures.immediateFuture(rpcResult);
913 // Grab the service instance ID from the input buffer
914 String siid = input.getServiceInformation().getServiceInstanceId();
916 if (input.getSdncRequestHeader() != null) {
917 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
920 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
921 getServiceData(siid, serviceDataBuilder);
923 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
924 getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
926 // Set the serviceStatus based on input
927 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
928 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
931 // setup a service-data object builder
932 // ACTION vnf-topology-operation
934 // USES sdnc-request-header;
935 // USES request-information;
936 // USES service-information;
937 // USES vnf-request-information
939 // USES vnf-topology-response-body;
940 // USES vnf-information
941 // USES service-information
943 // container service-data
944 // uses vnf-configuration-information;
947 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
948 VfModuleTopologyOperationInputBuilder inputBuilder = new VfModuleTopologyOperationInputBuilder(input);
949 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
951 log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid,
952 operDataBuilder.build());
953 GenericResourceApiUtil.toProperties(parms, OPERATIONAL_DATA_PARAM, operDataBuilder);
955 // Call SLI sync method
956 // Get SvcLogicService reference
958 ErrorObject error = new ErrorObject("200", "");
959 Properties respProps = null;
960 String ackFinal = "Y";
961 String serviceObjectPath = null;
964 if (svcLogicClient.hasGraph(APP_NAME, svcOperation, null, "sync")) {
967 respProps = svcLogicClient.execute(APP_NAME, svcOperation, null, "sync", serviceDataBuilder, parms);
968 } catch (Exception e) {
969 log.error("Caught exception executing service logic for " + svcOperation, e);
970 error.setMessage(e.getMessage());
971 error.setStatusCode("500");
974 error.setMessage(NO_SERVICE_LOGIC_ACTIVE + APP_NAME + ": '" + svcOperation + "'");
975 error.setStatusCode("503");
977 } catch (Exception e) {
978 error.setMessage(e.getMessage());
979 error.setStatusCode("500");
980 log.error(SERVICE_LOGIC_SEARCH_ERROR_MESSAGE, e);
983 if (respProps != null) {
984 error.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
985 error.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
986 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
987 serviceObjectPath = respProps.getProperty("vf-module-object-path");
990 setServiceStatus(serviceStatusBuilder, error.getStatusCode(), error.getMessage(), ackFinal);
991 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
992 serviceStatusBuilder.setRpcName(svcOperation);
994 if (validateErrorObject(error)) {
995 responseBuilder.setResponseCode(error.getStatusCode());
996 responseBuilder.setResponseMessage(error.getStatusCode());
997 responseBuilder.setAckFinalIndicator(ackFinal);
999 ServiceBuilder serviceBuilder = new ServiceBuilder();
1000 serviceBuilder.setServiceInstanceId(siid);
1001 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1003 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
1004 } catch (Exception e) {
1005 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1007 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1008 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
1009 .<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1011 return Futures.immediateFuture(rpcResult);
1014 // Got success from SLI
1016 serviceData = serviceDataBuilder.build();
1017 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
1020 ServiceBuilder serviceBuilder = new ServiceBuilder();
1021 serviceBuilder.setServiceData(serviceData);
1022 serviceBuilder.setServiceInstanceId(siid);
1023 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1024 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1026 if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null) {
1027 // Only update operational tree on activate or delete
1028 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Unassign)
1029 || input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate)) {
1030 log.info(UPDATING_TREE_INFO_MESSAGE);
1031 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1035 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1036 serviceResponseInformationBuilder.setInstanceId(siid);
1037 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1038 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1040 } catch (Exception e) {
1041 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1042 responseBuilder.setResponseCode("500");
1043 responseBuilder.setResponseMessage(e.toString());
1044 responseBuilder.setAckFinalIndicator("Y");
1045 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1046 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
1047 .<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1048 return Futures.immediateFuture(rpcResult);
1052 responseBuilder.setResponseCode(error.getStatusCode());
1053 responseBuilder.setAckFinalIndicator(ackFinal);
1054 if (!error.getMessage().isEmpty()) {
1055 responseBuilder.setResponseMessage(error.getMessage());
1057 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
1058 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
1060 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
1061 .<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1063 return Futures.immediateFuture(rpcResult);
1067 public Future<RpcResult<NetworkTopologyOperationOutput>> networkTopologyOperation(
1068 NetworkTopologyOperationInput input) {
1070 final String svcOperation = "network-topology-operation";
1071 ServiceData serviceData;
1072 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1073 Properties parms = new Properties();
1075 log.info(CALLED_STR, svcOperation);
1076 // create a new response object
1077 NetworkTopologyOperationOutputBuilder responseBuilder = new NetworkTopologyOperationOutputBuilder();
1079 if (input == null || input.getServiceInformation() == null
1080 || input.getServiceInformation().getServiceInstanceId() == null
1081 || input.getServiceInformation().getServiceInstanceId().length() == 0) {
1082 log.debug(NULL_OR_EMPTY_ERROR_LOG, svcOperation);
1083 responseBuilder.setResponseCode("404");
1084 responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
1085 responseBuilder.setAckFinalIndicator("Y");
1086 RpcResult<NetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
1087 .<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1088 return Futures.immediateFuture(rpcResult);
1091 String siid = input.getServiceInformation().getServiceInstanceId();
1093 // Get the service-instance service data from MD-SAL
1094 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1095 getServiceData(siid, serviceDataBuilder);
1097 if (input.getSdncRequestHeader() != null) {
1098 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1101 ServiceData sd = serviceDataBuilder.build();
1102 if (sd == null || sd.getServiceLevelOperStatus() == null) {
1103 log.debug(EMPTY_SERVICE_INSTANCE_MESSAGE, svcOperation);
1104 responseBuilder.setResponseCode("404");
1106 .setResponseMessage(INVALID_INPUT_ERROR_MESSAGE);
1107 responseBuilder.setAckFinalIndicator("Y");
1108 RpcResult<NetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
1109 .<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1110 return Futures.immediateFuture(rpcResult);
1113 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
1114 NetworkTopologyOperationInputBuilder inputBuilder = new NetworkTopologyOperationInputBuilder(input);
1115 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1117 // Call SLI sync method
1118 // Get SvcLogicService reference
1120 Properties respProps = null;
1122 ErrorObject error = new ErrorObject("200", "");
1123 String ackFinal = "Y";
1124 String networkId = ERROR_NETWORK_ID;
1125 String serviceObjectPath = null;
1126 String networkObjectPath = null;
1129 if (svcLogicClient.hasGraph(APP_NAME, svcOperation, null, "sync")) {
1132 respProps = svcLogicClient.execute(APP_NAME, svcOperation, null, "sync", serviceDataBuilder, parms);
1133 } catch (Exception e) {
1134 log.error(SERVICE_LOGIC_EXECUTION_ERROR_MESSAGE, svcOperation, e);
1135 error.setStatusCode("500");
1136 error.setMessage(e.getMessage());
1139 error.setStatusCode("503");
1140 error.setMessage(NO_SERVICE_LOGIC_ACTIVE + APP_NAME + ": '" + svcOperation + "'");
1142 } catch (Exception e) {
1143 error.setStatusCode("500");
1144 error.setMessage(e.getMessage());
1145 log.error(SERVICE_LOGIC_SEARCH_ERROR_MESSAGE, e);
1148 if (respProps != null) {
1149 error.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
1150 error.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
1151 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
1152 networkId = respProps.getProperty("networkId");
1153 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
1154 networkObjectPath = respProps.getProperty("network-object-path");
1157 if (validateErrorObject(error)) {
1158 responseBuilder.setResponseCode(error.getStatusCode());
1159 responseBuilder.setResponseMessage(error.getMessage());
1160 responseBuilder.setAckFinalIndicator(ackFinal);
1162 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1164 RpcResult<NetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
1165 .<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1166 return Futures.immediateFuture(rpcResult);
1169 // Got success from SLI
1172 serviceData = serviceDataBuilder.build();
1173 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
1176 ServiceBuilder serviceBuilder = new ServiceBuilder();
1177 serviceBuilder.setServiceData(serviceData);
1178 serviceBuilder.setServiceInstanceId(siid);
1179 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1180 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1182 if (isValidRequest(input) &&
1183 (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate) ||
1184 input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Create))) {
1185 // Only update operational tree on Activate
1186 log.info(UPDATING_TREE_INFO_MESSAGE);
1187 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1190 NetworkResponseInformationBuilder networkResponseInformationBuilder = new NetworkResponseInformationBuilder();
1191 networkResponseInformationBuilder.setInstanceId(networkId);
1192 networkResponseInformationBuilder.setObjectPath(networkObjectPath);
1193 responseBuilder.setNetworkResponseInformation(networkResponseInformationBuilder.build());
1195 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1196 serviceResponseInformationBuilder.setInstanceId(siid);
1197 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1198 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1200 } catch (IllegalStateException e) {
1201 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1202 responseBuilder.setResponseCode("500");
1203 responseBuilder.setResponseMessage(e.toString());
1204 responseBuilder.setAckFinalIndicator("Y");
1205 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1206 RpcResult<NetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
1207 .<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1208 return Futures.immediateFuture(rpcResult);
1212 responseBuilder.setResponseCode(error.getStatusCode());
1213 responseBuilder.setAckFinalIndicator(ackFinal);
1214 if (!error.getMessage().isEmpty()) {
1215 responseBuilder.setResponseMessage(error.getMessage());
1217 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
1218 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
1220 RpcResult<NetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
1221 .<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1222 return Futures.immediateFuture(rpcResult);
1225 private boolean isValidRequest(NetworkTopologyOperationInput input) {
1226 return input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null;
1230 public Future<RpcResult<ContrailRouteTopologyOperationOutput>> contrailRouteTopologyOperation(
1231 ContrailRouteTopologyOperationInput input) {
1233 final String svcOperation = "contrail-route-topology-operation";
1234 ServiceData serviceData;
1235 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1236 Properties parms = new Properties();
1238 log.info(CALLED_STR, svcOperation);
1239 // create a new response object
1240 ContrailRouteTopologyOperationOutputBuilder responseBuilder = new ContrailRouteTopologyOperationOutputBuilder();
1242 if (input == null || input.getServiceInformation() == null
1243 || input.getServiceInformation().getServiceInstanceId() == null
1244 || input.getServiceInformation().getServiceInstanceId().length() == 0) {
1245 log.debug(NULL_OR_EMPTY_ERROR_LOG, svcOperation);
1246 responseBuilder.setResponseCode("404");
1247 responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
1248 responseBuilder.setAckFinalIndicator("Y");
1249 RpcResult<ContrailRouteTopologyOperationOutput> rpcResult = RpcResultBuilder
1250 .<ContrailRouteTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1251 return Futures.immediateFuture(rpcResult);
1254 String siid = input.getServiceInformation().getServiceInstanceId();
1256 // Get the service-instance service data from MD-SAL
1257 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1258 getServiceData(siid, serviceDataBuilder);
1260 if (input.getSdncRequestHeader() != null) {
1261 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1264 ServiceData sd = serviceDataBuilder.build();
1265 if (sd == null || sd.getServiceLevelOperStatus() == null) {
1266 log.debug(EMPTY_SERVICE_INSTANCE_MESSAGE, svcOperation);
1267 responseBuilder.setResponseCode("404");
1269 .setResponseMessage(INVALID_INPUT_ERROR_MESSAGE);
1270 responseBuilder.setAckFinalIndicator("Y");
1271 RpcResult<ContrailRouteTopologyOperationOutput> rpcResult = RpcResultBuilder
1272 .<ContrailRouteTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1273 return Futures.immediateFuture(rpcResult);
1276 log.info("Adding INPUT data for " + svcOperation + " [" + siid + "] input: " + input);
1277 ContrailRouteTopologyOperationInputBuilder inputBuilder = new ContrailRouteTopologyOperationInputBuilder(input);
1278 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1280 // Call SLI sync method
1281 // Get SvcLogicService reference
1283 Properties respProps = null;
1285 ErrorObject error = new ErrorObject("200", "");
1286 String ackFinal = "Y";
1287 String allottedResourceId = ERROR_NETWORK_ID;
1288 String serviceObjectPath = null;
1289 String contrailRouteObjectPath = null;
1292 if (svcLogicClient.hasGraph(APP_NAME, svcOperation, null, "sync")) {
1295 respProps = svcLogicClient.execute(APP_NAME, svcOperation, null, "sync", serviceDataBuilder, parms);
1296 } catch (Exception e) {
1297 log.error(SERVICE_LOGIC_EXECUTION_ERROR_MESSAGE, svcOperation, e);
1298 error.setMessage(e.getMessage());
1299 error.setStatusCode("500");
1302 error.setMessage(NO_SERVICE_LOGIC_ACTIVE + APP_NAME + ": '" + svcOperation + "'");
1303 error.setStatusCode("503");
1305 } catch (Exception e) {
1306 error.setMessage(e.getMessage());
1307 error.setStatusCode("500");
1308 log.error(SERVICE_LOGIC_SEARCH_ERROR_MESSAGE, e);
1311 if (respProps != null) {
1312 error.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
1313 error.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
1314 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
1315 allottedResourceId = respProps.getProperty(ALLOTTED_RESOURCE_ID_PARAM);
1316 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
1317 contrailRouteObjectPath = respProps.getProperty("contrail-route-object-path");
1320 if (validateErrorObject(error)) {
1321 responseBuilder.setResponseCode(error.getStatusCode());
1322 responseBuilder.setResponseMessage(error.getMessage());
1323 responseBuilder.setAckFinalIndicator(ackFinal);
1325 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1327 RpcResult<ContrailRouteTopologyOperationOutput> rpcResult = RpcResultBuilder
1328 .<ContrailRouteTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1329 return Futures.immediateFuture(rpcResult);
1332 // Got success from SLI
1335 serviceData = serviceDataBuilder.build();
1336 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
1339 ServiceBuilder serviceBuilder = new ServiceBuilder();
1340 serviceBuilder.setServiceData(serviceData);
1341 serviceBuilder.setServiceInstanceId(siid);
1342 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1343 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1345 if (isValidRequest(input) &&
1346 (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Unassign) ||
1347 input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))) {
1348 // Only update operational tree on activate or delete
1349 log.info(UPDATING_TREE_INFO_MESSAGE);
1350 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1353 ContrailRouteResponseInformationBuilder contrailRouteResponseInformationBuilder = new ContrailRouteResponseInformationBuilder();
1354 contrailRouteResponseInformationBuilder.setInstanceId(allottedResourceId);
1355 contrailRouteResponseInformationBuilder.setObjectPath(contrailRouteObjectPath);
1356 responseBuilder.setContrailRouteResponseInformation(contrailRouteResponseInformationBuilder.build());
1358 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1359 serviceResponseInformationBuilder.setInstanceId(siid);
1360 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1361 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1363 } catch (IllegalStateException e) {
1364 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1365 responseBuilder.setResponseCode("500");
1366 responseBuilder.setResponseMessage(e.toString());
1367 responseBuilder.setAckFinalIndicator("Y");
1368 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1369 RpcResult<ContrailRouteTopologyOperationOutput> rpcResult = RpcResultBuilder
1370 .<ContrailRouteTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1371 return Futures.immediateFuture(rpcResult);
1375 responseBuilder.setResponseCode(error.getStatusCode());
1376 responseBuilder.setAckFinalIndicator(ackFinal);
1377 if (!error.getMessage().isEmpty()) {
1378 responseBuilder.setResponseMessage(error.getMessage());
1380 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
1381 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
1383 RpcResult<ContrailRouteTopologyOperationOutput> rpcResult = RpcResultBuilder
1384 .<ContrailRouteTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1385 return Futures.immediateFuture(rpcResult);
1388 private boolean isValidRequest(ContrailRouteTopologyOperationInput input) {
1389 return input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null;
1393 public Future<RpcResult<SecurityZoneTopologyOperationOutput>> securityZoneTopologyOperation(
1394 SecurityZoneTopologyOperationInput input) {
1396 final String svcOperation = "security-zone-topology-operation";
1397 ServiceData serviceData;
1398 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1399 Properties parms = new Properties();
1401 log.info(CALLED_STR, svcOperation);
1402 // create a new response object
1403 SecurityZoneTopologyOperationOutputBuilder responseBuilder = new SecurityZoneTopologyOperationOutputBuilder();
1405 if (input == null || input.getServiceInformation() == null
1406 || input.getServiceInformation().getServiceInstanceId() == null
1407 || input.getServiceInformation().getServiceInstanceId().length() == 0) {
1408 log.debug(NULL_OR_EMPTY_ERROR_LOG, svcOperation);
1409 responseBuilder.setResponseCode("404");
1410 responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
1411 responseBuilder.setAckFinalIndicator("Y");
1412 RpcResult<SecurityZoneTopologyOperationOutput> rpcResult = RpcResultBuilder
1413 .<SecurityZoneTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1414 return Futures.immediateFuture(rpcResult);
1417 String siid = input.getServiceInformation().getServiceInstanceId();
1419 // Get the service-instance service data from MD-SAL
1420 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1421 getServiceData(siid, serviceDataBuilder);
1423 if (input.getSdncRequestHeader() != null) {
1424 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1427 ServiceData sd = serviceDataBuilder.build();
1428 if (sd == null || sd.getServiceLevelOperStatus() == null) {
1429 log.debug(EMPTY_SERVICE_INSTANCE_MESSAGE, svcOperation);
1430 responseBuilder.setResponseCode("404");
1432 .setResponseMessage(INVALID_INPUT_ERROR_MESSAGE);
1433 responseBuilder.setAckFinalIndicator("Y");
1434 RpcResult<SecurityZoneTopologyOperationOutput> rpcResult = RpcResultBuilder
1435 .<SecurityZoneTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1436 return Futures.immediateFuture(rpcResult);
1439 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
1440 SecurityZoneTopologyOperationInputBuilder inputBuilder = new SecurityZoneTopologyOperationInputBuilder(input);
1441 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1443 // Call SLI sync method
1444 // Get SvcLogicService reference
1446 Properties respProps = null;
1448 ErrorObject error = new ErrorObject("200", "");
1449 String ackFinal = "Y";
1450 String allottedResourceId = ERROR_NETWORK_ID;
1451 String serviceObjectPath = null;
1452 String securityZoneObjectPath = null;
1455 if (svcLogicClient.hasGraph(APP_NAME, svcOperation, null, "sync")) {
1458 respProps = svcLogicClient.execute(APP_NAME, svcOperation, null, "sync", serviceDataBuilder, parms);
1459 } catch (Exception e) {
1460 log.error(SERVICE_LOGIC_EXECUTION_ERROR_MESSAGE, svcOperation, e);
1461 error.setMessage(e.getMessage());
1462 error.setStatusCode("500");
1465 error.setMessage(NO_SERVICE_LOGIC_ACTIVE + APP_NAME + ": '" + svcOperation + "'");
1466 error.setStatusCode("503");
1468 } catch (Exception e) {
1469 error.setStatusCode("500");
1470 error.setMessage(e.getMessage());
1471 log.error(SERVICE_LOGIC_SEARCH_ERROR_MESSAGE, e);
1474 if (respProps != null) {
1475 error.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
1476 error.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
1477 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
1478 allottedResourceId = respProps.getProperty(ALLOTTED_RESOURCE_ID_PARAM);
1479 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
1480 securityZoneObjectPath = respProps.getProperty("security-zone-object-path");
1483 if (validateErrorObject(error)) {
1484 responseBuilder.setResponseCode(error.getStatusCode());
1485 responseBuilder.setResponseMessage(error.getMessage());
1486 responseBuilder.setAckFinalIndicator(ackFinal);
1488 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1490 RpcResult<SecurityZoneTopologyOperationOutput> rpcResult = RpcResultBuilder
1491 .<SecurityZoneTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1492 return Futures.immediateFuture(rpcResult);
1495 // Got success from SLI
1498 serviceData = serviceDataBuilder.build();
1499 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
1502 ServiceBuilder serviceBuilder = new ServiceBuilder();
1503 serviceBuilder.setServiceData(serviceData);
1504 serviceBuilder.setServiceInstanceId(siid);
1505 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1506 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1508 if (isValidRequest(input) &&
1509 (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Unassign) ||
1510 input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))) {
1511 // Only update operational tree on activate or delete
1512 log.info(UPDATING_TREE_INFO_MESSAGE);
1513 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1516 SecurityZoneResponseInformationBuilder securityZoneResponseInformationBuilder = new SecurityZoneResponseInformationBuilder();
1517 securityZoneResponseInformationBuilder.setInstanceId(allottedResourceId);
1518 securityZoneResponseInformationBuilder.setObjectPath(securityZoneObjectPath);
1519 responseBuilder.setSecurityZoneResponseInformation(securityZoneResponseInformationBuilder.build());
1521 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1522 serviceResponseInformationBuilder.setInstanceId(siid);
1523 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1524 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1526 } catch (IllegalStateException e) {
1527 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1528 responseBuilder.setResponseCode("500");
1529 responseBuilder.setResponseMessage(e.toString());
1530 responseBuilder.setAckFinalIndicator("Y");
1531 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1532 RpcResult<SecurityZoneTopologyOperationOutput> rpcResult = RpcResultBuilder
1533 .<SecurityZoneTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1534 return Futures.immediateFuture(rpcResult);
1538 responseBuilder.setResponseCode(error.getStatusCode());
1539 responseBuilder.setAckFinalIndicator(ackFinal);
1540 if (!error.getMessage().isEmpty()) {
1541 responseBuilder.setResponseMessage(error.getMessage());
1543 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
1544 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
1546 RpcResult<SecurityZoneTopologyOperationOutput> rpcResult = RpcResultBuilder
1547 .<SecurityZoneTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1548 return Futures.immediateFuture(rpcResult);
1551 private boolean isValidRequest(SecurityZoneTopologyOperationInput input) {
1552 return input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null;
1556 public Future<RpcResult<TunnelxconnTopologyOperationOutput>> tunnelxconnTopologyOperation(
1557 TunnelxconnTopologyOperationInput input) {
1559 final String svcOperation = "tunnelxconn-topology-operation";
1560 Properties parms = new Properties();
1562 log.info(CALLED_STR, svcOperation);
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, svcOperation);
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 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
1581 TunnelxconnTopologyOperationInputBuilder inputBuilder = new TunnelxconnTopologyOperationInputBuilder(input);
1582 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1584 // Call SLI sync method
1585 // Get SvcLogicService reference
1587 Properties respProps = null;
1589 ErrorObject error = new ErrorObject("200", "");
1590 String ackFinal = "Y";
1591 String allottedResourceId = ERROR_NETWORK_ID;
1592 String serviceObjectPath = null;
1593 String tunnelxconnObjectPath = null;
1596 if (svcLogicClient.hasGraph(APP_NAME, svcOperation, null, "sync")) {
1599 respProps = svcLogicClient.execute(APP_NAME, svcOperation, null, "sync", parms);
1600 } catch (Exception e) {
1601 log.error(SERVICE_LOGIC_EXECUTION_ERROR_MESSAGE, svcOperation, e);
1602 error.setMessage(e.getMessage());
1603 error.setStatusCode("500");
1606 error.setMessage(NO_SERVICE_LOGIC_ACTIVE + APP_NAME + ": '" + svcOperation + "'");
1607 error.setStatusCode("503");
1609 } catch (Exception e) {
1610 error.setMessage(e.getMessage());
1611 error.setStatusCode("500");
1612 log.error(SERVICE_LOGIC_SEARCH_ERROR_MESSAGE, e);
1615 if (respProps != null) {
1616 error.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
1617 error.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
1618 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
1619 allottedResourceId = respProps.getProperty(ALLOTTED_RESOURCE_ID_PARAM);
1620 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
1621 tunnelxconnObjectPath = respProps.getProperty("tunnelxconn-object-path");
1624 if (validateErrorObject(error)) {
1625 responseBuilder.setResponseCode(error.getStatusCode());
1626 responseBuilder.setResponseMessage(error.getMessage());
1627 responseBuilder.setAckFinalIndicator(ackFinal);
1629 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1631 RpcResult<TunnelxconnTopologyOperationOutput> rpcResult = RpcResultBuilder
1632 .<TunnelxconnTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1633 return Futures.immediateFuture(rpcResult);
1636 // Got success from SLI
1641 TunnelxconnResponseInformationBuilder tunnelxconnResponseInformationBuilder = new TunnelxconnResponseInformationBuilder();
1642 tunnelxconnResponseInformationBuilder.setInstanceId(allottedResourceId);
1643 tunnelxconnResponseInformationBuilder.setObjectPath(tunnelxconnObjectPath);
1644 responseBuilder.setTunnelxconnResponseInformation(tunnelxconnResponseInformationBuilder.build());
1646 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1647 serviceResponseInformationBuilder.setInstanceId(siid);
1648 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1649 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1651 } catch (IllegalStateException e) {
1652 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1653 responseBuilder.setResponseCode("500");
1654 responseBuilder.setResponseMessage(e.toString());
1655 responseBuilder.setAckFinalIndicator("Y");
1656 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1657 RpcResult<TunnelxconnTopologyOperationOutput> rpcResult = RpcResultBuilder
1658 .<TunnelxconnTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1659 return Futures.immediateFuture(rpcResult);
1663 responseBuilder.setResponseCode(error.getStatusCode());
1664 responseBuilder.setAckFinalIndicator(ackFinal);
1665 if (!error.getMessage().isEmpty()) {
1666 responseBuilder.setResponseMessage(error.getMessage());
1668 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
1669 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
1671 RpcResult<TunnelxconnTopologyOperationOutput> rpcResult = RpcResultBuilder
1672 .<TunnelxconnTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1673 return Futures.immediateFuture(rpcResult);
1677 public Future<RpcResult<BrgTopologyOperationOutput>> brgTopologyOperation(BrgTopologyOperationInput input) {
1678 final String svcOperation = "brg-topology-operation";
1679 Properties parms = new Properties();
1681 log.info(CALLED_STR, svcOperation);
1682 // create a new response object
1683 BrgTopologyOperationOutputBuilder responseBuilder = new BrgTopologyOperationOutputBuilder();
1685 if (input == null || input.getServiceInformation() == null
1686 || input.getServiceInformation().getServiceInstanceId() == null
1687 || input.getServiceInformation().getServiceInstanceId().length() == 0) {
1688 log.debug(NULL_OR_EMPTY_ERROR_LOG, svcOperation);
1689 responseBuilder.setResponseCode("404");
1690 responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
1691 responseBuilder.setAckFinalIndicator("Y");
1692 RpcResult<BrgTopologyOperationOutput> rpcResult = RpcResultBuilder.<BrgTopologyOperationOutput>status(true)
1693 .withResult(responseBuilder.build()).build();
1694 return Futures.immediateFuture(rpcResult);
1697 String siid = input.getServiceInformation().getServiceInstanceId();
1699 log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
1700 BrgTopologyOperationInputBuilder inputBuilder = new BrgTopologyOperationInputBuilder(input);
1701 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1703 // Call SLI sync method
1704 // Get SvcLogicService reference
1706 Properties respProps = null;
1708 ErrorObject error = new ErrorObject("200", "");
1709 String ackFinal = "Y";
1710 String allottedResourceId = ERROR_NETWORK_ID;
1711 String serviceObjectPath = null;
1712 String brgObjectPath = null;
1715 if (svcLogicClient.hasGraph(APP_NAME, svcOperation, null, "sync")) {
1718 respProps = svcLogicClient.execute(APP_NAME, svcOperation, null, "sync", parms);
1719 } catch (Exception e) {
1720 log.error(SERVICE_LOGIC_EXECUTION_ERROR_MESSAGE, svcOperation, e);
1721 error.setMessage(e.getMessage());
1722 error.setStatusCode("500");
1725 error.setMessage(NO_SERVICE_LOGIC_ACTIVE + APP_NAME + ": '" + svcOperation + "'");
1726 error.setStatusCode("503");
1728 } catch (Exception e) {
1729 error.setMessage(e.getMessage());
1730 error.setStatusCode("500");
1731 log.error(SERVICE_LOGIC_SEARCH_ERROR_MESSAGE, e);
1734 if (respProps != null) {
1735 error.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
1736 error.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
1737 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
1738 allottedResourceId = respProps.getProperty(ALLOTTED_RESOURCE_ID_PARAM);
1739 serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
1740 brgObjectPath = respProps.getProperty("brg-object-path");
1743 if (validateErrorObject(error)) {
1744 responseBuilder.setResponseCode(error.getStatusCode());
1745 responseBuilder.setResponseMessage(error.getMessage());
1746 responseBuilder.setAckFinalIndicator(ackFinal);
1748 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1750 RpcResult<BrgTopologyOperationOutput> rpcResult = RpcResultBuilder.<BrgTopologyOperationOutput>status(true)
1751 .withResult(responseBuilder.build()).build();
1752 return Futures.immediateFuture(rpcResult);
1755 // Got success from SLI
1759 BrgResponseInformationBuilder brgResponseInformationBuilder = new BrgResponseInformationBuilder();
1760 brgResponseInformationBuilder.setInstanceId(allottedResourceId);
1761 brgResponseInformationBuilder.setObjectPath(brgObjectPath);
1762 responseBuilder.setBrgResponseInformation(brgResponseInformationBuilder.build());
1764 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1765 serviceResponseInformationBuilder.setInstanceId(siid);
1766 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1767 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1769 } catch (IllegalStateException e) {
1770 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1771 responseBuilder.setResponseCode("500");
1772 responseBuilder.setResponseMessage(e.toString());
1773 responseBuilder.setAckFinalIndicator("Y");
1774 log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1775 RpcResult<BrgTopologyOperationOutput> rpcResult = RpcResultBuilder.<BrgTopologyOperationOutput>status(true)
1776 .withResult(responseBuilder.build()).build();
1777 return Futures.immediateFuture(rpcResult);
1781 responseBuilder.setResponseCode(error.getStatusCode());
1782 responseBuilder.setAckFinalIndicator(ackFinal);
1783 if (!error.getMessage().isEmpty()) {
1784 responseBuilder.setResponseMessage(error.getMessage());
1786 log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
1787 log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
1789 RpcResult<BrgTopologyOperationOutput> rpcResult = RpcResultBuilder.<BrgTopologyOperationOutput>status(true)
1790 .withResult(responseBuilder.build()).build();
1791 return Futures.immediateFuture(rpcResult);
1795 public Future<RpcResult<PreloadVnfTopologyOperationOutput>> preloadVnfTopologyOperation(
1796 PreloadVnfTopologyOperationInput input) {
1798 final String svcOperation = "preload-vnf-topology-operation";
1799 PreloadData preloadData;
1800 Properties parms = new Properties();
1802 log.info(CALLED_STR, svcOperation);
1803 // create a new response object
1804 PreloadVnfTopologyOperationOutputBuilder responseBuilder = new PreloadVnfTopologyOperationOutputBuilder();
1806 if (input == null || input.getVnfTopologyInformation() == null
1807 || input.getVnfTopologyInformation().getVnfTopologyIdentifier() == null) {
1808 log.debug("exiting {} because of null input", svcOperation);
1809 responseBuilder.setResponseCode("403");
1810 responseBuilder.setResponseMessage("invalid input: input is null");
1811 responseBuilder.setAckFinalIndicator("Y");
1812 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult = RpcResultBuilder
1813 .<PreloadVnfTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1814 return Futures.immediateFuture(rpcResult);
1817 // Grab the name and type from the input buffer
1818 String preloadName = input.getVnfTopologyInformation().getVnfTopologyIdentifier().getVnfName();
1819 String preloadType = input.getVnfTopologyInformation().getVnfTopologyIdentifier().getVnfType();
1821 // Make sure we have a preload_name and preload_type
1822 if (preloadName == null || preloadName.length() == 0 || preloadType == null || preloadType.length() == 0) {
1823 log.debug("exiting {} vnf-name or vnf-type is null or empty", svcOperation);
1824 responseBuilder.setResponseCode("403");
1825 responseBuilder.setResponseMessage("invalid input: vnf-name or vnf-type is null or empty");
1826 responseBuilder.setAckFinalIndicator("Y");
1827 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult = RpcResultBuilder
1828 .<PreloadVnfTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1829 return Futures.immediateFuture(rpcResult);
1832 if (input.getSdncRequestHeader() != null) {
1833 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1836 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
1837 getPreloadData(preloadName, preloadType, preloadDataBuilder);
1839 PreloadDataBuilder operDataBuilder = new PreloadDataBuilder();
1840 getPreloadData(preloadName, preloadType, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
1842 // setup a preload-data object builder
1843 // ACTION preload-vnf-topology-operation
1845 // USES sdnc-request-header;
1846 // USES request-information;
1847 // uses vnf-topology-information;
1849 // USES vnf-topology-response-body;
1851 // container preload-data
1852 // uses vnf-topology-information;
1853 // uses network-topology-information;
1854 // uses oper-status;
1856 log.info("Adding INPUT data for {} [{},{}] input: {}", svcOperation, preloadName, preloadType, input);
1857 PreloadVnfTopologyOperationInputBuilder inputBuilder = new PreloadVnfTopologyOperationInputBuilder(input);
1858 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1859 log.info("Adding OPERATIONAL data for {} [{},{}] operational-data: {}", svcOperation, preloadName,
1860 preloadType, operDataBuilder.build());
1861 GenericResourceApiUtil.toProperties(parms, OPERATIONAL_DATA_PARAM, operDataBuilder);
1863 // Call SLI sync method
1864 // Get SvcLogicService reference
1866 Properties respProps = null;
1868 ErrorObject error = new ErrorObject("200", "");
1869 String ackFinal = "Y";
1872 if (svcLogicClient.hasGraph(APP_NAME, svcOperation, null, "sync")) {
1875 respProps = svcLogicClient.execute(APP_NAME, svcOperation, null, "sync", parms);
1876 } catch (Exception e) {
1877 log.error(SERVICE_LOGIC_EXECUTION_ERROR_MESSAGE, svcOperation, e);
1878 error.setMessage(e.getMessage());
1879 error.setStatusCode("500");
1882 error.setMessage(NO_SERVICE_LOGIC_ACTIVE + APP_NAME + ": '" + svcOperation + "'");
1883 error.setStatusCode("503");
1885 } catch (Exception e) {
1886 error.setMessage(e.getMessage());
1887 error.setStatusCode("500");
1888 log.error(SERVICE_LOGIC_SEARCH_ERROR_MESSAGE, e);
1891 if (respProps != null) {
1892 error.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
1893 error.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
1894 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
1897 if (validateErrorObject(error)) {
1899 responseBuilder.setResponseCode(error.getStatusCode());
1900 responseBuilder.setResponseMessage(error.getMessage());
1901 responseBuilder.setAckFinalIndicator(ackFinal);
1903 VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
1904 preloadVnfListBuilder.setVnfName(preloadName);
1905 preloadVnfListBuilder.setVnfType(preloadType);
1906 preloadVnfListBuilder.setPreloadData(preloadDataBuilder.build());
1907 log.error("Returned FAILED for {} [{},{}] error code: '{}', Reason: '{}'", svcOperation, preloadName,
1908 preloadType, error.getStatusCode(), error.getMessage());
1910 savePreloadList(preloadVnfListBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
1911 } catch (Exception e) {
1912 log.error(UPDATING_MDSAL_ERROR_MESSAGE_2, svcOperation, preloadName,
1915 log.debug("Sending Success rpc result due to external error");
1916 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult = RpcResultBuilder
1917 .<PreloadVnfTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1918 return Futures.immediateFuture(rpcResult);
1921 // Got success from SLI
1923 preloadData = preloadDataBuilder.build();
1924 log.info("Updating MD-SAL for {} [{},{}] preloadData: {}", svcOperation, preloadName, preloadType,
1926 // svc-configuration-list
1927 VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
1928 preloadVnfListBuilder.setVnfName(preloadName);
1929 preloadVnfListBuilder.setVnfType(preloadType);
1930 preloadVnfListBuilder.setPreloadData(preloadData);
1932 // merge flag sets to false to allow it to be overwritten (not appended)
1933 savePreloadList(preloadVnfListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1934 log.info(UPDATING_TREE_INFO_MESSAGE);
1935 savePreloadList(preloadVnfListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1936 } catch (Exception e) {
1937 log.error(UPDATING_MDSAL_ERROR_MESSAGE_2, svcOperation, preloadName, preloadType,
1939 responseBuilder.setResponseCode("500");
1940 responseBuilder.setResponseMessage(e.toString());
1941 responseBuilder.setAckFinalIndicator("Y");
1942 log.error("Returned FAILED for {} [{},{}] {}", svcOperation, preloadName, preloadType,
1943 responseBuilder.build());
1944 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult = RpcResultBuilder
1945 .<PreloadVnfTopologyOperationOutput>status(false).withResult(responseBuilder.build()).build();
1946 return Futures.immediateFuture(rpcResult);
1950 responseBuilder.setResponseCode(error.getStatusCode());
1951 responseBuilder.setAckFinalIndicator(ackFinal);
1952 if (!error.getMessage().isEmpty()) {
1953 responseBuilder.setResponseMessage(error.getMessage());
1955 log.info("Updated MD-SAL for {} [{},{}]", svcOperation, preloadName, preloadType);
1956 log.info("Returned SUCCESS for {} [{},{}] {}", svcOperation, preloadName, preloadType,
1957 responseBuilder.build());
1959 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult = RpcResultBuilder
1960 .<PreloadVnfTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1961 return Futures.immediateFuture(rpcResult);
1965 public Future<RpcResult<PreloadNetworkTopologyOperationOutput>> preloadNetworkTopologyOperation(
1966 PreloadNetworkTopologyOperationInput input) {
1968 final String svcOperation = "preload-network-topology-operation";
1969 PreloadData preloadData;
1970 Properties parms = new Properties();
1972 log.info(CALLED_STR, svcOperation);
1973 // create a new response object
1974 PreloadNetworkTopologyOperationOutputBuilder responseBuilder = new PreloadNetworkTopologyOperationOutputBuilder();
1976 if (input == null || input.getNetworkTopologyInformation() == null
1977 || input.getNetworkTopologyInformation().getNetworkTopologyIdentifier() == null) {
1979 log.debug("exiting {} because of null input", svcOperation);
1980 responseBuilder.setResponseCode("403");
1981 responseBuilder.setResponseMessage("input is null");
1982 responseBuilder.setAckFinalIndicator("Y");
1983 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
1984 .<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1985 return Futures.immediateFuture(rpcResult);
1988 // Grab the name and type from the input buffer
1989 String preloadName = input.getNetworkTopologyInformation().getNetworkTopologyIdentifier().getNetworkName();
1990 String preloadType = input.getNetworkTopologyInformation().getNetworkTopologyIdentifier().getNetworkType();
1992 // Make sure we have a preload_name and preload_type
1993 if (preloadName == null || preloadName.length() == 0 || preloadType == null || preloadType.length() == 0) {
1994 log.debug("exiting {} because of invalid preload-name", svcOperation);
1995 responseBuilder.setResponseCode("403");
1996 responseBuilder.setResponseMessage("input, invalid preload-name");
1997 responseBuilder.setAckFinalIndicator("Y");
1998 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
1999 .<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2000 return Futures.immediateFuture(rpcResult);
2003 if (input.getSdncRequestHeader() != null) {
2004 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
2007 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
2008 getPreloadData(preloadName, preloadType, preloadDataBuilder);
2010 PreloadDataBuilder operDataBuilder = new PreloadDataBuilder();
2011 getPreloadData(preloadName, preloadType, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
2014 // setup a preload-data object builder
2015 // ACTION preload-network-topology-operation
2017 // USES sdnc-request-header;
2018 // USES request-information;
2019 // uses network-topology-information;
2021 // USES vnf-topology-response-body;
2023 // container preload-data
2024 // uses vnf-topology-information;
2025 // uses network-topology-information;
2026 // uses oper-status;
2028 log.info("Adding INPUT data for {} [{},{}] input: {}", svcOperation, preloadName, preloadType, input);
2029 PreloadNetworkTopologyOperationInputBuilder inputBuilder = new PreloadNetworkTopologyOperationInputBuilder(
2031 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
2032 log.info("Adding OPERATIONAL data for {} [{},{}] operational-data: {}", svcOperation, preloadName,
2033 preloadType, operDataBuilder.build());
2034 GenericResourceApiUtil.toProperties(parms, OPERATIONAL_DATA_PARAM, operDataBuilder);
2036 // Call SLI sync method
2037 // Get SvcLogicService reference
2039 Properties respProps = null;
2040 ErrorObject error = new ErrorObject("200", "");
2041 String ackFinal = "Y";
2044 if (svcLogicClient.hasGraph(APP_NAME, svcOperation, null, "sync")) {
2047 respProps = svcLogicClient.execute(APP_NAME, svcOperation, null, "sync", parms);
2048 } catch (Exception e) {
2049 log.error(SERVICE_LOGIC_EXECUTION_ERROR_MESSAGE, svcOperation, e);
2050 error.setMessage(e.getMessage());
2051 error.setStatusCode("500");
2054 error.setMessage(NO_SERVICE_LOGIC_ACTIVE + APP_NAME + ": '" + svcOperation + "'");
2055 error.setStatusCode("503");
2057 } catch (Exception e) {
2058 error.setMessage(e.getMessage());
2059 error.setStatusCode("500");
2060 log.error(SERVICE_LOGIC_SEARCH_ERROR_MESSAGE, e);
2063 if (respProps != null) {
2064 error.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
2065 error.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
2066 ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
2069 if (validateErrorObject(error)) {
2071 responseBuilder.setResponseCode(error.getStatusCode());
2072 responseBuilder.setResponseMessage(error.getMessage());
2073 responseBuilder.setAckFinalIndicator(ackFinal);
2075 VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
2076 preloadVnfListBuilder.setVnfName(preloadName);
2077 preloadVnfListBuilder.setVnfType(preloadType);
2078 preloadVnfListBuilder.setPreloadData(preloadDataBuilder.build());
2079 log.error("Returned FAILED for {} [{},{}] error code: '{}', Reason: '{}'", svcOperation, preloadName,
2080 preloadType, error.getStatusCode(), error.getMessage());
2082 savePreloadList(preloadVnfListBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
2083 } catch (Exception e) {
2084 log.error(UPDATING_MDSAL_ERROR_MESSAGE_2, svcOperation, preloadName,
2088 log.debug("Sending Success rpc result due to external error");
2089 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
2090 .<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2091 return Futures.immediateFuture(rpcResult);
2094 // Got success from SLI
2096 preloadData = preloadDataBuilder.build();
2097 log.info("Updating MD-SAL for {} [{},{}] preloadData: {}", svcOperation, preloadName, preloadType,
2099 // svc-configuration-list
2100 VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
2101 preloadVnfListBuilder.setVnfName(preloadName);
2102 preloadVnfListBuilder.setVnfType(preloadType);
2103 preloadVnfListBuilder.setPreloadData(preloadData);
2105 // merge flag sets to false to allow it to be overwritten (not appended)
2106 savePreloadList(preloadVnfListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
2107 log.info(UPDATING_TREE_INFO_MESSAGE);
2108 savePreloadList(preloadVnfListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
2109 } catch (Exception e) {
2110 log.error("Caught Exception updating MD-SAL for " + svcOperation + " [" + preloadName + "," + preloadType
2112 responseBuilder.setResponseCode("500");
2113 responseBuilder.setResponseMessage(e.toString());
2114 responseBuilder.setAckFinalIndicator("Y");
2115 log.error("Returned FAILED for {} [{},{}] {}", svcOperation, preloadName, preloadType,
2116 responseBuilder.build());
2117 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
2118 .<PreloadNetworkTopologyOperationOutput>status(false).withResult(responseBuilder.build()).build();
2119 return Futures.immediateFuture(rpcResult);
2123 responseBuilder.setResponseCode(error.getStatusCode());
2124 responseBuilder.setAckFinalIndicator(ackFinal);
2125 if (!error.getMessage().isEmpty()) {
2126 responseBuilder.setResponseMessage(error.getMessage());
2128 log.info("Updated MD-SAL for {} [{},{}]", svcOperation, preloadName, preloadType);
2129 log.info("Returned SUCCESS for {} [{},{}] {}", svcOperation, preloadName, preloadType,
2130 responseBuilder.build());
2132 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
2133 .<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2134 return Futures.immediateFuture(rpcResult);